solutious-stella 0.5.5 → 0.6.0

data/lib/stella/command/get.rb

@@ -0,0 +1,44 @@
+
+require 'httpclient'
+
+require 'util/httputil'
+
+require 'stella/command/base'
+require 'stella/data/http'
+
+# NOTE: Not working
+
+#
+#
+module Stella::Command #:nodoc: all
+  class Get < Drydock::Command #:nodoc: all
+    include Stella::Command::Base
+    
+    attr_accessor :raw
+    attr_accessor :uri
+    attr_accessor :proxy
+    
+    def run
+      @req ||= req
+      raise "No request defined" unless @req
+      
+      c = (@proxy) ? HTTPClient.new(@proxy) : HTTPClient.new
+      c.get @req.uri, @req.headers
+    end
+    
+    def read_raw
+      Stella.info("Enter the raw GET request:")
+      @raw = gets
+      while raw !~ /^#{$/}$/ 
+        val = gets
+        @raw << val if val
+      end
+      @raw
+    end
+    
+    def req
+
+    end
+    
+  end
+end

data/lib/stella/common.rb

@@ -0,0 +1,53 @@
+
+
+module Stella
+  module Common
+    class Auth
+      attr_accessor :type
+      attr_accessor :user
+      attr_accessor :pass
+      attr_accessor :port
+      def initialize(type, user, pass=nil, port=nil)
+        @uri = type
+        @user = user
+        @pass = pass if pass
+        @port = port if port
+      end
+    end
+    class Proxy 
+      attr_accessor :uri
+      attr_accessor :user
+      attr_accessor :pass
+      def initialize(uri, user=nil, pass=nil)
+        @uri = uri
+        @user = user if user
+        @pass = pass if pass
+      end
+    end
+    class Machine
+      attr_accessor :host
+      attr_accessor :port
+      attr_accessor :role
+      attr_accessor :ssh
+      
+      def initialize(*args)
+        raise "You must at least a hostname or IP address" if args.empty?
+        if args.first.is_a? String
+          @host, @port = args.first.split(":") 
+        else  
+          @host, @port, @role = args.flatten
+        end
+        @role ||= "app"
+        @port = @port.to_i if @port
+      end
+      def to_s
+        str = "#{@host}"
+        str << ":#{@port}" if @port
+        str
+      end
+    end
+  end
+end
+
+
+

data/lib/stella/crypto.rb

@@ -0,0 +1,88 @@
+require 'base64'  
+
+if RUBY_PLATFORM !~ /java/
+  require 'openssl'
+else
+  module JRuby #:nodoc:
+     module OpenSSL #:nodoc:
+       GEM_ONLY = false unless defined?(GEM_ONLY)
+     end
+   end
+  
+   if JRuby::OpenSSL::GEM_ONLY
+     require 'jruby/openssl/gem'
+   else
+     module OpenSSL #:nodoc:all
+       class OpenSSLError < StandardError; end
+       # These require the gem
+       %w[
+       ASN1
+       BN
+       Cipher
+       Config
+       Netscape
+       PKCS7
+       PKey
+       Random
+       SSL
+       X509
+       ].each {|c| autoload c, "jruby/openssl/gem"}
+     end
+     require "jruby/openssl/builtin"
+   end
+end
+
+# A small collection of helper methods for dealing with RSA keys. 
+module Stella::Crypto
+  VERSION = 1.0
+  
+  def self.create_keys(bits = 2048)
+    pk = OpenSSL::PKey::RSA.new(bits)
+  end
+  
+  @@digest = OpenSSL::Digest::Digest.new("sha1")
+  def self.sign(secret, string)
+    sig = OpenSSL::HMAC.hexdigest(@@digest, secret, string).strip
+    #sig.gsub(/\+/, "%2b")
+  end
+  def self.aws_sign(secret, string)
+    Base64.encode64(self.sign(secret, string)).strip
+  end
+  
+  # A class which represents an RSA or DSA key. 
+  class Key
+    attr_reader :data, :key
+    
+    # Create an instance of Crypto::Key with the provided rsa or dsa 
+    # public or private key data. 
+    def initialize(data)
+      @data = data 
+      @public = (data =~ /^-----BEGIN (RSA|DSA) PRIVATE KEY-----$/).nil?
+      @key = OpenSSL::PKey::RSA.new(@data)
+    end  
+    
+    # Create an instance of Crypto::Key using a key file. 
+    #   key = Crypto::Key.from_file('path/2/id_rsa')
+    def self.from_file(filename)    
+      self.new File.read( filename )
+    end
+    
+    # Encrypt and base64 encode the given text.
+    def encrypt(text)
+      Base64.encode64(@key.send("#{type}_encrypt", text))
+    end
+    
+    # Decrypt the given base64 encoded text. 
+    def decrypt(text)
+      @key.send("#{type}_decrypt", Base64.decode64(text))
+    end
+  
+    def private?();  !@public; end
+    def public?();  @public;  end 
+    
+    def type
+      @public ? :public : :private
+    end
+  end
+end
+

data/lib/stella/data/domain.rb

@@ -1,7 +1,7 @@
 
 
 module Stella::Data
-  class DomainRequest < Stella::Storable
+  class DomainRequest < Storable
     attr_accessor :dns_data
     attr_reader :raw_data
     
@@ -40,7 +40,7 @@ module Stella::Data
     
   end
   
-  class DomainResponse < Stella::Storable
+  class DomainResponse < Storable
     attr_accessor :dns_data
     attr_reader :raw_data
     

data/lib/stella/data/http.rb

@@ -1,5 +1,6 @@
 
-require 'utils/httputil'
+require 'storable'
+require 'util/httputil'
 require 'base64'
 
 module Stella::Data
@@ -7,7 +8,7 @@ module Stella::Data
   # TODO: Implement HTTPHeaders. We should be printing untouched headers. 
   # HTTPUtil should split the HTTP event lines and that's it. Replace 
   # parse_header_body with split_header_body
-  class HTTPHeaders < Stella::Storable
+  class HTTPHeaders < Storable
     attr_reader :raw_data
     
     def to_s
@@ -16,41 +17,125 @@ module Stella::Data
     
   end
   
-  class HTTPRequest < Stella::Storable
+  class HTTPBody < Storable
+    field :content_type
+    field :form_param
+    field :content
+    
+    def has_content?
+      !@content.nil?
+    end
+    
+  end
+  
+  class HTTPRequest < Storable
+    # A string representing a raw HTTP request
     attr_reader :raw_data
     
+    # A hash containing blocks to be executed depending on the HTTP response status.
+    # The hash keys are numeric HTTP Status Codes. 
+    #
+    #     200 => { ... }
+    #     304 => { ... }
+    #     500 => { ... }
+    #
+    attr_accessor :response_handler
+    
+    field :name
+    field :stella_id
+    field :unique_id
     field :time => DateTime
-    field :client_ip => String
-    field :server_ip => String
-    field :header => String
-    field :uri => String
-    field :body => String
-    field :method => String
-    field :http_version => String
+    field :client_ip 
+    field :server_ip 
+    field :header 
+    field :uri
+    field :params
+    field :body 
+    field :http_method
+    field :http_version
+    
     
     def has_body?
-      @body && !@body.nil & !@body.empty?
+      !@body.nil? && !@body.empty?
     end
     def has_request?
       false
     end
-    def has_response?
-      (@response && @response.status && !@response.status.nil?)
+
+    def initialize (uri_str, method="GET", version="1.1")
+      @uri = (uri_str.is_a? String) ? URI.parse(uri_str) : uri
+      @http_method = method
+      @http_version = version
+      @headers = {}
+      @params = {}
+      @response_handler = {}
+      @time = Time.now
+      @stella_id = Stella::Crypto.sign(time.to_i.to_s, "#{@http_method}/#{@uri}/#{@params}")
+      @unique_id = nil
+      @body = HTTPBody.new
     end
     
-    def initialize(raw_data=nil)
+    def set_unique_id(seasoning=rand)
+      @unique_id = Stella::Crypto.sign(rand.to_s + seasoning.to_s, "#{@http_method}/#{@uri}/#{@params}")
+    end
+
+    
+    def from_raw(raw_data=nil)
       @raw_data = raw_data
-      if @raw_data
-        @method, @http_version, @uri, @header, @body = HTTPUtil::parse_http_request(raw_data) 
+      @http_method, @http_version, @uri, @header, @body = self.parse(@raw_data)
+      @time = DateTime.now
+    end
+    
+    def self.parse(raw)
+      return unless raw
+      HTTPUtil::parse_http_request(raw, @uri.host, @uri.port) 
+    end
+
+    
+    def add_header(*args)
+      name, value = (args[0].is_a? Hash) ? args[0].to_a.flatten : args
+      @headers[name.to_s] ||= []
+      @headers[name.to_s] << value
+    end
+    def add_param(*args)
+      name, value = (args[0].is_a? Hash) ? args[0].to_a.flatten : args
+      
+      # BUG: This auto-array shit is causing a problem where the one request
+      # will set the param and then next will set it again and it becomes
+      # an array. 
+      #if @params[name.to_s] && !@params[name.to_s].is_a?(Array)
+      #  @params[name.to_s] = [@params[name.to_s]]
+      #else
+      #  @params[name.to_s] = ""
+      #end
+      
+      @params[name.to_s] = value.to_s
+    end
+    
+    def add_response_handler(*args, &b)
+      args << 200 if args.empty?
+      args.each do |status|
+        @response_handler[status] = b
       end
-      @response = Stella::Data::HTTPResponse.new
     end
     
-    def uri
-      @uri.host = @server_ip.to_s if @uri && (@uri.host == 'unknown' || @uri.host.empty?)
-      @uri
+    # +content+ can be literal content or a file path
+    def add_body(content, form_param=nil, content_type=nil)
+      @body = Stella::Data::HTTPBody.new
+      
+      @body.form_param = form_param if form_param
+      @body.content_type = content_type if content_type
+      
+      if File.exists?(content)
+        @body.content = File.new(content)
+        @body.content_type ||= "application/x-www-form-urlencoded"
+      else
+        @body.content = content
+      end
+      
     end
     
+    
     def body
       return nil unless @body
       @body
@@ -58,26 +143,35 @@ module Stella::Data
     end
     
 
-    
-    def inspect
+    def headers
+      return [] unless header
       headers = []
       header.each_pair do |n,v|
-        headers << "#{n.to_s.gsub('_', '-')}: #{v[0]}"
+        headers << [n.to_s.gsub('_', '-'), v[0]]
       end
-      str = "%s %s HTTP/%s" % [method, uri.to_s, http_version]
-      str << $/ + headers.join($/)
-      str << $/ + $/ + body if body
+      headers
+    end
+    
+    def inspect
+      str = "%s %s HTTP/%s" % [http_method, uri.to_s, http_version]
+      str << $/ + headers.join($/) unless headers.empty?
+      str << $/ + $/ + body.to_s if body
       str
     end
     
     def to_s
-      str = "%s: %s %s HTTP/%s" % [time.strftime(NICE_TIME_FORMAT), method, uri.to_s, http_version]
+      str = "%s: %s %s HTTP/%s" % [time.strftime(NICE_TIME_FORMAT), http_method, uri.to_s, http_version]
       str
     end
     
+    def cookies
+      return [] if !header.is_a?(Hash) || header[:Cookie].empty?
+      header[:Cookie] 
+    end
+    
   end
   
-  class HTTPResponse < Stella::Storable
+  class HTTPResponse < Storable
     attr_reader :raw_data
     
     field :time => DateTime
@@ -91,13 +185,16 @@ module Stella::Data
     
     def initialize(raw_data=nil)
       @raw_data = raw_data
-      if @raw_data
-        @status, @http_version, @message, @header, @body = HTTPUtil::parse_http_response(@raw_data)
-      end
+      parse(@raw_data)
+    end
+    
+    def parse(raw)
+      return unless raw
+      @status, @http_version, @message, @header, @body = HTTPUtil::parse_http_response(raw)
     end
     
     def has_body?
-      @body && !@body.nil & !@body.empty?
+      !@body.nil? && !@body.empty?
     end
     def has_request?
       false
@@ -106,17 +203,42 @@ module Stella::Data
       false
     end
     
+    
     def body
       return nil unless @body
-      #Base64.encode64(@body)
-      (!header || !header[:Content_Type] || header[:Content_Type] !~ /text/) ? '' : @body
+      #TODO: Move to HTTPResponse::Body.to_s
+      if is_binary?
+       "[skipping binary content]"
+      elsif is_gzip?
+        #require 'zlib'
+        #Zlib::Inflate.inflate(@body)
+         "[skipping gzip content]"
+      else
+        @body
+      end
     end
     
-    def inspect
+    def headers
       headers = []
       header.each_pair do |n,v|
-        headers << "#{n.to_s.gsub('_', '-')}: #{v[0]}"
+        headers << [n.to_s.gsub('_', '-'), v[0]]
       end
+      headers
+    end
+    
+    def is_binary?
+      (!is_text?) == true
+    end
+    
+    def is_text?
+      (!header[:Content_Type].nil? && (header[:Content_Type][0].is_a? String) && header[:Content_Type][0][/text/] != nil)
+    end
+    
+    def is_gzip?
+      (!header[:Content_Encoding].nil? && (header[:Content_Encoding][0].is_a? String) && header[:Content_Encoding][0][/gzip/] != nil)
+    end
+    
+    def inspect
       str = "HTTP/%s %s (%s)" % [@http_version, @status, @message]
       str << $/ + headers.join($/)
       str << $/ + $/ + body if body
@@ -127,5 +249,11 @@ module Stella::Data
       str = "%s: HTTP/%s %s (%s)" % [time.strftime(NICE_TIME_FORMAT), @http_version, @status, @message]
       str 
     end
+    
+    
+    def cookies
+      return [] unless header.is_a?(Array) && !header[:Set_Cookie].empty?
+      header[:Set_Cookie] 
+    end
   end
 end