presto-client 0.5.7 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c323f1555c8b8911022378e1b6b5c3ab32ea198
-  data.tar.gz: dad8f48273aa312ff3c89809698f6bf4955d54b1
+  metadata.gz: 4443f4f6a4ddd03831d7882ca9f296e49b1df7b1
+  data.tar.gz: 075f86339df45b84b868e9d5d04e33983c27b8a4
 SHA512:
-  metadata.gz: 7ef2fa5dd5e59a1d5a68f064bf3af0cabbae98b72ab9c64764297491c60de03f5ce7a7f00b527f5763b8eb92bdf2f5ffe2a9c01c4dc57a1da17b0f6c773d6368
-  data.tar.gz: fe6c1fc26dff277531c8334b6feaf299b66f4cebdfc9b752ceda5e26c5edd3a4b95888c0b4292f22d526a364f61c1f1bcfb18f55c28e82b78e1bae32d9f2c35e
+  metadata.gz: 7def55d33d949cff35e14419682c792b821eba0550e1ca791cf49cefa58651c8badfb898b193372afa09290487a2c9fee2cfa58cf1b0bb3b0acac764d2e2b5e5
+  data.tar.gz: f0122e8873e0f037e47231774ba03d1dab3f291ed126edce63a1e6b62733e457b29784ea0f252c5dbf778c18e0ea0773a39905a40ac4d97a8759e758ec9c86b8

data/ChangeLog

@@ -1,3 +1,12 @@
+2017-11-13 version 0.5.8
+
+* Added `Client#kill(query_id)` method.
+* Added additional checking of internal exceptions so that client doesn't
+  silently return in case when Presto query is killed and Presto returns a
+  valid `200 OK` response with `result_uri: null`.
+* Fixed `undefined local variable 'body'` error that was possibly happening
+  when Presto returned an unexpected data structure.
+
 2017-08-28 version 0.5.7
 * Support a password option with HTTP basic auth
 * Changed retry timeout from hard coded 2h to configurable default 2min

data/README.md

@@ -58,6 +58,12 @@ client.query("select * from sys.node") do |q|
     p row  # row is an array
   }
 end
+
+# killing a query
+query = client.query("select * from sys.node")
+query_id = query.query_info.query_id
+query.each_row {|row| ... }  # when a thread is processing the query,
+client.kill(query_id)  # another thread / process can kill the query.
 ```
 
 ## Build models

data/lib/presto/client/client.rb

@@ -40,6 +40,10 @@ module Presto::Client
       return Query.resume(next_uri, @options)
     end
 
+    def kill(query_id)
+      return Query.kill(query_id, @options)
+    end
+
     def run(query)
       q = Query.start(query, @options)
       begin

data/lib/presto/client/faraday_client.rb

@@ -0,0 +1,154 @@
+#
+# Presto client for Ruby
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module Presto::Client
+
+  module PrestoHeaders
+    PRESTO_USER = "X-Presto-User"
+    PRESTO_SOURCE = "X-Presto-Source"
+    PRESTO_CATALOG = "X-Presto-Catalog"
+    PRESTO_SCHEMA = "X-Presto-Schema"
+    PRESTO_TIME_ZONE = "X-Presto-Time-Zone"
+    PRESTO_LANGUAGE = "X-Presto-Language"
+    PRESTO_SESSION = "X-Presto-Session"
+
+    PRESTO_CURRENT_STATE = "X-Presto-Current-State"
+    PRESTO_MAX_WAIT = "X-Presto-Max-Wait"
+    PRESTO_MAX_SIZE = "X-Presto-Max-Size"
+    PRESTO_PAGE_SEQUENCE_ID = "X-Presto-Page-Sequence-Id"
+  end
+
+  HEADERS = {
+    "User-Agent" => "presto-ruby/#{VERSION}",
+  }
+
+  def self.faraday_client(options)
+    server = options[:server]
+    unless server
+      raise ArgumentError, ":server option is required"
+    end
+
+    ssl = faraday_ssl_options(options)
+
+    if options[:password] && !ssl
+      raise ArgumentError, "Protocol must be https when passing a password"
+    end
+
+    url = "#{ssl ? "https" : "http"}://#{server}"
+    proxy = options[:http_proxy] || options[:proxy]  # :proxy is obsoleted
+
+    faraday_options = {url: url, proxy: "#{proxy}"}
+    faraday_options[:ssl] = ssl if ssl
+
+    faraday = Faraday.new(faraday_options) do |faraday|
+      if options[:user] && options[:password]
+        faraday.basic_auth(options[:user], options[:password])
+      end
+
+      faraday.response :logger if options[:http_debug]
+      faraday.adapter Faraday.default_adapter
+    end
+
+    faraday.headers.merge!(HEADERS)
+    faraday.headers.merge!(optional_headers(options))
+
+    return faraday
+  end
+
+  def self.faraday_ssl_options(options)
+    ssl = options[:ssl]
+
+    case ssl
+    when true
+      ssl = {verify: true}
+
+    when Hash
+      verify = ssl.fetch(:verify, true)
+      case verify
+      when true
+        # detailed SSL options. pass through to faraday
+      when nil, false
+        ssl = {verify: false}
+      else
+        raise ArgumentError, "Can't convert #{verify.class} of :verify option of :ssl option to true or false"
+      end
+
+    when nil, false
+      ssl = false
+
+    else
+      raise ArgumentError, "Can't convert #{ssl.class} of :ssl option to true, false, or Hash"
+    end
+
+    return ssl
+  end
+
+  def self.optional_headers(options)
+    headers = {}
+    if v = options[:user]
+      headers[PrestoHeaders::PRESTO_USER] = v
+    end
+    if v = options[:source]
+      headers[PrestoHeaders::PRESTO_SOURCE] = v
+    end
+    if v = options[:catalog]
+      headers[PrestoHeaders::PRESTO_CATALOG] = v
+    end
+    if v = options[:schema]
+      headers[PrestoHeaders::PRESTO_SCHEMA] = v
+    end
+    if v = options[:time_zone]
+      headers[PrestoHeaders::PRESTO_TIME_ZONE] = v
+    end
+    if v = options[:language]
+      headers[PrestoHeaders::PRESTO_LANGUAGE] = v
+    end
+    if v = options[:properties]
+      headers[PrestoHeaders::PRESTO_SESSION] = encode_properties(v)
+    end
+    if options[:enable_x_msgpack]
+      # option name is enable_"x"_msgpack because "Accept: application/x-msgpack" header is
+      # not officially supported by Presto. We can use this option only if a proxy server
+      # decodes & encodes response body. Once this option is supported by Presto, option
+      # name should be enable_msgpack, which might be slightly different behavior.
+      headers['Accept'] = 'application/x-msgpack,application/json'
+    end
+    headers
+  end
+
+  HTTP11_SEPARATOR = ["(", ")", "<", ">", "@", ",", ";", ":", "\\", "<", ">", "/", "[", "]", "?", "=", "{", "}", " ", "\v"]
+  HTTP11_TOKEN_CHARSET = (32..126).map {|x| x.chr } - HTTP11_SEPARATOR
+  HTTP11_TOKEN_REGEXP = /^[#{Regexp.escape(HTTP11_TOKEN_CHARSET.join)}]+\z/
+  HTTP11_CTL_CHARSET = (0..31).map {|x| x.chr } + [127.chr]
+  HTTP11_CTL_CHARSET_REGEXP = /[#{Regexp.escape(HTTP11_CTL_CHARSET.join)}]/
+
+  def self.encode_properties(properties)
+    # this is a hack to set same header multiple times.
+    properties.map do |k, v|
+      token = k.to_s
+      field_value = v.to_s  # TODO LWS encoding is not implemented
+      unless k =~ HTTP11_TOKEN_REGEXP
+        raise Faraday::ClientError, "Key of properties can't include HTTP/1.1 control characters or separators (#{HTTP11_SEPARATOR.map {|c| c =~ /\s/ ? c.dump : c }.join(' ')})"
+      end
+      if field_value =~ HTTP11_CTL_CHARSET_REGEXP
+        raise Faraday::ClientError, "Value of properties can't include HTTP/1.1 control characters"
+      end
+      "#{token}=#{field_value}"
+    end.join("\r\n#{PrestoHeaders::PRESTO_SESSION}: ")
+  end
+
+  private_class_method :faraday_ssl_options, :optional_headers, :encode_properties
+
+end

data/lib/presto/client/query.rb

@@ -18,6 +18,7 @@ module Presto::Client
   require 'faraday'
   require 'presto/client/models'
   require 'presto/client/errors'
+  require 'presto/client/faraday_client'
   require 'presto/client/statement_client'
 
   class Query
@@ -29,68 +30,18 @@ module Presto::Client
       new StatementClient.new(faraday_client(options), nil, options, next_uri)
     end
 
-    def self.faraday_client(options)
-      server = options[:server]
-      unless server
-        raise ArgumentError, ":server option is required"
-      end
-
-      ssl = faraday_ssl_options(options)
-
-      if options[:password] && !ssl
-        raise ArgumentError, "Protocol must be https when passing a password"
-      end
-
-      url = "#{ssl ? "https" : "http"}://#{server}"
-      proxy = options[:http_proxy] || options[:proxy]  # :proxy is obsoleted
-
-      faraday_options = {url: url, proxy: "#{proxy}"}
-      faraday_options[:ssl] = ssl if ssl
-
-      faraday = Faraday.new(faraday_options) do |faraday|
-        #faraday.request :url_encoded
-
-        if options[:user] && options[:password]
-          faraday.basic_auth(options[:user], options[:password])
-        end
-
-        faraday.response :logger if options[:http_debug]
-        faraday.adapter Faraday.default_adapter
+    def self.kill(query_id, options)
+      faraday = faraday_client(options)
+      response = faraday.delete do |req|
+        req.url "/v1/query/#{query_id}"
       end
-
-      return faraday
+      return response.status / 100 == 2
     end
 
-    def self.faraday_ssl_options(options)
-      ssl = options[:ssl]
-
-      case ssl
-      when true
-        ssl = {verify: true}
-
-      when Hash
-        verify = ssl.fetch(:verify, true)
-        case verify
-        when true
-          # detailed SSL options. pass through to faraday
-        when nil, false
-          ssl = {verify: false}
-        else
-          raise ArgumentError, "Can't convert #{verify.class} of :verify option of :ssl option to true or false"
-        end
-
-      when nil, false
-        ssl = false
-
-      else
-        raise ArgumentError, "Can't convert #{ssl.class} of :ssl option to true, false, or Hash"
-      end
-
-      return ssl
+    def self.faraday_client(options)
+      Presto::Client.faraday_client(options)
     end
 
-    private_class_method :faraday_client, :faraday_ssl_options
-
     def initialize(api)
       @api = api
     end
@@ -103,24 +54,29 @@ module Presto::Client
       @api.advance
     end
 
+    def advance_and_raise
+      cont = @api.advance
+      raise_if_failed
+      cont
+    end
+
     def wait_for_columns
-      while @api.current_results.columns == nil && @api.advance
+      while @api.current_results.columns == nil && advance_and_raise
       end
     end
 
     def wait_for_data
-      while @api.current_results.data == nil && @api.advance
+      while @api.current_results.data == nil && advance_and_raise
       end
     end
 
+    private :advance_and_raise
     private :wait_for_columns
     private :wait_for_data
 
     def columns
       wait_for_columns
 
-      raise_if_failed
-
       return @api.current_results.columns
     end
 
@@ -141,8 +97,6 @@ module Presto::Client
     def each_row_chunk(&block)
       wait_for_data
 
-      raise_if_failed
-
       if self.columns == nil
         raise PrestoError, "Query #{@api.current_results.id} has no columns"
       end
@@ -151,7 +105,7 @@ module Presto::Client
         if data = @api.current_results.data
           block.call(data)
         end
-      end while @api.advance
+      end while advance_and_raise
     end
 
     def query_info

data/lib/presto/client/statement_client.rb

@@ -20,26 +20,7 @@ module Presto::Client
   require 'presto/client/models'
   require 'presto/client/errors'
 
-  module PrestoHeaders
-    PRESTO_USER = "X-Presto-User"
-    PRESTO_SOURCE = "X-Presto-Source"
-    PRESTO_CATALOG = "X-Presto-Catalog"
-    PRESTO_SCHEMA = "X-Presto-Schema"
-    PRESTO_TIME_ZONE = "X-Presto-Time-Zone"
-    PRESTO_LANGUAGE = "X-Presto-Language"
-    PRESTO_SESSION = "X-Presto-Session"
-
-    PRESTO_CURRENT_STATE = "X-Presto-Current-State"
-    PRESTO_MAX_WAIT = "X-Presto-Max-Wait"
-    PRESTO_MAX_SIZE = "X-Presto-Max-Size"
-    PRESTO_PAGE_SEQUENCE_ID = "X-Presto-Page-Sequence-Id"
-  end
-
   class StatementClient
-    HEADERS = {
-      "User-Agent" => "presto-ruby/#{VERSION}",
-    }
-
     # Presto can return too deep nested JSON
     JSON_OPTIONS = {
         :max_nesting => false
@@ -47,7 +28,6 @@ module Presto::Client
 
     def initialize(faraday, query, options, next_uri=nil)
       @faraday = faraday
-      @faraday.headers.merge!(HEADERS)
 
       @options = options
       @query = query
@@ -60,8 +40,6 @@ module Presto::Client
         @models = Models
       end
 
-      @faraday.headers.merge!(optional_headers)
-
       if next_uri
         response = faraday_get_with_retry(next_uri)
         @results = @models::QueryResults.decode(parse_body(response))
@@ -70,41 +48,6 @@ module Presto::Client
       end
     end
 
-    def optional_headers
-      headers = {}
-      if v = @options[:user]
-        headers[PrestoHeaders::PRESTO_USER] = v
-      end
-      if v = @options[:source]
-        headers[PrestoHeaders::PRESTO_SOURCE] = v
-      end
-      if v = @options[:catalog]
-        headers[PrestoHeaders::PRESTO_CATALOG] = v
-      end
-      if v = @options[:schema]
-        headers[PrestoHeaders::PRESTO_SCHEMA] = v
-      end
-      if v = @options[:time_zone]
-        headers[PrestoHeaders::PRESTO_TIME_ZONE] = v
-      end
-      if v = @options[:language]
-        headers[PrestoHeaders::PRESTO_LANGUAGE] = v
-      end
-      if v = @options[:properties]
-        headers[PrestoHeaders::PRESTO_SESSION] = encode_properties(v)
-      end
-      if @options[:enable_x_msgpack]
-        # option name is enable_"x"_msgpack because "Accept: application/x-msgpack" header is
-        # not officially supported by Presto. We can use this option only if a proxy server
-        # decodes & encodes response body. Once this option is supported by Presto, option
-        # name should be enable_msgpack, which might be slightly different behavior.
-        headers['Accept'] = 'application/x-msgpack,application/json'
-      end
-      headers
-    end
-
-    private :optional_headers
-
     def init_request(req)
       req.options.timeout = @options[:http_timeout] || 300
       req.options.open_timeout = @options[:http_open_timeout] || 60
@@ -185,6 +128,7 @@ module Presto::Client
       begin
         body_class.decode(hash)
       rescue => e
+        body = JSON.dump(hash)
         if body.size > 1024 + 3
           body = "#{body[0, 1024]}..."
         end
@@ -251,27 +195,6 @@ module Presto::Client
       return false
     end
 
-    HTTP11_SEPARATOR = ["(", ")", "<", ">", "@", ",", ";", ":", "\\", "<", ">", "/", "[", "]", "?", "=", "{", "}", " ", "\v"]
-    HTTP11_TOKEN_CHARSET = (32..126).map {|x| x.chr } - HTTP11_SEPARATOR
-    HTTP11_TOKEN_REGEXP = /^[#{Regexp.escape(HTTP11_TOKEN_CHARSET.join)}]+\z/
-    HTTP11_CTL_CHARSET = (0..31).map {|x| x.chr } + [127.chr]
-    HTTP11_CTL_CHARSET_REGEXP = /[#{Regexp.escape(HTTP11_CTL_CHARSET.join)}]/
-
-    def encode_properties(properties)
-      # this is a hack to set same header multiple times.
-      properties.map do |k, v|
-        token = k.to_s
-        field_value = v.to_s  # TODO LWS encoding is not implemented
-        unless k =~ HTTP11_TOKEN_REGEXP
-          raise Faraday::ClientError, "Key of properties can't include HTTP/1.1 control characters or separators (#{HTTP11_SEPARATOR.map {|c| c =~ /\s/ ? c.dump : c }.join(' ')})"
-        end
-        if field_value =~ HTTP11_CTL_CHARSET_REGEXP
-          raise Faraday::ClientError, "Value of properties can't include HTTP/1.1 control characters"
-        end
-        "#{token}=#{field_value}"
-      end.join("\r\n#{PrestoHeaders::PRESTO_SESSION}: ")
-    end
-
     def close
       return if @closed
 

data/lib/presto/client/version.rb

@@ -15,6 +15,6 @@
 #
 module Presto
   module Client
-    VERSION = "0.5.7"
+    VERSION = "0.5.8"
   end
 end

data/spec/statement_client_spec.rb

@@ -25,6 +25,10 @@ describe Presto::Client::StatementClient do
     }
   end
 
+  let :faraday do
+    Presto::Client.faraday_client(options)
+  end
+
   it "sets headers" do
     stub_request(:post, "localhost/v1/statement").
       with(body: query,
@@ -38,7 +42,6 @@ describe Presto::Client::StatementClient do
               "X-Presto-Session" => options[:properties].map {|k,v| "#{k}=#{v}"}.join("\r\nX-Presto-Session: ")
     }).to_return(body: response_json.to_json)
 
-    faraday = Faraday.new(url: "http://localhost")
     StatementClient.new(faraday, query, options)
   end
 
@@ -75,7 +78,6 @@ describe Presto::Client::StatementClient do
               "X-Presto-Session" => options[:properties].map {|k,v| "#{k}=#{v}"}.join("\r\nX-Presto-Session: ")
     }).to_return(body: lambda{|req|if retry_p; response_json.to_json; else; retry_p=true; raise Timeout::Error.new("execution expired"); end })
 
-    faraday = Faraday.new(url: "http://localhost")
     sc = StatementClient.new(faraday, query, options.merge(http_open_timeout: 1))
     sc.has_next?.should be_true
     sc.advance.should be_true
@@ -109,8 +111,8 @@ describe Presto::Client::StatementClient do
               "Accept" => "application/x-msgpack,application/json"
     }).to_return(body: lambda{|req|if retry_p; MessagePack.dump(response_json); else; retry_p=true; raise Timeout::Error.new("execution expired"); end }, headers: {"Content-Type" => "application/x-msgpack"})
 
-    faraday = Faraday.new(url: "http://localhost")
-    sc = StatementClient.new(faraday, query, options.merge(http_open_timeout: 1, enable_x_msgpack: "application/x-msgpack"))
+    options.merge!(http_open_timeout: 1, enable_x_msgpack: "application/x-msgpack")
+    sc = StatementClient.new(faraday, query, options)
     sc.has_next?.should be_true
     sc.advance.should be_true
     retry_p.should be_true
@@ -136,6 +138,54 @@ describe Presto::Client::StatementClient do
     end.should raise_error(TypeError, /String to Hash/)
   end
 
+  describe '#query_info' do
+    it "raises an exception with sample JSON if response is unexpected" do
+      headers = {
+        "User-Agent" => "presto-ruby/#{VERSION}",
+        "X-Presto-Catalog" => options[:catalog],
+          "X-Presto-Schema" => options[:schema],
+          "X-Presto-User" => options[:user],
+          "X-Presto-Language" => options[:language],
+          "X-Presto-Time-Zone" => options[:time_zone],
+          "X-Presto-Session" => options[:properties].map {|k,v| "#{k}=#{v}"}.join("\r\nX-Presto-Session: ")
+      }
+
+      stub_request(:post, "http://localhost/v1/statement").
+        with(body: query, headers: headers).
+        to_return(body: response_json2.to_json)
+
+      sc = StatementClient.new(faraday, query, options)
+
+      stub_request(:get, "http://localhost/v1/query/#{response_json2[:id]}").
+        with(headers: headers).
+        to_return(body: {"session" => "invalid session structure"}.to_json)
+
+      lambda do
+        sc.query_info
+      end.should raise_error(PrestoHttpError, /Presto API returned unexpected structure at \/v1\/query\/queryid\. Expected Presto::Client::ModelVersions::.*::QueryInfo but got {"session":"invalid session structure"}/)
+    end
+  end
+
+  describe "Killing a query" do
+    let(:query_id) { 'A_QUERY_ID' }
+
+    it "sends DELETE request with empty body to /v1/query/{queryId}" do
+      stub_request(:delete, "http://localhost/v1/query/#{query_id}").
+        with(body: "",
+             headers: {
+                "User-Agent" => "presto-ruby/#{VERSION}",
+                "X-Presto-Catalog" => options[:catalog],
+                "X-Presto-Schema" => options[:schema],
+                "X-Presto-User" => options[:user],
+                "X-Presto-Language" => options[:language],
+                "X-Presto-Time-Zone" => options[:time_zone],
+                "X-Presto-Session" => options[:properties].map {|k,v| "#{k}=#{v}"}.join("\r\nX-Presto-Session: "),
+      }).to_return(body: {}.to_json)
+
+      Presto::Client.new(options).kill(query_id)
+    end
+  end
+
   describe 'HTTP basic auth' do
     let(:password) { 'abcd' }
 
@@ -154,7 +204,7 @@ describe Presto::Client::StatementClient do
             basic_auth: [options[:user], password]
       ).to_return(body: response_json.to_json)
 
-      faraday = Query.__send__(:faraday_client, options.merge(ssl: { verify: true }, password: password))
+      options.merge!(ssl: { verify: true }, password: password)
       StatementClient.new(faraday, query, options)
     end
 
@@ -289,7 +339,6 @@ describe Presto::Client::StatementClient do
                  "X-Presto-Session" => options[:properties].map {|k,v| "#{k}=#{v}"}.join("\r\nX-Presto-Session: ")
              }).to_return(body: nested_json.to_json(:max_nesting => false))
 
-    faraday = Faraday.new(url: "http://localhost")
     StatementClient.new(faraday, query, options)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: presto-client
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.5.8
 platform: ruby
 authors:
 - Sadayuki Furuhashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-28 00:00:00.000000000 Z
+date: 2017-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -131,6 +131,7 @@ files:
 - lib/presto/client.rb
 - lib/presto/client/client.rb
 - lib/presto/client/errors.rb
+- lib/presto/client/faraday_client.rb
 - lib/presto/client/model_versions/0.149.rb
 - lib/presto/client/model_versions/0.153.rb
 - lib/presto/client/model_versions/0.173.rb
@@ -168,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Presto client library