| gvSIG desktop 1

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

from bmcore.BMUtil import BMUtil

import os

class SVNPlugIn(IPlugIn):

	def __init__(self):

		IPlugIn.__init__(self)

		self._options = ['co','up', 'checkout', 'update']

		self._option = ""

		self._projectPath = ""

		self._svnUrl = ""

	def init(self):

		self.addGoal("svn", "This plugin is able to do checkout or update of a svn repository")

		self.addGoalOption("svn","--option", "sets the option of subversion: "+ str(self._options))

		self.addGoalOption("svn","--project-path", "sets the path of the project.")

		self.addGoalOption("svn","--url", "sets the path of the url")

		execute = False		

		while self._arguments.read("svn"):

			execute = True

		if execute:

			args = [""]

			while self._arguments.read("--option",args):

				self._option = args[0]

			args = [""]

			while self._arguments.read("--project-path",args):

				self._projectPath=args[0]

			args = [""]

			while self._arguments.read("--url",args):

				self._svnUrl=args[0]

			self.setExecute(True)

	def initFromXML(self,node):

		if node.localName=="svn":

			if node.hasAttributes():

				if node.attributes.has_key("option"):

					self._option = node.attributes.get("option").value

				if node.attributes.has_key("project-path"):

					self._projectPath = node.attributes.get("project-path").value

				if node.attributes.has_key("url"):

					self._svnUrl = node.attributes.get("url").value

	def execute(self):

		if self._option=="":

			self.reportError("Missing svn option, use one of " + 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())

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

from bmcore.BMUtil import BMUtil

from xml.dom import minidom

import os

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

PlugInManager().registerPlugIn("DepManCleanPlugIn",DepManCleanPlugIn())

#depman update plugin

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

from bmcore.BMUtil import BMUtil

import os

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

		#after unpacking, the unpack list is freed

PlugInManager().registerPlugIn("DepManUpdatePlugIn",DepManUpdatePlugIn())

#depman create plugin

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

from bmcore.BMUtil import BMUtil

from xml.dom import minidom

import string

import shutil

import os

import sys

import subprocess

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="depman"

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

PlugInManager().registerPlugIn("DepManCreatePlugIn",DepManCreatePlugIn())		

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

from bmcore.BMUtil import BMUtil

from xml.dom import minidom

import os

class BuildManPlugIn(IPlugIn):

	def __init__(self):

		IPlugIn.__init__(self)

		self.reset()

	def getFile(self):

		return self._file

	def getGoalList(self):

		return self._goalList

	def reset(self):

		self._goalList = []

		self._file = "buildman.xml"

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

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

import pprint

class TestPlugIn(IPlugIn):

	def __init__(self):

		IPlugIn.__init__(self)

	def init(self):

		self.addGoal("test", "Tests user buildman plugin path")

		while self._arguments.read("test"):

			self.setExecute(True)		

	def execute(self):

		print "Executing Plugin:" + str(self.__class__)

		l=[] 

		for id,plugin in PlugInManager().getPlugInInstances().items():

			l.append((id,plugin))	

		pp = pprint.PrettyPrinter(indent=4)

		pp.pprint(l) 

		return True

PlugInManager().registerPlugIn("TestPlugIn",TestPlugIn())

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

from bmcore.BMUtil import BMUtil

from xml.dom import minidom

import os

class DepManExtractPlugIn(IPlugIn):

    def __init__(self):

        IPlugIn.__init__(self)

        self._xmlFile = "depman.xml"

        self._destDir = "."

        self._filter = "*"

        self._isFromCache=False

        self._isInteractive=True

        self._depmanNode = None

    def init(self):

        self.addGoal("extract", "Extract the files of dependencies and package sections of a depman xml file.")

        self.addGoalOption("extract","--file", "Sets an alternate xml file. Default: depman.xml")

        self.addGoalOption("extract","--destdir", "Sets the destination directory of the extraction. Default: `.`")

        self.addGoalOption("extract","--filter", "Sets the the filter of the files to extract. Default: `*`")

        self.addGoalOption("extract","--cache", "Cache is preferred")

        self.addGoalOption("extract","--remote", "Remote repository is preferred")

        isExtract = False

        if self._arguments.read("extract"):

            self.setExecute(True)

            isExtract = True

        if not isExtract:

            return    

        args = [""]

        if self._arguments.read("--file", args):

            self._xmlFile = args[0]   

        args = [""]

        if self._arguments.read("--destdir", args):

            self._destDir = args[0]

        args = [""]

        if self._arguments.read("--filter", args):

            self._filter = args[0] 

        if self._arguments.read("--cache"):

            self._isFromCache = True

            self._isInteractive = False

        if self._arguments.read("--remote"):

            self._isFromCache = False

            self._isInteractive = False

    def initFromXML(self,node):

        if node.localName=="extract":

            if node.hasAttributes():

                if node.attributes.has_key("file"):

                    elf._xmlFile = node.attributes.get("file").value

                if node.attributes.has_key("destdir"):

                    elf._destDir = node.attributes.get("destdir").value                   

                if node.attributes.has_key("filter"):

                    elf._filter = node.attributes.get("filter").value    

                foundCache = False

                if node.attributes.has_key("cache"):

                    value = node.attributes.get("cache").value

                    if value == "True" or value == "true":

                        self._isFromCache = True

                        self._isInteractive = False

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

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

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

from bmcore.BMUtil import BMUtil

import os

class CreateSolutionPlugIn(IPlugIn):

	def __init__(self):

		IPlugIn.__init__(self)

		self._buildType = "Release"

		self._supportedGenerators = dict()

		self._supportedGenerators["vs8"] = "Visual Studio 8 2005"

		self._supportedGenerators["vs7"] = "Visual Studio 7 .NET 2003"

		self._supportedGenerators["unix"] = "Unix Makefiles"

		self._supportedGenerators["xcode"] = "Xcode"

		self._cmakeGenerator = ""

		self._projectPath = ""

		self._projectGenerationPath = ""

		self._installPath = ""

		self._cmakeOtherOptions = ""

	def init(self):

		self.addGoal("create-solution", "Creates the solution Makefiles/VisualStudio for Win/Linux/Mac based on CMake")

		self.addGoalOption("create-solution","--build-type", "sets the build path (Release/Debug). default=Release.")

		self.addGoalOption("create-solution","--generator", "selects the generator (vs8,vs7,unix,xcode).")

		self.addGoalOption("create-solution","--project-path", "sets the path of the project.")

		self.addGoalOption("create-solution","--project-gen-path", "sets the path to generate project files. default=${project-path}/CMake")

		self.addGoalOption("create-solution","--install", "sets the path to generate the product installation. default=${project-path}/../install")

		self.addGoalOption("create-solution","--cmake-options", "Adds other cmake command line options.")

		execute = False		

		if self._arguments.read("create-solution"):

			execute = True

		if execute:

			args = [""]

			if self._arguments.read("--build-type",args):

				self._buildType = args[0]

			args = [""]

			if self._arguments.read("--generator",args):

				if args[0] in self._supportedGenerators:

					self._cmakeGenerator = self._supportedGenerators[args[0]]

			args = [""]

			if self._arguments.read("--project-path",args):

				self._projectPath=args[0]

			args = [""]

			if self._arguments.read("--project-gen-path",args):

				self._projectGenerationPath=args[0]

			args = [""]

			if self._arguments.read("--install",args):

				self._installPath=args[0]

			args = [""]

			if self._arguments.read("--cmake-options",args):

				self._cmakeOtherOptions=args[0]

			self.setExecute(True)

	def initFromXML(self,node):

		if node.localName=="create-solution":

			if node.hasAttributes():

				if node.attributes.has_key("build-type"):

					self._buildType = node.attributes.get("build-type").value

				if node.attributes.has_key("generator"):

					gen = node.attributes.get("generator").value

					if gen in self._supportedGenerators:

						self._cmakeGenerator = self._supportedGenerators[gen]

				if node.attributes.has_key("project-path"):

					self._projectPath = node.attributes.get("project-path").value

				if node.attributes.has_key("project-gen-path"):

					self._projectGenerationPath = os.path.abspath(node.attributes.get("project-gen-path").value)

				if node.attributes.has_key("install"):

					self._installPath = os.path.abspath(node.attributes.get("install").value)

				if node.attributes.has_key("cmake-options"):

					self._cmakeOtherOptions = node.attributes.get("cmake-options").value

	def execute(self):

		if self._cmakeGenerator=="":

			self.reportError("Missing valid generator option")

			return False

		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"

		print "Executing Plugin:" + str(self.__class__)

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

"""

	Path where plugins reside

	Each plugin should implement IPlugIn interface

	from bmbase.

"""

import os

import sys

from bmcore.BMUtil import BMUtil

import imp

def bmimport(name, paths):

	# Fast path: see if the module has already been imported.

    try:

        return sys.modules[name]

    except KeyError:

        pass

    # If any of the following calls raises an exception,

    # there's a problem we can't handle -- let the caller handle it.

    fp, pathname, description = imp.find_module(name,paths)

    try:

        return imp.load_module(name, fp, pathname, description)

    finally:

        # Since we may exit via an exception, close fp explicitly.

        if fp:

            fp.close()

util = BMUtil()

searchPaths=[os.path.join(sys.path[0],'bmplugins'),util.buildmanPlugInPath(),os.path.join(sys.path[0],'../bmplugins')]

plugList = []

for dir in searchPaths:

	if not os.path.exists(dir):

		continue

	for f in os.listdir(dir):

		if f.endswith('.py') and not f.startswith('__init__'):

			plugList.append(f[0:-3])

print plugList

for m in plugList:

	bmimport(m,searchPaths)

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

from bmcore.BMUtil import BMUtil

import os

import sys

import shutil

class DeleteFilePlugIn(IPlugIn):

	def __init__(self):

		IPlugIn.__init__(self)

		self._path = ""

	def init(self):

		self.addGoal("delete", "deletes a file or directory")

		self.addGoalOption("delete", "--path", "Sets the file/path to be deleted")

		execute = False

		while self._arguments.read("delete"):

			execute = True

		if execute:

			args = [""]

			while self._arguments.read("--path",args):

				self._path = args[0]

			self.setExecute(True)

	def initFromXML(self,node):

		if node.localName=="delete":

			if node.hasAttributes():

				if node.attributes.has_key("path"):

					self._path = node.attributes.get("path").value

	def execute(self):

		print "Executing Plugin:" + str(self.__class__)

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

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

from bmcore.BMUtil import BMUtil

import os

import sys

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

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

from bmcore.BMUtil import BMUtil

from xml.dom import minidom

import os

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