# Lars Wirzenius.
# 
# Feel free to use this as you wish. It is simple enough that it is
# probably not even copyrightable.

pipelines:

  # Install APT signing keys from the apt_signing_pub_keys parameter.
  # The parameter should contain a dict, where each item is the name
  # of a signing key, and is used as the filename in
  # /etc/apt/trusted.gpg.d. The dict value is the actual public key,
  # in gpg --export --armore format.

  - pipeline: ick/add_apt_signing_keys
    parameters:
      - apt_signing_pub_keys
    actions:
      - python: |
          for name, key in params['apt_signing_pub_keys'].items():
            filename = '/etc/apt/trusted.gpg.d/{}.asc'.format(name)
            print('Writing key to', filename)
            with open(filename, 'w') as f:
              f.write(key)
        where: container

  # Install APT sources listed in the parameter apt_sources by
  # creating /etc/apt/sources.list.d/ick_apt_sources.list from the
  # list. Each list item must be a dict with fields url, codename,
  # section. For example:
  #
  #     apt_sources:
  #     - url: deb.example.com
  #       dist: unstable
  #       section: main
  #       key: CAFEBEEF
  #     - url: deb.example.com
  #       dist: unstable
  #       section: contrib
  #       key: CAFEBEEF

  - pipeline: ick/add_apt_sources
    parameters:
      - apt_sources
    actions:
      - python: |
          apts = params['apt_sources']
          filename = '/etc/apt/sources.list.d/ick_apt_sources.list'
          print('Creating', filename)
          with open(filename, 'w') as f:
            for apt in apts:
              f.write('deb {url} {dist} {section}\n'.format(**apt))
        where: container

      - shell: |
          apt-get update
        where: container

  # Install build-dependencies for a Debian build, by checking
  # debian/control for what's missing. The sources parameter is used
  # to find all the source trees: for each location, if debian/oontrol
  # exists as the location, look for missing build-dependencies.

  - pipeline: ick/install_debian_build_dependencies
    parameters:
      - sources
    actions:
      - python: |
          import os

          def is_package_name(s):
            ok = "abcdefghijklmnopqrstyuvwxyz"
            ok += ok.upper()
            ok += "0123456789.-"
            return all(c in ok for c in s)

          sources = params['sources']
          for source in sources:
            dirname = source['location']
            control = os.path.join(dirname, 'debian', 'control')
            if os.path.exists(control):
              RUN('apt', 'show', 'python-coverage-test-runner', check=False)
              RUN('apt', 'show', 'python3-coverage-test-runner', check=False)
              err = ERR('dpkg-checkbuilddeps', cwd=dirname)
              print('err', err)
              pat = 'Unmet build dependencies: '
              if pat in err:
                parts = err.split(pat)
                print('parts:', repr(parts))
                missing = [x for x in parts[1].split() if is_package_name(x)]
                print('missing', missing)
                for name in missing:
                  RUN('apt-get', 'install', '-y', name)
        where: container


  # Build Debian packages. This is a CI build, which means a new
  # debian/changelog entry is created, with a version number that
  # contains the build number. This way every build results in a new
  # package version.
  #
  # The build will be done in each location in the sources parameter,
  # where debian/control exists.

  - pipeline: ick/build_deb_ci
    parameters:
      - sources
      - distribution_ci
    actions:

      - where: container
        shell: |
          rm -rf ick-helpers
          git clone git://git.liw.fi/ick-helpers

      - python: |
          import sys
          sys.path.insert(0, '/workspace/ick-helpers')
          import ick_helpers
          ick_helpers.ci_build_debian(params)
        where: container

  # Upload all *.changes files at the root of the workspace.

  - pipeline: ick/upload_debs
    actions:
      - action: dput
        where: host


  # Build release .deb packages from new tags. For the first build,
  # only remember the tags. Note that the workspace must be saved and
  # restored for this to work. The release builds are stored in
  # .release-files in the workspace.
  #
  # Releases are built from release tags, which must be signed,
  # annotated tags, named as foo-1.2 (release 1.2 of project foo). The
  # tag signature must be made by one a key listed in the
  # release_signing_keys parameter.

  - pipeline: ick/build_debian_release
    parameters:
      - sources
      - release_signing_keys
      - distribution_rel
    actions:

      - where: container
        python: |
          for key in params['release_signing_keys']:
            open('key.asc', 'w').write(key)
            RUN('gpg', '--import', 'key.asc')

      - where: container
        shell: |
          rm -rf ick-helpers .release-files
          mkdir .release-files
          git clone git://git.liw.fi/ick-helpers

      - where: container
        python: |
          import sys
          sys.path.insert(0, '/workspace/ick-helpers')
          import ick_helpers
          resultsdir = '.release-files'
          ick_helpers.build_debian_releases(params, resultsdir)

  # Archive the release .debs and related files from .release-files in
  # the workspace. The deb_artifact parameter names the artifact.

  - pipeline: ick/archive_debian_release
    parameters:
      - deb_artifact
    actions:
      - archive: workspace
        where: host
        globs:
          - ".release-files"
        name_from: deb_artifact