exec_remote 0.0.1

data/CHANGELOG.rdoc

@@ -0,0 +1,3 @@
+== 0.0.1 / October 2, 2009
+
+* Some of the basic functionality.

data/Manifest

@@ -0,0 +1,11 @@
+CHANGELOG.rdoc
+Manifest
+README.rdoc
+Rakefile
+bin/exec_remote
+lib/exec_remote.rb
+lib/exec_remote/cli.rb
+lib/exec_remote/configuration.rb
+lib/exec_remote/remote_executor.rb
+lib/exec_remote/shell.rb
+spec/functional/basic_spec.rb

data/README.rdoc

@@ -0,0 +1,8 @@
+Exec Remote is a simple utility to run tests/build against your development code in a remote machine 
+without checking in to a repository. 
+
+It sync ups your code in local and remote machine with rsync and
+the commands are executed in remote machine via SSH
+
+
+More coming soon.

data/Rakefile

@@ -0,0 +1,28 @@
+begin
+  require 'echoe'
+rescue LoadError
+  abort "gem 'echoe' is required"
+end
+
+version = "0.0.1"
+
+Echoe.new('exec_remote', version) do |p|
+  p.include_gemspec = true
+  p.changelog        = "CHANGELOG.rdoc"
+
+  p.author           = "Selvakumar Natesan"
+  p.email            = "k.n.selvakumar@gmail.com"
+
+  p.summary = <<-DESC.strip.gsub(/\n\s+/, " ")
+    Exec Remote is a simple utility to run tests/build against your development code in a remote machine 
+    without checking in to a repository. 
+    
+    It sync ups your code in local and remote machine with rsync and
+    the commands are executed in remote machine via SSH
+  DESC
+
+  p.url              = "https://github.com/selvakn/exec_remote"
+  p.rdoc_pattern     = /^(lib|README.rdoc|CHANGELOG.rdoc)/
+
+  p.dependencies     = ["net-ssh"]
+end

data/bin/exec_remote

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'exec_remote/cli'
+ExecRemote::CLI.execute

data/exec_remote.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{exec_remote}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Selvakumar Natesan"]
+  s.date = %q{2009-10-03}
+  s.default_executable = %q{exec_remote}
+  s.description = %q{Exec Remote is a simple utility to run tests/build against your development code in a remote machine  without checking in to a repository.  It sync ups your code in local and remote machine with rsync and the commands are executed in remote machine via SSH}
+  s.email = %q{k.n.selvakumar@gmail.com}
+  s.executables = ["exec_remote"]
+  s.extra_rdoc_files = ["CHANGELOG.rdoc", "README.rdoc", "lib/exec_remote.rb", "lib/exec_remote/cli.rb", "lib/exec_remote/configuration.rb", "lib/exec_remote/remote_executor.rb", "lib/exec_remote/shell.rb"]
+  s.files = ["CHANGELOG.rdoc", "Manifest", "README.rdoc", "Rakefile", "bin/exec_remote", "lib/exec_remote.rb", "lib/exec_remote/cli.rb", "lib/exec_remote/configuration.rb", "lib/exec_remote/remote_executor.rb", "lib/exec_remote/shell.rb", "spec/functional/basic_spec.rb", "exec_remote.gemspec"]
+  s.homepage = %q{https://github.com/selvakn/exec_remote}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Exec_remote", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{exec_remote}
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Exec Remote is a simple utility to run tests/build against your development code in a remote machine  without checking in to a repository.  It sync ups your code in local and remote machine with rsync and the commands are executed in remote machine via SSH}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<net-ssh>, [">= 0"])
+    else
+      s.add_dependency(%q<net-ssh>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<net-ssh>, [">= 0"])
+  end
+end

data/lib/exec_remote/cli.rb

@@ -0,0 +1,53 @@
+require 'exec_remote'
+
+module ExecRemote
+  class CLI
+
+    def self.config
+      @@config ||= Configuration.new
+    end
+    
+    def self.execute
+      begin
+        puts "Exec Remote Shell"
+        puts "================="
+        
+        rsync
+
+        puts "Enter your commands now"
+        shell = Shell.new
+        while(true)
+          process_command shell.read_line
+        end
+      rescue StandardError => e
+        puts "Exiting because of error: #{e}"
+        raise e
+      end
+    end
+    
+    def self.process_command(command)
+      if command[0,1] == "!"
+        command = command[1..-1]
+        print "again? "
+        rsync
+      end
+
+      exit if command == "exit"
+      exec_remote command
+    end
+    
+    def self.exec_remote(command)
+      command = command.to_s.strip
+      command_to_exec = "cd #{config.my_current_project_dir_on_remote} && #{command}"
+      RemoteExecutor.connect_and_execute(command_to_exec, config.remote_host, config.remote_user) unless command.empty?
+    end
+
+    def self.rsync
+      rsync_command = <<EOS
+rsync -r --exclude=.git #{config.current_dir} #{config.remote_user}@#{config.remote_host}:#{config.my_dir_on_remote}
+EOS
+      puts "rsyncing.."; `#{rsync_command}`
+      puts "Done"
+    end
+  end
+end

data/lib/exec_remote/configuration.rb

@@ -0,0 +1,69 @@
+module ExecRemote
+  class Configuration
+    
+    def exec_config
+      config = config_from_file
+      updated_config = update_config_from_user(config.dup)
+      
+      return config if config == updated_config
+      File.open(config_file, "w") {|f| f.puts updated_config.to_yaml}
+      exec_config
+    end
+    
+    def current_dir
+      Dir.pwd
+    end
+
+    def current_project
+      File.basename(current_dir)
+    end
+
+    def remote_host
+      exec_config["host"]
+    end
+
+    def remote_user
+      exec_config["user"]
+    end
+
+    def my_dir_on_remote
+      File.join(exec_config["base_location"], exec_config["location"])
+    end
+
+    def my_current_project_dir_on_remote
+      File.join(my_dir_on_remote, current_project)
+    end
+    
+    private
+    def config_from_file
+      return {} unless File.exists?(config_file)
+      YAML.load_file config_file
+    end
+    
+    def update_config_from_user(config = {})
+      config = check_and_update_config(config, "host", "the remote hostname/ip")
+      config = check_and_update_config(config, "user", "the remote host username")
+      config = check_and_update_config(config, "location", "your location on remote host", current_project)
+      config["base_location"] ||= "data"
+      config
+    end
+    
+    def check_and_update_config(config, config_name, description = config_name, default_value = nil)
+      return config if config[config_name]
+      print "Enter #{description}: "
+      print "[#{default_value}] " if default_value
+      
+      config[config_name] = strip_string(gets) || default_value
+      config
+    end
+    
+    def config_file
+      File.join(current_dir, ".exec_remote.yml")
+    end
+    
+    def strip_string(string)
+      str = string.strip
+      str.empty? ? nil : str
+    end
+  end
+end

data/lib/exec_remote/remote_executor.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+gem 'net-ssh'
+require 'net/ssh'
+
+module ExecRemote
+  class RemoteExecutor
+    def self.connect_and_execute(command, host, user, pass = nil)
+      ssh_connect(host, user, pass) do |ssh|
+        execute(ssh, command)
+      end
+    end
+
+    def self.ssh_connect(host, user, password, &block)
+      puts "Connecting.."
+      ::Net::SSH.start(host, user, :password => password, :config=>false, :paranoid=>false) do |ssh|
+        yield(ssh)
+      end
+    end
+
+    def self.execute(ssh_connection, command)
+      ssh_connection.open_channel do |channel|
+        channel.request_pty do |ch, success|
+          if success
+            ch.exec "sh -c '#{command}'"
+          else
+            ch.close
+          end
+
+          ch.on_data do |c, data|
+            print data
+          end
+
+          ch.on_extended_data do |c, type, data|
+            print data
+          end
+
+          ch.on_close { puts "Remote Task Completed" }
+        end
+      end
+    end
+  end
+end

data/lib/exec_remote/shell.rb

@@ -0,0 +1,39 @@
+module ExecRemote
+  class Shell
+    class ReadlineFallback #:nodoc:
+      HISTORY = []
+
+      def self.readline(prompt)
+        STDOUT.print(prompt)
+        STDOUT.flush
+        STDIN.gets
+      end
+    end
+
+    def reader
+      @reader ||= begin
+        require 'readline'
+        Readline
+      rescue LoadError
+        ReadlineFallback
+      end
+    end
+
+    def read_line
+      loop do
+        command = reader.readline("> ")
+
+        if command.nil?
+          command = "exit"
+        else
+          command.strip!
+        end
+
+        unless command.empty?
+          reader::HISTORY << command
+          return command
+        end
+      end
+    end
+  end
+end

data/lib/exec_remote.rb

@@ -0,0 +1,3 @@
+require 'exec_remote/remote_executor'
+require 'exec_remote/shell'
+require 'exec_remote/configuration'

data/spec/functional/basic_spec.rb

@@ -0,0 +1,2 @@
+require 'exec_remote/cli'
+ExecRemote::CLI.execute

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: exec_remote
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Selvakumar Natesan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-03 00:00:00 +05:30
+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: "0"
+    version: 
+description: Exec Remote is a simple utility to run tests/build against your development code in a remote machine  without checking in to a repository.  It sync ups your code in local and remote machine with rsync and the commands are executed in remote machine via SSH
+email: k.n.selvakumar@gmail.com
+executables: 
+- exec_remote
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG.rdoc
+- README.rdoc
+- lib/exec_remote.rb
+- lib/exec_remote/cli.rb
+- lib/exec_remote/configuration.rb
+- lib/exec_remote/remote_executor.rb
+- lib/exec_remote/shell.rb
+files: 
+- CHANGELOG.rdoc
+- Manifest
+- README.rdoc
+- Rakefile
+- bin/exec_remote
+- lib/exec_remote.rb
+- lib/exec_remote/cli.rb
+- lib/exec_remote/configuration.rb
+- lib/exec_remote/remote_executor.rb
+- lib/exec_remote/shell.rb
+- spec/functional/basic_spec.rb
+- exec_remote.gemspec
+has_rdoc: true
+homepage: https://github.com/selvakn/exec_remote
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Exec_remote
+- --main
+- README.rdoc
+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: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: exec_remote
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Exec Remote is a simple utility to run tests/build against your development code in a remote machine  without checking in to a repository.  It sync ups your code in local and remote machine with rsync and the commands are executed in remote machine via SSH
+test_files: []
+