1 ;;; GNU Guix --- Functional package management for GNU
2 ;;; Copyright © 2016, 2017 Ludovic Courtès <ludo@gnu.org>
4 ;;; This file is part of GNU Guix.
6 ;;; GNU Guix is free software; you can redistribute it and/or modify it
7 ;;; under the terms of the GNU General Public License as published by
8 ;;; the Free Software Foundation; either version 3 of the License, or (at
9 ;;; your option) any later version.
11 ;;; GNU Guix is distributed in the hope that it will be useful, but
12 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
13 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 ;;; GNU General Public License for more details.
16 ;;; You should have received a copy of the GNU General Public License
17 ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
19 (define-module (guix ssh)
20 #:use-module (guix store)
21 #:use-module ((guix ui) #:select (G_ N_))
22 #:use-module (ssh session)
23 #:use-module (ssh auth)
24 #:use-module (ssh key)
25 #:use-module (ssh channel)
26 #:use-module (ssh popen)
27 #:use-module (ssh session)
28 #:use-module (ssh dist)
29 #:use-module (ssh dist node)
30 #:use-module (srfi srfi-11)
31 #:use-module (srfi srfi-34)
32 #:use-module (srfi srfi-35)
33 #:use-module (ice-9 match)
34 #:use-module (ice-9 binary-ports)
35 #:export (open-ssh-session
37 connect-to-remote-daemon
46 ;;; This module provides tools to support communication with remote stores
47 ;;; over SSH, using Guile-SSH.
52 "zlib@openssh.com,zlib")
54 (define* (open-ssh-session host #:key user port
55 (compression %compression))
56 "Open an SSH session for HOST and return it. When USER and PORT are #f, use
57 default values or whatever '~/.ssh/config' specifies; otherwise use them.
58 Throw an error on failure."
59 (let ((session (make-session #:user user
63 ;; #:log-verbosity 'protocol
65 ;; We need lightweight compression when
66 ;; exchanging full archives.
67 #:compression compression
68 #:compression-level 3)))
70 ;; Honor ~/.ssh/config.
71 (session-parse-config! session)
73 (match (connect! session)
75 ;; Use public key authentication, via the SSH agent if it's available.
76 (match (userauth-public-key/auto! session)
83 (message (format #f (G_ "SSH authentication failed for '~a': ~a~%")
84 host (get-error session)))))))))
86 ;; Connection failed or timeout expired.
89 (message (format #f (G_ "SSH connection to '~a' failed: ~a~%")
90 host (get-error session))))))))))
92 (define* (remote-daemon-channel session
95 "/var/guix/daemon-socket/socket"))
96 "Return an input/output port (an SSH channel) to the daemon at SESSION."
98 ;; Code run in SESSION to redirect the remote process' stdin/stdout to the
99 ;; daemon's socket, à la socat. The SSH protocol supports forwarding to
100 ;; Unix-domain sockets but libssh doesn't have an API for that, hence this
103 (use-modules (ice-9 match) (rnrs io ports))
105 (let ((sock (socket AF_UNIX SOCK_STREAM 0))
106 (stdin (current-input-port))
107 (stdout (current-output-port)))
108 (setvbuf stdin _IONBF)
109 (setvbuf stdout _IONBF)
110 (connect sock AF_UNIX ,socket-name)
113 (match (select (list stdin sock) '() (list stdin stdout sock))
115 (when (memq stdin reads)
116 (match (get-bytevector-some stdin)
120 (put-bytevector sock bv))))
121 (when (memq sock reads)
122 (match (get-bytevector-some sock)
126 (put-bytevector stdout bv))))
129 (primitive-exit 1)))))))
131 (open-remote-pipe* session OPEN_BOTH
132 ;; Sort-of shell-quote REDIRECT.
135 (object->string redirect))))
137 (define* (connect-to-remote-daemon session
140 "/var/guix/daemon-socket/socket"))
141 "Connect to the remote build daemon listening on SOCKET-NAME over SESSION,
142 an SSH session. Return a <nix-server> object."
143 (open-connection #:port (remote-daemon-channel session)))
146 (define (store-import-channel session)
147 "Return an output port to which archives to be exported to SESSION's store
149 ;; Using the 'import-paths' RPC on a remote store would be slow because it
150 ;; makes a round trip every time 32 KiB have been transferred. This
151 ;; procedure instead opens a separate channel to use the remote
152 ;; 'import-paths' procedure, which consumes all the data in a single round
153 ;; trip. This optimizes the successful case at the expense of error
154 ;; conditions: errors can only be reported once all the input has been
158 (use-modules (guix) (srfi srfi-34)
159 (rnrs io ports) (rnrs bytevectors))
161 (define (consume-input port)
162 (let ((bv (make-bytevector 32768)))
164 (let ((n (get-bytevector-n! port bv 0
165 (bytevector-length bv))))
166 (unless (eof-object? n)
169 ;; Upon completion, write an sexp that denotes the status.
173 (guard (c ((nix-protocol-error? c)
174 ;; Consume all the input since the only time we can
175 ;; report the error is after everything has been
177 (consume-input (current-input-port))
178 (list 'protocol-error (nix-protocol-error-message c))))
180 (setvbuf (current-input-port) _IONBF)
181 (import-paths store (current-input-port))
184 (cons 'error args))))))
186 (open-remote-pipe session
189 ,(object->string (object->string import))))
192 (define* (store-export-channel session files
194 "Return an input port from which an export of FILES from SESSION's store can
195 be read. When RECURSIVE? is true, the closure of FILES is exported."
196 ;; Same as above: this is more efficient than calling 'export-paths' on a
203 (setvbuf (current-output-port) _IONBF)
205 ;; FIXME: Exceptions are silently swallowed. We should report them
207 (export-paths store ',files (current-output-port)
208 #:recursive? ,recursive?))))
210 (open-remote-input-pipe session
214 (object->string export))))))
216 (define* (send-files local files remote
219 (log-port (current-error-port)))
220 "Send the subset of FILES from LOCAL (a local store) that's missing to
221 REMOTE, a remote store. When RECURSIVE? is true, send the closure of FILES.
222 Return the list of store items actually sent."
223 ;; Compute the subset of FILES missing on SESSION and send them.
224 (let* ((files (if recursive? (requisites local files) files))
225 (session (channel-get-session (nix-server-socket remote)))
226 (node (make-node session))
227 (missing (node-eval node
230 (srfi srfi-1) (srfi srfi-26))
233 (remove (cut valid-path? store <>)
235 (count (length missing))
236 (port (store-import-channel session)))
237 (format log-port (N_ "sending ~a store item to '~a'...~%"
238 "sending ~a store items to '~a'...~%" count)
239 count (session-get session 'host))
241 ;; Send MISSING in topological order.
242 (export-paths local missing port)
244 ;; Tell the remote process that we're done. (In theory the end-of-archive
245 ;; mark of 'export-paths' would be enough, but in practice it's not.)
246 (channel-send-eof port)
248 ;; Wait for completion of the remote process and read the status sexp from
250 (let* ((result (false-if-exception (read port)))
251 (status (zero? (channel-get-exit-status port))))
256 (('protocol-error message)
258 (&nix-protocol-error (message message) (status 42)))))
259 (('error key args ...)
262 (message (call-with-output-string
264 (print-exception port #f key args))))
269 (message "unknown error while sending files over SSH")
272 (define (remote-store-session remote)
273 "Return the SSH channel beneath REMOTE, a remote store as returned by
274 'connect-to-remote-daemon', or #f."
275 (channel-get-session (nix-server-socket remote)))
277 (define (remote-store-host remote)
278 "Return the name of the host REMOTE is connected to, where REMOTE is a
279 remote store as returned by 'connect-to-remote-daemon'."
280 (match (remote-store-session remote)
282 ((? session? session)
283 (session-get session 'host))))
285 (define* (file-retrieval-port files remote
287 "Return an input port from which to retrieve FILES (a list of store items)
288 from REMOTE, along with the number of items to retrieve (lower than or equal
289 to the length of FILES.)"
290 (values (store-export-channel (remote-store-session remote) files
291 #:recursive? recursive?)
292 (length files))) ;XXX: inaccurate when RECURSIVE? is true
294 (define* (retrieve-files local files remote
295 #:key recursive? (log-port (current-error-port)))
296 "Retrieve FILES from REMOTE and import them using the 'import-paths' RPC on
297 LOCAL. When RECURSIVE? is true, retrieve the closure of FILES."
298 (let-values (((port count)
299 (file-retrieval-port files remote
300 #:recursive? recursive?)))
301 (format #t (N_ "retrieving ~a store item from '~a'...~%"
302 "retrieving ~a store items from '~a'...~%" count)
303 count (remote-store-host remote))
304 (when (eof-object? (lookahead-u8 port))
305 ;; The failure could be because one of the requested store items is not
306 ;; valid on REMOTE, or because Guile or Guix is improperly installed.
307 ;; TODO: Improve error reporting.
312 (G_ "failed to retrieve store items from '~a'")
313 (remote-store-host remote)))))))
315 (let ((result (import-paths local port)))
319 ;;; ssh.scm ends here