influxdb-api 0.0.1

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

@@ -0,0 +1,14 @@
+module Influxdb
+  module Api
+    module Namespaces
+      class ClusterAdmins < Base
+        resource_path '/cluster_admins'
+
+        def update(name, attributes)
+          perform_post(resource_path(name), {}, attributes)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Influxdb
+  module Api
+    module Namespaces
+      class ContinuousQueries < WithDatabase
+        resource_path '/continuous_queries'
+
+        def create(query)
+          super(query: query)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Influxdb
+  module Api
+    module Namespaces
+      class Databases < Base
+        resource_path '/db'
+
+        def create(name)
+          super(name: name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Influxdb
+  module Api
+    module Namespaces
+      class Series < WithDatabase
+        resource_path '/series'
+
+        undef_method(:create) if method_defined?(:create)
+
+        def all
+          raw_execute('list series').map{|s| s['name']}
+        end
+
+        def write(*series)
+          series = if series.first.is_a?(String) || series.first.is_a?(Symbol)
+            { series.shift => series.shift }
+          else
+            series.shift
+          end
+
+          series = series.map{|name, points| writing_block(name, Array.wrap(points)) }
+          perform_writing(series)
+        end
+
+        def execute(*args)
+          raw_execute(*args).each_with_object({}) do |block_of_series, result|
+            result[block_of_series['name']] = block_of_series['points'].map do |point|
+              Hash[block_of_series['columns'].zip(point)]
+            end
+          end
+        end
+
+        def raw_execute(query_string, time_precision = nil)
+          params = { q: query_string }
+          params[:time_precision] = time_precision if time_precision
+          perform_get(resource_path, params)
+        end
+
+        private
+
+        def perform_writing(series, time_precision = nil)
+          params = { time_precision: time_precision } if time_precision
+          perform_post(resource_path, params, series)
+          true
+        end
+
+        def writing_block(name, points)
+          { name: name, columns: points.first.keys, points: points.map(&:values) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Influxdb
+  module Api
+    module Namespaces
+      class Servers < Base
+        resource_path '/cluster/servers'
+
+        undef_method(:create) if method_defined?(:create)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Influxdb
+  module Api
+    module Namespaces
+      class ShardSpaces < WithDatabase
+        resource_path '/cluster/shard_spaces'
+
+        def all
+          perform_get(resource_path)
+        end
+
+        def create(attributes)
+          perform_post(resource_path(database_name), {}, attributes)
+          true
+        end
+
+        def update(name, attributes)
+          perform_post(resource_path(database_name, name), {}, attributes)
+          true
+        end
+
+        def delete(name)
+          perform_delete(resource_path(database_name, name))
+          true
+        end
+
+        protected
+
+        def path_prefix
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Influxdb
+  module Api
+    module Namespaces
+      class Shards < Base
+        resource_path '/cluster/shards'
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Influxdb
+  module Api
+    module Namespaces
+      class Users < WithDatabase
+        resource_path '/users'
+
+        def find(name)
+          perform_get(resource_path(name))
+        end
+
+        def update(name, attributes)
+          perform_post(resource_path(name), {}, attributes)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Influxdb
+  module Api
+    module Namespaces
+      class WithDatabase < Base
+        attr_reader :database_name
+
+        def initialize(client, database_name)
+          @client = client
+          @database_name = database_name
+        end
+
+        protected
+
+        def path_prefix
+          "/db/#{database_name}"
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/api/server_version.rb

@@ -0,0 +1,62 @@
+module Influxdb
+  module Api
+    class ServerVersion
+      include Comparable
+
+      class Engine
+        attr_reader :name, :major, :minor, :patch
+
+        def initialize(name, major, minor, patch)
+          @name, @major, @minor, @patch = name, major, minor, patch
+        end
+
+        def to_s
+          "%s: %s.%s.%s" % [name, major, minor, patch]
+        end
+
+        def inspect
+          to_s.inspect
+        end
+      end
+
+      # InfluxDB v0.7.3 (git: 023abcdef) (leveldb: 1.7)
+      REGEXP = /^InfluxDB\sv(\d+)\.(\d+)\.(\d+)\s\(git:\s([0-9abcdef]+)\)\s\((\w+):\s(\d+)\.(\d+)\)$/
+
+      attr_reader :source, :git, :engine, :major, :minor, :patch
+
+      def initialize(source)
+        @source = source
+        parse!
+      end
+
+      def <=>(other)
+        other_major, other_minor, other_patch = (other.to_s.split('.', 3) + [0] * 3).first(3).map(&:to_i)
+        [major <=> other_major, minor <=> other_minor, patch <=> other_patch].detect{|c| c != 0 } || 0
+      end
+
+      def to_s
+        source
+      end
+
+      def inspect
+        to_s.inspect
+      end
+
+      private
+
+      def parse!
+        matched = REGEXP.match(source)
+
+        @major = matched[1].to_i
+        @minor = matched[2].to_i
+        @patch = matched[3].to_i
+        @git = matched[4]
+        @engine = build_engine(matched)
+      end
+
+      def build_engine(matched)
+        Engine.new(matched[5], matched[6].to_i, matched[7].to_i, matched[8].to_i)
+      end
+    end
+  end
+end

data/lib/influxdb/api/version.rb

@@ -0,0 +1,5 @@
+module Influxdb
+  module Api
+    VERSION = '0.0.1'
+  end
+end

data/spec/lib/influxdb/api/client/connection_pool_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Influxdb::Api::Client::ConnectionPool do
+  let(:config){ Influxdb::Api::Configuration.new }
+
+  subject{ Influxdb::Api::Client::ConnectionPool.new(config) }
+
+  describe '#initialize' do
+    before do
+      config.hosts = ['localhost', 'influxdb.server.com']
+      config.connection_block{|conn|  }
+      config.connection_options = { key: :value }
+    end
+
+    let(:conn){ double(:conn) }
+
+    specify do
+      expect(::Faraday::Connection).to receive(:new).with(
+        'http://localhost:8086', { key: :value }, &config.connection_block
+      ).and_return(conn)
+
+      expect(Influxdb::Api::Client::Connection).to receive(:new).with('http://localhost:8086', conn, config).
+        and_return(conn)
+
+      expect(::Faraday::Connection).to receive(:new).with(
+        'http://influxdb.server.com:8086', { key: :value }, &config.connection_block
+      ).and_return(conn)
+
+      expect(Influxdb::Api::Client::Connection).to receive(:new).with('http://influxdb.server.com:8086', conn, config).
+        and_return(conn)
+
+      expect(subject.all).to eq([conn, conn])
+    end
+  end
+
+  describe '#get_connection' do
+    let(:conn){ double(:conn) }
+
+    before{ allow(config.selector).to receive(:select_from).and_return(conn) }
+
+    specify{ expect(subject.get_connection).to eq(conn) }
+  end
+
+  describe '#connections' do
+    before do
+      config.hosts = ['localhost', 'influxdb01.server.com', 'influxdb02.server.com']
+      subject.all.first.dead!
+    end
+
+    specify{ expect(subject.connections.size).to eq(2) }
+  end
+
+  describe '#dead' do
+    before do
+      config.hosts = ['localhost', 'influxdb01.server.com', 'influxdb02.server.com']
+      subject.all.first.dead!
+    end
+
+    specify{ expect(subject.dead.size).to eq(1) }
+  end
+end

data/spec/lib/influxdb/api/client/connection_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Influxdb::Api::Client::Connection do
+  let(:config){ Influxdb::Api::Configuration.new }
+
+  subject{ Influxdb::Api::Client::Connection.new('http://localhost:8086', nil, config) }
+
+  describe '#full_path' do
+    let(:path){ '/some/path' }
+    let(:params){ { key1: 'value1', key2: 'value2' } }
+    let(:result){ '/some/path?key1=value1&key2=value2' }
+
+    specify{ expect(subject.full_path(path, params)).to eq(result) }
+  end
+
+  describe '#dead?' do
+    specify{ expect(subject.dead?).to be_falsy }
+
+    context do
+      before{ subject.dead! }
+      specify{ expect(subject.dead?).to be_truthy }
+    end
+  end
+
+  describe '#dead!', time_freeze: '16.9.2014 00:00:00 +0700' do
+    let(:now){ Time.parse('16.9.2014 00:00:00 +0700') }
+
+    specify{ expect{ subject.dead! }.to change{ subject.failures }.from(0).to(1) }
+    specify{ expect{ subject.dead! }.to change{ subject.dead? }.from(false).to(true) }
+    specify{ expect{ subject.dead! }.to change{ subject.dead_since }.from(nil).to(now) }
+    specify{ expect(subject.dead!).to eq(subject) }
+  end
+
+  describe '#alive!' do
+    before{ subject.dead! }
+
+    specify{ expect{ subject.alive! }.to change{ subject.dead? }.from(true).to(false) }
+    specify{ expect{ subject.alive! }.not_to change{ subject.failures } }
+    specify{ expect(subject.alive!).to eq(subject) }
+  end
+
+  describe '#healthy!' do
+    before{ subject.dead! }
+
+    specify{ expect{ subject.healthy! }.to change{ subject.dead? }.from(true).to(false) }
+    specify{ expect{ subject.healthy! }.to change{ subject.failures }.from(1).to(0) }
+    specify{ expect(subject.healthy!).to eq(subject) }
+  end
+
+  describe '#resurrect!' do
+    before{ subject.dead! }
+
+    context 'when connection is resurrectable' do
+      before{ allow(subject).to receive(:resurrectable?).and_return(true) }
+
+      specify{ expect{ subject.resurrect! }.to change{ subject.dead? }.from(true).to(false) }
+      specify{ expect(subject.resurrect!).to eq(subject) }
+    end
+
+    context 'when connection is not resurrectable' do
+      before{ allow(subject).to receive(:resurrectable?).and_return(false) }
+
+      specify{ expect{ subject.resurrect! }.not_to change{ subject.dead? } }
+      specify{ expect(subject.resurrect!).to eq(subject) }
+    end
+  end
+
+  describe '#resurrectable?' do
+
+
+  end
+end

data/spec/lib/influxdb/api/client/response_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Influxdb::Api::Client::Response do
+  describe '#initialize' do
+    let(:iso_8859){ 'Hello Encoding!'.encode(Encoding::ISO_8859_1) }
+
+    subject{ Influxdb::Api::Client::Response.new(200, iso_8859, {}) }
+
+    specify{ expect(subject.body.encoding.name).to eq('UTF-8') }
+  end
+end

data/spec/lib/influxdb/api/client/selector_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Influxdb::Api::Client::Selector do
+  describe 'Random' do
+    subject{ Influxdb::Api::Client::Selector::Random.new }
+
+    describe '#select_from' do
+      specify{ expect(subject.select_from([1, 2, 3])).not_to be_nil }
+    end
+  end
+
+  describe 'RoundRobin' do
+    subject{ Influxdb::Api::Client::Selector::RoundRobin.new }
+
+    describe '#select_from' do
+      specify do
+        expect(subject.select_from([1, 2, 3])).to eq(1)
+        expect(subject.select_from([1, 2, 3])).to eq(2)
+        expect(subject.select_from([1, 2, 3])).to eq(3)
+        expect(subject.select_from([1, 2, 3])).to eq(1)
+      end
+    end
+  end
+end

data/spec/lib/influxdb/api/client_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Influxdb::Api::Client do
+  let(:config){ Influxdb::Api::Configuration.new }
+  let(:client){ Influxdb::Api::Client.new(config) }
+
+  describe '#perform_request' do
+    let(:pool){ client.send(:connection_pool) }
+
+    context 'perform GET request without params' do
+      before do
+        stub_request(:get, 'http://root:root@localhost:8086/path').
+          to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+      end
+
+      subject{ client.perform_request('GET', '/path') }
+
+      specify{ expect(subject.status).to eq(200) }
+      specify{ expect(subject.body).to eq({}) }
+      specify{ expect(subject.headers).to include('content-type' => 'application/json') }
+    end
+
+    context 'perform GET request with params' do
+      before do
+        stub_request(:get, 'http://root:root@localhost:8086/path?key1=value1').
+          to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+      end
+
+      subject{ client.perform_request('GET', '/path', key1: 'value1') }
+
+      specify{ expect(subject.status).to eq(200) }
+      specify{ expect(subject.body).to eq({}) }
+      specify{ expect(subject.headers).to include('content-type' => 'application/json') }
+    end
+
+    context 'perform GET request with HTTP error' do
+      before do
+        stub_request(:get, 'http://root:root@localhost:8086/path').
+          to_return(status: 404, body: '', headers: { 'Content-Type' => 'application/json' })
+      end
+
+      subject{ client.perform_request('GET', '/path') }
+
+      specify{ expect{ subject }.to raise_error(Influxdb::Api::Client::Errors::NotFound) }
+    end
+
+    context 'perform GET request with transport error if connection pool more then retry number' do
+      before do
+        config.hosts = ['localhost', 'influxdb1.server.com', 'influxdb2.server.com']
+        config.retry_on_failure = 2
+
+        stub_request(:get, 'http://root:root@localhost:8086/path').
+          to_raise(::Faraday::Error::ConnectionFailed)
+        stub_request(:get, 'http://root:root@influxdb1.server.com:8086/path').
+          to_raise(::Faraday::Error::ConnectionFailed)
+        stub_request(:get, 'http://root:root@influxdb2.server.com:8086/path').
+          to_raise(::Faraday::Error::ConnectionFailed)
+      end
+
+      subject{ client.perform_request('GET', '/path') }
+
+      specify do
+        expect{ subject }.to raise_error(Faraday::Error::ConnectionFailed)
+        expect(pool.alive.size).to eq(1)
+      end
+    end
+
+    context 'perform GET request with transport error if connection pool less then retry number' do
+      before do
+        config.hosts = ['localhost', 'influxdb1.server.com', 'influxdb2.server.com']
+        config.retry_on_failure = 4
+
+        stub_request(:get, 'http://root:root@localhost:8086/path').
+          to_raise(::Faraday::Error::ConnectionFailed)
+        stub_request(:get, 'http://root:root@influxdb1.server.com:8086/path').
+          to_raise(::Faraday::Error::ConnectionFailed)
+        stub_request(:get, 'http://root:root@influxdb2.server.com:8086/path').
+          to_raise(::Faraday::Error::ConnectionFailed)
+      end
+
+      subject{ client.perform_request('GET', '/path') }
+
+      specify do
+        expect{ subject }.to raise_error(Faraday::Error::ConnectionFailed)
+        expect(pool.alive.size).to eq(0)
+      end
+    end
+
+    context 'perform GET request with 2 transport errors and success' do
+      before do
+        config.hosts = ['localhost', 'influxdb1.server.com', 'influxdb2.server.com']
+        config.retry_on_failure = 4
+
+        stub_request(:get, 'http://root:root@localhost:8086/path').
+          to_raise(::Faraday::Error::ConnectionFailed)
+        stub_request(:get, 'http://root:root@influxdb2.server.com:8086/path').
+          to_raise(::Faraday::Error::ConnectionFailed)
+        stub_request(:get, 'http://root:root@influxdb1.server.com:8086/path').
+          to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+      end
+
+      subject{ client.perform_request('GET', '/path') }
+
+      specify{ expect(subject.status).to eq(200) }
+      specify{ expect(subject.body).to eq({}) }
+      specify{ expect(subject.headers).to include('content-type' => 'application/json') }
+      specify{ expect{ subject }.to change{ pool.alive.size }.from(3).to(1) }
+    end
+  end
+end