fog-aws 0.4.1 → 0.5.0

data/lib/fog/aws/requests/ecs/describe_task_definition.rb

@@ -0,0 +1,64 @@
+module Fog
+  module AWS
+    class ECS
+      class Real
+        require 'fog/aws/parsers/ecs/describe_task_definition'
+
+        # Describes a task definition
+        # http://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTaskDefinition.html
+        # ==== Parameters
+        # * taskDefinition <~String> - The family for the latest revision, family and revision (family:revision) for a specific revision in the family, or full Amazon Resource Name (ARN) of the task definition that you want to describe.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'taskDefinition' <~Hash> - full task definition description
+        def describe_task_definition(params={})
+          request({
+            'Action'  => 'DescribeTaskDefinition',
+            :parser   => Fog::Parsers::AWS::ECS::DescribeTaskDefinition.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def describe_task_definition(params={})
+          response = Excon::Response.new
+          response.status = 200
+
+          taskdef_error = "ClientException => Task Definition can not be blank."
+          raise Fog::AWS::ECS::Error, taskdef_error unless params['taskDefinition']
+
+          task_def_name = params['taskDefinition']
+
+          case task_def_name
+          when /^arn:aws:ecs:.+:\d{1,12}:task-definition\/(.+:.+)$/
+            result = self.data[:task_definitions].select { |t| t['taskDefinitionArn'].eql?(task_def_name) }
+          when /^(.+:.+)$/
+            result = self.data[:task_definitions].select { |t| t['taskDefinitionArn'].match(/task-definition\/#{task_def_name}/) }
+          else
+            result = self.data[:task_definitions].select { |t| t['family'].eql?(task_def_name) }
+            if !result.empty?
+              result = [] << (result.max_by { |t| t['revision'] })
+            end
+          end
+
+          if result.empty?
+            raise Fog::AWS::ECS::Error, 'ClientException => Unable to describe task definition.'
+          end
+
+          task_definition = result.first
+
+          response.body = {
+            'DescribeTaskDefinitionResult' => {
+              'taskDefinition' => task_definition
+            },
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/ecs/describe_tasks.rb

@@ -0,0 +1,65 @@
+module Fog
+  module AWS
+    class ECS
+      class Real
+        require 'fog/aws/parsers/ecs/describe_tasks'
+
+        # Describes a specified task or tasks.
+        # http://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html
+        # ==== Parameters
+        # * cluster <~String> - short name or full Amazon Resource Name (ARN) of the cluster that hosts the task you want to describe
+        # * tasks <~Array> - space-separated list of task UUIDs or full Amazon Resource Name (ARN) entries
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'tasks' <~Array> - The list of tasks
+        #     * 'failures' <~Array> - The list of failures (if any)
+        def describe_tasks(params={})
+          if tasks = params.delete('tasks')
+            params.merge!(Fog::AWS.indexed_param('tasks.member', [*tasks]))
+          end
+
+          request({
+            'Action'  => 'DescribeTasks',
+            :parser   => Fog::Parsers::AWS::ECS::DescribeTasks.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def describe_tasks(params={})
+          response = Excon::Response.new
+          response.status = 200
+
+          unless tasks = params.delete('tasks')
+            msg = 'InvalidParameterException => Tasks cannot be empty.'
+            raise Fog::AWS::ECS::Error, msg
+          end
+
+          cluster = params.delete('cluster') || 'default'
+
+          result = []
+          [*tasks].each do |tid|
+            if match = tid.match(/^arn:aws:ecs:.+:\d{1,12}:task\/(.+)$/)
+              result = self.data[:tasks].select { |t| t['taskArn'].eql?(tid) }
+            else
+              result = self.data[:tasks].select { |t| t['taskArn'].match(/#{tid}$/) }
+            end
+          end
+
+          tasks = result
+          response.body = {
+            'DescribeTasksResult' => {
+              'failures' => [],
+              'tasks' => tasks
+            },
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/ecs/list_clusters.rb

@@ -0,0 +1,45 @@
+module Fog
+  module AWS
+    class ECS
+      class Real
+        require 'fog/aws/parsers/ecs/list_clusters'
+
+        # Returns a list of existing clusters
+        # http://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ListClusters.html
+        # ==== Parameters
+        # * maxResults <~Integer> - The maximum number of cluster results returned by ListClusters in paginated output.
+        # * nextToken <~String> - The nextToken value returned from a previous paginated ListClusters request where maxResults was used.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ClusterArns' <~Array> - list of full Amazon Resource Name (ARN) entries for each cluster associated with your account.
+        #     * 'NextToken' <~String> - nextToken value to include in a future ListClusters request.
+        def list_clusters(params={})
+          request({
+            'Action'  => 'ListClusters',
+            :parser   => Fog::Parsers::AWS::ECS::ListClusters.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def list_clusters(params={})
+          response = Excon::Response.new
+          response.status = 200
+
+          cluster_arns = self.data[:clusters].map { |c| c['clusterArn'] }
+
+          response.body = {
+            'ListClustersResult' => {
+              'clusterArns' => cluster_arns
+            },
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/ecs/list_container_instances.rb

@@ -0,0 +1,46 @@
+module Fog
+  module AWS
+    class ECS
+      class Real
+        require 'fog/aws/parsers/ecs/list_container_instances'
+
+        # Returns a list of container instances in a specified cluster.
+        # http://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ListContainerInstances.html
+        # ==== Parameters
+        # * cluster <~String> - short name or full Amazon Resource Name (ARN) of the cluster that hosts the container instances you want to list.
+        # * maxResults <~Integer> - maximum number of container instance results returned by ListContainerInstances in paginated output.
+        # * nextToken <~String> - nextToken value returned from a previous paginated ListContainerInstances request where maxResults was used.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ContainerInstanceArns' <~Array> - list of container instance full ARN entries for each container instance associated with the specified cluster.
+        #     * 'NextToken' <~String> - nextToken value to include in a future ListContainerInstances request.
+        def list_container_instances(params={})
+          request({
+            'Action'  => 'ListContainerInstances',
+            :parser   => Fog::Parsers::AWS::ECS::ListContainerInstances.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def list_container_instances(params={})
+          response = Excon::Response.new
+          response.status = 200
+
+          instance_arns = self.data[:container_instances].map { |i| i['containerInstanceArn'] }
+
+          response.body = {
+            'ListContainerInstancesResult' => {
+              'containerInstanceArns' => instance_arns
+            },
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/ecs/list_services.rb

@@ -0,0 +1,59 @@
+module Fog
+  module AWS
+    class ECS
+      class Real
+        require 'fog/aws/parsers/ecs/list_services'
+
+        # Lists the services that are running in a specified cluster.
+        # http://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ListServices.html
+        # ==== Parameters
+        # * cluster <~String> - The short name or full Amazon Resource Name (ARN) of the cluster that hosts the services you want to list.
+        # * maxResults <~Integer> - The maximum number of container instance results returned by ListServices in paginated output.
+        # * nextToken <~String> - The nextToken value returned from a previous paginated ListServices request where maxResults was used.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ServiceArns' <~Array> - list of full Amazon Resource Name (ARN) entries for each service associated with the specified cluster.
+        #     * 'NextToken' <~String> - nextToken value to include in a future ListServices request.
+        def list_services(params={})
+          request({
+            'Action'  => 'ListServices',
+            :parser   => Fog::Parsers::AWS::ECS::ListServices.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def list_services(params={})
+          response = Excon::Response.new
+          response.status = 200
+
+          owner_id = Fog::AWS::Mock.owner_id
+
+          cluster = params.delete('cluster') || 'default'
+          if !cluster.match(/^arn:aws:ecs:.+:.+:cluster\/(.+)$/)
+            cluster_path = "cluster/#{cluster}"
+            cluster_arn = Fog::AWS::Mock.arn('ecs', owner_id, cluster_path, region)
+          else
+            cluster_arn = cluster
+          end
+
+          result = self.data[:services].select do |s|
+            s['clusterArn'].eql?(cluster_arn)
+          end
+          service_arns = result.map { |s| s['serviceArn'] }
+
+          response.body = {
+            'ListServicesResult' => {
+              'serviceArns' => service_arns
+            },
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/ecs/list_task_definition_families.rb

@@ -0,0 +1,56 @@
+module Fog
+  module AWS
+    class ECS
+      class Real
+        require 'fog/aws/parsers/ecs/list_task_definition_families'
+
+        # Returns a list of task definition families that are registered to your account.
+        # http://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ListTaskDefinitionFamilies.html
+        # ==== Parameters
+        # * familyPrefix <~String> - familyPrefix is a string that is used to filter the results of ListTaskDefinitionFamilies.
+        # * maxResults <~Integer> - maximum number of task definition family results returned by ListTaskDefinitionFamilies in paginated output.
+        # * nextToken <~String> - nextToken value returned from a previous paginated ListTaskDefinitionFamilies request where maxResults was used.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Families' <~Array> - list of task definition family names that match the ListTaskDefinitionFamilies request.
+        #     * 'NextToken' <~String> - nextToken value to include in a future ListTaskDefinitionFamilies request.
+        def list_task_definition_families(params={})
+          request({
+            'Action'  => 'ListTaskDefinitionFamilies',
+            :parser   => Fog::Parsers::AWS::ECS::ListTaskDefinitionFamilies.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def list_task_definition_families(params={})
+          response = Excon::Response.new
+          response.status = 200
+
+          family_prefix = params['familyPrefix']
+
+          if family_prefix
+            result = self.data[:task_definitions].select do |t|
+              t['family'].match(/^#{family_prefix}/)
+            end
+          else
+            result = self.data[:task_definitions].dup
+          end
+          result.map! { |t| t['family'] }
+          result.uniq!
+
+          response.body = {
+            'ListTaskDefinitionFamiliesResult' => {
+              'families' => result
+            },
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/ecs/list_task_definitions.rb

@@ -0,0 +1,55 @@
+module Fog
+  module AWS
+    class ECS
+      class Real
+        require 'fog/aws/parsers/ecs/list_task_definitions'
+
+        # Returns a list of task definitions that are registered to your account
+        # http://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ListTaskDefinitions.html
+        # ==== Parameters
+        # * familyPrefix <~String> - The full family name that you want to filter the ListTaskDefinitions results with.
+        # * maxResults <~Integer> - The maximum number of task definition results returned by ListTaskDefinitions in paginated output.
+        # * nextToken <~String> - The nextToken value returned from a previous paginated ListTaskDefinitions request.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'TaskDefinitionArns' <~Array> - list of task definition Amazon Resource Name (ARN) entries for the ListTaskDefintions request.
+        #     * 'NextToken' <~String> - nextToken value to include in a future ListTaskDefinitions request
+        def list_task_definitions(params={})
+          request({
+            'Action'  => 'ListTaskDefinitions',
+            :parser   => Fog::Parsers::AWS::ECS::ListTaskDefinitions.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def list_task_definitions(params={})
+          if %w(
+            familyPrefix
+            maxResults
+            nextToken
+            ).any? { |k| params.has_key?(k) }
+            Fog::Logger.warning("list_task_definitions filters are not yet mocked [light_black](#{caller.first})[/]")
+            Fog::Mock.not_implemented
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+
+          taskdef_arns = self.data[:task_definitions].map { |c| c['taskDefinitionArn'] }
+
+          response.body = {
+            'ListTaskDefinitionsResult' => {
+              'taskDefinitionArns' => taskdef_arns
+            },
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/ecs/list_tasks.rb

@@ -0,0 +1,50 @@
+module Fog
+  module AWS
+    class ECS
+      class Real
+        require 'fog/aws/parsers/ecs/list_tasks'
+
+        # Returns a list of tasks for a specified cluster.
+        # http://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ListTasks.html
+        # ==== Parameters
+        # * cluster <~String> - short name or full Amazon Resource Name (ARN) of the cluster that hosts the tasks you want to list.
+        # * containerInstance <~String> - container instance UUID or full Amazon Resource Name (ARN) of the container instance that you want to filter the ListTasks results with.
+        # * family <~String> - name of the family that you want to filter the ListTasks results with.
+        # * maxResults <~Integer> - maximum number of task results returned by ListTasks in paginated output.
+        # * nextToken <~String> - nextToken value returned from a previous paginated ListTasks request where maxResults was used.
+        # * serviceName <~String> - name of the service that you want to filter the ListTasks results with.
+        # * startedBy <~String> - startedBy value that you want to filter the task results with.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'TaskArns' <~Array> - list of task Amazon Resource Name (ARN) entries for the ListTasks request.
+        #     * 'NextToken' <~String> - nextToken value to include in a future ListTasks request.
+        def list_tasks(params={})
+          request({
+            'Action'  => 'ListTasks',
+            :parser   => Fog::Parsers::AWS::ECS::ListTasks.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def list_tasks(params={})
+          response = Excon::Response.new
+          response.status = 200
+
+          task_arns = self.data[:tasks].map { |t| t['taskArn'] }
+
+          response.body = {
+            'ListTasksResult' => {
+              'taskArns' => task_arns
+            },
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end