Python path.path函数代码示例

def install_kernel_package(package, toolkit=None, target=None, loginfo=loginfo,
                           logerror=logerror):
    if toolkit is not None:
        target = toolkit.target
    if target is None:
        raise RuntimeError , "No target specified."
    target = path(target)
    chroot_precommand = ['chroot', str(target)]
    aptinstall = ['aptitude', '--assume-yes', 'install']
    cmd = chroot_precommand + aptinstall + [package]
    loginfo('install command is: %s' % ' '.join(cmd))
    kimgconf = target / 'etc' / 'kernel-img.conf'
    kimgconf_old = path('%s.paella-orig' % kimgconf)
    kimgconflines = ['do_bootloader = No',
                     'do_initrd = Yes',
                     'warn_initrd = No'
                     ]
    if kimgconf.exists():
        loginfo('/etc/kernel-img.conf already exists')
        k = '/etc/kernel-img.conf'
        msg ='renaming %s to %s.paella-orig' % (k, k)
        loginfo(msg)
        if kimgconf_old.exists():
            msg = '%s already exists, aborting install.' % kimgconf_old
            logerror(msg)
            raise RuntimeError , msg
        os.rename(kimgconf, kimgconf_old)
    kimgconf.write_lines(kimgconflines)
    subprocess.check_call(cmd)
    loginfo('Kernel installation is complete.')
    if kimgconf_old.exists():
        loginfo('Restoring /etc/kernel-img.conf')
        os.remove(kimgconf)
        os.rename(kimgconf_old, kimgconf)

 def _filename(self, sequence, filename=None):
     if filename is None:
         filename = self.orig_filename
     else:
         filename = path(filename)
     seqname = "%s.%d" % (filename, sequence)
     return path(seqname)

 def _setup_standard_directories(self):
     self._std_dirs = KStandardDirs()
     self.tmpdir_parent = path(str(self._std_dirs.findResourceDir('tmp', '/')))
     self.datadir_parent = path(str(self._std_dirs.findResourceDir('data', '/')))
     self.tmpdir = self.tmpdir_parent / 'utguests'
     self.datadir = self.datadir_parent / 'utguests'
     # we need this in dosbox object (for now)
     self.main_config_dir = self.datadir
     if not os.path.exists(self.datadir):
         os.mkdir(self.datadir)

 def export_profile(self, profile, dirname=None):
     if dirname is None:
         dirname = path('.')
     dirname = path(dirname)
     makepaths(dirname)
     # this env object should be handled
     # inside the profile object instead
     # of being handled here.
     env = self.profile.make_environment_object()
     env.set_profile(profile)
     self.profile.export_profile(dirname, profile=profile, env=env)

 def extract_base_tarball(self):
     suite = self.suitecursor.get_base_suite(self._suite)
     fstype = self.cfg.get('umlmachines', 'backup_filesystem')
     if fstype == 'hostfs':
         #backup_path = path(self.cfg.get('umlmachines', 'hostfs_backup_path')).expand()
         backup_path = path(self.options['hostfs_backup_path'].value)
     else:
         backup_path = path('/mnt')
     basetarball = backup_path / path('%s.base.tar.gz' % suite)
     if not basetarball.isfile():
         basetarball = backup_path / path('%s.base.tar' % suite)
     if basetarball.isfile():
         extract_tarball(self.target, basetarball)
     else:
         raise RuntimeError, 'No base tarball found for suite %s' % suite

 def import_all_aptkeys(self, dirname=None):
     if dirname is None:
         dirname = self.main_path / 'aptkeys'
     dirname = path(dirname)
     files = [f for f in dirname.listdir() if f.isfile() and f.endswith('.gpg')]
     for filename in files:
         self.import_aptkey(filename)

    def __init__(self):
        object.__init__(self)
        self.cfg = PaellaConfig()
        self.conn = InstallerConnection()
        self.profile = os.environ['PAELLA_PROFILE']
        self.target = path(os.environ['PAELLA_TARGET'])
        self.machine = None
        self.trait = None
        self.suite = get_suite(self.conn, self.profile)

        self.db = ToolkitDatabase(self.conn)
        self.db.set_profile(self.profile)
        self.traits = self.db.profile.make_traitlist()
        profile_families = self.db.profile.get_families()
        self.families = list(self.db.family.get_related_families(profile_families))
        self.default = DefaultEnvironment(self.conn)
        

        if os.environ.has_key('PAELLA_MACHINE'):
            self.machine = os.environ['PAELLA_MACHINE']
            self.db.set_machine(self.machine)
            
        # we need to make an installer to do
        # some of the installer functions.
        self.installer = None

        if os.environ.has_key('PAELLA_TRAIT'):
            self.set_trait(os.environ['PAELLA_TRAIT'])

 def install_kernel_package(self):
     self.log.info('called install_kernel_package')
     extra_modules = self.determine_extra_modules_from_diskconfig()
     if extra_modules:
         self.log.info('Checking if extra packages are required before kernel install.')
         self.install_packages_for_extra_modules(extra_modules)
     kernel = self.machine.get_kernel()
     cmd = self.chroot_precommand + self.aptinstall + [kernel]
     self.log.info('install cmd is: %s' % ' '.join(cmd))
     kimgconf = self.target / 'etc' / 'kernel-img.conf'
     kimgconf_old = path('%s.paella-orig' % kimgconf)
     kimgconflines = ['do_bootloader = No',
                      'do_initrd = Yes',
                      'warn_initrd = No'
                      ]
     if kimgconf.exists():
         self.log.info('/etc/kernel-img.conf already exists')
         k = '/etc/kernel-img.conf'
         msg ='renaming %s to %s.paella-orig' % (k, k)
         self.log.info(msg)
         if kimgconf_old.exists():
             raise RuntimeError , '%s already exists, aborting install.' % kimgconf_old
         os.rename(kimgconf, kimgconf_old)
     kimgconf.write_lines(kimgconflines)
     runlog(cmd)
     self.log.info('Kernel installation is complete.')
     if kimgconf_old.exists():
         self.log.info('Restoring /etc/kernel-img.conf')
         os.remove(kimgconf)
         os.rename(kimgconf_old, kimgconf)

    def __init__(self, conn, suite, target):
        # target should already be a path object
        self.target = path(target)
        self.trait = None

        # setup relation objects
        self.traitpackage = TraitPackage(conn, suite)
        self.traittemplate = TraitTemplate(conn, suite)
        self.traitscripts = TraitScript(conn, suite)

        # setup empty variable containers
        self.profiledata = {}
        self.machine_data = {}
        self.familydata = {}

        # It's odd, but running the same
        # code for setting debconf selections
        # returns a 1 on the preseed process, yet
        # returns a 0 when it's done during
        # the templates process.
        # -- I found the problem, debconf reports
        #    an error if the question doesn't exist
        #    yet.
        # This attribute helps keep track of the
        # problem, and will run the debconf
        # selections during the templates
        # process, if the value is True.
        # I don't really like this, but it seems
        # to work for now, so I'm going to leave
        # it as is, and come up with a better
        # solution later.
        self.debconf_problem = False

 def export_db_element(self, dirname=None, filename="database.xml"):
     if dirname is None:
         dirname = self.db_export_path
     filename = path(dirname) / filename
     dbfile = filename.open("w")
     self.dbelement.writexml(dbfile, indent="\t", newl="\n", addindent="\t")
     dbfile.close()

 def _bootstrap_with_tarball(self, suite):
     self.check_target_exists()
     suite_path = path(self.defenv.get('installer', 'suite_storage'))
     arch = get_architecture()
     filename = '%s-%s.tar.gz' % (suite, arch)
     basefile = suite_path / filename
     taropts = '-xzf'
     # we normally expect a tar.gz
     # but we'll check for a plain tar also
     if not basefile.exists():
         filename = '%s-%s.tar' % (suite, arch)
         basefile = suite_path / filename
         taropts = '-xf'
     if not basefile.exists():
         # We don't really want to ruin an install
         # by not having a tarball, so we log a warning
         # and proceed with a debootstrap.
         msg = "base tarball not found, reverting to debootstrap"
         self.log.warn(msg)
         self._bootstrap_with_debootstrap(suite)
     else:
         #cmd = 'tar -C %s %s %s' % (self.target, taropts, basefile)
         cmd = ['tar', '-C', str(self.target), taropts, str(basefile)]
         # if cmd returns nonzero, runlog will raise an error
         runlog(cmd)

 def __init__(self, conn=None, cfg=None):
     self.conn = conn
     UmlChroot.__init__(self, cfg=cfg)
     self.options['paella_action'] = 'install'
     paellarc = path(self.cfg['paellarc']).expand()
     self.paellarc = PaellaConfig(files=[paellarc])
     self.options['paellarc'] = paellarc

 def export_db_element(self, dirname=None, filename='database.xml'):
     if dirname is None:
         dirname = self.db_export_path
     filename = path(dirname) / filename
     dbfile = filename.open('w')
     self.dbelement.writexml(dbfile, indent='\t', newl='\n', addindent='\t')                                
     dbfile.close()

 def import_machines(self, machines, dirname):
     dirname = path(dirname)
     current_machine = self.current_machine
     # make a queue for the machines
     machine_queue = [machine for machine in machines]
     # I hope this is correct.  This is an
     # attempt to keep this function from
     # running in an infinite loop.
     num_machines = len(machine_queue)
     max_loops = (num_machines * (num_machines +1) ) / 2
     count = 0
     while machine_queue:
         machine = machine_queue.pop(0)
         machine_dir = dirname / machine
         try:
             self.import_machine(machine_dir)
         except UnbornError:
             print "The parent of machine %s hasn't been imported yet." % machine
             machine_queue.append(machine)
         count +=1
         if count > max_loops:
             msg = "We appear to be in an infinite loop.\n"
             msg += "It's likely that there are unmet dependencies"
             msg += " in your list of machines."
             raise RuntimeError , msg
     if current_machine is not None:
         self.set_machine(current_machine)

 def __init__(self, parent, logfile, name='LogBrowser'):
     BaseLogBrowser.__init__(self, parent, name=name)
     self.logfilename = path(logfile)
     if not self.logfilename.exists():
         file(self.logfilename, 'w').close()
     self.logfile_size = 0
     self.setVScrollBarMode(self.AlwaysOff)