class DepManCleanPlugIn(IPlugIn):
def __init__(self):
IPlugIn.__init__(self)
self._delete_cache = False
self._default_repository = ""
def init(self):
self.addGoal("clean", "Cleans the repository")
self.addGoalOption("clean", "--all", "Cleans also cache files")
isClean = False
if self._arguments.read("clean"):
self.setExecute(True)
isClean = True
if not isClean:
return
if self._arguments.read("--all"):
self._delete_cache = True
def initFromXML(self, dom):
node = dom.getElementsByTagName("clean")[0]
if node != None:
if node.localName == "clean":
if node.hasAttributes():
if node.attributes.has_key("all"):
value = node.attributes.get("all").value
if value == "True" or value == "true":
self._delete_cache = True
def execute(self):
print "Executing Plugin:" + str(self.__class__)
return self.clean()
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 setDeleteCache(self, value):
self._delete_cache = value
def getDeleteCache(self):
return self._delete_cache
def setDefaultRepository(self, defrepo):
self._default_repository = defrepo
def getDefaultRepository(self):
return self._default_repository
class DepManUpdatePlugIn(IPlugIn):
def __init__(self):
IPlugIn.__init__(self)
self._must_Clean=True
self._isFromCache=False
self._isInteractive=True
self._xmlfile="depman.xml"
self._depmanNode = None
self._defurl="http://murray.ai2.upv.es/depman"
def init(self):
self.addGoal("update", "Update current project")
self.addGoalOption("update","--no-clean", "Do not perform a repository clean before update")
self.addGoalOption("update","--cache", "Cache is preferred")
self.addGoalOption("update","--remote", "Remote repository is preferred")
self.addGoalOption("update","--file", "Specifies a dependency xml file")
isUpdate = False
if self._arguments.read("update"):
self.setExecute(True)
isUpdate = True
if not isUpdate:
return
if self._arguments.read("--no-clean"):
self._must_Clean = False
if self._arguments.read("--cache"):
self._isInteractive=False
self._isFromCache = True
if self._arguments.read("--remote"):
self._isInteractive=False
self._isFromCache = False
args=[""]
if self._arguments.read("--file",args):
self._xmlfile=args[0]
def initFromXML(self,node):
if node.localName == "update":
if node.hasAttributes():
if node.attributes.has_key("file"):
self.loadXMLFile(node.attributes.get("file").value)
if node.attributes.has_key("no-clean"):
value = node.attributes.get("no-clean").value
if value == "True" or value == "true":
self._must_Clean = True
foundCache = False
if node.attributes.has_key("cache"):
value = node.attributes.get("cache").value
if value == "True" or value == "true":
self._isFromCache = True
if node.attributes.has_key("remote") and not foundCache:
value = node.attributes.get("remote").value
if value == "True" or value == "true":
self._isFromCache = False
self._isInteractive = False
else:
self._depmanNode = node
def execute(self):
print "Executing Plugin:" + str(self.__class__)
return self.update()
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 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 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
class DepManCreatePlugIn(IPlugIn):
def __init__(self):
IPlugIn.__init__(self)
self._path="."
self._group=""
self._artifact=""
self._version=""
self._platform="default"
self._arch="default"
self._compiler="default"
self._ltype=""
self._upload=False
self._is_Interactive=True
self._xmlfile = ""
self._packageNode = None
self._default_ssh="murray.ai2.upv.es"
self._default_login="******"
self._default_destdir = "/projects/AI2/www-aliases/depman/"
def init(self):
self.addGoal("create", "Create an artifact")
self.addGoalOption("create","--path", "Specifies source directory")
self.addGoalOption("create","--group", "Specifies artifact group name")
self.addGoalOption("create","--artifact", "Specifies artifact name")
self.addGoalOption("create","--version", "Specifies artifact version")
self.addGoalOption("create","--platform", "Specifies artifact OS platform")
self.addGoalOption("create","--arch", "Specifies artifact hardware architecture")
self.addGoalOption("create","--compiler", "Specifies artifact compiler version")
self.addGoalOption("create","--ltype", "Specifies library type if needed")
self.addGoalOption("create","--upload", "Whenever the artifact must be uploaded or not")
self.addGoalOption("create","--from-xml", "Uses the given depman.xml file to create the package")
isCreate = False
if self._arguments.read("create"):
self.setExecute(True)
isCreate = True
if not isCreate:
return
args=[""]
use_xml=False
if self._arguments.read("--from-xml",args):
self._xmlfile=args[0]
use_xml=True
if use_xml:
self.loadXMLFile(self._xmlfile)
args=[""]
if self._arguments.read("--path",args):
self._path=args[0]
args=[""]
if self._arguments.read("--group",args):
self._group=args[0]
self._is_Interactive=False
args=[""]
if self._arguments.read("--artifact",args):
self._artifact=args[0]
self._is_Interactive=False
args=[""]
if self._arguments.read("--version",args):
self._version=args[0]
self._is_Interactive=False
args=[""]
if self._arguments.read("--platform",args):
self._platform=args[0]
self._is_Interactive=False
args=[""]
if self._arguments.read("--arch",args):
self._arch=args[0]
self._is_Interactive=False
args=[""]
if self._arguments.read("--compiler",args):
self._compiler=args[0]
self._is_Interactive=False
args=[""]
if self._arguments.read("--ltype",args):
self._ltype=args[0]
self._is_Interactive=False
if self._arguments.read("--upload"):
self._upload=True
def initFromXML(self,node):
if node.localName == "create":
if node.hasAttributes():
if node.attributes.has_key("from-xml"):
self._xmlfile=node.attributes.get("from-xml").value
self.loadXMLFile(self._xmlfile)
if node.attributes.has_key("path"):
self._path = node.attributes.get("path").value
if node.attributes.has_key("upload"):
value = node.attributes.get("upload").value
if value =="True" or value =="true":
self._upload = True
else:
if node.localName == "depman":
self._packageNode = node
self._is_Interactive=False
def execute(self):
print "Executing Plugin:" + str(self.__class__)
return self.create()
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")
class DepManCleanPlugIn(IPlugIn):
def __init__(self):
IPlugIn.__init__(self)
self._delete_cache = False
self._default_repository = ""
def init(self):
self.addGoal("clean", "Cleans dependency files")
self.addGoalOption("clean","--all", "Cleans also cache files")
isClean = False
if self._arguments.read("clean"):
self.setExecute(True)
isClean = True
if not isClean:
return
if self._arguments.read("--all"):
self._delete_cache = True
def initFromXML(self,node):
if node.localName=="clean":
if node.hasAttributes():
if node.attributes.has_key("all"):
value = node.attributes.get("all").value
if value=="True" or value == "true":
self._delete_cache = True
def execute(self):
print "Executing Plugin:" + str(self.__class__)
return self.clean()
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 setDeleteCache(self,value):
self._delete_cache = value
def getDeleteCache(self):
return self._delete_cache
def setDefaultRepository(self,defrepo):
self._default_repository = defrepo
def getDefaultRepository(self):
return self._default_repository
class DepManUpdatePlugIn(IPlugIn):
def __init__(self):
IPlugIn.__init__(self)
self._must_Clean=True
self._isFromCache=False
self._isInteractive=True
self._defurl="http://downloads.gvsig.org/pub/gvSIG-desktop/buildman-repository"
self._dependencyList = []
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,dom):
defurl=self._defurl
node = dom.getElementsByTagName("depman")[0]
if node != None:
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.getOSPlatform()
defdistribution=self._dmplugin.getOSDistribution()
defarch=self._dmplugin.getOSArch()
defcompiler=self._dmplugin.getOSCompiler()
if i.hasAttributes():
if i.attributes.has_key("platform"):
defplatform=i.attributes.get("platform").value
if i.attributes.has_key("distribution"):
defdistribution=i.attributes.get("distribution").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[:]
if not invalid_platform:
for j in i.childNodes:
if j.localName=="dependency":
dependency = DepManDependency(self._dmplugin)
#set default values
dependency.platform=defplatform
dependency.distribution=defdistribution
dependency.arch=defarch
dependency.compiler=defcompiler
dependency.url = url
if j.hasAttributes():
if j.attributes.has_key("url"):
dependency.url=j.attributes.get("url").value
for h in j.childNodes:
if h.localName=="group":
dependency.group=h.childNodes[0].nodeValue
if h.localName=="artifact":
dependency.artifact=h.childNodes[0].nodeValue
if h.localName=="version":
dependency.version=h.childNodes[0].nodeValue
if h.localName=="platform":
dependency.platform=h.childNodes[0].nodeValue
if h.localName=="distribution":
dependency.distribution=h.childNodes[0].nodeValue
if h.localName=="compiler":
dependency.compiler=h.childNodes[0].nodeValue
if h.localName=="architecture":
dependency.arch=h.childNodes[0].nodeValue
if h.localName=="type":
dependency.libraryType=h.childNodes[0].nodeValue
self._dependencyList.append(dependency)
def execute(self):
return self.update()
def update(self):
self.initFromXML(self._dmplugin.getNode())
for i in self._dependencyList:
print i
unPackList = self.getDependencies()
#once the xml is parsed and files downloaded, lets unpack them
self.unpack(unPackList)
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 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
class DepManUpdatePlugIn(IPlugIn):
def __init__(self):
IPlugIn.__init__(self)
self._must_Clean = True
self._isFromCache = False
self._isInteractive = True
self._xmlfile = "depman.xml"
self._depmanNode = None
self._defurl = "http://murray.ai2.upv.es/depman"
def init(self):
self.addGoal("update", "Update current project")
self.addGoalOption("update", "--no-clean",
"Do not perform a repository clean before update")
self.addGoalOption("update", "--cache", "Cache is preferred")
self.addGoalOption("update", "--remote",
"Remote repository is preferred")
self.addGoalOption("update", "--file",
"Specifies a dependency xml file")
isUpdate = False
if self._arguments.read("update"):
self.setExecute(True)
isUpdate = True
if not isUpdate:
return
if self._arguments.read("--no-clean"):
self._must_Clean = False
if self._arguments.read("--cache"):
self._isInteractive = False
self._isFromCache = True
if self._arguments.read("--remote"):
self._isInteractive = False
self._isFromCache = False
args = [""]
if self._arguments.read("--file", args):
self._xmlfile = args[0]
def initFromXML(self, node):
if node.localName == "update":
if node.hasAttributes():
if node.attributes.has_key("file"):
self.loadXMLFile(node.attributes.get("file").value)
if node.attributes.has_key("no-clean"):
value = node.attributes.get("no-clean").value
if value == "True" or value == "true":
self._must_Clean = True
foundCache = False
if node.attributes.has_key("cache"):
value = node.attributes.get("cache").value
if value == "True" or value == "true":
self._isFromCache = True
if node.attributes.has_key("remote") and not foundCache:
value = node.attributes.get("remote").value
if value == "True" or value == "true":
self._isFromCache = False
self._isInteractive = False
else:
self._depmanNode = node
def execute(self):
print "Executing Plugin:" + str(self.__class__)
return self.update()
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 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 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
class DepManGetPlugIn(IPlugIn):
def __init__(self):
IPlugIn.__init__(self)
self._default_repository = ""
self._dependency = None
self._forceCache = False
self._isInteractive = True
def setDependency(self, dependency):
self._dependency = dependency
def setURL(self, url):
self._url = url
def setForceCache(self):
self._forceCache = True
self._isInteractive = False
def setForceRemote(self):
self._forceCache = False
self._isInteractive = False
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 initFromXML(self, node):
pass
#TODO: . . .
def execute(self):
if self._dependency == None:
self.reportError("Missing dependency option")
return False
if self._url == "":
self.reportError("Missing url option")
return False
if not self._dmplugin.validateDependency(self._dependency):
return False
return self.get()
def get(self, unPackList=None):
print "[", self._dependency.artifact, "]"
file_name = self._dependency.getDepManFileName()
tarname = file_name + ".tar.gz"
md5name = tarname + ".md5"
download_path = self._dependency.getDepManFilePath()
download_dir = self._dependency.getDepManUrlPath()
cache_path = self._default_repository + os.path.sep + ".cache" + os.path.sep + download_path
is_snapshot = self._dependency.isSnapshot()
dmutil = BMUtil()
is_tar = True
is_md5 = True
if not dmutil.checkUrl(self._dependency.url + "/" + download_dir +
"/" + md5name):
#print "Error: File ",baseurl+"/"+download_dir+"/"+md5name, " not found in the repository"
is_md5 = False
if not dmutil.checkUrl(self._dependency.url + "/" + download_dir +
"/" + tarname):
#print "Error: File ",baseurl+"/"+download_dir+"/"+tarname, " not found in the repository"
is_tar = False
dmutil.mkdir(cache_path)
if not os.path.isfile(cache_path + os.path.sep + md5name):
is_cache = False
else:
is_cache = True
#Once all variables have been collected, lets decide what to do with the artifact
must_download = False
if (not is_md5 or not is_tar) and not is_cache:
print "Error: Artifact ", tarname, " not found"
return False
if not is_md5 and not is_tar and is_cache:
print "* file not found in repository, using cache..."
must_download = False
if is_md5 and is_tar and not is_cache:
print "* file is not in cache, downloading..."
must_download = True
if is_md5 and is_tar and is_cache:
if is_snapshot:
if self._isInteractive:
repo = raw_input(
"What snapshot do you want to use? (cache/remote): ")
else:
if self._forceCache:
repo = "cache"
else:
repo = "remote"
must_download = False
#in case of misspeling, using cache by default
if repo != "cache" and repo != "remote":
repo = "cache"
else:
repo = "remote"
if repo == "remote":
print "* file cached, checking md5..."
dmutil.download(self._url + "/" + download_dir + "/" + md5name,
cache_path + os.path.sep + md5name + ".new")
if dmutil.diff(cache_path + os.path.sep + md5name,
cache_path + os.path.sep + md5name + ".new"):
print "* no md5 matching, re-downloading..."
must_download = True
else:
print "* md5 matching succesful"
must_download = False
os.remove(cache_path + os.path.sep + md5name + ".new")
if must_download == True:
print "URL :", self._dependency.url
dmutil.download(
self._dependency.url + "/" + download_dir + "/" + md5name,
cache_path + os.path.sep + md5name)
#print "* downloaded [",md5name,"]"
dmutil.download(
self._dependency.url + "/" + download_dir + "/" + tarname,
cache_path + os.path.sep + tarname)
#print "* downloaded[",tarname,"]"
if unPackList != None:
if (cache_path + os.path.sep + tarname) not in unPackList:
unPackList.append(cache_path + os.path.sep + tarname)
return True
class DepManGetPlugIn(IPlugIn):
def __init__(self):
IPlugIn.__init__(self)
self._default_repository = ""
self._url = ""
self._group = ""
self._artifact = ""
self._version = ""
self._platform = ""
self._artifact = ""
self._compiler = ""
self._arch = ""
self._ltype = ""
self._forceCache = False
self._isInteractive = True
def setURL(self,url):
self._url = url
def setGroup(self,group):
self._group = group
def setArtifact(self,artifact):
self._artifact = artifact
def setVersion(self,version):
self._version = version
def setPlatform(self,platform):
self._platform = platform
def setCompiler(self,compiler):
self._compiler = compiler
def setArch(self,arch):
self._arch = arch
def setLibraryType(self,ltype):
self._ltype = ltype
def setForceCache(self):
self._forceCache = True
self._isInteractive = False
def setForceRemote(self):
self._forceCache = False
self._isInteractive = False
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","--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()
isGet = False
while self._arguments.read("get"):
isGet = True
if not isGet:
return
args=[""]
if self._arguments.read("--url",args):
self._url = args[0]
args=[""]
if self._arguments.read("--group",args):
self._group = args[0]
args=[""]
if self._arguments.read("--artifact",args):
self._artifact = args[0]
args=[""]
if self._arguments.read("--version",args):
self._version = args[0]
args=[""]
if self._arguments.read("--platform",args):
self._platform = args[0]
args=[""]
if self._arguments.read("--compiler",args):
self._compiler = args[0]
args=[""]
if self._arguments.read("--arch",args):
self._arch = args[0]
args=[""]
if self._arguments.read("--ltype",args):
self._ltype = args[0]
if self._arguments.read("--cache"):
self._forceCache = True
self._isInteractive = False
if self._arguments.read("--remote"):
self._forceCache = False
self._isInteractive = False
self.setExecute(True)
def initFromXML(self,node):
pass
#TODO: . . .
def execute(self):
print "Executing Plugin:" + str(self.__class__)
if self._url == "":
self.reportError("Missing url option")
return
if self._artifact == "":
self.reportError("Missing artifact option")
return
if self._group == "":
self.reportError("Missing group option")
return
if self._version == "":
self.reportError("Missing version option")
return
if self._platform == "":
self.reportError("Missing platform option")
return
if self._compiler == "":
self.reportError("Missing compiler option")
return
if self._arch == "":
self.reportError("Missing artifact option")
return
if self._ltype == "":
self.reportError("Missing library type option")
return
if self._platform not in self._dmplugin.getSupportedPlatforms():
self.reportError("* Platform not supported: " + self._platform)
return
if self._compiler not in self._dmplugin.getSupportedCompilers():
self.reportError("* Compiler not supported: "+ self._compiler)
return
if self._arch not in self._dmplugin.getSupportedArchs():
self.reportError("* Architecture not supported: "+ self._arch)
return
if self._ltype not in self._dmplugin.getSupportedLibraryTypes():
self.reportError("* Library type not supported: " + self._ltype)
return
if self._platform!=self._dmplugin.getOSPlatform() and self._platform!="all":
print "* Warning: Forced platform ",self._platform
return self.get()
def get(self, unPackList = None):
#transform namespaces org.foo to org/foo
group=self._group.replace(".","/")
print "[",self._artifact,"]"
file_name=self._artifact+"-"+self._version+"-"+self._platform+"-"+self._compiler+"-"+self._arch+"-"+self._ltype
tarname=file_name+".tar.gz"
md5name=tarname+".md5"
download_path = 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
download_dir = group+"/"+self._artifact+"/"+self._version+"/"+self._platform+"/"+self._compiler+"/"+self._arch+"/"+self._ltype
cache_path = self._default_repository+os.path.sep+".cache"+os.path.sep+download_path
tstr=self._version.lower()
if tstr.find("snapshot")!=-1:
is_snapshot=True
else:
is_snapshot=False
dmutil = BMUtil()
is_tar=True
is_md5=True
if not dmutil.checkUrl(self._url+"/"+download_dir+"/"+md5name):
#print "Error: File ",baseurl+"/"+download_dir+"/"+md5name, " not found in the repository"
is_md5=False
if not dmutil.checkUrl(self._url+"/"+download_dir+"/"+tarname):
#print "Error: File ",baseurl+"/"+download_dir+"/"+tarname, " not found in the repository"
is_tar=False
dmutil.mkdir(cache_path)
if not os.path.isfile(cache_path+os.path.sep+md5name):
is_cache=False
else:
is_cache=True
#Once all variables have been collected, lets decide what to do with the artifact
must_download=False
if (not is_md5 or not is_tar) and not is_cache:
print "Error: Artifact ",tarname," not found"
return False
if not is_md5 and not is_tar and is_cache:
print "* file not found in repository, using cache..."
must_download=False
if is_md5 and is_tar and not is_cache:
print "* file is not in cache, downloading..."
must_download=True
if is_md5 and is_tar and is_cache:
if is_snapshot:
if self._isInteractive:
repo=raw_input("What snapshot do you want to use? (cache/remote): ")
else:
if self._forceCache:
repo="cache"
else:
repo="remote"
must_download=False
#in case of misspeling, using cache by default
if repo!="cache" and repo!="remote":
repo="cache"
else:
repo="remote"
if repo=="remote":
print "* file cached, checking md5..."
dmutil.download(self._url+"/"+download_dir+"/"+md5name,cache_path+os.path.sep+md5name+".new")
if dmutil.diff(cache_path+os.path.sep+md5name,cache_path+os.path.sep+md5name+".new"):
print "* no md5 matching, re-downloading..."
must_download=True
else:
print "* md5 matching succesful"
must_download=False
os.remove(cache_path+os.path.sep+md5name+".new")
if must_download==True:
print "URL :", self._url
dmutil.download(self._url+"/"+download_dir+"/"+md5name,cache_path+os.path.sep+md5name)
#print "* downloaded [",md5name,"]"
dmutil.download(self._url+"/"+download_dir+"/"+tarname,cache_path+os.path.sep+tarname)
#print "* downloaded[",tarname,"]"
if unPackList != None:
if (cache_path+os.path.sep+tarname) not in unPackList:
unPackList.append(cache_path+os.path.sep+tarname)
return True
class DepManUpdatePlugIn(IPlugIn):
def __init__(self):
IPlugIn.__init__(self)
self._must_Clean = True
self._isFromCache = False
self._isInteractive = True
self._defurl = "http://downloads.gvsig.org/pub/gvSIG-desktop/buildman-repository"
self._dependencyList = []
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, dom):
defurl = self._defurl
node = dom.getElementsByTagName("depman")[0]
if node != None:
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.getOSPlatform()
defdistribution = self._dmplugin.getOSDistribution()
defarch = self._dmplugin.getOSArch()
defcompiler = self._dmplugin.getOSCompiler()
if i.hasAttributes():
if i.attributes.has_key("platform"):
defplatform = i.attributes.get("platform").value
if i.attributes.has_key("distribution"):
defdistribution = i.attributes.get(
"distribution").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[:]
if not invalid_platform:
for j in i.childNodes:
if j.localName == "dependency":
dependency = DepManDependency(self._dmplugin)
#set default values
dependency.platform = defplatform
dependency.distribution = defdistribution
dependency.arch = defarch
dependency.compiler = defcompiler
dependency.url = url
if j.hasAttributes():
if j.attributes.has_key("url"):
dependency.url = j.attributes.get(
"url").value
for h in j.childNodes:
if h.localName == "group":
dependency.group = h.childNodes[
0].nodeValue
if h.localName == "artifact":
dependency.artifact = h.childNodes[
0].nodeValue
if h.localName == "version":
dependency.version = h.childNodes[
0].nodeValue
if h.localName == "platform":
dependency.platform = h.childNodes[
0].nodeValue
if h.localName == "distribution":
dependency.distribution = h.childNodes[
0].nodeValue
if h.localName == "compiler":
dependency.compiler = h.childNodes[
0].nodeValue
if h.localName == "architecture":
dependency.arch = h.childNodes[
0].nodeValue
if h.localName == "type":
dependency.libraryType = h.childNodes[
0].nodeValue
self._dependencyList.append(dependency)
def execute(self):
return self.update()
def update(self):
self.initFromXML(self._dmplugin.getNode())
for i in self._dependencyList:
print i
unPackList = self.getDependencies()
#once the xml is parsed and files downloaded, lets unpack them
self.unpack(unPackList)
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 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
class DepManCreatePlugIn(IPlugIn):
def __init__(self):
IPlugIn.__init__(self)
self._path = "."
self._group = ""
self._artifact = ""
self._version = ""
self._platform = "default"
self._arch = "default"
self._compiler = "default"
self._ltype = ""
self._upload = False
self._is_Interactive = True
self._xmlfile = ""
self._packageNode = None
self._default_ssh = "murray.ai2.upv.es"
self._default_login = "******"
self._default_destdir = "/projects/AI2/www-aliases/depman/"
def init(self):
self.addGoal("create", "Create an artifact")
self.addGoalOption("create", "--path", "Specifies source directory")
self.addGoalOption("create", "--group",
"Specifies artifact group name")
self.addGoalOption("create", "--artifact", "Specifies artifact name")
self.addGoalOption("create", "--version", "Specifies artifact version")
self.addGoalOption("create", "--platform",
"Specifies artifact OS platform")
self.addGoalOption("create", "--arch",
"Specifies artifact hardware architecture")
self.addGoalOption("create", "--compiler",
"Specifies artifact compiler version")
self.addGoalOption("create", "--ltype",
"Specifies library type if needed")
self.addGoalOption("create", "--upload",
"Whenever the artifact must be uploaded or not")
self.addGoalOption(
"create", "--from-xml",
"Uses the given depman.xml file to create the package")
isCreate = False
if self._arguments.read("create"):
self.setExecute(True)
isCreate = True
if not isCreate:
return
args = [""]
use_xml = False
if self._arguments.read("--from-xml", args):
self._xmlfile = args[0]
use_xml = True
if use_xml:
self.loadXMLFile(self._xmlfile)
args = [""]
if self._arguments.read("--path", args):
self._path = args[0]
args = [""]
if self._arguments.read("--group", args):
self._group = args[0]
self._is_Interactive = False
args = [""]
if self._arguments.read("--artifact", args):
self._artifact = args[0]
self._is_Interactive = False
args = [""]
if self._arguments.read("--version", args):
self._version = args[0]
self._is_Interactive = False
args = [""]
if self._arguments.read("--platform", args):
self._platform = args[0]
self._is_Interactive = False
args = [""]
if self._arguments.read("--arch", args):
self._arch = args[0]
self._is_Interactive = False
args = [""]
if self._arguments.read("--compiler", args):
self._compiler = args[0]
self._is_Interactive = False
args = [""]
if self._arguments.read("--ltype", args):
self._ltype = args[0]
self._is_Interactive = False
if self._arguments.read("--upload"):
self._upload = True
def initFromXML(self, node):
if node.localName == "create":
if node.hasAttributes():
if node.attributes.has_key("from-xml"):
self._xmlfile = node.attributes.get("from-xml").value
self.loadXMLFile(self._xmlfile)
if node.attributes.has_key("path"):
self._path = node.attributes.get("path").value
if node.attributes.has_key("upload"):
value = node.attributes.get("upload").value
if value == "True" or value == "true":
self._upload = True
else:
if node.localName == "depman":
self._packageNode = node
self._is_Interactive = False
def execute(self):
print "Executing Plugin:" + str(self.__class__)
return self.create()
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")
class DepManGetPlugIn(IPlugIn):
def __init__(self):
IPlugIn.__init__(self)
self._default_repository = ""
self._dependency = None
self._forceCache = False
self._isInteractive = True
def setDependency(self, dependency):
self._dependency = dependency
def setURL(self,url):
self._url = url
def setForceCache(self):
self._forceCache = True
self._isInteractive = False
def setForceRemote(self):
self._forceCache = False
self._isInteractive = False
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 initFromXML(self,node):
pass
#TODO: . . .
def execute(self):
if self._dependency == None:
self.reportError("Missing dependency option")
return False
if self._url == "":
self.reportError("Missing url option")
return False
if not self._dmplugin.validateDependency(self._dependency):
return False
return self.get()
def get(self, unPackList = None):
print "[",self._dependency.artifact,"]"
file_name = self._dependency.getDepManFileName()
tarname=file_name+".tar.gz"
md5name=tarname+".md5"
download_path = self._dependency.getDepManFilePath()
download_dir = self._dependency.getDepManUrlPath()
cache_path = self._default_repository+os.path.sep+".cache"+os.path.sep+download_path
is_snapshot = self._dependency.isSnapshot()
dmutil = BMUtil()
is_tar=True
is_md5=True
if not dmutil.checkUrl(self._dependency.url+"/"+download_dir+"/"+md5name):
#print "Error: File ",baseurl+"/"+download_dir+"/"+md5name, " not found in the repository"
is_md5=False
if not dmutil.checkUrl(self._dependency.url+"/"+download_dir+"/"+tarname):
#print "Error: File ",baseurl+"/"+download_dir+"/"+tarname, " not found in the repository"
is_tar=False
dmutil.mkdir(cache_path)
if not os.path.isfile(cache_path+os.path.sep+md5name):
is_cache=False
else:
is_cache=True
#Once all variables have been collected, lets decide what to do with the artifact
must_download=False
if (not is_md5 or not is_tar) and not is_cache:
print "Error: Artifact ",tarname," not found"
return False
if not is_md5 and not is_tar and is_cache:
print "* file not found in repository, using cache..."
must_download=False
if is_md5 and is_tar and not is_cache:
print "* file is not in cache, downloading..."
must_download=True
if is_md5 and is_tar and is_cache:
if is_snapshot:
if self._isInteractive:
repo=raw_input("What snapshot do you want to use? (cache/remote): ")
else:
if self._forceCache:
repo="cache"
else:
repo="remote"
must_download=False
#in case of misspeling, using cache by default
if repo!="cache" and repo!="remote":
repo="cache"
else:
repo="remote"
if repo=="remote":
print "* file cached, checking md5..."
dmutil.download(self._url+"/"+download_dir+"/"+md5name,cache_path+os.path.sep+md5name+".new")
if dmutil.diff(cache_path+os.path.sep+md5name,cache_path+os.path.sep+md5name+".new"):
print "* no md5 matching, re-downloading..."
must_download=True
else:
print "* md5 matching succesful"
must_download=False
os.remove(cache_path+os.path.sep+md5name+".new")
if must_download==True:
print "URL :", self._dependency.url
dmutil.download(self._dependency.url+"/"+download_dir+"/"+md5name,cache_path+os.path.sep+md5name)
#print "* downloaded [",md5name,"]"
dmutil.download(self._dependency.url+"/"+download_dir+"/"+tarname,cache_path+os.path.sep+tarname)
#print "* downloaded[",tarname,"]"
if unPackList != None:
if (cache_path+os.path.sep+tarname) not in unPackList:
unPackList.append(cache_path+os.path.sep+tarname)
return True