def ssh_pubkey(PK: str = str(), user: models.User = None, **kwargs) -> None: if not PK: # If no pubkey is provided, wipe out any pubkeys the user # has and return out early. with db.begin(): db.delete_all(user.ssh_pub_keys) return # Otherwise, parse ssh keys and their fprints out of PK. keys = util.parse_ssh_keys(PK.strip()) fprints = [get_fingerprint(" ".join(k)) for k in keys] with db.begin(): # Delete any existing keys we can't find. to_remove = user.ssh_pub_keys.filter( ~SSHPubKey.Fingerprint.in_(fprints)) db.delete_all(to_remove) # For each key, if it does not yet exist, create it. for i, full_key in enumerate(keys): prefix, key = full_key exists = user.ssh_pub_keys.filter( SSHPubKey.Fingerprint == fprints[i]).exists() if not db.query(exists).scalar(): # No public key exists, create one. db.create(models.SSHPubKey, UserID=user.ID, PubKey=" ".join([prefix, key]), Fingerprint=fprints[i])
async def authenticate(self, conn: HTTPConnection): unauthenticated = (None, AnonymousUser()) sid = conn.cookies.get("AURSID") if not sid: return unauthenticated timeout = aurweb.config.getint("options", "login_timeout") remembered = ("AURREMEMBER" in conn.cookies and bool(conn.cookies.get("AURREMEMBER"))) if remembered: timeout = aurweb.config.getint("options", "persistent_cookie_timeout") # If no session with sid and a LastUpdateTS now or later exists. now_ts = time.utcnow() record = db.query(Session).filter(Session.SessionID == sid).first() if not record: return unauthenticated elif record.LastUpdateTS < (now_ts - timeout): with db.begin(): db.delete_all([record]) return unauthenticated # At this point, we cannot have an invalid user if the record # exists, due to ForeignKey constraints in the schema upheld # by mysqlclient. with db.begin(): user = db.query(User).filter(User.ID == record.UsersID).first() user.nonce = util.make_nonce() user.authenticated = True return (AuthCredentials(["authenticated"]), user)
async def pkgbase_keywords(request: Request, name: str, keywords: str = Form(default=str())): pkgbase = get_pkg_or_base(name, PackageBase) # Lowercase all keywords. Our database table is case insensitive, # and providing CI duplicates of keywords is erroneous. keywords = set(k.lower() for k in keywords.split(" ")) # Delete all keywords which are not supplied by the user. with db.begin(): other_keywords = pkgbase.keywords.filter( ~PackageKeyword.Keyword.in_(keywords)) other_keyword_strings = set(kwd.Keyword.lower() for kwd in other_keywords) existing_keywords = set( kwd.Keyword.lower() for kwd in pkgbase.keywords.filter( ~PackageKeyword.Keyword.in_(other_keyword_strings))) db.delete_all(other_keywords) new_keywords = keywords.difference(existing_keywords) for keyword in new_keywords: db.create(PackageKeyword, PackageBase=pkgbase, Keyword=keyword) return RedirectResponse(f"/pkgbase/{name}", status_code=HTTPStatus.SEE_OTHER)
def pkgbase_disown_instance(request: Request, pkgbase: PackageBase) -> None: disowner = request.user notifs = [notify.DisownNotification(disowner.ID, pkgbase.ID)] is_maint = disowner == pkgbase.Maintainer if is_maint: with db.begin(): # Comaintainer with the lowest Priority value; next-in-line. prio_comaint = pkgbase.comaintainers.order_by( PackageComaintainer.Priority.asc() ).first() if prio_comaint: # If there is such a comaintainer, promote them to maint. pkgbase.Maintainer = prio_comaint.User notifs.append(pkgbaseutil.remove_comaintainer(prio_comaint)) else: # Otherwise, just orphan the package completely. pkgbase.Maintainer = None elif request.user.has_credential(creds.PKGBASE_DISOWN): # Otherwise, the request user performing this disownage is a # Trusted User and we treat it like a standard orphan request. notifs += handle_request(request, ORPHAN_ID, pkgbase) with db.begin(): pkgbase.Maintainer = None db.delete_all(pkgbase.comaintainers) util.apply_all(notifs, lambda n: n.send())
def _main(): # One day behind. limit_to = time.utcnow() - 86400 query = db.query(PackageBase).filter( and_(PackageBase.SubmittedTS < limit_to, PackageBase.PackagerUID.is_(None))) db.delete_all(query)
def _main(force: bool = False): blacklist = set() providers = set() repomap = dict() db_path = aurweb.config.get("aurblup", "db-path") sync_dbs = aurweb.config.get('aurblup', 'sync-dbs').split(' ') server = aurweb.config.get('aurblup', 'server') h = pyalpm.Handle("/", db_path) for sync_db in sync_dbs: repo = h.register_syncdb(sync_db, pyalpm.SIG_DATABASE_OPTIONAL) repo.servers = [server.replace("%s", sync_db)] t = h.init_transaction() repo.update(force) t.release() for pkg in repo.pkgcache: blacklist.add(pkg.name) util.apply_all(pkg.replaces, blacklist.add) providers.add((pkg.name, pkg.name)) repomap[(pkg.name, pkg.name)] = repo.name for provision in pkg.provides: provisionname = re.sub(r'(<|=|>).*', '', provision) providers.add((pkg.name, provisionname)) repomap[(pkg.name, provisionname)] = repo.name with db.begin(): old_providers = set( db.query(OfficialProvider).with_entities( OfficialProvider.Name.label("Name"), OfficialProvider.Provides.label("Provides") ).distinct().order_by("Name").all() ) for name, provides in old_providers.difference(providers): db.delete_all(db.query(OfficialProvider).filter( and_(OfficialProvider.Name == name, OfficialProvider.Provides == provides) )) for name, provides in providers.difference(old_providers): repo = repomap.get((name, provides)) db.create(OfficialProvider, Name=name, Repo=repo, Provides=provides)
def remove_comaintainers(pkgbase: PackageBase, usernames: List[str]) -> None: """ Remove comaintainers from `pkgbase`. :param pkgbase: PackageBase instance :param usernames: Iterable of username strings """ notifications = [] with db.begin(): comaintainers = pkgbase.comaintainers.join(User).filter( User.Username.in_(usernames)).all() notifications = [ notify.ComaintainerRemoveNotification(co.User.ID, pkgbase.ID) for co in comaintainers ] db.delete_all(comaintainers) # Rotate comaintainer priority values. with db.begin(): rotate_comaintainers(pkgbase) # Send out notifications. util.apply_all(notifications, lambda n: n.send())