ruby-eql 0.0.1

data/History.txt

@@ -0,0 +1,7 @@
+=== 0.0.1 / 2008-05-28
+
+* Initial release 
+
+  * Birthday!
+  * Test release.
+

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+Todo.txt
+examples/ssh_show_members_with_volumes.rb
+examples/telnet_options_file_show_version.rb
+lib/eql.rb
+lib/eql/cli.rb
+lib/netsshtelnet.rb
+test/test_eql.rb

data/README.txt

@@ -0,0 +1,56 @@
+= ruby-eql 
+
+* http://ruby-eql.rubyforge.org
+* mailto:matt@bravenet.com
+
+== DESCRIPTION:
+
+Ruby module to make interacting with the Equallogic PSxxxE series command line
+interface a breeze.
+
+Initial development and testing done with firmware V3.3.1 and PS100E/PS300E
+series arrays.
+
+== FEATURES/PROBLEMS:
+
+* No testing with the latest PS5000x arrays, if you have one, let me know.
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* net-ssh 
+
+== INSTALL:
+
+* sudo gem install ruby-eql
+
+== LICENSE:
+
+This product is in no way sponsored, endorsed or associated with Dell Inc. or
+EqualLogic Inc.
+
+(The MIT License)
+
+Copyright (c) 2008 Matthew Kent, Bravenet Web Services Inc. 
+
+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/Rakefile

@@ -0,0 +1,14 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+$:.unshift(File.dirname(__FILE__) + "/lib")
+require 'eql'
+
+Hoe.new('ruby-eql', Eql::VERSION) do |p|
+  p.developer('Matthew Kent', 'matt@bravenet.com')
+  p.extra_deps << ['net-ssh', '>= 2.0.1']
+  p.remote_rdoc_dir = ''
+end
+
+# vim: syntax=Ruby

data/Todo.txt

@@ -0,0 +1,5 @@
+= to do
+
+== 0.1.0
+* proper documentation.
+* basic test suite.

data/examples/ssh_show_members_with_volumes.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/ruby
+
+$: << File.dirname(__FILE__) + "/../lib"
+
+require 'eql'
+
+san = Eql::GroupManager.open(
+      :method => 'ssh',
+      :host => 'eql.foo.com', 
+      :username => 'grpadmin', 
+      :password => 'pass', 
+      :timeout => 3,
+      # nb: In telnet mode will print your user/password into the log, though
+      # in ssh it won't.
+      :session_log => "debug.log"
+    )
+
+begin
+
+  puts "= Group Volumes ="
+  san.volumes.each do |v|
+    puts "* volume #{v.name}"
+    san.snapshots(v.name).each do |s|
+      puts "** snapshot #{s.name}"
+    end
+  end
+
+  puts ""
+
+  puts "= Group Members ="
+  san.members.each do |m|
+    puts "* member #{m.name}"
+    
+    Eql::CliTable.parse(san.raw("member select #{m.name} show volumes")).each do |v|
+      puts "** volume #{v.volume_name} (contribution #{v.contribution})" 
+    end
+  end
+
+  puts ""
+
+  san.raw("member select thisshouldfail")
+
+rescue Eql::GroupManager::GroupManagerError => e
+  puts "Error, GroupManager says '#{e}' :("
+end
+
+san.close

data/examples/telnet_options_file_show_version.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/ruby
+
+$: << File.dirname(__FILE__) + "/../lib"
+
+require 'eql'
+
+san = Eql::GroupManager.open(
+      :method => 'telnet',
+      :host => 'eql.foo.com', 
+      :timeout => 5, 
+      # This file can contain any of the options here, in this case it contains
+      # just our secret user/password, this file is set chmod 400 and doesn't
+      # have to live in source control.
+      :options_file => ENV['HOME'] + '/.eql_secrets.yaml'
+    )
+
+begin
+
+  member = san.members[0]
+  puts "#{member.name} version is #{member.version}."
+
+rescue Eql::GroupManager::GroupManagerError => e
+  puts "Error, GroupManager says '#{e}' :("
+end
+
+san.close

data/lib/eql/cli.rb

@@ -0,0 +1,227 @@
+require 'ostruct'
+
+module Eql
+  class CliTable
+    EQL_CLI_COLUMN_SEP = '-'
+    EQL_CLI_WRAPPED_INDENT = '  '
+
+    # Utility class to handle the unwrapping and interpreting of the Equallogic
+    # tables
+    #
+    # eg :
+    # eql2-Mirror> show volume
+    # Name            Size       SnapShots Status         Permission Connections TP
+    # --------------- ---------- --------- -------------- ---------- ----------- -
+    # shared          750GB      6         online         read-write 1           N
+    # shared.1        1000GB     0         online         read-write 0           Y
+    # backups.1       2000GB     1         online         read-write 1           Y
+    # eql2-Mirror>  
+    #
+    # this is made even more difficult by how they wrap
+    #
+    # eql2-Mirror> show member
+    # Name       Status  Version    Disks Capacity   FreeSpace  Connections
+    # ---------- ------- ---------- ----- ---------- ---------- -----------
+    # eql2       online  V3.3.1 (R6 14    6695.86GB  2908.3GB   3
+    #                      8703)
+    # eql2-Mirror>  
+
+    class<<self
+      # take string or array of raw cli output which includes a typical 
+      # equallogic table, process it and return an array of openstruct objects or yield each one
+      # eg:
+      #
+      # CliTable.parse(raw("show volume")
+      #
+      # input is pretty sensitive to format changes
+      def parse(raw_output)
+        table = raw_output
+
+        if raw_output.kind_of?(String)
+          table = raw_output.split("\n")
+        end
+
+        result = []
+
+        # Drop truely empty lines because some commands output them
+        # eg: volume select <vol> show access
+        table.each do |line|
+          if line.strip.length == 0
+            table.delete(line)
+          end
+        end
+
+        # Drop command
+        table.shift
+        # and prompt
+        table.pop
+
+        table = unwrap(table)
+
+        # Grab headers
+        # No multi line headers from what I see 
+        headers = table.shift
+
+        # Convert them to simple symbols
+        attributes = []
+        headers.each do |h|
+            # cleanup whitespace
+            prep = h
+            prep.strip!
+            prep.downcase!
+            prep.gsub!(%r{\s}, '_')
+            attributes << prep.to_sym
+        end
+        
+        # drop the header separator line
+        table.shift
+
+        # Now each row of output gets converted to its own object
+        tmp = {}
+        table.each do |line|
+          i = 0
+          line.each do |column|
+            tmp[attributes[i]] = column.strip
+            i += 1
+          end
+  
+          row = OpenStruct.new(tmp)
+          if block_given?
+            yield row
+          else
+            result << row
+          end
+        end
+  
+        result
+      end     
+      
+      # Returns a Regexp object matching column widths determined by examining our
+      # column seperator line
+      def get_filter(lines = [], columnsep = EQL_CLI_COLUMN_SEP) #:nodoc:
+        last = filter = nil
+      
+        lines.each do |line|
+          # assume just whitespace and columnsep means our column headers were on the
+          # previous line
+          if line =~ %r{^[#{columnsep} ]+$}
+
+            # okay this is fun
+            tmp = String.new
+            column_width = 0
+
+            # walk through the line
+            line.length.times do |pos|
+              # collecting column width based on seperator
+              if line[pos].chr == columnsep
+                column_width += 1
+              # end of column, but!
+              elsif line[pos].chr == ' '
+                # check our headers above us, sometimes the column header is
+                # larger than the field seperator as in 'show volume' eg:
+                #
+                # Name            Size       SnapShots Status         Permission Connections TP
+                # --------------- ---------- --------- -------------- ---------- ----------- -
+                # shared          750GB      5         online         read-write 1           N
+                mark = pos
+                # enlarge the filter to capture the header as well, makes for a
+                # proper attribute name later when we form the object
+                while mark+1 <= last.length and last[mark].chr != ' '
+                  column_width += 1
+                  mark += 1
+                end
+                tmp << "(.{#{column_width}}) "
+                column_width = 0
+              end
+            end
+            tmp.chop!
+            # hooray!
+            filter = %r{#{tmp}}
+            break
+          end
+      
+          last = line
+        end
+      
+        filter
+      end
+      
+      # break table into arrays of unwrapped data, yield array in block or
+      # return all arrays 
+      def unwrap(lines = [], filter = nil, indented = EQL_CLI_WRAPPED_INDENT) #:nodoc:
+        previous_columns = nil
+        rows = []
+ 
+        if filter.nil?
+          filter = get_filter(lines)
+        end
+ 
+        collecting = true
+        # reversed seemed easier to parse
+        lines.reverse.each do |line|
+          # get our columns and drop the 'match all' entry
+          columns = filter.match(line).to_a
+          columns.shift
+  
+          # step through the columns
+          i = 0
+          columns.each do |field|
+            # wrapped entries begin with indentation, its the only way to tell
+            # they are wrapped.
+            if field =~ %r{^#{indented}}
+              # we are building a line
+              collecting = true
+            else
+              # assume its done
+              collecting = false
+            end
+            if previous_columns.nil? == false and previous_columns[i].nil? == false
+              # append the last lines data to this new one, drop the indendation
+              columns[i] << previous_columns[i][(indented.length)..(previous_columns[i].length)]
+            end
+            i += 1
+          end
+  
+          # collect finished lines and reset 
+          if collecting == false
+            rows << columns 
+            previous_columns = nil
+          else
+            previous_columns = columns
+          end
+        end
+        
+        rows.reverse!
+  
+        if block_given?
+          rows.each do |row|
+            yield row
+          end
+        else
+          rows
+        end
+      end
+
+      def get_headers(lines = [], filter = nil, columnsep = EQL_CLI_COLUMN_SEP) #:nodoc:
+        last = nil
+
+        if filter.nil?
+          filter = get_filter(lines)
+        end
+
+        lines.each do |line|
+          # assume just whitespace and columnsep means our column headers were on the
+          # previous line
+          if line =~ %r{^[#{columnsep} ]+$}
+            ret = filter.match(last).to_a
+            ret.shift
+            return ret
+          end
+           
+          last = line
+        end
+      end
+  
+    end # self
+  end # class
+end # module

data/lib/eql.rb

@@ -0,0 +1,164 @@
+# FIXME: proper rdoc summary here
+
+require 'net/telnet'
+require 'yaml'
+
+require 'netsshtelnet'
+require 'eql/cli'
+
+module Eql
+  VERSION = '0.0.1'
+  COMPAT_VERSION = 'V3.3.1 (R68703)'
+
+  class GroupManager 
+    class GroupManagerError < Exception; end
+
+    attr_reader :ops
+
+    # Safer!
+    DEFAULT_METHOD = 'ssh'
+
+    DEFAULT_HOST = '127.0.0.1'
+    DEFAULT_SSH_PORT = 22
+    DEFAULT_TELNET_PORT = 23
+    DEFAULT_TIMEOUT = 10
+
+    DEFAULT_USERNAME = 'grpadmin'
+    DEFAULT_PASSWORD = 'grpadmin'
+
+    # Typical command prompt
+    PROMPT = %r{^\S+>\s.*$}
+    # Eql tty doesn't translate \n to \r\n
+    TERMINATOR = "\r"
+
+    # An options_file can be specified as well to keep user/passwords secret or
+    # abstract the config from code. It should be a yaml hash consisting of any
+    # of the 'args[]' below in the following format 
+    #
+    # ---
+    # :username: <user>
+    # :password: <pass>
+    # :method: [ssh|telnet]
+    # :host: <etc..>
+    #
+    # See examples/
+    def initialize(args = {})
+
+      # Pecking order:
+      # args > options_file > Defaults 
+      if args[:options_file]
+        tmp = YAML.load_file(args[:options_file])
+        args = tmp.merge(args)
+      end
+
+      # Setup some standard, and non standard net::ssh/net::telnet options for
+      # our connection
+      @ops = {
+        # nb: method isn't used by ssh/telnet, just here for consistency
+        "Method"     => args[:method]      || DEFAULT_METHOD,
+        "Host"       => args[:host]        || DEFAULT_HOST,
+        "Port"       => args[:port]        || nil,
+        "Timeout"    => args[:timeout]     || DEFAULT_TIMEOUT,
+        # nb: Telnet doesn't use user/pass in this hash, but net::ssh does
+        "Username"   => args[:username]    || DEFAULT_USERNAME,
+        "Password"   => args[:password]    || DEFAULT_PASSWORD,
+        "Dump_log"   => args[:session_log] || nil,
+        "Prompt"     => PROMPT,
+        # nb: Just net::ssh, net::telnet is autodetected
+        "Terminator" => TERMINATOR,
+      }
+
+      # Don't pass it at all if undefined, they will try to open it
+      @ops.delete("Dump_log") if @ops["Dump_log"].nil?
+
+      if @ops["Method"] == "ssh"
+        @ops["Port"] = DEFAULT_SSH_PORT if @ops["Port"].nil?
+
+        @connection = Net::SSH::Telnet::new(@ops)
+      elsif @ops["Method"] == "telnet" 
+        @ops["Port"] = DEFAULT_TELNET_PORT if @ops["Port"].nil?
+
+        @connection = Net::Telnet::new(@ops) 
+        @connection.login(@ops["Username"], @ops["Password"])
+      end
+
+      # Wish these were per session.. they could be read and restored on close
+      # but the that would likely break down quickly.
+      #
+      # Make output easier to parse
+      raw("cli-settings paging off")
+      raw("cli-settings confirmation off")
+      raw("cli-settings formatoutput off")
+      # Keep spurious info off of terminal
+      raw("cli-settings events off")
+
+      # Finally set the display as wide as possible, this IS per session
+      # thankfully
+      raw("stty rows 256")
+      raw("stty columns 255")
+      raw("stty hardwrap off")
+    end
+
+    def self.open(args = {})
+      new(args)
+    end
+
+    def close 
+      @connection.close
+    end
+
+    # Run an arbitrary command on the cli. Returning a String or yielding on 
+    # newlines in a block.
+    def raw(args)
+      timeout = @ops["Timeout"]
+
+      if args.kind_of?(Hash)
+        cmd = args[:cmd]
+        timeout = args[:timeout] || timeout
+      else
+        cmd = args
+      end
+
+      data = @connection.cmd("String" => cmd, "Timeout" => timeout)
+
+      # Errors seem to be in these formats:
+      #
+      # Error: Too many parameters
+      # or
+      # % Error - Member xxx does not exist.
+      if data =~ %r{Error(:| -) (.*)\s?$}
+        raise GroupManagerError.new($2)
+      end
+        
+      if block_given?
+        data.split("\n").each do |l|
+          yield l
+        end
+      else
+        data 
+      end
+    end
+    
+    # A few helper methods
+    #
+    # Next level of abstraction would be to create volume/member etc obj which
+    # would be do all the data conversion and be returned
+
+    # Get all available group volumes, returning the resulting Array
+    def volumes
+      CliTable.parse(raw("show volume"))
+    end
+
+    # Get all available group members, returning the resulting Array
+    def members
+      CliTable.parse(raw("show member"))
+    end
+
+    # Get all available snapshots on a given volume, returning the resulting
+    # Array 
+    def snapshots(volume)
+      CliTable.parse(raw("volume select #{volume} show snapshots"))
+    end
+
+  end # end class
+end # end module

data/lib/netsshtelnet.rb

@@ -0,0 +1,433 @@
+# Based on code in net/telnet.rb by Wakou Aoyama <wakou@ruby-lang.org>
+# Modified to work with Net::SSH by Brian Candler <b.candler@pobox.com>
+
+require 'rubygems'
+require 'net/ssh'
+ 
+module Net
+module SSH
+
+  # == Net::SSH::Telnet
+  #
+  # Provides a simple send/expect interface with an API almost
+  # identical to Net::Telnet. Please see Net::Telnet for main documentation.
+  # Only the differences are documented here.
+  
+  class Telnet
+
+    CR   = "\015"
+    LF   = "\012"
+    EOL  = CR + LF
+    REVISION = '$Id$'
+
+    # Wrapper to emulate the behaviour of Net::Telnet "Proxy" option, where
+    # the user passes in an already-open socket
+
+    class TinyFactory
+      def initialize(sock)
+        @sock = sock
+      end
+      def open(host, port)
+        s = @sock
+        @sock = nil
+        s
+      end
+    end
+
+    # Creates a new Net::SSH::Telnet object.
+    #
+    # The API is similar to Net::Telnet, although you will need to pass in
+    # either an existing Net::SSH::Session object or a Username and Password,
+    # as shown below.
+    #
+    # Note that unlike Net::Telnet there is no preprocess method automatically
+    # setting up options related to proper character translations, so if your 
+    # remote ptty is configured differently than the typical linux one you may 
+    # need to pass in a different terminator or call 'stty' remotely to set it 
+    # into an expected mode. This is better explained by the author of perl's 
+    # Net::SSH::Expect here:
+    #
+    # http://search.cpan.org/~bnegrao/Net-SSH-Expect-1.04/lib/Net/SSH/Expect.pod
+    # #IMPORTANT_NOTES_ABOUT_DEALING_WITH_SSH_AND_PSEUDO-TERMINALS
+    #
+    # though for most installs the default LF should be fine. See example 5
+    # below.
+    #
+    # A new option is added to correct a misfeature of Net::Telnet. If you
+    # pass "FailEOF" => true, then if the remote end disconnects while you
+    # are still waiting for your match pattern then an EOFError is raised.
+    # Otherwise, it reverts to the same behaviour as Net::Telnet, which is
+    # just to return whatever data was sent so far, or nil if no data was
+    # returned so far. (This is a poor design because you can't tell whether
+    # the expected pattern was successfully matched or the remote end
+    # disconnected unexpectedly, unless you perform a second match on the
+    # return string). See
+    # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/11373
+    # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/11380
+    #
+    # Example 1 - pass existing Net::SSH::Session object
+    #
+    #   ssh = Net::SSH.start("127.0.0.1",
+    #         :username=>"test123",
+    #         :password=>"pass456"
+    #   )
+    #   s = Net::SSH::Telnet.new(
+    #         "Dump_log" => "/dev/stdout",
+    #         "Session" => ssh
+    #   )
+    #   puts "Logged in"
+    #   p s.cmd("echo hello")
+    #
+    # This is the most flexible way as it allows you to set up the SSH
+    # session using whatever authentication system you like. When done this
+    # way, calling Net::SSH::Telnet.new multiple times will create
+    # multiple channels, and #close will only close one channel.
+    #
+    # In all later examples, calling #close will close the entire
+    # Net::SSH::Session object (and therefore drop the TCP connection)
+    #
+    # Example 2 - pass host, username and password
+    #
+    #   s = Net::SSH::Telnet.new(
+    #           "Dump_log" => "/dev/stdout",
+    #           "Host" => "127.0.0.1",
+    #           "Username" => "test123",
+    #           "Password" => "pass456"
+    #   )
+    #   puts "Logged in"
+    #   puts s.cmd("echo hello")
+    #
+    # Example 3 - pass open IO object, username and password (this is really
+    # just for compatibility with Net::Telnet Proxy feature)
+    #
+    #   require 'socket'
+    #   sock = TCPSocket.open("127.0.0.1",22)
+    #   s = Net::SSH::Telnet.new(
+    #           "Dump_log" => "/dev/stdout",
+    #           "Proxy" => sock,
+    #           "Username" => "test123",
+    #           "Password" => "pass456"
+    #   )
+    #   puts "Logged in"
+    #   puts s.cmd("echo hello")
+    #
+    # Example 4 - pass a connection factory, host, username and password;
+    # Net::SSH will call #open(host,port) on this object. Included just
+    # because it was easy :-)
+    #
+    #   require 'socket'
+    #   s = Net::SSH::Telnet.new(
+    #           "Dump_log" => "/dev/stdout",
+    #           "Factory" => TCPSocket,
+    #           "Host" => "127.0.0.1",
+    #           "Username" => "test123",
+    #           "Password" => "pass456"
+    #   )
+    #   puts "Logged in"
+    #   puts s.cmd("echo hello")
+    #
+    # Example 5 - connection to a SAN device running a customized NetBSD with
+    # different ptty defaults, it doesn't convert LF -> CR+LF (see the man
+    # page for 'stty')
+    #
+    #   require 'socket'
+    #   s = Net::SSH::Telnet.new(
+    #           "Dump_log" => "/dev/stdout",
+    #           "Factory" => TCPSocket,
+    #           "Host" => "192.168.1.1",
+    #           "Username" => "test123",
+    #           "Password" => "pass456",
+    #           "Terminator" => "\r"
+    #   )
+    #   puts "Logged in"
+    #   puts s.cmd("show alerts")
+
+    def initialize(options, &blk) # :yield: mesg
+      @options = options
+      @options["Host"]       = "localhost"   unless @options.has_key?("Host")
+      @options["Port"]       = 22            unless @options.has_key?("Port")
+      @options["Prompt"]     = /[$%#>] \z/n  unless @options.has_key?("Prompt")
+      @options["Timeout"]    = 10            unless @options.has_key?("Timeout")
+      @options["Waittime"]   = 0             unless @options.has_key?("Waittime")
+      @options["Terminator"] = LF            unless @options.has_key?("Terminator")
+
+      unless @options.has_key?("Binmode")
+        @options["Binmode"]    = false
+      else
+        unless (true == @options["Binmode"] or false == @options["Binmode"])
+          raise ArgumentError, "Binmode option must be true or false"
+        end
+      end
+
+      if @options.has_key?("Output_log")
+        @log = File.open(@options["Output_log"], 'a+')
+        @log.sync = true
+        @log.binmode
+      end
+
+      if @options.has_key?("Dump_log")
+        @dumplog = File.open(@options["Dump_log"], 'a+')
+        @dumplog.sync = true
+        @dumplog.binmode
+        def @dumplog.log_dump(dir, x)  # :nodoc:
+          len = x.length
+          addr = 0
+          offset = 0
+          while 0 < len
+            if len < 16
+              line = x[offset, len]
+            else
+              line = x[offset, 16]
+            end
+            hexvals = line.unpack('H*')[0]
+            hexvals += ' ' * (32 - hexvals.length)
+            hexvals = format("%s %s %s %s  " * 4, *hexvals.unpack('a2' * 16))
+            line = line.gsub(/[\000-\037\177-\377]/n, '.')
+            printf "%s 0x%5.5x: %s%s\n", dir, addr, hexvals, line
+            addr += 16
+            offset += 16
+            len -= 16
+          end
+          print "\n"
+        end
+      end
+
+      if @options.has_key?("Session")
+        @ssh = @options["Session"]
+        @close_all = false
+      elsif @options.has_key?("Proxy")
+        @ssh = Net::SSH.start(@options["Host"],  # ignored
+                :port => @options["Port"],       # ignored
+                :username => @options["Username"],
+                :password => @options["Password"],
+                :timeout => @options["Timeout"],
+                :proxy => TinyFactory.new(@options["Proxy"]),
+                :log => (@log ? @log : STDERR)
+        )
+        @close_all = true
+      else
+        message = "Trying " + @options["Host"] + "...\n"
+        yield(message) if block_given?
+        @log.write(message) if @options.has_key?("Output_log")
+        @dumplog.log_dump('#', message) if @options.has_key?("Dump_log")
+
+        begin
+          @ssh = Net::SSH.start(@options["Host"],
+                :port => @options["Port"],
+                :username => @options["Username"],
+                :password => @options["Password"],
+                :timeout => @options["Timeout"],
+                :proxy => @options["Factory"],
+                :log => (@log ? @log : STDERR)
+          )
+          @close_all = true
+        rescue TimeoutError
+          raise TimeoutError, "timed out while opening a connection to the host"
+        rescue
+          @log.write($ERROR_INFO.to_s + "\n") if @options.has_key?("Output_log")
+          @dumplog.log_dump('#', $ERROR_INFO.to_s + "\n") if @options.has_key?("Dump_log")
+          raise
+        end
+
+        message = "Connected to " + @options["Host"] + ".\n"
+        yield(message) if block_given?
+        @log.write(message) if @options.has_key?("Output_log")
+        @dumplog.log_dump('#', message) if @options.has_key?("Dump_log")
+      end
+
+      @buf = ""
+      @eof = false
+      @channel = nil
+      state = nil
+      @ssh.open_channel do |channel|
+        channel.on_success { |ch|
+          case state
+          when :pty
+            state = :shell
+            channel.send_request "shell", nil, true
+          when :shell
+            state = :prompt
+            @channel = ch
+            waitfor(@options['Prompt'], &blk)
+            return
+          end
+        }
+        channel.on_failure { |ch|
+          case state
+          when :pty
+            state = :shell
+            channel.send_request "shell", nil, true
+          else
+            ch.close
+            raise "Failed to open ssh #{state}"
+          end
+        }
+        channel.on_data { |ch,data| @buf << data }
+        channel.on_extended_data { |ch,type,data| @buf << data if type == 1 }
+        channel.on_close { @eof = true }
+        state = :pty
+        channel.request_pty(:want_reply => true)
+      end
+      @ssh.loop
+    end # initialize
+
+    # Close the ssh channel, and also the entire ssh session if we
+    # opened it.
+
+    def close
+      @channel.close if @channel
+      @channel = nil
+      @ssh.close if @close_all and @ssh
+    end
+        
+    # The ssh session and channel we are using.
+    attr_reader :ssh, :channel
+
+    # Turn newline conversion on (+mode+ == false) or off (+mode+ == true),
+    # or return the current value (+mode+ is not specified).
+    def binmode(mode = nil)
+      case mode
+      when nil
+        @options["Binmode"]
+      when true, false
+        @options["Binmode"] = mode
+      else
+        raise ArgumentError, "argument must be true or false"
+      end
+    end
+
+    # Turn newline conversion on (false) or off (true).
+    def binmode=(mode)
+      if (true == mode or false == mode)
+        @options["Binmode"] = mode
+      else
+        raise ArgumentError, "argument must be true or false"
+      end
+    end
+
+    # Read data from the host until a certain sequence is matched.
+
+    def waitfor(options) # :yield: recvdata
+      time_out = @options["Timeout"]
+      waittime = @options["Waittime"]
+      fail_eof = @options["FailEOF"]
+
+      if options.kind_of?(Hash)
+        prompt   = if options.has_key?("Match")
+                     options["Match"]
+                   elsif options.has_key?("Prompt")
+                     options["Prompt"]
+                   elsif options.has_key?("String")
+                     Regexp.new( Regexp.quote(options["String"]) )
+                   end
+        time_out = options["Timeout"]  if options.has_key?("Timeout")
+        waittime = options["Waittime"] if options.has_key?("Waittime")
+        fail_eof = options["FailEOF"]  if options.has_key?("FailEOF")
+      else
+        prompt = options
+      end
+
+      if time_out == false
+        time_out = nil
+      end
+
+      line = ''
+      buf = ''
+      rest = ''
+      # We want to use #read_ready?(maxwait) but it's not available
+      sock = @ssh.connection.instance_variable_get(:@session).instance_variable_get(:@socket)
+
+      until prompt === line and ((@eof and @buf == "") or not IO::select([sock], nil, nil, waittime))
+        while @buf == "" and !@eof
+          unless IO::select([sock], nil, nil, time_out)
+            raise TimeoutError, "timed out while waiting for more data"
+          end
+          # Note: this could hang if partial message received. Should we
+          # wrap with timeout { ... } instead?
+          @channel.connection.process
+        end
+        if @buf != ""
+          c = @buf; @buf = ""
+          @dumplog.log_dump('<', c) if @options.has_key?("Dump_log")
+          buf = c
+          buf.gsub!(/#{EOL}/no, "\n") unless @options["Binmode"]
+          rest = ''
+          @log.print(buf) if @options.has_key?("Output_log")
+          line += buf
+          yield buf if block_given?
+        elsif @eof # End of file reached
+          break if prompt === line
+          raise EOFError if fail_eof
+          if line == ''
+            line = nil
+            yield nil if block_given?
+          end
+          break
+        end
+      end
+      line
+    end
+
+    # Write +string+ to the host.
+    #
+    # Does not perform any conversions on +string+.  Will log +string+ to the
+    # dumplog, if the Dump_log option is set.
+    def write(string)
+      @dumplog.log_dump('>', string) if @options.has_key?("Dump_log")
+      @channel.send_data string
+      @channel.connection.process true
+    end
+
+    # Sends a string to the host.
+    #
+    # This does _not_ automatically append a newline to the string.  Embedded
+    # newlines may be converted depending upon the values of binmode or
+    # terminator.
+    def print(string)
+      terminator = @options["Terminator"]
+
+      if @options["Binmode"]
+        self.write(string)
+      else
+        self.write(string.gsub(/\n/n, terminator))
+      end
+    end
+
+    # Sends a string to the host.
+    #
+    # Same as #print(), but appends a newline to the string.
+    def puts(string)
+      self.print(string + "\n")
+    end
+
+    # Send a command to the host.
+    #
+    # More exactly, sends a string to the host, and reads in all received
+    # data until is sees the prompt or other matched sequence.
+    #
+    # The command or other string will have the newline sequence appended
+    # to it.
+
+    def cmd(options) # :yield: recvdata
+      match    = @options["Prompt"]
+      time_out = @options["Timeout"]
+
+      if options.kind_of?(Hash)
+        string   = options["String"]
+        match    = options["Match"]   if options.has_key?("Match")
+        time_out = options["Timeout"] if options.has_key?("Timeout")
+      else
+        string = options
+      end
+
+      self.puts(string)
+      if block_given?
+        waitfor({"Prompt" => match, "Timeout" => time_out}){|c| yield c }
+      else
+        waitfor({"Prompt" => match, "Timeout" => time_out})
+      end
+    end
+
+  end  # class Telnet
+end  # module SSH
+end  # module Net

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: ruby-eql
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2008-05-30 00:00:00 -07:00
+summary: Ruby module to make interacting with the Equallogic PSxxxE series command line interface a breeze
+require_paths: 
+- lib
+email: 
+- matt@bravenet.com
+homepage: http://ruby-eql.rubyforge.org
+rubyforge_project: ruby-eql
+description: Ruby module to make interacting with the Equallogic PSxxxE series command line interface a breeze.  Initial development and testing done with firmware V3.3.1 and PS100E/PS300E series arrays.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDMDCCAhigAwIBAgIBADANBgkqhkiG9w0BAQUFADA+MQ0wCwYDVQQDDARtYXR0
+  MRgwFgYKCZImiZPyLGQBGRYIYnJhdmVuZXQxEzARBgoJkiaJk/IsZAEZFgNjb20w
+  HhcNMDgwNTI5MjM1MDUwWhcNMDkwNTI5MjM1MDUwWjA+MQ0wCwYDVQQDDARtYXR0
+  MRgwFgYKCZImiZPyLGQBGRYIYnJhdmVuZXQxEzARBgoJkiaJk/IsZAEZFgNjb20w
+  ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDDGVrJnpk6/hCO5lg6T7As
+  unEksqdmCly6GkRpX0cVxusWG/wbjrZw4Ka5x9pSS2m3GfefEpu5CuWH9wnGB/q0
+  LwbWhrkpQb+uNVD6hEbQcngDEiQbiitaSWZKSvrIymbM5Tl92rIScmvx7Pd7l8tz
+  BLndL/DmrBHrHWQ47xLxOmBAA4NJy0gk7HdsdAFfJwrEoC14AAXqcI3X0qU3KGrr
+  9Fs0jVeIKktx3fthwGVPrpYrMIw3xgiUqOqn7M+V4soD013dopaN7orewmCm9dQL
+  4N06FMnGNjwFaS6+MV612nk8gkVpJwgcwTHE1GNt2NItR5zeK6j+AZ01DijYdjH9
+  AgMBAAGjOTA3MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQ6jcdN
+  QqNNsx2XxigfTWE0Owy0XzANBgkqhkiG9w0BAQUFAAOCAQEAvWBkYaD7eKP+KHxJ
+  dtQuaebQTZvBX4vjk/Omjn7hj7u8X8aTvmCKyopnmywiApFH1zgDa8NRc1KTsvZt
+  zhSRWIuI7fFB+JFZUatE7Nius56id9UchYO98569t6bNU284XwBtcj4MN5Andfcp
+  LKdUNuuT0yui1InJG4fD0uKnOS1qcXEm+mN2s1uqPGVltEHorG7L/bPNAw8xV+uq
+  NPc7hhQTkbi7HB2Uwxr9uK9IGHEE5tDVnsPWPnJJ4jSOc7Bd1eHZuSMkEPfyREDf
+  h9ljoX3AGXW8qYohFzGjflamaWZ4xYaKZSNqS2i0Kc+M76Sy+r9FldDRNn4FGUBE
+  JqYgHg==
+  -----END CERTIFICATE-----
+
+post_install_message: 
+authors: 
+- Matthew Kent
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- Todo.txt
+- examples/ssh_show_members_with_volumes.rb
+- examples/telnet_options_file_show_version.rb
+- lib/eql.rb
+- lib/eql/cli.rb
+- lib/netsshtelnet.rb
+- test/test_eql.rb
+test_files: 
+- test/test_eql.rb
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Todo.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.3
+    version: 

metadata.gz.sig

@@ -0,0 +1,2 @@
+綛���޴
X�V7x�ނ5��u�K!�Z8�c����|��a�����l�%x���!��A;���
+.|�yF����1=s�DCN��>���_���n�VǞ�҃w���X�]��a�MO	�L�HJ;ԟ��P�s�3�s����MY!��'����"�\�w�d�+����_����;�\��f�E�P��%��l�{-�p�Z���i��t�#7=�u%42I�zu�!��aUM�l�3����3�QA�