Class: NestConnect::Adapter::StreamingNetHttp

Inherits:
Faraday::Adapter
  • Object
show all
Defined in:
lib/nest_connect/api/adapter/streaming_net_http.rb

Constant Summary collapse

NET_HTTP_EXCEPTIONS = 
[
  IOError,
  Errno::ECONNABORTED,
  Errno::ECONNREFUSED,
  Errno::ECONNRESET,
  Errno::EHOSTUNREACH,
  Errno::EINVAL,
  Errno::ENETUNREACH,
  Errno::EPIPE,
  Net::HTTPBadResponse,
  Net::HTTPHeaderSyntaxError,
  Net::ProtocolError,
  SocketError,
  Zlib::GzipFile::Error,
]

Instance Method Summary collapse

Instance Method Details

#call(env) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/nest_connect/api/adapter/streaming_net_http.rb', line 39

def call(env)
  super
  with_net_http_connection(env) do |http|
    configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
    configure_request(http, env[:request])

    begin
      http_response = perform_request(http, env)
    rescue *NET_HTTP_EXCEPTIONS => err
      if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
        raise Faraday::SSLError, err
      else
        raise Error::ConnectionFailed, err
      end
    end

    save_response(env, http_response.code.to_i, http_response.body || '', nil, http_response.message) do |response_headers|
      http_response.each_header do |key, value|
        response_headers[key] = value
      end
    end
  end

  @app.call env
rescue Timeout::Error, Errno::ETIMEDOUT => err
  raise Faraday::Error::TimeoutError, err
end

#configure_request(http, req) ⇒ Object 



151
152
153
154
155
156
 
# File 'lib/nest_connect/api/adapter/streaming_net_http.rb', line 151

def configure_request(http, req)
  http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
  http.open_timeout = req[:open_timeout]                if req[:open_timeout]

  @config_block.call(http) if @config_block
end

#configure_ssl(http, ssl) ⇒ Object 



138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/nest_connect/api/adapter/streaming_net_http.rb', line 138

def configure_ssl(http, ssl)
  http.use_ssl      = true
  http.verify_mode  = ssl_verify_mode(ssl)
  http.cert_store   = ssl_cert_store(ssl)

  http.cert         = ssl[:client_cert]  if ssl[:client_cert]
  http.key          = ssl[:client_key]   if ssl[:client_key]
  http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
  http.ca_path      = ssl[:ca_path]      if ssl[:ca_path]
  http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
  http.ssl_version  = ssl[:version]      if ssl[:version]
end

#create_request(env) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/nest_connect/api/adapter/streaming_net_http.rb', line 67

def create_request(env)
  request = Net::HTTPGenericRequest.new \
    env[:method].to_s.upcase,    # request method
    !!env[:body],                # is there request body
    :head != env[:method],       # is there response body
    env[:url].request_uri,       # request uri path
    env[:request_headers]        # request headers

  if env[:body].respond_to?(:read)
    request.body_stream = env[:body]
  else
    request.body = env[:body]
  end
  request
end

#net_http_connection(env) ⇒ Object 



130
131
132
133
134
135
136
 
# File 'lib/nest_connect/api/adapter/streaming_net_http.rb', line 130

def net_http_connection(env)
  if proxy = env[:request][:proxy]
    Net::HTTP::Proxy(proxy[:uri].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
  else
    Net::HTTP
  end.new(env[:url].hostname, env[:url].port || (env[:url].scheme == 'https' ? 443 : 80))
end

#perform_request(http, env) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/nest_connect/api/adapter/streaming_net_http.rb', line 83

def perform_request(http, env)
  if env[:request].stream_response?
    size = 0
    yielded = false
    http_response = perform_request_with_wrapped_block(http, env) do |chunk|
      if chunk.bytesize > 0 || size > 0
        yielded = true
        size += chunk.bytesize
        env[:request].on_data.call(chunk, size)
      end
    end
    env[:request].on_data.call("", 0) unless yielded
    # Net::HTTP returns something, but it's not meaningful according to the docs.
    http_response.body = nil
    http_response
  else
    http_response = perform_request_with_wrapped_block(http, env)
  end
end

#perform_request_with_wrapped_block(http, env, &block) ⇒ Object 



103
104
105
106
107
108
109
110
 
# File 'lib/nest_connect/api/adapter/streaming_net_http.rb', line 103

def perform_request_with_wrapped_block(http, env, &block)
  if :get == env[:method] and !env[:body]
    # prefer `get` to `request` because the former handles gzip (ruby 1.9)
    request_via_get_method(http, env, &block)
  else
    request_via_request_method(http, env, &block)
  end
end

#request_via_get_method(http, env, &block) ⇒ Object 



112
113
114
 
# File 'lib/nest_connect/api/adapter/streaming_net_http.rb', line 112

def request_via_get_method(http, env, &block)
  http.get env[:url].request_uri, env[:request_headers], &block
end

#request_via_request_method(http, env, &block) ⇒ Object 



116
117
118
119
120
121
122
123
124
 
# File 'lib/nest_connect/api/adapter/streaming_net_http.rb', line 116

def request_via_request_method(http, env, &block)
  if block_given?
    http.request create_request(env) do |response|
      response.read_body(&block)
    end
  else
    http.request create_request(env)
  end
end

#ssl_cert_store(ssl) ⇒ Object 



158
159
160
161
162
163
164
 
# File 'lib/nest_connect/api/adapter/streaming_net_http.rb', line 158

def ssl_cert_store(ssl)
  return ssl[:cert_store] if ssl[:cert_store]
  # Use the default cert store by default, i.e. system ca certs
  cert_store = OpenSSL::X509::Store.new
  cert_store.set_default_paths
  cert_store
end

#ssl_verify_mode(ssl) ⇒ Object 



166
167
168
169
170
171
172
173
174
 
# File 'lib/nest_connect/api/adapter/streaming_net_http.rb', line 166

def ssl_verify_mode(ssl)
  ssl[:verify_mode] || begin
    if ssl.fetch(:verify, true)
      OpenSSL::SSL::VERIFY_PEER
    else
      OpenSSL::SSL::VERIFY_NONE
    end
  end
end

#with_net_http_connection(env) {|net_http_connection(env)| ... } ⇒ Object

Yields:



126
127
128
 
# File 'lib/nest_connect/api/adapter/streaming_net_http.rb', line 126

def with_net_http_connection(env)
  yield net_http_connection(env)
end