apcera 0.1.1

data/lib/apcera/models/provider.rb

@@ -0,0 +1,85 @@
+module Apcera
+  # 
+  class Provider < BaseObject
+    attr_accessor :backing_job_fqn, :backing_job_port, :description, :fqn, :name, :type, :uuid
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Backing job&#39;s FQN.
+        :'backing_job_fqn' => :'backing_job_fqn',
+        
+        # Backing job&#39;s port.
+        :'backing_job_port' => :'backing_job_port',
+        
+        # Provider description.
+        :'description' => :'description',
+        
+        # Provider FQN (Fully Qualified Name).
+        :'fqn' => :'fqn',
+        
+        # Provider name.
+        :'name' => :'name',
+        
+        # Provider type (e.g. mysql, posgres).
+        :'type' => :'type',
+        
+        # Provider UUID.
+        :'uuid' => :'uuid'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'backing_job_fqn' => :'String',
+        :'backing_job_port' => :'String',
+        :'description' => :'String',
+        :'fqn' => :'String',
+        :'name' => :'String',
+        :'type' => :'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[:'backing_job_fqn']
+        self.backing_job_fqn = attributes[:'backing_job_fqn']
+      end
+      
+      if attributes[:'backing_job_port']
+        self.backing_job_port = attributes[:'backing_job_port']
+      end
+      
+      if attributes[:'description']
+        self.description = attributes[:'description']
+      end
+      
+      if attributes[:'fqn']
+        self.fqn = attributes[:'fqn']
+      end
+      
+      if attributes[:'name']
+        self.name = attributes[:'name']
+      end
+      
+      if attributes[:'type']
+        self.type = attributes[:'type']
+      end
+      
+      if attributes[:'uuid']
+        self.uuid = attributes[:'uuid']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/resource.rb

@@ -0,0 +1,69 @@
+module Apcera
+  # 
+  class Resource < BaseObject
+    attr_accessor :cpu, :disk, :memory, :netmax, :network
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Milliseconds of CPU time per second of physical time allocated to the job. May be greater than 1000ms/second in cases where time is across multiple cores.
+        :'cpu' => :'cpu',
+        
+        # Amount of disk space allocated to the job, in MB.
+        :'disk' => :'disk',
+        
+        # Memory allocated to job, in MB.
+        :'memory' => :'memory',
+        
+        # Maximum amount of network throughput (ceiling) allowed, in Mbps.
+        :'netmax' => :'netmax',
+        
+        # Amount of network throughput (floor) allocated to the job, in Mbps.
+        :'network' => :'network'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'cpu' => :'Integer',
+        :'disk' => :'Integer',
+        :'memory' => :'Integer',
+        :'netmax' => :'Integer',
+        :'network' => :'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[:'cpu']
+        self.cpu = attributes[:'cpu']
+      end
+      
+      if attributes[:'disk']
+        self.disk = attributes[:'disk']
+      end
+      
+      if attributes[:'memory']
+        self.memory = attributes[:'memory']
+      end
+      
+      if attributes[:'netmax']
+        self.netmax = attributes[:'netmax']
+      end
+      
+      if attributes[:'network']
+        self.network = attributes[:'network']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/restart_config.rb

@@ -0,0 +1,53 @@
+module Apcera
+  # 
+  class RestartConfig < BaseObject
+    attr_accessor :maximum_attempts, :restart_mode
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # The maximum number of restart attempts per instance, applies to `always` and `failure` restart modes. If set to 0 restarts are not limited.
+        :'maximum_attempts' => :'maximum_attempts',
+        
+        # The restart mode to use. Valid values are `always` (always restart), `no` (never restart), and `failure` (only restart on application failure).
+        :'restart_mode' => :'restart_mode'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'maximum_attempts' => :'Integer',
+        :'restart_mode' => :'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[:'maximum_attempts']
+        self.maximum_attempts = attributes[:'maximum_attempts']
+      end
+      
+      if attributes[:'restart_mode']
+        self.restart_mode = attributes[:'restart_mode']
+      end
+      
+    end
+
+    def restart_mode=(restart_mode)
+      allowed_values = ["always", "no", "failure"]
+      if restart_mode && !allowed_values.include?(restart_mode)
+        fail "invalid value for 'restart_mode', must be one of #{allowed_values}"
+      end
+      @restart_mode = restart_mode
+    end
+
+  end
+end

data/lib/apcera/models/rollout_config.rb

@@ -0,0 +1,69 @@
+module Apcera
+  # 
+  class RolloutConfig < BaseObject
+    attr_accessor :errored_state_window, :flapping_minimum_restarts, :flapping_percent, :flapping_window, :force_stop_old_instances_after
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # The number of seconds a job should be cycling between flapping states before being considered in an errored state and stop attempting any restarts.
+        :'errored_state_window' => :'errored_state_window',
+        
+        # The minimum number of tasks that must have failed in order to trigger a flapping state.
+        :'flapping_minimum_restarts' => :'flapping_minimum_restarts',
+        
+        # The number of instances that must have restarted in a given window for flapping to kick in.
+        :'flapping_percent' => :'flapping_percent',
+        
+        # The number of seconds over which the job&#39;s flapping window operates.
+        :'flapping_window' => :'flapping_window',
+        
+        # If this field is non-zero then it will be used to represent how long an old version of a job is allowed to exist in the cluster. If this is zero then no fixed length is established and updates will be applied by starting a new version and then only when that instance is running will the old instance be killed.
+        :'force_stop_old_instances_after' => :'force_stop_old_instances_after'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'errored_state_window' => :'Integer',
+        :'flapping_minimum_restarts' => :'Integer',
+        :'flapping_percent' => :'Float',
+        :'flapping_window' => :'Integer',
+        :'force_stop_old_instances_after' => :'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[:'errored_state_window']
+        self.errored_state_window = attributes[:'errored_state_window']
+      end
+      
+      if attributes[:'flapping_minimum_restarts']
+        self.flapping_minimum_restarts = attributes[:'flapping_minimum_restarts']
+      end
+      
+      if attributes[:'flapping_percent']
+        self.flapping_percent = attributes[:'flapping_percent']
+      end
+      
+      if attributes[:'flapping_window']
+        self.flapping_window = attributes[:'flapping_window']
+      end
+      
+      if attributes[:'force_stop_old_instances_after']
+        self.force_stop_old_instances_after = attributes[:'force_stop_old_instances_after']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/route.rb

@@ -0,0 +1,53 @@
+module Apcera
+  # 
+  class Route < BaseObject
+    attr_accessor :endpoint, :type, :weight
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # The URI where the traffic should being routed to. For HTTP routes, the value should contain the route&#39;s host and path; for TCP routes, the value should take the form of \&quot;ip:port\&quot;.
+        :'endpoint' => :'endpoint',
+        
+        # The type of route. Valid values are `http` or `tcp`.
+        :'type' => :'type',
+        
+        # A value between 0 and 1 that specifies the route&#39;s weight, which is used to balance incoming traffic across apps that share the route. Weights are not on a specific scale; weights of all routes for a given job are normalized.
+        :'weight' => :'weight'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'endpoint' => :'String',
+        :'type' => :'String',
+        :'weight' => :'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[:'endpoint']
+        self.endpoint = attributes[:'endpoint']
+      end
+      
+      if attributes[:'type']
+        self.type = attributes[:'type']
+      end
+      
+      if attributes[:'weight']
+        self.weight = attributes[:'weight']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/rule.rb

@@ -0,0 +1,101 @@
+module Apcera
+  # 
+  class Rule < BaseObject
+    attr_accessor :action, :created_at, :created_by, :fqn, :job, :provider, :service, :type, :version_id
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # The type of action to take when the rule is triggered. Can either by &#39;hook&#39; or &#39;notification&#39;.
+        :'action' => :'action',
+        
+        # UNIX timestamp when event rule was created.
+        :'created_at' => :'created_at',
+        
+        # Principal name of user who created the event rule.
+        :'created_by' => :'created_by',
+        
+        # The rule&#39;s fully-qualified name against which policy may be enforced.
+        :'fqn' => :'fqn',
+        
+        # FQN of the job to enforce the rule against.
+        :'job' => :'job',
+        
+        # FQN of the provider to enforce this rule against. In only `provider` is populated for this rule, then all semantic pipelines consuming a provider matching this FQN will have the rule enforced against them.
+        :'provider' => :'provider',
+        
+        # FQN of the service to enforce this rule against. If only `service` is populated for this rule, then all semantic pipelines consuming a service matching this FQN will have the rule enforced against them.
+        :'service' => :'service',
+        
+        # Type depends upon specified `action` of event rule, and can specify the timing of the hook firing.
+        :'type' => :'type',
+        
+        # Rule&#39;s auto-incremented version number.
+        :'version_id' => :'version_id'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'action' => :'String',
+        :'created_at' => :'Float',
+        :'created_by' => :'String',
+        :'fqn' => :'String',
+        :'job' => :'String',
+        :'provider' => :'String',
+        :'service' => :'String',
+        :'type' => :'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[:'action']
+        self.action = attributes[:'action']
+      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[:'fqn']
+        self.fqn = attributes[:'fqn']
+      end
+      
+      if attributes[:'job']
+        self.job = attributes[:'job']
+      end
+      
+      if attributes[:'provider']
+        self.provider = attributes[:'provider']
+      end
+      
+      if attributes[:'service']
+        self.service = attributes[:'service']
+      end
+      
+      if attributes[:'type']
+        self.type = attributes[:'type']
+      end
+      
+      if attributes[:'version_id']
+        self.version_id = attributes[:'version_id']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/runtime.rb

@@ -0,0 +1,47 @@
+module Apcera
+  # 
+  class Runtime < BaseObject
+    attr_accessor :patterns, :runtime
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # An array of file names or patterns used to select the appropriate runtime.
+        :'patterns' => :'patterns',
+        
+        # Identfies the runtime (for example, \&quot;bash\&quot;, or \&quot;perl\&quot;).
+        :'runtime' => :'runtime'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'patterns' => :'Array<String>',
+        :'runtime' => :'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[:'patterns']
+        if (value = attributes[:'patterns']).is_a?(Array)
+          self.patterns = value
+        end
+      end
+      
+      if attributes[:'runtime']
+        self.runtime = attributes[:'runtime']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/semi_pipe_rule.rb

@@ -0,0 +1,101 @@
+module Apcera
+  # 
+  class SemiPipeRule < BaseObject
+    attr_accessor :action, :created_at, :created_by, :job, :name, :provider, :service, :type, :uuid
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'action' => :'action',
+        
+        # Date-time when rule was created.
+        :'created_at' => :'created_at',
+        
+        # User that created the rule.
+        :'created_by' => :'created_by',
+        
+        # Specific job that rule applies to.
+        :'job' => :'job',
+        
+        # Rule name.
+        :'name' => :'name',
+        
+        # Provider used to provision the service, if any.
+        :'provider' => :'provider',
+        
+        # FQN of service to which the rule applies.
+        :'service' => :'service',
+        
+        # Rule type.
+        :'type' => :'type',
+        
+        # Rule&#39;s unique identifier.
+        :'uuid' => :'uuid'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'action' => :'SemiPipeRuleAction',
+        :'created_at' => :'DateTime',
+        :'created_by' => :'String',
+        :'job' => :'String',
+        :'name' => :'String',
+        :'provider' => :'String',
+        :'service' => :'String',
+        :'type' => :'Integer',
+        :'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[:'action']
+        self.action = attributes[:'action']
+      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[:'job']
+        self.job = attributes[:'job']
+      end
+      
+      if attributes[:'name']
+        self.name = attributes[:'name']
+      end
+      
+      if attributes[:'provider']
+        self.provider = attributes[:'provider']
+      end
+      
+      if attributes[:'service']
+        self.service = attributes[:'service']
+      end
+      
+      if attributes[:'type']
+        self.type = attributes[:'type']
+      end
+      
+      if attributes[:'uuid']
+        self.uuid = attributes[:'uuid']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/semi_pipe_rule_action.rb

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

data/lib/apcera/models/stager_job.rb

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