commit: 36db6e7c8748e2d346e1ef92362807b0c242df76
Author: Matt Turner <mattst88 <AT> gentoo <DOT> org>
AuthorDate: Sat Jul 31 01:31:21 2021 +0000
Commit: Matt Turner <mattst88 <AT> gentoo <DOT> org>
CommitDate: Sat Jul 31 19:41:16 2021 +0000
URL: https://gitweb.gentoo.org/proj/releng.git/commit/?id=36db6e7c
scripts: Remove cruft
Presumably these were used once upon a time when catalyst builds were
done on infra-managed boxes (where puppet/chef made updating things
difficult).
Signed-off-by: Matt Turner <mattst88 <AT> gentoo.org>
scripts/backup_snapshot_repo | 10 -
scripts/cache-tools.py | 700 -------------------------------------------
scripts/run_catalyst | 2 -
scripts/run_official | 39 ---
scripts/run_snapshot | 2 -
scripts/stage_build.sh | 162 ----------
scripts/sudo_catalyst | 28 --
scripts/sudo_official | 46 ---
scripts/sudo_snapshot | 20 --
scripts/update_auto_tree | 14 -
scripts/update_official_tree | 14 -
scripts/update_snapshot_tree | 14 -
12 files changed, 1051 deletions(-)
diff --git a/scripts/backup_snapshot_repo b/scripts/backup_snapshot_repo
deleted file mode 100755
index 94b2828f..00000000
--- a/scripts/backup_snapshot_repo
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/bin/bash
-
-# Start our rsyncs
-RSYNC_OPTS="--archive --delete --sparse --whole-file"
-
-if [ -e /release/repos/snapshot-tree/hooks/post-commit ]
-then
- echo "$(date): Starting rsync of trees from tmpfs to disk..." >>
/var/log/snapshot-tree-backup.log
- rsync ${RSYNC_OPTS} /release/repos/snapshot-tree/*
/release/repos/snapshot-tree-disk 2>&1 >> /var/log/snapshot-tree-backup.log ||
echo "$(date): rsync failed!" >> /var/log/snapshot-tree-backup.log
-fi
diff --git a/scripts/cache-tools.py b/scripts/cache-tools.py
deleted file mode 100755
index 03644503..00000000
--- a/scripts/cache-tools.py
+++ /dev/null
@@ -1,700 +0,0 @@
-#!/usr/bin/env python
-# Copyright 1999-2006 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Header: $
-#
-# Zac Medico <[email protected]>
-#
-
-import errno, fpformat, os, sys, time
-
-if not hasattr(__builtins__, "set"):
- from sets import Set as set
-from itertools import chain
-
-def create_syncronized_func(myfunc, mylock):
- def newfunc(*pargs, **kwargs):
- mylock.acquire()
- try:
- myfunc(*pargs, **kwargs)
- finally:
- mylock.release()
- return myfunc
-
-class ConsoleUpdate(object):
-
- _synchronized_methods = ["append", "carriageReturn",
- "newLine", "reset", "update"]
-
- def __init__(self):
- self.offset = 0
- import sys
- self.stream = sys.stdout
- self.quiet = False
- import threading
- self._lock = threading.RLock()
- for method_name in self._synchronized_methods:
- myfunc = create_syncronized_func(
- getattr(self, method_name), self._lock)
- setattr(self, method_name, myfunc)
- # ANSI code that clears from the cursor to the end of the line
- self._CLEAR_EOL = None
- try:
- import curses
- try:
- curses.setupterm()
- self._CLEAR_EOL = curses.tigetstr('el')
- except curses.error:
- pass
- except ImportError:
- pass
- if not self._CLEAR_EOL:
- self._CLEAR_EOL = '\x1b[K'
-
- def acquire(self, **kwargs):
- return self._lock.acquire(**kwargs)
-
- def release(self):
- self._lock.release()
-
- def reset(self):
- self.offset = 0
-
- def carriageReturn(self):
- if not self.quiet:
- self.stream.write("\r")
- self.stream.write(self._CLEAR_EOL)
- self.offset = 0
-
- def newLine(self):
- if not self.quiet:
- self.stream.write("\n")
- self.stream.flush()
- self.reset()
-
- def update(self, msg):
- if not self.quiet:
- self.carriageReturn()
- self.append(msg)
-
- def append(self, msg):
- if not self.quiet:
- self.offset += len(msg)
- self.stream.write(msg)
- self.stream.flush()
-
-class ProgressCounter(object):
- def __init__(self):
- self.total = 0
- self.current = 0
-
-class ProgressAnalyzer(ProgressCounter):
- def __init__(self):
- self.start_time = time.time()
- self.currentTime = self.start_time
- self._samples = []
- self.sampleCount = 20
- def percentage(self, digs=0):
- if self.total > 0:
- float_percent = 100 * float(self.current) /
float(self.total)
- else:
- float_percent = 0.0
- return fpformat.fix(float_percent,digs)
- def totalTime(self):
- self._samples.append((self.currentTime, self.current))
- while len(self._samples) > self.sampleCount:
- self._samples.pop(0)
- prev_time, prev_count = self._samples[0]
- time_delta = self.currentTime - prev_time
- if time_delta > 0:
- rate = (self.current - prev_count) / time_delta
- if rate > 0:
- return self.total / rate
- return 0
- def remaining_time(self):
- return self.totalTime() - self.elapsed_time()
- def elapsed_time(self):
- return self.currentTime - self.start_time
-
-class ConsoleProgress(object):
- def __init__(self, name="Progress", console=None):
- self.name = name
- self.analyzer = ProgressAnalyzer()
- if console is None:
- self.console = ConsoleUpdate()
- else:
- self.console = console
- self.time_format="%H:%M:%S"
- self.quiet = False
- self.lastUpdate = 0
- self.latency = 0.5
-
- def formatTime(self, t):
- return time.strftime(self.time_format, time.gmtime(t))
-
- def displayProgress(self, current, total):
- if self.quiet:
- return
-
- self.analyzer.currentTime = time.time()
- if self.analyzer.currentTime - self.lastUpdate < self.latency:
- return
- self.lastUpdate = self.analyzer.currentTime
- self.analyzer.current = current
- self.analyzer.total = total
-
- output = ((self.name, self.analyzer.percentage(1).rjust(4) +
"%"),
- ("Elapsed", self.formatTime(self.analyzer.elapsed_time())),
- ("Remaining", self.formatTime(self.analyzer.remaining_time())),
- ("Total", self.formatTime(self.analyzer.totalTime())))
- self.console.update(" ".join([ x[0] + ": " + x[1] for x in
output ]))
-
-class ProgressHandler(object):
- def __init__(self):
- self.curval = 0
- self.maxval = 0
- self.last_update = 0
- self.min_display_latency = 0.2
-
- def onProgress(self, maxval, curval):
- self.maxval = maxval
- self.curval = curval
- cur_time = time.time()
- if cur_time - self.last_update >= self.min_display_latency:
- self.last_update = cur_time
- self.display()
-
- def display(self):
- raise NotImplementedError(self)
-
-def open_file(filename=None):
- if filename is None:
- f = sys.stderr
- elif filename == "-":
- f = sys.stdout
- else:
- try:
- filename = os.path.expanduser(filename)
- f = open(filename, "a")
- except (IOError, OSError), e:
- sys.stderr.write("%s\n" % e)
- sys.exit(e.errno)
- return f
-
-def create_log(name="", logfile=None, loglevel=0):
- import logging
- log = logging.getLogger(name)
- log.setLevel(loglevel)
- handler = logging.StreamHandler(open_file(logfile))
- handler.setFormatter(logging.Formatter("%(levelname)s %(message)s"))
- log.addHandler(handler)
- return log
-
-def is_interrupt(e):
- if isinstance(e, (SystemExit, KeyboardInterrupt)):
- return True
- return hasattr(e, "errno") and e.errno == errno.EINTR
-
-def mirror_cache(valid_nodes_iterable, src_cache, trg_cache, log,
- eclass_cache, cleanse_on_transfer_failure):
-
- cleanse_candidates = set(trg_cache.iterkeys())
- update_count = 0
-
- # Since the loop below is mission critical, we continue after *any*
- # exception that is not an interrupt.
-
- for x in valid_nodes_iterable:
- log.debug("%s mirroring" % x)
- if not cleanse_on_transfer_failure:
- cleanse_candidates.discard(x)
-
- try:
- entry = copy_dict(src_cache[x])
- except KeyError, e:
- log.error("%s missing source: %s" % (x, str(e)))
- del e
- continue
- except Exception, e:
- if is_interrupt(e):
- raise
- log.error("%s reading source: %s" % (x, str(e)))
- del e
- continue
-
- write_it = True
- trg = None
-
- try:
- trg = copy_dict(trg_cache[x])
- if long(trg["_mtime_"]) == long(entry["_mtime_"]) and \
-
eclass_cache.is_eclass_data_valid(trg["_eclasses_"]) and \
- set(trg["_eclasses_"]) ==
set(entry["_eclasses_"]):
- write_it = False
- except KeyError:
- pass
- except Exception, e:
- if is_interrupt(e):
- raise
- log.error("%s reading target: %s" % (x, str(e)))
- del e
-
- if trg and not write_it:
- """ We don't want to skip the write unless we're really
sure that
- the existing cache is identical, so don't trust _mtime_
and
- _eclasses_ alone."""
- for d in (entry, trg):
- if "EAPI" in d and d["EAPI"] in ("", "0"):
- del d["EAPI"]
- for k in set(chain(entry, trg)).difference(
- ("_mtime_", "_eclasses_")):
- if trg.get(k, "") != entry.get(k, ""):
- write_it = True
- break
-
- if write_it:
- update_count += 1
- log.info("%s transferring" % x)
- inherited = entry.get("INHERITED", None)
- if inherited:
- if src_cache.complete_eclass_entries:
- if not "_eclasses_" in entry:
- log.error("%s missing
_eclasses_" % x)
- continue
- if not
eclass_cache.is_eclass_data_valid(entry["_eclasses_"]):
- log.error("%s stale _eclasses_"
% x)
- continue
- else:
- entry["_eclasses_"] =
eclass_cache.get_eclass_data(entry["INHERITED"].split(), \
- from_master_only=True)
- if not entry["_eclasses_"]:
- log.error("%s stale _eclasses_"
% x)
- continue
- try:
- trg_cache[x] = entry
- cleanse_candidates.discard(x)
- except Exception, e:
- if is_interrupt(e):
- raise
- log.error("%s writing target: %s" % (x, str(e)))
- del e
- else:
- cleanse_candidates.discard(x)
-
- if not trg_cache.autocommits:
- try:
- trg_cache.commit()
- except Exception, e:
- if is_interrupt(e):
- raise
- log.error("committing target: %s" % str(e))
- del e
-
- return update_count, cleanse_candidates
-
-def copy_dict(src, dest=None):
- """Some cache implementations throw cache errors when accessing the
values.
- We grab all the values at once here so that we don't have to be
concerned
- about exceptions later."""
- if dest is None:
- dest = {}
- for k, v in src.iteritems():
- dest[k] = v
- return dest
-
-class ListPackages(object):
- def __init__(self, portdb, log, shuffle=False):
- self._portdb = portdb
- self._log = log
- self._shuffle = shuffle
-
- def run(self):
- log = self._log
- cp_list = self._portdb.cp_list
- cp_all = self._portdb.cp_all()
- if self._shuffle:
- from random import shuffle
- shuffle(cp_all)
- else:
- cp_all.sort()
- cpv_all = []
- # Since the loop below is mission critical, we continue after
*any*
- # exception that is not an interrupt.
- for cp in cp_all:
- log.debug("%s cp_list" % cp)
- try:
- cpv_all.extend(cp_list(cp))
- except Exception, e:
- if is_interrupt(e):
- raise
- self._log.error("%s cp_list: %s" % (cp, str(e)))
-
- self.cpv_all = cpv_all
-
-class MetadataGenerate(object):
- """When cache generation fails for some reason, cleanse the stale cache
- entry if it exists. This prevents the master mirror from distributing
- stale cache, and will allow clients to safely assume that all cache is
- valid. The mtime requirement is especially annoying due to bug #139134
- (timestamps of cache entries don't change when an eclass changes) and
the
- interaction of timestamps with rsync."""
- def __init__(self, portdb, cpv_all, log):
- self._portdb = portdb
- self._cpv_all = cpv_all
- self._log = log
-
- def run(self, onProgress=None):
- log = self._log
- portdb = self._portdb
- cpv_all = self._cpv_all
- auxdb = portdb.auxdb[portdb.porttree_root]
- cleanse_candidates = set(auxdb.iterkeys())
-
- # Since the loop below is mission critical, we continue after
*any*
- # exception that is not an interrupt.
- maxval = len(cpv_all)
- curval = 0
- if onProgress:
- onProgress(maxval, curval)
- while cpv_all:
- cpv = cpv_all.pop(0)
- log.debug("%s generating" % cpv)
- try:
- portdb.aux_get(cpv, ["EAPI"])
- # Cleanse if the above doesn't succeed (prevent
clients from
- # receiving stale cache, and let them assume it
is valid).
- cleanse_candidates.discard(cpv)
- except Exception, e:
- if is_interrupt(e):
- raise
- log.error("%s generating: %s" % (cpv, str(e)))
- del e
- curval += 1
- if onProgress:
- onProgress(maxval, curval)
-
- self.target_cache = auxdb
- self.dead_nodes = cleanse_candidates
-
-class MetadataTransfer(object):
- def __init__(self, portdb, cpv_all, forward,
cleanse_on_transfer_failure,
- log):
- self._portdb = portdb
- self._cpv_all = cpv_all
- self._log = log
- self._forward = forward
- self._cleanse_on_transfer_failure = cleanse_on_transfer_failure
-
- def run(self, onProgress=None):
- log = self._log
- portdb = self._portdb
- cpv_all = self._cpv_all
- aux_cache = portdb.auxdb[portdb.porttree_root]
- import portage
- auxdbkeys = portage.auxdbkeys[:]
- metadbmodule =
portdb.mysettings.load_best_module("portdbapi.metadbmodule")
- portdir_cache = metadbmodule(portdb.porttree_root,
"metadata/cache",
- auxdbkeys)
-
- maxval = len(cpv_all)
- curval = 0
- if onProgress:
- onProgress(maxval, curval)
- class pkg_iter(object):
- def __init__(self, pkg_list, onProgress=None):
- self.pkg_list = pkg_list
- self.maxval = len(pkg_list)
- self.curval = 0
- self.onProgress = onProgress
- def __iter__(self):
- while self.pkg_list:
- yield self.pkg_list.pop()
- self.curval += 1
- if self.onProgress:
- self.onProgress(self.maxval,
self.curval)
-
- if self._forward:
- src_cache = portdir_cache
- trg_cache = aux_cache
- else:
- src_cache = aux_cache
- trg_cache = portdir_cache
-
- """ This encapsulates validation of eclass timestamps and also
fills in
- missing data (mtimes and/or paths) as necessary for the given
cache
- format."""
- eclass_cache = portage.eclass_cache.cache(portdb.porttree_root)
-
- if not trg_cache.autocommits:
- trg_cache.sync(100)
-
- self.target_cache = trg_cache
- self.update_count, self.dead_nodes = mirror_cache(
- pkg_iter(cpv_all, onProgress=onProgress),
- src_cache, trg_cache, log, eclass_cache,
- self._cleanse_on_transfer_failure)
-
-class CacheCleanse(object):
- def __init__(self, auxdb, dead_nodes, log):
- self._auxdb = auxdb
- self._dead_nodes = dead_nodes
- self._log = log
- def run(self):
- auxdb = self._auxdb
- log = self._log
- for cpv in self._dead_nodes:
- try:
- log.info("%s cleansing" % cpv)
- del auxdb[cpv]
- except Exception, e:
- if is_interrupt(e):
- raise
- log.error("%s cleansing: %s" % (cpv, str(e)))
- del e
-
-def import_portage():
- try:
- from portage import data as portage_data
- except ImportError:
- import portage_data
- # If we're not already root or in the portage group, we make the gid of
the
- # current process become portage_gid.
- if os.getgid() != 0 and portage_data.portage_gid not in os.getgroups():
- portage_data.portage_gid = os.getgid()
- portage_data.secpass = 1
-
- os.environ["PORTAGE_LEGACY_GLOBALS"] = "false"
- import portage
- del os.environ["PORTAGE_LEGACY_GLOBALS"]
- return portage
-
-def create_portdb(portdir=None, cachedir=None, config_root=None,
- target_root=None, profile=None, **kwargs):
-
- if cachedir is not None:
- os.environ["PORTAGE_DEPCACHEDIR"] = cachedir
- if config_root is None:
- config_root = os.environ.get("PORTAGE_CONFIGROOT", "/")
- if target_root is None:
- target_root = os.environ.get("ROOT", "/")
- if profile is None:
- profile = ""
-
- portage = import_portage()
- try:
- from portage import const as portage_const
- except ImportError:
- import portage_const
-
- # Disable overlays because we only generate metadata for the main repo.
- os.environ["PORTDIR_OVERLAY"] = ""
- conf = portage.config(config_profile_path=profile,
- config_incrementals=portage_const.INCREMENTALS,
- target_root=target_root,
- config_root=config_root)
-
- if portdir is None:
- portdir = conf["PORTDIR"]
-
- # The cannonical path is the key for portdb.auxdb.
- portdir = os.path.realpath(portdir)
- conf["PORTDIR"] = portdir
- conf.backup_changes("PORTDIR")
-
- portdb = portage.portdbapi(portdir,
- mysettings=conf)
-
- return portdb
-
-def parse_args(myargv):
- description = "This program will ensure that the metadata cache is up
to date for entire portage tree."
- usage = "usage: cache-tools [options] --generate || --transfer"
- from optparse import OptionParser
- parser = OptionParser(description=description, usage=usage)
- parser.add_option("--portdir",
- help="location of the portage tree",
- dest="portdir")
- parser.add_option("--cachedir",
- help="location of the metadata cache",
- dest="cachedir")
- parser.add_option("--profile",
- help="location of the profile",
- dest="profile")
- parser.add_option("--generate",
- help="generate metadata as necessary to ensure that the cache
is fully populated",
- action="store_true", dest="generate", default=False)
- parser.add_option("--shuffle",
- help="generate cache in random rather than sorted order (useful
to prevent two separate instances from competing to generate metadata for the
same packages simultaneously)",
- action="store_true", dest="shuffle", default=False)
- parser.add_option("--transfer",
- help="transfer metadata from portdir to cachedir or vice versa",
- action="store_true", dest="transfer", default=False)
- parser.add_option("--cleanse-on-transfer-failure",
- help="cleanse target cache when transfer fails for any reason
(such as the source being unavailable)",
- action="store_true", dest="cleanse_on_transfer_failure",
default=False)
- parser.add_option("--forward",
- help="forward metadata transfer flows from portdir to cachedir
(default)",
- action="store_true", dest="forward", default=True)
- parser.add_option("--reverse",
- help="reverse metadata transfer flows from cachedir to portdir",
- action="store_false", dest="forward", default=True)
- parser.add_option("--logfile",
- help="send status messages to a file (default is stderr)",
- dest="logfile", default=None)
- parser.add_option("--loglevel",
- help="numeric log level (defauls to 0 and may range from 0 to
50 corresponding to the default levels of the python logging module)",
- dest="loglevel", default="0")
- parser.add_option("--reportfile",
- help="send a report to a file",
- dest="reportfile", default=None)
- parser.add_option("--spawn-outfile",
- help="redirect ouput of spawned processes to a file instead of
stdout/stderr",
- dest="spawn_outfile", default=None)
- parser.add_option("--no-progress",
- action="store_false", dest="progress", default=True,
- help="disable progress output to tty")
- options, args = parser.parse_args(args=myargv)
-
- # Conversion to dict allows us to use **opts as function args later on.
- opts = {}
- all_options = ("portdir", "cachedir", "profile", "progress", "logfile",
- "loglevel", "generate", "transfer", "forward", "shuffle",
- "spawn_outfile", "reportfile", "cleanse_on_transfer_failure")
- for opt_name in all_options:
- v = getattr(options, opt_name)
- opts[opt_name] = v
- return opts
-
-def run_command(args):
- opts = parse_args(sys.argv[1:])
-
- if opts["spawn_outfile"]:
- fd = os.dup(1)
- sys.stdout = os.fdopen(fd, 'w')
- fd = os.dup(2)
- sys.stderr = os.fdopen(fd, 'w')
- f = open_file(opts["spawn_outfile"])
- os.dup2(f.fileno(), 1)
- os.dup2(f.fileno(), 2)
- del fd, f
-
- console = ConsoleUpdate()
- if not opts["progress"] or not sys.stdout.isatty():
- console.quiet = True
- job = None
- import signal, thread, threading
- shutdown_initiated = threading.Event()
- shutdown_complete = threading.Event()
- def shutdown_console():
- console.acquire()
- try:
- console.update("Interrupted.")
- console.newLine()
- console.quiet = True
- shutdown_complete.set()
- # Kill the main thread if necessary.
- # This causes the SIGINT signal handler to be invoked
in the
- # main thread. The signal handler needs to be an actual
- # callable object (rather than something like
signal.SIG_DFL)
- # in order to avoid TypeError: 'int' object is not
callable.
- thread.interrupt_main()
- thread.exit()
- finally:
- console.release()
-
- def handle_interrupt(*args):
- if shutdown_complete.isSet():
- sys.exit(1)
- # Lock the console from a new thread so that the main thread is
allowed
- # to cleanly complete any console interaction that may have
been in
- # progress when this interrupt arrived.
- if not shutdown_initiated.isSet():
- thread.start_new_thread(shutdown_console, ())
- shutdown_initiated.set()
-
- signal.signal(signal.SIGINT, handle_interrupt)
- signal.signal(signal.SIGTERM, handle_interrupt)
-
- try:
- import datetime
- datestamp = str(datetime.datetime.now())
- time_begin = time.time()
- log = create_log(name="MetadataGenerate",
- logfile=opts["logfile"], loglevel=int(opts["loglevel"]))
- if opts["reportfile"]:
- reportfile = open_file(opts["reportfile"])
- portdb = create_portdb(**opts)
- try:
- os.nice(int(portdb.mysettings.get("PORTAGE_NICENESS",
"0")))
- except (OSError, ValueError), e:
- log.error("PORTAGE_NICENESS failed: '%s'" % str(e))
- del e
-
- job = ListPackages(portdb, log, shuffle=opts["shuffle"])
- console.update("Listing packages in repository...")
- job.run()
- cpv_all = job.cpv_all
- total_count = len(cpv_all)
- if opts["generate"]:
- job = MetadataGenerate(portdb, cpv_all, log)
- name = "Cache generation"
- complete_msg = "Metadata generation is complete."
- elif opts["transfer"]:
- job = MetadataTransfer(portdb, cpv_all, opts["forward"],
- opts["cleanse_on_transfer_failure"], log)
- if opts["forward"]:
- name = "Forward transfer"
- complete_msg = "Forward metadata transfer is
complete."
- else:
- name = "Reverse transfer"
- complete_msg = "Reverse metadata transfer is
complete."
- else:
- sys.stderr.write("required options: --generate ||
--transfer\n")
- sys.exit(os.EX_USAGE)
- job.opts = opts
-
- onProgress = None
- if not console.quiet:
- ui = ConsoleProgress(name=name, console=console)
- progressHandler = ProgressHandler()
- onProgress = progressHandler.onProgress
- def display():
- ui.displayProgress(progressHandler.curval,
progressHandler.maxval)
- progressHandler.display = display
-
- job.run(onProgress=onProgress)
-
- if not console.quiet:
- # make sure the final progress is displayed
- progressHandler.display()
-
- update_count = None
- if opts["transfer"]:
- update_count = job.update_count
- target_cache = job.target_cache
- dead_nodes = job.dead_nodes
- cleanse_count = len(dead_nodes)
- console.update("Cleansing cache...")
- job = CacheCleanse(target_cache, dead_nodes, log)
- job.run()
- console.update(complete_msg)
- console.newLine()
- time_end = time.time()
- if opts["reportfile"]:
- width = 20
- reportfile.write(name.ljust(width) + "%s\n" % datestamp)
- reportfile.write("Elapsed seconds".ljust(width) +
"%f\n" % (time_end - time_begin))
- reportfile.write("Total packages".ljust(width) + "%i\n"
% total_count)
- if update_count is not None:
- reportfile.write("Updated
packages".ljust(width) + "%i\n" % update_count)
- reportfile.write("Cleansed packages".ljust(width) +
"%i\n" % cleanse_count)
- reportfile.write(("-"*50)+"\n")
- except Exception, e:
- if not is_interrupt(e):
- raise
- del e
- handle_interrupt()
- sys.exit(0)
-
-if __name__ == "__main__":
- run_command(sys.argv[1:])
diff --git a/scripts/run_catalyst b/scripts/run_catalyst
deleted file mode 100755
index 997f6520..00000000
--- a/scripts/run_catalyst
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash
-sudo /release/bin/sudo_catalyst "$@"
diff --git a/scripts/run_official b/scripts/run_official
deleted file mode 100755
index dfb29f25..00000000
--- a/scripts/run_official
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/bin/bash
-
-email_from="auto"
-email_to="[email protected]"
-url="https://poseidon.amd64.dev.gentoo.org/snapshots";
-snapshot_uri="/release/webroot/snapshots"
-svn_repo="/release/repos/snapshot-tree"
-
-send_email() {
- subject="[Snapshot] ${1}"
-
- echo -e "From: ${email_from}\r\nTo: ${email_to}\r\nSubject:
${subject}\r\n\r\nA new snapshot has been built from revision `svnlook history
${svn_repo} | head -n 3 | tail -n 1 | sed -e 's:^ *::' -e 's: .*$::'` of
${svn_repo}. You can find it at ${url}.\r\n\r\n$(cat
/release/snapshots/portage-${1}.tar.bz2.DIGESTS)\r\n" | /usr/sbin/sendmail -f
${email_from} ${email_to}
-}
-
-if [ "${email_from}" == "auto" ]
-then
- username="$(whoami)"
- if [ "${username}" == "root" ]
- then
- email_from="[email protected]"
- else
- email_from="${username}@gentoo.org"
- fi
-fi
-
-sudo /release/bin/sudo_official "$@" && \
-echo "Starting rsync from /release/snapshots/portage-${1}.tar.bz2* to
${snapshot_uri}" && \
-rsync --archive --stats --progress /release/snapshots/portage-${1}.tar.bz2* \
- ${snapshot_uri}
-ret=$?
-
-if [ "${email_from}" == "none" ]
-then
- echo "Skipping email step as configured..."
-else
- [ $ret -eq 0 ] && send_email ${1}
-fi
-
-exit $ret
diff --git a/scripts/run_snapshot b/scripts/run_snapshot
deleted file mode 100755
index 20cc4609..00000000
--- a/scripts/run_snapshot
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash
-sudo /release/bin/sudo_snapshot "$@"
diff --git a/scripts/stage_build.sh b/scripts/stage_build.sh
deleted file mode 100755
index 46902c1e..00000000
--- a/scripts/stage_build.sh
+++ /dev/null
@@ -1,162 +0,0 @@
-#!/bin/bash
-
-PID=$$
-
-profile=
-version_stamp=
-subarch=
-stage1_seed=
-snapshot=
-config=/etc/catalyst/catalyst.conf
-email_from="catalyst@localhost"
-email_to="root@localhost"
-verbose=0
-
-usage() {
- msg=$1
-
- if [ -n "${msg}" ]; then
- echo -e "${msg}\n";
- fi
-
- cat <<EOH
-Usage:
- stage_build [-p|--profile <profile>] [-v|--version-stamp <stamp>]
- [-a|--arch <arch>] [-s|--stage1-seed <seed>] [--verbose]
- [-f|--email-from <from>] [-t|--email-to <to>] [-h|--help]
-
-Options:
- -p|--profile Sets the portage profile (required)
- -v|--version-stamp Sets the version stamp (required)
- -a|--arch Sets the 'subarch' in the spec (required)
- -s|--stage1-seed Sets the seed for the stage1 (required)
- -S|--snapshot Sets the snapshot name (if not given defaults to today's
- date)
- -c|--config catalyst config to use, defaults to catalyst default
- --verbose Send output of commands to console as well as log
- -f|--email-from Sets the 'From' on emails sent from this script (defaults
- to catalyst@localhost)
- -t|--email-to Sets the 'To' on emails sent from this script (defaults
- to root@localhost)
- -h|--help Show this message and quit
-
-Example:
- stage_build -p default-linux/x86/2006.1 -v 2007.0_pre -a i686 -s
default/stage3-i686-2006.1
-EOH
-}
-
-send_email() {
- subject="[${subarch}] $1"
- body=$2
-
- echo -e "From: ${email_from}\r\nTo: ${email_to}\r\nSubject:
${subject}\r\n\r\nArch: ${subarch}\r\nProfile: ${profile}\r\nVersion stamp:
${version_stamp}\r\nStage1 seed: ${stage1_seed}\r\nSnapshot:
${snapshot}\r\n\r\n${body}\r\n" | /usr/sbin/sendmail -f ${email_from}
${email_to}
-}
-
-run_cmd() {
- cmd=$1
- logfile=$2
-
- if [ $verbose = 1 ]; then
- ${cmd} 2>&1 | tee ${logfile}
- else
- ${cmd} &> ${logfile}
- fi
-}
-
-# Parse args
-params=${#}
-while [ ${#} -gt 0 ]
-do
- a=${1}
- shift
- case "${a}" in
- -h|--help)
- usage
- exit 0
- ;;
- -p|--profile)
- profile=$1
- shift
- ;;
- -v|--version-stamp)
- version_stamp=$1
- shift
- ;;
- -a|--arch)
- subarch=$1
- shift
- ;;
- -f|--email-from)
- email_from=$1
- shift
- ;;
- -t|--email-to)
- email_to=$1
- shift
- ;;
- -s|--stage1-seed)
- stage1_seed=$1
- shift
- ;;
- -S|--snapshot)
- snapshot=$1
- shift
- ;;
- -c|--config)
- config=$1
- shift
- ;;
- --verbose)
- verbose=1
- ;;
- -*)
- echo "You have specified an invalid option: ${a}"
- usage
- exit 1
- ;;
- esac
-done
-
-# Make sure all required values were specified
-if [ -z "${profile}" ]; then
- usage "You must specify a profile."
- exit 1
-fi
-if [ -z "${version_stamp}" ]; then
- usage "You must specify a version stamp."
- exit 1
-fi
-if [ -z "${subarch}" ]; then
- usage "You must specify an arch."
- exit 1
-fi
-if [ -z "${stage1_seed}" ]; then
- usage "You must specify a stage1 seed."
- exit 1
-fi
-cd /tmp
-
-if [ -z "${snapshot}" ]; then
- snapshot=`date +%Y%m%d`
- run_cmd "catalyst -c ${config} -s '${snapshot}'"
"/tmp/catalyst_build_snapshot.${PID}.log"
- if [ $? != 0 ]; then
- send_email "Catalyst build error - snapshot"
"$(</tmp/catalyst_build_snapshot.${PID}.log)"
- exit 1
- fi
-fi
-
-for i in 1 2 3; do
- echo -e "subarch: ${subarch}\ntarget: stage${i}\nversion_stamp:
${version_stamp}\nrel_type: default\nprofile: ${profile}\nsnapshot:
${snapshot}" > stage${i}.spec
- if [ ${i} = 1 ]; then
- echo "source_subpath: ${stage1_seed}" >> stage${i}.spec
- else
- echo "source_subpath: default/stage$(expr ${i} -
1)-${subarch}-${version_stamp}" >> stage${i}.spec
- fi
- run_cmd "catalyst -a -c ${config} -f stage${i}.spec"
"/tmp/catalyst_build_stage${i}.${PID}.log"
- if [ $? != 0 ]; then
- send_email "Catalyst build error - stage${i}" "$(tail -n 200
/tmp/catalyst_build_stage${i}.${PID}.log)\r\n\r\nFull build log at
/tmp/catalyst_build_stage${i}.${PID}.log"
- exit 1
- fi
-done
-
-send_email "Catalyst build success" "Everything finished successfully."
diff --git a/scripts/sudo_catalyst b/scripts/sudo_catalyst
deleted file mode 100755
index 19ecc90a..00000000
--- a/scripts/sudo_catalyst
+++ /dev/null
@@ -1,28 +0,0 @@
-#!/bin/bash
-
-usage() {
- echo "Usage: $(basename ${0}) <arch> <target> <spec>"
- echo "Where arch is either amd64 or x86, target is default, dev,
hardened,"
- echo "or uclibc, and spec is your spec file."
- echo
-}
-
-if [ -z "$1" -o -z "$2" -o -z "$3" ]
-then
- usage
-else
- target="$(grep target ${3} | cut -d' ' -f2)"
- /usr/bin/catalyst -c /etc/catalyst/${1}-${2}.conf -f ${3} ${4} ${5}
-# && \
-# case ${target} in
-# stage*|grp*|livecd-stage2)
-# echo "Cleaning out ${target} temp files"
-# rel_type="$(grep rel_type ${3} | cut -d' ' -f2)"
-# subarch="$(grep subarch ${3} | cut -d' ' -f2)"
-# version="$(grep version ${3} | cut -d' ' -f2)"
-# storedir="$(grep storedir /etc/catalyst/${1}-${2}.conf
| cut -d\" -f2)"
-# echo "Removing
${storedir}/tmp/${rel_type}/${target}-${subarch}-${version}"
-# rm -rf
${storedir}/tmp/${rel_type}/${target}-${subarch}-${version}
-# ;;
-# esac
-fi
diff --git a/scripts/sudo_official b/scripts/sudo_official
deleted file mode 100755
index 80e7ca04..00000000
--- a/scripts/sudo_official
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/bin/bash
-
-tree="/release/trees/snapshot-tree"
-portdir="${tree}/${1/_beta2/}/portage"
-cache_args="--portdir=${portdir} --cachedir=/release/tmp/depcache"
-
-usage() {
- echo "Usage: $(basename ${0}) <version>"
-}
-
-if [ -z "${1}" ]
-then
- usage
-else
- cd ${tree}
- echo "Clearing out old metadata cache"
- rm -rf ${portdir}/metadata/cache
- echo "Performing a svn up on ${tree}"
- svn up || exit 1
- mkdir -p ${portdir}/metadata/cache
- echo "Recreating portage metadata cache"
- cache-tools.py ${cache_args} --generate || exit 1
- cache-tools.py ${cache_args} --transfer --reverse \
- --cleanse-on-transfer-failure || exit 1
- if [ ! -d ${portdir}/metadata/cache/sys-kernel ]
- then
- echo "Metadata update failed! Bailing out!"
- exit 1
- fi
- catalyst -c /etc/catalyst/snapshot-official.conf -s ${1} \
- -C portdir="${portdir}" || exit 1
- for i in amd64 x86
- do
- for j in default dev hardened uclibc
- do
- cd /release/buildroot/${i}-${j}/snapshots
- rm -f portage-official.tar.bz2 portage-${1}.tar.bz2*
- ln -sf /release/snapshots/portage-${1}.tar.bz2 \
- portage-official.tar.bz2
- ln -sf /release/snapshots/portage-${1}.tar.bz2 \
- portage-${1}.tar.bz2
- ln -sf /release/snapshots/portage-${1}.tar.bz2.DIGESTS \
- portage-${1}.tar.bz2.DIGESTS
- done
- done
-fi
diff --git a/scripts/sudo_snapshot b/scripts/sudo_snapshot
deleted file mode 100755
index 1ba64855..00000000
--- a/scripts/sudo_snapshot
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/bash
-usage() {
- echo "Usage: $(basename ${0}) <version>"
-}
-if [ -z "${1}" ]
-then
- usage
-else
- catalyst -c /etc/catalyst/snapshot.conf -s ${1}
- for i in amd64 x86
- do
- for j in default dev hardened uclibc
- do
- cd /release/buildroot/${i}-${j}/snapshots
- rm -f portage-${1}.tar.bz2
- ln -sf /release/snapshots/portage-${1}.tar.bz2 \
- portage-${1}.tar.bz2
- done
- done
-fi
diff --git a/scripts/update_auto_tree b/scripts/update_auto_tree
deleted file mode 100755
index 029ef703..00000000
--- a/scripts/update_auto_tree
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-PORTDIR="/release/trees/portage-auto/"
-TMPREPO=$(mktemp)
-trap "rm -f $TMPREPO" EXIT
-cat >$TMPREPO <<EOF
-[DEFAULT]
-main-repo = gentoo
-
-[gentoo]
-location = $PORTDIR
-sync-type = rsync
-sync-uri = rsync://rsync.gentoo.org/gentoo-portage
-EOF
-PORTAGE_REPOSITORIES="$(cat $TMPREPO)" FEATURES="$FEATURES -news" emerge
--sync -q
diff --git a/scripts/update_official_tree b/scripts/update_official_tree
deleted file mode 100755
index 55ecea0b..00000000
--- a/scripts/update_official_tree
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-PORTDIR="/release/trees/portage-official/"
-TMPREPO=$(mktemp)
-trap "rm -f $TMPREPO" EXIT
-cat >$TMPREPO <<EOF
-[DEFAULT]
-main-repo = gentoo
-
-[gentoo]
-location = $PORTDIR
-sync-type = rsync
-sync-uri = rsync://rsync.gentoo.org/gentoo-portage
-EOF
-PORTAGE_REPOSITORIES="$(cat $TMPREPO)" FEATURES="$FEATURES -news" emerge
--sync -q
diff --git a/scripts/update_snapshot_tree b/scripts/update_snapshot_tree
deleted file mode 100755
index 76cd00ea..00000000
--- a/scripts/update_snapshot_tree
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-PORTDIR="/release/trees/portage-snapshot/"
-TMPREPO=$(mktemp)
-trap "rm -f $TMPREPO" EXIT
-cat >$TMPREPO <<EOF
-[DEFAULT]
-main-repo = gentoo
-
-[gentoo]
-location = $PORTDIR
-sync-type = rsync
-sync-uri = rsync://rsync.gentoo.org/gentoo-portage
-EOF
-PORTAGE_REPOSITORIES="$(cat $TMPREPO)" FEATURES="$FEATURES -news" emerge
--sync -q
