Application: gvSIG desktop

#!/usr/bin/python

# -*- coding: utf-8 -*-

#

import sys

import os

import os.path

import fnmatch

import shutil

import zipfile

import stat

import getopt

from os.path import dirname

import shutil

from os import system

import ConfigParser

import StringIO

import re

import urllib2

import time

DEBUG = False

DEBUG = False

VERBOSE = False

SEARCH_VERSIONS = list()

class Platform:

  def __init__(self,os,arch,exe,onlinefamily=None, portableSufix=""):

    self.osfamily = None

    self.osname = None

    self.osversion = None

    self.os = os

    self.arch = arch

    self.exe_extension = exe

    self.portableSufix = portableSufix

    if "_" in self.os:

      ss=self.os.split("_")

      self.osfamily = ss[0]

      if len(ss)>1:

        self.osname = ss[1]

        if len(ss)>2:

          self.osversion= ss[2]

    else:

      self.osfamily = self.os

    if onlinefamily == None:

      self.onlinefamily = self.osfamily

    else:

      self.onlinefamily = onlinefamily

  def getOS(self):

    return self.os

  def getOSFamily(self):

    return self.osfamily

  def getOSFamilyForOnlineInstaller(self):

    return self.onlinefamily

  def getOSName(self):

    return self.osname

  def getOSVersion(self):

    return self.osversion

  def getArch(self):

    return self.arch

  def getExeExtension(self):

    return self.exe_extension

  def getPortableSufix(self):

    return self.portableSufix

platforms = (

  Platform("darwin_macos_10.11","x86_64",".run",onlinefamily="lin", portableSufix=".app"),

  Platform("lin_ubuntu_16.04","x86_64",".run"),

  Platform("lin","x86",".run"),

  Platform("lin","x86_64",".run"),

  Platform("win","x86",".exe"),

  Platform("win","x86_64",".exe")

)

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

        sys.stdout.flush()

    log(msg)

def msgerror(msg, err=None):

    print "ERROR: ", msg

    log("ERROR: "+msg)

    if err!=None :

      print "ERROR: ", str(err)

      sys.stdout.flush()

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

def msgwarn(msg):

    print "WARNING: ", msg

    sys.stdout.flush()

    log("WARNING: "+ msg)

def debug(msg):

    if DEBUG:

        print "DEBUG: ", msg

        sys.stdout.flush()

        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)

RWALL = stat.S_IWOTH | stat.S_IROTH | stat.S_IWUSR | stat.S_IRUSR | stat.S_IWGRP | stat.S_IRGRP

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

VERSION = os.path.basename(os.getcwd())

GVSPKG_ROOT = search_GVSPKG_ROOT()

def getVersion():

    return VERSION

def getSearchVersions():

    vers = list();

    vers.extend(SEARCH_VERSIONS)

    vers.append(VERSION)

    return vers

def getPackagesRoot():

    return GVSPKG_ROOT

def getPool():

    return getPackagesRoot() + "/pool"

def getWeb():

    return getPackagesRoot() + "/web"

def getDist():

    return getPackagesRoot() + "/dists/" +getVersion()

def findfiles(root,filename):

    result=list()

    for wroot, dirs, files in os.walk(root):

        for f in files :

            if fnmatch.fnmatch(f,filename):

                result.append(wroot+"/"+f)

    result.sort()

    return result

def mychmod(filename, perms):

    try:

        os.chmod(filename,perms)

    except Exception, ex:

        msgwarn("Can't change permissions of file '%s', error %s" % (filename, str(ex)))

def makedirs(path):

    if not os.path.isdir(path) :

      os.makedirs(path)

class Command:

    def __init__(self, args):

        self.args = args

        self.defaultoptions = None

    def load_options(self,filename):

        debug("loading option from %s" % filename)

        if not os.path.isfile(filename):

            debug("filename %s not found" % filename)

            return

        f=file(filename,"r")

        for line in f.readlines():

            line = line.strip()

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

                continue

            if line[-1] == "\n":

                line = line[:-1]

            n = line.find("=")

            if n<0 :

                continue

            cmd = line[:n]

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

            if args != "":

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

            debug("add options: %s=%r" % (cmd, args.split(" ")))

        f.close()

    def load_default_options(self):

        if self.defaultoptions != None:

            return

        self.defaultoptions = dict()

        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)

    def getArgs(self,name):

        self.load_default_options()

        l = list()

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

        if cmd != None:

          l.extend(cmd)

        l.extend(self.args[1:])

        return l

def isDigit(s):

    if len(s)>1:

        s=s[0]

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

class PackageInfo(str):

    def __init__(self, filename):

        self._ini = None

        self.filename = filename[:-7]

        self.type = filename[-6:]

        s = os.path.basename(self.filename)

        s = s.split("-")

        #print "## PackageInfo ", repr(s)

        self.gvsig = s[0] + "-" + s[1]

        self.gvsig_version = s[2]

        self.code = s[3]

        try:

  # 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:

                self.version = s[4] + "-" + s[5]

                self.build = s[6]

                self.status = s[7]

                self.os = s[8]

                self.arch = s[9]

        except Exception:

            self.build = "0"

            self.status = "unknow"

            self.os = "all"

            self.arch = "all"

        try:

            self.build = int(self.build)

        except:

            pass

    def getCode(self):

        return self.code

    def getOS(self):

        return self.os

    def getArch(self):

        return self.arch

    def getKey(self):

        return self.code+"-"+self.os+"-"+self.arch

    def getFullName(self):

        return os.path.basename(self.filename)

    def getFullVersion(self):

        try:

          r = re.compile("([0-9]+)[.]([0-9]+)[.]([0-9]+)-([a-zA-Z0-0]+)$")

          m = r.match(self.version)

          if m == None:

            clasificador="ZZZZZZZZ"

            r = re.compile("([0-9]+)[.]([0-9]+)[.]([0-9]+)$")

            m = r.match(self.version)

          else:

            clasificador=m.group(4)

          v1=int(m.group(1))

          v2=int(m.group(2))

          v3=int(m.group(3))

          return "%06d.%06d.%06d-%s-%06d" % (v1,v2,v3,clasificador,self.build)

        except:

          if "-" in self.version :

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

          else:

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

    def getFilename(self):

        return self.filename + "." + self.type

    def hasPki(self):

        return os.path.isfile( self.getPkiFilename() )

    def getPkiFilename(self):

        return self.filename + ".gvspki"

    def hasPkg(self):

        return os.path.isfile( self.getPkgFilename() )

    def getPkgFilename(self):

        return self.filename + ".gvspkg"

    def getIniOption(self, name, default=None):

      section = "general"

      ini = self.getIni()

      if ini.has_option(section, name):

        x = ini.get(section, name)

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

        return x

      return default

    def getDescription(self):

      return self.getIniOption("description")

    def getCategories(self):

      return self.getIniOption("categories")

    def getName(self):

      return self.getIniOption("name")

    def getOwner(self):

      ini = self.getIni()

      if ini.has_option("general","owner"):

        return ini.get("general","owner")

      return None

    def getUrl(self):

      ini = self.getIni()

      if ini.has_option("general","download-url"):

        return ini.get("general","download-url")

      return None

    def getSourceUrl(self):

      ini = self.getIni()

      if ini.has_option("general","source-url"):

        return ini.get("general","source-url")

      return None

    def getDependencies(self):

      ini = self.getIni()

      if ini.has_option("general","dependencies"):

        return ini.get("general","dependencies")

      return None

    def getType(self):

      ini = self.getIni()

      if ini.has_option("general","type"):

        return ini.get("general","type")

      return None

    def getOfficial(self):

      ini = self.getIni()

      if ini.has_option("general","official"):

        return ini.get("general","official")

      return None

    def getIni(self):

        if self._ini != None:

          return self._ini

        index_path = self.getPkiFilename()

        outputfolder="/tmp/gvspkg.%s" % os.getpid()

        os.mkdir(outputfolder)

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

        files = findfiles(outputfolder, "package.info")

        if len(files) != 1:

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

            return None

        package_info = files[0]

        self._ini = ConfigParser.ConfigParser()

        f = file(package_info,"r")

        ss = f.read()

        self._ini.readfp(StringIO.StringIO("[general]\n"+ss))

        f.close()

        shutil.rmtree(outputfolder)

        return self._ini

    def __str__(self):

        return self.filename

    def __repr__(self):

        return "filename=%r:gvsig=%r:gvsig_version=%r:code=%r:version=%r:build=%r:status=%r" % (

                self.filename, self.gvsig, self.gvsig_version, self.code, self.version, self.build, self.status )

class IndexList(list):

    def load(self, fname):

        message( "Loading index list from '%s'." % fname)

        f=file(fname,"r")

        lines=f.readlines()

        f.close()

        for line in lines:

          if line[-1] == "\n":

            line = line[:-1]

          info = PackageInfo(line)

          self.append(info)

    def save(self,fname):

        message( "Saving index list from '%s'." % fname)

        f=file(fname,"w")

        for index in self:

          f.write("%s\n" % index.getFilename())

        f.close()

        mychmod(fname,RWALL)

    def build(self, pool, versions):

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

        packages=dict()

        for root, dirs, files in os.walk(pool):

            for f in files :

                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

                    else:

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

        self.extend(packages.values())

        self.sort()

def lsi(args):

    cmd = Command(args)

    try:

        opts, args = getopt.getopt(cmd.getArgs("lsi"), "l", ["long-format"])

    except getopt.GetoptError, err:

        # print help information and exit:

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

        shorthelp(args)

        sys.exit(2)

    long_format=False

    for opt, arg in opts:

        if opt in ("-l", "--long-format"):

            long_format = True

        else:

            assert False, "unhandled option"

    indexes = IndexList()

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

    for info in indexes:

        if info.hasPki():

            if long_format:

                print "["+os.path.basename(info.getPkiFilename())+"]"

                print "# ", info.getPkiFilename()

                show(["show", os.path.basename(info.getPkiFilename())])

            else:

                print info.getPkiFilename()

def installer_add(cmd,arg1,arg2):

    installer_add_use_zip(cmd,arg1,arg2)

def installer_add_use_zip(cmd,arg1,arg2):

    if cmd == "addjrelin":

      return

    if cmd == "addjrewin":

      return

    if cmd == "addpks":

       zip = zipfile.ZipFile(arg1,"a",zipfile.ZIP_STORED)

       zip.write(arg2,"package.gvspks")

       zip.close()

def installer_add_use_installkit(cmd,arg1,arg2):

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

    cmd = "%s/installkit %s/main.tcl %s %s %s" % (

        "/mnt/data0/public-files/gvsig-desktop/gvspkg.bin",

        folder,

        cmd,

        arg1,

        arg2

    )

    system(cmd)

def mkinstall(args):

    cmd = Command(args)

    try:

        opts, args = getopt.getopt(cmd.getArgs("mkinstall"), "N:lL:wW:", ["addjrewin", "addjrelin", "jrelin=", "jrewin=", "distribution-name="])

    except getopt.GetoptError, err:

        # print help information and exit:

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

        shorthelp(args)

        sys.exit(2)

    #print "opts = ",opts

    #print "args = ",args

    addjrelin=False

    addjrewin=False

    jrelin=None

    jrewin=None

    distribution_name = "custom"

    for opt, arg in opts:

        if opt in ("-L", "--jrelin"):

            jrelin = arg

        elif opt in ("-W", "--jrewin"):

            jrewin = arg

        elif opt in ("-l", "--addjrelin"):

            addjrelin = True

        elif opt in ("-w", "--addjrewin"):

            addjrewin = True

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

            distribution_name = arg

        else:

            assert False, "unhandled option"

    if len(args) != 2 :

        shorthelp(args)

        sys.exit(4)

    bin_name = args[0]

    gvspks_name = args[1]

    custom_name = bin_name.replace("online", distribution_name)

    if not "online" in bin_name :

        print "gvspkg mkinstall: binary file name must contain 'online'"

        sys.exit(3)

    if addjrelin and addjrewin :

        print "gvspkg mkinstall: only one of addjrelin or addjrewin is allowed."

        sys.exit(4)

    message("Creating %s..." % custom_name)

    shutil.copyfile(bin_name, custom_name)

    mychmod(custom_name,RWALL)

    message("Adding %s..." % gvspks_name)

    installer_add("addpks", custom_name, gvspks_name)

    """

    if addjrelin:

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

        message("Creating %s..." % withjre_name)

        shutil.copyfile(custom_name, withjre_name)

        mychmod(withjre_name,RWALL)

        message("Adding %s..." % jrelin)

        installer_add("addjrelin", withjre_name, jrelin)

    if addjrewin:

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

        message("Creating %s..." % withjre_name)

        shutil.copyfile(custom_name, withjre_name)

        mychmod(withjre_name,RWALL)

        message("Adding %s..." % jrewin)

        installer_add("addjrewin", withjre_name, jrewin)

    """

def mks(args):

    cmd = Command(args)

    try:

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

    except getopt.GetoptError, err:

        # print help information and exit:

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

        shorthelp(args)

        sys.exit(2)

    default_selection = None

    index_only = False

    clear_list=False

    includes=list()

    excludes_pki=list()

    excludes_pkg=list()

    for opt, arg in opts:

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

            clear_list = True

        elif opt in ("-s", "--include-default-selection"):

            default_selection = "defaultPackages"

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

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

        elif opt in ("-i", "--index-only"):

            index_only = True

        else:

            assert False, "unhandled option %r" % opt

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

        msgwarn("No se ha encontrado el fichero %r. la opcion -s/--include-default-selection sera ignorada." % default_selection)

        default_selection = None

    indexes = IndexList()

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

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

    message( "Creating 'packages.gvspki' for version '%s'" % getVersion() + "...")

    if not os.path.exists(getDist()):

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

        sys.exit(3)

    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)

    # 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.

    message( "Writing 'packages.gvspki' to '%s'" % packages_gvspki )

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

    for info in indexes:

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

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

            try:

                if info.hasPki() :

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

            except Exception, ex:

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

        else:

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

    if default_selection != None :

        set.write(default_selection,default_selection)

    set.close()

    mychmod(packages_gvspki,RWALL)

    md5sum(packages_gvspki,packages_gvspki+".md5")

    mychmod(packages_gvspki+".md5",RWALL)

    if not index_only :

      for platform in platforms:

        packages_gvspks = getDist() +"/packages-"+platform.getOS()+"-"+platform.getArch()+".gvspks"

        message( "Writing 'packages-"+platform.getOS()+"-"+platform.getArch()+".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 info.getOS() in ("all", platform.getOS()) :

                        if info.getArch() in ("all", platform.getArch()) :

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

                except Exception, ex:

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

            else:

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

    message( "Createds package indexes.\n")

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"

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

def domkmirror(root_src, version, build):

  join = os.path.join

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

  makedirs(root_target)

  makedirs(build_target)

  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)

      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)

def mkhtml(args):

    def getCode(info):

      return info.code

    cmd = Command(args)

    try:

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

    except getopt.GetoptError, err:

        # print help information and exit:

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

        shorthelp(args)

        sys.exit(2)

    index_only = False

    clear_list=False

    includes=list()

    excludes_pki=list()

    excludes_pkg=list()

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

        else:

            assert False, "unhandled option %r" % opt

    message("Creating html pages...")

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

    basepath = getWeb()

    for info in indexes:

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

            try:

                if info.hasPki() :

                    mkpkihtml(basepath, info)

                    allpackages.append(info)

            except Exception, ex:

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

    html = '''

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

  <meta http-equiv="Content-Type" content= "text/html; charset=us-ascii" />

      <title>"%s" package list</title>'''% getVersion() # Title

    html += '''

<!-- estilos para las tablas -->

  <style type="text/css" title="currentStyle">

    @import "css/demo_table.css";

    @import "css/thickbox.css";

    #pkglist{

        width:100%;

        clear:both;

        font-family:Arial,Helvetica,sans-serif;

    }

    #pkgdetails{

        width:600px !important;

        clear:both;

    }

    #pkgdetails table th{

        text-algin:right;

    }

  </style>

</head>'''

    html += '''

<body>

  <h1>%s package list</h1>

  <table id="pkglist" summary="%s package list" width="100%%" >

    <thead>

    <tr>

      <td>Package name</td>

      <td>Version</td>

      <td>O.S.</td>

      <td>Official</td>

      <td>Type</td>

      <td>Owner</td>

    </tr>

    </thead>

    <tbody>'''%(getVersion(),getVersion())

    # sort allpackages

    for item in sorted(allpackages, key=getCode):

      html += '''\n    <tr>

      <td><a class="thickbox" href="%s">%s</a></td>

      <td>%s</td>

      <td>%s</td>

      <td>%s</td>

      <td>%s</td>

      <td>%s</td>

    </tr>\n'''%(

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

        item.getName(),

  item.version,

  item.os,

  item.getOfficial(),

  item.getType(),

  item.getOwner()

      )

    html += """ </tbody>\n </table>

<!--javascript para la visualizacion de la tabla y carga dinamica del contenido del enlace -->

<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.4/jquery.min.js" type="text/javascript"></script>

<script src="http://datatables.net/release-datatables/media/js/jquery.dataTables.js" type="text/javascript"></script>

<script type="text/javascript" src="js/thickbox-compressed.js"></script>

<!-- inicializacion de la tabla con cosas chachis -->

<script type="text/javascript">

  $(document).ready(function() {

      $('#pkglist').dataTable( {

      "bPaginate": false,

      "bLengthChange": true,

      "bFilter": true,

      "bSort": true,

      "bInfo": true,

      "bAutoWidth": true

    });

 } );

</script>

</body>

</html>"""

    # generate index.html

    try:

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

      f.write(html)

      f.close()

    except Exception, ex:

      raise ex

    message("html pages createds.\n")

def mkpkihtml(basepath, info):

  html='''<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">

  <title>%s</title>

  <!-- estilos para las tablas -->

  <style type="text/css" title="currentStyle">

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

    #pkgdetails{

      width:600px;

      clear:both;

    }

    #pkgdetails table th{

        text-algin:right;

    }

  </style>

</head>

<body>\n'''%(info.getIniOption("name"), getVersion())

  html += '  <table id="pkgdetails" summary=%s >\n'%info.getIniOption("name")

  html += '    <thead>\n  <tr>\n  <th>%s </th>\n  <td>%s</td>\n  </tr>\n  </thead>\n'%("Name", info.getIniOption("name"))

  html += '    <tbody><tr><th>%s </th><td>%s</td></tr>\n'%("Code", info.code)

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

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

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

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

  #url = info.getUrl()

  url = info.getIniOption("download-url")

  if url != None:

    html += '    <tr><th valing="top">Downloads</th><td><a href ="%s">Binaries</a></td></tr>\n'%(url)

  else:

    html += '    <tr><th valing="top">Downloads</th><td>Binaries</td></tr>\n'

  sourceUrl = info.getSourceUrl()

  if sourceUrl != None:

    html += '    <tr><td></td><td><a href ="%s">Sources</a></td></tr>\n'%(sourceUrl)

  else:

    html += "    <tr><td></td><td>Sources</td></tr>\n"

  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'%("Type", info.getType())

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

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

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

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

  html += """  </tbody>\n</table>\n"""

  html += """

  <!-- javascript para la visualizacion de la tabla -->

  <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.2.6/jquery.min.js" type="text/javascript"></script>

  <script src="http://datatables.net/release-datatables/media/js/jquery.dataTables.js" type="text/javascript"></script>

  <!-- inicializacion de la tabla con cosas chachis -->

  <script type="text/javascript">

    $(document).ready(function() {

      $('#pkgdetails').dataTable( {

        "bPaginate": false,

        "bLengthChange": true,

        "bFilter": false,

        "bSort": false,

        "bInfo": false,

        "bAutoWidth": true

      });

    });

  </script>

  </body>\n</html>"""

  try:

    f = file(getWeb() + "/" + info.getFullName() + ".html","w")

    f.write(html)

    f.close()

  except Exception, ex:

    raise ex

def extract_make_portable(zfile, targetfolder):

  print "Extracting 'make-portable' from %r to %r" % (zfile,targetfolder)

  zf = zipfile.ZipFile(zfile)

  data = zf.read("tools/make-portable")

  f = open(os.path.join(targetfolder,"make-portable"),"wb")

  f.write(data)

  f.close()

  zf.close()

def extract_mkexec(zfile, targetfolder):

  print "extract_mkexec: zfile=%s, target=%s" % (zfile, os.path.join(targetfolder,"mkexec"))

  zf = zipfile.ZipFile(zfile)

  data = zf.read("tools/mkexec")

  f = open(os.path.join(targetfolder,"mkexec"),"wb")

  f.write(data)

  f.close()

  zf.close()

def prepare_portable(args):

    cmd = Command(args)

    try:

        opts, args = getopt.getopt(cmd.getArgs("prepare-portable"), "b:s:", [ "build=", "state=" ])

    except getopt.GetoptError, err:

        # print help information and exit:

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

        shorthelp(args)

        sys.exit(2)

    build=None

    state=None

    for opt, arg in opts:

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

            build=arg

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

            state=arg

        else:

            assert False, "unhandled option %r" % opt

    if build == None:

      print "Requiered option --build not found."

      shorthelp(args)

      sys.exit(2)

    if state == None:

      print "Requiered option --state not found."

      shorthelp(args)

      sys.exit(2)

    join = os.path.join

    build_folder = join(getPackagesRoot(),"dists",getVersion(),"builds",build)

    if not os.path.isdir(build_folder):

      print "Can't access the build folder "+build_folder+"."

      sys.exit(2)

    do_prepare_portable(build,state)

def do_prepare_portable(build,state):

    join = os.path.join

    build_folder = join(getPackagesRoot(),"dists",getVersion(),"builds",build)

    portable_folder = join(build_folder,"misc","portable")

    makedirs(portable_folder)

    makedirs(join(portable_folder,"packages","custom"))

    makedirs(join(portable_folder,"standard"))

    makedirs(join(portable_folder,"patchs"))

    f=open(join(portable_folder,"packages","excludes"),"w")

    f.write("""EPSG_v6

EPSG_v8_4

EPSG_v8_5

EPSG_v8_6

org.gvsig.app.document.layout1.app.mainplugin

org.gvsig.dyschromatopsia.app.extension

org.gvsig.educa.portableview.app.editor

org.gvsig.educa.portableview.app.viewer

org.gvsig.projection.app.cresques

org.gvsig.projection.app.proj4j

org.gvsig.editing.app.mainplugin

org.gvsig.downloader.app.mainplugin

org.gvsig.publish.app.mainplugin

org.gvsig.mapsheets.app.mainplugin

org.gvsig.customize.app.mainplugin

org.gvsig.timesupport.app.viewfilter

org.gvsig.timesupport.app.animation

""")

    f.close()

    fname_base = "gvSIG-desktop-%s-%s-%s" % (getVersion(),build,state)

    for platform in platforms :

      linkfile(

        join(build_folder,fname_base + "-" + platform.getOS() + "-" + platform.getArch() + "-online.zip"),

        join(portable_folder,"standard",fname_base + "-" + platform.getOS() + "-" + platform.getArch() + "-online.zip")

      )

      linkfile(

        join(build_folder,fname_base + "-" + platform.getOS() + "-" + platform.getArch() + ".gvspks"),

        join(portable_folder,"standard",fname_base + "-" + platform.getOS() + "-" + platform.getArch() + ".gvspks")

      )

    extract_make_portable(

      join(build_folder,fname_base + "-lin-x86_64-online.zip"),

      join(portable_folder)

    )

    mychmod(join(portable_folder,"make-portable"),RWXALL)

def zipfolder(source,target):

  def zipdir(path, zip):

      for root, dirs, files in os.walk(path):

          for file in files:

              zip.write(os.path.join(root, file))

  zipf = zipfile.ZipFile(target, 'w')

  zipdir(source, zipf)

  zipf.close()

def removefile(filename):

  if os.path.exists(filename):

    os.remove(filename)

def mkportable(args):

    cmd = Command(args)

    try:

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

    except getopt.GetoptError, err:

        # print help information and exit:

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

        shorthelp(args)

        sys.exit(2)

    build=None

    state=None

    for opt, arg in opts:

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

            build=arg

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

            state=arg

        else:

            assert False, "unhandled option %r" % opt

    if build == None:

      print "Requiered option --build not found."

      shorthelp(args)

      sys.exit(2)

    if state == None:

      print "Requiered option --state not found."

      shorthelp(args)

      sys.exit(2)

    join = os.path.join

    build_folder = join(getPackagesRoot(),"dists",getVersion(),"builds",build)

    if not os.path.isdir(build_folder):

      print "Can't access the build folder "+build_folder+"."

      sys.exit(2)

    portable_folder = join(build_folder,"misc","portable")

    if not os.path.isdir(portable_folder) :

      do_prepare_portable(build,state)

    os.system('cd %s ; ./make-portable' % (portable_folder))

    message("Removing previos portable zip files")

    for platform in platforms :

      removefile(join(build_folder,"gvSIG-desktop-%s-%s-%s-%s-%s%s.zip" %  (

        getVersion(),build,state,platform.getOS(),platform.getArch(), platform.getPortableSufix()

      )))

    target_folder = join(getPackagesRoot(),"dists",getVersion(),"builds",build,"misc","portable","target")

    for platform in platforms :

      message("Moving zip gvSIG-desktop-%s-%s-%s-%s-%s%s.zip" % (

        getVersion(),build,state,platform.getOS(),platform.getArch(), platform.getPortableSufix()

      ))

      shutil.move(

        join(portable_folder,"target","gvSIG-desktop-%s-%s-%s-%s-%s%s.zip" % (

        getVersion(), build, state, platform.getOS(), platform.getArch(), platform.getPortableSufix()

    )

  ),

        build_folder

      )

    message("Remove temporary folders")

    shutil.rmtree(target_folder)

def mkexec(version, build, state, distribution_name, folder):

  fname = "gvSIG-desktop-%s-%s-%s-lin-x86_64-online.zip" % (version,build,state)

  extract_mkexec(os.path.join(folder,fname), folder)

  mychmod(os.path.join(folder,"mkexec"),RWXALL)

  cmd = 'cd %s ; ./mkexec "%s" "%s" "%s" "%s" "%s"' % (folder,version, build, state, distribution_name, folder)

  print "mkexec: cmd=", cmd

  os.system(cmd)

  os.remove(os.path.join(folder,"mkexec"))

def mkdist(args):

    cmd = Command(args)

    try:

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

    except getopt.GetoptError, err:

        # print help information and exit:

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

        shorthelp(args)

        sys.exit(2)

    build=None

    state=None

    distribution_name = "standard"

    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

        else:

            assert False, "unhandled option %r" % opt

    if build == None:

      print "Requiered option --build not found."

      shorthelp(args)

      sys.exit(2)

    if state == None:

      print "Requiered option --state not found."

      shorthelp(args)

      sys.exit(2)

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

    message("Recreating index of packages...")

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

    executeCommand("mkhtml" )

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

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

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

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

    for platform in platforms:

        message( "Creating installers for platform "+platform.getOS()+"/"+platform.getArch()+"...")

        gvspks_filename = "builds/"+build+"/gvSIG-desktop-" + VERSION + "-" + build+ "-" + state + "-"+platform.getOS()+"-"+platform.getArch()+".gvspks"

        online_filename = "builds/"+build+"/gvSIG-desktop-" + VERSION + "-" + build+ "-" + state + "-"+platform.getOS()+"-"+platform.getArch() + "-online.jar"

        if not os.path.isfile(online_filename):

          osfamily=platform.getOSFamilyForOnlineInstaller()

          message("Coping standard online installer from os family (%s) to %s." % (osfamily, online_filename))

          shutil.copyfile(

            "builds/"+build+"/gvSIG-desktop-" + VERSION + "-" + build+ "-" + state + "-"+osfamily+"-"+platform.getArch() + "-online.jar",

            online_filename

          )

        if not os.path.isfile(online_filename):

          msgwarn("Can't access the online installer for "+platform.getOS()+"/"+platform.getArch() + " ("+online_filename+").")

          continue

        message( "Coping packages-"+platform.getOS()+"-"+platform.getArch()+".gvspks to "+ gvspks_filename)

        shutil.copyfile("packages-"+platform.getOS()+"-"+platform.getArch()+".gvspks", gvspks_filename)

        shutil.copyfile("packages-"+platform.getOS()+"-"+platform.getArch()+".gvspks.md5", gvspks_filename +".md5")

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

        mychmod(online_filename,RWXALL)

        md5sum(online_filename,online_filename+".md5")

        mychmod(online_filename+".md5",RWALL)

        executeCommand("mkinstall" , online_filename, gvspks_filename)

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

        target_filename = "builds/"+build+"/gvSIG-desktop-" + VERSION + "-" + build+ "-" + state + "-"+platform.getOS()+"-"+platform.getArch()+"-"+distribution_name + ".jar"

        shutil.move(

            "builds/"+build+"/gvSIG-desktop-" + VERSION + "-" + build+ "-" + state + "-"+platform.getOS()+"-"+platform.getArch() + "-custom.jar",

            target_filename

        )

        mychmod(target_filename,RWXALL)

        md5sum(target_filename,target_filename+".md5")

        mychmod(target_filename+".md5",RWALL)

        message( "Createds installers for platform "+platform.getOS()+"/"+platform.getArch()+"\n")

    mkexec(VERSION, build, state, distribution_name, os.path.join(os.getcwd(), "builds", build))

    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( "\nCreation of distribution completed.\n")

def show(args):

    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"

        shorthelp(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]

    message( "Show package.info from '%s'" % index_name)

    files = findfiles(getPool(), index_name)

    if len(files) != 1:

        msgerror("Can't locate package '%s' in pool '%s'." % (index_name, getPool()))

        return

    index_path = files[0]

    outputfolder="/tmp/gvspkg.%s" % os.getpid()

    os.mkdir(outputfolder)

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

    files = findfiles(outputfolder, "package.info")

    if len(files) != 1:

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

        return

    package_info = files[0]

    f = file(package_info,"r")

    s = f.read()

    f.close()

    print s

    if verify:

      verify_sign(package_info)

    shutil.rmtree(outputfolder)

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"

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

def edit(args):

    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"

        shorthelp(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]

    message( "Show package.info from '%s'" % index_name)

    files = findfiles(getPool(), index_name)

    if len(files) != 1:

        msgerror("Can't locate package '%s' in pool '%s'." % (index_name, getPool()))

        return

    index_path = files[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):

    outputfolder="/tmp/gvspkg.%s" % os.getpid()

    os.mkdir(outputfolder)

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

    files = findfiles(outputfolder, "package.info")

    if len(files) != 1:

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

        return

    package_info = files[0]

    code = package_info.split("/")[-2]

    operation(package_info, args)

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

    temp_index_name = "/tmp/packages.gvspki.%s" % os.getpid()

    temp_index = zipfile.ZipFile(temp_index_name,"w",zipfile.ZIP_STORED)

    temp_index.write(package_info, "%s/package.info" % (code))

    temp_index.close()

    shutil.rmtree(outputfolder)

    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"), "fS", [ "force","nohttps" ])

    except getopt.GetoptError, err:

        # print help information and exit:

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

        shorthelp(args)

        sys.exit(2)

    force = False

    nohttps = False

    for opt, arg in opts:

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

            force = True

        if opt in ("-S", "--nohttps"):

            nohttps = True

        else:

            assert False, "unhandled option %r" % opt

    url_pki = args[0]

    if url_pki.startswith("https:") and nohttps :

       url_pki = "http:" + url_pki[6:]

    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)

    if url_pkg.startswith("https:") and nohttps :

       url_pkg = "http:" + url_pkg[6:]

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

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