Пример #1
0
def main():
    containername = "kolabclient/presice"

    print("Building kolabclient for Ubuntu 12.04...")
    docker.build(settings.dockerCacheString(),
                 "-t",
                 containername,
                 "{c.SCRIPT_DIR}/ubuntu/precise/.".format(c=config),
                 _out=sys.stdout)
Пример #2
0
def main():
    containername="release"
    dataset="default"

    fdict = {"c": config,
            "containername": containername}

    print("Building release docker...")
    docker.build("-t", containername, "{c.SCRIPT_DIR}/release/.".format(**fdict), _out=sys.stdout)
Пример #3
0
def main():
    containername = "release"
    dataset = "default"

    fdict = {"c": config, "containername": containername}

    print("Building release docker...")
    docker.build("-t",
                 containername,
                 "{c.SCRIPT_DIR}/release/.".format(**fdict),
                 _out=sys.stdout)
Пример #4
0
def main():
    containername="pep"
    dataset="default"

    fdict = {"c": config,
            "dataset": dataset,
            "containername": containername}

    print("Building pep...")
    docker.build(settings.dockerCacheString(), "-t", containername, "{c.SCRIPT_DIR}/pep/.".format(**fdict), _out=sys.stdout)

    print("Building {dataset}'s pep...".format(**fdict))
    docker.build(settings.dockerCacheString(), "-t", "{containername}:{dataset}".format(**fdict), "-f", "{c.SCRIPT_DIR}/pep/Dockerfile-{dataset}".format(**fdict), "{c.SCRIPT_DIR}/pep/.".format(**fdict), _out=sys.stdout)
Пример #5
0
def main(dataset):
    tmpname="kolab/kolabtestcontainer:tmppopulated"
    imagename="kolab/kolabtestcontainer:populated-"+dataset
    basedir =  "{c.SCRIPT_DIR}/kolabpopulated".format(c=config)

    print("Building tmpcontainer...")
    docker.build(settings.dockerCacheString(), "-t", tmpname, "{basedir}/.".format(basedir=basedir))

    print("Starting tmpcontainer...")
    container = docker.run("-d", "-h", settings.HOSTNAME,
            "-v", "/sys/fs/cgroup:/sys/fs/cgroup:ro",
            "-v", "{basedir}/{dataset}/:/data/".format(basedir=basedir, dataset=dataset),
            '-v',  "{c.SCRIPT_DIR}/kolab/populate/:/populate".format(c=config),
            tmpname).rstrip()
    try:
        # Wait for imap to become available on imaps://localhost:993
        time.sleep(5)

        print "Populate OU..."
        docker("exec", container, "python2", "/populate/populate_ou.py", _out=sys.stdout)

        print "Populate users..."
        docker("exec", container, "python2", "/populate/populate_users.py", _out=sys.stdout)

        print "Populate resources..."
        docker("exec", container, "python2", "/populate/populate_resources.py", _out=sys.stdout)

        print("Running populate.sh...")
        docker("exec", container,  "/data/populate.sh", _out=sys.stdout)

        # Give kolabd some time to create all mailboxes
        time.sleep(5)

        docker("exec", container, "patch", "-R", "/etc/kolab/kolab.conf", "/data/kolab.conf.diff", _out=sys.stdout)
        docker("exec", container, "patch", "-R", "/etc/roundcubemail/calendar.inc.php", "/data/calendar.inc.php.diff", _out=sys.stdout)
        docker("exec", container, "patch", "-R", "/etc/roundcubemail/config.inc.php", "/data/config.inc.php.diff", _out=sys.stdout)
        docker("exec", container, "patch", "-R", "/etc/roundcubemail/kolab_addressbook.inc.php", "/data/kolab_addressbook.inc.php.diff", _out=sys.stdout)
        docker("exec", container, "patch", "-R", "/etc/roundcubemail/kolab_auth.inc.php", "/data/kolab_auth.inc.php.diff", _out=sys.stdout)
        docker("exec", container, "patch", "-R", "/etc/roundcubemail/password.inc.php", "/data/password.inc.php.diff", _out=sys.stdout)

        print("Comitting results to: {}".format(imagename))
        docker.commit(container, imagename)
    except:
        print("Unexpected error:", sys.exc_info()[0])
        traceback.print_exc(file=sys.stdout)
        print("Failed to setup container")

    docker.stop(container)
    docker.rm(container)
Пример #6
0
def main(dataset):
    containername="kontact"

    if dataset == "john":
        setupConfigDirs("john", "*****@*****.**", "*****@*****.**", "John Doe", "doe")
    if dataset == "jane":
        setupConfigDirs("jane", "*****@*****.**", "*****@*****.**", "Jane Doe", "doe2")

    fdict = {"c": config,
            "dataset": dataset,
            "containername": containername}

    print("Building kontact...")
    docker.build("-t", containername, "{c.SCRIPT_DIR}/kontact/.".format(**fdict), _out=sys.stdout)

    print("Building {dataset}'s kontact...".format(**fdict))
    docker.build("-t", "{containername}:{dataset}".format(**fdict), "-f", "{c.SCRIPT_DIR}/kontact/Dockerfile-{dataset}".format(**fdict), "{c.SCRIPT_DIR}/kontact/.".format(**fdict), _out=sys.stdout)
Пример #7
0
 def build_image(self):
     print("Running docker build",
           ["-t", self.image_name,
            os.path.dirname(self.dockerfile_path)])
     build_command = docker.build(
         "-t",
         self.image_name,
         os.path.dirname(self.dockerfile_path),
         _out=process_output)  # type: sh.RunningCommand
     if build_command.exit_code == 0:
         self.image_built = True
Пример #8
0
def main(dataset):
    tmpname="kolab/kolabtestcontainer:tmppopulated"
    imagename="kolab/kolabtestcontainer:populated-"+dataset

    SCRIPT_DIR = os.path.dirname(os.path.realpath(sys.argv[0]))

    print("Building tmpcontainer...")
    docker.build("-t", tmpname, SCRIPT_DIR+"/kolabpopulated/.")
    print("Starting tmpcontainer...")
    container = docker.run("-d", "-h", settings.HOSTNAME, "-v", "/sys/fs/cgroup:/sys/fs/cgroup:ro", "-v", SCRIPT_DIR+"/kolabpopulated/"+dataset+"/:/data/", tmpname).rstrip()

    # Wait for imap to become available on imaps://localhost:993
    time.sleep(5)

    print("Running populate.sh...")
    docker("exec", container,  "/data/populate.sh", _out=process_output)

    print("Comitting results...")
    docker.commit(container, imagename)
    docker.stop(container)
    docker.rm(container)
Пример #9
0
def main():
    containername = "kube"
    dataset = "default"

    fdict = {"c": config, "dataset": dataset, "containername": containername}

    print("Building kube...")
    docker.build(settings.dockerCacheString(),
                 "-t",
                 containername,
                 "{c.SCRIPT_DIR}/kube/.".format(**fdict),
                 _out=sys.stdout)

    print("Building {dataset}'s kube...".format(**fdict))
    docker.build(settings.dockerCacheString(),
                 "-t",
                 "{containername}:{dataset}".format(**fdict),
                 "-f",
                 "{c.SCRIPT_DIR}/kube/Dockerfile-{dataset}".format(**fdict),
                 "{c.SCRIPT_DIR}/kube/.".format(**fdict),
                 _out=sys.stdout)
Пример #10
0
def main():
    containername = "kubestandalone"
    dataset = "default"

    fdict = {"c": config, "dataset": dataset, "containername": containername}

    print("Building kubestandalone...")
    docker.build("-t",
                 containername,
                 "{c.SCRIPT_DIR}/kubestandalone/.".format(**fdict),
                 _out=sys.stdout)

    print("Building kube...".format(**fdict))
    docker.build(
        "-t",
        "{containername}:kdesrcbuild".format(**fdict),
        "-f",
        "{c.SCRIPT_DIR}/kubestandalone/Dockerfile-kdesrcbuild".format(**fdict),
        "{c.SCRIPT_DIR}/kubestandalone/.".format(**fdict),
        _out=sys.stdout)

    print("Building {dataset}'s kubestandalone...".format(**fdict))
    docker.build(
        "-t",
        "{containername}:{dataset}".format(**fdict),
        "-f",
        "{c.SCRIPT_DIR}/kubestandalone/Dockerfile-{dataset}".format(**fdict),
        "{c.SCRIPT_DIR}/kubestandalone/.".format(**fdict),
        _out=sys.stdout)
Пример #11
0
def main():
    containername="kubestandalone"
    dataset="default"

    fdict = {"c": config,
            "dataset": dataset,
            "containername": containername}

    print("Building kubestandalone...")
    docker.build("-t", containername, "{c.SCRIPT_DIR}/kubestandalone/.".format(**fdict), _out=sys.stdout)

    print("Building kube...".format(**fdict))
    docker.build("-t", "{containername}:kdesrcbuild".format(**fdict), "-f", "{c.SCRIPT_DIR}/kubestandalone/Dockerfile-kdesrcbuild".format(**fdict), "{c.SCRIPT_DIR}/kubestandalone/.".format(**fdict), _out=sys.stdout)

    print("Building {dataset}'s kubestandalone...".format(**fdict))
    docker.build("-t", "{containername}:{dataset}".format(**fdict), "-f", "{c.SCRIPT_DIR}/kubestandalone/Dockerfile-{dataset}".format(**fdict), "{c.SCRIPT_DIR}/kubestandalone/.".format(**fdict), _out=sys.stdout)
Пример #12
0
def main(dataset):
    tmpname = "kolab/kolabtestcontainer:tmppopulated"
    imagename = "kolab/kolabtestcontainer:populated-" + dataset
    basedir = "{c.SCRIPT_DIR}/kolabpopulated".format(c=config)

    print("Building tmpcontainer...")
    docker.build("-t", tmpname, "{basedir}/.".format(basedir=basedir))

    print("Starting tmpcontainer...")
    container = docker.run(
        "-d", "-h", settings.HOSTNAME, "-v",
        "/sys/fs/cgroup:/sys/fs/cgroup:ro",
        "-v", "{basedir}/{dataset}/:/data/".format(basedir=basedir,
                                                   dataset=dataset), '-v',
        "{c.SCRIPT_DIR}/kolab/populate/:/populate".format(c=config),
        tmpname).rstrip()
    try:
        # Wait for imap to become available on imaps://localhost:993
        time.sleep(5)

        print "Populate OU..."
        docker("exec",
               container,
               "python2",
               "/populate/populate_ou.py",
               _out=sys.stdout)

        print "Populate users..."
        docker("exec",
               container,
               "python2",
               "/populate/populate_users.py",
               _out=sys.stdout)

        print "Populate resources..."
        docker("exec",
               container,
               "python2",
               "/populate/populate_resources.py",
               _out=sys.stdout)

        print("Running populate.sh...")
        docker("exec", container, "/data/populate.sh", _out=sys.stdout)

        # Give kolabd some time to create all mailboxes
        time.sleep(5)

        docker("exec",
               container,
               "patch",
               "-R",
               "/etc/kolab/kolab.conf",
               "/data/kolab.conf.diff",
               _out=sys.stdout)
        docker("exec",
               container,
               "patch",
               "-R",
               "/etc/roundcubemail/calendar.inc.php",
               "/data/calendar.inc.php.diff",
               _out=sys.stdout)
        docker("exec",
               container,
               "patch",
               "-R",
               "/etc/roundcubemail/config.inc.php",
               "/data/config.inc.php.diff",
               _out=sys.stdout)
        docker("exec",
               container,
               "patch",
               "-R",
               "/etc/roundcubemail/kolab_addressbook.inc.php",
               "/data/kolab_addressbook.inc.php.diff",
               _out=sys.stdout)
        docker("exec",
               container,
               "patch",
               "-R",
               "/etc/roundcubemail/kolab_auth.inc.php",
               "/data/kolab_auth.inc.php.diff",
               _out=sys.stdout)
        docker("exec",
               container,
               "patch",
               "-R",
               "/etc/roundcubemail/password.inc.php",
               "/data/password.inc.php.diff",
               _out=sys.stdout)

        print("Comitting results to: {}".format(imagename))
        docker.commit(container, imagename)
    except:
        print("Unexpected error:", sys.exc_info()[0])
        traceback.print_exc(file=sys.stdout)
        print("Failed to setup container")

    docker.stop(container)
    docker.rm(container)
Пример #13
0
    def fuzz(self):
        print("Building your dockerimage")
        print("Running docker build",
              ["-t", self.base_image, self.build_folder])
        build_command = docker_bin.build(
            "-t", self.base_image,
            self.build_folder)  # type: sh.RunningCommand
        # TODO: Catch "pull access denied for pacmanfuzzer, repository does not exist or may require 'docker login'"
        #       >>  User needs to init first!"

        import docker
        docker_client = docker.from_env()
        dict = {
            "asan": True,
            "exec_timeout": "1000+",
            "fuzz_duration": self.fuzz_duration,
            "fuzzing_cores_per_binary": self.fuzzing_cores_per_binary,
            "package_folder": "/data/" + self.package_folder,
            "package": self.name,
            "qemu": False,
            "seeds": "/fuzz/seeds",
            "volume": "/results"
        }
        with open(
                os.path.join(self.configuration_dir, "run_configurations/",
                             self.name + ".json"), "w") as fp:
            json.dump(dict, fp)
        print("Doing the magic now!")
        volumes_dict = {
            os.path.abspath(os.path.join(self.configuration_dir, "fuzz_data")):
            {
                "bind": "/results",
                "mode": "rw"
            },
            os.path.abspath(os.path.join(self.configuration_dir, "build_data")):
            {
                "bind": "/build",
                "mode": "rw"
            },
            os.path.abspath(
                os.path.join(self.configuration_dir, "run_configurations")): {
                "bind": "/run_configurations",
                "mode": "ro"
            },
            os.path.abspath(self.seeds): {
                "bind": "/fuzz/seeds",
                "mode": "ro"
            },
        }
        eval_args = [
            "/inputinferer/configfinder/eval_package.py",
            "/run_configurations/" + self.name + ".json"
        ]
        container = docker_client.containers.run(
            image=self.base_image,
            remove=True,
            cap_add=["SYS_PTRACE"],
            security_opt=["seccomp=unconfined"],
            entrypoint="python",
            volumes=volumes_dict,
            command=eval_args,
            detach=True,
            stream=True,
            stdout=True,
            stderr=True,
            name=self.name + "_fuzz_" + str(uuid.uuid4())[:4])
        container_output = ""
        for line in container.logs(stream=True):
            print(line.decode("utf-8").strip())
            container_output += line.decode("utf-8")
        status = container.wait()
        if status["StatusCode"] != 0:
            print(
                "Error while running docker command. Docker Output:\n {0}. Return value {1}"
                .format(container_output, status["StatusCode"]))
            return False
        return True
Пример #14
0
def main(buildenvironment):
    docker.build(settings.dockerCacheString(), "-t", "{buildenvironment}dev".format(buildenvironment=buildenvironment), "{}/buildenvironments/{buildenvironment}/".format(BASEPATH, buildenvironment=buildenvironment), _out=sys.stdout)
Пример #15
0
def main():
    containername="kolabclient/presice"

    print("Building kolabclient for Ubuntu 12.04...")
    docker.build(settings.dockerCacheString(), "-t", containername, "{c.SCRIPT_DIR}/ubuntu/precise/.".format(c=config), _out=sys.stdout)
Пример #16
0
def build(*args):
    """ Build Image in the Current Working Directory """
    with sudo:
        ensure_service()
        docker.build('.', *args, _fg=True)
Пример #17
0
def main():
    docker.build("-t", "fedora-kdedev", settings.SCRIPT_DIR+"/kdesrcbuild/", _out=sys.stdout)