akamai_ccu 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c8ceea4c0a3db79103b414cf1ce2bbc11f8e3f23
+  data.tar.gz: 3f5f4bd41015eb19c8b52cede5c5b59a935e68be
+SHA512:
+  metadata.gz: c4ea9b531d9555251a929ff94a9b47ac0119f6c7beccc792daf5ef9f63c5bfc3a5c8f879d18fc45913504fcca07c531d0ed6d7b990bfea06621de6647884b63a
+  data.tar.gz: 6c764ef12c97e32febdf45f6f0fc05e886d88624ad71a713445cb059a67f8056c8b6a3870dd6734954cf52910f07fe0013aaedf2e263dc1f8addfabe069ffb81

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.edgerc
+/*.gem

data/.travis.yml

@@ -0,0 +1,7 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.2
+  - 2.3.0
+  - 2.4.0
+before_install: gem install bundler -v 1.15.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in akamai_ccu.gemspec
+gemspec

data/README.md

@@ -0,0 +1,209 @@
+## Table of Contents
+
+* [Scope](#scope)
+* [Motivation](#motivation)
+  * [akamai-edgerid](#akamai-edgerid)
+* [Installation](#installation)
+* [Usage](#usage)
+  * [Configuration](#configuration)
+    * [edgerc](#edgerc)
+    * [txt](#txt)
+  * [Inside your script](#inside-your-script)
+    * [Secret](#secret)
+    * [Invalidating](#invalidating)
+    * [Deleting](#deleting)
+    * [Reuse client](#reuse-client)
+  * [CLI](#cli)
+    * [Help](#help)
+    * [invalidate](#invalidate)
+    * [delete](#delete)
+    * [Overwriting options](#overwriting-options)
+  * [Possible issues](#possible-issues)
+
+## Scope
+This gem is a minimal wrapper of the [Akamai Content Control Utility](https://developer.akamai.com/api/purge/ccu/overview.html) APIs used to purge Edge content by request.  
+The library is compliant with [CCU API V3](https://developer.akamai.com/api/purge/ccu/resources.html), based on the *Fast Purge* utility.
+
+## Motivation
+The gem has two main responsibilities:
+1. sign the request with proper Authorization headers
+2. provide a wrapper around the CCU V3 APIs
+
+### akamai-edgerid
+There's an official gem by Akamai to sign HTTP headers called [akamai-edgegrid](https://github.com/akamai/AkamaiOPEN-edgegrid-ruby).  
+I've opted to go with my own implementation for the following reasons:
+* the official gem is not written in idiomatic ruby
+* Net::HTTP core class is extended, ignoring composition/decoration
+* single responsibility principle is broken
+* i prefer not relying on external dependencies when possible
+
+## Installation
+Add this line to your application's Gemfile:
+```ruby
+gem "akamai_ccu"
+```
+
+And then execute:
+```shell
+bundle
+```
+
+Or install it yourself as:
+```shell
+gem install akamai_ccu
+```
+
+## Usage
+
+### Configuration
+This gem requires you have a valid Akamai Luna Control Center account, enabled to use the CCU APIs.  
+Akamai relies on a credentials file with three secret keys and a dedicated host for API authorization.  
+Detailing how to get this file is out of the scope of this readme, check Akamai's [official documentation](https://developer.akamai.com/introduction/Conf_Client.html) for that.  
+Suffice to say have two main options:
+
+#### edgerc
+You can generate (by facility python scriot or by hand) a hidden file named `.edgerc`:
+```
+[default]
+client_secret = xxx=
+host = akaa-baseurl-xxx-xxx.luna.akamaiapis.net/
+access_token = akab-access-token-xxx-xxx
+client_token = akab-client-token-xxx-xxx
+max-body = 131072
+```
+
+#### txt
+You can download a plain text file directly from Luna Control Center `Manage APIs` page:
+```
+client_secret = xxx=
+
+host = akaa-baseurl-xxx-xxx.luna.akamaiapis.net/
+
+access_token = akab-access-token-xxx-xxx
+
+client_token = akab-client-token-xxx-xxx
+```
+
+### Inside your script
+You can obviously use the gem directly inside your Ruby's script:
+
+#### Secret
+Once you've got your tokens file, you can instantiate the secret object aimed to generate the authorization header:
+```ruby
+require "akamai_ccu"
+
+# by .edgerc
+secret = AkamaiCCU::Secret.by_edgerc("./.edgerc") # default to current working directory
+
+# by txt file
+secret = AkamaiCCU::Secret.by_txt("./tokens.txt")
+
+# by specifying arguments
+secret = AkamaiCCU::Secret.new(client_secret: "xxx=", host: "akaa-baseurl-xxx-xxx.luna.akamaiapis.net/", access_token: "akab-access-token-xxx-xxx", client_token: "akab-client-token-xxx-xxx", max_body: 131072)
+```
+
+#### Invalidating
+The CCU V3 APIs allow for invalidating the contents by URL or content provider (CP) code:
+```ruby
+# invalidating resources on staging by url
+AkamaiCCU::Wrapper.invalidate_by_url(%w[https://akaa-baseurl-xxx-xxx.luna.akamaiapis.net/index.html], secret)
+
+# invalidating resources on production (mind the "!") by CP code
+AkamaiCCU::Wrapper.invalidate_by_cpcode!([12345, 98765], secret)
+```
+
+#### Deleting
+You can also delete the contents by URL or CP code, just be aware of the consequences:
+```ruby
+# deleting resources on staging by CP code
+AkamaiCCU::Wrapper.delete_by_cpcode([12345, 98765], secret)
+
+# deleting resources on production (mind the "!") by url
+AkamaiCCU::Wrapper.delete_by_url!(%w[https://akaa-baseurl-xxx-xxx.luna.akamaiapis.net/*.js], secret)
+```
+
+#### Reuse client
+By default `Wrapper` class methods create a brand new Net::HTTP client on each call.  
+If this is an issue for you, you can rely on standard instance creation and just change the `endpoint` collaborator to switch API:
+```ruby
+wrapper = AkamaiCCU::Wrapper.new(secret: secret, endpoint: AkamaiCCU::Endpoint.by_name("invalidate_by_url"))
+wrapper.call(%w[https://akaa-baseurl-xxx-xxx.luna.akamaiapis.net/*.css])
+
+# switch to deleting on production
+wrapper.api = AkamaiCCU::Endpoint.by_name("delete_by_cpcode!")
+wrapper.call([12345, 98765])
+```
+
+#### Response
+The Net::HTTP response is wrapped by an utility struct:
+```ruby
+res = AkamaiCCU::Wrapper.invalidate_by_cpcode([12345, 98765], secret)
+puts res 
+# status=201; detail=Request accepted; purge_id=e535071c-26b2-11e7-94d7-276f2f54d938; support_id=17PY1492793544958045-219026624; copletion_at=20170620T11:19:16+0000
+```
+
+### CLI
+You can use the CLI by:
+
+#### Help
+Calling the help for the specific action:
+```shell
+invalidate -h
+Usage: invalidate --edgerc=./.edgerc --production --cp="12345, 98765"
+    -e, --edgerc=EDGERC              Load secret by .edgerc file
+    -t, --txt=TXT                    Load secret by TXT file
+    -c, --cp=CP                      Specify contents by provider (CP) codes
+    -u, --url=URL                    Specify contents by URLs
+        --headers=HEADERS            Specify HTTP headers to sign
+    -p, --production                 Purge on production network
+    -h, --help                       Prints this help
+```
+
+#### invalidate
+You can request for contents invalidation by calling:
+```shell
+invalidate --edgerc=~/.edgerc \ 
+           --url="https://akaa-baseurl-xxx-xxx.luna.akamaiapis.net/*.css,https://akaa-baseurl-xxx-xxx.luna.akamaiapis.net/*.js" \
+           --production
+```
+
+#### delete
+You can request for contents deletion by calling:
+```shell
+delete --txt=~/tokens.txt \ 
+       --cp=12345,98765 \
+       --headers=Accept,Content-Length
+```
+
+#### Overwriting options
+The CLI does allow only one option to specify the secret file and the content objects.  
+If multiple options for the same scope are provided, the program runs by giving precedence to:
+
+##### Secret file
+The `edgerc` option has always precedence over the `txt` one:
+```shell
+# will load secret from ~/.edgerc
+invalidate --txt=~/tokens.txt \
+           --edgerc=~/.edgerc \
+           --cp=12345,98765
+```
+
+##### Content objects
+The `cp` option has always precedence over the `url` one:
+```shell
+# will invalidate by CP code
+invalidate --txt=~/tokens.txt \
+           --url="https://akaa-baseurl-xxx-xxx.luna.akamaiapis.net/*.css,https://akaa-baseurl-xxx-xxx.luna.akamaiapis.net/*.js" \
+           --cp=12345,98765
+```
+
+### Possible Issues
+It happens you can get a `bad request` response by Akamai like this:
+```shell
+status=400; title=Bad request; detail=Invalid timestamp; request_id=2ce206fd; method=POST; requested_at=2017-06-21T12:33:10Z
+```
+
+This happens since Akamai APIs only tolerate a clock skew of at most 30 seconds to defend against certain network attacks (described [here](https://community.akamai.com/docs/DOC-1336)).  
+In order to fix this annoying issue please do synchronize you server clock by:
+* `NTP` if you are lucky to be on a UX server
+* `manually` versus an atomic clock site (check Internet) by using your workstation GUI

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs << "spec"
+  t.libs << "lib"
+  t.test_files = FileList["spec/**/*_spec.rb"]
+end
+
+task :default => :spec

data/akamai_ccu.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "akamai_ccu/version"
+
+Gem::Specification.new do |s|
+  s.name = "akamai_ccu"
+  s.version = AkamaiCCU::VERSION
+  s.authors = ["costajob"]
+  s.email = ["costajob@gmail.com"]
+  s.summary = "Minimal high performant wrapper around Akamai CCU APIs"
+  s.homepage = "https://github.com/costajob/akamai_ccu"
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec|test|s|features)/}) }
+  s.bindir = "bin"
+  s.executables = %w[invalidate delete]
+  s.require_paths = ["lib"]
+  s.license = "MIT"
+  s.required_ruby_version = ">= 2.2.2"
+
+  s.add_development_dependency "bundler", "~> 1.15"
+  s.add_development_dependency "rake", "~> 10.0"
+  s.add_development_dependency "minitest", "~> 5.0"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "akamai_ccu"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/delete

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "akamai_ccu"
+
+cli = AkamaiCCU::CLI.new(args: ARGV.clone, action: AkamaiCCU::Endpoint::Action::DELETE)
+cli.call

data/bin/invalidate

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "akamai_ccu"
+
+cli = AkamaiCCU::CLI.new(args: ARGV.clone, action: AkamaiCCU::Endpoint::Action::INVALIDATE)
+cli.call

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/akamai_ccu/cli.rb

@@ -0,0 +1,75 @@
+require "optparse"
+require "akamai_ccu/wrapper"
+
+module AkamaiCCU
+  class CLI
+    attr_reader :network, :action
+
+    def initialize(args:, action:, io: STDOUT, wrapper_klass: Wrapper, secret_klass: Secret, endpoint_klass: Endpoint)
+      @args = args
+      @action = action
+      @io = io
+      @wrapper_klass = wrapper_klass
+      @secret_klass = secret_klass
+      @endpoint_klass = endpoint_klass
+      @network = Endpoint::Network::STAGING
+    end
+
+    def call
+      parser.parse!(@args)
+      return @io.puts(%q{Specify contents to purge either by cp codes or by urls}) unless @objects
+      return @io.puts(%q{Specify path to the secret file either by edgerc or by txt}) unless @secret
+      wrapper = @wrapper_klass.new(secret: secret, endpoint: endpoint, headers: Array(@headers))
+      @io.puts wrapper.call(@objects)
+    end
+
+    private def secret
+      return @secret_klass.by_txt(name: @secret) if File.extname(@secret) == ".txt"
+      @secret_klass.by_edgerc(name: @secret)
+    end
+
+    private def endpoint
+      @endpoint_klass.new(network, action, mode) 
+    end
+
+    private def mode
+      return Endpoint::Mode::CPCODE if @objects.all? { |o| o.is_a?(Integer) } 
+      Endpoint::Mode::URL
+    end
+
+    private def parser
+      OptionParser.new do |opts|
+        opts.banner = %Q{Usage: #{@action} --edgerc=./.edgerc --production --cp="12345, 98765"}
+
+        opts.on("-eEDGERC", "--edgerc=EDGERC", "Load secret by .edgerc file") do |secret|
+          @secret = secret
+        end
+
+        opts.on("-tTXT", "--txt=TXT", "Load secret by TXT file") do |secret|
+          @secret = secret
+        end
+
+        opts.on("-cCP", "--cp=CP", "Specify contents by provider (CP) codes") do |objects|
+          @objects = objects.split(",").map(&:strip).map(&:to_i)
+        end
+
+        opts.on("-uURL", "--url=URL", "Specify contents by URLs") do |objects|
+          @objects = objects.split(",").map(&:strip)
+        end
+
+        opts.on("--headers=HEADERS", "Specify HTTP headers to sign") do |headers|
+          @headers = headers.split(",").map(&:strip)
+        end
+
+        opts.on("-p", "--production", "Purge on production network") do |prod|
+          @network = Endpoint::Network::PRODUCTION
+        end
+
+        opts.on("-h", "--help", "Prints this help") do
+          @io.puts opts
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/akamai_ccu/client.rb

@@ -0,0 +1,34 @@
+require "net/http"
+require "openssl"
+
+module AkamaiCCU
+  class Client
+    attr_reader :net_klass, :host
+
+    def initialize(host:, net_klass: Net::HTTP)
+      @host = host
+      @net_klass = net_klass
+    end
+
+    def call(path: "/", method: POST, initheader: JSON_HEADER)
+      request(path, method, initheader)
+      yield @request if block_given?
+      Thread.new { http.request(@request) }.value
+    end
+
+    private def base_uri
+      @base_uri ||= URI("#{SSL}://#{host}")
+    end
+
+    private def http
+      @http ||= @net_klass.new(base_uri.host, base_uri.port).tap do |http|
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+    end
+
+    private def request(path, klass = GET, initheader = nil)
+      @request ||= @net_klass.const_get(klass).new(base_uri.merge(path).to_s, initheader)
+    end
+  end
+end

data/lib/akamai_ccu/endpoint.rb

@@ -0,0 +1,63 @@
+module AkamaiCCU
+  class Endpoint
+    BASE_PATH = "/ccu/v3"
+    SHEBANG = "!"
+
+    module Network
+      %w[staging production].each do |network|
+        const_set(network.upcase, network)
+      end
+    end
+
+    module Action
+      %w[invalidate delete].each do |action|
+        const_set("#{action}".upcase, action)
+      end
+    end
+
+    module Mode
+      %w[url cpcode].each do |mode|
+        const_set("#{mode}".upcase, mode)
+      end
+    end
+
+    def self.by_constants(network_const, action_const, mode_const)
+      network = Network.const_get(network_const)
+      action = Action.const_get(action_const)
+      mode = Mode.const_get(mode_const)
+      new(network, action, mode)
+    end
+
+    def self.by_name(name)
+      network = name.delete!(SHEBANG) ? Network::PRODUCTION : Network::STAGING
+      tokens = name.split("_")
+      tokens.delete("by")
+      action, mode = tokens
+      new(network, action, mode)
+    end
+
+    attr_reader :network, :action, :mode
+
+    def initialize(network, action, mode)
+      @network = network
+      @action = action
+      @mode = mode
+    end
+
+    def to_s
+      "#{@action}_by_#{@mode}#{shebang}"
+    end
+
+    def path
+      File.join(BASE_PATH, @action, @mode, @network)
+    end
+
+    private def production?
+      @network == Network::PRODUCTION
+    end
+
+    private def shebang
+      SHEBANG if production?
+    end
+  end
+end

data/lib/akamai_ccu/response.rb

@@ -0,0 +1,86 @@
+require "time"
+
+module AkamaiCCU
+  class Response
+    BAD_STATUS = 400
+
+    def self.factory(body)
+      response = new(body)
+      case response
+      when ->(res) { res.successful? }
+        Ack.new(body)
+      else
+        Error.new(body)
+      end
+    end
+
+    attr_reader :body, :status, :detail
+
+    def initialize(body = {})
+      @body = parse(body)
+      @status = @body.fetch("httpStatus") { @body.fetch("status", BAD_STATUS) }
+      @detail = @body["detail"]
+    end
+
+    def successful?
+      (@status.to_i / 100) == 2
+    end
+
+    private def parse(body)
+      return body if body.is_a? Hash
+      JSON.parse(body)
+    end
+  end
+
+  class Error < Response
+    attr_reader :type, :title, :request_id, :instance, :method, :server_ip, :client_ip
+
+    def initialize(body)
+      super(body)
+      @type = @body["type"]
+      @title = @body["title"]
+      @request_id = @body["requestId"]
+      @instance = @body["instance"]
+      @method = @body["method"]
+      @serverIp = @body["serverIp"]
+      @clientIp = @body["clientIp"]
+      @requested_at = @body["requestTime"]
+    end
+
+    def requested_at
+      return nil unless @requested_at
+      Time.parse(@requested_at)
+    end
+
+    def to_s
+      %W[status=#{@status}].tap do |a|
+        a << "title=#{@title}" if @title
+        a << "detail=#{@detail}" if @detail
+        a << "request_id=#{@request_id}" if @request_id
+        a << "method=#{@method}" if @method
+        a << "requested_at=#{@requested_at}" if @requested_at
+      end.join("; ")
+    end
+  end
+
+  class Ack < Response
+    attr_reader :purge_id, :estimated_secs, :support_id, :completion_at
+
+    def initialize(body, time = Time.now)
+      super(body)
+      @purge_id = @body["purgeId"]
+      @estimated_secs = @body["estimatedSeconds"]
+      @support_id = @body["supportId"]
+      @completion_at = time + @estimated_secs.to_i
+    end
+
+    def to_s
+      %W[status=#{@status}].tap do |a|
+        a << "detail=#{@detail}" if @detail
+        a << "purge_id=#{@purge_id}" if @purge_id
+        a << "support_id=#{@support_id}" if @support_id
+        a << "copletion_at=#{AkamaiCCU.format_utc(@completion_at)}" if @completion_at
+      end.join("; ")
+    end
+  end
+end

data/lib/akamai_ccu/secret.rb

@@ -0,0 +1,61 @@
+require "uri"
+require "securerandom"
+
+module AkamaiCCU
+  class Secret
+    DIGEST = "EG1-HMAC-SHA256"
+    EQUALITY = " = "
+
+    class << self
+      private def factory(opts, time)
+        new(client_secret: opts.fetch("client_secret"), host: opts.fetch("host"), access_token: opts.fetch("access_token"), client_token: opts.fetch("client_token"), max_body: opts.fetch("max-body", 2048), time: time)
+      end
+
+      def by_txt(name:, time: Time.now)
+        return unless File.exist?(name)
+        data = File.readlines(name).map(&:strip).reject(&:empty?).map do |entry| 
+          entry.split(EQUALITY)
+        end
+        factory(Hash[data], time)
+      end
+
+      def by_edgerc(name: ".edgerc", time: Time.now)
+        return unless File.exist?(name)
+        data = File.readlines(name).map(&:strip)
+        data.shift
+        data.map! { |entry| entry.split(EQUALITY) }
+        factory(Hash[data], time)
+      end
+    end
+
+    attr_reader :host, :max_body
+
+    def initialize(client_secret:, host:, access_token:, client_token:, max_body: 2048, nonce: SecureRandom.uuid, time: Time.now)
+      @client_secret = client_secret
+      @host = URI(host)
+      @access_token = access_token
+      @client_token = client_token
+      @max_body = max_body.to_i
+      @nonce = nonce
+      @timestamp = AkamaiCCU.format_utc(time) 
+    end
+
+    def touch
+      @timestamp = AkamaiCCU.format_utc(Time.now)
+    end
+
+    def signed_key
+      AkamaiCCU.sign_HMAC(key: @client_secret, data: @timestamp)
+    end
+
+    def auth_header
+      DIGEST.dup.tap do |header|
+        header << " "
+        header << "client_token=#{@client_token};"
+        header << "access_token=#{@access_token};"
+        header << "timestamp=#{@timestamp};"
+        header << "nonce=#{@nonce};"
+      end
+    end
+  end
+end

data/lib/akamai_ccu/signer.rb

@@ -0,0 +1,73 @@
+require "forwardable"
+require "uri"
+require "akamai_ccu/secret"
+
+module AkamaiCCU
+  class Signer
+    extend Forwardable
+
+    POST = "POST"
+    TAB = "\t"
+    HEADER_NAME = "signature"
+    HEADER_KEY = "Authorization"
+
+    def_delegators :@request, :body, :request_body_permitted?, :path, :method
+    def_delegators :@secret, :max_body, :auth_header, :signed_key
+
+    attr_reader :request
+
+    def initialize(request, secret = nil, headers = [])
+      @request = request
+      @secret = secret
+      @headers = Array(headers)
+      @url = URI(path)
+    end
+
+    def call!
+      return unless @secret
+      @request[HEADER_KEY] = signed_headers
+    end
+
+    private def canonical_headers
+      @headers.map do |header|
+        next unless @request.key?(header)
+        value = @request[header].strip.gsub(/\s+/, " ")
+        "#{header.downcase}:#{value}"
+      end.compact
+    end
+
+    private def body?
+      body && request_body_permitted?
+    end
+
+    private def signed_body
+      return "" unless body?
+      truncated = body[0...max_body]
+      AkamaiCCU.sign(truncated)
+    end
+
+    private def signature_data
+      @signature_data ||= [].tap do |data|
+        data << method
+        data << @url.scheme
+        data << @request.fetch("host") { @url.host }
+        data << @url.request_uri
+        data << canonical_headers.join(TAB)
+        data << signed_body
+        data << auth_header
+      end
+    end
+
+    private def signature
+      AkamaiCCU.sign_HMAC(key: signed_key, data: signature_data.join(TAB))
+    end
+
+    def signed_header
+      "#{HEADER_NAME}=#{signature}"
+    end
+
+    private def signed_headers
+      @signed_headers ||= auth_header << signed_header
+    end
+  end
+end

data/lib/akamai_ccu/version.rb

@@ -0,0 +1,3 @@
+module AkamaiCCU
+  VERSION = "1.1.1"
+end

data/lib/akamai_ccu/wrapper.rb

@@ -0,0 +1,49 @@
+require "akamai_ccu/client"
+require "akamai_ccu/endpoint"
+require "akamai_ccu/signer"
+require "akamai_ccu/response"
+
+module AkamaiCCU
+  class Wrapper
+    class << self
+      Endpoint::Network.constants.each do |network|
+        Endpoint::Action.constants.each do |action|
+          Endpoint::Mode.constants.each do |mode|
+            endpoint = Endpoint.by_constants(network, action, mode)
+            define_method(endpoint.to_s) do |objects = [], secret = nil, headers = [], &block|
+              wrapper = new(secret: secret, endpoint: endpoint, headers: headers)
+              block.call(wrapper) if block
+              wrapper.call(objects)
+            end
+          end
+        end
+      end
+    end
+
+    attr_accessor :endpoint, :client_klass, :signer_klass, :response_klass
+
+    def initialize(secret:, endpoint:, headers: [],
+                   client_klass: Client, signer_klass: Signer, response_klass: Response)
+      @secret = secret
+      @endpoint = endpoint
+      @client_klass = client_klass
+      @signer_klass = signer_klass
+      @response_klass = response_klass
+      @headers = headers
+    end
+
+    def call(objects = [])
+      return if objects.empty?
+      res = client.call(path: @endpoint.path) do |request|
+        request.body = { objects: objects }.to_json
+        @secret.touch
+        @signer_klass.new(request, @secret, @headers).call!
+      end
+      response_klass.factory(res.body)
+    end
+
+    private def client
+      @client ||= @client_klass.new(host: @secret.host)
+    end
+  end
+end

data/lib/akamai_ccu.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+
+require "base64"
+require "json"
+require "openssl"
+require "akamai_ccu/version"
+require "akamai_ccu/wrapper"
+require "akamai_ccu/cli"
+
+module AkamaiCCU
+  extend self
+
+  GET = :Get
+  POST = :Post
+  SSL = "https"
+  JSON_HEADER = { "Content-Type" => "application/json" }
+
+  def format_utc(time)
+    time.utc.strftime("%Y%m%dT%H:%M:%S+0000")
+  end
+
+  def sign(data)
+    digest = OpenSSL::Digest::SHA256.new.digest(data)
+    Base64.encode64(digest).strip
+  end
+
+  def sign_HMAC(key:, data:)
+    digest = OpenSSL::HMAC.digest(OpenSSL::Digest::SHA256.new, key, data)
+    Base64.encode64(digest).strip
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: akamai_ccu
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- costajob
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email:
+- costajob@gmail.com
+executables:
+- invalidate
+- delete
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- akamai_ccu.gemspec
+- bin/console
+- bin/delete
+- bin/invalidate
+- bin/setup
+- lib/akamai_ccu.rb
+- lib/akamai_ccu/cli.rb
+- lib/akamai_ccu/client.rb
+- lib/akamai_ccu/endpoint.rb
+- lib/akamai_ccu/response.rb
+- lib/akamai_ccu/secret.rb
+- lib/akamai_ccu/signer.rb
+- lib/akamai_ccu/version.rb
+- lib/akamai_ccu/wrapper.rb
+homepage: https://github.com/costajob/akamai_ccu
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Minimal high performant wrapper around Akamai CCU APIs
+test_files: []