Esempio n. 1
0
def add_backup(flags, bak_dir, name="unknown"):
    """
    Adds a backup of the git repository.
    - bak_dir   -- The destination directory.
    - name      -- The name of the backup, replaces '_' with '-'.
    Returns the name of the created backup file.
    """
    try:
        check_git_rep()

        # Make sure there are no '_' in the name.
        name.replace('_', '-')

        # Set the path to the new backup file.
        tar_name = "{0}_{1}{2}".format(name,
                                       strftime(_BAK_FILE_DATE_FORMAT),
                                       _BAK_FILE_EXT)
        tar_path = path.join(bak_dir, tar_name)

        # Make a safety backup of the current git repository.
        log(flags, "Creating backup file \'" + tar_path + "\'")
        if not flags[Flag.SAFEMODE]:
            mkdirs(flags, bak_dir)
            exec_cmd(["tar", "-czf", tar_path, "."])

        return tar_name
    except Error as err:
        log(flags, "Could not add backup in \'" + bak_dir + "\'")
        raise OpError(err)
Esempio n. 2
0
def clean_repository(flags):
    """ Cleans untracked files and files matched by a .gitignore file. """
    try:
        if not flags[Flag.SAFEMODE]:
            exec_cmd(["git", "clean", "-fxd"])
            exec_cmd(["git", "clean", "-fX"])
    except CommandError:
        raise GitError("Could not clean ignored files", "clean")
Esempio n. 3
0
def check_git_rep():
    """
    Checks if the current directory is a git repository.
    Errors will be raised as GitError (if not a rep).
    """
    try:
        exec_cmd(["git", "status"])
    except CommandError:
        raise GitError(getcwd() + " is not a git repository", "status")
Esempio n. 4
0
def delete_tag(flags, tag):
    """
    Deletes the given tag.
    Errors will be raised as GitError.
    """
    check_git_rep()
    try:
        if not flags[Flag.SAFEMODE]:
            exec_cmd(["git", "tag", "-d", tag])
    except CommandError:
        raise GitError("The tag '" + tag + "' could not be deleted", "tag")
Esempio n. 5
0
def tag_head(flags, branch, tag):
    """
    Tags the HEAD of the given branch.
    Errors will be raised as GitError.
    """
    switch_branch(branch)
    try:
        if not flags[Flag.SAFEMODE]:
            exec_cmd(["git", "tag", tag])
    except CommandError:
        raise GitError("The tag '" + tag + "' could not be created " + "and may already exist", "tag")
Esempio n. 6
0
def reset_branch(flags, branch, commit):
    """
    Resets the given branch to the given commit, (accepts HEAD as commit).
    Errors will be raised as GitError.
    """
    switch_branch(branch)
    try:
        if not flags[Flag.SAFEMODE]:
            exec_cmd(["git", "reset", "--hard", commit])
    except CommandError:
        raise GitError("Could not reset branch '" + branch + "' " + "to commit '" + commit + "'")
Esempio n. 7
0
def commit_changes(flags, msg):
    """
    Commits all changes for the current branch.
    Errors will be raised as GitError.
    """
    check_git_rep()
    try:
        if not flags[Flag.SAFEMODE]:
            exec_cmd(["git", "add", "-A"])
            exec_cmd(["git", "commit", "-m", msg])
    except CommandError:
        raise GitError("Could not commit changes to current branch")
Esempio n. 8
0
def stash_changes(flags, name=None):
    """
    Stashes the changes in the working directory with a optional stash name.
    """
    check_git_rep()
    try:
        if not flags[Flag.SAFEMODE]:
            if name is not None:
                exec_cmd(["git", "stash", "save", "--include-untracked", name])
            else:
                exec_cmd(["git", "stash", "save", "--include-untracked"])
    except CommandError:
        raise GitError("Could not stash uncommitted changes", "stash")
Esempio n. 9
0
def switch_branch(branch):
    """
    Switches to git branch.
    Errors will be raised as GitError (if checkout isn't possible).
    """
    # Verify that the current dir is a git repository.
    check_git_rep()
    try:
        # Try to switch branch.
        exec_cmd(["git", "checkout", branch])
    except:
        raise GitError(
            "Please make sure that the branch '" + branch + "' exists and all changes " + "are commited", "checkout"
        )
Esempio n. 10
0
def init_repository(flags, dir_path):
    """
    Initiate a git repository.
        :param flags:
        :type flags: dict
        :param dir_path: path of the repository to initiate
        :type dir_path: str
        :raises: GitError
    """
    try:
        if not flags[Flag.SAFEMODE]:
            exec_cmd(["git", "init", dir_path])
    except CommandError:
        raise GitError("Could not initiate repository '{}' ".format(dir_path))
Esempio n. 11
0
def create_branch(flags, branch):
    """
    Create a branch from the current.
        :param flags:
        :type flags: dict
        :param branch: the branch to create
        :type branch: str
        :raises: GitError
    """
    try:
        if not flags[Flag.SAFEMODE]:
            exec_cmd(["git", "branch", branch])
    except CommandError:
        raise GitError("Could not create branch '{}' ".format(branch))
Esempio n. 12
0
def is_working_dir_clean():
    """
    Check if working directory is clean.
    Returns True if clean, False otherwise.
    """
    check_git_rep()
    try:
        return exec_cmd(["git", "status", "--porcelain"]) == ""
    except CommandError:
        raise GitError("Could not determine if working directory is clean.", "status")
Esempio n. 13
0
def get_branch():
    """
    Retrives the name of the current branch.
    Errors will be raised as GitError.
    """
    check_git_rep()
    try:
        return exec_cmd(["git", "rev-parse", "--abbrev-ref", "HEAD"])
    except CommandError:
        raise GitError("Could not find the name of the current branch", "rev-parse")
Esempio n. 14
0
def get_head_commit(branch):
    """
    Retrives the name HEAD commit on the given branch.
    Errors will be raised as GitError.
    """
    switch_branch(branch)
    try:
        return exec_cmd(["git", "rev-parse", "HEAD"])
    except CommandError:
        raise GitError("Could not find HEAD commit of branch '" + branch + "'", "rev-parse")
Esempio n. 15
0
def get_latest_tag(branch, tag_type):
    """
    Retrieves the latest tag (<tag_type>/<version>) for a branch.
    Errors will be raised as GitError (underlying errors or if no tags exists).
    """
    # Get the latest tag.
    switch_branch(branch)
    try:
        return exec_cmd(["git", "describe", "--abbrev=0", "--tags", "--match", tag_type + "/*"])
    except CommandError:
        raise GitError("The branch '" + branch + "' has no tags of type: " + tag_type + "/<version>")
Esempio n. 16
0
def get_head_tags(branch, tag_type):
    """
    Retrieves the tags for the HEAD commit on form (<tag_type>/<version>).
    Errors will be raised as GitError (underlying errors).
    Returns the list of HEAD tags for the given branch (can be empty).
    """
    switch_branch(branch)
    try:
        # Get all tags at HEAD.
        head_tags = exec_cmd(["git", "tag", "--points-at", "HEAD"])
        # Find the matching tags.
        matching_tags = findall(r"(?m)^" + tag_type + r"/.*$", head_tags)
        return matching_tags
    except CommandError:
        raise GitError("The tags pointing at '" + branch + "' HEAD, could not be retrieved", "tag")
Esempio n. 17
0
def apply_stash(flags, branch, name=None, drop=True):
    """
    Applies stashed changes on the given branch with a optional stash name.
    """
    switch_branch(branch)
    try:
        if not flags[Flag.SAFEMODE]:
            if name is not None:
                exec_cmd(["git", "stash", "apply", "stash^{/{}}".format(name)])
                if drop:
                    exec_cmd(["git", "stash", "drop", "stash^{/{}}".format(name)])
            else:
                exec_cmd(["git", "stash", "apply"])
                if drop:
                    exec_cmd(["git", "stash", "drop"])

    except CommandError:
        raise GitError("Could not apply stashed changes" + (" (" + name + ")" if name is not None else ""), "stash")
Esempio n. 18
0
def restore_backup(flags, bak_dir, num=None, name=None):
    """
    Tries to restore repository to a saved backup.
    Will prompt the user for the requested restore point if
    num is not set.
    - bak_dir   -- The backup storage directory.
    - num       -- The index number of the restore point (latest first).
    """
    try:
        check_git_rep()

        # If name is set just restore that file.
        if name is not None:
            bak_name = name

        else:
            # Find all previously backed up states.
            bak_files = get_files_with_extension(bak_dir, _BAK_FILE_EXT)
            if not bak_files:
                raise OpError("No backups exists in directory \'" +
                              bak_dir + "\'")

            # Sort the bak_files according to date.
            bak_files.sort(key=lambda bak_f: [int(v) for v in
                                              bak_f.split('_')[1].split('.')[
                                                  0].split('-')],
                           reverse=True)

            # Set the max tab depth.
            max_tab_depth = max([1 + (len(s.split('_')[0]) // _TAB_WIDTH)
                                 for s in bak_files])

            # Prompt user to select a state to restore.
            options = []
            for f_name in bak_files:
                option = "\t" + f_name.split('_')[0]
                option += "\t" * (max_tab_depth -
                                  len(f_name.split('_')[0]) // _TAB_WIDTH)
                option += datetime.strptime(
                    f_name.split('_')[1].split('.')[0],
                    _BAK_FILE_DATE_FORMAT).strftime(_BAK_DISPLAY_DATE_FORMAT)
                options.append(option)

            # Check if prompt can be skipped.
            if num is not None:
                if num >= len(options) or num < 0:
                    raise OpError("Invalid backup index \'" +
                                  num + "\' is outside [0-" +
                                  str(len(options) - 1) + "]")
            else:
                # Prompt.
                num = prompt_user_options("Select the backup to restore",
                                          options)
                if num is None:
                    raise OpError(msg="Restore aborted by user")

            # Set the chosen backup name.
            bak_name = bak_files[num]

        # Restore backup.
        try:
            log(flags, "Restoring backup \'" + bak_name + "\'")
            clean_dir(flags, getcwd())
            if not flags[Flag.SAFEMODE]:
                exec_cmd(["tar", "-xf", path.join(bak_dir, bak_name)])
        except Error as err:
            log(flags, "Restore failed, the backup can be found in \'" +
                bak_dir + "\'", TextType.ERR)
            raise OpError(err)
    except GitError as err:
        log(flags, "Restore could not be completed")
        raise OpError(err)