simple_gate 0.5.5

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,126 @@
+= 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.4
+
+* Fixed gemspec: add missing spec files and added missing gem dependencies
+* Updated Rakefile with ruby 1.9 workaround and a missing file spotter
+
+=== Version 0.5.3
+
+* Added yardoc documentation to all classes.
+* SimpleGate#through raises an error when no gates are chosen
+* SimpleGate#through uses local variables instead of instance variables
+* ServerDefinition#options is created on the fly
+
+=== Version 0.5.2
+
+* Added -V verbose flag to gate_cp
+* Use STDERR for status messages. STDOUT is used to output SSH responses
+* Updated executables to support direct server connections
+* SimpleGate#through_to can connect directly to a server without gateways
+
+=== 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,49 @@
+require "rake"
+require "rake/clean"
+require "rake/gempackagetask"
+require 'rubygems'
+
+################################################################################
+### Gem
+################################################################################
+
+begin
+  # Parse gemspec using the github safety level.
+  file = Dir['*.gemspec'].first
+  data = File.read(file)
+  spec = nil
+  # FIXME: Lowered SAFE from 3 to 2 to work with Ruby 1.9 due to rubygems
+  # performing a require internally
+  Thread.new { spec = eval("$SAFE = 2\n%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\n%s", e.class.name, e.message, e.backtrace[0...5].map {|l| '  %s' % l}.join("\n")
+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
+
+desc 'Show files missing from gemspec'
+task :diff do
+  files = %w[
+    Rakefile
+    *README*
+    *LICENSE*
+    *.gemspec
+    bin/*
+    lib/**/*
+    spec/**/*
+  ].map {|pattern| Dir.glob(pattern)}.flatten.select{|f| File.file?(f)}
+  missing_files = files - spec.files
+  extra_files = spec.files - files
+  puts "File missing from the gemspec:"
+  puts missing_files.join(" ")
+  puts "Extra files not (yet) in the gemspec:"
+  puts extra_files.join(" ")
+end

data/bin/gate_cp

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# Copy a single local file to a remote server.
+#   Syntax: gate_cp [-V] <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
+#     Set -V for verbose output.
+#
+#   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'
+
+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
+  STDERR.puts "No command was given"
+  exit 1
+end
+
+router = Router.new(connections)
+route = router.find(from, target)
+if route.nil?
+  STDERR.puts "No route to #{target}"
+  exit 1
+end
+
+route.shift if route.first == 'local'
+
+source = File.expand_path(ARGV.shift.to_s.strip)
+target = ARGV.shift.to_s.strip
+
+STDERR.puts "Connecting to #{route.last}, using #{route.size - 1} gateway(s)" if verbose
+
+gate = SimpleGate.new(:verbose=>verbose)
+gate.through_to(route) do |ssh|
+  STDERR.puts "Transferring: #{source} => #{target}" if verbose
+  ssh.sftp.upload!(source, target)
+end
+

data/bin/simple_gate

@@ -0,0 +1,56 @@
+#!/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
+  STDERR.puts "No command was given"
+  exit 1
+end
+
+router = Router.new(connections)
+route = router.find(from, target)
+if route.nil?
+  STDERR.puts "No route to #{target}"
+  exit 1
+end
+
+route.shift if route.first == 'local'
+
+STDERR.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.rb

@@ -0,0 +1,87 @@
+require 'rubygems'
+require 'net/ssh'
+require 'net/ssh/gateway'
+require 'activesupport'
+require 'simple_gate/server_definition'
+
+class SimpleGate
+  # Initialize a new SimpleGate
+  # @param [Hash] options Hash with options to configure SimpleGate. Defaults to set :verbose to false.
+  def initialize(options={})
+    @options = {
+      :verbose => false
+    }.merge(options)
+  end
+
+  # Is the verbose option turned on?
+  def verbose?
+    @options[:verbose]
+  end
+
+  # Connect through a list of gateways to a target server.
+  # Treats the last 'gateway' as the target server and the others as gateways.
+  #
+  # @param [Array] *gateways A list of gateway server names that can be found using ServerDefinition.find(). Should have at least one server name.
+  # @yieldparam [Net::SSH::Connection::Session] session SSH Session to the target server.
+  # @raise [ArgumentError] When no gateways are chosen.
+  def through_to(*gateways)
+    gateways = gateways.flatten
+    raise ArgumentError.new("No target chosen") if gateways.size == 0
+    target = ServerDefinition.find(gateways.pop)
+    if gateways.size == 0
+      target.connection_info do |host, user, options|
+        Net::SSH.start(host,user,options) do |session|
+          yield(session)
+        end
+      end
+      return
+    end
+    through(gateways) do |gate|
+      target.connection_info do |host, user, options|
+        gate.ssh(host, user, options) do |session|
+          yield(session)
+        end
+      end
+    end
+    nil
+  end
+
+  # Establish a series of gateways and yields the last one created.
+  # Will automatically shut down gateway connections when the block closes.
+  #
+  # Most of the code was taken from Capistrano and then changed to work
+  # outside of Capistrano.
+  #
+  # @param [Array] *gateways A list of gateway server names that can be found using ServerDefinition.find(). Should have at least one server name.
+  # @yieldparam [Net::SSH::Gateway] gateway Gateway object of the last tunnel endpoint.
+  # @raise [ArgumentError] When no gateways are chosen.
+  def through(*gateways)
+    Thread.abort_on_exception = true
+    open_connections = []
+    gateways = gateways.flatten.collect { |g| ServerDefinition.find(g) }
+    raise ArgumentError.new("No target chosen") if gateways.size == 0
+    tunnel = gateways[0].connection_info do |host, user, connect_options|
+      STDERR.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|
+      STDERR.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|
+        STDERR.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/lib/simple_gate/router.rb

@@ -0,0 +1,50 @@
+class Router
+  # Graph of server connections.
+  attr_accessor :paths
+
+  # Create a new Router for a network of interconnected servers.
+  # An example connections graph with three servers 'foo', 'bar' and 'baz':
+  #
+  #   router = Router.new
+  #   # Define a graph: foo -> bar -> baz
+  #   router.paths = {
+  #     'foo' => %w[bar],
+  #     'bar' => %w[baz]
+  #   }
+  #   router.find('foo', 'baz') #=> ['foo', 'bar', 'baz']
+  # @param [Hash] paths 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.
+  def initialize(paths={})
+    @paths = paths
+  end
+
+  # A simple recursive pathfinder.
+  # Uses a very naieve depth-first recursive full-graph search to
+  # find the shortest route.
+  # @param [String] start The node to start searching from for +target+.
+  # @param [String] target The node to look for. Once it is found, return the shortest route to it.
+  # @param [Array] current_route Internal variable that holds the route so far. Helps in preventing cyclic routes from being checked an infinite amount of times.
+  # @return [Array] The sequence of nodes that connect +start+ to +target+.
+  # @return [nil] When no route was found.
+  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,99 @@
+require 'yaml'
+class ServerDefinition
+  attr_accessor :host, :user, :port, :password, :auth_methods
+
+  # Create a new ServerDefinition.
+  #
+  # @param [String] host Name of server.
+  # @param [Hash] options Override the server's own configuration.
+  # @option options [Integer] port (22) Server port
+  # @option options [String] user SSH user
+  # @option options [String] password SSH password
+  def initialize(host, options = {})
+    self.host = host
+    self.user = options[:user]
+    self.password = options[:password]
+    self.port = options[:port] || 22
+    self.auth_methods = options[:auth_methods] || %w[password keyboard-interactive]
+  end
+
+  # SSH options
+  # @return [Hash]
+  def options
+    {
+      :user => user,
+      :password => password,
+      :port => port,
+      :auth_methods => auth_methods
+    }
+  end
+
+  # Yield connection information.
+  # @yieldparam [String] host SSH host
+  # @yieldparam [String] user SSH user
+  # @yieldparam [Hash] options SSH connection options
+  # @see ServerDefinition#initialize
+  # @see ServerDefinition#ssh_options
+  def connection_info(&block)
+    block.call(host, user, options)
+  end
+
+  # Represent server definition as URL-like string
+  # @return [String]
+  def to_s
+    "#{user}:#{'*' * password.to_s.size}@#{host}:#{port}"
+  end
+
+  # Factory method that uses pre-defined server configurations.
+  # @return [ServerDefinition]
+  def self.lookup(server)
+    server = servers[server]
+    new(server['address'],{
+      :user => server['username'],
+      :password => server['password'],
+      :port => server['port']
+    })
+  end
+
+  # Factory method that chooses between a lookup and parse.
+  # @param [String] server Server name or ssh string
+  # @return [ServerDefinition]
+  # @see ServerDefinition.lookup
+  # @see ServerDefinition.parse
+  def self.find(server)
+    servers.has_key?(server) ? lookup(server) : parse(server)
+  end
+
+  # Factory method that parses a connection string.
+  # @param [String] ssh_string String formatted as "user:password@host:port"
+  # @return [ServerDefinition]
+  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.
+    # @return [Hash] Server name to server configuration pairs.
+    def servers
+      @servers ||= YAML.load_file(File.expand_path('~/.servers.yml'))
+    end
+  end
+end

data/simple_gate.gemspec

@@ -0,0 +1,38 @@
+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.5'
+  s.date         = '2010-03-29'
+  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 simple_gate/router]
+  other_files    = %w[spec/spec_helper.rb]
+  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 + other_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"
+  s.add_dependency 'net-ssh', ">= 2.0.0"
+  s.add_dependency 'net-ssh-gateway', ">= 1.0.0"
+  s.add_dependency 'activesupport', ">= 2.2.0"
+end

data/spec/simple_gate/router_spec.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'simple_gate/router'
+
+describe Router do
+  describe "#find" do
+    it "should find a direct path from start to target" do
+      router = Router.new({
+        'start' => %w[target]
+      })
+      router.find('start','target').should == %w[start target]
+    end
+
+    it "should find a path from start to target through an intermediate node" do
+      router = Router.new({
+        'start' => %w[node],
+        'node' => %w[target],
+      })
+      router.find('start','target').should == %w[start node target]
+    end
+
+    it "should find the shortest path from start to target" do
+      router = Router.new({
+        'start' => %w[node node2 node3],
+        'node' => %w[node2],
+        'node2' => %w[node3],
+        'node3' => %w[target]
+      })
+      router.find('start','target').should == %w[start node3 target]
+    end
+
+    it 'should return nil if no route could be found' do
+      router = Router.new({
+        'start' => %w[],
+      })
+      router.find('start','target').should be_nil
+    end
+
+    it 'should return nil if the starting point can not be found' do
+      router = Router.new({})
+      router.find('start','target').should be_nil
+    end
+
+    it 'should not cause a stack overflow in a cyclical route graph' do
+      router = Router.new({
+        'start' => %w[node],
+        'node' => %w[node target],
+      })
+      lambda {
+        router.find('start','target').should == %w[start node target]
+      }.should_not raise_error(SystemStackError)
+    end
+  end
+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

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+lib_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(lib_dir)

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: simple_gate
+version: !ruby/object:Gem::Version 
+  version: 0.5.5
+platform: ruby
+authors: 
+- Wes Oldenbeuving
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-29 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: net-ssh-gateway
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.0
+    version: 
+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
+- spec/simple_gate/router_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://www.github.com/Narnach/simple_gate
+licenses: []
+
+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.3.5
+signing_key: 
+specification_version: 3
+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
+- spec/simple_gate/router_spec.rb