Narnach-simple_gate 0.5.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Wes Oldenbeuving
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,107 @@
+= SimpleGate
+
+SimpleGate makes it possible to use net/ssh/gateway's capabilities in a simple
+to use way. This makes it possible to write simple scripts that access servers that are located several hops inside a network.
+
+The core gateway chaining logic was taken from Capistrano, but it has been
+rewritten to be useful in a more generic way than Capistrano allows.
+
+SimpleGate's Router class makes it possible to automatically find a route
+through a maze of servers instead of having to manually define gateway chains.
+An added benefit is that a change to one server's connections no longer
+requires you to update all other servers if they relied on it as a gateway.
+
+SimpleGate is simple, meaning it does not (yet) do fancy things such as using
+~/.ssh. Because of this, you'll have to define ~/.servers.yml and add entries
+to configure your servers. To use the routing functionality used by the
+gate_cp and simple_gate executables, you have to define routes in
+~/.servers.connections.yml
+
+An example configuration for the servers 'foobar' and 'barfoo' would look be:
+
+  ---
+  foobar:
+    address: "127.0.0.1"
+    username: "foo"
+    password: "bar
+    port: 22
+  barfoo:
+    address: "192.168.0.1"
+    username: "bar"
+    password: "foo
+    port: 22
+
+Example of a ~/.servers.connections.yml file:
+
+  ---
+  local:
+  - foo
+  foo:
+  - bar
+  - baz
+  bar:
+  - foobar
+  - foobaz
+  - barbaz
+
+All keys are names of servers defined in ~/.servers.yml. The only special node
+is "local", which is the starting point for all connections and not a real
+connection.
+
+== Recent changes
+
+=== Version 0.5.1
+
+* Updated readme and simple_gate documentation
+* Implemented infinite loop prevention code in Router#find
+* Cleaned up Router#find to be more readable
+* Added spec to show stack overflow occurs when a cyclical graph is used to
+  find a route
+* Added specs for Router#find
+* Added a -V (verbose) flag option to simple_gate
+* Removed empty method definition
+
+=== Version 0.5.0
+
+* Added syntax explanation to gate_cp
+* Added gate_cp, which copies one local file to a remote destination
+
+=== Version 0.4.1
+
+* simple_gate is now executable
+
+=== Version 0.4.0
+
+* Updated readme with version history for previous gem versions
+* Added simple_gate executable to use SimpleGate's new Router class to find a path to a server and execute a command there.
+
+=== Version 0.3.0
+
+* Readme now has a project description and updated credits for a bit of Capistrano code
+* Added mutator and documentation for ServerDefinition.servers
+* Updated comment to make more sense
+
+=== Version 0.2.0
+
+* Implemented SimpleGate#through_to, which establishes a real ssh session through a number of gateways
+
+=== Version 0.1.0
+
+* Removed simple_gate executable
+* Imported SimpleGate and ServerDefinition
+
+=== Version 0.0.1
+* Created project
+
+== Installation
+=== From git
+From the project root, use rake to install.
+  git clone http://github.com/Narnach/simple_gate
+  cd simple_gate
+  rake install
+This will build the gem and install it for you.
+
+== About
+simple_gate was created by Wes Oldenbeuving. It is licensed under the MIT license.
+
+SimpleGate#through is based on GatewayConnectionFactory#initialize, which is part of Jamis Buck's Capistrano and is also licensed under the MIT license.

data/Rakefile

@@ -0,0 +1,29 @@
+require "rake"
+require "rake/clean"
+require "rake/gempackagetask"
+require 'rubygems'
+
+################################################################################
+### Gem
+################################################################################
+
+begin
+  # Parse gemspec using the github safety level.
+  data = File.read('simple_gate.gemspec')
+  spec = nil
+  Thread.new { spec = eval("$SAFE = 3
+%s" % data)}.join
+
+  # Create the gem tasks
+  Rake::GemPackageTask.new(spec) do |package|
+    package.gem_spec = spec
+  end
+rescue Exception => e
+  printf "WARNING: Error caught (%s): %s
+", e.class.name, e.message
+end
+
+desc 'Package and install the gem for the current version'
+task :install => :gem do
+  system "sudo gem install -l pkg/%s-%s.gem" % [spec.name, spec.version]
+end

data/bin/gate_cp

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# Copy a single local file to a remote server.
+#   Syntax: gate_cp <server> <source_file> <target_file>
+#     server: a server listed in ~/.servers.yml and reachable by a
+#             series of connections described in ~/.servers.connections.yml
+#     source_file: filename or full path+filename of local source file
+#     target_file: filename or full path+filename of target file
+#
+#   Example: gate_cp foobar ~/foo.txt foo.txt
+#     This copies ~/foo.txt too the server foobar as foo.txt in the home dir
+#
+#   Example: gate_cp foobar foo.txt /tmp/bar.txt
+#     This copies the local file foo.txt too the server foobar as /tmp/foo.txt
+require 'simple_gate'
+require 'simple_gate/router'
+require 'net/sftp'
+
+connections = YAML.load_file(File.expand_path('~/.servers.connections.yml'))
+from = 'local'
+target = ARGV.shift.to_s.strip
+
+cmd = ARGV.join(" ")
+if cmd.strip.size == 0
+  puts "No command was given"
+  exit 1
+end
+
+router = Router.new(connections)
+route = router.find(from, target)
+if route.nil?
+  puts "No route to #{target}"
+  exit 1
+end
+
+route.shift if route.first == 'local'
+
+if route.size==1
+  puts "No gateway needed to reach #{route.last}"
+  exit 2
+end
+
+source = File.expand_path(ARGV.shift.to_s.strip)
+target = ARGV.shift.to_s.strip
+
+puts "Connecting to #{route.last}, using #{route.size - 1} gateway(s)"
+
+gate = SimpleGate.new
+gate.through_to(route) do |ssh|
+  puts "Transferring: #{source} => #{target}"
+  ssh.sftp.upload!(source, target)
+end
+

data/bin/simple_gate

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# Syntax: simple_gate [-V] <server> <command>
+#   Finds a route to <server>, uses the neccesary gates to connect to it and
+#   executes <command> on that server. Set -V for verbose output.
+#
+# Uses ~/.servers.connections.yml and ~/.servers.yml to find the fastest path
+# from the local server to a target server, establish a series of gateways
+# and then execute a command on the remote server.
+# Example of a ~/.servers.connections.yml file:
+#
+#   ---
+#   local:
+#   - foo
+#   foo:
+#   - bar
+#   - baz
+#   bar:
+#   - foobar
+#   - foobaz
+#   - barbaz
+#
+# All keys are names of servers defined in ~/.servers.yml. The only special
+# node is "local", which is the starting point for all connections and not a
+# real connection.
+
+require 'simple_gate'
+require 'simple_gate/router'
+
+verbose = !ARGV.delete('-V').nil?
+
+connections = YAML.load_file(File.expand_path('~/.servers.connections.yml'))
+from = 'local'
+target = ARGV.shift.to_s.strip
+
+cmd = ARGV.join(" ")
+if cmd.strip.size == 0
+  puts "No command was given"
+  exit 1
+end
+
+router = Router.new(connections)
+route = router.find(from, target)
+if route.nil?
+  puts "No route to #{target}"
+  exit 1
+end
+
+route.shift if route.first == 'local'
+
+if route.size==1
+  puts "No gateway needed to reach #{route.last}"
+  exit 2
+end
+
+puts "Executing '#{cmd}' in #{route.last}, using #{route.size - 1} gateway(s)" if verbose
+
+gate = SimpleGate.new(:verbose=>verbose)
+gate.through_to(route) do |ssh|
+  puts ssh.exec!(cmd)
+end
+

data/lib/simple_gate/router.rb

@@ -0,0 +1,42 @@
+class Router
+  # Graph of server connections. 
+  # It's a Hash of Arrays, which contains strings. Keys are server names with
+  # a connection to other servers. Each of these servers is a string in the
+  # associated Array.
+  # An example graph with three servers 'foo', 'bar' and 'baz'.
+  #
+  #   router = Router.new
+  #   router.paths = {
+  #     'foo' => %w[bar],
+  #     'bar' => ['baz']
+  #   }
+  #   router.find('foo', 'baz') #=> ['foo', 'bar', 'baz']
+  attr_accessor :paths
+
+  def initialize(paths={})
+    @paths = paths
+  end
+
+  # A simple pathfinder. Returns a route as Array or nil.
+  # Uses a very naieve depth-first recursive full-graph search to
+  # find the shortest route.
+  def find(start, target, current_route = [])
+    return [target] if start == target
+    return nil unless paths.has_key?(start)
+
+    # Map all possible paths to the target.
+    # Skip nodes we have already visited
+    next_nodes = paths[start] - current_route
+    routes = next_nodes.map do |next_node|
+      find(next_node, target, current_route + [start])
+    end
+
+    # Reduce the collection to the shortest path
+    shortest_route = routes.compact.inject(nil) {|shortest,possibility|
+      next possibility if shortest.nil?
+      possibility.size < shortest.size ? possibility : shortest
+    }
+    return [start] + shortest_route if shortest_route
+    nil
+  end
+end

data/lib/simple_gate/server_definition.rb

@@ -0,0 +1,83 @@
+require 'yaml'
+class ServerDefinition
+  attr_accessor :host, :user, :options, :port, :password
+  
+  def initialize(host, options = {})
+    @options = {:port => 22}.merge(options)
+    self.host = host
+    self.user = @options[:user]
+    self.password = @options[:password]
+    self.port = @options[:port]
+  end
+  
+  def user=(user)
+    options[:user] = user
+    @user=user
+  end
+
+  def port=(port)
+    options[:port] = port
+    @port=port
+  end
+
+  def password=(password)
+    options[:password] = password
+    @password=password
+  end
+
+  def connection_info(&block)
+    block.call(host, user, options.merge(ssh_options))
+  end
+  
+  def ssh_options
+    {
+      :auth_methods => %w[password keyboard-interactive]
+    }
+  end
+  
+  def to_s
+    "#{user}:#{'*' * password.to_s.size}@#{host}:#{port}"
+  end
+  
+  def self.lookup(server)
+    server = servers[server]
+    new(server['address'],{ 
+      :user => server['username'],
+      :password => server['password'], 
+      :port => server['port']
+    })
+  end
+  
+  def self.find(server)
+    servers.has_key?(server) ? lookup(server) : parse(server)
+  end
+  
+  def self.parse(ssh_string)
+    user, password, host, port = ssh_string.match /\A(.*?):(.*?)@(.*?):(\d*?)\Z/
+    new(host, :user => user, :password => password, :port => port)
+  end
+
+  class << self
+    attr_accessor :servers
+
+    # Access the pre-configured servers. ~/.servers.yml is parsed for this.
+    # An example entry for the servers 'foobar' and 'barfoo' would look like:
+    #   ---
+    #   foobar:
+    #     address: "127.0.0.1"
+    #     username: "foo"
+    #     password: "bar
+    #     port: 22
+    #   barfoo:
+    #     address: "192.168.0.1"
+    #     username: "bar"
+    #     password: "foo
+    #     port: 22
+    #
+    # Since the parsed Hash of servers is cached, a value can be stored and
+    # the configuration file ignored if desired.
+    def servers
+      @servers ||= YAML.load_file(File.expand_path('~/.servers.yml'))
+    end
+  end
+end

data/lib/simple_gate.rb

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'net/ssh'
+require 'net/ssh/gateway'
+require 'activesupport'
+require 'simple_gate/server_definition'
+
+class SimpleGate
+  def initialize(options={})
+    @options = {
+      :verbose => false
+    }.merge(options)
+  end
+
+  def verbose?
+    @options[:verbose]
+  end
+
+  # Connect through a list of gateways to the real server.
+  # Treats the last 'gateway' as the real server and the others as gateways.
+  # Needs at least one real gateway and a real server.
+  def through_to(*gateways) # :yields: ssh session
+    gateways = gateways.flatten
+    raise ArgumentError.new("Need at least 2 servers") if gateways.size < 2
+    target = ServerDefinition.find(gateways.pop)
+    through(gateways) do |gate|
+      target.connection_info do |host, user, options|
+        gate.ssh(host, user, options) do |session|
+          yield(session)
+        end
+      end
+    end
+  end
+
+  # Most of the code was taken from Capistrano and then changed to work
+  # outside of Capistrano.
+  def through(*gateways)
+    Thread.abort_on_exception = true
+    @open_connections ||= []
+    @gateways = gateways.flatten.collect { |g| ServerDefinition.find(g) }
+    tunnel = @gateways[0].connection_info do |host, user, connect_options|
+      puts "Setting up tunnel #{@gateways[0]}" if verbose?
+      gw = Net::SSH::Gateway.new(host, user, connect_options)
+      @open_connections << gw
+      gw
+    end
+    @gateway = (@gateways[1..-1]).inject(tunnel) do |tunnel, destination|
+      puts "Connecting to #{destination}" if verbose?
+      tunnel_port = tunnel.open(destination.host, (destination.port || 22))
+      localhost_options = {:user => destination.user, :port => tunnel_port, :password => destination.password}
+      local_host = ServerDefinition.new("127.0.0.1", localhost_options)
+      local_host.connection_info do |host, user, connect_options|
+        puts "Connecting using local info #{local_host}" if verbose?
+        gw = Net::SSH::Gateway.new(host, user, connect_options)
+        @open_connections << gw
+        gw
+      end
+    end
+    yield(@gateway)
+  ensure
+    while g = @open_connections.pop
+      g.shutdown!
+    end
+  end
+end

data/simple_gate.gemspec

@@ -0,0 +1,34 @@
+Gem::Specification.new do |s|
+  # Project
+  s.name         = 'simple_gate'
+  s.summary      = "SimpleGate makes it possible to use net/ssh/gateway's capabilities in a simple to use way."
+  s.description  = s.summary
+  s.version      = '0.5.1'
+  s.date         = '2009-04-18'
+  s.platform     = Gem::Platform::RUBY
+  s.authors      = ["Wes Oldenbeuving"]
+  s.email        = "narnach@gmail.com"
+  s.homepage     = "http://www.github.com/Narnach/simple_gate"
+
+  # Files
+  root_files     = %w[MIT-LICENSE README.rdoc Rakefile simple_gate.gemspec]
+  bin_files      = %w[simple_gate gate_cp]
+  lib_files      = %w[simple_gate
+                      simple_gate/server_definition
+                      simple_gate/router]
+  test_files     = %w[]
+  spec_files     = %w[simple_gate]
+  s.bindir       = "bin"
+  s.require_path = "lib"
+  s.executables  = bin_files
+  s.test_files   = test_files.map {|f| 'test/%s_test.rb' % f} + spec_files.map {|f| 'spec/%s_spec.rb' % f}
+  s.files        = root_files + bin_files.map {|f| 'bin/%s' % f} + lib_files.map {|f| 'lib/%s.rb' % f} + s.test_files
+
+  # rdoc
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w[ README.rdoc MIT-LICENSE]
+  s.rdoc_options << '--inline-source' << '--line-numbers' << '--main' << 'README.rdoc'
+
+  # Requirements
+  s.required_ruby_version = ">= 1.8.0"
+end

data/spec/simple_gate_spec.rb

@@ -0,0 +1,6 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'simple_gate'
+
+describe SimpleGate do
+  it 'should be tested'
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: Narnach-simple_gate
+version: !ruby/object:Gem::Version 
+  version: 0.5.1
+platform: ruby
+authors: 
+- Wes Oldenbeuving
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-18 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: SimpleGate makes it possible to use net/ssh/gateway's capabilities in a simple to use way.
+email: narnach@gmail.com
+executables: 
+- simple_gate
+- gate_cp
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- simple_gate.gemspec
+- bin/simple_gate
+- bin/gate_cp
+- lib/simple_gate.rb
+- lib/simple_gate/server_definition.rb
+- lib/simple_gate/router.rb
+- spec/simple_gate_spec.rb
+has_rdoc: true
+homepage: http://www.github.com/Narnach/simple_gate
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --line-numbers
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: SimpleGate makes it possible to use net/ssh/gateway's capabilities in a simple to use way.
+test_files: 
+- spec/simple_gate_spec.rb