hover-ruby-client 0.3.1

data/lib/hover/client/http.rb

@@ -0,0 +1,141 @@
+require 'api-auth'
+require 'uri'
+require 'net/http'
+require 'json'
+
+module Hover
+  module Client
+    class HTTP
+      attr_accessor :prefix, :site
+
+      def initialize(site = 'http://localhost:3000', prefix = 'api/v1')
+        @prefix = prefix
+        @site = site
+      end
+
+      def authenticate(request)
+      end
+
+      def make_uri(path, parameters = {})
+        parts = [site, prefix, path]
+        uri = URI.parse(parts.map(&:presence).compact.join('/'))
+        uri = URI.parse("#{uri.to_s}?#{URI.encode_www_form(parameters)}") unless parameters.empty?
+
+        uri
+      end
+
+      def make_request(request, uri)
+        authenticate(request)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if 'https' == uri.scheme
+
+        response = http.request(request)
+
+        raise_errors_for_cloudfront_response(response)
+
+        response
+      end
+
+      def get(path, parameters = {})
+        uri = make_uri(path, parameters)
+        request = Net::HTTP::Get.new(uri)
+        response = make_request(request, uri)
+
+        response
+      end
+
+      def get_redirect_location(path, parameters = {}, &block)
+        uri = make_uri(path, parameters)
+        request = Net::HTTP::Get.new(uri)
+        redirect_response = make_request(request, uri)
+
+        if redirect_response.is_a?(Net::HTTPRedirection) && redirect_response['location']
+          redirect_response['location']
+        else
+          nil
+        end
+      end
+
+      def post(path, parameters = {})
+        uri = make_uri(path)
+        request = Net::HTTP::Post.new(uri)
+        make_form_request(request, uri, parameters)
+      end
+
+      def make_form_request(request, uri, parameters)
+        request.set_form_data(parameters)
+        response = make_request(request, uri)
+        response
+      end
+
+      def put(path, parameters = {})
+        uri = make_uri(path)
+        request = Net::HTTP::Put.new(uri)
+        make_form_request(request, uri, parameters)
+      end
+
+      def patch(path, parameters = {})
+        uri = make_uri(path)
+        request = Net::HTTP::Patch.new(uri)
+        make_form_request(request, uri, parameters)
+      end
+
+      def delete(path, parameters = {})
+        uri = make_uri(path)
+        request = Net::HTTP::Delete.new(uri)
+        make_form_request(request, uri, parameters)
+      end
+
+      def parse_response(response)
+        raise_errors(response)
+
+        case response.code.to_i
+          when 204 # no content
+            {}
+          else
+            ::JSON.parse(response.body)
+        end
+      end
+
+      def raise_errors_for_cloudfront_response(response)
+        #
+        # If the server can't be reached cloudfront will respond with an
+        # error message of it's own. We need to catch those so that we can retry
+        # the requests.
+        #
+
+        return unless (response.header['Server'] =~ /Cloudfront/i)
+
+        raise ::Hover::Client::Unavailable
+      end
+
+      def raise_errors(response)
+        message = "(#{response.code}): - #{response.body}"
+
+        case response.code.to_i
+          when 400
+            raise BadRequest, message
+          when 401
+            raise Unauthorized, message
+          when 403
+            raise General, message
+          when 404
+            raise NotFound, message
+          when 500
+            raise InternalError, "Internal error: #{message}"
+          when 502..503
+            raise Unavailable, message
+        end
+      end
+    end
+
+    class BadRequest        < StandardError; end
+    class Unauthorized      < StandardError; end
+    class General           < StandardError; end
+    class Unavailable       < StandardError; end
+    class InternalError     < StandardError; end
+    class NotFound          < StandardError; end
+    class AloomaReportingError < StandardError; end
+  end
+end

data/lib/hover/client/manowar.rb

@@ -0,0 +1,17 @@
+require 'hover/client/hover'
+
+module Hover
+  module Client
+    class Manowar < ::Hover::Client::Hover
+      
+      def submit_order(parameters = {})
+        json_post('orders.json', parameters)
+      end
+      
+      def order_results(order_id)
+        json_get("orders/#{order_id}/results.json")
+      end
+      
+    end
+  end
+end

data/lib/hover/client/midas.rb

@@ -0,0 +1,120 @@
+require 'open-uri'
+require 'tempfile'
+require 'zip'
+
+require 'hover/client/hover'
+
+module Hover
+  module Client
+    class Midas < ::Hover::Client::Hover
+      
+      #
+      # Users
+      #
+    
+      def me
+        json_get('me.json')
+      end
+    
+      #
+      # Orders
+      #
+    
+      def orders(parameters = {})
+        json_get('orders.json', parameters)
+      end
+    
+      def order(id, parameters = {})
+        json_get("orders/#{id}.json", parameters)
+      end
+      
+      def order_complete_work(order_id)
+        put("orders/#{order_id}/work_complete.json")
+      end
+    
+      #def update_order(id, order_attributes)
+      #  put("orders/#{id}.json", order_parameters(order_attributes))
+      #end
+    
+      def create_order(params = {})
+        json_post('orders.json', params)
+      end
+    
+      def complete_order_upload(order_id)
+        patch("orders/#{order_id}/archive_uploading_complete.json")
+      end
+    
+      #
+      # Images
+      #
+    
+      def images(parameters = {})
+        json_get("images.json", parameters)
+      end
+    
+      def image(id)
+        json_get("images/#{id}.json")
+      end
+    
+      def download_image(image, parameters = {}, &block)
+        return unless url = get_redirect_location("images/#{image["id"]}.jpg", parameters)
+      
+        Tempfile.open(["image-download", ".jpg"]) do |output|
+          output.write(Kernel.open(url).read)
+          output.rewind
+        
+          yield output
+        end
+      end
+    
+      def upload_image(image, io)
+        raise "Already Uploaded" unless upload_url = image["image"].try(:[], "upload_url")
+      
+        file = (io.is_a?(String) ? File.open(io) : io)
+      
+        uri = URI.parse(upload_url)
+      
+        request = Net::HTTP::Put.new(uri.request_uri)
+        request.body_stream = file
+        request.content_length = file.size
+        request['Content-Type'] = ''
+      
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        response = http.request(request)
+      end
+    
+      def image_upload_urls(order_id)
+        json_get("images/upload_urls.json", order_id: order_id)
+      end
+    
+      def upload_images_for_order(order_id, input_path)
+        image_array = image_upload_urls(order_id).map { |upload_url| {"image" => {"upload_url" => upload_url}} }
+        file_paths = Dir.glob(File.join(input_path, "*.jp*"))
+      
+        if file_paths.size > image_array.size
+          raise("Trying to upload #{file_paths.size} files. #{image_array.size} is the maximum.")
+        end
+      
+        file_paths.each do |file_path|
+          image = image_array.pop
+          upload_image(image, file_path)
+        end
+      end
+    
+      def upload_images_from_prometheus_export(order_id, export_zip_path)
+        Zip::File.open(export_zip_path) do |zip|
+          Dir.mktmpdir do |directory_path|
+            zip.entries.select { |entry| entry.name =~ /original_image\.jp(g|eg)$/ }.each do |entry|
+              basename = File.basename(entry.name)
+              next if basename =~ /^\./
+              entry.extract(File.join(directory_path, basename)) { true }
+            end
+          
+            upload_images_for_order(order_id, directory_path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hover/client/static.rb

@@ -0,0 +1,89 @@
+require 'hover/client/hover'
+
+module Hover
+  module Client
+    class Static < ::Hover::Client::Hover
+
+      attr_accessor :application, :environment
+
+      def initialize(application, environment, client_id, client_secret, site = 'http://localhost:3000', prefix = 'api/v1')
+        super(client_id, client_secret, site, prefix)
+
+        self.application = application
+        self.environment = environment
+      end
+
+      def create_metric(name:, value:, happened_at: Time.now.utc, tags: {}, remote_record_id: nil)
+        return unless alooma_url
+
+        parameters = {
+          "metric[name]" => name,
+          'metric[value]' => value,
+          'metric[happened_at]' => happened_at.to_s,
+          'metric[environment]' => environment,
+          'metric[application]' => application
+        }.merge(self.class.tags_to_params(tags))
+        parameters['metric[remote_record_id]'] = remote_record_id if remote_record_id
+        add_unique_identifier(parameters)
+
+        post_to_alooma(parameters, alooma_url)
+      end
+
+      def alooma_url
+        @alooma_url ||= if Rails.env.staging?
+                          "https://inputs.alooma.com/rest/eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJjbGllbnROYW1lIjoiaG92ZXItc2YtMSIsImlucHV0TGFiZWwiOiJzdGF0aWNfc3RhZ2luZyIsImlucHV0VHlwZSI6IlJFU1RBUEkifQ.Iba3VM9GaOjzJEmUFPuHDA6oaQT7TBe9A0iMxfYW0x0"
+                        elsif Rails.env.production?
+                          "https://inputs.alooma.com/rest/eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJjbGllbnROYW1lIjoiaG92ZXItc2YtMSIsImlucHV0TGFiZWwiOiJzdGF0aWNfcHJvZHVjdGlvbiIsImlucHV0VHlwZSI6IlJFU1RBUEkifQ.jiuWVLDPDvZSv4bmiy54GVEpOre19bDqr9ZC7Y-HKwo"
+                        end
+      end
+
+      def post_to_alooma(parameters, url)
+        uri = URI.parse(url)
+        request = Net::HTTP::Post.new(uri)
+        request.set_form_data(parameters)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if 'https' == uri.scheme
+        response = http.request(request)
+
+        unless (200 .. 299).include?(response.code.to_i)
+          raise AloomaReportingError.new("Error reporting to alooma. #{response.inspect}")
+        end
+
+        response
+      end
+
+      def add_unique_identifier(parameters)
+        sorted_array = parameters.to_a.sort_by(&:first)
+        metric_identifier = Digest::SHA256.hexdigest(sorted_array.to_json)
+
+        parameters['metric[identifier]'] = metric_identifier
+      end
+
+      #
+      # Class Methods
+      #
+
+      def self.tags_to_params(tags, parent_keys = ['metric', 'tags'])
+        params = {}
+
+        tags.each do |key, value|
+          if value.is_a?(Hash)
+            params.merge!(tags_to_params(value, (parent_keys + [key])))
+          elsif value.is_a?(Array)
+            params["#{param_name(*parent_keys, key)}[]"] = value
+          else
+            params[param_name(*parent_keys, key)] = value
+          end
+        end
+
+        params
+      end
+
+      def self.param_name(*args)
+        first = args.shift
+        "#{first}" + args.map{ |arg| "[#{arg}]" }.join
+      end
+
+    end
+  end
+end

data/lib/hover/decoder/json_stream.rb

@@ -0,0 +1,25 @@
+require 'yajl'
+
+module Hover
+  module Decoder
+    class JSONStream
+
+      def initialize(s3_object, block = ->(object) {})
+        @parser = Yajl::Parser.new
+        @s3_object = s3_object
+
+        @parser.on_parse_complete = block
+      end
+
+      def start
+        bucket_name = @s3_object.bucket.name
+        key = @s3_object.key
+
+        @s3_object.client.get_object(bucket: bucket_name, key: key) do |chunk|
+          @parser << chunk
+        end
+      end
+
+    end
+  end
+end

data/lib/hover/encoder/json_stream.rb

@@ -0,0 +1,35 @@
+module Hover
+  module Encoder
+    class JSONStream
+      attr_accessor :file
+
+      def initialize
+      end
+
+      def open(path)
+        self.file = File.open(path, 'w')
+      end
+
+      def close
+        self.file.close
+        self.file = nil
+      end
+
+      def append(attributes, klass)
+        self.file.puts(JSON.dump(attributes.merge('class' => klass.name)))
+      end
+
+      def append_each(attributes_sets, klass)
+        attributes_sets.each do |attributes|
+          append(attributes, klass)
+        end
+      end
+
+      def append_records(scope)
+        scope.find_each do |record|
+          append(record.attributes.as_json, record.class)
+        end
+      end
+    end
+  end
+end

data/lib/hover/importer/active_record.rb

@@ -0,0 +1,134 @@
+module Hover
+  module Importer
+    class ActiveRecord
+      attr_accessor :remote_local_map, :update_finder, :column_changes
+
+      def initialize(remote_local_map, update_finder = nil, column_changes = {})
+        self.remote_local_map = Hash.new { |hash, key| hash[key] = {} }
+        self.remote_local_map.merge!(remote_local_map)
+        self.update_finder = update_finder
+        self.column_changes = column_changes
+      end
+
+      def change_columns(attributes)
+        attributes.inject({}) do |hash, key_value|
+          hash[(column_changes[key_value[0]] || key_value[0])] = key_value[1]
+          hash
+        end
+      end
+
+      def update(table_name, records_attributes)
+        klass = table_name.singularize.camelize.constantize
+        records_attributes.collect { |attributes| update_record(klass, attributes) }
+      end
+
+      def update_record(klass, attributes)
+        return unless record = find_record_to_update(klass, attributes)
+
+        attributes = change_columns(attributes.dup)
+        s3_file_attributes = s3_file_keys(klass, attributes)
+
+        attributes.delete(klass.primary_key)
+        attributes.reject! { |key, value| !klass.column_names.include?(key) }
+        attributes.merge!(s3_file_attributes) if s3_file_attributes.is_a?(Hash)
+
+        record.assign_attributes(attributes)
+        record.save!(validate: false)
+
+        [klass, record.id]
+      end
+
+      def s3_file_keys(klass, attributes)
+        klass.try(:s3_file_versions).try(:keys).try(:inject, {}) do |output, attribute|
+          if value = attributes.delete(attribute.to_s)
+            output["#{attribute}_s3_keys"] = value
+          end
+
+          output
+        end
+      end
+
+      def find_record_to_update(klass, attributes)
+        self.update_finder.call(self, klass, attributes)
+      end
+
+      def import_results(results)
+        class_id_sets = []
+
+        results.each do |table_name, records_attributes|
+          if table_class_id_sets = import_table(table_name, records_attributes)
+            class_id_sets.concat(table_class_id_sets)
+          end
+        end
+
+        class_id_sets
+      end
+
+      def import_table(table_name, records_attributes)
+        klass = table_name.singularize.camelize.constantize
+
+        records_attributes.collect { |attributes|
+          import_record(klass, attributes) unless attributes.nil?
+        }
+      end
+
+      def import_record(klass, attributes)
+        attributes = change_columns(attributes.dup)
+        external_primary_key = attributes.delete(klass.primary_key)
+        s3_file_attributes = s3_file_keys(klass, attributes)
+
+        attributes.reject! { |key, value| !klass.column_names.include?(key) }
+        attributes.merge!(s3_file_attributes) if s3_file_attributes.is_a?(Hash)
+
+        record = klass.new(attributes)
+        return unless last_insert_id = insert_record(record)
+
+        remote_local_map[klass.table_name][external_primary_key] = last_insert_id
+
+        [klass, last_insert_id]
+      end
+
+      # see https://github.com/rails/rails/blob/v5.2.0/activerecord/lib/active_record/persistence.rb#L729-L741
+      def insert_record(record)
+        attribute_names = record.class.column_names
+        attributes_values = record.send(:attributes_with_values_for_create, attribute_names)
+
+        primary_key = record.class._insert_record(attributes_values)
+
+        record[record.class.primary_key] = primary_key
+      end
+
+      def new_foreign_keys(record)
+        record.class.reflect_on_all_associations.inject({}) do |hash, association|
+          method = "new_foreign_keys_for_#{association.macro}"
+          method += "_polymorphic" if association.options[:polymorphic]
+
+          if respond_to?(method) && before_after = send(method, record, association)
+            hash.store(*before_after)
+          end
+
+          hash
+        end
+      end
+
+      def new_foreign_keys_for_belongs_to(record, association)
+        return unless id = self.remote_local_map[association.klass.table_name].try(:[], record[association.foreign_key])
+        [association.foreign_key, id]
+      end
+
+      def new_foreign_keys_for_belongs_to_polymorphic(record, association)
+        return unless id = self.remote_local_map[record[association.foreign_type].tableize].try(:[], record[association.foreign_key])
+        [association.foreign_key, id]
+      end
+
+      def update_foreign_keys(record)
+        foreign_key_attributes = new_foreign_keys(record)
+        return if foreign_key_attributes.empty?
+
+        record.class.unscoped.where(id: record.id).update_all(foreign_key_attributes)
+
+        [record.reload.class, record.id]
+      end
+    end
+  end
+end