Application: gvSIG desktop

<?xml version="1.0" encoding="UTF-8"?>

<depman>

	<package>

		<group>es.upv.ai2</group><!-- requerido -->

		<artifact>buildman</artifact><!-- requerido -->

		<version>1.0-SNAPSHOT</version><!-- requerido -->

		<platform>all</platform><!-- no requerido pero se puede sobreescribir -->

		<compiler>all</compiler><!-- idem -->

		<arch>all</arch><!-- idem -->

		<libraryType>none</libraryType><!-- requerido -->

		<!-- upload no requerido si aparece entonces se debe de subir -->

		<!--<upload/> !--><!-- Esta opción usaría los valores por defecto -->

		<!--<upload> --><!-- Esta opción usaría los valores asignados abajo, no son requeridos y se puede sobreescribir solo algunos de ellos -->

		<!--	<sshserver>murray.ai2.upv.es</sshserver> -->

		<!-- 	<destdir>/projects/AI2/www-aliases/depman/</destdir> -->

		<!-- 	<username>depman</username> -->

		<!--</upload> -->

	</package>

	<dependencies platform="linux">

		<!-- others platform same configuration -->

		<dependency>

			<group>org.openscenegraph</group>

			<artifact>openscenegraph</artifact>

			<version>2.2.0-SNAPSHOT</version>

			<compiler>gcc3</compiler>

			<type>dynamic</type>

		</dependency>

		<dependency>

			<group>jogl</group>

			<artifact>jogl</artifact>

			<version>1.1.0</version>

			<type>dynamic</type>

		</dependency>

		<dependency>

			<group>org.gdal</group>

			<artifact>gdal-gvsig</artifact>

			<version>1.10</version>

			<type>dynamic</type>

		</dependency>

		<dependency url="http://larry.ai2.upv.es:8080/~depman/" >

			<group>es.upv.ai2</group>

			<artifact>libjosg</artifact>

			<version>2.0-SNAPSHOT</version>

			<compiler>gcc3</compiler>

			<type>dynamic</type>

		</dependency>

	</dependencies>

</depman>

<?xml version="1.0" encoding="UTF-8"?>

<depman>

	<package>

		<group>es.upv.ai2</group><!-- requerido -->

		<artifact>buildman</artifact><!-- requerido -->

		<version>1.0-SNAPSHOT</version><!-- requerido -->

		<libraryType>dynamic</libraryType><!-- requerido -->

				<!-- upload no requerido si aparece entonces se configura el servidor donde subir el paquete -->

		<upload> <!-- Esta opción usaría los valores asignados abajo, no son requeridos y se puede sobreescribir solo algunos de ellos -->

			<sshserver>larry.ai2.upv.es</sshserver>

		 	<destdir>public_html/</destdir>

		 	<username>depman</username>

		</upload>

	</package>

	<package platform="linux,mac">

		<platform>all</platform><!-- no requerido pero se puede sobreescribir -->

		<compiler>gcc4</compiler><!-- idem -->

		<arch>all</arch><!-- idem -->

	</package>

	<package platform="win">

		<compiler>vs7</compiler><!-- idem -->

		<arch>i386</arch><!-- idem -->

	</package>

	<dependencies platform="win">

		<dependency>

			<group>org.openscenegraph</group>

			<artifact>openscenegraph</artifact>

			<version>2.2.0-SNAPSHOT</version>

			<type>dynamic</type>

		</dependency>

		<dependency>

			<group>org.gdal</group>

			<artifact>gdal</artifact>

			<version>1.2.6</version>

			<type>dynamic</type>

			<compiler>vs6</compiler>

		</dependency>

		<dependency>

			<group>jogl</group>

			<artifact>jogl</artifact>

			<version>1.1.0</version>

			<type>dynamic</type>

			<compiler>all</compiler>

		</dependency>

	</dependencies>

	<dependencies platform="linux">

		<!-- others platform same configuration -->

		<dependency>

			<group>org.openscenegraph</group>

			<artifact>openscenegraph</artifact>

			<version>2.2.0-SNAPSHOT</version>

			<type>dynamic</type>

		</dependency>

		<dependency>

			<group>jogl</group>

			<artifact>jogl</artifact>

			<version>1.1.0</version>

			<type>dynamic</type>

		</dependency>

		<dependency>

			<group>org.gdal</group>

			<artifact>gdal-gvsig</artifact>

			<version>1.10</version>

			<type>dynamic</type>

		</dependency>

		<dependency url="http://larry.ai2.upv.es:8080/~depman/" >

			<group>es.upv.ai2</group>

			<artifact>libjosg</artifact>

			<version>2.0-SNAPSHOT</version>

			<type>dynamic</type>

		</dependency>

	</dependencies>

	<dependencies platform="mac">

		<!-- others platform same configuration -->

		<dependency>

			<group>org.openscenegraph</group>

			<artifact>openscenegraph</artifact>

			<version>2.2.0-SNAPSHOT</version>

			<type>dynamic</type>

			<architecture>universal</architecture>

		</dependency>

		<dependency>

			<group>jogl</group>

			<artifact>jogl</artifact>

			<version>1.1.0</version>

			<type>dynamic</type>

			<compiler>all</compiler>

		</dependency>

		<!--dependency>

			<group>org.gdal</group>

			<artifact>gdal</artifact>

			<version>1.4.0</version>

			<type>framework</type>

			</dependency-->

		<dependency url="http://larry.ai2.upv.es:8080/~depman/" >

			<group>es.upv.ai2</group>

			<artifact>libjosg</artifact>

			<version>2.0-SNAPSHOT</version>

			<type>dynamic</type>

			<architecture>universal</architecture>

		</dependency>

	</dependencies>

</depman>

<buildman>

	<goals platform="linux,mac">

		<delete path="/tmp/osgVP" />

	</goals>

	<goals platform="win">

		<delete path="./osgVP" />

	</goals>

	<goals>

		<svn option="co" url="https://josgplanets.ai2.upv.es/svn/josgplanets/trunk/libjni-osgvp" project-path="/tmp/osgVP" />

		<clean all="False" />

		<update file="/tmp/osgVP/build-scripts/depman.xml" />

	</goals>

	<goals platform="linux,mac">

		<create-solution project-path="/tmp/osgVP" generator="unix" install="/tmp/osgVP-install" />

		<compile-solution project-path="/tmp/osgVP" project-name="libjosg" install="True" />

	</goals>

	<goals platform="win">

		<create-solution project-path="./osgVP" project-gen-path="./osgVP/CMake-VS7" generator="vs7" install="./osgVP-install" />

		<compile-solution project-path="./osgVP" project-name="libjosg" project-gen-path="./osgVP/CMake-VS7" install="True" />

	</goals> -->

	<goals platform="linux">

		<create from-xml="/tmp/osgVP/build-scripts/depman.xml" path="/tmp/binaries/linux32" />

	</goals>

	<goals platform="mac">

		<create from-xml="/tmp/osgVP/build-scripts/depman.xml" path="/tmp/binaries/mac"/>

	</goals>

	<goals platform="win">

		<create from-xml="./osgVP/build-scripts/depman.xml" path="./osgVP/binaries/win32" />

	</goals>

</buildman>

#!/usr/bin/env python

__authors__=["Rafael Gaitan <rgaitan@ai2.upv.es>","Pedro Jorquera <pjorquera@okode.com>","Enrique Medina <quiqueiii@gmail.com>"]

__date__="30 Nov 2007"

__copyright__="Copyright 2007 AI2/OKODE"

__license__="GPL"

__version__="1.0.0"

__URL__="https://murray.ai2.upv.es/svn/buildman"

import sys

from bmcore import *

#main

def main():

	arguments = ArgumentParser(sys.argv)

	arguments.getApplicationUsage().setDescription(arguments.getApplicationName() + "is a set of scripts to create automatic and continuous build systems")

	arguments.getApplicationUsage().addCommandLineOption("--help", "Gets this help")

	arguments.getApplicationUsage().addCommandLineOption("--help-all", "Gets the help for all existing tasks")

	arguments.getApplicationUsage().addCommandLineOption("--help-goal [goal]", "Gets the help for the given task")

	if len(sys.argv)<2:

		arguments.writeHelpMessages()

		return

	if arguments.read("--help"):

		arguments.writeHelpMessages()

		return

	help_goal = False

	help_all = False

	goal = [""]

	if arguments.read("--help-goal",goal):

		help_goal = True

	if arguments.read("--help-all"):

		help_all = True

	bmn = BuildMan(arguments) 

	if help_goal:

		arguments.writeGoalHelpMessages(goal[0])

		return

	if help_all:

		arguments.writeHelpMessages()

		return

	if arguments.errors():

		arguments.writeErrorMessages()

		return

	if not bmn.run():

		bmn.writeErrorMessages()

if __name__ == '__main__': main()

"""

	ApplicationUsage manage the options of the application

	and plugins.

"""

class ApplicationUsage:

	def __init__(self):

		self._applicationName = ""

		self._commandLineOptions = []

		self._commandLineGoals = dict()

		self._commandLineGoalsDescriptions = dict()

		self._description = ""

	def setApplicationName(self,name):

		self._applicationName = name

	def getApplicationName(self):

		return self._applicationName

	def addCommandLineGoalOption(self,goal,option,description):

		self._commandLineGoals[goal].append((option,description))

	def addCommandLineGoal(self,goal,description):

		self._commandLineGoals[goal] = []

		self._commandLineGoalsDescriptions[goal] = description

	def addCommandLineOption(self,option,description):

		self._commandLineOptions.append((option,description))

	def getCommandLineGoalDescription(self,goal):

		if goal in self._commandLineGoalsDescriptions:

			return self._commandLineGoalsDescriptions[goal]

		return None

	def getCommandLineGoals(self):

		return self._commandLineGoals

	def getCommandLineGoalOptions(self,goal):

		return self._commandLineGoals[goal]

	def getCommandLineOptionDescription(self,option):

		for v in self._commandLineOptions:

			(opt,desc) = v

			if opt == option:

				return desc

		return None

	def getCommandLineOptions(self):

		return self._commandLineOptions

	def setDescription(self, str):

		self._description = str

	def getDescription(self):

		return self._description

from bmbase.PlugInManager import PlugInManager

"""

	BuildMan manages the loading of plugins and 

	dispatch the requested tasks to the appropiate

	plug-in. Each plug-in defines its parameters and

	its help environment, so an ArgumentParse is 

	necessary in the construction. 

"""

class BuildMan:

	# constructor

	def __init__(self,arguments):

		self._arguments = arguments

		self._errorMessages = []

		self.__configurePlugins(self._arguments)

	# configure arguments of the automatic loaded plugins

	def __configurePlugins(self, arguments):

		for plugin in PlugInManager().getPlugInInstances().values():

			plugin.initArguments(arguments)

		for plugin in PlugInManager().getPlugInInstances().values():

			plugin.init()

			if plugin.error():

				self._errorMessages += plugin.getErrorMessages()

	# execute all plugins, any plugin with his arguments has the responsability of do the correct

	def run(self):

		for plugin in PlugInManager().getPlugInInstances().values():

			plugin.run()

			if plugin.error():

				self._errorMessages += plugin.getErrorMessages()

				return False

		return True	

	def writeErrorMessages(self):

		for error in self._errorMessages:

			print "ERROR: " + error + "\n"

import os

import os.path

import zipfile

import difflib

import tarfile

import md5

import urllib2

import sys

import shutil

import re

class BMUtil:

	def buildmanPath(self):

		dr = os.getenv("BUILDMAN_PATH")

		if not dr is None:

			return dr

		if sys.platform == "linux2" or sys.platform == "linux1":

			dr = os.getenv("HOME")+os.path.sep+".buildman"

		if sys.platform == "win32" or sys.platform == "win64":

			#ex: c:\documents and setting\user\DepMan

			dr = os.getenv("USERPROFILE")+os.path.sep+"BuildMan"

		if sys.platform == "darwin":

			dr = os.path.sep + "Developer" + os.path.sep + "BuildMan"

		if dr is None:

			return None

		else:

			return dr

	def buildmanPlugInPath(self):

		dr = self.buildmanPath()

		if dr is None:

			return None

		else:

			return os.path.join(dr,'plugins')

	def mkdir(self,newdir):

		"""works the way a good mkdir should :)

			- already exists, silently complete

			- regular file in the way, raise an exception

			- parent directory(ies) does not exist, make them as well

		"""

		if os.path.isdir(newdir):

			pass

		elif os.path.isfile(newdir):

			raise OSError("a file with the same name as the desired " \

				"dir, '%s', already exists." % newdir)

		else:

			head, tail = os.path.split(newdir)

			if head and not os.path.isdir(head):

				self.mkdir(head)

			if tail:

				os.mkdir(newdir)

	#recursively directory tree removing

	def rmdir(self,path):

		if not os.path.isdir(path):

			return

		shutil.rmtree(path)	

		#files=os.listdir(path)

		#for x in files:

		#	fullpath=os.path.join(path, x)

		#	if os.path.isfile(fullpath):

		#		os.remove(fullpath)

		#	elif os.path.isdir(fullpath):

		#		rmdir(fullpath)

		#		os.rmdir(fullpath)

	def unzip(self,file, dir):

		mkdir(dir)

		zfobj = zipfile.ZipFile(open(file))

		for name in zfobj.namelist():

			if name.endswith('/'):

				mkdir(os.path.join(dir, name))

			else:

				outfile = open(os.path.join(dir, name), 'wb')

				outfile.write(zfobj.read(name))

				outfile.close()

	def targz(self,file, dir):

		cwd = os.getcwd()

		os.chdir(dir)

		dirs = os.listdir(".")

		if ".svn" in dirs:

			dirs.remove(".svn")

		if ".cvsignore" in dirs:

			dirs.remove(".cvsignore")

		tar = tarfile.open(str(file),"w|gz")

		for f in dirs:	

			tar.add(f)

		tar.close()

		os.chdir(cwd)

	def untargz(self,file, dir):

		tar = tarfile.open(file)

		for tarinfo in tar:

			tar.extract(tarinfo,dir)

		tar.close()

	def untargzFiltered(self,file,dir,filter):

		filter=filter.replace("*","(\S)*")

		filter="^(\S)*"+filter+"$"

		#print "filter: ",filter

		tar = tarfile.open(file)

		for tarinfo in tar:

			if re.match(filter,tarinfo.name):

				print "[file] ",tarinfo.name

				tar.extract(tarinfo,dir)

		tar.close()

	def diff(self,f1name, f2name):

		try:

			f1 = open(f1name)

			f2 = open(f2name)

			a = f1.readlines(); f1.close()

			b = f2.readlines(); f2.close()

			for line in difflib.unified_diff(a, b):

				print line,

				if line != "":

					return True 

				return False

		except:

			return True

	#creates the given fouput md5 file from the finput file

	def createMD5(self,finput,foutput):

		#input file

		file_in=open(finput,"rb")

		md5cpm=md5.new()

		while True:

			data = file_in.read(8096)

			if not data:

				break

			md5cpm.update(data)

		file_in.close()

		md5string=md5cpm.hexdigest()

		file_out=open(foutput,"w")

		file_out.write(md5string)

		file_out.close()

	def checkUrl(self,uri):

		try:

			fd=urllib2.urlopen(uri)

			fd.close()

			return True

		except:

			return False

	def download(self,uri,fout):

		try:

			fdes=urllib2.urlopen(uri)

			foutdes=open(fout,"wb")

			uinfo=fdes.info()

			size = uinfo.get('content-length')

			size=int(size)

			uristr=uri[uri.rfind("/")+1:]

			#lets read the file in 1kbyte blocks

			completed=0

			x=completed*100/size

			tstr="* downloading ["+str(x)+" %] "+uristr

			sys.stdout.write(tstr)

			while True:

				block=fdes.read(1024)

				if not block:

					break

				foutdes.write(block)

				completed=completed+len(block)

				x=completed*100/size

				sys.stdout.write("\r")

				tstr="* downloading ["+str(x)+" %] "+uristr

				sys.stdout.write(tstr)

				#insert write op here	

			foutdes.close()

			sys.stdout.write("\n")

			#print "* downloaded ",uri," [",size,"] bytes"

			return True

		except:		

			return False

from ApplicationUsage import ApplicationUsage

from bmbase.PlugInManager import PlugInManager

"""

	ArgumentParser is a helper in the task of 

	reading parameters from command line.

"""

class ArgumentParser:

	def __init__(self,argv):

		self._argv = argv

		self._argc = len(self._argv)

		self._error = False

		self._errorMessages = []

		self._applicationUsage = ApplicationUsage()

		self._applicationUsage.setApplicationName(self.getApplicationName())

	def errors(self):

		return self._error

	def writeErrorMessages(self):

		for error in self._errorMessages:

			print error + "\n"

	def writeGoalHelpMessages(self,goal):

		if goal in self._applicationUsage.getCommandLineGoals().keys():

			print "Goal supported by " + str(PlugInManager().getPlugInInstanceByGoal(goal).__class__) + " plugin:"

			print goal + "\t" + self._applicationUsage.getCommandLineGoalDescription(goal) + "\n"

			for option,value in self._applicationUsage.getCommandLineGoalOptions(goal):

				print "\t" + option + "\t" + value + "\n"

		else:

			print "Goal `" + goal +"` not supported, try --help-all option" 

	def writeHelpMessages(self):

		print "BuildMan options:"

		print "-----------------" + "\n"

		for option,value in self._applicationUsage.getCommandLineOptions():

			print option + "\t" + value + "\n"

		if len(self._applicationUsage.getCommandLineGoals().keys())>0:

			print "Supported Goals:"

			print "----------------" + "\n"

			for goal in self._applicationUsage.getCommandLineGoals().keys():

				print goal + "\t" + self._applicationUsage.getCommandLineGoalDescription(goal) + "\n"

				for option,value in self._applicationUsage.getCommandLineGoalOptions(goal):

					print "\t" + option + "\t" + value + "\n"

	def getApplicationUsage(self):

		return self._applicationUsage

	def getApplicationName(self):

		return self._argv[0]

	def isOption(self, str):

		return (len(str) > 1 and str[0]=='-')

	def argc(self):

		return self._argc

	def argv(self):

		return self._argv

	def find(self,str):

		for pos in range(1,self._argc):

			if str == self._argv[pos]:

				return pos

		return 0

	def match(self,pos,str):

		return (pos<self._argc and str==self._argv[pos])

	def containsOptions(self):

		for op in self._argv:

			if self.isOption(op):

				return True

		return False

	def remove(self,pos,num):

		if num==0: return

		removeList = []

		for i in range(pos,pos+num):

			removeList.append(self._argv[i])

		for r in removeList:

			self._argv.remove(r)

		self._argc-=num

	def read(self,str,values=[]):

		pos = self.find(str)

		if pos<=0:

			return False

		if len(values)==0:

			self.remove(pos,1)

			return True

		return self.__read(pos,str,values)

	def __read(self,pos,str,values):

		if self.match(pos,str):

			if pos+len(values)<self._argc:

				inc = 1

				for i in range(len(values)):

					values[i] = self._argv[pos+inc]

					inc+=1

				self.remove(pos,len(values)+1)

				return True

			self.__reportError("argument to `"+str+"` is missing")

			return False

		return False

	def __reportError(self, str):

		self._error = True

		self._errorMessages.append(str)

"""

	Main modules of the Build Manteinance Tool

"""

__version__="1.0.0"

from ArgumentParser import ArgumentParser

from BuildMan import BuildMan

from ApplicationUsage import ApplicationUsage

from BMUtil import BMUtil

"""

	PlugInManager is a singleton class that manages

	plugininstances, and register methods. Each

	plugin should call to register itself

"""

class PlugInManager:

	_pluginInstances = {}

	def registerPlugIn(self, id, pluginInstance):

		PlugInManager._pluginInstances[id] = pluginInstance

		pluginInstance.setId(id)

	def getPlugInInstances(self):

		return PlugInManager._pluginInstances

	def getPlugInInstance(self,id):

		return PlugInManager._pluginInstances[id]

	def getPlugInInstanceByGoal(self,goal):

		for plugin in PlugInManager._pluginInstances.values():

			if goal in plugin.getGoals().keys():

				return plugin

		return None

	def supportedGoals(self):

		goals = []

		for plugin in PlugInManager._pluginInstances.values():

			for g in plugin.getGoals().keys():

				goals.append(g)

		return goals

#loading plugins

from bmplugins import *

"""

	Bases classes to extend and create new plugins

"""

from xml.dom import minidom

'''

	Defines a interface for plugins

'''

class IPlugIn:

	def __init__(self):

		self._errorMessages = []

		self._error = False

		self._id = ""

		self._goals = dict()

		self._arguments = None

		self._execute = False

	def initArguments(self,arguments):

		self._arguments = arguments

	def init(self):

		pass

	def initFromXML(self,node):

		pass

	def execute(self):

		pass

	def loadXMLFile(self,xmlfile):

		xmldoc=minidom.parse(xmlfile)

		node = xmldoc.firstChild

		self.initFromXML(node)

	def getExecute(self):

		return self._execute

	def setExecute(self,value):

		self._execute = value

	def run(self):

		if self._execute:

			self.execute()

	def reportError(self,s):

		self._errorMessages.append(str(self.__class__)+":"+s)

		self._error = True

	def error(self):

		return self._error

	def getErrorMessages(self):

		return self._errorMessages

	def setId(self,id):

		self._id = id

	def getId(self):

		return self._id

	def addGoal(self,goal,description):

		self._goals[goal] = []

		self._arguments.getApplicationUsage().addCommandLineGoal(goal,description)

	def addGoalOption(self,goal,option,description):

		self._goals[goal].append(option)

		self._arguments.getApplicationUsage().addCommandLineGoalOption(goal,option,description)

	def getGoals(self):

		return self._goals

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._distribution = ""

		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 setDistribution(self,distribution):

		self._distribution = distribution

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

		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("--distribution",args):

			self._distribution = 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._platform!="all":

			if self._distribution == "":

				self.reportError("Missing distribution 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._platform!="all":

			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

		if self._platform!="all":

			file_name=file_name+"-"+self._distribution+"-"+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

		if self._platform!="all":

			download_path = download_path+os.path.sep+self._distribution+os.path.sep+self._compiler+os.path.sep+self._arch+os.path.sep+self._ltype

		download_dir = group+"/"+self._artifact+"/"+self._version+"/"+self._platform

		if self._platform!="all":	

			download_dir = download_dir+"/"+self._distribution+"/"+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

PlugInManager().registerPlugIn("DepManGetPlugIn",DepManGetPlugIn())

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

from bmcore.BMUtil import BMUtil

from xml.dom import minidom

import os

import sys

class DepManPlugIn(IPlugIn):

	def __init__(self):

		IPlugIn.__init__(self)

		self._depmanDataPath = sys.path[0]+os.path.sep+".."+os.path.sep+"plugins-data"+os.path.sep+"depman"

		self._supportedPlatforms = ["all","mac","linux","win"]

		self._supportedArchs = ["all","i386","ppc","ppc64","x86_64","universal"]

		self._supportedLibraryTypes = ["none","dynamic","static","framework"]

		self._supportedCompilers = ["all","vs6","vs7","vs8","gcc3","gcc4"]

		#tries to guess host OS values

		self._osplatform="unknown"

		self._osdistribution="unknown"

		self._osarch="unknown"

		self._oscompiler="unknown"

		if sys.platform=="darwin":

			self._osplatform="mac"

			self._osarch="universal"

			self._oscompiler="gcc4"

		elif sys.platform == "linux2" or sys.platform == "linux1":

			self._osplatform="linux"

			self._osarch="i386"

			self._oscompiler="gcc4"

		elif sys.platform == "win32" or sys.platform == "win64":

			self._osplatform="win"

			self._osarch="i386"

			self._oscompiler="vs8"

	def init(self):

		pass

	def initFromXML(self,node):

		pass

	def execute(self):

		pass

	def getSupportedPlatforms(self):

		return self._supportedPlatforms

	def getSupportedArchs(self):

		return self._supportedArchs

	def getSupportedLibraryTypes(self):

		return self._supportedLibraryTypes

	def getSupportedCompilers(self):

		return self._supportedCompilers

	def getOSPlatform(self):

		return self._osplatform

	def getOSDistribution(self):

		return self._osdistribution

	def getOSArch(self):

		return self._osarch

	def getOSCompiler(self):

		return self._oscompiler

	def getDepManPath(self):

		dr = os.getenv("DEPMAN_REPO")

		if not dr is None:

			return dr;

		if sys.platform == "linux2" or sys.platform == "linux1":

			dr = os.getenv("HOME")+os.path.sep+".depman"

			return dr;

		if sys.platform == "win32" or sys.platform == "win64":

			#ex: c:\documents and setting\user\DepMan

			dr = os.getenv("USERPROFILE")+os.path.sep+"DepMan"

			return dr;

		if sys.platform == "darwin":

			dr = os.path.sep + "Developer" + os.path.sep + "DepMan"

			return dr;

		return None

	def getDepManDataPath(self):

		return self._depmanDataPath

PlugInManager().registerPlugIn("DepManPlugIn",DepManPlugIn())

from bmbase.IPlugIn import IPlugIn

from bmbase.PlugInManager import PlugInManager

from bmcore.BMUtil import BMUtil

import os

import sys

class CompileSolutionPlugIn(IPlugIn):

	def __init__(self):

		IPlugIn.__init__(self)

		self._targetType = "Release" # only vs7/vs8 compilers

		self._projectPath = ""

		self._install = False

		self._projectName = ""

		self._projectGenerationPath = ""

		self._supportedCompilers = dict()

		self._supportedCompilers["vs8"]="devenv.exe"

		self._supportedCompilers["vs7"]="devenv.exe"

		self._supportedCompilers["gcc4"]="make"

		self._supportedCompilers["gcc3"]="make"

		self._compiler = ""

	def init(self):

		self.addGoal("compile-solution", "Compiles the solution based on Makefiles or VisualStudio for Win/Linux/Mac")

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

		self.addGoalOption("compile-solution", "--project-gen-path", "sets the path of the Makefiles/VS build files. Default: ${project-path}/BMCMake")

		self.addGoalOption("compile-solution", "--project-name", "sets the name of the project. If not given it uses the name of the project directory.")

		self.addGoalOption("compile-solution", "--install", "Executes target install after compilation.")

		self.addGoalOption("compile-solution", "--compiler", "Forces the compiler. If not try to determine using current platform\n" +

															"Supported Compilers:\n" + 

															str(self._supportedCompilers))

		execute = False

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

			execute = True

		if execute:

			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("--project-name", args):

				self._projectName=args[0]

			args = [""]

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

				if args[0] in self._supportedCompilers:

					self._compiler=args[0]

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

				self._install=True

			self.setExecute(True)

	def initFromXML(self, node):

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

			if node.hasAttributes():

				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 = node.attributes.get("project-gen-path").value

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

					self._projectName = node.attributes.get("project-name").value

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

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

					if args[0] in self._supportedCompilers:

						self._compiler = value

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

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

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

						self._install = True

	def execute(self):

		dmplugin = PlugInManager().getPlugInInstance("DepManPlugIn")

		if dmplugin == None:

			self.reportError("DepMan PlugIn not found")

			return False

		if self._projectPath=="":

			self.reportError("Missing required project path option")

			return False

		self._projectPath = os.path.abspath(self._projectPath)

		if self._compiler=="":

			self._compiler = dmplugin.getOSCompiler()

		if self._projectName == "":

			self._projectName = os.path.basename(self._projectPath)

		if self._projectGenerationPath == "":

			self._projectGenerationPath = os.path.join(self._projectPath, "BMCMake")

		else:

			self._projectGenerationPath = os.path.abspath(self._projectGenerationPath)

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

		platform = dmplugin.getOSPlatform()

		if platform == "linux" or platform == "mac":

			self.__executeUnix()

		else:

			self.__executeVS()	

		return True

	def __executeUnix(self):

		#make install

		print "CPUs Detected:" + str(self.__cpuCount())

		cmdCompiler = self._supportedCompilers[self._compiler] + " -j"+str(self.__cpuCount()) 

		if self._install:	

			cmdCompiler += " install"

		olddir = os.getcwd()

		os.chdir(self._projectGenerationPath)

		os.system(cmdCompiler)

		os.chdir(olddir)	

	def __executeVS(self):

		#devenv.exe /build Release /project INSTALL ../CMake/libjosg.sln

		cmdCompiler = self._supportedCompilers[self._compiler]

		cmdCompiler += " " + self._projectName + ".sln"

		cmdCompiler += " /build Release"

		if self._install:	

			cmdCompiler += " /project INSTALL"

		else:

			cmdCompiler += " /project ALL_BUILD"

		olddir = os.getcwd()

		os.chdir(self._projectGenerationPath)

		os.system(cmdCompiler)

		os.chdir(olddir)	

	def __cpuCount(self):

	    '''

	    Returns the number of CPUs in the system

	    '''

	    if sys.platform == 'win32':

	        try:

	            num = int(os.environ['NUMBER_OF_PROCESSORS'])

	        except (ValueError, KeyError):

	            pass

	    elif sys.platform == 'darwin':

	        try:

	            num = int(os.popen('sysctl -n hw.ncpu').read())

	        except ValueError:

	            pass

	    else:

	        try:

	            num = os.sysconf('SC_NPROCESSORS_ONLN')

	        except (ValueError, OSError, AttributeError):

	            pass

	    if num >= 1:

	        return num

	    return 1

PlugInManager().registerPlugIn("CompileSolutionPlugIn", CompileSolutionPlugIn())

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