fleet-api 0.9.0 → 1.0.0

data/lib/fleet/service_definition.rb

@@ -1,56 +1,39 @@
-require 'digest/sha1'
-
 module Fleet
   class ServiceDefinition
 
-    attr_reader :name
-
-    def initialize(name, service_def={})
-      @name = name
+    def initialize(service_def={})
       @service_def = service_def
     end
 
-    def to_unit
-      { 'Raw' => raw }
-    end
-
-    def to_job
+    def to_unit(name)
       {
-        'Name' => name,
-        'UnitHash' => sha1_byte_array
+        'name' => name,
+        'options' => options
       }
     end
 
-    def sha1
-      Digest::SHA1.hexdigest raw
-    end
-
     private
 
-    def raw
-      raw_string = ''
-
-      @service_def.each do |heading, section|
-        raw_string += "[#{heading}]\n"
-
-        if section.is_a?(Enumerable)
-          section.each do |key, value|
-            if value.is_a?(Enumerable)
-              value.each { |command| raw_string += "#{key}=#{command}\n" }
-            else
-              raw_string += "#{key}=#{value}\n"
+    def options
+      @service_def.each_with_object([]) do |(section, options), h|
+        options.each do |name, value|
+          if value.is_a?(Enumerable)
+            value.each do |v|
+              h << {
+              'section' => section,
+              'name' => name,
+              'value' => v
+              }
             end
+          else
+            h << {
+              'section' => section,
+              'name' => name,
+              'value' => value
+            }
           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

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

data/spec/fleet/client/machines_spec.rb

@@ -13,9 +13,8 @@ describe Fleet::Client::Machines do
     end
 
     it 'GETs the Fleet machines key' do
-      opts = { consistent: true, recursive: true, sorted: true }
       expect(subject).to receive(:get)
-        .with('v2/keys/_coreos.com/fleet/machines', opts)
+        .with('fleet/v1/machines', nil)
         .and_return(response)
 
       subject.list_machines

data/spec/fleet/client/state_spec.rb

@@ -12,10 +12,9 @@ describe Fleet::Client::State do
       allow(subject).to receive(:get).and_return(response)
     end
 
-    it 'GETs the Fleet state key' do
-      opts = { consistent: true, recursive: true, sorted: false }
+    it 'GETs the state resource' do
       expect(subject).to receive(:get)
-        .with('v2/keys/_coreos.com/fleet/state', opts)
+        .with('fleet/v1/state', {})
         .and_return(response)
 
       subject.list_states
@@ -25,26 +24,4 @@ describe Fleet::Client::State 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

@@ -12,65 +12,80 @@ describe Fleet::Client::Unit do
       allow(subject).to receive(:get).and_return(response)
     end
 
-    it 'GETs the Fleet unit key' do
+    it 'GETs all Fleet units' do
       expect(subject).to receive(:get)
-        .with("v2/keys/_coreos.com/fleet/unit")
+        .with("fleet/v1/units")
         .and_return(response)
 
       subject.list_units
     end
 
-    it 'returns the job response' do
+    it 'returns the unit response' do
       expect(subject.list_units).to eql(response)
     end
   end
 
+  describe '#get_unit' do
+
+    let(:name) { 'foo.service' }
+
+    before do
+      allow(subject).to receive(:get).and_return(response)
+    end
+
+    it 'GETs the Fleet unit' do
+      expect(subject).to receive(:get)
+        .with("fleet/v1/units/#{name}")
+        .and_return(response)
+
+      subject.get_unit(name)
+    end
+
+    it 'returns the unit response' do
+      expect(subject.get_unit(name)).to eql(response)
+    end
+  end
+
   describe '#create_unit' do
 
-    let(:sha) { '33ef9ba9029c' }
-    let(:unit_def) { { exec_start: '/bin/bash' } }
+    let(:name) { 'foo.service' }
+    let(:options) { { 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)
+        .with("fleet/v1/units/#{name}", options)
         .and_return(response)
 
-      subject.create_unit(sha, unit_def)
+      subject.create_unit(name, options)
     end
 
-    it 'returns the job response' do
-      expect(subject.create_unit(sha, unit_def)).to eql(response)
+    it 'returns the unit response' do
+      expect(subject.create_unit(name, options)).to eql(response)
     end
   end
 
   describe '#delete_unit' do
 
-    let(:sha) { '33ef9ba9029c' }
+    let(:name) { 'foo.service' }
 
     before do
       allow(subject).to receive(:delete).and_return(response)
     end
 
-    it 'DELETEs the named Fleet unit key' do
-      opts = { dir: false, recursive: false }
+    it 'DELETEs the named Fleet unit' do
       expect(subject).to receive(:delete)
-        .with("v2/keys/_coreos.com/fleet/unit/#{sha}", opts)
+        .with("fleet/v1/units/#{name}")
         .and_return(response)
 
-      subject.delete_unit(sha)
+      subject.delete_unit(name)
     end
 
     it 'returns the job response' do
-      expect(subject.delete_unit(sha)).to eql(response)
+      expect(subject.delete_unit(name)).to eql(response)
     end
   end
 end

data/spec/fleet/client_spec.rb

@@ -27,28 +27,24 @@ describe Fleet::Client do
 
     let(:machine_list) do
       {
-        'node' => {
-          'nodes' => [
-            {
-              'nodes' => [
-                { 'value' => '{"ID":"123","PublicIP":"1.1.1.1"}' }
-              ]
-            }
-          ]
-        }
+        'machines' => [
+          { 'id' => '123', 'primaryIP' => '1.1.1.1' }
+        ]
       }
     end
 
     let(:state_list) do
       {
-        'node' => {
-          'nodes' => [
-            {
-              'key' => '/_coreos.com/fleet/state/foo.service',
-              'value' => '{"loadState":"a","activeState":"b","subState":"c","machineState":{"ID":"123"}}'
-            }
-          ]
-        }
+        'states' => [
+          {
+            'hash' => 'abc123',
+            'machineID' => '123',
+            'name' => 'foo.service',
+            'systemdActiveState' => 'b',
+            'systemdLoadState' => 'a',
+            'systemdSubState' => 'c'
+          }
+        ]
       }
     end
 
@@ -69,8 +65,8 @@ describe Fleet::Client do
 
     it 'returns the list of units' do
       expected = [{
-        name: 'foo.service', 
-        load_state: 'a', 
+        name: 'foo.service',
+        load_state: 'a',
         active_state: 'b',
         sub_state: 'c',
         machine_id: '123',
@@ -85,51 +81,25 @@ describe Fleet::Client do
 
     let(:name) { 'foo.service' }
     let(:service_def) { { 'Unit' => { 'Description' => 'bar' } } }
-    let(:sd) { Fleet::ServiceDefinition.new(name, service_def) }
+    let(:sd) { Fleet::ServiceDefinition.new(service_def) }
+    let(:response) { double(:response) }
 
     context 'when a service definition is provided' do
       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(:create_unit).and_return(response)
         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)
+          .with(name, sd.to_unit(name))
 
         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
-
-      context 'when sync=true is set' do
-
-        let(:fleet_state) do
-          { 'node' => { 'value' => '{ "loadState": "loaded" }' } }
-        end
-
-        before do
-          allow(subject).to receive(:get_state).and_return(fleet_state)
-        end
-
-        it 'checks the job state' do
-          expect(subject).to receive(:get_state).with(sd.name)
-          subject.load(name, service_def, sync=true)
-        end
+      it 'returns the #create_unit response' do
+        r = subject.load(name, service_def)
+        expect(r).to eq response
       end
 
       context 'when #create_unit raises PreconditionFailed' do
@@ -155,36 +125,12 @@ describe Fleet::Client 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
 
     context 'when no service definition is provided' do
 
       before do
-        allow(subject).to receive(:update_job_target_state).and_return(nil)
+        allow(subject).to receive(:update_unit).and_return(response)
       end
 
       it 'does NOT invoke #create_unit' do
@@ -192,33 +138,12 @@ describe Fleet::Client do
         subject.load(name)
       end
 
-      it 'does NOT invoke #create_job' do
-        expect(subject).to_not receive(:create_job)
-        subject.load(name)
-      end
-
-      it 'invokes #update_job_target_state' do
-        expect(subject).to receive(:update_job_target_state)
-          .with(sd.name, :loaded)
+      it 'invokes #update' do
+        expect(subject).to receive(:update_unit)
+          .with(name, { 'desiredState' => 'loaded', 'name' => name })
 
         subject.load(name)
       end
-
-      context 'when sync=true is set' do
-
-        let(:fleet_state) do
-          { 'node' => { 'value' => '{ "loadState": "loaded" }' } }
-        end
-
-        before do
-          allow(subject).to receive(:get_state).and_return(fleet_state)
-        end
-
-        it 'checks the job state' do
-          expect(subject).to receive(:get_state).with(sd.name)
-          subject.load(name, nil, sync=true)
-        end
-      end
     end
 
     context 'when the supplied name is invalid' do
@@ -235,12 +160,12 @@ describe Fleet::Client do
     let(:service_name) { 'foo.service' }
 
     before do
-      allow(subject).to receive(:update_job_target_state)
+      allow(subject).to receive(:update_unit).and_return(nil)
     end
 
-    it 'invokes #update_job_target_state' do
-      expect(subject).to receive(:update_job_target_state)
-        .with(service_name, :launched)
+    it 'invokes #update_unit' do
+      expect(subject).to receive(:update_unit)
+        .with(service_name, { 'desiredState' => 'launched', 'name' => service_name })
 
       subject.start(service_name)
     end
@@ -250,111 +175,47 @@ describe Fleet::Client do
     let(:service_name) { 'foo.service' }
 
     before do
-      allow(subject).to receive(:update_job_target_state)
+      allow(subject).to receive(:update_unit).and_return(nil)
     end
 
-    it 'invokes #update_job_target_state' do
-      expect(subject).to receive(:update_job_target_state)
-                         .with(service_name, :loaded)
+    it 'invokes #update_unit' do
+      expect(subject).to receive(:update_unit)
+        .with(service_name, { 'desiredState' => 'loaded', 'name' => service_name })
 
       subject.stop(service_name)
     end
-
-    context 'when sync=true is set' do
-
-      let(:fleet_state) do
-        { 'node' => { 'value' => '{ "load_state": "loaded" }' } }
-      end
-
-      before do
-        allow(subject).to receive(:get_state).and_return(fleet_state)
-      end
-
-      it 'checks the job state' do
-        expect(subject).to receive(:get_state).with(service_name)
-        subject.stop(service_name, sync=true)
-      end
-    end
   end
 
   describe '#unload' do
     let(:service_name) { 'foo.service' }
 
     before do
-      allow(subject).to receive(:update_job_target_state)
+      allow(subject).to receive(:update_unit).and_return(nil)
     end
 
-    it 'invokes #update_job_target_state' do
-      expect(subject).to receive(:update_job_target_state)
-                         .with(service_name, :inactive)
+    it 'invokes #update_unit' do
+      expect(subject).to receive(:update_unit)
+        .with(service_name, { 'desiredState' => 'inactive', 'name' => service_name })
 
       subject.unload(service_name)
     end
-
-    context 'when sync=true is set' do
-
-      before do
-        allow(subject).to receive(:get_state).and_raise(Fleet::NotFound, 'boom')
-      end
-
-      it 'checks the job state' do
-        expect(subject).to receive(:get_state).with(service_name)
-        subject.unload(service_name, sync=true)
-      end
-
-      context 'when the unload state cannot be achieved' do
-
-        let(:fleet_state) do
-          { 'node' => { 'value' => '{ "load_state": "loaded" }' } }
-        end
-
-        before do
-          allow(subject).to receive(:get_state).and_return(fleet_state)
-          allow(subject).to receive(:sleep)
-        end
-
-        it 're-checks the state 20 times' do
-          expect(subject).to receive(:get_state).exactly(20).times
-          subject.unload(service_name, sync=true) rescue nil
-        end
-
-        it 'raises an error' do
-          expect do
-            subject.unload(service_name, sync=true)
-          end.to raise_error(Fleet::Error)
-        end
-
-      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(:delete_unit).and_return(nil)
     end
 
     it 'invokes #delete_job' do
 
-      expect(subject).to receive(:delete_job)
+      expect(subject).to receive(:delete_unit)
                          .with(service_name)
                          .and_return(nil)
 
       subject.destroy(service_name)
     end
-
-    context 'when sync=true is set' do
-
-      before do
-        allow(subject).to receive(:get_state).and_raise(Fleet::NotFound, 'boom')
-      end
-
-      it 'checks the job state' do
-        expect(subject).to receive(:get_state).with(service_name)
-        subject.destroy(service_name, sync=true)
-      end
-    end
   end
 
   describe '#status' do
@@ -362,20 +223,59 @@ describe Fleet::Client do
     let(:service_name) { 'foo.service' }
 
     let(:fleet_state) do
-      { 'node' => { 'value' => '{"load": "loaded", "run": "running"}' } }
+      { 'currentState' => 'launched' }
     end
 
     before do
-      allow(subject).to receive(:get_state).and_return(fleet_state)
+      allow(subject).to receive(:get_unit).and_return(fleet_state)
     end
 
     it 'retrieves service state from the fleet client' do
-      expect(subject).to receive(:get_state).with(service_name)
+      expect(subject).to receive(:get_unit).with(service_name)
       subject.status(service_name)
     end
 
-    it 'returns the state hash w/ normalized keys' do
-      expect(subject.status(service_name)).to eq(load: 'loaded', run: 'running')
+    it 'returns the symbolized state' do
+      expect(subject.status(service_name)).to eq(:launched)
+    end
+  end
+
+  describe '#get_unit_state' do
+
+    let(:service_name) { 'foo.service' }
+
+    let(:states) do
+      { 'states' => [] }
+    end
+
+    before do
+      allow(subject).to receive(:list_states).and_return(states)
+    end
+
+    it 'retrieves the states from the fleet API' do
+      expect(subject).to receive(:list_states).with({ unitName: service_name })
+      subject.get_unit_state(service_name)
+    end
+
+    context 'when unit is found' do
+
+      let(:states) do
+        { 'states' => [{ 'name' => 'foo.service' }, {}] }
+      end
+
+      it 'returns the first matching state hash' do
+        expect(subject.get_unit_state(service_name)).to eq(states['states'].first)
+      end
+    end
+
+    context 'when unit is NOT found' do
+
+      let(:states) { {} }
+
+      it 'returns the first matching state hash' do
+        expect { subject.get_unit_state(service_name) }.to(
+          raise_error(Fleet::NotFound))
+      end
     end
   end
 end

data/spec/fleet/configuration_spec.rb

@@ -13,15 +13,15 @@ describe Fleet::Configuration do
 
   describe 'default values' do
 
-    describe 'adapter' do
-      it 'is matches DEFAULT_ADAPTER' do
-        expect(subject.adapter).to eq Fleet::Configuration::DEFAULT_ADAPTER
+    describe 'fleet_api_url' do
+      it 'is matches DEFAULT_FLEET_API_URL' do
+        expect(subject.fleet_api_url).to eq Fleet::Configuration::DEFAULT_FLEET_API_URL
       end
     end
 
-    describe 'fleet_api_url' do
-      it 'is matches DEFAULT_ETCD_API_URL' do
-        expect(subject.fleet_api_url).to eq Fleet::Configuration::DEFAULT_ETCD_API_URL
+    describe 'fleet_api_version' do
+      it 'is matches DEFAULT_FLEET_API_VERSION' do
+        expect(subject.fleet_api_version).to eq Fleet::Configuration::DEFAULT_FLEET_API_VERSION
       end
     end