Example #1
0
 def _finalize_project_build(self, project):
     # build the package
     pkg = Package(project.package_name, project.version,
                   project.install_path, self._spec.settings.output_dir,
                   self._spec.settings.force_overwrite,
                   project.system_dependencies)
     pkg.build()
Example #2
0
    def build(self):
        """ this is where all the magic happens """

        try:
            spec = self._spec
            for project in self._spec.projects:
                LOG.info("Beginning to build '%s'", project.name)
                os.makedirs(project.install_path)

                LOG.info("Fetching source code for '%s'", project.name)
                repo = OpenstackGitRepo(project.giturl, project.gitref)
                repo.clone(project.install_path)
                review = GerritReview(repo.change_id, project.git_path)

                LOG.info("Creating the virtualenv for '%s'", project.name)
                execute(project.venv_command, project.install_path)

                LOG.info("Installing '%s' pip dependencies to the virtualenv",
                         project.name)
                execute(project.install_command %
                        review.build_pip_dependencies(string=True),
                        project.install_path)

                LOG.info("Installing '%s' to the virtualenv", project.name)
                execute(".venv/bin/python setup.py install",
                        project.install_path)

                if not spec.settings.all_in_one:
                    pkg = Package(project.package_name, project.version,
                                  project.install_path, True)
                    pkg.build()

        except Exception as e:
            LOG.exception("Oops. Something went wrong. Error was:\n%s", e)
            sys.exit(-1)
Example #3
0
 def _finalize_project_build(self, project):
     # build the package
     pkg = Package(project.package_name, project.version,
                   project.install_path, self._spec.settings.output_dir,
                   self._spec.settings.force_overwrite,
                   project.system_dependencies)
     pkg.build()
Example #4
0
    def _build(self):
        spec = self._spec

        self._tempdir = tempfile.mkdtemp(prefix='giftwrap')
        src_path = os.path.join(self._tempdir, 'src')
        build_path = os.path.join(self._tempdir, 'build')
        os.makedirs(build_path)
        LOG.debug("Temporary working directory: %s", self._tempdir)

        for project in spec.projects:
            LOG.info("Beginning to build '%s'", project.name)

            install_path = os.path.join(build_path,
                                        relative_pathify(project.install_path))
            LOG.debug("Installing '%s' to '%s'", project.name, install_path)
            os.makedirs(install_path)

            # clone the project's source to a temporary directory
            project_src_path = os.path.join(src_path, project.name)
            os.makedirs(project_src_path)

            LOG.info("Fetching source code for '%s'", project.name)
            repo = OpenstackGitRepo(project.giturl, project.gitref)
            repo.clone(project_src_path)

            # tell package users where this came from
            gitinfo_file = os.path.join(install_path, 'gitinfo')
            with open(gitinfo_file, 'w') as fh:
                fh.write("%s %s" % (project.giturl, repo.head.hexsha))

            # start building the virtualenv for the project
            LOG.info("Creating the virtualenv for '%s'", project.name)
            execute(project.venv_command, install_path)

            # install into the virtualenv
            LOG.info("Installing '%s' to the virtualenv", project.name)
            venv_python_path = os.path.join(install_path, 'bin/python')
            venv_pip_path = os.path.join(install_path, 'bin/pip')

            deps = " ".join(project.pip_dependencies)
            execute("%s install %s" % (venv_pip_path, deps))

            if spec.settings.gerrit_dependencies:
                self._install_gerrit_dependencies(repo, project, install_path)

            execute("%s setup.py install" % venv_python_path, project_src_path)
            execute("%s install pbr" % venv_pip_path)

            # now build the package
            pkg = Package(project.package_name, project.version, build_path,
                          relative_pathify(project.install_path),
                          spec.settings.force_overwrite,
                          project.system_dependencies)
            pkg.build()
Example #5
0
    def _build(self):
        spec = self._spec

        tempdir = tempfile.mkdtemp(prefix='giftwrap')
        src_dir = os.path.join(tempdir, 'src')
        LOG.debug("Temporary working directory: %s", tempdir)

        for project in spec.projects:
            LOG.info("Beginning to build '%s'", project.name)

            # if anything is in our way, see if we can get rid of it
            if os.path.exists(project.install_path):
                if spec.settings.force_overwrite:
                    LOG.info("force_overwrite is set, so removing "
                             "existing path '%s'" % project.install_path)
                    shutil.rmtree(project.install_path)
                else:
                    raise Exception("Install path '%s' already exists" %
                                    project.install_path)
            os.makedirs(project.install_path)

            # clone the project's source to a temporary directory
            project_src_path = os.path.join(src_dir, project.name)
            os.makedirs(project_src_path)

            LOG.info("Fetching source code for '%s'", project.name)
            repo = OpenstackGitRepo(project.giturl, project.gitref)
            repo.clone(project_src_path)

            # start building the virtualenv for the project
            LOG.info("Creating the virtualenv for '%s'", project.name)
            execute(project.venv_command, project.install_path)

            # install into the virtualenv
            LOG.info("Installing '%s' to the virtualenv", project.name)
            venv_python_path = os.path.join(project.install_path, 'bin/python')
            venv_pip_path = os.path.join(project.install_path, 'bin/pip')

            deps = " ".join(project.pip_dependencies)
            execute("%s install %s" % (venv_pip_path, deps))

            if spec.settings.gerrit_dependencies:
                self._install_gerrit_dependencies(repo, project)

            execute("%s setup.py install" % venv_python_path, project_src_path)
            execute("%s install pbr" % venv_pip_path)

            # now build the package
            pkg = Package(project.package_name, project.version,
                          project.install_path, spec.settings.force_overwrite,
                          project.system_dependencies)
            pkg.build()
    def _build(self):
        spec = self._spec

        self._tempdir = tempfile.mkdtemp(prefix='giftwrap')
        src_path = os.path.join(self._tempdir, 'src')
        LOG.debug("Temporary working directory: %s", self._tempdir)

        for project in spec.projects:
            LOG.info("Beginning to build '%s'", project.name)

            install_path = project.install_path
            LOG.debug("Installing '%s' to '%s'", project.name, install_path)

            # if anything is in our way, see if we can get rid of it
            if os.path.exists(install_path):
                if spec.settings.force_overwrite:
                    LOG.info("force_overwrite is set, so removing "
                             "existing path '%s'" % install_path)
                    shutil.rmtree(install_path)
                else:
                    raise Exception("Install path '%s' already exists" %
                                    install_path)
            os.makedirs(install_path)

            # clone the project's source to a temporary directory
            project_src_path = os.path.join(src_path, project.name)
            os.makedirs(project_src_path)

            LOG.info("Fetching source code for '%s'", project.name)
            repo = OpenstackGitRepo(project.giturl,
                                    project.name,
                                    project.gitref,
                                    depth=project.gitdepth)
            repo.clone(project_src_path)

            # tell package users where this came from
            gitinfo_file = os.path.join(install_path, 'gitinfo')
            with open(gitinfo_file, 'w') as fh:
                fh.write("%s %s" % (project.giturl, repo.head.hexsha))

            # start building the virtualenv for the project
            LOG.info("Creating the virtualenv for '%s'", project.name)
            execute(project.venv_command, install_path)

            # install into the virtualenv
            LOG.info("Installing '%s' to the virtualenv", project.name)
            venv_python_path = os.path.join(install_path, 'bin/python')
            venv_pip_path = os.path.join(install_path, 'bin/pip')

            deps = " ".join(project.pip_dependencies)
            execute("%s install %s" % (venv_pip_path, deps))

            if spec.settings.include_config:
                src_config = os.path.join(project_src_path, 'etc')
                dest_config = os.path.join(install_path, 'etc')
                if not os.path.exists(src_config):
                    LOG.warning(
                        "Project configuration does not seem to exist "
                        "in source repo '%s'. Skipping.", project.name)
                else:
                    LOG.debug("Copying config from '%s' to '%s'", src_config,
                              dest_config)
                    distutils.dir_util.copy_tree(src_config, dest_config)

            if spec.settings.gerrit_dependencies:
                self._install_gerrit_dependencies(repo, project, install_path)

            execute("%s setup.py install" % venv_python_path, project_src_path)
            execute("%s install pbr" % venv_pip_path)

            # now build the package
            pkg = Package(project.package_name, project.version, install_path,
                          spec.settings.output_dir,
                          spec.settings.force_overwrite,
                          project.system_dependencies)
            pkg.build()
Example #7
0
    def _build(self):
        spec = self._spec

        self._tempdir = tempfile.mkdtemp(prefix='giftwrap')
        src_path = os.path.join(self._tempdir, 'src')
        LOG.debug("Temporary working directory: %s", self._tempdir)

        for project in spec.projects:
            LOG.info("Beginning to build '%s'", project.name)

            install_path = project.install_path
            LOG.debug("Installing '%s' to '%s'", project.name, install_path)

            # if anything is in our way, see if we can get rid of it
            if os.path.exists(install_path):
                if spec.settings.force_overwrite:
                    LOG.info("force_overwrite is set, so removing "
                             "existing path '%s'" % install_path)
                    shutil.rmtree(install_path)
                else:
                    raise Exception("Install path '%s' already exists" %
                                    install_path)
            os.makedirs(install_path)

            # clone the project's source to a temporary directory
            project_src_path = os.path.join(src_path, project.name)
            os.makedirs(project_src_path)

            LOG.info("Fetching source code for '%s'", project.name)
            repo = OpenstackGitRepo(project.giturl, project.name,
                                    project.gitref,
                                    depth=project.gitdepth)
            repo.clone(project_src_path)

            # tell package users where this came from
            gitinfo_file = os.path.join(install_path, 'gitinfo')
            with open(gitinfo_file, 'w') as fh:
                fh.write("%s %s" % (project.giturl, repo.head.hexsha))

            # start building the virtualenv for the project
            LOG.info("Creating the virtualenv for '%s'", project.name)
            execute(project.venv_command, install_path)

            # install into the virtualenv
            LOG.info("Installing '%s' to the virtualenv", project.name)
            venv_pip_path = os.path.join(install_path, 'bin/pip')

            deps = " ".join(project.pip_dependencies)
            execute("%s install %s" % (venv_pip_path, deps))

            if spec.settings.include_config:
                src_config = os.path.join(project_src_path, 'etc')
                dest_config = os.path.join(install_path, 'etc')
                if not os.path.exists(src_config):
                    LOG.warning("Project configuration does not seem to exist "
                                "in source repo '%s'. Skipping.", project.name)
                else:
                    LOG.debug("Copying config from '%s' to '%s'", src_config,
                              dest_config)
                    distutils.dir_util.copy_tree(src_config, dest_config)

            if spec.settings.gerrit_dependencies:
                self._install_gerrit_dependencies(repo, project, install_path)

            execute("%s install %s" % (venv_pip_path, project_src_path))

            # now build the package
            pkg = Package(project.package_name, project.version,
                          install_path, spec.settings.output_dir,
                          spec.settings.force_overwrite,
                          project.system_dependencies)
            pkg.build()