Merge lp:~apw/ubuntu-archive-tools/use-kernel-series-routing-information into lp:ubuntu-archive-tools

[Andy Whitcroft]

Initial support for kernel routing lookups via KernelSeries data from the kernel team.

[Łukasz Zemczak (sil2100)]

Ok, this generally looks good. The design of this module feels a bit strange, but I guess the reason for that is how our current tools were created. Like, it would be probably a bit more intuitive for me if KernelSeries had some get_routing_for_package() function that would simply take series and package as arguments and spit out some routing info class.
Anyway, this here is good as is, and we can certainly enhance this even further if needed.

review: Approve

=== modified file 'copy-proposed-kernel'
--- copy-proposed-kernel	2019-08-27 11:32:43 +0000
+++ copy-proposed-kernel	2019-09-19 13:51:06 +0000
@@ -32,12 +32,16 @@
 
 from launchpadlib.launchpad import Launchpad
 
+from kernel_series import KernelSeries
+
 
 class TestBase(unittest.TestCase):
     class FakeArgs:
         def __init__(self, **kwargs):
+            self.testing = True
             self.series = None
             self.source = None
+            self.ppa2 = False
             self.security = False
             self.security2 = False
             self.esm = False
@@ -45,6 +49,7 @@
             self.ibmgt = False
             self.to_signing = False
             self.from_signing = False
+            self.no_auto = False
 
             self.update(**kwargs)
 
@@ -63,56 +68,139 @@
         finally:
             sys.stdout, sys.stderr = old_out, old_err
 
+    @classmethod
+    def setUpClass(cls):
+        data = """
+            defaults:
+                routing-table:
+                    default:
+                        security-build:
+                            - ['ppa:canonical-kernel-security-team/ubuntu/ppa', 'Release' ]
+                            - ['ppa:canonical-kernel-security-team/ubuntu/ppa2', 'Release' ]
+                        build:
+                            - ['ppa:canonical-kernel-team/ubuntu/ppa', 'Release' ]
+                        proposed:
+                            - ['ubuntu', 'Proposed' ]
+                    esm:
+                        security-build:
+                            - ['ppa:canonical-kernel-security-team/ubuntu/esm', 'Release']
+                        build:
+                            - ['ppa:canonical-kernel-esm/ubuntu/ppa', 'Release']
+                        signing:
+                            - ['ppa:canonical-signing/ubuntu/esm', 'Release']
+                        proposed:
+                            - ['ppa:canonical-kernel-esm/ubuntu/proposed', 'Release']
+            14.04:
+                codename: trusty
+                supported: true
+                esm: true
+                sources:
+                    linux:
+                        packages:
+                            linux:
+                            linux-signed:
+                                type: signed
+                            linux-meta:
+                                type: meta
+            16.04:
+                codename: xenial
+                supported: true
+                sources:
+                    linux-fips:
+                        routing:
+                            security-build:
+                                - ['ppa:canonical-kernel-security-team/ubuntu/ppa', 'Release']
+                                - ['ppa:canonical-kernel-security-team/ubuntu/ppa2', 'Release']
+                            build:
+                                - ['ppa:fips-cc-stig/ubuntu/fips-build', 'Release']
+                            signing:
+                                - ['ppa:canonical-signing/ubuntu/fips', 'Release']
+                            proposed:
+                                - ['ppa:ubuntu-advantage/ubuntu/fips-proposed', 'Release']
+                        packages:
+                            linux-fips:
+                            linux-meta-fips:
+                                type: meta
+                            linux-signed-fips:
+                                type: signed
+            18.04:
+                codename: bionic
+                supported: true
+                sources:
+                    linux:
+                        packages:
+                            linux:
+                            linux-signed:
+                                type: signed
+                            linux-meta:
+                                type: meta
+                    linux-ibm-gt:
+                        routing:
+                            security-build:
+                                - ['ppa:canonical-kernel-security-team/ubuntu/ppa', 'Release']
+                                - ['ppa:canonical-kernel-security-team/ubuntu/ppa2', 'Release']
+                            build:
+                                - ['ppa:ibm-cloud/ubuntu/build', 'Release']
+                            proposed:
+                                - ['ppa:ibm-cloud/ubuntu/proposed', 'Release']
+                        packages:
+                            linux-ibm-gt:
+                            linux-meta-ibm-gt:
+                                type: meta
+        """
+        cls.ks = KernelSeries(data=data)
+
 
 class TestRouting(TestBase):
     def test_default(self):
-        expected = ('~canonical-kernel-team/ubuntu/ppa', 'ubuntu', False)
-        result = routing(self.FakeArgs())
+        expected = (['ppa:canonical-kernel-team/ubuntu/ppa', 'Release'], ['ubuntu', 'Proposed'], False)
+        result = routing(self.FakeArgs(series='bionic', source='linux'), self.ks)
         self.assertEqual(expected, result)
 
     def test_security(self):
-        expected = ('~canonical-kernel-security-team/ubuntu/ppa', 'ubuntu', True)
-        result = routing(self.FakeArgs(security=True))
+        expected = (['ppa:canonical-kernel-security-team/ubuntu/ppa', 'Release'], ['ubuntu', 'Proposed'], True)
+        result = routing(self.FakeArgs(series='bionic', source='linux', security=True), self.ks)
         self.assertEqual(expected, result)
 
     def test_security2(self):
-        expected = ('~canonical-kernel-security-team/ubuntu/ppa2', 'ubuntu', True)
-        result = routing(self.FakeArgs(security2=True))
+        expected = (['ppa:canonical-kernel-security-team/ubuntu/ppa2', 'Release'], ['ubuntu', 'Proposed'], True)
+        result = routing(self.FakeArgs(series='bionic', source='linux', security2=True), self.ks)
         self.assertEqual(expected, result)
 
     def test_to_signing(self):
-        expected = ('~canonical-kernel-team/ubuntu/ppa', None, False)
-        result = routing(self.FakeArgs(to_signing=True))
+        expected = (['ppa:canonical-kernel-team/ubuntu/ppa', 'Release'], None, False)
+        result = routing(self.FakeArgs(series='bionic', source='linux', to_signing=True), self.ks)
         self.assertEqual(expected, result)
 
     def test_from_signing(self):
-        expected = (None, 'ubuntu', False)
-        result = routing(self.FakeArgs(from_signing=True))
+        expected = (None, ['ubuntu', 'Proposed'], False)
+        result = routing(self.FakeArgs(series='bionic', source='linux', from_signing=True), self.ks)
         self.assertEqual(expected, result)
 
     def test_esm(self):
-        expected = ('~canonical-kernel-esm/ubuntu/ppa', '~canonical-kernel-esm/ubuntu/proposed', False)
-        result = routing(self.FakeArgs(esm=True))
+        expected = (['ppa:canonical-kernel-esm/ubuntu/ppa', 'Release'], ['ppa:canonical-signing/ubuntu/esm', 'Release'], False)
+        result = routing(self.FakeArgs(series='trusty', source='linux'), self.ks)
         self.assertEqual(expected, result)
 
     def test_esm_security(self):
-        expected = ('~canonical-kernel-security-team/ubuntu/esm', '~canonical-kernel-esm/ubuntu/proposed', False)
-        result = routing(self.FakeArgs(esm=True, security=True))
+        expected = (['ppa:canonical-kernel-security-team/ubuntu/esm', 'Release'], ['ppa:canonical-signing/ubuntu/esm', 'Release'], False)
+        result = routing(self.FakeArgs(series='trusty', source='linux', security=True), self.ks)
         self.assertEqual(expected, result)
 
     def test_esm_security2(self):
-        expected = (None, '~canonical-kernel-esm/ubuntu/proposed', False)
-        result = routing(self.FakeArgs(esm=True, security2=True))
-        self.assertEqual(expected, result)
+        with self.assertRaises(SystemExit), self.capture() as (out, err):
+            expected = (None, ['ppa:canonical-kernel-esm/ubuntu/proposed', 'Release'], False)
+            result = routing(self.FakeArgs(series='trusty', source='linux', security2=True), self.ks)
+            self.assertEqual(expected, result)
 
     def test_esm_to_signing(self):
-        expected = ('~canonical-kernel-esm/ubuntu/ppa', '~canonical-signing/ubuntu/esm', False)
-        result = routing(self.FakeArgs(esm=True, to_signing=True))
+        expected = (['ppa:canonical-kernel-esm/ubuntu/ppa', 'Release'], ['ppa:canonical-signing/ubuntu/esm', 'Release'], False)
+        result = routing(self.FakeArgs(series='trusty', source='linux', esm=True, to_signing=True), self.ks)
         self.assertEqual(expected, result)
 
     def test_esm_from_signing(self):
-        expected = ('~canonical-signing/ubuntu/esm', '~canonical-kernel-esm/ubuntu/proposed', False)
-        result = routing(self.FakeArgs(esm=True, from_signing=True))
+        expected = (['ppa:canonical-signing/ubuntu/esm', 'Release'], ['ppa:canonical-kernel-esm/ubuntu/proposed', 'Release'], False)
+        result = routing(self.FakeArgs(series='trusty', source='linux', esm=True, from_signing=True), self.ks)
         self.assertEqual(expected, result)
 
     # Autorouting will enable to_signing, the user will then want to switch us
@@ -120,226 +208,145 @@
     # simple we make from_signing take presidence over to_signing.  Test this
     # is honoured correctly.
     def test_esm_from_signing_override_to_signing(self):
-        expected = ('~canonical-signing/ubuntu/esm', '~canonical-kernel-esm/ubuntu/proposed', False)
-        result = routing(self.FakeArgs(esm=True, to_signing=True, from_signing=True))
+        expected = (['ppa:canonical-signing/ubuntu/esm', 'Release'], ['ppa:canonical-kernel-esm/ubuntu/proposed', 'Release'], False)
+        result = routing(self.FakeArgs(series='trusty', source='linux', esm=True, to_signing=True, from_signing=True), self.ks)
         self.assertEqual(expected, result)
 
     def test_fips(self):
-        expected = ('~fips-cc-stig/ubuntu/fips-build', '~ubuntu-advantage/ubuntu/fips-proposed', False)
-        result = routing(self.FakeArgs(fips=True))
+        expected = (['ppa:fips-cc-stig/ubuntu/fips-build', 'Release'], ['ppa:canonical-signing/ubuntu/fips', 'Release'], False)
+        result = routing(self.FakeArgs(series='xenial', source='linux-fips'), self.ks)
         self.assertEqual(expected, result)
 
     def test_fips_security(self):
-        expected = ('~canonical-kernel-security-team/ubuntu/ppa', '~ubuntu-advantage/ubuntu/fips-proposed', False)
-        result = routing(self.FakeArgs(fips=True, security=True))
+        expected = (['ppa:canonical-kernel-security-team/ubuntu/ppa', 'Release'], ['ppa:canonical-signing/ubuntu/fips', 'Release'], False)
+        result = routing(self.FakeArgs(series='xenial', source='linux-fips', security=True), self.ks)
         self.assertEqual(expected, result)
 
     def test_fips_security2(self):
-        expected = ('~canonical-kernel-security-team/ubuntu/ppa2', '~ubuntu-advantage/ubuntu/fips-proposed', False)
-        result = routing(self.FakeArgs(fips=True, security2=True))
+        expected = (['ppa:canonical-kernel-security-team/ubuntu/ppa2', 'Release'], ['ppa:canonical-signing/ubuntu/fips', 'Release'], False)
+        result = routing(self.FakeArgs(series='xenial', source='linux-fips', security2=True), self.ks)
         self.assertEqual(expected, result)
 
     def test_fips_to_signing(self):
-        expected = ('~fips-cc-stig/ubuntu/fips-build', '~canonical-signing/ubuntu/fips', False)
-        result = routing(self.FakeArgs(fips=True, to_signing=True))
+        expected = (['ppa:fips-cc-stig/ubuntu/fips-build', 'Release'], ['ppa:canonical-signing/ubuntu/fips', 'Release'], False)
+        result = routing(self.FakeArgs(series='xenial', source='linux-fips', to_signing=True), self.ks)
         self.assertEqual(expected, result)
 
     def test_fips_from_signing(self):
-        expected = ('~canonical-signing/ubuntu/fips', '~ubuntu-advantage/ubuntu/fips-proposed', False)
-        result = routing(self.FakeArgs(fips=True, from_signing=True))
+        expected = (['ppa:canonical-signing/ubuntu/fips', 'Release'], ['ppa:ubuntu-advantage/ubuntu/fips-proposed', 'Release'], False)
+        result = routing(self.FakeArgs(series='xenial', source='linux-fips', from_signing=True), self.ks)
         self.assertEqual(expected, result)
 
     def test_ibmgt(self):
-        expected = ('~ibm-cloud/ubuntu/build', '~ibm-cloud/ubuntu/proposed', False)
-        result = routing(self.FakeArgs(ibmgt=True))
+        expected = (['ppa:ibm-cloud/ubuntu/build', 'Release'], ['ppa:ibm-cloud/ubuntu/proposed', 'Release'], False)
+        result = routing(self.FakeArgs(series='bionic', source='linux-ibm-gt'), self.ks)
         self.assertEqual(expected, result)
 
     def test_ibmgt_security(self):
-        expected = ('~canonical-kernel-security-team/ubuntu/ppa', '~ibm-cloud/ubuntu/proposed', False)
-        result = routing(self.FakeArgs(ibmgt=True, security=True))
+        expected = (['ppa:canonical-kernel-security-team/ubuntu/ppa', 'Release'], ['ppa:ibm-cloud/ubuntu/proposed', 'Release'], False)
+        result = routing(self.FakeArgs(series='bionic', source='linux-ibm-gt', security=True), self.ks)
         self.assertEqual(expected, result)
 
     def test_ibmgt_security2(self):
-        expected = ('~canonical-kernel-security-team/ubuntu/ppa2', '~ibm-cloud/ubuntu/proposed', False)
-        result = routing(self.FakeArgs(ibmgt=True, security2=True))
+        expected = (['ppa:canonical-kernel-security-team/ubuntu/ppa2', 'Release'], ['ppa:ibm-cloud/ubuntu/proposed', 'Release'], False)
+        result = routing(self.FakeArgs(series='bionic', source='linux-ibm-gt', security2=True), self.ks)
         self.assertEqual(expected, result)
 
 
-def routing(args):
+def routing(args, ks):
+    series_name = args.series
+    package_name = args.source
+
+    series = ks.lookup_series(codename=series_name)
+    if series is None:
+        print("ERROR: {} -- series unknown".format(series_name))
+        sys.exit(1)
+
+    package = None
+    package_signed = None
+    for source_srch in series.sources:
+        package_signed = None
+        for package_srch in source_srch.packages:
+            if package_srch.name == package_name:
+                package = package_srch
+            if (package_srch.name.startswith('linux-signed-') or
+                    package_srch.name == 'linux-signed'):
+                package_signed = package_srch
+        if package is not None:
+            break
+    if package is None:
+        print("ERROR: {}/{} -- package unknown".format(series_name, package_name))
+        sys.exit(1)
+
+    source = package.source
+    routing = source.routing
+    if routing is None:
+        print("ERROR: {}/{} -- package has no routing".format(series_name, package_name))
+        sys.exit(1)
+
+    build_archives = routing.lookup_destination('build')
+    security_archives = routing.lookup_destination('security-build')
+    proposed_archive = routing.lookup_destination('proposed', primary=True)
+    signing_archive = routing.lookup_destination('signing', primary=True)
+
+    if build_archives is None or len(build_archives) < 1:
+        print("ERROR: {}/{} -- package has no primary build archive".format(series_name, package_name))
+        sys.exit(1)
+    if args.ppa2 and (build_archives is None or len(build_archives) < 2):
+        print("ERROR: {}/{} -- package has no secondary build archive".format(series_name, package_name))
+        sys.exit(1)
+    if build_archives is None:
+        print("ERROR: {}/{} -- package has no build archive".format(series_name, package_name))
+        sys.exit(1)
+    if proposed_archive is None:
+        print("ERROR: {}/{} -- package has no proposed archive".format(series_name, package_name))
+        sys.exit(1)
+    if args.security and (security_archives is None or len(security_archives) < 1):
+        print("ERROR: {}/{} -- package has no primary security archive".format(series_name, package_name))
+        sys.exit(1)
+    if args.security2 and (security_archives is None or len(security_archives) < 2):
+        print("ERROR: {}/{} -- package has no secondary security archive".format(series_name, package_name))
+        sys.exit(1)
+
+    # Default route build -> proposed
+    if args.ppa2:
+        from_archive = build_archives[1]
+    else:
+        from_archive = build_archives[0]
+    to_archive = proposed_archive
+
     unembargo = False
 
-    # Default routing.
-    security_name = (
-        '~canonical-kernel-security-team/ubuntu/ppa',
-        '~canonical-kernel-security-team/ubuntu/ppa2',
-        )
-    signing = None
-
-    # ESM specific routing
-    if args.esm:
-        ppa_name = '~canonical-kernel-esm/ubuntu/ppa'
-        to = '~canonical-kernel-esm/ubuntu/proposed'
-        signing = '~canonical-signing/ubuntu/esm'
-        security_name = (
-            '~canonical-kernel-security-team/ubuntu/esm',
-            None,
-            )
-
-    # FIPS specific routing
-    elif args.fips:
-        ppa_name = '~fips-cc-stig/ubuntu/fips-build'
-        to = '~ubuntu-advantage/ubuntu/fips-proposed'
-        signing = '~canonical-signing/ubuntu/fips'
-
-    # IBMGT specific routing
-    elif args.ibmgt:
-        ppa_name = '~ibm-cloud/ubuntu/build'
-        to = '~ibm-cloud/ubuntu/proposed'
-
-    # Default routing.
-    else:
-        ppa_name = '~canonical-kernel-team/ubuntu/ppa'
-        to = 'ubuntu'
-        if args.security or args.security2:
-            # Allow us to unembargo when releasing from security to ubuntu.
-            unembargo = True
-
     # Handle security routing.
     if args.security:
-        ppa_name = security_name[0]
-    elif args.security2:
-        ppa_name = security_name[1]
+        from_archive = security_archives[0]
+    if args.security2:
+        from_archive = security_archives[1]
+
+    # Allow us to unembargo when releasing from security to ubuntu.
+    if (args.security or args.security2) and to_archive[0] == 'ubuntu':
+        unembargo = True
 
     # Handle signing routing.
     if args.from_signing:
-        ppa_name = signing
+        from_archive = signing_archive
     elif args.to_signing:
-        to = signing
-
-    return (ppa_name, to, unembargo)
-
-class TestAutoRoute(TestBase):
-    def test_default(self):
-        results = self.FakeArgs(series='bionic', source='linux')
-        expected = copy(results).update()
-        with self.capture() as (out, err):
-            auto_route(results)
-        self.assertEqual(expected.__dict__, results.__dict__)
-        self.assertEqual('', out.getvalue().strip())
-
-    def test_esm_precise_linux(self):
-        results = self.FakeArgs(series='precise', source='linux')
-        expected = copy(results).update(esm=True)
-        with self.capture() as (out, err):
-            auto_route(results)
-        self.assertEqual(expected.__dict__, results.__dict__)
-        self.assertIn('from and to ESM', out.getvalue().strip())
-        self.assertNotIn('via signing', out.getvalue().strip())
-
-    def test_esm_precise_linux_meta(self):
-        results = self.FakeArgs(series='precise', source='linux-meta')
-        expected = copy(results).update(esm=True)
-        with self.capture() as (out, err):
-            auto_route(results)
-        self.assertEqual(expected.__dict__, results.__dict__)
-        self.assertIn('from and to ESM', out.getvalue().strip())
-        self.assertNotIn('via signing', out.getvalue().strip())
-
-    def test_esm_precise_lbm(self):
-        results = self.FakeArgs(series='precise', source='linux-backports-modules-3.2.0')
-        expected = copy(results).update(esm=True)
-        with self.capture() as (out, err):
-            auto_route(results)
-        self.assertEqual(expected.__dict__, results.__dict__)
-        self.assertIn('from and to ESM', out.getvalue().strip())
-        self.assertNotIn('via signing', out.getvalue().strip())
-
-    def test_esm_precise_linux_lts_trusty(self):
-        results = self.FakeArgs(series='precise', source='linux-lts-trusty')
-        expected = copy(results).update(esm=True, to_signing=True)
-        with self.capture() as (out, err):
-            auto_route(results)
-        self.assertEqual(expected.__dict__, results.__dict__)
-        self.assertIn('from and to ESM', out.getvalue().strip())
-        self.assertIn('via signing', out.getvalue().strip())
-
-    def test_esm_trusty_linux(self):
-        results = self.FakeArgs(series='trusty', source='linux')
-        expected = copy(results).update(esm=True, to_signing=True)
-        with self.capture() as (out, err):
-            auto_route(results)
-        self.assertEqual(expected.__dict__, results.__dict__)
-        self.assertIn('from and to ESM', out.getvalue().strip())
-        self.assertIn('via signing', out.getvalue().strip())
-
-    def test_esm_trusty_linux_aws(self):
-        results = self.FakeArgs(series='trusty', source='linux-aws')
-        expected = copy(results).update(esm=True)
-        with self.capture() as (out, err):
-            auto_route(results)
-        self.assertEqual(expected.__dict__, results.__dict__)
-        self.assertIn('from and to ESM', out.getvalue().strip())
-        self.assertNotIn('via signing', out.getvalue().strip())
-
-    def test_esm_precise_linux_lts_trusty(self):
-        results = self.FakeArgs(series='precise', source='linux-lts-trusty')
-        expected = copy(results).update(esm=True, to_signing=True)
-        with self.capture() as (out, err):
-            auto_route(results)
-        self.assertEqual(expected.__dict__, results.__dict__)
-        self.assertIn('from and to ESM', out.getvalue().strip())
-        self.assertIn('via signing', out.getvalue().strip())
-
-    def test_fips_bionic_linux_fips(self):
-        results = self.FakeArgs(series='bionic', source='linux-fips')
-        expected = copy(results).update(fips=True, to_signing=True)
-        with self.capture() as (out, err):
-            auto_route(results)
-        self.assertEqual(expected.__dict__, results.__dict__)
-        self.assertIn('from and to FIPS', out.getvalue().strip())
-        self.assertIn('via signing', out.getvalue().strip())
-
-    def test_ibmgt_bionic_linux_ibmgt(self):
-        results = self.FakeArgs(series='bionic', source='linux-ibm-gt')
-        expected = copy(results).update(ibmgt=True)
-        with self.capture() as (out, err):
-            auto_route(results)
-        self.assertEqual(expected.__dict__, results.__dict__)
-        self.assertIn('from and to IBM-GT', out.getvalue().strip())
-        self.assertNotIn('via signing', out.getvalue().strip())
-
-def auto_route(args):
-    before = (args.esm, args.fips, args.ibmgt, args.to_signing)
-
-    if args.series in ('precise', 'trusty'):
-        args.esm = True
-    if args.esm:
-        if (args.series == 'precise' and args.source in ('linux', 'linux-meta', 'linux-backports-modules-3.2.0') or
-                args.series == 'trusty' and args.source in ('linux-aws', 'linux-meta-aws')):
-            args.to_signing = False
-        else:
-            args.to_signing = True
-
-    if args.source.endswith('-fips'):
-        args.fips = True
-    if args.fips:
-        args.to_signing = True
-
-    if args.source.endswith('-ibm-gt'):
-        args.ibmgt = True
-
-    if before != (args.esm, args.fips, args.ibmgt, args.to_signing):
-        msg = "NOTE: directing copy "
-        if args.esm:
-            msg += "from and to ESM"
-        elif args.fips:
-            msg += "from and to FIPS"
-        elif args.ibmgt:
-            msg += "from and to IBM-GT PPAs"
-        if args.to_signing:
-            msg += " via signing"
+        to_archive = signing_archive
+    # Automatically route to signing by default.
+    elif args.no_auto is False and signing_archive is not None and package_signed is not None:
+        to_archive = signing_archive
+
+    # Announce the routing if needed.
+    if (args.testing is False and (routing.name != 'default' or from_archive == signing_archive or to_archive == signing_archive)):
+        msg = "NOTE: directing copy using {} routes".format(routing.name)
+        if from_archive == signing_archive:
+            msg += ' from signing'
+        elif to_archive == signing_archive:
+            msg += ' to signing'
         print(msg)
 
+    return (from_archive, to_archive, unembargo)
+
 
 # SELF-TESTS:
 if len(sys.argv) >= 2 and sys.argv[1] == '--self-test':
@@ -347,7 +354,9 @@
     sys.exit(0)
 
 parser = argparse.ArgumentParser(description='Copy a proposed kernel to the apropriate archive pocket')
+parser.set_defaults(testing=False)
 parser.add_argument('--dry-run', action='store_true', help='Do everything but actually copy the package')
+parser.add_argument('--ppa2', action='store_true', help='Copy from the kernel build PPA2')
 parser.add_argument('--security', '-S', action='store_true', help='Copy from the kernel security PPA')
 parser.add_argument('--security2', action='store_true', help='Copy from the kernel security PPA2')
 parser.add_argument('--esm', '-E', action='store_true', help='Copy from the kernel ESM PPA and to the kernel ESM proposed PPA')
@@ -357,73 +366,87 @@
 parser.add_argument('--to-signing', action='store_true', help='Copy from the kernel ESM/FIPS PPA to the ESM/FIPS signing PPA')
 parser.add_argument('--from-signing', action='store_true', help='Copy from the ESM/FIPS signing PPA to the ESM/FIPS proposed PPA')
 parser.add_argument('series', action='store', help='The series the source package is in')
-parser.add_argument('source', action='store', help='The source package name')
+parser.add_argument('source', action='store', nargs='+', help='The source package name')
 
 args = parser.parse_args()
 
-# If we are allowed to intuit destinations do so:
-# 1) precise is now destined for the ESM PPAs
-if not args.no_auto:
-    auto_route(args)
-
-(ppa_name, to, security) = routing(args)
-
-##print("ppa_name<{}> to<{}>".format(ppa_name, to))
-
-if ppa_name is None:
-    print("ERROR: bad source PPA")
-    sys.exit(1)
-if to is None:
-    print("ERROR: bad destination")
-    sys.exit(1)
-
-(release, pkg) = (args.series, args.source)
+if args.esm or args.fips or args.ibmgt:
+    print("NOTE: flags --esm, --fips, and --ibmgt are now deprecated")
+
+release = args.series
+
+ks = KernelSeries()
 
 launchpad = Launchpad.login_with(
     'ubuntu-archive-tools', 'production', version='devel')
 ubuntu = launchpad.distributions['ubuntu']
 distro_series = ubuntu.getSeries(name_or_version=release)
-kernel_ppa = launchpad.archives.getByReference(
-    reference=ppa_name)
-
-# Grab a reference to the 'to' archive and select a pocket.
-to_archive = launchpad.archives.getByReference(reference=to)
-if to == 'ubuntu':
-    to_pocket = 'proposed'
-else:
-    to_pocket = 'release'
-
-# get current version in PPA for that series
-versions = kernel_ppa.getPublishedSources(
-    source_name=pkg, exact_match=True, status='Published', pocket='Release',
-    distro_series=distro_series)
-version = None
-if versions.total_size == 1:
-    version = versions[0].source_package_version
-
-include_binaries = (pkg not in ('debian-installer')
-                    and not pkg.startswith('linux-signed'))
-if args.from_signing:
-    include_binaries = True
-
-print("""Copying {}/{}:
- From: {} release
- To: {} {}
- Binaries: {}""".format(pkg, version, kernel_ppa, to_archive, to_pocket, include_binaries))
-
-if not version:
-    print("ERROR: no version to copy")
-    sys.exit(1)
+
+copies = []
+for pkg in list(args.source):
+    # BODGE: routing should just take release/pkg.
+    args.source = pkg
+
+    (from_archive, to_archive, security) = routing(args, ks)
+    ##print("from_archive<{}> to_archive<{}>".format(from_archive, to_archive))
+
+    if from_archive is None:
+        print("ERROR: bad source PPA")
+        sys.exit(1)
+    if to_archive is None:
+        print("ERROR: bad destination")
+        sys.exit(1)
+
+    (from_reference, from_pocket) = from_archive
+    (to_reference, to_pocket) = to_archive
+
+    # Grab a reference to the 'from' archive.
+    from_archive = launchpad.archives.getByReference(
+        reference=from_reference)
+
+    # Grab a reference to the 'to' archive.
+    to_archive = launchpad.archives.getByReference(reference=to_reference)
+
+    # get current version in PPA for that series
+    versions = from_archive.getPublishedSources(
+        source_name=pkg, exact_match=True, status='Published', pocket=from_pocket,
+        distro_series=distro_series)
+    version = None
+    if versions.total_size == 1:
+        version = versions[0].source_package_version
+
+    include_binaries = (pkg not in ('debian-installer')
+                        and not pkg.startswith('linux-signed'))
+    if args.from_signing:
+        include_binaries = True
+
+    print("""Copying {}/{}:
+     From: {} {}
+     To: {} {}
+     Binaries: {}""".format(pkg, version, from_archive.reference, from_pocket, to_archive.reference, to_pocket, include_binaries))
+
+    if not version:
+        print("ERROR: no version to copy")
+        sys.exit(1)
+
+    copies.append({
+            'from_archive': from_archive,
+            'include_binaries': include_binaries,
+            'source_name': pkg,
+            'to_series': release,
+            'to_pocket': to_pocket,
+            'version': version,
+            'auto_approve': True,
+            'unembargo': security,
+        })
 
 if args.dry_run:
     print("Dry run; no packages copied.")
     sys.exit(0)
 
-# Finally ready to actually copy this.
-to_archive.copyPackage(
-    from_archive=kernel_ppa, include_binaries=include_binaries,
-    source_name=pkg, to_series=release, to_pocket=to_pocket, version=version,
-    auto_approve=True, unembargo=security)
+for copy in copies:
+    # We found valid packages for each requested element, actually copy them.
+    to_archive.copyPackage(**copy)
 
 # TODO: adjust this script to use find-bin-overrides or rewrite
 # find-bin-overrides to use lpapi and use it here.

=== added file 'kernel_series.py'
--- kernel_series.py	1970-01-01 00:00:00 +0000
+++ kernel_series.py	2019-09-19 13:51:06 +0000
@@ -0,0 +1,657 @@
+#!/usr/bin/env python
+#
+
+try:
+    from urllib.request import urlopen
+except ImportError:
+    from urllib2 import urlopen
+
+import os
+import yaml
+
+class KernelRoutingEntry:
+    def __init__(self, ks, source, data):
+        name = "{}:{}".format(source.series.codename, source.name)
+        if isinstance(data, str):
+            name = data
+            table = source.series.routing_table
+            if table is None:
+                raise ValueError("unable to map routing alias {}, "
+                                 "no series routing table".format(data))
+            if data not in table:
+                raise ValueError("unable to map routing alias {}, "
+                                 "not listed in series routing table".format(data))
+            data = table[data]
+
+        # Clear out any entries that have been overriden to None.
+        for entry in dict(data):
+            if data[entry] is None:
+                del data[entry]
+
+        self._ks = ks
+        self._source = source
+        self._name = name
+        self._data = data if data else {}
+
+    @property
+    def source(self):
+        return self._source
+
+    @property
+    def name(self):
+        return self._name
+
+    def __eq__(self, other):
+        if isinstance(self, other.__class__):
+            return list(self) == list(other)
+        return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __iter__(self):
+        return iter(self._data.items())
+
+    def __getitem__(self, which):
+        return self._data[which]
+
+    def lookup_destination(self, dest, primary=False):
+        data = self._data.get(dest, None)
+        if primary is False or data is None:
+            return data
+        return data[0]
+
+    def __str__(self):
+        return str(self._data)
+
+
+class KernelRepoEntry:
+    def __init__(self, ks, owner, data):
+        if isinstance(data, list):
+            new_data = {'url': data[0]}
+            if len(data) == 1:
+                new_data['branch'] = 'master'
+            elif len(data) == 2:
+                new_data['branch'] = data[1]
+            data = new_data
+
+        self._ks = ks
+        self._owner = owner
+        self._data = data if data else {}
+
+    @property
+    def owner(self):
+        return self._owner
+
+    # XXX: should this object have a name ?
+
+    def __eq__(self, other):
+        if isinstance(self, other.__class__):
+            return self.url == other.url and self.branch == other.branch
+        return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    @property
+    def url(self):
+        return self._data['url']
+
+    @property
+    def branch(self):
+        return self._data.get('branch', None)
+
+    def __str__(self):
+        return "{} {}".format(self.url, self.branch)
+
+
+class KernelSnapEntry:
+    def __init__(self, ks, source, name, data):
+        self._ks = ks
+        self._source = source
+        self._name = name
+        self._data = data if data else {}
+
+        # Convert arches/track to publish-to form.
+        if 'publish-to' not in self._data:
+            if 'arches' in self._data:
+                publish_to = {}
+                for arch in self._data['arches']:
+                    publish_to[arch] = [self._data.get('track', 'latest')]
+                self._data['publish-to'] = publish_to
+
+        # Convert stable to promote-to form.
+        if 'promote-to' not in self._data and 'stable' in self._data:
+            if self._data['stable'] is True:
+                self._data['promote-to'] = 'stable'
+            else:
+                self._data['promote-to'] = 'candidate'
+        # Assume no promote-to data to mean just to edge.
+        promote_to = self._data.get('promote-to', 'edge')
+        if isinstance(promote_to, str):
+            expand_promote_to = []
+            for risk in ('edge', 'beta', 'candidate', 'stable'):
+                expand_promote_to.append(risk)
+                if risk == promote_to:
+                    break
+            self._data['promote-to'] = expand_promote_to
+        # Ensure we have stable when promote-to is present.
+        if 'promote-to' in self._data and 'stable' not in self._data:
+            if 'stable' in self._data['promote-to']:
+                self._data['stable'] = True
+            else:
+                self._data['stable'] = False
+
+    def __eq__(self, other):
+        if isinstance(self, other.__class__):
+            return self.name == other.name and self.source == other.source
+        return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    @property
+    def series(self):
+        return self._source.series
+
+    @property
+    def source(self):
+        return self._source
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def repo(self):
+        data = self._data.get('repo', None)
+        if not data:
+            return None
+        return KernelRepoEntry(self._ks, self, data)
+
+    @property
+    def primary(self):
+        return self._data.get('primary', False)
+
+    @property
+    def gated(self):
+        return self._data.get('gated', False)
+
+    @property
+    def stable(self):
+        return self._data.get('stable', False)
+
+    @property
+    def qa(self):
+        return self._data.get('qa', False)
+
+    @property
+    def hw_cert(self):
+        return self._data.get('hw-cert', False)
+
+    @property
+    def arches(self):
+        # XXX: should this be []
+        return self._data.get('arches', None)
+
+    @property
+    def track(self):
+        return self._data.get('track', None)
+
+    @property
+    def publish_to(self):
+        return self._data.get('publish-to', None)
+
+    @property
+    def promote_to(self):
+        return self._data.get('promote-to', None)
+
+    def promote_to_risk(self, risk):
+        return risk in self._data.get('promote-to', [])
+
+    def __str__(self):
+        return "{} {}".format(str(self.source), self.name)
+
+
+class KernelPackageEntry:
+    def __init__(self, ks, source, name, data):
+        self._ks = ks
+        self._source = source
+        self._name = name
+        self._data = data if data else {}
+
+    def __eq__(self, other):
+        if isinstance(self, other.__class__):
+            return self.name == other.name and self.source == other.source
+        return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    @property
+    def series(self):
+        return self._source.series
+
+    @property
+    def source(self):
+        return self._source
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def type(self):
+        return self._data.get('type', None)
+
+    @property
+    def repo(self):
+        data = self._data.get('repo', None)
+        if not data:
+            return None
+        return KernelRepoEntry(self._ks, self, data)
+
+    def __str__(self):
+        return "{} {} {}".format(str(self.source), self.name, self.type)
+
+
+class KernelSourceEntry:
+    def __init__(self, ks, series, name, data):
+        self._ks = ks
+        self._series = series
+        self._name = name
+        self._data = data if data else {}
+
+    def __eq__(self, other):
+        if isinstance(self, other.__class__):
+            return self.name == other.name and self.series == other.series
+        return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def series(self):
+        return self._series
+
+    @property
+    def versions(self):
+        if 'versions' in self._data:
+            return self._data['versions']
+
+        derived_from = self.derived_from
+        if derived_from is not None:
+            return derived_from.versions
+
+        copy_forward = self.copy_forward
+        if copy_forward is not None:
+            return copy_forward.versions
+
+        # XXX: should this be []
+        return None
+
+    @property
+    def version(self):
+        versions = self.versions
+        if not versions:
+            return None
+        return versions[-1]
+
+    @property
+    def development(self):
+        return self._data.get('development', self.series.development)
+
+    @property
+    def supported(self):
+        return self._data.get('supported', self.series.supported)
+
+    @property
+    def severe_only(self):
+        return self._data.get('severe-only', False)
+
+    @property
+    def stakeholder(self):
+        return self._data.get('stakeholder', None)
+
+    @property
+    def packages(self):
+        # XXX: should this return None when empty
+        result = []
+        packages = self._data.get('packages')
+        if packages:
+            for package_key, package in packages.items():
+                result.append(KernelPackageEntry(self._ks, self, package_key, package))
+        return result
+
+    def lookup_package(self, package_key):
+        packages = self._data.get('packages')
+        if not packages or package_key not in packages:
+            return None
+        return KernelPackageEntry(self._ks, self, package_key, packages[package_key])
+
+    @property
+    def snaps(self):
+        # XXX: should this return None when empty
+        result = []
+        snaps = self._data.get('snaps')
+        if snaps:
+            for snap_key, snap in snaps.items():
+                result.append(KernelSnapEntry(self._ks, self, snap_key, snap))
+        return result
+
+    def lookup_snap(self, snap_key):
+        snaps = self._data.get('snaps')
+        if not snaps or snap_key not in snaps:
+            return None
+        return KernelSnapEntry(self._ks, self, snap_key, snaps[snap_key])
+
+    @property
+    def derived_from(self):
+        if 'derived-from' not in self._data:
+            return None
+
+        (series_key, source_key) = self._data['derived-from']
+
+        series = self._ks.lookup_series(series_key)
+        source = series.lookup_source(source_key)
+
+        return source
+
+    @property
+    def testable_flavours(self):
+        retval = []
+        if (self._data.get('testing') is not None and
+                self._data['testing'].get('flavours') is not None
+           ):
+            for flavour in self._data['testing']['flavours'].keys():
+                fdata = self._data['testing']['flavours'][flavour]
+                # If we have neither arches nor clouds we represent a noop
+                if not fdata:
+                    continue
+                arches = fdata.get('arches', None)
+                arches = arches if arches is not None else []
+                clouds = fdata.get('clouds', None)
+                clouds = clouds if clouds is not None else []
+                retval.append(KernelSourceTestingFlavourEntry(flavour, arches, clouds))
+        return retval
+
+    @property
+    def invalid_tasks(self):
+        retval = self._data.get('invalid-tasks', [])
+        if retval is None:
+            retval = []
+        return retval
+
+    @property
+    def copy_forward(self):
+        if 'copy-forward' not in self._data:
+            return None
+
+        # XXX: backwards compatibility.
+        if self._data['copy-forward'] is False:
+            return None
+        if self._data['copy-forward'] is True:
+            derived_from = self.derived_from
+            if derived_from is None:
+                return True
+            return self.derived_from
+
+        (series_key, source_key) = self._data['copy-forward']
+
+        series = self._ks.lookup_series(series_key)
+        source = series.lookup_source(source_key)
+
+        return source
+
+    @property
+    def backport(self):
+        return self._data.get('backport', False)
+
+    @property
+    def routing(self):
+        default = 'default'
+        if self.series.development:
+            default = 'devel'
+        if self.series.esm:
+            default = 'esm'
+        data = self._data.get('routing', default)
+        if data is None:
+            return data
+        return KernelRoutingEntry(self._ks, self, data)
+
+    @property
+    def swm_data(self):
+        return self._data.get('swm')
+
+    @property
+    def private(self):
+        return self._data.get('private', False)
+
+    def __str__(self):
+        return "{} {}".format(self.series.name, self.name)
+
+class KernelSourceTestingFlavourEntry:
+    def __init__(self, name, arches, clouds):
+        self._name = name
+        self._arches = arches
+        self._clouds = clouds
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def arches(self):
+        return self._arches
+
+    @property
+    def clouds(self):
+        return self._clouds
+
+class KernelSeriesEntry:
+    def __init__(self, ks, name, data, defaults=None):
+        self._ks = ks
+        self._name = name
+        self._data = {}
+        if defaults is not None:
+            self._data.update(defaults)
+        if data is not None:
+            self._data.update(data)
+
+    def __eq__(self, other):
+        if isinstance(self, other.__class__):
+            return self.name == other.name
+        return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def codename(self):
+        return self._data.get('codename', None)
+
+    @property
+    def opening(self):
+        if 'opening' in self._data:
+            if self._data['opening'] is not False:
+                return True
+        return False
+
+    def opening_ready(self, *flags):
+        if 'opening' not in self._data:
+            return True
+        allow = self._data['opening']
+        if allow is None:
+            return False
+        if allow in (True, False):
+            return not allow
+        for flag in flags:
+            flag_allow = allow.get(flag, False)
+            if flag_allow is None or flag_allow is False:
+                return False
+        return True
+    opening_allow = opening_ready
+
+    @property
+    def development(self):
+        return self._data.get('development', False)
+
+    @property
+    def supported(self):
+        return self._data.get('supported', False)
+
+    @property
+    def lts(self):
+        return self._data.get('lts', False)
+
+    @property
+    def esm(self):
+        return self._data.get('esm', False)
+
+    def __str__(self):
+        return "{} ({})".format(self.name, self.codename)
+
+    @property
+    def sources(self):
+        result = []
+        sources = self._data.get('sources')
+        if sources:
+            for source_key, source in sources.items():
+                result.append(KernelSourceEntry(
+                    self._ks, self, source_key, source))
+        return result
+
+    @property
+    def routing_table(self):
+        return self._data.get('routing-table', None)
+
+    def lookup_source(self, source_key):
+        sources = self._data.get('sources')
+        if not sources or source_key not in sources:
+            return None
+        return KernelSourceEntry(self._ks, self, source_key, sources[source_key])
+
+
+# KernelSeries
+#
+class KernelSeries:
+    _url = 'https://git.launchpad.net/~canonical-kernel/' \
+        '+git/kteam-tools/plain/info/kernel-series.yaml'
+    _url_local = 'file://' + os.path.realpath(os.path.join(os.path.dirname(__file__),
+                                                           '..', 'info', 'kernel-series.yaml'))
+    #_url = 'file:///home/apw/git2/kteam-tools/info/kernel-series.yaml'
+    #_url = 'file:///home/work/kteam-tools/info/kernel-series.yaml'
+    _data_txt = {}
+
+    @classmethod
+    def __load_once(cls, url):
+        if url not in cls._data_txt:
+            response = urlopen(url)
+            data = response.read()
+            if not isinstance(data, str):
+                data = data.decode('utf-8')
+            cls._data_txt[url] = data
+        return cls._data_txt[url]
+
+    def __init__(self, url=None, data=None, use_local=os.getenv("USE_LOCAL_KERNEL_SERIES_YAML", False)):
+        if data or url:
+            if url:
+                response = urlopen(url)
+                data = response.read()
+            if not isinstance(data, str):
+                data = data.decode('utf-8')
+        else:
+            data = self.__load_once(self._url_local if use_local else self._url)
+        self._data = yaml.load(data)
+
+        self._development_series = None
+        self._codename_to_series = {}
+        for series_key, series in self._data.items():
+            if not series:
+                continue
+            if series.get('development', False):
+                self._development_series = series_key
+            if 'codename' in series:
+                self._codename_to_series[series['codename']] = series_key
+
+        # Pull out the defaults.
+        self._defaults_series = {}
+        if 'defaults' in self._data:
+            self._defaults_series = self._data['defaults']
+            del self._data['defaults']
+
+    @staticmethod
+    def key_series_name(series):
+        return [int(x) for x in series.name.split('.')]
+
+    @property
+    def series(self):
+        return [KernelSeriesEntry(self, series_key, series,
+                defaults=self._defaults_series)
+                for series_key, series in self._data.items()]
+
+    def lookup_series(self, series=None, codename=None, development=False):
+        if not series and not codename and not development:
+            raise ValueError("series/codename/development required")
+        if not series and codename:
+            if codename not in self._codename_to_series:
+                return None
+            series = self._codename_to_series[codename]
+        if not series and development:
+            if not self._development_series:
+                return None
+            series = self._development_series
+        if series and series not in self._data:
+            return None
+        return KernelSeriesEntry(self, series, self._data[series],
+                                 defaults=self._defaults_series)
+
+
+if __name__ == '__main__':
+    db = KernelSeries()
+
+    series = db.lookup_series('16.04')
+    if series.name != '16.04':
+        print('series.name != 16.04')
+    if series.codename != 'xenial':
+        print('series.codename != xenial')
+
+    series2 = db.lookup_series(codename='xenial')
+    if series2.name != '16.04':
+        print('series2.name != 16.04')
+    if series2.codename != 'xenial':
+        print('series2.codename != xenial')
+
+    series3 = db.lookup_series(development=True)
+    if series3.name != '18.04':
+        print('series3.name != 18.04')
+    if series3.codename != 'bionic':
+        print('series3.codename != bionic')
+
+    print(str(series), str(series2), str(series3))
+
+    for series2 in sorted(db.series, key=db.key_series_name):
+        print(series2)
+
+    for source in series.sources:
+        print(str(source), source.series.name, source.name)
+
+        print(source.derived_from)
+        print(source.versions)
+
+        for package in source.packages:
+            print("PACKAGE", str(package))
+
+        for snap in source.snaps:
+            print("SNAP", str(snap), snap.arches)
+
+
+# vi:set ts=4 sw=4 expandtab:

=== modified file 'sru-release'
--- sru-release	2019-08-27 11:30:27 +0000
+++ sru-release	2019-09-19 13:51:06 +0000
@@ -39,6 +39,8 @@
 
 from launchpadlib.launchpad import Launchpad
 
+from kernel_series import KernelSeries
+
 
 # Each entry in this list is a list of source packages that are known
 # to have inter-dependencies and must be released simultaneously.
@@ -179,10 +181,10 @@
       'published': proposed_date}
     '''
     versions = defaultdict(dict)
-    if options.esm:
+    if src_archive.reference == 'ubuntu':
+        pocket = 'Proposed'
+    else:
         pocket = 'Release'
-    else:
-        pocket = 'Proposed'
 
     matches = src_archive.getPublishedSources(
         source_name=sourcename, exact_match=not options.pattern,
@@ -193,9 +195,9 @@
                 source_name=match.source_package_name, exact_match=True,
                 status='Published', distro_series=series):
             key = pub.pocket.lower()
-            # special case for ESM ppas, which don't have pockets but need
+            # special case for ppas, which don't have pockets but need
             # to be treated as -proposed
-            if options.esm and key == 'release':
+            if pocket == 'Release' and key == 'release':
                 key = 'proposed'
             versions[pub.source_package_name][key] = (
                 pub.source_package_version)
@@ -213,7 +215,6 @@
                 if pocket in pub.pocket:
                     versions[pub.source_package_name]['changesfile'] = (
                         pub.changesFileUrl())
-            
         # devel version
         if devel_series:
             for pub in src_archive.getPublishedSources(
@@ -360,6 +361,13 @@
     release = args.pop(0)
     packages = args
 
+    # XXX: we only want to instantiate KernelSeries if we suspect this is
+    #      a kernel package, this is necessarily dirty, dirty, dirty.
+    kernel_checks = False
+    for package in packages:
+        if package.startswith('linux-') or package == 'linux':
+            kernel_checks = True
+
     if not options.skip_package_group_check:
         try:
             packages = check_package_sets(packages)
@@ -376,12 +384,57 @@
         sys.stderr.write(
             'WARNING: No current development series, -d will not work\n')
         devel_series = None
-    if release in ('precise', 'trusty'):
+
+    ks_source = None
+    if kernel_checks:
+        kernel_series = KernelSeries()
+
+        # See if we have a kernel-series record for this package.  If we do
+        # then we are going to pivot to the routing therein.
+        ks_series = kernel_series.lookup_series(codename=release)
+        for ks_source_find in ks_series.sources:
+            for ks_package in ks_source_find.packages:
+                if ks_package.name == packages[0]:
+                    ks_source = ks_source_find
+                    break
+
+        # First confirm everything in this set we are attempting to release
+        # are indeed listed as valid for this kernel.
+        if ks_source is not None:
+            for package in packages:
+                if ks_source.lookup_package(package) is None:
+                    sys.stderr.write(
+                        'WARNING: {} not found in packages for kernel {}\n'.format(
+                        package, ks_source.name))
+
+    if ks_source is None and release in ('precise', 'trusty'):
         sys.stdout.write(
             'Called for {}; assuming kernel ESM publication\n'.format(release))
         options.esm = True
 
-    if options.esm:
+    # If we found a KernelSeries entry this has accurate routing information
+    # attached use that.
+    if ks_source is not None:
+        src_archive_ref, src_archive_pocket = ks_source.routing.lookup_destination('proposed', primary=True)
+        src_archive = launchpad.archives.getByReference(
+            reference=src_archive_ref)
+        dst_archive_ref, dst_archive_pocket = ks_source.routing.lookup_destination('updates', primary=True)
+        if dst_archive_ref == src_archive_ref:
+            dst_archive = src_archive
+        else:
+            dst_archive = launchpad.archives.getByReference(
+                reference=dst_archive_ref)
+
+        # Announce any non-standard archive routing.
+        if src_archive_ref != 'ubuntu':
+            print("Src Archive: {}".format(src_archive_ref))
+        if dst_archive_ref != 'ubuntu':
+            print("Dst Archive: {}".format(dst_archive_ref))
+            # --security is meaningless for private PPA publishing (XXX: currently true)
+            options.security = False
+            options.release = True
+
+    elif options.esm:
         # --security is meaningless for ESM everything is a security update.
         options.security = False
         options.release = True