aaalex-cloudy_integrate 0.0.1

data/bin/cloudy_integrate

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+ 
+require 'getoptlong'
+require 'rubygems'
+require 'rake'
+require 'net/ssh'
+
+require 'cloudy_integrate'
+
+
+include CloudyIntegrate
+
+USAGE = "USAGE: cloudy_integrate [options] [command] (try cloudy_integrate --help)"
+ 
+HELP = <<-end_doc
+cloudy_integrate - virtually integrate an EC2 instance into your local network
+ 
+USAGE: cloudy_integrate [options] [command]
+ 
+COMMANDS:
+#{CloudyIntegrate::Session.commands_with_description.map{|method, desc| " %-17s %s" % [method, desc]}.join("\n")}
+The default command is "list"
+
+OPTIONS:
+  --help      -h  You're reading it
+  --verbose   -v  Show work
+  --version   -V  Show version
+  --backtrace     Show ruby backtrace on error
+
+end_doc
+
+VERSION_STRING = <<-end_doc
+#{USAGE}
+Version: #{CloudyIntegrate::Version::String}
+
+end_doc
+ 
+@verbose = false
+ 
+GetoptLong.new(
+  ['--help', '-h', GetoptLong::NO_ARGUMENT],
+  ['--verbose', '-v', GetoptLong::NO_ARGUMENT],
+  ['--version', '-V', GetoptLong::NO_ARGUMENT],
+  ['--backtrace', GetoptLong::NO_ARGUMENT]
+  ).each do |opt, arg|
+  case opt
+  when '--help' then STDOUT << HELP; exit true
+  when '--verbose' then @verbose = true
+  when '--version' then STDOUT << VERSION_STRING; exit true
+  when '--backtrace' then @backtrace = true
+  end
+end
+ 
+begin
+  # run a cloudy_integrate command
+  raise "Unknown command: #{ARGV.first}" unless ARGV.empty? || CloudyIntegrate::Session.commands.include?(ARGV.first)
+  
+  # configure the garlic runner
+  CloudyIntegrate::Session.runner.verbose = @verbose
+#  garlic.run_targets = @run_targets
+  
+  # run the command
+  ARGV << 'list' if ARGV.empty?
+  CloudyIntegrate::Session.call_command *ARGV
+
+rescue Exception => e
+  STDERR << "\n#{USAGE}\n\nError: #{e.message}\n\n"
+  raise e if @backtrace
+  exit false
+end

data/lib/cloudy_integrate.rb

@@ -0,0 +1,18 @@
+require "cloudy_integrate/session"
+require "cloudy_integrate/help_command"
+require "cloudy_integrate/check_command"
+require "cloudy_integrate/list_command"
+require "cloudy_integrate/start_command"
+require "cloudy_integrate/stop_command"
+
+module CloudyIntegrate
+  
+  module Version
+    Major = 0
+    Minor = 0
+    Tiny = 1
+    
+    String = [Major, Minor, Tiny].join('.')
+  end
+
+end

data/lib/cloudy_integrate/list_command.rb

@@ -0,0 +1,22 @@
+module CloudyIntegrate
+
+  class Session
+
+    define_command :list, "List all running tunnels on remote host" do |a_end_name|
+
+      ssh = Net::SSH.start(a_end_name, 'root', :forward_agent => true, :paranoid => false)
+      res = ssh.exec!("ps -ef | egrep autossh.*-Nqw | grep -v egrep")
+      if res
+        while( mtch = res.match( /\w+ *(\d+).*-Nqw (\d+):(\d+).*Checking=no ([\w\d.\-]+)/ )) do
+          puts "#{mtch[1]} #{mtch[2]} #{mtch[3]} #{mtch[4]}"
+          res = mtch.post_match
+        end
+      else
+        puts "no tunnels found on #{a_end_name}"
+      end
+      ssh.close
+
+    end
+
+  end
+end

data/lib/cloudy_integrate/session.rb

@@ -0,0 +1,41 @@
+module CloudyIntegrate
+  # this class runs the top level garlic commands
+  class Session
+
+    attr_accessor :verbose
+
+    # meta data about command methods which can be used by both rake and the cli tool
+    @@commands, @@command_descriptions = [], {}
+    
+    class << self
+      def define_command(name, desc, &block)
+        @@commands << name
+        @@command_descriptions[name] = desc
+        define_method name, &block
+      end
+      
+      def commands_with_description
+        @@commands.map{ |m| [m, @@command_descriptions[m]]}
+      end
+      
+      def command_description(name)
+        @@command_descriptions[name]
+      end
+      
+      def commands
+        @@command_descriptions.keys.map { |c| c.to_s}
+      end
+
+      def call_command(id, *args)
+        meth = runner.method(id.to_sym)
+        raise ArgumentError.new("Wrong number of arguments for #{meth.to_s}. Need #{meth.arity}}") unless meth.arity == args.size
+        meth.call *args
+      end
+
+      def runner
+        @runner ||= new
+      end
+    end
+
+  end
+end

data/lib/cloudy_integrate/start_command.rb

@@ -0,0 +1,94 @@
+# TODO: make tun interface discovery automatic
+# TODO: make tun ip discovery dynamic
+
+module CloudyIntegrate
+
+  class Session
+
+    define_command :start, "Integrate a cloudy instance into your network" do |a_end_name, b_end_name, a_end_ip, b_end_ip|
+      puts "connecting #{a_end_name} to #{b_end_name}"
+
+#      require 'ifconfig'
+      class Node
+        attr_reader :name, :tun, :tun_ip
+        def initialize(name)
+          @name = name
+          @ssh = Net::SSH.start(name, 'root', :forward_agent => true, :paranoid => false)
+        end
+
+        def prepare_for_tunneling(tun_ip = nil, tun = nil)
+          # find unused ip on network
+          @tun_ip = tun_ip || find_free_ip
+          # find free tun interface
+          @tun = tun || find_free_tunnel_interface
+        end
+        def find_free_ip
+          raise NotImplementedError.new "find_free_ip not implemented"
+        end
+        def find_free_tunnel_interface
+          tun_arr = exec "netstat -in | tail --lines=+3".inject([]) do |arr,line|
+            f = line.match(/^tun(\d+)/)
+            arr << f[1] if f
+            arr
+          end
+          free_tun = (0..(tun_arr.size)).each do |num|
+            return num unless tun_arr.include? num
+          end
+          free_tun
+        end
+
+        def exec(cmd);
+          # system cmd
+          puts "executing #{name}:#{cmd}" if true
+          @ssh.exec!(cmd)
+        end
+
+        def set_tun_ip(remote_ip)
+          exec "ifconfig tun#{tun} #{tun_ip} pointopoint #{remote_ip}"
+        end
+        def network; "192.168.1.0"; end
+        def netmask; "255.255.255.0"; end
+        def interface; "eth0"; end
+
+        def set_proc_ipv4(proc_name); exec "echo 1 > /proc/sys/net/ipv4/#{ proc_name}"; end
+        def enable_ip_forward; set_proc_ipv4 "ip_forward"; end
+        def enable_proxy_arp; set_proc_ipv4 "conf/#{ interface}/proxy_arp"; end
+      end
+
+      aEnd = Node.new a_end_name
+      aEnd.prepare_for_tunneling a_end_ip, 2
+      bEnd = Node.new b_end_name
+      bEnd.prepare_for_tunneling b_end_ip, 2
+
+      # prepare ssh tunnel
+
+      # check for PermitTunnel option in sshd_config on bEnd
+      # should check if really needed
+      if true
+        bEnd.exec( 'echo "PermitTunnel yes" >> /etc/ssh/sshd_config')
+        bEnd.exec( 'invoke-rc.d ssh reload')
+      end
+
+      # start ssh on aEnd
+      aEnd.exec "autossh -f -Nqw #{aEnd.tun}:#{bEnd.tun} -o StrictHostKeyChecking=no #{bEnd.name}"
+      
+      # wait for stable tunnel
+      # TODO: better checking
+      begin
+        sleep 2
+      end while aEnd.exec("ifconfig tun#{aEnd.tun} | grep 'Device not found'")
+
+      # setup ip networking
+      aEnd.set_tun_ip bEnd.tun_ip
+      bEnd.set_tun_ip aEnd.tun_ip
+      bEnd.exec "route add -net #{aEnd.network} netmask #{aEnd.netmask} gw #{aEnd.tun_ip} tun#{aEnd.tun}"
+
+      # enable forwarding and proxy_arp in a_end
+      aEnd.enable_ip_forward
+      aEnd.enable_proxy_arp
+
+      puts "integrated node #{bEnd.name} with IP #{bEnd.tun_ip}"
+    end
+
+  end
+end

data/lib/cloudy_integrate/stop_command.rb

@@ -0,0 +1,18 @@
+module CloudyIntegrate
+
+  class Session
+
+    define_command :stop, "Stop one integration" do |a_end_name, local_tun|
+
+      ssh = Net::SSH.start(a_end_name, 'root', :forward_agent => true, :paranoid => false)
+      res = ssh.exec!("ps -ef | grep -v egrep | egrep 'autossh.*-Nqw #{local_tun}'")
+      if res
+        pid = res.match( /\w+ *(\d+)/ )[1]
+        ssh.exec!("kill -TERM #{pid}")
+        ssh.close
+      end
+
+    end
+
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: aaalex-cloudy_integrate
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alex Peuchert
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-11 00:00:00 -08:00
+default_executable: cloudy_integrate
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: aaalex-ruby-ifconfig
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+description: Set of commands/rake-tasks .
+email: apeuchert@googlemail.com
+executables: 
+- cloudy_integrate
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/cloudy_integrate/session.rb
+- lib/cloudy_integrate/list_command.rb
+- lib/cloudy_integrate/start_command.rb
+- lib/cloudy_integrate/stop_command.rb
+- lib/cloudy_integrate.rb
+- README.textile
+- History.txt
+- bin/cloudy_integrate
+has_rdoc: false
+homepage: http://github.com/aaalex/cloudy_integrate
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "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: Virtually integrate an EC2 instance into your local network.
+test_files: []
+