dpl 1.8.33.travis.2049.5 → 1.8.34.travis.2089.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6bc174c17fad30b36ac9b2e2367a6b535a46ebd8
-  data.tar.gz: 058ee4f23d5412dc20611a0c91c6e813362c6ed0
+  metadata.gz: 344f328801c80df62034fbfcc73345c4f1777df5
+  data.tar.gz: 126e4bd8d202e46a3b2096fcd1a45b137742fb16
 SHA512:
-  metadata.gz: 44cb5e03513e86c8ee0610c705a64f73cb59d0fb17db8ca1d863a06b1462d4650e77a3134042f636c7133c1d185783b3ddcab4e368379058142fd89250486e94
-  data.tar.gz: 4c02d030e307fb7adb256276eff47fa700bc1baf23865c157306548f66b5f2112a4039a31ae31edb17efb8c3de9bb0de1f2733fe672202635710a008b40bcc8d
+  metadata.gz: a57556f2852be0c4df1a23656529984bc66225f84b4519690114b9387824828b11fafb3e2ba06c70823125621878822386e775e9dbc04aea523899e71328041d
+  data.tar.gz: c2890e7cc455e59bfeb074fc9779754a12d1c8e8c9887ad07e724175434f8c6ce6afe41886c03189be5cd878a001ffeb80af40b7d43393e213fad8bb632f675d

data/Gemfile

@@ -15,6 +15,7 @@ group :heroku do
   gem 'heroku-api', '= 0.3.16'
   gem 'anvil-cli', '~> 0.16.1'
   gem 'netrc'
+  gem 'faraday'
 end
 
 group :openshift do

data/lib/dpl/provider/heroku/api.rb

@@ -1,11 +1,67 @@
 require 'json'
 require 'shellwords'
+require 'logger'
 
 module DPL
   class Provider
     module Heroku
       class API < Generic
         attr_reader :build_id
+        requires 'faraday'
+        requires 'rendezvous'
+
+        def check_auth
+          response = faraday.get('/account')
+
+          if response.success?
+            email = JSON.parse(response.body)["email"]
+            log "authenticated as #{email}"
+          else
+            handle_error_response(response)
+          end
+        end
+
+        def faraday
+          return @conn if @conn
+          headers = { "Accept" => "application/vnd.heroku+json; version=3" }
+
+          if options[:user] and options[:password]
+            # no-op
+          else
+            headers.merge!({ "Authorization" => "Bearer #{option(:api_key)}" })
+          end
+
+          @conn = Faraday.new( url: 'https://api.heroku.com', headers: headers ) do |faraday|
+            if options[:user] and options[:password]
+              faraday.basic_auth(options[:user], options[:password])
+            end
+            if log_level = options[:log_level]
+              logger = Logger.new($stderr)
+              logger.level = Logger.const_get(log_level.upcase)
+
+              faraday.response :logger, logger do | logger |
+                logger.filter(/(.*Authorization: ).*/,'\1[REDACTED]')
+              end
+            end
+            faraday.adapter Faraday.default_adapter
+          end
+        end
+
+        def check_app
+          log "checking for app #{option(:app)}"
+          response = faraday.get("/apps/#{option(:app)}")
+          if response.success?
+            name = JSON.parse(response.body)["name"]
+            log "found app #{name}"
+          else
+            handle_error_response(response)
+          end
+        end
+
+        def handle_error_response(response)
+          error_response = JSON.parse(response.body)
+          error "API request failed.\nMessage: #{error_response["message"]}\nReference: #{error_response["url"]}"
+        end
 
         def push_app
           pack_archive
@@ -30,16 +86,29 @@ module DPL
 
         def trigger_build
           log "triggering new deployment"
-          response   = post(:builds, source_blob: { url: get_url, version: version })
-          @build_id  = response.fetch('id')
-          output_stream_url = response.fetch('output_stream_url')
-          context.shell "curl #{Shellwords.escape(output_stream_url)}"
+          response = faraday.post("/apps/#{option(:app)}/builds") do |req|
+            req.headers['Content-Type'] = 'application/json'
+            req.body = {
+              "source_blob" => {
+                "url" => get_url,
+                "version" => version
+              }
+              }.to_json
+          end
+
+          if response.success?
+            @build_id  = JSON.parse(response.body)['id']
+            output_stream_url = JSON.parse(response.body)['output_stream_url']
+            context.shell "curl #{Shellwords.escape(output_stream_url)}"
+          else
+            handle_error_response(response)
+          end
         end
 
         def verify_build
           loop do
-            response = get("builds/#{build_id}/result")
-            exit_code = response.fetch('exit_code')
+            response = faraday.get("/apps/#{option(:app)}/builds/#{build_id}/result")
+            exit_code = JSON.parse(response.body)['exit_code']
             if exit_code.nil?
               log "heroku build still pending"
               sleep 5
@@ -61,38 +130,41 @@ module DPL
         end
 
         def source_blob
-          @source_blob ||= post(:sources).fetch("source_blob")
+          return @source_blob if @source_blob
+
+          response = faraday.post('/sources')
+
+          if response.success?
+            @source_blob = JSON.parse(response.body)["source_blob"]
+          else
+            handle_error_response(response)
+          end
         end
 
         def version
           @version ||= options[:version] || context.env['TRAVIS_COMMIT'] || `git rev-parse HEAD`.strip
         end
 
-        def get(subpath, options = {})
-          options = {
-            method: :get,
-            path: "/apps/#{option(:app)}/#{subpath}",
-            headers: { "Accept" => "application/vnd.heroku+json; version=3" },
-            expects: [200]
-          }.merge(options)
-
-          api.request(options).body
+        def restart
+          response = faraday.delete "/apps/#{option(:app)}/dynos" do |req|
+            req.headers['Content-Type'] = 'application/json'
+          end
+          unless response.success?
+            handle_error_response(response)
+          end
         end
 
-        def post(subpath, body = nil, options = {})
-          options = {
-            method: :post,
-            path: "/apps/#{option(:app)}/#{subpath}",
-            headers: { "Accept" => "application/vnd.heroku+json; version=3" },
-            expects: [200, 201]
-          }.merge(options)
-
-          if body
-            options[:body]                    = JSON.dump(body)
-            options[:headers]['Content-Type'] = 'application/json'
+        def run(command)
+          response = faraday.post "/apps/#{option(:app)}/dynos" do |req|
+            req.headers['Content-Type'] = 'application/json'
+            req.body = {"command" => command, "attach" => true}.to_json
+          end
+          if response.success?
+            rendezvous_url = JSON.parse(response.body)["attach_url"]
+            Rendezvous.start(url: rendezvous_url)
+          else
+            handle_error_response(response)
           end
-
-          api.request(options).body
         end
       end
     end

data/lib/dpl/version.rb

@@ -1,3 +1,3 @@
 module DPL
-  VERSION = '1.8.32'
+  VERSION = '1.8.33'
 end

data/spec/provider/heroku_api_spec.rb

@@ -1,16 +1,160 @@
 require 'spec_helper'
-require 'heroku-api'
 require 'dpl/provider/heroku'
+require 'faraday'
 
 describe DPL::Provider::Heroku do
+  let(:api_key) { 'foo' }
+  let(:stubs) { Faraday::Adapter::Test::Stubs.new }
+  let(:faraday) {
+    Faraday.new do |builder|
+      builder.adapter :test, stubs do |stub|
+        stub.get("/account") {|env| [200, response_headers, account_response_body]}
+        stub.post("/apps/example/builds") {|env| [201, response_headers, builds_response_body]}
+        stub.get("/apps/example/builds/01234567-89ab-cdef-0123-456789abcdef/result") {|env| [200, response_headers, build_result_response_body]}
+        stub.post("/sources") {|env| [201, response_headers, source_response_body] }
+      end
+    end
+  }
+
+  let(:response_headers) {
+    {'Content-Type' => 'application/json'}
+  }
+
+  let(:account_response_body) {
+'{
+  "allow_tracking": true,
+  "beta": false,
+  "created_at": "2012-01-01T12:00:00Z",
+  "email": "username@example.com",
+  "federated": false,
+  "id": "01234567-89ab-cdef-0123-456789abcdef",
+  "identity_provider": {
+    "id": "01234567-89ab-cdef-0123-456789abcdef",
+    "organization": {
+      "name": "example"
+    }
+  },
+  "last_login": "2012-01-01T12:00:00Z",
+  "name": "Tina Edmonds",
+  "sms_number": "+1 ***-***-1234",
+  "suspended_at": "2012-01-01T12:00:00Z",
+  "delinquent_at": "2012-01-01T12:00:00Z",
+  "two_factor_authentication": false,
+  "updated_at": "2012-01-01T12:00:00Z",
+  "verified": false,
+  "default_organization": {
+    "id": "01234567-89ab-cdef-0123-456789abcdef",
+    "name": "example"
+  }
+}'
+  }
+
+  let(:builds_response_body) {
+'{
+  "app": {
+    "id": "01234567-89ab-cdef-0123-456789abcdef"
+  },
+  "buildpacks": [
+    {
+      "url": "https://github.com/heroku/heroku-buildpack-ruby"
+    }
+  ],
+  "created_at": "2012-01-01T12:00:00Z",
+  "id": "01234567-89ab-cdef-0123-456789abcdef",
+  "output_stream_url": "https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef",
+  "source_blob": {
+    "checksum": "SHA256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "url": "https://example.com/source.tgz?token=xyz",
+    "version": "v1.3.0"
+  },
+  "release": {
+    "id": "01234567-89ab-cdef-0123-456789abcdef"
+  },
+  "slug": {
+    "id": "01234567-89ab-cdef-0123-456789abcdef"
+  },
+  "status": "succeeded",
+  "updated_at": "2012-01-01T12:00:00Z",
+  "user": {
+    "id": "01234567-89ab-cdef-0123-456789abcdef",
+    "email": "username@example.com"
+  }
+}'
+  }
+
+  let(:source_response_body) {
+'{
+  "source_blob": {
+    "get_url": "https://api.heroku.com/sources/1234.tgz",
+    "put_url": "https://api.heroku.com/sources/1234.tgz"
+  }
+}'
+  }
+
+  let(:build_result_response_body) {
+'{
+    "build": {
+    "id": "01234567-89ab-cdef-0123-456789abcdef",
+    "status": "succeeded",
+    "output_stream_url": "https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef"
+  },
+  "exit_code": 0,
+  "lines": [
+    {
+      "line": "-----> Ruby app detected\n",
+      "stream": "STDOUT"
+    }
+  ]
+}'
+  }
+
+  let(:build_result_response_body_failure) {
+'{
+    "build": {
+    "id": "01234567-89ab-cdef-0123-456789abcdef",
+    "status": "failed",
+    "output_stream_url": "https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef"
+  },
+  "exit_code": 1,
+  "lines": [
+    {
+      "line": "-----> Ruby app detected\n",
+      "stream": "STDOUT"
+    }
+  ]
+}'
+  }
+
+  let(:build_result_response_body_in_progress) {
+'{
+    "build": {
+    "id": "01234567-89ab-cdef-0123-456789abcdef",
+    "status": "failed",
+    "output_stream_url": "https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef"
+  },
+  "lines": [
+    {
+      "line": "-----> Ruby app detected\n",
+      "stream": "STDOUT"
+    }
+  ]
+}'
+  }
+
   subject(:provider) do
-    described_class.new(DummyContext.new, :app => 'example', :key_name => 'key', :api_key => "foo", :strategy => "api")
+    described_class.new(DummyContext.new, provider_options.merge({ :api_key => api_key}))
   end
 
+  let(:provider_options) {
+    {:app => 'example', :key_name => 'key', :strategy => "api"}
+  }
+
   let(:expected_headers) do
-    { "User-Agent" => "dpl/#{DPL::VERSION} heroku-rb/#{Heroku::API::VERSION}", "Accept" => "application/vnd.heroku+json; version=3" }
+    { "Authorization" => "Bearer #{api_key}", "Accept" => "application/vnd.heroku+json; version=3" }
   end
 
+  let(:api_url) { 'https://api.heroku.com' }
+
   describe "#ssh" do
     it "doesn't require an ssh key" do
       expect(provider.needs_key?).to eq(false)
@@ -19,74 +163,61 @@ describe DPL::Provider::Heroku do
 
   describe "#api" do
     it 'accepts an api key' do
-      api = double(:api)
-      expect(::Heroku::API).to receive(:new).with(:api_key => "foo", :headers => expected_headers).and_return(api)
-      expect(provider.api).to eq(api)
+      expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+      provider.check_auth
     end
 
-    it 'accepts a user and a password' do
-      api = double(:api)
-      provider.options.update(:user => "foo", :password => "bar")
-      expect(::Heroku::API).to receive(:new).with(:user => "foo", :password => "bar", :headers => expected_headers).and_return(api)
-      expect(provider.api).to eq(api)
+    context "when api_key is not given" do
+      let(:provider) { described_class.new(DummyContext.new, provider_options) }
+      it 'raises DPL::Error' do
+        provider.options.update(:user => "foo", :password => "bar")
+        expect(::Heroku::API).not_to receive(:new)
+        expect { provider.check_auth }.to raise_error(DPL::Error)
+      end
     end
   end
 
   describe "#trigger_build" do
-    let(:response_body) { {
-      "created_at" => "2012-01-01T12:00:00Z",
-      "id" => "abc",
-      "status" => "pending",
-      "output_stream_url" => "http://example.com/stream",
-      "updated_at" => "2012-01-01T12:00:00Z",
-      "user" => { "id" => "01234567-89ab-cdef-0123-456789abcdef", "email" => "username@example.com" }
-    } }
+    it "does not initiate legacy API object" do
+      expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+      expect(::Heroku::API).not_to receive(:new)
+      provider.trigger_build
+    end
+
     example do
       expect(provider).to receive(:log).with('triggering new deployment')
+      expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
       expect(provider).to receive(:get_url).and_return 'http://example.com/source.tgz'
-      expect(provider).to receive(:version).and_return 'sha'
-      expect(provider).to receive(:post).with(
-        :builds, source_blob: {url: 'http://example.com/source.tgz', version: 'sha'}
-      ).and_return(response_body)
-      expect(provider.context).to receive(:shell).with('curl http://example.com/stream')
+      expect(provider).to receive(:version).and_return 'v1.3.0'
+      expect(provider.context).to receive(:shell).with('curl https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef')
       provider.trigger_build
-      expect(provider.build_id).to eq('abc')
+      expect(provider.build_id).to eq('01234567-89ab-cdef-0123-456789abcdef')
     end
   end
 
   describe "#verify_build" do
-    def response_body(status, exit_code)
-      {
-        "build" => {
-          "id" => "01234567-89ab-cdef-0123-456789abcdef",
-          "status" => status
-        },
-        "exit_code" => exit_code
-      }
-    end
-
-    before do
-      allow(provider).to receive(:build_id).and_return('abc')
-    end
-
     context 'when build succeeds' do
       example do
-        expect(provider).to receive(:get).with('builds/abc/result').and_return(response_body('succeeded', 0))
+        expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+        expect(provider).to receive(:build_id).at_least(:once).and_return('01234567-89ab-cdef-0123-456789abcdef')
         expect{ provider.verify_build }.not_to raise_error
       end
     end
 
     context 'when build fails' do
       example do
-        expect(provider).to receive(:get).with('builds/abc/result').and_return(response_body('failed', 1))
+        expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+        expect(provider).to receive(:build_id).at_least(:once).and_return('01234567-89ab-cdef-0123-456789abcdef')
+        stubs.get("/apps/example/builds/01234567-89ab-cdef-0123-456789abcdef/result") {|env| [200, response_headers, build_result_response_body_failure]}
         expect{ provider.verify_build }.to raise_error("deploy failed, build exited with code 1")
       end
     end
 
     context 'when build is pending, then succeeds' do
       example do
-        expect(provider).to receive(:get).with('builds/abc/result').and_return(response_body('pending', nil), response_body('succeeded', 0))
-        expect(provider).to receive(:log).with('heroku build still pending')
+        expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+        expect(provider).to receive(:build_id).at_least(:once).and_return('01234567-89ab-cdef-0123-456789abcdef')
+        stubs.get("/apps/example/builds/01234567-89ab-cdef-0123-456789abcdef/result") {|env| [200, response_headers, build_result_response_body_in_progress]}
         expect(provider).to receive(:sleep).with(5) # stub sleep
         expect{ provider.verify_build }.not_to raise_error
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dpl
 version: !ruby/object:Gem::Version
-  version: 1.8.33.travis.2049.5
+  version: 1.8.34.travis.2089.5
 platform: ruby
 authors:
 - Konstantin Haase
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-30 00:00:00.000000000 Z
+date: 2017-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec