Esempio n. 1
0
    def installApplication(self, installDir, testmode):
        """
        Manager.installApplication
          Installs the application by performing the following steps:
            - checks to see if the installation directory is writable
            - loads metadata
            - checks if enough disk space is available
            - checks to see if this is an incremental installation
              - looks for the base disribution for this release
            - checks for previous installation of this package
              and checks the md5sum <not implemented>
            - unpacks the installation package
            - publishes package metadata
            - sets up the environment scripts and runs setup scripts
            - creates links and checks installation size
        """
        if notWritable(installDir):
            sys.exit(notWritable(installDir))
        # Absolutize path if needed:
        if not os.path.isabs(installDir):
            installDir = os.path.abspath(installDir)
        # Extract metadata from distribution:
        metadata = loadMetadata(getMetaDataFile(),
                                archive = self.currentRequest.getDarFile())

        infoOut('Loaded DAR metadata from '+self.currentRequest.getDarFile())
        # If in test mode, print out users info and exit:
        if testmode:
            print metadata.userInfo()
            return
        # Check  that  there is enough space in the installation directory:
        available = spaceLeft(installDir)
        installSize = float(metadata.getInstallationSize())

        if available < installSize:
            sys.exit('Not enough space on the disk!\n Installation size: ' \
                     + str(installSize) +
                     ' KB\n Available: ' +
                     str(available) + ' KB')

        self.timingLog('Checked space left in '+installDir)
        ##########################################
        #   Handling  incremental DARballs:
        ##########################################
        # Check if darball metadata contain a reference to a base dar:
        baseDar = metadata.getBaseDar()
        if baseDar:
            infoOut("This is  incremental distribution based on "+baseDar)
            # This is an incremental darball, so 
            # we need matching base installation.
            baseInstallation = self.currentRequest.baseDar
            if  not baseInstallation:
                usageError ('Please specify a base .')
                # Lookup for base installation in the installation pool:
                # baseInstallation = self.findBaseInstallation(self.distPool,
                #                                           baseDar)
                # if not baseInstallation:
                #    sys.exit( 'Could not find base installation for ' +
                #                   baseDar + '
                #                   in '+self.sharedPool)
            infoOut("(todo)Verifying base installation "+baseInstallation)
        ##########################################
        #   General actions for all DARballs:
        ##########################################
        # Check if the installation already exists:
        releaseInstTop = os.path.join(installDir,
                                      metadata.getVersionTag(),
                                      metadata.getArchitecture())
        if os.path.exists( releaseInstTop):
            # TODO: validate the installation using  md5sum and
            # tell user the results
            sys.exit("ERROR: You already have installation here: \n   " \
                     +releaseInstTop+"\nExiting ....\n")
        # Unpack darball
        infoOut('Unpacking '+self.currentRequest.getDarFile()+' .... ')
        unpackCommand = 'tar -xz -C ' + \
                        installDir + ' -f ' + \
                        self.currentRequest.getDarFile()

        (status, out) = commands.getstatusoutput(unpackCommand)
        
        # Check that in unpacked into toInstallDir as expected:
        if status: # failed
            if out:
                # save command output in the logfile:
                unpackLogfile = os.path.join(self.logdir, 'dar_unpack.log')
                tarlog = open(unpackLogfile, 'w')
                tarlog.write('Output from unpacking command:\n' + \
                         unpackCommand + '\n' + out )
                tarlog.close()
            sys.exit ('Unpacking failed with exit status ' + status + \
                      '\nOutput can be found in \n' + unpackLogfile )
        elif not os.path.isdir(releaseInstTop):
            sys.exit ('Can not  find  '+releaseInstTop)            
        # Link to a base installation for incremental darballs 
        if baseDar:
            infoOut("Create a link to base installation:\n ln -s "
                     +baseInstallation+'/shared '+releaseInstTop+'/base')
            os.symlink(baseInstallation+'/shared', releaseInstTop+'/base')
        # Set up environment scripts:
        infoOut("Setting up the installation")
        templateStub = os.path.join(releaseInstTop, getSetupScriptBasename())
        newSetupScriptStub = os.path.join(releaseInstTop, 'envSetup')
        helpText = self.updateSetupScripts(\
                   templateStub, \
                   releaseInstTop, \
                   newSetupScriptStub )

        # For compatibility with the old Production tools:
        oldSetupScriptStub = os.path.join(releaseInstTop,
                                          metadata.getVersionTag() + '_env')
        self.updateSetupScripts(\
                   templateStub, \
                   releaseInstTop, \
                   oldSetupScriptStub )

        # Move script templates to the DAR admin directory. 
        #infoOut('Removing setup scripts templates ...')
        cmd = 'mv ' + templateStub + '.*sh' + ' ' \
              + installDir + '/' + getDarDirName()
        (status, out)=commands.getstatusoutput(cmd)
        if status != 0: # did not succeed
            DARInternalError("In installApplication: " +
                             "doing command" + cmd +
                             "\ncommand output :\n" + out)
        
        
        #infoOut("(todo) Do md5sum check of BOM in resulting installation")
        #infoOut("(todo) If successful, " +
        #        "register installation in publishing service ")
        self.publishMetadata(installDir + '/' + getDarDirName())
        # Publish installation metadata:
        self.publishMetadata(installDir + '/' + getDarDirName())

        #Print out runtime environment setup help (and exit):
        infoOut(helpText)
        infoOut("Installation completed.")
Esempio n. 2
0
    def prepareDistribution(self, method = 'copy'):
        """
        Manager.prepareDistribution:
          Creates DARball structure according to current request, using
          copy, or link method.
        """
        # Check  how  much  space is  left in tmp dir,
        # where the darball will be built:
        spaceLeft(self.tmpdir)
        self.timingLog('Checked space left in '+self.tmpdir)

        # If incremental darbal was requested, get its metadata,
        # and fill up base bomdictionary
        baseDar = self.currentRequest.baseDar
        self.darMeta.setBaseDar(baseDar)
        
        if baseDar:
            if os.path.isdir(baseDar):
                # This should be an installation directory:
                bomFile = baseDar+'/' + getBOMFileName()

                if os.path.isfile(bomFile):
                    # Create base bom dictionary directly from file 
                    for entry in open(bomFile,'r').readlines():
                        # a list of lines
                        (md5, entryPath) = string.split(entry)
                        self.baseBomDict[entryPath] = md5
                else:
                    raise InputError(baseDar,
                                    'Could not find ' +
                                     getBOMFileName() + ' here.')
            else:
                if os.path.isfile(baseDar):
                    # This should be a DARball:
                    baseDarball = baseDar
                else:
                    # This should be a release tag of a base darball
                    # available from the dar pool.
                    # Lookup for base darball in the distribution pool:
                    
                    if notReadable(self.distPool):
                        sys.exit(notReadable(self.distPool))
                    baseDarball = self.findBaseDarball(self.distPool, baseDar)
                    if not baseDarball:
                        sys.exit( 'Could not find base distribution for ' \
                                  +baseDar+' in '+self.sharedPool)
                        
                # Create base bom dictionary on the flight from the archive:
                result = readFileFromArchive(baseDarball, getBOMFileName())

                for entry in string.split(result,'\n'):
                    md5, entryPath = string.split(entry)
                    self.baseBomDict[entryPath] = md5

        # Now create DAR directory structure:
        self.dar = Structure(self.blddir, self.currentRequest,
                             method, baseBom = self.baseBomDict)

        self.timingLog('Created DAR in ' + self.blddir +
                       ' using ' + method + ' method')
        instDir = self.dar.getTopInstDir()
        if method == 'copy':
            self.timingLog('Counted install. size ' +
                           'before cleanup in shared dir')
            # Make cleanup and create BOM only for the FSO image (shared 
            # between the environment variables):
            cleanup(self.dar.getSharedTop(),
                    os.path.join(self.dar.getTopInstDir(), getBOMFileName()))
            self.timingLog('Removed duplicates and created BOM for ' +
                           self.dar.getSharedTop())
        size = noteSize(instDir)
        self.timingLog('Counted size after cleanup in ' +
                       self.dar.getSharedTop())
        self.darMeta.setInstallationSize(size)
        # fakeScram()
        # including scram runtime command, which may replace setup scripts.
        self.saveMetadata(os.path.join(self.dar.getTopInstDir(),
                                       getMetaDataFile()))
        
        # - saves into metadata file info about creation of a darball,
        # project conifguration info. Adds a spec file (and darInput in
        # scram mode). DAR info and its source code go here.
        self.createReadmeFile()