here_or_there 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 028df86fad5122406b9777794a31fd0b3618ad5d
+  data.tar.gz: 8b492ae31ae4df58236da68b478e99ece562e4a3
+SHA512:
+  metadata.gz: fcaeba290157c9d4b63fc0058849b4b9a2d9939aa5f04e51fbc1be8d97db6c8d55f145e5ddd842838f7bd17e19280ee0b46ae1a7a6b9b6bae653c4d498e5d6ad
+  data.tar.gz: 02b3273e0e0e7bab4eedee8af30d2b917c75a5b185d2662993d13bebba5e42c3afb65a6bf93087693a946cd4f2dc17e8ad4f8e37805e18839750914d94f5d5ac

data/lib/here_or_there/local.rb

@@ -0,0 +1,14 @@
+module HereOrThere
+  class Local
+
+    def run command, &block
+      stdout, stderr, status = Open3.capture3(command)
+      response = Response.new( stdout, stderr, status.success? )
+
+      yield response if block_given?
+
+      return response
+    end
+
+  end
+end

data/lib/here_or_there/remote.rb

@@ -0,0 +1,71 @@
+module HereOrThere
+  module Remote
+    class << self
+
+      def session options={}
+        sessions.fetch(options) { add_session(options) }
+      end
+
+      private
+
+        def sessions
+          @_sessions ||= {}
+        end
+
+        def add_session options
+          sessions[options] = SSH.new( options )
+        end
+
+    end
+
+    class SSH
+      attr_reader :hostname, :user, :options
+      attr_reader :session
+
+      def initialize options
+        @options   = options.dup
+        @hostname  = @options.delete(:hostname)
+        @user      = @options.delete(:user)
+      end
+
+      def run command
+        stdout, stderr, status = [ '', '', false ]
+
+        open_session
+
+        session.exec! command do |channel, response_type, response_data|
+
+          if response_type == :stdout
+            stdout = response_data
+            status = true
+          else
+            stderr = response_data
+          end
+
+          return Response.new( stdout, stderr, status )
+        end
+
+        # catch that odd state where no data is returned
+        # but the execution is successful
+        return Response.new( '', '', true )
+
+      rescue Net::SSH::AuthenticationFailed
+        close_session
+        return Response.new( '', 'Authentication failed when connecting to remote', false )
+      end
+
+      private
+
+        def open_session
+          unless session && !session.closed?
+            @session = Net::SSH.start hostname, user, options
+          end
+        end
+
+        def close_session
+          session.close unless !session || session.closed?
+        end
+
+    end
+  end
+end

data/lib/here_or_there/response.rb

@@ -0,0 +1,29 @@
+module HereOrThere
+  class Response
+    attr_reader :stdout, :stderr, :status
+
+    def initialize stdout, stderr, status
+      @stdout = stdout
+      @stderr = stderr
+      @status = status
+    end
+
+    def [] key
+      case key
+      when 0 then stdout
+      when 1 then stderr
+      when 2 then status
+      else
+        nil
+      end
+    end
+
+    def success?
+      if status.respond_to? :success?
+        status.success?
+      else
+        status
+      end
+    end
+  end
+end

data/lib/here_or_there/version.rb

@@ -0,0 +1,3 @@
+module HereOrThere
+  VERSION = "0.1.0"
+end

data/lib/here_or_there.rb

@@ -0,0 +1,21 @@
+# util
+require 'open3'
+require 'net/ssh'
+
+# gem
+require 'here_or_there/version'
+require 'here_or_there/response'
+require 'here_or_there/local'
+require 'here_or_there/remote'
+
+module HereOrThere
+
+  def run_local command
+    Local.new.run command
+  end
+
+  def run_remote command, options={}
+    Remote.session( options ).run( command )
+  end
+
+end

data/spec/here_or_there/local_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe HereOrThere::Local do
+  context "when not given a block" do
+
+    it "returns a Response instance" do
+      ret = HereOrThere::Local.new.run( 'spec/fixtures/hello_stdout')
+      expect( ret.is_a? HereOrThere::Response ).to be_true
+    end
+    it "returns stdout as return.stdout" do
+      ret = HereOrThere::Local.new.run( 'spec/fixtures/hello_stdout' )
+      expect( ret.stdout ).to eq "Hello Stdout\n"
+    end
+
+    it "returns stderr as return.stderr" do
+      ret = HereOrThere::Local.new.run( 'spec/fixtures/hello_stderr' )
+      expect( ret.stderr ).to eq "Hello Stderr\n"
+    end
+
+    it "returns a successful status for a successful command" do
+      ret_succ = HereOrThere::Local.new.run( 'spec/fixtures/hello_stdout' )
+      expect( ret_succ.success? ).to be_true
+    end
+
+    it "returns an unsuccessful status for an unsuccessful command" do
+      ret_err  = HereOrThere::Local.new.run( 'spec/fixtures/hello_stderr' )
+      expect( ret_err.success? ).to be_false
+    end
+  end
+
+  context "when given a block" do
+    it "yields Response" do
+      ret = ""
+      HereOrThere::Local.new.run( 'spec/fixtures/hello_stdout' ) do |response|
+        ret = response
+      end
+
+      expect( ret.class ).to eq HereOrThere::Response
+    end
+  end
+end

data/spec/here_or_there/remote_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe HereOrThere::Remote do
+
+  before :each do
+    Net::SSH.stub( start: StubbedSession.new )
+  end
+
+  describe "::session" do
+
+    before :each do
+      if HereOrThere::Remote.send(:instance_variable_defined?, :@_sessions)
+        HereOrThere::Remote.send(:remove_instance_variable, :@_sessions)
+      end
+    end
+
+    it "creates an SSH object" do
+      expect(
+        HereOrThere::Remote.session( hostname: 'foo', user: 'bar' ).is_a?(HereOrThere::Remote::SSH)
+      ).to be_true
+    end
+
+    it "doesn't recreate an instance" do
+      first_instance = HereOrThere::Remote.session( hostname: 'foo', user: 'bar' )
+      expect( HereOrThere::Remote.session( hostname: 'foo', user: 'bar' ) ).to eq first_instance
+    end
+
+    it "creates a new instance for uniq options" do
+      first_instance = HereOrThere::Remote.session( hostname: 'foo', user: 'bar' )
+      expect( HereOrThere::Remote.session( hostname: 'wu', user: 'tang' ) ).not_to eq first_instance
+    end
+
+  end
+
+  describe HereOrThere::Remote::SSH do
+
+    before :each do
+      @ssh = HereOrThere::Remote::SSH.new( hostname: 'foo', user: 'bar' )
+    end
+
+    describe "#run" do
+      it "returns a response object" do
+        expect( @ssh.run("foo").is_a? HereOrThere::Response ).to be_true
+      end
+
+      context "when response is stdout" do
+
+        before :each do
+          StubbedSession.any_instance.stub(:exec!).and_yield("foo", :stdout, "hello stdout")
+        end
+
+        it "assigns response_data to Response.stdout" do
+          expect( @ssh.run("foo").stdout ).to eq "hello stdout"
+        end
+
+        it "responds with a successful response object" do
+          expect( @ssh.run("foo") ).to be_success
+        end
+
+      end
+
+      context "when response is stderr" do
+
+        before :each do
+          StubbedSession.any_instance.stub(:exec!).and_yield("foo", :stderr, "hello stderr")
+        end
+
+        it "assigns response_data to Response.stderr" do
+          expect( @ssh.run("foo").stderr ).to eq "hello stderr"
+        end
+
+        it "responds with an unsuccessful response object" do
+          expect( @ssh.run("foo") ).not_to be_success
+        end
+
+      end
+
+      context "when the block isn't called" do
+        # this happens when there is an empty response
+        # and no error from the remote
+
+        before :each do
+          StubbedSession.any_instance.stub(:exec!).and_return(nil)
+        end
+
+        it "returns an empty successful response" do
+          resp = @ssh.run('foo')
+
+          expect( resp ).to be_success
+          expect( resp.stdout ).to eq ''
+          expect( resp.stderr ).to eq ''
+        end
+      end
+
+      context "when raises Net::SSH::AuthenticationFailed" do
+
+        before :each do
+          StubbedSession.any_instance.stub(:exec!).and_raise(Net::SSH::AuthenticationFailed)
+        end
+
+        it "returns an unsucessful response with err as stderr" do
+          resp = @ssh.run("foo")
+          expect( resp ).not_to be_success
+          expect( resp.stderr ).to eq "Authentication failed when connecting to remote"
+        end
+
+        it "closes the session" do
+          this_session = @ssh.session
+          @ssh.run("foo")
+          expect( @ssh.session ).not_to eq this_session
+        end
+      end
+    end
+  end
+
+end

data/spec/here_or_there/response_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe HereOrThere::Response do
+  let(:response) { HereOrThere::Response.new( 'stdout', 'stderr', 'status' ) }
+
+  describe "#stdout" do
+    it "returns the stdout value" do
+      expect( response.stdout ).to eq 'stdout'
+    end
+  end
+
+  describe "#stderr" do
+    it "returns the stderr value" do
+      expect( response.stderr ).to eq 'stderr'
+    end
+  end
+
+  describe "#status" do
+    it "returns the status value" do
+      expect( response.status ).to eq 'status'
+    end
+  end
+
+  describe "#[]" do
+    it "returns stdout for [0]" do
+      expect( response[0] ).to eq 'stdout'
+    end
+    it "returns stderr for [1]" do
+      expect( response[1] ).to eq 'stderr'
+    end
+    it "returns status for [2]" do
+      expect( response[2] ).to eq 'status'
+    end
+  end
+
+  describe "#success?" do
+    context "when status responds to success? (an open3 response)" do
+      it "is truthy when process is success" do
+        ret_succ = HereOrThere::Local.new.run( 'spec/fixtures/hello_stdout' )
+        expect( ret_succ ).to be_success
+      end
+      it "is falsy when status returns err" do
+        ret_err  = HereOrThere::Local.new.run( 'spec/fixtures/hello_stderr' )
+        expect( ret_err ).not_to be_success
+      end
+    end
+    context "when status is a boolean (a ssh response)" do
+      it "is truthy when status is true" do
+        expect( HereOrThere::Response.new( 'stdout', 'stderr', true ) ).to be_success
+      end
+      it "is falsy when status is false" do
+        expect( HereOrThere::Response.new( 'stdout', 'stderr', false ) ).not_to be_success
+      end
+    end
+  end
+
+end

data/spec/here_or_there_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe HereOrThere do
+  include HereOrThere
+
+  describe "#run_local" do
+    it "passes the command to a Local instance" do
+      HereOrThere::Local.any_instance.should_receive(:run).with("foo")
+
+      run_local('foo')
+    end
+    it "returns a response object" do
+      expect( run_local('spec/fixtures/hello_stdout').is_a? HereOrThere::Response ).to be_true
+    end
+  end
+
+  describe "#run_remote" do
+    it "passes the command to a SSH instance" do
+      HereOrThere::Remote::SSH.any_instance.should_receive(:run).with('ls')
+
+      run_remote( 'ls', hostname: 'foo', user: 'bar' )
+    end
+    it "returns a response object" do
+      HereOrThere::Remote::SSH.any_instance.stub( session: StubbedSession.new )
+      expect( run_remote( 'ls', hostname: 'foo', user: 'bar').is_a? HereOrThere::Response ).to be_true
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+# utils
+# nice to have for debugging -- uncomment in gemfile to use
+# require 'pry'
+# require 'byebug'
+
+# rspec support
+require 'support/capture'
+require 'support/stubbed_session'
+
+# library
+require 'here_or_there'
+
+describe "support" do
+
+  describe Capture do
+    describe "#stdout" do
+      it "returns a string representation fo what is sent to stdout inside the given block" do
+        out = Capture.stdout { $stdout.puts "hello"; $stdout.puts "world" }
+        expect( out ).to eq "hello\nworld\n"
+      end
+    end
+
+    describe "#stderr" do
+      it "returns a string representation fo what is sent to stderr inside the given block" do
+        out = Capture.stderr { $stderr.puts "hello"; $stderr.puts "world" }
+        expect( out ).to eq "hello\nworld\n"
+      end
+    end
+  end
+
+end
+
+
+describe "fixtures" do
+
+  describe "hello_stdout" do
+    it "puts hello stdout to stdout" do
+      stdout, stderr, status = Open3.capture3('spec/fixtures/hello_stdout')
+      expect( stdout ).to eq "Hello Stdout\n"
+    end
+
+    it "returns success code" do
+      stdout, stderr, status = Open3.capture3('spec/fixtures/hello_stdout')
+      expect( status.success? ).to be_true
+    end
+  end
+
+  describe "hello_stderr" do
+    it "puts hello stderr to stderr" do
+      stdout, stderr, status = Open3.capture3('spec/fixtures/hello_stderr')
+      expect( stderr ).to eq "Hello Stderr\n"
+    end
+
+    it "returns error code" do
+      stdout, stderr, status = Open3.capture3('spec/fixtures/hello_stderr')
+      expect( status.success? ).to be_false
+    end
+  end
+
+end

data/spec/support/capture.rb

@@ -0,0 +1,59 @@
+module Capture
+
+  class << self
+    def stdout &block
+      StdOut.new.capture(&block).read
+    end
+
+    def stderr &block
+      StdErr.new.capture(&block).read
+    end
+  end
+
+  class StdOut
+    attr_reader :orig_stdout
+    attr_reader :new_stdout
+
+    def initialize
+      @orig_stdout = $stdout
+      @new_stdout  = StringIO.open('','w+')
+    end
+
+    def capture &block
+      $stdout = new_stdout
+      yield
+      $stdout = orig_stdout
+
+      return self
+    end
+
+    def read
+      new_stdout.rewind
+      new_stdout.read
+    end
+  end
+
+  class StdErr
+    attr_reader :orig_stderr
+    attr_reader :new_stderr
+
+    def initialize
+      @orig_stderr = $stderr
+      @new_stderr  = StringIO.open('','w+')
+    end
+
+    def capture &block
+      $stderr = new_stderr
+      yield
+      $stderr = orig_stderr
+
+      return self
+    end
+
+    def read
+      new_stderr.rewind
+      new_stderr.read
+    end
+  end
+
+end

data/spec/support/stubbed_session.rb

@@ -0,0 +1,17 @@
+class StubbedSession
+  def initialize
+    @closed = false
+  end
+
+  def close
+    @closed = true
+  end
+
+  def closed?
+    @closed
+  end
+
+  def exec! command, &block
+    yield ['foo', :stdout, "woop woop"]
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: here_or_there
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Steven Sloan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: A unified interface for running local or remote commands. Provides a
+  dependable & identical response from both types of command.
+email:
+- stevenosloan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/here_or_there/local.rb
+- lib/here_or_there/remote.rb
+- lib/here_or_there/response.rb
+- lib/here_or_there/version.rb
+- lib/here_or_there.rb
+- spec/here_or_there/local_spec.rb
+- spec/here_or_there/remote_spec.rb
+- spec/here_or_there/response_spec.rb
+- spec/here_or_there_spec.rb
+- spec/spec_helper.rb
+- spec/support/capture.rb
+- spec/support/stubbed_session.rb
+homepage: http://github.com/stevenosloan/here_or_there
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.5
+signing_key: 
+specification_version: 4
+summary: Unified interface for running local and remote commands
+test_files:
+- spec/here_or_there/local_spec.rb
+- spec/here_or_there/remote_spec.rb
+- spec/here_or_there/response_spec.rb
+- spec/here_or_there_spec.rb
+- spec/spec_helper.rb
+- spec/support/capture.rb
+- spec/support/stubbed_session.rb