apcera 0.1.1

data/lib/apcera/models/package.rb

@@ -0,0 +1,183 @@
+module Apcera
+  # 
+  class Package < BaseObject
+    attr_accessor :created_at, :created_by, :dependencies, :environment, :error_message, :fqn, :name, :provides, :resource, :resources, :staging_pipeline, :staging_pipeline_fqn, :state, :tags, :updated_at, :updated_by, :uuid, :version_id
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # The date and time when the package was created.
+        :'created_at' => :'created_at',
+        
+        # Principal name of the user who created the package.
+        :'created_by' => :'created_by',
+        
+        # List of dependencies that the package has in order to be used. A dependency expresses a requirement that a package has on an other package.
+        :'dependencies' => :'dependencies',
+        
+        # List of environment variables that are added to any process that uses the package.
+        :'environment' => :'environment',
+        
+        # Error encountered during an asynchronous operation on the package. An example is a failure encountered during instance snapshot; the ErrorMessage field on the created snapshot package would contain more information.
+        :'error_message' => :'error_message',
+        
+        # Package&#39;s fully-qualified name.
+        :'fqn' => :'fqn',
+        
+        # Package name.
+        :'name' => :'name',
+        
+        # List of &#39;provides&#39; that the package provides for other packages to use. A &#39;provide&#39; expresses a named resource that other packages or jobs can add as a dependency.
+        :'provides' => :'provides',
+        
+        # Deprecated. Use `resources`. An object that describes the package&#39;s associated binary resource.
+        :'resource' => :'resource',
+        
+        # An list of objects that describes the package&#39;s associated binary resources.
+        :'resources' => :'resources',
+        
+        # The UUID of the staging pipeline used to stage this package into a runnable state.
+        :'staging_pipeline' => :'staging_pipeline',
+        
+        # The fully-qualified name of the staging pipeline used to stage the package.
+        :'staging_pipeline_fqn' => :'staging_pipeline_fqn',
+        
+        # Package state. Possible values are `uploading`, &#39;staging`, `failed`, `ready`, `deleted`, and `unknown`.
+        :'state' => :'state',
+        
+        # Map of tags by tag name.
+        :'tags' => :'tags',
+        
+        # The date and time when the package was most recently updated.
+        :'updated_at' => :'updated_at',
+        
+        # Principal name of the last user to update the package.
+        :'updated_by' => :'updated_by',
+        
+        # The package&#39;s unique identifier.
+        :'uuid' => :'uuid',
+        
+        # Package&#39;s auto-incremented version number.
+        :'version_id' => :'version_id'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'created_at' => :'DateTime',
+        :'created_by' => :'String',
+        :'dependencies' => :'Array<Dependency>',
+        :'environment' => :'Hash<String, String>',
+        :'error_message' => :'String',
+        :'fqn' => :'String',
+        :'name' => :'String',
+        :'provides' => :'Array<Provide>',
+        :'resource' => :'PackageResource',
+        :'resources' => :'Array<PackageResource>',
+        :'staging_pipeline' => :'String',
+        :'staging_pipeline_fqn' => :'String',
+        :'state' => :'String',
+        :'tags' => :'Hash<String, String>',
+        :'updated_at' => :'DateTime',
+        :'updated_by' => :'String',
+        :'uuid' => :'String',
+        :'version_id' => :'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[:'created_at']
+        self.created_at = attributes[:'created_at']
+      end
+      
+      if attributes[:'created_by']
+        self.created_by = attributes[:'created_by']
+      end
+      
+      if attributes[:'dependencies']
+        if (value = attributes[:'dependencies']).is_a?(Array)
+          self.dependencies = value
+        end
+      end
+      
+      if attributes[:'environment']
+        if (value = attributes[:'environment']).is_a?(Array)
+          self.environment = value
+        end
+      end
+      
+      if attributes[:'error_message']
+        self.error_message = attributes[:'error_message']
+      end
+      
+      if attributes[:'fqn']
+        self.fqn = attributes[:'fqn']
+      end
+      
+      if attributes[:'name']
+        self.name = attributes[:'name']
+      end
+      
+      if attributes[:'provides']
+        if (value = attributes[:'provides']).is_a?(Array)
+          self.provides = value
+        end
+      end
+      
+      if attributes[:'resource']
+        self.resource = attributes[:'resource']
+      end
+      
+      if attributes[:'resources']
+        if (value = attributes[:'resources']).is_a?(Array)
+          self.resources = value
+        end
+      end
+      
+      if attributes[:'staging_pipeline']
+        self.staging_pipeline = attributes[:'staging_pipeline']
+      end
+      
+      if attributes[:'staging_pipeline_fqn']
+        self.staging_pipeline_fqn = attributes[:'staging_pipeline_fqn']
+      end
+      
+      if attributes[:'state']
+        self.state = attributes[:'state']
+      end
+      
+      if attributes[:'tags']
+        if (value = attributes[:'tags']).is_a?(Array)
+          self.tags = value
+        end
+      end
+      
+      if attributes[:'updated_at']
+        self.updated_at = attributes[:'updated_at']
+      end
+      
+      if attributes[:'updated_by']
+        self.updated_by = attributes[:'updated_by']
+      end
+      
+      if attributes[:'uuid']
+        self.uuid = attributes[:'uuid']
+      end
+      
+      if attributes[:'version_id']
+        self.version_id = attributes[:'version_id']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/package_depends_request.rb

@@ -0,0 +1,47 @@
+module Apcera
+  # 
+  class PackageDependsRequest < BaseObject
+    attr_accessor :dependencies, :job_target
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'dependencies' => :'dependencies',
+        
+        # Namespace in which dependencies will be resolved (e.g. the namespace of a job that is being staged, the namespace of the user requesting the resolution).
+        :'job_target' => :'job_target'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'dependencies' => :'Array<DependencyResolve>',
+        :'job_target' => :'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[:'dependencies']
+        if (value = attributes[:'dependencies']).is_a?(Array)
+          self.dependencies = value
+        end
+      end
+      
+      if attributes[:'job_target']
+        self.job_target = attributes[:'job_target']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/package_info.rb

@@ -0,0 +1,69 @@
+module Apcera
+  # 
+  class PackageInfo < BaseObject
+    attr_accessor :source, :state, :uuid
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # The source of the package, whether it was provided by the user or calculated by the Package Manager.
+        :'source' => :'source',
+        
+        # Represents the availability of the package.
+        :'state' => :'state',
+        
+        # UUID of the package.
+        :'uuid' => :'uuid'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'source' => :'String',
+        :'state' => :'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[:'source']
+        self.source = attributes[:'source']
+      end
+      
+      if attributes[:'state']
+        self.state = attributes[:'state']
+      end
+      
+      if attributes[:'uuid']
+        self.uuid = attributes[:'uuid']
+      end
+      
+    end
+
+    def source=(source)
+      allowed_values = ["user", "system"]
+      if source && !allowed_values.include?(source)
+        fail "invalid value for 'source', must be one of #{allowed_values}"
+      end
+      @source = source
+    end
+
+    def state=(state)
+      allowed_values = ["unknown", "uploading", "staging", "failed", "ready", "deleted"]
+      if state && !allowed_values.include?(state)
+        fail "invalid value for 'state', must be one of #{allowed_values}"
+      end
+      @state = state
+    end
+
+  end
+end

data/lib/apcera/models/package_resource.rb

@@ -0,0 +1,61 @@
+module Apcera
+  # 
+  class PackageResource < BaseObject
+    attr_accessor :digest, :length, :sha1, :uuid
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # A hash of the binary resource prefixed by its algorithm (e.g. &#39;sha1:abcd...&#39;).
+        :'digest' => :'digest',
+        
+        # The length of the binary resource in bytes.
+        :'length' => :'length',
+        
+        # A hash of the binary resource.
+        :'sha1' => :'sha1',
+        
+        # The package resource&#39;s unique identifier.
+        :'uuid' => :'uuid'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'digest' => :'String',
+        :'length' => :'Integer',
+        :'sha1' => :'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[:'digest']
+        self.digest = attributes[:'digest']
+      end
+      
+      if attributes[:'length']
+        self.length = attributes[:'length']
+      end
+      
+      if attributes[:'sha1']
+        self.sha1 = attributes[:'sha1']
+      end
+      
+      if attributes[:'uuid']
+        self.uuid = attributes[:'uuid']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/policy_error.rb

@@ -0,0 +1,63 @@
+module Apcera
+  # 
+  class PolicyError < BaseObject
+    attr_accessor :errors, :job, :job_changed, :repairable
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # An array of specific policy errors that occurred.
+        :'errors' => :'errors',
+        
+        # A reference to the job associated with the policy error.
+        :'job' => :'job',
+        
+        # If `true`, the policy error was the result of changes to a job.
+        :'job_changed' => :'job_changed',
+        
+        # If `true`, the error is repairable.
+        :'repairable' => :'repairable'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'errors' => :'Array<String>',
+        :'job' => :'Job',
+        :'job_changed' => :'BOOLEAN',
+        :'repairable' => :'BOOLEAN'
+        
+      }
+    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[:'errors']
+        if (value = attributes[:'errors']).is_a?(Array)
+          self.errors = value
+        end
+      end
+      
+      if attributes[:'job']
+        self.job = attributes[:'job']
+      end
+      
+      if attributes[:'job_changed']
+        self.job_changed = attributes[:'job_changed']
+      end
+      
+      if attributes[:'repairable']
+        self.repairable = attributes[:'repairable']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/port.rb

@@ -0,0 +1,55 @@
+module Apcera
+  # 
+  class Port < BaseObject
+    attr_accessor :number, :optional, :routes
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # The numerical port exposed for connectivity.
+        :'number' => :'number',
+        
+        # A value of `true` indicates that the instance manager (IM) should attempt to verify that connectivity has been established for this port; if `false`, no such verification occurs.
+        :'optional' => :'optional',
+        
+        # An array of URLs to map to the port.
+        :'routes' => :'routes'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'number' => :'Integer',
+        :'optional' => :'BOOLEAN',
+        :'routes' => :'Array<Route>'
+        
+      }
+    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[:'number']
+        self.number = attributes[:'number']
+      end
+      
+      if attributes[:'optional']
+        self.optional = attributes[:'optional']
+      end
+      
+      if attributes[:'routes']
+        if (value = attributes[:'routes']).is_a?(Array)
+          self.routes = value
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/process.rb

@@ -0,0 +1,37 @@
+module Apcera
+  # 
+  class Process < BaseObject
+    attr_accessor :app
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'app' => :'app'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'app' => :'ProcessObject'
+        
+      }
+    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[:'app']
+        self.app = attributes[:'app']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/process_object.rb

@@ -0,0 +1,115 @@
+module Apcera
+  # 
+  class ProcessObject < BaseObject
+    attr_accessor :environment, :group, :heavy, :start_command, :start_command_raw, :start_command_timeout, :stop_command, :stop_command_raw, :stop_timeout, :user
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # An optional list of environment values to attach to the process within the job.
+        :'environment' => :'environment',
+        
+        # Name of the group used to run the process within a container. An empty string lets the the instance manager choose a group.
+        :'group' => :'group',
+        
+        # Start the process in \&quot;heavy\&quot; mode: giving it pid 1.  Only one process within the job can set this flag to true.
+        :'heavy' => :'heavy',
+        
+        # The command used to start the process within the container&#39;s isolation context.
+        :'start_command' => :'start_command',
+        
+        # The command used to start the process, specified as an array. The first element in the array is the command/binary to execute, and subsequent array elements are command arguments. The expanded command string is passed directly to `exec()` without shell or template interpretation.  If `start_command_raw` is provided then `start_command`, if specified, is ignored. This property is typically used with exact processes that have an extremely well-known start command.
+        :'start_command_raw' => :'start_command_raw',
+        
+        # The number of seconds that the system will wait for startup to complete. This includes the time that it will take for ports to become available.
+        :'start_command_timeout' => :'start_command_timeout',
+        
+        # The command used to stop the process within the container&#39;s isolation context. If not defined, OS-level signals (like `TERM`) may be used to shut down the process.
+        :'stop_command' => :'stop_command',
+        
+        # The command used to stop the process, specified as an array. The first element in the array is the command/binary to execute, and subsequent array elements are command arguments. The expanded command string is passed directly to `exec()` without shell or template interpretation.  If `stop_command_raw` is provided then `stop_command`, if specified, is ignored. This property is typically used with exact processes that have an extremely well-known start command.
+        :'stop_command_raw' => :'stop_command_raw',
+        
+        # The number of seconds to give the process after `stop_command` has been run before forcing the command to shutdown via OS-level signals, such as `TERM`. If no `stop_command` is provided for the process, OS-level signals (like `TERM`) may be used to terminate the process.
+        :'stop_timeout' => :'stop_timeout',
+        
+        # Name of the user used to run the process within a container. An empty string lets the the instance manager choose a user.
+        :'user' => :'user'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'environment' => :'Hash<String, String>',
+        :'group' => :'String',
+        :'heavy' => :'BOOLEAN',
+        :'start_command' => :'String',
+        :'start_command_raw' => :'Array<String>',
+        :'start_command_timeout' => :'Integer',
+        :'stop_command' => :'String',
+        :'stop_command_raw' => :'Array<String>',
+        :'stop_timeout' => :'Integer',
+        :'user' => :'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[:'environment']
+        if (value = attributes[:'environment']).is_a?(Array)
+          self.environment = value
+        end
+      end
+      
+      if attributes[:'group']
+        self.group = attributes[:'group']
+      end
+      
+      if attributes[:'heavy']
+        self.heavy = attributes[:'heavy']
+      end
+      
+      if attributes[:'start_command']
+        self.start_command = attributes[:'start_command']
+      end
+      
+      if attributes[:'start_command_raw']
+        if (value = attributes[:'start_command_raw']).is_a?(Array)
+          self.start_command_raw = value
+        end
+      end
+      
+      if attributes[:'start_command_timeout']
+        self.start_command_timeout = attributes[:'start_command_timeout']
+      end
+      
+      if attributes[:'stop_command']
+        self.stop_command = attributes[:'stop_command']
+      end
+      
+      if attributes[:'stop_command_raw']
+        if (value = attributes[:'stop_command_raw']).is_a?(Array)
+          self.stop_command_raw = value
+        end
+      end
+      
+      if attributes[:'stop_timeout']
+        self.stop_timeout = attributes[:'stop_timeout']
+      end
+      
+      if attributes[:'user']
+        self.user = attributes[:'user']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/provide.rb

@@ -0,0 +1,53 @@
+module Apcera
+  # 
+  class Provide < 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 provided (e.g., &#39;java&#39;, &#39;apache-2.2&#39;).
+        :'name' => :'name',
+        
+        # The type of provide. Possible 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