fleet-api 0.0.1

data/lib/fleet/request.rb

@@ -0,0 +1,56 @@
+require 'fleet/version'
+
+module Fleet
+  module Request
+
+    private
+
+    [:get, :head, :put, :post, :delete].each do |method|
+      define_method(method) do |path, options={}, headers={}|
+        request(connection, method, path, options, headers)
+      end
+    end
+
+    def request(connection, method, path, options, headers)
+      options ||= {}
+
+      response = connection.send(method) do |request|
+        request.options[:open_timeout] = open_timeout
+        request.options[:timeout] = read_timeout
+        request.headers = {
+          user_agent: user_agent,
+          accept: 'application/json'
+        }.merge(headers)
+
+        request.path = URI.escape(path)
+
+        case method
+        when :delete, :get, :head
+          request.params = options unless options.empty?
+        when :post, :put
+          if options.key?(:querystring)
+            request.params = options[:querystring]
+            request.body = options[:body]
+          else
+            request.body = options unless options.empty?
+          end
+        end
+      end
+
+      response.body
+    rescue Faraday::Error::ConnectionFailed => ex
+      raise Fleet::ConnectionError, ex.message
+    end
+
+    private
+
+    def user_agent
+      ua_chunks = []
+      ua_chunks << "fleet/#{Fleet::VERSION}"
+      ua_chunks << "(#{RUBY_ENGINE}; #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}; #{RUBY_PLATFORM})"
+      ua_chunks << "faraday/#{Faraday::VERSION}"
+      ua_chunks << "(#{adapter})"
+      ua_chunks.join(' ')
+    end
+  end
+end

data/lib/fleet/service_definition.rb

@@ -0,0 +1,63 @@
+require 'digest/sha1'
+
+module Fleet
+  class ServiceDefinition
+
+    attr_reader :name
+
+    def initialize(name, service_def={})
+      @name = name
+      @service_def = service_def
+    end
+
+    def to_unit
+      {
+        'Contents' => unit_body,
+        'Raw' => raw
+      }
+    end
+
+    def to_job
+      {
+        'Name' => name,
+        'UnitHash' => sha1_byte_array
+      }
+    end
+
+    def sha1
+      Digest::SHA1.hexdigest raw
+    end
+
+    private
+
+    def unit_body
+      @service_def.each_with_object({}) do |(heading, section), memo|
+        memo[heading] = section.each_with_object({}) do |(key, value), memo|
+          memo[key] = [value]
+        end
+      end
+    end
+
+    def raw
+      raw_string = ''
+
+      @service_def.each do |heading, section|
+        raw_string += "[#{heading}]\n"
+
+        if section.is_a?(Enumerable)
+          section.each do |key, value|
+            raw_string += "#{key}=#{value}\n"
+          end
+        end
+
+        raw_string += "\n"
+      end
+
+      raw_string.chomp
+    end
+
+    def sha1_byte_array
+      Digest::SHA1.digest(raw).unpack('C20')
+    end
+  end
+end

data/lib/fleet/version.rb

@@ -0,0 +1,3 @@
+module Fleet
+  VERSION = '0.0.1'.freeze unless defined?(Fleet::VERSION)
+end

data/lib/fleet.rb

@@ -0,0 +1,15 @@
+require 'fleet/configuration'
+require 'fleet/client'
+
+module Fleet
+  extend Configuration
+
+  def self.new(options={})
+    Fleet::Client.new(options)
+  end
+
+  def self.configure
+    yield self
+    true
+  end
+end

data/lib/middleware/response/raise_error.rb

@@ -0,0 +1,37 @@
+require 'faraday'
+require 'json'
+require 'fleet/error'
+
+module Middleware
+  module Response
+
+    class RaiseError < Faraday::Response::Middleware
+
+      def on_complete(env)
+        status = env[:status].to_i
+        return unless (400..600).include?(status)
+
+        error = parse_error(env[:body])
+
+        # Find the error class that matches the HTTP status code. Default to
+        # Error if no matching class exists.
+        class_name = Fleet::Error::HTTP_CODE_MAP.fetch(status, 'Error')
+
+        fail Fleet.const_get(class_name).new(
+          error['message'],
+          error['errorCode'],
+          error['cause'])
+      end
+
+      private
+
+      def parse_error(body)
+        JSON.parse(body)
+      rescue StandardError
+        { 'message' => body }
+      end
+    end
+
+    Faraday.register_middleware :response, raise_error: -> { RaiseError }
+  end
+end

data/spec/fleet/client/job_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Fleet::Client::Job do
+
+  subject { Fleet::Client.new }
+
+  let(:response) { double(:response) }
+
+  describe '#list_jobs' do
+
+    before do
+      allow(subject).to receive(:get).and_return(response)
+    end
+
+    it 'GETs the Fleet job key' do
+      opts = { consistent: true, recursive: true, sorted: true }
+      expect(subject).to receive(:get)
+        .with('v2/keys/_coreos.com/fleet/job', opts)
+        .and_return(response)
+
+      subject.list_jobs
+    end
+
+    it 'returns the job response' do
+      expect(subject.list_jobs).to eql(response)
+    end
+  end
+
+  describe '#get_job' do
+
+    let(:service_name) { 'foo.service' }
+
+    before do
+      allow(subject).to receive(:get).and_return(response)
+    end
+
+    it 'GETs the named Fleet job key' do
+      opts = { consistent: true, recursive: true, sorted: false }
+      expect(subject).to receive(:get)
+        .with("v2/keys/_coreos.com/fleet/job/#{service_name}/object", opts)
+        .and_return(response)
+
+      subject.get_job(service_name)
+    end
+
+    it 'returns the job response' do
+      expect(subject.get_job(service_name)).to eql(response)
+    end
+  end
+
+  describe '#create_job' do
+
+    let(:service_name) { 'foo.service' }
+    let(:service_def) { { name: service_name } }
+
+    before do
+      allow(subject).to receive(:put).and_return(response)
+    end
+
+    it 'PUTs the service def to the Fleet job key' do
+      opts = {
+        querystring: { 'prevExist' => false },
+        body: { value: service_def.to_json }
+      }
+
+      expect(subject).to receive(:put)
+        .with("v2/keys/_coreos.com/fleet/job/#{service_name}/object", opts)
+        .and_return(response)
+
+      subject.create_job(service_name, service_def)
+    end
+
+    it 'returns the job response' do
+      expect(subject.create_job(service_name, service_def)).to eql(response)
+    end
+  end
+
+  describe '#delete_job' do
+
+    let(:service_name) { 'foo.service' }
+
+    before do
+      allow(subject).to receive(:delete).and_return(response)
+    end
+
+    it 'DELETEs the named Fleet job key' do
+      opts = { dir: false, recursive: true }
+      expect(subject).to receive(:delete)
+        .with("v2/keys/_coreos.com/fleet/job/#{service_name}", opts)
+        .and_return(response)
+
+      subject.delete_job(service_name)
+    end
+
+    it 'returns the job response' do
+      expect(subject.delete_job(service_name)).to eql(response)
+    end
+  end
+
+  describe '#update_job_target_state' do
+
+    let(:service_name) { 'foo.service' }
+    let(:state) { :foobared }
+
+    before do
+      allow(subject).to receive(:put).and_return(response)
+    end
+
+    it 'PUTs the state to the Fleet job state key' do
+      opts = { value: state }
+
+      expect(subject).to receive(:put)
+        .with("v2/keys/_coreos.com/fleet/job/#{service_name}/target-state", opts)
+        .and_return(response)
+
+      subject.update_job_target_state(service_name, state)
+    end
+
+    it 'returns the job response' do
+      expect(subject.update_job_target_state(service_name, state)).to eql(response)
+    end
+  end
+end

data/spec/fleet/client/state_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Fleet::Client::State do
+
+  subject { Fleet::Client.new }
+
+  let(:response) { double(:response) }
+
+  describe '#list_states' do
+
+    before do
+      allow(subject).to receive(:get).and_return(response)
+    end
+
+    it 'GETs the Fleet state key' do
+      opts = { consistent: true, recursive: true, sorted: false }
+      expect(subject).to receive(:get)
+        .with('v2/keys/_coreos.com/fleet/state', opts)
+        .and_return(response)
+
+      subject.list_states
+    end
+
+    it 'returns the state response' do
+      expect(subject.list_states).to eql(response)
+    end
+  end
+
+  describe '#get_state' do
+
+    let(:service_name) { 'foo.service' }
+
+    before do
+      allow(subject).to receive(:get).and_return(response)
+    end
+
+    it 'GETs the named Fleet state key' do
+      opts = { consistent: true, recursive: true, sorted: false }
+      expect(subject).to receive(:get)
+        .with("v2/keys/_coreos.com/fleet/state/#{service_name}", opts)
+        .and_return(response)
+
+      subject.get_state(service_name)
+    end
+
+    it 'returns the state response' do
+      expect(subject.get_state(service_name)).to eql(response)
+    end
+  end
+end

data/spec/fleet/client/unit_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Fleet::Client::Unit do
+
+  subject { Fleet::Client.new }
+
+  let(:response) { double(:response) }
+
+  describe '#list_units' do
+
+    before do
+      allow(subject).to receive(:get).and_return(response)
+    end
+
+    it 'GETs the Fleet unit key' do
+      expect(subject).to receive(:get)
+        .with("v2/keys/_coreos.com/fleet/unit")
+        .and_return(response)
+
+      subject.list_units
+    end
+
+    it 'returns the job response' do
+      expect(subject.list_units).to eql(response)
+    end
+  end
+
+  describe '#create_unit' do
+
+    let(:sha) { '33ef9ba9029c' }
+    let(:unit_def) { { exec_start: '/bin/bash' } }
+
+    before do
+      allow(subject).to receive(:put).and_return(response)
+    end
+
+    it 'PUTs the unit def to the Fleet unit key' do
+      opts = {
+        querystring: { 'prevExist' => false },
+        body: { value: unit_def.to_json }
+      }
+
+      expect(subject).to receive(:put)
+        .with("v2/keys/_coreos.com/fleet/unit/#{sha}", opts)
+        .and_return(response)
+
+      subject.create_unit(sha, unit_def)
+    end
+
+    it 'returns the job response' do
+      expect(subject.create_unit(sha, unit_def)).to eql(response)
+    end
+  end
+
+  describe '#delete_unit' do
+
+    let(:sha) { '33ef9ba9029c' }
+
+    before do
+      allow(subject).to receive(:delete).and_return(response)
+    end
+
+    it 'DELETEs the named Fleet unit key' do
+      opts = { dir: false, recursive: false }
+      expect(subject).to receive(:delete)
+        .with("v2/keys/_coreos.com/fleet/unit/#{sha}", opts)
+        .and_return(response)
+
+      subject.delete_unit(sha)
+    end
+
+    it 'returns the job response' do
+      expect(subject.delete_unit(sha)).to eql(response)
+    end
+  end
+end

data/spec/fleet/client_spec.rb

@@ -0,0 +1,247 @@
+require 'spec_helper'
+
+require 'fleet/service_definition'
+
+describe Fleet::Client do
+
+  describe '#initialize' do
+
+    after do
+      Fleet.reset
+    end
+
+    Fleet::Configuration::VALID_OPTIONS_KEYS.each do |option|
+      it "inherits default #{option} value from Panamax" do
+        client = Fleet::Client.new
+        expect(client.send(option)).to eql(Fleet.send(option))
+      end
+
+      it "overrides default for #{option} when specified" do
+        client = Fleet::Client.new(option => :foo)
+        expect(client.send(option)).to eql(:foo)
+      end
+    end
+  end
+
+  describe '#load' do
+
+    let(:name) { 'foo.service' }
+    let(:service_def) { { 'Unit' => { 'Description' => 'bar' } } }
+    let(:sd) { Fleet::ServiceDefinition.new(name, service_def) }
+    let(:fleet_state) do
+      { 'node' => { 'value' => '{ "loadState": "loaded" }' } }
+    end
+
+    before do
+      allow(subject).to receive(:create_unit).and_return(nil)
+      allow(subject).to receive(:create_job).and_return(nil)
+      allow(subject).to receive(:update_job_target_state).and_return(nil)
+      allow(subject).to receive(:get_state).and_return(fleet_state)
+      allow(Fleet::ServiceDefinition).to receive(:new).and_return(sd)
+    end
+
+    it 'invokes #create_unit' do
+      expect(subject).to receive(:create_unit)
+        .with(sd.sha1, sd.to_unit)
+
+      subject.load(name, service_def)
+    end
+
+    it 'invokes #create_job' do
+      expect(subject).to receive(:create_job)
+        .with(sd.name, sd.to_job)
+
+      subject.load(name, service_def)
+    end
+
+    it 'invokes #update_job_target_state' do
+      expect(subject).to receive(:update_job_target_state)
+        .with(sd.name, :loaded)
+
+      subject.load(name, service_def)
+    end
+
+    it 'checks the job state' do
+      expect(subject).to receive(:get_state).with(sd.name)
+      subject.load(name, service_def)
+    end
+
+    context 'when #create_unit raises PreconditionFailed' do
+
+      before do
+        allow(subject).to receive(:create_unit)
+          .and_raise(Fleet::PreconditionFailed.new('boom'))
+      end
+
+      it 'does not blow up' do
+        expect { subject.load(name, service_def) }.to_not raise_error
+      end
+    end
+
+    context 'when #create_unit raises something other than PreconditionFailed' do
+
+      before do
+        allow(subject).to receive(:create_unit)
+          .and_raise(Fleet::BadRequest.new('boom'))
+      end
+
+      it 'propagates the error' do
+        expect { subject.load(name, service_def) }.to(raise_error(Fleet::BadRequest))
+      end
+    end
+
+    context 'when #create_job raises PreconditionFailed' do
+
+      before do
+        allow(subject).to receive(:create_job)
+          .and_raise(Fleet::PreconditionFailed.new('boom'))
+      end
+
+      it 'does not blow up' do
+        expect { subject.load(name, service_def) }.to_not raise_error
+      end
+    end
+
+    context 'when #create_job raises something other than PreconditionFailed' do
+
+      before do
+        allow(subject).to receive(:create_job)
+          .and_raise(Fleet::BadRequest.new('boom'))
+      end
+
+      it 'propagates the error' do
+        expect { subject.load(name, service_def) }.to(raise_error(Fleet::BadRequest))
+      end
+    end
+  end
+
+  describe '#start' do
+    let(:service_name) { 'foo.service' }
+
+    before do
+      allow(subject).to receive(:update_job_target_state)
+    end
+
+    it 'invokes #update_job_target_state' do
+      expect(subject).to receive(:update_job_target_state)
+        .with(service_name, :launched)
+
+      subject.start(service_name)
+    end
+  end
+
+  describe '#stop' do
+    let(:service_name) { 'foo.service' }
+
+    let(:fleet_state) do
+      { 'node' => { 'value' => '{ "load_state": "loaded" }' } }
+    end
+
+    before do
+      allow(subject).to receive(:update_job_target_state)
+      allow(subject).to receive(:get_state).and_return(fleet_state)
+    end
+
+    it 'invokes #update_job_target_state' do
+      expect(subject).to receive(:update_job_target_state)
+                         .with(service_name, :loaded)
+
+      subject.stop(service_name)
+    end
+
+    it 'checks the job state' do
+      expect(subject).to receive(:get_state).with(service_name)
+      subject.stop(service_name)
+    end
+  end
+
+  describe '#unload' do
+    let(:service_name) { 'foo.service' }
+
+    let(:fleet_state) do
+      { 'node' => { 'value' => '{ "load_state": "not-found" }' } }
+    end
+
+    before do
+      allow(subject).to receive(:update_job_target_state)
+      allow(subject).to receive(:get_state).and_return(fleet_state)
+    end
+
+    it 'invokes #update_job_target_state' do
+      expect(subject).to receive(:update_job_target_state)
+                         .with(service_name, :inactive)
+
+      subject.unload(service_name)
+    end
+
+    it 'checks the job state' do
+      expect(subject).to receive(:get_state).with(service_name)
+      subject.unload(service_name)
+    end
+
+    context 'when the unload state cannot be achieved' do
+
+      before do
+        allow(subject).to receive(:get_state).and_raise(Fleet::NotFound, 'boom')
+        allow(subject).to receive(:sleep)
+      end
+
+      it 're-checks the state 10 times' do
+        expect(subject).to receive(:get_state).exactly(10).times
+        subject.unload(service_name) rescue nil
+      end
+
+      it 'raises an error' do
+        expect do
+          subject.unload(service_name)
+        end.to raise_error(Fleet::Error)
+      end
+
+    end
+  end
+
+  describe '#destroy' do
+    let(:service_name) { 'foo.service' }
+
+    before do
+      allow(subject).to receive(:delete_job).and_return(nil)
+      allow(subject).to receive(:get_state).and_raise(Fleet::NotFound, 'boom')
+    end
+
+    it 'invokes #delete_job' do
+
+      expect(subject).to receive(:delete_job)
+                         .with(service_name)
+                         .and_return(nil)
+
+      subject.destroy(service_name)
+    end
+
+    it 'checks the job state' do
+      expect(subject).to receive(:get_state).with(service_name)
+      subject.destroy(service_name)
+    end
+  end
+
+  describe '#states' do
+
+    let(:service_name) { 'foo.service' }
+
+    let(:fleet_state) do
+      { 'node' => { 'value' => '{"load": "loaded", "run": "running"}' } }
+    end
+
+    before do
+      allow(subject).to receive(:get_state).and_return(fleet_state)
+    end
+
+    it 'retrieves service state from the fleet client' do
+      expect(subject).to receive(:get_state).with(service_name)
+      subject.states(service_name)
+    end
+
+    it 'returns the state hash w/ normalized keys' do
+      expect(subject.states(service_name)).to eq(load: 'loaded', run: 'running')
+    end
+  end
+end