Merge pull request #711 from fcollonval/auto-backport-of-pr-658-on-0.11.x

Backport PR #658: Check git version and compatibility front/backend v…

Author: fcollonval

README.md

@@ -57,7 +57,7 @@ jupyter labextension list
   - Be sure to be in a Git repository in the filebrowser tab
 
   - Check the server log. If you see a warning with a 404 code similar to:
-    `[W 00:27:41.800 LabApp] 404 GET /git/server_root?1576081660665`
+    `[W 00:27:41.800 LabApp] 404 GET /git/settings?version=0.20.0`
 
     Explicitly enable the server extension by running:
 

jupyterlab_git/git.py

@@ -24,6 +24,8 @@
 MAX_WAIT_FOR_LOCK_S = 5
 # How often should we check for the lock above to be free? This comes up more on things like NFS
 CHECK_LOCK_INTERVAL_S = 0.1
+# Parse Git version output
+GIT_VERSION_REGEX = re.compile(r"^git\sversion\s(?P<version>\d+(.\d+)*)")
 
 execution_lock = tornado.locks.Lock()
 
@@ -1109,3 +1111,17 @@ def remote_add(self, top_repo_path, url, name=DEFAULT_REMOTE_NAME):
                 "command": " ".join(cmd),
                 "message": my_error.decode("utf-8").strip()
             }
+
+    async def version(self):
+        """Return the Git command version.
+        
+        If an error occurs, return None.
+        """
+        command = ["git", "--version"]
+        code, output, _ = await execute(command, cwd=os.curdir)
+        if code == 0:
+            version = GIT_VERSION_REGEX.match(output)
+            if version is not None:
+                return version.group('version')
+        
+        return None

jupyterlab_git/handlers.py

@@ -8,7 +8,9 @@
 
 from notebook.base.handlers import APIHandler
 from notebook.utils import url_path_join as ujoin, url2path
+from packaging.version import parse
 
+from ._version import __version__
 from .git import DEFAULT_REMOTE_NAME
 
 class GitHandler(APIHandler):
@@ -532,13 +534,31 @@ async def post(self):
         self.finish(json.dumps(response))
 
 
-class GitServerRootHandler(GitHandler):
+class GitSettingsHandler(GitHandler):
     @web.authenticated
     async def get(self):
+        jlab_version = self.get_query_argument("version", None)
+        if jlab_version is not None:
+            jlab_version = str(parse(jlab_version))
+        git_version = None
+        try:
+            git_version = await self.git.version()
+        except Exception as error:
+            self.log.debug("[jupyterlab_git] Failed to execute 'git' command: {!s}".format(error))
+        server_version = str(parse(__version__))
         # Similar to https://github.com/jupyter/nbdime/blob/master/nbdime/webapp/nb_server_extension.py#L90-L91
         root_dir = getattr(self.contents_manager, "root_dir", None)
         server_root = None if root_dir is None else Path(root_dir).as_posix()
-        self.finish(json.dumps({"server_root": server_root}))
+        self.finish(
+            json.dumps(
+                {
+                    "frontendVersion": jlab_version,
+                    "gitVersion": git_version,
+                    "serverRoot": server_root,
+                    "serverVersion": server_version,
+                }
+            )
+        )
 
 
 def setup_handlers(web_app):
@@ -569,7 +589,7 @@ def setup_handlers(web_app):
         ("/git/remote/add", GitRemoteAddHandler),
         ("/git/reset", GitResetHandler),
         ("/git/reset_to_commit", GitResetToCommitHandler),
-        ("/git/server_root", GitServerRootHandler),
+        ("/git/settings", GitSettingsHandler),
         ("/git/show_prefix", GitShowPrefixHandler),
         ("/git/show_top_level", GitShowTopLevelHandler),
         ("/git/status", GitStatusHandler),

jupyterlab_git/tests/test_settings.py

@@ -0,0 +1,79 @@
+import os
+from unittest.mock import Mock, patch
+
+from packaging.version import parse
+
+from jupyterlab_git import __version__
+from jupyterlab_git.handlers import GitSettingsHandler
+
+from .testutils import ServerTest, assert_http_error, maybe_future
+
+
+class TestSettings(ServerTest):
+    @patch("jupyterlab_git.git.execute")
+    def test_git_get_settings_success(self, mock_execute):
+        # Given
+        git_version = "2.10.3"
+        jlab_version = "2.1.42-alpha.24"
+        mock_execute.return_value = maybe_future(
+            (0, "git version {}.os_platform.42".format(git_version), "")
+        )
+
+        # When
+        response = self.tester.get(["settings"], params={"version": jlab_version})
+
+        # Then
+        mock_execute.assert_called_once_with(["git", "--version"], cwd=os.curdir)
+
+        assert response.status_code == 200
+        payload = response.json()
+        assert payload == {
+            "frontendVersion": str(parse(jlab_version)),
+            "gitVersion": git_version,
+            "serverRoot": self.notebook.notebook_dir,
+            "serverVersion": str(parse(__version__)),
+        }
+        
+    @patch("jupyterlab_git.git.execute")
+    def test_git_get_settings_no_git(self, mock_execute):
+        # Given
+        jlab_version = "2.1.42-alpha.24"
+        mock_execute.side_effect = FileNotFoundError("[Errno 2] No such file or directory: 'git'")
+
+        # When
+        response = self.tester.get(["settings"], params={"version": jlab_version})
+
+        # Then
+        mock_execute.assert_called_once_with(["git", "--version"], cwd=os.curdir)
+
+        assert response.status_code == 200
+        payload = response.json()
+        assert payload == {
+            "frontendVersion": str(parse(jlab_version)),
+            "gitVersion": None,
+            "serverRoot": self.notebook.notebook_dir,
+            "serverVersion": str(parse(__version__)),
+        }
+
+    @patch("jupyterlab_git.git.execute")
+    def test_git_get_settings_no_jlab(self, mock_execute):
+        # Given
+        git_version = "2.10.3"
+        mock_execute.return_value = maybe_future(
+            (0, "git version {}.os_platform.42".format(git_version), "")
+        )
+
+        # When
+        response = self.tester.get(["settings"])
+
+        # Then
+        mock_execute.assert_called_once_with(["git", "--version"], cwd=os.curdir)
+
+        assert response.status_code == 200
+        payload = response.json()
+        assert payload == {
+            "frontendVersion": None,
+            "gitVersion": git_version,
+            "serverRoot": self.notebook.notebook_dir,
+            "serverVersion": str(parse(__version__)),
+        }

package.json

@@ -13,7 +13,7 @@
     "jupyterlab-extension"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "genversion --es6 --semi src/version.ts && tsc",
     "build:labextension": "jlpm && jlpm clean:labextension && mkdirp jupyterlab_git/labextension && cd jupyterlab_git/labextension && npm pack ../..",
     "clean": "rimraf lib tsconfig.tsbuildinfo",
     "clean:more": "jlpm clean && rimraf build dist MANIFEST",
@@ -92,6 +92,7 @@
     "eslint-config-prettier": "^6.10.1",
     "eslint-plugin-prettier": "^3.1.2",
     "eslint-plugin-react": "^7.19.0",
+    "genversion": "^2.2.1",
     "husky": "1.3.1",
     "identity-obj-proxy": "^3.0.0",
     "jest": "^24",

setup.py

@@ -67,11 +67,13 @@ def runPackLabextension():
         'Programming Language :: Python :: 3.5',
         'Programming Language :: Python :: 3.6',
         'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
         'Framework :: Jupyter',
     ],
     install_requires = [
         'notebook',
         'nbdime >= 1.1.0, < 2.0.0',
+        'packaging',
         'pexpect'
     ],
     extras_require = {

src/index.ts

@@ -4,6 +4,7 @@ import {
   JupyterFrontEndPlugin
 } from '@jupyterlab/application';
 import { IChangedArgs, ISettingRegistry } from '@jupyterlab/coreutils';
+import { Dialog, showErrorMessage } from '@jupyterlab/apputils';
 import { FileBrowserModel, IFileBrowserFactory } from '@jupyterlab/filebrowser';
 import { IMainMenu } from '@jupyterlab/mainmenu';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
@@ -12,7 +13,8 @@ import { defaultIconRegistry } from '@jupyterlab/ui-components';
 import { addCommands, createGitMenu } from './commandsAndMenu';
 import { GitExtension } from './model';
 import { registerGitIcons } from './style/icons';
-import { IGitExtension } from './tokens';
+import { getServerSettings } from './server';
+import { Git, IGitExtension } from './tokens';
 import { addCloneButton } from './widgets/gitClone';
 import { GitWidget } from './widgets/GitWidget';
 import { addStatusBarWidget } from './widgets/StatusWidget';
@@ -54,11 +56,13 @@ async function activate(
   settingRegistry: ISettingRegistry,
   statusBar: IStatusBar
 ): Promise<IGitExtension> {
+  let gitExtension: GitExtension | null = null;
   let settings: ISettingRegistry.ISettings;
 
   // Register Git icons with the icon registry
   registerGitIcons(defaultIconRegistry);
 
+  let serverSettings: Git.IServerSettings;
   // Get a reference to the default file browser extension
   const filebrowser = factory.defaultBrowser;
 
@@ -68,8 +72,45 @@ async function activate(
   } catch (error) {
     console.error(`Failed to load settings for the Git Extension.\n${error}`);
   }
+  try {
+    serverSettings = await getServerSettings();
+    const { frontendVersion, gitVersion, serverVersion } = serverSettings;
+
+    // Version validation
+    if (!gitVersion) {
+      throw new Error(
+        'git command not found - please ensure you have Git > 2 installed'
+      );
+    } else {
+      const gitVersion_ = gitVersion.split('.');
+      if (Number.parseInt(gitVersion_[0]) < 2) {
+        throw new Error(`git command version must be > 2; got ${gitVersion}.`);
+      }
+    }
+
+    if (frontendVersion && frontendVersion !== serverVersion) {
+      throw new Error(
+        'The versions of the JupyterLab Git server frontend and backend do not match. ' +
+          `The @jupyterlab/git frontend extension has version: ${frontendVersion} ` +
+          `while the python package has version ${serverVersion}. ` +
+          'Please install identical version of jupyterlab-git Python package and the @jupyterlab/git extension. Try running: pip install --upgrade jupyterlab-git'
+      );
+    }
+  } catch (error) {
+    // If we fall here, nothing will be loaded in the frontend.
+    console.error(
+      'Failed to load the jupyterlab-git server extension settings',
+      error
+    );
+    showErrorMessage(
+      'Failed to load the jupyterlab-git server extension',
+      error.message,
+      [Dialog.warnButton({ label: 'DISMISS' })]
+    );
+    return null;
+  }
   // Create the Git model
-  const gitExtension = new GitExtension(app, settings);
+  gitExtension = new GitExtension(serverSettings.serverRoot, app, settings);
 
   // Whenever we restore the application, sync the Git extension path
   Promise.all([app.restored, filebrowser.model.restored]).then(() => {

src/model.ts

@@ -13,7 +13,6 @@ import { LinkedList } from '@phosphor/collections';
 import { httpGitRequest } from './git';
 import { IGitExtension, Git } from './tokens';
 import { decodeStage } from './utils';
-import { Dialog, showErrorMessage } from '@jupyterlab/apputils';
 
 // Default refresh interval (in milliseconds) for polling the current Git status (NOTE: this value should be the same value as in the plugin settings schema):
 const DEFAULT_REFRESH_INTERVAL = 3000; // ms
@@ -30,27 +29,15 @@ export class GitExtension implements IGitExtension {
    * @returns extension model
    */
   constructor(
+    serverRoot: string,
     app: JupyterFrontEnd = null,
     settings?: ISettingRegistry.ISettings
   ) {
     const self = this;
+    this._serverRoot = serverRoot;
     this._app = app;
     this._settings = settings || null;
 
-    // Load the server root path
-    this._getServerRoot()
-      .then(root => {
-        this._serverRoot = root;
-      })
-      .catch(reason => {
-        console.error(`Fail to get the server root path.\n${reason}`);
-        showErrorMessage(
-          'Internal Error:',
-          `Fail to get the server root path.\n\n${reason}`,
-          [Dialog.warnButton({ label: 'DISMISS' })]
-        );
-      });
-
     let interval: number;
     if (settings) {
       interval = settings.composite.refreshInterval as number;
@@ -1153,30 +1140,6 @@ export class GitExtension implements IGitExtension {
     this._statusChanged.emit(this._status);
   }
 
-  /**
-   * Retrieve the path of the root server directory.
-   *
-   * @returns promise which resolves upon retrieving the root server path
-   */
-  private async _getServerRoot(): Promise<string> {
-    let response;
-    try {
-      response = await httpGitRequest('/git/server_root', 'GET', null);
-    } catch (err) {
-      throw new ServerConnection.NetworkError(err);
-    }
-    if (response.status === 404) {
-      throw new ServerConnection.ResponseError(
-        response,
-        'Git server extension is unavailable. Please ensure you have installed the ' +
-          'JupyterLab Git server extension by running: pip install --upgrade jupyterlab-git. ' +
-          'To confirm that the server extension is installed, run: jupyter serverextension list.'
-      );
-    }
-    const data = await response.json();
-    return data['server_root'];
-  }
-
   /**
    * Set the marker object for a repository path and branch.
    *

src/server.ts

@@ -0,0 +1,35 @@
+import { URLExt } from '@jupyterlab/coreutils';
+import { ServerConnection } from '@jupyterlab/services';
+import { Git } from './tokens';
+import { httpGitRequest } from './git';
+import { version } from './version';
+
+export async function getServerSettings(): Promise<Git.IServerSettings> {
+  try {
+    const endpoint = '/git/settings' + URLExt.objectToQueryString({ version });
+    const response = await httpGitRequest(endpoint, 'GET', null);
+    if (response.status === 404) {
+      const message =
+        'Git server extension is unavailable. Please ensure you have installed the ' +
+        'JupyterLab Git server extension by running: pip install --upgrade jupyterlab-git. ' +
+        'To confirm that the server extension is installed, run: jupyter serverextension list.';
+      throw new ServerConnection.ResponseError(response, message);
+    }
+    let content: string | any = await response.text();
+    if (content.length > 0) {
+      content = JSON.parse(content);
+    }
+    if (!response.ok) {
+      const message = content.message || content;
+      console.error('Failed to get the server extension settings', message);
+      throw new ServerConnection.ResponseError(response, message);
+    }
+    return content as Git.IServerSettings;
+  } catch (error) {
+    if (error instanceof ServerConnection.ResponseError) {
+      throw error;
+    } else {
+      throw new Error(error);
+    }
+  }
+}