FCL/sftools/dev/build: comparison sbsv2/raptor/python/raptor.py

equal deleted inserted replaced

-:6983dbbe3d70
+:ee00c00df073
 import raptor_cli
 import raptor_data
 import raptor_make
 import raptor_makefile
 import raptor_meta
+import raptor_timing
 import raptor_utilities
 import raptor_version
 import raptor_xml
 import filter_list
 import sys
 			makefile = generic_path.Path(str(makefilename_base))
 		# insert the start time into the Makefile name?
 		makefile.path = makefile.path.replace("%TIME", build.timestring)
+		build.InfoDiscovery(object_type = "layers", count = 1)
+		build.InfoStartTime(object_type = "layer", task = "parse",
+				key = str(makefile.path))
 		makefileset = build.maker.Write(makefile, specs, build.buildUnitsToBuild)
+		build.InfoEndTime(object_type = "layer", task = "parse",
+				key = str(makefile.path))
 		return makefileset
 	def realise(self, build):
 		"""Give the spec trees to the make engine and actually
 		"build" the product represented by this model node"""
 		# Must ensure that all children are unfurled at this point
 		build.AssertBuildOK()
 		m = self.realise_makefile(build, sp)
-		return build.Make(m)
+		build.InfoStartTime(object_type = "layer", task = "build",
+				key = (str(m.directory) + "/" + str(m.filenamebase)))
+		result = build.Make(m)
+		build.InfoEndTime(object_type = "layer", task = "build",
+				key = (str(m.directory) + "/" + str(m.filenamebase)))
+		return result
 class Project(ModelNode):
 	"""A project or, in symbian-speak, an MMP
 	"""
 		if build.keepGoing == True:
 			cli_options += " -k"
 		if build.quiet == True:
 			cli_options += " -q"
+		if build.timing == True:
+			cli_options += " --timing"
 		nc = len(self.children)
 		number_blocks = build.jobs
 		block_size = (nc / number_blocks) + 1
 				build.Error("Can't find flm interface 'build.makefiles' ")
 			spec_nodes.append(specNode)
 			binding_makefiles.addInclude(str(makefile_path)+"_all")
-		ppstart = time.time()
+		build.InfoDiscovery(object_type = "layers", count = 1)
-		build.Info("Parallel Parsing: time: Start %d", int(ppstart))
+		build.InfoStartTime(object_type = "layer", task = "parse",
+				key = str(build.topMakefile))
 		m = self.realise_makefile(build, spec_nodes)
 		m.close()
 		gen_result = build.Make(m)
-		ppfinish = time.time()
+		build.InfoEndTime(object_type = "layer", task = "parse",
-		build.Info("Parallel Parsing: time: Finish %d", int(ppfinish))
+				key = str(build.topMakefile))
-		build.Info("Parallel Parsing: time: Parse Duration %d", int(ppfinish - ppstart))
+		build.InfoStartTime(object_type = "layer", task = "build",
+				key = str(build.topMakefile))
 		build.Debug("Binding Makefile base name is %s ", binding_makefiles.filenamebase)
 		binding_makefiles.close()
 		b = build.Make(binding_makefiles)
-		buildfinish = time.time()
+		build.InfoEndTime(object_type = "layer", task = "build",
-		build.Info("Parallel Parsing: time: Build Duration %d", int(buildfinish - ppfinish))
+				key = str(build.topMakefile))
 		return b
 		self.mission = Raptor.M_BUILD
 		# what platform and filesystem are we running on?
 		self.filesystem = raptor_utilities.getOSFileSystem()
+		self.timing = False
 		self.toolset = None
 		self.starttime = time.time()
 		self.timestring = time.strftime("%Y-%m-%d-%H-%M-%S")
 		else:
 			self.Warn("toolcheck option must be one of: %s" % toolcheck_types)
 			return False
 		return True
+	def SetTiming(self, TrueOrFalse):
+		self.timing = TrueOrFalse
+		return True
 	def SetParallelParsing(self, type):
 		type = type.lower()
 		if type == "on":
 			self.doParallelParsing = True
+		elif type == "slave":
+			self.isParallelParsingSlave = True
 		elif type == "off":
 			self.doParallelParsing = False
 		else:
 			self.Warn(" parallel parsing option must be either 'on' or 'off' (was %s)"  % type)
 			return False
 			# log header
 			self.out.write("<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\n")
 			namespace = "http://symbian.com/xml/build/log"
+			progress_namespace = "http://symbian.com/xml/build/log/progress"
 			schema = "http://symbian.com/xml/build/log/1_0.xsd"
-			self.out.write("<buildlog sbs_version=\"%s\" xmlns=\"%s\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"%s %s\">\n"
+			self.out.write("<buildlog sbs_version=\"%s\" xmlns=\"%s\" xmlns:progress=\"%s\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"%s %s\">\n"
-						   % (raptor_version.fullversion(), namespace, namespace, schema))
+						   % (raptor_version.fullversion(), namespace, progress_namespace, namespace, schema))
 			self.logOpen = True
 		except Exception,e:
 			self.out = sys.stdout # make sure that we can actually get errors out.
 			self.logOpen = False
 			self.FatalError("Unable to open the output logs: %s" % str(e))
 		"""Send an information message to the configured channel
 				(XML control characters will be escaped)
 		"""
 		self.out.write("<info" + self.attributeString(attributes) + ">" +
 		               escape(format % extras) + "</info>\n")
+	def InfoDiscovery(self, object_type, count):
+		if self.timing:
+			try:
+				self.out.write(raptor_timing.Timing.discovery_string(object_type = object_type,
+						count = count))
+			except Exception, exception:
+				Error(exception.Text, function = "InfoDiscoveryTime")
+	def InfoStartTime(self, object_type, task, key):
+		if self.timing:
+			try:
+				self.out.write(raptor_timing.Timing.start_string(object_type = object_type,
+						task = task, key = key))
+			except Exception, exception:
+				Error(exception.Text, function = "InfoStartTime")
+	def InfoEndTime(self, object_type, task, key):
+		if self.timing:
+			try:
+				self.out.write(raptor_timing.Timing.end_string(object_type = object_type,
+						task = task, key = key))
+			except Exception, exception:
+				Error(exception.Text, function = "InfoEndTime")
 	def Debug(self, format, *extras, **attributes):
 		"Send a debugging message to the configured channel"
 		# the debug text is out of our control so wrap it in a CDATA

branch	wip
changeset 29	ee00c00df073
parent 21	a695dd5e4c37
child 59	0f7d6c11c675