Release version 0.12.1

Avoid remote branch name churn

CHANGES.rst

@@ -1,6 +1,164 @@
 Changelog
 =========
 
+0.12.1 (2017-03-27)
+-------------------
+
+- Avoid remote branch name churn. [Chris Adams]
+
+  This avoids the backup output having lots of "[new branch]" messages
+  because removing the old remote name removed all of the existing branch
+  references.
+
+
+- Fix detection of bare git directories. [Andrzej Maczuga]
+
+0.12.0 (2016-11-22)
+-------------------
+
+Fix
+~~~
+
+- Properly import version from github_backup package. [Jose Diaz-
+  Gonzalez]
+
+- Support alternate git status output. [Jose Diaz-Gonzalez]
+
+Other
+~~~~~
+
+- Pep8: E501 line too long (83 > 79 characters) [Jose Diaz-Gonzalez]
+
+- Pep8: E128 continuation line under-indented for visual indent. [Jose
+  Diaz-Gonzalez]
+
+- Support archivization using bare git clones. [Andrzej Maczuga]
+
+- Fix typo, 3x. [Terrell Russell]
+
+0.11.0 (2016-10-26)
+-------------------
+
+- Support --token file:///home/user/token.txt (fixes gh-51) [Björn
+  Dahlgren]
+
+- Fix some linting. [Albert Wang]
+
+- Fix byte/string conversion for python 3. [Albert Wang]
+
+- Support python 3. [Albert Wang]
+
+- Encode special characters in password. [Remi Rampin]
+
+- Don't pretend program name is "Github Backup" [Remi Rampin]
+
+- Don't install over insecure connection. [Remi Rampin]
+
+  The git:// protocol is unauthenticated and unencrypted, and no longer advertised by GitHub. Using HTTPS shouldn't impact performance.
+
+0.10.3 (2016-08-21)
+-------------------
+
+- Fixes #29. [Jonas Michel]
+
+  Reporting an error when the user's rate limit is exceeded causes
+  the script to terminate after resuming execution from a rate limit
+  sleep. Instead of generating an explicit error we just want to
+  inform the user that the script is going to sleep until their rate
+  limit count resets.
+
+
+- Fixes #29. [Jonas Michel]
+
+  The errors list was not being cleared out after resuming a backup
+  from a rate limit sleep. When the backup was resumed, the non-empty
+  errors list caused the backup to quit after the next `retrieve_data`
+  request.
+
+
+0.10.2 (2016-08-21)
+-------------------
+
+- Add a note regarding git version requirement. [Jose Diaz-Gonzalez]
+
+  Closes #37
+
+0.10.0 (2016-08-18)
+-------------------
+
+- Implement incremental updates. [Robert Bradshaw]
+
+  Guarded with an --incremental flag.
+
+  Stores the time of the last update and only downloads issue and
+  pull request data since this time.  All other data is relatively
+  small (likely fetched with a single request) and so is simply
+  re-populated from scratch as before.
+
+
+0.9.0 (2016-03-29)
+------------------
+
+- Fix cloning private repos with basic auth or token. [Kazuki Suda]
+
+0.8.0 (2016-02-14)
+------------------
+
+- Don't store issues which are actually pull requests. [Enrico Tröger]
+
+  This prevents storing pull requests twice since the Github API returns
+  pull requests also as issues. Those issues will be skipped but only if
+  retrieving pull requests is requested as well.
+  Closes #23.
+
+
+0.7.0 (2016-02-02)
+------------------
+
+- Softly fail if not able to read hooks. [Albert Wang]
+
+- Add note about 2-factor auth. [Albert Wang]
+
+- Make user repository search go through endpoint capable of reading
+  private repositories. [Albert Wang]
+
+- Prompt for password if only username given. [Alex Hall]
+
+0.6.0 (2015-11-10)
+------------------
+
+- Force proper remote url. [Jose Diaz-Gonzalez]
+
+- Improve error handling in case of HTTP errors. [Enrico Tröger]
+
+  In case of a HTTP status code 404, the returned 'r' was never assigned.
+  In case of URL errors which are not timeouts, we probably should bail
+  out.
+
+
+- Add --hooks to also include web hooks into the backup. [Enrico Tröger]
+
+- Create the user specified output directory if it does not exist.
+  [Enrico Tröger]
+
+  Fixes #17.
+
+
+- Add missing auth argument to _get_response() [Enrico Tröger]
+
+  When running unauthenticated and Github starts rate-limiting the client,
+  github-backup crashes because the used auth variable in _get_response()
+  was not available. This change should fix it.
+
+
+- Add repository URL to error message for non-existing repositories.
+  [Enrico Tröger]
+
+  This makes it easier for the user to identify which repository does not
+  exist or is not initialised, i.e. whether it is the main repository or
+  the wiki repository and which clone URL was used to check.
+
+
 0.5.0 (2015-10-10)
 ------------------
 

README.rst

@@ -4,6 +4,11 @@ github-backup
 
 backup a github user or organization
 
+Requirements
+============
+
+- GIT 1.9+
+
 Installation
 ============
 
@@ -13,25 +18,25 @@ Using PIP via PyPI::
 
 Using PIP via Github::
 
-    pip install git+git://github.com/josegonzalez/python-github-backup.git#egg=github-backup
+    pip install git+https://github.com/josegonzalez/python-github-backup.git#egg=github-backup
 
 Usage
 =====
 
 CLI Usage is as follows::
 
-    Github Backup [-h] [-u USERNAME] [-p PASSWORD] [-t TOKEN]
-                     [-o OUTPUT_DIRECTORY] [--starred] [--watched] [--all]
-                     [--issues] [--issue-comments] [--issue-events] [--pulls]
-                     [--pull-comments] [--pull-commits] [--repositories]
-                     [--wikis] [--skip-existing]
-                     [-L [LANGUAGES [LANGUAGES ...]]] [-N NAME_REGEX]
-                     [-H GITHUB_HOST] [-O] [-R REPOSITORY] [-P] [-F]
-                     [--prefer-ssh] [-v]
-                     USER
+    github-backup [-h] [-u USERNAME] [-p PASSWORD] [-t TOKEN]
+                  [-o OUTPUT_DIRECTORY] [-i] [--starred] [--watched]
+                  [--all] [--issues] [--issue-comments] [--issue-events]
+                  [--pulls] [--pull-comments] [--pull-commits] [--labels]
+                  [--hooks] [--milestones] [--repositories] [--bare]
+                  [--wikis] [--skip-existing]
+                  [-L [LANGUAGES [LANGUAGES ...]]] [-N NAME_REGEX]
+                  [-H GITHUB_HOST] [-O] [-R REPOSITORY] [-P] [-F]
+                  [--prefer-ssh] [-v]
+                  USER
 
-
-    Backup a github users account
+    Backup a github account
 
     positional arguments:
       USER                  github username
@@ -41,11 +46,13 @@ CLI Usage is as follows::
       -u USERNAME, --username USERNAME
                             username for basic auth
       -p PASSWORD, --password PASSWORD
-                            password for basic auth
+                            password for basic auth. If a username is given but
+                            not a password, the password will be prompted for.
       -t TOKEN, --token TOKEN
                             personal access or OAuth token
       -o OUTPUT_DIRECTORY, --output-directory OUTPUT_DIRECTORY
                             directory at which to backup the repositories
+      -i, --incremental     incremental backup
       --starred             include starred repositories in backup
       --watched             include watched repositories in backup
       --all                 include everything in backup
@@ -55,7 +62,12 @@ CLI Usage is as follows::
       --pulls               include pull requests in backup
       --pull-comments       include pull request review comments in backup
       --pull-commits        include pull request commits in backup
+      --labels              include labels in backup
+      --hooks               include hooks in backup (works only when
+                            authenticated)
+      --milestones          include milestones in backup
       --repositories        include repository clone in backup
+      --bare                clone bare repositories
       --wikis               include wiki clone in backup
       --skip-existing       skip project if a backup directory exists
       -L [LANGUAGES [LANGUAGES ...]], --languages [LANGUAGES [LANGUAGES ...]]
@@ -64,7 +76,7 @@ CLI Usage is as follows::
                             python regex to match names against
       -H GITHUB_HOST, --github-host GITHUB_HOST
                             GitHub Enterprise hostname
-      -O, --organization    whether or not this is a query for an organization
+      -O, --organization    whether or not this is an organization user
       -R REPOSITORY, --repository REPOSITORY
                             name of repository to limit backup to
       -P, --private         include private repositories
@@ -74,3 +86,8 @@ CLI Usage is as follows::
 
 
 The package can be used to backup an *entire* organization or repository, including issues and wikis in the most appropriate format (clones for wikis, json files for issues).
+
+Authentication
+==============
+
+Note: Password-based authentication will fail if you have two-factor authentication enabled.

bin/github-backup

@@ -7,6 +7,7 @@ import base64
 import calendar
 import codecs
 import errno
+import getpass
 import json
 import logging
 import os
@@ -15,8 +16,22 @@ import select
 import subprocess
 import sys
 import time
-import urllib
-import urllib2
+try:
+    # python 3
+    from urllib.parse import urlparse
+    from urllib.parse import quote as urlquote
+    from urllib.parse import urlencode
+    from urllib.error import HTTPError, URLError
+    from urllib.request import urlopen
+    from urllib.request import Request
+except ImportError:
+    # python 2
+    from urlparse import urlparse
+    from urllib import quote as urlquote
+    from urllib import urlencode
+    from urllib2 import HTTPError, URLError
+    from urllib2 import urlopen
+    from urllib2 import Request
 
 from github_backup import __version__
 
@@ -78,8 +93,8 @@ def logging_subprocess(popenargs,
     rc = child.wait()
 
     if rc != 0:
-        print(u'{} returned {}:'.format(popenargs[0], rc), file=sys.stderr)
-        print('\t', u' '.join(popenargs), file=sys.stderr)
+        print('{} returned {}:'.format(popenargs[0], rc), file=sys.stderr)
+        print('\t', ' '.join(popenargs), file=sys.stderr)
 
     return rc
 
@@ -95,9 +110,19 @@ def mkdir_p(*args):
                 raise
 
 
+def mask_password(url, secret='*****'):
+    parsed = urlparse(url)
+
+    if not parsed.password:
+        return url
+    elif parsed.password == 'x-oauth-basic':
+        return url.replace(parsed.username, secret)
+
+    return url.replace(parsed.password, secret)
+
+
 def parse_args():
-    parser = argparse.ArgumentParser(description='Backup a github account',
-                                     prog='Github Backup')
+    parser = argparse.ArgumentParser(description='Backup a github account')
     parser.add_argument('user',
                         metavar='USER',
                         type=str,
@@ -109,16 +134,23 @@ def parse_args():
     parser.add_argument('-p',
                         '--password',
                         dest='password',
-                        help='password for basic auth')
+                        help='password for basic auth. '
+                             'If a username is given but not a password, the '
+                             'password will be prompted for.')
     parser.add_argument('-t',
                         '--token',
                         dest='token',
-                        help='personal access or OAuth token')
+                        help='personal access or OAuth token, or path to token (file://...)')  # noqa
     parser.add_argument('-o',
                         '--output-directory',
                         default='.',
                         dest='output_directory',
                         help='directory at which to backup the repositories')
+    parser.add_argument('-i',
+                        '--incremental',
+                        action='store_true',
+                        dest='incremental',
+                        help='incremental backup')
     parser.add_argument('--starred',
                         action='store_true',
                         dest='include_starred',
@@ -159,6 +191,10 @@ def parse_args():
                         action='store_true',
                         dest='include_labels',
                         help='include labels in backup')
+    parser.add_argument('--hooks',
+                        action='store_true',
+                        dest='include_hooks',
+                        help='include hooks in backup (works only when authenticated)')  # noqa
     parser.add_argument('--milestones',
                         action='store_true',
                         dest='include_milestones',
@@ -167,6 +203,10 @@ def parse_args():
                         action='store_true',
                         dest='include_repository',
                         help='include repository clone in backup')
+    parser.add_argument('--bare',
+                        action='store_true',
+                        dest='bare_clone',
+                        help='clone bare repositories')
     parser.add_argument('--wikis',
                         action='store_true',
                         dest='include_wiki',
@@ -214,18 +254,33 @@ def parse_args():
     return parser.parse_args()
 
 
-def get_auth(args):
+def get_auth(args, encode=True):
     auth = None
+
     if args.token:
-        auth = base64.b64encode(args.token + ':' + 'x-oauth-basic')
-    elif args.username and args.password:
-        auth = base64.b64encode(args.username + ':' + args.password)
-    elif args.username and not args.password:
-        log_error('You must specify a password for basic auth')
-    elif args.password and not args.username:
+        _path_specifier = 'file://'
+        if args.token.startswith(_path_specifier):
+            args.token = open(args.token[len(_path_specifier):],
+                              'rt').readline().strip()
+        auth = args.token + ':' + 'x-oauth-basic'
+    elif args.username:
+        if not args.password:
+            args.password = getpass.getpass()
+        if encode:
+            password = args.password
+        else:
+            password = urlquote(args.password)
+        auth = args.username + ':' + password
+    elif args.password:
         log_error('You must specify a username for basic auth')
 
-    return auth
+    if not auth:
+        return None
+
+    if not encode:
+        return auth
+
+    return base64.b64encode(auth.encode('ascii'))
 
 
 def get_github_api_host(args):
@@ -237,7 +292,7 @@ def get_github_api_host(args):
     return host
 
 
-def get_github_ssh_host(args):
+def get_github_host(args):
     if args.github_host:
         host = args.github_host
     else:
@@ -246,6 +301,23 @@ def get_github_ssh_host(args):
     return host
 
 
+def get_github_repo_url(args, repository):
+    if args.prefer_ssh:
+        return repository['ssh_url']
+
+    auth = get_auth(args, False)
+    if auth:
+        repo_url = 'https://{0}@{1}/{2}/{3}.git'.format(
+            auth,
+            get_github_host(args),
+            args.user,
+            repository['name'])
+    else:
+        repo_url = repository['clone_url']
+
+    return repo_url
+
+
 def retrieve_data(args, template, query_args=None, single_request=False):
     auth = get_auth(args)
     query_args = get_query_args(query_args)
@@ -256,7 +328,7 @@ def retrieve_data(args, template, query_args=None, single_request=False):
     while True:
         page = page + 1
         request = _construct_request(per_page, page, query_args, template, auth)  # noqa
-        r, errors = _get_response(request, template)
+        r, errors = _get_response(request, auth, template)
 
         status_code = int(r.getcode())
 
@@ -265,7 +337,7 @@ def retrieve_data(args, template, query_args=None, single_request=False):
             errors.append(template.format(status_code, r.reason))
             log_error(errors)
 
-        response = json.loads(r.read())
+        response = json.loads(r.read().decode('utf-8'))
         if len(errors) == 0:
             if type(response) == list:
                 data.extend(response)
@@ -289,7 +361,7 @@ def get_query_args(query_args=None):
     return query_args
 
 
-def _get_response(request, template):
+def _get_response(request, auth, template):
     retry_timeout = 3
     errors = []
     # We'll make requests in a loop so we can
@@ -297,11 +369,14 @@ def _get_response(request, template):
     while True:
         should_continue = False
         try:
-            r = urllib2.urlopen(request)
-        except urllib2.HTTPError as exc:
+            r = urlopen(request)
+        except HTTPError as exc:
             errors, should_continue = _request_http_error(exc, auth, errors)  # noqa
-        except urllib2.URLError:
+            r = exc
+        except URLError:
             should_continue = _request_url_error(template, retry_timeout)
+            if not should_continue:
+                raise
 
         if should_continue:
             continue
@@ -311,14 +386,14 @@ def _get_response(request, template):
 
 
 def _construct_request(per_page, page, query_args, template, auth):
-    querystring = urllib.urlencode(dict({
+    querystring = urlencode(dict(list({
         'per_page': per_page,
         'page': page
-    }.items() + query_args.items()))
+    }.items()) + list(query_args.items())))
 
-    request = urllib2.Request(template + '?' + querystring)
+    request = Request(template + '?' + querystring)
     if auth is not None:
-        request.add_header('Authorization', 'Basic ' + auth)
+        request.add_header('Authorization', 'Basic '.encode('ascii') + auth)
     return request
 
 
@@ -345,10 +420,9 @@ def _request_http_error(exc, auth, errors):
         print('Exceeded rate limit of {} requests; waiting {} seconds to reset'.format(limit, delta),  # noqa
               file=sys.stderr)
 
-        ratelimit_error = 'No more requests remaining'
         if auth is None:
-            ratelimit_error += '; authenticate to raise your GitHub rate limit'  # noqa
-        errors.append(ratelimit_error)
+            print('Hint: Authenticate to raise your GitHub rate limit',
+                  file=sys.stderr)
 
         time.sleep(delta)
         should_continue = True
@@ -371,9 +445,8 @@ def _request_url_error(template, retry_timeout):
 def retrieve_repositories(args):
     log_info('Retrieving repositories')
     single_request = False
-    template = 'https://{0}/users/{1}/repos'.format(
-        get_github_api_host(args),
-        args.user)
+    template = 'https://{0}/user/repos'.format(
+        get_github_api_host(args))
     if args.organization:
         template = 'https://{0}/orgs/{1}/repos'.format(
             get_github_api_host(args),
@@ -389,8 +462,14 @@ def retrieve_repositories(args):
     return retrieve_data(args, template, single_request=single_request)
 
 
-def filter_repositories(args, repositories):
+def filter_repositories(args, unfiltered_repositories):
     log_info('Filtering repositories')
+
+    repositories = []
+    for r in unfiltered_repositories:
+        if r['owner']['login'] == args.user:
+            repositories.append(r)
+
     name_regex = None
     if args.name_regex:
         name_regex = re.compile(args.name_regex)
@@ -415,28 +494,36 @@ def backup_repositories(args, output_directory, repositories):
     log_info('Backing up repositories')
     repos_template = 'https://{0}/repos'.format(get_github_api_host(args))
 
+    if args.incremental:
+        last_update = max(repository['updated_at'] for repository in repositories)  # noqa
+        last_update_path = os.path.join(output_directory, 'last_update')
+        if os.path.exists(last_update_path):
+            args.since = open(last_update_path).read().strip()
+        else:
+            args.since = None
+    else:
+        args.since = None
+
     for repository in repositories:
         backup_cwd = os.path.join(output_directory, 'repositories')
         repo_cwd = os.path.join(backup_cwd, repository['name'])
         repo_dir = os.path.join(repo_cwd, 'repository')
-
-        if args.prefer_ssh:
-            repo_url = repository['ssh_url']
-        else:
-            repo_url = repository['clone_url']
+        repo_url = get_github_repo_url(args, repository)
 
         if args.include_repository or args.include_everything:
             fetch_repository(repository['name'],
                              repo_url,
                              repo_dir,
-                             skip_existing=args.skip_existing)
+                             skip_existing=args.skip_existing,
+                             bare_clone=args.bare_clone)
 
         download_wiki = (args.include_wiki or args.include_everything)
         if repository['has_wiki'] and download_wiki:
             fetch_repository(repository['name'],
                              repo_url.replace('.git', '.wiki.git'),
                              os.path.join(repo_cwd, 'wiki'),
-                             skip_existing=args.skip_existing)
+                             skip_existing=args.skip_existing,
+                             bare_clone=args.bare_clone)
 
         if args.include_issues or args.include_everything:
             backup_issues(args, repo_cwd, repository, repos_template)
@@ -450,6 +537,12 @@ def backup_repositories(args, output_directory, repositories):
         if args.include_labels or args.include_everything:
             backup_labels(args, repo_cwd, repository, repos_template)
 
+        if args.include_hooks or args.include_everything:
+            backup_hooks(args, repo_cwd, repository, repos_template)
+
+    if args.incremental:
+        open(last_update_path, 'w').write(last_update)
+
 
 def backup_issues(args, repo_cwd, repository, repos_template):
     has_issues_dir = os.path.isdir('{0}/issues/.git'.format(repo_cwd))
@@ -461,26 +554,42 @@ def backup_issues(args, repo_cwd, repository, repos_template):
     mkdir_p(repo_cwd, issue_cwd)
 
     issues = {}
+    issues_skipped = 0
+    issues_skipped_message = ''
     _issue_template = '{0}/{1}/issues'.format(repos_template,
                                               repository['full_name'])
 
+    should_include_pulls = args.include_pulls or args.include_everything
     issue_states = ['open', 'closed']
     for issue_state in issue_states:
         query_args = {
             'filter': 'all',
             'state': issue_state
         }
+        if args.since:
+            query_args['since'] = args.since
 
         _issues = retrieve_data(args,
                                 _issue_template,
                                 query_args=query_args)
         for issue in _issues:
+            # skip pull requests which are also returned as issues
+            # if retrieving pull requests is requested as well
+            if 'pull_request' in issue and should_include_pulls:
+                issues_skipped += 1
+                continue
+
             issues[issue['number']] = issue
 
-    log_info('Saving {0} issues to disk'.format(len(issues.keys())))
+    if issues_skipped:
+        issues_skipped_message = ' (skipped {0} pull requests)'.format(
+            issues_skipped)
+
+    log_info('Saving {0} issues to disk{1}'.format(
+        len(list(issues.keys())), issues_skipped_message))
     comments_template = _issue_template + '/{0}/comments'
     events_template = _issue_template + '/{0}/events'
-    for number, issue in issues.iteritems():
+    for number, issue in list(issues.items()):
         if args.include_issue_comments or args.include_everything:
             template = comments_template.format(number)
             issues[number]['comment_data'] = retrieve_data(args, template)
@@ -510,19 +619,24 @@ def backup_pulls(args, repo_cwd, repository, repos_template):
     for pull_state in pull_states:
         query_args = {
             'filter': 'all',
-            'state': pull_state
+            'state': pull_state,
+            'sort': 'updated',
+            'direction': 'desc',
         }
 
+        # It'd be nice to be able to apply the args.since filter here...
         _pulls = retrieve_data(args,
                                _pulls_template,
                                query_args=query_args)
         for pull in _pulls:
-            pulls[pull['number']] = pull
+            if not args.since or pull['updated_at'] >= args.since:
+                pulls[pull['number']] = pull
 
-    log_info('Saving {0} pull requests to disk'.format(len(pulls.keys())))
+    log_info('Saving {0} pull requests to disk'.format(
+        len(list(pulls.keys()))))
     comments_template = _pulls_template + '/{0}/comments'
     commits_template = _pulls_template + '/{0}/commits'
-    for number, pull in pulls.iteritems():
+    for number, pull in list(pulls.items()):
         if args.include_pull_comments or args.include_everything:
             template = comments_template.format(number)
             pulls[number]['comment_data'] = retrieve_data(args, template)
@@ -556,8 +670,9 @@ def backup_milestones(args, repo_cwd, repository, repos_template):
     for milestone in _milestones:
         milestones[milestone['number']] = milestone
 
-    log_info('Saving {0} milestones to disk'.format(len(milestones.keys())))
-    for number, milestone in milestones.iteritems():
+    log_info('Saving {0} milestones to disk'.format(
+        len(list(milestones.keys()))))
+    for number, milestone in list(milestones.items()):
         milestone_file = '{0}/{1}.json'.format(milestone_cwd, number)
         with codecs.open(milestone_file, 'w', encoding='utf-8') as f:
             json_dump(milestone, f)
@@ -575,29 +690,82 @@ def backup_labels(args, repo_cwd, repository, repos_template):
                  label_cwd)
 
 
-def fetch_repository(name, remote_url, local_dir, skip_existing=False):
-    clone_exists = os.path.exists(os.path.join(local_dir, '.git'))
+def backup_hooks(args, repo_cwd, repository, repos_template):
+    auth = get_auth(args)
+    if not auth:
+        log_info("Skipping hooks since no authentication provided")
+        return
+    hook_cwd = os.path.join(repo_cwd, 'hooks')
+    output_file = '{0}/hooks.json'.format(hook_cwd)
+    template = '{0}/{1}/hooks'.format(repos_template,
+                                      repository['full_name'])
+    try:
+        _backup_data(args,
+                     'hooks',
+                     template,
+                     output_file,
+                     hook_cwd)
+    except SystemExit:
+        log_info("Unable to read hooks, skipping")
+
+
+def fetch_repository(name,
+                     remote_url,
+                     local_dir,
+                     skip_existing=False,
+                     bare_clone=False):
+    if bare_clone:
+        if os.path.exists(local_dir):
+            clone_exists = subprocess.check_output(['git',
+                                                    'rev-parse',
+                                                    '--is-bare-repository'],
+                                                   cwd=local_dir) == "true\n"
+        else:
+            clone_exists = False
+    else:
+        clone_exists = os.path.exists(os.path.join(local_dir, '.git'))
 
     if clone_exists and skip_existing:
         return
 
-    initalized = subprocess.call('git ls-remote ' + remote_url,
-                                 stdout=FNULL,
-                                 stderr=FNULL,
-                                 shell=True)
-    if initalized == 128:
-        log_info("Skipping {0} since it's not initalized".format(name))
+    masked_remote_url = mask_password(remote_url)
+
+    initialized = subprocess.call('git ls-remote ' + remote_url,
+                                  stdout=FNULL,
+                                  stderr=FNULL,
+                                  shell=True)
+    if initialized == 128:
+        log_info("Skipping {0} ({1}) since it's not initialized".format(
+            name, masked_remote_url))
         return
 
     if clone_exists:
         log_info('Updating {0} in {1}'.format(name, local_dir))
-        git_command = ['git', 'fetch', '--all', '--tags', '--prune']
+
+        remotes = subprocess.check_output(['git', 'remote', 'show'],
+                                          cwd=local_dir)
+        remotes = [i.strip() for i in remotes.decode('utf-8')]
+
+        if 'origin' not in remotes:
+            git_command = ['git', 'remote', 'rm', 'origin']
+            logging_subprocess(git_command, None, cwd=local_dir)
+            git_command = ['git', 'remote', 'add', 'origin', remote_url]
+            logging_subprocess(git_command, None, cwd=local_dir)
+        else:
+            git_command = ['git', 'remote', 'set-url', 'origin', remote_url]
+            logging_subprocess(git_command, None, cwd=local_dir)
+
+        git_command = ['git', 'fetch', '--all', '--force', '--tags', '--prune']
         logging_subprocess(git_command, None, cwd=local_dir)
     else:
-        log_info('Cloning {0} repository from {1} to {2}'.format(name,
-                                                                 remote_url,
-                                                                 local_dir))
-        git_command = ['git', 'clone', remote_url, local_dir]
+        log_info('Cloning {0} repository from {1} to {2}'.format(
+            name,
+            masked_remote_url,
+            local_dir))
+        if bare_clone:
+            git_command = ['git', 'clone', '--mirror', remote_url, local_dir]
+        else:
+            git_command = ['git', 'clone', remote_url, local_dir]
         logging_subprocess(git_command, None)
 
 
@@ -651,8 +819,8 @@ def main():
 
     output_directory = os.path.realpath(args.output_directory)
     if not os.path.isdir(output_directory):
-        log_error('Specified output directory is not a directory: {0}'.format(
-            output_directory))
+        log_info('Create output directory {0}'.format(output_directory))
+        mkdir_p(output_directory)
 
     log_info('Backing up user {0} to {1}'.format(args.user, output_directory))
 

github_backup/__init__.py

@@ -1 +1 @@
-__version__ = '0.5.0'
+__version__ = '0.12.1'

release

@@ -34,7 +34,7 @@ fi
 echo -e "\n${GREEN}STARTING RELEASE PROCESS${COLOR_OFF}\n"
 
 set +e;
-git status | grep "working directory clean" &> /dev/null
+git status | grep -Eo "working (directory|tree) clean" &> /dev/null
 if [ ! $? -eq 0 ]; then # working directory is NOT clean
     echo -e "${RED}WARNING: You have uncomitted changes, you may have forgotten something${COLOR_OFF}\n"
     exit 1