Esempio n. 1
0
    def update_dist_git(self, version, release):
        with Chdir(self.path):
            # Add new Dockerfile
            subprocess.check_call(["git", "add", "Dockerfile"])

            # Add the scripts directory if it exists
            if os.path.exists(os.path.join(self.path, "scripts")):
                subprocess.check_call(["git", "add", "scripts"])

        commit_msg = "Sync"

        if self.source_repo_name:
            commit_msg += " with %s" % self.source_repo_name

        if self.source_repo_commit:
            commit_msg += ", commit %s" % self.source_repo_commit

        commit_msg += ", release %s-%s" % (version, release)

        with Chdir(self.path):
            # Commit the change
            self.log.info("Commiting with message: '%s'" % commit_msg)
            subprocess.check_output(["git", "commit", "-m", commit_msg])

            untracked = subprocess.check_output(["git", "ls-files", "--others", "--exclude-standard"])

            if untracked:
                self.log.warn(
                    "There are following untracked files: %s. Please review your commit."
                    % ", ".join(untracked.splitlines())
                )

            diffs = subprocess.check_output(["git", "diff-files", "--name-only"])

            if diffs:
                self.log.warn(
                    "There are uncommited changes in following files: '%s'. Please review your commit."
                    % ", ".join(diffs.splitlines())
                )

        with Chdir(self.path):
            subprocess.call(["git", "status"])
            subprocess.call(["read", "-p", "\nPress any key to see the last commit...", "-n1", "-s"])
            subprocess.call(["git", "show"])

        if Tools.decision("Do you want to review your changes?"):
            with Chdir(self.path):
                subprocess.call(["bash"])

        if Tools.decision("Do you want to push the commit?"):
            print("")
            with Chdir(self.path):
                self.log.info("Pushing change to the upstream repository...")
                subprocess.check_output(["git", "push", "-q"])
                self.log.info("Change pushed.")

                if Tools.decision("Do you want to execute a build on OSBS?"):
                    subprocess.call(["rhpkg", "container-build"])
Esempio n. 2
0
    def __init__(self, log, source, path):
        self.log = log
        self.path = path
        self.dockerfile = os.path.join(self.path, "Dockerfile")
        self.tools = Tools()

        self.name, self.branch, self.commit = self.tools.repo_info(path)
        self.source_repo_name, self.source_repo_branch, self.source_repo_commit = self.tools.repo_info(
            source)
Esempio n. 3
0
    def commit(self):
        commit_msg = "Sync"

        if self.source_repo_name:
            commit_msg += " with %s" % self.source_repo_name

        if self.source_repo_commit:
            commit_msg += ", commit %s" % self.source_repo_commit

        # Commit the change
        self.log.info("Commiting with message: '%s'" % commit_msg)
        subprocess.check_output(["git", "commit", "-q", "-m", commit_msg])

        untracked = subprocess.check_output(["git", "ls-files", "--others", "--exclude-standard"])

        if untracked:
            self.log.warn("There are following untracked files: %s. Please review your commit." % ", ".join(untracked.splitlines()))

        diffs = subprocess.check_output(["git", "diff-files", "--name-only"])

        if diffs:
            self.log.warn("There are uncommited changes in following files: '%s'. Please review your commit." % ", ".join(diffs.splitlines()))

        if not self.noninteractive:
            subprocess.call(["git", "status"])
            subprocess.call(["git", "show"])

        if not (self.noninteractive or Tools.decision("Are you ok with the changes?")):
            subprocess.call(["bash"])
Esempio n. 4
0
 def build(self):
     if self.args.dist_git_assume_yes or Tools.decision("Do you want to execute a build on OSBS?"):
         self.log.info("Executing container build on OSBS...")
         cmd = ["rhpkg", "container-build"]
         if self.args.dist_git_scratch:
             cmd.append('--scratch')
         subprocess.call(cmd)
Esempio n. 5
0
File: git.py Progetto: luiz158/dogen
    def __init__(self, log, source, path):
        self.log = log
        self.path = path
        self.dockerfile = os.path.join(self.path, "Dockerfile")
        self.tools = Tools()

        self.name, self.branch, self.commit = self.tools.repo_info(path)
        self.source_repo_name, self.source_repo_branch, self.source_repo_commit = self.tools.repo_info(source)
Esempio n. 6
0
    def prepare(self):
        self.log.debug("Resetting git repository...")

        # Reset all changes first - nothing should be done by hand
        with Chdir(self.path):
            subprocess.check_output(["git", "reset", "--hard"])

        # Just check if the target branch is correct
        if not Tools.decision("You are currently working on the '%s' branch, is this what you want?" % self.branch):
            print("")
            self.switch_branch()

        self.old_version, self.old_release = self.read_version_and_release()
Esempio n. 7
0
    def _handle_custom_template(self):
        """
        Fetches custom template (if provided) and saves as temporary
        file. This file is removed later in the process.
        """

        if not self.template:
            return

        self.log.info("Using custom provided template file: '%s'" % self.template)

        if Tools.is_url(self.template):
            self.template = self._fetch_file(self.template)

        if not os.path.exists(self.template):
            raise Error("Template file '%s' could not be found. Please make sure you specified correct path or check if the file was successfully fetched." % self.template)
Esempio n. 8
0
    def _handle_additional_scripts(self):
        self.log.info("Additional scripts provided, installing them...")
        output_scripts = os.path.join(self.output, "scripts")

        if not os.path.exists(output_scripts):
            os.makedirs(output_scripts)

        for f in self.additional_scripts:
            self.log.debug("Handling '%s' file..." % f)
            if Tools.is_url(f):
                self._fetch_file(f, os.path.join(output_scripts, os.path.basename(f)))
            else:
                if not (os.path.exists(f) and os.path.isfile(f)):
                    raise Error("File '%s' does not exist. Please make sure you specified correct path to a file when specifying additional scripts." % f)

                self.log.debug("Copying '%s' file to target scripts directory..." % f)
                shutil.copy(f, output_scripts)
Esempio n. 9
0
    def render_from_template(self):
        if not self.cfg.get('labels'):
            self.cfg['labels'] = []

        labels = {}

        for label in self.cfg.get('labels'):
            labels[label['name']] = label['value']

        # https://github.com/jboss-dockerfiles/dogen/issues/129
        # https://github.com/jboss-dockerfiles/dogen/issues/137
        for label in ['maintainer', 'description']:
            value = self.cfg.get(label)

            if value and not label in labels:
                self.cfg['labels'].append({'name': label, 'value': value})
                labels[label] = value

        # https://github.com/jboss-dockerfiles/dogen/issues/195
        if 'summary' not in labels:
            if 'description' in labels:
                self.cfg['labels'].append({
                    'name': 'summary',
                    'value': labels.get('description')
                })

        if self.template:
            template_file = self.template
        else:
            self.log.debug("Using dogen provided template file")
            template_file = os.path.join(self.pwd, "templates",
                                         "template.jinja")

        self.log.info("Rendering Dockerfile...")
        loader = FileSystemLoader(os.path.dirname(template_file))
        env = Environment(loader=loader, trim_blocks=True, lstrip_blocks=True)
        env.globals['helper'] = TemplateHelper()
        template = env.get_template(os.path.basename(template_file))

        with open(self.dockerfile, 'wb') as f:
            f.write(template.render(self.cfg).encode('utf-8'))
        self.log.debug("Done")

        if self.template and Tools.is_url(self.template):
            self.log.debug("Removing temporary template file...")
            os.remove(self.template)
Esempio n. 10
0
 def _download_source(self, artifact, filename, hint=None):
     if Tools.is_url(artifact):
         self.log.warn(
             "Trying to download the '%s' artifact from original location" %
             artifact)
         try:
             self._fetch_file(artifact, filename)
         except Exception as e:
             raise Error(
                 "Could not download artifact from orignal location, reason: %s"
                 % str(e))
     else:
         if hint:
             self.log.info(hint)
         self.log.info(
             "Please download the '%s' artifact manually and save it as '%s'"
             % (artifact, filename))
         raise Error("Artifact '%s' could not be fetched!" % artifact)
Esempio n. 11
0
    def _handle_custom_template(self):
        """
        Fetches custom template (if provided) and saves as temporary
        file. This file is removed later in the process.
        """

        if not self.template:
            return

        self.log.info("Using custom provided template file: '%s'" %
                      self.template)

        if Tools.is_url(self.template):
            self.template = self._fetch_file(self.template)

        if not os.path.exists(self.template):
            raise Error(
                "Template file '%s' could not be found. Please make sure you specified correct path or check if the file was successfully fetched."
                % self.template)
Esempio n. 12
0
    def render_from_template(self):
        if self.template:
            template_file = self.template
        else:
            self.log.debug("Using dogen provided template file")
            template_file = os.path.join(self.pwd, "templates", "template.jinja")

        self.log.info("Rendering Dockerfile...")
        loader = FileSystemLoader(os.path.dirname(template_file))
        env = Environment(loader=loader, trim_blocks=True, lstrip_blocks=True)
        env.globals['helper'] = TemplateHelper()
        template = env.get_template(os.path.basename(template_file))

        with open(self.dockerfile, 'wb') as f:
            f.write(template.render(self.cfg).encode('utf-8'))
        self.log.debug("Done")

        if self.template and Tools.is_url(self.template):
            self.log.debug("Removing temporary template file...")
            os.remove(self.template)
Esempio n. 13
0
    def render_from_template(self):
        if self.template:
            template_file = self.template
        else:
            self.log.debug("Using dogen provided template file")
            template_file = os.path.join(self.pwd, "templates",
                                         "template.jinja")

        self.log.info("Rendering Dockerfile...")
        loader = FileSystemLoader(os.path.dirname(template_file))
        env = Environment(loader=loader, trim_blocks=True, lstrip_blocks=True)
        env.globals['helper'] = TemplateHelper()
        template = env.get_template(os.path.basename(template_file))

        with open(self.dockerfile, 'w') as f:
            f.write(template.render(self.cfg).encode('utf-8'))
        self.log.debug("Done")

        if self.template and Tools.is_url(self.template):
            self.log.debug("Removing temporary template file...")
            os.remove(self.template)
Esempio n. 14
0
    def _handle_additional_scripts(self):
        self.log.info("Additional scripts provided, installing them...")
        output_scripts = os.path.join(self.output, "scripts")

        if not os.path.exists(output_scripts):
            os.makedirs(output_scripts)

        for f in self.additional_scripts:
            self.log.debug("Handling '%s' file..." % f)
            if Tools.is_url(f):
                self._fetch_file(
                    f, os.path.join(output_scripts, os.path.basename(f)))
            else:
                if not (os.path.exists(f) and os.path.isfile(f)):
                    raise Error(
                        "File '%s' does not exist. Please make sure you specified correct path to a file when specifying additional scripts."
                        % f)

                self.log.debug(
                    "Copying '%s' file to target scripts directory..." % f)
                shutil.copy(f, output_scripts)
 def test_local_file(self):
     self.assertFalse(Tools.is_url("a_file.tmp"))
Esempio n. 16
0
 def push(self):
     if self.noninteractive or Tools.decision("Do you want to push the commit?"):
         print("")
         self.log.info("Pushing change to the upstream repository...")
         subprocess.check_output(["git", "push", "-q"])
         self.log.info("Change pushed.")
Esempio n. 17
0
File: git.py Progetto: luiz158/dogen
class Git(object):
    """
    Git support for target directories
    """

    def __init__(self, log, source, path):
        self.log = log
        self.path = path
        self.dockerfile = os.path.join(self.path, "Dockerfile")
        self.tools = Tools()

        self.name, self.branch, self.commit = self.tools.repo_info(path)
        self.source_repo_name, self.source_repo_branch, self.source_repo_commit = self.tools.repo_info(source)

    def prepare(self):
        self.log.debug("Resetting git repository...")

        # Reset all changes first - nothing should be done by hand
        with Chdir(self.path): 
            subprocess.check_output(["git", "reset", "--hard"])

        # Just check if the target branch is correct
        if not self.tools.decision("You are currently working on the '%s' branch, is this what you want?" % self.branch):
            print("")
            self.switch_branch()


        self.old_version, self.old_release = self.read_version_and_release()

    def update(self):
        new_version, release = self.read_version_and_release()
        new_release = int(self.old_release) + 1

        self.log.info("New release will be: %s-%s." % (new_version, new_release))

        # Bump the release environment variable
        self.update_value("JBOSS_IMAGE_RELEASE", new_release)
        self.update_dist_git(new_version, new_release)

    def clean_scripts(self):
        """ Removes the scripts directory from staging and disk """

        with Chdir(self.path): 
            if os.path.exists("scripts"):
                self.log.info("Removing old scripts directory")
                subprocess.check_output(["git", "rm", "-rf", "scripts"])

    def read_dockerfile(self):
        with open(self.dockerfile, 'r') as f:
            return f.read()

    def read_value(self, dockerfile, exp):
        pattern = re.compile(exp)
        match = pattern.search(dockerfile)
        if match:
            return match.group(1)

        raise Exception("Could not find the '%s' pattern in %s" % (exp, dockerfile))

    def update_value(self, env, value):
        """
        This fnction updates the value of the selected environment variable
        or label that is set in the following pattern: env="[TO_REPLACE]".
        """

        # Read Dockerfile
        dockerfile = self.read_dockerfile()

        with open(self.dockerfile, 'w') as f:
            f.write(re.sub("(?<=%s=\")(.*)(?=\")" % env, str(value), dockerfile))

    def read_version_and_release(self):
        # If there is no Dockerfile, there are no old versions
        if not os.path.exists(self.dockerfile):
            return None, 0

        # Read *already existing* Dockerfile
        dockerfile = self.read_dockerfile()

        # Read envs from Dockerfile
        # Used to bump the release label and fill the commit message later
        try:
            version = self.read_value(dockerfile, 'JBOSS_IMAGE_VERSION="([\w\.]+)"')
        except:
            version = self.read_value(dockerfile, 'Version="([\w\.]+)"')

        try:
            release = self.read_value(dockerfile, 'JBOSS_IMAGE_RELEASE="(\d+)"')
        except:
            try:
                release = self.read_value(dockerfile, 'Release="(\d+)"')
            except:
                release = 0

        return version, release

    def switch_branch(self):

        with Chdir(self.path): 
            branches = subprocess.check_output(["git", "for-each-ref", "--format=%(refname)", "refs/heads"])

        branches = [b.strip().split("/")[-1] for b in branches.splitlines()] 
        
        self.log.info("Available branches:")

        for branch in branches:
            self.log.info(branch)

        target_branch = raw_input("\nTo which branch do you want to switch? ")

        if not target_branch in branches:
            print("")
            self.switch_branch()

        with Chdir(self.path): 
            # Checkout the correct branch
            self.log.info("Switching to '%s' branch" % target_branch)
            subprocess.check_output(["git", "checkout", "-q", "-f", target_branch])

    def update_lookaside_cache(self, files):
        with Chdir(self.path):
            self.log.info("Updating lookaside cache...")
            subprocess.check_output(["rhpkg", "new-sources"] + files)
            self.log.info("Update finished.")

    def update_dist_git(self, version, release):
        with Chdir(self.path):
            # Add new Dockerfile
            subprocess.check_call(["git", "add", "Dockerfile"])

            # Add the scripts directory if it exists
            if os.path.exists(os.path.join(self.path, "scripts")):
                subprocess.check_call(["git", "add", "scripts"])

        commit_msg = "Sync"

        if self.source_repo_name:
            commit_msg += " with %s" % self.source_repo_name
 
        if self.source_repo_commit:
            commit_msg += ", commit %s" % self.source_repo_commit
 
        commit_msg += ", release %s-%s" % (version, release) 
 
        with Chdir(self.path): 
            # Commit the change 
            self.log.info("Commiting with message: '%s'" % commit_msg)
            subprocess.check_output(["git", "commit", "-m", commit_msg])

        
            untracked = subprocess.check_output(["git", "ls-files", "--others", "--exclude-standard"])

            if untracked: 
                self.log.warn("There are following untracked files: %s. Please review your commit." % ", ".join(untracked.splitlines()))
 
            diffs = subprocess.check_output(["git", "diff-files", "--name-only"])
 
            if diffs: 
                self.log.warn("There are uncommited changes in following files: '%s'. Please review your commit." % ", ".join(diffs.splitlines()))
 
        if self.tools.decision("Do you want to review your changes?"): 
            with Chdir(self.path): 
                subprocess.call(["bash"]) 
 
        if self.tools.decision("Do you want to push the commit?"): 
            print("")
            with Chdir(self.path): 
                self.log.info("Pushing change to the upstream repository...")
                subprocess.check_output(["git", "push", "-q"])
                self.log.info("Change pushed.")
 
                if self.tools.decision("Do you want to execute a build on OSBS?"): 
                    subprocess.call(["rhpkg", "container-build"])
Esempio n. 18
0
 def test_local_file(self):
     self.assertFalse(Tools.is_url("a_file.tmp"))
Esempio n. 19
0
class Git(object):
    """
    Git support for target directories
    """
    def __init__(self, log, source, path):
        self.log = log
        self.path = path
        self.dockerfile = os.path.join(self.path, "Dockerfile")
        self.tools = Tools()

        self.name, self.branch, self.commit = self.tools.repo_info(path)
        self.source_repo_name, self.source_repo_branch, self.source_repo_commit = self.tools.repo_info(
            source)

    def prepare(self):
        self.log.debug("Resetting git repository...")

        # Reset all changes first - nothing should be done by hand
        with Chdir(self.path):
            subprocess.check_output(["git", "reset", "--hard"])

        # Just check if the target branch is correct
        if not self.tools.decision(
                "You are currently working on the '%s' branch, is this what you want?"
                % self.branch):
            print("")
            self.switch_branch()

        self.old_version, self.old_release = self.read_version_and_release()

    def update(self):
        new_version, release = self.read_version_and_release()
        new_release = int(self.old_release) + 1

        self.log.info("New release will be: %s-%s." %
                      (new_version, new_release))

        # Bump the release environment variable
        self.update_value("JBOSS_IMAGE_RELEASE", new_release)
        self.update_dist_git(new_version, new_release)

    def clean_scripts(self):
        """ Removes the scripts directory from staging and disk """

        with Chdir(self.path):
            if os.path.exists("scripts"):
                self.log.info("Removing old scripts directory")
                subprocess.check_output(["git", "rm", "-rf", "scripts"])

    def read_dockerfile(self):
        with open(self.dockerfile, 'r') as f:
            return f.read()

    def read_value(self, dockerfile, exp):
        pattern = re.compile(exp)
        match = pattern.search(dockerfile)
        if match:
            return match.group(1)

        raise Exception("Could not find the '%s' pattern in %s" %
                        (exp, dockerfile))

    def update_value(self, env, value):
        """
        This fnction updates the value of the selected environment variable
        or label that is set in the following pattern: env="[TO_REPLACE]".
        """

        # Read Dockerfile
        dockerfile = self.read_dockerfile()

        with open(self.dockerfile, 'w') as f:
            f.write(
                re.sub("(?<=%s=\")(.*)(?=\")" % env, str(value), dockerfile))

    def read_version_and_release(self):
        # If there is no Dockerfile, there are no old versions
        if not os.path.exists(self.dockerfile):
            return None, 0

        # Read *already existing* Dockerfile
        dockerfile = self.read_dockerfile()

        # Read envs from Dockerfile
        # Used to bump the release label and fill the commit message later
        try:
            version = self.read_value(dockerfile,
                                      'JBOSS_IMAGE_VERSION="([\w\.]+)"')
        except:
            version = self.read_value(dockerfile, 'Version="([\w\.]+)"')

        try:
            release = self.read_value(dockerfile,
                                      'JBOSS_IMAGE_RELEASE="(\d+)"')
        except:
            try:
                release = self.read_value(dockerfile, 'Release="(\d+)"')
            except:
                release = 0

        return version, release

    def switch_branch(self):

        with Chdir(self.path):
            branches = subprocess.check_output(
                ["git", "for-each-ref", "--format=%(refname)", "refs/heads"])

        branches = [b.strip().split("/")[-1] for b in branches.splitlines()]

        self.log.info("Available branches:")

        for branch in branches:
            self.log.info(branch)

        target_branch = raw_input("\nTo which branch do you want to switch? ")

        if not target_branch in branches:
            print("")
            self.switch_branch()

        with Chdir(self.path):
            # Checkout the correct branch
            self.log.info("Switching to '%s' branch" % target_branch)
            subprocess.check_output(
                ["git", "checkout", "-q", "-f", target_branch])

    def update_lookaside_cache(self, files):
        with Chdir(self.path):
            self.log.info("Updating lookaside cache...")
            subprocess.check_output(["rhpkg", "new-sources"] + files)
            self.log.info("Update finished.")

    def update_dist_git(self, version, release):
        with Chdir(self.path):
            # Add new Dockerfile
            subprocess.check_call(["git", "add", "Dockerfile"])

            # Add the scripts directory if it exists
            if os.path.exists(os.path.join(self.path, "scripts")):
                subprocess.check_call(["git", "add", "scripts"])

        commit_msg = "Sync"

        if self.source_repo_name:
            commit_msg += " with %s" % self.source_repo_name

        if self.source_repo_commit:
            commit_msg += ", commit %s" % self.source_repo_commit

        commit_msg += ", release %s-%s" % (version, release)

        with Chdir(self.path):
            # Commit the change
            self.log.info("Commiting with message: '%s'" % commit_msg)
            subprocess.check_output(["git", "commit", "-m", commit_msg])

            untracked = subprocess.check_output(
                ["git", "ls-files", "--others", "--exclude-standard"])

            if untracked:
                self.log.warn(
                    "There are following untracked files: %s. Please review your commit."
                    % ", ".join(untracked.splitlines()))

            diffs = subprocess.check_output(
                ["git", "diff-files", "--name-only"])

            if diffs:
                self.log.warn(
                    "There are uncommited changes in following files: '%s'. Please review your commit."
                    % ", ".join(diffs.splitlines()))

        if self.tools.decision("Do you want to review your changes?"):
            with Chdir(self.path):
                subprocess.call(["bash"])

        if self.tools.decision("Do you want to push the commit?"):
            print("")
            with Chdir(self.path):
                self.log.info("Pushing change to the upstream repository...")
                subprocess.check_output(["git", "push", "-q"])
                self.log.info("Change pushed.")

                if self.tools.decision(
                        "Do you want to execute a build on OSBS?"):
                    subprocess.call(["rhpkg", "container-build"])
Esempio n. 20
0
 def test_remote_https_file(self):
     self.assertTrue(Tools.is_url("https://host/file.tmp"))
 def test_remote_https_file(self):
     self.assertTrue(Tools.is_url("https://host/file.tmp"))