akamai_api 0.4.1 → 1.1.0

data/lib/akamai_api/ccu/purge/request.rb

@@ -1,5 +1,3 @@
-require "httparty"
-
 require 'active_support'
 require 'active_support/core_ext/array'
 
@@ -7,6 +5,11 @@ require "akamai_api/unauthorized"
 require "akamai_api/ccu/unrecognized_option"
 require "akamai_api/ccu/purge/response"
 
+require "akamai/edgegrid"
+require "net/http"
+require "uri"
+require "json"
+
 module AkamaiApi::CCU::Purge
   # {AkamaiApi::CCU::Purge} encapsulates the behavior needed to purge a resource from Akamai via CCU.
   #
@@ -15,10 +18,7 @@ module AkamaiApi::CCU::Purge
   # @example Invalidate multiple CPCodes
   #     AkamaiApi::CCU::Purge::Request.new(:invalidate, :cpcode).execute(12345, 12346)
   class Request
-    include HTTParty
-    format :json
-    base_uri 'https://api.ccu.akamai.com/ccu/v2/queues/default'
-    headers 'Content-Type' => 'application/json'
+    @@headers = { "Content-Type" => "application/json" }
 
     attr_reader :type, :action, :domain
 
@@ -72,9 +72,25 @@ module AkamaiApi::CCU::Purge
     # @example Clean multiple resources
     #   request.execute '12345', '12346'
     def execute *items
+      akamai = Akamai::Edgegrid::HTTP.new(address=baseuri.host, port=baseuri.port)
+      akamai.setup_edgegrid(creds)
+      http = Net::HTTP.new(address=baseuri.host, port=baseuri.port)
+      http.use_ssl = true
+
       items = Array.wrap(items.first) if items.length == 1
-      response = self.class.post('/', basic_auth: AkamaiApi.auth, body: request_body(items))
-      parse_response response
+      req = Net::HTTP::Post.new(resource, initheader = @@headers).tap do |pq|
+        if for_ccu_v2?
+          pq.body = request_body items
+        else
+          pq.body = {"objects" => items}.to_json
+        end
+      end
+
+      timestamp = Akamai::Edgegrid::HTTP.eg_timestamp()
+      nonce = Akamai::Edgegrid::HTTP.new_nonce()
+      req['Authorization'] = akamai.make_auth_header(req, timestamp, nonce)
+
+      parse_response http.request(req)
     end
 
     # Request body to send to the API.
@@ -85,11 +101,35 @@ module AkamaiApi::CCU::Purge
     end
 
     private
+    def creds
+      AkamaiApi.auth.tap do |auth|
+        auth.delete(:base_url)
+        auth[:max_body] = 128*1024
+      end
+    end
+
+    def for_ccu_v2?
+      @type == :cpcode || (@type == :arl && @action == :remove)
+    end
+
+    def resource
+      if for_ccu_v2?
+        URI.join(baseuri.to_s, "/ccu/v2/queues/default").to_s
+      else
+        URI.join(baseuri.to_s, "/ccu/v3/#{action}/url/#{domain}").to_s
+      end
+    end
+
+    def baseuri
+      URI(AkamaiApi.auth[:base_url])
+    end
 
     def parse_response response
-      raise ::AkamaiApi::Unauthorized if response.code == 401
-      raise AkamaiApi::CCU::Error.new response.parsed_response unless successful_response? response
-      Response.new response.parsed_response
+      parsed_response = JSON.load(response.body)
+
+      raise ::AkamaiApi::Unauthorized if ["400", 401].include?(response.code)
+      raise AkamaiApi::CCU::Error.new parsed_response unless successful_response? parsed_response
+      Response.new parsed_response
     end
 
     def raise_unrecognized_action bad_action
@@ -117,7 +157,7 @@ module AkamaiApi::CCU::Purge
     end
 
     def successful_response? response
-      (200...300).include? response.parsed_response['httpStatus']
+      (200...300).include? response['httpStatus']
     end
   end
 end

data/lib/akamai_api/cli/ccu/arl.rb

@@ -22,10 +22,6 @@ module AkamaiApi::CLI::CCU
                   :desc => 'Optional argument used to specify the environment. Usually you will not need this option'
     method_option :banner => "foo@foo.com bar@bar.com",
                   :desc => 'Email(s) used to send notification when the purge has been completed'
-    method_option :poll,
-                  :desc => 'whether or not to poll for status',
-                  :type => :boolean,
-                  :default => false
 
     def invalidate(*arls)
       purge_action :invalidate, arls
@@ -34,32 +30,21 @@ module AkamaiApi::CLI::CCU
     no_tasks do
       def purge_action type, arls
         raise 'You should provide at least one valid URL' if arls.blank?
-        load_config
+
+        begin
+          load_config
+        rescue ArgumentError
+          return
+        end
+
         res = AkamaiApi::CCU.purge type, :arl, arls, :domain => options[:domain]
         puts PurgeRenderer.new(res).render
 
-        if options[:poll] == true && res.code == 201
-          poll_status res
-        end
-      rescue AkamaiApi::CCU::Error
+      rescue AkamaiApi::CCU::Error => e
         puts StatusRenderer.new($!).render_error
       rescue AkamaiApi::Unauthorized
         puts 'Your login credentials are invalid.'
       end
     end
-
-    no_commands do 
-      def poll_status purge_response
-        if purge_response.time_to_wait
-          status = AkamaiApi::CCU.status purge_response.uri
-          while status.completed_at.nil?
-            puts StatusRenderer.new(status).render
-            sleep 60
-            status = AkamaiApi::CCU.status purge_response.uri
-          end
-        end
-        puts StatusRenderer.new(status).render
-      end
-    end
   end
 end

data/lib/akamai_api/cli/ccu/purge_renderer.rb

@@ -34,15 +34,12 @@ module AkamaiApi::CLI::CCU
       result = [
         "Purge request successfully submitted:",
         "\t* Result: #{response.code} - #{response.message}",
-        "\t* Purge ID: #{response.purge_id} | Support ID: #{response.support_id}"
+        "\t* Purge ID: #{response.purge_id} | Support ID: #{response.support_id}",
+        "\t* Estimated time: #{response.estimated_time} secs.",
+        "\t* Progress URI: #{response.uri}",
+        "\t* Time to wait before check: #{response.time_to_wait} secs."
       ]
-      if response.time_to_wait
-        result.concat [
-          "\t* Estimated time: #{response.estimated_time} secs.",
-          "\t* Progress URI: #{response.uri}",
-          "\t* Time to wait before check: #{response.time_to_wait} secs.",
-        ]
-      end
+
       result
     end
   end

data/lib/akamai_api/cli/command.rb

@@ -11,12 +11,10 @@ module AkamaiApi::CLI
 
     no_tasks do
       def load_config
+        return if AkamaiApi.auth_ok?
         load_config_from_file
-        load_config_from_env
-        load_config_from_options
         if AkamaiApi.auth_empty?
           render_auth_info
-          exit 1
         end
       end
 
@@ -27,37 +25,24 @@ module AkamaiApi::CLI
       def load_config_from_file
         if File.exists?(config_file)
           AkamaiApi.config.merge! YAML::load_file(config_file).symbolize_keys
-        end
-      end
-
-      def load_config_from_options
-        AkamaiApi.config[:auth].tap do |auth|
-          auth[0] = options.fetch 'username', auth[0]
-          auth[1] = options.fetch 'password', auth[1]
-        end
-      end
-
-      def load_config_from_env
-        AkamaiApi.config[:auth].tap do |auth|
-          auth[0] = ENV.fetch 'AKAMAI_USERNAME', auth[0]
-          auth[1] = ENV.fetch 'AKAMAI_PASSWORD', auth[1]
+        else
+          render_auth_info
+          raise ArgumentError
         end
       end
 
       def render_auth_info
         puts <<-OUTPUT
-No authentication config found. You can specify auth credentials with one of the following methods:"
-
-* Creating a file in your home directory named `.akamai_api.yml` with the following content:"
-  auth:"
-    - my_username"
-    - my_password"
-
-* Using the environment variables AKAMAI_USERNAME and AKAMAI_PASSWORD. E.g:"
-  AKAMAI_USERNAME=my_username AKAMAI_PASSWORD=my_password akamai_api ECCU last_request"
-
-* Passing username and password options from command line. E.g.:"
- akamai_api ECCU last_request -u my_username -p my_password"
+No authentication config found. At the very least, specify auth credentials by creating a file in your home directory named `.akamai_api.yml` with the following content:"
+  auth:
+    - my_username
+    - my_password
+If using "ccu arl invalidate", your CCU api credentials should also be added:
+  openapi:
+    base_url:
+    client_token:
+    client_secret:
+    access_token:
 OUTPUT
       end
     end

data/lib/akamai_api/version.rb

@@ -1,3 +1,3 @@
 module AkamaiApi
-  VERSION = "0.4.1"
+  VERSION = "1.1.0"
 end

data/spec/features/ccu/purge_request_spec.rb

@@ -3,6 +3,8 @@ require 'spec_helper'
 describe 'Given I request to purge an asset' do
   subject { AkamaiApi::CCU }
 
+  let(:estimated_time) { 420 }
+
   shared_examples 'purge helper' do
     let(:method) { "#{action}_#{type}" }
 
@@ -14,7 +16,6 @@ describe 'Given I request to purge an asset' do
 
     it 'raises error when user is not authorized' do
       VCR.use_cassette "akamai_api_ccu_#{type}_#{action}/invalid_credentials" do
-        allow(AkamaiApi).to receive(:auth) { { username: 'foo', password: 'bar' } }
         expect { subject.send(method, items) }.to raise_error AkamaiApi::Unauthorized
       end
     end
@@ -52,7 +53,7 @@ describe 'Given I request to purge an asset' do
 
       it 'returns the estimated time in seconds' do
         VCR.use_cassette "akamai_api_ccu_#{type}_#{action}/single_item" do
-          expect(subject.send(method, items).estimated_time).to eq 420
+          expect(subject.send(method, items).estimated_time).to eq estimated_time
         end
       end
     end
@@ -63,6 +64,8 @@ describe 'Given I request to purge an asset' do
     let(:type) { 'arl' }
     let(:items) { ['http://www.foo.bar/t.txt'] }
 
+    let(:estimated_time) { 5 }
+
     it_should_behave_like 'purge helper'
   end
 

data/spec/lib/akamai_api/ccu/purge/request_spec.rb

@@ -1,18 +1,6 @@
 require 'spec_helper'
 
 describe AkamaiApi::CCU::Purge::Request do
-  it "includes httparty" do
-    expect(subject.class.included_modules).to include HTTParty
-  end
-
-  it "sets a base_uri" do
-    expect(subject.class.base_uri).to eq 'https://api.ccu.akamai.com/ccu/v2/queues/default'
-  end
-
-  it "sets a content type header" do
-    expect(subject.class.headers).to eq 'Content-Type' => 'application/json'
-  end
-
   describe "#action" do
     it "is :remove by default" do
       expect(subject.action).to eq :remove
@@ -59,59 +47,54 @@ describe AkamaiApi::CCU::Purge::Request do
     let(:fake_response) { double code: 201, parsed_response: { 'httpStatus' => 201, 'submissionTime' => 1 } }
     let(:sample_arl) { 'http://www.foo.bar/t.txt' }
 
+    before(:each) do
+      allow_any_instance_of(Net::HTTP).to receive(:request).and_return(double code: 201, body: '{ "httpStatus" : 201}')
+      allow_any_instance_of(Akamai::Edgegrid::HTTP).to receive(:make_auth_header)
+    end
+
     it "executes a post on the base url" do
-      expect(subject.class).to receive :post do |path, args|
-        expect(path).to eq '/'
-        fake_response
-      end
+      expect_any_instance_of(Net::HTTP).to receive(:request).with an_instance_of(Net::HTTP::Post)
       subject.execute sample_arl
     end
 
     it "sets the auth in the post" do
-      allow(AkamaiApi).to receive(:auth) { 'foo' }
-      expect(subject.class).to receive :post do |path, args|
-        expect(args[:basic_auth]).to eq 'foo'
-        fake_response
-      end
+      expect_any_instance_of(Akamai::Edgegrid::HTTP).to receive(:setup_edgegrid).with({:username => 'USERNAME', :password => 'PASSWORD', :max_body=>131072, :client_token => "client_token", :client_secret => "client_secret", :access_token => "access_token"})
       subject.execute sample_arl
     end
 
-    it "accepts a single element" do
-      expect(subject).to receive(:request_body).with([sample_arl])
-      allow(subject.class).to receive(:post) { fake_response }
+    it "sets headers and base uri" do
+      fake_net_http_post = double
+      allow(fake_net_http_post).to receive(:body=)
+      allow(fake_net_http_post).to receive(:[]=)
+      expect(Net::HTTP::Post).to receive(:new) do |base_uri, initheaders|
+        expect(base_uri).to eq "https://some-subdomain.purge.akamaiapis.net/ccu/v2/queues/default"
+        expect(initheaders)
+        fake_net_http_post
+      end
       subject.execute sample_arl
     end
 
-    it "accepts a collection with a single element" do
-      expect(subject).to receive(:request_body).with([sample_arl])
-      allow(subject.class).to receive(:post) { fake_response }
+    it "accepts a single element" do
+      require "json"
+      expect_any_instance_of(Net::HTTP::Post).to receive(:body=).with({type: :arl, action: :remove, domain: :production, objects: [ sample_arl ] }.to_json)
       subject.execute sample_arl
     end
 
     it "accepts a collection" do
-      expect(subject).to receive(:request_body).with(['a', 'b'])
-      allow(subject.class).to receive(:post) { fake_response }
-      subject.execute ['a', 'b']
+      require "json"
+      expect_any_instance_of(Net::HTTP::Post).to receive(:body=).with({type: :arl, action: :remove, domain: :production, objects: ["a", "b"]}.to_json)
+      subject.execute ["a", "b"]
     end
 
     it "works with splatting" do
-      expect(subject).to receive(:request_body).with(['a', 'b'])
-      allow(subject.class).to receive(:post) { fake_response }
-      subject.execute 'a', 'b'
-    end
-
-    it "sets the request body" do
-      expect(subject).to receive(:request_body).with([sample_arl]).and_return 'foo'
-      expect(subject.class).to receive :post do |path, args|
-        expect(args[:body]).to eq 'foo'
-        fake_response
-      end
-      subject.execute sample_arl
+      require "json"
+      expect_any_instance_of(Net::HTTP::Post).to receive(:body=).with({type: :arl, action: :remove, domain: :production, objects: ["a", "b"]}.to_json)
+      subject.execute "a", "b"
     end
 
     it "raises an exception when the response code is 401" do
-      fake_response = double code: 401
-      allow(subject.class).to receive(:post) { fake_response }
+      fake_response = double code: 401, body: '{ "httpStatus" : 401}'
+      allow_any_instance_of(Net::HTTP).to receive(:request) { fake_response }
       expect { subject.execute sample_arl }.to raise_error AkamaiApi::Unauthorized
     end
 
@@ -122,8 +105,8 @@ describe AkamaiApi::CCU::Purge::Request do
     end
 
     it "raises an error when json code in response is not successful" do
-      fake_response = double code: 201, parsed_response: { 'httpStatus' => 403 }
-      allow(subject.class).to receive(:post) { fake_response }
+      fake_response = double code: 403, body: '{ "httpStatus" : 403 }'
+      allow_any_instance_of(Net::HTTP).to receive(:request) { fake_response }
       expect { subject.execute sample_arl }.to raise_error AkamaiApi::CCU::Error
     end
   end

data/spec/lib/akamai_api/ccu_spec.rb

@@ -54,22 +54,4 @@ describe AkamaiApi::CCU do
       end
     end
   end
-
-  describe '#status' do
-    context "when no argument is given" do
-      it "delegates to Status request instance" do
-        expect(AkamaiApi::CCU::Status::Request).to receive(:new).and_return double execute: 'foo'
-        expect(subject.status).to eq 'foo'
-      end
-    end
-
-    context "when a progress uri is passed as argument" do
-      it "delegates to PurgeStatus request instance" do
-        fake_instance = double
-        expect(AkamaiApi::CCU::PurgeStatus::Request).to receive(:new).and_return fake_instance
-        expect(fake_instance).to receive(:execute).with('foo').and_return 'asd'
-        expect(subject.status 'foo').to eq 'asd'
-      end
-    end
-  end
 end

data/spec/spec_helper.rb

@@ -4,7 +4,14 @@ require File.expand_path '../../lib/akamai_api/cli', __FILE__
 begin
   require File.expand_path '../auth.rb', __FILE__
 rescue LoadError
-  AkamaiApi.config[:auth] = ['test_username', 'test_password']
+  AkamaiApi.config[:auth] = ['USERNAME', 'PASSWORD']
+  AkamaiApi.config[:log] = true
+  AkamaiApi.config[:openapi] = {
+    :base_url => "https://some-subdomain.purge.akamaiapis.net",
+    :client_token => "client_token",
+    :client_secret => "client_secret",
+    :access_token => "access_token"
+  }
 end
 require 'savon/mock/spec_helper'
 require 'webmock/rspec'
@@ -16,7 +23,6 @@ VCR.configure do |c|
   c.cassette_library_dir = 'cassettes'
   c.hook_into :webmock
   c.default_cassette_options = {
-    record: :once,
     match_requests_on: [:method, :uri, :body]
   }
   c.configure_rspec_metadata!