dtk-common-core 0.5.6

data/README.md

@@ -0,0 +1,6 @@
+dtk-common-repo
+===============
+
+License
+----------------------
+DTK Common Core is released under the GPLv3 license. Please see LICENSE for more details.

data/dtk-common-core.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/dtk-common-core/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Rich PELAVIN"]
+  gem.email         = ["rich@reactor8.com"]
+  gem.description   = %q{Dtk common repo is core common librabry of dtk, and mostly hold libraries used for http communication.}
+  gem.summary       = %q{Common libraries used for DTK CLI client.}
+  gem.homepage      = "https://github.com/rich-reactor8/dtk-common-repo"
+  gem.licenses      = ["GPL-3.0"]
+
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "dtk-common-core"
+  gem.require_paths = ["lib"]
+  gem.version       = "#{DtkCommonCore::VERSION}.#{ARGV[3]}".chomp(".")
+
+  gem.add_dependency 'rest-client','~> 1.6.7'
+end

data/lib/auxiliary.rb

@@ -0,0 +1,131 @@
+#TODO: will start moving over to using DtkCommon namespace; versions in DtkCommon namespace also in DTK::Common are teh upgraded versions
+require 'etc'
+
+module DtkCommon
+  module Aux
+    def self.dtk_instance_repo_username(tenant_id=nil)
+      instance_unique_id = get_ec2_instance_id() || get_macaddress().gsub(/:/,'-')
+      tenant_id ||= ::DTK::Common::Aux.running_process_user()
+      "dtk-#{instance_unique_id}--#{tenant_id}"
+    end
+  end
+end
+
+module DTK
+  module Common
+    module AuxMixin
+      def get_ssh_rsa_pub_key()
+        path = "#{running_process_home_dir()}/.ssh/id_rsa.pub"
+        begin
+          File.open(path){|f|f.read}.chomp
+         rescue Errno::ENOENT
+          raise Error.new("user (#{ENV['USER']}) does not have a public key under #{path}")
+         rescue => e
+          raise e
+         end
+      end
+
+      def hash_subset(hash,keys_subset,opts={})
+        keys_subset.inject(Hash.new) do |h,k|
+          index = k.kind_of?(Hash) ? k.keys.first : k
+          if opts[:no_non_nil] and hash[index].nil? then h
+          elsif not hash.has_key?(index) then h
+          else
+            key = k.kind_of?(Hash) ? k.values.first : k
+            val = hash[index]
+            h.merge(key => val)
+          end
+        end
+      end
+
+      def convert_keys_to_symbols(hash)
+        hash.keys.inject(Hash.new){|h,k|h.merge(k.to_sym => hash[k])}
+      end
+
+      def dtk_instance_repo_username()
+        #on ec2 changing mac addresses; so selectively pick instance id on ec2
+        unique_id = get_ec2_instance_id() || get_macaddress().gsub(/:/,'-')
+        "dtk-#{unique_id}"
+      end
+
+      def update_ssh_known_hosts(remote_host)
+        fingerprint = `ssh-keyscan -H -t rsa #{remote_host}`
+        ssh_known_hosts = "#{running_process_home_dir()}/.ssh/known_hosts"
+        if File.file?(ssh_known_hosts)
+          `ssh-keygen -f "#{ssh_known_hosts}" -R #{remote_host}`
+        end
+        File.open(ssh_known_hosts,"a"){|f| f << "#{fingerprint}\n"}
+      end
+
+      def get_macaddress()
+        return @macaddress if @macaddress
+        #TODO: may just use underlying routines for facter - macaddress
+        require 'facter'
+        collection = ::Facter.collection
+        @macaddress = collection.fact('macaddress').value
+      end
+
+      def get_ec2_public_dns()
+        get_ec2_meta_data('public-hostname')
+      end
+
+      def get_ec2_instance_id()
+        # @ec2_instance_id_cached used because it could have tried to get this info and result was null
+        return @ec2_instance_id if @ec2_instance_id_cached
+        @ec2_instance_id_cached = true
+        @ec2_instance_id = get_ec2_meta_data('instance-id')
+      end
+
+      def snake_to_camel_case(snake_case)
+        snake_case.gsub(/(^|_)(.)/) { $2.upcase }
+      end
+
+      def platform_is_linux?()
+        RUBY_PLATFORM.downcase.include?("linux")
+      end
+
+      def platform_is_windows?()
+        RUBY_PLATFORM.downcase.include?("mswin") or RUBY_PLATFORM.downcase.include?("mingw")
+      end
+
+      def  running_process_user()
+        if platform_is_windows?()
+          Etc.getlogin
+        else
+          Etc.getpwuid(Process.uid).name
+        end
+      end
+
+      def running_process_home_dir()
+        if platform_is_windows?()
+          File.expand_path('~')
+        else
+          Etc.getpwuid(Process.uid).dir
+        end
+      end
+
+     private
+      def get_ec2_meta_data(var)
+       #Fragments taken from Puppetlabs facter ec2
+        require 'open-uri'
+        require 'timeout'
+        ret = nil
+        begin 
+          url = "http://169.254.169.254:80/"
+          Timeout::timeout(WaitSec) {open(url)}
+          ret = OpenURI.open_uri("http://169.254.169.254/2008-02-01/meta-data/#{var}").read
+         rescue Timeout::Error
+         rescue
+          #TODO: unexpected; write t log what error is
+        end
+        ret
+      end    
+      WaitSec = 2
+    end
+    module Aux
+      class << self
+        include AuxMixin
+      end
+    end
+  end
+end

data/lib/dtk-common-core/version.rb

@@ -0,0 +1,3 @@
+module DtkCommonCore
+  VERSION = "0.5.6"
+end

data/lib/dtk_common_core.rb

@@ -0,0 +1,5 @@
+require File.expand_path('auxiliary.rb', File.dirname(__FILE__))
+require File.expand_path('errors.rb', File.dirname(__FILE__))
+require File.expand_path('hash_object.rb', File.dirname(__FILE__))
+require File.expand_path('log.rb', File.dirname(__FILE__))
+require File.expand_path('response.rb', File.dirname(__FILE__))

data/lib/errors.rb

@@ -0,0 +1,2 @@
+require File.expand_path('errors/errors', File.dirname(__FILE__))
+require File.expand_path('errors/rest_error', File.dirname(__FILE__))

data/lib/errors/errors.rb

@@ -0,0 +1,127 @@
+#TODO: should have a Common namespace put in after DTK
+module DTK
+  class Error < NameError
+    def self.top_error_in_hash()
+      {:error => :Error}
+    end
+    def initialize(msg="",name_or_opts=nil)
+      name = nil
+      opts = Hash.new
+      if name_or_opts.kind_of?(Hash)
+        opts = name_or_opts
+      else
+        name = name_or_opts
+      end
+      super(msg,name)
+      #TODO: might make default to be :log_error => false
+      unless opts.has_key?(:log_error) and not opts[:log_error]
+        Log.info(to_s)
+        if caller_info = opts[:caller_info]
+          caller_depth = (caller_info.kind_of?(Hash) ? caller_info[:depth] : nil)||DefaultCallerDepth 
+          Log.info_pp(caller[CallerOffset,caller_depth])
+        end
+      end
+    end
+    CallerOffset = 3
+    DefaultCallerDepth = 3
+
+    def to_hash()
+      if to_s == "" 
+        Error.top_error_in_hash()
+      elsif name.nil?
+        {:error => {:Error => {:msg => to_s}}}
+      else
+        {:error => {name.to_sym => {:msg => to_s}}}
+      end
+    end
+  end
+
+  class R8ParseError < Error
+    def initialize(msg,calling_obj=nil)
+      msg = (calling_obj ? "#{msg} in class #{calling_obj.class.to_s}" : msg)
+      super(msg)
+    end
+  end
+  class ErrorUsage < Error
+  end
+
+  class ErrorConstraintViolations < ErrorUsage
+    def initialize(violations)
+       super(msg(violations),:ConstraintViolations)
+    end
+   private
+    def msg(violations)
+      return ("constraint violation: " + violations) if violations.kind_of?(String)
+      v_with_text = violations.compact
+      if v_with_text.size < 2
+        return "constraint violations"
+      elsif v_with_text.size == 2
+        return "constraint violations: #{v_with_text[1]}"
+      end
+      ret = "constraint violations: "
+      ret << (v_with_text.first == :or ? "(atleast) one of " : "")
+      ret << "(#{v_with_text[1..v_with_text.size-1].join(", ")})"
+    end
+  end
+
+  class ErrorUserInputNeeded < ErrorUsage
+    def initialize(needed_inputs)
+      super()
+      @needed_inputs = needed_inputs
+    end
+    def to_s()
+      ret = "following inputs are needed:\n"
+      @needed_inputs.each do |k,v|
+        ret << "  #{k}: type=#{v[:type]}; description=#{v[:description]}\n"
+      end
+      ret
+    end
+  end
+
+  class ErrorNotImplemented < Error
+    def initialize(msg="NotImplemented error")
+      super("in #{this_parent_parent_method}: #{msg}",:NotImplemented)
+    end
+  end
+
+  class ErrorNotFound < Error
+    attr_reader :obj_type,:obj_value
+    def initialize(obj_type=nil,obj_value=nil)
+      @obj_type = obj_type
+      @obj_value = obj_value
+    end
+    def to_s()
+      if obj_type.nil?
+        "NotFound error:" 
+      elsif obj_value.nil?
+        "NotFound error: type = #{@obj_type.to_s}"
+      else
+        "NotFound error: #{@obj_type.to_s} = #{@obj_value.to_s}"
+      end
+    end
+    def to_hash()
+      if obj_type.nil?
+         {:error => :NotFound}
+      elsif obj_value.nil?
+        {:error => {:NotFound => {:type => @obj_type}}}
+      else
+        {:error => {:NotFound => {:type => @obj_type, :value => @obj_value}}}
+      end
+    end
+  end
+
+  class ErrorAMQP < Error
+    def to_s()
+      "AMQP error"
+    end
+  end
+  class ErrorAMQPQueueDoesNotExist < ErrorAMQP
+    attr_reader :queue_name
+    def initialize(queue_name)
+      @queue_name = queue_name
+    end
+    def to_s()
+      "queue #{queue_name} does not exist"
+    end
+  end
+end

data/lib/errors/rest_error.rb

@@ -0,0 +1,59 @@
+#TODO: should have a Common namespace put in after DTK
+#When creating these objects, an internal errro class is passed to the creation functions
+module DTK
+  class RestError  
+    def self.create(err)
+      if RestUsageError.match?(err)
+        RestUsageError.new(err)
+      elsif NotFound.match?(err)
+        NotFound.new(err)
+      else
+        Internal.new(err)
+      end
+    end
+    def initialize(err)
+      @code = nil
+      @message = nil
+    end
+    def hash_form()
+      {:code => code||:error, :message => message||''}
+    end 
+    private
+     attr_reader :code, :message
+    public
+    #its either its a usage or and internal (application error) bug
+    class Internal < RestError
+      def hash_form()
+        super.merge(:internal => true)
+      end 
+     private
+      def initialize(err)
+        super
+        @message = "#{err.to_s} (#{err.backtrace.first})"
+      end
+    end
+    class RestUsageError < RestError
+      def initialize(err)
+        super
+        @message = err.to_s
+      end
+      def self.match?(err)
+        err.kind_of?(ErrorUsage)
+      end
+    end
+    class NotFound < RestUsageError
+      def self.match?(err)
+        err.kind_of?(::NoMethodError) and is_controller_method(err)
+      end
+      def initialize(err)
+        super
+        @code = :not_found
+        @message = "'#{err.name}' was not found"
+      end
+     private
+      def self.is_controller_method(err)
+        err.to_s =~ /#<XYZ::.+Controller:/
+      end
+    end
+  end
+end

data/lib/hash_object.rb

@@ -0,0 +1,49 @@
+module DTK
+  module Common
+    class SimpleHashObject < Hash
+      def initialize(initial_val=nil,&block)
+        block ? super(&block) : super()
+        if initial_val
+          replace(initial_val)
+        end
+      end
+    end
+
+    # require 'active_support/ordered_hash'
+    # class SimpleOrderedHash < ::ActiveSupport::OrderedHash
+    class SimpleOrderedHash < Hash
+      def initialize(elements=[])
+        super()
+        elements = [elements] unless elements.kind_of?(Array)
+        elements.each{|el|self[el.keys.first] = el.values.first}
+      end
+    
+      #set unless value is nill
+      def set_unless_nil(k,v)
+        self[k] = v unless v.nil?
+      end
+    end
+
+    class PrettyPrintHash < SimpleOrderedHash
+      #field with '?' suffix means optioanlly add depending on whether name present and non-null in source
+      #if block is given then apply to source[name] rather than returning just source[name]
+      def add(model_object,*keys,&block)
+        keys.each do |key|
+          #if marked as optional skip if not present
+          if key.to_s =~ /(^.+)\?$/
+            key = $1.to_sym
+            next unless model_object[key]
+          end
+          #special treatment of :id
+          val = (key == :id ? model_object.id : model_object[key]) 
+          self[key] = (block ? block.call(val) : val)
+        end
+        self
+      end
+
+      def slice(*keys)
+        keys.inject(self.class.new){|h,k|h.merge(k => self[k])}
+      end
+    end
+  end
+end

data/lib/log.rb

@@ -0,0 +1,37 @@
+#TODO: bring in a production quality ruby logging capability that gets wrapped here
+#TODO: would put this in config
+module DTK
+  module Log
+    Config = Hash.new
+    Config[:print_time] = false
+    Config[:print_method] = false
+
+    def self.info(msg, out = $stdout)
+      out << "info: "
+      out << format(msg)
+    end
+    def self.debug(msg, out = $stdout)
+      out << "debug: "
+      out << format(msg)
+    end
+    def self.error(msg, out = $stdout)
+      out << "error: "
+      out << format(msg)
+    end
+    def self.info_pp(obj, out = $stdout)
+      out << Aux::pp_form(obj)
+    end
+    def self.debug_pp(obj, out = $stdout)
+      out << Aux::pp_form(obj)
+      obj
+    end
+   private
+    def self.format(msg)
+      ret = String.new
+      ret << "#{Time.now}: " if Config[:print_time]
+      ret << "in fn: #{this_parent_method}: " if Config[:print_method]
+      ret << msg
+      ret << "\n"
+    end
+  end
+end