Merge pull request #345 from LabShare/feature/simple_auth

Simple Auth support

Author: fcollonval

jupyterlab_git/git.py

@@ -4,14 +4,61 @@
 import os
 import subprocess
 from subprocess import Popen, PIPE, CalledProcessError
-from urllib.parse import unquote
 
+import pexpect
+from urllib.parse import unquote
 from tornado.web import HTTPError
 
 
 ALLOWED_OPTIONS = ['user.name', 'user.email']
 
 
+class GitAuthInputWrapper:
+    """
+    Helper class which is meant to replace subprocess.Popen for communicating
+    with git CLI when also sending username and password for auth
+    """
+    def __init__(self, command, cwd, env, username, password):
+        self.command = command
+        self.cwd = cwd
+        self.env = env
+        self.username = username
+        self.password = password
+    def communicate(self):
+        try:
+            p = pexpect.spawn(
+                self.command, 
+                cwd = self.cwd,
+                env = self.env
+            )
+
+            # We expect a prompt from git
+            # In most of cases git will prompt for username and
+            #  then for password
+            # In some cases (Bitbucket) username is included in
+            #  remote URL, so git will not ask for username 
+            i = p.expect(['Username for .*: ', 'Password for .*:'])
+            if i==0: #ask for username then password
+                p.sendline(self.username)
+                p.expect('Password for .*:')
+                p.sendline(self.password)
+            elif i==1: #only ask for password
+                p.sendline(self.password)
+
+            p.expect(pexpect.EOF)
+            response = p.before
+
+            self.returncode = p.wait()
+            p.close()
+            
+            return response
+        except pexpect.exceptions.EOF: #In case of pexpect failure
+            response = p.before
+            self.returncode = p.exitstatus
+            p.close() #close process
+            return response
+
+
 class Git:
     """
     A single parent class containing all of the individual git methods in it.
@@ -110,23 +157,37 @@ def changed_files(self, base=None, remote=None, single_commit=None):
         return response
 
 
-    def clone(self, current_path, repo_url):
+    def clone(self, current_path, repo_url, auth=None):
         """
-        Execute `git clone`. Disables prompts for the password to avoid the terminal hanging.
+        Execute `git clone`.
+        When no auth is provided, disables prompts for the password to avoid the terminal hanging.
+        When auth is provided, await prompts for username/passwords and sends them
         :param current_path: the directory where the clone will be performed.
         :param repo_url: the URL of the repository to be cloned.
+        :param auth: OPTIONAL dictionary with 'username' and 'password' fields
         :return: response with status code and error message.
         """
         env = os.environ.copy()
-        env["GIT_TERMINAL_PROMPT"] = "0"
-        p = subprocess.Popen(
-            ["git", "clone", unquote(repo_url)],
-            stdout=PIPE,
-            stderr=PIPE,
-            cwd=os.path.join(self.root_dir, current_path),
-            env=env,
-        )
-        _, error = p.communicate()
+        if (auth):
+            env["GIT_TERMINAL_PROMPT"] = "1"
+            p = GitAuthInputWrapper(
+                command='git clone {} -q'.format(unquote(repo_url)),
+                cwd=os.path.join(self.root_dir, current_path),
+                env = env,
+                username=auth['username'],
+                password=auth['password'],
+            )
+            error = p.communicate()
+        else:
+            env["GIT_TERMINAL_PROMPT"] = "0"
+            p = subprocess.Popen(
+                ['git', 'clone', unquote(repo_url)],
+                stdout=PIPE,
+                stderr=PIPE,
+                env = env,
+                cwd=os.path.join(self.root_dir, current_path),
+            )
+            _, error = p.communicate()
 
         response = {"code": p.returncode}
 
@@ -544,22 +605,33 @@ def commit(self, commit_msg, top_repo_path):
             ["git", "commit", "-m", commit_msg], cwd=top_repo_path
         )
         return my_output
-
-    def pull(self, curr_fb_path):
+            
+    def pull(self, curr_fb_path, auth=None):
         """
         Execute git pull --no-commit.  Disables prompts for the password to avoid the terminal hanging while waiting
         for auth.
         """
         env = os.environ.copy()
-        env["GIT_TERMINAL_PROMPT"] = "0"
-        p = subprocess.Popen(
-            ["git", "pull", "--no-commit"],
-            stdout=PIPE,
-            stderr=PIPE,
-            cwd=os.path.join(self.root_dir, curr_fb_path),
-            env=env,
-        )
-        _, error = p.communicate()
+        if (auth):
+            env["GIT_TERMINAL_PROMPT"] = "1"
+            p = GitAuthInputWrapper(
+                command = 'git pull --no-commit',
+                cwd = os.path.join(self.root_dir, curr_fb_path),
+                env = env,
+                username = auth['username'],
+                password = auth['password']
+            )
+            error = p.communicate()
+        else:
+            env["GIT_TERMINAL_PROMPT"] = "0"
+            p = subprocess.Popen(
+                ['git', 'pull', '--no-commit'],
+                stdout=PIPE,
+                stderr=PIPE,
+                env = env,
+                cwd=os.path.join(self.root_dir, curr_fb_path),
+            )
+            _, error = p.communicate()
 
         response = {"code": p.returncode}
 
@@ -568,20 +640,31 @@ def pull(self, curr_fb_path):
 
         return response
 
-    def push(self, remote, branch, curr_fb_path):
+    def push(self, remote, branch, curr_fb_path, auth=None):
         """
         Execute `git push $UPSTREAM $BRANCH`. The choice of upstream and branch is up to the caller.
         """
         env = os.environ.copy()
-        env["GIT_TERMINAL_PROMPT"] = "0"
-        p = subprocess.Popen(
-            ["git", "push", remote, branch],
-            stdout=PIPE,
-            stderr=PIPE,
-            cwd=os.path.join(self.root_dir, curr_fb_path),
-            env=env,
-        )
-        _, error = p.communicate()
+        if (auth):
+            env["GIT_TERMINAL_PROMPT"] = "1"
+            p = GitAuthInputWrapper(
+                command = 'git push {} {}'.format(remote, branch),
+                cwd = os.path.join(self.root_dir, curr_fb_path),
+                env = env,
+                username = auth['username'],
+                password = auth['password']
+            )
+            error = p.communicate()
+        else:
+            env["GIT_TERMINAL_PROMPT"] = "0"
+            p = subprocess.Popen(
+                ['git', 'push', remote, branch],
+                stdout=PIPE,
+                stderr=PIPE,
+                env = env,
+                cwd=os.path.join(self.root_dir, curr_fb_path),
+            )
+            _, error = p.communicate()
 
         response = {"code": p.returncode}
 

jupyterlab_git/handlers.py

@@ -25,11 +25,14 @@ def post(self):
         Input format:
             {
               'current_path': 'current_file_browser_path',
-              'repo_url': 'https://github.com/path/to/myrepo'
+              'repo_url': 'https://github.com/path/to/myrepo',
+              OPTIONAL 'auth': '{ 'username': '<username>',
+                                  'password': '<password>'
+                                }'
             }
         """
-        data = json.loads(self.request.body.decode("utf-8"))
-        response = self.git.clone(data["current_path"], data["clone_url"])
+        data = json.loads(self.request.body.decode('utf-8'))
+        response = self.git.clone(data['current_path'], data['clone_url'], data.get('auth', None))
         self.finish(json.dumps(response))
 
 
@@ -339,8 +342,10 @@ def post(self):
         """
         POST request handler, pulls files from a remote branch to your current branch.
         """
-        output = self.git.pull(self.get_json_body()["current_path"])
-        self.finish(json.dumps(output))
+        data = self.get_json_body()
+        response = self.git.pull(data['current_path'], data.get('auth', None))
+        
+        self.finish(json.dumps(response))
 
 
 class GitPushHandler(GitHandler):
@@ -354,7 +359,8 @@ def post(self):
         POST request handler,
         pushes committed files from your current branch to a remote branch
         """
-        current_path = self.get_json_body()["current_path"]
+        data = self.get_json_body()
+        current_path = data['current_path']
 
         current_local_branch = self.git.get_current_branch(current_path)
         current_upstream_branch = self.git.get_upstream_branch(
@@ -372,7 +378,7 @@ def post(self):
                 remote = upstream[0]
                 branch = ":".join(["HEAD", upstream[1]])
 
-            response = self.git.push(remote, branch, current_path)
+            response = self.git.push(remote, branch, current_path, data.get('auth', None))
 
         else:
             response = {

jupyterlab_git/tests/test_clone.py

@@ -2,7 +2,7 @@
 
 from mock import patch, call, Mock
 
-from jupyterlab_git.git import Git
+from jupyterlab_git.git import Git, GitAuthInputWrapper
 
 
 @patch('subprocess.Popen')
@@ -66,3 +66,109 @@ def test_git_clone_failure_from_git(mock_subproc_popen):
         call().communicate()
     ])
     assert {'code': 128, 'message': 'fatal: Not a git repository'} == actual_response
+
+@patch('jupyterlab_git.git.GitAuthInputWrapper')
+@patch('os.environ', {'TEST': 'test'})
+def test_git_clone_with_auth_success(mock_GitAuthInputWrapper):
+    # Given
+    process_mock = Mock()
+    attrs = {
+        'communicate.return_value': '',
+        'returncode': 0
+    }
+    process_mock.configure_mock(**attrs)
+    mock_GitAuthInputWrapper.return_value = process_mock
+
+    # When
+    auth = {
+        'username' : 'asdf', 
+        'password' : 'qwerty'
+    }
+    actual_response = Git(root_dir='/bin').clone(current_path='test_curr_path', repo_url='ghjkhjkl', auth=auth)
+
+    # Then
+    mock_GitAuthInputWrapper.assert_has_calls([
+        call(
+            command = 'git clone ghjkhjkl -q',
+            cwd = '/bin/test_curr_path',
+            env={'TEST': 'test', 'GIT_TERMINAL_PROMPT': '1'},
+            username = 'asdf',
+            password = 'qwerty'
+        ),
+        call().communicate()
+    ])
+    assert {'code': 0} == actual_response
+
+@patch('jupyterlab_git.git.GitAuthInputWrapper')
+@patch('os.environ', {'TEST': 'test'})
+def test_git_clone_with_auth_wrong_repo_url_failure_from_git(mock_GitAuthInputWrapper):
+    """
+    Git internally will throw an error if it is an invalid URL, or if there is a permissions issue. We want to just
+    relay it back to the user.
+
+    """
+    # Given
+    process_mock = Mock()
+    attrs = {
+        'communicate.return_value': "fatal: repository 'ghjkhjkl' does not exist".encode('utf-8'),
+        'returncode': 128
+    }
+    process_mock.configure_mock(**attrs)
+    mock_GitAuthInputWrapper.return_value = process_mock
+
+    # When
+    auth = {
+        'username' : 'asdf', 
+        'password' : 'qwerty'
+    }
+    actual_response = Git(root_dir='/bin').clone(current_path='test_curr_path', repo_url='ghjkhjkl', auth=auth)
+
+    # Then
+    mock_GitAuthInputWrapper.assert_has_calls([
+        call(
+            command = 'git clone ghjkhjkl -q',
+            cwd = '/bin/test_curr_path',
+            env={'TEST': 'test', 'GIT_TERMINAL_PROMPT': '1'},
+            username = 'asdf',
+            password = 'qwerty'
+        ),
+        call().communicate()
+    ])
+    assert {'code': 128, 'message': "fatal: repository 'ghjkhjkl' does not exist"} == actual_response
+
+@patch('jupyterlab_git.git.GitAuthInputWrapper')
+@patch('os.environ', {'TEST': 'test'})
+def test_git_clone_with_auth_auth_failure_from_git(mock_GitAuthInputWrapper):
+    """
+    Git internally will throw an error if it is an invalid URL, or if there is a permissions issue. We want to just
+    relay it back to the user.
+
+    """
+    # Given
+    process_mock = Mock()
+    attrs = {
+        'communicate.return_value': "remote: Invalid username or password.\r\nfatal: Authentication failed for 'ghjkhjkl'".encode('utf-8'),
+        'returncode': 128
+    }
+    process_mock.configure_mock(**attrs)
+    mock_GitAuthInputWrapper.return_value = process_mock
+
+    # When
+    auth = {
+        'username' : 'asdf', 
+        'password' : 'qwerty'
+    }
+    actual_response = Git(root_dir='/bin').clone(current_path='test_curr_path', repo_url='ghjkhjkl', auth=auth)
+
+    # Then
+    mock_GitAuthInputWrapper.assert_has_calls([
+        call(
+            command = 'git clone ghjkhjkl -q',
+            cwd = '/bin/test_curr_path',
+            env={'TEST': 'test', 'GIT_TERMINAL_PROMPT': '1'},
+            username = 'asdf',
+            password = 'qwerty'
+        ),
+        call().communicate()
+    ])
+    assert {'code': 128, 'message': "remote: Invalid username or password.\r\nfatal: Authentication failed for 'ghjkhjkl'"} == actual_response

jupyterlab_git/tests/test_handlers.py

@@ -47,7 +47,7 @@ def test_push_handler_localbranch(mock_finish, mock_git):
     # Then
     mock_git.get_current_branch.assert_called_with('test_path')
     mock_git.get_upstream_branch.assert_called_with('test_path', 'foo')
-    mock_git.push.assert_called_with('.', 'HEAD:localbranch', 'test_path')
+    mock_git.push.assert_called_with('.', 'HEAD:localbranch', 'test_path', None)
     mock_finish.assert_called_with('{"code": 0}')
 
 
@@ -67,7 +67,7 @@ def test_push_handler_remotebranch(mock_finish, mock_git):
     # Then
     mock_git.get_current_branch.assert_called_with('test_path')
     mock_git.get_upstream_branch.assert_called_with('test_path', 'foo')
-    mock_git.push.assert_called_with('origin', 'HEAD:remotebranch', 'test_path')
+    mock_git.push.assert_called_with('origin', 'HEAD:remotebranch', 'test_path', None)
     mock_finish.assert_called_with('{"code": 0}')