deployment-tracker-client 0.1.0

data/lib/deployment-tracker-client/api/default_api.rb

@@ -0,0 +1,482 @@
+require "uri"
+
+module DeploymentTrackerClient
+  class DefaultApi
+    basePath = "http://localhost:8080/"
+    # apiInvoker = APIInvoker
+
+    # 
+    # Return the current application configuration
+    # @param [Hash] opts the optional parameters
+    # @return [ObjectResponse]
+    def self.config(opts = {})
+      
+
+      # resource path
+      path = "/config".sub('{format}','json')
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = []
+      _header_accept_result =SwaggerClient::Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] =SwaggerClient::Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      
+
+      auth_names = []
+      response =SwaggerClient::Swagger::Request.new(:GET, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make.body
+      obj = ObjectResponse.new() and obj.build_from_hash(response)
+    end
+
+    # 
+    # Run a health check and return the test results
+    # @param [Hash] opts the optional parameters
+    # @return [ObjectResponse]
+    def self.healthcheck(opts = {})
+      
+
+      # resource path
+      path = "/healthcheck".sub('{format}','json')
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = []
+      _header_accept_result =SwaggerClient::Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] =SwaggerClient::Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      
+
+      auth_names = []
+      response =SwaggerClient::Swagger::Request.new(:GET, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make.body
+      obj = ObjectResponse.new() and obj.build_from_hash(response)
+    end
+
+    # 
+    # Get the list of most recently completed deployments
+    # @param offset Which result to start with
+    # @param limit Number of results to return
+    # @param [Hash] opts the optional parameters
+    # @return [array[Deployment]]
+    def self.get_deployments(offset, limit, opts = {})
+      
+      # verify the required parameter 'offset' is set
+      raise "Missing the required parameter 'offset' when calling get_deployments" if offset.nil?
+      
+      # verify the required parameter 'limit' is set
+      raise "Missing the required parameter 'limit' when calling get_deployments" if limit.nil?
+      
+
+      # resource path
+      path = "/v1/deployments".sub('{format}','json')
+
+      # query parameters
+      query_params = {}
+      query_params[:'offset'] = offset
+      query_params[:'limit'] = limit
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = []
+      _header_accept_result =SwaggerClient::Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] =SwaggerClient::Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      
+
+      auth_names = []
+      response =SwaggerClient::Swagger::Request.new(:GET, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make.body
+      response.map {|response| obj = Deployment.new() and obj.build_from_hash(response) }
+    end
+
+    # 
+    # Get a deployment
+    # @param id Unique Identifier (UUID) of the deployment to retrieve
+    # @param [Hash] opts the optional parameters
+    # @return [Deployment]
+    def self.get_deployment(id, opts = {})
+      
+      # verify the required parameter 'id' is set
+      raise "Missing the required parameter 'id' when calling get_deployment" if id.nil?
+      
+
+      # resource path
+      path = "/v1/deployments/{id}".sub('{format}','json').sub('{' + 'id' + '}', id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = []
+      _header_accept_result =SwaggerClient::Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] =SwaggerClient::Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      
+
+      auth_names = []
+      response =SwaggerClient::Swagger::Request.new(:GET, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make.body
+      obj = Deployment.new() and obj.build_from_hash(response)
+    end
+
+    # 
+    # Record the completion of a new deployment
+    # @param id Unique Identifier (UUID) of the deployment that has completed
+    # @param body The Deployment object to be updated
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def self.put_deployment(id, body, opts = {})
+      
+      # verify the required parameter 'id' is set
+      raise "Missing the required parameter 'id' when calling put_deployment" if id.nil?
+      
+      # verify the required parameter 'body' is set
+      raise "Missing the required parameter 'body' when calling put_deployment" if body.nil?
+      
+
+      # resource path
+      path = "/v1/deployments/{id}".sub('{format}','json').sub('{' + 'id' + '}', id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = ['text/plain']
+      _header_accept_result =SwaggerClient::Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] =SwaggerClient::Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body =SwaggerClient::Swagger::Request.object_to_http_body(body)
+      
+
+      auth_names = []
+     SwaggerClient::Swagger::Request.new(:PUT, path, {:params => query_params,:headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make
+      nil
+    end
+
+    # 
+    # Record the start of a new deployment
+    # @param id Unique Identifier (UUID) of the deployment that is starting
+    # @param body The Deployment object to be created
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def self.post_deployment(id, body, opts = {})
+      
+      # verify the required parameter 'id' is set
+      raise "Missing the required parameter 'id' when calling post_deployment" if id.nil?
+      
+      # verify the required parameter 'body' is set
+      raise "Missing the required parameter 'body' when calling post_deployment" if body.nil?
+      
+
+      # resource path
+      path = "/v1/deployments/{id}".sub('{format}','json').sub('{' + 'id' + '}', id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = ['text/plain']
+      _header_accept_result =SwaggerClient::Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] =SwaggerClient::Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body =SwaggerClient::Swagger::Request.object_to_http_body(body)
+      
+
+      auth_names = []
+     SwaggerClient::Swagger::Request.new(:POST, path, {:params => query_params,:headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make
+      nil
+    end
+
+    # 
+    # Record a log message associated with a deployment
+    # @param id Unique Identifier (UUID) of the deployment that is starting
+    # @param body The log message to be recorded
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def self.post_logs(id, body, opts = {})
+      
+      # verify the required parameter 'id' is set
+      raise "Missing the required parameter 'id' when calling post_logs" if id.nil?
+      
+      # verify the required parameter 'body' is set
+      raise "Missing the required parameter 'body' when calling post_logs" if body.nil?
+      
+
+      # resource path
+      path = "/v1/deployments/{id}/logs".sub('{format}','json').sub('{' + 'id' + '}', id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = ['text/plain']
+      _header_accept_result =SwaggerClient::Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] =SwaggerClient::Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body =SwaggerClient::Swagger::Request.object_to_http_body(body)
+      
+
+      auth_names = []
+     SwaggerClient::Swagger::Request.new(:POST, path, {:params => query_params,:headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make
+      nil
+    end
+
+    # 
+    # Record the completion of a deployment to a server
+    # @param id Unique Identifier (UUID) of the deployment that has completed
+    # @param body The server on which the deployment has completed
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def self.put_server(id, body, opts = {})
+      
+      # verify the required parameter 'id' is set
+      raise "Missing the required parameter 'id' when calling put_server" if id.nil?
+      
+      # verify the required parameter 'body' is set
+      raise "Missing the required parameter 'body' when calling put_server" if body.nil?
+      
+
+      # resource path
+      path = "/v1/deployments/{id}/servers".sub('{format}','json').sub('{' + 'id' + '}', id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = ['text/plain']
+      _header_accept_result =SwaggerClient::Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] =SwaggerClient::Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body =SwaggerClient::Swagger::Request.object_to_http_body(body)
+      
+
+      auth_names = []
+     SwaggerClient::Swagger::Request.new(:PUT, path, {:params => query_params,:headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make
+      nil
+    end
+
+    # 
+    # Record the start of a deployment to a server
+    # @param id Unique Identifier (UUID) of the deployment that is starting
+    # @param body The server on which the deployment is starting
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def self.post_server(id, body, opts = {})
+      
+      # verify the required parameter 'id' is set
+      raise "Missing the required parameter 'id' when calling post_server" if id.nil?
+      
+      # verify the required parameter 'body' is set
+      raise "Missing the required parameter 'body' when calling post_server" if body.nil?
+      
+
+      # resource path
+      path = "/v1/deployments/{id}/servers".sub('{format}','json').sub('{' + 'id' + '}', id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = ['text/plain']
+      _header_accept_result =SwaggerClient::Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] =SwaggerClient::Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body =SwaggerClient::Swagger::Request.object_to_http_body(body)
+      
+
+      auth_names = []
+     SwaggerClient::Swagger::Request.new(:POST, path, {:params => query_params,:headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make
+      nil
+    end
+
+    # 
+    # Return a list of all servers that have been deployed to
+    # @param offset Which result to start with
+    # @param limit Number of results to return
+    # @param [Hash] opts the optional parameters
+    # @return [array[string]]
+    def self.get_all_servers(offset, limit, opts = {})
+      
+      # verify the required parameter 'offset' is set
+      raise "Missing the required parameter 'offset' when calling get_all_servers" if offset.nil?
+      
+      # verify the required parameter 'limit' is set
+      raise "Missing the required parameter 'limit' when calling get_all_servers" if limit.nil?
+      
+
+      # resource path
+      path = "/v1/servers".sub('{format}','json')
+
+      # query parameters
+      query_params = {}
+      query_params[:'offset'] = offset
+      query_params[:'limit'] = limit
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = []
+      _header_accept_result =SwaggerClient::Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] =SwaggerClient::Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      
+
+      auth_names = []
+      response =SwaggerClient::Swagger::Request.new(:GET, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make.body
+      response.map {|response| obj = string.new() and obj.build_from_hash(response) }
+    end
+
+    # 
+    # Return a list of all servers that have been deployed to
+    # @param hostname The hostname for the server
+    # @param offset Which result to start with
+    # @param limit Number of results to return
+    # @param [Hash] opts the optional parameters
+    # @return [array[Server]]
+    def self.get_server_by_hostname(hostname, offset, limit, opts = {})
+      
+      # verify the required parameter 'hostname' is set
+      raise "Missing the required parameter 'hostname' when calling get_server_by_hostname" if hostname.nil?
+      
+      # verify the required parameter 'offset' is set
+      raise "Missing the required parameter 'offset' when calling get_server_by_hostname" if offset.nil?
+      
+      # verify the required parameter 'limit' is set
+      raise "Missing the required parameter 'limit' when calling get_server_by_hostname" if limit.nil?
+      
+
+      # resource path
+      path = "/v1/servers/{hostname}".sub('{format}','json').sub('{' + 'hostname' + '}', hostname.to_s)
+
+      # query parameters
+      query_params = {}
+      query_params[:'offset'] = offset
+      query_params[:'limit'] = limit
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = []
+      _header_accept_result =SwaggerClient::Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] =SwaggerClient::Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      
+
+      auth_names = []
+      response =SwaggerClient::Swagger::Request.new(:GET, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make.body
+      response.map {|response| obj = Server.new() and obj.build_from_hash(response) }
+    end
+  end
+end

data/lib/deployment-tracker-client/models/base_object.rb

@@ -0,0 +1,83 @@
+module DeploymentTrackerClient
+  # base class containing fundamental method such as to_hash, build_from_hash and more
+  class BaseObject
+
+    # return the object in the form of hash
+    def to_body
+      body = {}
+      self.class.attribute_map.each_pair do |key, value|
+        body[value] = self.send(key) unless self.send(key).nil?
+      end
+      body
+    end
+
+    # 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 :string
+        value.to_s
+      when :int
+        value.to_i
+      when :double
+        value.to_f
+      when :boolean
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      else # model
+        _model = DeploymentTrackerClient.const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    # to_body is an alias to to_body (backward compatibility)
+    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/deployment-tracker-client/models/deployment.rb

@@ -0,0 +1,118 @@
+module DeploymentTrackerClient
+  # 
+  class Deployment < BaseObject
+    attr_accessor :deployment_id, :engine, :engine_version, :host, :user, :environment, :package, :version, :result, :elapsed_seconds, :servers
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Unique identifier of a deployment. UUID
+        :'deployment_id' => :'deployment_id',
+        
+        # The execution engine of the deployment
+        :'engine' => :'engine',
+        
+        # The version of the execution engine
+        :'engine_version' => :'engine_version',
+        
+        # The host from which the deployment is being executed
+        :'host' => :'host',
+        
+        # The user executing the deploymetn
+        :'user' => :'user',
+        
+        # The target environment of the deployment
+        :'environment' => :'environment',
+        
+        # The name of the software application or service being deployed
+        :'package' => :'package',
+        
+        # The version of the package being deployed
+        :'version' => :'version',
+        
+        # The result of running the deployment
+        :'result' => :'result',
+        
+        # The elapsed time of the deployment, in seconds
+        :'elapsed_seconds' => :'elapsed_seconds',
+        
+        # The servers that participated in the deployment
+        :'servers' => :'servers'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'deployment_id' => :'string',
+        :'engine' => :'string',
+        :'engine_version' => :'string',
+        :'host' => :'string',
+        :'user' => :'string',
+        :'environment' => :'string',
+        :'package' => :'string',
+        :'version' => :'string',
+        :'result' => :'string',
+        :'elapsed_seconds' => :'int',
+        :'servers' => :'array[Server]'
+        
+      }
+    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[:'deployment_id']
+        @deployment_id = attributes[:'deployment_id']
+      end
+      
+      if attributes[:'engine']
+        @engine = attributes[:'engine']
+      end
+      
+      if attributes[:'engine_version']
+        @engine_version = attributes[:'engine_version']
+      end
+      
+      if attributes[:'host']
+        @host = attributes[:'host']
+      end
+      
+      if attributes[:'user']
+        @user = attributes[:'user']
+      end
+      
+      if attributes[:'environment']
+        @environment = attributes[:'environment']
+      end
+      
+      if attributes[:'package']
+        @package = attributes[:'package']
+      end
+      
+      if attributes[:'version']
+        @version = attributes[:'version']
+      end
+      
+      if attributes[:'result']
+        @result = attributes[:'result']
+      end
+      
+      if attributes[:'elapsed_seconds']
+        @elapsed_seconds = attributes[:'elapsed_seconds']
+      end
+      
+      if attributes[:'servers']
+        if (value = attributes[:'servers']).is_a?(Array)
+          @servers = value
+        end
+      end
+      
+    end
+  end
+end