apcera 0.1.1

data/lib/apcera/models/instances.rb

@@ -0,0 +1,109 @@
+module Apcera
+  # 
+  class Instances < BaseObject
+    attr_accessor :announced_routes, :created_time, :exit_code, :exited, :failed, :host, :instance_manager, :job_version_id, :state, :uuid
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Indicates whether the routes for this instance have been announced.
+        :'announced_routes' => :'announced_routes',
+        
+        # UNIX timestamp for when instance was created.
+        :'created_time' => :'created_time',
+        
+        # Exit code of the main processes; should only be checked if `exited` is `true`.
+        :'exit_code' => :'exit_code',
+        
+        # Set to true if the instance started and its main process managed to exit.
+        :'exited' => :'exited',
+        
+        # Set to `true` if the instance has failed in some way.
+        :'failed' => :'failed',
+        
+        # Name of the host the instance is running on.
+        :'host' => :'host',
+        
+        # UUID of the instance manager running the instance.
+        :'instance_manager' => :'instance_manager',
+        
+        # The sequence number of the job the instance is running.
+        :'job_version_id' => :'job_version_id',
+        
+        # State of the instance.
+        :'state' => :'state',
+        
+        # The instance&#39;s unique identifier.
+        :'uuid' => :'uuid'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'announced_routes' => :'BOOLEAN',
+        :'created_time' => :'Float',
+        :'exit_code' => :'Integer',
+        :'exited' => :'BOOLEAN',
+        :'failed' => :'BOOLEAN',
+        :'host' => :'String',
+        :'instance_manager' => :'String',
+        :'job_version_id' => :'Integer',
+        :'state' => :'InstanceState',
+        :'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[:'announced_routes']
+        self.announced_routes = attributes[:'announced_routes']
+      end
+      
+      if attributes[:'created_time']
+        self.created_time = attributes[:'created_time']
+      end
+      
+      if attributes[:'exit_code']
+        self.exit_code = attributes[:'exit_code']
+      end
+      
+      if attributes[:'exited']
+        self.exited = attributes[:'exited']
+      end
+      
+      if attributes[:'failed']
+        self.failed = attributes[:'failed']
+      end
+      
+      if attributes[:'host']
+        self.host = attributes[:'host']
+      end
+      
+      if attributes[:'instance_manager']
+        self.instance_manager = attributes[:'instance_manager']
+      end
+      
+      if attributes[:'job_version_id']
+        self.job_version_id = attributes[:'job_version_id']
+      end
+      
+      if attributes[:'state']
+        self.state = attributes[:'state']
+      end
+      
+      if attributes[:'uuid']
+        self.uuid = attributes[:'uuid']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/job.rb

@@ -0,0 +1,243 @@
+module Apcera
+  # 
+  class Job < BaseObject
+    attr_accessor :bindings, :created_at, :created_by, :docker_origin, :fqn, :hard_scheduling_tags, :health, :logs, :name, :num_instances, :packages, :ports, :processes, :resources, :restart, :rollout, :soft_scheduling_tags, :state, :tags, :updated_at, :updated_by, :uuid, :version_id, :weight
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # A list of service bindings associated with the job.
+        :'bindings' => :'bindings',
+        
+        # Time at which the job was created.
+        :'created_at' => :'created_at',
+        
+        # The principal name of user who created the job.
+        :'created_by' => :'created_by',
+        
+        # For jobs that run Docker images, specifies the Docker registry, image name and tag that were used to create the job. This field can&#39;t be changed after the job is created.
+        :'docker_origin' => :'docker_origin',
+        
+        # Job&#39;s fully-qualified name.
+        :'fqn' => :'fqn',
+        
+        # List of hard scheduling tags. See [Hard Tags](http://enterprise-docs.apcera.com/other/job-scheduling/#hard-tags) for more information.
+        :'hard_scheduling_tags' => :'hard_scheduling_tags',
+        
+        # Indicates the health of the job. If empty then the job&#39;s health has not been retrieved from the health manager yet.
+        :'health' => :'health',
+        
+        # An array of logs the job will be producing that should be collected for aggregation or streaming.
+        :'logs' => :'logs',
+        
+        # Name of the job.
+        :'name' => :'name',
+        
+        # The number of job instances currently running.
+        :'num_instances' => :'num_instances',
+        
+        # Array of packages for this Job. Includes both user-specified packages and the packages calculated by the package manager.
+        :'packages' => :'packages',
+        
+        # An array of ports associated with the job.
+        :'ports' => :'ports',
+        
+        # A list of processes associated with the job.
+        :'processes' => :'processes',
+        
+        # A list of compute and network resources that this job can consume.
+        :'resources' => :'resources',
+        
+        # Configuration related to restarting the job.
+        :'restart' => :'restart',
+        
+        # Configuration related to rolling updates of the job.
+        :'rollout' => :'rollout',
+        
+        # List of soft scheduling tags. See [Soft Tags](http://enterprise-docs.apcera.com/other/job-scheduling/#soft-tags) for more information.
+        :'soft_scheduling_tags' => :'soft_scheduling_tags',
+        
+        # General state of this Job in the system.
+        :'state' => :'state',
+        
+        # Map of tags (arbitrary strings) to values.
+        :'tags' => :'tags',
+        
+        # Time at which the job was most recently updated.
+        :'updated_at' => :'updated_at',
+        
+        # The principal name of the last user to update the job.
+        :'updated_by' => :'updated_by',
+        
+        # The job&#39;s unique identifier.
+        :'uuid' => :'uuid',
+        
+        # An auto-incremented number that indicates the revision of the object.
+        :'version_id' => :'version_id',
+        
+        # A job&#39;s weight is used to route requests to this job relative to other job that have the same routes. See [Sharing Routes and Route Weights](http://docs.apcera.com/jobs/routes/#about-route-weights).
+        :'weight' => :'weight'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'bindings' => :'Hash<String, Binding>',
+        :'created_at' => :'DateTime',
+        :'created_by' => :'String',
+        :'docker_origin' => :'DockerOrigin',
+        :'fqn' => :'String',
+        :'hard_scheduling_tags' => :'Hash<String, BOOLEAN>',
+        :'health' => :'JobHealth',
+        :'logs' => :'Array<Log>',
+        :'name' => :'String',
+        :'num_instances' => :'Integer',
+        :'packages' => :'Array<PackageInfo>',
+        :'ports' => :'Array<Port>',
+        :'processes' => :'Process',
+        :'resources' => :'Resource',
+        :'restart' => :'RestartConfig',
+        :'rollout' => :'RolloutConfig',
+        :'soft_scheduling_tags' => :'Hash<String, BOOLEAN>',
+        :'state' => :'String',
+        :'tags' => :'Hash<String, String>',
+        :'updated_at' => :'DateTime',
+        :'updated_by' => :'String',
+        :'uuid' => :'String',
+        :'version_id' => :'Integer',
+        :'weight' => :'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[:'bindings']
+        if (value = attributes[:'bindings']).is_a?(Array)
+          self.bindings = value
+        end
+      end
+      
+      if attributes[:'created_at']
+        self.created_at = attributes[:'created_at']
+      end
+      
+      if attributes[:'created_by']
+        self.created_by = attributes[:'created_by']
+      end
+      
+      if attributes[:'docker_origin']
+        self.docker_origin = attributes[:'docker_origin']
+      end
+      
+      if attributes[:'fqn']
+        self.fqn = attributes[:'fqn']
+      end
+      
+      if attributes[:'hard_scheduling_tags']
+        if (value = attributes[:'hard_scheduling_tags']).is_a?(Array)
+          self.hard_scheduling_tags = value
+        end
+      end
+      
+      if attributes[:'health']
+        self.health = attributes[:'health']
+      end
+      
+      if attributes[:'logs']
+        if (value = attributes[:'logs']).is_a?(Array)
+          self.logs = value
+        end
+      end
+      
+      if attributes[:'name']
+        self.name = attributes[:'name']
+      end
+      
+      if attributes[:'num_instances']
+        self.num_instances = attributes[:'num_instances']
+      end
+      
+      if attributes[:'packages']
+        if (value = attributes[:'packages']).is_a?(Array)
+          self.packages = value
+        end
+      end
+      
+      if attributes[:'ports']
+        if (value = attributes[:'ports']).is_a?(Array)
+          self.ports = value
+        end
+      end
+      
+      if attributes[:'processes']
+        self.processes = attributes[:'processes']
+      end
+      
+      if attributes[:'resources']
+        self.resources = attributes[:'resources']
+      end
+      
+      if attributes[:'restart']
+        self.restart = attributes[:'restart']
+      end
+      
+      if attributes[:'rollout']
+        self.rollout = attributes[:'rollout']
+      end
+      
+      if attributes[:'soft_scheduling_tags']
+        if (value = attributes[:'soft_scheduling_tags']).is_a?(Array)
+          self.soft_scheduling_tags = value
+        end
+      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
+      
+      if attributes[:'weight']
+        self.weight = attributes[:'weight']
+      end
+      
+    end
+
+    def state=(state)
+      allowed_values = ["invalid", "unknown", "created", "errored", "staging", "staging_failed", "ready", "started", "stopped", "finished"]
+      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/job_health.rb

@@ -0,0 +1,63 @@
+module Apcera
+  # 
+  class JobHealth < BaseObject
+    attr_accessor :flapping, :instance_state_count, :score, :uuid
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Indicates if job is in a flapping state (true) or not (false).
+        :'flapping' => :'flapping',
+        
+        # Map of instance states to the number of instances in that state, as reported by the health manager.
+        :'instance_state_count' => :'instance_state_count',
+        
+        # Score is the ratio of running instances to configured instances, capped between 0 and 1.
+        :'score' => :'score',
+        
+        # UUID of the job.
+        :'uuid' => :'uuid'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'flapping' => :'BOOLEAN',
+        :'instance_state_count' => :'Hash<String, InstanceState>',
+        :'score' => :'Integer',
+        :'uuid' => :'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[:'flapping']
+        self.flapping = attributes[:'flapping']
+      end
+      
+      if attributes[:'instance_state_count']
+        if (value = attributes[:'instance_state_count']).is_a?(Array)
+          self.instance_state_count = value
+        end
+      end
+      
+      if attributes[:'score']
+        self.score = attributes[:'score']
+      end
+      
+      if attributes[:'uuid']
+        self.uuid = attributes[:'uuid']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/job_preferences.rb

@@ -0,0 +1,37 @@
+module Apcera
+  # 
+  class JobPreferences < BaseObject
+    attr_accessor :docker_cache_namespace
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # The package namespace where Docker jobs should look for cached packages.
+        :'docker_cache_namespace' => :'docker_cache_namespace'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'docker_cache_namespace' => :'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[:'docker_cache_namespace']
+        self.docker_cache_namespace = attributes[:'docker_cache_namespace']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/log.rb

@@ -0,0 +1,53 @@
+module Apcera
+  # 
+  class Log < BaseObject
+    attr_accessor :channel, :file, :jobid
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # The name of the channel that the log should be published on.
+        :'channel' => :'channel',
+        
+        # The path to the log file within the job&#39;s container that should be collected.
+        :'file' => :'file',
+        
+        # UUID of the job generating the log.
+        :'jobid' => :'jobid'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'channel' => :'String',
+        :'file' => :'String',
+        :'jobid' => :'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[:'channel']
+        self.channel = attributes[:'channel']
+      end
+      
+      if attributes[:'file']
+        self.file = attributes[:'file']
+      end
+      
+      if attributes[:'jobid']
+        self.jobid = attributes[:'jobid']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/metric_series.rb

@@ -0,0 +1,49 @@
+module Apcera
+  # 
+  class MetricSeries < BaseObject
+    attr_accessor :times, :values
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # times
+        :'times' => :'times',
+        
+        # times
+        :'values' => :'values'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'times' => :'Array<Integer>',
+        :'values' => :'Array<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[:'times']
+        if (value = attributes[:'times']).is_a?(Array)
+          self.times = value
+        end
+      end
+      
+      if attributes[:'values']
+        if (value = attributes[:'values']).is_a?(Array)
+          self.values = value
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/metric_series_hash.rb

@@ -0,0 +1,29 @@
+module Apcera
+  # 
+  class MetricSeriesHash < BaseObject
+    attr_accessor 
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        
+      }
+    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}
+
+      
+    end
+
+  end
+end

data/lib/apcera/models/metrics.rb

@@ -0,0 +1,49 @@
+module Apcera
+  # 
+  class Metrics < BaseObject
+    attr_accessor :errors, :metrics
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # A hash list of errors
+        :'errors' => :'errors',
+        
+        # 
+        :'metrics' => :'metrics'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'errors' => :'Hash<String, String>',
+        :'metrics' => :'Hash<String, MetricSeriesHash>'
+        
+      }
+    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[:'metrics']
+        if (value = attributes[:'metrics']).is_a?(Array)
+          self.metrics = value
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/namespace.rb

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