FCL/interim/sftools/linux_build: comparison sbsv2/raptor/python/raptor.py

equal deleted inserted replaced

-:eb060913c963
+:de5b887c98f7
 			cli_options += " -k"
 		if build.quiet == True:
 			cli_options += " -q"
-		if build.timing == True:
-			cli_options += " --timing"
 		if build.noDependInclude == True:
 			cli_options += " --no-depend-include"
 		if build.noDependGenerate == True:
 			cli_options += " --no-depend-generate"
 	When operated from the command-line there is a single Raptor object
 	created by the Main function. When operated by an IDE several Raptor
 	objects may be created and operated at the same time."""
+	# mission enumeration
 	M_BUILD = 1
-	M_VERSION = 2
+	M_QUERY = 2
+	M_VERSION = 3
 	def __init__(self, home = None):
 		self.DefaultSetUp(home)
 		self.doExport = True
 		self.noBuild = False
 		self.noDependInclude = False
 		self.noDependGenerate = False
 		self.projects = set()
+		self.queries = []
 		self.cache = raptor_cache.Cache(self)
 		self.override = {env: str(self.home)}
 		self.targets = []
 		self.defaultTargets = []
 		self.mission = Raptor.M_BUILD
 		# what platform and filesystem are we running on?
 		self.filesystem = raptor_utilities.getOSFileSystem()
-		self.timing = False
+		self.timing = True # Needed by filters such as copy_file to monitor progress
 		self.toolset = None
 		self.starttime = time.time()
 		self.timestring = time.strftime("%Y-%m-%d-%H-%M-%S")
 			return False
 		return True
 	def SetTiming(self, TrueOrFalse):
-		self.timing = TrueOrFalse
+		self.Info("--timing switch no longer has any effect - build timing is now permanently on")
 		return True
 	def SetParallelParsing(self, type):
 		type = type.lower()
 		if type == "on":
 	def AddProject(self, projectName):
 		self.projects.add(projectName.lower())
 		return True
+	def AddQuery(self, q):
+		self.queries.append(q)
+		self.mission = Raptor.M_QUERY
+		return True
 	def FilterList(self, value):
 		self.filterList = value
 		return True
 	def IgnoreOsDetection(self, value):
 	def CommandLine(self, args):
 		# remember the arguments for the log
 		self.args = args
 		# assuming self.CLI = "raptor_cli"
-		more_to_do = raptor_cli.GetArgs(self, args)
+		if not raptor_cli.GetArgs(self, args):
+			self.skipAll = True		# nothing else to do
+	def ParseCommandLineTargets(self):
 		# resolve inter-argument dependencies.
 		# --what or --check implies the WHAT target and FilterWhat Filter
 		if self.doWhat or self.doCheck:
 			self.targets = ["WHAT"]
 			self.filterList = "filterwhat"
 			if is_clean:
 				self.filterList += ",filterclean"
 				if is_suspicious_clean:
 					self.Warn('CLEAN, CLEANEXPORT and a REALLYCLEAN should not be combined with other targets as the result is unpredictable.')
+			else:
-		if not more_to_do:
+				""" Copyfile implements the <copy> tag which is primarily useful with cluster builds.
-			self.skipAll = True		# nothing else to do
+				    It allows file copying to occur on the primary build host rather than on the cluster.
+				    This is more efficient.
+				"""
+				self.filterList += ",filtercopyfile"
 	def ProcessConfig(self):
 		# this function will perform additional processing of config
 		# create list of generic paths
 			self.pbox = pluginbox.PluginBox(str(self.systemPlugins))
 			self.raptor_params = BuildStats(self)
 			# Open the requested plugins using the pluginbox
-			self.out.open(self.raptor_params, self.filterList.split(','), self.pbox)
+			self.out.open(self.raptor_params, self.filterList, self.pbox)
 			# log header
 			self.out.write("<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\n")
 			namespace = "http://symbian.com/xml/build/log"
 					newcg.add(c)
 			layers = [newcg]
 		return layers
+	def Query(self):
+		"process command-line queries."
+		if self.mission != Raptor.M_QUERY:
+			return 0
+		# establish an object cache based on the current settings
+		self.LoadCache()
+		# our "self" is a valid object for initialising an API Context
+		import raptor_api
+		api = raptor_api.Context(self)
+		print "<sbs version='%s'>" % raptor_version.numericversion()
+		for q in self.queries:
+			try:
+				print api.stringquery(q)
+			except Exception, e:
+				self.Error("exception '%s' with query '%s'", str(e), q)
+		print "</sbs>"
+		return self.errorCode
 	def Build(self):
 		if self.mission != Raptor.M_BUILD: # help or version requested instead.
 			return 0
 		build = Raptor()
 		build.AssertBuildOK()
 		build.ConfigFile()
 		build.ProcessConfig()
 		build.CommandLine(argv)
+		build.ParseCommandLineTargets()
 		return build
+	@classmethod
+	def CreateCommandlineAnalysis(cls, argv):
+		""" Perform an analysis run where a build is not performed. """
+		build = Raptor()
+		build.AssertBuildOK()
+		build.ConfigFile()
+		build.ProcessConfig()
+		build.CommandLine(argv)
+		# Don't parse command line targets - they don't make any sense if you're not doing a build
+		return build
 # Class for passing constricted parameters to filters
 class BuildStats(object):
 	DisplayBanner()
 	# object which represents a build
 	b = Raptor.CreateCommandlineBuild(argv)
+	if b.mission == Raptor.M_QUERY:
+		return b.Query()
 	return b.Build()
 def DisplayBanner():
 	"""Stuff that needs printing out for every command."""

changeset 18	de5b887c98f7
parent 13	c327db0664bb
child 28	b8fa7dfeeaa1