marathon-api 0.9.0 → 1.0.0

data/lib/marathon/base.rb

@@ -0,0 +1,32 @@
+# Base class for all the API specific classes.
+class Marathon::Base
+
+  include Marathon::Error
+
+  attr_reader :info
+
+  # Create the object
+  # ++hash++: object returned from API. May be Hash or Array.
+  # ++attr_readers++: List of attribute readers.
+  def initialize(hash, attr_readers = [])
+    raise ArgumentError, 'hash must be a Hash' if attr_readers and attr_readers.size > 0 and not hash.is_a?(Hash)
+    raise ArgumentError, 'hash must be Hash or Array' unless hash.is_a?(Hash) or hash.is_a?(Array)
+    raise ArgumentError, 'attr_readers must be an Array' unless attr_readers.is_a?(Array)
+    @info = Marathon::Util.keywordize_hash(hash)
+    attr_readers.each { |e| add_attr_reader(e) }
+  end
+
+  # Return application as JSON formatted string.
+  def to_json
+    info.to_json
+  end
+
+  private
+
+  # Create attr_reader for @info[key].
+  # ++key++: key in @info
+  def add_attr_reader(key)
+    sym = key.to_sym
+    self.class.send(:define_method, sym.id2name) { |*args, &block| info[sym] }
+  end
+end

data/lib/marathon/connection.rb

@@ -13,12 +13,22 @@ class Marathon::Connection
   default_timeout 5
   maintain_method_across_redirects
 
-  attr_reader :url
+  attr_reader :url, :options
 
   # Create a new API connection.
   # ++url++: URL of the marathon API.
-  def initialize(url)
+  # ++options++: Hash with options for marathon API.
+  def initialize(url, options = {})
     @url = url
+    @options = options
+    if @options[:username] and @options[:password]
+      @options[:basic_auth] = {
+        :username => @options[:username],
+        :password => @options[:password]
+      }
+      @options.delete(:username)
+      @options.delete(:password)
+    end
   end
 
   # Delegate all HTTP methods to the #request.
@@ -27,7 +37,7 @@ class Marathon::Connection
   end
 
   def to_s
-    "Marathon::Connection { :url => #{url} }"
+    "Marathon::Connection { :url => #{url} :options => #{options} }"
   end
 
 private
@@ -58,16 +68,25 @@ private
   end
 
   # Create full URL with query parameters.
-  # ++url++: Base URL.
-  # ++query++: Hash of query parameters.
-  def build_url(url, query)
-    url = URI.escape(url)
-    if query.size > 0
-      url += '?' + query_params(query)
+  # ++request++: hash containing :url and optional :query
+  def build_url(request)
+    url = URI.escape(request[:url])
+    if request[:query].size > 0
+      url += '?' + query_params(request[:query])
     end
     url
   end
 
+  # Parse response or raise error.
+  # ++response++: response from HTTParty call.
+  def parse_response(response)
+    if response.success?
+      response.parsed_response
+    else
+      raise Marathon::Error.from_response(response)
+    end
+  end
+
   # Send a request to the server and parse response.
   # ++http_method++: GET/POST/PUT/DELETE.
   # ++path++: Relative path to connection's URL.
@@ -75,19 +94,10 @@ private
   # ++opts++: Optional options. Ex. opts[:body] is used for PUT/POST request.
   def request(*args)
     request = compile_request_params(*args)
-    url = build_url(request[:url], request[:query])
-    response = self.class.send(request[:method], url, request)
-    if response.success?
-      response.parsed_response
-    else
-      raise Marathon::Error.from_response(response)
-    end
-  rescue MarathonError => e
-    raise e
-  rescue SocketError => e
-    raise IOError, "HTTP call failed: #{e.message}"
-  rescue SystemCallError => e
-    if e.class.name.start_with?('Errno::')
+    url = build_url(request)
+    parse_response(self.class.send(request[:method], url, request))
+  rescue => e
+    if e.class == SocketError or e.class.name.start_with?('Errno::')
       raise IOError, "HTTP call failed: #{e.message}"
     else
       raise e

data/lib/marathon/constraint.rb

@@ -0,0 +1,39 @@
+# This class represents a Marathon Constraint.
+# See https://mesosphere.github.io/marathon/docs/constraints.html for full details.
+class Marathon::Constraint < Marathon::Base
+
+  # Create a new constraint object.
+  # ++array++: Array returned by API, holds attribute, operator and parameter.
+  def initialize(array)
+    raise Marathon::Error::ArgumentError, 'array must be an Array' unless array.is_a?(Array)
+    raise Marathon::Error::ArgumentError,
+      'array must be [attribute, operator, parameter] where only parameter is optional' \
+      unless array.size != 2 or array.size != 3
+    super
+  end
+
+  def attribute
+    info[0]
+  end
+
+  def operator
+    info[1]
+  end
+
+  def parameter
+    info[2]
+  end
+
+  def to_s
+    if parameter
+      "Marathon::Constraint { :attribute => #{attribute} :operator => #{operator} :parameter => #{parameter} }"
+    else
+      "Marathon::Constraint { :attribute => #{attribute} :operator => #{operator} }"
+    end
+  end
+
+  # Returns a string for listing the constraint.
+  def to_pretty_s
+    info.join(':')
+  end
+end

data/lib/marathon/container.rb

@@ -0,0 +1,41 @@
+# This class represents a Marathon Container information.
+# It is included in App's definition.
+# See https://mesosphere.github.io/marathon/docs/native-docker.html for full details.
+class Marathon::Container < Marathon::Base
+
+  SUPPERTED_TYPES = %w[ DOCKER ]
+  ACCESSORS = %w[ type ]
+  DEFAULTS = {
+    :type => 'DOCKER',
+    :volumes => []
+  }
+
+  # Create a new container object.
+  # ++hash++: Hash returned by API.
+  def initialize(hash)
+    super(Marathon::Util.merge_keywordized_hash(DEFAULTS, hash), ACCESSORS)
+    Marathon::Util.validate_choice('type', type, SUPPERTED_TYPES)
+  end
+
+  # Get container's docker information.
+  # This is read only!
+  def docker
+    if @info[:docker]
+      Marathon::ContainerDocker.new(@info[:docker])
+    else
+      nil
+    end
+  end
+
+  # Get container's volumes.
+  # This is read only!
+  def volumes
+    @info[:volumes].map { |e| Marathon::ContainerVolume.new(e) }
+  end
+
+  def to_s
+    "Marathon::Container { :type => #{type} :docker => #{Marathon::Util.items_to_pretty_s(docker)}"\
+    + " :volumes => #{Marathon::Util.items_to_pretty_s(volumes)} }"
+  end
+
+end

data/lib/marathon/container_docker.rb

@@ -0,0 +1,33 @@
+# This class represents a Marathon Container docker information.
+# See https://mesosphere.github.io/marathon/docs/native-docker.html for full details.
+class Marathon::ContainerDocker < Marathon::Base
+
+  ACCESSORS = %w[ image network ]
+  DEFAULTS = {
+    :network => 'BRIDGE',
+    :portMappings => []
+  }
+
+  # Create a new container docker object.
+  # ++hash++: Hash returned by API.
+  def initialize(hash)
+    super(Marathon::Util.merge_keywordized_hash(DEFAULTS, hash), ACCESSORS)
+    Marathon::Util.validate_choice('network', network, %w[BRIDGE HOST])
+    raise Marathon::Error::ArgumentError, 'image must not be nil' unless image
+  end
+
+  # Get container's port mappings.
+  # This is read only!
+  def portMappings
+    @info[:portMappings].map { |e| Marathon::ContainerDockerPortMapping.new(e) }
+  end
+
+  def to_pretty_s
+    "#{image}"
+  end
+
+  def to_s
+    "Marathon::ContainerDocker { :image => #{image} }"
+  end
+
+end

data/lib/marathon/container_docker_port_mapping.rb

@@ -0,0 +1,32 @@
+# This class represents a Marathon Container docker information.
+# See https://mesosphere.github.io/marathon/docs/native-docker.html for full details.
+class Marathon::ContainerDockerPortMapping < Marathon::Base
+
+  ACCESSORS = %w[ containerPort hostPort servicePort protocol ]
+  DEFAULTS = {
+    :protocol => 'tcp',
+    :hostPort => 0
+  }
+
+  # Create a new container docker port mappint 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[tcp udp])
+    raise Marathon::Error::ArgumentError, 'containerPort must not be nil' unless containerPort
+    raise Marathon::Error::ArgumentError, 'containerPort must be a positive number' \
+      unless containerPort.is_a?(Integer) and containerPort > 0
+    raise Marathon::Error::ArgumentError, 'hostPort must be a non negative number' \
+      unless hostPort.is_a?(Integer) and hostPort >= 0
+  end
+
+  def to_pretty_s
+    "#{protocol}/#{containerPort}:#{hostPort}"
+  end
+
+  def to_s
+    "Marathon::ContainerDockerPortMapping { :protocol => #{protocol} " \
+    + ":containerPort => #{containerPort} :hostPort => #{hostPort} }"
+  end
+
+end

data/lib/marathon/container_volume.rb

@@ -0,0 +1,31 @@
+# This class represents a Marathon Container Volume information.
+# See https://mesosphere.github.io/marathon/docs/native-docker.html for full details.
+class Marathon::ContainerVolume < Marathon::Base
+
+  ACCESSORS = %w[ containerPath hostPath mode ]
+  DEFAULTS = {
+    :mode => 'RW'
+  }
+
+  # Create a new container volume object.
+  # ++hash++: Hash returned by API.
+  def initialize(hash)
+    super(Marathon::Util.merge_keywordized_hash(DEFAULTS, hash), ACCESSORS)
+    Marathon::Util.validate_choice('mode', mode, %w[RW RO])
+    raise Marathon::Error::ArgumentError, 'containerPath must not be nil' unless containerPath
+    raise Marathon::Error::ArgumentError, 'containerPath must be an absolute path' \
+      unless Pathname.new(containerPath).absolute?
+    raise Marathon::Error::ArgumentError, 'hostPath must not be nil' unless hostPath
+    raise Marathon::Error::ArgumentError, 'hostPath must be an absolute path' \
+      unless Pathname.new(hostPath).absolute?
+  end
+
+  def to_pretty_s
+    "#{containerPath}:#{hostPath}:#{mode}"
+  end
+
+  def to_s
+    "Marathon::ContainerVolume { :containerPath => #{containerPath} :hostPath => #{hostPath} :mode => #{mode} }"
+  end
+
+end

data/lib/marathon/deployment.rb

@@ -1,19 +1,14 @@
 # This class represents a Marathon Deployment.
 # See https://mesosphere.github.io/marathon/docs/rest-api.html#deployments for full list of API's methods.
-class Marathon::Deployment
+class Marathon::Deployment < Marathon::Base
 
-  attr_reader :info
+  ACCESSORS = %w[ id affectedApps steps currentActions version currentStep totalSteps ]
 
   # Create a new deployment object.
   # ++hash++: Hash including all attributes.
   #           See https://mesosphere.github.io/marathon/docs/rest-api.html#get-/v2/deployments for full details.
-  def initialize(hash = {})
-    @info = hash
-  end
-
-  # Shortcuts for reaching attributes
-  %w[ id affectedApps steps currentActions version currentStep totalSteps ].each do |method|
-    define_method(method) { |*args, &block| info[method] }
+  def initialize(hash)
+    super(hash, ACCESSORS)
   end
 
   # Cancel the deployment.
@@ -30,11 +25,6 @@ class Marathon::Deployment
       + ":id => #{id} :affectedApps => #{affectedApps} :currentStep => #{currentStep} :totalSteps => #{totalSteps} }"
   end
 
-  # Return deployment as JSON formatted string.
-  def to_json
-    info.to_json
-  end
-
   class << self
 
     # List running deployments.
@@ -52,7 +42,7 @@ class Marathon::Deployment
       query = {}
       query[:force] = true if force
       json = Marathon.connection.delete("/v2/deployments/#{id}")
-      # TODO parse deploymentId + version
+      Marathon::DeploymentInfo.new(json)
     end
     alias :cancel :delete
     alias :remove :delete

data/lib/marathon/deployment_info.rb

@@ -0,0 +1,20 @@
+# This class represents a Marathon Deployment information.
+# It is returned by asynchronious deployment calls.
+class Marathon::DeploymentInfo < Marathon::Base
+
+  # Create a new deployment info object.
+  # ++hash++: Hash returned by API, including 'deploymentId' and 'version'
+  def initialize(hash)
+    super(hash, %w[deploymentId version])
+    raise Marathon::Error::ArgumentError, 'version must not be nil' unless version
+  end
+
+  def to_s
+    if deploymentId
+      "Marathon::DeploymentInfo { :version => #{version} :deploymentId => #{deploymentId} }"
+    else
+      "Marathon::DeploymentInfo { :version => #{version} }"
+    end
+  end
+
+end

data/lib/marathon/error.rb

@@ -7,7 +7,7 @@ module Marathon::Error
   # Raised when invalid arguments are passed to a method.
   class ArgumentError < MarathonError; end
 
-  # Raised when a request returns a 400.
+  # Raised when a request returns a 400 or 422.
   class ClientError < MarathonError; end
 
   # Raised when a request returns a 404.
@@ -39,6 +39,8 @@ module Marathon::Error
     case response.code
     when 400
       ClientError
+    when 422
+      ClientError
     when 404
       NotFoundError
     else
@@ -50,8 +52,12 @@ module Marathon::Error
   # ++response++: HTTParty response object.
   def error_message(response)
     body = response.parsed_response
-    if body.is_a?(Hash)
+    if not body.is_a?(Hash)
+      body
+    elsif body['message']
       body['message']
+    elsif body['errors']
+      body['errors']
     else
       body
     end

data/lib/marathon/group.rb

@@ -0,0 +1,166 @@
+# This class represents a Marathon Group.
+# See https://mesosphere.github.io/marathon/docs/rest-api.html#groups for full list of API's methods.
+class Marathon::Group < Marathon::Base
+
+  ACCESSORS = %w[ id dependencies version ]
+
+  DEFAULTS = {
+    :apps => [],
+    :dependencies => [],
+    :groups => []
+  }
+
+  # Create a new group object.
+  # ++hash++: Hash including all attributes.
+  #           See https://mesosphere.github.io/marathon/docs/rest-api.html#post-/v2/groups for full details.
+  def initialize(hash)
+    super(Marathon::Util.merge_keywordized_hash(DEFAULTS, hash), ACCESSORS)
+    raise ArgumentError, 'Group must have an id' unless id
+    raise ArgumentError, 'Group can have either groups or apps, not both' if apps.size > 0 and groups.size > 0
+  end
+
+  # Get apps.
+  # This is read only!
+  def apps
+    @info[:apps].map { |e| Marathon::App.new(e) }
+  end
+
+  # Get groups.
+  # This is read only!
+  def groups
+    @info[:groups].map { |e| Marathon::Group.new(e) }
+  end
+
+  # Reload attributes from marathon API.
+  def refresh
+    new_app = self.class.get(id)
+    @info = new_app.info
+  end
+
+  # Create and start a the application group. Application groups can contain other application groups.
+  # An application group can either hold other groups or applications, but can not be mixed in one.
+  # Since the deployment of the group can take a considerable amount of time,
+  # this endpoint returns immediatly with a version. The failure or success of the action is signalled via event.
+  # There is a group_change_success and group_change_failed event with the given version.
+  def start!
+    self.class.start(info)
+  end
+
+  # Change parameters of a deployed application group.
+  # Changes to application parameters will result in a restart of this application.
+  # A new application added to the group is started.
+  # An existing application removed from the group gets stopped.
+  # If there are no changes to the application definition, no restart is triggered.
+  # During restart marathon keeps track, that the configured amount of minimal running instances are always available.
+  # A deployment can run forever. This is the case, when the new application has a problem and does not become healthy.
+  # In this case, human interaction is needed with 2 possible choices:
+  # Rollback to an existing older version (send an existing version in the body)
+  # Update with a newer version of the group which does not have the problems of the old one.
+  # If there is an upgrade process already in progress, a new update will be rejected unless the force flag is set.
+  # With the force flag given, a running upgrade is terminated and a new one is started.
+  # Since the deployment of the group can take a considerable amount of time,
+  # this endpoint returns immediatly with a version. The failure or success of the action is signalled via event.
+  # There is a group_change_success and group_change_failed event with the given version.
+  # ++hash++: Hash of attributes to change.
+  # ++force++: If the group is affected by a running deployment, then the update operation will fail.
+  #            The current deployment can be overridden by setting the `force` query parameter.
+  def change!(hash, force = false)
+    self.class.change(id, hash, force)
+  end
+
+  # Create a new version with parameters of an old version.
+  # Currently running tasks are restarted, while maintaining the minimumHealthCapacity.
+  # ++version++: Version name of the old version.
+  # ++force++: If the group is affected by a running deployment, then the update operation will fail.
+  #            The current deployment can be overridden by setting the `force` query parameter.
+  def roll_back!(version, force = false)
+    change!({'version' => version}, force)
+  end
+
+  def to_s
+    "Marathon::Group { :id => #{id} }"
+  end
+
+  # Returns a string for listing the group.
+  def to_pretty_s
+    %Q[
+Group ID:   #{id}
+#{pretty_array(apps)}
+#{pretty_array(groups)}
+Version:    #{version}
+    ].gsub(/\n\n+/, "\n").strip
+  end
+
+  private
+
+  def pretty_array(array)
+    array.map { |e| e.to_pretty_s.split("\n").map { |e| "    #{e}" }}.join("\n")
+  end
+
+  class << self
+
+    # List the group with the specified ID.
+    # ++id++: Group's id.
+    def get(id)
+      json = Marathon.connection.get("/v2/groups/#{id}")
+      new(json)
+    end
+
+    # List all groups.
+    def list
+      json = Marathon.connection.get('/v2/groups')
+      new(json)
+    end
+
+    # Delete the application group with id.
+    # ++id++: Group's id.
+    # ++force++: If the group is affected by a running deployment, then the update operation will fail.
+    #            The current deployment can be overridden by setting the `force` query parameter.
+    def delete(id, force = false)
+      query = {}
+      query[:force] = true if force
+      Marathon.connection.delete("/v2/groups/#{id}", query)
+    end
+    alias :remove :delete
+
+    # Create and start a new application group. Application groups can contain other application groups.
+    # An application group can either hold other groups or applications, but can not be mixed in one.
+    # Since the deployment of the group can take a considerable amount of time,
+    # this endpoint returns immediatly with a version. The failure or success of the action is signalled via event.
+    # There is a group_change_success and group_change_failed event with the given version.
+    # ++hash++: Hash including all attributes
+    #           see https://mesosphere.github.io/marathon/docs/rest-api.html#post-/v2/groups for full details
+    def start(hash)
+      json = Marathon.connection.post('/v2/groups', nil, :body => hash)
+      Marathon::DeploymentInfo.new(json)
+    end
+    alias :create :start
+
+    # Change parameters of a deployed application group.
+    # Changes to application parameters will result in a restart of this application.
+    # A new application added to the group is started.
+    # An existing application removed from the group gets stopped.
+    # If there are no changes to the application definition, no restart is triggered.
+    # During restart marathon keeps track, that the configured amount of minimal running instances are always available.
+    # A deployment can run forever. This is the case,
+    # when the new application has a problem and does not become healthy.
+    # In this case, human interaction is needed with 2 possible choices:
+    # Rollback to an existing older version (send an existing version in the body)
+    # Update with a newer version of the group which does not have the problems of the old one.
+    # If there is an upgrade process already in progress, a new update will be rejected unless the force flag is set.
+    # With the force flag given, a running upgrade is terminated and a new one is started.
+    # Since the deployment of the group can take a considerable amount of time,
+    # this endpoint returns immediatly with a version. The failure or success of the action is signalled via event.
+    # There is a group_change_success and group_change_failed event with the given version.
+    # ++id++: Group's id.
+    # ++hash++: Hash of attributes to change.
+    # ++force++: If the group is affected by a running deployment, then the update operation will fail.
+    #            The current deployment can be overridden by setting the `force` query parameter.
+    def change(id, hash, force = false)
+      query = {}
+      query[:force] = true if force
+      json = Marathon.connection.put("/v2/groups/#{id}", query, :body => hash)
+      Marathon::DeploymentInfo.new(json)
+    end
+  end
+end