channelizer 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+  - rbx-19mode
+  - ree

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+
+gem 'rake'
+
+# Specify your gem's dependencies in channelizer.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Paul Morton
+
+MIT License
+
+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.md

@@ -0,0 +1 @@
+Test

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+RSpec::Core::RakeTask.new(:test) do |spec|
+  spec.rspec_opts = "-bc"
+end

data/channelizer.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/channelizer/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Paul Morton"]
+  gem.email         = ["pmorton@biaprotect.com"]
+  gem.description   = %q{A gem that abstracts shell and upload channels}
+  gem.summary       = File.read('README.md')
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "channelizer"
+  gem.require_paths = ["lib"]
+  gem.version       = Channelizer::VERSION
+  gem.add_runtime_dependency "winrm", "~> 1.1.2"
+  gem.add_runtime_dependency "net-ssh", "~> 2.5.2"
+  gem.add_runtime_dependency "net-scp", "~> 1.0.4"
+  gem.add_runtime_dependency 'rspec'
+  gem.add_runtime_dependency 'rake'
+end

data/lib/channelizer.rb

@@ -0,0 +1,7 @@
+require 'winrm'
+require 'channelizer/util/retryable'
+require 'channelizer/exceptions/exceptions'
+require 'channelizer/factory'
+require 'channelizer/channels/base'
+require 'channelizer/channels/winrm'
+require 'channelizer/channels/ssh'

data/lib/channelizer/channels/base.rb

@@ -0,0 +1,130 @@
+module Channelizer
+  module Channels
+    class Base
+      include Channelizer::Exceptions
+      include Channelizer::Util::Retryable
+
+      def initialize(options)
+        self.class.validate_options(options)  
+      end
+      # Executes a command on the channel
+      #
+      # @param [String] command the command to execute on the channel
+      # @param [Hash] options the options string to be used in executing the command
+      # @option options [Array] :exit_codes ([0]) the valid exit codes for the command
+      # @option options [TrueClass,FalseClass] :check_exit_code (true) make that the command returned a valid exit code
+      # @return [Fixnum] the exit code of the command
+      # @raise [BadExitCode] The command exited with a bad exitcode
+      def shell_execute(command, options = {})
+        defaults = {:exit_codes => [0], :check_exit_code => true, :sudo => false}
+        options = defaults.merge(options)
+
+        new_command = options[:sudo] ? sudo_command(command) : command
+
+        exit_code = execute(new_command, options)
+
+        if not options[:exit_codes].include? exit_code and options[:check_exit_code]
+          raise BadExitCode, "Exit Code: #{exit_code}"
+        end
+
+        exit_code.to_i
+      end
+
+      # Returns a command wrapped in a sudo context
+      #
+      # @param [String] command the command to wrap in a sudo context
+      # @return [String] the command that has been wrapped in a sudo context
+      # @raise [NotImplementedError] this method has not been implemented
+      def sudo_command(command)
+        raise NotImplementedError, "sudo command not implemented"  
+      end
+
+      # Executes a command on the channel
+      #
+      # @param command the command to execute on the channel
+      # @return [Fixnum] 
+      # @raise [NotImplementedError] this method has not been implemented
+      def execute(command, options = {})
+        raise NotImplementedError, "Execute not implemented"
+      end
+
+      # Uploads a file over the channel
+      #
+      # @param source the file to upload
+      # @param destination where to place the file on the remote host
+      # @return [Fixnum] 
+      # @raise [NotImplementedError] this method has not been implemented
+      def upload(source, destination, options = {} )
+        raise NotImplementedError, "Upload not implemented"
+      end
+
+      # Checks if the channel is ready for action
+      #
+      # @return [TrueClass,FalseClass]
+      def ready?
+        begin
+          Timeout.timeout(60) do
+            execute "hostname"
+          end
+          return true
+        rescue Timeout::Error => e
+          return false
+        rescue Errno::ECONNREFUSED => e
+          return false
+        rescue HTTPClient::KeepAliveDisconnected => e
+          return false
+        end
+      end
+
+      class <<self
+      # Validates the option set for the channel
+      #
+      # @param [Hash] options the options hash to validate
+      # @return [True]
+      def validate_options(options)
+        @required_options.each do |o|
+          if o.is_a? Array
+            # At least one of the items in an array must be set, if the value is
+            # an array it is treated as a group of arguments that are required.
+            condition_met = false
+            o.each do |o_set|
+              if o_set.is_a? Array
+                included_options = []
+                o_set.each do |o_req_set|
+                  included_options << o_req_set if options[o_req_set]
+                end
+                condition_met = true if included_options.length.eql?(o_set.length)
+              else
+                condition_met = true if options[o_set]
+              end
+            end
+            raise ArgumentError, "You must specify one of #{o.inspect}" unless condition_met
+          else
+            raise ArgumentError, "#{o} is a required option, but was not provided"  unless options[o]
+
+            if options[o].respond_to? :empty?
+              raise ArgumentError, "#{o} cannot be empty" if options[o].empty?
+            end  
+          end
+        end
+        true
+      end
+
+      # Register a required option
+      #
+      # @param [Symbol] value the option name that is required
+      def required_option(value)
+        @required_options ||= []
+        if value.respond_to? :to_sym
+          @required_options << value.to_sym
+        elsif value.is_a? Array
+          @required_options << value
+        else
+          raise ArgumentError, "#{value.inspect} cannot be added to the validation list"  
+        end
+      end
+      end
+
+    end
+  end
+end

data/lib/channelizer/channels/ssh.rb

@@ -0,0 +1,107 @@
+require 'net/ssh'
+require 'net/scp'
+module Channelizer
+  module Channels
+    class Ssh < Channelizer::Channels::Base
+
+      required_option :host
+      required_option :port
+      required_option [[:username,:password], :keys]
+
+      # Creates a SSH Session 
+      #
+      # @option options [String] :username the username
+      # @option options [String] :password the password
+      # @option options [String] :host the remote host
+      # @option options [String] :port (5985) the port to connect on
+      # @option options [String] :keys the keys to try logging in with
+      def initialize(options)
+        defaults = { :port => 22, :paranoid => false }
+        options = defaults.merge(options)
+
+        # Options need to be in a final state before we call the parent initializer
+        super(options)
+
+        @connection_options = options
+
+      end
+
+      def session
+        options = @connection_options.clone
+        host = options.delete(:host)
+        username = options.delete(:username)
+        Net::SSH.start(host,username,options)
+      end
+
+      # Executes a command on the channel
+      #
+      # @param command the command to execute on the channel
+      # @return [Fixnum] the exit code of the command
+      # @raise [StandardException]
+      def execute(command, options = { })
+        defaults = { :out_console => true }
+        options = defaults.merge(options)
+        # open a new channel and configure a minimal set of callbacks, then run
+        # the event loop until the channel finishes (closes)
+        last_exit = -1
+        channel = session.open_channel do |ch|
+
+          #request pty for sudo stuff and so
+          ch.request_pty do |ch, success|
+            raise "Error requesting pty" unless success
+          end
+            
+          ch.exec "#{command}" do |ch, success|
+            raise "could not execute command" unless success
+
+
+            # "on_data" is called when the process writes something to stdout
+            ch.on_data do |c, data|
+              STDOUT.print data if options[:out_console]
+
+            end
+
+            # "on_extended_data" is called when the process writes something to stderr
+            ch.on_extended_data do |c, type, data|
+              STDOUT.print data if options[:out_console]
+            end
+
+            channel.on_request("exit-signal") do |ch, data|
+              last_exit = data.read_long
+            end
+
+            channel.on_request("exit-status") do |ch,data|
+              last_exit = data.read_long
+            end
+
+          end
+        end
+        channel.wait
+        last_exit
+      end
+
+      # Echos the command (Windows does not support sudo)
+      #
+      # @param [String] command the command to wrap in a sudo context
+      # @return [String] the command that has been wrapped in a sudo context
+      def sudo_command(command)
+        "sudo #{command}"
+      end
+
+      # Uploads a file over WinRM
+      #
+      # @param source the file to upload
+      # @param destination where to place the file on the remote host
+      # @return [Fixnum] 
+      def upload(source, destination, options = {} )
+        options = @connection_options.clone
+        host = options.delete(:host)
+        username = options.delete(:username)
+        channel = session.scp.upload(source,destination)
+        channel.wait
+      end
+    end
+  end
+end
+
+Channelizer::Factory.register(:ssh, Channelizer::Channels::Ssh)

data/lib/channelizer/channels/winrm.rb

@@ -0,0 +1,121 @@
+require 'winrm'
+module Channelizer
+  module Channels
+    class WinRM < Channelizer::Channels::Base
+
+      # @return [WinRM::WinRMWebService] the winrm management session
+      attr_reader :session
+
+      required_option :host
+      required_option :port
+      required_option [[:username,:password], :realm]
+
+      # Creates a WinRM Channel
+      #
+      # @option options [String] :username the username
+      # @option options [String] :password the password
+      # @option options [String] :host the remote host
+      # @option options [String] :port (5985) the port to connect on
+      # @option options [String] :realm the realm to use when using kerberos authentication
+      def initialize(options)
+        defaults = { :port => 5985, :basic_auth_only => true }
+        options = defaults.merge(options)
+        options[:pass] = options[:password] if options[:password]
+        options[:user] = options[:username] if options[:username]
+
+        # Options need to be in a final state before we call the parent initializer
+        super(options)
+
+        endpoint = "http://#{options[:host]}:#{options[:port]}/wsman"
+
+        if options[:realm]
+          @session = ::WinRM::WinRMWebService.new(endpoint, :kerberos, :realm => options[:realm])
+        else
+          @session = ::WinRM::WinRMWebService.new(endpoint, :plaintext, options)
+        end
+
+      end
+
+      # Executes a command on the channel
+      #
+      # @param command the command to execute on the channel
+      # @return [Fixnum] the exit code of the command
+      # @raise [StandardException]
+      def execute(command, options = { })
+        defaults = { :shell => :cmd, :out_console => true }
+        options = defaults.merge(options)
+
+        run_proc = Proc.new do |stdout, stderr|
+          STDOUT.print stdout
+          STDERR.print stderr
+        end
+
+        shell = options.delete(:shell)
+        case shell
+        when :cmd
+          if options[:out_console]
+            status = session.cmd(command,&run_proc) 
+          else
+            status = session.cmd(command)
+          end
+        when :powershell
+          if options[:out_console]
+            status = session.powershell(command, &run_proc)
+          else
+            status = session.powershell(command)
+          end  
+        else
+          raise StandardError, "Invalid shell #{options[:shell]}"
+        end
+        status[:exitcode]
+      end
+
+      # Echos the command (Windows does not support sudo)
+      #
+      # @param [String] command the command to wrap in a sudo context
+      # @return [String] the command that has been wrapped in a sudo context
+      def sudo_command(command)
+        command
+      end
+
+      # Uploads a file over WinRM
+      #
+      # @param source the file to upload
+      # @param destination where to place the file on the remote host
+      # @return [Fixnum] 
+      def upload(source, destination, options = {} )
+        file = "winrm-upload-#{rand()}"
+        puts "File: " + file
+        file_name = (session.cmd("echo %TEMP%\\#{file}"))[:data][0][:stdout].chomp
+        puts "File Name: " + file_name
+        puts session.powershell <<-EOH
+          if(Test-Path #{destination})
+          {
+            rm #{destination}
+          }
+        EOH
+
+        Base64.encode64(IO.binread(source)).gsub("\n",'').chars.to_a.each_slice(8000-file_name.size) do |chunk|
+          out = session.cmd( "echo #{chunk.join} >> \"#{file_name}\"" )
+          puts out
+        end
+
+        puts session.powershell <<-EOH
+          $dir = [System.IO.Path]::GetDirectoryName(\"#{destination}\")
+          Write-host $dir
+          New-Item $dir -type directory -ea SilentlyContinue
+        EOH
+
+        puts session.powershell <<-EOH
+          $base64_string = Get-Content \"#{file_name}\"
+          $bytes  = [System.Convert]::FromBase64String($base64_string) 
+          $new_file = [System.IO.Path]::GetFullPath(\"#{destination}\")
+          [System.IO.File]::WriteAllBytes($new_file,$bytes)
+        EOH
+      end
+
+    end
+  end
+end
+
+Channelizer::Factory.register(:winrm, Channelizer::Channels::WinRM)

data/lib/channelizer/exceptions/exceptions.rb

@@ -0,0 +1,13 @@
+module Channelizer
+  module Exceptions
+    # Generic Channel Error
+    class ChannelError < StandardError ; end
+
+    # Invalid Exit Code
+    class BadExitCode < StandardError ; end
+
+    # Invalid Channel Type Code
+    class InvalidChannelTypeError < StandardError ; end
+
+  end
+end

data/lib/channelizer/factory.rb

@@ -0,0 +1,23 @@
+module Channelizer
+  class Factory
+    include Channelizer::Exceptions
+
+    class << self
+
+      def register(name,klass)
+        @registered_channels ||= {}
+        @registered_channels[name.to_sym] = klass
+      end
+
+      def build_channel(type,options)
+        raise InvalidChannelTypeError, ":#{type} is not a registered channel" unless @registered_channels[type.to_sym]
+        @registered_channels[type.to_sym].new(options)
+      end
+
+      def channels
+        @registered_channels ||= {}
+      end
+    end
+
+  end
+end

data/lib/channelizer/util/retryable.rb

@@ -0,0 +1,25 @@
+module Channelizer
+  module Util
+    module Retryable
+      # Retries a given block a specified number of times in the
+      # event the specified exception is raised. If the retries
+      # run out, the final exception is raised.
+      #
+      # This code is adapted slightly from the following blog post:
+      # http://blog.codefront.net/2008/01/14/retrying-code-blocks-in-ruby-on-exceptions-whatever/
+      def retryable(opts=nil)
+        opts = { :tries => 1, :on => Exception }.merge(opts || {})
+
+        begin
+          return yield
+        rescue *opts[:on]
+          if (opts[:tries] -= 1) > 0
+            sleep opts[:sleep].to_f if opts[:sleep]
+            retry
+          end
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/channelizer/version.rb

@@ -0,0 +1,3 @@
+module Channelizer
+  VERSION = "0.0.1"
+end

data/spec/channel_helper.rb

@@ -0,0 +1,19 @@
+$: << File.dirname(__FILE__) + '../lib/'
+$: << File.dirname(__FILE__)
+require 'channelizer'
+module ChannelHelper
+
+  def new_channel(type)
+    case type
+    when :winrm
+      Channelizer::Factory.build_channel(type, :username => 'vagrant', :password => 'vagrant', :host => 'localhost', :port => 5985)
+    when :ssh
+      Channelizer::Factory.build_channel(type, :username => 'vagrant', :keys => ['/Users/pmorton/.ssh/deploy'],:password => 'vagrant', :host => 'localhost', :port => 2200)  
+    end
+  end
+
+end
+
+RSpec.configure do |config|
+  config.include(ChannelHelper)
+end

data/spec/test_data/test_file.txt

@@ -0,0 +1 @@
+This is a test upload

data/spec/winrm_form_spec.rb

@@ -0,0 +1,16 @@
+require 'channel_helper.rb'
+describe "winrm object form" do
+  it 'should expose a session' do
+    c = Channelizer::Factory.build_channel(:winrm, :host => 'localhost', :username => 'vagrant', :password => 'vagrant') 
+    c.session.should be_a_kind_of(WinRM::WinRMWebService)
+  end
+
+  it 'should respond to instance methods of the base interface' do
+    c = Channelizer::Factory.build_channel(:winrm, :host => 'localhost', :username => 'vagrant', :password => 'vagrant')
+    c.should respond_to(:execute,:upload,:shell_execute,:sudo_command, :ready?)
+  end
+
+  it 'should respond to class methods of the base interface' do
+    Channelizer::Channels::WinRM.should respond_to(:validate_options)
+  end
+end

data/spec/winrm_functional_spec.rb

@@ -0,0 +1,111 @@
+require 'channel_helper.rb'
+
+Channelizer::Factory.channels.each do |channel,klass| 
+  puts "CLASS #{channel}"
+  describe "#{channel} command execution" do 
+    before(:all) do
+      @channel = new_channel(channel.to_sym)
+      puts @channel
+    end
+
+    it 'should echo back a sudo command' do
+      @channel.sudo_command('test_command').should == "sudo test_command" unless channel.to_sym.eql? :winrm
+    end
+
+    it 'should execute a command sucessfully' do
+      @channel.execute('hostname').should == 0
+    end
+  end
+
+  describe "#{channel} shell execution" do
+    before(:all) do
+      @channel = new_channel(:winrm)
+    end
+
+    it 'should except when non-zero exit code is specified' do
+      expect {
+        @channel.shell_execute('exit 1')
+      }.to raise_error(Channelizer::Exceptions::BadExitCode, /1/)
+    end
+
+    it 'should NOT except when non-zero exit code is specified and it has been told not to' do
+      @channel.shell_execute('exit 1',:check_exit_code => false)
+    end
+
+    it 'should except based on custom error codes' do
+      expect {
+        @channel.shell_execute('exit 0', :exit_codes => [1,2])
+      }.to raise_error(Channelizer::Exceptions::BadExitCode, /0/)
+    end
+
+    it 'should return the exit code of the command' do
+      @channel.shell_execute('exit 1',:check_exit_code => false).should == 1
+    end
+
+    it 'should output stuff to the console' do
+      STDOUT.should_receive(:print).with("test message\r\n")
+      @channel.shell_execute('echo test message')
+    end
+
+    it 'should NOT output stuff to the console' do
+      STDOUT.should_not_receive(:print).with("test message\r\n")
+      @channel.shell_execute('echo test message', :out_console => false)
+    end
+  end
+
+  describe "#{channel} upload" do
+    before(:all) do
+      @channel = new_channel(channel.to_sym)
+    end
+
+    
+  end
+
+  describe "#{channel} interogatory methods" do
+    before(:all) do
+      @channel = new_channel(channel.to_sym)
+    end
+
+    it 'should be ready' do
+      @channel.ready?.should == true
+    end  
+  end
+end
+
+describe 'winrm specifc functionality' do
+    before(:all) do
+      @channel = new_channel(:winrm)
+    end
+
+    it 'should echo back a sudo command' do
+      @channel.sudo_command('test_command').should == "test_command"
+    end
+
+    it 'should execute in powershell when requested' do
+      @channel.execute('dir ENV:\\', :shell => :powershell).should == 0
+      @channel.execute('dir ENV:\\').should == 1
+    end
+
+    it 'should upload a file' do
+      @channel.upload('./spec/test_data/test_file.txt', 'C:\test_file.txt')
+      STDOUT.should_receive(:print).with("This is a test upload")
+      (@channel.execute "type test_file.txt") == 0     
+
+    end
+
+end
+
+describe 'ssh specifc functionality' do
+    before(:all) do
+      @channel = new_channel(:ssh)
+    end
+
+    it 'should upload a file' do
+      @channel.upload('./spec/test_data/test_file.txt', '/tmp/test_file.txt')
+      STDOUT.should_receive(:print).with("This is a test upload")
+      (@channel.execute "cat /tmp/test_file.txt") == 0     
+
+    end
+
+end
+

data/spec/winrm_options_spec.rb

@@ -0,0 +1,38 @@
+require 'channel_helper.rb'
+
+describe "winrm option parsing" do 
+  it 'should require a host' do
+    expect {
+      Channelizer::Factory.build_channel(:winrm, :username => 'vagrant', :password => 'vagrant', :port => 5985)
+    }.to raise_error(ArgumentError, /host is a required option/)
+  end
+
+  it 'should use the default port' do
+      Channelizer::Factory.build_channel(:winrm, :host => 'localhost', :username => 'vagrant', :password => 'vagrant')
+  end
+
+  # Requires a wokring kerberos setup
+  #it 'should not require username and password if kerberos is specified' do
+  #  Channelizer::Factory.build_channel(:winrm, :host => 'localhost', :realm => 'test')
+  #end
+
+  it 'should require a username and password' do
+    expect {
+      Channelizer::Factory.build_channel(:winrm, :host => 'localhost')
+    }.to raise_error(ArgumentError, /You must specify one of \[\[\:username, \:password\]/)  
+  end
+
+  it 'should require a username even if a password is given' do
+    expect {
+      Channelizer::Factory.build_channel(:winrm, :host => 'localhost', :password => 'vagrant')
+    }.to raise_error(ArgumentError, /You must specify one of \[\[\:username, \:password\]/)  
+  end
+
+  it 'should require a password even if a username is given' do
+    expect {
+      Channelizer::Factory.build_channel(:winrm, :host => 'localhost', :username => 'vagrant')
+    }.to raise_error(ArgumentError, /You must specify one of \[\[\:username, \:password\]/)  
+  end
+
+end
+

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: channelizer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Paul Morton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: winrm
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.2
+- !ruby/object:Gem::Dependency
+  name: net-scp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A gem that abstracts shell and upload channels
+email:
+- pmorton@biaprotect.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- channelizer.gemspec
+- lib/channelizer.rb
+- lib/channelizer/channels/base.rb
+- lib/channelizer/channels/ssh.rb
+- lib/channelizer/channels/winrm.rb
+- lib/channelizer/exceptions/exceptions.rb
+- lib/channelizer/factory.rb
+- lib/channelizer/util/retryable.rb
+- lib/channelizer/version.rb
+- spec/channel_helper.rb
+- spec/test_data/test_file.txt
+- spec/winrm_form_spec.rb
+- spec/winrm_functional_spec.rb
+- spec/winrm_options_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -721956935773256320
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -721956935773256320
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Test
+test_files:
+- spec/channel_helper.rb
+- spec/test_data/test_file.txt
+- spec/winrm_form_spec.rb
+- spec/winrm_functional_spec.rb
+- spec/winrm_options_spec.rb