#!/usr/bin/python2.7

#

# Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.

#

import argparse

import os

from subprocess import Popen, PIPE

import sys

DOCKERFILE = """FROM scratch

ADD %(archive)s /

LABEL vendor="Oracle USA"

LABEL com.oracle.solaris.version.release="beta"

LABEL com.oracle.solaris.version.branch="%(osversion)s"

CMD /bin/bash

"""

class DockerSupportCmd(object):

    def __init__(self, cmd, verbose=False):

        self.cmd = cmd

        self.verbose = verbose

    def run(self, expect_nonzero=None):

        if self.verbose:

            out = None

        else:

            out = PIPE

        p = Popen(self.cmd, stdout=out, stderr=PIPE)

        output, error = p.communicate()

        if not expect_nonzero and p.returncode != 0:

            raise RuntimeError(error)

        return output

def docker_is_online():

    try:

        return DockerSupportCmd(['/usr/bin/svcs', '-Ho', 'state',

            'docker']).run().strip() == 'online'

    except Exception as err:

        raise RuntimeError("Unable to determine version: %s" % err)

def get_os_version():

    try:

        output = DockerSupportCmd(['/usr/bin/pkg', 'info', '-r',

            'osnet/osnet-incorporation']).run()

        for line in map(str.strip, output.splitlines()):

            if line.startswith("Branch"):

                return line.split(":")[1].strip()

    except Exception as err:

        raise RuntimeError("Unable to determine version: %s" % err)

def create_rootfs_archive(args):

    # we'll build the default archive, make sure we don't clobber one

    if os.path.exists("rootfs.tar.gz"):

        raise RuntimeError("archive already exists 'rootfs.tar.gz'")

    # build here with mkimage, send output to stdout

    cmd = ['/usr/lib/brand/solaris-oci/mkimage-solaris']

    if args.devbuild:

        cmd.append('-D')

    if args.profile:

        if not os.path.exists(args.profile):

            raise RuntimeError("'%s' not found" % args.profile)

        cmd.extend(['-c', args.profile])

    try:

        DockerSupportCmd(cmd, verbose=True).run()

        return "rootfs.tar.gz"

    except Exception as err:

        raise RuntimeError("mkimage-solaris failure: %s" % err)

def create_base_image(args):

    if not docker_is_online():

        raise SystemExit("Docker service not online, is Docker configured?")

    if os.path.exists("Dockerfile"):

        raise SystemExit("Dockerfile already exists in working directory.")

    try:

        print "Creating container rootfs from host publishers..."

        rootfs = create_rootfs_archive(args)

    except Exception as err:

        raise SystemExit("Failed to create rootfs: %s" % err)

    osversion = get_os_version()

    with open("Dockerfile", "w") as dockerfile:

        dockerfile.write(

            DOCKERFILE % {"archive": rootfs, "osversion": osversion})

    tag = "solaris:%s" % osversion

    print "Creating Docker base image '%s'..." % tag

    try: 

        DockerSupportCmd(

            ["/usr/bin/docker", "build", "-t", tag, "."], verbose=True).run()

        DockerSupportCmd(

            ["/usr/bin/docker", "tag", tag, "solaris:latest"]).run()

    except Exception as err:

        raise SystemExit("Failed image build: %s" % err)

    assert os.path.exists("rootfs.tar.gz")

    os.unlink("rootfs.tar.gz")

    print "Build complete."

def build_parser():

    parser_main = argparse.ArgumentParser()

    parser_main.add_argument("-v", "--version", action="version",

        version="%(prog)s 0.1")

    subparsers = parser_main.add_subparsers(title="sub-commands", metavar="")

    parser_create = subparsers.add_parser("create-base-image",

        help="create a base image from host publisher content",

        usage=argparse.SUPPRESS)

    parser_create.add_argument("-D", "--devbuild", action="store_true",

        help="use development build options for the package image")

    parser_create.add_argument("-p", "--profile",

        help="TEMPORARY: optional syconfig profile")

    parser_create.set_defaults(func=create_base_image)

    return parser_main

def main():

    parser = build_parser()

    args = parser.parse_args()

    if not vars(args):

        raise SystemExit(parser.print_help())

    return args.func(args)

if __name__ == "__main__":

    sys.exit(main())