rem
stringlengths 0
322k
| add
stringlengths 0
2.05M
| context
stringlengths 8
228k
|
|---|---|---|
cache = self.cmd.run("equery -q list")[1]
|
ret, cache = self.cmd.run("equery -q list") if ret == 2: cache = self.cmd.run("equery -q list '*'")[1]
|
def RefreshPackages(self): '''Refresh memory hashes of packages''' cache = self.cmd.run("equery -q list")[1] pattern = re.compile('(.*)-(\d.*)') self.installed = {} for pkg in cache: if pattern.match(pkg): name = pattern.match(pkg).group(1) version = pattern.match(pkg).group(2) self.installed[name] = version else: self.logger.info("Failed to parse pkg name %s" % pkg)
|
if arch not in metadata.groups + ['global']:
|
if arch not in metadata.groups + set(['global']):
|
def get_vpkgs(self, metadata): rv = Source.get_vpkgs(self, metadata) for arch, fmdata in self.filemap.iteritems(): if arch not in metadata.groups + ['global']: continue for filename, pkgs in fmdata.iteritems(): rv[filename] = pkgs return rv
|
ypname = pkgname
|
d = {} d['name'] = pkgname
|
def build_yname(pkgname, inst): """Build yum appropriate package name.""" ypname = pkgname if inst.get('version') != 'any': ypname += '-' if inst.get('epoch', False): ypname += "%s:" % inst.get('epoch') if inst.get('version', False) and inst.get('version') != 'any': ypname += "%s" % (inst.get('version')) if inst.get('release', False) and inst.get('release') != 'any': ypname += "-%s" % (inst.get('release')) if inst.get('arch', False) and inst.get('arch') != 'any': ypname += ".%s" % (inst.get('arch')) return ypname
|
ypname += '-'
|
d['version'] = inst.get('version')
|
def build_yname(pkgname, inst): """Build yum appropriate package name.""" ypname = pkgname if inst.get('version') != 'any': ypname += '-' if inst.get('epoch', False): ypname += "%s:" % inst.get('epoch') if inst.get('version', False) and inst.get('version') != 'any': ypname += "%s" % (inst.get('version')) if inst.get('release', False) and inst.get('release') != 'any': ypname += "-%s" % (inst.get('release')) if inst.get('arch', False) and inst.get('arch') != 'any': ypname += ".%s" % (inst.get('arch')) return ypname
|
ypname += "%s:" % inst.get('epoch') if inst.get('version', False) and inst.get('version') != 'any': ypname += "%s" % (inst.get('version'))
|
d['epoch'] = inst.get('epoch')
|
def build_yname(pkgname, inst): """Build yum appropriate package name.""" ypname = pkgname if inst.get('version') != 'any': ypname += '-' if inst.get('epoch', False): ypname += "%s:" % inst.get('epoch') if inst.get('version', False) and inst.get('version') != 'any': ypname += "%s" % (inst.get('version')) if inst.get('release', False) and inst.get('release') != 'any': ypname += "-%s" % (inst.get('release')) if inst.get('arch', False) and inst.get('arch') != 'any': ypname += ".%s" % (inst.get('arch')) return ypname
|
ypname += "-%s" % (inst.get('release'))
|
d['release'] = inst.get('release')
|
def build_yname(pkgname, inst): """Build yum appropriate package name.""" ypname = pkgname if inst.get('version') != 'any': ypname += '-' if inst.get('epoch', False): ypname += "%s:" % inst.get('epoch') if inst.get('version', False) and inst.get('version') != 'any': ypname += "%s" % (inst.get('version')) if inst.get('release', False) and inst.get('release') != 'any': ypname += "-%s" % (inst.get('release')) if inst.get('arch', False) and inst.get('arch') != 'any': ypname += ".%s" % (inst.get('arch')) return ypname
|
ypname += ".%s" % (inst.get('arch')) return ypname
|
d['arch'] = inst.get('arch') return d
|
def build_yname(pkgname, inst): """Build yum appropriate package name.""" ypname = pkgname if inst.get('version') != 'any': ypname += '-' if inst.get('epoch', False): ypname += "%s:" % inst.get('epoch') if inst.get('version', False) and inst.get('version') != 'any': ypname += "%s" % (inst.get('version')) if inst.get('release', False) and inst.get('release') != 'any': ypname += "-%s" % (inst.get('release')) if inst.get('arch', False) and inst.get('arch') != 'any': ypname += ".%s" % (inst.get('arch')) return ypname
|
self.logger.info("Installing GPG keys.")
|
def Install(self, packages, states): """ Try and fix everything that RPMng.VerifyPackages() found wrong for each Package Entry. This can result in individual RPMs being installed (for the first time), deleted, downgraded or upgraded.
|
|
key_arg = os.path.join(self.instance_status[inst].get('pkg').get('uri'), \
|
key_file = os.path.join(self.instance_status[inst].get('pkg').get('uri'), \
|
def Install(self, packages, states): """ Try and fix everything that RPMng.VerifyPackages() found wrong for each Package Entry. This can result in individual RPMs being installed (for the first time), deleted, downgraded or upgraded.
|
cmdrc, output = self.cmd.run("rpm --import %s" % key_arg) if cmdrc != 0: self.logger.debug("Unable to install %s-%s" % \ (self.instance_status[inst].get('pkg').get('name'), \ self.str_evra(inst))) else: self.logger.debug("Installed %s-%s-%s" % \ (self.instance_status[inst].get('pkg').get('name'), \ inst.get('version'), inst.get('release')))
|
self._installGPGKey(inst, key_file)
|
def Install(self, packages, states): """ Try and fix everything that RPMng.VerifyPackages() found wrong for each Package Entry. This can result in individual RPMs being installed (for the first time), deleted, downgraded or upgraded.
|
if YAD: pkgtool = "/usr/bin/yum -d0 -y install %s" else: pkgtool = "/usr/bin/yum -d0 install %s" install_args = []
|
def Install(self, packages, states): """ Try and fix everything that RPMng.VerifyPackages() found wrong for each Package Entry. This can result in individual RPMs being installed (for the first time), deleted, downgraded or upgraded.
|
|
install_args.append(build_yname(pkg_arg, inst)) cmdrc, output = self.cmd.run(pkgtool % " ".join(install_args)) if cmdrc == 0: self.logger.info("Single Pass for Install Succeeded") self.RefreshPackages() else: self.logger.error("Single Pass Install of Packages Failed") installed_instances = [] for inst in install_pkgs: pkg_arg = build_yname(self.instance_status[inst].get('pkg').get('name'), inst) cmdrc, output = self.cmd.run(pkgtool % pkg_arg) if cmdrc == 0: installed_instances.append(inst) else: self.logger.debug("%s %s would not install." % \ (self.instance_status[inst].get('pkg').get('name'), \ self.str_evra(inst))) self.RefreshPackages()
|
self.yb.install(**build_yname(pkg_arg, inst))
|
def Install(self, packages, states): """ Try and fix everything that RPMng.VerifyPackages() found wrong for each Package Entry. This can result in individual RPMs being installed (for the first time), deleted, downgraded or upgraded.
|
if YAD: pkgtool = "/usr/bin/yum -d0 -y update %s" else: pkgtool = "/usr/bin/yum -d0 update %s" upgrade_args = []
|
def Install(self, packages, states): """ Try and fix everything that RPMng.VerifyPackages() found wrong for each Package Entry. This can result in individual RPMs being installed (for the first time), deleted, downgraded or upgraded.
|
|
pkg_arg = build_yname(self.instance_status[inst].get('pkg').get('name'), inst) upgrade_args.append(pkg_arg) cmdrc, output = self.cmd.run(pkgtool % " ".join(upgrade_args)) if cmdrc == 0: self.logger.info("Single Pass for Install Succeeded") self.RefreshPackages() else: self.logger.error("Single Pass Install of Packages Failed") installed_instances = [] for inst in upgrade_pkgs: pkg_arg = build_yname(self.instance_status[inst].get('pkg').get('name'), inst) cmdrc, output = self.cmd.run(pkgtool % pkg_arg) if cmdrc == 0: installed_instances.append(inst) else: self.logger.debug("%s %s would not install." % \ (self.instance_status[inst].get('pkg').get('name'), \ self.str_evra(inst))) self.RefreshPackages()
|
pkg_arg = self.instance_status[inst].get('pkg').get('name') self.yb.update(**build_yname(pkg_arg, inst)) self._runYumTransaction()
|
def Install(self, packages, states): """ Try and fix everything that RPMng.VerifyPackages() found wrong for each Package Entry. This can result in individual RPMs being installed (for the first time), deleted, downgraded or upgraded.
|
if YAD: pkgtool = "/usr/bin/yum -d0 -y erase %s" else: pkgtool = "/usr/bin/yum -d0 erase %s"
|
def RemovePackages(self, packages): """ Remove specified entries.
|
|
pkg_arg = pkg.get('name') + '-' if inst.get('epoch', False): pkg_arg = pkg_arg + inst.get('epoch') + ':' pkg_arg = pkg_arg + inst.get('version') + '-' + inst.get('release') if inst.get('arch', False): pkg_arg = pkg_arg + '.' + inst.get('arch') erase_args.append(pkg_arg)
|
self.yb.remove(**nevra) self.modified.append(pkg)
|
def RemovePackages(self, packages): """ Remove specified entries.
|
pkgspec = { 'name':pkg.get('name'), 'version':inst.get('version'), 'release':inst.get('release')} self.logger.info("WARNING: gpg-pubkey package not in configuration %s %s"\ % (pkgspec.get('name'), self.str_evra(pkgspec))) self.logger.info(" This package will be deleted in a future version of the RPMng driver.") cmdrc, output = self.cmd.run(pkgtool % " ".join(erase_args)) if cmdrc == 0: self.modified += packages for pkg in erase_args: self.logger.info("Deleted %s" % (pkg)) else: self.logger.info("Bulk erase failed with errors:") self.logger.debug("Erase results = %s" % output) self.logger.info("Attempting individual erase for each package.") for pkg in packages: pkg_modified = False for inst in pkg: if pkg.get('name') != 'gpg-pubkey': pkg_arg = pkg.get('name') + '-' if inst.attrib.has_key('epoch'): pkg_arg = pkg_arg + inst.get('epoch') + ':' pkg_arg = pkg_arg + inst.get('version') + '-' + inst.get('release') if 'arch' in inst.attrib: pkg_arg = pkg_arg + '.' + inst.get('arch') else: self.logger.info("WARNING: gpg-pubkey package not in configuration %s %s"\ % (pkg.get('name'), self.str_evra(pkg))) self.logger.info(" This package will be deleted in a future version of the RPMng driver.") continue cmdrc, output = self.cmd.run(self.pkgtool % pkg_arg) if cmdrc == 0: pkg_modified = True self.logger.info("Deleted %s" % pkg_arg) else: self.logger.error("unable to delete %s" % pkg_arg) self.logger.debug("Failure = %s" % output) if pkg_modified == True: self.modified.append(pkg) self.RefreshPackages()
|
self.logger.info("WARNING: gpg-pubkey package not in configuration %s %s-%s"\ % (nevra['name'], nevra['version'], nevra['release'])) self.logger.info(" This package will be deleted in a future version of the YUMng driver.") self._runYumTransaction()
|
def RemovePackages(self, packages): """ Remove specified entries.
|
request.shutdown(2)
|
def close_request(self, request): request.unwrap() request.shutdown(2) request.close()
|
|
if arch not in metadata.groups + set(['global']):
|
if arch not in metadata.groups and arch != 'global':
|
def get_vpkgs(self, metadata): rv = Source.get_vpkgs(self, metadata) for arch, fmdata in self.filemap.iteritems(): if arch not in metadata.groups + set(['global']): continue for filename, pkgs in fmdata.iteritems(): rv[filename] = pkgs return rv
|
output = self.cmd.run('/usr/sbin/service %s status' % \ entry.get('name'))[1][0]
|
try: output = self.cmd.run('/usr/sbin/service %s status' % \ entry.get('name'))[1][0] except IndexError: self.logger.error("Service %s not an Upstart service" % \ entry.get('name')) return False
|
def VerifyService(self, entry, _): '''Verify Service status for entry
|
__req__ = {'Package': ['name', 'version'],
|
__req__ = {'Package': ['name'],
|
def __init__(self, logger): self.logger = logger
|
__new_req__ = {'Package': ['name'], 'Instance': ['version', 'release', 'arch']} __new_ireq__ = {'Package': ['name'], \ 'Instance': []} __gpg_req__ = {'Package': ['name', 'version']} __gpg_ireq__ = {'Package': ['name', 'version']} __new_gpg_req__ = {'Package': ['name'], 'Instance': ['version', 'release']} __new_gpg_ireq__ = {'Package': ['name'], 'Instance': ['version', 'release']}
|
def __init__(self, logger): self.logger = logger
|
|
if entry.get('mode', 'default') == 'supervised': pstatus, pout = self.cmd.run('/usr/sbin/service %s status' % \ entry.get('name')) if pstatus: self.cmd.run('/usr/sbin/service %s start' % (entry.get('name'))) return True
|
if entry.get('status') == 'on': pstatus = self.cmd.run(self.get_svc_command(entry, 'start'))[0] elif entry.get('status') == 'off': pstatus = self.cmd.run(self.get_svc_command(entry, 'stop'))[0] return not pstatus
|
def InstallService(self, entry): """Install Service for entry.""" if entry.get('mode', 'default') == 'supervised': pstatus, pout = self.cmd.run('/usr/sbin/service %s status' % \ entry.get('name')) if pstatus: self.cmd.run('/usr/sbin/service %s start' % (entry.get('name'))) return True
|
opts, args = getopt(argv[1:], "hvudc:s:", ["help", "verbose", "updates" ,
|
opts, args = getopt(argv[1:], "hvudc:s:C", ["help", "verbose", "updates" ,
|
def load_stats(cdata, sdata, vlevel, quick=False, location=''): cursor = connection.cursor() clients = {} cursor.execute("SELECT name, id from reports_client;") [clients.__setitem__(a, b) for a, b in cursor.fetchall()] for node in sdata.findall('Node'): name = node.get('name') if not name in clients: cursor.execute(\ "INSERT INTO reports_client VALUES (NULL, %s, %s, NULL, NULL)", [datetime.now(), name]) clients[name] = cursor.lastrowid if vlevel > 0: print("Client %s added to db" % name) else: if vlevel > 0: print("Client %s already exists in db" % name) pingability = {} [pingability.__setitem__(n.get('name'), n.get('pingable', default='N')) \ for n in cdata.findall('Client')] for node in sdata.findall('Node'): name = node.get('name') c_inst = Client.objects.filter(id=clients[name])[0] try: pingability[name] except KeyError: pingability[name] = 'N' for statistics in node.findall('Statistics'): t = strptime(statistics.get('time')) # Maybe replace with django.core.db typecasts typecast_timestamp()? # import from django.backends util timestamp = datetime(t[0], t[1], t[2], t[3], t[4], t[5]) ilist = Interaction.objects.filter(client=c_inst, timestamp=timestamp) if ilist: current_interaction = ilist[0] if vlevel > 0: print("Interaction for %s at %s with id %s already exists"%(clients[name], datetime(t[0],t[1],t[2],t[3],t[4],t[5]),current_interaction.id)) continue else: newint = Interaction(client=c_inst, timestamp = timestamp, state = statistics.get('state', default="unknown"), repo_rev_code = statistics.get('revision',default="unknown"), client_version = statistics.get('client_version',default="unknown"), goodcount = statistics.get('good',default="0"), totalcount = statistics.get('total',default="0"), server = location) newint.save() current_interaction = newint if vlevel > 0: print("Interaction for %s at %s with id %s INSERTED in to db"%(clients[name], timestamp, current_interaction.id)) pattern = [('Bad/*', TYPE_CHOICES[0]), ('Extra/*', TYPE_CHOICES[2]), ('Modified/*', TYPE_CHOICES[1]),] for (xpath, type) in pattern: for x in statistics.findall(xpath): kargs = build_reason_kwargs(x) if not quick: rls = Reason.objects.filter(**kargs) else: rls = [] if rls: rr = rls[0] if vlevel > 0: print "Reason exists: %s"% (rr.id) else: rr = Reason(**kargs) rr.save() if vlevel > 0: print "Created reason: %s" % rr.id links = Entries.objects.filter(name=x.get('name'), kind=x.tag) if links: entry = links[0] else: entry = Entries(name=x.get('name'), kind=x.tag) entry.save() interaction = Entries_interactions(entry=entry, reason=rr, interaction=current_interaction, type=type[0]) interaction.save() if vlevel > 0: print "%s interaction created with reason id %s and entry %s" % (xpath, rr.id, entry.id) for times in statistics.findall('OpStamps'): for metric, value in times.items(): if not quick: mmatch = Performance.objects.filter(metric=metric, value=value) else: mmatch = [] if mmatch: item_id = mmatch[0].id else: mperf = Performance(metric=metric, value=value) mperf.save() item_id = mperf.id try: cursor.execute("INSERT INTO reports_performance_interaction VALUES (NULL, %s, %s);", [item_id, current_interaction.id]) except: pass if vlevel > 1: print("----------------INTERACTIONS SYNCED----------------") cursor.execute("select reports_interaction.id, x.client_id from (select client_id, MAX(timestamp) as timer from reports_interaction Group BY client_id) x, reports_interaction where reports_interaction.client_id = x.client_id AND reports_interaction.timestamp = x.timer") for row in cursor.fetchall(): cursor.execute("UPDATE reports_client SET current_interaction_id = %s where reports_client.id = %s", [row[0],row[1]]) if vlevel > 1: print("------------LATEST INTERACTION SET----------------") for key in pingability.keys(): if key not in clients: #print "Ping Save Problem with client %s" % name continue cmatch = Client.objects.filter(id=clients[key])[0] pmatch = Ping.objects.filter(client=cmatch).order_by('-endtime') if pmatch: if pmatch[0].status == pingability[key]: pmatch[0].endtime = datetime.now() pmatch[0].save() else: newp = Ping(client=cmatch, status=pingability[key], starttime=datetime.now(), endtime=datetime.now()) newp.save() else: newp = Ping(client=cmatch, status=pingability[key], starttime=datetime.now(), endtime=datetime.now()) newp.save() if vlevel > 1: print "---------------PINGDATA SYNCED---------------------" connection._commit() #Clients are consistent
|
self.__important__ = [entry.get('name') for struct in config for entry in struct \ if entry.tag in ['Path', 'ConfigFile'] and \ entry.get('name').startswith('/etc/yum.d') or entry.get('name') == '/etc/yum.conf']
|
self.__important__ = [entry.get('name') for struct in config \ for entry in struct \ if entry.tag in ['Path', 'ConfigFile'] and \ entry.get('name').startswith('/etc/yum.d') \ or entry.get('name') == '/etc/yum.conf']
|
def __init__(self, logger, setup, config): Bcfg2.Client.Tools.RPMng.RPMng.__init__(self, logger, setup, config) self.__important__ = [entry.get('name') for struct in config for entry in struct \ if entry.tag in ['Path', 'ConfigFile'] and \ entry.get('name').startswith('/etc/yum.d') or entry.get('name') == '/etc/yum.conf'] self.yum_avail = dict() self.yum_installed = dict() self.yb = yum.YumBase() self.yb.doConfigSetup() self.yb.doTsSetup() self.yb.doRpmDBSetup() yup = self.yb.doPackageLists(pkgnarrow='updates') if hasattr(self.yb.rpmdb, 'pkglist'): yinst = self.yb.rpmdb.pkglist else: yinst = self.yb.rpmdb.getPkgList() for dest, source in [(self.yum_avail, yup.updates), (self.yum_installed, yinst)]: for pkg in source: if dest is self.yum_avail: pname = pkg.name data = [(pkg.arch, (pkg.epoch, pkg.version, pkg.release))] else: pname = pkg[0] data = [(pkg[1], (pkg[2], pkg[3], pkg[4]))] if pname in dest: dest[pname].update(data) else: dest[pname] = dict(data)
|
view, args, kw = resolve(request.path)
|
view, args, kw = resolve(request.META['PATH_INFO'])
|
def _handle_timeview(request, **kwargs): """Send any posts back.""" if request.method == 'POST': cal_date = request.POST['cal_date'] try: fmt = "%Y/%m/%d" if cal_date.find(' ') > -1: fmt += " %H:%M" timestamp = datetime(*strptime(cal_date, fmt)[0:6]) view, args, kw = resolve(request.path) kw['year'] = "%0.4d" % timestamp.year kw['month'] = "%02.d" % timestamp.month kw['day'] = "%02.d" % timestamp.day if cal_date.find(' ') > -1: kw['hour'] = timestamp.hour kw['minute'] = timestamp.minute return HttpResponseRedirect(reverse(view, args=args, kwargs=kw)) except KeyError: pass except: pass # FIXME - Handle this """Extract timestamp from args.""" timestamp = None try: timestamp = datetime(int(kwargs.pop('year')), int(kwargs.pop('month')), int(kwargs.pop('day')), int(kwargs.pop('hour', 0)), int(kwargs.pop('minute', 0)), 0) kwargs['timestamp'] = timestamp except KeyError: pass except: raise return fn(request, **kwargs)
|
self.session_cache[address] = (time.time(), user)
|
self.session_cache[address] = (time.time(), client)
|
def AuthenticateConnection(self, cert, user, password, address): '''This function checks auth creds''' if cert: id_method = 'cert' certinfo = dict([x[0] for x in cert['subject']]) # look at cert.cN client = certinfo['commonName'] self.debug_log("Got cN %s; using as client name" % client) auth_type = self.auth.get(client, 'cert+password') elif user == 'root': id_method = 'address' try: client = self.resolve_client(address) except MetadataConsistencyError: self.logger.error("Client %s failed to resolve; metadata problem" % (address[0])) return False else: id_method = 'uuid' # user maps to client if user not in self.uuid: client = user self.uuid[user] = user else: client = self.uuid[user]
|
cursor.close() connection.close()
|
try: cursor.close() connection.close() except: pass
|
def dosync(): """Function to do the syncronisation for the models""" # try to detect if it's a fresh new database try: cursor = connection.cursor() # If this table goes missing then don't forget to change it to the new one cursor.execute("Select * from reports_client") # if we get here with no error then the database has existing tables fresh = False except: logger.debug("there was an error while detecting the freshness of the database") #we should get here if the database is new fresh = True # ensure database connection are close, so that the management can do it's job right cursor.close() connection.close() # Do the syncdb according to the django version if "call_command" in dir(django.core.management): # this is available since django 1.0 alpha. # not yet tested for full functionnality django.core.management.call_command("syncdb", interactive=False, verbosity=0) if fresh: django.core.management.call_command("loaddata", 'initial_version.xml', verbosity=0) elif "syncdb" in dir(django.core.management): # this exist only for django 0.96.* django.core.management.syncdb(interactive=False, verbosity=0) if fresh: logger.debug("loading the initial_version fixtures") django.core.management.load_data(fixture_labels=['initial_version'], verbosity=0) else: logger.warning("Don't forget to run syncdb")
|
if event.filename[0] == '/' or event.filename.startswith('CAs'):
|
if event.filename[0] == '/':
|
def HandleEvent(self, event=None): """ Updates which files this plugin handles based upon filesystem events. Allows configuration items to be added/removed without server restarts. """ action = event.code2str() if event.filename[0] == '/' or event.filename.startswith('CAs'): return epath = "".join([self.data, self.handles[event.requestID], event.filename]) if posixpath.isdir(epath): ident = self.handles[event.requestID] + event.filename else: ident = self.handles[event.requestID][:-1] fname = "".join([ident, '/', event.filename]) if event.filename.endswith('.xml'): if action in ['exists', 'created', 'changed']: if event.filename.endswith('key.xml'): key_spec = dict(lxml.etree.parse(epath).find('Key').items()) self.key_specs[ident] = { 'bits': key_spec.get('bits', 2048), 'type': key_spec.get('type', 'rsa') } self.Entries['Path'][ident] = self.get_key elif event.filename.endswith('cert.xml'): cert_spec = dict(lxml.etree.parse(epath).find('Cert').items()) ca = cert_spec.get('ca', 'default') self.cert_specs[ident] = { 'ca': ca, 'format': cert_spec.get('format', 'pem'), 'key': cert_spec.get('key'), 'days': cert_spec.get('days', 365), 'C': cert_spec.get('c'), 'L': cert_spec.get('l'), 'ST': cert_spec.get('st'), 'OU': cert_spec.get('ou'), 'O': cert_spec.get('o'), 'emailAddress': cert_spec.get('emailaddress') } cp = ConfigParser() cp.read(self.core.cfile) self.ca_passphrases[ca] = cp.get('sslca', ca+'_passphrase') self.Entries['Path'][ident] = self.get_cert if action == 'deleted': if ident in self.Entries['Path']: del self.Entries['Path'][ident] else: if action in ['exists', 'created']: if posixpath.isdir(epath): self.AddDirectoryMonitor(epath[len(self.data):]) if ident not in self.entries and posixpath.isfile(epath): self.entries[fname] = self.__child__(epath) self.entries[fname].HandleEvent(event) if action == 'changed': self.entries[fname].HandleEvent(event) elif action == 'deleted': if fname in self.entries: del self.entries[fname] else: self.entries[fname].HandleEvent(event)
|
self.ca_passphrases[ca] = cp.get('sslca', ca+'_passphrase')
|
self.CAs[ca] = dict(cp.items('sslca_'+ca))
|
def HandleEvent(self, event=None): """ Updates which files this plugin handles based upon filesystem events. Allows configuration items to be added/removed without server restarts. """ action = event.code2str() if event.filename[0] == '/' or event.filename.startswith('CAs'): return epath = "".join([self.data, self.handles[event.requestID], event.filename]) if posixpath.isdir(epath): ident = self.handles[event.requestID] + event.filename else: ident = self.handles[event.requestID][:-1] fname = "".join([ident, '/', event.filename]) if event.filename.endswith('.xml'): if action in ['exists', 'created', 'changed']: if event.filename.endswith('key.xml'): key_spec = dict(lxml.etree.parse(epath).find('Key').items()) self.key_specs[ident] = { 'bits': key_spec.get('bits', 2048), 'type': key_spec.get('type', 'rsa') } self.Entries['Path'][ident] = self.get_key elif event.filename.endswith('cert.xml'): cert_spec = dict(lxml.etree.parse(epath).find('Cert').items()) ca = cert_spec.get('ca', 'default') self.cert_specs[ident] = { 'ca': ca, 'format': cert_spec.get('format', 'pem'), 'key': cert_spec.get('key'), 'days': cert_spec.get('days', 365), 'C': cert_spec.get('c'), 'L': cert_spec.get('l'), 'ST': cert_spec.get('st'), 'OU': cert_spec.get('ou'), 'O': cert_spec.get('o'), 'emailAddress': cert_spec.get('emailaddress') } cp = ConfigParser() cp.read(self.core.cfile) self.ca_passphrases[ca] = cp.get('sslca', ca+'_passphrase') self.Entries['Path'][ident] = self.get_cert if action == 'deleted': if ident in self.Entries['Path']: del self.Entries['Path'][ident] else: if action in ['exists', 'created']: if posixpath.isdir(epath): self.AddDirectoryMonitor(epath[len(self.data):]) if ident not in self.entries and posixpath.isfile(epath): self.entries[fname] = self.__child__(epath) self.entries[fname].HandleEvent(event) if action == 'changed': self.entries[fname].HandleEvent(event) elif action == 'deleted': if fname in self.entries: del self.entries[fname] else: self.entries[fname].HandleEvent(event)
|
ca_config = "".join([self.data, '/CAs/', ca, '/', 'openssl.cnf'])
|
ca_config = self.CAs[ca]['config']
|
def build_cert(self, entry, metadata): """ creates a new certificate according to the specification """ req_config = self.build_req_config(entry, metadata) req = self.build_request(req_config, entry) ca = self.cert_specs[entry.get('name')]['ca'] ca_config = "".join([self.data, '/CAs/', ca, '/', 'openssl.cnf']) days = self.cert_specs[entry.get('name')]['days'] passphrase = self.ca_passphrases[ca] cmd = "openssl ca -config %s -in %s -days %s -batch -passin pass:%s" % (ca_config, req, days, passphrase) cert = Popen(cmd, shell=True, stdout=PIPE).stdout.read() try: os.unlink(req_config) os.unlink(req) except OSError: self.logger.error("Failed to unlink temporary files") return cert
|
passphrase = self.ca_passphrases[ca] cmd = "openssl ca -config %s -in %s -days %s -batch -passin pass:%s" % (ca_config, req, days, passphrase)
|
passphrase = self.CAs[ca].get('passphrase') if passphrase: cmd = "openssl ca -config %s -in %s -days %s -batch -passin pass:%s" % (ca_config, req, days, passphrase) else: cmd = "openssl ca -config %s -in %s -days %s -batch" % (ca_config, req, days)
|
def build_cert(self, entry, metadata): """ creates a new certificate according to the specification """ req_config = self.build_req_config(entry, metadata) req = self.build_request(req_config, entry) ca = self.cert_specs[entry.get('name')]['ca'] ca_config = "".join([self.data, '/CAs/', ca, '/', 'openssl.cnf']) days = self.cert_specs[entry.get('name')]['days'] passphrase = self.ca_passphrases[ca] cmd = "openssl ca -config %s -in %s -days %s -batch -passin pass:%s" % (ca_config, req, days, passphrase) cert = Popen(cmd, shell=True, stdout=PIPE).stdout.read() try: os.unlink(req_config) os.unlink(req) except OSError: self.logger.error("Failed to unlink temporary files") return cert
|
__req__ = {'Package': ['name', 'version']}
|
__req__ = {'Package': ['name', 'version'], 'Path': ['type']}
|
def __init__(self, logger): self.logger = logger
|
if entry.get('type') == 'ignore' ]
|
if entry.tag == 'Path' and \ entry.get('type') == 'ignore' ]
|
def __init__(self, logger, setup, config): self.yb = yum.YumBase() Bcfg2.Client.Tools.PkgTool.__init__(self, logger, setup, config) self.ignores = [ entry.get('name') for struct in config \ for entry in struct \ if entry.get('type') == 'ignore' ] self.instance_status = {} self.extra_instances = [] self.modlists = {} self._loadConfig() self.__important__ = self.__important__ + \ [entry.get('name') for struct in config \ for entry in struct \ if entry.tag in ['Path', 'ConfigFile'] and \ (entry.get('name').startswith('/etc/yum.d') \ or entry.get('name').startswith('/etc/yum.repos.d')) \ or entry.get('name') == '/etc/yum.conf'] self.yum_avail = dict() self.yum_installed = dict() try: self.yb.doConfigSetup() self.yb.doTsSetup() self.yb.doRpmDBSetup() except yum.Errors.RepoError, e: self.logger.error("YUMng Repository error: %s" % e) raise Bcfg2.Client.Tools.toolInstantiationError except yum.Errors.YumBaseError, e: self.logger.error("YUMng error: %s" % e) raise Bcfg2.Client.Tools.toolInstantiationError
|
self.__important__ = [entry.get('name') for struct in config for entry in struct \
|
self.__important__ = [entry.get('name') \ for struct in config for entry in struct \
|
def __init__(self, logger, setup, config): self.__important__ = [entry.get('name') for struct in config for entry in struct \ if entry.tag == 'Path' and \ entry.get('important') in ['true', 'True']] self.setup = setup self.logger = logger if not hasattr(self, '__ireq__'): self.__ireq__ = self.__req__ self.config = config self.cmd = executor(logger) self.modified = [] self.extra = [] self.handled = [entry for struct in self.config for entry in struct \ if self.handlesEntry(entry)] for filename in self.__execs__: try: mode = stat.S_IMODE(os.stat(filename)[stat.ST_MODE]) if mode & stat.S_IEXEC != stat.S_IEXEC: self.logger.debug("%s: %s not executable" % \ (self.name, filename)) raise toolInstantiationError except OSError: raise toolInstantiationError except: self.logger.debug("%s failed" % filename, exc_info=1) raise toolInstantiationError
|
self.logger.debug('Setting state to true for pkg %s' % (entry.get('name')))
|
self.logger.debug('Setting state to true for pkg %s' % \ (entry.get('name')))
|
def Install(self, packages, states): """ Run a one-pass install, followed by single pkg installs in case of failure. """ self.logger.info("Trying single pass package install for pkgtype %s" % \ self.pkgtype)
|
self.logger.info("Forcing state to true for pkg %s" % (pkg.get('name')))
|
self.logger.info("Forcing state to true for pkg %s" % \ (pkg.get('name')))
|
def Install(self, packages, states): """ Run a one-pass install, followed by single pkg installs in case of failure. """ self.logger.info("Trying single pass package install for pkgtype %s" % \ self.pkgtype)
|
self.logger.error("Failed to install package %s" % (pkg.get('name')))
|
self.logger.error("Failed to install package %s" % \ (pkg.get('name')))
|
def Install(self, packages, states): """ Run a one-pass install, followed by single pkg installs in case of failure. """ self.logger.info("Trying single pass package install for pkgtype %s" % \ self.pkgtype)
|
status = (rc == 0)
|
return (rc == 0)
|
def InstallService(self, entry): ''' Install Service entry In supervised mode we also take care it's (not) running ''' self.logger.info('Installing Service %s' % entry.get('name')) if entry.get('status') == 'on': # make sure it's enabled cmd = '/sbin/rc-update add %s default' rc = self.cmd.run(cmd % entry.get('name'))[0] status = (rc == 0)
|
return status
|
return False
|
def InstallService(self, entry): ''' Install Service entry In supervised mode we also take care it's (not) running ''' self.logger.info('Installing Service %s' % entry.get('name')) if entry.get('status') == 'on': # make sure it's enabled cmd = '/sbin/rc-update add %s default' rc = self.cmd.run(cmd % entry.get('name'))[0] status = (rc == 0)
|
elif words[0] == 'Depends':
|
elif words[0] in ['Depends', 'Pre-Depends']:
|
def read_files(self): bdeps = dict() bprov = dict() for fname in self.files: barch = [x for x in fname.split('@') if x.startswith('binary-')][0][7:] if barch not in bdeps: bdeps[barch] = dict() bprov[barch] = dict() try: reader = gzip.GzipFile(fname) except: print("Failed to read file %s" % fname) raise for line in reader.readlines(): words = line.strip().split(':', 1) if words[0] == 'Package': pkgname = words[1].strip().rstrip() self.pkgnames.add(pkgname) elif words[0] == 'Depends': bdeps[barch][pkgname] = [] vindex = 0 for dep in words[1].split(','): if '|' in dep: cdeps = [re.sub('\(.*\)', '', cdep) for cdep in dep.split('|')] dyn_dname = "choice-%s-%s-%s" % (pkgname, barch, vindex) vindex += 1 bdeps[barch][pkgname].append(dyn_dname) bprov[barch][dyn_dname] = set(cdeps) else: raw_dep = re.sub('\(.*\)', '', dep) raw_dep = raw_dep.rstrip().strip() bdeps[barch][pkgname].append(raw_dep) elif words[0] == 'Provides': for pkg in words[1].split(','): dname = pkg.rstrip().strip() if dname not in bprov[barch]: bprov[barch][dname] = set() bprov[barch][dname].add(pkgname)
|
self.gpg_keyids = self.getinstalledgpg()
|
def queuePkg(pkg, inst, queue): if pkg.get('name') == 'gpg-pubkey': gpg_keys.append(inst) else: queue.append(inst)
|
|
elif "is not installed" in item:
|
elif "is not installed" in item or "missing file" in item:
|
def VerifyDebsums(self, entry, modlist): output = self.cmd.run("/usr/bin/debsums -as %s" % entry.get('name'))[1] if len(output) == 1 and "no md5sums for" in output[0]: self.logger.info("Package %s has no md5sums. Cannot verify" % \ entry.get('name')) entry.set('qtext', "Reinstall Package %s-%s to setup md5sums? (y/N) " \ % (entry.get('name'), entry.get('version'))) return False files = [] for item in output: if "checksum mismatch" in item: files.append(item.split()[-1]) elif "can't open" in item: files.append(item.split()[5]) elif "is not installed" in item: self.logger.error("Package %s is not fully installed" \ % entry.get('name')) else: self.logger.error("Got Unsupported pattern %s from debsums" \ % item) files.append(item) # We check if there is file in the checksum to do if files: # if files are found there we try to be sure our modlist is sane # with erroneous symlinks modlist = [os.path.realpath(filename) for filename in modlist] bad = [filename for filename in files if filename not in modlist] if bad: self.logger.info("Package %s failed validation. Bad files are:" % \ entry.get('name')) self.logger.info(bad) entry.set('qtext', "Reinstall Package %s-%s to fix failing files? (y/N) " % \ (entry.get('name'), entry.get('version'))) return False return True
|
return item in self.packages['global'] or item in self.packages[arch[0]]
|
return (item in self.packages['global'] or item in self.packages[arch[0]]) and \ item not in self.blacklist and \ ((len(self.whitelist) == 0) or item in self.whitelist)
|
def is_package(self, metadata, item): arch = [a for a in self.arches if a in metadata.groups] if not arch: return False return item in self.packages['global'] or item in self.packages[arch[0]]
|
return pkg in self.pkgnames
|
return pkg in self.pkgnames and \ pkg not in self.blacklist and \ (len(self.whitelist) == 0 or pkg in self.whitelist)
|
def is_package(self, _, pkg): return pkg in self.pkgnames
|
blacklisted = set() for source in sources: blacklisted.update(source.blacklist)
|
def complete(self, meta, input_requirements, debug=False): '''Build the transitive closure of all package dependencies
|
|
if current in blacklisted: continue
|
def complete(self, meta, input_requirements, debug=False): '''Build the transitive closure of all package dependencies
|
|
try: deps = source.get_deps(meta, current) break except: continue
|
if source.is_pkg(meta, current): try: deps = source.get_deps(meta, current) break except: continue
|
def complete(self, meta, input_requirements, debug=False): '''Build the transitive closure of all package dependencies
|
try: deps = source.get_deps(meta, pkgname) except: continue for rpkg in deps: if rpkg in pkgnames: redundant.add(rpkg)
|
if source.is_pkg(meta, current): try: deps = source.get_deps(meta, pkgname) except: continue for rpkg in deps: if rpkg in pkgnames: redundant.add(rpkg)
|
def make_non_redundant(self, meta, plname=None, plist=None): '''build a non-redundant version of a list of packages
|
self.installed_action = 'install' self.pkg_checks = 'true' self.pkg_verify = 'true' self.version_fail_action = 'upgrade' self.verify_fail_action = 'reinstall' self.installed_action = CP.get(self.name, "installed_action", self.installed_action) self.pkg_checks = CP.get(self.name, "pkg_checks", self.pkg_checks) self.pkg_verify = CP.get(self.name, "pkg_verify", self.pkg_verify) self.version_fail_action = CP.get(self.name, "version_fail_action", self.version_fail_action) self.verify_fail_action = CP.get(self.name, "verify_fail_action", self.verify_fail_action)
|
truth = ['true', 'yes', '1'] self.pkg_checks = CP.get(self.name, "pkg_checks", "true").lower() \ in truth self.pkg_verify = CP.get(self.name, "pkg_verify", "true").lower() \ in truth self.doInstall = CP.get(self.name, "installed_action", "install").lower() == "install" self.doUpgrade = CP.get(self.name, "version_fail_action", "upgrade").lower() == "upgrade" self.doReinst = CP.get(self.name, "verify_fail_action", "reinstall").lower() == "reinstall"
|
def _loadConfig(self): # Process the YUMng section from the config file. CP = Parser() CP.read(self.setup.get('setup'))
|
self.logger.debug("YUMng: installed_action = %s" \ % self.installed_action) self.logger.debug("YUMng: pkg_checks = %s" % self.pkg_checks) self.logger.debug("YUMng: pkg_verify = %s" % self.pkg_verify) self.logger.debug("YUMng: version_fail_action = %s" \ % self.version_fail_action) self.logger.debug("YUMng: verify_fail_action = %s" \ % self.verify_fail_action) self.logger.debug("YUMng: installOnlyPkgs = %s" \
|
self.logger.debug("YUMng: Install missing: %s" \ % self.doInstall) self.logger.debug("YUMng: pkg_checks: %s" % self.pkg_checks) self.logger.debug("YUMng: pkg_verify: %s" % self.pkg_verify) self.logger.debug("YUMng: Upgrade on version fail: %s" \ % self.doUpgrade) self.logger.debug("YUMng: Reinstall on verify fail: %s" \ % self.doReinst) self.logger.debug("YUMng: installOnlyPkgs: %s" \
|
def _loadConfig(self): # Process the YUMng section from the config file. CP = Parser() CP.read(self.setup.get('setup'))
|
pkg_checks = self.pkg_checks.lower() == 'true' and \
|
pkg_checks = self.pkg_checks and \
|
def VerifyPackage(self, entry, modlist, pinned_version=None): """ Verify Package status for entry. Performs the following: - Checks for the presence of required Package Instances. - Compares the evra 'version' info against self.installed{}. - RPM level package verify (rpm --verify). - Checks for the presence of unrequired package instances.
|
pkg_verify = self.pkg_verify.lower() == 'true' and \
|
pkg_verify = self.pkg_verify and \
|
def VerifyPackage(self, entry, modlist, pinned_version=None): """ Verify Package status for entry. Performs the following: - Checks for the presence of required Package Instances. - Compares the evra 'version' info against self.installed{}. - RPM level package verify (rpm --verify). - Checks for the presence of unrequired package instances.
|
try: vResult = _POs[0].verify(fast=self.setup.get('quick', False)) except TypeError: vResult = _POs[0].verify()
|
vResult = self._verifyHelper(_POs[0])
|
def VerifyPackage(self, entry, modlist, pinned_version=None): """ Verify Package status for entry. Performs the following: - Checks for the presence of required Package Instances. - Compares the evra 'version' info against self.installed{}. - RPM level package verify (rpm --verify). - Checks for the presence of unrequired package instances.
|
Try and fix everything that RPMng.VerifyPackages() found wrong for
|
Try and fix everything that YUMng.VerifyPackages() found wrong for
|
def Install(self, packages, states): """ Try and fix everything that RPMng.VerifyPackages() found wrong for each Package Entry. This can result in individual RPMs being installed (for the first time), deleted, downgraded or upgraded.
|
NOTE: YUM can not reinstall a package that it thinks is already installed.
|
def Install(self, packages, states): """ Try and fix everything that RPMng.VerifyPackages() found wrong for each Package Entry. This can result in individual RPMs being installed (for the first time), deleted, downgraded or upgraded.
|
|
if status.get('installed', False) == False:
|
if not status.get('installed', False) and self.doInstall:
|
def queuePkg(pkg, inst, queue): if pkg.get('name') == 'gpg-pubkey': gpg_keys.append(inst) else: queue.append(inst)
|
elif status.get('version_fail', False) == True:
|
elif status.get('version_fail', False) and self.doUpgrade:
|
def queuePkg(pkg, inst, queue): if pkg.get('name') == 'gpg-pubkey': gpg_keys.append(inst) else: queue.append(inst)
|
elif status.get('verify_fail', False) == True:
|
elif status.get('verify_fail', False) and self.doReinst:
|
def queuePkg(pkg, inst, queue): if pkg.get('name') == 'gpg-pubkey': gpg_keys.append(inst) else: queue.append(inst)
|
msg = "Internal error install/upgrade/reinstall-ing: " self.logger.error("YUMng: %s%s" % \ (msg, pkg.get('name')))
|
pass
|
def queuePkg(pkg, inst, queue): if pkg.get('name') == 'gpg-pubkey': gpg_keys.append(inst) else: queue.append(inst)
|
if output.split(' ')[1].split('/')[1].startswith('running'): entry.set('current_status', 'on') if entry.get('status') == 'off': status = False
|
try: running = output.split(' ')[1].split('/')[1].startswith('running') if running: entry.set('current_status', 'on') if entry.get('status') == 'off': status = False else: status = True
|
def VerifyService(self, entry, _): '''Verify Service status for entry
|
status = True else:
|
entry.set('current_status', 'off') if entry.get('status') == 'on': status = False else: status = True except IndexError:
|
def VerifyService(self, entry, _): '''Verify Service status for entry
|
if entry.get('status') == 'on': status = False else: status = True
|
status = False
|
def VerifyService(self, entry, _): '''Verify Service status for entry
|
'''Unified interface for handling group-specific data (e.g. .G
|
def bind_entry(self, entry, metadata): '''Return the appropriate interpreted template from the set of available templates''' self.bind_info_to_entry(entry, metadata) matching = self.get_matching(metadata)
|
|
gprofiles = [profile for profile in self.profiles if \ self.groups[profile][1].issuperset(groups)] return self.get_client_names_by_profiles(gprofiles)
|
mdata = [self.core.build_metadata(client) for client in self.clients.keys()] return [md.hostname for md in mdata if md.groups.issuperset(groups)]
|
def get_client_names_by_groups(self, groups): gprofiles = [profile for profile in self.profiles if \ self.groups[profile][1].issuperset(groups)] return self.get_client_names_by_profiles(gprofiles)
|
django.core.management.call_command("loaddata", fixture_labels=['initial_version'], verbosity=0)
|
django.core.management.call_command("loaddata", 'initial_version.xml', verbosity=0)
|
def dosync(): """Function to do the syncronisation for the models""" # try to detect if it's a fresh new database try: cursor = connection.cursor() # If this table goes missing then don't forget to change it to the new one cursor.execute("Select * from reports_client") # if we get here with no error then the database has existing tables fresh = False except: logger.debug("there was an error while detecting the freshness of the database") #we should get here if the database is new fresh = True # ensure database connection are close, so that the management can do it's job right cursor.close() connection.close() # Do the syncdb according to the django version if "call_command" in dir(django.core.management): # this is available since django 1.0 alpha. # not yet tested for full functionnality django.core.management.call_command("syncdb", interactive=False, verbosity=0) if fresh: django.core.management.call_command("loaddata", fixture_labels=['initial_version'], verbosity=0) elif "syncdb" in dir(django.core.management): # this exist only for django 0.96.* django.core.management.syncdb(interactive=False, verbosity=0) if fresh: logger.debug("loading the initial_version fixtures") django.core.management.load_data(fixture_labels=['initial_version'], verbosity=0) else: logger.warning("Don't forget to run syncdb")
|
open(fileloc, 'w').write(open(temploc).read()) open(publoc, 'w').write(open("%s.pub" % temploc).read())
|
shutil.copy(temploc, fileloc) shutil.copy("%s.pub" % temploc, publoc)
|
def GenerateHostKeys(self, client): '''Generate new host keys for client''' keylist = [keytmpl % client for keytmpl in self.hostkeys] for hostkey in keylist: if 'ssh_host_rsa_key.H_' == hostkey[:19]: keytype = 'rsa' elif 'ssh_host_dsa_key.H_' == hostkey[:19]: keytype = 'dsa' else: keytype = 'rsa1'
|
bdeps[barch][pkgname] = []
|
def read_files(self): bdeps = dict() bprov = dict() for fname in self.files: barch = [x for x in fname.split('@') if x.startswith('binary-')][0][7:] if barch not in bdeps: bdeps[barch] = dict() bprov[barch] = dict() try: reader = gzip.GzipFile(fname) except: print("Failed to read file %s" % fname) raise for line in reader.readlines(): words = line.strip().split(':', 1) if words[0] == 'Package': pkgname = words[1].strip().rstrip() self.pkgnames.add(pkgname) elif words[0] in ['Depends', 'Pre-Depends']: bdeps[barch][pkgname] = [] vindex = 0 for dep in words[1].split(','): if '|' in dep: cdeps = [re.sub('\(.*\)', '', cdep) for cdep in dep.split('|')] dyn_dname = "choice-%s-%s-%s" % (pkgname, barch, vindex) vindex += 1 bdeps[barch][pkgname].append(dyn_dname) bprov[barch][dyn_dname] = set(cdeps) else: raw_dep = re.sub('\(.*\)', '', dep) raw_dep = raw_dep.rstrip().strip() bdeps[barch][pkgname].append(raw_dep) elif words[0] == 'Provides': for pkg in words[1].split(','): dname = pkg.rstrip().strip() if dname not in bprov[barch]: bprov[barch][dname] = set() bprov[barch][dname].add(pkgname)
|
|
sock.settimeout(90)
|
def get_request(self): (sock, sockinfo) = self.socket.accept() sock.settimeout(90) sslsock = ssl.wrap_socket(sock, server_side=True, certfile=self.certfile, keyfile=self.keyfile, cert_reqs=self.mode, ca_certs=self.ca, ssl_version=self.ssl_protocol) return sslsock, sockinfo
|
|
self.connection.unwrap() self.connection.close() os.close(self.connection.fileno())
|
def finish(self): # shut down the connection if not self.wfile.closed: self.wfile.flush() self.wfile.close() self.rfile.close() self.connection.unwrap() self.connection.close() os.close(self.connection.fileno())
|
|
if xsource.find('Recommended').text is not None:
|
if xsource.find('Recommended').text == 'true':
|
def source_from_xml(xsource): ret = dict([('rawurl', False), ('url', False)]) for key, tag in [('groups', 'Group'), ('components', 'Component'), ('arches', 'Arch'), ('blacklist', 'Blacklist')]: ret[key] = [item.text for item in xsource.findall(tag)] # version and component need to both contain data for sources to work try: ret['version'] = xsource.find('Version').text except: ret['version'] = 'placeholder' if ret['components'] == []: ret['components'] = ['placeholder'] try: if xsource.find('Recommended').text is not None: ret['recommended'] = True except: ret['recommended'] = False if xsource.find('RawURL') is not None: ret['rawurl'] = xsource.find('RawURL').text if not ret['rawurl'].endswith('/'): ret['rawurl'] += '/' else: ret['url'] = xsource.find('URL').text if not ret['url'].endswith('/'): ret['url'] += '/' return ret
|
self.cachefile = self.escape_url(self.url + '@' + version) + '.data'
|
if not self.rawurl: self.cachefile = self.escape_url(self.url + '@' + self.version) + '.data' else: self.cachefile = self.escape_url(self.rawurl) + '.data'
|
def __init__(self, basepath, url, version, arches, components, groups, rawurl, blacklist, recommended): Source.__init__(self, basepath, url, version, arches, components, groups, rawurl, blacklist, recommended) self.cachefile = self.escape_url(self.url + '@' + version) + '.data' self.pkgnames = set()
|
return ["%sdists/%s/%s/binary-%s/Packages.gz" % \ (self.url, self.version, part, arch) for part in self.components \ for arch in self.arches]
|
if not self.rawurl: return ["%sdists/%s/%s/binary-%s/Packages.gz" % \ (self.url, self.version, part, arch) for part in self.components \ for arch in self.arches] else: return ["%sPackages.gz" % (self.rawurl)]
|
def get_urls(self): return ["%sdists/%s/%s/binary-%s/Packages.gz" % \ (self.url, self.version, part, arch) for part in self.components \ for arch in self.arches]
|
def get_aptsrc(self): return ["deb %s %s %s" % (self.url, self.version, " ".join(self.components)), "deb-src %s %s %s" % (self.url, self.version, " ".join(self.components))]
|
def get_urls(self): return ["%sdists/%s/%s/binary-%s/Packages.gz" % \ (self.url, self.version, part, arch) for part in self.components \ for arch in self.arches]
|
|
barch = [x for x in fname.split('@') if x.startswith('binary-')][0][7:]
|
if not self.rawurl: barch = [x for x in fname.split('@') if x.startswith('binary-')][0][7:] else: barch = self.arches[0]
|
def read_files(self): bdeps = dict() bprov = dict() if self.recommended: depfnames = ['Depends', 'Pre-Depends', 'Recommends'] else: depfnames = ['Depends', 'Pre-Depends'] for fname in self.files: barch = [x for x in fname.split('@') if x.startswith('binary-')][0][7:] if barch not in bdeps: bdeps[barch] = dict() bprov[barch] = dict() try: reader = gzip.GzipFile(fname) except: print("Failed to read file %s" % fname) raise for line in reader.readlines(): words = line.strip().split(':', 1) if words[0] == 'Package': pkgname = words[1].strip().rstrip() self.pkgnames.add(pkgname) bdeps[barch][pkgname] = [] elif words[0] in depfnames: vindex = 0 for dep in words[1].split(','): if '|' in dep: cdeps = [re.sub('\s+', '', re.sub('\(.*\)', '', cdep)) for cdep in dep.split('|')] dyn_dname = "choice-%s-%s-%s" % (pkgname, barch, vindex) vindex += 1 bdeps[barch][pkgname].append(dyn_dname) bprov[barch][dyn_dname] = set(cdeps) else: raw_dep = re.sub('\(.*\)', '', dep) raw_dep = raw_dep.rstrip().strip() bdeps[barch][pkgname].append(raw_dep) elif words[0] == 'Provides': for pkg in words[1].split(','): dname = pkg.rstrip().strip() if dname not in bprov[barch]: bprov[barch][dname] = set() bprov[barch][dname].add(pkgname)
|
s = "YUMng: chosing: %s" % pkg.name
|
s = "YUMng: choosing: %s" % pkg.name
|
def VerifyPackage(self, entry, modlist): pinned_version = None if entry.get('version', False) == 'auto': # old style entry; synthesize Instances from current installed if entry.get('name') not in self.yum_installed and \ entry.get('name') not in self.yum_avail: # new entry; fall back to default entry.set('version', 'any') else: data = copy.copy(self.yum_installed[entry.get('name')]) if entry.get('name') in self.yum_avail: # installed but out of date data.update(self.yum_avail[entry.get('name')]) for (arch, (epoch, vers, rel)) in list(data.items()): x = Bcfg2.Client.XML.SubElement(entry, "Instance", name=entry.get('name'), version=vers, arch=arch, release=rel, epoch=epoch) if 'verify_flags' in entry.attrib: x.set('verify_flags', entry.get('verify_flags')) if 'verify' in entry.attrib: x.set('verify', entry.get('verify'))
|
raise self.send_response(500) self.end_headers()
|
try: self.send_response(500) self.end_headers() except: (type, msg) = sys.exc_info()[:2] self.logger.error("Error sending 500 response (%s): %s" % \ (type, msg)) raise
|
def do_POST(self): try: max_chunk_size = 10*1024*1024 size_remaining = int(self.headers["content-length"]) L = [] while size_remaining: try: select.select([self.rfile.fileno()], [], [], 3) except select.error: print "got select timeout" raise chunk_size = min(size_remaining, max_chunk_size) L.append(self.rfile.read(chunk_size)) size_remaining -= len(L[-1]) data = ''.join(L) response = self.server._marshaled_dispatch(self.client_address, data) except: raise self.send_response(500) self.end_headers() else: # got a valid XML RPC response self.send_response(200) self.send_header("Content-type", "text/xml") self.send_header("Content-length", str(len(response))) self.end_headers() self.wfile.write(response)
|
self.send_response(200) self.send_header("Content-type", "text/xml") self.send_header("Content-length", str(len(response))) self.end_headers() self.wfile.write(response)
|
try: self.send_response(200) self.send_header("Content-type", "text/xml") self.send_header("Content-length", str(len(response))) self.end_headers() failcount = 0 while True: try: self.wfile.write(response) break except ssl.SSLError, e: if str(e).find("SSL3_WRITE_PENDING") < 0: raise self.logger.error("SSL3_WRITE_PENDING") failcount += 1 if failcount < 5: continue raise except: (type, msg) = sys.exc_info()[:2] if str(type) == 'socket.error' and msg[0] == 32: self.logger.warning("Connection dropped from %s" % self.client_address[0]) elif str(type) == 'socket.error' and msg[0] == 104: self.logger.warning("Connection reset by peer: %s" % self.client_address[0]) else: self.logger.error("Error sending response (%s): %s" % \ (type, msg)) raise
|
def do_POST(self): try: max_chunk_size = 10*1024*1024 size_remaining = int(self.headers["content-length"]) L = [] while size_remaining: try: select.select([self.rfile.fileno()], [], [], 3) except select.error: print "got select timeout" raise chunk_size = min(size_remaining, max_chunk_size) L.append(self.rfile.read(chunk_size)) size_remaining -= len(L[-1]) data = ''.join(L) response = self.server._marshaled_dispatch(self.client_address, data) except: raise self.send_response(500) self.end_headers() else: # got a valid XML RPC response self.send_response(200) self.send_header("Content-type", "text/xml") self.send_header("Content-length", str(len(response))) self.end_headers() self.wfile.write(response)
|
logger.error("Packages: File read failed; falling back to file download")
|
logger.error("Packages: File read failed; " "falling back to file download")
|
def setup_data(self, force_update=False): should_read = True should_download = False if os.path.exists(self.cachefile): try: self.load_state() should_read = False except: logger.error("Cachefile %s load failed; falling back to file read"\ % (self.cachefile)) if should_read: try: self.read_files() except: logger.error("Packages: File read failed; falling back to file download") should_download = True
|
raw_dep = re.sub('\(.*\)', '', dep) if '|' in raw_dep:
|
if '|' in dep: cdeps = [re.sub('\(.*\)', '', cdep) for cdep in dep.split('|')]
|
def read_files(self): bdeps = dict() bprov = dict() for fname in self.files: barch = [x for x in fname.split('@') if x.startswith('binary-')][0][7:] if barch not in bdeps: bdeps[barch] = dict() bprov[barch] = dict() try: reader = gzip.GzipFile(fname) except: print("Failed to read file %s" % fname) raise for line in reader.readlines(): words = line.strip().split(':', 1) if words[0] == 'Package': pkgname = words[1].strip().rstrip() self.pkgnames.add(pkgname) elif words[0] == 'Depends': bdeps[barch][pkgname] = [] vindex = 0 for dep in words[1].split(','): raw_dep = re.sub('\(.*\)', '', dep) if '|' in raw_dep: dyn_dname = "choice-%s-%s-%s" % (pkgname, barch, vindex) vindex += 1 bdeps[barch][pkgname].append(dyn_dname) dyn_list = [x.strip() for x in raw_dep.split('|')] bprov[barch][dyn_dname] = set(dyn_list) else: raw_dep = raw_dep.rstrip().strip() bdeps[barch][pkgname].append(raw_dep) elif words[0] == 'Provides': for pkg in words[1].split(','): dname = pkg.rstrip().strip() if dname not in bprov[barch]: bprov[barch][dname] = set() bprov[barch][dname].add(pkgname)
|
dyn_list = [x.strip() for x in raw_dep.split('|')] bprov[barch][dyn_dname] = set(dyn_list)
|
bprov[barch][dyn_dname] = set(cdeps)
|
def read_files(self): bdeps = dict() bprov = dict() for fname in self.files: barch = [x for x in fname.split('@') if x.startswith('binary-')][0][7:] if barch not in bdeps: bdeps[barch] = dict() bprov[barch] = dict() try: reader = gzip.GzipFile(fname) except: print("Failed to read file %s" % fname) raise for line in reader.readlines(): words = line.strip().split(':', 1) if words[0] == 'Package': pkgname = words[1].strip().rstrip() self.pkgnames.add(pkgname) elif words[0] == 'Depends': bdeps[barch][pkgname] = [] vindex = 0 for dep in words[1].split(','): raw_dep = re.sub('\(.*\)', '', dep) if '|' in raw_dep: dyn_dname = "choice-%s-%s-%s" % (pkgname, barch, vindex) vindex += 1 bdeps[barch][pkgname].append(dyn_dname) dyn_list = [x.strip() for x in raw_dep.split('|')] bprov[barch][dyn_dname] = set(dyn_list) else: raw_dep = raw_dep.rstrip().strip() bdeps[barch][pkgname].append(raw_dep) elif words[0] == 'Provides': for pkg in words[1].split(','): dname = pkg.rstrip().strip() if dname not in bprov[barch]: bprov[barch][dname] = set() bprov[barch][dname].add(pkgname)
|
for plugin in self.bcore.plugins.values(): if isinstance(plugin, Bcfg2.Server.Plugin.Version):
|
for vcsplugin in self.bcore.plugins.values(): if isinstance(vcsplugin, Bcfg2.Server.Plugin.Version):
|
def PullEntry(self, client, etype, ename): """Make currently recorded client state correct for entry.""" new_entry = self.BuildNewEntry(client, etype, ename)
|
plugin.commit_data([files], comment)
|
vcsplugin.commit_data([files], comment)
|
def PullEntry(self, client, etype, ename): """Make currently recorded client state correct for entry.""" new_entry = self.BuildNewEntry(client, etype, ename)
|
Bcfg2.Client.Tools.PkgTool.__init__(self, logger, cfg, setup)
|
Bcfg2.Client.Tools.PkgTool.__init__(self, logger, setup, cfg)
|
def __init__(self, logger, setup, cfg): self.installed = {} self.pending_upgrades = set() self.image = image.Image() self.image.find_root('/', False) self.image.load_config() Bcfg2.Client.Tools.PkgTool.__init__(self, logger, cfg, setup) self.cfg = cfg
|
names[cmeta.hostname].update(newips) if True: for ip in newips: try: names[cmeta.hostname].update(self.get_namecache_entry(ip)) except: continue
|
names[cmeta.hostname].update(newips) if True: for ip in newips: try: names[cmeta.hostname].update(self.get_namecache_entry(ip)) except: continue names[cmeta.hostname] = sorted(names[cmeta.hostname])
|
def get_skn(self): '''build memory cache of the ssh known hosts file''' if not self.__skn: self.__skn = "\n".join([value.data for key, value in \ self.entries.iteritems() if \ key.endswith('.static')]) names = dict() # if no metadata is registered yet, defer if len(self.core.metadata.query.all()) == 0: self.__skn = False return self.__skn for cmeta in self.core.metadata.query.all(): names[cmeta.hostname] = set([cmeta.hostname]) names[cmeta.hostname].update(cmeta.aliases) newnames = set()
|
def __init__(self, logger, cfg, setup):
|
def __init__(self, logger, setup, cfg):
|
def __init__(self, logger, cfg, setup): self.installed = {} self.pending_upgrades = set() self.image = image.Image() self.image.find_root('/', False) self.image.load_config() Bcfg2.Client.Tools.PkgTool.__init__(self, logger, cfg, setup) self.cfg = cfg
|
options = {'plugins': Bcfg2.Options.SERVER_PLUGINS}
|
options = {'plugins': Bcfg2.Options.SERVER_PLUGINS, 'configfile': Bcfg2.Options.CFILE}
|
def __init__(self, configfile, usage, pwhitelist=None, pblacklist=None): Mode.__init__(self, configfile) options = {'plugins': Bcfg2.Options.SERVER_PLUGINS} setup = Bcfg2.Options.OptionParser(options) setup.hm = usage setup.parse(sys.argv[1:]) if pwhitelist is not None: setup['plugins'] = [x for x in setup['plugins'] if x in pwhitelist] elif pblacklist is not None: setup['plugins'] = [x for x in setup['plugins'] if x not in pblacklist] try: self.bcore = Bcfg2.Server.Core.Core(self.get_repo_path(), setup['plugins'], 'foo', 'UTF-8') except Bcfg2.Server.Core.CoreInitError, msg: self.errExit("Core load failed because %s" % msg) self.bcore.fam.handle_events_in_interval(5) self.metadata = self.bcore.metadata
|
def Verifynonexistent(self, entry, _): return True def Installnonexistent(self, entry): return True
|
def Verifynonexistent(self, entry, _): # FIXME: not implemented return True
|
|
cert = self.build_cert(entry, metadata)
|
cert = self.build_cert(key_filename, entry, metadata)
|
def get_cert(self, entry, metadata): """ either grabs a prexisting cert hostfile, or triggers the generation of a new cert if one doesn't exist. """ # set path type and permissions, otherwise bcfg2 won't bind the file permdata = {'owner':'root', 'group':'root', 'type':'file', 'perms':'644'} [entry.attrib.__setitem__(key, permdata[key]) for key in permdata]
|
cert = "".join([self.data, '/', filename])
|
cert = self.data + filename
|
def verify_cert(self, filename, entry): """ check that a certificate validates against the ca cert, and that it has not expired. """ chaincert = self.CAs[self.cert_specs[entry.get('name')]['ca']].get('chaincert') cert = "".join([self.data, '/', filename]) cmd = "openssl verify -CAfile %s %s" % (chaincert, cert) proc = Popen(cmd, shell=True) proc.communicate() if proc.returncode != 0: return False return True
|
proc = Popen(cmd, shell=True) proc.communicate() if proc.returncode != 0: return False return True def build_cert(self, entry, metadata):
|
res = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT).stdout.read() if res == cert + ": OK\n" return True return False def build_cert(self, key_filename, entry, metadata):
|
def verify_cert(self, filename, entry): """ check that a certificate validates against the ca cert, and that it has not expired. """ chaincert = self.CAs[self.cert_specs[entry.get('name')]['ca']].get('chaincert') cert = "".join([self.data, '/', filename]) cmd = "openssl verify -CAfile %s %s" % (chaincert, cert) proc = Popen(cmd, shell=True) proc.communicate() if proc.returncode != 0: return False return True
|
req = self.build_request(req_config, entry)
|
req = self.build_request(key_filename, req_config, entry)
|
def build_cert(self, entry, metadata): """ creates a new certificate according to the specification """ req_config = self.build_req_config(entry, metadata) req = self.build_request(req_config, entry) ca = self.cert_specs[entry.get('name')]['ca'] ca_config = self.CAs[ca]['config'] days = self.cert_specs[entry.get('name')]['days'] passphrase = self.CAs[ca].get('passphrase') if passphrase: cmd = "openssl ca -config %s -in %s -days %s -batch -passin pass:%s" % (ca_config, req, days, passphrase) else: cmd = "openssl ca -config %s -in %s -days %s -batch" % (ca_config, req, days) cert = Popen(cmd, shell=True, stdout=PIPE).stdout.read() try: os.unlink(req_config) os.unlink(req) except OSError: self.logger.error("Failed to unlink temporary files") return cert
|
deps = set() pname = list(provset)[0]
|
pkg_to_add = list(provset)[0] elif satisfiers: if item_is_pkg and requirement in satisfiers: pkg_to_add = requirement else: pkg_to_add = list(satisfiers)[0] elif item_is_pkg: pkg_to_add = requirement else: raise SomeData if debug: logger.debug("Adding Package %s for %s" % (pkg_to_add, requirement)) try: deps = self.get_deps(metadata, pkg_to_add)
|
def resolve_requirement(self, metadata, requirement, packages, debug=False): '''Resolve requirement to packages and or additional requirements
|
logger.debug("Adding Package %s for %s" % (pname, requirement)) try: deps = self.get_deps(metadata, pname) if debug: logger.debug("Package %s: adding new deps %s" \ % (pname, deps)) except: pass return (set([pname]), deps) satisfiers = provset.intersection(packages) if satisfiers: if debug: logger.debug("Requirement %s satisfied by %s" \ % (requirement, satisfiers)) return (set(), set()) if item_is_pkg: deps = set() if debug: logger.debug("Adding Package %s for %s" \ % (requirement, requirement)) try: deps = self.get_deps(metadata, requirement) if debug: logger.debug("Package %s: adding new deps %s" \ % (requirement, deps)) except: pass return (set([requirement]), deps) raise SomeData
|
logger.debug("Package %s: adding new deps %s" \ % (pkg_to_add, deps)) except: pass return (set([pkg_to_add]), deps)
|
def resolve_requirement(self, metadata, requirement, packages, debug=False): '''Resolve requirement to packages and or additional requirements
|
self.cachefile = self.escape_url(self.baseurl) + '.data'
|
self.cachefile = self.escape_url(self.baseurl + '@' + version) + '.data'
|
def __init__(self, basepath, url, version, arches, components, groups, rawurl): Source.__init__(self, basepath, url, version, arches, components, groups, rawurl) if not self.rawurl: self.baseurl = self.url + '%(version)s/%(component)s/%(arch)s/' else: self.baseurl = self.rawurl self.cachefile = self.escape_url(self.baseurl) + '.data' self.packages = dict() self.deps = dict([('global', dict())]) self.provides = dict([('global', dict())]) self.filemap = dict([(x, dict()) for x in ['global'] + self.arches]) self.needed_paths = set() self.file_to_arch = dict()
|
self.cachefile = self.escape_url(self.url) + '.data'
|
self.cachefile = self.escape_url(self.url + '@' + version) + '.data'
|
def __init__(self, basepath, url, version, arches, components, groups, rawurl): Source.__init__(self, basepath, url, version, arches, components, groups, rawurl) self.cachefile = self.escape_url(self.url) + '.data' self.pkgnames = set()
|
def delete(self, groupId, adminInfo):
|
def delete(self, groupId):
|
def delete(self, groupId, adminInfo): assert groupId, 'No group ID' assert adminInfo, 'No admin' if type(groupId) == unicode: groupId = groupId.encode('ascii', 'ignore')
|
assert adminInfo, 'No admin'
|
def delete(self, groupId, adminInfo): assert groupId, 'No group ID' assert adminInfo, 'No admin' if type(groupId) == unicode: groupId = groupId.encode('ascii', 'ignore')
|
|
groupInfo = createObject('groupserver.UserFromId', self.siteInfo.siteObj, groupId)
|
def delete(self, groupId, adminInfo): assert groupId, 'No group ID' assert adminInfo, 'No admin' if type(groupId) == unicode: groupId = groupId.encode('ascii', 'ignore')
|
|
self.delete_user_group() self.delete_list()
|
self.delete_user_group(groupId) self.delete_list(groupId)
|
def delete(self, groupId, adminInfo): assert groupId, 'No group ID' assert adminInfo, 'No admin' if type(groupId) == unicode: groupId = groupId.encode('ascii', 'ignore')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.