"""Clear the build artifacts"""

for root, folder, files in os.walk(blddir):

for f in files:

path = os.path.join(root, f)

print "Removing artifact %s"%path

def rpmdeps(fileset):

for f in fileset:

lines = file(f).readlines()

lines = [ x[len("BuildRequires: "):] for x in lines if x.startswith("BuildRequires") ]

for l in lines:

deps = [ x.strip() for x in l.split(",") ]

for d in deps:

if "%s-"%APPNAME in d: continue

yield d

yield "rpm-build"

deps = set(rpmdeps(_glob("./*.spec")))

deps.add("ant")

import subprocess

retcode = subprocess.call(*popenargs, **kwargs)

cmd = kwargs.get("args")

if cmd is None: cmd = popenargs[0]

if retcode: raise CalledProcessError(retcode, cmd)

def g(*args,**kwargs):

try: return f(*args,**kwargs)

except CalledProcessError,e:

raise Utils.WafError("system command %s failed with error value %s"%(e.cmd[0],e.returncode))

except IOError,e:

if e.errno is 32:

raise Utils.WafError("system command %s terminated abruptly, closing communications with parent's pipe"%e.cmd[0])

raise

try: p = _Popen(['svn','info']+list(args),stdin=PIPE,stdout=PIPE,stderr=PIPE)

except OSError,e:

if e.errno == 2: return '' # svn command is not installed

raise

stdout,stderr = p.communicate('')

retcode = p.wait()

# If the guess fails, just return nothing.

if retcode: return

# SVN available

rev = [ x for x in stdout.splitlines() if x.startswith('Revision') ]

if not rev: rev = ''

else: rev = "SVN " + rev[0].strip()

url = [ x for x in stdout.splitlines() if x.startswith('URL') ]

if not url: url = ''

else: url = "SVN " + url[0].strip()

if dir and not _isdir(dir): return ''

try: p = _Popen(['git','remote','show','-n','origin'],stdin=PIPE,stdout=PIPE,stderr=PIPE,cwd=dir)

except OSError,e:

if e.errno == 2: return '' # svn command is not installed

raise

stdout,stderr = p.communicate('')

retcode = p.wait()

# If the guess fails, just return nothing.

if retcode: return

stdout = [ s.strip() for s in stdout.splitlines() ]

try: url = [ s[11:] for s in stdout if s.startswith("Fetch URL") ][0]

except IndexError: url = [ s[5:] for s in stdout if s.startswith("URL") ][0]

assert url

p = _Popen(['git','log','-1'],stdin=PIPE,stdout=PIPE,stderr=PIPE,cwd=dir)

stdout,stderr = p.communicate('')

retcode = p.wait()

if retcode: return

# If the guess fails, just return nothing.

stdout = [ s.strip() for s in stdout.splitlines() ]

commitid = [ s.split()[1] for s in stdout if s.startswith("commit") ][0]

assert commitid

t = gitinfo()

if not t: return t

u = gitinfo(_join(pardir,"cloudstack-proprietary"))

if not u: return t

n = Options.options.BUILDNUMBER

if n:

# luntbuild prepends "build-" to the build number. we work around this here:

if n.startswith("build-"): n = n[6:]

# SVN identifiers prepend "$Revision:" to the build number. we work around this here:

if n.startswith("$Revision:"): n = n[11:-2].strip()

return n

else:

# Try to guess the SVN revision number by calling SVN info.

stdout = svninfo()

if not stdout: return ''

# Filter lines.

rev = [ x for x in stdout.splitlines() if x.startswith('SVN Revision') ]

if not rev: return ''

# Parse revision number.

rev = rev[0][14:].strip()

if not path: raise ValueError("no path specified")

start_list = os.path.abspath(start).split(sep)

path_list = os.path.abspath(path).split(sep)

# Work out how much of the filepath is shared by start and path.

i = len(os.path.commonprefix([start_list, path_list]))

rel_list = [pardir] * (len(start_list)-i) + path_list[i:]

if not rel_list:

return curdir

p,e = _split(pathname)

overridden = _join(p,"override",e)

if _exists(overridden): return overridden

doms = [ xml.dom.minidom.parseString(file(f).read(-1)) for f in files if f.endswith(".xml") ]

targets = dict( [ (target.getAttribute("name"),target) for dom in doms for target in dom.getElementsByTagName("target") if target.getElementsByTagName("compile-java") ] )

propsinxml = [ (prop.getAttribute("name"),prop.getAttribute("value") or prop.getAttribute("location")) for dom in doms for prop in dom.getElementsByTagName("property") ]

propsinpropfiles = [ l.strip().split("=",1) for f in files if f.endswith(".properties") for l in file(f).readlines() if "=" in l and not l.startswith("#") ]

props = dict( propsinxml + propsinpropfiles )

props["base.dir"] = '.'

props["p.base.dir"] = '.'

result = []

for name,target in targets.items():

sourcedir = target.getElementsByTagName("compile-java")[0].getAttribute("top.dir") + "/src"

classdir = "${classes.dir}/" + target.getElementsByTagName("compile-java")[0].getAttribute("jar.name")

jarpath = "${jar.dir}/" + target.getElementsByTagName("compile-java")[0].getAttribute("jar.name")

def lookup(matchobject): return props[matchobject.group(1)]

while "$" in sourcedir: sourcedir = re.sub("\${(.+?)}",lookup,sourcedir)

while "$" in classdir: classdir = re.sub("\${(.+?)}",lookup,classdir)

while "$" in jarpath: jarpath= re.sub("\${(.+?)}",lookup,jarpath)

dependencies = [ dep.strip() for dep in target.getAttribute("depends").split(",") if dep.strip() in targets ]

result.append([str(name),str(relpath(sourcedir)),str(relpath(classdir)),str(relpath(jarpath)),[str(s) for s in dependencies]])

# hardcoded here because the discovery process does not get it

result.append( ["build-console-viewer","console-viewer/src", "target/classes/console-viewer", "target/jar/VMOpsConsoleApplet.jar", ["compile-utils","compile-console-common"] ] )

environ = dict(os.environ)

environ["CATALINA_HOME"] = tsk.env.TOMCATHOME

if tsk.generator.env.DISTRO == "Windows":

stanzas = [

"ant",

"-Dthirdparty.classpath=\"%s\""%(tsk.env.CLASSPATH.replace(os.pathsep,",")),

]

else:

stanzas = [

"ant",

"-Dthirdparty.classpath=%s"%(tsk.env.CLASSPATH.replace(os.pathsep,",")),

]

stanzas += tsk.generator.antargs

ret = Utils.exec_command(" ".join(stanzas),cwd=tsk.generator.bld.srcnode.abspath(),env=environ,log=True)

if ret != 0: raise Utils.WafError("Ant command %s failed with error value %s"%(stanzas,ret))

if not options: options = []

if not arguments: arguments = []

if type(classpath) in [list,tuple]: classpath = pathsep.join(classpath)

Utils.pprint("BLUE","Run-time CLASSPATH:")

for v in classpath.split(pathsep): Utils.pprint("BLUE"," %s"%v)

cmd = ["java","-classpath",classpath] + options + [classname] + arguments

Utils.pprint("BLUE"," ".join([ _trm(x,32) for x in cmd ]))

lst = self.to_list(getattr(self, 'after', []))

for x in lst:

obj = self.bld.name_to_obj(x,self.bld.env)

if not obj: break

obj.post()

for a in obj.tasks:

for b in self.tasks:

ctx = Build.BuildContext()

ctx.load_dirs(_abspath(srcdir),_abspath(blddir))

ctx.load_envs()

if "cwd" in kwargs: cwd = kwargs["cwd"]

else: cwd = self.path

if isinstance(listoffiles,str) and '**' in listoffiles:

listoffiles = cwd.ant_glob(listoffiles,flat=True)

elif isinstance(listoffiles,str) and '*' in listoffiles:

listoffiles = [ n for x in listoffiles.split() for n in _glob(cwd.abspath() + os.sep + x.replace("/",os.sep)) ]

listoffiles = Utils.to_list(listoffiles)[:]

listoffiles = [ x for x in listoffiles if not ( x.endswith("~") or x == "override" or "%soverride"%os.sep in x ) ]

for n,f in enumerate(listoffiles):

f = os.path.abspath(f)

f = dev_override(f)

if _isdir(f): continue

if f.endswith(".in"):

source = f ; target = f[:-3]

tgen = self(features='subst', source=source[len(self.path.abspath())+1:], target=target[len(self.path.abspath())+1:], name="filtered_%s"%source)

tgen.dict = self.env.get_merged_dict()

else:

source = f ; target = f

listoffiles[n] = target[len(cwd.abspath())+1:]

if "postpone" not in kwargs: kwargs["postpone"] = True

ret = self.install_files(destdir,listoffiles,**kwargs)

if cwd is None: cwd = self.path

tgenkwargs = {}

if name is not None: tgenkwargs["name"] = name

if isinstance(listoffiles,str) and '**' in listoffiles:

listoffiles = cwd.ant_glob(listoffiles,flat=True)

elif isinstance(listoffiles,str) and '*' in listoffiles:

listoffiles = [ n for x in listoffiles.split() for n in _glob(cwd.abspath() + os.sep + x.replace("/",os.sep)) ]

for src in Utils.to_list(listoffiles):

tgt = src + ".subst"

inst = src # Utils.relpath(src,relative_to) <- disabled

# Use cwd path when creating task and shift back later

tmp = self.path

self.path = cwd

tgen = self(features='subst', source=src, target=tgt, **tgenkwargs)

self.path = tmp

if dict is not None: tgen.dict = dict

else: tgen.dict = self.env.get_merged_dict()

self.path.find_or_declare(tgt)

"""Register command line options"""

opt.tool_options('gnu_dirs')

opt.tool_options('python')

opt.tool_options('tar',tooldir='tools/waf')

opt.tool_options('mkisofs',tooldir='tools/waf')

if Options.platform not in ['darwin','win32']: opt.tool_options('usermgmt',tooldir='tools/waf')

if Options.platform not in ['darwin','win32']: opt.tool_options('javadir',tooldir='tools/waf')

opt.tool_options('tomcat',tooldir='tools/waf')

if Options.platform not in ['darwin',"win32"]: opt.tool_options('compiler_cc')

inst_dir = opt.get_option_group('--srcdir')

inst_dir.add_option('--with-db-host',

help = 'Database host to use for waf deploydb [Default: 127.0.0.1]',

default = '127.0.0.1',

dest = 'DBHOST')

inst_dir.add_option('--with-db-user',

help = 'Database user to use for waf deploydb [Default: root]',

default = 'root',

dest = 'DBUSER')

inst_dir.add_option('--with-db-pw',

help = 'Database password to use for waf deploydb [Default: ""]',

default = '',

dest = 'DBPW')

inst_dir.add_option('--tomcat-user',

help = 'UNIX user that the management server initscript will switch to [Default: <autodetected>]',

default = '',

dest = 'MSUSER')

inst_dir.add_option('--no-dep-check',

action='store_true',

help = 'Skip dependency check and assume JARs already exist',

default = False,

dest = 'NODEPCHECK')

inst_dir.add_option('--fast',

action='store_true',

help = 'does ---no-dep-check',

default = False,

dest = 'NODEPCHECK')

inst_dir = opt.get_option_group('--force')

inst_dir.add_option('--preserve-config',

action='store_true',

help = 'do not install configuration files',

default = False,

dest = 'PRESERVECONFIG')

debugopts = optparse.OptionGroup(opt.parser,'run/debug options')

opt.add_option_group(debugopts)

debugopts.add_option('--debug-port',

help = 'Port on which the debugger will listen when running waf debug [Default: 8787]',

default = '8787',

dest = 'DEBUGPORT')

debugopts.add_option('--debug-suspend',

action='store_true',

help = 'Suspend the process upon startup so that a debugger can attach and set breakpoints',

default = False,

dest = 'DEBUGSUSPEND')

debugopts.add_option('--run-verbose',

action='store_true',

help = 'Run Tomcat in verbose mode (java option -verbose)',

default = False,

dest = 'RUNVERBOSE')

rpmopts = optparse.OptionGroup(opt.parser,'RPM/DEB build options')

opt.add_option_group(rpmopts)

rpmopts.add_option('--build-number',

help = 'Build number [Default: SVN revision number for builds from checkouts, or empty for builds from source releases]',

default = '',

dest = 'BUILDNUMBER')

rpmopts.add_option('--package-version',

help = 'package version',

default = '',

dest = 'VERNUM')

rpmopts.add_option('--release-version',

help = 'release version',

default = '',

dest = 'RELEASENUM')

rpmopts.add_option('--prerelease',

help = 'Branch name to append to the release number (if specified, alter release number to be a prerelease); this option requires --build-number=X [Default: nothing]',

default = '',

dest = 'PRERELEASE')

rpmopts.add_option('--skip-dist',

action='store_true',

help = 'Normally, dist() is called during package build. This makes the package build assume that a distribution tarball has already been made, and use that. This option is also valid during distcheck and dist.',

default = False,

dest = 'DONTDIST')

distopts = optparse.OptionGroup(opt.parser,'dist options')

opt.add_option_group(distopts)

distopts.add_option('--oss',

help = 'Only include open source components',

action = 'store_true',

default = False,

"""prints out the current configure environment configuration"""

conf = _getbuildcontext()

Utils.pprint("WHITE","Build environment:")

for key,val in sorted(conf.env.get_merged_dict().items()):

if "CLASSPATH" in key:

Utils.pprint("BLUE"," %s:"%key)

for v in val.split(pathsep):

Utils.pprint("BLUE"," %s"%v)

continue

lines = []

for key,val in sorted(self.env.get_merged_dict().items()):

if "CLASSPATH" in key:

lines.append(" %s:"%key)

for v in val.split(pathsep):

lines.append(" %s"%v)

continue

lines.append(" %s: %s"%(key,val))

"""return the list of buildable and installable targets"""

bld = Build.BuildContext()

proj = Environment.Environment(Options.lockfile)

bld.load_dirs(proj['srcdir'], proj['blddir'])

bld.load_envs()

bld.add_subdirs([os.path.split(Utils.g_module.root_path)[0]])

names = set([])

for x in bld.all_task_gen:

try:

names.add(x.name or x.target)

except AttributeError:

pass

lst = list(names)

lst.sort()

for name in lst:

def dist(appname='',version=''):

'''makes a tarball for redistributing the sources -- if --skip-dist is specified, does nothing'''

if Options.options.DONTDIST:

if not appname: appname=Utils.g_module.APPNAME

if not version: version=Utils.g_module.VERSION

tmp_folder=appname+'-'+version

if Scripting.g_gz in['gz','bz2']:

arch_name=tmp_folder+'.tar.'+Scripting.g_gz

else:

arch_name=tmp_folder+'.'+'zip'

Logs.info('New archive skipped: %s'%(arch_name))

return arch_name

else:

return f(appname,version)

# Clean the GARBAGE that clogs our repo to the tune of 300 MB

# so downloaders won't have to cry every time they download a "source"

# package over 90 MB in size

[ shutil.rmtree(f) for f in _glob(_join("*","bin")) if _isdir(f) ]

[ shutil.rmtree(f) for f in _glob(_join("cloudstack-proprietary","thirdparty","*")) if _isdir(f) ]

[ shutil.rmtree(f) for f in [ _join("cloudstack-proprietary","tools") ] if _isdir(f) ]

if Options.options.OSS:

[ shutil.rmtree(f) for f in "cloudstack-proprietary".split() if _exists(f) ]

stdout = svninfo("..") or allgitinfo()

if stdout:

f = file("sccs-info","w")

f.write(stdout)

f.flush()

f.close()

else:

# No SVN available

if _exists("sccs-info"):

# If the file already existed, we preserve it

return

else:

f = file("sccs-info","w")

f.write("No revision control information could be detected when the source distribution was built.")

f.flush()

"""creates a binary distribution that, when unzipped in the root directory of a machine, deploys the entire stack"""

ctx = _getbuildcontext()

if Options.options.VERNUM:

VERSION = Options.options.VERNUM

tarball = "%s-bindist-%s.tar.%s"%(APPNAME,VERSION,Scripting.g_gz)

zf = _join(ctx.bldnode.abspath(),tarball)

Options.options.destdir = _join(ctx.bldnode.abspath(),"bindist-destdir")

Scripting.install(ctx)

if _exists(zf): _unlink(zf)

Utils.pprint("GREEN","Creating %s"%(zf))

z = tarfile.open(zf,"w:bz2")

cwd = _getcwd()

_chdir(Options.options.destdir)

z.add(".")

z.close()

buildnumber = Utils.getbuildnumber()

if buildnumber: buildnumber = ["--define","_build_number %s"%buildnumber]

else: buildnumber = []

if Options.options.PRERELEASE:

if not buildnumber:

raise Utils.WafError("Please specify a build number to go along with --prerelease")

prerelease = ["--define","_prerelease %s"%Options.options.PRERELEASE]

else: prerelease = []

if Options.options.RELEASENUM:

release = Options.options.RELEASENUM

else: release = "1"

releasever = ["--define", "_rel %s" % release]

if Options.options.VERNUM:

ver = Options.options.VERNUM

else: ver = SHORTVERSION

packagever = ["--define", "_ver %s" % ver]

# FIXME wrap the source tarball in POSIX locking!

if not Options.options.blddir: outputdir = _join(context.curdir,blddir,"rpmbuild")

else: outputdir = _join(_abspath(Options.options.blddir),"rpmbuild")

Utils.pprint("GREEN","Building RPMs")

tarball = Scripting.dist('', ver)

sourcedir = _join(outputdir,"SOURCES")

if _exists(sourcedir): shutil.rmtree(sourcedir)

for a in ["RPMS/noarch","SRPMS","BUILD","SPECS","SOURCES"]: mkdir_p(_join(outputdir,a))

shutil.move(tarball,_join(sourcedir,tarball))

specfile = "%s.spec"%APPNAME

checkdeps = lambda: c(["rpmbuild","--define","_topdir %s"%outputdir,"--nobuild",specfile]+packagever+releasever)

dorpm = lambda: c(["rpmbuild","--define","_topdir %s"%outputdir,"-bb",specfile]+buildnumber+prerelease+packagever+releasever)

try: checkdeps()

except (CalledProcessError,OSError),e:

Utils.pprint("YELLOW","Dependencies might be missing. Trying to auto-install them...")

installrpmdeps(context)

"""uninstalls any Cloud Stack RPMs on this system"""

Utils.pprint("GREEN","Uninstalling any installed RPMs")

cmd = "rpm -qa | grep %s- | xargs -r sudo rpm -e"%APPNAME

Utils.pprint("BLUE",cmd)

"""installs all the necessary dependencies to build the RPM packages of the stack"""

runnable = ["sudo","yum","install","-y"]+list(getrpmdeps())

Utils.pprint("GREEN","Installing RPM build dependencies")

Utils.pprint("BLUE"," ".join(runnable))

if not virttech: raise Utils.WafError('use deploydb_xenserver, deploydb_vmware or deploydb_kvm rather than deploydb')

ctx = _getbuildcontext()

setupdatabases = _join(ctx.env.BINDIR,"cloud-setup-databases")

serversetup = _join(ctx.env.SETUPDATADIR,"server-setup.xml")

if not _exists(setupdatabases): # Needs install!

Scripting.install(ctx)

cmd = [

ctx.env.PYTHON,

setupdatabases,

"cloud@%s"%ctx.env.DBHOST,

virttech,

"--auto=%s"%serversetup,

"--deploy-as=%s:%s"%(ctx.env.DBUSER,ctx.env.DBPW),

]

Utils.pprint("BLUE"," ".join(cmd))

retcode = Utils.exec_command(cmd,shell=False,stdout=None,stderr=None,log=True)

"""runs the management server"""

conf = _getbuildcontext()

runverbose = []

if Options.options.RUNVERBOSE: runverbose = ['-verbose']

if args == "debug":

suspend = "n"

if Options.options.DEBUGSUSPEND: suspend = "y"

debugargs = [

"-Xdebug","-Xrunjdwp:transport=dt_socket,address=%s,server=y,suspend=%s"%(

Options.options.DEBUGPORT,suspend),

"-ea"]

Utils.pprint("GREEN","Starting Tomcat in debug mode")

else:

Utils.pprint("GREEN","Starting Tomcat in foreground mode")

debugargs = []

options = runverbose + debugargs + [

"-Dcatalina.base=" + conf.env.MSENVIRON,

"-Dcatalina.home=" + conf.env.MSENVIRON,

"-Djava.io.tmpdir="+_join(conf.env.MSENVIRON,"temp"), ]

if not _exists(_join(conf.env.BINDIR,"cloud-setup-databases")): Scripting.install(conf)

cp = [conf.env.MSCONF]

cp += _glob(_join(conf.env.MSENVIRON,'bin',"*.jar"))

cp += _glob(_join(conf.env.MSENVIRON,'lib',"*.jar"))

cp += _glob( _join ( conf.env.PREMIUMJAVADIR , "*" ) )

cp += [conf.env.SYSTEMCLASSPATH]

cp += [conf.env.DEPSCLASSPATH]

cp += [conf.env.MSCLASSPATH]

# FIXME Make selectable at runtime

#plugins = _glob( _join(conf.env.PLUGINJAVADIR,"*") )

#if plugins: cp = plugins + cp

#vendorconfs = _glob( _join(conf.env.MSCONF,"vendor","*") )

#if vendorconfs: cp = plugins + cp

"""runs the agent""" # FIXME: make this use the run/debug options

conf = _getbuildcontext()

if not _exists(_join(conf.env.LIBEXECDIR,"agent-runner")): Scripting.install(conf)

"""runs the agent simulator, compiling and installing files as needed

# to get this to work smoothly from the configure onwards, you need to

# create an override directory in java/agent/conf, then add an agent.properties

# there, with the correct configuration that you desire

# that is it -- you are now ready to simulate_agent

conf = _getbuildcontext()

args = sys.argv[sys.argv.index("simulate_agent")+1:]

if '--' in args: args.remove('--')

cp = [conf.env.AGENTSYSCONFDIR]

cp += _glob( _join ( conf.env.PREMIUMJAVADIR , "*" ) )

cp += [conf.env.SYSTEMCLASSPATH]

cp += [conf.env.DEPSCLASSPATH]

cp += [conf.env.AGENTSIMULATORCLASSPATH]

if not _exists(_join(conf.env.LIBEXECDIR,"agent-runner")): Scripting.install(conf)