influxdb 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 760707db17ad8199b2159d6e1e0f28e420f60f2f
-  data.tar.gz: 1fb214ed28fe1978c7fc7a0b4a1aa9b2d6572988
+  metadata.gz: 79714dbe624e4485dfefc69e334b3234daf4c5c6
+  data.tar.gz: 8a36045de479f5406d65b332c191edb3cfe327bb
 SHA512:
-  metadata.gz: 7348efe2e8cf889cfcb6f4fa5557eb217438abb7c87a43813b3da1290412107f7b73f0959cd7a590172ed0158ef9663716c3ac1de733dcb6e26038e90ddbacfd
-  data.tar.gz: 4fbceddc8faa2e02bc7ef272c17c63d4fc81f73c9f964f51003cbd96769786d84d07369d52617737c5618f15a66fa67eaf55aaf9cbf76beb54ec8921a4373935
+  metadata.gz: f29ae07c03cd04314bfc82af8510334c7a6e829a33ef1eaa1a7d8a5be802bf53883bab852075d64b3fd142b319e7ea9ecfb5a4f447671bd5629af0be4087dda3
+  data.tar.gz: 478b0d0002b481bed502b6682f795bad4a61f69eaa4c459dacc9f8050023ba1ed78d15bd27187914d0c6b6d2ea0b6e6989945f5b399f97c0ffefb0596e2d9514

data/.gitignore

@@ -12,6 +12,8 @@ test/tmp
 test/version_tmp
 tmp
 Gemfile.lock
+.rvmrc
+.ruby-version
 
 # YARD artifacts
 .yardoc

data/.travis.yml

@@ -2,9 +2,9 @@ language: ruby
 before_install:
   - gem update bundler
 rvm:
-  - 1.8.7-p374
-  - ree
   - 1.9.3
   - 2.0.0
+  - 2.1.0
+  - 2.2.0
   - ruby-head
   - jruby

data/README.md

@@ -1,6 +1,14 @@
 influxdb-ruby
 =============
 
+# This library is not updated for InfluxDB 0.9.0. There are breaking changes to the API, use at your own risk.
+
+We encourage you to submit a pull request if you have a contribution.
+
+----------
+
+
+
 [![Build Status](https://travis-ci.org/influxdb/influxdb-ruby.png?branch=master)](https://travis-ci.org/influxdb/influxdb-ruby)
 
 Ruby client library for [InfluxDB](http://influxdb.org/).
@@ -23,6 +31,8 @@ Connecting to a single host:
 require 'influxdb'
 
 influxdb = InfluxDB::Client.new host: "influxdb.domain.com"
+# or
+influxdb = InfluxDB::Client.new  # no host given defaults connecting to localhost
 ```
 
 Connecting to multiple hosts (with built-in load balancing and failover):
@@ -40,6 +50,8 @@ require 'influxdb'
 
 influxdb = InfluxDB::Client.new
 
+database = 'site_development'
+
 influxdb.create_database(database)
 ```
 
@@ -137,6 +149,25 @@ data = {
 influxdb.write_point(name, data, false, time_precision)
 ```
 
+Write data via UDP:
+
+``` ruby
+require 'influxdb'
+host = '127.0.0.1'
+port = 4444
+
+influxdb = InfluxDB::Client.new :udp => { :host => host, :port => port }
+
+name = 'hitchhiker'
+
+data = {
+  :answer => 42,
+  :question => "life the universe and everything?"
+}
+
+influxdb.write_point(name, data)
+```
+
 
 List cluster admins:
 

data/influxdb.gemspec

@@ -19,9 +19,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency "json"
+  spec.add_runtime_dependency "cause"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
   spec.add_development_dependency "webmock"
 end

data/lib/influxdb.rb

@@ -5,4 +5,5 @@ require "influxdb/logger"
 require "influxdb/max_queue"
 require "influxdb/worker"
 require "influxdb/client"
+require "influxdb/udp_client"
 require "influxdb/point_value"

data/lib/influxdb/client.rb

@@ -3,6 +3,7 @@ require 'cgi'
 require 'net/http'
 require 'net/https'
 require 'json'
+require 'cause'
 
 module InfluxDB
   class Client
@@ -12,10 +13,13 @@ module InfluxDB
                   :password,
                   :database,
                   :time_precision,
+                  :auth_method,
                   :use_ssl,
+                  :verify_ssl,
+                  :ssl_ca_cert,
                   :stopped
 
-    attr_accessor :queue, :worker
+    attr_accessor :queue, :worker, :udp_client
 
     include InfluxDB::Logging
 
@@ -33,21 +37,30 @@ module InfluxDB
     #
     #     Influxdb::Client.new 'db', :username => 'username' # override username, use 'db' as the db name
     #
+    #     Influxdb::Client.new 'db', :path => '/prefix'      # use the specified path prefix when building the
+    #                                                        # url e.g.: /prefix/db/dbname...
+    #
     # === Valid options in hash
     #
     # +:host+:: the hostname to connect to
     # +:port+:: the port to connect to
     # +:username+:: the username to use when executing commands
     # +:password+:: the password associated with the username
-    # +:use_ssl+:: use ssl to connect
+    # +:use_ssl+:: use ssl to connect?
+    # +:verify_ssl+:: verify ssl server certificate?
+    # +:ssl_ca_cert+:: ssl CA certificate, chainfile or CA path. The system CA path is automatically included.
     def initialize *args
       @database = args.first if args.first.is_a? String
       opts = args.last.is_a?(Hash) ? args.last : {}
       @hosts = Array(opts[:hosts] || opts[:host] || ["localhost"])
       @port = opts[:port] || 8086
+      @path = opts[:path] || ""
       @username = opts[:username] || "root"
       @password = opts[:password] || "root"
+      @auth_method = %w{params basic_auth}.include?(opts[:auth_method]) ? opts[:auth_method] : "params"
       @use_ssl = opts[:use_ssl] || false
+      @verify_ssl = opts.fetch(:verify_ssl, true)
+      @ssl_ca_cert = opts[:ssl_ca_cert] || false
       @time_precision = opts[:time_precision] || "s"
       @initial_delay = opts[:initial_delay] || 0.01
       @max_delay = opts[:max_delay] || 30
@@ -65,14 +78,18 @@ module InfluxDB
       end
 
       @worker = InfluxDB::Worker.new(self) if @async
+      self.udp_client = opts[:udp] ? InfluxDB::UDPClient.new(opts[:udp][:host], opts[:udp][:port]) : nil
+
+      at_exit { stop! } if @retry > 0
+    end
 
-      at_exit { stop! }
+    def ping
+      get "/ping"
     end
 
     ## allow options, e.g. influxdb.create_database('foo', replicationFactor: 3)
     def create_database(name, options = {})
-      url = full_url("/db")
-      options[:name] = name
+      url = full_url("/cluster/database_configs/#{name}")
       data = JSON.generate(options)
       post(url, data)
     end
@@ -85,6 +102,10 @@ module InfluxDB
       get full_url("/db")
     end
 
+    def authenticate_cluster_admin
+      get(full_url('/cluster_admins/authenticate'), true)
+    end
+
     def create_cluster_admin(username, password)
       url = full_url("/cluster_admins")
       data = JSON.generate({:name => username, :password => password})
@@ -105,9 +126,13 @@ module InfluxDB
       get full_url("/cluster_admins")
     end
 
-    def create_database_user(database, username, password)
+    def authenticate_database_user(database)
+      get(full_url("/db/#{database}/authenticate"), true)
+    end
+
+    def create_database_user(database, username, password, options={})
       url = full_url("/db/#{database}/users")
-      data = JSON.generate({:name => username, :password => password})
+      data = JSON.generate({:name => username, :password => password}.merge(options))
       post(url, data)
     end
 
@@ -133,6 +158,7 @@ module InfluxDB
       update_database_user(database, username, :admin => admin)
     end
 
+    # NOTE: Only cluster admin can call this
     def continuous_queries(database)
       get full_url("/db/#{database}/continuous_queries")
     end
@@ -141,12 +167,126 @@ module InfluxDB
       get full_url("/cluster/shards")
     end
 
-    def delete_shard(shard_id, server_ids, username, password)
+    def delete_shard(shard_id, server_ids)
       data = JSON.generate({"serverIds" => server_ids})
-      delete full_url("/cluster/shards/#{shard_id}", :u => username, :p => password), data
+      delete full_url("/cluster/shards/#{shard_id}"), data
+    end
+
+    # EXAMPLE:
+    #
+    # db.create_continuous_query(
+    #   "select mean(sys) as sys, mean(usr) as usr from cpu group by time(15m)",
+    #   "cpu.15m",
+    # )
+    #
+    # NOTE: Only cluster admin can call this
+    def create_continuous_query(query, name)
+      query("#{query} into #{name}")
+    end
+
+    # NOTE: Only cluster admin can call this
+    def get_continuous_query_list
+      query("list continuous queries")
+    end
+    
+    # NOTE: Only cluster admin can call this
+    def delete_continuous_query(id)
+      query("drop continuous query #{id}")
+    end
+
+    def get_shard_space_list
+      get full_url("/cluster/shard_spaces")
+    end
+
+    def get_shard_space(database_name, shard_space_name)
+      get_shard_space_list.find do |shard_space|
+        shard_space["database"] == database_name &&
+          shard_space["name"] == shard_space_name
+      end
+    end
+
+    def create_shard_space(database_name, options = {})
+      url  = full_url("/cluster/shard_spaces/#{database_name}")
+      data = JSON.generate(default_shard_space_options.merge(options))
+
+      post(url, data)
+    end
+
+    def delete_shard_space(database_name, shard_space_name)
+      delete full_url("/cluster/shard_spaces/#{database_name}/#{shard_space_name}")
+    end
+
+    ## Get the shard space first, so the user doesn't have to specify the existing options
+    def update_shard_space(database_name, shard_space_name, options)
+      shard_space_options = get_shard_space(database_name, shard_space_name)
+      shard_space_options.delete("database")
+
+      url  = full_url("/cluster/shard_spaces/#{database_name}/#{shard_space_name}")
+      data = JSON.generate(shard_space_options.merge(options))
+
+      post(url, data)
+    end
+
+    def default_shard_space_options
+      {
+        "name"              => "default",
+        "regEx"             => "/.*/",
+        "retentionPolicy"   => "inf",
+        "shardDuration"     => "7d",
+        "replicationFactor" => 1,
+        "split"             => 1
+      }
+    end
+
+    def configure_database(database_name, options = {})
+      url  = full_url("/cluster/database_configs/#{database_name}")
+      data = JSON.generate(default_database_configuration.merge(options))
+
+      post(url, data)
+    end
+
+    def default_database_configuration
+      {:spaces => [default_shard_space_options]}
     end
 
     def write_point(name, data, async=@async, time_precision=@time_precision)
+      write_points([{:name => name, :data => data}], async, time_precision)
+    end
+
+    # Example:
+    # db.write_points(
+    #     [
+    #         {
+    #             name: 'first_name',
+    #             data: {
+    #                 value: 'val1'
+    #             }
+    #         },
+    #         {
+    #             name: 'first_name',
+    #             data: {
+    #                 value: 'val1'
+    #             }
+    #         }
+    #     ]
+    # )
+    def write_points(name_data_hashes_array, async=@async, time_precision=@time_precision)
+
+      payloads = []
+      name_data_hashes_array.each do |attrs|
+        payloads << generate_payload(attrs[:name], attrs[:data])
+      end
+
+      if async
+        worker.push(payloads)
+      elsif udp_client
+        udp_client.send(payloads)
+      else
+        _write(payloads, time_precision)
+      end
+    end
+
+    def generate_payload(name, data)
       data = data.is_a?(Array) ? data : [data]
       columns = data.reduce(:merge).keys.sort {|a,b| a.to_s <=> b.to_s}
       payload = {:name => name, :points => [], :columns => columns}
@@ -157,11 +297,7 @@ module InfluxDB
         end
       end
 
-      if async
-        worker.push(payload)
-      else
-        _write([payload], time_precision)
-      end
+      payload
     end
 
     def _write(payload, time_precision=@time_precision)
@@ -201,19 +337,31 @@ module InfluxDB
     private
 
     def full_url(path, params={})
-      params[:u] = @username
-      params[:p] = @password
+      unless basic_auth?
+        params[:u] = @username
+        params[:p] = @password
+      end
 
       query = params.map { |k, v| [CGI.escape(k.to_s), "=", CGI.escape(v.to_s)].join }.join("&")
 
-      URI::Generic.build(:path => path, :query => query).to_s
+      URI::Generic.build(:path => "#{@path}#{path}", :query => query).to_s
     end
 
-    def get(url)
+    def basic_auth?
+      @auth_method == 'basic_auth'
+    end
+
+    def get(url, return_response = false)
       connect_with_retry do |http|
-        response = http.request(Net::HTTP::Get.new(url))
+        request = Net::HTTP::Get.new(url)
+        request.basic_auth @username, @password if basic_auth?
+        response = http.request(request)
         if response.kind_of? Net::HTTPSuccess
-          return JSON.parse(response.body)
+          if return_response
+            return response
+          else
+            return JSON.parse(response.body)
+          end
         elsif response.kind_of? Net::HTTPUnauthorized
           raise InfluxDB::AuthenticationError.new response.body
         else
@@ -225,7 +373,9 @@ module InfluxDB
     def post(url, data)
       headers = {"Content-Type" => "application/json"}
       connect_with_retry do |http|
-        response = http.request(Net::HTTP::Post.new(url, headers), data)
+        request = Net::HTTP::Post.new(url, headers)
+        request.basic_auth @username, @password if basic_auth?
+        response = http.request(request, data)
         if response.kind_of? Net::HTTPSuccess
           return response
         elsif response.kind_of? Net::HTTPUnauthorized
@@ -239,7 +389,9 @@ module InfluxDB
     def delete(url, data = nil)
       headers = {"Content-Type" => "application/json"}
       connect_with_retry do |http|
-        response = http.request(Net::HTTP::Delete.new(url, headers), data)
+        request = Net::HTTP::Delete.new(url, headers)
+        request.basic_auth @username, @password if basic_auth?
+        response = http.request(request, data)
         if response.kind_of? Net::HTTPSuccess
           return response
         elsif response.kind_of? Net::HTTPUnauthorized
@@ -261,6 +413,21 @@ module InfluxDB
         http.open_timeout = @open_timeout
         http.read_timeout = @read_timeout
         http.use_ssl = @use_ssl
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless @verify_ssl
+
+        if @use_ssl
+          store = OpenSSL::X509::Store.new
+          store.set_default_paths
+          if @ssl_ca_cert
+            if File.directory?(@ssl_ca_cert)
+              store.add_path(@ssl_ca_cert)
+            else
+              store.add_file(@ssl_ca_cert)
+            end
+          end
+          http.cert_store = store
+        end
+
         block.call(http)
 
       rescue Timeout::Error, *InfluxDB::NET_HTTP_EXCEPTIONS => e
@@ -272,7 +439,7 @@ module InfluxDB
           delay = [@max_delay, delay * 2].min
           retry
         else
-          raise e, "Tried #{retry_count-1} times to reconnect but failed."
+          raise InfluxDB::ConnectionError, "Tried #{retry_count-1} times to reconnect but failed."
         end
       ensure
         http.finish if http.started?

data/lib/influxdb/logger.rb

@@ -9,12 +9,13 @@ module InfluxDB
     end
 
     def self.logger
-      @logger ||= ::Logger.new(STDERR).tap {|logger| logger.level = Logger::INFO}
+      return @logger unless @logger.nil?
+      @logger = ::Logger.new(STDERR).tap {|logger| logger.level = Logger::INFO}
     end
 
     private
     def log(level, message)
-      InfluxDB::Logging.logger.send(level.to_sym, PREFIX + message)
+      InfluxDB::Logging.logger.send(level.to_sym, PREFIX + message) if InfluxDB::Logging.logger
     end
   end
 end

data/lib/influxdb/udp_client.rb

@@ -0,0 +1,16 @@
+require "json"
+
+module InfluxDB
+  class UDPClient
+    attr_accessor :socket
+    def initialize(host, port)
+      self.socket = UDPSocket.new
+      self.socket.connect(host, port)
+    end
+
+    def send(payload)
+      socket.send(JSON.generate(payload), 0)
+    rescue
+    end
+  end
+end

data/lib/influxdb/version.rb

@@ -1,3 +1,3 @@
 module InfluxDB
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

data/lib/influxdb/worker.rb

@@ -17,6 +17,11 @@ module InfluxDB
       @queue = InfluxDB::MaxQueue.new
       @client = client
       spawn_threads!
+
+      at_exit do
+        log :debug, "Thread exiting, flushing queue."
+        check_background_queue until @queue.empty?
+      end
     end
 
     def current_threads
@@ -28,7 +33,11 @@ module InfluxDB
     end
 
     def push(payload)
-      queue.push(payload)
+      if payload.is_a? Array
+        payload.each {|p| queue.push(p) }
+      else
+        queue.push(payload)
+      end
     end
 
     def spawn_threads!
@@ -38,11 +47,6 @@ module InfluxDB
         Thread.new do
           Thread.current[:influxdb] = self.object_id
 
-          at_exit do
-            log :debug, "Thread exiting, flushing queue."
-            check_background_queue(thread_num) until @queue.empty?
-          end
-
           while !client.stopped?
             self.check_background_queue(thread_num)
             sleep rand(SLEEP_INTERVAL)

data/spec/influxdb/client_spec.rb

@@ -22,6 +22,7 @@ describe InfluxDB::Client do
         @influxdb.password.should == "root"
         @influxdb.use_ssl.should be_falsey
         @influxdb.time_precision.should == "s"
+        @influxdb.auth_method.should == "params"
       end
     end
 
@@ -101,16 +102,70 @@ describe InfluxDB::Client do
         @influxdb.password.should == "root"
       end
     end
+
+    describe "with auth_method basic auth specified" do
+      it "should be initialized with basic auth enabled" do
+        @influxdb = InfluxDB::Client.new :auth_method => 'basic_auth'
+
+        @influxdb.should be_a(InfluxDB::Client)
+        @influxdb.auth_method.should == 'basic_auth'
+        @influxdb.username.should == "root"
+        @influxdb.password.should == "root"
+      end
+    end
+
+    describe "with udp specified" do
+      it "should initialize a udp client" do
+        @influxdb = InfluxDB::Client.new :udp => { :host => 'localhost', :port => 4444 }
+        expect(@influxdb.udp_client).to be_a(InfluxDB::UDPClient)
+      end
+
+      context "without udp specfied" do
+        it "does not initialize a udp client" do
+          @influxdb = InfluxDB::Client.new
+          expect(@influxdb.udp_client).to be_nil
+        end
+      end
+    end
+  end
+
+
+  context "with basic auth enabled" do
+    let(:args) { { :auth_method => 'basic_auth' } }
+    it "should use basic authorization for get" do
+      stub_request(:get, "http://username:password@influxdb.test:9999/").to_return(:body => '[]')
+      @influxdb.send(:get , @influxdb.send(:full_url,'/')).should == []
+    end
+    it "should use basic authorization for post" do
+      stub_request(:post, "http://username:password@influxdb.test:9999/")
+      @influxdb.send(:post , @influxdb.send(:full_url,'/'), {}).should be_a(Net::HTTPOK)
+    end
+    it "should use basic authorization for delete" do
+      stub_request(:delete, "http://username:password@influxdb.test:9999/")
+      @influxdb.send(:delete , @influxdb.send(:full_url,'/')).should be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#ping" do
+    it "should return status ok" do
+      status_ok = {"status" => "ok"}
+      stub_request(:get, "http://influxdb.test:9999/ping"
+      ).to_return(:body => JSON.generate(status_ok), :status => 200)
+
+      @influxdb.ping.should == status_ok
+    end
   end
 
   describe "#create_database" do
     it "should POST to create a new database" do
-      stub_request(:post, "http://influxdb.test:9999/db").with(
+      stub_request(
+        :post, 'http://influxdb.test:9999/cluster/database_configs/foo'
+      ).with(
         :query => {:u => "username", :p => "password"},
-        :body => {:name => "foo"}
+        :body => {:spaces => []}
       )
 
-      @influxdb.create_database("foo").should be_a(Net::HTTPOK)
+      @influxdb.create_database("foo", {:spaces => []}).should be_a(Net::HTTPOK)
     end
   end
 
@@ -135,6 +190,16 @@ describe InfluxDB::Client do
     end
   end
 
+  describe "#authenticate_cluster_admin" do
+    it "should GET to authenticate a cluster admin" do
+      stub_request(:get, "http://influxdb.test:9999/cluster_admins/authenticate").with(
+        :query => {:u => "username", :p => "password"}
+      )
+
+      @influxdb.authenticate_cluster_admin.should be_a(Net::HTTPOK)
+    end
+  end
+
   describe "#create_cluster_admin" do
     it "should POST to create a new cluster admin" do
       stub_request(:post, "http://influxdb.test:9999/cluster_admins").with(
@@ -178,6 +243,16 @@ describe InfluxDB::Client do
     end
   end
 
+  describe "#authenticate_database_user" do
+    it "should GET to authenticate a database database" do
+      stub_request(:get, "http://influxdb.test:9999/db/foo/authenticate").with(
+        :query => {:u => "username", :p => "password"}
+      ).to_return(:body => '', :status => 200)
+
+      @influxdb.authenticate_database_user("foo").should be_a(Net::HTTPOK)
+    end
+  end
+
   describe "#create_database_user" do
     it "should POST to create a new database user" do
       stub_request(:post, "http://influxdb.test:9999/db/foo/users").with(
@@ -187,6 +262,20 @@ describe InfluxDB::Client do
 
       @influxdb.create_database_user("foo", "useruser", "passpass").should be_a(Net::HTTPOK)
     end
+
+    it "should POST to create a new database user with permissions" do
+      stub_request(:post, "http://influxdb.test:9999/db/foo/users").with(
+        :query => {:u => "username", :p => "password"},
+        :body => {:name => "useruser", :password => "passpass", :readFrom => "/read*/", :writeTo => "/write*/"}
+      )
+
+      @influxdb.create_database_user(
+        "foo",
+        "useruser",
+        "passpass",
+        {:readFrom => "/read*/", :writeTo => "/write*/"}
+      ).should be_a(Net::HTTPOK)
+    end
   end
 
   describe "#update_database_user" do
@@ -261,7 +350,174 @@ describe InfluxDB::Client do
         :query => {:u => "username", :p => "password"}
       )
 
-      @influxdb.delete_shard(shard_id, [1, 2], "username", "password").should be_a(Net::HTTPOK)
+      @influxdb.delete_shard(shard_id, [1, 2]).should be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#create_continuous_query" do
+    it "should GET to create a continuous query" do
+      stub_request(:get, "http://influxdb.test:9999/db/database/series").with(
+        :query => { :q => "select sys from cpu into sys", :u => "username", :p => "password", :time_precision => "s"}
+      ).to_return(:body => JSON.generate({}))
+
+      @influxdb.create_continuous_query("select sys from cpu", "sys").should == {}
+    end
+  end
+
+  describe "#get_continuous_query_list" do
+    it "should GET to get continuous query list" do
+      body = [{
+        "name"=>"continuous queries",
+        "columns"=>["time", "sequence_number", "id", "query"],
+        "points"=>[
+          [1399, 1, 1, "select sys from cpu into sys"]
+        ]
+      }]
+      expected = {
+        "continuous queries" => [
+          {
+            "time" => 1399,
+            "sequence_number" => 1,
+            "id" => 1,
+            "query" => "select sys from cpu into sys"
+          }
+        ]
+      }
+      stub_request(:get, "http://influxdb.test:9999/db/database/series").with(
+        :query => { :q => "list continuous queries", :u => "username", :p => "password", :time_precision => "s"}
+      ).to_return(:body => JSON.generate(body))
+
+      @influxdb.get_continuous_query_list.should == expected
+    end
+  end
+
+  describe "#delete_continuous_query" do
+    it "should GET to delete continuous query" do
+      id = 1
+      stub_request(:get, "http://influxdb.test:9999/db/database/series").with(
+        :query => { :q => "drop continuous query #{id}", :u => "username", :p => "password", :time_precision => "s"}
+      ).to_return(:body => JSON.generate({}))
+
+      @influxdb.delete_continuous_query(id).should == {}
+    end
+  end
+
+  describe "#get_shard_space_list" do
+    let(:url)            { "http://influxdb.test:9999/cluster/shard_spaces" }
+    let(:request_params) { {:query => {:u => "username", :p => "password"}} }
+    let(:response)       { {:body => JSON.generate(shard_spaces, :status => 200)} }
+    let(:shard_spaces)   { [@influxdb.default_shard_space_options.merge(:database => "foo")] }
+
+    it 'should GET a list of shard spaces' do
+      request = stub_request(:get, url).with(request_params).to_return(response)
+
+      @influxdb.get_shard_space_list
+
+      expect(request).to have_been_requested
+    end
+  end
+
+  describe "#get_shard_space" do
+    let(:url)            { "http://influxdb.test:9999/cluster/shard_spaces" }
+    let(:request_params) { {:query => {:u => "username", :p => "password"}} }
+    let(:response)       { {:body => JSON.generate(shard_spaces, :status => 200)} }
+
+    describe "#get_shard_space_list returns a non-empty list" do
+      let(:shard_spaces) { [@influxdb.default_shard_space_options.merge("database" => "foo")] }
+
+      it "finds the indicated shard space" do
+        request = stub_request(:get, url).with(request_params).to_return(response)
+
+        expect(@influxdb.get_shard_space('foo', 'default')).to eq shard_spaces.first
+
+        expect(request).to have_been_requested
+      end
+    end
+
+    describe "#get_shard_space_list returns an empty list" do
+      let(:shard_spaces) { [] }
+
+      it "finds no shard space" do
+        request = stub_request(:get, url).with(request_params).to_return(response)
+
+        expect(@influxdb.get_shard_space('foo', 'default')).to eq nil
+
+        expect(request).to have_been_requested
+      end
+    end
+  end
+
+  describe "#create_shard_space" do
+    let(:url) { "http://influxdb.test:9999/cluster/shard_spaces/foo" }
+    let(:request_params) do
+      {
+        :query => {:u => "username", :p => "password"},
+        :body  => @influxdb.default_shard_space_options
+      }
+    end
+
+    it 'should POST to create a shard space' do
+      request = stub_request(:post, url).with(request_params)
+
+      @influxdb.create_shard_space("foo", @influxdb.default_shard_space_options)
+
+      expect(request).to have_been_requested
+    end
+  end
+
+  describe "#delete_shard_space" do
+    let(:url)            { "http://influxdb.test:9999/cluster/shard_spaces/foo/default" }
+    let(:request_params) { {:query => {:u => "username", :p => "password"}} }
+
+    it 'should DELETE to delete the shard space' do
+      request = stub_request(:delete, url).with(request_params)
+
+      @influxdb.delete_shard_space("foo", "default")
+
+      expect(request).to have_been_requested
+    end
+  end
+
+  describe "#update_shard_space" do
+    let(:get_url)            { "http://influxdb.test:9999/cluster/shard_spaces" }
+    let(:get_request_params) { {:query => {:u => "username", :p => "password"}} }
+    let(:get_response)       { {:body => JSON.generate(shard_spaces, :status => 200)} }
+    let(:shard_spaces)       { [@influxdb.default_shard_space_options.merge("database" => "foo")] }
+
+    let(:post_url) { "http://influxdb.test:9999/cluster/shard_spaces/foo/default" }
+    let(:post_request_params) do
+      {
+        :query => {:u => "username", :p => "password"},
+        :body  => @influxdb.default_shard_space_options.merge("shardDuration" => "30d")
+      }
+    end
+
+    it 'should GET the shard space and then POST to update the shard space' do
+      get_request  = stub_request(:get, get_url).with(get_request_params).to_return(get_response)
+      post_request = stub_request(:post, post_url).with(post_request_params)
+
+      @influxdb.update_shard_space("foo", "default", {"shardDuration" => "30d"})
+
+      expect(get_request).to have_been_requested
+      expect(post_request).to have_been_requested
+    end
+  end
+
+  describe "#configure_database" do
+    let(:url) { "http://influxdb.test:9999/cluster/database_configs/foo" }
+    let(:request_params) do
+      {
+        :query => {:u => "username", :p => "password"},
+        :body => @influxdb.default_database_configuration
+      }
+    end
+
+    it "should POST to create a new database config" do
+      request = stub_request(:post, url).with(request_params)
+
+      @influxdb.configure_database("foo").should be_a(Net::HTTPOK)
+
+      expect(request).to have_been_requested
     end
   end
 
@@ -307,14 +563,18 @@ describe InfluxDB::Client do
       it "raises when stopped" do
         @influxdb.stop!
         @influxdb.should_not_receive :sleep
-        expect { subject }.to raise_error(Timeout::Error)
+        expect { subject }.to raise_error(InfluxDB::ConnectionError) do |e|
+          expect(e.cause).to be_an_instance_of(Timeout::Error)
+        end
       end
 
       context "when retry is 0" do
         let(:args) { { :retry => 0 } }
         it "raise error directly" do
           @influxdb.should_not_receive :sleep
-          expect { subject }.to raise_error(Timeout::Error)
+          expect { subject }.to raise_error(InfluxDB::ConnectionError) do |e|
+            expect(e.cause).to be_an_instance_of(Timeout::Error)
+          end
         end
       end
 
@@ -323,7 +583,9 @@ describe InfluxDB::Client do
 
         it "raise error after 'n' attemps" do
           @influxdb.should_receive(:sleep).exactly(3).times
-          expect { subject }.to raise_error(Timeout::Error)
+          expect { subject }.to raise_error(InfluxDB::ConnectionError) do |e|
+            expect(e.cause).to be_an_instance_of(Timeout::Error)
+          end
         end
       end
 
@@ -471,21 +733,41 @@ describe InfluxDB::Client do
       it "should push to the worker with payload if client is async" do
         @influxdb = InfluxDB::Client.new "database", :host => "influxdb.test", :async => true
 
-        data = {:name => "juan", :age => 87, :time => Time.now.to_i}
-        @influxdb.stub_chain(:worker, :push).with(hash_including({:name => 'seriez'})).and_return(:ok)
+        time = Time.now.to_i
+        data = {:name => "juan", :age => 87, :time => time}
+        expected_data = [{:name => 'seriez', :points => [[87, 'juan', time]], :columns => [:age, :name, :time]}]
+        @influxdb.stub_chain(:worker, :push).with(expected_data).and_return(:ok)
         @influxdb.write_point("seriez", data).should eq(:ok)
       end
 
       it "should push to the worker with payload if write_point call is async" do
         @influxdb = InfluxDB::Client.new "database", :host => "influxdb.test", :async => false
 
-        data = {:name => "juan", :age => 87, :time => Time.now.to_i}
-        @influxdb.stub_chain(:worker, :push).with(hash_including({:name => 'seriez'})).and_return(:ok)
+        time = Time.now.to_i
+        data = {:name => "juan", :age => 87, :time => time}
+        expected_data = [{:name => 'seriez', :points => [[87, 'juan', time]], :columns => [:age, :name, :time]}]
+        @influxdb.stub_chain(:worker, :push).with(expected_data).and_return(:ok)
         @influxdb.write_point("seriez", data, true).should eq(:ok)
       end
 
     end
 
+    describe "udp" do
+      let(:udp_client) { double }
+      let(:time) { Time.now.to_i }
+      let(:influxdb)  { InfluxDB::Client.new(:udp => { :host => "localhost", :port => 44444 }) }
+
+      before do
+        allow(InfluxDB::UDPClient).to receive(:new).with('localhost', 44444).and_return(udp_client)
+      end
+
+      it "should send payload via udp if udp client is set up" do
+        expect(udp_client).to receive(:send).with([{:name=>"seriez", :points=>[[87, "juan", time]], :columns=>[:age, :name, :time]}])
+        data = {:name => "juan", :age => 87, :time => time}
+        influxdb.write_point("seriez", data)
+      end
+    end
+
   end
 
   describe "#execute_queries" do

data/spec/influxdb/logger_spec.rb

@@ -23,6 +23,22 @@ describe InfluxDB::Logging do
     InfluxDB::Logging.logger = new_logger
     expect(InfluxDB::Logging.logger).to eq(new_logger)
   end
+  
+  it "allows disabling of a logger" do
+    InfluxDB::Logging.logger = false
+    expect(InfluxDB::Logging.logger).to eql false
+  end
+  
+  context "when logging is disabled" do
+    
+    subject { LoggerTest.new }
+    
+    it "does not log" do
+      InfluxDB::Logging.logger = false
+      expect(InfluxDB::Logging.logger).not_to receive(:debug)
+      subject.write_to_log(:debug, 'test')
+    end      
+  end
 
   context "when included in classes" do
 

data/spec/influxdb/udp_client_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "json"
+
+describe InfluxDB::UDPClient do
+  subject { described_class.new("localhost", 44444) }
+  let(:message) { [{ "foo" => "bar" }] }
+
+  describe "#send" do
+    it "sends a UPD packet" do
+      s = UDPSocket.new
+      s.bind("localhost", 44444)
+      subject.send(message)
+      rec_mesage = JSON.parse(s.recvfrom(15).first)
+      expect(rec_mesage).to eq message
+    end
+
+    context "it can't connect" do
+      before do
+        subject.socket = FailingSocket.new
+      end
+
+      it "doesn't blow up" do
+        expect { subject.send(message) }.to_not raise_error
+      end
+    end
+
+    class FailingSocket < UDPSocket
+      def send(*args)
+        fail
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,2 +1,11 @@
-require "influxdb"
-require "webmock/rspec"
+require 'influxdb'
+require 'webmock/rspec'
+
+RSpec.configure do |config|
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = [:should, :expect]
+  end
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = [:should, :expect]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: influxdb
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Todd Persen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-06 00:00:00.000000000 Z
+date: 2015-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -24,6 +24,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: cause
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +70,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -100,11 +114,13 @@ files:
 - lib/influxdb/logger.rb
 - lib/influxdb/max_queue.rb
 - lib/influxdb/point_value.rb
+- lib/influxdb/udp_client.rb
 - lib/influxdb/version.rb
 - lib/influxdb/worker.rb
 - spec/influxdb/client_spec.rb
 - spec/influxdb/logger_spec.rb
 - spec/influxdb/point_value_spec.rb
+- spec/influxdb/udp_client_spec.rb
 - spec/influxdb/worker_spec.rb
 - spec/influxdb_spec.rb
 - spec/max_queue_spec.rb
@@ -129,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Ruby library for InfluxDB.
@@ -137,6 +153,7 @@ test_files:
 - spec/influxdb/client_spec.rb
 - spec/influxdb/logger_spec.rb
 - spec/influxdb/point_value_spec.rb
+- spec/influxdb/udp_client_spec.rb
 - spec/influxdb/worker_spec.rb
 - spec/influxdb_spec.rb
 - spec/max_queue_spec.rb