Merge ~dannf/canonical-server-hwe-utils:redirect-to-pe-repo into canonical-server-hwe-utils:main

[dann frazier]

[Taihsiang Ho (tai271828)]

I did not manage to see the updated README to point to the new repository. Is there a typo or something?

[dann frazier (dannf)]

Nice attention to detail @Tai!

Now added.

Unmerged commits

f8ab178... by dann frazier on 2023-03-23

Clear contents and update README.md to point to new repository

diff --git a/README.md b/README.md
index 9291131..b24b096 100644
--- a/README.md
+++ b/README.md
@@ -1,32 +1,3 @@
-canonical-server-hwe-utils
-==========================
+# This repository has moved #
 
-This package brings a few utilities used internally by the Canonical HWE
-Team; most of them are used directly from the repository working copy, but
-a few can also be installed in the user's home directory or in a virtual
-environment, so they are always available in the current path. It will also
-install the required dependencies automatically.
-
-
-
-Installation
-------------
-
-To install, run a `pip install .` from the repository root, optionally
-using an already created and activated virtual environment. After that, the
-following scripts will be installed in the corresponding `bin` directory:
-
-- labkey: A script tool to manipulate machines in the lab.
-- weekly-rota-init.py: scans a Jenkins server looking for tests which most
-  recent run failed and creates Jira (sub-)tasks accordingly.
-- sbsh: Obtain a jenkins user shell within a ScaleBot deployment.
-
-
-
-
-Upgrade and uninstall
----------------------
-
-To upgrade an already installed copy of the scripts, run `pip install -U .`
-from the repository root; to uninstall the scripts, run
-`pip uninstall canonical-server-hwe-utils`.
+Now located at: [lp:canonical-partner-eng-utils](https://code.launchpad.net/~canonical-partner-eng/canonical-partner-eng-utils/+git/canonical-partner-eng-utils)
diff --git a/installer-test-matrix/config.yaml b/installer-test-matrix/config.yaml
deleted file mode 100644
index af38628..0000000
--- a/installer-test-matrix/config.yaml
+++ /dev/null
@@ -1,33 +0,0 @@
-releases:
-  # The HWE option needs to be added at the 2nd point release
-  jammy:
-    boot-options: [ GA, HWE ]
-  impish:
-    boot-options: [ GA ]
-  hirsute:
-    boot-options: [ GA ]
-  focal:
-    boot-options: [ GA, HWE ]
-  bionic:
-    boot-options: [ GA, HWE ]
-
-# 'coverage: full' is intended for platforms that are covered by an
-# active maintenance engagement. 'coverage: spot' is for certified
-# platforms that are no longer covered by an engagement.
-platforms:
-  crb1s:
-    coverage: spot
-  crb2s:
-    coverage: spot
-  d05:
-    coverage: full
-  mtjade:
-    coverage: full
-    unsupported:
-      releases:
-        bionic:
-          boot-options: GA
-  saber:
-    coverage: spot
-  taishan2280v2:
-    coverage: full
diff --git a/installer-test-matrix/generate-matrix.py b/installer-test-matrix/generate-matrix.py
deleted file mode 100755
index 8c1f161..0000000
--- a/installer-test-matrix/generate-matrix.py
+++ /dev/null
@@ -1,76 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import random
-import sys
-import yaml
-
-
-def is_supported(platform_config, release, boot_option):
-    if "unsupported" not in platform_config.keys():
-        return True
-    if "releases" not in platform_config["unsupported"]:
-        return True
-    if release not in platform_config["unsupported"]["releases"]:
-        return True
-    if "boot-options" not in platform_config["unsupported"]["releases"][release].keys():
-        return False
-    if (
-        boot_option
-        in platform_config["unsupported"]["releases"][release]["boot-options"]
-    ):
-        return False
-    return True
-
-
-if __name__ == "__main__":
-    desc = """
-Generates a random test matrix of platform/kernel/boot method combinations,
-per a policy supplied in a configuration file.
-    """
-    parser = argparse.ArgumentParser(description=desc)
-    parser.add_argument("--config", "-c", default="./config.yaml")
-    parser.add_argument("--release", "-r", required=True)
-    args = parser.parse_args()
-
-    with open(args.config, "r") as f:
-        y = yaml.safe_load(f)
-    release = y["releases"][args.release]
-
-    # Create shuffled lists of the various install
-    # config variables. We'll round-robin through them.
-    boot_options = release["boot-options"][:]
-    random.shuffle(boot_options)
-    media_options = ["iso", "pxe"]
-    random.shuffle(media_options)
-    cd_hdd = ["cd", "usb-hdd"]
-    random.shuffle(cd_hdd)
-
-    for platform in y["platforms"]:
-        p = y["platforms"][platform]
-        done = False
-        for m in range(len(media_options)):
-            if done:
-                break
-            # pop/append pattern creates a circular queue
-            media_type = media_options.pop(0)
-            media_options.append(media_type)
-            for b in range(len(boot_options)):
-                boot_type = boot_options.pop(0)
-                boot_options.append(boot_type)
-                if not is_supported(p, args.release, boot_type):
-                    continue
-                # Alternate between booting the ISO as a CD
-                # and as a USB stick. Both create a nearly identical
-                # install environment, so we don't consider them
-                # separate media types.
-                if media_type == "iso":
-                    media_string = cd_hdd.pop(0)
-                    cd_hdd.append(media_string)
-                else:
-                    media_string = media_type
-                sys.stdout.write("%s %s %s\n" % (platform, media_string, boot_type))
-                if p["coverage"] == "spot":
-                    # We only need 1 case for spot testing
-                    done = True
-                    break
diff --git a/jenkins-scripts/sbsh b/jenkins-scripts/sbsh
deleted file mode 100755
index 5a13ad9..0000000
--- a/jenkins-scripts/sbsh
+++ /dev/null
@@ -1,55 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import subprocess
-import sys
-import yaml
-
-LabHosts = {"1ss": "10.229.0.101", "tremont": "10.228.0.2"}
-
-if __name__ == "__main__":
-    try:
-        idx = sys.argv.index("--")
-        argv = sys.argv[1:idx]
-        cmd = sys.argv[idx + 1 :]
-    except ValueError:
-        argv = sys.argv[1:]
-        cmd = []
-
-    parser = argparse.ArgumentParser(
-        description="Obtain a jenkins user shell within a ScaleBot deployment"
-    )
-    parser.add_argument("-l", "--lab", choices=LabHosts.keys(), required=True)
-    args = parser.parse_args(args=argv)
-
-    juju_proc = subprocess.run(
-        [
-            "ssh",
-            "-t",
-            f"ubuntu@{LabHosts[args.lab]}",
-            "juju",
-            "status",
-            "--format=yaml",
-        ],
-        check=True,
-        capture_output=True,
-    )
-
-    status = yaml.safe_load(juju_proc.stdout)
-    unit_name = list(status["applications"]["jenkins"]["units"].keys())[0]
-    juju_cmd = [
-        "ssh",
-        "-t",
-        f"ubuntu@{LabHosts[args.lab]}",
-        "juju",
-        "ssh",
-        unit_name,
-        "sudo",
-        "su",
-        "-",
-        "jenkins",
-    ]
-    if cmd:
-        juju_cmd.extend(["-c", f"\"'{' '.join(cmd)}'\""])
-
-    subprocess.run(juju_cmd)
diff --git a/jenkins-scripts/weekly-rota-init.py b/jenkins-scripts/weekly-rota-init.py
deleted file mode 100755
index 7c2d663..0000000
--- a/jenkins-scripts/weekly-rota-init.py
+++ /dev/null
@@ -1,294 +0,0 @@
-#!/usr/bin/env python3
-
-#
-# This script scans a Jenkins server instance for jobs that did not pass in
-# their most recent runs. It then generates a primary Jira task for that
-# lab/week, and attaches to it a set of sub-tasks (one per unsuccessful test)
-# that can be used for tracking the analysis of those potential failures. The
-# created jobs are automatically assigned to the owner of the API token used to
-# authenticate to Jira.
-#
-# Jira authentication requires an API user field and an API token. This
-# script expects to find them in the JIRA_API_USER and JIRA_API_TOKEN
-# environment variables, respectively.
-#
-# The Jenkins endpoint and credentials are supplied via command line options.
-#
-
-import argparse
-import datetime
-import jenkins
-import logging
-import os
-import re
-import requests
-import tempfile
-from jira import JIRA
-
-JIRA_URL = "https://warthogs.atlassian.net"
-# The lane to which new cards will be moved
-JIRA_INITIAL_TRANSITION = "In Progress"
-
-Subnet2LabNameMap = {
-    "10.228": "Tremont",
-    "10.229": "Needham",
-}
-
-
-def jenkins_url_to_lab_name(url):
-    r = re.compile(r"http://(?P<subnet>[0-9]+\.[0-9]+)\.")
-    m = r.match(url)
-    try:
-        return Subnet2LabNameMap[m.group("subnet")]
-    except IndexError:
-        return "Unknown Lab Subnet"
-
-
-if __name__ == "__main__":
-    desc = """
-    Parse a Jenkins Atom feed and create Jira cards for
-    any unexpected failures.
-    """
-    logging.basicConfig(level=logging.INFO)
-    parser = argparse.ArgumentParser(description=desc)
-    parser.add_argument(
-        "-j",
-        "--jenkins-url",
-        help="Jenkins URL, e.g. http://localhost:8080",
-        required=True,
-        dest="jenkins_url",
-    )
-    parser.add_argument(
-        "-u",
-        "--jenkins-user",
-        help="Jenkins username",
-        required=True,
-        dest="jenkins_user",
-    )
-    parser.add_argument(
-        "-p",
-        "--jenkins-password",
-        help="Jenkins password",
-        required=True,
-        dest="jenkins_password",
-    )
-    parser.add_argument(
-        "-k",
-        "--jira-project-key",
-        help="JIRA project key to use. This argument is useful when you need to test the script result in JIRA without messing up the default project. (Default: SHENG)",
-        required=False,
-        default="SHENG",
-        dest="jira_project_key",
-    )
-    parser.add_argument(
-        "--dry-run",
-        help="Don't make any updates to Jira, just report what it would do.",
-        default=False,
-        action="store_true",
-    )
-    args = parser.parse_args()
-
-    labname = jenkins_url_to_lab_name(args.jenkins_url)
-    jenkins_server = jenkins.Jenkins(
-        args.jenkins_url,
-        username=args.jenkins_user,
-        password=args.jenkins_password,
-    )
-
-    jira_project_key = args.jira_project_key
-
-    today = datetime.date.today()
-    monday = today - datetime.timedelta(days=today.weekday())
-    weeknum = monday.isocalendar()[1]
-    prefix = (
-        f"[{monday.year}W{weeknum:02}][{monday.year}-{monday.month:02}-{monday.day:02}]"
-    )
-    title = f"Review weekend {labname} lab tests"
-
-    JIRA_API_USER = os.environ["JIRA_API_USER"]
-    JIRA_API_TOKEN = os.environ["JIRA_API_TOKEN"]
-
-    jira = JIRA(
-        options={
-            "server": JIRA_URL,
-        },
-        basic_auth=(JIRA_API_USER, JIRA_API_TOKEN),
-    )
-
-    summary = f"{prefix} {title}"
-    description = "||Job Name||Last Run||Status||Cause By||\n"
-    if args.dry_run:
-        logging.info(f'[dry-run] Creating task for "{summary}"')
-    else:
-        primary = jira.create_issue(
-            fields={
-                "summary": summary,
-                "project": {
-                    "key": jira_project_key,
-                },
-                "issuetype": {
-                    "name": "Task",
-                    "subtask": False,
-                },
-                "components": [
-                    {
-                        "name": "Scalebot Rota Review",
-                    },
-                ],
-                "assignee": {"id": jira.myself()["accountId"]},
-            }
-        )
-        # Adding a link to the Launchpad bug into the JIRA entry
-        link = {
-            "url": "https://docs.google.com/document/d/1ui1sHSSNPaqV9K1p9IQrHS0Qrb0TUTcSKU5hHMEQoQ8/edit",
-            "title": "Instructions",
-        }
-        jira.add_simple_link(primary, object=link)
-    if args.dry_run:
-        logging.info(
-            f'[dry-run] Transitioning "{summary}" to {JIRA_INITIAL_TRANSITION}'
-        )
-    else:
-        jira.transition_issue(primary, JIRA_INITIAL_TRANSITION)
-        logging.info(f"Primary issue: {primary.permalink()}")
-
-    for job in jenkins_server.get_jobs():
-        last_build = jenkins_server.get_job_info(job["name"])["lastCompletedBuild"]
-        last_successful_build = jenkins_server.get_job_info(job["name"])[
-            "lastSuccessfulBuild"
-        ]
-        last_failed_build = jenkins_server.get_job_info(job["name"])["lastFailedBuild"]
-        if last_build is None:
-            logging.info(
-                f"{job['name']} has never been run. Is this jenkins project just created?"
-            )
-            continue
-        if last_successful_build is None:
-            last_successful_build_number = -1
-        else:
-            last_successful_build_number = last_successful_build["number"]
-        if last_failed_build is None:
-            last_failed_build_number = -1
-        else:
-            last_failed_build_number = last_failed_build["number"]
-
-        if last_successful_build_number > last_failed_build_number:
-            last_build_number = last_successful_build_number
-        else:
-            last_build_number = last_failed_build_number
-
-        logging.info(
-            f"{job['name']} Last build: #{last_build['number']} Last success: #{last_successful_build_number} Last failed: #{last_failed_build_number}"
-        )
-
-        if last_build_number == -1:
-            logging.info(f"{job['name']} has never been run successfully, skipping")
-            continue
-
-        build_info = jenkins_server.get_build_info(job["name"], last_build_number)
-        result = build_info["result"]
-        timestamp = datetime.datetime.fromtimestamp(
-            int(build_info["timestamp"] / 1000)
-        ).strftime("%Y-%m-%d")
-        url = build_info["url"]
-        logging.info(
-            f"{job['name']} #{last_build_number} status is {result} time: {build_info['timestamp']}"
-        )
-        artifacts = build_info["artifacts"]
-
-        # Save all job's status to the task's description
-        stale = ""
-        if (
-            datetime.datetime.now().timestamp() - build_info["timestamp"] / 1000
-            > 14 * 24 * 60 * 60
-        ):
-            stale = "STALE!"
-        result_color = "black"
-        if result in ["FAILURE"]:
-            result_color = "red"
-
-        description += f"|{job['name']}|[{timestamp}|{url}] {stale}|{{color:{result_color}}}{result}{{color}}| |\n"
-
-        if result in ["SUCCESS"]:
-            logging.info(f"{job['name']} status is {result}, skipping")
-            continue
-
-        # We only want to create one task per job failure. To ensure
-        # that, we need a way to see if a Jira card for this failed job
-        # already exists. Let's define a summary string that uniquely
-        # identifies the job.
-        summary = f"{job['name']} #{last_build_number} {timestamp}"
-        # Check to see if a task already exists for this card. This can
-        # happen for jobs that only run every 2 weeks - there's no need
-        # to investigate a failure twice.
-        duplicates = jira.search_issues(
-            f'project = {jira_project_key} AND summary ~ "{summary}"'
-        )
-        if len(duplicates) > 0:
-            logging.info(f'"{summary}" matches the following existing tasks:')
-            for dup in duplicates:
-                logging.info(f"  {dup.permalink()}")
-            answer = None
-            while answer not in ["n", "no", "y", "yes"]:
-                answer = input("Create anyway? ")
-            if answer in ["n", "no"]:
-                continue
-        if args.dry_run:
-            logging.info(f'[dry-run] Creating subtask for "{summary}"')
-        else:
-            subtask = jira.create_issue(
-                fields={
-                    "summary": summary,
-                    "description": f"{url}",
-                    "project": {
-                        "key": jira_project_key,
-                    },
-                    "issuetype": {
-                        "name": "Sub-task",
-                    },
-                    "parent": {
-                        "key": primary.key,
-                    },
-                    "components": [
-                        {
-                            "name": "Scalebot Rota Review",
-                        },
-                    ],
-                    "assignee": {"id": jira.myself()["accountId"]},
-                }
-            )
-            response = requests.get(
-                f"{url}consoleText",
-                stream=True,
-                auth=(args.jenkins_user, args.jenkins_password),
-            )
-            with tempfile.TemporaryFile() as fp:
-                for chunk in response.iter_content(chunk_size=10 * 1024 * 1024):
-                    fp.write(chunk)
-                jira.add_attachment(subtask, fp, "Jenkins_console")
-
-            for artifact in artifacts:
-                logging.info(f"{url}artifact/{artifact['relativePath']}")
-                response = requests.get(
-                    f"{url}artifact/{artifact['relativePath']}",
-                    stream=True,
-                    auth=(args.jenkins_user, args.jenkins_password),
-                )
-                with tempfile.TemporaryFile() as fp:
-                    for chunk in response.iter_content(chunk_size=10 * 1024 * 1024):
-                        fp.write(chunk)
-                    jira.add_attachment(subtask, fp, artifact["relativePath"])
-
-        if args.dry_run:
-            logging.info(
-                f'[dry-run] Transitioning "{summary}" task to {JIRA_INITIAL_TRANSITION}'
-            )
-        else:
-            jira.transition_issue(subtask, JIRA_INITIAL_TRANSITION)
-            logging.info(f"{job['name']} is {result}: {subtask.permalink()}")
-
-    if args.dry_run:
-        logging.info(f"[dry-run] Update description {description}")
-    else:
-        desc_value = {"description": description}
-        primary.update(fields=desc_value)
diff --git a/labkey b/labkey
deleted file mode 100755
index ea4e707..0000000
--- a/labkey
+++ /dev/null
@@ -1,419 +0,0 @@
-#!/usr/bin/env python3
-"""
-A script tool to manipulate machines in the lab.
-
-Requirements:
-    - python 3.6 or above (if you want to launch pre-commit hook, you need 3.8)
-    - pyyml python package (via pip)
-    - ipmi tools (for ubuntu users it could be installed via apt)
-"""
-
-import argparse
-import os
-import os.path
-import shutil
-import subprocess
-import sys
-import yaml
-
-ProgName = "labkey"
-Config = os.path.join(os.environ["HOME"], ".config", ProgName)
-ScaleBotLocal = os.path.join(Config, "scalebot-repo")
-
-
-def handle_default_branch_rename():
-    """
-    We've renamed the default branch from "master" to "main". Migrate
-    the local clone if necessary.
-    """
-    local_branch = (
-        subprocess.check_output(["git", "branch", "--show-current"])
-        .decode("UTF-8")
-        .split()[0]
-    )
-    if local_branch == "main":
-        return
-    # Unknown state; bail to avoid doing any damage
-    assert local_branch == "master"
-    sys.stderr.write('Migrating local default branch name to "main"...\n')
-    subprocess.check_call(["git", "branch", "-m", "master", "main"])
-    subprocess.check_call(["git", "fetch"])
-    subprocess.check_call(["git", "branch", "--unset-upstream"])
-    subprocess.check_call(["git", "branch", "-u", "origin/main"])
-    subprocess.check_call(
-        ["git", "symbolic-ref", "refs/remotes/origin/HEAD", "refs/remotes/origin/main"]
-    )
-
-
-def update(lpid, force):
-    if lpid:
-        user = "%s@" % (lpid)
-    else:
-        user = ""
-    if force and os.path.exists(ScaleBotLocal):
-        shutil.rmtree(ScaleBotLocal)
-
-    ScaleBotRemote = "git+ssh://%sgit.launchpad.net/scalebot" % (user)
-    umaskSav = os.umask(int("077", 8))
-    if os.path.exists(ScaleBotLocal):
-        os.chdir(ScaleBotLocal)
-        handle_default_branch_rename()
-        subprocess.run(["git", "pull"], check=True)
-    else:
-        subprocess.run(["git", "clone", ScaleBotRemote, ScaleBotLocal], check=True)
-    os.umask(umaskSav)
-
-
-def loadLabs():
-    config = []
-    labroot = os.path.join(ScaleBotLocal, "labs")
-    for labdir in os.scandir(labroot):
-        if not labdir.is_dir():
-            continue
-        labcfg = {}
-        interesting_yaml = ["lab", "machines", "clouds"]
-        for f in os.scandir(labdir):
-            if f.name[-5:] != ".yaml":
-                continue
-            if f.name[:-5] not in interesting_yaml:
-                continue
-            with open(f.path, "r") as stream:
-                y = yaml.safe_load(stream)
-            labcfg[f.name[:-5]] = y
-        if "lab" not in labcfg.keys():
-            continue
-        config.append(labcfg)
-    return config
-
-
-class YAMLCache:
-    """
-    Save/load an object from a YAML file
-    """
-
-    def __init__(self, path):
-        """
-        path: file to save/load from
-        """
-        self.path = path
-
-    def load(self):
-        try:
-            with open(self.path, "r") as stream:
-                return yaml.safe_load(stream)
-        except FileNotFoundError:
-            return {}
-
-    def save(self, data):
-        oldumask = os.umask(0o077)
-        tmppath = "%s.tmp" % (self.path)
-        with open(tmppath, "w") as tmpfile:
-            yaml.dump(data, tmpfile)
-            os.fsync(tmpfile)
-        os.rename(tmppath, self.path)
-        os.umask(oldumask)
-
-
-class LabMAAS:
-    MAASCreds = os.path.join(Config, "mass-credentials.yaml")
-    MAASHostCache = os.path.join(Config, "maas-host-cache.yaml")
-
-    def __init__(self, endpoint):
-        self.endpoint = endpoint
-        self.client = self._get_client()
-
-    def api_key_prompt(self):
-        """
-        Prompt the user for a MAAS API key and save it for next time
-        """
-        key = input("Enter a MAAS API key for %s: " % (self.endpoint))
-        cache = YAMLCache(self.MAASCreds)
-        y = cache.load()
-        y[self.endpoint] = key
-        cache.save(y)
-        return key
-
-    def get_api_key(self):
-        """
-        Lookup the user's API key for endpoint, fallback to prompting
-        """
-        try:
-            with open(self.MAASCreds, "r") as stream:
-                y = yaml.safe_load(stream)
-            key = y[self.endpoint]
-        except (FileNotFoundError, KeyError):
-            key = self.api_key_prompt()
-        return key
-
-    def get_machine_by_hostname(self, hostname):
-        """
-        Return a MAAS machine object for a given hostname
-        """
-        import maas.client
-
-        machine = None
-        cache = YAMLCache(self.MAASHostCache)
-        y = cache.load()
-        try:
-            maas_id = y[self.endpoint][hostname]
-            machine = self.client.machines.get(system_id=maas_id)
-        except (maas.client.bones.CallError, KeyError):
-            for m in self.client.machines.list(hostnames=[hostname]):
-                if m.hostname == hostname:
-                    machine = m
-                    if self.endpoint not in y.keys():
-                        y[self.endpoint] = {}
-                    y[self.endpoint][hostname] = m.system_id
-                    cache.save(y)
-        return machine
-
-    def _get_client(self):
-        """
-        Return a MAAS client object for the MAAS endpoint where our node
-        resides.
-        """
-        import maas.client
-
-        while True:
-            try:
-                apikey = self.get_api_key()
-                client = maas.client.connect(self.endpoint, apikey=apikey)
-                # Test the client. This will raise maas.client.bones.CallError
-                # if authentication fails
-                client.users.whoami()
-                return client
-            except (maas.client.bones.CallError, AttributeError, ValueError):
-                sys.stderr.write("Unable to authenticate to %s\n" % (self.endpoint))
-                self.api_key_prompt()
-
-
-class Machine:
-    def __init__(self, name):
-        self.name = name
-        labs = loadLabs()
-        for lab in labs:
-            if lab["machines"] is None:
-                continue
-            if name in lab["machines"].keys():
-                self.data = lab["machines"][name]
-                self.labdata = lab["lab"]
-                try:
-                    self.clouddata = lab["clouds"]
-                except KeyError:
-                    # clouds.yaml is only needed for subcommands that
-                    # use MAAS. Those commands will fail later.
-                    pass
-                return
-        raise KeyError("Machine not found")
-
-    def __repr__(self):
-        return yaml.dump(self.data, default_flow_style=False)
-
-    def _do_ipmitool(self, cmd):
-        bmc = self.data["bmc"]
-        if bmc["type"] != "ipmi":
-            raise KeyError("Machine has unknown power type")
-        subprocess.run(
-            [
-                "ipmitool",
-                "-I",
-                "lanplus",
-                "-H",
-                bmc["address"],
-                "-U",
-                bmc["user"],
-                "-P",
-                bmc["password"],
-            ]
-            + cmd,
-            check=True,
-        )
-
-    def mc_reset(self):
-        cmd = ["mc", "reset", "cold"]
-        self._do_ipmitool(cmd)
-
-    def sel_clear(self):
-        cmd = ["sel", "clear"]
-        self._do_ipmitool(cmd)
-
-    def power(self, state):
-        cmd = ["chassis", "power", state]
-        self._do_ipmitool(cmd)
-
-    def open_console(self, force):
-        """
-        Open an interactive console session to the machine.
-        Currently only supports conserver.
-        """
-        # We currently assume that any lab that provides a conserver
-        # will have all machines in that lab connected to the conserver.
-        # Theory is that if labkey can connect to a console, so could
-        # a conserver, and that's the better layer. However, there are
-        # situations where this may not be true. For example, the Moonshot
-        # chassis does not support an active console connection to every
-        # server at the same time like conserver would do, so labkey may
-        # want to support connecting to those systems directly. In which
-        # case, we may need to introduce a per-machine console-type field.
-        if self.labdata and "conserver" in self.labdata.keys():
-            if shutil.which("console") is None:
-                raise OSError(
-                    "'console' command not found. Try 'sudo apt install conserver-client'"
-                )
-            concfg = self.labdata["conserver"]
-            subprocess.run(
-                [
-                    "console",
-                    "-M%s" % (concfg["master"]),
-                    "-p%s" % (concfg["port"]),
-                    self.name,
-                ],
-                stdin=sys.stdin,
-                stdout=sys.stdout,
-                stderr=sys.stderr,
-            )
-            return
-        if "bmc" in self.data.keys() and self.data["bmc"]["type"] == "ipmi":
-            if shutil.which("ipmitool") is None:
-                raise OSError(
-                    "'ipmitool' command not found. Try 'sudo apt install ipmitool'"
-                )
-            if force:
-                self._do_ipmitool(["sol", "deactivate"])
-            self._do_ipmitool(["sol", "activate"])
-            return
-
-        raise Exception("No valid console definition for %s" % (self.name))
-
-    def get_cloud_endpoint(self):
-        if self.labdata is None:
-            raise KeyError("No lab.yaml associated with %s" % (self.name))
-        if not hasattr(self, "clouddata"):
-            raise KeyError("No clouds.yaml associated with %s" % (self.name))
-
-        if self.clouddata["clouds"]["scalebot"]["type"] != "maas":
-            raise KeyError("Cloud is not of type MAAS")
-        endpoint = self.clouddata["clouds"]["scalebot"]["endpoint"]
-        return endpoint
-
-    def ssh(self):
-        if "maas-name" in self.data.keys():
-            hostname = self.data["maas-name"]
-        else:
-            hostname = self.name
-
-        labmaas = LabMAAS(self.get_cloud_endpoint())
-        machine = labmaas.get_machine_by_hostname(hostname)
-        if machine is None:
-            raise KeyError("MAAS Server has no machine with hostname %s" % (hostname))
-        # We use the first IP address we can ping. This is just a heuristic.
-        # It is possible that the node has an IP we can not reach that happens
-        # to match an IP on another host that we can reach, say if we've
-        # picked the same RFC 1918 subnets. In which case, we could connect
-        # to the wrong system.
-        ip = None
-        for address in machine.ip_addresses:
-            try:
-                subprocess.check_call(
-                    ["ping", "-c", "1", address],
-                    stdout=subprocess.DEVNULL,
-                    stderr=subprocess.DEVNULL,
-                )
-                ip = address
-            except subprocess.CalledProcessError:
-                print("Could not ping %s" % (address))
-                continue
-        if ip is None:
-            raise KeyError(
-                "Unable to determine IP address for %s from MAAS" % (hostname)
-            )
-        subprocess.run(["ssh", "-l", "ubuntu", ip])
-
-
-def show_owners(lab):
-    """Print owner-* tags for all machines in the given lab."""
-    lablist = loadLabs()
-    labs = {a["lab"]["name"]: a["machines"] for a in lablist}
-    if lab not in labs.keys():
-        print("Lab %s not found. Valid ones are: %s." % (lab, ", ".join(labs.keys())))
-        return
-    for labhost, machine in labs[lab].items():
-        if "maas-tags" in machine:
-            owners = [tag for tag in machine["maas-tags"] if tag.startswith("owner-")]
-        else:
-            owners = []
-        print("%s: %s" % (labhost, ", ".join(owners)))
-
-
-if __name__ == "__main__":
-    power_cmds = ["on", "off", "cycle", "mc-reset", "reset", "status"]
-    machine_cmds = power_cmds + ["console", "sel-clear", "show", "ssh"]
-    lab_cmds = ["show-owners"]
-    cmd_help = {
-        "show": "Show machine configuration",
-        "on": "Power machine on",
-        "off": "Power machine off",
-        "cycle": "Power cycle machine",
-        "mc-reset": "Perform cold reset of BMC",
-        "sel-clear": "Clear system event log",
-        "reset": "Hard reset machine",
-        "console": "Open a console session",
-        "ssh": "ssh to machine",
-        "status": "Show machine power status",
-        "update": "Update cached machine information",
-        "show-owners": "Print owner-* tags for all machines in a lab",
-    }
-
-    d = "Do things with machines in ScaleBot labs"
-    parser = argparse.ArgumentParser(prog=ProgName, description=d)
-    subparsers = parser.add_subparsers(help="sub-command help")
-    update_parser = subparsers.add_parser("update", help=cmd_help["update"])
-    update_parser.add_argument(
-        "-u", dest="lpid", metavar="LPID", required=False, help="Launchpad ID"
-    )
-    update_parser.add_argument(
-        "-f",
-        dest="force",
-        action="store_true",
-        required=False,
-        help="Flush machine cache before update",
-    )
-    update_parser.set_defaults(cmd="update")
-    for a in machine_cmds:
-        action_parser = subparsers.add_parser(a, help=cmd_help[a])
-        action_parser.add_argument("machine", metavar="MACHINE")
-        action_parser.set_defaults(cmd=a)
-        if a == "console":
-            action_parser.add_argument(
-                "-f",
-                dest="force",
-                action="store_true",
-                required=False,
-                help="Terminate all other console connections to MACHINE if necessary",
-            )
-    for a in lab_cmds:
-        action_parser = subparsers.add_parser(a, help=cmd_help[a])
-        action_parser.add_argument("lab", metavar="LAB")
-        action_parser.set_defaults(cmd=a)
-    args = parser.parse_args()
-
-    if args.cmd == "update":
-        update(lpid=args.lpid, force=args.force)
-        sys.exit(0)
-    elif args.cmd == "show-owners":
-        show_owners(args.lab)
-        sys.exit(0)
-
-    m = Machine(args.machine)
-    if args.cmd == "show":
-        print(m)
-    elif args.cmd == "mc-reset":
-        m.mc_reset()
-    elif args.cmd == "sel-clear":
-        m.sel_clear()
-    elif args.cmd == "console":
-        m.open_console(args.force)
-    elif args.cmd == "ssh":
-        m.ssh()
-    elif args.cmd in power_cmds:
-        m.power(args.cmd)
diff --git a/lp-scripts/LaunchpadBugBucketer.py b/lp-scripts/LaunchpadBugBucketer.py
deleted file mode 100644
index 81e9e99..0000000
--- a/lp-scripts/LaunchpadBugBucketer.py
+++ /dev/null
@@ -1,82 +0,0 @@
-import collections
-import inspect
-from launchpadlib.launchpad import Launchpad
-
-
-class LaunchpadBugBucketer(collections.UserDict):
-    """Sort project bugs into buckets to aide in report generation.
-
-    This is a base class. It is not intended to be used directly. Rather,
-    it should be inherited by subclasses which add their own "bucketing"
-    methods.
-
-    Bucketing methods names begin with the string "is_" and take a bug task
-    parameter. Each bucketing method is called for each task until one
-    matches. The task is then placed in the bucket that it first matches.
-    It is up to the subclass to make sure that each task falls into one and
-    only one bucket.
-
-    A simple two bucket subclass example would be:
-
-    class MyBugBucket(LaunchpadBugBucketer):
-        LaunchpadBugBucketer.__init__(self, 'myproject', 'myseries',
-                                      requiredTags=['patchset'])
-        def is_green(self, task):
-            if task.status in ['Fix Committed', 'Fix Released']:
-                return True
-            return False
-
-        def is_red(self, task):
-            if not self.is_green(task):
-                return True
-            return False
-
-    The returned object can be treated as a dictionary, where the bucketnames
-    (is_BUCKET) are the keys that return a list of bug tasks in that bucket.
-    For example:
-
-    b = MyBugBucket()
-    for task in b['green']:
-        bug = s.tasktoBug(task)
-        sys.stdout.write("%s: %s\n" % (bug.title, task.web_link))
-    """
-
-    def __init__(self, project, series, requiredTags=[]):
-        """
-        Args:
-            project (str): Launchpad project name
-            series (str): A series defined in the given Launchpad project
-            requiredTags (:obj:`list` of :obj:`str`): Only bucket bugs that
-                have one or more tags from this list.
-        """
-        self.lp = Launchpad.login_with("lpbugs", "production", version="devel")
-        self.project = self.lp.projects[project]
-        self.series = series
-        self.requiredTags = requiredTags
-        self._doBucketing()
-        collections.UserDict.__init__(self, self.buckets)
-
-    def taskToBug(self, task):
-        bugid = int(task.self_link.split("/")[-1])
-        return self.lp.bugs[bugid]
-
-    def _doBucketing(self):
-        methods = inspect.getmembers(self, predicate=inspect.ismethod)
-
-        self.buckets = {}
-        for series in self.project.series:
-            if series.name != self.series:
-                continue
-            for task in series.searchTasks():
-                bug = self.taskToBug(task)
-                if not set(self.requiredTags) & set(bug.tags):
-                    continue
-                for mName, mFunc in methods:
-                    if not mName.startswith("is_"):
-                        continue
-                    if mFunc(task):
-                        b = mName[len("is_") :]
-                        if b not in self.buckets.keys():
-                            self.buckets[b] = []
-                        self.buckets[b].append(task)
-                        break
diff --git a/lp-scripts/bandera-bug-csv-summary.py b/lp-scripts/bandera-bug-csv-summary.py
deleted file mode 100755
index 05f84aa..0000000
--- a/lp-scripts/bandera-bug-csv-summary.py
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/usr/bin/python3
-
-import argparse
-import csv
-from LaunchpadBugBucketer import LaunchpadBugBucketer
-
-
-class BanderaBugBucketer(LaunchpadBugBucketer):
-    def __init__(self):
-        LaunchpadBugBucketer.__init__(
-            self, "bandera", "ubuntu-16.04", requiredTags=["patchset"]
-        )
-
-    def is_green(self, task):
-        if task.status in ["Fix Committed", "Fix Released"]:
-            return True
-        return False
-
-    def is_amber(self, task):
-        if self.is_green(task):
-            return False
-        elif task.milestone and task.milestone.name == "ubuntu-16.04.3":
-            return True
-        return False
-
-    def is_red(self, task):
-        if self.is_green(task) or self.is_amber(task):
-            return False
-        return True
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-o", "--outfile")
-    args = parser.parse_args()
-
-    s = BanderaBugBucketer()
-
-    with open(args.outfile, "w") as csvfile:
-        c = csv.writer(csvfile)
-        c.writerow(["Title", "Bug ID", "Importance", "Status", "RAG Risk"])
-        for bucket in s.keys():
-            for task in s[bucket]:
-                bug = s.taskToBug(task)
-                link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
-                c.writerow([bug.title, link, task.importance, task.status, bucket])
diff --git a/lp-scripts/bugreport/README.md b/lp-scripts/bugreport/README.md
deleted file mode 100644
index 253303a..0000000
--- a/lp-scripts/bugreport/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# bugreport
-This tool help with collecting information on bugs, you can use this tool to generate a report on how many bugs were processed 
-during a given timeframe. You can generate a quick summary to show you the number of fix-released, fix-commited, in-progress etc. It also displays some statistics like how long the bug was active, how long it was dormant/inactive etc that might come handy in triaging bugs reported for your project.
-
-# How to invoke the tool:
-## Summary only:
-./bugreport.py -p project -d start date 
-
-Will generate a summary bug report based on importance (ie Critical, High etc).
-
-## Summary with bug details:
-./bugreport.py -p project -d start date -v 
-
-Will generate a summary bug report as above, and detailed report for each bug.
-
-## Summary for bugs by importance (high, medium, low etc)
-./bugreport.py -p project -d start date -i high,medium,low
-
-Please do not use spaces in comma separated list.
-
-# How to create HTML files:
-1. ./bugreport.py -p ubuntu-power-systems -d 2017-08-01 -o out.t2t
-
-Where out.t2t is an ascii text file, you could use the -v option to generate 
-a full report.
-
-2. txt2tags -C htmlconvert.conf -t html out.t2t
-
-This will generate out.html.
-
-## How to create PDF:
-1. Open the out.html in a web browser.
-2. Print and save as PDF.
diff --git a/lp-scripts/bugreport/bugreport.py b/lp-scripts/bugreport/bugreport.py
deleted file mode 100755
index ca9b5b1..0000000
--- a/lp-scripts/bugreport/bugreport.py
+++ /dev/null
@@ -1,232 +0,0 @@
-#! /usr/bin/python
-# Author: Manoj Iyer [e-mail]
-# License: GPLv3
-from launchpadlib.launchpad import Launchpad
-from launchpadlib.uris import LPNET_SERVICE_ROOT
-from optparse import OptionParser
-from re import compile
-from datetime import datetime as dt
-from collections import defaultdict as coldict
-import numpy as np
-import os
-import sys
-
-
-def gen_bug_report(lp, lp_bugs, project, verbose):
-    bug_summary_info = coldict(dict)
-    bug_details_info = coldict(dict)
-    url = compile("https://api.launchpad.net/1.0/~|/")
-
-    for task in lp_bugs:
-        bug_info = {}
-        bug_subtask = []
-
-        if task.status in bug_summary_info[task.importance]:
-            bug_summary_info[task.importance][task.status] += 1
-        else:
-            bug_summary_info[task.importance][task.status] = 1
-
-        if "#Bugs Processed" in bug_summary_info[task.importance]:
-            bug_summary_info[task.importance]["#Bugs Processed"] += 1
-        else:
-            bug_summary_info[task.importance]["#Bugs Processed"] = 1
-
-        if "#Bugs Closed" not in bug_summary_info[task.importance]:
-            bug_summary_info[task.importance]["#Bugs Closed"] = 0
-
-        # A bug could affect multiple projects, we care only whether
-        # the project we are tracking is complete.
-        lp_bug_tasks = lp.bugs[task.bug.id].bug_tasks
-        for bugtask in lp_bug_tasks:
-            if bugtask.bug_target_name in project:
-                bug_is_complete = bugtask.is_complete
-            if verbose is True:
-                bug_subtask.append("%s: %s" % (bugtask.bug_target_name, bugtask.status))
-
-        if bug_is_complete is True:
-            if "#Bugs Closed" in bug_summary_info[task.importance]:
-                bug_summary_info[task.importance]["#Bugs Closed"] += 1
-
-        if verbose is True:
-            inactive_days = 0
-            if bug_is_complete is not True:
-                inactive_days = np.busday_count(
-                    task.bug.date_last_updated.strftime("%Y-%m-%d"),
-                    dt.now().strftime("%Y-%m-%d"),
-                )
-
-            active_days = np.busday_count(
-                task.bug.date_created.strftime("%Y-%m-%d"),
-                task.bug.date_last_updated.strftime("%Y-%m-%d"),
-            )
-
-            assignee = (
-                "Unassigned"
-                if task.assignee_link is None
-                else url.sub("", task.assignee_link)
-            )
-
-            bug_info[task.bug.id] = [
-                task.bug.date_created.strftime("%Y-%m-%d"),
-                task.bug.date_last_updated.strftime("%Y-%m-%d"),
-                active_days,
-                inactive_days,
-                task.bug.message_count,
-                assignee,
-                "''<br>''".join(bug_subtask),
-            ]
-
-            bug_details_info[task.importance].update(bug_info)
-
-    return bug_summary_info, bug_details_info
-
-
-def main():
-    parser = OptionParser(usage="usage: %prog [options]", version="%prog 1.0")
-    parser.add_option(
-        "-d",
-        "--date",
-        dest="start_date",
-        action="store",
-        default="2017-01-01",
-        type="string",
-        help="start date for bug search",
-    )
-    parser.add_option(
-        "-p",
-        "--project",
-        dest="project",
-        action="store",
-        default="ubuntu-power-systems",
-        type="string",
-        help="name of the launchpad project",
-    )
-    parser.add_option(
-        "-s",
-        "--status",
-        dest="bug_status",
-        action="store",
-        default=(
-            "New,Opinion,Invalid,Won't Fix,Expired,"
-            "Confirmed,Triaged,In Progress,Fix Committed,"
-            "Fix Released,Incomplete"
-        ),
-        type="string",
-        help="bug status (or quoted and comma seperated list)",
-    )
-    parser.add_option(
-        "-i",
-        "--importance",
-        dest="bug_importance",
-        default=("Unknown,Undecided,Critical,High,Medium,Low,Wishlist"),
-        type="string",
-        help="bug importance (or comma seperated list, no spaces)",
-    )
-    parser.add_option(
-        "-t",
-        "--tag",
-        dest="bug_tag",
-        default=None,
-        help="bug tag (or quoted and comma seperated list)",
-    )
-    parser.add_option(
-        "-m",
-        "--modify",
-        dest="bug_tag_modify",
-        default="Any",
-        help="search any or all tags (valid args: any or all)",
-    )
-    parser.add_option(
-        "-v",
-        "--verbose",
-        dest="verbose",
-        action="store_true",
-        help="verbose output with bug details",
-    )
-    parser.add_option(
-        "-a",
-        "--author",
-        dest="author",
-        default="Manoj Iyer [e-mail]",
-        help='"Firstname Lastname [e-mail]"',
-    )
-    parser.add_option(
-        "-o",
-        "--outfile",
-        dest="outfile",
-        help="filename to store output (default stdout)",
-    )
-
-    (options, args) = parser.parse_args()
-
-    if len(args) is None:
-        parser.error("No arguments found!")
-
-    script_name = sys.argv[0].split("/")[-1].split(".")[0]
-    cachedir = os.path.expanduser("~/.launchpadlib/cache")
-
-    launchpad = Launchpad.login_with(script_name, LPNET_SERVICE_ROOT, cachedir)
-    lp_project = launchpad.projects[options.project]
-
-    lp_bugs = [
-        task
-        for task in lp_project.searchTasks(
-            created_since=None
-            if options.start_date is None
-            else dt.strptime(options.start_date, "%Y-%m-%d").isoformat(),
-            status=options.bug_status.split(","),
-            importance=options.bug_importance.title().replace(" ", "").split(","),
-            tags=None if options.bug_tag is None else options.bug_tag.split(","),
-            tags_combinator=options.bug_tag_modify.title(),
-        )
-    ]
-
-    with (open(options.outfile, "w") if options.outfile else sys.stdout) as f:
-        f.write(
-            "Bug activity in %s project since %s\n\n\n"
-            % (options.project, options.start_date)
-        )
-        f.write(" || {:<35} | {:<20} |\n".format("Created By", "Date"))
-        f.write("  | [%s]" % (options.author) + " | %%mtime(%A %B %d, %Y) |\n")
-
-        if f is not sys.stdout and options.verbose is True:
-            sys.stdout.write(
-                "Bug activity in %s project since %s\n"
-                % (options.project, options.start_date)
-            )
-            sys.stdout.write("Generating detailed report in %s \n" % options.outfile)
-            sys.stdout.write("Please wait...\n")
-            sys.stdout.flush()
-
-        summary_report, detailed_report = gen_bug_report(
-            launchpad, lp_bugs, options.project, options.verbose
-        )
-
-        for k, v in sorted(summary_report.iteritems()):
-            f.write("\n= Summary of %s bugs =\n" % k)
-            f.write("|| {:<14} | {:<8} |\n".format("Status", "Count"))
-            for x, y in sorted(v.iteritems()):
-                f.write("| {:<15} | {:<8} |\n".format(x, y))
-            if options.verbose is True:
-                f.write("== Details on %s bugs ==\n" % k)
-                f.write(
-                    "|| Bug# | Created | Last Updated | Active Period "
-                    "| Dormant Period | #Comments | Assignee | Status |\n"
-                )
-
-                for a, b in sorted(
-                    detailed_report[k].iteritems(),
-                    key=lambda item: item[1][1],
-                    reverse=True,
-                ):
-                    f.write(
-                        "| [%s https://launchpad.net/bugs/%s] | %s |\n"
-                        % (a, a, " | ".join(map(str, b)))
-                    )
-
-        if f is not sys.stdout:
-            f.close()
-
-
-if __name__ == "__main__":
-    main()
diff --git a/lp-scripts/bugreport/htmlconvert.conf b/lp-scripts/bugreport/htmlconvert.conf
deleted file mode 100644
index 9338612..0000000
--- a/lp-scripts/bugreport/htmlconvert.conf
+++ /dev/null
@@ -1,10 +0,0 @@
-%!options: --toc-level 4
-%!postproc(html): '(?i)(<TH)' '\1 style="text-align:left;"'
-%!postproc(html): '(?i)(<TR)' '\1 style="font-size:11; font-family:ubuntu,sans-serif; text-align:left;"'
-%!postproc(html): <HEAD>      '<HEAD>\n<STYLE TYPE="text/css">\n</STYLE>'
-%!postproc(html): (</STYLE>)  'h1 {color:#740946; font-size:16; font-family:ubuntu,sans-serif;} \n\1'
-%!postproc(html): (</STYLE>)  'h2 {color:#740946; font-size:14; font-family:ubuntu,sans-serif;} \n\1'
-%!postproc(html): (</STYLE>)  'h3 {color:#740946; font-size:12; font-family:ubuntu,sans-serif;} \n\1'
-%!postproc(html): (</STYLE>)  'h4 {color:#740946; font-size:11; font-family:ubuntu,sans-serif;} \n\1'
-%!postproc(html): (</STYLE>)  'body {font-size:11; font-family:ubuntu,sans-serif;;} \n\1'
-
diff --git a/lp-scripts/clone-project-milestones.py b/lp-scripts/clone-project-milestones.py
deleted file mode 100755
index 39099ab..0000000
--- a/lp-scripts/clone-project-milestones.py
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/usr/bin/env python3
-
-#
-# Copy the series and milestones from one project to another.
-#
-
-import argparse
-import logging
-from launchpadlib.launchpad import Launchpad
-
-
-# These may contain proprietary content, skip them
-IgnoredSeries = ["firmware", "ppa-uose", "silicon", "trunk"]
-
-
-def clone_project_milestones(src, dest, dry_run):
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-    src_project = lp.projects[src]
-    dest_project = lp.projects[dest]
-    for src_series in src_project.series:
-        if src_series.name in IgnoredSeries:
-            continue
-        dest_series = dest_project.getSeries(name=src_series.name)
-        if dest_series:
-            logger.warning("Series %s already exists, skipping\n" % (dest_series))
-        else:
-            logger.info("Creating series %s" % (src_series.name))
-            if not dry_run:
-                dest_series = dest_project.newSeries(
-                    name=src_series.name, summary=src_series.summary
-                )
-        for src_milestone in src_series.all_milestones:
-            dest_milestone = dest_project.getMilestone(name=src_milestone.name)
-            if dest_milestone:
-                logger.warning(
-                    "Project already has milestone %s, skipping\n"
-                    % (dest_milestone.name)
-                )
-            else:
-                logger.info("Creating milestone %s" % (src_milestone.name))
-                if not dry_run:
-                    dest_milestone = dest_series.newMilestone(
-                        name=src_milestone.name,
-                        date_targeted=src_milestone.date_targeted,
-                    )
-                    dest_milestone.is_active = src_milestone.is_active
-                    dest_milestone.lp_save()
-                src_release = src_milestone.release
-                if src_release:
-                    logger.info(
-                        "Releasing milestone %s on %s "
-                        % (src_milestone.name, src_milestone.release.date_released)
-                    )
-                    if not dry_run:
-                        dest_milestone.createProductRelease(
-                            date_released=src_milestone.release.date_released
-                        )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-s", "--source", required=True)
-    parser.add_argument("-d", "--dest", required=True)
-    parser.add_argument("--dry-run", action="store_true")
-    args = parser.parse_args()
-
-    logger = logging.getLogger("clone-project-milestones")
-    logger.setLevel(logging.INFO)
-    ch = logging.StreamHandler()
-    formatter = logging.Formatter("%(levelname)s - %(message)s")
-    ch.setFormatter(formatter)
-    logger.addHandler(ch)
-
-    clone_project_milestones(args.source, args.dest, args.dry_run)
diff --git a/lp-scripts/dgx2-performance-regression-googlesheet.py b/lp-scripts/dgx2-performance-regression-googlesheet.py
deleted file mode 100755
index d84a410..0000000
--- a/lp-scripts/dgx2-performance-regression-googlesheet.py
+++ /dev/null
@@ -1,99 +0,0 @@
-#!/usr/bin/env python3
-#
-# Updates an existing google sheet that tracks performance regression bugs.
-# To run, you'll need google sheet API credentials, and a number of pip
-# libraries installed (a virtualenv is recommended). See
-#  https://developers.google.com/sheets/api/quickstart/python
-# And, of course, you'll need write-access to the spreadsheet.
-#
-import pickle
-import os.path
-from googleapiclient.discovery import build
-from google_auth_oauthlib.flow import InstalledAppFlow
-from google.auth.transport.requests import Request
-from launchpadlib.launchpad import Launchpad
-
-FIELDNAMES = ["Link", "Title", "Importance", "Status"]
-GOOGLE_SPREADSHEET_ID = "1CkjLn_yWxR_LN2nhOHCkyiJq-UvuI2XTGjHIiUAW7mU"
-GOOGLE_RANGE_NAME = "Sheet1!A2"
-
-
-def update_google_sheet(data):
-    # If modifying these scopes, delete the file token.pickle.
-    scopes = ["https://www.googleapis.com/auth/spreadsheets"]
-
-    creds = None
-    # The file token.pickle stores the user's access and refresh tokens, and is
-    # created automatically when the authorization flow completes for the first
-    # time.
-    if os.path.exists("token.pickle"):
-        with open("token.pickle", "rb") as token:
-            creds = pickle.load(token)
-    # If there are no (valid) credentials available, let the user log in.
-    if not creds or not creds.valid:
-        if creds and creds.expired and creds.refresh_token:
-            creds.refresh(Request())
-        else:
-            flow = InstalledAppFlow.from_client_secrets_file(
-                "credentials.json",
-                scopes,
-            )
-            creds = flow.run_local_server(port=0)
-        # Save the credentials for the next run
-        with open("token.pickle", "wb") as token:
-            pickle.dump(creds, token)
-
-    service = build("sheets", "v4", credentials=creds)
-
-    result = (
-        service.spreadsheets()
-        .values()
-        .clear(
-            spreadsheetId=GOOGLE_SPREADSHEET_ID,
-            range=GOOGLE_RANGE_NAME,
-        )
-        .execute()
-    )
-
-    body = {"values": data}
-    result = (
-        service.spreadsheets()
-        .values()
-        .update(
-            spreadsheetId=GOOGLE_SPREADSHEET_ID,
-            range=GOOGLE_RANGE_NAME,
-            valueInputOption="USER_ENTERED",
-            body=body,
-        )
-        .execute()
-    )
-    print("{0} cells updated.".format(result.get("updatedCells")))
-
-
-if __name__ == "__main__":
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-
-    p = lp.projects["ubuntu"]
-
-    data = [FIELDNAMES]
-
-    for task in p.searchTasks(tags=["dgx2-performance-regression"], status=[]):
-        row = []
-        bug = int(task.web_link.split("/")[-1])
-        for field in FIELDNAMES:
-            if field == "Link":
-                row.append(
-                    '=HYPERLINK("{}", "LP: #{}")'.format(
-                        task.web_link,
-                        bug,
-                    )
-                )
-            if field == "Title":
-                row.append(lp.bugs[bug].title)
-            if field == "Importance":
-                row.append(task.importance)
-            if field == "Status":
-                row.append(task.status)
-        data.append(row)
-
-    update_google_sheet(data)
diff --git a/lp-scripts/dump-bug-subscribers.py b/lp-scripts/dump-bug-subscribers.py
deleted file mode 100755
index 70f8c72..0000000
--- a/lp-scripts/dump-bug-subscribers.py
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/usr/bin/python3
-
-# Dump the bugs associated subscribers for a specified
-# LP project into a CSV file
-
-import argparse
-import csv
-from launchpadlib.launchpad import Launchpad
-
-
-bugStatuses = [
-    "New",
-    "Opinion",
-    "Invalid",
-    "Won't Fix",
-    "Expired",
-    "Confirmed",
-    "Triaged",
-    "In Progress",
-    "Fix Committed",
-    "Fix Released",
-    "Incomplete",
-]
-
-
-def taskToBug(task):
-    bugid = int(task.self_link.split("/")[-1])
-    return lp.bugs[bugid]
-
-
-def getSubscriptionId(subscription_url):
-    lpString = str(subscription_url)
-    lpPath = lpString.rsplit("/", 1)
-    return lpPath[-1]
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "project",
-        help="Launchpad project from which \
-                         subscribers will be dumped",
-    )
-    parser.add_argument("-o", "--outfile", help="Output file", required=True)
-    args = parser.parse_args()
-
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-    project = lp.projects[args.project]
-
-    with open(args.outfile, "w") as csvfile:
-        c = csv.writer(csvfile)
-        c.writerow(["Bug", "Title", "Subscribers"])
-        # no way to list all open/closed bugs, so iterate through bug states
-        for bugStatus in bugStatuses:
-            for task in project.searchTasks(status=bugStatus):
-                output = []
-                bug = taskToBug(task)
-                output.append('=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id))
-                output.append(bug.title)
-                for subscription in bug.subscriptions:
-                    output.append(getSubscriptionId(subscription))
-                c.writerow(output)
diff --git a/lp-scripts/hisi_sync_patch_count.py b/lp-scripts/hisi_sync_patch_count.py
deleted file mode 100755
index fc72e07..0000000
--- a/lp-scripts/hisi_sync_patch_count.py
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-
-# Count the patches in the kunpeng920 "sync" bugs
-# Output to stdout
-
-from launchpadlib.launchpad import Launchpad
-
-
-def taskToBug(task):
-    bugid = int(task.self_link.split("/")[-1])
-    return lp.bugs[bugid]
-
-
-if __name__ == "__main__":
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-
-    subsystem_search_strings = [
-        "hns3",
-        "RDMA/hns",
-        "crypto: hisilicon",
-        "hisi_sas",
-        "irqchip/gic-v",
-        "drivers/perf",
-        "spi:",
-        "mtd:",
-        "drm/hisilicon",
-        "PCI:",
-        "PCI/",
-    ]
-
-    kunpeng = lp.projects["kunpeng920"]
-    total = 0
-    for task in kunpeng.searchTasks(search_text="sync"):
-        bug = taskToBug(task)
-        count = 0
-        lines = bug.description.split("\n")
-        for line in lines:
-            for subsystem in subsystem_search_strings:
-                if subsystem in line:
-                    count += 1
-        print(f'LP#{bug.id}, "{bug.title}", {count}')
-        total += count
-
-    print(f"Grand Total: {total}")
diff --git a/lp-scripts/lp-bulk-action.py b/lp-scripts/lp-bulk-action.py
deleted file mode 100755
index 12cca76..0000000
--- a/lp-scripts/lp-bulk-action.py
+++ /dev/null
@@ -1,119 +0,0 @@
-#!/usr/bin/python3
-
-import argparse
-import sys
-from launchpadlib.launchpad import Launchpad
-
-Projects = [
-    "bandera",
-    "kunpeng920",
-    "pearl",
-    "pearl2",
-    "quicksilver",
-    "ubuntu-power-systems",
-    "ubuntu-z-systems",
-    "yarmouth",
-    "yarmouth2",
-]
-
-
-def createMilestone(lp, project, series, milestone, date):
-    p = lp.projects[project]
-    s = p.getSeries(name=series)
-    if not s:
-        sys.stderr.write(
-            "Warning: Project %s has no series %s, skipping\n" % (project, series)
-        )
-        return
-    if p.getMilestone(name=milestone):
-        sys.stderr.write(
-            "Warning: Project %s already has milestone %s, skipping\n"
-            % (project, milestone)
-        )
-        return
-    s.newMilestone(name=milestone, date_targeted=date)
-
-
-def releaseMilestone(lp, project, milestone, date):
-    p = lp.projects[project]
-    m = p.getMilestone(name=milestone)
-    if not m:
-        sys.stderr.write(
-            "Warning: Project %s has no milestone %s, skipping\n" % (project, milestone)
-        )
-        return
-    if m.release:
-        sys.stderr.write(
-            "Warning: Milestone %s in project %s is already released\n"
-            % (milestone, project)
-        )
-        return
-    m.createProductRelease(date_released=date)
-
-
-def updateMilestone(lp, project, milestone, date):
-    p = lp.projects[project]
-    m = p.getMilestone(name=milestone)
-    if not m:
-        sys.stderr.write(
-            "Warning: Project %s does not have milestone %s, skipping\n"
-            % (project, milestone)
-        )
-        return
-    m.date_targeted = date
-    m.lp_save()
-
-
-def createSeries(lp, project, series, summary):
-    p = lp.projects[project]
-    if p.getSeries(name=series):
-        sys.stderr.write(
-            "Warning: Project %s already has series %s, skipping\n" % (project, series)
-        )
-        return
-    p.newSeries(name=series, summary=summary)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    subparsers = parser.add_subparsers(dest="cmd")
-    subparsers.required = True
-    createMilestoneParser = subparsers.add_parser(
-        "create-milestone", help="Create Milestone"
-    )
-    createMilestoneParser.add_argument("-s", "--series", required=True)
-    createMilestoneParser.add_argument("-d", "--date", required=True)
-    createMilestoneParser.add_argument("milestone")
-    createMilestoneParser.set_defaults(cmd="create-milestone")
-
-    releaseMilestoneParser = subparsers.add_parser(
-        "release-milestone", help="Release Milestone"
-    )
-    releaseMilestoneParser.add_argument("-d", "--date", required=True)
-    releaseMilestoneParser.add_argument("milestone")
-    releaseMilestoneParser.set_defaults(cmd="release-milestone")
-
-    releaseMilestoneParser = subparsers.add_parser(
-        "update-milestone", help="Update Milestone"
-    )
-    releaseMilestoneParser.add_argument("-d", "--date", required=True)
-    releaseMilestoneParser.add_argument("milestone")
-    releaseMilestoneParser.set_defaults(cmd="update-milestone")
-
-    createSeriesParser = subparsers.add_parser("create-series", help="Create Series")
-    createSeriesParser.add_argument("-s", "--summary", required=True)
-    createSeriesParser.add_argument("series")
-    createSeriesParser.set_defaults(cmd="create-series")
-    args = parser.parse_args()
-
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-
-    for project in Projects:
-        if args.cmd == "create-milestone":
-            createMilestone(lp, project, args.series, args.milestone, args.date)
-        elif args.cmd == "create-series":
-            createSeries(lp, project, args.series, args.summary)
-        elif args.cmd == "release-milestone":
-            releaseMilestone(lp, project, args.milestone, args.date)
-        elif args.cmd == "update-milestone":
-            updateMilestone(lp, project, args.milestone, args.date)
diff --git a/lp-scripts/pearl-biweekly-bug-report-csv4.py b/lp-scripts/pearl-biweekly-bug-report-csv4.py
deleted file mode 100755
index 1295c43..0000000
--- a/lp-scripts/pearl-biweekly-bug-report-csv4.py
+++ /dev/null
@@ -1,143 +0,0 @@
-#!/usr/bin/python3
-# Change History
-# Modify encode utf_8 to byte code in Rationale/Comment
-# Add Date_created column for creating date for bug
-# Add Scope column for showing impact for all arc or arch-arm64 or D05 Boad only
-
-import argparse
-import csv
-from launchpadlib.launchpad import Launchpad
-
-rationaleSectionHeader = "[16.04.3 Risk Comments]"
-rationaleBoilerplate = "Still under investigation, not yet root-caused."
-
-
-def taskToBug(task):
-    bugid = int(task.self_link.split("/")[-1])
-    return lp.bugs[bugid]
-
-
-def ownerFromStatus(status):
-    if "Incomplete" in status:
-        owner = "Huawei"
-    else:
-        owner = "Canonical"
-    return owner
-
-
-def rationaleFromDescription(des):
-    export_rationale_flag = (
-        0  # Flag to detect the start of the "[16.04.3 Risk Comments]" section
-    )
-    rationale = ""
-    for (
-        des_line
-    ) in (
-        des.splitlines()
-    ):  # Loop through the bug description line-by-line looking for sections to export
-        if des_line == rationaleSectionHeader:
-            export_rationale_flag = 1
-        else:
-            if export_rationale_flag == 1:
-                if des_line == "":
-                    export_rationale_flag = 0
-                else:
-                    rationale += des_line
-    return rationale
-
-
-def checkScopeTags(tags):
-    scopeTags = ["scope-arch-all", "scope-arch-arm64", "scope-d05-only"]
-    scope = set(scopeTags).intersection(tags)
-    for i in scope:
-        return i
-
-    return "Unknown"
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-o", "--outfile", required=True)
-    args = parser.parse_args()
-
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-
-    pearl = lp.projects["pearl"]
-
-    with open(args.outfile, "w") as csvfile:
-        c = csv.writer(csvfile)
-        c.writerow(
-            [
-                "Title",
-                "Link",
-                "Status",
-                "Milestone",
-                "Scope",
-                "Rationale/Comment",
-                "Owner",
-                "DateCreated",
-            ]
-        )
-        # First pass: patchset bugs
-        for series in pearl.series:
-            if series.name not in ["ubuntu-16.04"]:
-                continue
-            # First pass, phase one: search for the 'open' bugs
-            for task in series.searchTasks():
-                bug = taskToBug(task)
-                # All kernel patchset bugs in the pearl project are tagged 'upstream-risky'
-                #                if 'upstream-risky' not in bug.tags:
-                #                   continue
-                if task.milestone is None:
-                    milestone = "TBD"
-                else:
-                    milestone = task.milestone.name
-                link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
-                rationale = rationaleFromDescription(bug.description)
-                if (not rationale) and (task.milestone is None):
-                    rationale = rationaleBoilerplate
-                scope = checkScopeTags(bug.tags)
-                owner = ownerFromStatus(task.status)
-                date_created = bug.date_created.strftime("%Y/%m/%d")
-                c.writerow(
-                    [
-                        bug.title,
-                        link,
-                        task.status,
-                        milestone,
-                        scope,
-                        rationale.encode("utf_8"),
-                        owner,
-                        date_created,
-                    ]
-                )
-
-            # First pass, phase two: Fix Released bugs
-            for task in series.searchTasks(status="Fix Released"):
-                bug = taskToBug(task)
-                # All kernel patchset bugs in the pearl project are tagged 'upstream-risky'
-                #                if not 'upstream-risky' not in bug.tags:
-                #                    continue
-                if task.milestone is None:
-                    milestone = "TBD"
-                else:
-                    milestone = task.milestone.name
-                link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
-                rationale = rationaleFromDescription(bug.description)
-                if (not rationale) and (task.milestone is None):
-                    rationale = rationaleBoilerplate
-                scope = checkScopeTags(bug.tags)
-                owner = ownerFromStatus(task.status)
-                date_created = bug.date_created.strftime("%Y/%m/%d")
-                c.writerow(
-                    [
-                        bug.title,
-                        link,
-                        task.status,
-                        milestone,
-                        scope,
-                        rationale.encode("utf_8"),
-                        owner,
-                        date_created,
-                    ]
-                )
diff --git a/lp-scripts/pearl-biweekly-report-csv.py b/lp-scripts/pearl-biweekly-report-csv.py
deleted file mode 100755
index 5da289d..0000000
--- a/lp-scripts/pearl-biweekly-report-csv.py
+++ /dev/null
@@ -1,125 +0,0 @@
-#!/usr/bin/python3
-
-import argparse
-import csv
-from launchpadlib.launchpad import Launchpad
-
-rationaleSectionHeader = "[16.04.3 Risk Comments]"
-rationaleBoilerplate = "Still under investigation, not yet root-caused."
-
-
-def taskToBug(task):
-    bugid = int(task.self_link.split("/")[-1])
-    return lp.bugs[bugid]
-
-
-def ownerFromStatus(status):
-    if "Incomplete" in status:
-        owner = "Huawei"
-    else:
-        owner = "Canonical"
-    return owner
-
-
-def rationaleFromDescription(des):
-    export_rationale_flag = (
-        0  # Flag to detect the start of the "[16.04.3 Risk Comments]" section
-    )
-    rationale = ""
-    for (
-        des_line
-    ) in (
-        des.splitlines()
-    ):  # Loop through the bug description line-by-line looking for sections to export
-        if des_line == rationaleSectionHeader:
-            export_rationale_flag = 1
-        else:
-            if export_rationale_flag == 1:
-                if des_line == "":
-                    export_rationale_flag = 0
-                else:
-                    rationale += des_line
-    return rationale
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-o", "--outfile", required=True)
-    args = parser.parse_args()
-
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-
-    pearl = lp.projects["pearl"]
-
-    with open(args.outfile, "w") as csvfile:
-        c = csv.writer(csvfile)
-        c.writerow(
-            [
-                "Title",
-                "Link",
-                "Status",
-                "Milestone",
-                "Rationale/Comment",
-                "Owner",
-                "DateCreated",
-            ]
-        )
-        # First pass: patchset bugs
-        for series in pearl.series:
-            if series.name not in ["ubuntu-16.04"]:
-                continue
-            # First pass, phase one: search for the 'open' bugs
-            for task in series.searchTasks():
-                bug = taskToBug(task)
-                # All kernel patchset bugs in the pearl project are tagged 'upstream-risky'
-                #                if 'upstream-risky' not in bug.tags:
-                #                   continue
-                if task.milestone is None:
-                    milestone = "TBD"
-                else:
-                    milestone = task.milestone.name
-                link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
-                rationale = rationaleFromDescription(bug.description)
-                if (not rationale) and (task.milestone is None):
-                    rationale = rationaleBoilerplate
-                owner = ownerFromStatus(task.status)
-                date_created = bug.date_created.strftime("%Y/%m/%d")
-                c.writerow(
-                    [
-                        bug.title,
-                        link,
-                        task.status,
-                        milestone,
-                        rationale.encode("utf_8"),
-                        owner,
-                        date_created,
-                    ]
-                )
-
-            # First pass, phase two: Fix Released bugs
-            for task in series.searchTasks(status="Fix Released"):
-                bug = taskToBug(task)
-                # All kernel patchset bugs in the pearl project are tagged 'upstream-risky'
-                #                if not 'upstream-risky' not in bug.tags:
-                #                    continue
-                if task.milestone is None:
-                    milestone = "TBD"
-                else:
-                    milestone = task.milestone.name
-                link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
-                rationale = rationaleFromDescription(bug.description)
-                if (not rationale) and (task.milestone is None):
-                    rationale = rationaleBoilerplate
-                owner = ownerFromStatus(task.status)
-                date_created = bug.date_created.strftime("%Y/%m/%d")
-                c.writerow(
-                    [
-                        bug.title,
-                        link,
-                        task.status,
-                        milestone,
-                        rationale.encode("utf_8"),
-                        owner,
-                        date_created,
-                    ]
-                )
diff --git a/lp-scripts/pearl-biweekly-report.csv.py b/lp-scripts/pearl-biweekly-report.csv.py
deleted file mode 100644
index bfebacc..0000000
--- a/lp-scripts/pearl-biweekly-report.csv.py
+++ /dev/null
@@ -1,149 +0,0 @@
-#!/usr/bin/python3
-# Change History
-# Modify encode utf_8 to byte code in Rationale/Comment
-# Add Date_created column for creating date for bug
-# Add Scope column for showing impact for all arc or arch-arm64 or D05 Boad only
-
-import argparse
-import csv
-from launchpadlib.launchpad import Launchpad
-
-rationaleSectionHeader = "[16.04.3 Risk Comments]"
-rationaleBoilerplate = "Still under investigation, not yet root-caused."
-
-
-def taskToBug(task):
-    bugid = int(task.self_link.split("/")[-1])
-    return lp.bugs[bugid]
-
-
-def ownerFromStatus(status):
-    if "Incomplete" in status:
-        owner = "Huawei"
-    else:
-        owner = "Canonical"
-    return owner
-
-
-def rationaleFromDescription(des):
-    export_rationale_flag = (
-        0  # Flag to detect the start of the "[16.04.3 Risk Comments]" section
-    )
-    rationale = ""
-    for (
-        des_line
-    ) in (
-        des.splitlines()
-    ):  # Loop through the bug description line-by-line looking for sections to export
-        if des_line == rationaleSectionHeader:
-            export_rationale_flag = 1
-        else:
-            if export_rationale_flag == 1:
-                if des_line == "":
-                    export_rationale_flag = 0
-                else:
-                    rationale += des_line
-    return rationale
-
-
-def checkScopeTags(tags):
-    scopeTags = ["scope-arch-all", "scope-arch-arm64", "scope-d05-only"]
-    scope = set(scopeTags).intersection(tags)
-    for i in scope:
-        if i == "scope-arch-all":
-            i = "Generic"
-        elif i == "scope-arch-arm64":
-            i = "ARM64 generic"
-        elif i == "scope-d05-only":
-            i = "D05 only"
-        return i
-
-    return "Unknown"
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-o", "--outfile", required=True)
-    args = parser.parse_args()
-
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-
-    pearl = lp.projects["pearl"]
-
-    with open(args.outfile, "w") as csvfile:
-        c = csv.writer(csvfile)
-        c.writerow(
-            [
-                "Title",
-                "Link",
-                "Status",
-                "Milestone",
-                "Scope",
-                "Rationale/Comment",
-                "Owner",
-                "DateCreated",
-            ]
-        )
-        # First pass: patchset bugs
-        for series in pearl.series:
-            if series.name not in ["ubuntu-16.04"]:
-                continue
-            # First pass, phase one: search for the 'open' bugs
-            for task in series.searchTasks():
-                bug = taskToBug(task)
-                # All kernel patchset bugs in the pearl project are tagged 'upstream-risky'
-                #                if 'upstream-risky' not in bug.tags:
-                #                   continue
-                if task.milestone is None:
-                    milestone = "TBD"
-                else:
-                    milestone = task.milestone.name
-                link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
-                rationale = rationaleFromDescription(bug.description)
-                if (not rationale) and (task.milestone is None):
-                    rationale = rationaleBoilerplate
-                scope = checkScopeTags(bug.tags)
-                owner = ownerFromStatus(task.status)
-                date_created = bug.date_created.strftime("%Y/%m/%d")
-                c.writerow(
-                    [
-                        bug.title,
-                        link,
-                        task.status,
-                        milestone,
-                        scope,
-                        rationale.encode("utf_8"),
-                        owner,
-                        date_created,
-                    ]
-                )
-
-            # First pass, phase two: Fix Released bugs
-            for task in series.searchTasks(status="Fix Released"):
-                bug = taskToBug(task)
-                # All kernel patchset bugs in the pearl project are tagged 'upstream-risky'
-                #                if not 'upstream-risky' not in bug.tags:
-                #                    continue
-                if task.milestone is None:
-                    milestone = "TBD"
-                else:
-                    milestone = task.milestone.name
-                link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
-                rationale = rationaleFromDescription(bug.description)
-                if (not rationale) and (task.milestone is None):
-                    rationale = rationaleBoilerplate
-                scope = checkScopeTags(bug.tags)
-                owner = ownerFromStatus(task.status)
-                date_created = bug.date_created.strftime("%Y/%m/%d")
-                c.writerow(
-                    [
-                        bug.title,
-                        link,
-                        task.status,
-                        milestone,
-                        scope,
-                        rationale.encode("utf_8"),
-                        owner,
-                        date_created,
-                    ]
-                )
diff --git a/lp-scripts/pearl-bug-csv-summary.py b/lp-scripts/pearl-bug-csv-summary.py
deleted file mode 100755
index ad4a049..0000000
--- a/lp-scripts/pearl-bug-csv-summary.py
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/usr/bin/python3
-
-import argparse
-import csv
-from LaunchpadBugBucketer import LaunchpadBugBucketer
-
-
-class PearlBugBucketer(LaunchpadBugBucketer):
-    def __init__(self):
-        LaunchpadBugBucketer.__init__(
-            self, "pearl", "ubuntu-16.04", requiredTags=["upstream-risky"]
-        )
-
-    def is_green(self, task):
-        if task.status in ["Fix Committed", "Fix Released"]:
-            return True
-        return False
-
-    def is_amber(self, task):
-        if self.is_green(task):
-            return False
-        elif task.milestone and task.milestone.name == "ubuntu-16.04.3":
-            return True
-        return False
-
-    def is_red(self, task):
-        if self.is_green(task) or self.is_amber(task):
-            return False
-        return True
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-o", "--outfile")
-    args = parser.parse_args()
-
-    s = PearlBugBucketer()
-
-    with open(args.outfile, "w") as csvfile:
-        c = csv.writer(csvfile)
-        c.writerow(["Title", "Bug ID", "Importance", "Status", "RAG Risk"])
-        for bucket in s.keys():
-            for task in s[bucket]:
-                bug = s.taskToBug(task)
-                link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
-                c.writerow([bug.title, link, task.importance, task.status, bucket])
diff --git a/lp-scripts/pearl-risky-patch-schedule.py b/lp-scripts/pearl-risky-patch-schedule.py
deleted file mode 100755
index 01d546e..0000000
--- a/lp-scripts/pearl-risky-patch-schedule.py
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/usr/bin/python3
-
-import argparse
-import csv
-from launchpadlib.launchpad import Launchpad
-
-
-def taskToBug(task):
-    bugid = int(task.self_link.split("/")[-1])
-    return lp.bugs[bugid]
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-o", "--outfile", required=True)
-    args = parser.parse_args()
-
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-
-    pearl = lp.projects["pearl"]
-
-    with open(args.outfile, "w") as csvfile:
-        c = csv.writer(csvfile)
-        for series in pearl.series:
-            if series.name not in ["ubuntu-17.04"]:
-                continue
-            for task in series.searchTasks():
-                bug = taskToBug(task)
-                # All kernel patchset bugs in the pearl project are tagged
-                # 'upstream-risky'
-                if "upstream-risky" not in bug.tags:
-                    continue
-                if task.milestone is None:
-                    date = "TBD"
-                else:
-                    date = task.milestone.date_targeted
-                link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
-                c.writerow([bug.title, link, date])
diff --git a/lp-scripts/pearl2-biweekly-report.csv.py b/lp-scripts/pearl2-biweekly-report.csv.py
deleted file mode 100755
index a5323cd..0000000
--- a/lp-scripts/pearl2-biweekly-report.csv.py
+++ /dev/null
@@ -1,120 +0,0 @@
-#!/usr/bin/python3
-
-# To Do
-# 1) Currently this script requires the ppa-uose series to be present. Enhance
-# to remove this restriction while ensuring there are no duplicate bug imports
-# 2) Add "scope" information back in once bugs are appropriated tagged
-# 3) Add "rationale" information back in once bugs are updated with 'Rationale' sections in description
-
-
-import argparse
-import csv
-from launchpadlib.launchpad import Launchpad
-
-rationaleSectionHeader = "[18.04.1 Risk Comments]"
-rationaleBoilerplate = "Still under investigation, not yet root-caused."
-
-
-def taskToBug(task):
-    bugid = int(task.self_link.split("/")[-1])
-    return lp.bugs[bugid]
-
-
-def ownerFromStatus(status):
-    if "Incomplete" in status:
-        owner = "Huawei"
-    else:
-        owner = "Canonical"
-    return owner
-
-
-def rationaleFromDescription(des):
-    export_rationale_flag = (
-        0  # Flag to detect the start of the "[18.04.1 Risk Comments]" section
-    )
-    rationale = ""
-    for (
-        des_line
-    ) in (
-        des.splitlines()
-    ):  # Loop through the bug description line-by-line looking for sections to export
-        if des_line == rationaleSectionHeader:
-            export_rationale_flag = 1
-        else:
-            if export_rationale_flag == 1:
-                if des_line == "":
-                    export_rationale_flag = 0
-                else:
-                    rationale += des_line
-    return rationale
-
-
-def checkScopeTags(tags):
-    scopeTags = ["scope-arch-all", "scope-arch-arm64", "scope-d06-only"]
-    scope = set(scopeTags).intersection(tags)
-    for i in scope:
-        if i == "scope-arch-all":
-            i = "Generic"
-        elif i == "scope-arch-arm64":
-            i = "ARM64 generic"
-        elif i == "scope-d06-only":
-            i = "D06 only"
-        return i
-
-    return "Unknown"
-
-
-def getMilestones(series_array):
-    milestones = []
-    for series in series_array:
-        milestone_url = series["milestone_link"]
-        if milestone_url is not None:
-            milestone_name = milestone_url.rsplit("/", 1)
-            milestones.append(milestone_name[-1])
-    return milestones
-
-
-def getUoseMilestone(series_array):
-    milestones = getMilestones(series_array)
-    uose_milestone = ""
-    for milestone in milestones:
-        if "uose" in milestone:
-            uose_milestone = milestone
-    return uose_milestone
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-o", "--outfile", required=True)
-    args = parser.parse_args()
-
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-
-    pearl = lp.projects["pearl2"]
-
-    with open(args.outfile, "w") as csvfile:
-        c = csv.writer(csvfile)
-        c.writerow(
-            ["Title", "Link", "Status", "Milestone", "Owner", "DateCreated", "Comments"]
-        )
-        # First pass: search for the 'open' bugs
-        for task in pearl.searchTasks():
-            uose_milestone = getUoseMilestone(task.related_tasks.entries)
-            bug = taskToBug(task)
-            link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
-            owner = ownerFromStatus(task.status)
-            date_created = bug.date_created.strftime("%Y/%m/%d")
-            c.writerow(
-                [bug.title, link, task.status, uose_milestone, owner, date_created]
-            )
-
-        # Second pass: search for the 'Fix Released' bugs
-        for task in pearl.searchTasks(status="Fix Released"):
-            bug = taskToBug(task)
-            uose_milestone = getUoseMilestone(task.related_tasks.entries)
-            link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
-            owner = ownerFromStatus(task.status)
-            date_created = bug.date_created.strftime("%Y/%m/%d")
-            c.writerow(
-                [bug.title, link, task.status, uose_milestone, owner, date_created]
-            )
diff --git a/lp-scripts/pearl2-d06-18.04-patch-status.py b/lp-scripts/pearl2-d06-18.04-patch-status.py
deleted file mode 100755
index 79316bc..0000000
--- a/lp-scripts/pearl2-d06-18.04-patch-status.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/python3
-
-import argparse
-import csv
-from launchpadlib.launchpad import Launchpad
-
-
-def taskToBug(task):
-    bugid = int(task.self_link.split("/")[-1])
-    return lp.bugs[bugid]
-
-
-Pre18041Milestones = [
-    "ubuntu-18.04-ga",
-    "ubuntu-18.04-sru-1",
-    "ubuntu-18.04-sru-2",
-    "ubuntu-18.04-sru-3",
-    "ubuntu-18.04-sru-4",
-    "ubuntu-18.04.1",
-]
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-o", "--outfile", required=True)
-    args = parser.parse_args()
-
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-
-    pearl = lp.projects["pearl2"]
-    series = pearl.getSeries(name="ubuntu-18.04")
-
-    with open(args.outfile, "w") as csvfile:
-        c = csv.writer(csvfile)
-        c.writerow(["Title", "Link", "Status", "Expected"])
-        for task in series.searchTasks(status=[]):
-            bug = taskToBug(task)
-            link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
-            # At this point we should know which milestone (SRU cycle)
-            # patches will land in, or it should be tagged as risky.
-            if task.status in ["Invalid", "Won't Fix"]:
-                continue
-            if task.status == "Incomplete":
-                if "needs-sru-justification" in bug.tags:
-                    expected = "Needs SRU Justification"
-                else:
-                    expected = "Need input from HiSilicon"
-            elif task.milestone:
-                if task.milestone.name in Pre18041Milestones:
-                    expected = "Before 18.04.1 GA"
-                else:
-                    expected = "After 18.04.1 GA"
-            else:
-                expected = "Needs Canonical Review"
-            c.writerow([bug.title, link, task.status, expected])
diff --git a/lp-scripts/pearl2-tag-ubuntu-18.04.3-risky.py b/lp-scripts/pearl2-tag-ubuntu-18.04.3-risky.py
deleted file mode 100755
index 01dc923..0000000
--- a/lp-scripts/pearl2-tag-ubuntu-18.04.3-risky.py
+++ /dev/null
@@ -1,100 +0,0 @@
-#!/usr/bin/python3
-
-#
-# Make sure all bugs that should have the ubuntu-18.04.3-ga-risky tag
-# do, and those that shouldn't, don't.
-#
-import datetime
-from enum import Enum
-import sys
-from launchpadlib.launchpad import Launchpad
-
-
-class Risky(Enum):
-    HIGH = 1
-    LOW = 2
-    WONT_FIX = 3
-    TBD = 4
-
-
-RiskyTagMap = {
-    Risky.HIGH: "ubuntu-18.04.3-ga-risk-high",
-    Risky.LOW: "ubuntu-18.04.3-ga-risk-low",
-    Risky.WONT_FIX: "ubuntu-18.04.3-ga-wont-fix",
-    Risky.TBD: "ubuntu-18.04.3-ga-risk-tbd",
-}
-
-
-def get_risk(bug):
-    found = None
-    for r in RiskyTagMap.keys():
-        if RiskyTagMap[r] in bug.tags:
-            # Only one tag should be found
-            assert found is None
-            found = r
-    return found
-
-
-def set_risk(bug, risk):
-    # First remove all the risky tags that do not apply
-    for r in RiskyTagMap.keys():
-        if r is risk:
-            continue
-        rmtag = RiskyTagMap[r]
-        if rmtag in bug.tags:
-            sys.stderr.write("Removing %s tag from %s\n" % (rmtag, bug.web_link))
-            newtags = list(bug.tags)
-            newtags.remove(rmtag)
-            bug.tags = newtags
-    # Now make sure the correct risky tag is applied
-    addtag = RiskyTagMap[risk]
-    if addtag not in bug.tags:
-        sys.stderr.write("Adding %s tag to %s\n" % (addtag, bug.web_link))
-        bug.tags = bug.tags + [addtag]
-    bug.lp_save()
-
-
-if __name__ == "__main__":
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-
-    pearl2 = lp.projects["pearl2"]
-    target_milestone = "ubuntu-18.04.3"
-    target_date = None
-    # Find the target date of our milestone. We can compare this with
-    # the target date of other milestones to figure out if they come
-    # before or after it
-    for m in pearl2.active_milestones:
-        if m.name in [target_milestone]:
-            target_date = m.date_targeted
-            break
-    assert target_date is not None
-
-    series = pearl2.getSeries(name="ubuntu-18.04-hwe")
-    for task in series.searchTasks():
-        if task.milestone is not None:
-            tdelta = task.milestone.date_targeted - target_date
-            if tdelta > datetime.timedelta(0):
-                # The target milestone is after ours - we've already
-                # decided it won't happen in time.
-                set_risk(task.bug, Risky.WONT_FIX)
-            else:
-                # If it is our milestone or before, we're confident it'll
-                # land in time.
-                set_risk(task.bug, Risky.LOW)
-            continue
-        # Now process the ones w/ no milestone set.
-        # These by definition should all have milestones set.
-        assert task.status not in [
-            "Opinion",
-            "Invalid",
-            "Won't Fix",
-            "Fix Committed",
-            "Fix Released",
-        ]
-        if task.status == "Incomplete":
-            set_risk(task.bug, Risky.HIGH)
-            continue
-        # The rest need manually-set tags. Set them to TBD by default
-        if get_risk(task.bug):
-            continue
-        set_risk(task.bug, Risky.TBD)
diff --git a/lp-scripts/project-bug-lint.py b/lp-scripts/project-bug-lint.py
deleted file mode 100755
index b341bf2..0000000
--- a/lp-scripts/project-bug-lint.py
+++ /dev/null
@@ -1,182 +0,0 @@
-#!/usr/bin/python3
-
-from launchpadlib.launchpad import Launchpad
-import argparse
-import sys
-
-
-# A base class for bug properties, mainly to make them sortable
-class BugProperty:
-    def __init__(self, property):
-        self.index = self.PropertyList.index(property)
-
-    def __eq__(self, other):
-        return self.index == other.index
-
-    def __ne__(self, other):
-        return self.index != other.index
-
-    def __lt__(self, other):
-        return self.index < other.index
-
-    def __le__(self, other):
-        return self.index <= other.index
-
-    def __gt__(self, other):
-        return self.index > other.index
-
-    def __ge__(self, other):
-        return self.index >= other.index
-
-    def __repr__(self):
-        return self.PropertyList[self.index]
-
-
-class BugStatus(BugProperty):
-    PropertyList = [
-        "New",
-        "Incomplete",
-        "Opinion",
-        "Invalid",
-        "Won't Fix",
-        "Confirmed",
-        "Triaged",
-        "In Progress",
-        "Fix Committed",
-        "Fix Released",
-    ]
-
-    # min/max could ideally be in the baseclass, but I don't know
-    # how to do that and stil refer to the correct PropertyList
-    def min():
-        return BugStatus(BugStatus.PropertyList[0])
-
-    def max():
-        return BugStatus(BugStatus.PropertyList[-1])
-
-    def isTerminalState(self):
-        terminalStates = ["Fix Released", "Invalid", "Won't Fix"]
-        return self.PropertyList[self.index] in terminalStates
-
-
-class BugImportance(BugProperty):
-    PropertyList = ["Undecided", "Wishlist", "Low", "Medium", "High", "Critical"]
-
-    # min/max could ideally be in the baseclass, but I don't know
-    # how to do that and stil refer to the correct PropertyList
-    def min():
-        return BugImportance(BugImportance.PropertyList[0])
-
-    def max():
-        return BugImportance(BugImportance.PropertyList[-1])
-
-
-class BugTask:
-    def __init__(self, lptask):
-        self.status = BugStatus(lptask.status)
-        self.importance = BugImportance(lptask.importance)
-
-
-class Bug:
-    def __init__(self):
-        self.defaultTask = None
-        self.targetedTasks = {}
-
-    def addDefaultTask(self, task):
-        self.defaultTask = BugTask(task)
-
-    def getDefaultTask(self):
-        return self.defaultTask
-
-    def addTargetedTask(self, series, task):
-        self.targetedTasks[series] = BugTask(task)
-
-    def getTargetedTasks(self):
-        return self.targetedTasks
-
-
-def checkScopeTags(lpbug):
-    scopeTags = ["scope-arch-all", "scope-arch-arm64", "scope-d05-only"]
-    common = set(scopeTags).intersection(lpbug.tags)
-    if len(common) == 0:
-        sys.stdout.write("http://launchpad.net/bugs/%d has no scope tag\n" % (bugid))
-    if len(common) > 1:
-        sys.stdout.write(
-            "http://launchpad.net/bugs/%d has multiple scope tags\n" % (bugid)
-        )
-
-
-def taskToBugId(task):
-    return int(task.self_link.split("/")[-1])
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-p", "--project", required=True)
-    args = parser.parse_args()
-    lp = Launchpad.login_with("lpbugs", "production", version="devel")
-    project = lp.projects[args.project]
-
-    bugs = {}
-    # Create a list of bugs for all the "default" tasks
-    for task in project.searchTasks(status=[]):
-        bugid = taskToBugId(task)
-        bugs[bugid] = Bug()
-        bugs[bugid].addDefaultTask(task)
-
-    # Next, add all the series-targeted tasks
-    for series in project.series:
-        for task in series.searchTasks(status=[]):
-            bugid = taskToBugId(task)
-            if bugid in bugs.keys():
-                bugs[bugid].addTargetedTask(series.name, task)
-            else:
-                sys.stderr.write(
-                    "WARNING: http://launchpad.net/bugs/%d does not have a default task\n"
-                    % (bugid)
-                )
-
-    # Now process them.
-    for bugid in bugs.keys():
-        bug = bugs[bugid]
-        targetedTasks = bug.getTargetedTasks()
-        if len(targetedTasks) == 0:
-            defaultStatus = bug.getDefaultTask().status
-            if not defaultStatus.isTerminalState():
-                sys.stderr.write(
-                    "WARNING: http://launchpad.net/bugs/%d only has a default task\n"
-                    % (bugid)
-                )
-            continue
-
-        statusList = []
-        for k in targetedTasks.keys():
-            s = targetedTasks[k].status
-            if not s.isTerminalState():
-                statusList.append(s)
-        statusList.sort()
-        targetStatus = None
-        if len(statusList) > 0:
-            targetStatus = statusList[0]
-
-        importanceList = [targetedTasks[k].importance for k in targetedTasks.keys()]
-        importanceList.sort()
-        targetImportance = importanceList[-1]
-
-        defaultTask = bug.getDefaultTask()
-        currentStatus = defaultTask.status
-        currentImportance = defaultTask.importance
-        if targetStatus and targetStatus != currentStatus:
-            sys.stdout.write(
-                "http://launchpad.net/bugs/%d status %s -> %s\n"
-                % (bugid, currentStatus, targetStatus)
-            )
-        if targetImportance != currentImportance:
-            sys.stdout.write(
-                "http://launchpad.net/bugs/%d importance %s -> %s\n"
-                % (bugid, currentImportance, targetImportance)
-            )
-
-        if args.project == "pearl":
-            if not defaultTask.status.isTerminalState():
-                checkScopeTags(lp.bugs[bugid])
diff --git a/maasimg-mod.sh b/maasimg-mod.sh
deleted file mode 100755
index 001f9f4..0000000
--- a/maasimg-mod.sh
+++ /dev/null
@@ -1,94 +0,0 @@
-#!/bin/sh
-
-set -e
-set -x
-
-proposed=0
-while [ $# -gt 0 ]; do
-    arg="$1"
-    case $arg in
-	-k|--kerneldeb)
-	    kerndeb="$2"
-	    shift
-	    ;;
-	-i|--imagedir)
-	    imgdir="$2"
-	    shift
-	    ;;
-	--ppa)
-	    ppa="$2"
-	    shift
-	    ;;
-	--proposed)
-	    proposed=1
-	    ;;
-	*)
-	    echo "Error: Unknown argument: $arg" 1>&2
-	    exit 1
-	    ;;
-    esac
-    shift
-done
-
-if [ -z "$imgdir" ]; then
-    echo "Error: No image directory (-i) specified." 1>&2
-    exit 1
-fi
-
-tmpdir="$(mktemp -d)"
-cleanup() {
-    sudo rm -rf "$tmpdir"
-}
-trap cleanup EXIT INT TERM
-
-if [ -n "$kerndeb" ] && [ -n "$imgdir" ]; then
-    kernel="$imgdir/boot-kernel"
-    initrd="$imgdir/boot-initrd"
-    kernunpack="$tmpdir/kernel"
-    mkdir -p "$kernunpack"
-    initrddir="$tmpdir/initrd"
-    mkdir -p "$initrddir"
-
-    # Just overwrite the kernel
-    dpkg-deb -x "$kerndeb" "$kernunpack"
-    newkver="$(ls $kernunpack/lib/modules)"
-    cat $kernunpack/boot/vmlinuz-$newkver | sudo tee $kernel > /dev/null
-
-    gunzip < $initrd | (cd $initrddir && sudo cpio -i -d)
-    oldkver="$(ls $initrddir/lib/modules)"
-
-    # Replace the modules in the initrd w/ the same subset of modules
-    # from the new kernel.
-    (cd $initrddir/lib/modules/$oldkver && sudo find) > $tmpdir/modlist
-    sudo rm -rf $initrddir/lib/modules/$oldkver
-    sudo mkdir -p $initrddir/lib/modules/$newkver
-    (cd $kernunpack/lib/modules/$newkver && cpio -H newc -o < $tmpdir/modlist) | \
-	(cd $initrddir/lib/modules/$newkver && sudo cpio -i -d)
-    sudo depmod -b $initrddir $newkver
-    (cd $initrddir && sudo find | sudo cpio -H newc -o) | gzip | sudo tee $initrd > /dev/null
-fi
-
-if [ -n "$ppa" ] || [ $proposed = 1 ]; then
-    rootdir="$tmpdir/root"
-    mkdir -p "$rootdir"
-
-    roottgz="$imgdir/root-tgz"
-    (cd $rootdir && sudo tar --xattrs -x -z -f $roottgz)
-    
-    if [ -n "$ppa" ]; then
-       sudo chroot "$rootdir" apt install software-properties-common -y
-       sudo chroot "$rootdir" apt-add-repository "$ppa" -y
-    fi
-       
-    if [ $proposed = 1 ]; then
-	echo "deb http://us.ports.ubuntu.com/ubuntu-ports/ xenial-proposed main restricted universe multiverse" | sudo tee "$rootdir/etc/apt/sources.list.d/proposed.list" > /dev/null
-    fi
-    (cd $rootdir && sudo tar -c --xattrs * | gzip -9) | sudo tee "$roottgz" > /dev/null
-fi
-       
-# In case they have old fds open...
-sudo service maas-rackd restart
-sudo service maas-regiond restart
-sudo service tgt restart
-
-exit 0
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 9d50d6c..0000000
--- a/setup.cfg
+++ /dev/null
@@ -1,24 +0,0 @@
-[metadata]
-name = canonical-server-hwe-utils
-version = 1.0.0
-url = https://launchpad.net/canonical-server-hwe-utils
-license = AGPLv3
-maintainer = CE Hyperscale Team
-maintainer_email = [e-mail]
-description = Assorted utilities used by Canonical's Server Hardware Enablement team
-long_description = file: README.md
-long_description_content_type = text/markdown
-classifiers =
-    Programming Language :: Python
-    Programming Language :: Python :: 3
-
-[options]
-python_requires = >=3.8
-packages = find:
-zip_safe = true
-scripts = labkey, jenkins-scripts/weekly-rota-init.py, jenkins-scripts/sbsh
-install_requires =
-    requests >= 2.27.1
-    jira >= 3.1.1
-    python-jenkins >= 1.7.0
-    pyyaml >= 5.4
diff --git a/setup.py b/setup.py
deleted file mode 100755
index 229b2eb..0000000
--- a/setup.py
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env python3
-
-from setuptools import setup
-
-setup()
diff --git a/sysadmin-tools/gen_conserver_cf.py b/sysadmin-tools/gen_conserver_cf.py
deleted file mode 100755
index 491f5b3..0000000
--- a/sysadmin-tools/gen_conserver_cf.py
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/usr/bin/env python3
-#
-# Generate conserver.cf from machines.yaml
-#
-
-import argparse
-import sys
-import yaml
-
-# Header information scraped from r815 conserver.cf
-header = """
-# DO NOT EDIT DIRECTLY, YOUR CHANGES WILL BE OVERWRITTEN
-# Auto-generated by {progname}
-#
-# The character '&' in logfile names are substituted with the console
-# name.
-#
-config * {{
-        initdelay 10;
-}}
-
-default full {{
-        rw *;
-}}
-
-default * {{
-        logfile /var/log/conserver/&.log;
-        timestamp "";
-        include full;
-}}"""
-
-# Footer information scraped from r815 conserver.cf
-footer = """
-#
-# list of clients allowed
-#
-access * {{
-        trusted 127.0.0.1,10.228.0.2,10.172.64.0/18,10.172.192.0/18,10.246.72.53,10.246.72.142;
-        allowed 127.0.0.1,10.228.0.2,10.172.64.0/18,10.172.192.0/18,10.246.72.53,10.246.72.142;
-}}
-"""
-
-# Console entry for ipmi sol connection
-ipmi_sol_entry = """
-console {srv} {{
-        master localhost;
-        type exec;
-        exec (ipmitool -I lanplus -H {addr} -U {user} -P {pwd} sol deactivate || : && ipmitool -I lanplus -H {addr} -U {user} -P {pwd} sol activate);
-}}"""  # noqa: E501
-
-if __name__ == "__main__":
-    arg_parser = argparse.ArgumentParser()
-    arg_parser.add_argument("machines_yaml", help="Lab's machines.yaml file")
-    arg_parser.add_argument("-o", "--outfile", help="Output filename")
-    args = arg_parser.parse_args()
-
-    with open(args.machines_yaml) as f:
-        machines = yaml.safe_load(f)
-
-    if args.outfile:
-        outfile = open(args.outfile, "w")
-    else:
-        outfile = sys.stdout
-    outfile.write(header.format(progname=arg_parser.prog))
-    for server in machines:
-        # bmc is required for conserver to attach
-        if "bmc" not in machines[server]:
-            continue
-        bmc_info = machines[server]["bmc"]
-        # type is required so the conserver knows how to attach
-        if "type" not in bmc_info:
-            continue
-        if bmc_info["type"] == "ipmi":
-            addr = bmc_info["address"].replace("#", "\\#")
-            user = bmc_info["user"].replace("#", "\\#")
-            pwd = bmc_info["password"].replace("#", "\\#")
-            outfile.write(
-                ipmi_sol_entry.format(srv=server, addr=addr, user=user, pwd=pwd)
-            )
-    outfile.write(footer.format())
diff --git a/sysadmin-tools/update_conserver.py b/sysadmin-tools/update_conserver.py
deleted file mode 100755
index eee1fbd..0000000
--- a/sysadmin-tools/update_conserver.py
+++ /dev/null
@@ -1,114 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-from datetime import date
-import logging
-import os.path
-import subprocess
-import tempfile
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-l", "--lab", required=True)
-    args = parser.parse_args()
-
-    gen_conserver_cf = os.path.join(".", "gen_conserver_cf.py")
-    if not os.path.exists(gen_conserver_cf):
-        raise Exception(f"Did not find {gen_conserver_cf} in the current directory.")
-
-    if args.lab == "1ss":
-        server = "10.229.0.101"
-    elif args.lab == "tremont":
-        server = "10.228.0.2"
-    else:
-        raise Exception("Unknown lab {args.lab}")
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        subprocess.run(
-            [
-                "git",
-                "clone",
-                "--depth",
-                "1",
-                "git+ssh://git.launchpad.net/scalebot",
-                os.path.join(tmpdir, "scalebot"),
-            ],
-            check=True,
-        )
-        labdir = os.path.join(tmpdir, "scalebot", "labs", args.lab)
-        if not os.path.isdir(labdir):
-            raise Exception("Lab {args.lab} directory not found")
-        subprocess.run(
-            [
-                gen_conserver_cf,
-                "-o",
-                os.path.join(tmpdir, "conserver.cf"),
-                os.path.join(labdir, "machines.yaml"),
-            ],
-            check=True,
-        )
-        logging.info(f"sudo password prompts that follow are from {server}")
-        backup = f"/etc/conserver/conserver.cf.{date.today().isoformat()}"
-        subprocess.run(
-            ["ssh", "-t", server, "sudo", "cp", "/etc/conserver/conserver.cf", backup],
-            check=True,
-        )
-        logging.info(f"Previous file backed up to {backup}")
-        remote_mktemp = subprocess.run(
-            ["ssh", server, "mktemp"],
-            check=True,
-            capture_output=True,
-        )
-        remote_tmp = remote_mktemp.stdout.decode("UTF-8").splitlines()[0]
-        logging.info(f"Tempfile is {remote_tmp}")
-        subprocess.run(
-            ["scp", os.path.join(tmpdir, "conserver.cf"), f"{server}:{remote_tmp}"],
-            check=True,
-        )
-        subprocess.run(
-            [
-                "ssh",
-                "-t",
-                server,
-                "sudo",
-                "chown",
-                "--reference=/etc/conserver/conserver.cf",
-                remote_tmp,
-            ],
-            check=True,
-        )
-        subprocess.run(
-            [
-                "ssh",
-                "-t",
-                server,
-                "sudo",
-                "chmod",
-                "--reference=/etc/conserver/conserver.cf",
-                remote_tmp,
-            ],
-            check=True,
-        )
-        subprocess.run(
-            [
-                "ssh",
-                "-t",
-                server,
-                "sudo",
-                "cp",
-                remote_tmp,
-                "/etc/conserver/conserver.cf",
-            ],
-            check=True,
-        )
-        logging.info(f"Stopping conserver-server on {server}...")
-        subprocess.run(
-            ["ssh", "-t", server, "sudo", "service", "conserver-server", "stop"],
-            check=True,
-        )
-        logging.info(f"Starting conserver-server on {server}...")
-        subprocess.run(
-            ["ssh", "-t", server, "sudo", "service", "conserver-server", "start"],
-            check=True,
-        )