apcera 0.1.1

data/lib/apcera/models/audit_log_item.rb

@@ -0,0 +1,117 @@
+module Apcera
+  # 
+  class AuditLogItem < BaseObject
+    attr_accessor :event_type, :event_type_int, :fqn, :localname, :namespace, :on_behalf_of, :payload, :principal_name, :resource_type, :timestamp, :uuid
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Event type.
+        :'event_type' => :'event_type',
+        
+        # Integer used as the index of an enumeration of human-readable event types (see `event_type`).
+        :'event_type_int' => :'event_type_int',
+        
+        # Fully-qualified name of the resource on which the auditable action was attempted.
+        :'fqn' => :'fqn',
+        
+        # Local name of the resource on which the auditable action was attempted.
+        :'localname' => :'localname',
+        
+        # Namespace of the resource on which the auditable action was attempted.
+        :'namespace' => :'namespace',
+        
+        # Username on whose behalf the auditable action was attempted by `principal_name`.
+        :'on_behalf_of' => :'on_behalf_of',
+        
+        # Simple structured auditing data like JSON output.
+        :'payload' => :'payload',
+        
+        # The actor (API Server or Health Manager, for example) or user that attempted the auditable action.
+        :'principal_name' => :'principal_name',
+        
+        # The resource type on which the auditable action was attempted.
+        :'resource_type' => :'resource_type',
+        
+        # UNIX timestamp that indicates when the event occurred.
+        :'timestamp' => :'timestamp',
+        
+        # Unique identifier for the audit log entry.
+        :'uuid' => :'uuid'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'event_type' => :'String',
+        :'event_type_int' => :'Integer',
+        :'fqn' => :'String',
+        :'localname' => :'String',
+        :'namespace' => :'String',
+        :'on_behalf_of' => :'String',
+        :'payload' => :'String',
+        :'principal_name' => :'String',
+        :'resource_type' => :'String',
+        :'timestamp' => :'Float',
+        :'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[:'event_type']
+        self.event_type = attributes[:'event_type']
+      end
+      
+      if attributes[:'event_type_int']
+        self.event_type_int = attributes[:'event_type_int']
+      end
+      
+      if attributes[:'fqn']
+        self.fqn = attributes[:'fqn']
+      end
+      
+      if attributes[:'localname']
+        self.localname = attributes[:'localname']
+      end
+      
+      if attributes[:'namespace']
+        self.namespace = attributes[:'namespace']
+      end
+      
+      if attributes[:'on_behalf_of']
+        self.on_behalf_of = attributes[:'on_behalf_of']
+      end
+      
+      if attributes[:'payload']
+        self.payload = attributes[:'payload']
+      end
+      
+      if attributes[:'principal_name']
+        self.principal_name = attributes[:'principal_name']
+      end
+      
+      if attributes[:'resource_type']
+        self.resource_type = attributes[:'resource_type']
+      end
+      
+      if attributes[:'timestamp']
+        self.timestamp = attributes[:'timestamp']
+      end
+      
+      if attributes[:'uuid']
+        self.uuid = attributes[:'uuid']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/audit_log_item_old.rb

@@ -0,0 +1,85 @@
+module Apcera
+  # 
+  class AuditLogItemOld < BaseObject
+    attr_accessor :action, :allowed, :method, :requester_addr, :resp_msg, :response_time, :t
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # URL endpoint of action.
+        :'action' => :'action',
+        
+        # Indicates if action was allowed (true) or not (false).
+        :'allowed' => :'allowed',
+        
+        # HTTP method.
+        :'method' => :'method',
+        
+        # IP address of client that made request.
+        :'requester_addr' => :'requester_addr',
+        
+        # Response message, if any.
+        :'resp_msg' => :'resp_msg',
+        
+        # Time it took to respond to the request in milliseconds.
+        :'response_time' => :'response_time',
+        
+        # Date-time stamp of request.
+        :'t' => :'t'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'action' => :'String',
+        :'allowed' => :'BOOLEAN',
+        :'method' => :'String',
+        :'requester_addr' => :'String',
+        :'resp_msg' => :'String',
+        :'response_time' => :'Integer',
+        :'t' => :'DateTime'
+        
+      }
+    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[:'allowed']
+        self.allowed = attributes[:'allowed']
+      end
+      
+      if attributes[:'method']
+        self.method = attributes[:'method']
+      end
+      
+      if attributes[:'requester_addr']
+        self.requester_addr = attributes[:'requester_addr']
+      end
+      
+      if attributes[:'resp_msg']
+        self.resp_msg = attributes[:'resp_msg']
+      end
+      
+      if attributes[:'response_time']
+        self.response_time = attributes[:'response_time']
+      end
+      
+      if attributes[:'t']
+        self.t = attributes[:'t']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/base_object.rb

@@ -0,0 +1,96 @@
+require 'date'
+
+module Apcera
+  # base class containing fundamental method such as to_hash, build_from_hash and more
+  class BaseObject
+
+    # build the object from hash
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      else # model
+        # _model = Apcera.const_get(type).new
+        # _model.build_from_hash(value)
+		# JRS
+		#
+			if (type.to_s.start_with?("Hash"))
+				_model = JSON.parse(value.to_json)
+				_model
+			else
+				_model = Apcera.const_get(type).new
+				_model.build_from_hash(value)
+			end		
+      end
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_body (backward compatibility))
+    def to_body
+      to_hash
+    end
+
+    # return the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |key, value|
+        if self.send(key).is_a?(Array)
+          next if self.send(key).empty?
+          hash[value] = self.send(key).select{|v| !v.nil?}.map{ |v| _to_hash v} unless self.send(key).nil?
+        else
+          unless (_tmp_value = _to_hash self.send(key)).nil?
+            hash[value] = _tmp_value
+          end
+        end
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    def _to_hash(value)
+      if value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+end

data/lib/apcera/models/binding.rb

@@ -0,0 +1,137 @@
+module Apcera
+  # 
+  class Binding < BaseObject
+    attr_accessor :env_var, :fqn, :job_fqn, :name, :parameters, :provider_fqn, :service_fqn, :target_job_bound_ip, :target_job_bound_port, :target_job_fqn, :target_job_port, :target_job_uuid, :uuid
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # List of environment variables generated for the binding.
+        :'env_var' => :'env_var',
+        
+        # The binding&#39;s fully-qualified name.
+        :'fqn' => :'fqn',
+        
+        # Fully-qualified name of the job that is bound to another job or service.
+        :'job_fqn' => :'job_fqn',
+        
+        # The base name of the binding.
+        :'name' => :'name',
+        
+        # A map of custom binding parameter names to their values.
+        :'parameters' => :'parameters',
+        
+        # Fully-qualified name of the provider used to create the service to which the source job is bound. Only relevant for job-to-service bindings.
+        :'provider_fqn' => :'provider_fqn',
+        
+        # Fully-qualified name of a the service to which the source job is bound. Only relevant for for job-to-service bindings.
+        :'service_fqn' => :'service_fqn',
+        
+        # IP address where the connection to the target job should be exposed.
+        :'target_job_bound_ip' => :'target_job_bound_ip',
+        
+        # Port that the target job should be exposed at.
+        :'target_job_bound_port' => :'target_job_bound_port',
+        
+        # Fully-qualified name of the job to which the source job wants to bind (input only).
+        :'target_job_fqn' => :'target_job_fqn',
+        
+        # Port on the target job that the source job wants to bind to.
+        :'target_job_port' => :'target_job_port',
+        
+        # UUID of the job to which the source job is bound (output only).
+        :'target_job_uuid' => :'target_job_uuid',
+        
+        # The binding&#39;s unique identifier.
+        :'uuid' => :'uuid'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'env_var' => :'Array<String>',
+        :'fqn' => :'String',
+        :'job_fqn' => :'String',
+        :'name' => :'String',
+        :'parameters' => :'Hash<String, String>',
+        :'provider_fqn' => :'String',
+        :'service_fqn' => :'String',
+        :'target_job_bound_ip' => :'String',
+        :'target_job_bound_port' => :'String',
+        :'target_job_fqn' => :'String',
+        :'target_job_port' => :'String',
+        :'target_job_uuid' => :'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[:'env_var']
+        if (value = attributes[:'env_var']).is_a?(Array)
+          self.env_var = value
+        end
+      end
+      
+      if attributes[:'fqn']
+        self.fqn = attributes[:'fqn']
+      end
+      
+      if attributes[:'job_fqn']
+        self.job_fqn = attributes[:'job_fqn']
+      end
+      
+      if attributes[:'name']
+        self.name = attributes[:'name']
+      end
+      
+      if attributes[:'parameters']
+        if (value = attributes[:'parameters']).is_a?(Array)
+          self.parameters = value
+        end
+      end
+      
+      if attributes[:'provider_fqn']
+        self.provider_fqn = attributes[:'provider_fqn']
+      end
+      
+      if attributes[:'service_fqn']
+        self.service_fqn = attributes[:'service_fqn']
+      end
+      
+      if attributes[:'target_job_bound_ip']
+        self.target_job_bound_ip = attributes[:'target_job_bound_ip']
+      end
+      
+      if attributes[:'target_job_bound_port']
+        self.target_job_bound_port = attributes[:'target_job_bound_port']
+      end
+      
+      if attributes[:'target_job_fqn']
+        self.target_job_fqn = attributes[:'target_job_fqn']
+      end
+      
+      if attributes[:'target_job_port']
+        self.target_job_port = attributes[:'target_job_port']
+      end
+      
+      if attributes[:'target_job_uuid']
+        self.target_job_uuid = attributes[:'target_job_uuid']
+      end
+      
+      if attributes[:'uuid']
+        self.uuid = attributes[:'uuid']
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/create_docker_job_request.rb

@@ -0,0 +1,197 @@
+module Apcera
+  # 
+  class CreateDockerJobRequest < BaseObject
+    attr_accessor :allow_egress, :env, :exposed_ports, :group, :hard_scheduling_tags, :ignore_volumes, :image_url, :interactive, :job_fqn, :resources, :restart, :routes, :soft_scheduling_tags, :start, :start_command, :stop_command, :user, :volume_provider_fqn, :volumes
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # If `true`, the job is allowed outbound network connectivity.
+        :'allow_egress' => :'allow_egress',
+        
+        # List of environment variables that are added to the job.
+        :'env' => :'env',
+        
+        # An array of ports exposed on job instances.
+        :'exposed_ports' => :'exposed_ports',
+        
+        # Group to run Docker image as (default: picked by Apcera).
+        :'group' => :'group',
+        
+        # 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',
+        
+        # If `true`, volumes specified in the Docker image spec are ignored and no data will be persisted. If `false` or not specified, and the Docker image specifies volumes, then you must supply a provider FQN in the request object&#39;s `volume_provider_fqn` property.
+        :'ignore_volumes' => :'ignore_volumes',
+        
+        # Docker image URL.
+        :'image_url' => :'image_url',
+        
+        # If `true`, the start command is removed from the job definition. The start command string is saved to the `DOCKER_START_COMMAND` environment variable on the job&#39;s environment.
+        :'interactive' => :'interactive',
+        
+        # The fully-qualified name of the job to create from the Docker image.
+        :'job_fqn' => :'job_fqn',
+        
+        # A list of compute and network resources that the job can consume.
+        :'resources' => :'resources',
+        
+        # Configuration related to restarting the job.
+        :'restart' => :'restart',
+        
+        # A map of routes to the ports where the routes are available.
+        :'routes' => :'routes',
+        
+        # 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',
+        
+        # If `true` the job is started after its created. Default is `false`.
+        :'start' => :'start',
+        
+        # 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.
+        :'start_command' => :'start_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.
+        :'stop_command' => :'stop_command',
+        
+        # User to run Docker image as. Defaults to user in the Docker image configuration, or &#39;root&#39; if image doesn&#39;t have a user configured.
+        :'user' => :'user',
+        
+        # Volume provider&#39;s fully-qualified name. Required if `ignore_volumes` is not set to `true`.
+        :'volume_provider_fqn' => :'volume_provider_fqn',
+        
+        # A list of volumes used by the Docker image for persistence.
+        :'volumes' => :'volumes'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'allow_egress' => :'BOOLEAN',
+        :'env' => :'Hash<String, String>',
+        :'exposed_ports' => :'Array<Integer>',
+        :'group' => :'String',
+        :'hard_scheduling_tags' => :'Hash<String, BOOLEAN>',
+        :'ignore_volumes' => :'BOOLEAN',
+        :'image_url' => :'String',
+        :'interactive' => :'BOOLEAN',
+        :'job_fqn' => :'String',
+        :'resources' => :'Resource',
+        :'restart' => :'RestartConfig',
+        :'routes' => :'Hash<String, Integer>',
+        :'soft_scheduling_tags' => :'Hash<String, BOOLEAN>',
+        :'start' => :'BOOLEAN',
+        :'start_command' => :'Array<String>',
+        :'stop_command' => :'Array<String>',
+        :'user' => :'String',
+        :'volume_provider_fqn' => :'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[:'allow_egress']
+        self.allow_egress = attributes[:'allow_egress']
+      end
+      
+      if attributes[:'env']
+        if (value = attributes[:'env']).is_a?(Array)
+          self.env = value
+        end
+      end
+      
+      if attributes[:'exposed_ports']
+        if (value = attributes[:'exposed_ports']).is_a?(Array)
+          self.exposed_ports = value
+        end
+      end
+      
+      if attributes[:'group']
+        self.group = attributes[:'group']
+      end
+      
+      if attributes[:'hard_scheduling_tags']
+        if (value = attributes[:'hard_scheduling_tags']).is_a?(Array)
+          self.hard_scheduling_tags = value
+        end
+      end
+      
+      if attributes[:'ignore_volumes']
+        self.ignore_volumes = attributes[:'ignore_volumes']
+      end
+      
+      if attributes[:'image_url']
+        self.image_url = attributes[:'image_url']
+      end
+      
+      if attributes[:'interactive']
+        self.interactive = attributes[:'interactive']
+      end
+      
+      if attributes[:'job_fqn']
+        self.job_fqn = attributes[:'job_fqn']
+      end
+      
+      if attributes[:'resources']
+        self.resources = attributes[:'resources']
+      end
+      
+      if attributes[:'restart']
+        self.restart = attributes[:'restart']
+      end
+      
+      if attributes[:'routes']
+        if (value = attributes[:'routes']).is_a?(Array)
+          self.routes = value
+        end
+      end
+      
+      if attributes[:'soft_scheduling_tags']
+        if (value = attributes[:'soft_scheduling_tags']).is_a?(Array)
+          self.soft_scheduling_tags = value
+        end
+      end
+      
+      if attributes[:'start']
+        self.start = attributes[:'start']
+      end
+      
+      if attributes[:'start_command']
+        if (value = attributes[:'start_command']).is_a?(Array)
+          self.start_command = value
+        end
+      end
+      
+      if attributes[:'stop_command']
+        if (value = attributes[:'stop_command']).is_a?(Array)
+          self.stop_command = value
+        end
+      end
+      
+      if attributes[:'user']
+        self.user = attributes[:'user']
+      end
+      
+      if attributes[:'volume_provider_fqn']
+        self.volume_provider_fqn = attributes[:'volume_provider_fqn']
+      end
+      
+      if attributes[:'volumes']
+        if (value = attributes[:'volumes']).is_a?(Array)
+          self.volumes = value
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/apcera/models/create_docker_job_response.rb

@@ -0,0 +1,37 @@
+module Apcera
+  # 
+  class CreateDockerJobResponse < BaseObject
+    attr_accessor :location
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # The location of the Task created for the Docker job creation request. A client can use the location to opt-in to subscribing to the task endpoint.
+        :'location' => :'location'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'location' => :'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[:'location']
+        self.location = attributes[:'location']
+      end
+      
+    end
+
+  end
+end