#!/usr/bin/python2.7

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

import grp
import os
from subprocess import Popen, PIPE, check_call, CalledProcessError
import sys
import traceback

import smf_include

DOCKER_EXEC="/usr/bin/docker"
MKDIR="/usr/bin/mkdir"
SVCADM="/usr/sbin/svcadm"
SVCCFG="/usr/sbin/svccfg"
SVCPROP="/usr/bin/svcprop"
ZFS="/usr/sbin/zfs"

DOCKER_SVC = 'svc:/application/docker/docker'
DOCKER_ROOT="/var/run/docker"
DOCKER_MOUNTPOINT="/var/lib/docker"


class SvcDockerException(Exception):
    pass


class SvcDockerCmd(object):
    def __init__(self, cmd):
        self.cmd = cmd

    def run(self, expect_nonzero=None):
        p = Popen(self.cmd, stdout=PIPE, stderr=PIPE)
        output, error = p.communicate()
        if not expect_nonzero and p.returncode != 0:
            raise SvcDockerException(error)
        return output


def _get_docker_prop(pname):
    try:
        output = SvcDockerCmd([SVCPROP, '-p', pname, DOCKER_SVC]).run()
        return output.strip('"').strip()
    except SvcDockerException as e:
        print "Unable to retrieve property '%s': %s" % (pname, e)
        sys.exit(1)


def _set_docker_prop(pname, pval):
    try:
        SvcDockerCmd(
            [SVCCFG, '-s', DOCKER_SVC, 'setprop', pname, '=', pval]).run()
        SvcDockerCmd(cmd = [SVCADM, 'refresh', 'docker']).run()
    except SvcDockerException as e:
        print "Unable to set property '%s', value '%s': %s" % \
            (pname, pval, e)
        sys.exit(1)


def _get_root_pool():
    try:
        return SvcDockerCmd(
            [ZFS, 'list', '-Ho', 'name', '/']).run().split('/')[0]
    except SvcDockerException as e:
        print "Unable to get root pool: %s" % e
        sys.exit(1)


def _fsname_in_active_be(fsname):
    try:
        root_ds = SvcDockerCmd(
            [ZFS, 'list', '-r', '-Ho', 'name', '/']).run().split()[0]
        return fsname.startswith(root_ds)
    except SvcDockerException as e:
        print "Unable to get active root dataset: %s" % e
        sys.exit(1)


def _fsname_exists(fsname):
    try:
        SvcDockerCmd([ZFS, 'list', fsname]).run()
        return True
    except SvcDockerException as e:
        if "does not exist" in str(e):
            return False
        print "Unable to list dataset: %s" % e
        sys.exit(1)


def _get_mounted_dataset():
    if not os.path.exists(DOCKER_MOUNTPOINT):
        return None
    try:
        return SvcDockerCmd(
            [ZFS, 'list', '-Ho', 'name', DOCKER_MOUNTPOINT]).run().strip()
    except SvcDockerException as e:
        print "Unable to get mounted Docker dataset: %s" % e
        sys.exit(1)


def _get_dataset_mountpoint(fsname):
    try:
        return SvcDockerCmd(
            [ZFS, 'list', '-Ho', 'mountpoint', fsname]).run().strip()
    except SvcDockerException as e:
        print "Unable to get mountpoint for dataset: %s" % e
        sys.exit(1)


def _mount_dataset(fsname):
    try:
        return SvcDockerCmd([ZFS, 'mount', fsname]).run()
    except SvcDockerException as e:
        print "Unable to mount Docker root: %s" % e
        sys.exit(1)


def _unmount_dataset(fsname):
    try:
        return SvcDockerCmd([ZFS, 'unmount', fsname]).run()
    except SvcDockerException as e:
        print "Unable to unmount Docker root: %s" % e
        sys.exit(1)


def _set_ds_props_for_varshare(fsname):
    # If in VARSHARE (default), make sure we turn setuid/exec/xattr on
    # (off by default in VARSHARE).
    for prop in ['setuid', 'exec', 'xattr']:
        try:
            SvcDockerCmd([ZFS, 'set', prop + '=on', fsname]).run()
        except SvcDockerException as e:
            print "Failed to set '%s' prop on dataset '%s': %s" % \
                (prop, fsname, error)
            sys.exit(1)


def _create_docker_dir():
    if not os.path.exists(DOCKER_ROOT):
        try:
            os.mkdir(DOCKER_ROOT, 0770)
        except OSError as e:
            print "Unable to create dir '%s': %s" % (DOCKER_ROOT, e)
            sys.exit(1)


def _init_dataset(fsname):
    if not fsname:
        # Default to 'docker' in varshare
        fsname = os.path.join(_get_root_pool(), "VARSHARE/docker")
        _set_docker_prop("config/fsname", fsname)

    if _fsname_in_active_be(fsname):
        print "config/fsname cannot be child of active root dataset"
        sys.exit(smf_include.SMF_EXIT_ERR_CONFIG)

    if _fsname_exists(fsname):
        if _get_mounted_dataset() != fsname:
            if _get_dataset_mountpoint(fsname) != DOCKER_MOUNTPOINT:
                print "Configured dataset '%s' mountpoint must be '%s'" % \
                    (fsname, DOCKER_MOUNTPOINT)
                sys.exit(smf_include.SMF_EXIT_ERR_CONFIG)
            _mount_dataset(fsname)
        if fsname.startswith('rpool/VARSHARE/'):
            _set_ds_props_for_varshare(fsname)
    else:
        # Dataset doesn't exist, try and create it. This may fail if
        # /var/lib/docker is not empty, or if another dataset is mounted there.
        try:
            SvcDockerCmd(
                [ZFS, 'create', '-o', 'mountpoint=' + DOCKER_MOUNTPOINT,
                 '-o', 'setuid=on', '-o', 'exec=on', '-o', 'xattr=on',
                 '-o', 'compression=on', fsname]).run()
        except SvcDockerException as e:
            print "Failed to create dataset '%s' on %s: %s" % \
                (DOCKER_MOUNTPOINT, fsname, e)
            sys.exit(1)


def start():
    # Setup /var/lib/docker and the root dataset
    _create_docker_dir()
    fsname = _get_docker_prop("config/fsname")
    _init_dataset(fsname)

    # Setup environment variables for the daemon
    for p in ['http_proxy', 'https_proxy']:
        v = _get_docker_prop("config/%s" % p)
        if v:
            os.putenv(p, v)

    # Set up the service command line to execut the daemon
    dcmd = DOCKER_EXEC + ' daemon'
    if _get_docker_prop('config/debug') == 'true':
        dcmd += ' -D'
    dcmd += ' --exec-root="%s"' % DOCKER_ROOT
    dcmd += ' --graph="%s"' % DOCKER_MOUNTPOINT
    dcmd += ' --pidfile="%s/docker.pid"' % DOCKER_ROOT
    dcmd += ' --storage-opt zfs.fsname=' + fsname

    smf_include.smf_subprocess(dcmd)
    sys.exit(smf_include.SMF_EXIT_OK)


def stop():
    # First, kill off the SMF contract
    try:
        check_call(["/usr/bin/pkill", "-c", sys.argv[2]])
    except CalledProcessError as e:
        # 1 is returncode if no SMF contract processes were matched,
        # meaning they have already terminated.
        if e.returncode != 1:
            print "failed to kill the SMF contract: %s" % e
            return smf_include.SMF_EXIT_ERR_FATAL

    # Now unmount the root dataset from /var/lib/docker
    _unmount_dataset(DOCKER_MOUNTPOINT)


if __name__ == '__main__':
    os.putenv('LC_ALL', 'C')
    try:
        smf_include.smf_main()
    except RuntimeError:
        sys.exit(smf_include.SMF_EXIT_ERR_FATAL)
    except Exception as err:
        print 'Unknown error:  %s' % err
        print
        traceback.print_exc(file=sys.stdout)
        sys.exit(smf_include.SMF_EXIT_ERR_FATAL)