synaptic4r 0.1.5

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+*~
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) 2009 AT&T Intellectual Property.
+ 
+All rights reserved.
+ 
+AT&T, AT&T logo and all other AT&T marks contained herein
+are trademarks of AT&T Intellectual Property and/or AT&T affiliated companies.
+ 
+All other trademarks are the property of their owners.
+ 
+The above copyright notice shall be included in all copies or
+substantial portions of the Software.

data/README.rdoc

@@ -0,0 +1,88 @@
+= synaptic4r
+
+Ruby REST Client and CLI for ATT Synaptic Storage. The CLI directly maps
+onto the REST API and can be used to inspect request headers and payloads, as well as,
+a reference for the REST API. 
+
+== Install
+
+The synptic4r gem is in the gemcutter.org repository. If gemcutter.org is not in your gem sources 
+issue the following command only one time,
+
+	sudo gem source -a http://gemcutter.org
+
+and install synaptic4r
+
+	sudo gem install synaptic4r
+
+== Credentials
+
+Save credentials to $HOME/.synaptic4r
+
+single account
+
+   subtenant: SubtenantID 
+   uid:       UserID
+   key:       SecretKey
+   site:      https://storage.synaptic.att.com/rest
+
+multiple accounts (the first is used by default, the dashes must 
+be included in the file)
+
+   -
+    account:   myacct
+    subtenant: SubtenantID 
+    uid:       UserID
+    key:       SecretKey
+    site:      https://storage.synaptic.att.com/rest
+
+   -
+    account:   myotheracct
+    subtenant: OtherSubtenantID 
+    uid:       OtherUserID
+    key:       OtherSecretKey
+    site:      https://storage.synaptic.att.com/rest
+
+== Basic CLI Commands
+   
+list information here
+
+        synrest get-started
+
+list all commands with descriptions
+
+	synrest
+
+list contents of remote root directory   
+
+	synrest get
+
+create a remote directory named foo    
+
+     	synrest create-dir foo
+
+upload a file to directory foo    
+
+     	synrest create-file file.txt foo/
+
+list contents remote directory foo   
+
+     	synrest get foo
+
+list contents remote file foo/file.txt   
+
+     	synrest get foo/file.txt
+
+execute command for account other than default
+
+     	synrest command args [options] -u myotheracct
+
+show examples for a command
+
+     	synrest command examples
+
+
+
+== Copyright
+
+Copyright (c) 2009 ATT. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "synaptic4r"
+    gem.summary = "CLI and Ruby REST Client for ATT Synaptic Storage"
+    gem.email = "troy.stribling@usi.com"
+    gem.homepage = "http://github.com/attsynaptic/synaptic4r"
+    gem.authors = ["troystribling-att"]
+    gem.add_dependency('rest-client', '>= 1.0.2')
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "synaptic4r #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.5

data/bin/synrest

@@ -0,0 +1,316 @@
+#!/usr/bin/ruby
+
+####---------------------------------------------------------------------------------------------------------
+SYNLIB = "#{File.dirname($0)}/../lib"
+$:.unshift(SYNLIB) unless $:.include?(SYNLIB)
+
+####---------------------------------------------------------------------------------------------------------
+require 'yaml'
+require 'optparse'
+require 'synaptic4r'
+require 'logger'
+
+#############################################################################################################
+####---------------------------------------------------------------------------------------------------------
+def credentials_configured?
+  config_keys = %w(key site subtenant uid)
+  status = if File.exists?(Synaptic4r::Client.config_file)
+             config = File.open(Synaptic4r::Client.config_file){|yf| YAML::load(yf)}
+             if config.kind_of?(Hash)
+               config.keys.sort.eql?(config_keys) or config.keys.sort.eql?(config_keys.unshift('account'))
+             elsif config.kind_of?(Array) 
+               config_keys.unshift('account')
+               config.select{|c| c.keys.sort.eql?(config_keys)}.length.eql?(config.length)
+             else
+               puts "#{Synaptic4r::Client.config_file} not formatted properly"
+               exit
+             end
+           else
+             puts "#{Synaptic4r::Client.config_file} not found"
+             exit
+           end
+  unless status
+    puts "#{Synaptic4r::Client.config_file} missing one of 'key', 'site', 'subtenant' or 'uid'"
+    exit
+  end
+end
+
+####---------------------------------------------------------------------------------------------------------
+def dump(cmd, input, result)
+  output = if input[:dump]
+             <<-DUMP
+COMMAND:        #{cmd}
+ARGS:           #{input.inspect}
+SIGNING STRING: #{result.sign.inspect}
+HTTP METHOD:    #{result.http_request}
+URL:            #{result.url}
+HEADERS:        #{result.headers.inspect}
+              DUMP
+           else; ''; end
+  if input[:payload] and result.payload
+    output + "PAYLOAD:\n" + result.payload
+  else
+    output
+  end
+end
+
+####---------------------------------------------------------------------------------------------------------
+def run(cmd, input)
+  begin    
+    result = Synaptic4r::Client.new(input[:account].nil? ? nil : {:account => input[:account]}).send(cmd, input)
+    {:out => (input[:dump] or input[:payload]) ? dump(cmd, input, result) : result.print, :logger => :info}
+  rescue RestClient::RequestFailed, RestClient::ResourceNotFound, RestClient::Unauthorized, 
+         RestClient::NotModified => err
+    {:out => "#{err.message}\n" + Synaptic4r::RequestError.new(err).print, :logger => :error}
+  rescue RestClient::Redirect, RestClient::ServerBrokeConnection, RestClient::RequestTimeout => err
+    {:out => err.message, :logger => :error}
+  rescue ArgumentError => err
+    {:out => err.to_s, :logger  => :error}
+  rescue Errno::ENOENT, Errno::EISDIR => err
+    {:out => err.to_s, :logger  => :error}
+  end
+end
+
+####---------------------------------------------------------------------------------------------------------
+def extract_cmd(meths)
+  if ARGV.first 
+    if meths.include?(ARGV.first.gsub(/-/,'_').to_sym)
+      ARGV.shift.gsub(/-/,'_').to_sym 
+    else
+      puts "Error: '#{ARGV.first}' is not a valid command"
+      exit
+    end
+  end
+end
+
+####---------------------------------------------------------------------------------------------------------
+def format_required_args(args)
+  args.inject("") do |f,a|
+    aname = lambda{|v,l| arg_name(Synaptic4r::Request.rest_arg(v),l)}
+    if a.kind_of?(Array)
+      f + [aname[a.first,false],a[1..-1].map{|v| aname[v,true]}].join('|') + ' '  
+    else
+      "#{f}#{aname[a, false]} "  
+    end
+  end.chomp(' ')
+end
+
+####---------------------------------------------------------------------------------------------------------
+def diagnostic_args(opts, input, cmd)
+  if Synaptic4r::Request.diagnostics(cmd)
+    opts.separator "\ndiagnostic options"
+    opts.on('-q', '--dump', 'do not send request but print headers and service url to STDOUT'){|d| input[:dump] = true}
+    opts.on('-p', '--payload', 'do not send request print payload to STDOUT if present'){|p| input[:payload] = true}
+    opts.on('-l', '--log [file]', 'log request to file (by default file is synaptic4r.log)') do |file|
+      input[:log] = true
+      input[:log_file] = file
+    end
+  end
+  opts.on_tail('-h', '--help', "this listing\n") {
+    puts 
+    puts opts
+    puts "Examples: synrest #{cmd.to_s.gsub(/_/,'-')} examples\n\n"
+    exit
+  }
+end
+
+####---------------------------------------------------------------------------------------------------------
+def set_opts(opts, input, opt_args)
+  opt_args = [opt_args].flatten
+  unless opt_args.empty?
+    opts.separator "\noptions"
+    opt_args.sort_by{|m| m.to_s}.each do |a|
+      arg_info = Synaptic4r::Request.rest_arg(a)
+      sopt = arg_info[:cli][1]
+      lopt = "--#{arg_info[:cli][0]}" + (arg_info[:cli][2].eql?(:flag) ? '' : " #{arg_info[:cli][0]}")
+      opts.on(sopt, lopt, arg_info[:desc]) do |v|
+        input[a] = arg_info[:map].nil? ? v : arg_info[:map][v]
+      end
+    end
+  end
+end
+
+####---------------------------------------------------------------------------------------------------------
+def set_args(opts, meths, input, cmd)
+  extract_positional_args(meths, input, cmd)
+  all_args = Synaptic4r::Request.required_rest_args(cmd)
+  fmt = "    %-32s %s"
+  unless all_args.empty?
+    opts.separator "\nargs"
+    arg_row = lambda{|a,l| arg_info = Synaptic4r::Request.rest_arg(a)
+                           opts.separator fmt % [arg_name(arg_info,l), arg_info[:desc]]}
+    all_args.each do |a|
+      if a.kind_of?(Array)
+        opts.separator "one of"
+        arg_row[a.first,false]
+        a[1..-1].each{|e| arg_row[e,true]}
+      else
+        arg_row[a,false]
+      end
+    end
+  end
+end
+
+####---------------------------------------------------------------------------------------------------------
+def prep_argv
+  add = true
+  inargs = ARGV.inject([]) do |o,a|
+    if /^-/.match(a)
+      i = ARGV.index(a)
+      n = ARGV[i+1]
+      if n and not /^-/.match(n)
+        add = false;  o << [a,n].join(' ')
+      else
+        o << a
+      end
+    elsif add
+      o << a
+    else
+      add = true; o
+    end
+  end
+end
+
+####---------------------------------------------------------------------------------------------------------
+def extract_positional_args(meths, input, cmd)
+  eargs = Synaptic4r::Request.required_rest_args(cmd)
+  elength = eargs.length
+  pvals= prep_argv.first(elength)
+  nvals = if Synaptic4r::Request.map_required_args(cmd)
+            Synaptic4r::Request.map_required_args(cmd)[pvals]
+          else 
+            {:pvals => pvals, :dlen => 0}
+          end
+  if pvals.include?('-h')
+  elsif ARGV.first.eql?('examples')
+    begin
+      send("#{cmd}_examples".to_sym)
+      exit
+    rescue NoMethodError
+      puts "'#{cmd.to_s.gsub(/_/,'-')}' examples are not availble"
+      exit
+    end
+  elsif nvals[:pvals].length < elength
+    puts "Error: expecting args '#{format_required_args(eargs)}'"
+    exit
+  else
+    set_positional_args(input, nvals, eargs)
+  end
+end
+
+####---------------------------------------------------------------------------------------------------------
+def set_positional_args(input, nvals, eargs)
+  assign_input = lambda{|a,v| info = Synaptic4r::Request.rest_arg(a); 
+                              input[a] = info[:map].nil? ? v : info[:map][v]}
+  length = 0
+  nvals[:pvals].each_index do |i|
+    pv = nvals[:pvals][i]
+    ea = eargs[i]
+    if ea.kind_of?(Array)
+      if /^-/.match(pv)
+        matched = false
+        ea[1..-1].each do |a|
+          info = Synaptic4r::Request.rest_arg(a)
+          flag = info[:cli][1]
+          next unless flag
+          if /^#{flag}/.match(pv)
+            input[a] = pv.split(/\s/).last
+            matched = true
+            length += 2
+            break
+          end
+        end
+        unless matched
+          puts "Error: expecting args '#{format_required_args(eargs)}'"
+          exit
+        end
+      else
+        length += 1
+        assign_input[ea.first,pv]
+      end
+    else
+      length += 1
+      assign_input[ea,pv]
+    end
+  end
+  ARGV.slice!(0, length - nvals[:dlen])
+end
+
+####---------------------------------------------------------------------------------------------------------
+def arg_name(arg_info, long=true)
+  cli = arg_info[:cli]
+  if cli.kind_of?(Array) and long
+    cli.length > 1 ? "#{cli[1]} #{cli[0]}" : cli.first
+  else; [cli].flatten.first; end
+end
+
+####---------------------------------------------------------------------------------------------------------
+def build_banner(opts, cmd)
+  exp_args = Synaptic4r::Request.required_rest_args(cmd)
+  opts.banner = Synaptic4r::Request.banner(cmd) || \
+                "\nUsage: synrest #{cmd.to_s.gsub(/_/,'-')} #{format_required_args(exp_args)} [options]"
+
+end
+
+####---------------------------------------------------------------------------------------------------------
+def process_input(opts, meths, input, cmd)
+  build_banner(opts, cmd)
+  set_args(opts, meths, input, cmd)
+  set_opts(opts, input, Synaptic4r::Request.optional_rest_args(cmd))
+  diagnostic_args(opts, input, cmd)
+end
+
+
+####---------------------------------------------------------------------------------------------------------
+def cmd_help(meths) 
+  puts "\nUsage: synrest command args [options]" 
+  puts "\nCommands"
+  meths.sort_by{|m| m.to_s}.each do |m| 
+    next if m.eql?(:get_started)
+    meth_str = "  %-30s" % m.to_s.gsub(/_/,'-')
+    puts "#{meth_str} #{Synaptic4r::Request.desc(m)}"
+  end
+  puts "\nCommand args and options\n synrest command -h"
+  puts "\nGet Started\n synrest get-started"
+  puts "\nCommand examples\n synrest command examples\n\n"
+end
+
+####---------------------------------------------------------------------------------------------------------
+meths = Synaptic4r::Request.rest_methods << :get_started
+input = {}
+cmd = extract_cmd(meths)
+
+####---------------------------------------------------------------------------------------------------------
+if cmd.eql?(:get_started)
+  get_started
+  exit
+elsif cmd
+  OptionParser.new do |opts|
+    process_input(opts, meths, input, cmd)
+    begin
+      credentials_configured?
+      opts.parse!(ARGV)
+    rescue OptionParser::MissingArgument, OptionParser::InvalidOption  => err
+      puts err.to_s
+      exit
+    end
+  end
+else
+  puts "\nsynrest provides a command line interface that maps directly onto the"
+  puts "synaptic storage rest API"
+  cmd_help(meths)
+  exit
+end
+
+####---------------------------------------------------------------------------------------------------------
+if input[:log]
+  log = Logger.new(input[:log_file] || 'synaptic4r.log')
+  request = run(cmd, input.merge(:dump => true))
+end
+
+####---------------------------------------------------------------------------------------------------------
+result = run(cmd, input)
+puts result[:out] if result[:out]
+
+####---------------------------------------------------------------------------------------------------------
+log.send(result[:logger], "\n#{request[:out]}#{result[:out]}") if input[:log]

data/lib/synaptic4r/client.rb

@@ -0,0 +1,77 @@
+####-----------------------------------------------------------------------------------------------------
+module Synaptic4r
+  
+  ####------------------------------------------------------------------------------------------------------
+  class Client
+    
+
+    ####------------------------------------------------------------------------------------------------------
+    include Utils
+
+    #.........................................................................................................
+    @config_file = ENV['HOME'] + '/.synaptic4r'
+
+    ####------------------------------------------------------------------------------------------------------
+    class << self
+      attr_reader :config_file
+    end
+
+    #.........................................................................................................
+    attr_reader :uid, :key, :site, :resource, :subtenant
+  
+    #.........................................................................................................
+    def initialize(args = nil)
+      config_params = %w(key site subtenant uid)
+      if args
+        account = args[:account]
+        if account
+          aconfig = config_by_account(account)
+          raise ArgumentError, "Account '#{account}' not found in #{ENV['HOME']}/.synaptic4r" unless aconfig
+          args.update(symbolize(aconfig))
+        end
+      else
+        if config.kind_of?(Hash)
+          args = symbolize(config)
+        elsif config.kind_of?(Array)
+          cfg = config.first
+          args = symbolize(cfg)
+        else
+          raise ArgumentError, "#{ENV['HOME']}/.synaptic4r not formatted properly"
+        end
+      end
+      unary_args_given?(symbolize(config_params), args.keys)
+      @subtenant = args[:subtenant]
+      @uid = args[:uid]
+      @key = args[:key]
+      @site = args[:site]
+    end
+
+    #.........................................................................................................
+    def method_missing(meth, *args, &blk)
+      if Request.has_rest_method?(meth)
+        Request.new(:uid => uid, :subtenant => subtenant, :key => key, :site => site).execute(meth, *args, &blk)
+      else
+        super
+      end
+    end
+
+  private
+
+    #.........................................................................................................
+    def config
+      @config ||= File.open(Client.config_file){|yf| YAML::load(yf)}
+    end
+
+    #.........................................................................................................
+    def config_by_account(account)
+      if config.kind_of?(Array)
+        a = config.select{|c| c['account'].eql?(account)}.first
+        a.delete('account') unless a.nil?; a
+      else; config; end
+    end
+
+  #### Client
+  end
+
+#### Synaptic4r
+end