lolitado 0.0.8 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c680b69ccfdd2b65f17e34620494d141e94241a9ffbf7b475baf370a323eaa4
-  data.tar.gz: 7f7b4b404ae6d9d8bc6d54c612216f1d125caf3b7c4fd65ad29410c50c61a2da
+  metadata.gz: 1e3340ad161dcc24cdbdf7f33fb3a5d3320e2f1d803b62450aaea1c675ea22e9
+  data.tar.gz: 841aa2524c08929995ad31d1b327a5845ff6f9dc9d85640ed5de8231f26c8153
 SHA512:
-  metadata.gz: d522c333a7c845b3bf34f5bb24d331fea0b51cc57d54e2a697619ad98abe682672678a3b0181d0eef5a344d6daf580e0dbdb41216b65c25fdd413c1f27f68744
-  data.tar.gz: edb4a324e9a147514005ee259f50f1a2b25187e6988a5e5824e2c108cb03be32f4d3ad10b57bbaa3a1106bda3d1bcb951d03265114d8bb9832b2791f51bfde07
+  metadata.gz: e03f1347e053cd101482de80c4cdc19c4f7ab7a707f21445a988d53490b1bdd570ebbfb4fc80fd1c9e1721fce697cefdd5859ff0748149147fd8c1545493a0bd
+  data.tar.gz: feb5d8b78188e22ae3afb1c591873bf2b0b85672b4565245a94d547099f5f5d4797c0f3f72d2c074b00904292b75961162cd3ee03d56a2c0bd58b38c1a943849

data/.gitignore

@@ -0,0 +1 @@
+lolitado*.gem

data/README.md

@@ -0,0 +1,69 @@
+# lolitado
+Library for using database and API
+
+----
+## How to call database?
+
+
+You need to do these things：
+
+* put all sql in sql.yml or in code
+* put database connect info in xx_db.yml
+----
+run case like
+
+````ruby
+pool = Lolitado:Pool.new('xx_db.yml')
+db = pool.use(:db =>'db_name')
+sql = "select * from identity.user where phone = '+86 139 0000 0000"
+result = db.query(sql)
+````
+----
+## How to call API?
+
+----
+run case like
+
+````ruby
+ * Rest API
+  class TestRest
+    include Lolitado
+
+    def initialize
+      base_uri 'https://xxx.com'
+    end
+
+    def get_details_of_a_city city_slug, locale
+      add_headers({'Accept-Language' => locale})
+      request('get', "/cities/#{city_slug}")
+    end
+  end
+
+* Graph API
+  class TestGraph
+    include Lolitado
+
+    def initialize
+      base_uri 'https://xxx.com'
+    end
+
+    def user_login payload
+      add_headers({'Content-Type' => "application/json"})
+      query = "mutation login($input: UserLoginInput!) {userLogin(input:$input) {authToken}}"
+      graph_request(query, payload)
+    end
+  end
+````
+----
+## How to encrypt/decrypt credential file?
+
+* Initialize Box with secret key of environment variable
+* file_encrypt to encrypt the file
+* file_decrypt to decrypt the file
+
+----
+````ruby
+box = Lolitado:Box.new('ENV_KEY')
+box.file_encrypt('file_name')
+box.file_decrypt('encrypt_file_name')
+````

data/lib/lolitado.rb

@@ -1,10 +1,89 @@
-require 'pool'
-require 'db'
-require 'request'
-require 'box'
+$:.unshift File.expand_path('..', __FILE__)
 
-module LolitaDo
-  class LolitaClass
+require 'lolitado/pool'
+require 'lolitado/db'
+require 'lolitado/api'
+require 'lolitado/box'
 
+#
+# Module that when included adds functionality to an API(Rest/Graph) Class.
+# 
+# How to use it ?
+# 
+# @example Rest API
+#   class TestRest
+#     include Lolitado
+
+#     def initialize
+#       base_uri 'https://xxx.com'
+#     end
+
+#     def get_details_of_a_city city_slug, locale
+#       request('get', "/cities/#{city_slug}", locale)
+#     end
+#   end
+#
+# @example Graph API
+#   class TestGraph
+#     include Lolitado
+
+#     def initialize
+#       base_uri 'https://xxx.com'
+#     end
+
+#     def user_login payload
+#       query = "mutation login($input: UserLoginInput!) {userLogin(input:$input) {authToken}}"
+#       graph_request(query, payload)
+#     end
+#   end
+module Lolitado
+
+  #
+  # forward request method from Rest class to API.request method
+  # 
+  # @param method [String] http request method
+  # @param endpoint [String] http request endpoint
+  # @param token [String] authorization token if query needed
+  # @param locale [String] locale if query needed
+  # @param body [String] http request body
+  #
+  def request method, endpoint, token = false, locale = false, body=false
+    add_headers({'Authorization' => "Bearer #{token}"}) if token
+    add_headers({'Accept-Language' => locale}) if locale
+    API.request(method, endpoint, body)
   end
+
+  #
+  # forward graph_request method from Graph class to Graph.request method
+  #
+  # @param query [String] graph query
+  # @param token [String] authorization token if query needed
+  # @param locale [String] locale if query needed
+  # @param variables [String] input variables for graph query using
+  #
+  def graph_request query, token = false, locale = false, variables = false
+    add_headers({'Content-Type' => "application/json"})
+    add_headers({'Authorization' => "Bearer #{token}"}) if token
+    add_headers({'Accept-Language' => locale}) if locale
+    Graph.request(query, variables)
+  end
+  
+  #
+  # forward add_headers from Rest/Graph class to API.add_headers method
+  # 
+  # @param value [Hash] http header value
+  #
+  def add_headers value
+    API.add_headers value
+  end
+
+  #
+  # forward uri from Rest/Graph class to API.uri method
+  #
+  # @param uri [String] http request uri
+  #
+  def base_uri uri
+    API.base_uri uri
+  end
+
 end

data/lib/lolitado/api.rb

@@ -0,0 +1,130 @@
+require 'httparty'
+module Lolitado
+  class API
+    include HTTParty
+
+    #
+    # format api response
+    #
+    # @param response [String] api response
+    # @param msecs [Float] benchmark for api response time
+    #
+    def self.format_response response, msecs
+      new_response = {:response => response, :message => response.parsed_response, :status => response.code, :duration => msecs}
+      response_with_hash_key = JSON.parse(JSON[new_response], symbolize_names: true)
+      return response_with_hash_key
+    end
+    
+    #
+    # define a customize http request method for rest api, forward this method to call HTTParty.get or HTTParty.post or HTTParty.put
+    # or HTTParty.delete method
+    #
+    # @param method [String] http request method
+    # @param endpoint [String] http request endpoint
+    # @param body [String] http request body
+    #
+    def self.request method, endpoint, body = false
+      start = Time.now
+      case method.to_s
+      when "get"
+        response = self.get(endpoint, :body => body, :headers => API.new_headers, :verify => false)
+      when "post"
+        response = self.post(endpoint, :body => body, :headers => API.new_headers, :verify => false)
+      when "put"
+        response = self.put(endpoint, :body => body, :headers => API.new_headers, :verify => false)
+      when "delete"
+        response = self.delete(endpoint, :headers => API.new_headers, :verify => false)
+      else
+        warn "#{method} is invalid http method."
+      end
+      finish = Time.now
+      msecs = (finish - start) * 1000.0
+      clear_headers
+      # puts "RESPONSE - #{msecs}"
+      return self.format_response(response, msecs)
+    end 
+
+    #
+    # define a method to set http headers
+    #
+    # @param value [Hash] http header value
+    #
+    def self.add_headers value
+      @new_headers ||= {}
+      @new_headers = @new_headers.merge(value.to_hash)
+      return @new_headers
+    end
+
+    #
+    # define a method to get http headers
+    #
+    def self.new_headers
+      return @new_headers
+    end
+
+    #
+    # clear headers
+    #
+    def self.clear_headers
+      API.new_headers.clear unless API.new_headers.nil?
+    end
+  end
+
+  class Graph < API
+
+    #
+    #
+    # define a customize http request method for graph api, forward this method to call HTTParty.get or HTTParty.post or HTTParty.put
+    # or HTTParty.delete method
+    #
+    # @param query [String] graph query
+    # @param variables [String] input variables for graph query using
+    #
+    def self.request query, variables = false
+      super(:post, '', generate_body(query, variables))
+    end
+
+    #
+    # format api response, override the parent method in API class
+    #
+    # @param response [String] api response
+    # @param msecs [Float] benchmark for api response time
+    #
+    def self.format_response response, msecs
+      if response.parsed_response.is_a?(Hash)
+        if response.parsed_response.has_key?('errors')
+          message = response.parsed_response
+        else
+          message = response.parsed_response['data'].values[0]
+        end
+      else
+        message = {'errors'=>response.parsed_response}
+      end
+      new_response =  {:response => response, :message => message, :status => response.code, :duration => msecs}
+      response_with_hash_key = JSON.parse(JSON[new_response], symbolize_names: true)
+      return response_with_hash_key
+    end
+
+    # 
+    # generate http request body for graph api response
+    #
+    # @param query [String] graph query
+    # @param variables [String] input variables for graph query using
+    #
+    def self.generate_body query, variables
+      body = {}
+      body['query'] = query
+      if variables
+        variable_indices = query.enum_for(:scan, /(?=\$.*:)/).map { Regexp.last_match.offset(0).first }
+        if query.include?('$input') && variable_indices.to_a.length == 1
+          body['variables'] = {'input'=>variables}
+        else
+          body['variables'] = variables
+        end
+      end
+      body['operationName'] = query.split(' ')[1].split('(')[0]
+      return body.to_json
+    end
+  end
+end
+

data/lib/lolitado/box.rb

@@ -0,0 +1,44 @@
+require 'rbnacl'
+require 'base64'
+
+module Lolitado
+  class Box
+    
+    attr_accessor :box
+
+    #
+    # initialize box 
+    #
+    # @param key [String] ENV key value used for initialize box
+    #
+    def initialize key
+      fail "There's no environment variable #{key}..." if ENV[key].nil?
+      key = Base64.decode64(ENV[key])
+      @box = RbNaCl::SimpleBox.from_secret_key(key)
+    end
+
+    #
+    # encrypt file
+    #
+    # @param file [String] the file need to be encrypted
+    #
+    def file_encrypt file
+      plaintext = File.read(file)
+      ciphertext = box.encrypt(plaintext)
+      enc_file = file + '.enc'
+      File.write(enc_file, Base64.encode64(ciphertext))
+    end
+
+    #
+    # decrypt file
+    #
+    # @param file [String] the file need to be decrypted
+    #
+    def file_decrypt file
+      ciphertext = File.read(file)
+      plaintext = box.decrypt(Base64.decode64(ciphertext))
+      plain_file = file[0..-5]
+      File.write(plain_file, plaintext)
+    end
+  end
+end

data/lib/lolitado/db.rb

@@ -0,0 +1,140 @@
+module Lolitado
+  class Database
+
+    attr_accessor :db
+
+    def initialize db
+      @db = db
+    end
+
+    #
+    # Return the data by sql.
+    #
+    # @param [String] sql the sql you wanna query
+    #
+    def query sql
+      result = db[sql].all
+      return result
+    end
+
+    #
+    # Return the data by sql.
+    #
+    # @param [String] sql the sql you wanna query, the multiple sql should be split by ;
+    #
+    def multiple_query sql
+      splited_sql = sql.split(';')
+      splited_sql.each do |each_sql|
+        query(each_sql)
+      end
+    end
+    
+    #
+    # Return the data and execute duration by sql.
+    #
+    # @param [String] sql the sql you wanna query
+    # @param [Boolean] type the default value is true that the expected result is not empty, otherwise, the expected result is empty
+    # @param [Number] waiting_time the default value is 10 that maxium execute duration is 10 second
+    #
+    def query_duration sql, type = true, waiting_time = 10
+      start = Time.now
+      if type
+        result = query_wait(sql, waiting_time)
+      else
+        result = query_empty(sql, waiting_time)
+      end
+      finish = Time.now
+      msecs = (finish - start) * 1000.0
+      hash = {'result' => result, 'duration' => msecs}
+      return hash
+    end
+    
+    #
+    # Expect to return data for the query. If the result is empty then it will be called again until waiting_time reach.
+    #
+    # @param [String] sql the sql you wanna query
+    # @param [Number] waiting_time the default value is 10 that maxium execute duration is 10 second
+    #
+    def query_wait sql, waiting_time = 10
+      result = db[sql].all
+      if result.empty?
+        if waiting_time != 0
+          sleep 1
+          result = query_wait(sql, waiting_time - 1)
+        end
+      end
+      return result
+    end
+
+    #
+    # Expect to return empty for the query. If the result is not empty then it will be called again until waiting_time reach.
+    #
+    # @param [String] sql the sql you wanna query
+    # @param [Number] waiting_time the default value is 10 that maxium execute duration is 10 second
+    #
+    def query_empty sql, waiting_time = 10
+      result = db[sql].all
+      if !result.empty?
+        if waiting_time != 0
+          sleep 1
+          result = query(sql, waiting_time - 1)
+        end
+      end
+      return result
+    end
+
+    #
+    # Execute by sql, the sql is normally update or insert.
+    #
+    # @param [String] sql the sql you wanna execute
+    #
+    def execute sql
+      db[sql]
+    end
+
+    #
+    # Insert data by data.
+    #
+    # @param [String] data the data wanna insert which is array or hash
+    # @param [String] table the table wanna insert
+    #
+    def insert_by_data data, table
+      sql = "insert into #{table} "
+      case data
+        when Array
+          data.each do |d|
+            insert_by_data(d, table)
+          end
+        when Hash
+          columns = data.keys.to_s.gsub('[','(').gsub(']',')').gsub('"','')
+          values = data.values.to_s.gsub('[','(').gsub(']',')').gsub('nil','NULL')
+          sql = sql + columns + " values " + values
+          query(sql)
+      end
+    end
+
+    #
+    # Update data by data.
+    #
+    # @param [Hash] data the data wanna update which is hash
+    # @param [String] table the table for the update
+    # @param [Hash] condition the condition for the update
+    #
+    def update data, table, condition = {}
+      sql = "update #{table} set"
+      data.each do |k,v|
+        v = v.to_json if v.is_a?(Hash)
+        if !!v == v
+          sql = "#{sql} #{k}=#{v},"
+        else
+          sql = "#{sql} #{k}='#{v}',"
+        end
+      end
+      sql = sql[0..-2] + " where"
+      condition.each do |k,v|
+        sql = "#{sql} #{k} = '#{v}' and"
+      end
+      query(sql[0..-4])
+    end
+  end
+end

data/lib/lolitado/pool.rb

@@ -0,0 +1,139 @@
+require 'mysql2'
+require 'sequel'
+require 'net/ssh/gateway'
+require 'psych'
+require_relative 'db'
+
+module Lolitado
+  class Pool
+
+    attr_accessor :db_pool, :ssh_pool, :file
+
+    #
+    # initialize Lolitado::Pool, generate db_pool, ssh_pool object to use
+    #
+    # @param file_path [String] the configure file to used for initialize 
+    #
+    def initialize file_path
+      @db_pool = {}
+      @ssh_pool = {}
+      @file = Psych.load_file(file_path)
+    end
+    
+    # 
+    # use existing db or ssh pool or switch to another db and ssh pool
+    #
+    # @param params [Hash] key, value used to use db/ssh pool
+    # 
+    # @example 
+    #   pool.use(:db => 'db_name')
+    #
+    def use(params = {})
+      ssh_name = params.fetch(:ssh, false)
+      db_name = params.fetch(:db, false)
+      if db_name
+        return get_db db_name
+      elsif ssh_name
+        return get_ssh ssh_name
+      else
+        fail "Please provide :ssh or :db"
+      end
+    end
+
+    # 
+    # return existing db object or create new db object
+    #
+    # @param name [String] db configure name in yaml file
+    #
+    def get_db name
+      if db_pool[name].nil?
+        db_conf =  file[name]
+        if db_conf['proxy'].nil?
+          db = connect_database db_conf
+        else
+          db = connect_database_by_proxy db_conf
+        end
+        db_pool[name] = Database.new(db)
+      end
+      return db_pool[name]
+    end
+
+    # 
+    # return existing ssh object or create new ssh object
+    #
+    # @param name [String] ssh configure name in yaml file
+    #
+    def get_ssh name
+      if ssh_pool[name].nil?
+        ssh = connect_remote_server name
+        ssh_pool[name] = ssh
+      else
+        ssh_pool[name]
+      end
+    end
+
+    #
+    # connect database by ssh proxy
+    #
+    # @param conf [Hash] configuration for connect remote databse via ssh
+    # 
+    def connect_database_by_proxy conf
+      port = forward_port conf['proxy']
+      connect_database conf, port
+    end
+
+    #
+    # connect databse
+    # 
+    # @param conf [Hash] configuration for connect databse directly
+    # @pram port [Integer] forward port
+    #
+    def connect_database conf, port = false
+      conf.delete('proxy') if port
+      conf = conf.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+      conf = conf.merge(:port => port) if port
+      begin
+        Sequel.connect(conf)
+      rescue
+        fail "database configuration \n #{conf} \n is not correct, please double check"
+      end
+    end
+
+    # 
+    # connect remote server
+    # 
+    # @param name [String] the ssh server name wanna to connect
+    #
+    def connect_remote_server name
+      ssh_conf = file[name]
+      host = ssh_conf.delete('host')
+      user = ssh_conf.delete('user')
+      options = ssh_conf.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+      begin
+        Net::SSH::Gateway.new(host, user, options)
+      rescue
+        fail "ssh configuration \n #{ssh_conf} \n is not correct, please double check"
+      end
+    end
+
+    #
+    # forward port
+    #
+    # @param conf [Hash] configuration for generate forward port
+    #
+    def forward_port conf
+      ssh = get_ssh conf['ssh']
+      host = conf['database']['host']
+      remote_port = conf['database']['remote_port']
+      local_port = conf['database']['local_port']
+      # puts "forward remote port #{remote_port} to local port #{local_port}"
+      begin
+        ssh.open(host, remote_port, local_port)
+      rescue Errno::EADDRINUSE
+        return local_port
+      rescue
+        fail "fail to forward remote port #{remote_port} to local_port #{local_port}"
+      end
+    end
+  end
+end

data/lib/{version.rb → lolitado/version.rb}

@@ -1,3 +1,3 @@
 module Lolitado
-  VERSION = "0.0.8"
+  VERSION = "0.1.3"
 end

data/lolitado.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "lolitado/version"
+
+Gem::Specification.new do |s|
+  s.name = "lolitado"
+  s.platform = Gem::Platform::RUBY
+  s.version = Lolitado::VERSION
+  s.date = '2018-12-14'
+  s.authors = ["Dolores Zhang"]
+  s.email = ["379808610@qq.com"]
+  s.homepage = "http://github.com/doloreszhang/lolitado"
+  s.summary = %q{Lolitado DSL for database process}
+  s.description = %q{Lolitado DSL that works with Watir}
+  s.files = `git ls-files`.split("\n")
+  s.license = 'MIT'
+  s.require_paths = ["lib"]
+  s.add_dependency "sequel", "~> 4.37"
+  s.add_dependency "net-ssh-gateway", "~> 1.2"
+  s.add_dependency "httparty", "~> 0.14"
+  s.add_dependency "rbnacl-libsodium", "~> 1.0.10"
+end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: lolitado
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.3
 platform: ruby
 authors:
 - Dolores Zhang
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
 date: 2018-12-14 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: mysql2
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.4'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -87,18 +73,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/accessors.rb
-- lib/box.rb
-- lib/db.rb
+- ".DS_Store"
+- ".gitignore"
+- README.md
+- lib/.DS_Store
 - lib/lolitado.rb
-- lib/pool.rb
-- lib/request.rb
-- lib/version.rb
+- lib/lolitado/api.rb
+- lib/lolitado/box.rb
+- lib/lolitado/db.rb
+- lib/lolitado/pool.rb
+- lib/lolitado/version.rb
+- lolitado.gemspec
 homepage: http://github.com/doloreszhang/lolitado
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -113,9 +103,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.7.6
+signing_key:
 specification_version: 4
 summary: Lolitado DSL for database process
 test_files: []

data/lib/accessors.rb

@@ -1,22 +0,0 @@
-#
-# Contains the class level methods that are inserted into your api class
-#
-module Accessors
-
-  # just for example "how to create method in accesors"
-  def row name, identifier
-    define_method("delete_#{name}") do |value|
-      db[identifier[:table].to_sym].filter(value).delete
-    end
-  end
-
-  def column name, identifier
-    define_method("avg_#{name}") do |value|
-      db[identifier[:table].to_sym].filter(value).avg(identifier.values.last.to_sym)
-    end
-    define_method("query_#{name}") do |value|
-      db[identifier[:table].to_sym].filter(value).all
-    end
-  end
-
-end

data/lib/box.rb

@@ -1,29 +0,0 @@
-require 'rbnacl'
-require 'base64'
-
-class Box
-
-  def initialize key
-    key_env = ENV[key]
-    if key_env.nil?
-      puts "There's no environment variable #{key}..."
-      return
-    end
-    key = Base64.decode64(key_env)
-    @box = RbNaCl::SimpleBox.from_secret_key(key)
-  end
-
-  def file_encrypt file
-    plaintext = File.read(file)
-    ciphertext = @box.encrypt(plaintext)
-    enc_file = file + '.enc'
-    File.write(enc_file, Base64.encode64(ciphertext))
-  end
-
-  def file_decrypt file
-    ciphertext = File.read(file)
-    plaintext = @box.decrypt(Base64.decode64(ciphertext))
-    plain_file = file[0..-5]
-    File.write(plain_file, plaintext)
-  end
-end

data/lib/db.rb

@@ -1,27 +0,0 @@
-require 'accessors'
-
-class DBFactory
-  extend Accessors
-
-  attr_accessor :db
-
-  def initialize db
-    @db = db
-  end
-
-  def query sql
-    result = db[sql].all
-    return result
-  end
-
-  def multiple_query sql
-    splited_sql = sql.split(';')
-    splited_sql.each do |each_sql|
-      query(each_sql)
-    end
-  end
-
-  def insert sql
-    db[sql]
-  end
-end

data/lib/pool.rb

@@ -1,109 +0,0 @@
-require 'mysql2'
-require 'sequel'
-require 'net/ssh/gateway'
-
-class Pool
-
-  attr_accessor :db_pool, :ssh_pool, :file_path
-
-  def initialize file_path
-    @db_pool = {}
-    @ssh_pool = {}
-    @file_path = file_path
-  end
-
-  def use(params ={})
-    ssh_name = params.fetch(:ssh, false)
-    db_name = params.fetch(:db, false)
-    if db_pool[db_name].nil? && db_name
-      ssh_key = fetch_ssh_config db_name
-      unless ssh_key.nil?
-        ssh = create_or_use_ssh ssh_key
-        port = forward_port ssh, ssh_key
-        db = connect_database db_name, port
-        db_pool[db_name] = db
-      else
-        db = connect_database_directly db_name
-        db_pool[db_name] = db
-      end
-    elsif ssh_name
-      create_or_use_ssh ssh_name
-    else
-      db_pool[db_name]
-    end
-  end
-
-  def create_or_use_ssh name
-    if ssh_pool[name].nil?
-      ssh = connect_remote_server name
-      ssh_pool[name] = ssh
-    else
-      ssh_pool[name]
-    end
-  end
-
-  def connect_database name, port=false
-    database_file = YAML.load_file(file_path)
-    db_conf = database_file[name]
-    db_conf = db_conf.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
-    db_conf = db_conf.merge(:port => port) if port
-    db = get_ready_for_database db_conf
-  end
-
-  def get_ready_for_database conf
-    begin
-      Sequel.connect(conf)
-    rescue
-      fail "database configuration \n #{conf} \n is not correct, please double check"
-    end
-  end
-
-  def connect_remote_server name
-    database_file = YAML.load_file(file_path)
-    ssh_conf = database_file[name]
-    ssh_conf = ssh_conf.delete_if { |key,value| key == 'database'}
-    ssh = get_ready_for_ssh ssh_conf
-    return ssh
-  end
-
-  def get_ready_for_ssh conf
-    host = conf.delete('host')
-    user = conf.delete('user')
-    options = conf.delete_if {|key,value| key == 'host' && 'user'}
-    options = options.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
-    begin
-      Net::SSH::Gateway.new(host, user, options)
-    rescue
-      fail "ssh configuration \n #{conf} \n is not correct, please double check"
-    end
-  end
-
-  def forward_port ssh, name
-    database_file = YAML.load_file(file_path)
-    ssh_conf = database_file[name]
-    new_conf = ssh_conf.delete('database')
-    host = new_conf.delete('host')
-    remote_port = new_conf.delete('remote_port')
-    local_port = new_conf.delete('local_port')
-    begin
-      ssh.open(host, remote_port, local_port)
-    rescue Errno::EADDRINUSE
-      return local_port
-    rescue
-      fail "fail to forward remote port #{remote_port} to local_port #{local_port}"
-    end
-  end
-
-  def fetch_ssh_config db_name
-    database_file = YAML.load_file(file_path)
-    db_conf  = database_file[db_name]
-    ssh_key = db_conf.delete('ssh')
-  end
-
-  def connect_database_directly db_name
-    database_file = YAML.load_file(file_path)
-    db_conf  = database_file[db_name]
-    db_conf = db_conf.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
-    db = Sequel.connect(db_conf)
-  end
-end

data/lib/request.rb

@@ -1,46 +0,0 @@
-require 'httparty'
-
-class Request
-  include HTTParty
-
-  attr_accessor :new_headers
-  # debug_output $stdout
-
-  def new_response response, msecs
-    new_response = {}
-    new_response.merge({:response => response, :message => response.parsed_response, :status => response.code, :duration => msecs})
-  end
-
-  def request base_uri, method, endpoint, body = false
-    url = base_uri + endpoint
-    case method
-    when "get"
-      start = Time.now
-      response = self.class.get(url, :body => body, :headers => new_headers, :verify => false)
-      finish = Time.now
-    when "post"
-      start = Time.now
-      response = self.class.post(url, :body => body, :headers => new_headers, :verify => false)
-      finish = Time.now
-    when "put"
-      start = Time.now
-      response = self.class.put(url, :body => body, :headers => new_headers, :verify => false)
-      finish = Time.now
-    when "delete"
-      start = Time.now
-      response = self.class.delete(url, :headers => new_headers, :verify => false)
-      finish = Time.now
-    else
-      puts "#{method} is invalid method."
-      exit
-    end
-    msecs = (finish - start) * 1000.0
-    return new_response(response, msecs)
-  end
-
-  def add_headers value
-    @new_headers ||= {}
-    @new_headers = @new_headers.merge(value.to_hash)
-    return @new_headers
-  end
-end