def execute(self): dmplugin = PlugInManager().getPlugInInstance("DepManPlugIn") if dmplugin == None: self.reportError("DepMan PlugIn not found") return False if self._projectPath == "": self.reportError("Missing required project path option") return False self._projectPath = os.path.abspath(self._projectPath) if self._compiler == "": self._compiler = dmplugin.getOSCompiler() if self._projectName == "": self._projectName = os.path.basename(self._projectPath) if self._projectGenerationPath == "": self._projectGenerationPath = os.path.join(self._projectPath, "BMCMake") else: self._projectGenerationPath = os.path.abspath( self._projectGenerationPath) platform = dmplugin.getOSPlatform() if platform == "linux" or platform == "mac": self.__executeUnix() else: self.__executeVS() return True
def writeGoalHelpMessages(self,goal): if goal in self._applicationUsage.getCommandLineGoals().keys(): print "Goal supported by " + str(PlugInManager().getPlugInInstanceByGoal(goal).__class__) + " plugin:" print goal + "\t" + self._applicationUsage.getCommandLineGoalDescription(goal) + "\n" for option,value in self._applicationUsage.getCommandLineGoalOptions(goal): print "\t" + option + "\t" + value + "\n" else: print "Goal `" + goal +"` not supported, try --help-all option"
def testExecute(self): arguments = ArgumentParser([ 'bmn.py', 'buildman', '--file', 'bmtests/data/batch-buildman.xml' ]) bm = BuildMan(arguments) plugin = PlugInManager().getPlugInInstance("BuildManPlugIn") plugin._goalList = [] plugin.execute()
def init(self): self.addGoal("deploy", "deploys an artifact") self.addGoalOption( "deploy", "--interactive", "ask for server or artifact deployment configuration") self.addPreGoal("deploy", "create") self._dmplugin = PlugInManager().getPlugInInstance("DepManPlugIn") self._dmcreateplugin = PlugInManager().getPlugInInstance( "DepManCreatePlugIn") if self._dmplugin == None: self.reportError("PlugIn `depman` not found") return False if self._arguments.read("deploy"): self.setExecute(True) if self._arguments.read("--interactive"): self._is_Interactive = True
def buildman(self): self.loadXMLFile(self._file) for goal in self._goalList: plugin = PlugInManager().getPlugInInstanceByGoal(goal.localName) plugin.initFromXML(goal) plugin.execute() if plugin.error(): for error in plugin.getErrorMessages(): self.reportError(error) return False return True
def init(self): self.addGoal("create", "Create an artifact") self.addGoalOption("create", "--path", "Specifies source directory") self.addGoalOption( "create", "--interactive", "ask for server or artifact deployment configuration") self.addPreGoal("create", "depman") self._dmplugin = PlugInManager().getPlugInInstance("DepManPlugIn") self._dmdeployplugin = PlugInManager().getPlugInInstance( "DepManDeployPlugIn") if self._dmplugin == None: self.reportError("PlugIn `depman` not found") return False if self._arguments.read("create"): self.setExecute(True) args = [""] if self._arguments.read("--path", args): self._path = args[0] if self._arguments.read("--interactive"): self._is_Interactive = True
def testGoals(self): arguments = ArgumentParser( ['bmn.py', 'buildman', '--file', 'bmtests/data/buildman.xml']) bm = BuildMan(arguments) plugin = PlugInManager().getPlugInInstance("BuildManPlugIn") plugin._goalList = [] plugin.loadXMLFile(plugin.getFile()) goals = [ 'delete', 'svn', 'clean', 'update', 'create-solution', 'compile-solution', 'create' ] i = 0 for goal in plugin.getGoalList(): self.assertEqual(goal.localName, goals[i]) i += 1
def getDependencies(self): self._dmget = PlugInManager().getPlugInInstance("DepManGetPlugIn") if self._dmget == None: self.reportError("PlugIn `depman get` not found") return unPackList = [] for dep in self._dependencyList: self._dmget.setDependency(dep) #prevents downloading of not matching platforms but overrided if not self._isInteractive: if self._isFromCache: self._dmget.setForceCache() else: self._dmget.setForceRemote() self._dmget.get(unPackList) return unPackList
def clean(self): self._dmplugin = PlugInManager().getPlugInInstance("DepManPlugIn") if self._dmplugin == None: self.reportError("PlugIn `depman` not found") self.setExecute(False) return self._default_repository = self._dmplugin.getDepManPath() #the extra parameter "all" enables dmn to clear the cache directory print "* cleaning..." util = BMUtil() util.rmdir(self._default_repository + os.path.sep + "include") util.rmdir(self._default_repository + os.path.sep + "lib") util.rmdir(self._default_repository + os.path.sep + "bin") util.rmdir(self._default_repository + os.path.sep + "share") util.rmdir(self._default_repository + os.path.sep + "Frameworks") if self._delete_cache: util.rmdir(self._default_repository + os.path.sep + ".cache") return True
def init(self): self.addGoal("buildman", "executes goals from a buildman file") self.addGoalOption("buildman","--file", "Sets the file to execute, otherwise search for buildman.xml") self._dmplugin = PlugInManager().getPlugInInstance("DepManPlugIn") if self._dmplugin == None: self.reportError("PlugIn `depman` not found") return isBuildMan = False while self._arguments.read("buildman"): self.setExecute(True) isBuildMan = True if not isBuildMan: return args=[""] while self._arguments.read("--file",args): self._file = args[0]
def update(self): if self._must_Clean: self._dmclean = PlugInManager().getPlugInInstance( "DepManCleanPlugIn") if self._dmclean == None: self.reportError("PlugIn `depman clean` not found") return delete_cache = self._dmclean.getDeleteCache() self._dmclean.setDeleteCache(False) self._dmclean.clean() self._dmclean.setDeleteCache(delete_cache) if self._depmanNode == None: self.loadXMLFile(self._xmlfile) unPackList = self.getDependencies(self._depmanNode) #once the xml is parsed and files downloaded, lets unpack them self.unpack(unPackList)
def init(self): self.addGoal("update", "Update current project") self.addGoalOption("update", "--cache", "Cache is preferred") self.addGoalOption("update", "--remote", "Remote repository is preferred") self.addPreGoal("update", "depman") self.addPreGoal("update", "clean") if self._arguments.read("update"): self.setExecute(True) if self._arguments.read("--cache"): self._isInteractive = False self._isFromCache = True if self._arguments.read("--remote"): self._isInteractive = False self._isFromCache = False self._dmplugin = PlugInManager().getPlugInInstance("DepManPlugIn") if self._dmplugin == None: self.reportError("PlugIn `depman` not found") return
def initFromXML(self,node): if node.localName=="buildman": for g in node.childNodes: if g.localName == "goals": addGoals = False if g.hasAttributes(): if g.attributes.has_key("platform"): value = g.attributes.get("platform").value platforms = value.split(",") for platform in platforms: if platform == self._dmplugin.getOSPlatform(): addGoals = True else: addGoals = True if addGoals: for goalNode in g.childNodes: #print goalNode.localName, " in ", PlugInManager().supportedGoals(), "?" if goalNode.localName=="buildman": if goalNode.hasAttributes(): if goalNode.attributes.has_key("file"): self.loadXMLFile(goalNode.attributes.get("file").value) else: if goalNode.localName in PlugInManager().supportedGoals(): self._goalList.append(goalNode)
def extract(self): self._dmupdate = PlugInManager().getPlugInInstance( "DepManUpdatePlugIn") if self._dmupdate == None: self.reportError("PlugIn `depman update` not found") return if self._depmanNode == None: self.loadXMLFile(self._xmlFile) if not self._isInteractive: if self._isFromCache: self._dmupdate.setForceCache() else: self._dmupdate.setForceRemote() dependency_filenamepaths = self._dmupdate.getDependencies( self._depmanNode) package_namepath = self.parsePackage(self._depmanNode) print dependency_filenamepaths, self._destDir, self._filter bmutil = BMUtil() for file in dependency_filenamepaths: bmutil.untargzFiltered(file, self._destDir, self._filter)
return self._osplatform def getOSArch(self): return self._osarch def getOSCompiler(self): return self._oscompiler def getDepManPath(self): dr = os.getenv("DEPMAN_REPO") if not dr is None: return dr; if sys.platform == "linux2" or sys.platform == "linux1": dr = os.getenv("HOME")+os.path.sep+".depman" return dr; if sys.platform == "win32" or sys.platform == "win64": #ex: c:\documents and setting\user\DepMan dr = os.getenv("USERPROFILE")+os.path.sep+"DepMan" return dr; if sys.platform == "darwin": dr = os.path.sep + "Developer" + os.path.sep + "DepMan" return dr; return None def getDepManDataPath(self): return self._depmanDataPath PlugInManager().registerPlugIn("DepManPlugIn",DepManPlugIn())
import shutil class PrepareSystemPlugIn(IPlugIn): def __init__(self): IPlugIn.__init__(self) def init(self): self.addGoal( "init", "Prepares the system with the buildman user directory with an example plugin" ) while self._arguments.read("init"): self.setExecute(True) def execute(self): print "Executing Plugin:" + str(self.__class__) + "\n" util = BMUtil() bmpath = util.buildmanPlugInPath() try: util.mkdir(bmpath) #shutil.copy(sys.path[0]+os.path.sep+"bmplugins"+os.path.sep+"TestPlugIn.py_",util.buildmanPlugInPath()+os.path.sep+"TestPlugIn.py") except: self.reportError( "Error creating buildman directory or copying test plugin") return False return True PlugInManager().registerPlugIn("PrepareSystemPlugIn", PrepareSystemPlugIn())
def extract(self): self._dmupdate = PlugInManager().getPlugInInstance( "DepManUpdatePlugIn") if self._dmupdate == None: self.reportError("PlugIn `depman update` not found") return if self._depmanNode == None: self.loadXMLFile(self._xmlFile) if not self._isInteractive: if self._isFromCache: self._dmupdate.setForceCache() else: self._dmupdate.setForceRemote() dependency_filenamepaths = self._dmupdate.getDependencies( self._depmanNode) package_namepath = self.parsePackage(self._depmanNode) print dependency_filenamepaths, self._destDir, self._filter bmutil = BMUtil() for file in dependency_filenamepaths: bmutil.untargzFiltered(file, self._destDir, self._filter) def parsePackage(self, node): return "" PlugInManager().registerPlugIn("DepManExtractPlugIn", DepManExtractPlugIn())
self._path = args[0] self.setExecute(True) def initFromXML(self, dom): node = dom.getElementsByTagName("delete")[0] if node != None: if node.hasAttributes(): if node.attributes.has_key("path"): self._path = node.attributes.get("path").value def execute(self): if self._path == "": self.reportError("Missing required path option") self._path = os.path.abspath(self._path) util = BMUtil() if not os.path.exists(self._path): return True if os.path.isdir(self._path): print "* Removing directory " + self._path util.rmdir(self._path) else: print "* Removing file " + self._path os.remove(self._path) return True PlugInManager().registerPlugIn("DeleteFilePlugIn", DeleteFilePlugIn())
str(self._options)) return False if self._option not in self._options: self.reportError("not supported svn option, use one of " + str(self._options)) return False if self._projectPath == "": self.reportError("Missing required project path option") return False if self._option == "co" or self._option == "checkout": if self._svnUrl == "": self.reportError("Missing required svn url ption") return False self._projectPath = os.path.abspath(self._projectPath) projectName = os.path.basename(self._projectPath) print "Executing Plugin:" + str(self.__class__) bmutil = BMUtil() svnCommand = "svn " + self._option if self._option in ['co', 'checkout']: svnCommand += " " + self._svnUrl + " " + self._projectPath else: if self._option in ['up', 'update']: svnCommand += " " + self._projectPath os.system(svnCommand) return True PlugInManager().registerPlugIn("SVNPlugIn", SVNPlugIn())
def init(self): self.addGoal("get", "downloads an artifact if not in cache.") self.addGoalOption("get", "--url", "URL base for the DepMan repository.") self.addGoalOption("get", "--group", "Group namespace of the artifact.") self.addGoalOption("get", "--artifact", "Name of the artifact to download.") self.addGoalOption("get", "--version", "Version of the artifact.") self.addGoalOption("get", "--platform", "Platform of the artifact.") self.addGoalOption("get", "--distribution", "Distribution of the artifact.") self.addGoalOption( "get", "--compiler", "Selects the compiler version that was used to compile the artifact." ) self.addGoalOption("get", "--arch", "Selects the architecture of the artifact.") self.addGoalOption("get", "--ltype", "Type of library of the artifact.") self.addGoalOption("get", "--cache", "Forces the use of cache files without asking.") self.addGoalOption( "get", "--remote", "Forces the download of remote without the use of the cache and without asking." ) self._dmplugin = PlugInManager().getPlugInInstance("DepManPlugIn") if self._dmplugin == None: self.reportError("PlugIn `depman` not found") return self._default_repository = self._dmplugin.getDepManPath() while self._arguments.read("get"): self._dependency = Dependency() self.setExecute(true) args = [""] if self._arguments.read("--url", args): self._dependency.url = args[0] args = [""] if self._arguments.read("--group", args): self._dependency.group = args[0] args = [""] if self._arguments.read("--artifact", args): self._dependency.artifact = args[0] args = [""] if self._arguments.read("--version", args): self._dependency.version = args[0] args = [""] if self._arguments.read("--platform", args): self._dependency.platform = args[0] args = [""] if self._arguments.read("--distribution", args): self._dependency.distribution = args[0] args = [""] if self._arguments.read("--compiler", args): self._dependency.compiler = args[0] args = [""] if self._arguments.read("--arch", args): self._dependency.arch = args[0] args = [""] if self._arguments.read("--ltype", args): self._dependency.libraryType = args[0] if self._arguments.read("--cache"): self._forceCache = True self._isInteractive = False if self._arguments.read("--remote"): self._forceCache = False self._isInteractive = False
def testArguments(self): arguments = ArgumentParser( ['bmn.py', 'buildman', '--file', 'bmtests/data/buildman.xml']) bm = BuildMan(arguments) plugin = PlugInManager().getPlugInInstance("BuildManPlugIn") self.assertEqual('bmtests/data/buildman.xml', plugin.getFile())
addGoals = True if addGoals: for goalNode in g.childNodes: #print goalNode.localName, " in ", PlugInManager().supportedGoals(), "?" if goalNode.localName=="buildman": if goalNode.hasAttributes(): if goalNode.attributes.has_key("file"): self.loadXMLFile(goalNode.attributes.get("file").value) else: if goalNode.localName in PlugInManager().supportedGoals(): self._goalList.append(goalNode) def execute(self): print "Executing Plugin:" + str(self.__class__) return self.buildman() def buildman(self): self.loadXMLFile(self._file) for goal in self._goalList: plugin = PlugInManager().getPlugInInstanceByGoal(goal.localName) plugin.initFromXML(goal) plugin.execute() if plugin.error(): for error in plugin.getErrorMessages(): self.reportError(error) return False return True PlugInManager().registerPlugIn("BuildManPlugIn",BuildManPlugIn())
os.system(cmdCompiler) os.chdir(olddir) def __cpuCount(self): ''' Returns the number of CPUs in the system ''' if sys.platform == 'win32': try: num = int(os.environ['NUMBER_OF_PROCESSORS']) except (ValueError, KeyError): pass elif sys.platform == 'darwin': try: num = int(os.popen('sysctl -n hw.ncpu').read()) except ValueError: pass else: try: num = os.sysconf('SC_NPROCESSORS_ONLN') except (ValueError, OSError, AttributeError): pass if num >= 1: return num return 1 PlugInManager().registerPlugIn("CompileSolutionPlugIn", CompileSolutionPlugIn())
self._dmget.setLibraryType(ltype) #prevents downloading of not matching platforms but overrided if not self._isInteractive: if self._isFromCache: self._dmget.setForceCache() else: self._dmget.setForceRemote() self._dmget.get(unPackList) return unPackList def unpack(self, unPackList): sep = os.path.sep dmutil = BMUtil() for file in unPackList: tmpstr = file[file.rfind(sep) + 1:] print "* unpacking ", tmpstr dmutil.untargz(file, self._dmplugin.getDepManPath()) def setForceCache(self): self._isFromCache = True self._isInteractive = False def setForceRemote(self): self._isFromCache = False self._isInteractive = False #after unpacking, the unpack list is freed PlugInManager().registerPlugIn("DepManUpdatePlugIn", DepManUpdatePlugIn())
def getDependencies(self, node): self._dmplugin = PlugInManager().getPlugInInstance("DepManPlugIn") if self._dmplugin == None: self.reportError("PlugIn `depman` not found") return self._dmget = PlugInManager().getPlugInInstance("DepManGetPlugIn") if self._dmget == None: self.reportError("PlugIn `depman get` not found") return group = "none" artifact = "none" version = "0" platform = "none" compiler = "none" arch = "none" ltype = "none" #os default values defplatform = self._dmplugin.getOSPlatform() defarch = self._dmplugin.getOSArch() defcompiler = self._dmplugin.getOSCompiler() #hardcoded default url #defurl=default_url defurl = self._defurl unPackList = [] if node.hasAttributes(): if node.attributes.has_key("url"): defurl = node.attributes.get("url").value for i in node.childNodes: if i.localName == "dependencies": url = defurl #os default values defplatform = self._dmplugin._osplatform defarch = self._dmplugin._osarch defcompiler = self._dmplugin._oscompiler if i.hasAttributes(): if i.attributes.has_key("platform"): defplatform = i.attributes.get("platform").value if i.attributes.has_key("architecture"): defarch = i.attributes.get("architecture").value if i.attributes.has_key("compiler"): defcompiler = i.attributes.get("compiler").value if i.attributes.has_key("url"): url = i.attributes.get("url").value list_of_platforms = defplatform.split(",") #depedencies platform checking #we just go on whenever host os or all matches if len(list_of_platforms) > 0 and self._dmplugin.getOSPlatform( ) not in list_of_platforms and "all" not in list_of_platforms: invalid_platform = True else: invalid_platform = False defplatform = self._dmplugin.getOSPlatform() del list_of_platforms[:] #print "Url: ",url if not invalid_platform: for j in i.childNodes: if j.localName == "dependency": #set default values platform = defplatform arch = defarch compiler = defcompiler group = "none" artifact = "none" version = "0" ltype = "none" durl = url if j.hasAttributes(): if j.attributes.has_key("url"): durl = j.attributes.get("url").value for h in j.childNodes: if h.localName == "group": group = h.childNodes[0].nodeValue if h.localName == "artifact": artifact = h.childNodes[0].nodeValue if h.localName == "version": version = h.childNodes[0].nodeValue if h.localName == "platform": platform = h.childNodes[0].nodeValue if h.localName == "compiler": compiler = h.childNodes[0].nodeValue if h.localName == "architecture": arch = h.childNodes[0].nodeValue if h.localName == "type": ltype = h.childNodes[0].nodeValue self._dmget.setURL(durl) self._dmget.setGroup(group) self._dmget.setArtifact(artifact) self._dmget.setVersion(version) self._dmget.setPlatform(platform) self._dmget.setCompiler(compiler) self._dmget.setArch(arch) self._dmget.setLibraryType(ltype) #prevents downloading of not matching platforms but overrided if not self._isInteractive: if self._isFromCache: self._dmget.setForceCache() else: self._dmget.setForceRemote() self._dmget.get(unPackList) return unPackList
def create(self): self._dmplugin = PlugInManager().getPlugInInstance("DepManPlugIn") if self._dmplugin == None: self.reportError("PlugIn `depman` not found") return False #user questions if self._is_Interactive: self._group = raw_input("Group: ") self._artifact = raw_input("Artifact: ") self._version = raw_input("Version: ") tmpstr = "" for p in self._dmplugin.getSupportedPlatforms(): tmpstr = tmpstr + p + " " print "( ", tmpstr, ")" tmstr = "Platform [*]:" self._platform = raw_input( string.replace(tmstr, "*", self._dmplugin.getOSPlatform())) if len(self._platform) == 0: self._platform = self._dmplugin.getOSPlatform() tmpstr = "" for p in self._dmplugin.getSupportedCompilers(): tmpstr = tmpstr + p + " " print "( ", tmpstr, ")" tmstr = "Compiler [*]:" self._compiler = raw_input( string.replace(tmstr, "*", self._dmplugin.getOSCompiler())) if len(self._compiler) == 0: self._compiler = self._dmplugin.getOSCompiler() tmpstr = "" for p in self._dmplugin.getSupportedArchs(): tmpstr = tmpstr + p + " " print "( ", tmpstr, ")" tmstr = "Architecture [*]:" self._arch = raw_input( string.replace(tmstr, "*", self._dmplugin.getOSArch())) if len(self._arch) == 0: self._arch = self._dmplugin.getOSArch() tmpstr = "" for p in self._dmplugin.getSupportedLibraryTypes(): tmpstr = tmpstr + p + " " print "( ", tmpstr, ")" self._ltype = raw_input("Library Type: ") upload_response = raw_input("Upload to server? (y/n): ") if upload_response == "y" or upload_response == "yes": self._upload = True if self._packageNode != None: for n in self._packageNode.childNodes: if n.localName == "package": processPackage = True if n.hasAttributes(): if n.attributes.has_key("platform"): values = n.attributes.get("platform").value.split( ",") if self._dmplugin.getOSPlatform() in values: processPackage = True else: processPackage = False if processPackage: print "Processing for platform..." for p in n.childNodes: if p.localName == "group": self._group = p.childNodes[0].nodeValue if p.localName == "artifact": self._artifact = p.childNodes[0].nodeValue if p.localName == "version": self._version = p.childNodes[0].nodeValue if p.localName == "platform": self._platform = p.childNodes[0].nodeValue if p.localName == "compiler": self._compiler = p.childNodes[0].nodeValue if p.localName == "arch": self._arch = p.childNodes[0].nodeValue if p.localName == "libraryType": self._ltype = p.childNodes[0].nodeValue if p.localName == "upload": #TODO: Maybe upload should be an external plugin for k in p.childNodes: if k.localName == "sshserver": self._default_ssh = k.childNodes[ 0].nodeValue if k.localName == "destdir": self._default_destdir = k.childNodes[ 0].nodeValue if k.localName == "username": self._default_login = k.childNodes[ 0].nodeValue if self._group == "": self.reportError("Group cannot be empty") return False if self._artifact == "": self.reportError("Artifact cannot be empty") return False if self._version == "": self.reportError("Version cannog be empty") return self._group = self._group.replace(".", "/") if self._platform == "default": self._platform = self._dmplugin.getOSPlatform() if self._compiler == "default": self._compiler = self._dmplugin.getOSCompiler() if self._arch == "default": self._arch = self._dmplugin.getOSArch() #let's check user input consistency if self._platform not in self._dmplugin.getSupportedPlatforms(): self.reportError("Platform not supported: " + self._platform + ". Supported platforms:" + str(self._dmplugin.getSupportedPlatforms())) return False if self._compiler not in self._dmplugin.getSupportedCompilers(): self.reportError("Compiler not supported: " + self._compiler + ". Supported compilers:" + str(self._dmplugin.getSupportedCompilers())) return False if self._arch not in self._dmplugin.getSupportedArchs(): self.reportError("Architecture not supported: " + self._arch + ". Supported archs:" + str(self._dmplugin.getSupportedArchs())) return False if self._ltype not in self._dmplugin.getSupportedLibraryTypes(): self.reportError("Library type not supported: " + self._ltype + ". Supported libraries:" + str(self._dmplugin.getSupportedLibraryTypes())) return False #artifact and md5 generation file_name = self._artifact + "-" + self._version + "-" + self._platform + "-" + self._compiler + "-" + self._arch + "-" + self._ltype tarname = file_name + ".tar.gz" md5name = tarname + ".md5" dmfile = file_name + ".xml" dmutil = BMUtil() tmpdir = self._dmplugin.getDepManPath( ) + os.path.sep + ".cache" + os.path.sep + self._group + os.path.sep + self._artifact + os.path.sep + self._version + os.path.sep + self._platform + os.path.sep + self._compiler + os.path.sep + self._arch + os.path.sep + self._ltype dmutil.mkdir(tmpdir) print tmpdir + os.path.sep + tarname, self._path dmutil.targz(os.path.join(tmpdir, tarname), self._path) #print "targz ",tmpdir+os.path.sep+tarname dmutil.createMD5(tmpdir + os.path.sep + tarname, tmpdir + os.path.sep + md5name) if self._xmlfile != "": shutil.copyfile(self._xmlfile, tmpdir + os.path.sep + dmfile) print "Artifact " + tarname + " created in:\n" + tmpdir if self._upload: dmutil.rmdir( ".dmn_tmp") # Prevent for uploading bad previous compilations! sshtmpdir = ".dmn_tmp" + os.path.sep + self._group + os.path.sep + self._artifact + os.path.sep + self._version + os.path.sep + self._platform + os.path.sep + self._compiler + os.path.sep + self._arch + os.path.sep + self._ltype dmutil.mkdir(sshtmpdir) shutil.copyfile(tmpdir + os.path.sep + tarname, sshtmpdir + os.path.sep + tarname) shutil.copyfile(tmpdir + os.path.sep + md5name, sshtmpdir + os.path.sep + md5name) if self._xmlfile != "": shutil.copyfile(tmpdir + os.path.sep + dmfile, sshtmpdir + os.path.sep + dmfile) url = self._default_ssh destdir = self._default_destdir login = self._default_login if self._is_Interactive: tmstr = "SSH Server [*]:" url = raw_input(string.replace(tmstr, "*", self._default_ssh)) if len(url) == 0: url = self._default_ssh tmstr = "Destination Directory [*]:" destdir = raw_input( string.replace(tmstr, "*", self._default_destdir)) if len(destdir) == 0: destdir = self._default_destdir tmstr = "Login [*]:" login = raw_input( string.replace(tmstr, "*", self._default_login)) if len(login) == 0: login = self._default_login download_dir = self._group + "/" + self._artifact + "/" + self._version + "/" + self._platform + "/" + self._compiler + "/" + self._arch + "/" + self._ltype print "* Uploading ", tarname print "* Uploading ", md5name #scp base_ssh = destdir url_ssh = url scpcommand = "scp" pscppath = "" if sys.platform == "win32": scpcommand = self._dmplugin.getDepManDataPath( ) + os.path.sep + "win32" + os.path.sep + "pscp.exe" scpcommand = '"' + os.path.normpath(scpcommand) + '"' cmdstr = scpcommand + " -r " + ".dmn_tmp" + os.path.sep + "*" + " " + login + "@" + url_ssh + ":" + base_ssh print cmdstr os.system(cmdstr) #scp dmutil.rmdir(".dmn_tmp")
if self._projectPath=="": self.reportError("Missing required project path option") return False if self._cmakeGenerator!="" and self._projectPath!="": self._projectPath = os.path.abspath(self._projectPath) projectName = os.path.basename(self._projectPath) if self._projectGenerationPath=="": self._projectGenerationPath=os.path.abspath(os.path.join(self._projectPath,"BMCMake")) if self._installPath=="": self._installPath=os.path.abspath(self._projectPath+os.path.sep+".."+os.path.sep+projectName+"-install") if self._buildType=="": self._buildType="Release" bmutil = BMUtil() print " * Creating Project Generation Path: "+self._projectGenerationPath bmutil.mkdir(self._projectGenerationPath) olddir = os.getcwd() os.chdir(self._projectGenerationPath) if os.path.exists("CMakeCache.txt"): os.remove("CMakeCache.txt") cmakeCommand = "cmake "+self._cmakeOtherOptions+" -G\""+self._cmakeGenerator+"\" -DCMAKE_BUILD_TYPE="+self._buildType+" -DCMAKE_INSTALL_PREFIX="+self._installPath+" "+self._projectPath print " * Running CMAKE: " + cmakeCommand os.system(cmakeCommand) os.chdir(olddir) return True PlugInManager().registerPlugIn("CreateSolutionPlugIn",CreateSolutionPlugIn())