influxdb-api 0.0.1

data/lib/influxdb/api/client/connection.rb

@@ -0,0 +1,55 @@
+module Influxdb
+  module Api
+    class Client
+      class Connection
+        attr_reader :host, :connection, :failures, :dead_since, :config
+
+        def initialize(host, connection, config = Influxdb::Api.config)
+          @config = config
+          @host = host
+          @connection = connection
+          @failures = 0
+        end
+
+        def full_path(path, params={})
+          path + (params.empty? ? '' : "?#{::Faraday::Utils::ParamsHash[params].to_query}")
+        end
+
+        def dead?
+          !!@dead
+        end
+
+        def dead!
+          @dead = true
+          @failures += 1
+          @dead_since = Time.now
+          self
+        end
+
+        def alive!
+          @dead = false
+          self
+        end
+
+        def healthy!
+          @dead = false
+          @failures = 0
+          self
+        end
+
+        def resurrect!
+          alive! if resurrectable?
+          self
+        end
+
+        def resurrectable?
+          Time.now > dead_since + (config.resurrect_timeout * 2 ** (failures - 1))
+        end
+
+        def to_s
+          "<#{self.class.name} host: #{host} (#{dead? ? 'dead since ' + dead_since.to_s : 'alive'})>"
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/api/client/connection_pool.rb

@@ -0,0 +1,52 @@
+module Influxdb
+  module Api
+    class Client
+      class ConnectionPool
+        attr_reader :config
+
+        def initialize(config = Influxdb::Api.config)
+          @config = config
+          @connections = build_connections
+        end
+
+        def connections
+          @connections.reject{|c| c.dead? }
+        end
+        alias :alive :connections
+
+        def dead
+          @connections.select{|c| c.dead? }
+        end
+
+        def all
+          @connections
+        end
+
+        def each(&block)
+          connections.each(&block)
+        end
+
+        def get_connection
+          if connections.empty? && dead_connection = dead.sort{|a, b| a.failures <=> b.failures }.first
+            dead_connection.alive!
+          end
+          config.selector.select_from(alive)
+        end
+
+        def build_connections
+          config.hosts.map do |host|
+            Connection.new(
+              host,
+              ::Faraday::Connection.new(
+                host,
+                config.connection_options,
+                &config.connection_block
+              ),
+              config
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/api/client/errors.rb

@@ -0,0 +1,62 @@
+module Influxdb
+  module Api
+    class Client
+      class Error < StandardError; end
+      class ServerError < StandardError; end
+
+      module Errors; end
+
+      HTTP_STATUSES = {
+        300 => 'MultipleChoices',
+        301 => 'MovedPermanently',
+        302 => 'Found',
+        303 => 'SeeOther',
+        304 => 'NotModified',
+        305 => 'UseProxy',
+        307 => 'TemporaryRedirect',
+        308 => 'PermanentRedirect',
+
+        400 => 'BadRequest',
+        401 => 'Unauthorized',
+        402 => 'PaymentRequired',
+        403 => 'Forbidden',
+        404 => 'NotFound',
+        405 => 'MethodNotAllowed',
+        406 => 'NotAcceptable',
+        407 => 'ProxyAuthenticationRequired',
+        408 => 'RequestTimeout',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'LengthRequired',
+        412 => 'PreconditionFailed',
+        413 => 'RequestEntityTooLarge',
+        414 => 'RequestURITooLong',
+        415 => 'UnsupportedMediaType',
+        416 => 'RequestedRangeNotSatisfiable',
+        417 => 'ExpectationFailed',
+        418 => 'ImATeapot',
+        421 => 'TooManyConnectionsFromThisIP',
+        426 => 'UpgradeRequired',
+        450 => 'BlockedByWindowsParentalControls',
+        494 => 'RequestHeaderTooLarge',
+        497 => 'HTTPToHTTPS',
+        499 => 'ClientClosedRequest',
+
+        500 => 'InternalServerError',
+        501 => 'NotImplemented',
+        502 => 'BadGateway',
+        503 => 'ServiceUnavailable',
+        504 => 'GatewayTimeout',
+        505 => 'HTTPVersionNotSupported',
+        506 => 'VariantAlsoNegotiates',
+        510 => 'NotExtended'
+      }
+
+      ERRORS = HTTP_STATUSES.inject({}) do |sum, error|
+        status, name = error
+        sum[status] = Errors.const_set(name, Class.new(ServerError))
+        sum
+      end
+    end
+  end
+end

data/lib/influxdb/api/client/response.rb

@@ -0,0 +1,14 @@
+module Influxdb
+  module Api
+    class Client
+      class Response
+        attr_reader :status, :body, :headers
+
+        def initialize(status, body, headers = {})
+          @status, @body, @headers = status, body, headers
+          @body = body.force_encoding('UTF-8') if body.respond_to?(:force_encoding)
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/api/client/selector.rb

@@ -0,0 +1,27 @@
+module Influxdb
+  module Api
+    class Client
+      module Selector
+        class Base
+          def select_from
+            raise NoMethodError, "Implement this method in the selector implementation."
+          end
+        end
+
+        class Random < Base
+          def select_from(connections)
+            connections.to_a.sample
+          end
+        end
+
+        class RoundRobin < Base
+          def select_from(connections)
+            @current = @current.nil? ? 0 : @current + 1
+            @current = 0 if @current >= connections.size
+            connections[@current]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/api/configuration.rb

@@ -0,0 +1,116 @@
+module Influxdb
+  module Api
+    class Configuration
+      attr_accessor :resurrect_timeout, :retry_on_failure, :connection_options,
+        :serializer, :log, :selector, :user, :password
+
+      attr_writer :logger
+      attr_reader :hosts
+
+      class Host
+        DEFAULT = ['http://localhost:8086'].freeze
+        DEFAULT_PORT = 8086
+        DEFAULT_PROTOCOL = 'http'.freeze
+
+        def initialize(source)
+          @source = to_hash(source)
+        end
+
+        def build
+          result = "#{protocol}://"
+          result << "#{user}:#{password}@" if user
+          result << "#{host}:#{port}"
+          result << path if path
+          result
+        end
+
+        private
+
+        attr_reader :source
+
+        def to_hash(source)
+          case source
+          when String
+            source =~ /^[a-z]+\:\/\// ? to_hash(URI.parse(source)) : Hash[[:host, :port].zip(source.split(?:))]
+          when URI
+            {
+              scheme: source.scheme,
+              user: source.user,
+              password: source.password,
+              host: source.host,
+              path: source.path,
+              port: source.port.to_s
+            }
+          when Hash
+            source
+          else
+            raise ArgumentError, "Please pass host as a String, URI or Hash -- #{source.class} given."
+          end
+        end
+
+        def protocol
+          source[:scheme] || DEFAULT_PROTOCOL
+        end
+
+        def port
+          source[:port] || DEFAULT_PORT
+        end
+
+        [:host, :user, :password, :path].each do |method|
+          define_method(method) do
+            source[method]
+          end
+        end
+      end
+
+      DEFAULT_LOGGER = ->{
+        require 'logger'
+        logger = Logger.new(STDERR)
+        logger.progname = 'influxdb'
+        logger.formatter = ->(severity, datetime, progname, msg){ "#{datetime}: #{msg}\n" }
+        logger
+      }
+
+      def initialize
+        @log = false
+        @user = 'root'
+        @password = 'root'
+        @serializer = MultiJson
+        @connection_options = {}
+        @connection_block = nil
+        @retry_on_failure = false
+        @resurrect_timeout = 60
+        @hosts = Host::DEFAULT
+        @selector = Client::Selector::RoundRobin.new
+      end
+
+      def logger
+        @logger ||= log ? DEFAULT_LOGGER.call : nil
+      end
+
+      def hosts=(value)
+        @hosts = Array.wrap(value).map(&method(:normalize_host))
+      end
+
+      def connection_block(&block)
+        if block_given?
+          @connection_block = block
+        else
+          @connection_block
+        end
+      end
+
+      def dup
+        clone = super
+        clone.connection_options = connection_options.dup
+        clone
+      end
+
+      private
+
+      def normalize_host(host)
+        Host.new(host).build
+      end
+    end
+  end
+end

data/lib/influxdb/api/database.rb

@@ -0,0 +1,29 @@
+module Influxdb
+  module Api
+    class Database
+      attr_reader :client, :name
+
+      def initialize(client, name)
+        @client = client
+        @name = name
+      end
+
+      def series
+        @series ||= Namespaces::Series.new(client, name)
+      end
+
+      def users
+        @users ||= Namespaces::Users.new(client, name)
+      end
+
+      def continuous_queries
+        @continuous_queries ||= Namespaces::ContinuousQueries.new(client, name)
+      end
+
+      def shard_spaces
+        @shard_spaces ||= Namespaces::ShardSpaces.new(client, name)
+      end
+    end
+  end
+end
+

data/lib/influxdb/api/extensions.rb

@@ -0,0 +1,15 @@
+class Array
+  class << self
+    unless method_defined?(:wrap)
+      def wrap(object)
+        if object.nil?
+          []
+        elsif object.respond_to?(:to_ary)
+          object.to_ary || [object]
+        else
+          [object]
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/api/namespaces.rb

@@ -0,0 +1,50 @@
+require_relative 'namespaces/base'
+require_relative 'namespaces/with_database'
+require_relative 'namespaces/databases'
+require_relative 'namespaces/series'
+require_relative 'namespaces/users'
+require_relative 'namespaces/continuous_queries'
+require_relative 'namespaces/shard_spaces'
+require_relative 'namespaces/cluster_admins'
+require_relative 'namespaces/servers'
+require_relative 'namespaces/shards'
+
+module Influxdb
+  module Api
+    module Namespaces
+      def databases(name = nil)
+        if name
+          Database.new(self, name)
+        else
+          @databases ||= Databases.new(self)
+        end
+      end
+      alias_method :dbs, :databases
+
+      def cluster_admins
+        @cluster_admins ||= ClusterAdmins.new(self)
+      end
+
+      def servers
+        @servers ||= Servers.new(self)
+      end
+
+      def shards
+        @shards ||= Shards.new(self)
+      end
+
+      def version
+        ServerVersion.new(perform_request('get', '/ping').headers['x-influxdb-version'])
+      end
+
+      def sync?
+        config.serializer.load(perform_request('get', '/sync').body)
+      end
+      alias_method :cluster_synchronized?, :sync?
+
+      def interfaces
+        perform_request('get', '/interfaces').body
+      end
+    end
+  end
+end

data/lib/influxdb/api/namespaces/base.rb

@@ -0,0 +1,61 @@
+module Influxdb
+  module Api
+    module Namespaces
+      class Base
+        attr_reader :client
+
+        class << self
+          attr_accessor :_resource_path
+
+          protected
+
+          def resource_path(value)
+            self._resource_path = value
+          end
+        end
+
+        def initialize(client)
+          @client = client
+        end
+
+        def all
+          perform_get(resource_path)
+        end
+
+        def create(attributes)
+          perform_post(resource_path, {}, attributes)
+          true
+        end
+
+        def delete(name)
+          perform_delete(resource_path(name))
+          true
+        end
+
+        protected
+
+        def resource_path(*args)
+          [path_prefix, self.class._resource_path, path_postfix, args].compact.flatten.join(?/).squeeze(?/)
+        end
+
+        def path_prefix
+        end
+
+        def path_postfix
+        end
+
+        def perform_get(path, params = {})
+          client.perform_request('get', path, params || {}).body
+        end
+
+        def perform_post(path, params, body)
+          client.perform_request('post', path, params || {}, body).body
+        end
+
+        def perform_delete(path, params = {}, body = nil)
+          client.perform_request('delete', path, params || {}, body).body
+        end
+      end
+    end
+  end
+end