rct 0.1

data/bin/rct

@@ -0,0 +1,44 @@
+#!/usr/bin/env jruby
+#
+#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#
+#  This file is part of rct.
+#
+#  rct is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  rct is distributed in the hope that it will be useful, but
+#  WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with rct.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+#--------------------------------------------------------------------------------------------------
+# rct main
+#
+# Runs either a CLI invocation or a test suite depending on arguments.
+# 
+
+require 'rct'
+
+# A few globals:
+$HTTP = RCTHTTP.new()
+$STATE = State.new()
+
+# Set some defaults:
+RCT.sset(RCT_MODE, RCT_MODE_CLI)
+RCT.sset(SERVER_PROTOCOL, 'http')
+RCT.sset(SERVER_HOSTNAME, 'localhost')
+RCT.sset(SERVER_PORT, '80')
+
+RCT.parse_global_options()
+
+if ($STATE.get(RCT_MODE) == RCT_MODE_CLI)
+  RCTCLI.rct_cli
+end

data/lib/rct.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env jruby
+#
+#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#
+#  This file is part of rct.
+#
+#  rct is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  rct is distributed in the hope that it will be useful, but
+#  WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with rct.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+require 'rct/constants'
+require 'rct/baseutils'
+require 'rct/rct_cli'
+require 'rct/state'
+require 'rct/response'
+require 'rct/rct_http'

data/lib/rct/baseutils.rb

@@ -0,0 +1,132 @@
+#
+#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#
+#  This file is part of rct.
+#
+#  rct is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  rct is distributed in the hope that it will be useful, but
+#  WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with rct.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+#--------------------------------------------------------------------------------------------------
+# Assorted utility methods.
+#
+class RCT
+
+
+  def self.rct_log(level, line)
+    puts line
+  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)
+    return value
+  end
+
+  def self.help
+
+    # default is CLI invocation of method name
+    # rct Time.get_time
+    #
+    # provide require file if it is not in CLI list
+    # rct Time.get_time --req time_client
+    # rct --test test-suite
+
+  end
+
+  def self.parse_global_options
+    pos = 0
+    while (pos < $ARGV.length)
+      arg = $ARGV[pos]
+
+      if (arg == '-t' || arg == '--test')
+        sset(RCT_MODE, RCT_MODE_TEST)
+        sset(TEST_SUITE_FILE, argv_get(pos))
+
+      elsif (arg == '--req')
+        require argv_get(pos)
+
+      elsif (arg == '-h' || arg == '--host')
+        sset(SERVER_HOSTNAME, argv_get(pos))
+
+      elsif (arg == '-p' || arg == '--port')
+        sset(SERVER_PORT, argv_get(pos))
+
+      else
+        pos += 1
+      end
+
+    end
+  end
+
+  def self.get_opt(info)
+    pos = 0
+    while (pos < $ARGV.length)
+      arg = $ARGV[pos]
+      if (arg == info[0] || arg == info[1])
+        return argv_get(pos)
+      else
+        pos += 1
+      end
+    end
+  end
+
+  def self.parse_options(opts, required)
+    return if opts == nil
+    opts.each { |key, info|
+      value = get_opt(info)
+      if (required && value == nil)
+        bad_invocation("Required argument #{info[0]}|#{info[1]} has no value!")
+      end
+      $STATE.set(key, value)
+    }
+  end
+
+
+  def self.sset(key, value, temp=false)
+    $STATE.set(key, value, temp)
+  end
+
+
+  def self.ssettmp(key, value)
+    $STATE.set(key, value, true)
+  end
+
+
+  def self.sget(key)
+    $STATE.get(key)
+  end
+
+
+  def self.sdelete(key)
+    $STATE.delete(key)
+  end
+
+
+end

data/lib/rct/constants.rb

@@ -0,0 +1,43 @@
+#
+#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#
+#  This file is part of rct.
+#
+#  rct is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  rct is distributed in the hope that it will be useful, but
+#  WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with rct.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+RCT_VERSION = '0.1'
+
+RCT_MODE = '_mode'
+RCT_MODE_CLI = 'cli'
+RCT_MODE_TEST = 'test'
+TEST_SUITE_FILE = '_test_suite'
+
+SERVER_PROTOCOL = '_protocol'
+SERVER_HOSTNAME = '_hostname'
+SERVER_PORT = '_port'
+
+SERVER_TYPE = '_server_type'
+
+REQ_METHOD = '_method'
+REQ_PATH = '_path'
+REQ_PARAMS = '_req_params'
+REQ_BODY = '_req_body'
+REQ_HEADERS = '_req_headers'
+
+RESULT = 1
+INFO = 2
+DEBUG = 3
+
+

data/lib/rct/rct_cli.rb

@@ -0,0 +1,69 @@
+#
+#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#
+#  This file is part of rct.
+#
+#  rct is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  rct is distributed in the hope that it will be useful, but
+#  WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with rct.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+#--------------------------------------------------------------------------------------------------
+# 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.
+#
+class RCTCLI
+
+
+  def self.rct_cli
+    method = $ARGV.shift
+    if (method == nil || method.empty?)
+      RCT.bad_invocation("no CLI class/method given!")
+    end
+
+    method =~ /([^\.]*)\.(.*)/
+    class_name = $1
+    method_name = $2
+    RCT.rct_log(DEBUG, "CLI class: #{class_name}, method: #{method_name}")
+
+    obj = Object::const_get(class_name).new()
+    begin
+      cli_info = obj.send('cli')
+    rescue Exception => e
+      puts e
+      error("#{class_name} does not support CLI operations")
+      exit(1)
+    end
+
+    method_info = cli_info[method_name]
+    if (method_info == nil)
+      error("#{class_name}.#{method_name} not available")
+      exit(1)
+    end
+
+    RCT.parse_options(method_info['required'], true)
+    RCT.parse_options(method_info['optional'], false)
+
+    response = obj.send(method_name) {
+      $HTTP.handle_request()
+    }
+
+    puts response
+    puts response.body
+  end
+
+
+end
+

data/lib/rct/rct_http.rb

@@ -0,0 +1,130 @@
+#
+#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#
+#  This file is part of rct.
+#
+#  rct is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  rct is distributed in the hope that it will be useful, but
+#  WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with rct.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+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.
+#
+# Currently using HTTPClient:
+# http://rubydoc.info/gems/httpclient/2.1.5.2/HTTPClient
+#
+class RCTHTTP
+
+
+  #------------------------------------------------------------------------------------------------
+  # Constructor.
+  #
+  def initialize
+    @http_client = HTTPClient.new()
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Handle one HTTP request.
+  #
+  # Connection parameters are all obtained from the current state (see constants.rb):
+  #
+  # * SERVER_TYPE     - Connect to a server of this type (overrides SERVER_HOSTNAME/SERVER_PORT).
+  # * SERVER_HOSTNAME - Connect to this server.
+  # * SERVER_PORT     - Connect to this port on server.
+  # * SERVER_PROTOCOL - Protocol (http/https).
+  # * REQ_PATH        - Request path.
+  # * REQ_PARAMS      - If set, appended to request path.
+  # * REQ_METHOD      - HTTP method to use (if not set, default is GET)
+  # * REQ_HEADERS     - Optional hash of additional request headers to set.
+  # * REQ_BODY        - Optional request body.
+  #
+  # Always returns an rct Response object.
+  #
+  def handle_request
+
+    if (RCT.sget(SERVER_TYPE) != nil)
+      die("request by server type not implemented!")
+    end
+
+    protocol = RCT.sget(SERVER_PROTOCOL)
+    host = RCT.sget(SERVER_HOSTNAME)
+
+    if (protocol == nil)
+      die("server protocol missing!")
+    end
+
+    if (host == nil)
+      die("server hostname missing!")
+    end
+
+    url = "#{protocol}://#{host}"
+    port = RCT.sget(SERVER_PORT)
+    if (port != nil)
+      url += ":#{port}"
+    end
+    url += RCT.sget(REQ_PATH)
+
+    params = RCT.sget(REQ_PARAMS)
+    if (params != nil && !params.empty?)
+      url += params
+    end
+
+    method = RCT.sget(REQ_METHOD)
+    if (method == nil || method.empty?)
+      method = "GET"
+    end
+
+    headers = RCT.sget(REQ_HEADERS)
+    if (headers == nil)
+      headers = Hash.new()
+    end
+    headers['User-agent'] = "rct/#{RCT_VERSION}"
+
+    res = nil
+
+    begin
+      if (method == "GET")
+        res = @http_client.get(url, nil, headers)
+
+      elsif (method == "POST")
+        body = RCT.sget(REQ_BODY)
+        res = @http_client.post(url, body, headers)
+
+      elsif (method == "PUT")
+        body = RCT.sget(REQ_BODY)
+        res = @http_client.put(url, body, headers)
+
+      elsif (method == "DELETE")
+        res = @http_client.delete(url, headers)
+
+      else
+        raise "Method #{method} not implemented yet!"
+      end
+    rescue Exception => e
+      response = Response.new(nil)
+      response.add_error(e.to_s)
+      return response
+    end
+
+    response = Response.new(res)
+    return response
+  end
+
+
+end

data/lib/rct/response.rb

@@ -0,0 +1,105 @@
+#
+#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#
+#  This file is part of rct.
+#
+#  rct is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  rct is distributed in the hope that it will be useful, but
+#  WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with rct.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+#--------------------------------------------------------------------------------------------------
+# 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.
+#
+# 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
+#++
+class Response
+
+
+  #------------------------------------------------------------------------------------------------
+  # Constructor...
+  #
+  # 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
+    @fail_msg = nil
+  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.
+  #
+  def add_error(msg)
+    if (@fail_msg == nil)
+      @fail_msg = msg
+    else
+      @fail_msg = "#{@fail_msg}; #{msg}"
+    end
+  end
+  
+
+  #------------------------------------------------------------------------------------------------
+  # Returns true unless this response has been flagged as an error via add_error() method.
+  #
+  def ok
+    return true if @fail_msg == nil
+    return false
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Return HTTP status code (or -1 if an error)
+  #
+  def status
+    return -1 if @res == nil
+    return @res.status
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Return requested HTTP header (or nil if an error)
+  #
+  def header(name)
+    return nil if @res == nil
+    return @res.header[name]
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Return HTTP response body (or nil if an error)
+  #
+  def body
+    return nil if @res == nil
+    return @res.content
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # 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
+    return "#{@res.status} #{@res.reason}"
+  end
+
+
+end

data/lib/rct/state.rb

@@ -0,0 +1,88 @@
+#
+#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#
+#  This file is part of rct.
+#
+#  rct is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  rct is distributed in the hope that it will be useful, but
+#  WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with rct.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+#--------------------------------------------------------------------------------------------------
+# 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).
+#
+# 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
+    @h = Hash.new()
+    @tmp = Hash.new()
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Set (or change) 'key' in state to contain 'value'.
+  # If 'temp' is true, this key is stored in temporary state only.
+  #
+  def set(key, value, temp=false)
+    if (temp)
+      @tmp[key] = value
+    else
+      @h[key] = value
+    end
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Get the value of 'key' (if available, or returns nil).
+  #
+  def get(key)
+    if (@tmp[key] != nil)
+      return @tmp[key]
+    else
+      return @h[key]
+    end
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Delete the given 'key' from both permanent and temporary state.
+  #
+  def delete(key)
+    @h.delete(key)
+    @tmp.delete(key)
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Reset temporary state.
+  # Returns the old temporary state hash object.
+  #
+  def reset
+    tmp = @tmp
+    @tmp = Hash.new
+    return tmp
+  end
+
+
+end

data/lib/rct_client.rb

@@ -0,0 +1,122 @@
+#
+#  Copyright 2012 Jyri J. Virkki <jyri@virkki.com>
+#
+#  This file is part of rct.
+#
+#  rct is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  rct is distributed in the hope that it will be useful, but
+#  WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with rct.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+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.
+  #
+  # 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?)
+      return params
+    end
+
+    if (params == nil || params.empty?)
+      return "?#{name}=#{value}"
+    end
+
+    return "#{params}&#{name}=#{value}"
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Returns a random UUID.
+  #
+  def uuid
+    return SecureRandom.uuid()
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Return true if var contains something (that is, it is not nil and not empty).
+  #
+  def set(var)
+    return false if var == nil
+    return false if var.empty?
+    return true
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # If the global state contains a non-nil/non-empty value for key 'name', add this to the
+  # 'hash' provided.
+  #
+  def add_to_hash_if_set(name, hash)
+    value = RCT.sget(name)
+    return false if value == nil
+    return false if value.empty?
+    hash[name] = value
+    return true
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Log a message. Level is one of RESULT, INFO, DEBUG.
+  #
+  def log(level, line)
+    rct_log(level, line)
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Set (or change) 'key' in state to contain 'value'.
+  # If 'temp' is true, this key is stored in temporary state only.
+  #
+  def sset(key, value, temp=false)
+    RCT.sset(key, value, temp)
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Set (or change) 'key' in temporary state to contain 'value'.
+  #
+  def ssettmp(key, value)
+    RCT.sset(key, value, true)
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Get the value of 'key' (if available, or returns nil).
+  #
+  def sget(key)
+    RCT.sget(key)
+  end
+
+
+  #------------------------------------------------------------------------------------------------
+  # Delete the given 'key' from both permanent and temporary state.
+  #
+  def sdelete(key)
+    RCT.sdelete(key)
+  end
+
+
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: rct
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: '0.1'
+platform: ruby
+authors:
+- Jyri J. Virkki
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-12-17 00:00:00.000000000 Z
+dependencies: []
+description: wip
+email: jyri@virkki.com
+executables:
+- rct
+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/state.rb
+- lib/rct.rb
+- lib/rct_client.rb
+- bin/rct
+homepage: https://github.com/jvirkki/rct
+licenses:
+- GPLv3
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+requirements: []
+rubyforge_project: nowarning
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: rct
+test_files: []