libssh 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 639bee53286516a176e3e46c5646a93593405f3e
-  data.tar.gz: e934c062774b730c8a35a4b69ea075f9389af9d1
+  metadata.gz: 4aaa6647d6cc89439be59eeacbf35a3a21d72bf5
+  data.tar.gz: fe1ea02bf8d3405739187fddcfa2064486d5db98
 SHA512:
-  metadata.gz: 6e1596553a20bb479ebb3878fc1a2dbb968bbf9eb3fb3a4c6308ec85ce2e34ddd52770584b85764a8fde72260fb4ddec5da926923ae4a5da1e137d91fe1147b2
-  data.tar.gz: 4ba23660ed50cb0193df4bdac73134138fcb2dfe6bef6c84c00c4b883d81db8bc2ccd2f6b8ac3bb37e9281efb33b22a0bfde564b33b8ef7ce792063d0eb9cf31
+  metadata.gz: ded180b1cfe0766e45e2ddefd438db49c9ca8c2a4edf2dde1fe59453274010df4d7c3a9f038224d35345285d22a6c3b7a7836b1ffb6601119ce2aa3cb464c94a
+  data.tar.gz: 7b6fda7559baeeabe109e7ac30222335d52d930f752ae4542d51a81351d5e08e444fb48ad41826616d0b298dea8c67415e9d99f2c11b2a48d19c5e09d7a2e690

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.1 (2016-04-08)
+- Fix SSHKit::Backend::Libssh for SSHKit v1.9.0
+    - libssh now requires SSHKit v1.9.0 or later.
+
 ## 0.3.0 (2016-02-06)
 - Add wrapper methods
     - `Session#fd`

data/README.md

@@ -38,6 +38,7 @@ See [example](example) directory.
 See [example/sshkit.rb](example/sshkit.rb) .
 
 ### With Capistrano
+sshkit must be v1.9.0 or later due to [SSHKit::Backend::ConnectionPool API change](https://github.com/capistrano/sshkit/releases/tag/v1.9.0.rc1).
 
 ```ruby
 require 'sshkit/backends/libssh'

data/example/exec.rb

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
 require 'libssh'
-require 'io/wait'
 
 GC.stress = true
 puts "libssh #{LibSSH::LIBSSH_VERSION}"
@@ -39,28 +38,17 @@ end
 bufsiz = 16384
 
 channel = LibSSH::Channel.new(session)
-io = IO.for_fd(session.fd, autoclose: false)
 channel.open_session do
   channel.request_exec('ps auxf')
   until channel.eof?
-    io.wait_readable
-
-    loop do
-      out = channel.read_nonblocking(bufsiz)
-      if out && !out.empty?
-        $stdout.write(out)
-      else
-        break
-      end
+    LibSSH::Channel.select([channel], [], [], nil)
+    out = channel.read_nonblocking(bufsiz)
+    if out && !out.empty?
+      $stdout.write(out)
     end
-
-    loop do
-      err = channel.read_nonblocking(bufsiz, true)
-      if err && !err.empty?
-        $stderr.write(err)
-      else
-        break
-      end
+    err = channel.read_nonblocking(bufsiz, stderr: true)
+    if err && !err.empty?
+      $stderr.write(err)
     end
   end
 end

data/example/local_forward.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+require 'libssh'
+require 'socket'
+require 'thread'
+
+GC.stress = true
+
+ssh_host = 'rossmann'
+remote_host = 'localhost'
+remote_port = 5432
+local_port = 3000
+
+session = LibSSH::Session.new
+session.host = ssh_host
+session.parse_config
+session.add_identity('%d/id_ed25519')
+
+session.connect
+if session.server_known != LibSSH::SERVER_KNOWN_OK
+  raise 'server unknown'
+end
+if session.userauth_publickey_auto != LibSSH::AUTH_SUCCESS
+  raise 'authorization failed'
+end
+
+mutex = Mutex.new
+cv = ConditionVariable.new
+server_thread = Thread.start do
+  bufsiz = 16384
+  TCPServer.open(local_port) do |server|
+    mutex.synchronize { cv.signal }
+    socket = server.accept
+    channel = LibSSH::Channel.new(session)
+    channel.open_forward(remote_host, remote_port) do
+      reader = Thread.start do
+        begin
+          loop do
+            channel.write(socket.readpartial(bufsiz))
+          end
+        # rubocop:disable Lint/HandleExceptions
+        rescue EOFError
+        end
+        channel.send_eof
+      end
+
+      writer = Thread.start do
+        loop do
+          size = channel.poll
+          if size.nil?
+            break
+          end
+          data = channel.read(size)
+          socket.write(data)
+        end
+      end
+
+      reader.join
+      writer.join
+    end
+  end
+end
+
+mutex.synchronize { cv.wait(mutex) }
+system('psql', '-h', 'localhost', '-p', local_port.to_s, '-U', 'postgres', '-d', 'postgres', '-c', 'SELECT NOW()')
+server_thread.join

data/example/sshkit.rb

@@ -15,6 +15,8 @@ end
 SSHKit.config.output = SSHKit::Formatter::Pretty.new($stdout)
 SSHKit.config.output_verbosity = :debug
 
+include SSHKit::DSL
+
 on %w[barkhorn rossmann], in: :parallel do |host|
   date = capture(:date)
   puts "#{host}: #{date}"

data/ext/libssh_ruby/channel.c

@@ -105,34 +105,14 @@ static VALUE m_close(VALUE self) {
   return Qnil;
 }
 
-static void select_session(ssh_session session) {
-  fd_set fds;
-  int fd;
-
-  FD_ZERO(&fds);
-  fd = ssh_get_fd(session);
-  FD_SET(fd, &fds);
-  select(fd + 1, &fds, NULL, NULL, NULL);
-}
-
 static void *nogvl_open_session(void *ptr) {
   struct nogvl_channel_args *args = ptr;
-  ssh_session session = ssh_channel_get_session(args->channel);
-  int blocking = ssh_is_blocking(session);
-
-  ssh_set_blocking(session, 0);
-  while (1) {
-    args->rc = ssh_channel_open_session(args->channel);
-    if (args->rc != SSH_AGAIN) {
-      break;
-    }
-    rb_thread_check_ints();
-    select_session(session);
-  }
-  ssh_set_blocking(session, blocking);
+  args->rc = ssh_channel_open_session(args->channel);
   return NULL;
 }
 
+/* FIXME: When Channel#open_session is called before authorization,
+ * #open_session will block infinitely and unable to stop it by C-c. */
 /*
  * @overload open_session
  *  Open a session channel, and close it after the block.
@@ -162,6 +142,51 @@ static VALUE m_open_session(VALUE self) {
   }
 }
 
+struct nogvl_open_forward_args {
+  ssh_channel channel;
+  const char *remote_host;
+  int remote_port;
+  int rc;
+};
+
+static void *nogvl_open_forward(void *ptr) {
+  struct nogvl_open_forward_args *args = ptr;
+  args->rc = ssh_channel_open_forward(args->channel, args->remote_host,
+                                      args->remote_port, "localhost", 22);
+  return NULL;
+}
+
+/* FIXME: When Channel#open_forward is called before authorization,
+ * #open_session will block infinitely and unable to stop it by C-c. */
+/*
+ * @overload open_forward(remote_host, remote_port)
+ *  Open a TCP/IP forwarding channel.
+ *  @param [String] remote_host The remote host to connected.
+ *  @param [Fixnum] remote_port The remote port.
+ *  @return [nil]
+ *  @since 0.4.0
+ *  @see http://api.libssh.org/stable/group__libssh__channel.html
+ *    ssh_channel_open_forward
+ */
+static VALUE m_open_forward(VALUE self, VALUE remote_host, VALUE remote_port) {
+  ChannelHolder *holder;
+  struct nogvl_open_forward_args args;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  args.remote_host = StringValueCStr(remote_host);
+  Check_Type(remote_port, T_FIXNUM);
+  args.remote_port = FIX2INT(remote_port);
+  args.channel = holder->channel;
+  rb_thread_call_without_gvl(nogvl_open_forward, &args, RUBY_UBF_IO, NULL);
+  RAISE_IF_ERROR(args.rc);
+
+  if (rb_block_given_p()) {
+    return rb_ensure(rb_yield, Qnil, m_close, self);
+  } else {
+    return Qnil;
+  }
+}
+
 struct nogvl_request_exec_args {
   ssh_channel channel;
   char *cmd;
@@ -236,10 +261,10 @@ static void *nogvl_read(void *ptr) {
 }
 
 /*
- * @overload read(count, is_stderr: false, timeout: -1)
+ * @overload read(count, stderr: false, timeout: -1)
  *  Read data from a channel.
  *  @param [Fixnum] count The count of bytes to be read.
- *  @param [Boolean] is_stderr Read from the stderr flow or not.
+ *  @param [Boolean] stderr Read from the stderr flow or not.
  *  @param [Fixnum] timeout A timeout in seconds. +-1+ means infinite timeout.
  *  @return [String] Data read from the channel.
  *  @see http://api.libssh.org/stable/group__libssh__channel.html
@@ -333,7 +358,7 @@ static VALUE m_read_nonblocking(int argc, VALUE *argv, VALUE self) {
 
 /*
  * @overload eof?
- *  Check if remote ha sent an EOF.
+ *  Check if remote has sent an EOF.
  *  @return [Boolean]
  *  @see http://api.libssh.org/stable/group__libssh__channel.html
  *    ssh_channel_is_eof
@@ -345,6 +370,36 @@ static VALUE m_eof_p(VALUE self) {
   return ssh_channel_is_eof(holder->channel) ? Qtrue : Qfalse;
 }
 
+/*
+ * @overload closed?
+ *  Check if the channel is closed or not.
+ *  @return [Boolean]
+ *  @since 0.4.0
+ *  @see http://api.libssh.org/stable/group__libssh__channel.html
+ *    ssh_channel_is_closed
+ */
+static VALUE m_closed_p(VALUE self) {
+  ChannelHolder *holder;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  return ssh_channel_is_closed(holder->channel) ? Qtrue : Qfalse;
+}
+
+/*
+ * @overload open?
+ *  Check if the channel is open or not.
+ *  @return [Boolean]
+ *  @since 0.4.0
+ *  @see http://api.libssh.org/stable/group__libssh__channel.html
+ *    ssh_channel_is_open
+ */
+static VALUE m_open_p(VALUE self) {
+  ChannelHolder *holder;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  return ssh_channel_is_open(holder->channel) ? Qtrue : Qfalse;
+}
+
 struct nogvl_poll_args {
   ssh_channel channel;
   int timeout;
@@ -360,9 +415,9 @@ static void *nogvl_poll(void *ptr) {
 }
 
 /*
- * @overload poll(is_stderr: false, timeout: -1)
+ * @overload poll(stderr: false, timeout: -1)
  *  Poll a channel for data to read.
- *  @param [Boolean] is_stderr A boolean to select the stderr stream.
+ *  @param [Boolean] stderr A boolean to select the stderr stream.
  *  @param [Fixnum] timeout A timeout in milliseconds. A negative value means an
  *    infinite timeout.
  *  @return [Fixnum, nil] The number of bytes available for reading. +nil+ if
@@ -405,22 +460,12 @@ static VALUE m_poll(int argc, VALUE *argv, VALUE self) {
 
 static void *nogvl_get_exit_status(void *ptr) {
   struct nogvl_channel_args *args = ptr;
-  ssh_session session = ssh_channel_get_session(args->channel);
-  int blocking = ssh_is_blocking(session);
-
-  ssh_set_blocking(session, 0);
-  while (1) {
-    args->rc = ssh_channel_get_exit_status(args->channel);
-    if (args->rc != SSH_ERROR) {
-      break;
-    }
-    rb_thread_check_ints();
-    select_session(session);
-  }
-  ssh_set_blocking(session, blocking);
+  args->rc = ssh_channel_get_exit_status(args->channel);
   return NULL;
 }
 
+/* FIXME: When Channel#get_exit_status is called before #request_exec,
+ * #get_exit_status will block infinitely and unable to stop it by C-c. */
 /*
  * @overload get_exit_status
  *  Get the exit status of the channel.
@@ -502,6 +547,76 @@ static VALUE m_send_eof(VALUE self) {
   return Qnil;
 }
 
+struct nogvl_select_args {
+  ssh_channel *read_channels, *write_channels, *except_channels;
+  struct timeval *timeout;
+  int rc;
+};
+
+static void *nogvl_select(void *ptr) {
+  struct nogvl_select_args *args = ptr;
+  args->rc = ssh_channel_select(args->read_channels, args->write_channels,
+                                args->except_channels, args->timeout);
+  return NULL;
+}
+
+static void set_select_channels(ssh_channel **c_channels, VALUE rb_channels) {
+  long i, len;
+
+  Check_Type(rb_channels, T_ARRAY);
+  len = RARRAY_LEN(rb_channels);
+  if (len == 0) {
+    *c_channels = NULL;
+  } else {
+    for (i = 0; i < len; i++) {
+      Check_TypedStruct(RARRAY_AREF(rb_channels, i), &channel_type);
+    }
+    *c_channels = ALLOC_N(ssh_channel, len+1);
+    for (i = 0; i < len; i++) {
+      ChannelHolder *holder;
+      TypedData_Get_Struct(RARRAY_AREF(rb_channels, i), ChannelHolder,
+          &channel_type, holder);
+      (*c_channels)[i] = holder->channel;
+    }
+    (*c_channels)[len] = NULL;
+  }
+}
+
+/*
+ * @overload select(read_channels, write_channels, except_channels, timeout)
+ *  Act like the standard select(2) on channels.
+ *  @param [Array<Channel>] read_channels
+ *  @param [Array<Channel>] write_channels
+ *  @param [Array<Channel>] except_channels
+ *  @param [Fixnum, nil] timeout timeout in seconds.
+ *  @return [nil]
+ *  @see http://api.libssh.org/stable/group__libssh__channel.html
+ *    ssh_channel_select
+ */
+static VALUE s_select(RB_UNUSED_VAR(VALUE self), VALUE read_channels,
+                      VALUE write_channels, VALUE except_channels,
+                      VALUE timeout) {
+  struct nogvl_select_args args;
+  struct timeval tv;
+
+  if (NIL_P(timeout)) {
+    args.timeout = NULL;
+  } else {
+    Check_Type(timeout, T_FIXNUM);
+    tv.tv_sec = FIX2INT(timeout);
+    tv.tv_usec = 0;
+    args.timeout = &tv;
+  }
+  set_select_channels(&args.read_channels, read_channels);
+  set_select_channels(&args.write_channels, write_channels);
+  set_select_channels(&args.except_channels, except_channels);
+  rb_thread_call_without_gvl(nogvl_select, &args, RUBY_UBF_IO, NULL);
+  ruby_xfree(args.read_channels);
+  ruby_xfree(args.write_channels);
+  ruby_xfree(args.except_channels);
+  return Qnil;
+}
+
 /*
  * Document-class: LibSSH::Channel
  * Wrapper for ssh_channel struct in libssh.
@@ -518,6 +633,8 @@ void Init_libssh_channel(void) {
                    RUBY_METHOD_FUNC(m_initialize), 1);
   rb_define_method(rb_cLibSSHChannel, "open_session",
                    RUBY_METHOD_FUNC(m_open_session), 0);
+  rb_define_method(rb_cLibSSHChannel, "open_forward",
+                   RUBY_METHOD_FUNC(m_open_forward), 2);
   rb_define_method(rb_cLibSSHChannel, "close", RUBY_METHOD_FUNC(m_close), 0);
   rb_define_method(rb_cLibSSHChannel, "request_exec",
                    RUBY_METHOD_FUNC(m_request_exec), 1);
@@ -528,12 +645,17 @@ void Init_libssh_channel(void) {
                    RUBY_METHOD_FUNC(m_read_nonblocking), -1);
   rb_define_method(rb_cLibSSHChannel, "poll", RUBY_METHOD_FUNC(m_poll), -1);
   rb_define_method(rb_cLibSSHChannel, "eof?", RUBY_METHOD_FUNC(m_eof_p), 0);
+  rb_define_method(rb_cLibSSHChannel, "closed?", RUBY_METHOD_FUNC(m_closed_p), 0);
+  rb_define_method(rb_cLibSSHChannel, "open?", RUBY_METHOD_FUNC(m_open_p), 0);
   rb_define_method(rb_cLibSSHChannel, "get_exit_status",
                    RUBY_METHOD_FUNC(m_get_exit_status), 0);
   rb_define_method(rb_cLibSSHChannel, "write", RUBY_METHOD_FUNC(m_write), 1);
   rb_define_method(rb_cLibSSHChannel, "send_eof", RUBY_METHOD_FUNC(m_send_eof),
                    0);
 
+  rb_define_singleton_method(rb_cLibSSHChannel, "select",
+                             RUBY_METHOD_FUNC(s_select), 4);
+
   id_stderr = rb_intern("stderr");
   id_timeout = rb_intern("timeout");
 }

data/ext/libssh_ruby/extconf.rb

@@ -1,9 +1,21 @@
 require 'mkmf'
 
-$CFLAGS << ' -Wall -W'
+if ENV['LIBSSH_CFLAGS']
+  $CFLAGS = ENV['LIBSSH_CFLAGS']
+else
+  $CFLAGS << ' -Wall -W'
+end
+
+unless have_header('libssh/libssh.h')
+  abort 'Cannot find libssh/libssh.h'
+end
+unless have_library('ssh')
+  abort 'Cannot find libssh'
+end
+unless have_library('ssh_threads')
+  abort 'Cannot find libssh_threads'
+end
 
-have_header('libssh/libssh.h')
-have_library('ssh')
 have_const('SSH_KEYTYPE_ED25519', 'libssh/libssh.h')
 
 create_makefile('libssh/libssh_ruby')

data/ext/libssh_ruby/libssh_ruby.c

@@ -1,4 +1,5 @@
 #include "libssh_ruby.h"
+#include <libssh/callbacks.h>
 
 VALUE rb_mLibSSH;
 
@@ -26,6 +27,9 @@ static VALUE m_version(int argc, VALUE *argv, RB_UNUSED_VAR(VALUE self)) {
 }
 
 void Init_libssh_ruby(void) {
+  ssh_threads_set_callbacks(ssh_threads_get_pthread());
+  ssh_init();
+
   rb_mLibSSH = rb_define_module("LibSSH");
 
   /* @see Session#server_known */

data/lib/libssh/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module LibSSH
   # The version of libssh gem.
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.3.1'.freeze
 end

data/lib/sshkit/backends/libssh.rb

@@ -1,5 +1,4 @@
 require 'libssh'
-require 'io/wait'
 require 'sshkit/backends/abstract'
 require 'sshkit/backends/connection_pool'
 
@@ -53,8 +52,12 @@ module SSHKit
             scp.init do
               scp.push_file(File.basename(remote), io.size, mode)
               info "Uploading #{remote}"
-              while (buf = io.read(BUFSIZ))
-                scp.write(buf)
+              begin
+                loop do
+                  scp.write(io.readpartial(BUFSIZ))
+                end
+              # rubocop:disable Lint/HandleExceptions
+              rescue EOFError
               end
             end
           end
@@ -110,33 +113,24 @@ module SSHKit
 
         with_session do |session|
           channel = LibSSH::Channel.new(session)
-          io = IO.for_fd(session.fd, autoclose: false)
           channel.open_session do
             if Libssh.config.pty
               channel.request_pty
             end
             channel.request_exec(cmd.to_command)
             until channel.eof?
-              io.wait_readable
-
-              loop do
-                buf = channel.read_nonblocking(BUFSIZ)
-                if buf && !buf.empty?
-                  cmd.on_stdout(channel, buf)
-                  output.log_command_data(cmd, :stdout, buf)
-                else
-                  break
-                end
+              LibSSH::Channel.select([channel], [], [], nil)
+
+              buf = channel.read_nonblocking(BUFSIZ)
+              if buf && !buf.empty?
+                cmd.on_stdout(channel, buf)
+                output.log_command_data(cmd, :stdout, buf)
               end
 
-              loop do
-                buf = channel.read_nonblocking(BUFSIZ, true)
-                if buf && !buf.empty?
-                  cmd.on_stderr(channel, buf)
-                  output.log_command_data(cmd, :stderr, buf)
-                else
-                  break
-                end
+              buf = channel.read_nonblocking(BUFSIZ, stderr: true)
+              if buf && !buf.empty?
+                cmd.on_stderr(channel, buf)
+                output.log_command_data(cmd, :stderr, buf)
               end
             end
 
@@ -182,30 +176,26 @@ module SSHKit
         end
       end
 
-      def with_session
+      def with_session(&block)
         host.ssh_options = Libssh.config.ssh_options.merge(host.ssh_options || {})
-        entry = self.class.pool.checkout(String(host.hostname), host.username, host.netssh_options) do |hostname, username, ssh_options|
-          LibSSH::Session.new.tap do |session|
-            session.host = hostname
-            username = ssh_options.fetch(:user, username)
-            if username
-              session.user = username
-            end
-            configure_session(session, ssh_options)
-            session.connect
-            if session.server_known != LibSSH::SERVER_KNOWN_OK
-              raise 'unknown host'
-            end
-            if session.userauth_publickey_auto != LibSSH::AUTH_SUCCESS
-              raise 'authorization failed'
-            end
-          end
-        end
+        self.class.pool.with(method(:create_session), String(host.hostname), host.username, host.netssh_options, &block)
+      end
 
-        begin
-          yield entry.connection
-        ensure
-          self.class.pool.checkin(entry)
+      def create_session(hostname, username, ssh_options)
+        LibSSH::Session.new.tap do |session|
+          session.host = hostname
+          username = ssh_options.fetch(:user, username)
+          if username
+            session.user = username
+          end
+          configure_session(session, ssh_options)
+          session.connect
+          if session.server_known != LibSSH::SERVER_KNOWN_OK
+            raise 'unknown host'
+          end
+          if session.userauth_publickey_auto != LibSSH::AUTH_SUCCESS
+            raise 'authorization failed'
+          end
         end
       end
 

data/libssh.gemspec

@@ -26,6 +26,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake-compiler'
   spec.add_development_dependency 'rspec', '>= 3.0.0'
   spec.add_development_dependency 'rubocop', '>= 0.36.0'
-  spec.add_development_dependency 'sshkit'
+  spec.add_development_dependency 'sshkit', '>= 1.9.0'
   spec.add_development_dependency 'yard'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libssh
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Kohei Suzuki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-06 00:00:00.000000000 Z
+date: 2016-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.9.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.9.0
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -130,6 +130,7 @@ files:
 - bin/console
 - bin/setup
 - example/exec.rb
+- example/local_forward.rb
 - example/scp_download.rb
 - example/scp_upload.rb
 - example/sshkit.rb
@@ -167,7 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.1
 signing_key: 
 specification_version: 4
 summary: Ruby binding for libssh.