marathon-api 0.9.0 → 1.0.0

data/lib/marathon/health_check.rb

@@ -0,0 +1,35 @@
+# This class represents a Marathon HealthCheck.
+# See https://mesosphere.github.io/marathon/docs/health-checks.html for full details.
+class Marathon::HealthCheck < Marathon::Base
+
+  DEFAULTS = {
+    :gracePeriodSeconds => 300,
+    :intervalSeconds => 60,
+    :maxConsecutiveFailures => 3,
+    :path => '/',
+    :portIndex => 0,
+    :protocol => 'HTTP',
+    :timeoutSeconds => 20
+  }
+
+  ACCESSORS = %w[ command gracePeriodSeconds intervalSeconds maxConsecutiveFailures
+                  path portIndex protocol timeoutSeconds ]
+
+  # Create a new health check object.
+  # ++hash++: Hash returned by API.
+  def initialize(hash)
+    super(Marathon::Util.merge_keywordized_hash(DEFAULTS, hash), ACCESSORS)
+    Marathon::Util.validate_choice(:protocol, protocol, %w[HTTP TCP COMMAND])
+  end
+
+  def to_s
+    if protocol == 'COMMAND'
+      "Marathon::HealthCheck { :protocol => #{protocol} :command => #{command} }"
+    elsif protocol == 'HTTP'
+      "Marathon::HealthCheck { :protocol => #{protocol} :portIndex => #{portIndex} :path => #{path} }"
+    else
+      "Marathon::HealthCheck { :protocol => #{protocol} :portIndex => #{portIndex} }"
+    end
+  end
+
+end

data/lib/marathon/queue.rb

@@ -1,29 +1,20 @@
 # This class represents a Marathon Queue element.
 # See https://mesosphere.github.io/marathon/docs/rest-api.html#queue for full list of API's methods.
-class Marathon::Queue
+class Marathon::Queue < Marathon::Base
 
   attr_reader :app
-  attr_reader :delay
 
   # Create a new queue element object.
   # ++hash++: Hash returned by API, including 'app' and 'delay'
-  def initialize(hash = {})
-    @app = Marathon::App.new(hash['app'], true)
-    @delay = hash['delay']
+  def initialize(hash)
+    super(hash, %w[delay])
+    @app = Marathon::App.new(info[:app], true)
   end
 
   def to_s
     "Marathon::Queue { :appId => #{app.id} :delay => #{delay} }"
   end
 
-  # Return queue element as JSON formatted string.
-  def to_json
-    {
-      'app' => @app.info,
-      'delay' => @delay
-    }.to_json
-  end
-
   class << self
 
     # Show content of the task queue.

data/lib/marathon/task.rb

@@ -1,18 +1,13 @@
 # This class represents a Marathon Task.
 # See https://mesosphere.github.io/marathon/docs/rest-api.html#get-/v2/tasks for full list of API's methods.
-class Marathon::Task
+class Marathon::Task < Marathon::Base
 
-  attr_reader :info
+  ACCESSORS = %w[ id appId host ports servicePorts version stagedAt startedAt ]
 
   # Create a new task object.
   # ++hash++: Hash including all attributes
-  def initialize(hash = {})
-    @info = hash
-  end
-
-  # Shortcuts for reaching attributes
-  %w[ id appId host ports servicePorts version stagedAt startedAt ].each do |method|
-    define_method(method) { |*args, &block| info[method] }
+  def initialize(hash)
+    super(hash, ACCESSORS)
   end
 
   # Kill the task that belongs to an application.
@@ -28,9 +23,17 @@ class Marathon::Task
     "Marathon::Task { :id => #{self.id} :appId => #{appId} :host => #{host} }"
   end
 
-  # Return task as JSON formatted string.
-  def to_json
-    info.to_json
+  # Returns a string for listing the task.
+  def to_pretty_s
+    %Q[
+Task ID:    #{id}
+App ID:     #{appId}
+Host:       #{host}
+Ports:      #{(ports || []).join(',')}
+Staged at:  #{stagedAt}
+Started at: #{startedAt}
+Version:    #{version}
+    ].strip
   end
 
   class << self

data/lib/marathon/util.rb

@@ -8,6 +8,7 @@ class Marathon::Util
     # ++allowed++: array of allowd values
     # ++nil_allowed++: allow nil values
     def validate_choice(name, value, allowed, nil_allowed = true)
+      value = value[name] if value.is_a?(Hash)
       if value.nil?
         unless nil_allowed
           raise Marathon::Error::ArgumentError, "#{name} must not be nil"
@@ -15,8 +16,13 @@ class Marathon::Util
       else
         # value is not nil
         unless allowed.include?(value)
-          msg = nil_allowed ? "#{name} must be one of #{allowed}, or nil" : "#{name} must be one of #{allowed}"
-          raise Marathon::Error::ArgumentError, msg
+          if nil_allowed
+            raise Marathon::Error::ArgumentError,
+              "#{name} must be one of #{allowed.join(', ')} or nil, but is '#{value}'"
+          else
+            raise Marathon::Error::ArgumentError,
+              "#{name} must be one of #{allowed.join(', ')} or nil, but is '#{value}'"
+          end
         end
       end
     end
@@ -31,5 +37,43 @@ class Marathon::Util
       validate_choice(name, value, allowed, nil_allowed)
       opts[name] = value if value
     end
+
+    # Swap keys of the hash against their symbols.
+    # ++hash++: the hash
+    def keywordize_hash(hash)
+      if hash.is_a?(Hash)
+        new_hash = {}
+        hash.each do |k,v|
+          key = k.to_sym
+          if key == :env and v.is_a?(Hash)
+            # ignore :env => {} to prevent renameing environment variables
+            new_hash[key] = hash[k]
+          else
+            new_hash[key] = keywordize_hash(hash[k])
+          end
+        end
+        new_hash
+      elsif hash.is_a?(Array)
+        hash.map { |e| keywordize_hash(e) }
+      else
+        hash
+      end
+    end
+
+    # Merge two hashes but keywordize both.
+    def merge_keywordized_hash(h1, h2)
+      keywordize_hash(h1).merge(keywordize_hash(h2))
+    end
+
+    # Stringify an item or an array of items.
+    def items_to_pretty_s(item)
+      if item.nil?
+        nil
+      elsif item.is_a?(Array)
+        item.map {|e| e.to_pretty_s}.join(',')
+      else
+        item.to_pretty_s
+      end
+    end
   end
-end
+end

data/lib/marathon/version.rb

@@ -1,3 +1,3 @@
 module Marathon
-  VERSION = '0.9.0'
+  VERSION = '1.0.0'
 end

data/marathon-api.gemspec

@@ -5,10 +5,10 @@ Gem::Specification.new do |gem|
   gem.name          = "marathon-api"
   gem.version       = Marathon::VERSION
   gem.authors       = ["Felix Bechstein"]
-  gem.email         = %w{f@ub0r.de}
+  gem.email         = %w{felix.bechstein@otto.de}
   gem.description   = %q{A simple REST client for the Marathon Remote API}
   gem.summary       = %q{A simple REST client for the Marathon Remote API}
-  gem.homepage      = 'https://github.com/felixb/marathon-api'
+  gem.homepage      = 'https://github.com/otto-de/marathon-api'
   gem.license       = 'MIT'
 
   gem.files         = `git ls-files`.split($\)
@@ -17,7 +17,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = %w{lib}
 
   gem.add_dependency 'json'
-  gem.add_dependency "httparty", ">= 0.11"
+  gem.add_dependency 'httparty', '>= 0.11'
+  gem.add_dependency 'trollop', '>= 2.0'
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec', '~> 3.0'

data/spec/marathon/app_spec.rb

@@ -3,20 +3,42 @@ require 'spec_helper'
 describe Marathon::App do
 
   describe '#to_s' do
-    subject { described_class.new({ 'id' => '/app/foo' }) }
+    subject { described_class.new({
+      'id' => '/app/foo',
+      'instances' => 1,
+      'tasks' => [],
+      'env' => {'FOO' => 'BAR', 'blubb' => 'blah'},
+      'constraints' => [['hostname', 'UNIQUE']],
+      'uris' => ['http://example.com/big.tar'],
+      'version' => 'foo-version'
+    }) }
 
     let(:expected_string) do
       "Marathon::App { :id => /app/foo }"
     end
 
+    let(:expected_pretty_string) do
+      "App ID:     /app/foo\n" + \
+      "Instances:  0/1\n" + \
+      "Command:    \n" + \
+      "CPUs:       \n" + \
+      "Memory:      MB\n" + \
+      "URI:        http://example.com/big.tar\n" + \
+      "ENV:        FOO=BAR\n" + \
+      "ENV:        blubb=blah\n" + \
+      "Constraint: hostname:UNIQUE\n" + \
+      "Version:    foo-version"
+    end
+
     its(:to_s) { should == expected_string }
+    its(:to_pretty_s) { should == expected_pretty_string }
   end
 
   describe '#to_json' do
     subject { described_class.new({ 'id' => '/app/foo' }) }
 
     let(:expected_string) do
-      '{"id":"/app/foo"}'
+      '{"constraints":[],"env":{},"ports":[],"uris":[],"id":"/app/foo"}'
     end
 
     its(:to_json) { should == expected_string }
@@ -30,12 +52,41 @@ describe Marathon::App do
     end
   end
 
+  describe '#container' do
+    subject { described_class.new({
+      'id' => '/ubuntu2', 'container' => {'type'=>'DOCKER', 'docker'=>{'image'=>'felixb/yocto-httpd'}}
+    })}
+
+    it 'has container' do
+      expect(subject.container).to be_instance_of(Marathon::Container)
+      expect(subject.container.type).to eq('DOCKER')
+    end
+  end
+
+  describe '#constraints' do
+    subject { described_class.new({ 'id' => '/ubuntu2', 'constraints' => [['hostname', 'UNIQUE']] }) }
+
+    it 'has constraints' do
+      expect(subject.constraints).to be_instance_of(Array)
+      expect(subject.constraints.first).to be_instance_of(Marathon::Constraint)
+    end
+  end
+
+  describe '#constraints' do
+    subject { described_class.new({ 'id' => '/ubuntu2', 'healthChecks' => [{ 'path' => '/ping' }] }) }
+
+    it 'has healthChecks' do
+      expect(subject.healthChecks).to be_instance_of(Array)
+      expect(subject.healthChecks.first).to be_instance_of(Marathon::HealthCheck)
+    end
+  end
+
   describe '#tasks' do
     subject { described_class.new({ 'id' => '/ubuntu2' }) }
 
     it 'checks for read only' do
       expect(subject).to receive(:check_read_only)
-      subject.info['tasks'] = []
+      subject.info[:tasks] = []
       subject.tasks
     end
 
@@ -48,13 +99,13 @@ describe Marathon::App do
     end
 
     it 'loads tasks from API when not loaded already' do
-      subject.info['tasks'] = nil
-      expect(subject).to receive(:refresh) { subject.info['tasks'] = [] }
+      subject.info[:tasks] = nil
+      expect(subject).to receive(:refresh) { subject.info[:tasks] = [] }
       expect(subject.tasks).to eq([])
     end
 
     it 'shows already loaded tasks w/o API call' do
-      subject.info['tasks'] = []
+      subject.info[:tasks] = []
       expect(subject).not_to receive(:refresh)
       expect(subject.tasks).to eq([])
     end
@@ -77,29 +128,30 @@ describe Marathon::App do
   end
 
   describe '#start!' do
-    let(:app) { described_class.new({ 'id' => '/app/foo' }) }
+    subject { described_class.new({ 'id' => '/app/foo' }) }
 
     it 'checks for read only' do
       expect(subject).to receive(:check_read_only)
-      expect(described_class).to receive(:start) { described_class.new }
+      expect(described_class).to receive(:start) { described_class.new('id' => subject.id) }
       subject.start!
     end
 
     it 'starts the app' do
-      expect(described_class).to receive(:start).with({ 'id' => '/app/foo'}) do
-        described_class.new({ 'id' => '/app/foo', 'started' => true })
+      expect(described_class).to receive(:start)
+        .with({:constraints=>[], :env=>{}, :ports=>[], :uris=>[], :id=>"/app/foo"}) do
+          described_class.new({ 'id' => '/app/foo', 'started' => true })
       end
-      app.start!
-      expect(app.info['started']).to be(true)
+      subject.start!
+      expect(subject.info[:started]).to be(true)
     end
   end
 
   describe '#refresh' do
-    let(:app) { described_class.new({ 'id' => '/app/foo' }) }
+    subject { described_class.new({ 'id' => '/app/foo' }) }
 
     it 'checks for read only' do
       expect(subject).to receive(:check_read_only)
-      expect(described_class).to receive(:get) { described_class.new }
+      expect(described_class).to receive(:get) { described_class.new('id' => subject.id) }
       subject.refresh
     end
 
@@ -107,13 +159,13 @@ describe Marathon::App do
       expect(described_class).to receive(:get).with('/app/foo') do
         described_class.new({ 'id' => '/app/foo', 'refreshed' => true })
       end
-      app.refresh
-      expect(app.info['refreshed']).to be(true)
+      subject.refresh
+      expect(subject.info[:refreshed]).to be(true)
     end
   end
 
   describe '#restart!' do
-    let(:app) { described_class.new({ 'id' => '/app/foo' }) }
+    subject { described_class.new({ 'id' => '/app/foo' }) }
 
     it 'checks for read only' do
       expect(subject).to receive(:check_read_only)
@@ -124,18 +176,18 @@ describe Marathon::App do
     it 'restarts the app' do
       expect(described_class).to receive(:restart)
         .with('/app/foo', false)
-      app.restart!
+      subject.restart!
     end
 
     it 'restarts the app, force' do
       expect(described_class).to receive(:restart)
         .with('/app/foo', true)
-      app.restart!(true)
+      subject.restart!(true)
     end
   end
 
   describe '#change!' do
-    let(:app) { described_class.new({ 'id' => '/app/foo' }) }
+    subject { described_class.new({ 'id' => '/app/foo' }) }
 
     it 'checks for read only' do
       expect(subject).to receive(:check_read_only)
@@ -145,12 +197,12 @@ describe Marathon::App do
 
     it 'changes the app' do
       expect(described_class).to receive(:change).with('/app/foo', {'instances' => 9000 }, false)
-      app.change!('instances' => 9000)
+      subject.change!('instances' => 9000)
     end
   end
 
   describe '#roll_back!' do
-    let(:app) { described_class.new({ 'id' => '/app/foo', 'instances' => 10 }) }
+    subject { described_class.new({ 'id' => '/app/foo', 'instances' => 10 }) }
 
     it 'checks for read only' do
       expect(subject).to receive(:check_read_only)
@@ -159,18 +211,18 @@ describe Marathon::App do
     end
 
     it 'changes the app' do
-      expect(app).to receive(:change!).with({'version' => 'old_version' }, false)
-      app.roll_back!('old_version')
+      expect(subject).to receive(:change!).with({'version' => 'old_version' }, false)
+      subject.roll_back!('old_version')
     end
 
     it 'changes the app with force' do
-      expect(app).to receive(:change!).with({'version' => 'old_version' }, true)
-      app.roll_back!('old_version', true)
+      expect(subject).to receive(:change!).with({'version' => 'old_version' }, true)
+      subject.roll_back!('old_version', true)
     end
   end
 
   describe '#scale!' do
-    let(:app) { described_class.new({ 'id' => '/app/foo', 'instances' => 10 }) }
+    subject { described_class.new({ 'id' => '/app/foo', 'instances' => 10 }) }
 
     it 'checks for read only' do
       expect(subject).to receive(:check_read_only)
@@ -179,18 +231,18 @@ describe Marathon::App do
     end
 
     it 'changes the app' do
-      expect(app).to receive(:change!).with({'instances' => 9000 }, false)
-      app.scale!(9000)
+      expect(subject).to receive(:change!).with({'instances' => 9000 }, false)
+      subject.scale!(9000)
     end
 
     it 'changes the app with force' do
-      expect(app).to receive(:change!).with({'instances' => 9000 }, true)
-      app.scale!(9000, true)
+      expect(subject).to receive(:change!).with({'instances' => 9000 }, true)
+      subject.scale!(9000, true)
     end
   end
 
   describe '#suspend!' do
-    let(:app) { described_class.new({ 'id' => '/app/foo', 'instances' => 10 }) }
+    subject { described_class.new({ 'id' => '/app/foo', 'instances' => 10 }) }
 
     it 'checks for read only' do
       expect(subject).to receive(:check_read_only)
@@ -199,13 +251,13 @@ describe Marathon::App do
     end
 
     it 'scales the app to 0' do
-      expect(app).to receive(:scale!).with(0, false)
-      app.suspend!
+      expect(subject).to receive(:scale!).with(0, false)
+      subject.suspend!
     end
 
     it 'scales the app to 0 with force' do
-      expect(app).to receive(:scale!).with(0, true)
-      app.suspend!(true)
+      expect(subject).to receive(:scale!).with(0, true)
+      subject.suspend!(true)
     end
   end
 
@@ -216,17 +268,17 @@ describe Marathon::App do
       expect(Marathon.connection).to receive(:get)
         .with('/v2/apps', {:cmd => 'foo', :embed => 'apps.tasks'})
         .and_return({ 'apps' => [] })
-      described_class.list('foo', 'apps.tasks')
+      subject.list('foo', 'apps.tasks')
     end
 
     it 'raises error when run with strange embed' do
       expect {
-        described_class.list(nil, 'foo')
+        subject.list(nil, 'foo')
       }.to raise_error(Marathon::Error::ArgumentError)
     end
 
     it 'lists apps', :vcr do
-      apps = described_class.list
+      apps = subject.list
       expect(apps.size).not_to eq(0)
       expect(apps.first).to be_instance_of(described_class)
       expect(apps.first.cpus).to eq(0.1)
@@ -238,7 +290,7 @@ describe Marathon::App do
     subject { described_class }
 
     it 'starts the app', :vcr do
-      app = described_class.start({ :id => '/test', :cmd => 'sleep 10', :instances => 1, :cpus => 0.1, :mem => 32})
+      app = subject.start({ :id => '/test', :cmd => 'sleep 10', :instances => 1, :cpus => 0.1, :mem => 32})
       expect(app).to be_instance_of(described_class)
       expect(app.id).to eq('/test')
       expect(app.instances).to eq(1)
@@ -248,7 +300,7 @@ describe Marathon::App do
 
     it 'fails getting not existing app', :vcr do
       expect {
-        described_class.get('fooo app')
+        subject.get('fooo app')
       }.to raise_error(Marathon::Error::NotFoundError)
     end
   end
@@ -257,7 +309,7 @@ describe Marathon::App do
     subject { described_class }
 
     it 'gets the app', :vcr do
-      app = described_class.get('/ubuntu')
+      app = subject.get('/ubuntu')
       expect(app).to be_instance_of(described_class)
       expect(app.id).to eq('/ubuntu')
       expect(app.instances).to eq(1)
@@ -267,7 +319,7 @@ describe Marathon::App do
 
     it 'fails getting not existing app', :vcr do
       expect {
-        described_class.get('fooo app')
+        subject.get('fooo app')
       }.to raise_error(Marathon::Error::NotFoundError)
     end
   end
@@ -276,12 +328,12 @@ describe Marathon::App do
     subject { described_class }
 
     it 'deletes the app', :vcr do
-      described_class.delete('/ubuntu')
+      subject.delete('/ubuntu')
     end
 
     it 'fails deleting not existing app', :vcr do
       expect {
-        described_class.delete('fooo app')
+        subject.delete('fooo app')
       }.to raise_error(Marathon::Error::NotFoundError)
     end
   end
@@ -289,9 +341,13 @@ describe Marathon::App do
   describe '.restart' do
     subject { described_class }
 
+    it 'restarts an app', :vcr do
+      expect(subject.restart('/ubuntu2')).to be_instance_of(Marathon::DeploymentInfo)
+    end
+
     it 'fails restarting not existing app', :vcr do
       expect {
-        described_class.restart('fooo app')
+        subject.restart('fooo app')
       }.to raise_error(Marathon::Error::NotFoundError)
     end
   end
@@ -300,13 +356,15 @@ describe Marathon::App do
     subject { described_class }
 
     it 'changes the app', :vcr do
-      described_class.change('/ubuntu2', { 'instances' => 2 })
-      described_class.change('/ubuntu2', { 'instances' => 1 }, true)
+      expect(subject.change('/ubuntu2', { 'instances' => 2 }))
+        .to be_instance_of(Marathon::DeploymentInfo)
+      expect(subject.change('/ubuntu2', { 'instances' => 1 }, true))
+        .to be_instance_of(Marathon::DeploymentInfo)
     end
 
     it 'fails with stange attributes', :vcr do
       expect {
-        described_class.change('/ubuntu2', { 'instances' => 'foo' })
+        subject.change('/ubuntu2', { 'instances' => 'foo' })
       }.to raise_error(Marathon::Error::ClientError)
     end
   end
@@ -331,4 +389,4 @@ describe Marathon::App do
       expect(version.read_only).to be(true)
     end
   end
-end
+end