tsm-command 1.2

data/README

@@ -0,0 +1,33 @@
+== Description
+        A wrapper for TSM dsmadmc and dsmc commands
+
+== Prerequisites
+        * Ruby 1.8.4 or later
+
+== Usage
+        t = TSM::Dsmadmc(id,pass)
+        t.open { |d|
+                d.command('q pr')
+                d.command('select count(*) from volumes')
+        }
+
+        TSM::Dsmadmc.command(id,pass,'q pr',{:se => :testserver})
+
+
+        class TestObserver
+                def update(msg)
+                        p msg
+                end
+        end
+
+        TSM::Dsmadmc(id,pass) { |t|
+                t.add_observer(TestObserver.new())
+                t.command('q pr')
+        }
+
+== Installation
+=== Manual Installation
+=== Gem Installation
+        gem install tsm-<version>.gem
+
+== Notes

data/lib/tsm.rb

@@ -0,0 +1,5 @@
+require 'tsm/error'
+require 'tsm/dsmio'
+require 'tsm/response'
+require 'tsm/dsmadmc'
+require 'tsm/dsm'

data/lib/tsm/dsm.rb

@@ -0,0 +1,69 @@
+module TSM
+        class Dsm
+                def self.opt(filename='dsm.opt')
+                        sys = {}
+                        self.new(filename) { |line|
+                                if (m = /^(\S+)(\s+)(\S+)/i.match(line))
+                                        sys[m[1].downcase.to_sym] = m[3]
+                                end
+                        }
+                        sys
+                end
+
+                def self.sys(filename='dsm.sys')
+                        sys = {} and hsh = {} and name = nil
+                        self.new(filename) { |line|
+                                if (m = /^se([a-zA-Z]*)(\s+)(\S+)/i.match(line))
+                                        sys[name] = hsh.dup if name
+                                        hsh.clear
+                                        name = m[3].downcase.to_sym
+                                        next
+                                end
+
+                                if (m = /^(\S+)(\s+)(\S+)/i.match(line))
+                                        k = m[1].downcase
+                                        if k[0..3] == 'incl'
+                                                h = {}
+                                                self.new(m[3]) { |i|
+                                                        if (n = /^(\S+)(\s+)(\S+)/.match(i))
+                                                                k2 = n[1].downcase
+                                                                h[k2] = [] unless h.has_key?(k2)
+                                                                h[k2].push(n[3])
+                                                        end
+                                                }
+                                                hsh[k.to_sym] = h.dup
+                                        else
+                                                hsh[k.to_sym] = m[3]
+                                        end
+                                end
+                        }
+                        sys[name] = hsh.dup if name
+                        sys
+                end
+
+                def initialize(filename,&block)
+                        process(filename) { |line|
+                                line = line.chomp
+                                line.strip!
+
+                                next if line[0..0] == '*' or line == ''
+
+                                yield line
+                        }
+                end
+
+                private
+
+                def process(name,&block)
+                        f = File.readable?(name) ? name : nil
+                        path = ['/opt/tivoli/tsm/client/ba/bin','/usr/tivoli/tsm/client/ba/bin']
+                        (ENV['PATH'].split(File::PATH_SEPARATOR) + path).each { |p|
+                                if File.readable?(x=File.join(p,name))
+                                        f = x
+                                end
+                        }
+
+                        IO.foreach(f) { |l| yield l } if f
+                end
+        end
+end

data/lib/tsm/dsmadmc.rb

@@ -0,0 +1,207 @@
+require 'pty'
+require 'observer'
+require 'parsedate'
+
+module TSM
+        class Dsmadmc
+                include Observable
+
+                FORCE_OPT = {:displ => 'list',:out => true,:noc => true}
+                FAKE_QUIT = {:command=>"quit", :messages=>[], :rows=>[], :count=>0}
+
+                @@path = ['/opt/tivoli/tsm/client/ba/bin','/usr/tivoli/tsm/client/ba/bin']
+                @@quit = true
+
+                attr_accessor :timeout
+                attr_reader :host, :header, :prompt
+                attr_reader :pty, :cmd
+
+                def self.command(id,password,command,opts = {})
+                        self.new(id,password,opts).command(command)
+                end
+
+                def self.quit?
+                        @@quit
+                end
+
+                def self.quit=(bool)
+                        @@quit = bool ? true : false
+                end
+
+                def initialize(id,password,opt = {},&block)
+                        @timeout = 60
+
+                        opt[:id] = id
+                        opt[:pa] = password
+
+                        args = [find(self.class.to_s.split(":").last.downcase)]
+
+                        opt.merge(FORCE_OPT).each{|k,v| args.push("-#{k.to_s}#{'=' << v.to_s if v.class != TrueClass}") }
+                        opt.each_key do |k|
+                                opt.each_key {|k2| opt.delete(k2) if k.to_s.casecmp(k2.to_s) == -1}
+                        end
+
+                        @cmd = args.join(" ")
+
+                        return self unless block_given?
+
+                        open(&block)
+                ensure
+                        close if block_given? and not closed?
+                end
+
+                def open(&block)
+                        ptyval = nil and success = false
+                        begin
+                        PTY.spawn(@cmd) { |r,w,pid|
+                                @header,@prompt,@host = r._dsm_prompt([/tsm: ([A-Z0-9]*)>/i,/Enter your password: /i],@timeout)
+                                parse(TSM::Response.new,@header.to_s).validate(TSM::Error::CommandError) if @host.to_s.empty?
+                                raise TSM::Error::FatalError if @host.to_s.empty?
+
+                                @established = Time.now()
+                                @pty = {:r => r,:w => w,:pid => pid}
+
+                                notify('open',{'host'=>@host})
+
+                                ptyval = yield self
+                                success = true
+                        }
+                        rescue PTY::ChildExited
+                        end
+
+                        raise TSM::Error::CommandError, 'Error establishing connection' if ptyval == nil and not success
+
+                        ptyval
+                ensure
+                        close if not closed?
+                end
+
+                def close
+                        notify('close',{'closed' => closed?})
+                        if @pty
+                                @pty[:r].close unless @pty[:r].closed?
+                                @pty[:w].close unless @pty[:w].closed?
+                        end
+                        @pty = nil
+                end
+
+                def closed?
+                        return true unless @pty
+                        return true if @pty[:r].closed? or @pty[:w].closed?
+
+                        begin
+                                Process.kill(0,@pty[:pid])
+                        rescue Errno::ESRCH
+                                return true
+                        end
+
+                        false
+                end
+
+                def command(cmd,&block)
+
+                        return self.open { |t| t.command(cmd,&block) } if closed?
+
+                        cmd.to_s.strip!
+
+                        notify('execute',{'command' => cmd,'closed'=>closed?})
+
+                        start = Time.now()
+
+                        res = nil
+                        if cmd =~ /quit/ and not @@quit
+                                res = TSM::Response.new(FAKE_QUIT)
+                        else
+                                res = TSM::Response.new
+                                @pty[:w].puts(cmd.to_s)
+                                @pty[:r]._dsm_response(@prompt) do |line| parse(res,line,&block) end
+                        end
+
+                        duration = Time.now() - start
+
+                        notify('complete',{'duration' => "%.2f" % duration,'rows' => res[:count] || 0})
+
+                        res
+                ensure
+                        close if cmd =~ /quit/ and @@quit
+                end
+
+                def server
+                        raise TSM::Error::PTYError, "No connection was established" unless @header
+
+                        svr = {}
+                        @header.each {|l|
+                                l = l.chomp
+                                l.strip!
+                                next if l.empty?
+
+                                if (m=/Command Line ([\S^-]+)([\s\S]+) - Version (\d+), Release (\d+), Level (\d(.\d))/i.match(l))
+                                        svr[:interface] = {:version => m[3],:release => m[4],:level =>m[5],:type => m[1].downcase}
+                                elsif (m=/Session established with server (\w+): (\S+)/i.match(l))
+                                        svr[:host] = {:hostname => m[1],:arch => m[2]}
+                                elsif (m=/Server Version (\d+), Release (\d+), Level (\d(.\d))/i.match(l))
+                                        svr[:version] = {:version => m[1],:release => m[2],:level => m[3]}
+                                elsif (m=/Server date.time: ([0-9\/]+) ([0-9:]+)(\s+)Last access: ([0-9\/]+) ([0-9:]+)/i.match(l))
+                                        svr[:established] = Time.local(*(ParseDate.parsedate("#{m[1]} #{m[2]}")))
+                                        svr[:access] = Time.local(*(ParseDate.parsedate("#{m[4]} #{m[5]}")))
+                                end
+                        }
+                        svr[:time] = @established if @established
+
+                        svr
+                end
+
+                def self.path=(path)
+                        @@path = [path].flatten
+                end
+                def self.path
+                        @@path
+                end
+
+                protected
+
+                def notify(st,opts = {})
+                        pid = @pty[:pid] if @pty
+                        changed and notify_observers(opts.merge({'status' => st,'time' => Time.now,'pid' => pid || 0}))
+                end
+
+                def find(name,path=@@path)
+                        path ||= ['/usr/local/bin']
+                        (ENV['PATH'].split(File::PATH_SEPARATOR) + path).each { |p|
+                                if File.executable?(f=File.join(p,name))
+                                        return f
+                                end
+                        }
+                end
+
+                def parse(res,chrs,&block)
+                        chrs.each { |line|
+                                line = line.chomp
+                                line.strip!
+
+                                if (m = res.message?(line))
+                                        res.messages(m[1],m[5]) and next
+                                end
+
+                                res[:command] = line and next unless res[:command]
+
+                                if line.empty? and not @tmp.empty?
+                                        res.rows(@tmp)
+
+                                        yield @tmp if block_given?
+
+                                        @tmp.clear
+
+                                        next
+                                end if @tmp
+
+                                if (sp = line.index(":")) != nil
+                                        @tmp = {} unless @tmp
+                                        @tmp[line[0...sp].downcase.tr(" ","_").to_sym] = line[(sp+1)..-1].lstrip
+                                end
+                        }
+
+                        res
+                end
+        end
+end

data/lib/tsm/dsmio.rb

@@ -0,0 +1,49 @@
+
+class IO
+        def _dsm_prompt(pat,timeout=9999999)
+                buf = ''
+                pat = [pat] unless pat.respond_to?('each')
+                result = nil
+                while true
+                        break if IO.select([self],nil,nil,timeout).nil?
+                        begin
+                                buf << getc.chr
+                        rescue Errno::EIO
+                                result = [buf,'']
+                        end
+
+                        pat.each { |p|
+                                if mat=p.match(buf)
+                                        result = [buf,*mat.to_a] and break
+                                end
+                        }
+                        break if result
+                end
+                result
+        end
+
+        def _dsm_response(str,timeout=9999999,&block)
+                tbuf = '' and buf = ''
+                mode = :chr
+                while true
+                        result = nil and break if IO.select([self],nil,nil,timeout).nil?
+                        if mode == :chr
+                                begin
+                                        tbuf << getc.chr
+                                rescue Errno::EIO
+                                        result = result.to_s
+                                        result << tbuf and break
+                                end
+                                buf << tbuf and tbuf = '' and mode = :line if str[0...tbuf.size] != tbuf
+                                buf << tbuf and result = buf and break if tbuf == str
+                                buf << tbuf if tbuf[-($/.size)..-1] == $/
+                                next
+                        end
+
+                        buf << gets and mode = :chr
+                        yield buf
+                        buf = ''
+                end 
+                result
+        end
+end

data/lib/tsm/error.rb

@@ -0,0 +1,8 @@
+module TSM
+        class Error < RuntimeError
+                class FatalError < Error; end
+                class CommandError < Error; end
+                class PTYError < Error; end
+                class NoData < Error; end
+        end
+end

data/lib/tsm/response.rb

@@ -0,0 +1,45 @@
+module TSM
+        class Response < Hash
+                def initialize(hsh = {})
+                        {:messages => [],:rows => [],:count => 0,:command => nil}.each do |k,v|
+                                if hsh.has_key?(k)
+                                        self.store(k,hsh[k])
+                                else
+                                        self.store(k,v)
+                                end
+                        end
+
+                        self
+                end
+
+                def message?(str)
+                        if (m = /(([ABDEI][DEKNC][ERSDNOUIP])(\d+)([IESWK])) (.*)/.match(str))
+                                return m
+                        end
+
+                        false
+                end
+
+                def messages(id,msg)
+                        self[:messages].push({:id=>id,:msg=>msg})
+                end
+
+                def rows(val)
+                        self[:rows].push(val.dup)
+                        self[:count] += 1
+                end
+
+                def validate(err=TSM::Error::FatalError)
+                        self[:messages].each do |msg|
+                                raise TSM::Error::NoData, msg[:msg] if msg[:id] =~ /ANR2034E/i
+                                raise err, msg[:msg] if msg[:id][-1..-1] =~ /^[ES]$/i
+                        end
+
+                        true
+                end
+
+                def to_hash
+                        Hash.new().replace(self)
+                end
+        end
+end

data/tests/ts_tsm.rb

@@ -0,0 +1,24 @@
+require 'tsm'
+
+require 'yaml'
+require 'test/unit'
+
+USER = YAML.load(File.open(File.expand_path("~/auth.yaml")))
+
+class TestTsm < Test::Unit::TestCase
+
+        def test_simple
+                assert_raise(TSM::Error::CommandError) {
+                        TSM::Dsmadmc.new(USER['user'],'pass') { |t| }
+                }
+
+                res = TSM::Dsmadmc.new(USER['user'],USER['pass']) { |t|
+                        assert_kind_of(Hash,t.server)
+                        assert_kind_of(TSM::Response,t.command('q pr'))
+                }
+
+                assert_kind_of(TSM::Dsmadmc,res)
+
+                assert_kind_of(TSM::Response,TSM::Dsmadmc.command(USER['user'],USER['pass'],'q pr'))
+        end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: tsm-command
+version: !ruby/object:Gem::Version 
+  version: "1.2"
+date: 2006-11-07 00:00:00 -05:00
+summary: Wrapper for TSM client and administrative command interfaces
+require_paths: 
+- lib
+email: s.e.collison@gmail.com
+homepage: http://tsm-command.rubyforge.org/
+rubyforge_project: 
+description: 
+autorequire: tsm
+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: 
+post_install_message: 
+authors: 
+- Sarah Collison
+files: 
+- tests/ts_tsm.rb
+- lib/tsm
+- lib/tsm.rb
+- lib/tsm/response.rb
+- lib/tsm/dsm.rb
+- lib/tsm/dsmadmc.rb
+- lib/tsm/error.rb
+- lib/tsm/dsmio.rb
+- README
+test_files: 
+- tests/ts_tsm.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+