Streamline login

Merge the login and open commands (open aliased to login).  Add login
tests described in #352.

Attempt to improve user experience by synchronously executing
`ein:jupyter-server-start`.  `ein:dev-prefer-deferred` custom variable
allows easy switch to compare sychronous versus old asynchronous behavior.

Author: dickmao

.travis.yml

@@ -37,4 +37,4 @@ before_script:
   - sh tools/install-cask.sh
 
 script:
-  - make test || ( ( zip -q - log/{testein,testfunc,ecukes}.* 2>/dev/null | uuencode log.zip ) && false )
+  - make test || ( ( zip -q - log/{testein,testfunc,ecukes}.* 2>/dev/null | uuencode log.zip ) && ( printf "To diagnose, travis logs -i | dos2unix | sed '/^begin 644/,/^end/!d' | uudecode" ) && false )

Makefile

@@ -4,8 +4,8 @@ IPY_VERSION = 5.8.0
 SRC=$(shell cask files)
 ELCFILES = $(SRC:.el=.elc)
 
-.PHONY: loaddefs
-loaddefs:
+.PHONY: autoloads
+autoloads:
 	sh tools/update-autoloads.sh
 
 .PHONY: clean
@@ -16,15 +16,21 @@ env-ipy.%:
 	tools/makeenv.sh env/ipy.$* tools/requirement-ipy.$*.txt
 
 .PHONY: test-compile
-test-compile: clean
+test-compile: clean autoloads
 	! ( cask build 2>&1 | awk '{if (/^ /) { gsub(/^ +/, " ", $$0); printf "%s", $$0 } else { printf "\n%s", $$0 }}' | egrep "not known|Error|free variable" )
 	-cask clean-elc
 
+.PHONY: quick
+quick: test-compile test-unit
+
 .PHONY: test-no-build
-test-no-build: test-unit test-int
+test-no-build: test-unit test-int autoloads
+
+.PHONY: quick
+quick: test-compile test-unit
 
 .PHONY: test
-test: test-compile test-unit test-int
+test: quick test-int
 
 .PHONY: test-int
 test-int:

features/login.feature

@@ -0,0 +1,4 @@
+@login
+Scenario: Logging into nowhere
+Given I login to 0
+Then I should see message "demoted: (error Connection refused: [error] http://127.0.0.1:0)"

features/notebooklist.feature

@@ -34,13 +34,30 @@ Scenario: Global notebooks
   And I switch to log expr "ein:log-all-buffer-name"
   Then I should see "Opened notebook"
 
-@foo
-Scenario: notebooklist-open works interactively (should be same notebooklist as server-start)
-  Given I am in buffer "*scratch*"
-  When I clear log expr "ein:log-all-buffer-name"
+@login
+Scenario: No token server
+  Given I start the server configured "c.NotebookApp.token = u''\n"
+  And I switch to log expr "ein:log-all-buffer-name"
+  Then I should not see "[warn]"
+  And I should not see "[error]"
+
+@login
+Scenario: With token server
+  Given I start the server configured "\n"
   And I login if necessary
-  And I open notebooklist
-  And I wait for the smoke to clear
   And I switch to log expr "ein:log-all-buffer-name"
   Then I should not see "[warn]"
   And I should not see "[error]"
+
+@login
+Scenario: With password server
+  Given I start the server configured "c.NotebookApp.password=u'sha1:712118ed6c09:bc02227d84b76b720cc320b855e1006d0b120f98'\n"
+  And I login with password "foo"
+  And I switch to log expr "ein:log-all-buffer-name"
+  Then I should not see "[warn]"
+  And I should not see "[error]"
+
+@login
+Scenario: Logging into nowhere
+  Given I login to 0
+  Then I should see message "demoted: (error Connection refused: [error] http://127.0.0.1:0)"

features/step-definitions/ein-steps.el

@@ -1,8 +1,10 @@
 (When "^I clear log expr \"\\(.+\\)\"$"
       (lambda (log-expr)
-        (with-current-buffer (symbol-value (intern log-expr))
-          (let ((inhibit-read-only t))
-            (erase-buffer)))))
+        (let ((buffer (get-buffer (symbol-value (intern log-expr)))))
+          (when (buffer-live-p buffer)
+            (with-current-buffer buffer
+              (let ((inhibit-read-only t))
+                (erase-buffer)))))))
 
 (When "^I switch to log expr \"\\(.+\\)\"$"
       (lambda (log-expr)
@@ -15,40 +17,76 @@
           (sit-for 0.8)
           )))
 
-(When "^I wait \\([.0-9]+\\) seconds$"
+(When "^I wait \\([.0-9]+\\) seconds?$"
       (lambda (seconds)
         (sit-for (string-to-number seconds))))
 
 (When "^I am in log buffer$"
       (lambda ()
         (switch-to-buffer ein:log-all-buffer-name)))
 
+(defun ein:testing-new-notebook (url-or-port ks)
+  (lexical-let (notebook)
+    (condition-case err
+        (progn
+          (ein:notebooklist-new-notebook url-or-port ks nil
+                                         (lambda (nb created &rest ignore)
+                                           (setq notebook nb)))
+          (ein:testing-wait-until (lambda () 
+                                    (and notebook
+                                         (ein:aand (ein:$notebook-kernel notebook)
+                                                   (ein:kernel-live-p it))))
+                                  nil 10000 2000)
+          notebook)
+      (error (message "ein:testing-new-notebook: %s" (error-message-string err))
+             (when notebook
+               (ein:notebook-close notebook))
+             nil))))
+
 (When "^new \\(.+\\) notebook$"
       (lambda (kernel)
         (multiple-value-bind (url-or-port token) (ein:jupyter-server-conn-info)
-          (lexical-let ((ks (ein:get-kernelspec url-or-port kernel)) notebook)
-            (ein:notebooklist-new-notebook url-or-port ks nil
-                (lambda (nb created &rest ignore)
-                  (setq notebook nb)))
-            (ein:testing-wait-until (lambda () (and notebook
-                                                    (ein:aand (ein:$notebook-kernel notebook)
-                                                              (ein:kernel-live-p it))))
-                                    nil 10000 2000)
-            (let ((buf-name (format ein:notebook-buffer-name-template
-                                    (ein:$notebook-url-or-port notebook)
-                                    (ein:$notebook-notebook-name notebook))))
-              (switch-to-buffer buf-name)
-              (Then "I should be in buffer \"%s\"" buf-name))))))
-
-(When "^I open notebooklist"
-      (lambda ()
-        (multiple-value-bind (url-or-port token) (ein:jupyter-server-conn-info)
-          (cl-letf (((symbol-function 'ein:notebooklist-ask-url-or-port)
-                     (lambda (&rest args) url-or-port)))
-            (When "I call \"ein:notebooklist-open\"")
+          (with-current-buffer (ein:notebooklist-get-buffer url-or-port)
+            (lexical-let ((ks (ein:get-kernelspec url-or-port kernel)) notebook)
+              (loop repeat 2
+                    until notebook
+                    do (setq notebook (ein:testing-new-notebook url-or-port ks)))
+              (let ((buf-name (format ein:notebook-buffer-name-template
+                                      (ein:$notebook-url-or-port notebook)
+                                      (ein:$notebook-notebook-name notebook))))
+                (switch-to-buffer buf-name)
+                (Then "I should be in buffer \"%s\"" buf-name)))))))
+
+(When "^I start \\(and login to \\)?the server configured \"\\(.*\\)\"$"
+      (lambda (login config)
+        (cl-letf (((symbol-function 'y-or-n-p) #'ignore))
+          (ein:jupyter-server-stop t))
+        (loop repeat 10
+              with buffer = (get-buffer ein:jupyter-server-buffer-name)
+              until (null (get-buffer-process buffer))
+              do (sleep-for 1) 
+              finally do (ein:aif (get-buffer-process buffer) (delete-process it)))
+        (When "I clear log expr \"ein:log-all-buffer-name\"")
+        (When "I clear log expr \"ein:jupyter-server-buffer-name\"")
+        (clrhash ein:notebooklist-map)
+        (with-temp-file ".ecukes-temp-config.py" (insert (s-replace "\\n" "\n" config)))
+        (setq ein:jupyter-server-args '("--no-browser" "--debug" "--config=.ecukes-temp-config.py"))
+        (ein:jupyter-server-start (executable-find "jupyter") 
+                                  ein:testing-jupyter-server-root (not login))
+        (if login
+            (ein:testing-wait-until (lambda () (ein:notebooklist-list)) nil 20000 1000))))
+
+(When "^I login to \\([.0-9]+\\)$"
+      (lambda (port)
+        (cl-letf (((symbol-function 'ein:notebooklist-ask-url-or-port)
+                   (lambda (&rest args) (ein:url port)))
+                  ((symbol-function 'read-passwd)
+                   (lambda (&rest args) "foo")))
+          (with-demoted-errors "demoted: %s"
+            (When "I call \"ein:notebooklist-login\"")
             (And "I wait for the smoke to clear")))))
 
-(When "^I login if necessary"
+(When "^I login if necessary$"
       (lambda ()
         (multiple-value-bind (url-or-port token) (ein:jupyter-server-conn-info)
           (when token
@@ -59,15 +97,15 @@
               (When "I call \"ein:notebooklist-login\"")
               (And "I wait for the smoke to clear"))))))
 
-(When "^I wait for the smoke to clear"
-      (lambda ()
-        (ein:testing-flush-queries)))
-
-(When "^I enter the prevailing port"
-      (lambda ()
+(When "^I login with password \"\\(.+\\)\"$"
+      (lambda (password)
         (multiple-value-bind (url-or-port token) (ein:jupyter-server-conn-info)
-          (let ((parsed-url (url-generic-parse-url url-or-port)))
-            (When "I type \"%d\"") (url-port parsed-url)))))
+          (cl-letf (((symbol-function 'ein:notebooklist-ask-url-or-port)
+                     (lambda (&rest args) url-or-port))
+                    ((symbol-function 'read-passwd)
+                     (lambda (&rest args) password)))
+            (When "I call \"ein:notebooklist-login\"")
+            (And "I wait for the smoke to clear")))))
 
 (When "^I wait for the smoke to clear"
       (lambda ()

features/support/env.el

@@ -14,11 +14,10 @@
 (require 'ein-testing)
 
 (defvar ein:testing-jupyter-server-root (f-parent (f-dirname load-file-name)))
-(ein:deflocal ein:%testing-port% nil)
 
 (defun ein:testing-after-scenario ()
   (ein:testing-flush-queries)
-  (with-current-buffer (ein:notebooklist-get-buffer ein:%testing-url%)
+  (with-current-buffer (ein:notebooklist-get-buffer (car (ein:jupyter-server-conn-info)))
     (let ((urlport (ein:$notebooklist-url-or-port ein:%notebooklist%)))
       (loop for notebook in (ein:notebook-opened-notebooks)
             for path = (ein:$notebook-notebook-path notebook)
@@ -35,20 +34,15 @@
  (setq ein:testing-dump-file-messages (concat default-directory "log/ecukes.messages"))
  (setq ein:testing-dump-file-server  (concat default-directory  "log/ecukes.server"))
  (setq ein:testing-dump-file-request  (concat default-directory "log/ecukes.request"))
- (setq ein:jupyter-server-args '("--no-browser" "--debug"))
- (setq ein:%testing-url% nil)
- (deferred:sync! (ein:jupyter-server-start (executable-find "jupyter") ein:testing-jupyter-server-root))
- (ein:testing-wait-until (lambda () (ein:notebooklist-list)) nil 20000 1000)
- (assert (processp %ein:jupyter-server-session%) t "notebook server defunct")
- (setq ein:%testing-url% (car (ein:jupyter-server-conn-info))))
+ (Given "I start and login to the server configured \"\\n\"")
+)
 
 (After
  (ein:testing-after-scenario))
 
 (Teardown
  (cl-letf (((symbol-function 'y-or-n-p) #'ignore))
-   (ein:jupyter-server-stop t))
- (assert (not (processp %ein:jupyter-server-session%)) t "notebook server orphaned"))
+   (ein:jupyter-server-stop t)))
 
 (Fail
  (if noninteractive

lisp/ein-core.el

@@ -66,6 +66,14 @@ Notebook server."
                  (const :tag "First value of `ein:url-or-port'" nil))
   :group 'ein)
 
+(defcustom ein:jupyter-default-server-command "jupyter"
+  "The default command to start a jupyter notebook server.
+
+It is used when the `ein:jupyter-server-start' command is
+interactively called."
+  :group 'ein
+  :type '(file))
+
 (defcustom ein:filename-translations nil
   "Convert file paths between Emacs and Python process.
 
@@ -136,6 +144,44 @@ the source is in git repository."
 (defvar *ein:kernelspecs* (make-hash-table :test #'equal)
   "url-or-port to kernelspecs")
 
+(defun ein:need-password-required (url-or-port)
+  "Synchronously test whether URL-OR-PORT requires a password."
+  (lexical-let* (answer 
+                 done-p
+                 error-p
+                 (callback1 (lambda (ans) (setf answer ans) (setf done-p t)))
+                 (callback-err (lambda (status) (setf error-p status))))
+    (ein:query-singleton-ajax
+     (list 'need-password-required url-or-port)
+     (ein:url url-or-port "login")
+     ;; request--safe-apply swallowing errors -- so that's why error-p
+     :error (apply-partially #'ein:need-password-required--error url-or-port callback-err)
+     :type "POST"
+     :parser #'ignore
+     :success (apply-partially #'ein:need-password-required--success url-or-port callback1)
+     :complete (apply-partially #'ein:need-password-required--complete url-or-port))
+    (loop repeat 30
+          until done-p
+          if error-p
+            do (error "Connection refused: [%s] %s" error-p url-or-port)
+          end
+          do (sleep-for 0 300))
+    answer))
+
+(defun* ein:need-password-required--error (url-or-port callback &key symbol-status &allow-other-keys)
+  (funcall callback symbol-status))
+
+(defun* ein:need-password-required--success (url-or-port callback &key data response &allow-other-keys)
+  (when callback
+    (let ((explicitly-dont-need 
+           (ein:aand (request-response-status-code response) (= 405 it))))
+      (funcall callback (not explicitly-dont-need)))))
+
+(defun* ein:need-password-required--complete (url-or-port &key data response
+                                                          &allow-other-keys 
+                                                          &aux (resp-string (format "STATUS: %s DATA: %s" (request-response-status-code response) data)))
+  (ein:log 'debug "ein:need-password-required--complete %s" resp-string))
+
 (defun ein:need-kernelspecs (url-or-port)
   "Callers assume ein:query-kernelspecs succeeded.  If not, nil."
   (ein:aif (gethash url-or-port *ein:kernelspecs*) it

lisp/ein-dev.el

@@ -32,6 +32,11 @@
 (require 'ein-notebook)
 (require 'ein-subpackages)
 
+(defcustom ein:dev-prefer-deferred nil
+  "Deferred chains have unpredictable and often delayed timings.  For some user interactions, it may be preferable to act synchronously."
+  :group 'ein
+  :type 'boolean)
+
 ;;;###autoload
 (defun ein:dev-insert-mode-map (map-string)
   "Insert mode-map into rst document.  For README.rst."

lisp/ein-ipynb-mode.el

@@ -26,8 +26,7 @@
 
 ;;; Code:
 
-(require 'ein-notebooklist)
-
+(require 'ein-process)
 
 (defvar ein:ipynb-parent-mode 'js-mode
   "A mode (a symbol) to use for parent mode for `ein:ipynb-mode'.
@@ -39,13 +38,15 @@ Note that this variable must be set *before* compiling EIN.")
 (define-derived-mode ein:ipynb-mode ein:ipynb-parent-mode "ein:ipynb"
   "A simple mode for ipynb file.")
 
+;; TODO replace ignore with ein:process-find-file-callback in the
+;; eagerly awaited "without-notebooklist" branch
 (let ((map ein:ipynb-mode-map))
-  (define-key map "\C-c\C-z" 'ein:notebooklist-open-notebook-by-file-name)
-  (define-key map "\C-c\C-o" 'ein:notebooklist-open-notebook-by-file-name)
+  (define-key map "\C-c\C-z" 'ignore)
+  (define-key map "\C-c\C-o" 'ignore)
   (easy-menu-define ein:ipynb-menu map "EIN IPyNB Mode Menu"
     `("EIN IPyNB File"
       ,@(ein:generate-menu
-         '(("Open notebook" ein:notebooklist-open-notebook-by-file-name))))))
+         '(("Open notebook" ignore))))))
 
 ;;;###autoload
 (add-to-list 'auto-mode-alist '(".*\\.ipynb\\'" . ein:ipynb-mode))

lisp/ein-junk.el

@@ -42,6 +42,33 @@ format string which can be passed to `format-time-string'."
 `ein:junk-notebook-name-template'."
   (format-time-string ein:junk-notebook-name-template (current-time)))
 
+;;;###autoload
+(defun ein:junk-new (name kernelspec url-or-port)
+  "Open a notebook to try random thing.
+Notebook name is determined based on
+`ein:junk-notebook-name-template'.
+
+When prefix argument is given, it asks URL or port to use."
+  (interactive (let* ((name (ein:junk-notebook-name))
+                      (url-or-port (or (ein:get-url-or-port)
+                                       (ein:default-url-or-port)))
+                      (kernelspec (completing-read
+                                   "Select kernel [default]: "
+                                   (ein:list-available-kernels url-or-port) nil t nil nil "default" nil)))
+                 (setq name (read-string "Open notebook as: " name))
+                 (when current-prefix-arg
+                   (setq url-or-port (ein:notebooklist-ask-url-or-port)))
+                 (list name url-or-port)
+                 (ein:notebooklist-new-notebook-with-name name kernelspec url-or-port))))
+
+;;;###autoload
+(defun ein:junk-rename (name)
+  "Rename the current notebook based on `ein:junk-notebook-name-template'
+and save it immediately."
+  (interactive
+   (list (read-string "Rename notebook: "
+                      (ein:junk-notebook-name))))
+  (ein:notebook-rename-command name))
 
 (define-obsolete-function-alias 'ein:notebooklist-new-scratch-notebook
   'ein:junk-new)