def main(self): """Generate signing keys for the selected PPAs.""" owner_name = self.options.archive_owner_name if owner_name is not None: owner = getUtility(IPersonSet).getByName(owner_name) if owner is None: raise LaunchpadScriptFailure( "No person named '%s' could be found." % owner_name) if owner.archive is None: raise LaunchpadScriptFailure("Person named '%s' has no PPA." % owner_name) if owner.archive.signing_key is not None: raise LaunchpadScriptFailure( "%s already has a signing_key (%s)" % (owner.archive.displayname, owner.archive.signing_key.fingerprint)) archives = [owner.archive] else: archive_set = getUtility(IArchiveSet) archives = list(archive_set.getPPAsPendingSigningKey()) for archive in archives: self.generateKey(archive) self.txn.commit()
def main(self): self.logger.info('Initializing...') if self.options.cvefile is not None: try: cve_db = open(self.options.cvefile, 'r').read() except IOError: raise LaunchpadScriptFailure( 'Unable to open CVE database in %s' % self.options.cvefile) elif self.options.cveurl is not None: self.logger.info("Downloading CVE database from %s..." % self.options.cveurl) try: url = urllib2.urlopen(self.options.cveurl) except (urllib2.HTTPError, urllib2.URLError): raise LaunchpadScriptFailure( 'Unable to connect for CVE database %s' % self.options.cveurl) cve_db_gz = url.read() self.logger.info("%d bytes downloaded." % len(cve_db_gz)) cve_db = gzip.GzipFile(fileobj=StringIO.StringIO(cve_db_gz)).read() else: raise LaunchpadScriptFailure('No CVE database file or URL given.') # Start analysing the data. start_time = time.time() self.logger.info("Processing CVE XML...") self.processCVEXML(cve_db) finish_time = time.time() self.logger.info('%d seconds to update database.' % (finish_time - start_time))
def main(self): if len(self.args) != 1: raise LaunchpadScriptFailure( "Need to be given exactly one non-option " "argument, namely the fsroot for the upload.") self.options.base_fsroot = os.path.abspath(self.args[0]) if not os.path.isdir(self.options.base_fsroot): raise LaunchpadScriptFailure("%s is not a directory" % self.options.base_fsroot) self.logger.debug("Initializing connection.") def getPolicy(distro, build): self.options.distro = distro.name policy = findPolicyByName(self.options.context) policy.setOptions(self.options) if self.options.builds: assert build, "--builds specified but no build" policy.distroseries = build.distro_series policy.pocket = build.pocket policy.archive = build.archive return policy processor = UploadProcessor(self.options.base_fsroot, self.options.dryrun, self.options.nomails, self.options.builds, self.options.keep, getPolicy, self.txn, self.logger) processor.processUploadQueue(self.options.leafname)
def main(self): if len(self.args) < 1: raise LaunchpadScriptFailure('Please specify a target directory.') if len(self.args) > 1: raise LaunchpadScriptFailure('Too many arguments.') target_dir = self.args[0] with server(get_rw_server()): if self.options.finish: Upgrader.finish_all_upgrades(target_dir, self.logger) else: Upgrader.start_all_upgrades(target_dir, self.logger)
def checkOptions(self): """Verify if the given command-line options are sane.""" if ((self.options.gen_orphan_repos or self.options.gen_missing_repos or self.options.gen_over_quota) and self.options.gen_user_emails): raise LaunchpadScriptFailure( 'Users-list cannot be combined with other reports.') if ((self.options.gen_orphan_repos or self.options.gen_missing_repos) and self.options.archive_owner_name is not None): raise LaunchpadScriptFailure( 'Cannot calculate repository paths for a single PPA.') if ((self.options.gen_orphan_repos or self.options.gen_missing_repos) and not os.path.exists(config.personalpackagearchive.root)): raise LaunchpadScriptFailure('Cannot access PPA root directory.')
def execute(logger, command, args=None): """Execute a shell command. :param logger: Output from the command will be logged here. :param command: Command to execute, as a string. :param args: Optional list of arguments for `command`. :raises LaunchpadScriptFailure: If the command returns failure. """ command_line = [command] if args is not None: command_line += args description = ' '.join(command_line) logger.debug("Execute: %s", description) # Some of these commands can take a long time. Use CommandSpawner # and friends to provide "live" log output. Simpler ways of running # commands tend to save it all up and then dump it at the end, or # have trouble logging it as neat lines. stderr_logger = OutputLineHandler(logger.info) stdout_logger = OutputLineHandler(logger.debug) receiver = ReturnCodeReceiver() spawner = CommandSpawner() spawner.start(command_line, completion_handler=receiver, stderr_handler=stderr_logger, stdout_handler=stdout_logger) spawner.complete() stdout_logger.finalize() stderr_logger.finalize() if receiver.returncode != 0: raise LaunchpadScriptFailure("Failure while running command: %s" % description)
def main(self): """Entry point for `LaunchpadScript`s.""" try: self.setupLocation() except SoyuzScriptError as err: raise LaunchpadScriptFailure(err) if not self.options.arch_tags: self.parser.error("Specify at least one architecture.") arches = [] for arch_tag in self.options.arch_tags: try: das = self.location.distroseries.getDistroArchSeries(arch_tag) arches.append(das) except NotFoundError: self.parser.error("%s not a valid architecture for %s" % (arch_tag, self.location.distroseries.name)) # I'm tired of parsing options. Let's do it. try: self.add_missing_builds(self.location.archive, arches, self.location.distroseries, self.location.pocket) self.txn.commit() self.logger.info("Finished adding builds.") except Exception as err: self.logger.error(err) self.txn.abort() self.logger.info("Errors, aborted transaction.") sys.exit(1)
def run_parts(distribution_name, parts, log=None, env=None): """Execute run-parts. :param distribution_name: The name of the distribution to execute run-parts scripts for. :param parts: The run-parts directory to execute: "publish-distro.d" or "finalize.d". :param log: An optional logger. :param env: A dict of additional environment variables to pass to the scripts in the run-parts directory, or None. """ parts_dir = find_run_parts_dir(distribution_name, parts) if parts_dir is None: if log is not None: log.debug("Skipping run-parts %s: not configured.", parts) return cmd = ["run-parts", "--", parts_dir] failure = LaunchpadScriptFailure( "Failure while executing run-parts %s." % parts_dir) full_env = dict(os.environ) if env is not None: full_env.update(env) scripts_dir = os.path.join(config.root, "cronscripts", "publishing") path_elements = full_env.get("PATH", "").split(os.pathsep) path_elements.append(scripts_dir) full_env["PATH"] = os.pathsep.join(path_elements) execute_subprocess(cmd, log=None, failure=failure, env=full_env)
def main(self): """See `LaunchpadScript`.""" self._setDistroDetails() self._setPackage() if self.options.dryrun: self.logger.info("Dry run. Not really uploading anything.") queue = getUtility(ITranslationImportQueue) rosetta_team = getUtility(ILaunchpadCelebrities).rosetta_experts for filename in self.args: if not os.access(filename, os.R_OK): raise LaunchpadScriptFailure("File not readable: %s" % filename) self.logger.info("Uploading: %s." % filename) content = open(filename).read() queue.addOrUpdateEntry(filename, content, True, rosetta_team, sourcepackagename=self.sourcepackagename, distroseries=self.distroseries) self._commit() self.logger.info("Done.")
def supported(self): """Return the names of the distroseries currently supported. 'supported' means not EXPERIMENTAL or OBSOLETE. It is restricted for the context distribution. It may raise `LaunchpadScriptFailure` if a suite was passed on the command-line or if there is not supported distroseries for the distribution given. Return a space-separated list of distroseries names. """ self.checkNoSuiteDefined() supported_series = [] unsupported_status = (SeriesStatus.EXPERIMENTAL, SeriesStatus.OBSOLETE) for distroseries in self.location.distribution: if distroseries.status not in unsupported_status: supported_series.append(distroseries.name) if not supported_series: raise LaunchpadScriptFailure( 'There is no supported distroseries for %s' % self.location.distribution.name) return " ".join(supported_series)
def main(self): """See `LaunchpadScript`.""" process_options(self.options) (result, message) = self._check_constraints_safety() if not result: raise LaunchpadScriptFailure(message) if message is not None: self.logger.warn(message) if self.options.dry_run: self.logger.info("Dry run only. Not really deleting.") remove_translations( logger=self.logger, submitter=self.options.submitter, reject_license=self.options.reject_license, reviewer=self.options.reviewer, ids=self.options.ids, potemplate=self.options.potemplate, language_code=self.options.language, not_language=self.options.not_language, is_current_ubuntu=self.options.is_current_ubuntu, is_current_upstream=self.options.is_current_upstream, msgid_singular=self.options.msgid, origin=self.options.origin) if self.options.dry_run: if self.txn is not None: self.txn.abort() else: self.txn.commit()
def main(self): emailaddress = unicode(self.options.email) if not emailaddress: raise LaunchpadScriptFailure('--email is required') person = getUtility(IPersonSet).getByEmail(emailaddress) if person is None: raise LaunchpadScriptFailure( 'Account with email address {} does not exist'.format( emailaddress)) person.account.setStatus(AccountStatus.SUSPENDED, None, 'Suspended by suspend-bot-account.py') self.logger.info('Suspended {}'.format(canonical_url(person))) self.txn.commit()
def main(self): """Flag expired team memberships.""" if self.args: raise LaunchpadScriptFailure( "Unhandled arguments %s" % repr(self.args)) self.logger.info("Flagging expired team memberships.") self.flag_expired_memberships_and_send_warnings() self.logger.info("Finished flagging expired team memberships.")
def getCopyArchives(self, distribution): """Find copy archives for the selected distribution.""" copy_archives = list( getUtility(IArchiveSet).getArchivesForDistribution( distribution, purposes=[ArchivePurpose.COPY])) if copy_archives == []: raise LaunchpadScriptFailure("Could not find any COPY archives") return copy_archives
def _setPackage(self): """Find `SourcePackage` of given name.""" if not self.options.package: raise LaunchpadScriptFailure("No package specified.") nameset = getUtility(ISourcePackageNameSet) self.sourcepackagename = nameset.queryByName(self.options.package)
def findNamedDistro(self, distro_name): """Find the `Distribution` called `distro_name`.""" self.logger.debug("Finding distribution %s.", distro_name) distro = getUtility(IDistributionSet).getByName(distro_name) if distro is None: raise LaunchpadScriptFailure("Distribution '%s' not found." % distro_name) return distro
def _setargs(self, args): """Set distribution_name and series_name from the args.""" if len(args) != 2: raise LaunchpadScriptFailure( 'Wrong number of arguments: should include distribution ' 'and series name.') self._args = args self.distribution_name, self.series_name = self._args
def main(self): """Upload file, commit the transaction and prints the file URL.""" if self.options.filepath is None: raise LaunchpadScriptFailure('File not provided.') library_file = self.upload_file(self.options.filepath) self.txn.commit() self.logger.info(library_file.http_url)
def main(self): try: handleMail(self.txn) except ComponentLookupError as lookup_error: if lookup_error.args[0] != IMailBox: raise raise LaunchpadScriptFailure( "No mail box is configured. " "Please see mailbox.txt for info on how to configure one.")
def getConfig(self): """Set up a configuration object for this archive.""" archive = self.distribution.main_archive if archive: return getPubConfig(archive) else: raise LaunchpadScriptFailure( "There is no PRIMARY archive for %s." % self.options.distribution)
def checkNoSuiteDefined(self): """Raises LaunchpadScriptError if a suite location was passed. It is re-used in action properties to avoid conflicting contexts, i.e, passing an arbitrary 'suite' and asking for the CURRENT suite in the context distribution. """ if self.options.suite is not None: raise LaunchpadScriptFailure( "Action does not accept defined suite.")
def _setDistroDetails(self): """Figure out the `Distribution`/`DistroSeries` to act upon.""" distroset = getUtility(IDistributionSet) self.distro = distroset.getByName(self.options.distro) if not self.options.distroseries: raise LaunchpadScriptFailure( "Specify a distribution release series.") self.distroseries = self.distro.getSeries(self.options.distroseries)
def main(self): self.logger.info('Initializing...') if self.options.cvefile is not None: try: cve_db = open(self.options.cvefile, 'r').read() except IOError: raise LaunchpadScriptFailure( 'Unable to open CVE database in %s' % self.options.cvefile) elif self.options.cveurl is not None: cve_db = self.fetchCVEURL(self.options.cveurl) else: raise LaunchpadScriptFailure('No CVE database file or URL given.') # Start analysing the data. start_time = time.time() self.logger.info("Processing CVE XML...") self.processCVEXML(cve_db) finish_time = time.time() self.logger.info('%d seconds to update database.' % (finish_time - start_time))
def main(self): """LaunchpadScript entry point. Can only raise LaunchpadScriptFailure - other exceptions are absorbed into that. """ try: self.setupLocation() self.mainTask() except SoyuzScriptError as err: raise LaunchpadScriptFailure(err) self.finishProcedure()
def main(self): if len(self.args) != 2: raise LaunchpadScriptFailure( "You must specify the name of the person to be converted " "and the person/team who should be its teamowner.") person_set = getUtility(IPersonSet) person_name, owner_name = self.args person = person_set.getByName(person_name) if person is None: raise LaunchpadScriptFailure( "There's no person named '%s'." % person_name) if person.account_status != AccountStatus.NOACCOUNT: raise LaunchpadScriptFailure( "Only people which have no account can be turned into teams.") owner = person_set.getByName(owner_name) if owner is None: raise LaunchpadScriptFailure( "There's no person named '%s'." % owner_name) person.convertToTeam(owner) self.txn.commit()
def _setDistroDetails(self): """Figure out the `Distribution`/`DistroSeries` to act upon.""" # Avoid circular imports. from lp.registry.interfaces.distribution import IDistributionSet distroset = getUtility(IDistributionSet) self.distro = distroset.getByName(self.options.distro) if not self.options.distroseries: raise LaunchpadScriptFailure( "Specify a distribution release series.") self.distroseries = self.distro.getSeries(self.options.distroseries)
def get_last_modified_epoch(self): """Return the timezone aware datetime for the last modified epoch. """ if (self.options.last_hours is not None and self.options.since is not None): raise LaunchpadScriptFailure( "Only one of --since or --last-hours can be specified.") last_modified = None if self.options.last_hours is not None: last_modified = (self.now_timestamp - timedelta(hours=self.options.last_hours)) elif self.options.since is not None: try: parsed_time = strptime(self.options.since, '%Y-%m-%d') last_modified = datetime(*(parsed_time[:3])) except ValueError as e: raise LaunchpadScriptFailure(str(e)) else: raise LaunchpadScriptFailure( "One of --since or --last-hours needs to be specified.") # Make the datetime timezone aware. return last_modified.replace(tzinfo=pytz.UTC)
def main(self): """Generate signing keys for the selected PPAs.""" if self.options.archive is not None: archive = getUtility(IArchiveSet).getByReference( self.options.archive) if archive is None: raise LaunchpadScriptFailure( "No archive named '%s' could be found." % self.options.archive) if archive.signing_key is not None: raise LaunchpadScriptFailure( "%s (%s) already has a signing_key (%s)" % (archive.reference, archive.displayname, archive.signing_key.fingerprint)) archives = [archive] else: archive_set = getUtility(IArchiveSet) archives = list(archive_set.getPPAsPendingSigningKey()) for archive in archives: self.generateKey(archive) self.txn.commit()
def _buildLocation(self): """Build a PackageLocation object The location will correspond to the given 'distribution' and 'suite', Any PackageLocationError occurring at this point will be masked into LaunchpadScriptFailure. """ try: self.location = build_package_location( distribution_name=self.options.distribution_name, suite=self.options.suite) except PackageLocationError as err: raise LaunchpadScriptFailure(err)
def processOptions(self): """Handle command-line options. Sets `self.distributions` to the `Distribution`s to publish. """ if self.options.distribution is None and not self.options.all_derived: raise LaunchpadScriptFailure( "Specify a distribution, or --all-derived.") if self.options.distribution is not None and self.options.all_derived: raise LaunchpadScriptFailure( "Can't combine the --distribution and --all-derived options.") if self.options.all_derived: distro_set = getUtility(IDistributionSet) self.distributions = distro_set.getDerivedDistributions() else: distro = getUtility(IDistributionSet).getByName( self.options.distribution) if distro is None: raise LaunchpadScriptFailure("Distribution %s not found." % self.options.distribution) self.distributions = [distro]