apcera 0.1.1

data/lib/apcera/models/dependency.rb

@@ -0,0 +1,53 @@
+module Apcera
+  # 
+  class Dependency < BaseObject
+    attr_accessor :name, :type
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # A string that describes the resource that can be depended on (e.g., &#39;java&#39;, &#39;apache-2.2&#39;).
+        :'name' => :'name',
+        
+        # The type of dependency. Valid values are `file`, `package`, `runtime`, and `os`.
+        :'type' => :'type'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'name' => :'String',
+        :'type' => :'String'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'name']
+        self.name = attributes[:'name']
+      end
+      
+      if attributes[:'type']
+        self.type = attributes[:'type']
+      end
+      
+    end
+
+    def type=(type)
+      allowed_values = ["file", "package", "runtime", "os"]
+      if type && !allowed_values.include?(type)
+        fail "invalid value for 'type', must be one of #{allowed_values}"
+      end
+      @type = type
+    end
+
+  end
+end

data/lib/apcera/models/dependency_resolve.rb

@@ -0,0 +1,45 @@
+module Apcera
+  # 
+  class DependencyResolve < BaseObject
+    attr_accessor :name, :type
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Name of the resource that can be depended upon.
+        :'name' => :'name',
+        
+        # Dependency type. Can be one of the following values: \n * `file` \n  * `package` \n * `runtime` \n `os`.
+        :'type' => :'type'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'name' => :'String',
+        :'type' => :'String'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'name']
+        self.name = attributes[:'name']
+      end
+      
+      if attributes[:'type']
+        self.type = attributes[:'type']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/docker_origin.rb

@@ -0,0 +1,63 @@
+module Apcera
+  # 
+  class DockerOrigin < BaseObject
+    attr_accessor :image_name, :image_tag, :registry_url, :volumes
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Name of Docker image used to create the job.
+        :'image_name' => :'ImageName',
+        
+        # Tag assigned to the Docker image used to create the job.
+        :'image_tag' => :'ImageTag',
+        
+        # URL of private Docker registry used to create the job. Empty for if the Docker public registry (a.k.a. DockerHub) was used.
+        :'registry_url' => :'RegistryURL',
+        
+        # Volumes defined by the Docker image used to create the job.
+        :'volumes' => :'Volumes'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'image_name' => :'String',
+        :'image_tag' => :'String',
+        :'registry_url' => :'String',
+        :'volumes' => :'Array<String>'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'ImageName']
+        self.image_name = attributes[:'ImageName']
+      end
+      
+      if attributes[:'ImageTag']
+        self.image_tag = attributes[:'ImageTag']
+      end
+      
+      if attributes[:'RegistryURL']
+        self.registry_url = attributes[:'RegistryURL']
+      end
+      
+      if attributes[:'Volumes']
+        if (value = attributes[:'Volumes']).is_a?(Array)
+          self.volumes = value
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/drain.rb

@@ -0,0 +1,61 @@
+module Apcera
+  # 
+  class Drain < BaseObject
+    attr_accessor :conf, :max_size, :url, :uuid
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Drain configuration object.
+        :'conf' => :'conf',
+        
+        # Maximum bytes per log line to send. Defaults to 2048 bytes.
+        :'max_size' => :'max_size',
+        
+        # A syslog URL in the form of syslog://hostname:port.
+        :'url' => :'url',
+        
+        # UUID of the drain object.
+        :'uuid' => :'uuid'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'conf' => :'DrainConfig',
+        :'max_size' => :'Integer',
+        :'url' => :'String',
+        :'uuid' => :'String'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'conf']
+        self.conf = attributes[:'conf']
+      end
+      
+      if attributes[:'max_size']
+        self.max_size = attributes[:'max_size']
+      end
+      
+      if attributes[:'url']
+        self.url = attributes[:'url']
+      end
+      
+      if attributes[:'uuid']
+        self.uuid = attributes[:'uuid']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/drain_config.rb

@@ -0,0 +1,53 @@
+module Apcera
+  # 
+  class DrainConfig < BaseObject
+    attr_accessor :priority, :protocol
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # The configured syslog priority.
+        :'priority' => :'priority',
+        
+        # The default syslog protocol to dial over. Defaults to TCP.
+        :'protocol' => :'protocol'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'priority' => :'Integer',
+        :'protocol' => :'String'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'priority']
+        self.priority = attributes[:'priority']
+      end
+      
+      if attributes[:'protocol']
+        self.protocol = attributes[:'protocol']
+      end
+      
+    end
+
+    def protocol=(protocol)
+      allowed_values = ["udp", "tcp"]
+      if protocol && !allowed_values.include?(protocol)
+        fail "invalid value for 'protocol', must be one of #{allowed_values}"
+      end
+      @protocol = protocol
+    end
+
+  end
+end

data/lib/apcera/models/file_listing.rb

@@ -0,0 +1,45 @@
+module Apcera
+  # 
+  class FileListing < BaseObject
+    attr_accessor :name, :size
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Name of the file or directory in the target path. Directory names are suffixed by a trailing forward slash (for example, `/app`).
+        :'name' => :'name',
+        
+        # Size of the file resource; not calculated for directories.
+        :'size' => :'size'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'name' => :'String',
+        :'size' => :'Float'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'name']
+        self.name = attributes[:'name']
+      end
+      
+      if attributes[:'size']
+        self.size = attributes[:'size']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/info.rb

@@ -0,0 +1,53 @@
+module Apcera
+  # 
+  class Info < BaseObject
+    attr_accessor :cluster_domain, :name, :url
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Cluster domain.
+        :'cluster_domain' => :'cluster_domain',
+        
+        # API server name. Currently contains \&quot;Continuum\&quot;.
+        :'name' => :'name',
+        
+        # URL of Apcera API Server (for example, api.try.apcera.net).
+        :'url' => :'url'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'cluster_domain' => :'String',
+        :'name' => :'String',
+        :'url' => :'String'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'cluster_domain']
+        self.cluster_domain = attributes[:'cluster_domain']
+      end
+      
+      if attributes[:'name']
+        self.name = attributes[:'name']
+      end
+      
+      if attributes[:'url']
+        self.url = attributes[:'url']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/instance_manager.rb

@@ -0,0 +1,105 @@
+module Apcera
+  # 
+  class InstanceManager < BaseObject
+    attr_accessor :resources_provisioned, :resources_total, :datacenter, :hostname, :num_instances, :start_time, :system_tags, :tags, :uuid
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'resources_provisioned' => :'ResourcesProvisioned',
+        
+        # 
+        :'resources_total' => :'ResourcesTotal',
+        
+        # 
+        :'datacenter' => :'datacenter',
+        
+        # Instance manager&#39;s host name.
+        :'hostname' => :'hostname',
+        
+        # The number of instances being managed by the instance manager.
+        :'num_instances' => :'num_instances',
+        
+        # Date and time that instance manager was started.
+        :'start_time' => :'start_time',
+        
+        # System tags assigned to the instance manager.
+        :'system_tags' => :'system_tags',
+        
+        # Tags assigned to the instance manager.
+        :'tags' => :'tags',
+        
+        # Instance manager&#39;s unique identifier.
+        :'uuid' => :'uuid'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'resources_provisioned' => :'Resource',
+        :'resources_total' => :'Resource',
+        :'datacenter' => :'String',
+        :'hostname' => :'String',
+        :'num_instances' => :'Integer',
+        :'start_time' => :'String',
+        :'system_tags' => :'Array<String>',
+        :'tags' => :'Array<String>',
+        :'uuid' => :'String'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'ResourcesProvisioned']
+        self.resources_provisioned = attributes[:'ResourcesProvisioned']
+      end
+      
+      if attributes[:'ResourcesTotal']
+        self.resources_total = attributes[:'ResourcesTotal']
+      end
+      
+      if attributes[:'datacenter']
+        self.datacenter = attributes[:'datacenter']
+      end
+      
+      if attributes[:'hostname']
+        self.hostname = attributes[:'hostname']
+      end
+      
+      if attributes[:'num_instances']
+        self.num_instances = attributes[:'num_instances']
+      end
+      
+      if attributes[:'start_time']
+        self.start_time = attributes[:'start_time']
+      end
+      
+      if attributes[:'system_tags']
+        if (value = attributes[:'system_tags']).is_a?(Array)
+          self.system_tags = value
+        end
+      end
+      
+      if attributes[:'tags']
+        if (value = attributes[:'tags']).is_a?(Array)
+          self.tags = value
+        end
+      end
+      
+      if attributes[:'uuid']
+        self.uuid = attributes[:'uuid']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/instance_state.rb

@@ -0,0 +1,117 @@
+module Apcera
+  # 
+  class InstanceState < BaseObject
+    attr_accessor :first_running, :new, :removed, :running, :setup, :starting, :starting_wait, :stopping, :stopping_wait, :teardown, :updating
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Number of instances where the job was started and is about to move into the `RUNNING` state.
+        :'first_running' => :'FIRST_RUNNING',
+        
+        # Number of instances in the `NEW` state.
+        :'new' => :'NEW',
+        
+        # Number of instances that are no longer consuming resources and have no remaining configuration on the system.
+        :'removed' => :'REMOVED',
+        
+        # Number of instances that are running.
+        :'running' => :'RUNNING',
+        
+        # Number of instances in which packages are being installed, networking initialized, etc.
+        :'setup' => :'SETUP',
+        
+        # Number of instances whose processes have been started, but have not been verified to be running.
+        :'starting' => :'STARTING',
+        
+        # Number of instances that are waiting for dependent jobs to become ready.
+        :'starting_wait' => :'STARTING_WAIT',
+        
+        # Number of instances that are in the process of having their processes shutdown.
+        :'stopping' => :'STOPPING',
+        
+        # Number of instances that are being stopped, but have jobs depending on it. In this case the other jobs must first transition past the `STOPPING` state before this instance can be stopped.
+        :'stopping_wait' => :'STOPPING_WAIT',
+        
+        # Number of instances whose user-defined processes have been killed, and the instance is being removed from cluster resources.
+        :'teardown' => :'TEARDOWN',
+        
+        # Number of instances that are in a state that allows the instance to update various properties of the container.
+        :'updating' => :'UPDATING'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'first_running' => :'Integer',
+        :'new' => :'Integer',
+        :'removed' => :'Integer',
+        :'running' => :'Integer',
+        :'setup' => :'Integer',
+        :'starting' => :'Integer',
+        :'starting_wait' => :'Integer',
+        :'stopping' => :'Integer',
+        :'stopping_wait' => :'Integer',
+        :'teardown' => :'Integer',
+        :'updating' => :'Integer'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'FIRST_RUNNING']
+        self.first_running = attributes[:'FIRST_RUNNING']
+      end
+      
+      if attributes[:'NEW']
+        self.new = attributes[:'NEW']
+      end
+      
+      if attributes[:'REMOVED']
+        self.removed = attributes[:'REMOVED']
+      end
+      
+      if attributes[:'RUNNING']
+        self.running = attributes[:'RUNNING']
+      end
+      
+      if attributes[:'SETUP']
+        self.setup = attributes[:'SETUP']
+      end
+      
+      if attributes[:'STARTING']
+        self.starting = attributes[:'STARTING']
+      end
+      
+      if attributes[:'STARTING_WAIT']
+        self.starting_wait = attributes[:'STARTING_WAIT']
+      end
+      
+      if attributes[:'STOPPING']
+        self.stopping = attributes[:'STOPPING']
+      end
+      
+      if attributes[:'STOPPING_WAIT']
+        self.stopping_wait = attributes[:'STOPPING_WAIT']
+      end
+      
+      if attributes[:'TEARDOWN']
+        self.teardown = attributes[:'TEARDOWN']
+      end
+      
+      if attributes[:'UPDATING']
+        self.updating = attributes[:'UPDATING']
+      end
+      
+    end
+
+  end
+end