ruby-druid 0.1.9 → 0.9.0

data/lib/druid/context.rb

@@ -0,0 +1,37 @@
+module Druid
+  class Context
+    include ActiveModel::Model
+
+    attr_accessor :timeout
+    validates :timeout, allow_nil: true, numericality: true
+
+    attr_accessor :priority
+    validates :priority, allow_nil: true, numericality: true
+
+    attr_accessor :queryId
+
+    attr_accessor :useCache
+    validates :useCache, allow_nil: true, inclusion: { in: [true, false] }
+
+    attr_accessor :populateCache
+    validates :populateCache, allow_nil: true, inclusion: { in: [true, false] }
+
+    attr_accessor :bySegment
+    validates :bySegment, allow_nil: true, inclusion: { in: [true, false] }
+
+    attr_accessor :finalize
+    validates :finalize, allow_nil: true, inclusion: { in: [true, false] }
+
+    attr_accessor :chunkPeriod
+
+    def initialize(attributes = {})
+      super
+      @queryId ||= SecureRandom.uuid
+    end
+
+    def as_json(options = {})
+      super(options.merge(except: %w(errors validation_context)))
+    end
+
+  end
+end

data/lib/druid/data_source.rb

@@ -0,0 +1,95 @@
+require 'multi_json'
+require 'iso8601'
+
+module Druid
+  class DataSource
+
+    attr_reader :name, :uri, :metrics, :dimensions
+
+    def initialize(name, uri)
+      @name = name.split('/').last
+      uri = uri.sample if uri.is_a?(Array)
+      if uri.is_a?(String)
+        @uri = URI(uri)
+      else
+        @uri = uri
+      end
+    end
+
+    def metadata
+      @metadata ||= metadata!
+    end
+
+    def metadata!(opts = {})
+      meta_path = "#{@uri.path}datasources/#{name}"
+
+      if opts[:interval]
+        from, to = opts[:interval]
+        from = from.respond_to?(:iso8601) ? from.iso8601 : ISO8601::DateTime.new(from).to_s
+        to = to.respond_to?(:iso8601) ? to.iso8601 : ISO8601::DateTime.new(to).to_s
+
+        meta_path += "?interval=#{from}/#{to}"
+      end
+
+      req = Net::HTTP::Get.new(meta_path)
+      response = Net::HTTP.new(uri.host, uri.port).start do |http|
+        http.open_timeout = 10 # if druid is down fail fast
+        http.read_timeout = nil # we wait until druid is finished
+        http.request(req)
+      end
+
+      if response.code != '200'
+        raise "Request failed: #{response.code}: #{response.body}"
+      end
+
+      MultiJson.load(response.body)
+    end
+
+    def metrics
+      @metrics ||= metadata['metrics']
+    end
+
+    def dimensions
+      @dimensions ||= metadata['dimensions']
+    end
+
+    def post(query)
+      query = query.query if query.is_a?(Druid::Query::Builder)
+      query = Query.new(MultiJson.load(query)) if query.is_a?(String)
+      query.dataSource = name
+
+      req = Net::HTTP::Post.new(uri.path, { 'Content-Type' => 'application/json' })
+      req.body = query.to_json
+
+      response = Net::HTTP.new(uri.host, uri.port).start do |http|
+        http.open_timeout = 10 # if druid is down fail fast
+        http.read_timeout = nil # we wait until druid is finished
+        http.request(req)
+      end
+
+      if response.code != '200'
+        # ignore GroupBy cache issues and try again without cached results
+        if query.context.useCache != false && response.code == "500" && response.body =~ /Cannot have a null result!/
+          query.context.useCache = false
+          return self.post(query)
+        end
+
+        raise Error.new(response), "request failed"
+      end
+
+      MultiJson.load(response.body)
+    end
+
+    class Error < StandardError
+      attr_reader :response
+      def initialize(response)
+        @response = response
+      end
+
+      def message
+        MultiJson.load(response.body)["error"]
+      end
+    end
+
+  end
+end

data/lib/druid/filter.rb

@@ -1,269 +1,325 @@
 module Druid
   class Filter
-    (instance_methods + private_instance_methods).each do |method|
-      unless method.to_s =~ /^(__|instance_eval|instance_exec|initialize|object_id|raise|puts|inspect|send)/ || method.to_s =~ /\?/
-        undef_method method
+    include ActiveModel::Model
+
+    attr_accessor :type
+    validates :type, inclusion: { in: %w(selector regex and or not javascript) }
+
+    class DimensionValidator < ActiveModel::EachValidator
+      TYPES = %w(selector regex javascript)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'may not be blank') if value.blank?
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
       end
     end
 
-    def method_missing(method_id, *args)
-      FilterDimension.new(method_id)
+    attr_accessor :dimension
+    validates :dimension, dimension: true
+
+    class ValueValidator < ActiveModel::EachValidator
+      TYPES = %w(selector)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'may not be blank') if value.blank?
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
     end
-  end
 
-  class FilterParameter
-    (instance_methods + private_instance_methods).each do |method|
-      unless method.to_s =~ /^(__|instance_eval|instance_exec|initialize|object_id|raise|puts|inspect|class|send)/ || method.to_s =~ /\?/
-        undef_method method
+    attr_accessor :value
+    validates :value, value: true
+
+    class PatternValidator < ActiveModel::EachValidator
+      TYPES = %w(regex)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'may not be blank') if value.blank?
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :pattern
+    validates :pattern, pattern: true
+
+    class FieldsValidator < ActiveModel::EachValidator
+      TYPES = %w(and or)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          value.each(&:valid?) # trigger validation
+          value.each do |fvalue|
+            fvalue.errors.messages.each do |k, v|
+              record.errors.add(attribute, { k => v })
+            end
+          end
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") unless value.blank?
+        end
+      end
+    end
+
+    attr_accessor :fields
+    validates :fields, fields: true
+
+    def fields
+      @fields ||= []
+    end
+
+    def fields=(value)
+      if value.is_a?(Array)
+        @fields = value.map do |x|
+          x.is_a?(Filter) ? x : Filter.new(x)
+        end
+      else
+        @fields = [value]
+      end
+    end
+
+    class FieldValidator < ActiveModel::EachValidator
+      TYPES = %w(not)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          if value
+            value.valid? # trigger validation
+            value.errors.messages.each do |k, v|
+              record.errors.add(attribute, { k => v })
+            end
+          else
+            record.errors.add(attribute, "may not be blank")
+          end
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :field
+    validates :field, field: true
+
+    def field=(value)
+      if value.is_a?(Hash)
+        @field = Filter.new(value)
+      else
+        @field = value
       end
     end
 
-    def to_s
-      to_hash.to_s
+    class FunctionValidator < ActiveModel::EachValidator
+      TYPES = %w(javascript)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'may not be blank') if value.blank?
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
     end
 
-    def as_json(*a)
-      to_hash
+    attr_accessor :function
+    validates :function, function: true
+
+    def as_json(options = {})
+      super(options.merge(except: %w(errors validation_context)))
     end
 
-    def to_json(*a)
-      to_hash.to_json(*a)
+    def method_missing(name, *args)
+      DimensionFilter.new(dimension: name)
     end
   end
 
-  class FilterDimension < FilterParameter
-    def initialize(name)
-      @name = name
-      @value = nil
-      @regexp = nil
+  module BooleanOperators
+    def &(other)
+      BooleanFilter.new({
+        type: 'and',
+        fields: [self, other],
+      })
+    end
+
+    def |(other)
+      BooleanFilter.new({
+        type: 'or',
+        fields: [self, other],
+      })
     end
 
+    def !()
+      BooleanFilter.new({
+        type: 'not',
+        field: self,
+      })
+    end
+  end
+
+  class DimensionFilter < Filter
+    include BooleanOperators
+
     def in_rec(bounds)
-      RecFilter.new(@name, bounds)
-    end 
+      RecFilter.new(@dimension, bounds)
+    end
 
     def in_circ(bounds)
-      CircFilter.new(@name, bounds)
-    end 
+      CircFilter.new(@dimension, bounds)
+    end
 
     def eq(value)
-      return self.in(value) if value.is_a? Array
-      return self.regexp(value) if value.is_a? Regexp
-      @value = value
+      case value
+      when ::Array
+        self.in(value)
+      when ::Regexp
+        self.regexp(value)
+      else
+        @type = 'selector'
+        @value = value
+      end
       self
     end
 
     alias :'==' :eq
 
     def neq(value)
-      return !self.in(value)
+      return !self.eq(value)
     end
 
     alias :'!=' :neq
 
     def in(*args)
-      values = args.flatten
-      filter_multiple(values, 'or', :eq)
+      filter_multiple(args.flatten, 'or', :eq)
     end
 
     def nin(*args)
-      values = args.flatten
-      filter_multiple(values, 'and', :neq)
+      filter_multiple(args.flatten, 'and', :neq)
     end
 
-    def &(other)
-      filter_and = FilterOperator.new('and', true)
-      filter_and.add(self)
-      filter_and.add(other)
-      filter_and
+    def filter_multiple(values, operator, method)
+      ::Kernel.raise 'Values cannot be empty' if values.empty?
+      return self.__send__(method, values[0]) if values.length == 1
+      BooleanFilter.new({
+        type: operator,
+        fields: values.map do |value|
+          DimensionFilter.new(dimension: @dimension).__send__(method, value)
+        end
+      })
     end
 
-    def |(other)
-      filter_or = FilterOperator.new('or', true)
-      filter_or.add(self)
-      filter_or.add(other)
-      filter_or
-    end
+    alias_method :not_in, :nin
 
-    def !()
-      filter_not = FilterOperator.new('not', false)
-      filter_not.add(self)
-      filter_not
+    def regexp(r)
+      r = ::Regexp.new(r) unless r.is_a?(::Regexp)
+      @pattern = r.inspect[1...-1] #to_s doesn't work
+      @type = 'regex'
+      self
     end
 
     def >(value)
-      filter_js = FilterJavascript.new_comparison(@name, '>', value)
-      filter_js
+      JavascriptFilter.new_comparison(@dimension, '>', value)
     end
 
     def <(value)
-      filter_js = FilterJavascript.new_comparison(@name, '<', value)
-      filter_js
+      JavascriptFilter.new_comparison(@dimension, '<', value)
     end
 
     def >=(value)
-      filter_js = FilterJavascript.new_comparison(@name, '>=', value)
-      filter_js
+      JavascriptFilter.new_comparison(@dimension, '>=', value)
     end
 
     def <=(value)
-      filter_js = FilterJavascript.new_comparison(@name, '<=', value)
-      filter_js
+      JavascriptFilter.new_comparison(@dimension, '<=', value)
     end
 
     def javascript(js)
-      filter_js = FilterJavascript.new(@name, js)
-      filter_js
-    end
-
-    def regexp(r)
-      r = Regexp.new(r) unless r.is_a? Regexp
-      @regexp = r.inspect[1...-1] #to_s doesn't work
-      self
-    end
-
-    def to_hash
-      raise 'no value assigned' unless @value.nil? ^ @regexp.nil?
-      hash = {
-        :dimension => @name
-      }
-      if @value
-        hash['type'] = 'selector'
-        hash['value'] = @value
-      elsif @regexp
-        hash['type'] = 'regex'
-        hash['pattern'] = @regexp
-      end
-      hash
-    end
-
-    private
-
-    def filter_multiple(values, operator, method)
-      raise 'Values cannot be empty' if values.empty?
-      return self.send(method, values[0]) if values.length == 1
-
-      filter = FilterOperator.new(operator, true)
-      values.each do |value|
-        raise 'Value cannot be a parameter' if value.is_a?(FilterParameter)
-        filter.add(FilterDimension.new(@name).send(method, value))
-      end
-      filter
+      JavascriptFilter.new(@dimension, js)
     end
   end
 
-  class FilterOperator < FilterParameter
-    def initialize(name, takes_many)
-      @name = name
-      @takes_many = takes_many
-      @elements = []
-    end
-
-    def add(element)
-      @elements.push element
-    end
-
+  class BooleanFilter < Filter
     def &(other)
-      if @name == 'and'
-        filter_and = self
+      if @type.to_s == 'and'
+        self.fields << other
+        self
       else
-        filter_and = FilterOperator.new('and', true)
-        filter_and.add(self)
+        BooleanFilter.new({
+          type: 'and',
+          fields: [self, other],
+        })
       end
-      filter_and.add(other)
-      filter_and
     end
 
     def |(other)
-      if @name == 'or'
-        filter_or = self
+      if @type.to_s == 'or'
+        self.fields << other
+        self
       else
-        filter_or = FilterOperator.new('or', true)
-        filter_or.add(self)
+        BooleanFilter.new({
+          type: 'or',
+          fields: [self, other],
+        })
       end
-      filter_or.add(other)
-      filter_or
     end
 
     def !()
-      if @name == 'not'
-        @elements[0]
-      else
-        filter_not = FilterOperator.new('not', false)
-        filter_not.add(self)
-        filter_not
-      end
-    end
-
-    def to_hash
-      result = {
-        :type => @name
-      }
-      if @takes_many
-        result[:fields] = @elements.map(&:to_hash)
+      if @type.to_s == 'not'
+        self.field
+        self
       else
-        result[:field] = @elements[0].to_hash
+        BooleanFilter.new({
+          type: 'not',
+          field: self,
+        })
       end
-      result
     end
   end
-  
-  class RecFilter < FilterDimension
+
+  class RecFilter < Filter
+    include BooleanOperators
 
     def initialize(dimension, bounds)
+      super()
+      @type = 'spatial'
       @dimension = dimension
-      @bounds = bounds
-    end 
-
-    def to_hash
-      {
-      :type => "spatial",
-      :dimension => @dimension,
-      :bound =>{
-        :type => "rectangular",
-        :minCoords => @bounds.first,
-        :maxCoords => @bounds.last
-        }
+      @bound = {
+        type: 'rectangular',
+        minCoords: bounds.first,
+        maxCoords: bounds.last,
       }
     end
   end
 
-  class CircFilter < FilterDimension
+  class CircFilter < Filter
+    include BooleanOperators
 
     def initialize(dimension, bounds)
+      super()
+      @type = 'spatial'
       @dimension = dimension
-      @bounds = bounds
-    end 
-
-    def to_hash
-      {
-      :type => "spatial",
-      :dimension => @dimension,
-      :bound =>{
-        :type => "radius",
-        :coords => @bounds.first,
-        :radius => @bounds.last
-        }
+      @bound = {
+        type: 'radius',
+        coords: bounds.first,
+        radius: bounds.last,
       }
     end
   end
 
-  class FilterJavascript < FilterDimension
-    def initialize(dimension, expression)
+  class JavascriptFilter < Filter
+    include BooleanOperators
+
+    def initialize(dimension, function)
+      super()
+      @type = 'javascript'
       @dimension = dimension
-      @expression = expression
+      @function = function
     end
 
-    def self.new_comparison(dimension, operator, value)
-      self.new(dimension, "#{dimension} #{operator} #{value.is_a?(String) ? "'#{value}'" : value}")
+    def self.new_expression(dimension, expression)
+      self.new(dimension, "function(#{dimension}) { return(#{expression}); }")
     end
 
-    def to_hash
-      {
-        :type => 'javascript',
-        :dimension => @dimension,
-        :function => "function(#{@dimension}) { return(#{@expression}); }"
-      }
+    def self.new_comparison(dimension, operator, value)
+      self.new_expression(dimension, "#{dimension} #{operator} #{value.to_json}")
     end
   end
-end
+end