Example #1
0
    def test_builder(self):
        passphrase = 'passphrase'
        private_key = utils.generate_private_key(passphrase)

        with kozmic.builds.tasks.create_temp_dir() as build_dir:
            head_sha = utils.create_git_repo(
                os.path.join(build_dir, 'test-repo'))

            message_queue = Queue.Queue()
            builder = kozmic.builds.tasks.Builder(
                docker=docker._get_current_object(),
                deploy_key=(private_key, passphrase),
                docker_image='kozmic/ubuntu-base:12.04',
                script='#!/bin/bash\nbash ./kozmic.sh',
                working_dir=build_dir,
                clone_url='/kozmic/test-repo',
                commit_sha=head_sha,
                message_queue=message_queue)
            builder.start()
            container = message_queue.get(True, 60)
            assert isinstance(container, dict) and 'Id' in container
            message_queue.task_done()
            builder.join()

            log_path = os.path.join(build_dir, 'script.log')
            with open(log_path, 'r') as log:
                stdout = log.read().strip()

        assert not builder.exc_info
        assert builder.return_code == 0
        assert stdout == 'Hello!'
Example #2
0
    def test_builder(self):
        passphrase = 'passphrase'
        private_key = utils.generate_private_key(passphrase)

        with kozmic.builds.tasks.create_temp_dir() as build_dir:
            head_sha = utils.create_git_repo(os.path.join(build_dir, 'test-repo'))

            message_queue = Queue.Queue()
            builder = kozmic.builds.tasks.Builder(
                docker=docker._get_current_object(),
                deploy_key=(private_key, passphrase),
                docker_image='kozmic/ubuntu-base:12.04',
                script='#!/bin/bash\nbash ./kozmic.sh',
                working_dir=build_dir,
                clone_url='/kozmic/test-repo',
                commit_sha=head_sha,
                message_queue=message_queue)
            builder.start()
            container = message_queue.get(True, 60)
            assert isinstance(container, dict) and 'Id' in container
            message_queue.task_done()
            builder.join()

            log_path = os.path.join(build_dir, 'script.log')
            with open(log_path, 'r') as log:
                stdout = log.read().strip()

        assert not builder.exc_info
        assert builder.return_code == 0
        assert stdout == 'Hello!'
Example #3
0
    def test_builder_with_wrong_passphrase(self):
        """Tests that Builder does not hang being called
        with a wrong passphrase.
        """
        with kozmic.builds.tasks.create_temp_dir() as build_dir:
            head_sha = utils.create_git_repo(os.path.join(build_dir, 'test-repo'))

            message_queue = Queue.Queue()
            builder = kozmic.builds.tasks.Builder(
                docker=docker._get_current_object(),
                deploy_key=(utils.generate_private_key('passphrase'),
                            'wrong-passphrase'),
                docker_image='kozmic/ubuntu-base:12.04',
                script='#!/bin/bash\nbash ./kozmic.sh',
                working_dir=build_dir,
                clone_url='/kozmic/test-repo',
                commit_sha=head_sha,
                message_queue=mock.MagicMock())
            builder.run()
        assert builder.return_code == 1
Example #4
0
def _run(publisher, stall_timeout, clone_url, commit_sha,
         docker_image, script, deploy_key=None, remove_container=True):
    yielded = False
    stdout = ''
    try:
        with create_temp_dir() as working_dir:
            message_queue = Queue.Queue()
            builder = Builder(
                docker=docker._get_current_object(),  # `docker` is a local proxy
                deploy_key=deploy_key,
                clone_url=clone_url,
                commit_sha=commit_sha,
                docker_image=docker_image,
                script=script,
                working_dir=working_dir,
                message_queue=message_queue)

            log_path = os.path.join(working_dir, 'script.log')
            stop_reason = ''
            try:
                # Start Builder and wait until it will create the container
                builder.start()
                container = message_queue.get(block=True, timeout=60)

                # Now the container id is known and we can pass it to Tailer
                tailer = Tailer(
                    log_path=log_path,
                    publisher=publisher,
                    container=container,
                    kill_timeout=stall_timeout)
                tailer.start()
                try:
                    # Tell Builder to continue and wait for it to finish
                    message_queue.task_done()
                    builder.join()
                finally:
                    tailer.stop()
                    if tailer.has_killed_container:
                        stop_reason = '\nSorry, your script has stalled and been killed.\n'
            finally:
                if builder.container and remove_container:
                    docker.remove_container(builder.container)

                if os.path.exists(log_path):
                    with open(log_path, 'r') as log:
                        stdout = log.read()

                assert ((builder.return_code is not None) ^
                        (builder.exc_info is not None))
                if builder.exc_info:
                    # Re-raise exception happened in builder
                    # (it will be catched in the outer try-except)
                    raise builder.exc_info[1], None, builder.exc_info[2]
                else:
                    try:
                        yield (builder.return_code,
                               stdout + stop_reason,
                               builder.container)
                    except:
                        raise
                    finally:
                        yielded = True  # otherwise we get "generator didn't
                                        # stop after throw()" error if nested
                                        # code raised exception
    except:
        stdout += ('\nSorry, something went wrong. We are notified of '
                   'the issue and will fix it soon.')
        exc_type, exc_value, exc_traceback = sys.exc_info()
        lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
        stdout += ('\n'.join('!! ' + line for line in lines))
        if not yielded:
            yield 1, stdout, None
        raise