rct 0.1 → 0.3

data/bin/rct

@@ -19,7 +19,7 @@
 #
 
 
-#--------------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------
 # rct main
 #
 # Runs either a CLI invocation or a test suite depending on arguments.

data/lib/rct.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env jruby
 #
-#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#  Copyright 2012-2013 Jyri J. Virkki <jyri@virkki.com>
 #
 #  This file is part of rct.
 #

data/lib/rct/baseutils.rb

@@ -1,5 +1,5 @@
 #
-#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#  Copyright 2012-2013 Jyri J. Virkki <jyri@virkki.com>
 #
 #  This file is part of rct.
 #
@@ -18,37 +18,63 @@
 #
 
 
-#--------------------------------------------------------------------------------------------------
-# Assorted utility methods.
+#-----------------------------------------------------------------------------
+# Assorted utility methods. TODO: cleanup
 #
 class RCT
 
+  @log_level = RESULT
 
-  def self.rct_log(level, line)
-    puts line
+
+  def self.log_level
+    @log_level
+  end
+
+
+  def self.set_log_level(level)
+    @log_level = RESULT if level == RESULT
+    @log_level = INFO if level == INFO
+    @log_level = DEBUG if level == DEBUG
+  end
+
+
+  def self.increase_log_level
+    @log_level += 1
+  end
+
+
+  def self.log(level, line)
+    if (level <= @log_level)
+      puts line
+    end
   end
 
+
   def self.error(msg)
     puts "error: #{msg}"
   end
 
+
   def self.bad_invocation(msg)
     error(msg)
     exit(1)
   end
 
+
   def self.die(msg)
     error(msg)
     exit(1)
   end
 
+
   def self.argv_get(pos)
-    value = $ARGV[pos + 1]
-    $ARGV.delete_at(pos + 1)
-    $ARGV.delete_at(pos)
+    value = ARGV[pos + 1]
+    ARGV.delete_at(pos + 1)
+    ARGV.delete_at(pos)
     return value
   end
 
+
   def self.help
 
     # default is CLI invocation of method name
@@ -60,10 +86,16 @@ class RCT
 
   end
 
+
   def self.parse_global_options
     pos = 0
-    while (pos < $ARGV.length)
-      arg = $ARGV[pos]
+
+    if (ARGV == nil)
+      die("No arguments!")
+    end
+
+    while (pos < ARGV.length)
+      arg = ARGV[pos]
 
       if (arg == '-t' || arg == '--test')
         sset(RCT_MODE, RCT_MODE_TEST)
@@ -78,6 +110,10 @@ class RCT
       elsif (arg == '-p' || arg == '--port')
         sset(SERVER_PORT, argv_get(pos))
 
+      elsif (arg == '-v')
+        increase_log_level()
+        ARGV.delete_at(pos)
+
       else
         pos += 1
       end
@@ -85,10 +121,11 @@ class RCT
     end
   end
 
+
   def self.get_opt(info)
     pos = 0
-    while (pos < $ARGV.length)
-      arg = $ARGV[pos]
+    while (pos < ARGV.length)
+      arg = ARGV[pos]
       if (arg == info[0] || arg == info[1])
         return argv_get(pos)
       else
@@ -97,6 +134,7 @@ class RCT
     end
   end
 
+
   def self.parse_options(opts, required)
     return if opts == nil
     opts.each { |key, info|

data/lib/rct/constants.rb

@@ -1,5 +1,5 @@
 #
-#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#  Copyright 2012-2013 Jyri J. Virkki <jyri@virkki.com>
 #
 #  This file is part of rct.
 #
@@ -17,7 +17,7 @@
 #  along with rct.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-RCT_VERSION = '0.1'
+RCT_VERSION = '0.3'
 
 RCT_MODE = '_mode'
 RCT_MODE_CLI = 'cli'
@@ -36,6 +36,11 @@ REQ_PARAMS = '_req_params'
 REQ_BODY = '_req_body'
 REQ_HEADERS = '_req_headers'
 
+REQ_AUTH_TYPE = '_auth_type'
+REQ_AUTH_TYPE_BASIC = 'basic'
+REQ_AUTH_NAME = '_req_auth_name'
+REQ_AUTH_PWD = '_req_auth_pwd'
+
 RESULT = 1
 INFO = 2
 DEBUG = 3

data/lib/rct/rct_cli.rb

@@ -1,5 +1,5 @@
 #
-#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#  Copyright 2012-2013 Jyri J. Virkki <jyri@virkki.com>
 #
 #  This file is part of rct.
 #
@@ -18,17 +18,18 @@
 #
 
 
-#--------------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------
 # Provides access to rct client methods as a CLI.
 #
-# In order to be accessible via CLI, a client class must implement a 'cli' method which
-# provides info about the CLI methods and their arguments.
+# In order to be accessible via CLI, a client class must implement a
+# 'cli' method which provides info about the CLI methods and their
+# arguments.
 #
 class RCTCLI
 
 
   def self.rct_cli
-    method = $ARGV.shift
+    method = ARGV.shift
     if (method == nil || method.empty?)
       RCT.bad_invocation("no CLI class/method given!")
     end
@@ -36,7 +37,8 @@ class RCTCLI
     method =~ /([^\.]*)\.(.*)/
     class_name = $1
     method_name = $2
-    RCT.rct_log(DEBUG, "CLI class: #{class_name}, method: #{method_name}")
+    RCT.log(DEBUG, "Requested [#{method}]")
+    RCT.log(DEBUG, "CLI class: #{class_name}, method: #{method_name}")
 
     obj = Object::const_get(class_name).new()
     begin
@@ -60,10 +62,9 @@ class RCTCLI
       $HTTP.handle_request()
     }
 
-    puts response
+    RCT.log(INFO, response)
     puts response.body
   end
 
 
 end
-

data/lib/rct/rct_http.rb

@@ -1,5 +1,5 @@
 #
-#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#  Copyright 2012-2013 Jyri J. Virkki <jyri@virkki.com>
 #
 #  This file is part of rct.
 #
@@ -21,9 +21,10 @@
 require 'httpclient'
 
 
-#--------------------------------------------------------------------------------------------------
-# This class provides the HTTP connection support for rct. This serves to hide the details
-# of the underlying HTTP connector class so that it can be changed conveniently if desired.
+#------------------------------------------------------------------------------
+# This class provides the HTTP connection support for rct. This serves
+# to hide the details of the underlying HTTP connector class so that
+# it can be changed conveniently if desired.
 #
 # Currently using HTTPClient:
 # http://rubydoc.info/gems/httpclient/2.1.5.2/HTTPClient
@@ -31,7 +32,7 @@ require 'httpclient'
 class RCTHTTP
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Constructor.
   #
   def initialize
@@ -39,12 +40,14 @@ class RCTHTTP
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Handle one HTTP request.
   #
-  # Connection parameters are all obtained from the current state (see constants.rb):
+  # Connection parameters are all obtained from the current state (see
+  # constants.rb). Destination server is specified by type (SERVER_TYPE)
+  # OR by hostname+port. If both are given, type takes precedence.
   #
-  # * SERVER_TYPE     - Connect to a server of this type (overrides SERVER_HOSTNAME/SERVER_PORT).
+  # * SERVER_TYPE     - Connect to a server of this type.
   # * SERVER_HOSTNAME - Connect to this server.
   # * SERVER_PORT     - Connect to this port on server.
   # * SERVER_PROTOCOL - Protocol (http/https).
@@ -96,8 +99,20 @@ class RCTHTTP
     end
     headers['User-agent'] = "rct/#{RCT_VERSION}"
 
-    res = nil
+    auth = RCT.sget(REQ_AUTH_TYPE)
+    if (auth != nil)
+      if (auth == REQ_AUTH_TYPE_BASIC)
+        name = RCT.sget(REQ_AUTH_NAME)
+        pwd = RCT.sget(REQ_AUTH_PWD)
+        @http_client.set_auth(nil, name, pwd)
+      else
+        raise "Requested auth type '#{auth}' unknown"
+      end
+    end
+
+    show_request(method, url, headers, RCT.sget(REQ_BODY))
 
+    res = nil
     begin
       if (method == "GET")
         res = @http_client.get(url, nil, headers)
@@ -116,15 +131,57 @@ class RCTHTTP
       else
         raise "Method #{method} not implemented yet!"
       end
+
     rescue Exception => e
       response = Response.new(nil)
       response.add_error(e.to_s)
+      show_response(response)
       return response
     end
 
+    show_response(res)
     response = Response.new(res)
     return response
   end
 
 
+  #----------------------------------------------------------------------------
+  # Show verbose info about the request.
+  #
+  def show_request(method, url, headers, body)
+    return if (RCT.log_level < INFO)
+
+    RCT.log(INFO, "-----[ REQUEST ]---" + "-" * 60)
+    RCT.log(INFO, "#{method} #{url}")
+    headers.each { |k,v|
+      RCT.log(INFO, "#{k}: #{v}")
+    }
+    RCT.log(INFO, "")
+
+    if (body != nil)
+      RCT.log(INFO, body)
+      RCT.log(INFO, "")
+    end
+  end
+
+
+  #----------------------------------------------------------------------------
+  # Show verbose info about the response.
+  #
+  def show_response(res)
+    return if (RCT.log_level < INFO)
+
+    RCT.log(INFO, "-----[ RESPONSE ]--" + "-" * 60)
+    RCT.log(INFO, "#{res.to_s}")
+
+    headers = res.headers
+    if (headers != nil)
+      headers.each { |k,v|
+        RCT.log(INFO, "XH: #{k}: #{v}")
+      }
+    end
+
+    RCT.log(INFO, res.body)
+  end
+
 end

data/lib/rct/response.rb

@@ -1,5 +1,5 @@
 #
-#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#  Copyright 2012-2013 Jyri J. Virkki <jyri@virkki.com>
 #
 #  This file is part of rct.
 #
@@ -18,24 +18,26 @@
 #
 
 
-#--------------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------
 # The Response object represents the response from one HTTP call.
-# This Response class wraps the response object from the underlying HTTP client library and
-# provides assorted convenience methods.
+# This Response class wraps the response object from the underlying
+# HTTP client library and provides assorted convenience methods.
 #
 # Client class methods will receive a Response object back from yield.
 # Client class methods must return this Response object.
-#--
-# Currently using response from HTTPClient: http://rubydoc.info/gems/httpclient/HTTP/Message
-#++
+#
+# Currently using response from HTTPClient:
+# http://rubydoc.info/gems/httpclient/HTTP/Message
+#
+#
 class Response
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Constructor...
   #
-  # The 'res' argument must never be nil for successful responses. It may be nil if this
-  # represents an error response.
+  # The 'res' argument must never be nil for successful responses. It
+  # may be nil if this represents an error response.
   #
   def initialize(res)
     @res = res
@@ -43,9 +45,10 @@ class Response
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Flag this reponse as an error and add an error message string.
-  # This method may be called multiple times, the error messages are appended to each other.
+  # This method may be called multiple times, the error messages are
+  # appended to each other.
   #
   def add_error(msg)
     if (@fail_msg == nil)
@@ -56,8 +59,9 @@ class Response
   end
   
 
-  #------------------------------------------------------------------------------------------------
-  # Returns true unless this response has been flagged as an error via add_error() method.
+  #----------------------------------------------------------------------------
+  # Returns true unless this response has been flagged as an error via
+  # add_error() method.
   #
   def ok
     return true if @fail_msg == nil
@@ -65,7 +69,7 @@ class Response
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Return HTTP status code (or -1 if an error)
   #
   def status
@@ -74,7 +78,7 @@ class Response
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Return requested HTTP header (or nil if an error)
   #
   def header(name)
@@ -83,7 +87,16 @@ class Response
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
+  # Return all HTTP headers (or nil if an error)
+  #
+  def headers
+    return nil if @res == nil
+    return @res.header
+  end
+
+
+  #----------------------------------------------------------------------------
   # Return HTTP response body (or nil if an error)
   #
   def body
@@ -92,9 +105,10 @@ class Response
   end
 
 
-  #------------------------------------------------------------------------------------------------
-  # Return short string representation. On error, contains the error message(s). Otherwise,
-  # contains the HTTP response code and text description.
+  #----------------------------------------------------------------------------
+  # Return short string representation. On error, contains the error
+  # message(s). Otherwise, contains the HTTP response code and text
+  # description.
   #
   def to_s
     return "error: #{@fail_msg}" if @res == nil

data/lib/rct/state.rb

@@ -18,20 +18,22 @@
 #
 
 
-#--------------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------
 # This is the global state where mostly everything is kept in rct.
 #
-# There are two kinds of state, permanent and temporary. Values set in temporary state can be
-# removed with the reset() method. Values in permanent state remain available for the lifetime
-# of this State object (unless individually removed with delete() method).
+# There are two kinds of state, permanent and temporary. Values set in
+# temporary state can be removed with the reset() method. Values in
+# permanent state remain available for the lifetime of this State
+# object (unless individually removed with delete() method).
 #
-# When retrieving a value, content in the temporary state overrides content in permanent state
-# if the key is present in both. This provides a way to temporarily override a global default.
+# When retrieving a value, content in the temporary state overrides
+# content in permanent state if the key is present in both. This
+# provides a way to temporarily override a global default.
 #
 class State
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Constructor...
   #
   def initialize
@@ -40,7 +42,7 @@ class State
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Set (or change) 'key' in state to contain 'value'.
   # If 'temp' is true, this key is stored in temporary state only.
   #
@@ -53,7 +55,7 @@ class State
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Get the value of 'key' (if available, or returns nil).
   #
   def get(key)
@@ -65,7 +67,7 @@ class State
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Delete the given 'key' from both permanent and temporary state.
   #
   def delete(key)
@@ -74,7 +76,7 @@ class State
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Reset temporary state.
   # Returns the old temporary state hash object.
   #

data/lib/rct_client.rb

@@ -22,17 +22,18 @@ require 'securerandom'
 require 'json'
 
 
-#--------------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------
 # Base class for rct client classes.
 #
 class RCTClient
 
 
-  #------------------------------------------------------------------------------------------------
-  # Adds an additional query param "name=value" to the given 'params'. This 'params' may be nil.
+  #----------------------------------------------------------------------------
+  # Adds an additional query param "name=value" to the given 'params'.
+  # This 'params' may be nil.
   #
-  # The new param is added only if both name and value are non-nil, otherwise params is
-  # returned unchanged.
+  # The new param is added only if both name and value are non-nil,
+  # otherwise params is returned unchanged.
   #
   def add_param(params, name, value)
     if (name == nil || name.empty? || value == nil || value.empty?)
@@ -47,7 +48,7 @@ class RCTClient
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Returns a random UUID.
   #
   def uuid
@@ -55,8 +56,9 @@ class RCTClient
   end
 
 
-  #------------------------------------------------------------------------------------------------
-  # Return true if var contains something (that is, it is not nil and not empty).
+  #----------------------------------------------------------------------------
+  # Return true if var contains something (that is, it is not nil and
+  # not empty).
   #
   def set(var)
     return false if var == nil
@@ -65,9 +67,9 @@ class RCTClient
   end
 
 
-  #------------------------------------------------------------------------------------------------
-  # If the global state contains a non-nil/non-empty value for key 'name', add this to the
-  # 'hash' provided.
+  #----------------------------------------------------------------------------
+  # If the global state contains a non-nil/non-empty value for key
+  # 'name', add it to the 'hash' provided.
   #
   def add_to_hash_if_set(name, hash)
     value = RCT.sget(name)
@@ -78,7 +80,7 @@ class RCTClient
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Log a message. Level is one of RESULT, INFO, DEBUG.
   #
   def log(level, line)
@@ -86,7 +88,7 @@ class RCTClient
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Set (or change) 'key' in state to contain 'value'.
   # If 'temp' is true, this key is stored in temporary state only.
   #
@@ -95,7 +97,7 @@ class RCTClient
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Set (or change) 'key' in temporary state to contain 'value'.
   #
   def ssettmp(key, value)
@@ -103,7 +105,7 @@ class RCTClient
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Get the value of 'key' (if available, or returns nil).
   #
   def sget(key)
@@ -111,7 +113,7 @@ class RCTClient
   end
 
 
-  #------------------------------------------------------------------------------------------------
+  #----------------------------------------------------------------------------
   # Delete the given 'key' from both permanent and temporary state.
   #
   def sdelete(key)

metadata

@@ -2,14 +2,14 @@
 name: rct
 version: !ruby/object:Gem::Version
   prerelease:
-  version: '0.1'
+  version: '0.3'
 platform: ruby
 authors:
 - Jyri J. Virkki
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-12-17 00:00:00.000000000 Z
+date: 2013-06-11 00:00:00.000000000 Z
 dependencies: []
 description: wip
 email: jyri@virkki.com
@@ -19,13 +19,13 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/rct/baseutils.rb
-- lib/rct/constants.rb
 - lib/rct/rct_cli.rb
-- lib/rct/rct_http.rb
-- lib/rct/response.rb
+- lib/rct/constants.rb
 - lib/rct/state.rb
-- lib/rct.rb
+- lib/rct/response.rb
+- lib/rct/rct_http.rb
 - lib/rct_client.rb
+- lib/rct.rb
 - bin/rct
 homepage: https://github.com/jvirkki/rct
 licenses: