right_support 2.4.1 → 2.5.0

data/lib/right_support/crypto/signed_hash.rb

@@ -5,6 +5,8 @@ module RightSupport::Crypto
 
     if require_succeeds?('yajl')
       DefaultEncoding = ::Yajl
+    elsif require_succeeds?('oj')
+      DefaultEncoding = ::Oj
     elsif require_succeeds?('json')
       DefaultEncoding = ::JSON
     else

data/lib/right_support/data/serializer.rb

@@ -0,0 +1,223 @@
+require 'time'
+require 'date'
+
+module RightSupport::Data
+  # Utility class that implements true, lossless Ruby-to-JSON serialization.
+  # With a few small exceptions, this module can #dump any Ruby object in your
+  # VM, and later #load the exact same object from its serialized representation.
+  # It can also be used with encoding schemes other than JSON, e.g. msgpack.
+  #
+  # This class works by transforming Ruby object graphs into an intermediate
+  # representation that consists solely of JSON-clean Ruby objects (String,
+  # Integer, ...). This intermediate format is dubbed "JSONish", and it can
+  # be transformed to JSON and back without losing data or creating ambiguity.
+  #
+  # If you use the class-level (::load and ::dump) interface to this class,
+  # it always uses JSON serialization by default. If you construct an instance,
+  # you can control which encoding scheme to use, as well as which Hash key to use
+  # to mark a serialized object.
+  #
+  # === JSONish Object Representation
+  # Most Ruby simple types (String, Integer, Float, true/false/nil) are
+  # represented by their corresponding JSON type. However, some JSONish
+  # values have special meaning:
+  #  * Strings beginning with a ':' represent a Ruby Symbol
+  #  * Strings in the ISO 8601 timestamp format represent a Ruby Time
+  #
+  # To avoid ambiguity due to Ruby Strings that happen to look like a
+  # JSONish Time or Symbol, some Strings are "object-escaped," meaning they
+  # are represented as a JSON object with _ruby_class:String.
+  #
+  # Arbitrary Ruby objects are represented as a Hash that contains a special
+  # key '_ruby_class'. The other key/value pairs of the hash consist of the
+  # object's instance variables. Any object whose state is solely contained
+  # in its instance variables is therefore eligible for serialization.
+  #
+  # JSONish also has special-purpose logic for some Ruby built-ins,
+  # allowing them to be serialized even though their state is not contained in
+  # instance variables. The following are all serializable built-ins:
+  #  * Class
+  #  * Module
+  #  * String (see below).
+  #
+  # === Capabilities
+  # The serializer can handle any Ruby object that uses instance variables to
+  # record state. It cleanly round-trips the following Ruby object types:
+  #  * Collections (Hash, Array)
+  #  * JSON-clean data (Numeric, String, true, false, nil)
+  #  * Symbol
+  #  * Time
+  #  * Class
+  #  * Module
+  #
+  # === Known Limitations
+  # Cannot record the following kinds of state:
+  #  * Class variables of objects
+  #  * State that lives outside of instance variables, e.g. IO#fileno
+  #
+  # Cannot cleanly round-trip the following:
+  #  * Objects that represent callable code: Proc, Lambda, etc.
+  #  * High-precision floating point numbers (due to truncation)
+  #  * Times with timezone other than UTC or precision greater than 1 sec
+  #  * Hash keys that are anything other than a String (depends on JSON parser)
+  #  * Hashes that contain a String key whose value is '_ruby_class'
+  class Serializer
+    if require_succeeds?('yajl')
+      Encoder = ::Yajl
+    elsif require_succeeds?('oj')
+      Encoder = ::Oj
+    elsif require_succeeds?('json')
+      Encoder = ::JSON
+    else
+      Encoder = nil
+    end unless defined?(Encoder)
+
+    # Format string to use when sprintf'ing a JSONish Time
+    TIME_FORMAT       = '%4.4d-%2.2d-%2.2dT%2.2d:%2.2d:%2.2dZ'
+    # Pattern to match Strings against for object-escaping
+    TIME_PATTERN      = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/
+    # Special key used as a pseudo-instance-variable for Class and Module
+    CLASS_ESCAPE_KEY  = 'name'
+    # Special key used as a pseudo-instance-variable for String
+    STRING_ESCAPE_KEY = 'value'
+
+    DEFAULT_OPTIONS = {
+        :marker  => '_ruby_class',
+        :encoder => Encoder
+    }
+
+    def self.load(data)
+      self.new.load(data)
+    end
+
+    def self.dump(object)
+      self.new.dump(object)
+    end
+
+    # Instantiate a Serializer instance.
+    # @option options :encoder [#load, #dump] underlying data-encoder to use. Defaults to any available JSON gem.
+    # @option options :marker special object key to use when representing a serialized Ruby object. Defaults to '_ruby_class'.
+    def initialize(options={})
+      options = DEFAULT_OPTIONS.merge(options)
+      @marker = options[:marker]
+      @encoder = options[:encoder]
+    end
+
+    # @param [String] data valid JSON document representing a serialized object
+    # @return [Object] unserialized Ruby object
+    def load(data)
+      jsonish = @encoder.load(data)
+      jsonish_to_object(jsonish)
+    end
+
+    # @param [Object] object any Ruby object
+    # @return [String] JSON document representing the serialized object
+    def dump(object)
+      jsonish = object_to_jsonish(object)
+      @encoder.dump(jsonish)
+    end
+
+    protected
+
+    # Given an Object, transform it into a JSONish Ruby structure.
+    # @param [Object] object any Ruby object
+    # @return [Object] JSONish representation of input object
+    def object_to_jsonish(object)
+      case object
+      when String
+        if (object =~ /^:/ ) || (object =~ TIME_PATTERN)
+          # Strings that look like a Symbol or Time must be object-escaped.
+          {@marker => String.name,
+           STRING_ESCAPE_KEY => object}
+        else
+          object
+        end
+      when Fixnum, Float, TrueClass, FalseClass, NilClass
+        object
+      when Hash
+        object.inject({}) do |result, (k, v)|
+          result[object_to_jsonish(k)] = object_to_jsonish(v)
+          result
+        end
+      when Array
+        object.map { |e| object_to_jsonish(e) }
+      when Symbol
+        # Ruby Symbol is represented as a string beginning with ':'
+        ":#{object}"
+      when Time
+        # Ruby Time is represented as an ISO 8601 timestamp in UTC timeztone
+        utc = object.utc
+        TIME_FORMAT % [utc.year, utc.mon, utc.day, utc.hour, utc.min, utc.sec]
+      when Class, Module
+        # Ruby Class/Module needs special handling - no instance vars
+        { @marker => object.class.name,
+          CLASS_ESCAPE_KEY  => object.name }
+      else
+        # Generic serialized object; convert to Hash.
+        hash = {}
+        hash[@marker] = object.class.name
+
+        object.instance_variables.each do |var|
+          hash[ var[1..-1] ] = object_to_jsonish(object.instance_variable_get(var))
+        end
+
+        hash
+      end
+    end
+
+    # Given a JSONish structure, transform it back to a Ruby object.
+    # @param [Object] jsonish JSONish Ruby structure
+    # @return [Object] unserialized Ruby object
+    def jsonish_to_object(jsonish)
+      case jsonish
+      when String
+        if jsonish =~ /^:/
+          # JSONish Symbol
+          jsonish[1..-1].to_sym
+        elsif TIME_PATTERN.match(jsonish)
+          # JSONish Time
+          Time.parse(jsonish)
+        else
+          # Normal String
+          jsonish
+        end
+      when Fixnum, Float, TrueClass, FalseClass, NilClass
+        jsonish
+      when Hash
+        if jsonish.key?(@marker) # We have a serialized Ruby object!
+          hash   = jsonish
+          klass  = hash.delete(@marker)
+          case klass
+          when Class.name, Module.name
+            # Serialized instance of Ruby Class or Module
+            jsonish = hash.delete(CLASS_ESCAPE_KEY).to_const
+          when String.name
+            # Object-escaped Ruby String
+            jsonish = String.new(hash.delete(STRING_ESCAPE_KEY))
+          when Time.name
+            # Object-escaped Ruby String
+            jsonish = Time.at(hash.delete(TIME_ESCAPE_KEY))
+          else
+            # Generic serialized object
+            klass = klass.to_const
+            jsonish = klass.allocate
+            hash.each_pair do |k, v|
+              jsonish.instance_variable_set("@#{k}", jsonish_to_object(v))
+            end
+          end
+
+          jsonish
+        else # We have a plain old Ruby Hash
+          jsonish.inject({}) do |result, (k, v)|
+            result[jsonish_to_object(k)] = jsonish_to_object(v)
+            result
+          end
+        end
+      when Array
+        jsonish.map { |e| jsonish_to_object(e) }
+      else
+        raise ArgumentError, "Non-JSONish object of type '#{jsonish.class}'"
+      end
+    end
+  end
+end

data/lib/right_support/data.rb

@@ -29,5 +29,6 @@ module RightSupport
   end
 end
 
+require 'right_support/data/serializer'
 require 'right_support/data/hash_tools'
 require 'right_support/data/uuid'

data/lib/right_support/net/s3_helper.rb

@@ -0,0 +1,144 @@
+# Copyright (c) 2009-2011 RightScale, Inc, All Rights Reserved Worldwide.
+#
+# THIS PROGRAM IS CONFIDENTIAL AND PROPRIETARY TO RIGHTSCALE
+# AND CONSTITUTES A VALUABLE TRADE SECRET.  Any unauthorized use,
+# reproduction, modification, or disclosure of this program is
+# strictly prohibited.  Any use of this program by an authorized
+# licensee is strictly subject to the terms and conditions,
+# including confidentiality obligations, set forth in the applicable
+# License Agreement between RightScale.com, Inc. and the licensee.
+
+module RightSupport::Net
+  # Class provides S3 functionality.
+  # As part of RightSupport S3Helper does not include Rightscale::S3 and Encryptor modules.
+  # This modules must be included in application.
+  #
+  # Example:
+  #
+  # require 'right_support'
+  # require 'right_aws'
+  # require 'encryptor'
+  #
+  # s3_config = YAML.load_file(File.expand_path("../../config/s3.yml",__FILE__))[ENV['RACK_ENV']]
+  # RightSupport::Net::S3Helper.init(s3_config, Rightscale::S3, Encryptor)
+  # s3_health = RightSupport::Net::S3Helper.health_check
+  class S3Helper
+    # Init() is the first method which must be called.
+    # This is configuration and integration with S3 and Encryptor
+    #
+    # @param  [Hash]  config     config for current environment (from YAML config file)
+    #                              creds:
+    #                                aws_access_key_id: String
+    #                                aws_secret_access_key: String
+    #                              bucket_name: String
+    #                              master_secret: String
+    # @param  [Class] s3         Rightscale::S3 class is used to connect to S3
+    # @param  [Class] encryptor  Class which will be used to encrypt data
+    #                              encrypt() and decrypt() methods must be implemented
+    #
+    # Init() does not return anything
+    def self.init(config, s3, encryptor)
+      @config = config
+      @s3class = s3
+      @encryptor = encryptor
+    end
+    # Checks S3 credentials syntax in config parameter
+    #
+    # @return  [Boolean]  true if s3 creadentials are ok or false if not
+    def self.s3_enabled?
+      return @s3_enabled if @s3_enabled
+      @s3_enabled ||= !config.empty? &&
+        !config["creds"].empty?    &&
+        !config["creds"]["aws_access_key_id"].nil? &&
+        config["creds"]["aws_access_key_id"] != "@@AWS_ACCESS_KEY_ID@@"
+    end
+    # Returns @config parameter
+    def self.config
+      @config
+    end
+    # Creates (if does not exist) and return S3 object
+    def self.s3
+      @s3 ||= @s3class.new config["creds"]["aws_access_key_id"], config["creds"]["aws_secret_access_key"]
+    end
+    # Creates S3 Bucket object using created in s3() object
+    def self.bucket
+      #TO DISCUSS: second param 'true' means 'create new bucket'
+      #@bucket ||= s3.bucket(config["bucket_name"], true)
+      @bucket ||= s3.bucket(config["bucket_name"])
+    end
+    # Returns Master secret from config
+    def self.master_secret
+      config["master_secret"]
+    end
+    # Downloads data from S3 Bucket
+    #
+    # @param   [String]  key   Name of the bucket key
+    # @param   [Block]   blck  Ruby code wich will be done by Bucket object
+    #
+    # @return  [String]  S3 bucket's key content in plain/text format
+    def self.get(key, &blck)
+      return nil unless s3_enabled?
+
+      object = bucket.key(key, true, &blck)
+      return nil if object.nil?
+
+      # don't decrypt/verify unencrypted values
+      return object.data if object.meta_headers["digest"].nil?
+
+      ciphertext = object.data
+      passphrase = "#{key}:#{master_secret}"
+      plaintext = @encryptor.decrypt(:key=>passphrase, :value=>ciphertext)
+      digest = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new, passphrase, plaintext)
+
+      if digest == object.meta_headers["digest"]
+        return plaintext
+      else
+        raise "digest for key:#{key} in s3 does not match calculated digest."
+      end
+    end
+    # Upload data to S3 Bucket
+    #
+    # @param   [String]  key        Name of the bucket key
+    # @param   [String]  plaintext  Data which should be saved in the Bucket
+    # @param   [Block]   blck       Ruby code wich will be done by Bucket object
+    #
+    def self.post(key, plaintext, &blck)
+      passphrase = "#{key}:#{master_secret}"
+      plaintext = "-- no detail --" unless plaintext && plaintext.size > 0
+      ciphertext = @encryptor.encrypt(:key=>passphrase, :value=>plaintext)
+      digest = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new, passphrase, plaintext)
+      bucket.put(key, ciphertext, {"digest" => digest}, &blck)
+    end
+    # Checks if it is possible to connect to the S3 Bucket.
+    #
+    # @return [String or True]  If test was successful then return true
+    #                           Else return error message
+    def self.health_check
+      config
+      s3
+      # test config file
+      return 'S3 Config file: Credentials: Syntax error.' unless s3_enabled?
+      ["bucket_name", "master_secret"].each do |conf|
+        return "S3 Config file: #{conf.upcase}: Syntax error." if config[conf].nil? || config[conf] == '' || config[conf] == "@@#{conf.upcase}@@"
+      end
+      # test connection
+      original_text = 'heath check'
+      test_key  = 'ping'
+      begin
+        post(test_key, original_text)
+      rescue Exception => e
+        return e.message
+      end
+      begin
+        result_text = get(test_key)
+      rescue Exception => e
+        return e.message
+      end
+      return 'Sended text and returned one are not equal. Possible master_secret problem' if result_text != original_text
+      # retrurn true if there were not errors
+      true
+    end
+
+  end
+
+end

data/lib/right_support/net.rb

@@ -36,5 +36,6 @@ require 'right_support/net/lb'
 require 'right_support/net/request_balancer'
 require 'right_support/net/ssl'
 require 'right_support/net/dns'
+require 'right_support/net/s3_helper'
 
 RightSupport::Net.extend(RightSupport::Net::AddressHelper)

data/right_support.gemspec

@@ -7,8 +7,8 @@ spec = Gem::Specification.new do |s|
   s.required_ruby_version = Gem::Requirement.new(">= 1.8.7")
 
   s.name    = 'right_support'
-  s.version = '2.4.1'
-  s.date    = '2012-09-18'
+  s.version = '2.5.0'
+  s.date    = '2012-09-19'
 
   s.authors = ['Tony Spataro', 'Sergey Sergyenko', 'Ryan Williamson', 'Lee Kirchhoff', 'Sergey Enin']
   s.email   = 'support@rightscale.com'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: right_support
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 2
-  - 4
-  - 1
-  version: 2.4.1
+  - 5
+  - 0
+  version: 2.5.0
 platform: ruby
 authors: 
 - Tony Spataro
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-09-18 00:00:00 -07:00
+date: 2012-09-19 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -43,6 +43,7 @@ files:
 - lib/right_support/crypto/signed_hash.rb
 - lib/right_support/data.rb
 - lib/right_support/data/hash_tools.rb
+- lib/right_support/data/serializer.rb
 - lib/right_support/data/uuid.rb
 - lib/right_support/db.rb
 - lib/right_support/db/cassandra_model.rb
@@ -62,6 +63,7 @@ files:
 - lib/right_support/net/lb/round_robin.rb
 - lib/right_support/net/lb/sticky.rb
 - lib/right_support/net/request_balancer.rb
+- lib/right_support/net/s3_helper.rb
 - lib/right_support/net/ssl.rb
 - lib/right_support/net/ssl/open_ssl_patch.rb
 - lib/right_support/net/string_encoder.rb