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())
