class Fog::AWS::ECS::Mock

Attributes

region[RW]

Public Class Methods

data() click to toggle source
# File lib/fog/aws/ecs.rb, line 142
def self.data
  @data ||= Hash.new do |hash, region|
    hash[region] = Hash.new do |region_hash, key|
      region_hash[key] = {
        :clusters => [],
        :task_definitions => [],
        :services => [],
        :container_instances => [],
        :tasks => []
      }
    end
  end
end
new(options={}) click to toggle source
# File lib/fog/aws/ecs.rb, line 162
def initialize(options={})
  @use_iam_profile = options[:use_iam_profile]
  @region          = options[:region] || 'us-east-1'

  Fog::AWS.validate_region!(@region)

  setup_credentials(options)
end
reset() click to toggle source
# File lib/fog/aws/ecs.rb, line 156
def self.reset
  @data = nil
end

Public Instance Methods

create_cluster(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/create_cluster.rb, line 24
def create_cluster(params={})
  response = Excon::Response.new
  response.status = 200

  params.has_key?('clusterName') || params['clusterName'] = 'default'

  owner_id = Fog::AWS::Mock.owner_id
  cluster_name = params['clusterName']
  cluster_path = "cluster/#{cluster_name}"
  cluster_arn = Fog::AWS::Mock.arn('ecs', owner_id, cluster_path, region)
  cluster = {}

  search_cluster_result = self.data[:clusters].select { |c| c['clusterName'].eql?(cluster_name) }
  if search_cluster_result.empty?
    cluster = {
      'clusterName'                       => cluster_name,
      'clusterArn'                        => cluster_arn,
      'status'                            => 'ACTIVE',
      'registeredContainerInstancesCount' => 0,
      'runningTasksCount'                 => 0,
      'pendingTasksCount'                 => 0
    }
    self.data[:clusters] << cluster
  else
    cluster = search_cluster_result.first
  end

  response.body = {
    'CreateClusterResult' => {
      'cluster' => cluster
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end
create_service(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/create_service.rb, line 33
def create_service(params={})
  response = Excon::Response.new
  response.status = 200

  e = Fog::AWS::ECS::Error
  msg = 'ClientException => desiredCount cannot be empty.'
  raise e, msg unless desired_count = params['desiredCount']
  msg = 'ClientException => serviceName cannot be empty.'
  raise e unless service_name = params['serviceName']
  msg = 'ClientException => taskDefinition cannot be empty.'
  raise e unless task_definition = params['taskDefinition']

  owner_id = Fog::AWS::Mock.owner_id

  service_path = "service/#{service_name}"
  service_arn = Fog::AWS::Mock.arn('ecs', owner_id, service_path, region)

  cluster = params['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

  if params['role']
    role = params['role'] if params['role']
    if !role.match(/^arn:aws:iam:.*:.*:role\/(.+)$/)
      role_path = "role/#{role}"
      role_arn = Fog::AWS::Mock.arn('iam', owner_id, role_path, region)
    else
      role_arn = role
    end
  end

  if !task_definition.match(/^arn:aws:ecs:.+:.+:task-definition\/.+$/)
    task_def_path = "task-definition\/#{task_definition}"
    task_def_arn = Fog::AWS::Mock.arn('ecs', owner_id, task_def_path, region)
  else
    task_def_arn = task_definition
  end

  load_balancers = params['loadBalancers'] || []

  service = {
    'events'         => [],
    'serviceName'    => service_name,
    'serviceArn'     => service_arn,
    'taskDefinition' => task_def_arn,
    'clusterArn'     => cluster_arn,
    'status'         => 'ACTIVE',
    'roleArn'        => role_arn,
    'loadBalancers'  => [*load_balancers],
    'deployments'    => [],
    'desiredCount'   => desired_count,
    'pendingCount'   => 0,
    'runningCount'   => 0
  }

  service['deployments'] << {
    'updatedAt'      => Time.now.utc,
    'id'             => "ecs-svc/#{Fog::Mock.random_numbers(19)}",
    'taskDefinition' => task_def_arn,
    'status'         => 'PRIMARY',
    'desiredCount'   => desired_count,
    'createdAt'      => Time.now.utc,
    'pendingCount'   => 0,
    'runningCount'   => 0
  }

  self.data[:services] << service

  response.body = {
    'CreateServiceResult' => {
      'service' => service,
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end
data() click to toggle source
# File lib/fog/aws/ecs.rb, line 171
def data
  self.class.data[@region][@aws_access_key_id]
end
delete_cluster(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/delete_cluster.rb, line 24
def delete_cluster(params={})
  response = Excon::Response.new
  response.status = 200

  cluster_id = params.delete('cluster')

  if !cluster_id
    message = 'ClientException => Cluster can not be blank.'
    raise Fog::AWS::ECS::Error, message
  end

  if match = cluster_id.match(/^arn:aws:ecs:.+:\d{1,12}:cluster\/(.+)$/)
    i = self.data[:clusters].index { |c| c['clusterArn'].eql?(cluster_id) }
  else
    i = self.data[:clusters].index { |c| c['clusterName'].eql?(cluster_id) }
  end

  if i
    cluster = self.data[:clusters].delete_at(i)
  else
    raise Fog::AWS::ECS::NotFound, 'Cluster not found.'
  end

  cluster['status'] = 'INACTIVE'
  response.body = {
    'DeleteClusterResult' => {
      'cluster' => cluster
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end
delete_service(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/delete_service.rb, line 25
def delete_service(params={})
  response = Excon::Response.new
  response.status = 200

  service_id = params.delete('service')
  msg = 'ClientException => Service cannot be empty.'
  raise Fog::AWS::ECS::Error, msg unless service_id

  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

  if match = service_id.match(/^arn:aws:ecs:.+:\d{1,12}:service\/(.+)$/)
    i = self.data[:services].index do |s|
      s['clusterArn'].eql?(cluster_arn) && s['serviceArn'].eql?(service_id)
    end
  else
    i = self.data[:services].index do |s|
      s['clusterArn'].eql?(cluster_arn) && s['serviceName'].eql?(service_id)
    end
  end

  msg = "ServiceNotFoundException => Service not found."
  raise Fog::AWS::ECS::Error, msg unless i

  service = self.data[:services][i]
  self.data[:services].delete_at(i)

  response.body = {
    'DeleteServiceResult' => {
      'service' => service
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end
deregister_container_instance(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/deregister_container_instance.rb, line 26
def deregister_container_instance(params={})
  response = Excon::Response.new
  response.status = 200

  instance_id = params.delete('containerInstance')
  instance_error = "ClientException => Container instance can not be blank."
  raise Fog::AWS::ECS::Error, instance_error unless instance_id

  if match = instance_id.match(/^arn:aws:ecs:.+:\d{1,12}:container-instance\/(.+)$/)
    i = self.data[:container_instances].index do |inst|
      inst['containerInstanceArn'].eql?(instance_id)
    end
  else
    i = self.data[:container_instances].index do |inst|
      inst['containerInstanceArn'].match(/#{instance_id}$/)
    end
  end

  msg = "ClientException => Referenced container instance #{instance_id} not found."
  raise Fog::AWS::ECS::Error, msg unless i

  instance = self.data[:container_instances][i]
  self.data[:container_instances].delete_at(i)

  response.body = {
    'DeregisterContainerInstanceResult' => {
      'containerInstance' => instance
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end
deregister_task_definition(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/deregister_task_definition.rb, line 24
def deregister_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\/(.+:.+)$/
    i = self.data[:task_definitions].index { |t| t['taskDefinitionArn'].eql?(task_def_name) }
  when /^(.+:.+)$/
    i = self.data[:task_definitions].index { |t| t['taskDefinitionArn'].match(/task-definition\/#{task_def_name}$/) }
  else
    raise Fog::AWS::ECS::Error, 'Invalid task definition'
  end

  raise Fog::AWS::ECS::NotFound, 'Task definition not found.' unless i
  task_definition = self.data[:task_definitions].delete_at(i)

  response.body = {
    'DeregisterTaskDefinitionResult' => {
      'taskDefinition' => task_definition
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end
describe_clusters(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/describe_clusters.rb, line 29
def describe_clusters(params={})
  response = Excon::Response.new
  response.status = 200

  members = params.delete('clusters')
  members = 'default' unless members
  clusters = []
  failures = []

  [*members].each do |c|
    if match = c.match(/^arn:aws:ecs:.+:\d{1,12}:cluster\/(.+)$/)
      result = self.data[:clusters].select { |cl| cl['clusterArn'].eql?(c) }
    else
      result = self.data[:clusters].select { |cl| cl['clusterName'].eql?(c) }
    end
    if result.empty?
      cluster_name = match[1] if match
      cluster_name = c        unless match
      failures << { 'name' => cluster_name }
    else
      clusters << result.first
    end
  end

  owner_id = Fog::AWS::Mock.owner_id

  failures.map! do |f|
    {
      'arn' => Fog::AWS::Mock.arn('ecs', owner_id, "cluster/#{f['name']}", region),
      'reason' => 'MISSING'
    }
  end
  clusters.map! do |c|
    {
      'clusterName' => c['clusterName'],
      'clusterArn'  => c['clusterArn'],
      'status'      => c['status']
    }
  end

  response.body = {
    'DescribeClustersResult' => {
      'failures' => failures,
      'clusters' => clusters
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end
describe_container_instances(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/describe_container_instances.rb, line 30
def describe_container_instances(params={})
  response = Excon::Response.new
  response.status = 200

  cluster = params.delete('cluster') || 'default'

  instances_id = params.delete('containerInstances')
  msg = 'ClientException => Container instance cannot be empty.'
  raise Fog::AWS::ECS::Error, msg unless instances_id

  result = []
  [*instances_id].each do |inst|
    if match = inst.match(/^arn:aws:ecs:.+:\d{1,12}:container-instance\/(.+)$/)
      result = self.data[:container_instances].select { |i| i['containerInstanceArn'].eql?(inst) }
    else
      result = self.data[:container_instances].select { |i| i['containerInstanceArn'].match(/#{inst}$/) }
    end
  end

  instances = result
  response.body = {
    'DescribeContainerInstancesResult' => {
      'containerInstances' => instances,
      'failures'           => []
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end
describe_services(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/describe_services.rb, line 30
def describe_services(params={})
  response = Excon::Response.new
  response.status = 200

  cluster = params.delete('cluster') || 'default'
  services = params.delete('services')
  msg = 'InvalidParameterException => Services cannot be empty.'
  raise Fog::AWS::ECS::Error, msg unless services

  owner_id = Fog::AWS::Mock.owner_id

  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 = []
  ([*services].select { |s| s.match(/^arn:/) }).each do |ds|
    result.concat(self.data[:services].select do |sv|
      sv['serviceArn'].eql?(ds) && sv['clusterArn'].eql?(cluster_arn)
    end)
  end
  ([*services].select { |s| !s.match(/^arn:/) }).each do |ds|
    result.concat(self.data[:services].select do |sv|
      sv['serviceName'].eql?(ds) && sv['clusterArn'].eql?(cluster_arn)
    end)
  end

  response.body = {
    'DescribeServicesResult' => {
      'services' => result,
      'failures' => []
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end
describe_task_definition(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/describe_task_definition.rb, line 24
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
describe_tasks(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/describe_tasks.rb, line 30
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
list_clusters(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/list_clusters.rb, line 26
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
list_container_instances(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/list_container_instances.rb, line 27
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
list_services(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/list_services.rb, line 27
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
list_task_definition_families(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/list_task_definition_families.rb, line 27
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
list_task_definitions(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/list_task_definitions.rb, line 27
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
list_tasks(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/list_tasks.rb, line 31
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
register_task_definition(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/register_task_definition.rb, line 30
def register_task_definition(params={})
  response = Excon::Response.new
  response.status = 200

  family_error = 'ClientException => Family can not be blank.'
  container_error = 'ClientException => Container list cannot be empty.'
  raise Fog::AWS::ECS::Error, family_error    unless params['family']
  raise Fog::AWS::ECS::Error, container_error unless params['containerDefinitions']

  owner_id = Fog::AWS::Mock.owner_id
  taskdef_name = params['family']
  taskdef_rev = (1..9).to_a.shuffle.first
  taskdef_path = "task-definition/#{taskdef_name}:#{taskdef_rev}"
  taskdef_arn = Fog::AWS::Mock.arn('ecs', owner_id, taskdef_path, region)

  task_definition = {
    'revision'             => taskdef_rev,
    'taskDefinitionArn'    => taskdef_arn,
    'family'               => params['family'],
    'containerDefinitions' => params['containerDefinitions']
  }
  task_definition['volumes'] = params['volumes'] if params['volumes']

  self.data[:task_definitions] << task_definition

  response.body = {
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    },
    'RegisterTaskDefinitionResult' => {
      'taskDefinition' => task_definition
    }
  }
  response
end
reset_data() click to toggle source
# File lib/fog/aws/ecs.rb, line 175
def reset_data
  self.class.data[@region].delete(@aws_access_key_id)
end
run_task(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/run_task.rb, line 39
def run_task(params={})
  response = Excon::Response.new
  response.status = 200

  unless task_def_id = params.delete('taskDefinition')
    msg = 'ClientException => TaskDefinition cannot be empty.'
    raise Fog::AWS::ECS::Error, msg
  end

  begin
    result = describe_task_definition('taskDefinition' => task_def_id).body
    task_def = result["DescribeTaskDefinitionResult"]["taskDefinition"]
    task_def_arn = task_def["taskDefinitionArn"]
  rescue Fog::AWS::ECS::Error => e
    msg = 'ClientException => TaskDefinition not found.'
    raise Fog::AWS::ECS::Error, msg
  end

  if %w(count overrides).any? { |k| params.has_key?(k) }
    Fog::Logger.warning("you used parameters not mocked yet [light_black](#{caller.first})[/]")
    Fog::Mock.not_implemented
  end

  cluster_id = params.delete('cluster') || 'default'
  cluster_arn = nil
  owner_id = Fog::AWS::Mock.owner_id

  if cluster_id.match(/^arn:aws:ecs:.+:\d{1,12}:cluster\/(.+)$/)
    cluster_arn = cluster_id
  else
    cluster_path = "cluster/#{cluster_id}"
    cluster_arn = Fog::AWS::Mock.arn('ecs', owner_id, cluster_path, region)
  end

  task_path = "task/#{UUID.uuid}"
  task_arn = Fog::AWS::Mock.arn('ecs', owner_id, task_path, region)
  instance_path = "container-instance/#{UUID.uuid}"
  container_instance_arn = Fog::AWS::Mock.arn('ecs', owner_id, instance_path, region)

  containers = []
  task_def["containerDefinitions"].each do |c|
    container_path = "container/#{UUID.uuid}"
    containers << {
      'name'         => c['name'],
      'taskArn'      => task_arn,
      'lastStatus'   => 'PENDING',
      'containerArn' => Fog::AWS::Mock.arn('ecs', owner_id, container_path, region)
    }
  end

  task = {
    'clusterArn'           => cluster_arn,
    'desiredStatus'        => 'RUNNING',
    'taskDefinitionArn'    => task_def_arn,
    'lastStatus'           => 'PENDING',
    'taskArn'              => task_arn,
    'containerInstanceArn' => container_instance_arn,
    'containers'           => containers
  }
  self.data[:tasks] << task

  response.body = {
    'RunTaskResult' => {
      'failures' => [],
      'tasks' => [] << task
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end
setup_credentials(options) click to toggle source
# File lib/fog/aws/ecs.rb, line 179
def setup_credentials(options)
  @aws_access_key_id = options[:aws_access_key_id]
end
start_task(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/start_task.rb, line 43
def start_task(params={})
  response = Excon::Response.new
  response.status = 200

  unless task_def_id = params.delete('taskDefinition')
    msg = 'ClientException => TaskDefinition cannot be empty.'
    raise Fog::AWS::ECS::Error, msg
  end

  unless instances_id = params.delete('containerInstances')
    msg = 'ClientException => Container instances cannot be empty.'
    raise Fog::AWS::ECS::Error, msg
  end

  begin
    result = describe_task_definition('taskDefinition' => task_def_id).body
    task_def = result["DescribeTaskDefinitionResult"]["taskDefinition"]
    task_def_arn = task_def["taskDefinitionArn"]
  rescue Fog::AWS::ECS::Error => e
    msg = 'ClientException => TaskDefinition not found.'
    raise Fog::AWS::ECS::Error, msg
  end

  if %w(startedBy overrides).any? { |k| params.has_key?(k) }
    Fog::Logger.warning("you used parameters not mocked yet [light_black](#{caller.first})[/]")
    Fog::Mock.not_implemented
  end

  cluster_id = params.delete('cluster') || 'default'
  cluster_arn = nil
  owner_id = Fog::AWS::Mock.owner_id

  if cluster_id.match(/^arn:aws:ecs:.+:\d{1,12}:cluster\/(.+)$/)
    cluster_arn = cluster_id
  else
    cluster_path = "cluster/#{cluster_id}"
    cluster_arn = Fog::AWS::Mock.arn('ecs', owner_id, cluster_path, region)
  end

  task_path = "task/#{UUID.uuid}"
  task_arn = Fog::AWS::Mock.arn('ecs', owner_id, task_path, region)
  instance_path = "container-instance/#{UUID.uuid}"

  instance_id = [*instances_id].first
  if instance_id.match(/^arn:aws:ecs:.+:\d{1,12}:container-instance\/(.+)$/)
    container_instance_arn = instance_id
  else
    instance_path = "container-instance/#{instance_id}"
    container_instance_arn = Fog::AWS::Mock.arn('ecs', owner_id, instance_path, region)
  end

  containers = []
  task_def["containerDefinitions"].each do |c|
    container_path = "container/#{UUID.uuid}"
    containers << {
      'name'         => c['name'],
      'taskArn'      => task_arn,
      'lastStatus'   => 'PENDING',
      'containerArn' => Fog::AWS::Mock.arn('ecs', owner_id, container_path, region)
    }
  end

  task = {
    'clusterArn'           => cluster_arn,
    'desiredStatus'        => 'RUNNING',
    'taskDefinitionArn'    => task_def_arn,
    'lastStatus'           => 'PENDING',
    'taskArn'              => task_arn,
    'containerInstanceArn' => container_instance_arn,
    'containers'           => containers
  }
  self.data[:tasks] << task

  response.body = {
    'StartTaskResult' => {
      'failures' => [],
      'tasks' => [] << task
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end
stop_task(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/stop_task.rb, line 25
def stop_task(params={})
  response = Excon::Response.new
  response.status = 200

  unless task_id = params.delete('task')
    msg = "InvalidParameterException => Task can not be blank."
    raise Fog::AWS::ECS::Error, msg
  end

  if cluster = params.delete('cluster')
    Fog::Logger.warning("you used parameters not mocked yet [light_black](#{caller.first})[/]")
  end

  if match = task_id.match(/^arn:aws:ecs:.+:\d{1,12}:task\/(.+)$/)
    i = self.data[:tasks].index { |t| t['taskArn'].eql?(task_id) }
  else
    i = self.data[:tasks].index { |t| t['taskArn'].match(/#{task_id}$/) }
  end

  msg = "ClientException => The referenced task was not found."
  raise Fog::AWS::ECS::Error, msg unless i

  task = self.data[:tasks][i]
  task['desiredStatus'] = 'STOPPED'
  self.data[:tasks].delete_at(i)

  response.body = {
    'StopTaskResult' => {
      'task' => task
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end
update_service(params={}) click to toggle source
# File lib/fog/aws/requests/ecs/update_service.rb, line 27
def update_service(params={})
  response = Excon::Response.new
  response.status = 200

  service_id = params.delete('service')
  msg = 'ClientException => Service cannot be empty.'
  raise Fog::AWS::ECS::Error, msg unless service_id

  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

  if match = service_id.match(/^arn:aws:ecs:.+:\d{1,12}:service\/(.+)$/)
    i = self.data[:services].index do |s|
      s['clusterArn'].eql?(cluster_arn) && s['serviceArn'].eql?(service_id)
    end
  else
    i = self.data[:services].index do |s|
      s['clusterArn'].eql?(cluster_arn) && s['serviceName'].eql?(service_id)
    end
  end

  msg = "ServiceNotFoundException => Service not found."
  raise Fog::AWS::ECS::Error, msg unless i

  service = self.data[:services][i]

  if desired_count = params.delete('desiredCount')
    # ignore
  end

  if task_definition = params.delete('taskDefinition')
    service['taskDefinition'] = task_definition
  end

  response.body = {
    'UpdateServiceResult' => {
      'service' => service
    },
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    }
  }
  response
end