Application: gvSIG desktop

import re

import urllib2

import time

DEBUG = False

DEBUG = False

VERBOSE = False

SEARCH_VERSIONS = list()

LINUX_EXEC_EXTENSION=".run" # antes ".bin"

def log(msg):

  f=open("/tmp/gvspkg.log","a")

  f.write(time.ctime())

  f.write(": ")

  f.write(msg)

  f.write("\n")

  f.close()

def message(msg):

    if VERBOSE:

        print msg

    log(msg)

def msgerror(msg, err=None):

    print "ERROR: ", msg

    log("ERROR: "+msg)

    if err!=None :

      print "ERROR: ", str(err)

      log("ERROR: "+ str(err))

def msgwarn(msg):

    print "WARNING: ", msg

    log("WARNING: "+ msg)

def debug(msg):

    if DEBUG:

        print "DEBUG: ", msg

        log("DEBUG: "+ msg)

def acquire_file(name):

  files = list()

  folder = os.getcwd()

  while folder not in ( None, "", "/"):

    pathname = os.path.join(folder,name)

    if os.path.exists(pathname):

      files.append(pathname)

    folder = os.path.dirname(folder)

  return files

def get_gvspkg_bin_folder(): 

    files = list()

    if os.environ.get("HOME") != None :

        files.append(os.path.join(os.environ['HOME'],".gvspkg.bin"))

    files.extend( acquire_file(".gvspkg.bin") )

    files.extend( acquire_file("gvspkg.bin") )

    if len(files)<1 :

      return None

    debug( "gvspkg.bin = %s" % files[-1])

    return files[-1]

def search_GVSPKG_ROOT():

  f = get_gvspkg_bin_folder()

  if f==None:

    return None

  return os.path.dirname(f)

RWXALL = RWALL | stat.S_IXUSR | stat.S_IXOTH | stat.S_IXGRP 

GVSPKG_ROOT = search_GVSPKG_ROOT()

def getSearchVersions():

    vers = list();

    vers.extend(SEARCH_VERSIONS)

    vers.append(VERSION)

    return vers

            if line=="" or line.startswith("#"):

            args = line[n+1:].strip()

            if args != "":

              self.defaultoptions[cmd] = self.defaultoptions.get(cmd,[]) +  args.split(" ")

        options = list();

        if GVSPKG_ROOT != None:

          rootoptions = os.path.join(GVSPKG_ROOT,"gvspkg.bin/options")

        else:

          rootoptions = None

        if rootoptions != None and os.path.isfile(rootoptions):

            options.append(rootoptions)

        else:

            options.append("~/.gvspkg.bin/options")

        options.extend(acquire_file(".gvspkg.options"))

        options.extend(acquire_file("gvspkg.options"))

        for optionfile in options:

          self.load_options(optionfile)

        l = list()

        cmd = self.defaultoptions.get(name,None)

        if cmd != None:

          l.extend(cmd)

def isDigit(s):

    if len(s)>1:

        s=s[0]

    return s in ("0","1","2","3","4","5","6","7","8","9")

	# gvSIG-desktop-1.12.0-com.iver.cit.gvsig.cad-1.12.0-opencadtools-1418-final-all-all-j1_6.gvspkg

	#    0 -  1    -  2   -          3           -  4   - 5          -  6 - 7   - 8 - 9 - 10

	# gvSIG-desktop-1.12.0-com.iver.cit.gvsig.cad-1.12.0-1418-final-all-all-j1_6.gvspkg

	#    0 -  1    -  2   -          3           -  4   - 5  -  6  - 7 - 8 - 9 

	    if isDigit(s[5]) :

                self.version = s[4]

                self.build = s[5]

                self.status = s[6]

                self.os = s[7]

                self.arch = s[8]

            else:

    def getCode(self):

        return self.code

    def getOS(self):

        return self.os

    def getArch(self):

        return self.arch

        if "-" in self.version :

          return "%s-%06d" %(self.version,self.build)

        else:

          return "%s-ZZZ-%06d" %(self.version,self.build)

      	x = x.replace("\\:", ":")

    def getCategories(self):

      return self.getIniOption("categories")

            msgerror("Can't locate package.info in pool '%s'." % (index_path))

    def build(self, pool, versions):

        message( "Creating index list for version '%s' from '%s'" % (versions, pool) )

                if f[-7:].lower()  in (".gvspki", ".gvspkg") :

                    fullpath = root+"/"+f

                    info = PackageInfo(fullpath)

                    if info.gvsig == "gvSIG-desktop" and info.gvsig_version in versions :

                        if packages.get(info.getKey()) == None:

                            debug( "build: add    " + repr(info))

                            packages[info.getKey()]=info

                        else:

                            oldinfo = packages[info.getKey()]

                            debug("build: %s %s %s" % ( info.getKey(), oldinfo.getFullVersion(),info.getFullVersion()))

                            if oldinfo.getFullVersion()<info.getFullVersion()  :

                                debug( "build: update "+ repr(oldinfo))

                                packages[info.getKey()]=info

                        debug( "build: skip   "+ repr(info))

    indexes.build(getPool(), getSearchVersions())

    folder = "%s/gvspkg.bin" % GVSPKG_ROOT

    #print "opts = ",opts

    #print "args = ",args

    message("A�adiendo %s..." % gvspks_name)

        withjre_name = bin_name.replace("online", distribution_name+"-withjre")

        message("A�adiendo %s..." % jrelin)

        withjre_name = bin_name.replace("online", distribution_name+"-withjre")

        message("A�adiendo %s..." % jrewin)

        opts, args = getopt.getopt(cmd.getArgs("mks"), "ixscI:p:", ["index-only","include-default-selection", "clear-list", "exclude=", "excludepki=", "excludepkg=", "include=", "platform="])

    platforms = ("x86", "x86_64")

    oss = ("lin","win")

        elif opt in ("-p", "--platform"):

            if arg == "amd64":

              arg = "x86_64"

            if not platform in ( "x86", "x86_64", "all"):

                msgerror("Unsuported platform value "+repr(platform)+". available values are x86, x86_64, amd64 or all")

                sys.exit(3)

            platforms = (arg,)

            if not os.path.isabs(arg) :

              arg = os.path.join(getPool(), arg)

            if arg.endswith(".*"):

              includes.append(PackageInfo(arg[:-2]+".gvspkg"))

              includes.append(PackageInfo(arg[:-2]+".gvspki"))

            else:

              includes.append(PackageInfo(arg))

    packages_gvspki = getDist() +"/packages.gvspki"    

        msgerror("Can't locate version folder '%s'." % getDist())

        indexes.build(getPool(), getSearchVersions())

    # El indice de paquetes lleva los paquetes para todas las plataformas y sistemas

    # ya que al conectarnos a el desde el administrador de complementos ya

    # se encarga la aplicacion de seleccionar los correspondientes a la plataforma

    # sobre la que esta rodando gvSIG.

            debug("Add package '%s'" % info.getPkiFilename())

        else:

            message("Exclude package '%s'" % info.getFullName())

    md5sum(packages_gvspki,packages_gvspki+".md5")

    mychmod(packages_gvspki+".md5",RWALL)

      for cur_os in oss:

        for cur_platform in platforms:

          packages_gvspks = getDist() +"/packages-"+cur_os+"-"+cur_platform+".gvspks"

          message( "Writing 'packages-"+cur_os+"-"+cur_platform+".gvspks' to '%s'" % packages_gvspks )

          set = zipfile.ZipFile(packages_gvspks,"w",zipfile.ZIP_STORED)

          for info in indexes:

              if not ( info.code in excludes_pkg or info.getFullName() in excludes_pkg ):

                  try:

                      if info.hasPkg():

                        if cur_os == "all" or info.getOS() in ("all", cur_os) :

                          if cur_platform == "all" or info.getArch() in ("all", cur_platform) :

                            set.write(info.getPkgFilename(), os.path.basename(info.getPkgFilename()))

                  except Exception, ex:

                      msgerror("Can't add package '%s', error %s" % (index, str(ex)))

              else:

                  message("Exclude package '%s'" % info.getFullName())

          if default_selection != None :

              set.write(default_selection,default_selection)

          set.close()

          mychmod(packages_gvspks,RWALL)

          md5sum(packages_gvspks,packages_gvspks+".md5")

          mychmod(packages_gvspks+".md5",RWALL)

def mkmirror(args):

    cmd = Command(args)

    try:

        opts, args = getopt.getopt(cmd.getArgs("mkmirrot"), "b:", [ "build="])

    except getopt.GetoptError, err:

        # print help information and exit:

        print str(err) # will print something like "option -a not recognized"

        help(args)

        sys.exit(2)

    build = None

    for opt, arg in opts:

        if opt in ("-b", "--build"):

            build = arg

        else:

            assert False, "unhandled option %r" % opt

    if build == None:

        msgerror("Build number required.")

        sys.exit(3)

    domkmirror( getPackagesRoot(),getVersion(),build)

def domkmirror(root_src, version, build):

  join = os.path.join

  def linkfile(src,dst):

    if os.path.lexists(dst):

      os.remove(dst)

    os.symlink(src,dst)

    if os.path.lexists(src+".md5") :

      if os.path.lexists(dst+".md5"):

        os.remove(dst+".md5")

      os.symlink(src+".md5",dst+".md5")

  build = str(build)

  root_target = join(root_src,"mirrors",version+"-"+build,"gvsig-desktop")

  build_src = join(root_src,"dists",version,"builds",build)

  build_target = join(root_target,"dists",version,"builds",build)

  pool_src = join(root_src,"pool")

  pool_target = join(root_target,"pool")

  if not os.path.isdir(root_target):

    os.makedirs(root_target)

  if not os.path.isdir(build_target):

    os.makedirs(build_target)

  if not os.path.isdir(pool_target):

    os.makedirs(pool_target)

  files = os.listdir(build_src)

  linkfile(join(build_src,"packages.gvspki"), join(root_target,"dists",version,"packages.gvspki"))

  for f in files:

    f_src = join(build_src,f)

    f_target = join(build_target,f)

    if os.path.isfile(f_src):

      linkfile(f_src,f_target)

  z = zipfile.ZipFile(join(build_src,"packages.gvspki"))

  pkgs = z.namelist()

  for pkgname in pkgs:

    if pkgname!='defaultPackages':

      pkg = PackageInfo(pkgname)

      if not os.path.exists(join(root_target,"pool",pkg.getCode())) :

        os.makedirs(join(root_target,"pool",pkg.getCode()))

      src = join(root_src,"pool",pkg.getCode(),pkg.getPkgFilename())

      target = join(root_target,"pool",pkg.getCode(),pkg.getPkgFilename())

      linkfile(src,target)

  cmd = "cd %s ; find . ! -type d >%s/files.lst" % (root_target, build_target)

  os.system(cmd)

        opts, args = getopt.getopt(cmd.getArgs("mkhtml"), "xsc", ["clear-list", "exclude=", "excludepki=", "excludepkg=", "include="])

        indexes.build(getPool(), getSearchVersions())

                msgerror("Can't create html '%s', error %s" % (info, str(ex)))

	"../../../web/" + item.getFullName() + ".html?height=400&width=600",

<!--javascript para la visualizaci�n de la tabla y carga din�mica del contenido del enlace -->

<!-- inicializaci�n de la tabla con cosas chachis -->

    @import "../dists/%s/web/css/demo_table.css";

  if info.getDependencies() == None:

    html += '    <tr><th valing="top">%s </th><td>%s</td></tr>\n'%("Dependencies", "")

  else:

    html += '    <tr><th valing="top">%s </th><td>%s</td></tr>\n'%("Dependencies", info.getDependencies().replace("\:",":"))

  html += '    <tr><th valing="top">%s </th><td>%s</td></tr>\n'%("O.S.", info.getOS())

  html += '    <tr><th valing="top">%s </th><td>%s</td></tr>\n'%("Architecture", info.getArch())

  html += '    <tr><th valing="top">%s </th><td>%s</td></tr>\n'%("Categories", info.getCategories())

  description = info.getDescription()

  if description == None:

    description = ""

  description = description.replace("\\n", "<br>")

  <!-- javascript para la visualizaci�n de la tabla -->

  <!-- inicializaci�n de la tabla con cosas chachis -->

def mkdist(args):

    cmd = Command(args)

    try:

        opts, args = getopt.getopt(cmd.getArgs("mkdist"), "b:s:p:", [ "build=", "state=", "distribution_name=", "platform" ])

    except getopt.GetoptError, err:

        # print help information and exit:

        print str(err) # will print something like "option -a not recognized"

        help(args)

        sys.exit(2)

    build=None

    state=None

    distribution_name = "standard"

    platforms = ("x86", "x86_64")

    oss = ("lin", "win")

    for opt, arg in opts:

        if opt in ("-b", "--build"):

            build=arg

        elif opt in ("-s", "--state"):

            state=arg

        elif opt in ("-N", "--distrinution-name"):

            distribution_name = arg

        elif opt in ("-p", "--platform"):

          if args == "amd64":

            # Aceptamos la plataforma amd64 como sinonimo de x86_64

            args = "x86_64"

          if not arg in ("x86","x86_64"):

            print "Unsuported platform "+repr(platform)+", must be x86, x86_64 or amd64."

            help(args)

            sys.exit(2)

          platforms = (arg,)

        else:

            assert False, "unhandled option %r" % opt

    if build == None:

      print "Requiered option --build not found."

      help(args)

      sys.exit(2)

    if state == None:

      print "Requiered option --state not found."

      help(args)

      sys.exit(2)

    #

    # Independientemente de la plataforma, los binarios de la version online a utilizar

    # que usamos son siempre los de x86, con lo que el instalador siempre sera para x86.

    # Si hemos especificado que queremos una instalacion para x86, este llevara solo paquetes

    # multiplataforma, "all", y "x86".

    # Si hemos especificado que queremos una instalacion para x86_64, este llevara solo paquetes

    # multiplataforma, "all", y "x86_64".

    #

    if not os.path.isdir("builds/"+build):

      print "Can't access the build folder builds/"+build+"."

      sys.exit(2)

    message( "Generating distribution for build "+ build + "...")

    executeCommand("mks", "-s", "-c")

    executeCommand("mkhtml" )

    gvspki_filename = "builds/"+build+"/packages.gvspki"

    message( "Coping packages.gvspki to "+ gvspki_filename)

    shutil.copyfile("packages.gvspki", gvspki_filename)

    shutil.copyfile("packages.gvspki.md5", gvspki_filename +".md5")

    exec_extensions = { 

      "lin" : LINUX_EXEC_EXTENSION,

      "win" : ".exe"

    }

    for cur_os in oss:

      exec_extension = exec_extensions[cur_os]

      for cur_platform in platforms:

        message( "Process "+cur_os+"/"+cur_platform)

        gvspks_filename = "builds/"+build+"/gvSIG-desktop-" + VERSION + "-" + build+ "-" + state + "-"+cur_os+"-"+cur_platform+".gvspks"

        online_filename = "builds/"+build+"/gvSIG-desktop-" + VERSION + "-" + build+ "-" + state + "-"+cur_os+"-x86-online" + exec_extension

        if not os.path.isfile(online_filename):

          msgwarn("Can't access the online installable for "+cur_os+"/"+cur_platform + " ("+online_filename+").")

          continue

        message( "Coping packages-"+cur_os+"-"+cur_platform+"..gvspks to "+ gvspks_filename)

        shutil.copyfile("packages-"+cur_os+"-"+cur_platform+".gvspks", gvspks_filename)

        shutil.copyfile("packages-"+cur_os+"-"+cur_platform+".gvspks.md5", gvspks_filename +".md5")

        message( "Add execution permissions to online installables....")

        mychmod(online_filename,RWXALL)

        md5sum(online_filename,online_filename+".md5")

        mychmod(online_filename+".md5",RWALL)

        executeCommand("mkinstall" , "--addjre"+cur_os, online_filename, gvspks_filename)

        message( "Renaming files from custom to standard...")

        target_filename = "builds/"+build+"/gvSIG-desktop-" + VERSION + "-" + build+ "-" + state + "-"+cur_os+"-"+cur_platform+"-"+distribution_name + exec_extension

        shutil.move(

            "builds/"+build+"/gvSIG-desktop-" + VERSION + "-" + build+ "-" + state + "-"+cur_os+"-x86-custom" + exec_extension,

            target_filename

        )

        mychmod(target_filename,RWXALL)

        md5sum(target_filename,target_filename+".md5")

        mychmod(target_filename+".md5",RWALL)

        target_filename = "builds/"+build+"/gvSIG-desktop-" + VERSION + "-" + build+ "-" + state + "-"+cur_os+"-"+cur_platform+"-"+distribution_name+"-withjre" + exec_extension

        shutil.move(

            "builds/"+build+"/gvSIG-desktop-" + VERSION + "-" + build+ "-" + state + "-"+cur_os+"-x86-custom-withjre" + exec_extension,

            target_filename

        )

        mychmod(target_filename,RWXALL)

        md5sum(target_filename,target_filename+".md5")

        mychmod(target_filename+".md5",RWALL)

        message( "Coping html index to browse paqueges of the distro.")

        shutil.rmtree("builds/"+build+"/web", ignore_errors=True)

        shutil.copytree("web", "builds/"+build+"/web")

        f = file("builds/"+build+"/web/index.html","r")

        contents = f.read()

        f.close()

        contents = contents.replace("href=\"../../../web/gvSIG-desktop-", "href=\"../../../../../web/gvSIG-desktop-")

        f = file("builds/"+build+"/web/index.html","w")

        f.write(contents)

        f.close()

    message( "Process completed.")

    cmd = Command(args)

    try:

        opts, args = getopt.getopt(cmd.getArgs("show"), "S", [ "verify"])

    except getopt.GetoptError, err:

        # print help information and exit:

        print str(err) # will print something like "option -a not recognized"

        help(args)

        sys.exit(2)

    eerify = False

    for opt, arg in opts:

        if opt in ("-V", "--verify"):

            verify = True

        else:

            assert False, "unhandled option %r" % opt

    index_name=args[0]

    print s

    if verify:

      verify_sign(package_info)

def editall(args):

    cmd = Command(args)

    try:  

        opts, args = getopt.getopt(cmd.getArgs("editall"), "Scx:I:r:", ["clear-list", "exclude=", "excludepki=", "excludepkg=", "include=", "replace=", "sign"])

    except getopt.GetoptError, err:

        # print help information and exit:

        print str(err) # will print something like "option -a not recognized"

        help(args)

        sys.exit(2)

    index_only = False

    clear_list=False

    includes=list()

    excludes_pki=list()

    replaces = list()

    excludes_pkg=list()

    sign = False

    interactive = True

    for opt, arg in opts:

        if opt in ("-c", "--clear-list"):

            clear_list = True

        elif opt in ("-x", "--exclude"):

            excludes_pki.append(arg)

            excludes_pkg.append(arg)

        elif opt in ( "--excludepki"):

            excludes_pki.append(arg)

        elif opt in ( "--excludepkg"):

            excludes_pkg.append(arg)

        elif opt in ( "--include", "-I"):

            includes.append(PackageInfo(arg))

        elif opt in ("-r", "--replace"):

            interactive = False

            replaces.append(arg)

        elif opt in ("-S", "--sign"):

            sign = True

        else:

            assert False, "unhandled option %r" % opt

    indexes = IndexList()

    packages_txt = getDist() +"/packages.txt"

    if os.path.exists(packages_txt) and not clear_list:

        indexes.load(packages_txt)

    else:

        indexes.build(getPool(), getSearchVersions())

        indexes.save(packages_txt)

    for pkg in includes:

      indexes.append(pkg)

    allpackages = list()

    for info in indexes:

        if not ( info.code in excludes_pki or info.getFullName() in excludes_pki ):

            try:

                if info.hasPki() :

                  print info.getPkiFilename() 

                  if interactive :

                    edit_pkginfo_of_package(info.getPkiFilename(), edit_ui)

                  elif len(replaces) < 1:

                    edit_pkginfo_of_package(info.getPkiFilename(), edit_replace, replaces)

                  if sign:

                    edit_pkginfo_of_package(info.getPkiFilename(), edit_sign)

            except Exception, ex:

                msgerror("Can't add index '%s', error %s" % (info, str(ex)))

    cmd = Command(args)

    try:

        opts, args = getopt.getopt(cmd.getArgs("edit"), "Sr:", [ "replace=", "onlysign", "sign" ])

    except getopt.GetoptError, err:

        # print help information and exit:

        print str(err) # will print something like "option -a not recognized"

        help(args)

        sys.exit(2)

    replaces = list()

    interactive = True

    sign = False

    for opt, arg in opts:

        if opt in ("-r", "--replace"):

            interactive = False

            replaces.append(arg)

        elif opt in ("--onlysign"):

            interactive = False

            sign = True

        elif opt in ("-S", "--sign"):

            sign = True

        else:

            assert False, "unhandled option %r" % opt

    index_name=args[0]

    if interactive:

      edit_pkginfo_of_package(index_path, edit_ui)

    elif len(replaces) < 1:

      edit_pkginfo_of_package(index_path, edit_replace, replaces)

    if sign:

      edit_pkginfo_of_package(index_path, edit_sign)

def edit_ui(filename, args):

      os.system('vi "%s"' % filename)

def edit_replace(filename, args):

      replaces = args[0]

      f = open(filename)

      s = f.read()

      f.close()

      for replace in replaces:

        x = replace.split(replace[0])

        if len(x)==4:

          s=re.sub(x[1],x[2],s)

      f = open(filename,"w")

      f.write(s)

      f.close()

def edit_sign(filename, args):

      os.system('java -cp "%s/commons-codec-1.6.jar:%s/org.gvsig.installer.lib.impl-1.0.1-SNAPSHOT.jar" org.gvsig.installer.lib.impl.utils.SignUtil sign %s' %  (

        get_gvspkg_bin_folder(),

        get_gvspkg_bin_folder(),

        filename)

      )

def verify_sign(filename):

      os.system('java -cp "%s/commons-codec-1.6.jar:%s/org.gvsig.installer.lib.impl-1.0.1-SNAPSHOT.jar" org.gvsig.installer.lib.impl.utils.SignUtil verify %s' % (

        get_gvspkg_bin_folder(),

        get_gvspkg_bin_folder(),

        filename)

      )

def edit_pkginfo_of_package(pkg_path, operation, *args):

    os.system('unzip -q %s -d %s' % (pkg_path,outputfolder))

        msgerror("Can't locate package.info in pool '%s'." % (pkg_path))

    operation(package_info, args)

    # zip -Dr kk.zip org.gvsig.wfs

    os.remove(pkg_path)

    shutil.move(temp_index_name,pkg_path)

def install(args):

    cmd = Command(args)

    try:

        opts, args = getopt.getopt(cmd.getArgs("install"), "f", [ "force" ])

    except getopt.GetoptError, err:

        # print help information and exit:

        print str(err) # will print something like "option -a not recognized"

        help(args)

        sys.exit(2)

    force = False

    for opt, arg in opts:

        if opt in ("-f", "--force"):

            force = True

        else:

            assert False, "unhandled option %r" % opt

    url_pki = args[0]

    message( "Download package index '%s'" % url_pki)

    temppath_pki= os.path.join("/tmp",os.path.basename(url_pki))

    if not downloadFile(url_pki,temppath_pki):

      msgerror("Can't download index.")

      msgerror("Can't install '%s'." % url_pki)

      print # force a newline

      return 1

    pkg = PackageInfo(temppath_pki)

    url_pkg = pkg.getUrl().replace("\\","")

    if url_pkg[-7:] == ".gvspki" :

      msgwarn("Suspicious download-url value. Ends with gvspki, expected gvspkg.")

      msgwarn("download-url ='%s'." % url_pkg)

    message( "Download package '%s'" % url_pkg)

    temppath_pkg= os.path.join("/tmp",os.path.basename(url_pkg))

    if not downloadFile(url_pkg,temppath_pkg):

      msgerror("Can't download package from download-url ('%s')." % url_pkg)

      msgerror("Can't install '%s'," % url_pki)

      print # force a newline

      return 1

    folder = os.path.join(getPool(),pkg.getCode())

    if not os.path.isdir(folder) :

        os.makedirs(folder)

    pathname_pki = os.path.join(folder,os.path.basename(url_pki))

    if not force and os.path.isfile(pathname_pki) :

        msgwarn("The package index alreade exist in the pool. Use -f to forrce install.")

        print # force a newline

        return 1

    pathname_pkg = os.path.join(folder,os.path.basename(url_pkg))

    if  not force and os.path.isfile(pathname_pki) :

        msgwarn("The package downloaded from download-url alredy exists in the pool. Use -f to force install.")

        print # force a newline  

        return 1

    message( "installing package '%s'" % os.path.basename(pathname_pki))

    shutil.copyfile(temppath_pki, pathname_pki)

    message( "installing package '%s'" % os.path.basename(pathname_pkg))

    shutil.copyfile(temppath_pkg, pathname_pkg)

    md5sum(pathname_pki, pathname_pki+".md5")

    md5sum(pathname_pkg, pathname_pkg+".md5")

def md5sum(fin, fout):

    message( "Calculating md5sum of %s..." % fin )

    system("md5sum -b %s >%s" % (fin, fout) )

def downloadFile(url,path):

  try:

    fsrc = urllib2.urlopen(url)

  except urllib2.HTTPError,e:

    msgerror("Error abriendo url '%s'." % url, e)

    return False

  fdst = file(path,"wb")

  shutil.copyfileobj(fsrc,fdst)

  fdst.close()

  fsrc.close()

  return True

     -p | --platform=name

        Indica para que plataforma queremos generar el conjunto de paquetes. 

        Es un parametro opcional.

        Sus valores pueden ser:

        - all (Se incluiren los de todas las plataformas, no solo los multiplataforma)

        - x86

        - x86_64

        - amd64 (sinonimo aceptado para x86_64)

        Si no se indica plataforma se generara para "all".

        El indice,"gvspki", siempre llevara los de todas las plataformas, esta opcion

        solo afecta a la genracion del "gvspks".

        A�ade el paquete indicado a la lista de paquetes aunque no coincida para 

mkdist [OPTIONS]

     Crea los ficheros de la distribucion standard para el buil dindicado a partir de 

     la distribucion online y los paquetes que hayan en el pool para esta version.

     Ejecuta un "mks" y un "mkhtml" automaticamente para preparar el conjunto de paquetes

     a incluir en la distribucion, y una vez preparados ejecuta un "mkinsrall" por

     S.O. (win y lin), renombrando los ficheros generados segun corresponda.

     OPTIONS:

     -s STATE | --state=STATE

        Indica el estado de la distribucion a generar, devel, alpha, ..., debe estar

        deacuerdo con lo que diga el cihero online a usar como base.

     -b BUILD | --build=BUILD

        Indica el numero de build de la destribucion a generar. Es usado para localizar

        los ficheros en la carpeta builds de la distribucion y para saber donde debe

        dejar los ficheros generados.

     -p | --platform=name

        Indica para que plataforma queremos generar los instalables de gvSIG. 

        Es un parametro opcional.

        Sus valores pueden ser:

        - all (si se indica se generara para x86)

        - x86

        - x86_64

        - amd64 (sinonimo aceptado para x86_64)

        Si no se indica plataforma se generara para x86.

     -N | --distribution-name=name

        Nombre usado como sufijo del nuevo binario a generar. Por defecto si no se

        indica valdra "standard".

mkmirror [OPTIONS]

  Prepara una carpeta para hacer un mirror de un build en concreto.

     OPTIONS:

     -b | --build buildnumber

       Indica el numero de build del que se quiere hacer un mirror.

show OPTIONS package-index

    OPTIONS

    --verify | -V

      Comprueba la forma del packete.

edit [OPTIONS] package-index

     OPTIONS:

     --replace=@search@replace@

       Reemplaza en el package.info de cada paquete la cadena "search" por "replace"

       todas las veces que aparezca. "@" puede ser cualquier caracter que no aparezca

       en "search" y "replace".

       Esta opcion puede indicarse tatas veces como reemplazos se deseen efectuar.

     --onlysign

       firma el package.info sin editarlo de forma interactiva (no invoca al editor antes 

       de firmarlo).

     --sign | -S

       Firma el package.info tras terminar la edicion (bach o interactiva)

editall [OPTIONS]

    Edita todos los package.info 

     OPTIONS:

     -c | --clear-list

        Elimina la lista de paquetes a utilizar recreandola a partir

        de los paquetes del pool tomando el ultimo build de cada paquete.

     --excludepkg pkgcode

        No incluye el paquete indicado en el fichero gvspkg a generar

     --excludepki pkgcode

        No incluye el paquete indicado en el fichero gvspki a generar

     --exclude pkgcode

        No incluye el paquete indicado en los ficheros gvspkg y gvspki a generar

     --replace=@search@replace@

       Reemplaza en el package.info de cada paquete la cadena "search" por "replace"

       todas las veces que aparezca. "@" puede ser cualquier caracter que no aparezca

       en "search" y "replace".

       Esta opcion puede indicarse tatas veces como reemplazos se deseen efectuar.

      --sign | -S

        Firma todos los paquetes que sean oficiales

install [OPTIONS] url-to-pki

    descarga de la url indicada un fichero gvspki e instala este junto con su correspondiente

    pkg en el pool local.

     OPTIONS:

     -f | --force

       fuerza la sobreescritura de los ficheros en caso de que estos ya existan.

def executeCommand(*args):

    command = "help"

    if len(args)>0:

        command=args[0]

    if command=="lsi" :

        lsi(args)

    elif command == "mks":

        mks(args)

    elif command == "edit":

        edit(args)

    elif command == "editall":

        editall(args)

    elif command == "show":

        show(args)

    elif command == "mkhtml":

        mkhtml(args)

    elif command == "mkinstall":

        mkinstall(args)

    elif command == "install":

        install(args)

    elif command == "mkdist":

        mkdist(args)

    elif command == "mkmirror":

        mkmirror(args)

    else:

        help(args)

    global DEBUG

    global SEARCH_VERSIONS

        opts, args = getopt.getopt(cmd.getArgs("main"), "dhvr:", ["debug", "verbose", "version=", "package-root=","help","search_versions="])

        elif opt in ("--search_versions"):

            SEARCH_VERSIONS.append(arg)

    debug("DEBUG=%s" % DEBUG)

    debug("VERSION=%s" % VERSION)

    debug("GVSPKG_ROOT=%s" % GVSPKG_ROOT)

    if GVSPKG_ROOT == None:

      help(None)

      executeCommand(*args)