dizby 1.3.0

data/lib/dizby/tunnel/abstract.rb

@@ -0,0 +1,52 @@
+
+require 'net/ssh'
+
+module Dizby
+  class AbstractTunnel
+    def initialize(server, strategy, user, host)
+      @server = server
+      @config = [user, host, @server.config[:ssh_config]]
+      @strategy = strategy
+
+      reader, writer = IO.pipe
+
+      @thread = Thread.start do
+        open_ssh(writer)
+        writer.close
+      end
+
+      @thread.abort_on_exception = true
+
+      read_ports(reader)
+      reader.close
+    end
+
+    # wait(ssh) is not defined in this class
+    def open_ssh(output)
+      ssh = nil
+      begin
+        ssh = Net::SSH.start(*@config)
+
+        get_and_write_ports(ssh, output)
+
+        wait(ssh)
+      ensure
+        ssh.close if ssh
+      end
+    end
+
+    def read_ports(input)
+      @local_port, @remote_port = @strategy.read(input)
+    end
+
+    def get_and_write_ports(ssh, output)
+      @strategy.write(ssh, output)
+    end
+
+    def close
+      @thread.join
+    end
+
+    attr_reader :local_port, :remote_port
+  end
+end

data/lib/dizby/tunnel/basic.rb

@@ -0,0 +1,21 @@
+
+require 'dizby/tunnel/abstract'
+
+module Dizby
+  class BasicTunnel < AbstractTunnel
+    def initialize(server, strategy, user, host)
+      @working = true
+
+      super(server, strategy, user, host)
+    end
+
+    def wait(ssh)
+      ssh.loop { @working }
+    end
+
+    def close # TODO: test this
+      @working = false
+      super
+    end
+  end
+end

data/lib/dizby/tunnel/basic_spawn.rb

@@ -0,0 +1,50 @@
+
+require 'dizby/tunnel/abstract'
+require 'dizby/error'
+
+module Dizby
+  class BasicSpawnTunnel < AbstractTunnel
+    def initialize(server, strategy, command, user, host)
+      @command = command
+
+      super(server, strategy, user, host)
+    end
+
+    def get_and_write_ports(ssh, output)
+      @command.set_dynamic_mode unless @tunnel.server_port
+
+      @channel = ssh.open_channel do |ch|
+        ch.exec @command.to_cmd do |_, success|
+          fail SpawnError, 'could not spawn host' unless success
+
+          # it is already triggered if the port is set
+          get_remote_server_port(ch) if @command.dynamic?
+        end
+      end
+
+      ssh.loop { !@channel[:triggered] } if @command.dynamic?
+      @channel.eof!
+
+      super
+    end
+
+    def get_remote_server_port(ch)
+      ch[:data] = ''
+      ch[:triggered] = false
+
+      ch.on_data { |_, data| ch[:data] << data }
+      ch.on_extended_data { |_, _, data| @server.log(data.inspect) }
+
+      ch.on_process do |_|
+        if !ch[:triggered] && ch[:data] =~ /Running on port (\d+)\./
+          @strategy.instance_variable_set(:@server_port, $~[1])
+          ch[:triggered] = true
+        end
+      end
+    end
+
+    def wait(ssh)
+      ssh.loop { @channel.active? }
+    end
+  end
+end

data/lib/dizby/tunnel/bidirectional_strategy.rb

@@ -0,0 +1,29 @@
+
+require 'dizby/tunnel/tunnelable_local'
+require 'dizby/tunnel/tunnelable_remote'
+
+module Dizby
+  class BidirectionalTunnelStrategy
+    include TunnelableLocal
+    include TunnelableRemote
+
+    def initialize(server_port, client_port)
+      @server_port = server_port
+      @client_port = client_port
+    end
+
+    def write(ssh, stream)
+      local_tunnel = create_local_tunnel(ssh, @server_port)
+      remote_tunnel = create_remote_tunnel(ssh, @client_port)
+
+      stream.puts local_tunnel, remote_tunnel
+    end
+
+    def read(stream)
+      local_tunnel = stream.gets.chomp.to_i
+      remote_tunnel = stream.gets.chomp.to_i
+
+      [local_tunnel, remote_tunnel]
+    end
+  end
+end

data/lib/dizby/tunnel/factory.rb

@@ -0,0 +1,29 @@
+
+require 'dizby/tunnel/local_strategy'
+require 'dizby/tunnel/bidirectional_strategy'
+require 'dizby/utility/semi_built'
+
+module Dizby
+  class TunnelFactory
+    def initialize(server, port)
+      @server = server
+      @port = port
+    end
+
+    def create(type)
+      SemibuiltObject.new(type, @server, strategy)
+    end
+
+    def bidirectional?
+      @server.respond_to?(:port)
+    end
+
+    def strategy
+      if bidirectional?
+        BidirectionalTunnelStrategy.new(@port, @server.port)
+      else
+        LocalTunnelStrategy.new(@port)
+      end
+    end
+  end
+end

data/lib/dizby/tunnel/local_strategy.rb

@@ -0,0 +1,24 @@
+
+require 'dizby/tunnel/tunnelable_local'
+
+module Dizby
+  class LocalTunnelStrategy
+    include TunnelableLocal
+
+    def initialize(server_port)
+      @server_port = server_port
+    end
+
+    def write(ssh, stream)
+      local_tunnel = create_local_tunnel(ssh, @server_port)
+
+      stream.puts local_tunnel
+    end
+
+    def read(stream)
+      local_tunnel = stream.gets.chomp.to_i
+
+      [local_tunnel, nil]
+    end
+  end
+end

data/lib/dizby/tunnel/spawn_command.rb

@@ -0,0 +1,49 @@
+
+require 'shellwords'
+
+module Dizby
+  class SpawnCommand
+    TEMPLATE = "require'dizby/tunnel/spawned';Dizby::Spawned.%s('%s',%s){%s}"
+
+    def initialize(data, config = {})
+      @data = data
+      @ruby_cmd = 'ruby'
+      @uri = 'drb://'
+      @config = config
+      @mode = :static
+    end
+
+    def set_dynamic_mode
+      @mode = :dynamic
+    end
+
+    def dynamic?
+      @mode == :dynamic
+    end
+
+    attr_accessor :ruby_cmd, :config, :uri
+
+    def to_cmd
+      # TODO: needs a lot of work...
+      args = [@mode, @uri.shellescape, @config.inspect, @data.shellescape]
+      [@ruby_cmd, '-e', %("#{TEMPLATE % args}")].join ' '
+    end
+    alias_method :to_s, :to_cmd
+
+    class << self
+      def text(script)
+        new(script)
+      end
+
+      def local_file(file)
+        new(File.read(file))
+      end
+
+      # WARNING: Dangerous operation. This loads an object from a file on the
+      # remote machine. That file may be insecure or modified without notice.
+      def remote_file(file, obj_name)
+        new("load '#{file}'; #{obj_name}")
+      end
+    end
+  end
+end

data/lib/dizby/tunnel/spawned.rb

@@ -0,0 +1,43 @@
+
+# require the whole package, minimizes command length
+require 'dizby'
+require 'dizby/utility/io_barrier'
+
+module Dizby
+  class Spawned
+    def self.static(uri, config, &block)
+      handle_spawned(uri, config, block)
+    end
+
+    def self.dynamic(uri, config, &block)
+      handle_spawned(uri, config, block) do |service|
+        $stdout.puts "Running on port #{service.server.port}."
+      end
+    end
+
+    def self.handle_spawned(uri, config, origin)
+      service = nil
+
+      obj = obtain_object(&origin)
+
+      obj.define_singleton_method :__dizby_exit__ do
+        service.close if service
+      end
+
+      service = Service.new(uri, obj, Marshal.load(config))
+      yield service if block_given?
+    ensure
+      service.wait if service
+    end
+
+    def self.obtain_object(&origin)
+      barriers = [$stdout, $stdin, $stderr].map { |io| IOBarrier.new(io) }
+
+      barriers.each(&:block)
+
+      origin.call
+    ensure
+      barriers.each(&:allow)
+    end
+  end
+end

data/lib/dizby/tunnel/tunnelable_local.rb

@@ -0,0 +1,8 @@
+
+module Dizby
+  module TunnelableLocal
+    def create_local_tunnel(ssh, server_port)
+      ssh.forward.local 0, 'localhost', server_port
+    end
+  end
+end

data/lib/dizby/tunnel/tunnelable_remote.rb

@@ -0,0 +1,21 @@
+
+module Dizby
+  module TunnelableRemote
+    def create_remote_tunnel(ssh, client_port)
+      remote_tunnel_port = nil
+      ssh.forward.remote client_port, 'localhost',
+                         0, 'localhost' do |remote_port|
+        remote_tunnel_port = remote_port
+        :no_exception
+      end
+
+      ssh.loop { remote_tunnel_port.nil? }
+
+      if remote_tunnel_port == :error
+        fail Net::SSH::Exception, 'remote forwarding request failed'
+      end
+
+      remote_tunnel_port
+    end
+  end
+end

data/lib/dizby/utility/classic_access.rb

@@ -0,0 +1,25 @@
+
+module Dizby
+  module ClassicAttributeAccess
+    def attr_reader(*args)
+      args.each do |method|
+        define_method(method) do
+          instance_variable_get(:"@#{method}")
+        end
+      end
+    end
+
+    def attr_writer(*args)
+      args.each do |method|
+        define_method("#{method}=") do |value|
+          instance_variable_set(:"@#{method}", value)
+        end
+      end
+    end
+
+    def attr_accessor(*args)
+      attr_reader(*args)
+      attr_writer(*args)
+    end
+  end
+end

data/lib/dizby/utility/configurable.rb

@@ -0,0 +1,25 @@
+
+module Dizby
+  module Configurable
+    def config_reader(*args)
+      args.each do |method|
+        define_method(method) do
+          instance_variable_get(:@config)[method]
+        end
+      end
+    end
+
+    def config_writer(*args)
+      args.each do |method|
+        define_method("#{method}=") do |value|
+          instance_variable_get(:@config)[method] = value
+        end
+      end
+    end
+
+    def config_accessor(*args)
+      config_reader(*args)
+      config_writer(*args)
+    end
+  end
+end

data/lib/dizby/utility/delegator.rb

@@ -0,0 +1,28 @@
+
+module Dizby
+  class Delegator
+    def initialize(obj)
+      @__delegated_object__ = obj
+    end
+
+    def instance_variable_get(sym)
+      @__delegated_object__.instance_variable_get(sym)
+    end
+
+    def instance_variable_set(sym, value)
+      @__delegated_object__.instance_variable_set(sym, value)
+    end
+
+    def __undelegated_get__(sym)
+      __instance_variable_get__(sym)
+    end
+
+    def __undelegated_set__(sym, value)
+      __instance_variable_set__(sym, value)
+    end
+
+    def method_missing(name, *args, &block)
+      @__delegated_object__.__delegate__(name, self, *args, &block)
+    end
+  end
+end

data/lib/dizby/utility/io_barrier.rb

@@ -0,0 +1,18 @@
+
+module Dizby
+  class IOBarrier
+    def initialize(var)
+      @var = var
+      @orig = var.dup
+    end
+
+    def block
+      @var.reopen(File::NULL)
+    end
+
+    def allow
+      @var.reopen(@orig)
+      @var.sync = true
+    end
+  end
+end

data/lib/dizby/utility/log.rb

@@ -0,0 +1,23 @@
+
+require 'logger'
+
+module Dizby
+  def self.create_logger(config, &transformer)
+    log = Logger.new(config[:output])
+
+    default_formatter = Logger::Formatter.new
+    log.formatter = proc do |severity, datetime, progname, msg|
+      msg = transformer.call(msg) if transformer
+      default_formatter.call(severity, datetime, progname, msg)
+    end
+
+    log.level = config[:level]
+
+    log.define_singleton_method(:backtrace) do |exception|
+      error(exception.inspect)
+      exception.backtrace.each { |trace| error(trace) }
+    end
+
+    log
+  end
+end