(.*)})[1]]
end
end
tests('#get_bucket_lifecycle').returns([404, 'NoSuchBucket']) do
begin
Fog::Storage[:aws].get_bucket_lifecycle('fognonbucket')
rescue Excon::Errors::NotFound => e
[e.response.status, e.response.body.match(%r{(.*)})[1]]
end
end
tests('#delete_bucket_lifecycle').returns([404, 'NoSuchBucket']) do
begin
Fog::Storage[:aws].delete_bucket_lifecycle('fognonbucket')
rescue Excon::Errors::NotFound => e
[e.response.status, e.response.body.match(%r{(.*)})[1]]
end
end
end
tests('no lifecycle') do
tests('#get_bucket_lifecycle').returns([404, 'NoSuchLifecycleConfiguration']) do
begin
Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name)
rescue Excon::Errors::NotFound => e
[e.response.status, e.response.body.match(%r{(.*)})[1]]
end
end
tests('#delete_bucket_lifecycle').succeeds do
Fog::Storage[:aws].delete_bucket_lifecycle(@aws_bucket_name)
end
end
tests('create').succeeds do
Fog::Storage[:aws].put_bucket_lifecycle(@aws_bucket_name, lifecycle)
end
tests('read').formats(@bucket_lifecycle_format) do
Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name).body
end
lifecycle = { 'Rules' => 5.upto(6).map { |i| {'ID' => "rule\##{i}", 'Prefix' => i.to_s, 'Enabled' => true, 'Days' => i} } }
lifecycle_return = { 'Rules' => 5.upto(6).map { |i| {'ID' => "rule\##{i}", 'Prefix' => i.to_s, 'Enabled' => true, 'Expiration' => {'Days' => i}} } }
tests('update').returns(lifecycle_return) do
Fog::Storage[:aws].put_bucket_lifecycle(@aws_bucket_name, lifecycle)
Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name).body
end
lifecycle = {'Rules' => [{'ID' => 'test rule', 'Prefix' => '/prefix', 'Enabled' => true, 'Expiration' => {'Days' => 42}, 'Transition' => {'Days' => 6, 'StorageClass'=>'GLACIER'}}]}
tests('transition').returns(lifecycle) do
Fog::Storage[:aws].put_bucket_lifecycle(@aws_bucket_name, lifecycle)
Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name).body
end
lifecycle = {'Rules' => [{'ID' => 'test rule', 'Prefix' => '/prefix', 'Enabled' => true, 'Expiration' => {'Date' => '2012-12-31T00:00:00.000Z'}}]}
tests('date').returns(lifecycle) do
Fog::Storage[:aws].put_bucket_lifecycle(@aws_bucket_name, lifecycle)
Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name).body
end
tests('delete').succeeds do
Fog::Storage[:aws].delete_bucket_lifecycle(@aws_bucket_name)
end
tests('read').returns([404, 'NoSuchLifecycleConfiguration']) do
begin
Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name)
rescue Excon::Errors::NotFound => e
[e.response.status, e.response.body.match(%r{(.*)})[1]]
end
end
end
tests("put_bucket_cors('#{@aws_bucket_name}', cors)").succeeds do
cors = {'CORSConfiguration' =>
[
{
'AllowedOrigin' => 'http://localhost:3000',
'AllowedMethod' => ['POST', 'GET'],
'AllowedHeader' => '*',
'MaxAgeSeconds' => 3000
}
]
}
Fog::Storage[:aws].put_bucket_cors(@aws_bucket_name, cors)
end
tests("bucket tagging") do
tests("#put_bucket_tagging('#{@aws_bucket_name}')").succeeds do
Fog::Storage[:aws].put_bucket_tagging(@aws_bucket_name, {'Key1' => 'Value1', 'Key2' => 'Value2'})
end
tests("#get_bucket_tagging('#{@aws_bucket_name}')").
returns('BucketTagging' => {'Key1' => 'Value1', 'Key2' => 'Value2'}) do
Fog::Storage[:aws].get_bucket_tagging(@aws_bucket_name).body
end
tests("#delete_bucket_tagging('#{@aws_bucket_name}')").succeeds do
Fog::Storage[:aws].delete_bucket_tagging(@aws_bucket_name)
end
end
tests("bucket notification") do
@topic_arn = Fog::AWS[:sns].create_topic('fog_notifications_tests').body['TopicArn']
tests("#put_bucket_notification('#{@aws_bucket_name}')").succeeds do
Fog::Storage[:aws].put_bucket_notification(@aws_bucket_name, { 'Topics' => [{
'Topic' => @topic_arn, 'Event' => 's3:ObjectCreated:CompleteMultipartUpload'
}]})
end
tests("#get_bucket_notification('#{@aws_bucket_name}')").
returns({'Topics' => [{ 'Topic' => @topic_arn, 'Event' => 's3:ObjectCreated:CompleteMultipartUpload' }]}) do
Fog::Storage[:aws].get_bucket_notification(@aws_bucket_name).body
end
Fog::AWS[:sns].delete_topic(@topic_arn)
end
tests("#delete_bucket('#{@aws_bucket_name}')").succeeds do
Fog::Storage[:aws].delete_bucket(@aws_bucket_name)
end
end
tests('failure') do
tests("#delete_bucket('fognonbucket')").raises(Excon::Errors::NotFound) do
Fog::Storage[:aws].delete_bucket('fognonbucket')
end
@bucket = Fog::Storage[:aws].directories.create(:key => 'fognonempty')
@file = @bucket.files.create(:key => 'foo', :body => 'bar')
tests("#delete_bucket('fognonempty')").raises(Excon::Errors::Conflict) do
Fog::Storage[:aws].delete_bucket('fognonempty')
end
@file.destroy
@bucket.destroy
tests("#get_bucket('fognonbucket')").raises(Excon::Errors::NotFound) do
Fog::Storage[:aws].get_bucket('fognonbucket')
end
tests("#get_bucket_location('fognonbucket')").raises(Excon::Errors::NotFound) do
Fog::Storage[:aws].get_bucket_location('fognonbucket')
end
tests("#get_bucket_notification('fognonbucket')").raises(Excon::Errors::NotFound) do
Fog::Storage[:aws].get_bucket_notification('fognonbucket')
end
tests("#get_request_payment('fognonbucket')").raises(Excon::Errors::NotFound) do
Fog::Storage[:aws].get_request_payment('fognonbucket')
end
tests("#put_request_payment('fognonbucket', 'Requester')").raises(Excon::Errors::NotFound) do
Fog::Storage[:aws].put_request_payment('fognonbucket', 'Requester')
end
tests("#put_bucket_acl('fognonbucket', 'invalid')").raises(Excon::Errors::BadRequest) do
Fog::Storage[:aws].put_bucket_acl('fognonbucket', 'invalid')
end
tests("#put_bucket_website('fognonbucket', 'index.html')").raises(Excon::Errors::NotFound) do
Fog::Storage[:aws].put_bucket_website('fognonbucket', 'index.html')
end
tests('put existing bucket - non-default region') do
storage_eu_endpoint = Fog::Storage[:aws]
storage_eu_endpoint.region = "eu-west-1"
storage_eu_endpoint.put_bucket(@aws_bucket_name)
tests("#put_bucket('#{@aws_bucket_name}') existing").raises(Excon::Errors::Conflict) do
storage_eu_endpoint.put_bucket(@aws_bucket_name)
end
end
tests("#put_bucket_website('fognonbucket', :RedirectAllRequestsTo => 'redirect.example.com')").raises(Excon::Errors::NotFound) do
Fog::Storage[:aws].put_bucket_website('fognonbucket', :RedirectAllRequestsTo => 'redirect.example.com')
end
end
# don't keep the bucket around
Fog::Storage[:aws].delete_bucket(@aws_bucket_name) rescue nil
end
fog-aws-0.7.6/tests/requests/emr/ 0000755 0000041 0000041 00000000000 12576636531 016735 5 ustar www-data www-data fog-aws-0.7.6/tests/requests/emr/helper.rb 0000644 0000041 0000041 00000011547 12576636531 020551 0 ustar www-data www-data class AWS
module EMR
module Formats
BASIC = {
'RequestId' => String
}
RUN_JOB_FLOW = BASIC.merge({
'JobFlowId' => String
})
ADD_INSTANCE_GROUPS = {
'JobFlowId' => String,
'InstanceGroupIds' => Array
}
SIMPLE_DESCRIBE_JOB_FLOW = {
'JobFlows' => [{
'Name' => String,
'BootstrapActions' => {
'ScriptBootstrapActionConfig' => {
'Args' => Array
}
},
'ExecutionStatusDetail' => {
'CreationDateTime' => String,
'State' => String,
'LastStateChangeReason' => String
},
'Steps' => [{
'ActionOnFailure' => String,
'Name' => String,
'StepConfig' => {
'HadoopJarStepConfig' => {
'MainClass' => String,
'Jar' => String,
'Args' => Array,
'Properties' => Array
}
},
'ExecutionStatusDetail' => {
'CreationDateTime' => String,
'State' => String
}
}],
'JobFlowId' => String,
'Instances' => {
'InstanceCount' => String,
'NormalizedInstanceHours' => String,
'KeepJobFlowAliveWhenNoSteps' => String,
'Placement' => {
'AvailabilityZone' => String
},
'MasterInstanceType' => String,
'SlaveInstanceType' => String,
'InstanceGroups' => Array,
'TerminationProtected' => String,
'HadoopVersion' => String
}
}]
}
JOB_FLOW_WITHOUT_CHANGE = {
'JobFlows' => [{
'Name' => String,
'BootstrapActions' => {
'ScriptBootstrapActionConfig' => {
'Args' => Array
}
},
'ExecutionStatusDetail' => {
'CreationDateTime' => String,
'State' => String,
'LastStateChangeReason' => NilClass
},
'Steps' => [{
'ActionOnFailure' => String,
'Name' => String,
'StepConfig' => {
'HadoopJarStepConfig' => {
'MainClass' => String,
'Jar' => String,
'Args' => Array,
'Properties' => Array
}
},
'ExecutionStatusDetail' => {
'CreationDateTime' => String,
'State' => String
}
}],
'JobFlowId' => String,
'Instances' => {
'InstanceCount' => String,
'NormalizedInstanceHours' => String,
'KeepJobFlowAliveWhenNoSteps' => String,
'Placement' => {
'AvailabilityZone' => String
},
'MasterInstanceType' => String,
'SlaveInstanceType' => String,
'InstanceGroups' => Array,
'TerminationProtected' => String,
'HadoopVersion' => String
}
}]
}
DESCRIBE_JOB_FLOW_WITH_INSTANCE_GROUPS = {
'JobFlows' => [{
'Name' => String,
'BootstrapActions' => {
'ScriptBootstrapActionConfig' => {
'Args' => Array
}
},
'ExecutionStatusDetail' => {
'CreationDateTime' => String,
'State' => String,
'LastStateChangeReason' => NilClass
},
'Steps' => [{
'ActionOnFailure' => String,
'Name' => String,
'StepConfig' => {
'HadoopJarStepConfig' => {
'MainClass' => String,
'Jar' => String,
'Args' => Array,
'Properties' => Array
}
},
'ExecutionStatusDetail' => {
'CreationDateTime' => String,
'State' => String
}
}],
'JobFlowId' => String,
'Instances' => {
'InstanceCount' => String,
'NormalizedInstanceHours' => String,
'KeepJobFlowAliveWhenNoSteps' => String,
'Placement' => {
'AvailabilityZone' => String
},
'InstanceGroups' => [{
'Name' => String,
'InstanceRole' => String,
'CreationDateTime' => String,
'LastStateChangeReason' => nil,
'InstanceGroupId' => String,
'Market' => String,
'InstanceType' => String,
'State' => String,
'InstanceRunningCount' => String,
'InstanceRequestCount' => String
}],
'MasterInstanceType' => String,
'SlaveInstanceType' => String,
'TerminationProtected' => String,
'HadoopVersion' => String
}
}]
}
end
end
end
fog-aws-0.7.6/tests/requests/emr/job_flow_tests.rb 0000644 0000041 0000041 00000004375 12576636531 022316 0 ustar www-data www-data Shindo.tests('AWS::EMR | job flows', ['aws', 'emr']) do
pending if Fog.mocking?
@job_flow_name = "fog_job_flow_#{Time.now.to_f.to_s.gsub('.','')}"
@job_flow_options = {
'Instances' => {
'MasterInstanceType' => 'm1.small',
'SlaveInstanceType' => 'm1.small',
'InstanceCount' => 2,
'Placement' => {
'AvailabilityZone' => 'us-east-1a'
},
'KeepJobFlowAliveWhenNoSteps' => false,
'TerminationProtected' => false,
'HadoopVersion' => '0.20'
}
}
@step_name = "fog_job_flow_step_#{Time.now.to_f.to_s.gsub('.','')}"
@job_flow_steps = {
'Steps' => [{
'Name' => @step_name,
'ActionOnFailure' => 'CONTINUE',
'HadoopJarStep' => {
'Jar' => 'FakeJar',
'MainClass' => 'FakeMainClass',
'Args' => ['arg1', 'arg2']
}
}]
}
@job_flow_id = nil
tests('success') do
tests("#run_job_flow").formats(AWS::EMR::Formats::RUN_JOB_FLOW) do
pending if Fog.mocking?
result = Fog::AWS[:emr].run_job_flow(@job_flow_name, @job_flow_options).body
@job_flow_id = result['JobFlowId']
result
end
tests("#add_job_flow_steps").formats(AWS::EMR::Formats::BASIC) do
pending if Fog.mocking?
result = Fog::AWS[:emr].add_job_flow_steps(@job_flow_id, @job_flow_steps).body
result
end
tests("#set_termination_protection").formats(AWS::EMR::Formats::BASIC) do
result = Fog::AWS[:emr].set_termination_protection(true, 'JobFlowIds' => [@job_flow_id]).body
test("protected?") do
res = Fog::AWS[:emr].describe_job_flows('JobFlowIds' => [@job_flow_id]).body
jf = res['JobFlows'].first
jf['Instances']['TerminationProtected'] == 'true'
end
result
end
tests("#terminate_job_flow").formats(AWS::EMR::Formats::BASIC) do
pending if Fog.mocking?
Fog::AWS[:emr].set_termination_protection(false, 'JobFlowIds' => [@job_flow_id])
result = Fog::AWS[:emr].terminate_job_flows('JobFlowIds' => [@job_flow_id]).body
result
end
tests("#describe_job_flows").formats(AWS::EMR::Formats::SIMPLE_DESCRIBE_JOB_FLOW) do
pending if Fog.mocking?
result = Fog::AWS[:emr].describe_job_flows('JobFlowIds' => [@job_flow_id]).body
result
end
end
end
fog-aws-0.7.6/tests/requests/emr/instance_group_tests.rb 0000644 0000041 0000041 00000006364 12576636531 023535 0 ustar www-data www-data Shindo.tests('AWS::EMR | instance groups', ['aws', 'emr']) do
pending if Fog.mocking?
@job_flow_name = "fog_job_flow_#{Time.now.to_f.to_s.gsub('.','')}"
@job_flow_options = {
'Instances' => {
'MasterInstanceType' => 'm1.small',
'SlaveInstanceType' => 'm1.small',
'InstanceCount' => 2,
'Placement' => {
'AvailabilityZone' => 'us-east-1a'
},
'KeepJobFlowAliveWhenNoSteps' => false,
'TerminationProtected' => false,
'HadoopVersion' => '0.20'
}
}
@job_flow_steps = {
'Steps' => [{
'Name' => 'Dummy streaming job',
'ActionOnFailure' => 'CONTINUE',
'HadoopJarStep' => {
'Jar' => '/home/hadoop/contrib/streaming/hadoop-streaming.jar',
'MainClass' => nil,
'Args' => %w(-input s3n://elasticmapreduce/samples/wordcount/input -output hdfs:///examples/output/2011-11-03T090856 -mapper s3n://elasticmapreduce/samples/wordcount/wordSplitter.py -reducer aggregate)
}
}]
}
@instance_group_name = "fog_instance_group_#{Time.now.to_f.to_s.gsub('.','')}"
@instance_groups = {
'InstanceGroups' => [{
'Name' => @instance_group_name,
'InstanceRole' => 'TASK',
'InstanceType' => 'm1.small',
'InstanceCount' => 2
}]
}
result = Fog::AWS[:emr].run_job_flow(@job_flow_name, @job_flow_options).body
@job_flow_id = result['JobFlowId']
tests('success') do
tests("#add_instance_groups").formats(AWS::EMR::Formats::ADD_INSTANCE_GROUPS) do
pending if Fog.mocking?
result = Fog::AWS[:emr].add_instance_groups(@job_flow_id, @instance_groups).body
@instance_group_id = result['InstanceGroupIds'].first
result
end
tests("#describe_job_flows_with_instance_groups").formats(AWS::EMR::Formats::DESCRIBE_JOB_FLOW_WITH_INSTANCE_GROUPS) do
pending if Fog.mocking?
result = Fog::AWS[:emr].describe_job_flows('JobFlowIds' => [@job_flow_id]).body
result
end
tests("#modify_instance_groups").formats(AWS::EMR::Formats::BASIC) do
pending if Fog.mocking?
# Add a step so the state doesn't go directly from STARTING to SHUTTING_DOWN
Fog::AWS[:emr].add_job_flow_steps(@job_flow_id, @job_flow_steps)
# Wait until job has started before modifying the instance group
begin
sleep 10
result = Fog::AWS[:emr].describe_job_flows('JobFlowIds' => [@job_flow_id]).body
job_flow = result['JobFlows'].first
state = job_flow['ExecutionStatusDetail']['State']
print "."
end while(state == 'STARTING')
# Check results
result = Fog::AWS[:emr].modify_instance_groups('InstanceGroups' => [{'InstanceGroupId' => @instance_group_id, 'InstanceCount' => 4}]).body
# Check the it actually modified the instance count
tests("modify worked?") do
ig_res = Fog::AWS[:emr].describe_job_flows('JobFlowIds' => [@job_flow_id]).body
matched = false
jf = ig_res['JobFlows'].first
jf['Instances']['InstanceGroups'].each do | ig |
if ig['InstanceGroupId'] == @instance_group_id
matched = true if ig['InstanceRequestCount'].to_i == 4
end
end
matched
end
result
end
end
Fog::AWS[:emr].terminate_job_flows('JobFlowIds' => [@job_flow_id])
end
fog-aws-0.7.6/tests/requests/auto_scaling/ 0000755 0000041 0000041 00000000000 12576636531 020622 5 ustar www-data www-data fog-aws-0.7.6/tests/requests/auto_scaling/helper.rb 0000644 0000041 0000041 00000014752 12576636531 022437 0 ustar www-data www-data class AWS
module AutoScaling
module Formats
BASIC = {
'ResponseMetadata' => {'RequestId' => String}
}
PAGINATED = {
'NextToken' => Fog::Nullable::String
}
ACTIVITY = {
'ActivityId' => String,
'AutoScalingGroupName' => String,
'Cause' => Fog::Nullable::String,
'Description' => String,
'EndTime' => Time,
'Progress' => Integer,
'StartTime' => Time,
'StatusCode' => String,
'StatusMessage' => Fog::Nullable::String
}
ALARM = {
'AlarmARN' => String,
'AlarmName' => String
}
BLOCK_DEVICE_MAPPING = {
'DeviceName' => String,
'Ebs' => {'SnapshotId' => String, 'VolumeSize' => Integer},
'VirtualName' => String
}
ENABLED_METRIC = {
'Granularity' => Array,
'Metric' => Array
}
INSTANCE = {
'AvailabilityZone' => String,
'HealthStatus' => String,
'InstanceId' => String,
'LaunchConfigurationName' => String,
'LifecycleState' => String
}
NOTIFICATION_CONFIGURATION = {
'AutoScalingGroupName' => String,
'NotificationType' => String,
'TopicARN' => String
}
SCHEDULED_UPDATE_GROUP_ACTION = {
'AutoScalingGroupName' => String,
'DesiredCapacity' => Integer,
'EndTime' => Time,
'MaxSize' => Integer,
'MinSize' => Integer,
'Recurrence' => String,
'ScheduledActionARN' => String,
'ScheduledActionName' => String,
'StartTime' => Time,
}
PROCESS_TYPE = {
'ProcessName' => String
}
SUSPENDED_PROCESS = PROCESS_TYPE.merge({
'SuspensionReason' => String
})
TAG_DESCRIPTION = {
'Key' => String,
'PropagateAtLaunch' => Fog::Boolean,
'ResourceId' => String,
'ResourceType' => String,
'Value' => Fog::Nullable::String
}
AUTO_SCALING_GROUP = {
'AutoScalingGroupARN' => String,
'AutoScalingGroupName' => String,
'AvailabilityZones' => Array,
'CreatedTime' => Time,
'DefaultCooldown' => Integer,
'DesiredCapacity' => Integer,
'EnabledMetrics' => [ENABLED_METRIC],
'HealthCheckGracePeriod' => Integer,
'HealthCheckType' => String,
'Instances' => [INSTANCE],
'LaunchConfigurationName' => String,
'LoadBalancerNames' => Array,
'MaxSize' => Integer,
'MinSize' => Integer,
'PlacementGroup' => Fog::Nullable::String,
'Status' => Fog::Nullable::String,
'SuspendedProcesses' => [SUSPENDED_PROCESS],
'Tags' => [TAG_DESCRIPTION],
'TerminationPolicies' => [String],
'VPCZoneIdentifier' => Fog::Nullable::String
}
AUTO_SCALING_INSTANCE_DETAILS = INSTANCE.merge({
'AutoScalingGroupName' => String
})
LAUNCH_CONFIGURATION = {
'BlockDeviceMappings' => [BLOCK_DEVICE_MAPPING],
'CreatedTime' => Time,
'ImageId' => String,
'InstanceMonitoring' => {'Enabled' => Fog::Boolean},
'InstanceType' => String,
'KernelId' => Fog::Nullable::String,
'KeyName' => Fog::Nullable::String,
'LaunchConfigurationARN' => String,
'LaunchConfigurationName' => String,
'RamdiskId' => Fog::Nullable::String,
'SpotPrice' => Fog::Nullable::String,
'SecurityGroups' => Array,
'UserData' => Fog::Nullable::String
}
SCALING_POLICY = {
'AdjustmentType' => String,
'Alarms' => [ALARM],
'AutoScalingGroupName' => String,
'Cooldown' => Integer,
'MinAdjustmentStep' => Integer,
'PolicyARN' => String,
'PolicyName' => String,
'ScalingAdjustment' => Integer
}
DESCRIBE_ADJUSTMENT_TYPES = BASIC.merge({
'DescribeAdjustmentTypesResult' => {
'AdjustmentTypes' => [{'AdjustmentType' => String}]
}
})
DESCRIBE_AUTO_SCALING_GROUPS = BASIC.merge({
'DescribeAutoScalingGroupsResult' => PAGINATED.merge({
'AutoScalingGroups' => [AUTO_SCALING_GROUP],
})
})
DESCRIBE_AUTO_SCALING_INSTANCES = BASIC.merge({
'DescribeAutoScalingInstancesResult' => PAGINATED.merge({
'AutoScalingInstances' => [AUTO_SCALING_INSTANCE_DETAILS],
})
})
DESCRIBE_AUTO_SCALING_NOTIFICATION_TYPES = BASIC.merge({
'DescribeAutoScalingNotificationTypesResult' => {
'AutoScalingNotificationTypes' => [String]
}
})
DESCRIBE_LAUNCH_CONFIGURATIONS = BASIC.merge({
'DescribeLaunchConfigurationsResult' => PAGINATED.merge({
'LaunchConfigurations' => [LAUNCH_CONFIGURATION],
})
})
DESCRIBE_METRIC_COLLECTION_TYPES = BASIC.merge({
'DescribeMetricCollectionTypesResult' => {
'Granularities' => [{'Granularity' => String}],
'Metrics' => [{'Metric' => String}]
}
})
DESCRIBE_NOTIFICATION_CONFIGURATIONS = BASIC.merge({
'DescribeNotificationConfigurationsResult' => PAGINATED.merge({
'NotificationConfigurations' => [NOTIFICATION_CONFIGURATION]
})
})
DESCRIBE_POLICIES = BASIC.merge({
'DescribePoliciesResult' => PAGINATED.merge({
'ScalingPolicies' => [SCALING_POLICY]
})
})
DESCRIBE_SCALING_ACTIVITIES = BASIC.merge({
'DescribeScalingActivitiesResult' => PAGINATED.merge({
'Activities' => [ACTIVITY],
})
})
DESCRIBE_SCALING_PROCESS_TYPES = BASIC.merge({
'DescribeScalingProcessTypesResult' => {
'Processes' => [PROCESS_TYPE]
}
})
DESCRIBE_SCHEDULED_ACTIONS = BASIC.merge({
'DescribeScheduledActionsResult' => PAGINATED.merge({
'ScheduledUpdateGroupActions' => [SCHEDULED_UPDATE_GROUP_ACTION]
})
})
DESCRIBE_TAGS = BASIC.merge({
'DescribeTagsResult' => PAGINATED.merge({
'Tags' => [TAG_DESCRIPTION]
})
})
DESCRIBE_TERMINATION_POLICY_TYPES = BASIC.merge({
'DescribeTerminationPolicyTypesResult' => {
'TerminationPolicyTypes' => [String]
}
})
PUT_SCALING_POLICY = BASIC.merge({
'PutScalingPolicyResult' => {
'PolicyARN' => String
}
})
TERMINATE_INSTANCE_IN_AUTO_SCALING_GROUP = BASIC.merge({
'TerminateInstanceInAutoScalingGroupResult' => {
'Activity' => [ACTIVITY]
}
})
end
end
end
fog-aws-0.7.6/tests/requests/auto_scaling/auto_scaling_tests.rb 0000644 0000041 0000041 00000010404 12576636531 025040 0 ustar www-data www-data Shindo.tests('AWS::AutoScaling | auto_scaling_tests', ['aws', 'auto_scaling']) do
@asg_name = 'fog-test-asg'
@lc_name = 'fog-test-lc'
tests('success') do
tests("#create_launch_configuration").formats(AWS::AutoScaling::Formats::BASIC) do
image_id = 'ami-8c1fece5'
instance_type = 't1.micro'
#listeners = [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'http'}]
Fog::AWS[:auto_scaling].create_launch_configuration(image_id, instance_type, @lc_name).body
end
tests("#describe_launch_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_LAUNCH_CONFIGURATIONS) do
Fog::AWS[:auto_scaling].describe_launch_configurations().body
end
tests("#describe_launch_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_LAUNCH_CONFIGURATIONS) do
Fog::AWS[:auto_scaling].describe_launch_configurations('LaunchConfigurationNames' => @lc_name).body
end
tests("#describe_launch_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_LAUNCH_CONFIGURATIONS) do
Fog::AWS[:auto_scaling].describe_launch_configurations('LaunchConfigurationNames' => [@lc_name]).body
end
tests("#create_auto_scaling_group").formats(AWS::AutoScaling::Formats::BASIC) do
zones = ['us-east-1d']
max_size = 0
min_size = 0
Fog::AWS[:auto_scaling].create_auto_scaling_group(@asg_name, zones, @lc_name, max_size, min_size).body
end
tests("#attach_load_balancers").formats(AWS::AutoScaling::Formats::BASIC) do
Fog::AWS[:auto_scaling].attach_load_balancers(@asg_name, 'LoadBalancerNames' => 'elb-test-fog').body
end
tests("#detach_load_balancers").formats(AWS::AutoScaling::Formats::BASIC) do
Fog::AWS[:auto_scaling].detach_load_balancers(@asg_name, 'LoadBalancerNames' => 'elb-test-fog').body
end
tests("#describe_auto_scaling_groups").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_GROUPS) do
Fog::AWS[:auto_scaling].describe_auto_scaling_groups().body
end
tests("#describe_auto_scaling_groups").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_GROUPS) do
Fog::AWS[:auto_scaling].describe_auto_scaling_groups('AutoScalingGroupNames' => @asg_name).body
end
tests("#describe_auto_scaling_groups").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_GROUPS) do
Fog::AWS[:auto_scaling].describe_auto_scaling_groups('AutoScalingGroupNames' => [@asg_name]).body
end
tests("#describe_auto_scaling_instances").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_INSTANCES) do
Fog::AWS[:auto_scaling].describe_auto_scaling_instances().body
end
tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
pending if Fog.mocking?
Fog::AWS[:auto_scaling].describe_scaling_activities().body
end
tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
pending if Fog.mocking?
Fog::AWS[:auto_scaling].describe_scaling_activities('ActivityIds' => '1').body
end
tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
pending if Fog.mocking?
Fog::AWS[:auto_scaling].describe_scaling_activities('ActivityIds' => ['1', '2']).body
end
tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
pending if Fog.mocking?
Fog::AWS[:auto_scaling].describe_scaling_activities('AutoScalingGroupName' => @asg_name).body
end
tests("#set_desired_capacity").formats(AWS::AutoScaling::Formats::BASIC) do
desired_capacity = 0
Fog::AWS[:auto_scaling].set_desired_capacity(@asg_name, desired_capacity).body
end
tests("#delete_auto_scaling_group").formats(AWS::AutoScaling::Formats::BASIC) do
Fog::AWS[:auto_scaling].delete_auto_scaling_group(@asg_name, 'ForceDelete' => true).body
end
tests("#delete_auto_scaling_group that does not exists").raises(Fog::AWS::AutoScaling::ValidationError) do
Fog::AWS[:auto_scaling].delete_auto_scaling_group("group that does not exist")
end
tests("#delete_launch_configuration").formats(AWS::AutoScaling::Formats::BASIC) do
Fog::AWS[:auto_scaling].delete_launch_configuration(@lc_name).body
end
end
end
fog-aws-0.7.6/tests/requests/auto_scaling/describe_types_tests.rb 0000644 0000041 0000041 00000006337 12576636531 025406 0 ustar www-data www-data Shindo.tests('AWS::AutoScaling | describe types requests', ['aws', 'auto_scaling']) do
tests('success') do
tests("#describe_adjustment_types").formats(AWS::AutoScaling::Formats::DESCRIBE_ADJUSTMENT_TYPES) do
body = Fog::AWS[:auto_scaling].describe_adjustment_types.body
[ 'ChangeInCapacity',
'ExactCapacity',
'PercentChangeInCapacity'
].each do |v|
returns(true, "AdjustmentTypes contains #{v}") do
body['DescribeAdjustmentTypesResult']['AdjustmentTypes'].any? {|t| t['AdjustmentType'] == v}
end
end
body
end
tests("#describe_auto_scaling_notification_types").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_NOTIFICATION_TYPES) do
body = Fog::AWS[:auto_scaling].describe_auto_scaling_notification_types.body
[ 'autoscaling:EC2_INSTANCE_LAUNCH',
'autoscaling:EC2_INSTANCE_LAUNCH_ERROR',
'autoscaling:EC2_INSTANCE_TERMINATE',
'autoscaling:EC2_INSTANCE_TERMINATE_ERROR',
'autoscaling:TEST_NOTIFICATION'
].each do |v|
returns(true, "AutoScalingNotificationTypes contains #{v}") do
body['DescribeAutoScalingNotificationTypesResult']['AutoScalingNotificationTypes'].include?(v)
end
end
body
end
tests("#describe_metric_collection_types").formats(AWS::AutoScaling::Formats::DESCRIBE_METRIC_COLLECTION_TYPES) do
body = Fog::AWS[:auto_scaling].describe_metric_collection_types.body
[ 'GroupDesiredCapacity',
'GroupInServiceInstances',
'GroupMaxSize',
'GroupMinSize',
'GroupPendingInstances',
'GroupTerminatingInstances',
'GroupTotalInstances'
].each do |v|
returns(true, "Metrics contains #{v}") do
body['DescribeMetricCollectionTypesResult']['Metrics'].any? {|t| t['Metric'] == v}
end
end
[ '1Minute'
].each do |v|
returns(true, "Granularities contains #{v}") do
body['DescribeMetricCollectionTypesResult']['Granularities'].any? {|t| t['Granularity'] == v}
end
end
body
end
tests("#describe_scaling_process_types").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_PROCESS_TYPES) do
body = Fog::AWS[:auto_scaling].describe_scaling_process_types.body
[ 'AZRebalance',
'AddToLoadBalancer',
'AlarmNotification',
'HealthCheck',
'Launch',
'ReplaceUnhealthy',
'ScheduledActions',
'Terminate'
].each do |v|
returns(true, "Processes contains #{v}") do
body['DescribeScalingProcessTypesResult']['Processes'].any? {|t| t['ProcessName'] == v}
end
end
body
end
tests("#describe_termination_policy_types").formats(AWS::AutoScaling::Formats::DESCRIBE_TERMINATION_POLICY_TYPES) do
body = Fog::AWS[:auto_scaling].describe_termination_policy_types.body
[ 'ClosestToNextInstanceHour',
'Default',
'NewestInstance',
'OldestInstance',
'OldestLaunchConfiguration'
].each do |v|
returns(true, "TerminationPolicyTypes contains #{v}") do
body['DescribeTerminationPolicyTypesResult']['TerminationPolicyTypes'].include?(v)
end
end
body
end
end
end
fog-aws-0.7.6/tests/requests/auto_scaling/notification_configuration_tests.rb 0000644 0000041 0000041 00000012612 12576636531 030010 0 ustar www-data www-data Shindo.tests('AWS::AutoScaling | notification configuration requests', ['aws', 'auto_scaling']) do
image_id = { # Ubuntu 12.04 LTS 64-bit EBS
'ap-northeast-1' => 'ami-60c77761',
'ap-southeast-1' => 'ami-a4ca8df6',
'ap-southeast-2' => 'ami-fb8611c1',
'eu-west-1' => 'ami-e1e8d395',
'sa-east-1' => 'ami-8cd80691',
'us-east-1' => 'ami-a29943cb',
'us-west-1' => 'ami-87712ac2',
'us-west-2' => 'ami-20800c10'
}
now = Time.now.utc.to_i
lc_name = "fog-test-#{now}"
asg_name = "fog-test-#{now}"
topic_name = "fog-test-#{now}"
begin
topic = Fog::AWS[:sns].create_topic(topic_name).body
topic_arn = topic['TopicArn']
rescue Fog::Errors::MockNotImplemented
topic_arn = Fog::AWS::Mock.arn('sns', Fog::AWS[:auto_scaling].data[:owner_id], "fog-test-#{now}", Fog::AWS[:auto_scaling].region)
end
lc = Fog::AWS[:auto_scaling].create_launch_configuration(image_id[Fog::AWS[:auto_scaling].region], 't1.micro', lc_name)
asg = Fog::AWS[:auto_scaling].create_auto_scaling_group(asg_name, "#{Fog::AWS[:auto_scaling].region}a", lc_name, 0, 0)
tests('raises') do
tests("#put_notification_configuration(non-existent-group)").raises(Fog::AWS::AutoScaling::ValidationError) do
Fog::AWS[:auto_scaling].put_notification_configuration('fog-test-nonexistent-group', 'autoscaling:TEST_NOTIFICATION', topic_arn)
end
tests("#put_notification_configuration(null-types)").raises(Fog::AWS::AutoScaling::ValidationError) do
Fog::AWS[:auto_scaling].put_notification_configuration(asg_name, [], topic_arn)
end
end
tests('success') do
tests("#put_notification_configuration(string)").formats(AWS::AutoScaling::Formats::BASIC) do
pending if Fog.mocking?
Fog::AWS[:auto_scaling].put_notification_configuration(asg_name, 'autoscaling:TEST_NOTIFICATION', topic_arn).body
end
tests("#describe_notification_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_NOTIFICATION_CONFIGURATIONS) do
pending if Fog.mocking?
body = Fog::AWS[:auto_scaling].describe_notification_configurations('AutoScalingGroupNames' => asg_name).body
notification_configurations = body['DescribeNotificationConfigurationsResult']['NotificationConfigurations']
returns(true, 'exactly 1 configurations') do
notification_configurations.size == 1
end
returns(true) do
config = notification_configurations.first
config['AutoScalingGroupName'] == asg_name && config['TopicARN'] == topic_arn && config['NotificationType'] == 'autoscaling:TEST_NOTIFICATION'
end
body
end
tests("#put_notification_configuration(array)").formats(AWS::AutoScaling::Formats::BASIC) do
pending if Fog.mocking?
Fog::AWS[:auto_scaling].put_notification_configuration(asg_name, ['autoscaling:EC2_INSTANCE_LAUNCH', 'autoscaling:EC2_INSTANCE_TERMINATE'], topic_arn).body
end
tests("#describe_notification_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_NOTIFICATION_CONFIGURATIONS) do
pending if Fog.mocking?
body = Fog::AWS[:auto_scaling].describe_notification_configurations('AutoScalingGroupName' => asg_name).body
notification_configurations = body['DescribeNotificationConfigurationsResult']['NotificationConfigurations']
returns(true, 'exactly 2 configurations') do
notification_configurations.size == 2
end
[ 'autoscaling:EC2_INSTANCE_LAUNCH', 'autoscaling:EC2_INSTANCE_TERMINATE'].each do |type|
returns(true) do
notification_configurations.any? do |config|
config['AutoScalingGroupName'] == asg_name && config['TopicARN'] == topic_arn && config['NotificationType'] == type
end
end
end
body
end
tests("#describe_notification_configurations(all)").formats(AWS::AutoScaling::Formats::DESCRIBE_NOTIFICATION_CONFIGURATIONS) do
pending if Fog.mocking?
body = Fog::AWS[:auto_scaling].describe_notification_configurations().body
notification_configurations = body['DescribeNotificationConfigurationsResult']['NotificationConfigurations']
returns(true, 'at least 2 configurations') do
notification_configurations.size >= 2
end
[ 'autoscaling:EC2_INSTANCE_LAUNCH', 'autoscaling:EC2_INSTANCE_TERMINATE'].each do |type|
returns(true) do
notification_configurations.any? do |config|
config['AutoScalingGroupName'] == asg_name && config['TopicARN'] == topic_arn && config['NotificationType'] == type
end
end
end
body
end
tests("#delete_notification_configuration").formats(AWS::AutoScaling::Formats::BASIC) do
pending if Fog.mocking?
Fog::AWS[:auto_scaling].delete_notification_configuration(asg_name, topic_arn).body
end
tests("#describe_notification_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_NOTIFICATION_CONFIGURATIONS) do
pending if Fog.mocking?
body = Fog::AWS[:auto_scaling].describe_notification_configurations('AutoScalingGroupNames' => asg_name).body
returns(true) do
body['DescribeNotificationConfigurationsResult']['NotificationConfigurations'].empty?
end
body
end
end
Fog::AWS[:auto_scaling].delete_auto_scaling_group(asg_name)
Fog::AWS[:auto_scaling].delete_launch_configuration(lc_name)
if topic
begin
Fog::AWS[:sns].delete_topic(topic_arn)
rescue Fog::Errors::MockNotImplemented
end
end
end
fog-aws-0.7.6/tests/requests/auto_scaling/model_tests.rb 0000644 0000041 0000041 00000017133 12576636531 023476 0 ustar www-data www-data Shindo.tests('AWS::AutoScaling | model_tests', ['aws', 'auto_scaling']) do
tests('success') do
lc = nil
lc_id = 'fog-model-lc'
tests('configurations') do
tests('getting a missing configuration') do
returns(nil) { Fog::AWS[:auto_scaling].configurations.get('fog-no-such-lc') }
end
tests('create configuration') do
lc = Fog::AWS[:auto_scaling].configurations.create(:id => lc_id, :image_id => 'ami-8c1fece5', :instance_type => 't1.micro')
#tests("dns names is set").returns(true) { lc.dns_name.is_a?(String) }
tests("created_at is set").returns(true) { Time === lc.created_at }
#tests("policies is empty").returns([]) { lc.policies }
end
tests('all configurations') do
lc_ids = Fog::AWS[:auto_scaling].configurations.all.map{|e| e.id}
tests("contains lc").returns(true) { lc_ids.include? lc_id }
end
tests('get configuration') do
lc2 = Fog::AWS[:auto_scaling].configurations.get(lc_id)
tests('ids match').returns(lc_id) { lc2.id }
end
tests('creating a duplicate configuration') do
raises(Fog::AWS::AutoScaling::IdentifierTaken) do
Fog::AWS[:auto_scaling].configurations.create(:id => lc_id, :image_id => 'ami-8c1fece5', :instance_type => 't1.micro')
end
end
end
tests('groups') do
tests('getting a missing group') do
returns(nil) { Fog::AWS[:auto_scaling].groups.get('fog-no-such-asg') }
end
asg = nil
asg_id = 'fog-model-asg'
tests('create') do
asg = Fog::AWS[:auto_scaling].groups.create(:id => asg_id, :availability_zones => ['us-east-1d'], :launch_configuration_name => lc_id)
#tests("dns names is set").returns(true) { asg.dns_name.is_a?(String) }
tests("created_at is set").returns(true) { Time === asg.created_at }
#tests("policies is empty").returns([]) { asg.policies }
end
tests('all') do
asg_ids = Fog::AWS[:auto_scaling].groups.all.map{|e| e.id}
tests("contains asg").returns(true) { asg_ids.include? asg_id }
end
tests('get') do
asg2 = Fog::AWS[:auto_scaling].groups.get(asg_id)
tests('ids match').returns(asg_id) { asg2.id }
end
tests('suspend processes') do
asg.suspend_processes()
tests('processes suspended').returns([]) { asg.suspended_processes }
end
tests('resume processes') do
asg.resume_processes()
tests('no processes suspended').returns([]) { asg.suspended_processes }
end
tests('creating a duplicate group') do
raises(Fog::AWS::AutoScaling::IdentifierTaken) do
Fog::AWS[:auto_scaling].groups.create(:id => asg_id, :availability_zones => ['us-east-1d'], :launch_configuration_name => lc_id)
end
end
tests('destroy group') do
asg.destroy
asg = nil
end
#tests('registering an invalid instance') do
# raises(Fog::AWS::AutoScaling::InvalidInstance) { asg.register_instances('i-00000000') }
#end
#tests('deregistering an invalid instance') do
# raises(Fog::AWS::AutoScaling::InvalidInstance) { asg.deregister_instances('i-00000000') }
#end
end
tests('configurations') do
tests('destroy configuration') do
lc.destroy
lc = nil
end
end
#server = Fog::AWS[:compute].servers.create
#tests('register instance') do
# begin
# elb.register_instances(server.id)
# rescue Fog::AWS::ELB::InvalidInstance
# # It may take a moment for a newly created instances to be visible to ELB requests
# raise if @retried_registered_instance
# @retried_registered_instance = true
# sleep 1
# retry
# end
#
# returns([server.id]) { elb.instances }
#end
#tests('instance_health') do
# returns('OutOfService') do
# elb.instance_health.detect{|hash| hash['InstanceId'] == server.id}['State']
# end
#
# returns([server.id]) { elb.instances_out_of_service }
#end
#tests('deregister instance') do
# elb.deregister_instances(server.id)
# returns([]) { elb.instances }
#end
#server.destroy
#tests('disable_availability_zones') do
# elb.disable_availability_zones(%w{us-east-1c us-east-1d})
# returns(%w{us-east-1a us-east-1b}) { elb.availability_zones.sort }
#end
#tests('enable_availability_zones') do
# elb.enable_availability_zones(%w{us-east-1c us-east-1d})
# returns(%w{us-east-1a us-east-1b us-east-1c us-east-1d}) { elb.availability_zones.sort }
#end
#tests('default health check') do
# default_health_check = {
# "HealthyThreshold"=>10,
# "Timeout"=>5,
# "UnhealthyThreshold"=>2,
# "Interval"=>30,
# "Target"=>"TCP:80"
# }
# returns(default_health_check) { elb.health_check }
#end
#tests('configure_health_check') do
# new_health_check = {
# "HealthyThreshold"=>5,
# "Timeout"=>10,
# "UnhealthyThreshold"=>3,
# "Interval"=>15,
# "Target"=>"HTTP:80/index.html"
# }
# elb.configure_health_check(new_health_check)
# returns(new_health_check) { elb.health_check }
#end
#tests('listeners') do
# default_listener_description = [{"Listener"=>{"InstancePort"=>80, "Protocol"=>"HTTP", "LoadBalancerPort"=>80}, "PolicyNames"=>[]}]
# tests('default') do
# returns(1) { elb.listeners.size }
#
# listener = elb.listeners.first
# returns([80,80,'HTTP', []]) { [listener.instance_port, listener.lb_port, listener.protocol, listener.policy_names] }
#
# end
#
# tests('#get') do
# returns(80) { elb.listeners.get(80).lb_port }
# end
#
# tests('create') do
# new_listener = { 'InstancePort' => 443, 'LoadBalancerPort' => 443, 'Protocol' => 'TCP'}
# elb.listeners.create(:instance_port => 443, :lb_port => 443, :protocol => 'TCP')
# returns(2) { elb.listeners.size }
# returns(443) { elb.listeners.get(443).lb_port }
# end
#
# tests('destroy') do
# elb.listeners.get(443).destroy
# returns(nil) { elb.listeners.get(443) }
# end
#end
#tests('policies') do
# app_policy_id = 'my-app-policy'
#
# tests 'are empty' do
# returns([]) { elb.policies.to_a }
# end
#
# tests('#all') do
# returns([]) { elb.policies.all.to_a }
# end
#
# tests('create app policy') do
# elb.policies.create(:id => app_policy_id, :cookie => 'my-app-cookie', :cookie_stickiness => :app)
# returns(app_policy_id) { elb.policies.first.id }
# end
#
# tests('get policy') do
# returns(app_policy_id) { elb.policies.get(app_policy_id).id }
# end
#
# tests('destroy app policy') do
# elb.policies.first.destroy
# returns([]) { elb.policies.to_a }
# end
#
# lb_policy_id = 'my-lb-policy'
# tests('create lb policy') do
# elb.policies.create(:id => lb_policy_id, :expiration => 600, :cookie_stickiness => :lb)
# returns(lb_policy_id) { elb.policies.first.id }
# end
#
# tests('setting a listener policy') do
# elb.set_listener_policy(80, lb_policy_id)
# returns([lb_policy_id]) { elb.listeners.get(80).policy_names }
# end
#
# tests('unsetting a listener policy') do
# elb.unset_listener_policy(80)
# returns([]) { elb.listeners.get(80).policy_names }
# end
#
# tests('a malformed policy') do
# raises(ArgumentError) { elb.policies.create(:id => 'foo', :cookie_stickiness => 'invalid stickiness') }
# end
#end
end
end
fog-aws-0.7.6/tests/requests/auto_scaling/tag_tests.rb 0000644 0000041 0000041 00000004441 12576636531 023147 0 ustar www-data www-data Shindo.tests('AWS::AutoScaling | tag requests', ['aws', 'auto_scaling']) do
image_id = { # Ubuntu 12.04 LTS 64-bit EBS
'ap-northeast-1' => 'ami-60c77761',
'ap-southeast-1' => 'ami-a4ca8df6',
'ap-southeast-2' => 'ami-fb8611c1',
'eu-west-1' => 'ami-e1e8d395',
'sa-east-1' => 'ami-8cd80691',
'us-east-1' => 'ami-a29943cb',
'us-west-1' => 'ami-87712ac2',
'us-west-2' => 'ami-20800c10'
}
now = Time.now.utc.to_i
lc_name = "fog-test-#{now}"
asg_name = "fog-test-#{now}"
asg_tag = {
'Key' => 'Name',
'PropagateAtLaunch' => true,
'ResourceId' => asg_name,
'ResourceType' => 'auto-scaling-group',
'Value' => asg_name
}
lc = Fog::AWS[:auto_scaling].create_launch_configuration(image_id[Fog::AWS[:auto_scaling].region], 't1.micro', lc_name)
asg = Fog::AWS[:auto_scaling].create_auto_scaling_group(asg_name, "#{Fog::AWS[:auto_scaling].region}a", lc_name, 0, 0, 'Tags' => [asg_tag])
tests('raises') do
tests("#create_or_update_tags(empty)").raises(Fog::AWS::AutoScaling::ValidationError) do
Fog::AWS[:auto_scaling].create_or_update_tags([])
end
tests("#delete_tags(empty)").raises(Fog::AWS::AutoScaling::ValidationError) do
Fog::AWS[:auto_scaling].delete_tags([])
end
end
tests('success') do
tests("#describe_auto_scaling_groups(#{asg_name}").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_GROUPS) do
body = Fog::AWS[:auto_scaling].describe_auto_scaling_groups('AutoScalingGroupNames' => asg_name).body
auto_scaling_group = body['DescribeAutoScalingGroupsResult']['AutoScalingGroups'].first
returns(true) { auto_scaling_group.key?('Tags') }
returns(true) { auto_scaling_group['Tags'].size == 1 }
returns(true) { auto_scaling_group['Tags'].first == asg_tag }
body
end
tests("#describe_tags").formats(AWS::AutoScaling::Formats::DESCRIBE_TAGS) do
pending if Fog.mocking?
body = Fog::AWS[:auto_scaling].describe_tags.body
tags = body['DescribeTagsResult']['Tags']
returns(true) { tags.any? {|tag| tag == asg_tag} }
body
end
# TODO: more tests!
end
Fog::AWS[:auto_scaling].delete_auto_scaling_group(asg_name)
Fog::AWS[:auto_scaling].delete_launch_configuration(lc_name)
end
fog-aws-0.7.6/tests/requests/redshift/ 0000755 0000041 0000041 00000000000 12576636531 017762 5 ustar www-data www-data fog-aws-0.7.6/tests/requests/redshift/cluster_parameter_group_tests.rb 0000644 0000041 0000041 00000005524 12576636531 026474 0 ustar www-data www-data Shindo.tests('Fog::Redshift[:aws] | cluster parameter group requests', ['aws']) do
pending if Fog.mocking?
suffix = rand(65536).to_s(16)
parameter_group = "test-cluster-parameter-group-#{suffix}"
@cluster_parameter_format = {
'Parameter' => {
"ParameterValue" => String,
"DataType" => String,
"Source" => String,
"IsModifiable" => Fog::Boolean,
"Description" => String,
"ParameterName" => String
}
}
@cluster_parameters_format = {
"Parameters"=> [@cluster_parameter_format]
}
@cluster_parameter_group_format = {
'ClusterParameterGroup' => {
"ParameterGroupFamily" => String,
"Description" => String,
"ParameterGroupName" => String
}
}
@cluster_parameter_groups_format = {
"ParameterGroups"=> [@cluster_parameter_group_format]
}
@modify_cluster_parameter_group_format = {
"ParameterGroupStatus" => String,
"ParameterGroupName" => String
}
tests('success') do
tests("create_cluster_parameter_group").formats(@cluster_parameter_group_format) do
body = Fog::AWS[:redshift].create_cluster_parameter_group(:parameter_group_name=> parameter_group,
:parameter_group_family=>"redshift-1.0",
:description=>'testing').body
body
end
tests("describe_cluster_parameter_groups").formats(@cluster_parameter_groups_format) do
body = Fog::AWS[:redshift].describe_cluster_parameter_groups.body
body
end
tests("describe_cluster_parameters").formats(@cluster_parameters_format) do
body = Fog::AWS[:redshift].describe_cluster_parameters(:parameter_group_name=>parameter_group).body
body
end
tests("modify_cluster_parameter_groups").formats(@modify_cluster_parameter_group_format) do
body = Fog::AWS[:redshift].modify_cluster_parameter_group(:parameter_group_name=>parameter_group,
:parameters=>{
:parameter_name=>'extra_float_digits',
:parameter_value=>2}).body
body
end
tests("delete_cluster_parameter_group") do
present = !Fog::AWS[:redshift].describe_cluster_parameter_groups(:parameter_group_name=>parameter_group).body['ParameterGroups'].empty?
tests("verify presence before deletion").returns(true) { present }
Fog::AWS[:redshift].delete_cluster_parameter_group(:parameter_group_name=>parameter_group)
not_present = Fog::AWS[:redshift].describe_cluster_parameter_groups(:parameter_group_name=>parameter_group).body['ParameterGroups'].empty?
tests("verify deletion").returns(true) { not_present }
end
end
end
fog-aws-0.7.6/tests/requests/redshift/cluster_tests.rb 0000644 0000041 0000041 00000006251 12576636531 023216 0 ustar www-data www-data Shindo.tests('Fog::Redshift[:aws] | cluster requests', ['aws']) do
pending if Fog.mocking?
identifier = "test-cluster-#{rand(65536).to_s(16)}"
@cluster_format = {
'Cluster' => {
"ClusterParameterGroups" => [{
"ClusterParameterGroup" => {
"ParameterApplyStatus" => String,
"ParameterGroupName" => String
}
}],
"ClusterSecurityGroups" => [{
'ClusterSecurityGroup' => {
"Status" => String,
"ClusterSecurityGroupName" => String
}
}],
"VpcSecurityGroups" => Fog::Nullable::Array,
"EndPoint" => Fog::Nullable::Hash,
"PendingModifiedValues" => Fog::Nullable::Hash,
"RestoreStatus" => Fog::Nullable::Hash,
"ClusterVersion" => String,
"ClusterStatus" => String,
"Encrypted" => Fog::Boolean,
"NumberOfNodes" => Integer,
"PubliclyAccessible" => Fog::Boolean,
"AutomatedSnapshotRetentionPeriod" => Integer,
"DBName" => String,
"PreferredMaintenanceWindow" => String,
"NodeType" => String,
"ClusterIdentifier" => String,
"AllowVersionUpgrade" => Fog::Boolean,
"MasterUsername" => String
}
}
@describe_clusters_format = {
"ClusterSet" => [{
'Cluster' => @cluster_format['Cluster'].merge({"ClusterCreateTime"=>Time, "AvailabilityZone"=>String, "EndPoint"=>{"Port"=>Integer, "Address"=>String}})
}]
}
tests('success') do
tests('create_cluster').formats(@cluster_format) do
body = Fog::AWS[:redshift].create_cluster(:cluster_identifier => identifier,
:master_user_password => 'Password1234',
:master_username => 'testuser',
:node_type => 'dw.hs1.xlarge',
:cluster_type => 'single-node').body
Fog.wait_for do
"available" == Fog::AWS[:redshift].describe_clusters(:cluster_identifier=>identifier).body['ClusterSet'].first['Cluster']['ClusterStatus']
end
body
end
tests('describe_clusters').formats(@describe_clusters_format["ClusterSet"]) do
sleep 30 unless Fog.mocking?
body = Fog::AWS[:redshift].describe_clusters(:cluster_identifier=>identifier).body["ClusterSet"]
body
end
tests('reboot_cluster') do
sleep 30 unless Fog.mocking?
body = Fog::AWS[:redshift].reboot_cluster(:cluster_identifier=>identifier).body
tests("verify reboot").returns("rebooting") { body['Cluster']['ClusterStatus']}
body
end
tests('delete_cluster') do
Fog.wait_for do
"available" == Fog::AWS[:redshift].describe_clusters(:cluster_identifier=>identifier).body['ClusterSet'].first['Cluster']['ClusterStatus']
end
sleep 30 unless Fog.mocking?
body = Fog::AWS[:redshift].delete_cluster(:cluster_identifier=>identifier, :skip_final_cluster_snapshot=>true).body
tests("verify delete").returns("deleting") { body['Cluster']['ClusterStatus']}
body
end
end
end
fog-aws-0.7.6/tests/requests/redshift/cluster_security_group_tests.rb 0000644 0000041 0000041 00000003200 12576636531 026350 0 ustar www-data www-data Shindo.tests('Fog::Redshift[:aws] | cluster security group requests', ['aws']) do
pending if Fog.mocking?
suffix = rand(65536).to_s(16)
identifier = "test-cluster-security-group-#{suffix}"
@cluster_security_group_format = {
"ClusterSecurityGroup" => {
"EC2SecurityGroups" => Fog::Nullable::Array,
"IPRanges" => Fog::Nullable::Array,
"Description" => String,
"ClusterSecurityGroupName" => String
}
}
@describe_cluster_security_groups_format = {
"ClusterSecurityGroups" => [@cluster_security_group_format]
}
tests('success') do
tests("create_cluster_security_group").formats(@cluster_security_group_format) do
body = Fog::AWS[:redshift].create_cluster_security_group(:cluster_security_group_name => identifier, :description => 'testing').body
body
end
tests("describe_cluster_security_groups").formats(@describe_cluster_security_groups_format) do
body = Fog::AWS[:redshift].describe_cluster_security_groups.body
body
end
tests("delete_cluster_security_group") do
present = !Fog::AWS[:redshift].describe_cluster_security_groups(:cluster_security_group_name => identifier).body['ClusterSecurityGroups'].empty?
tests("verify presence before deletion").returns(true) { present }
Fog::AWS[:redshift].delete_cluster_security_group(:cluster_security_group_name => identifier)
not_present = Fog::AWS[:redshift].describe_cluster_security_groups(:cluster_security_group_name => identifier).body['ClusterSecurityGroups'].empty?
tests("verify deletion").returns(true) { not_present }
end
end
end
fog-aws-0.7.6/tests/requests/redshift/cluster_snapshot_tests.rb 0000644 0000041 0000041 00000006474 12576636531 025144 0 ustar www-data www-data Shindo.tests('Fog::Redshift[:aws] | cluster snapshot requests', ['aws']) do
pending if Fog.mocking?
suffix = rand(65536).to_s(16)
identifier = "test-snapshot-#{suffix}"
cluster = "test-cluster-#{suffix}"
start_time = Fog::Time.now.to_iso8601_basic
@cluster_snapshot_format = {
'Snapshot' => {
"AccountsWithRestoreAccess" => Fog::Nullable::Array,
"Port" => Integer,
"SnapshotIdentifier" => String,
"OwnerAccount" => String,
"Status" => String,
"SnapshotType" => String,
"ClusterVersion" => String,
"EstimatedSecondsToCompletion" => Integer,
"SnapshotCreateTime" => Time,
"Encrypted" => Fog::Boolean,
"NumberOfNodes" => Integer,
"DBName" => String,
"CurrentBackupRateInMegaBytesPerSecond" => Float,
"ClusterCreateTime" => Time,
"AvailabilityZone" => String,
"ActualIncrementalBackupSizeInMegaBytes" => Float,
"TotalBackupSizeInMegaBytes" => Float,
"ElapsedTimeInSeconds" => Integer,
"BackupProgressInMegaBytes" => Float,
"NodeType" => String,
"ClusterIdentifier" => String,
"MasterUsername" => String
}
}
@describe_cluster_snapshots_format = {
"Snapshots" => [@cluster_snapshot_format]
}
tests('success') do
tests("create_cluster_snapshot").formats(@cluster_snapshot_format) do
Fog::AWS[:redshift].create_cluster(:cluster_identifier => cluster,
:master_user_password => 'Pass1234',
:master_username => 'testuser',
:node_type => 'dw.hs1.xlarge',
:cluster_type => 'single-node')
Fog.wait_for do
"available" == Fog::AWS[:redshift].describe_clusters(:cluster_identifier=>cluster).body['ClusterSet'].first['Cluster']['ClusterStatus']
end
body = Fog::AWS[:redshift].create_cluster_snapshot(:snapshot_identifier => identifier,
:cluster_identifier => cluster).body
body
end
tests('describe_cluster_snaphots').formats(@describe_cluster_snapshots_format) do
sleep 30 unless Fog.mocking?
body = Fog::AWS[:redshift].describe_cluster_snapshots(:start_time=>start_time).body
body
end
tests('delete_cluster_snapshot').formats(@cluster_snapshot_format) do
Fog.wait_for do
"available" == Fog::AWS[:redshift].describe_cluster_snapshots(:snapshot_identifier=>identifier).body['Snapshots'].first['Snapshot']['Status']
end
sleep 30 unless Fog.mocking?
body = Fog::AWS[:redshift].delete_cluster_snapshot(:snapshot_identifier=>identifier).body
body
end
Fog::AWS[:redshift].delete_cluster(:cluster_identifier => cluster,
:skip_final_cluster_snapshot => true)
end
end
fog-aws-0.7.6/tests/requests/beanstalk/ 0000755 0000041 0000041 00000000000 12576636531 020116 5 ustar www-data www-data fog-aws-0.7.6/tests/requests/beanstalk/application_tests.rb 0000644 0000041 0000041 00000010147 12576636531 024173 0 ustar www-data www-data Shindo.tests('AWS::ElasticBeanstalk | application_tests', ['aws', 'beanstalk']) do
def unique_name(prefix)
#get time (with 1/100th of sec accuracy)
#want unique domain name and if provider is fast, this can be called more than once per second
time = Time.now.to_i.to_s
prefix + time
end
unless Fog.mocking?
@beanstalk = Fog::AWS[:beanstalk]
end
@test_description = "A unique description."
@test_app_name = unique_name("fog-test-app-")
tests('success') do
pending if Fog.mocking?
@describe_applications_format = {
'DescribeApplicationsResult' => {
'Applications' => [
'ApplicationName' => String,
'ConfigurationTemplates' => [String],
'Description' => Fog::Nullable::String,
'DateCreated' => Time,
'DateUpdated' => Time,
'Versions' => [String]
]},
'ResponseMetadata' => {'RequestId'=> String},
}
tests("#describe_applications format").formats(@describe_applications_format) do
result = @beanstalk.describe_applications.body
end
test("#create_application") {
response = @beanstalk.create_application({
'ApplicationName' => @test_app_name,
'Description' => @test_description
})
result = false
if response.status == 200
app_info = response.body['CreateApplicationResult']['Application']
if app_info
if app_info['ApplicationName'] == @test_app_name &&
app_info['Description'] == @test_description &&
app_info['ConfigurationTemplates'].empty? &&
app_info['Versions'].empty?
result = true
end
end
end
result
}
test("#describe_applications all") {
response = @beanstalk.describe_applications
result = false
if response.status == 200
apps = response.body['DescribeApplicationsResult']['Applications']
apps.each { |app_info|
if app_info
if app_info['ApplicationName'] == @test_app_name &&
app_info['Description'] == @test_description &&
app_info['ConfigurationTemplates'].empty? &&
app_info['Versions'].empty?
result = true
end
end
}
end
result
}
test("#create_application filter") {
# Test for a specific app
response = @beanstalk.describe_applications([@test_app_name])
result = false
if response.status == 200
apps = response.body['DescribeApplicationsResult']['Applications']
if apps && apps.length == 1
app_info = apps.first
if app_info['ApplicationName'] == @test_app_name &&
app_info['Description'] == @test_description &&
app_info['ConfigurationTemplates'].empty? &&
app_info['Versions'].empty?
result = true
end
end
end
result
}
test("#update_application description") {
@test_description = "A completely new description."
response = @beanstalk.update_application({
'ApplicationName' => @test_app_name,
'Description' => @test_description
})
result = false
if response.status == 200
app_info = response.body['UpdateApplicationResult']['Application']
if app_info
if app_info['ApplicationName'] == @test_app_name &&
app_info['Description'] == @test_description &&
app_info['ConfigurationTemplates'].empty? &&
app_info['Versions'].empty?
result = true
end
end
end
result
}
test("#delete_application") {
response = @beanstalk.delete_application(@test_app_name)
result = false
if response.status == 200
result = true
end
result
}
end
end
fog-aws-0.7.6/tests/requests/beanstalk/solution_stack_tests.rb 0000644 0000041 0000041 00000001217 12576636531 024727 0 ustar www-data www-data Shindo.tests('AWS::ElasticBeanstalk | solution_stack_tests', ['aws', 'beanstalk']) do
tests('success') do
pending if Fog.mocking?
@solution_stack_result_format = {
'ListAvailableSolutionStacksResult' => {
'SolutionStackDetails' => [
'SolutionStackName' => String,
'PermittedFileTypes' => [String]
],
'SolutionStacks' => [String]
},
'ResponseMetadata' => {'RequestId'=> String},
}
tests("#list_available_solution_stacks").formats(@solution_stack_result_format) do
Fog::AWS[:beanstalk].list_available_solution_stacks.body
end
end
end
fog-aws-0.7.6/tests/requests/cloud_watch/ 0000755 0000041 0000041 00000000000 12576636531 020446 5 ustar www-data www-data fog-aws-0.7.6/tests/requests/cloud_watch/put_metric_data_tests.rb 0000644 0000041 0000041 00000002575 12576636531 025372 0 ustar www-data www-data Shindo.tests('AWS::CloudWatch | metric requests', ['aws', 'cloudwatch']) do
tests('success') do
namespace = 'Custom/Test'
@puts_format = {'ResponseMetadata' => {'RequestId' => String}}
tests('#puts_value').formats(@puts_format) do
pending if Fog.mocking?
Fog::AWS[:cloud_watch].put_metric_data(namespace, [{'MetricName' => 'RequestTest', 'Unit' => 'None', 'Value' => 1}]).body
end
tests('#puts_statistics_set').succeeds do
pending if Fog.mocking?
Fog::AWS[:cloud_watch].put_metric_data(namespace, [{'MetricName' => 'RequestTest', 'Unit' => 'None', 'StatisticValues' => {'Minimum' => 0, 'Maximum' => 9, 'Sum' => 45, 'SampleCount' => 10, 'Average' => 4.5}}]).body
end
tests('#puts with dimensions').succeeds do
pending if Fog.mocking?
dimensions = [{}]
Fog::AWS[:cloud_watch].put_metric_data(namespace, [{'MetricName' => 'RequestTest', 'Unit' => 'None', 'Value' => 1, 'Dimensions' => dimensions}]).body
end
tests('#puts more than one').succeeds do
pending if Fog.mocking?
datapoints = (0...3).map do |i|
dp = {'MetricName' => "#{i}RequestTest", 'Unit' => 'None', 'Value' => i}
if i%2==0
dp['Dimensions'] = [{'Name' => 'Ruler', 'Value' => "measurement_#{i}"}]
end
dp
end
Fog::AWS[:cloud_watch].put_metric_data(namespace, datapoints).body
end
end
end
fog-aws-0.7.6/tests/requests/cloud_watch/list_metrics_test.rb 0000644 0000041 0000041 00000003740 12576636531 024537 0 ustar www-data www-data Shindo.tests('AWS::CloudWatch | metric requests', ['aws', 'cloudwatch']) do
tests('success') do
@metrics_list_format = {
'ListMetricsResult' => {
'Metrics' =>
[{
'Dimensions' =>
[{
'Name' => String,
'Value' => String
}],
"MetricName" => String,
"Namespace" => String
}],
'NextToken' => Fog::Nullable::String,
},
'ResponseMetadata' => {"RequestId"=> String},
}
@instanceId = 'i-2f3eab59'
@dimension_filtered_metrics_list_format = {
'ListMetricsResult' => {
'Metrics' =>
[{
'Dimensions' =>
[{
'Name' => 'InstanceId',
'Value' => @instanceId
}],
"MetricName" => String,
"Namespace" => String
}],
'NextToken' => Fog::Nullable::String,
},
'ResponseMetadata' => {"RequestId"=> String},
}
tests("#list_metrics").formats(@metrics_list_format) do
pending if Fog.mocking?
Fog::AWS[:cloud_watch].list_metrics.body
end
tests("#dimension_filtered_list_metrics").formats(@dimension_filtered_metrics_list_format) do
pending if Fog.mocking?
Fog::AWS[:cloud_watch].list_metrics('Dimensions' => [{'Name' => 'InstanceId', 'Value' => @instanceId}]).body
end
tests("#metric_name_filtered_list_metrics").returns(true) do
pending if Fog.mocking?
metricName = "CPUUtilization"
Fog::AWS[:cloud_watch].list_metrics('MetricName' => metricName).body['ListMetricsResult']['Metrics'].all? do |metric|
metric['MetricName'] == metricName
end
end
tests("#namespace_filtered_list_metrics").returns(true) do
pending if Fog.mocking?
namespace = "AWS/EC2"
Fog::AWS[:cloud_watch].list_metrics('Namespace' => namespace).body['ListMetricsResult']['Metrics'].all? do |metric|
metric['Namespace'] == namespace
end
end
end
end
fog-aws-0.7.6/tests/requests/cloud_watch/get_metric_statistics_tests.rb 0000644 0000041 0000041 00000001777 12576636531 026625 0 ustar www-data www-data Shindo.tests('AWS::CloudWatch | metric requests', ['aws', 'cloudwatch']) do
tests('success') do
@metrics_statistic_format = {
'GetMetricStatisticsResult' => {
'Label' => String,
'Datapoints' => [{
"Timestamp" => Time,
'Unit' => String,
'Minimum' => Float,
'Maximum' => Float,
'Average' => Float,
'Sum' => Float,
'SampleCount' => Float
}],
},
'ResponseMetadata' => {
'RequestId' => String
}
}
tests("#get_metric_statistics").formats(@metrics_statistic_format) do
pending if Fog.mocking?
instanceId = 'i-420c352f'
Fog::AWS[:cloud_watch].get_metric_statistics({'Statistics' => ['Minimum','Maximum','Sum','SampleCount','Average'], 'StartTime' => (Time.now-600).iso8601, 'EndTime' => Time.now.iso8601, 'Period' => 60, 'MetricName' => 'DiskReadBytes', 'Namespace' => 'AWS/EC2', 'Dimensions' => [{'Name' => 'InstanceId', 'Value' => instanceId}]}).body
end
end
end
fog-aws-0.7.6/tests/requests/ecs/ 0000755 0000041 0000041 00000000000 12576636531 016724 5 ustar www-data www-data fog-aws-0.7.6/tests/requests/ecs/task_tests.rb 0000644 0000041 0000041 00000013170 12576636531 021437 0 ustar www-data www-data require 'fog/json'
Shindo.tests('AWS::ECS | task requests', ['aws', 'ecs']) do
Fog::AWS[:ecs].reset_data
tests('success') do
tests("#list_tasks").formats(AWS::ECS::Formats::LIST_TASKS) do
result = Fog::AWS[:ecs].list_tasks.body
list_instances_arns = result['ListTasksResult']['taskArns']
returns(true) { list_instances_arns.empty? }
result
end
tests("#run_task").formats(AWS::ECS::Formats::RUN_TASK) do
task_def_params = Fog::JSON.decode(IO.read(AWS::ECS::Samples::TASK_DEFINITION_1))
result1 = Fog::AWS[:ecs].register_task_definition(task_def_params).body
task_def = result1['RegisterTaskDefinitionResult']['taskDefinition']
task_def_arn = task_def['taskDefinitionArn']
result2 = Fog::AWS[:ecs].run_task('taskDefinition' => task_def_arn).body
task = result2['RunTaskResult']['tasks'].first
returns(true) { task.has_key?('containerInstanceArn') }
returns(true) { task['containers'].size.eql?(2) }
returns(true) { task['desiredStatus'].eql?('RUNNING') }
returns(true) { task['taskDefinitionArn'].eql?(task_def_arn) }
result2
end
tests("#describe_tasks").formats(AWS::ECS::Formats::DESCRIBE_TASKS) do
result1 = Fog::AWS[:ecs].list_tasks.body
task_arn = result1['ListTasksResult']['taskArns'].first
result2 = Fog::AWS[:ecs].describe_tasks('tasks' => task_arn).body
task = result2['DescribeTasksResult']['tasks'].first
returns(true) { task['taskArn'].eql?(task_arn) }
returns(true) { task['containers'].size.eql?(2) }
returns(true) { task['desiredStatus'].eql?('RUNNING') }
result2
end
tests("#list_tasks").formats(AWS::ECS::Formats::LIST_TASKS) do
result = Fog::AWS[:ecs].list_tasks.body
list_instances_arns = result['ListTasksResult']['taskArns']
returns(false) { list_instances_arns.empty? }
result
end
tests("#stop_task").formats(AWS::ECS::Formats::STOP_TASK) do
result1 = Fog::AWS[:ecs].list_tasks.body
task_arn = result1['ListTasksResult']['taskArns'].first
result2 = Fog::AWS[:ecs].stop_task('task' => task_arn).body
task = result2['StopTaskResult']['task']
returns(true) { task['taskArn'].eql?(task_arn) }
returns(true) { task['containers'].size.eql?(2) }
returns(true) { task['desiredStatus'].eql?('STOPPED') }
result2
end
tests("#start_task").formats(AWS::ECS::Formats::START_TASK) do
owner_id = Fog::AWS::Mock.owner_id
container_instance_path = "container-instance/#{Fog::UUID.uuid}"
region = "us-east-1"
container_instance_arn = Fog::AWS::Mock.arn('ecs', owner_id, container_instance_path, region)
task_def_params = Fog::JSON.decode(IO.read(AWS::ECS::Samples::TASK_DEFINITION_1))
result1 = Fog::AWS[:ecs].register_task_definition(task_def_params).body
task_def = result1['RegisterTaskDefinitionResult']['taskDefinition']
task_def_arn = task_def['taskDefinitionArn']
result2 = Fog::AWS[:ecs].start_task(
'taskDefinition' => task_def_arn,
'containerInstances' => container_instance_arn
).body
task = result2['StartTaskResult']['tasks'].first
returns(true) { task['containerInstanceArn'].eql?(container_instance_arn) }
returns(true) { task['containers'].size.eql?(2) }
returns(true) { task['desiredStatus'].eql?('RUNNING') }
returns(true) { task['taskDefinitionArn'].eql?(task_def_arn) }
result2
end
tests("#list_tasks").formats(AWS::ECS::Formats::LIST_TASKS) do
result = Fog::AWS[:ecs].list_tasks.body
list_instances_arns = result['ListTasksResult']['taskArns']
returns(false) { list_instances_arns.empty? }
result
end
end
tests('failures') do
tests("#describe_tasks nonexistent") do
task_arn = "arn:aws:ecs:us-west-2:938269302734:task/6893440f-2165-47aa-8cfa-b2f413a26f00"
result = Fog::AWS[:ecs].describe_tasks('tasks' => task_arn).body
end
tests('describe_tasks without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].describe_tasks.body
end
tests('#run_task without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].run_task.body
end
tests('#run_task nonexistent').raises(Fog::AWS::ECS::Error) do
task_def_arn = "arn:aws:ecs:us-west-2:539573770077:task-definition/foo-xanadu-app-static:33"
response = Fog::AWS[:ecs].run_task('taskDefinition' => task_def_arn).body
end
tests('#start_task without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].start_task.body
end
tests('#start_task with missing params').raises(Fog::AWS::ECS::Error) do
task_def_arn = "arn:aws:ecs:us-west-2:539573770077:task-definition/foo-xanadu-app-static:33"
response = Fog::AWS[:ecs].start_task('taskDefinition' => task_def_arn).body
end
tests('#start_task nonexistent').raises(Fog::AWS::ECS::Error) do
task_def_arn = "arn:aws:ecs:us-west-2:539573770077:task-definition/foo-xanadu-app-static:33"
container_instance_arn = "arn:aws:ecs:us-west-2:938269302734:container-instance/6893440f-2165-47aa-8cfa-b2f413a26f00"
response = Fog::AWS[:ecs].start_task(
'taskDefinition' => task_def_arn,
'containerInstances' => container_instance_arn
).body
end
tests('#stop_task without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].stop_task.body
end
tests('#stop_task nonexistent params').raises(Fog::AWS::ECS::Error) do
task_arn = "arn:aws:ecs:us-west-2:938269302734:task/6893440f-2165-47aa-8cfa-b2f413a26f00"
response = Fog::AWS[:ecs].stop_task('task' => task_arn).body
end
end
end
fog-aws-0.7.6/tests/requests/ecs/helper.rb 0000644 0000041 0000041 00000023145 12576636531 020535 0 ustar www-data www-data class AWS
module ECS
module Formats
BASIC = {
'ResponseMetadata' => { 'RequestId' => String }
}
CREATE_CLUSTER = BASIC.merge({
'CreateClusterResult' => {
'cluster' => {
'clusterName' => String,
'clusterArn' => String,
'status' => String,
'registeredContainerInstancesCount' => Integer,
'runningTasksCount' => Integer,
'pendingTasksCount' => Integer
}
}
})
LIST_CLUSTERS = BASIC.merge({
'ListClustersResult' => {
'clusterArns' => [String],
'nextToken' => Fog::Nullable::String
}
})
DELETE_CLUSTER = BASIC.merge({
'DeleteClusterResult' => {
'cluster' => {
'clusterName' => String,
'clusterArn' => String,
'status' => String,
'registeredContainerInstancesCount' => Integer,
'runningTasksCount' => Integer,
'pendingTasksCount' => Integer
}
}
})
DESCRIBE_CLUSTERS = BASIC.merge({
'DescribeClustersResult' => {
'failures' => [Fog::Nullable::Hash],
'clusters' => [Fog::Nullable::Hash]
}
})
REGISTER_TASK_DEFINITION = BASIC.merge({
'RegisterTaskDefinitionResult' => {
'taskDefinition' => {
'revision' => Integer,
'taskDefinitionArn' => String,
'family' => String,
'containerDefinitions' => [Hash],
'volumes' => Fog::Nullable::Array
}
}
})
LIST_TASK_DEFINITIONS = BASIC.merge({
'ListTaskDefinitionsResult' => {
'taskDefinitionArns' => [String]
}
})
DESCRIBE_TASK_DEFINITION = BASIC.merge({
'DescribeTaskDefinitionResult' => {
'taskDefinition' => {
'revision' => Integer,
'taskDefinitionArn' => String,
'family' => String,
'containerDefinitions' => [Hash],
'volumes' => Fog::Nullable::Array
}
}
})
DEREGISTER_TASK_DEFINITION = BASIC.merge({
'DeregisterTaskDefinitionResult' => {
'taskDefinition' => {
'revision' => Integer,
'taskDefinitionArn' => String,
'family' => String,
'containerDefinitions' => [Hash],
'volumes' => Fog::Nullable::Array
}
}
})
LIST_TASK_DEFINITION_FAMILIES = BASIC.merge({
'ListTaskDefinitionFamiliesResult' => {
'families' => [String]
}
})
CREATE_SERVICE = BASIC.merge({
'CreateServiceResult' => {
'service' => {
'events' => [Fog::Nullable::Hash],
'serviceName' => String,
'serviceArn' => String,
'taskDefinition' => String,
'clusterArn' => String,
'status' => String,
'roleArn' => Fog::Nullable::String,
'loadBalancers' => [Fog::Nullable::Hash],
'deployments' => [Fog::Nullable::Hash],
'desiredCount' => Integer,
'pendingCount' => Integer,
'runningCount' => Integer
}
}
})
DELETE_SERVICE = BASIC.merge({
'DeleteServiceResult' => {
'service' => {
'events' => [Fog::Nullable::Hash],
'serviceName' => String,
'serviceArn' => String,
'taskDefinition' => String,
'clusterArn' => String,
'status' => String,
'roleArn' => Fog::Nullable::String,
'loadBalancers' => [Fog::Nullable::Hash],
'deployments' => [Fog::Nullable::Hash],
'desiredCount' => Integer,
'pendingCount' => Integer,
'runningCount' => Integer
}
}
})
DESCRIBE_SERVICES = BASIC.merge({
'DescribeServicesResult' => {
'failures' => [Fog::Nullable::Hash],
'services' => [{
'events' => [Fog::Nullable::Hash],
'serviceName' => String,
'serviceArn' => String,
'taskDefinition' => String,
'clusterArn' => String,
'status' => String,
'roleArn' => Fog::Nullable::String,
'loadBalancers' => [Fog::Nullable::Hash],
'deployments' => [Fog::Nullable::Hash],
'desiredCount' => Integer,
'pendingCount' => Integer,
'runningCount' => Integer
}]
}
})
LIST_SERVICES = BASIC.merge({
'ListServicesResult' => {
'serviceArns' => [Fog::Nullable::String],
'nextToken' => Fog::Nullable::String
}
})
UPDATE_SERVICE = BASIC.merge({
'UpdateServiceResult' => {
'service' => {
'events' => [Fog::Nullable::Hash],
'serviceName' => String,
'serviceArn' => String,
'taskDefinition' => String,
'clusterArn' => String,
'status' => String,
'roleArn' => Fog::Nullable::String,
'loadBalancers' => [Fog::Nullable::Hash],
'deployments' => [Fog::Nullable::Hash],
'desiredCount' => Integer,
'pendingCount' => Integer,
'runningCount' => Integer
}
}
})
LIST_CONTAINER_INSTANCES = BASIC.merge({
'ListContainerInstancesResult' => {
'containerInstanceArns' => [Fog::Nullable::String]
}
})
DESCRIBE_CONTAINER_INSTANCES = BASIC.merge({
'DescribeContainerInstancesResult' => {
'containerInstances' => [{
'remainingResources' => [Hash],
'agentConnected' => Fog::Boolean,
'runningTasksCount' => Integer,
'status' => String,
'registeredResources' => [Hash],
'containerInstanceArn' => String,
'pendingTasksCount' => Integer,
'ec2InstanceId' => String
}],
'failures' => [Fog::Nullable::Hash],
}
})
DEREGISTER_CONTAINER_INSTANCE = BASIC.merge({
'DeregisterContainerInstanceResult' => {
'containerInstance' => {
'remainingResources' => [Hash],
'agentConnected' => Fog::Boolean,
'runningTasksCount' => Integer,
'status' => String,
'registeredResources' => [Hash],
'containerInstanceArn' => String,
'pendingTasksCount' => Integer,
'ec2InstanceId' => String
}
}
})
LIST_TASKS = BASIC.merge({
'ListTasksResult' => {
'taskArns' => [Fog::Nullable::String]
}
})
DESCRIBE_TASKS = BASIC.merge({
'DescribeTasksResult' => {
'failures' => [Fog::Nullable::Hash],
'tasks' => [
{
'clusterArn' => String,
'containers' => Array,
'overrides' => Fog::Nullable::Hash,
'startedBy' => Fog::Nullable::String,
'desiredStatus' => String,
'taskArn' => String,
'containerInstanceArn' => String,
'lastStatus' => String,
'taskDefinitionArn' => String
}
]
}
})
RUN_TASK = BASIC.merge({
'RunTaskResult' => {
'failures' => [Fog::Nullable::Hash],
'tasks' => [
{
'clusterArn' => String,
'containers' => [Hash],
'overrides' => Fog::Nullable::Hash,
'desiredStatus' => String,
'taskArn' => String,
'containerInstanceArn' => String,
'lastStatus' => String,
'taskDefinitionArn' => String
}
]
}
})
STOP_TASK = BASIC.merge({
'StopTaskResult' => {
'task' => {
'clusterArn' => String,
'containers' => [Hash],
'overrides' => Fog::Nullable::Hash,
'desiredStatus' => String,
'taskArn' => String,
'startedBy' => Fog::Nullable::String,
'containerInstanceArn' => String,
'lastStatus' => String,
'taskDefinitionArn' => String
}
}
})
START_TASK = BASIC.merge({
'StartTaskResult' => {
'failures' => [Fog::Nullable::Hash],
'tasks' => [
{
'clusterArn' => String,
'containers' => [Hash],
'overrides' => Fog::Nullable::Hash,
'desiredStatus' => String,
'taskArn' => String,
'containerInstanceArn' => String,
'lastStatus' => String,
'taskDefinitionArn' => String
}
]
}
})
end
module Samples
TASK_DEFINITION_1 = File.dirname(__FILE__) + '/sample_task_definition1.json'
end
end
end
fog-aws-0.7.6/tests/requests/ecs/service_tests.rb 0000644 0000041 0000041 00000011553 12576636531 022140 0 ustar www-data www-data Shindo.tests('AWS::ECS | service requests', ['aws', 'ecs']) do
Fog::AWS[:ecs].reset_data
cluster = 'arn:aws:ecs:us-east-1:994922842243:cluster/default'
desired_count = 1
role = 'arn:aws:iam::806753142346:role/ecsServiceRole'
service_name = 'sample-webapp'
task_definition = 'console-sample-app-static:18'
load_balancers = [{
'containerName' => 'simple-app',
'containerPort' => 80,
'loadBalancerName' => 'ecsunittests-EcsElastic-OI09IAP3PVIP'
}]
tests('success') do
tests("#list_services").formats(AWS::ECS::Formats::LIST_SERVICES) do
result = Fog::AWS[:ecs].list_services('cluster' => cluster).body
list_services_arns = result['ListServicesResult']['serviceArns']
returns(true) { list_services_arns.empty? }
result
end
tests("#create_service").formats(AWS::ECS::Formats::CREATE_SERVICE) do
params = {
'cluster' => cluster,
'desiredCount' => desired_count,
'loadBalancers' => load_balancers,
'role' => role,
'serviceName' => service_name,
'taskDefinition' => task_definition
}
result = Fog::AWS[:ecs].create_service(params).body
service = result['CreateServiceResult']['service']
returns('sample-webapp') { service['serviceName'] }
returns(false) { service['serviceArn'].match(/^arn:aws:ecs:.+:.+:service\/.+$/).nil? }
result
end
tests("#list_services again").formats(AWS::ECS::Formats::LIST_SERVICES) do
result = Fog::AWS[:ecs].list_services('cluster' => cluster).body
list_services_arns = result['ListServicesResult']['serviceArns']
returns(false) { list_services_arns.empty? }
returns(true) { !list_services_arns.first.match(/#{service_name}/).nil? }
result
end
tests("#describe_services").formats(AWS::ECS::Formats::DESCRIBE_SERVICES) do
result1 = Fog::AWS[:ecs].list_services('cluster' => cluster).body
service_arn = result1['ListServicesResult']['serviceArns'].first
result2 = Fog::AWS[:ecs].describe_services(
'services' => service_arn,
'cluster' => cluster
).body
returns(true) { result2['DescribeServicesResult']['services'].size.eql?(1) }
service = result2['DescribeServicesResult']['services'].first
returns(true) { service['serviceName'].eql?(service_name) }
returns(true) { service['status'].eql?('ACTIVE') }
returns(false) { service['deployments'].empty? }
returns(true) { service['desiredCount'].eql?(desired_count) }
result2
end
tests("#update_service").formats(AWS::ECS::Formats::UPDATE_SERVICE) do
new_task_def = 'arn:aws:ecs:us-east-1:994922842243:task-definitions/foobar-app:32'
result1 = Fog::AWS[:ecs].list_services('cluster' => cluster).body
service_arn = result1['ListServicesResult']['serviceArns'].first
result2 = Fog::AWS[:ecs].update_service(
'service' => service_arn,
'cluster' => cluster,
'taskDefinition' => new_task_def
).body
service = result2['UpdateServiceResult']['service']
returns(true) { service['serviceName'].eql?(service_name) }
returns(true) { service['taskDefinition'].eql?(new_task_def) }
result2
end
tests("#delete_service").formats(AWS::ECS::Formats::DELETE_SERVICE) do
result1 = Fog::AWS[:ecs].list_services('cluster' => cluster).body
service_arn = result1['ListServicesResult']['serviceArns'].first
result2 = Fog::AWS[:ecs].delete_service(
'service' => service_arn,
'cluster' => cluster
).body
service = result2['DeleteServiceResult']['service']
returns(true) { service['serviceName'].eql?(service_name) }
result2
end
tests("#list_services yet again").formats(AWS::ECS::Formats::LIST_SERVICES) do
result = Fog::AWS[:ecs].list_services('cluster' => cluster).body
list_services_arns = result['ListServicesResult']['serviceArns']
returns(true) { list_services_arns.empty? }
result
end
end
tests('failures') do
tests('#describe_services without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].describe_services.body
end
tests('#create_service without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].create_service.body
end
tests('#update_service without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].update_service.body
end
tests('#update_service nonexistent').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].update_service('service' => 'whatever2329').body
end
tests('#delete_service without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].delete_service.body
end
tests('#delete_service nonexistent').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].delete_service('service' => 'foobar787383').body
end
end
end
fog-aws-0.7.6/tests/requests/ecs/task_definitions_tests.rb 0000644 0000041 0000041 00000010232 12576636531 024026 0 ustar www-data www-data require 'fog/json'
Shindo.tests('AWS::ECS | task definitions requests', ['aws', 'ecs']) do
Fog::AWS[:ecs].reset_data
tests('success') do
tests("#list_task_definitions").formats(AWS::ECS::Formats::LIST_TASK_DEFINITIONS) do
result = Fog::AWS[:ecs].list_task_definitions.body
list_task_def_arns = result['ListTaskDefinitionsResult']['taskDefinitionArns']
returns(true) { list_task_def_arns.empty? }
result
end
tests("#register_task_definition").formats(AWS::ECS::Formats::REGISTER_TASK_DEFINITION) do
task_def_params = Fog::JSON.decode(IO.read(AWS::ECS::Samples::TASK_DEFINITION_1))
result = Fog::AWS[:ecs].register_task_definition(task_def_params).body
task_def = result['RegisterTaskDefinitionResult']['taskDefinition']
returns('console-sample-app-static') { task_def['family'] }
returns(true) { task_def['revision'] > 0 }
returns(false) { task_def['taskDefinitionArn'].match(/^arn:aws:ecs:.+:.+:task-definition\/.+:\d+$/).nil? }
result
end
tests("#list_task_definition_families").formats(AWS::ECS::Formats::LIST_TASK_DEFINITION_FAMILIES) do
result = Fog::AWS[:ecs].list_task_definition_families.body
families = result['ListTaskDefinitionFamiliesResult']['families']
returns(false) { families.empty? }
returns(true) { families.include?('console-sample-app-static') }
result
end
tests("#list_task_definitions again").formats(AWS::ECS::Formats::LIST_TASK_DEFINITIONS) do
result = Fog::AWS[:ecs].list_task_definitions.body
list_task_def_arns = result['ListTaskDefinitionsResult']['taskDefinitionArns']
returns(true) { list_task_def_arns.size.eql?(1) }
result
end
tests("#describe_task_definition").formats(AWS::ECS::Formats::DESCRIBE_TASK_DEFINITION) do
result1 = Fog::AWS[:ecs].list_task_definitions.body
task_def_arn = result1['ListTaskDefinitionsResult']['taskDefinitionArns'].first
result2 = Fog::AWS[:ecs].describe_task_definition('taskDefinition' => task_def_arn).body
task_def = result2['DescribeTaskDefinitionResult']['taskDefinition']
returns(true) { task_def['taskDefinitionArn'].eql?(task_def_arn) }
returns(true) { task_def['containerDefinitions'].size > 0 }
result2
end
tests("#deregister_task_definition").formats(AWS::ECS::Formats::DEREGISTER_TASK_DEFINITION) do
result1 = Fog::AWS[:ecs].list_task_definitions.body
task_def_arn = result1['ListTaskDefinitionsResult']['taskDefinitionArns'].first
result2 = Fog::AWS[:ecs].deregister_task_definition('taskDefinition' => task_def_arn).body
task_def = result2['DeregisterTaskDefinitionResult']['taskDefinition']
returns(true) { task_def['taskDefinitionArn'].eql?(task_def_arn) }
result2
end
tests("#list_task_definitions yet again").formats(AWS::ECS::Formats::LIST_TASK_DEFINITIONS) do
result = Fog::AWS[:ecs].list_task_definitions.body
list_task_def_arns = result['ListTaskDefinitionsResult']['taskDefinitionArns']
returns(true) { list_task_def_arns.empty? }
result
end
tests("#list_task_definition_families again").formats(AWS::ECS::Formats::LIST_TASK_DEFINITION_FAMILIES) do
result = Fog::AWS[:ecs].list_task_definition_families.body
families = result['ListTaskDefinitionFamiliesResult']['families']
returns(true) { families.empty? }
returns(false) { families.include?('console-sample-app-static') }
result
end
end
tests('failures') do
tests('#describe_task_definition without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].describe_task_definition.body
end
tests('#describe_task_definition nonexistent').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].describe_task_definition('taskDefinition' => 'foobar').body
end
tests('#deregister_task_definition without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].deregister_task_definition.body
end
tests('#deregister_task_definition nonexistent').raises(Fog::AWS::ECS::NotFound) do
response = Fog::AWS[:ecs].deregister_task_definition('taskDefinition' => 'foobar:7873287283').body
end
end
end
fog-aws-0.7.6/tests/requests/ecs/cluster_tests.rb 0000644 0000041 0000041 00000010505 12576636531 022155 0 ustar www-data www-data Shindo.tests('AWS::ECS | cluster requests', ['aws', 'ecs']) do
Fog::AWS[:ecs].reset_data
tests('success') do
tests("#create_cluster").formats(AWS::ECS::Formats::CREATE_CLUSTER) do
result = Fog::AWS[:ecs].create_cluster('clusterName' => 'cluster1').body
cluster = result['CreateClusterResult']['cluster']
returns('cluster1') { cluster['clusterName'] }
returns('ACTIVE') { cluster['status'] }
result
end
tests("#create_cluster another").formats(AWS::ECS::Formats::CREATE_CLUSTER) do
result = Fog::AWS[:ecs].create_cluster('clusterName' => 'foobar').body
cluster = result['CreateClusterResult']['cluster']
returns('foobar') { cluster['clusterName'] }
returns('ACTIVE') { cluster['status'] }
result
end
tests("#create_cluster without params").formats(AWS::ECS::Formats::CREATE_CLUSTER) do
result = Fog::AWS[:ecs].create_cluster.body
cluster = result['CreateClusterResult']['cluster']
returns('default') { cluster['clusterName'] }
result
end
tests("#list_clusters").formats(AWS::ECS::Formats::LIST_CLUSTERS) do
result = Fog::AWS[:ecs].list_clusters.body
clusters = result['ListClustersResult']['clusterArns']
returns(true) { clusters.size.eql?(3) }
result
end
tests("#describe_clusters with name").formats(AWS::ECS::Formats::DESCRIBE_CLUSTERS) do
result = Fog::AWS[:ecs].describe_clusters('clusters' => 'cluster1').body
clusters = result['DescribeClustersResult']['clusters']
failures = result['DescribeClustersResult']['failures']
returns(true) { clusters.size.eql?(1) }
returns('cluster1') { clusters.first['clusterName'] }
returns(true) { failures.empty? }
result
end
tests("#describe_clusters without params").formats(AWS::ECS::Formats::DESCRIBE_CLUSTERS) do
result = Fog::AWS[:ecs].describe_clusters.body
clusters = result['DescribeClustersResult']['clusters']
failures = result['DescribeClustersResult']['failures']
returns(true) { clusters.size.eql?(1) }
returns('default') { clusters.first['clusterName'] }
result
end
tests("#describe_clusters several with name").formats(AWS::ECS::Formats::DESCRIBE_CLUSTERS) do
result = Fog::AWS[:ecs].describe_clusters('clusters' => %w(cluster1 foobar)).body
clusters = result['DescribeClustersResult']['clusters']
cluster_names = clusters.map { |c| c['clusterName'] }.sort
returns(true) { clusters.size.eql?(2) }
returns('cluster1') { cluster_names.first }
returns('foobar') { cluster_names[1] }
result
end
tests("#describe_clusters with errors").formats(AWS::ECS::Formats::DESCRIBE_CLUSTERS) do
result = Fog::AWS[:ecs].describe_clusters('clusters' => %w(foobar not_here wtf)).body
clusters = result['DescribeClustersResult']['clusters']
failures = result['DescribeClustersResult']['failures']
returns(true) { failures.size.eql?(2) }
returns('MISSING') { failures.first['reason'] }
returns(true) { clusters.size.eql?(1) }
result
end
tests("#delete_cluster").formats(AWS::ECS::Formats::DELETE_CLUSTER) do
cluster_name = 'foobar'
result = Fog::AWS[:ecs].delete_cluster('cluster' => cluster_name).body
cluster = result['DeleteClusterResult']['cluster']
returns(true) { cluster['clusterName'].eql?(cluster_name) }
returns('INACTIVE') { cluster['status'] }
result
end
tests("#list_clusters after one delete").formats(AWS::ECS::Formats::LIST_CLUSTERS) do
result = Fog::AWS[:ecs].list_clusters.body
clusters = result['ListClustersResult']['clusterArns']
returns(true) { clusters.size.eql?(2) }
result
end
tests("#delete_cluster by arn").formats(AWS::ECS::Formats::DELETE_CLUSTER) do
result1 = Fog::AWS[:ecs].describe_clusters.body
cluster1 = result1['DescribeClustersResult']['clusters'].first
result2 = Fog::AWS[:ecs].delete_cluster('cluster' => cluster1['clusterArn']).body
cluster2 = result2['DeleteClusterResult']['cluster']
returns('default') { cluster2['clusterName'] }
returns('INACTIVE') { cluster2['status'] }
result2
end
end
tests('failures') do
tests('#delete_cluster without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].delete_cluster.body
end
end
end
fog-aws-0.7.6/tests/requests/ecs/container_instance_tests.rb 0000644 0000041 0000041 00000010625 12576636531 024345 0 ustar www-data www-data Shindo.tests('AWS::ECS | container instance requests', ['aws', 'ecs']) do
Fog::AWS[:ecs].reset_data
container_instance_arn = 'arn:aws:ecs:us-west-2:738152598183:container-instance/eff1068d-5fcb-4804-89f0-7d18ffc6879c'
ec2_instance_id = 'i-58f4b4ae'
Fog::AWS[:ecs].data[:container_instances] << {
'remainingResources' => [
{
'longValue' => 0,
'name' => 'CPU',
'integerValue' => 1004,
'doubleValue' => 0.0,
'type' => 'INTEGER'
},
{
'longValue' => 0,
'name' => 'MEMORY',
'integerValue' => 496,
'doubleValue' => 0.0,
'type' => 'INTEGER'
},
{
'stringSetValue' => [2376, 22, 80, 51678, 2375],
'longValue' => 0,
'name' => 'PORTS',
'integerValue' => 0,
'doubleValue' => 0.0,
'type' => 'STRINGSET'
}
],
'agentConnected' => true,
'runningTasksCount' => 1,
'status' => 'ACTIVE',
'registeredResources' => [
{
'longValue' => 0,
'name' => 'CPU',
'integerValue' => 1024,
'doubleValue' => 0.0,
'type' => 'INTEGER'
},
{
'longValue' => 0,
'name' => 'MEMORY',
'integerValue' => 996,
'doubleValue' => 0.0,
'type' => 'INTEGER'
},
{
'stringSetValue' => [2376, 22, 80, 51678, 2375],
'longValue' => 0,
'name' => 'PORTS',
'integerValue' => 0,
'doubleValue' => 0.0,
'type' => 'STRINGSET'
}
],
'containerInstanceArn' => container_instance_arn,
'pendingTasksCount' => 0,
'ec2InstanceId' => ec2_instance_id
}
tests('success') do
tests("#list_container_instances").formats(AWS::ECS::Formats::LIST_CONTAINER_INSTANCES) do
result = Fog::AWS[:ecs].list_container_instances.body
list_instances_arns = result['ListContainerInstancesResult']['containerInstanceArns']
returns(false) { list_instances_arns.empty? }
returns(true) { list_instances_arns.first.eql?(container_instance_arn) }
result
end
tests("#describe_container_instances").formats(AWS::ECS::Formats::DESCRIBE_CONTAINER_INSTANCES) do
result = Fog::AWS[:ecs].describe_container_instances('containerInstances' => container_instance_arn).body
instance = result['DescribeContainerInstancesResult']['containerInstances'].first
returns(true) { instance['containerInstanceArn'].eql?(container_instance_arn) }
returns(true) { instance['ec2InstanceId'].eql?(ec2_instance_id) }
returns(true) { instance['status'].eql?('ACTIVE') }
result
end
tests("#deregister_container_instance").formats(AWS::ECS::Formats::DEREGISTER_CONTAINER_INSTANCE) do
result = Fog::AWS[:ecs].deregister_container_instance('containerInstance' => container_instance_arn).body
instance = result['DeregisterContainerInstanceResult']['containerInstance']
returns(true) { instance['containerInstanceArn'].eql?(container_instance_arn) }
returns(true) { instance['ec2InstanceId'].eql?(ec2_instance_id) }
returns(true) { instance['pendingTasksCount'].eql?(0) }
result
end
tests("#list_container_instances again").formats(AWS::ECS::Formats::LIST_CONTAINER_INSTANCES) do
result = Fog::AWS[:ecs].list_container_instances.body
list_instances_arns = result['ListContainerInstancesResult']['containerInstanceArns']
returns(true) { list_instances_arns.empty? }
result
end
end
tests('failures') do
tests('#describe_container_instances without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].describe_container_instances.body
end
tests('#deregister_container_instance without params').raises(Fog::AWS::ECS::Error) do
response = Fog::AWS[:ecs].deregister_container_instance.body
end
tests('#deregister_container_instance nonexistent').raises(Fog::AWS::ECS::Error) do
instance_uuid = 'ffffffff-ffff-0000-ffff-deadbeefff'
response = Fog::AWS[:ecs].deregister_container_instance('containerInstance' => instance_uuid).body
end
end
end
fog-aws-0.7.6/tests/requests/ecs/sample_task_definition1.json 0000644 0000041 0000041 00000002717 12576636531 024422 0 ustar www-data www-data {
"family": "console-sample-app-static",
"containerDefinitions": [
{
"name": "simple-app",
"image": "httpd:2.4",
"cpu": 10,
"memory": 300,
"environment": [],
"portMappings": [
{
"hostPort": 80,
"containerPort": 80
}
],
"volumesFrom": [],
"links": [],
"mountPoints": [
{
"sourceVolume": "my-vol",
"containerPath": "/usr/local/apache2/htdocs"
}
],
"essential": true
},
{
"name": "busybox",
"image": "busybox",
"cpu": 10,
"memory": 200,
"entryPoint": [
"sh",
"-c"
],
"environment": [],
"command": [
"/bin/sh -c \"while true; do echo ' Your application is now running on a container in Amazon ECS.
' > top; /bin/date > date ; echo '(.*)<\/Code>)(?:.*(.*)<\/Message>)/m)},
lambda {|s| s.match(/.*<(.+Exception)>(?:.*(.*)<\/Message>)/m)}
]
[error.message, error.response.body].each(&Proc.new {|s|
matchers.each do |matcher|
match = matcher.call(s)
return {:code => match[1].split('.').last, :message => match[2]} if match
end
})
else
begin
full_msg_error = Fog::JSON.decode(error.response.body)
if (full_msg_error.has_key?('Message') || full_msg_error.has_key?('message')) &&
(error.response.headers.has_key?('x-amzn-ErrorType') || full_msg_error.has_key?('__type'))
matched_error = {
:code => full_msg_error['__type'] || error.response.headers['x-amzn-ErrorType'].split(':').first,
:message => full_msg_error['Message'] || full_msg_error['message']
}
return matched_error
end
rescue Fog::JSON::DecodeError => e
Fog::Logger.warning("Error parsing response json - #{e}")
end
end
{} # we did not match the message or response body
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/cdn.rb 0000644 0000041 0000041 00000017206 12576636531 016347 0 ustar www-data www-data module Fog
module CDN
class AWS < Fog::Service
extend Fog::AWS::CredentialFetcher::ServiceMethods
requires :aws_access_key_id, :aws_secret_access_key
recognizes :host, :path, :port, :scheme, :version, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
model_path 'fog/aws/models/cdn'
model :distribution
collection :distributions
model :streaming_distribution
collection :streaming_distributions
request_path 'fog/aws/requests/cdn'
request 'delete_distribution'
request 'delete_streaming_distribution'
request 'get_distribution'
request 'get_distribution_list'
request 'get_invalidation_list'
request 'get_invalidation'
request 'get_streaming_distribution'
request 'get_streaming_distribution_list'
request 'post_distribution'
request 'post_streaming_distribution'
request 'post_invalidation'
request 'put_distribution_config'
request 'put_streaming_distribution_config'
class Mock
def self.data
@data ||= Hash.new do |hash, key|
hash[key] = {
:distributions => {},
:streaming_distributions => {},
:invalidations => {}
}
end
end
def self.reset
@data = nil
end
def initialize(options={})
@use_iam_profile = options[:use_iam_profile]
setup_credentials(options)
end
def data
self.class.data[@aws_access_key_id]
end
def reset_data
self.class.data.delete(@aws_access_key_id)
end
def signature(params)
"foo"
end
def setup_credentials(options={})
@aws_access_key_id = options[:aws_access_key_id]
end
def self.distribution_id
random_id(14)
end
def self.generic_id
random_id(14)
end
def self.domain_name
"#{random_id(12).downcase}.cloudfront.net"
end
def self.random_id(length)
Fog::Mock.random_selection("abcdefghijklmnopqrstuvwxyz0123456789", length).upcase
end
CDN_ERRORS = {
:access_denies => {:code => 'AccessDenied',:msg => 'Access denied.',:status => 403},
:inappropriate_xml => {:code => 'InappropriateXML',:msg => 'The XML document you provided was well-formed and valid, but not appropriate for this operation.',:status => 400},
:internal_error => {:code => 'InternalError',:msg => 'We encountered an internal error. Please try again.',:status => 500},
:invalid_action => {:code => 'InvalidAction',:msg => 'The action specified is not valid.',:status => 400},
:invalid_argument => {:code => 'InvalidArgument',:msg => '%s', :status => 400},
:not_implemented => {:code => 'NotImplemented', :msg => 'Not implemented.',:status => 501},
:no_such_distribution => { :code => 'NoSuchDistribution', :msg => 'The specified distribution does not exist', :status => 404 },
:no_such_streaming_distribution => { :code => 'NoSuchStreamingDistribution', :msg => 'The specified streaming distribution does not exist', :status => 404 },
:no_such_invalidation => { :code => 'NoSuchInvalidation', :msg => 'The specified invalidation does not exist', :status => 404 },
:cname_exists => { :code => 'CNAMEAlreadyExists', :msg => 'One or more of the CNAMEs you provided are already associated with a different distribution', :status => 409 },
:illegal_update => { :code => 'IllegalUpdate', :msg => 'Origin and CallerReference cannot be updated.', :status => 400 },
:invalid_if_match_version => { :code => 'InvalidIfMatchVersion', :msg => 'The If-Match version is missing or not valid for the distribution.', :status => 400},
:distribution_not_disabled => { :code => 'DistributionNotDisabled', :msg => 'The distribution you are trying to delete has not been disabled.', :status => 409 },
}
def self.error(code, argument = '')
if error = CDN_ERRORS[code]
raise_error(error[:status], error[:code], error[:msg] % argument)
end
end
def self.raise_error(status, code, message='')
response = Excon::Response.new
response.status = status
response.body = <
Sender
#{code}
#{message}.
#{Fog::AWS::Mock.request_id}
EOF
raise(Excon::Errors.status_error({:expects => 201}, response))
end
end
class Real
include Fog::AWS::CredentialFetcher::ConnectionMethods
# Initialize connection to Cloudfront
#
# ==== Notes
# options parameter must include values for :aws_access_key_id and
# :aws_secret_access_key in order to create a connection
#
# ==== Examples
# cdn = Fog::AWS::CDN.new(
# :aws_access_key_id => your_aws_access_key_id,
# :aws_secret_access_key => your_aws_secret_access_key
# )
#
# ==== Parameters
# * options<~Hash> - config arguments for connection. Defaults to {}.
#
# ==== Returns
# * cdn object with connection to aws.
def initialize(options={})
@use_iam_profile = options[:use_iam_profile]
setup_credentials(options)
@instrumentor = options[:instrumentor]
@instrumentor_name = options[:instrumentor_name] || 'fog.aws.cdn'
@connection_options = options[:connection_options] || {}
@host = options[:host] || 'cloudfront.amazonaws.com'
@path = options[:path] || '/'
@persistent = options.fetch(:persistent, true)
@port = options[:port] || 443
@scheme = options[:scheme] || 'https'
@version = options[:version] || '2010-11-01'
@connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
end
def reload
@connection.reset
end
private
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
@aws_secret_access_key = options[:aws_secret_access_key]
@aws_session_token = options[:aws_session_token]
@aws_credentials_expire_at = options[:aws_credentials_expire_at]
@hmac = Fog::HMAC.new('sha1', @aws_secret_access_key)
end
def request(params, &block)
refresh_credentials_if_expired
params[:headers] ||= {}
params[:headers]['Date'] = Fog::Time.now.to_date_header
params[:headers]['x-amz-security-token'] = @aws_session_token if @aws_session_token
params[:headers]['Authorization'] = "AWS #{@aws_access_key_id}:#{signature(params)}"
params[:path] = "/#{@version}/#{params[:path]}"
if @instrumentor
@instrumentor.instrument("#{@instrumentor_name}.request", params) do
_request(params, &block)
end
else
_request(params, &block)
end
end
def _request(params, &block)
@connection.request(params, &block)
end
def signature(params)
string_to_sign = params[:headers]['Date']
signed_string = @hmac.sign(string_to_sign)
Base64.encode64(signed_string).chomp!
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/dynamodb.rb 0000644 0000041 0000041 00000011074 12576636531 017375 0 ustar www-data www-data module Fog
module AWS
class DynamoDB < Fog::Service
extend Fog::AWS::CredentialFetcher::ServiceMethods
requires :aws_access_key_id, :aws_secret_access_key
recognizes :aws_session_token, :host, :path, :port, :scheme, :persistent, :region, :use_iam_profile, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
request_path 'fog/aws/requests/dynamodb'
request :batch_get_item
request :batch_write_item
request :create_table
request :delete_item
request :delete_table
request :describe_table
request :get_item
request :list_tables
request :put_item
request :query
request :scan
request :update_item
request :update_table
class Mock
def self.data
@data ||= Hash.new do |hash, key|
hash[key] = {
:domains => {}
}
end
end
def self.reset
@data = nil
end
def initialize(options={})
@use_iam_profile = options[:use_iam_profile]
setup_credentials(options)
end
def data
self.class.data[@aws_access_key_id]
end
def reset_data
self.class.data.delete(@aws_access_key_id)
end
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
end
end
class Real
include Fog::AWS::CredentialFetcher::ConnectionMethods
# Initialize connection to DynamoDB
#
# ==== Notes
# options parameter must include values for :aws_access_key_id and
# :aws_secret_access_key in order to create a connection
#
# ==== Examples
# ddb = DynamoDB.new(
# :aws_access_key_id => your_aws_access_key_id,
# :aws_secret_access_key => your_aws_secret_access_key
# )
#
# ==== Parameters
# * options<~Hash> - config arguments for connection. Defaults to {}.
#
# ==== Returns
# * DynamoDB object with connection to aws
def initialize(options={})
@use_iam_profile = options[:use_iam_profile]
@region = options[:region] || 'us-east-1'
setup_credentials(options)
@connection_options = options[:connection_options] || {}
@instrumentor = options[:instrumentor]
@instrumentor_name = options[:instrumentor_name] || 'fog.aws.dynamodb'
@host = options[:host] || "dynamodb.#{@region}.amazonaws.com"
@path = options[:path] || '/'
@persistent = options[:persistent] || false
@port = options[:port] || '443'
@scheme = options[:scheme] || 'https'
@connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
end
private
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
@aws_secret_access_key = options[:aws_secret_access_key]
@aws_session_token = options[:aws_session_token]
@aws_credentials_expire_at = options[:aws_credentials_expire_at]
@signer = Fog::AWS::SignatureV4.new(@aws_access_key_id, @aws_secret_access_key, @region, 'dynamodb')
end
def reload
@connection.reset
end
def request(params)
refresh_credentials_if_expired
# defaults for all dynamodb requests
params.merge!({
:expects => 200,
:method => :post,
:path => '/'
})
# setup headers and sign with signature v4
date = Fog::Time.now
params[:headers] = {
'Content-Type' => 'application/x-amz-json-1.0',
'Date' => date.to_iso8601_basic,
'Host' => @host,
}.merge!(params[:headers])
params[:headers]['x-amz-security-token'] = @aws_session_token if @aws_session_token
params[:headers]['Authorization'] = @signer.sign(params, date)
if @instrumentor
@instrumentor.instrument("#{@instrumentor_name}.request", params) do
_request(params)
end
else
_request(params)
end
end
def _request(params)
response = @connection.request(params)
unless response.body.empty?
response.body = Fog::JSON.decode(response.body)
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/kms.rb 0000644 0000041 0000041 00000013743 12576636531 016377 0 ustar www-data www-data module Fog
module AWS
class KMS < Fog::Service
extend Fog::AWS::CredentialFetcher::ServiceMethods
DependencyTimeoutException = Class.new(Fog::Errors::Error)
DisabledException = Class.new(Fog::Errors::Error)
InvalidArnException = Class.new(Fog::Errors::Error)
InvalidGrantTokenException = Class.new(Fog::Errors::Error)
InvalidKeyUsageException = Class.new(Fog::Errors::Error)
KMSInternalException = Class.new(Fog::Errors::Error)
KeyUnavailableException = Class.new(Fog::Errors::Error)
MalformedPolicyDocumentException = Class.new(Fog::Errors::Error)
NotFoundException = Class.new(Fog::Errors::Error)
requires :aws_access_key_id, :aws_secret_access_key
recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :instrumentor, :instrumentor_name
request_path 'fog/aws/requests/kms'
request :list_keys
request :create_key
request :describe_key
model_path 'fog/aws/models/kms'
model :key
collection :keys
class Mock
def self.data
@data ||= Hash.new do |hash, region|
hash[region] = Hash.new do |region_hash, access_key|
region_hash[access_key] = {
:keys => {},
}
end
end
end
def self.reset
data.clear
end
attr_reader :account_id
def initialize(options={})
@use_iam_profile = options[:use_iam_profile]
@account_id = Fog::AWS::Mock.owner_id
@region = options[:region] || 'us-east-1'
setup_credentials(options)
Fog::AWS.validate_region!(@region)
end
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
@aws_secret_access_key = options[:aws_secret_access_key]
@signer = Fog::AWS::SignatureV4.new(@aws_access_key_id, @aws_secret_access_key, @region, 'kms')
end
def data
self.class.data[@region][@aws_access_key_id]
end
def reset_data
self.class.data[@region].delete(@aws_access_key_id)
end
end
class Real
include Fog::AWS::CredentialFetcher::ConnectionMethods
# Initialize connection to KMS
#
# ==== Notes
# options parameter must include values for :aws_access_key_id and
# :aws_secret_access_key in order to create a connection
#
# ==== Examples
# kms = KMS.new(
# :aws_access_key_id => your_aws_access_key_id,
# :aws_secret_access_key => your_aws_secret_access_key
# )
#
# ==== Parameters
# * options<~Hash> - config arguments for connection. Defaults to {}.
# * region<~String> - optional region to use. For instance, 'eu-west-1', 'us-east-1', etc.
#
# ==== Returns
# * KMS object with connection to AWS.
def initialize(options={})
@use_iam_profile = options[:use_iam_profile]
@connection_options = options[:connection_options] || {}
@instrumentor = options[:instrumentor]
@instrumentor_name = options[:instrumentor_name] || 'fog.aws.kms'
options[:region] ||= 'us-east-1'
@region = options[:region]
@host = options[:host] || "kms.#{@region}.amazonaws.com"
@path = options[:path] || '/'
@persistent = options[:persistent] || false
@port = options[:port] || 443
@scheme = options[:scheme] || 'https'
@connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
setup_credentials(options)
end
def reload
@connection.reset
end
private
def setup_credentials(options={})
@aws_access_key_id = options[:aws_access_key_id]
@aws_secret_access_key = options[:aws_secret_access_key]
@aws_session_token = options[:aws_session_token]
@signer = Fog::AWS::SignatureV4.new(@aws_access_key_id, @aws_secret_access_key, @region, 'kms')
end
def request(params)
refresh_credentials_if_expired
idempotent = params.delete(:idempotent)
parser = params.delete(:parser)
body, headers = Fog::AWS.signed_params_v4(
params,
{ 'Content-Type' => 'application/x-www-form-urlencoded' },
{
:aws_session_token => @aws_session_token,
:signer => @signer,
:host => @host,
:path => @path,
:port => @port,
:version => '2014-11-01',
:method => 'POST'
}
)
if @instrumentor
@instrumentor.instrument("#{@instrumentor_name}.request", params) do
_request(body, headers, idempotent, parser)
end
else
_request(body, headers, idempotent, parser)
end
end
def _request(body, headers, idempotent, parser)
@connection.request({
:body => body,
:expects => 200,
:headers => headers,
:idempotent => idempotent,
:method => 'POST',
:parser => parser
})
rescue Excon::Errors::HTTPStatusError => error
match = Fog::AWS::Errors.match_error(error)
if match.empty?
raise
elsif Fog::AWS::KMS.const_defined?(match[:code])
raise Fog::AWS::KMS.const_get(match[:code]).slurp(error, match[:message])
else
raise Fog::AWS::KMS::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/redshift.rb 0000644 0000041 0000041 00000011623 12576636531 017410 0 ustar www-data www-data module Fog
module AWS
class Redshift < Fog::Service
extend Fog::AWS::CredentialFetcher::ServiceMethods
requires :aws_access_key_id, :aws_secret_access_key
recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
request_path 'fog/aws/requests/redshift'
request :describe_clusters
request :describe_cluster_parameter_groups
request :describe_cluster_parameters
request :describe_cluster_security_groups
request :describe_cluster_snapshots
request :describe_cluster_subnet_groups
request :describe_cluster_versions
request :describe_default_cluster_parameters
request :describe_events
request :describe_orderable_cluster_options
request :describe_reserved_node_offerings
request :describe_reserved_nodes
request :describe_resize
request :create_cluster
request :create_cluster_parameter_group
request :create_cluster_security_group
request :create_cluster_snapshot
request :create_cluster_subnet_group
request :modify_cluster
request :modify_cluster_parameter_group
request :modify_cluster_subnet_group
request :delete_cluster
request :delete_cluster_parameter_group
request :delete_cluster_security_group
request :delete_cluster_snapshot
request :delete_cluster_subnet_group
request :authorize_cluster_security_group_ingress
request :authorize_snapshot_access
request :copy_cluster_snapshot
request :purchase_reserved_node_offering
request :reboot_cluster
request :reset_cluster_parameter_group
request :restore_from_cluster_snapshot
request :revoke_cluster_security_group_ingress
request :revoke_snapshot_access
class Mock
def initialize(options={})
Fog::Mock.not_implemented
end
end
class Real
include Fog::AWS::CredentialFetcher::ConnectionMethods
# Initialize connection to Redshift
#
# ==== Notes
# options parameter must include values for :aws_access_key_id and
# :aws_secret_access_key in order to create a connection
#
# ==== Examples
# ses = SES.new(
# :aws_access_key_id => your_aws_access_key_id,
# :aws_secret_access_key => your_aws_secret_access_key
# )
#
# ==== Parameters
# * options<~Hash> - config arguments for connection. Defaults to {}.
# * region<~String> - optional region to use. For instance, 'us-east-1' and etc.
#
# ==== Returns
# * Redshift object with connection to AWS.
def initialize(options={})
@use_iam_profile = options[:use_iam_profile]
@region = options[:region] || 'us-east-1'
setup_credentials(options)
@instrumentor = options[:instrumentor]
@instrumentor_name = options[:instrumentor_name] || 'fog.aws.redshift'
@connection_options = options[:connection_options] || {}
@host = options[:host] || "redshift.#{@region}.amazonaws.com"
@version = '2012-12-01'
@path = options[:path] || '/'
@persistent = options[:persistent] || false
@port = options[:port] || 443
@scheme = options[:scheme] || 'https'
@connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
end
private
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
@aws_secret_access_key = options[:aws_secret_access_key]
@aws_session_token = options[:aws_session_token]
@aws_credentials_expire_at = options[:aws_credentials_expire_at]
@signer = Fog::AWS::SignatureV4.new( @aws_access_key_id, @aws_secret_access_key,@region,'redshift')
end
def request(params, &block)
refresh_credentials_if_expired
parser = params.delete(:parser)
date = Fog::Time.now
params[:headers]['Date'] = date.to_date_header
params[:headers]['x-amz-date'] = date.to_iso8601_basic
params[:headers]['Host'] = @host
params[:headers]['x-amz-redshift-version'] = @version
params[:headers]['x-amz-security-token'] = @aws_session_token if @aws_session_token
params[:headers]['Authorization'] = @signer.sign params, date
params[:parser] = parser
if @instrumentor
@instrumentor.instrument("#{@instrumentor_name}.request", params) do
_request(params, &block)
end
else
_request(params, &block)
end
end
def _request(params, &block)
@connection.request(params, &block)
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/federation.rb 0000644 0000041 0000041 00000002562 12576636531 017722 0 ustar www-data www-data module Fog
module AWS
class Federation < Fog::Service
extend Fog::AWS::CredentialFetcher::ServiceMethods
recognizes :instrumentor, :instrumentor_name
request_path 'fog/aws/requests/federation'
request 'get_signin_token'
class Mock
def self.data
@data ||= {}
end
def self.reset
@data = nil
end
def initialize(options={})
end
def data
self.class.data
end
def reset_data
self.class.reset
end
end
class Real
include Fog::AWS::CredentialFetcher::ConnectionMethods
def initialize(options={})
@instrumentor = options[:instrumentor]
@instrumentor_name = options[:instrumentor_name] || 'fog.aws.federation'
@connection_options = options[:connection_options] || {}
@host = 'signin.aws.amazon.com'
@path = '/federation'
@scheme = 'https'
@connection = Excon.new("#{@scheme}://#{@host}#{@path}")
end
def request(action, session)
response = @connection.get(
:query => "Action=#{action}&SessionType=json&Session=#{session}",
:expects => 200
).body
Fog::JSON.decode(response)
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/auto_scaling.rb 0000644 0000041 0000041 00000022552 12576636531 020253 0 ustar www-data www-data module Fog
module AWS
class AutoScaling < Fog::Service
extend Fog::AWS::CredentialFetcher::ServiceMethods
class IdentifierTaken < Fog::Errors::Error; end
class ResourceInUse < Fog::Errors::Error; end
class ValidationError < Fog::Errors::Error; end
requires :aws_access_key_id, :aws_secret_access_key
recognizes :host, :path, :port, :scheme, :persistent, :region, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
request_path 'fog/aws/requests/auto_scaling'
request :attach_load_balancers
request :create_auto_scaling_group
request :create_launch_configuration
request :create_or_update_tags
request :delete_auto_scaling_group
request :delete_launch_configuration
request :delete_notification_configuration
request :delete_policy
request :delete_scheduled_action
request :delete_tags
request :describe_adjustment_types
request :describe_auto_scaling_groups
request :describe_auto_scaling_instances
request :describe_auto_scaling_notification_types
request :describe_launch_configurations
request :describe_metric_collection_types
request :describe_notification_configurations
request :describe_policies
request :describe_scaling_activities
request :describe_scaling_process_types
request :describe_scheduled_actions
request :describe_tags
request :describe_termination_policy_types
request :detach_load_balancers
request :disable_metrics_collection
request :enable_metrics_collection
request :execute_policy
request :put_notification_configuration
request :put_scaling_policy
request :put_scheduled_update_group_action
request :resume_processes
request :set_desired_capacity
request :set_instance_health
request :suspend_processes
request :terminate_instance_in_auto_scaling_group
request :update_auto_scaling_group
model_path 'fog/aws/models/auto_scaling'
model :activity
collection :activities
model :configuration
collection :configurations
model :group
collection :groups
model :instance
collection :instances
model :policy
collection :policies
ExpectedOptions = {}
class Real
include Fog::AWS::CredentialFetcher::ConnectionMethods
attr_accessor :region
# Initialize connection to AutoScaling
#
# ==== Notes
# options parameter must include values for :aws_access_key_id and
# :aws_secret_access_key in order to create a connection
#
# ==== Examples
# as = AutoScaling.new(
# :aws_access_key_id => your_aws_access_key_id,
# :aws_secret_access_key => your_aws_secret_access_key
# )
#
# ==== Parameters
# * options<~Hash> - config arguments for connection. Defaults to {}.
#
# ==== Returns
# * AutoScaling object with connection to AWS.
def initialize(options={})
@use_iam_profile = options[:use_iam_profile]
@connection_options = options[:connection_options] || {}
@instrumentor = options[:instrumentor]
@instrumentor_name = options[:instrumentor_name] || 'fog.aws.auto_scaling'
options[:region] ||= 'us-east-1'
@region = options[:region]
@host = options[:host] || "autoscaling.#{options[:region]}.amazonaws.com"
@path = options[:path] || '/'
@port = options[:port] || 443
@persistent = options[:persistent] || false
@scheme = options[:scheme] || 'https'
@connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
setup_credentials(options)
end
def reload
@connection.reset
end
private
def request(params)
refresh_credentials_if_expired
idempotent = params.delete(:idempotent)
parser = params.delete(:parser)
body, headers = AWS.signed_params_v4(
params,
{ 'Content-Type' => 'application/x-www-form-urlencoded' },
{
:aws_session_token => @aws_session_token,
:method => 'POST',
:signer => @signer,
:host => @host,
:path => @path,
:port => @port,
:version => '2011-01-01'
}
)
if @instrumentor
@instrumentor.instrument("#{@instrumentor_name}.request", params) do
_request(body, headers, idempotent, parser)
end
else
_request(body, headers, idempotent, parser)
end
end
def _request(body, headers, idempotent, parser)
begin
@connection.request({
:body => body,
:expects => 200,
:idempotent => idempotent,
:headers => headers,
:method => 'POST',
:parser => parser
})
rescue Excon::Errors::HTTPStatusError => error
match = Fog::AWS::Errors.match_error(error)
raise if match.empty?
raise case match[:code]
when 'AlreadyExists'
Fog::AWS::AutoScaling::IdentifierTaken.slurp(error, match[:message])
when 'ResourceInUse'
Fog::AWS::AutoScaling::ResourceInUse.slurp(error, match[:message])
when 'ValidationError'
Fog::AWS::AutoScaling::ValidationError.slurp(error, match[:message])
else
Fog::AWS::AutoScaling::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
end
end
end
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
@aws_secret_access_key = options[:aws_secret_access_key]
@aws_session_token = options[:aws_session_token]
@aws_credentials_expire_at = options[:aws_credentials_expire_at]
@signer = Fog::AWS::SignatureV4.new( @aws_access_key_id, @aws_secret_access_key, @region, 'autoscaling')
end
end
class Mock
include Fog::AWS::CredentialFetcher::ConnectionMethods
attr_accessor :region
def self.data
@data ||= Hash.new do |hash, region|
owner_id = Fog::AWS::Mock.owner_id
hash[region] = Hash.new do |region_hash, key|
region_hash[key] = {
:adjustment_types => [
'ChangeInCapacity',
'ExactCapacity',
'PercentChangeInCapacity'
],
:auto_scaling_groups => {},
:scaling_policies => {},
:health_states => [
'Healthy',
'Unhealthy'
],
:launch_configurations => {},
:metric_collection_types => {
:granularities => [
'1Minute'
],
:metrics => [
'GroupMinSize',
'GroupMaxSize',
'GroupDesiredCapacity',
'GroupInServiceInstances',
'GroupPendingInstances',
'GroupTerminatingInstances',
'GroupTotalInstances'
]
},
:notification_configurations => {},
:notification_types => [
'autoscaling:EC2_INSTANCE_LAUNCH',
'autoscaling:EC2_INSTANCE_LAUNCH_ERROR',
'autoscaling:EC2_INSTANCE_TERMINATE',
'autoscaling:EC2_INSTANCE_TERMINATE_ERROR',
'autoscaling:TEST_NOTIFICATION'
],
:owner_id => owner_id,
:process_types => [
'AZRebalance',
'AddToLoadBalancer',
'AlarmNotification',
'HealthCheck',
'Launch',
'ReplaceUnhealthy',
'ScheduledActions',
'Terminate'
],
:termination_policy_types => [
'ClosestToNextInstanceHour',
'Default',
'NewestInstance',
'OldestInstance',
'OldestLaunchConfiguration'
]
}
end
end
end
def self.reset
@data = nil
end
def initialize(options={})
@use_iam_profile = options[:use_iam_profile]
setup_credentials(options)
@region = options[:region] || 'us-east-1'
Fog::AWS.validate_region!(@region)
end
def region_data
self.class.data[@region]
end
def data
self.region_data[@aws_access_key_id]
end
def reset_data
self.region_data.delete(@aws_access_key_id)
end
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/sqs.rb 0000644 0000041 0000041 00000012276 12576636531 016413 0 ustar www-data www-data module Fog
module AWS
class SQS < Fog::Service
extend Fog::AWS::CredentialFetcher::ServiceMethods
requires :aws_access_key_id, :aws_secret_access_key
recognizes :region, :host, :path, :port, :scheme, :persistent, :aws_session_token, :use_iam_profile, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
request_path 'fog/aws/requests/sqs'
request :change_message_visibility
request :create_queue
request :delete_message
request :delete_queue
request :get_queue_attributes
request :list_queues
request :receive_message
request :send_message
request :set_queue_attributes
class Mock
def self.data
@data ||= Hash.new do |hash, region|
hash[region] = Hash.new do |region_hash, key|
region_hash[key] = {
:owner_id => Fog::AWS::Mock.owner_id,
:queues => {}
}
end
end
end
def self.reset
@data = nil
end
def initialize(options={})
@use_iam_profile = options[:use_iam_profile]
setup_credentials(options)
@region = options[:region] || 'us-east-1'
Fog::AWS.validate_region!(@region)
end
def data
self.class.data[@region][@aws_access_key_id]
end
def reset_data
self.class.data[@region].delete(@aws_access_key_id)
end
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
end
end
class Real
include Fog::AWS::CredentialFetcher::ConnectionMethods
# Initialize connection to SQS
#
# ==== Notes
# options parameter must include values for :aws_access_key_id and
# :aws_secret_access_key in order to create a connection
#
# ==== Examples
# sqs = SQS.new(
# :aws_access_key_id => your_aws_access_key_id,
# :aws_secret_access_key => your_aws_secret_access_key
# )
#
# ==== Parameters
# * options<~Hash> - config arguments for connection. Defaults to {}.
# * region<~String> - optional region to use. For instance, 'eu-west-1', 'us-east-1' and etc.
#
# ==== Returns
# * SQS object with connection to AWS.
def initialize(options={})
@use_iam_profile = options[:use_iam_profile]
@instrumentor = options[:instrumentor]
@instrumentor_name = options[:instrumentor_name] || 'fog.aws.sqs'
@connection_options = options[:connection_options] || {}
options[:region] ||= 'us-east-1'
@region = options[:region]
@host = options[:host] || "sqs.#{options[:region]}.amazonaws.com"
@path = options[:path] || '/'
@persistent = options[:persistent] || false
@port = options[:port] || 443
@scheme = options[:scheme] || 'https'
@connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
setup_credentials(options)
end
def reload
@connection.reset
end
private
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
@aws_secret_access_key = options[:aws_secret_access_key]
@aws_session_token = options[:aws_session_token]
@aws_credentials_expire_at = options[:aws_credentials_expire_at]
@signer = Fog::AWS::SignatureV4.new( @aws_access_key_id, @aws_secret_access_key, @region, 'sqs')
end
def path_from_queue_url(queue_url)
queue_url.split('.com', 2).last.sub(/^:[0-9]+/, '')
end
def request(params)
refresh_credentials_if_expired
idempotent = params.delete(:idempotent)
parser = params.delete(:parser)
path = params.delete(:path)
body, headers = AWS.signed_params_v4(
params,
{ 'Content-Type' => 'application/x-www-form-urlencoded' },
{
:method => 'POST',
:aws_session_token => @aws_session_token,
:signer => @signer,
:host => @host,
:path => path || @path,
:port => @port,
:version => '2009-02-01'
}
)
if @instrumentor
@instrumentor.instrument("#{@instrumentor_name}.request", params) do
_request(body, headers, idempotent, parser, path)
end
else
_request(body, headers, idempotent, parser, path)
end
end
def _request(body, headers, idempotent, parser, path)
args = {
:body => body,
:expects => 200,
:idempotent => idempotent,
:headers => headers,
:method => 'POST',
:parser => parser,
:path => path
}.reject{|_,v| v.nil? }
@connection.request(args)
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/ses.rb 0000644 0000041 0000041 00000012230 12576636531 016365 0 ustar www-data www-data module Fog
module AWS
class SES < Fog::Service
extend Fog::AWS::CredentialFetcher::ServiceMethods
class InvalidParameterError < Fog::Errors::Error; end
class MessageRejected < Fog::Errors::Error; end
requires :aws_access_key_id, :aws_secret_access_key
recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
request_path 'fog/aws/requests/ses'
request :delete_verified_email_address
request :verify_email_address
request :verify_domain_identity
request :get_send_quota
request :get_send_statistics
request :list_verified_email_addresses
request :send_email
request :send_raw_email
class Mock
def initialize(options={})
Fog::Mock.not_implemented
end
end
class Real
include Fog::AWS::CredentialFetcher::ConnectionMethods
# Initialize connection to SES
#
# ==== Notes
# options parameter must include values for :aws_access_key_id and
# :aws_secret_access_key in order to create a connection
#
# ==== Examples
# ses = SES.new(
# :aws_access_key_id => your_aws_access_key_id,
# :aws_secret_access_key => your_aws_secret_access_key
# )
#
# ==== Parameters
# * options<~Hash> - config arguments for connection. Defaults to {}.
# * region<~String> - optional region to use. For instance, 'us-east-1' and etc.
#
# ==== Returns
# * SES object with connection to AWS.
def initialize(options={})
@use_iam_profile = options[:use_iam_profile]
setup_credentials(options)
@instrumentor = options[:instrumentor]
@instrumentor_name = options[:instrumentor_name] || 'fog.aws.ses'
@connection_options = options[:connection_options] || {}
options[:region] ||= 'us-east-1'
@host = options[:host] || "email.#{options[:region]}.amazonaws.com"
@path = options[:path] || '/'
@persistent = options[:persistent] || false
@port = options[:port] || 443
@scheme = options[:scheme] || 'https'
@connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
end
def reload
@connection.reset
end
private
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
@aws_secret_access_key = options[:aws_secret_access_key]
@aws_session_token = options[:aws_session_token]
@aws_credentials_expire_at = options[:aws_credentials_expire_at]
@hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
end
def request(params)
refresh_credentials_if_expired
idempotent = params.delete(:idempotent)
parser = params.delete(:parser)
headers = {
'Content-Type' => 'application/x-www-form-urlencoded',
'Date' => Fog::Time.now.to_date_header,
}
headers['x-amz-security-token'] = @aws_session_token if @aws_session_token
#AWS3-HTTPS AWSAccessKeyId=, Algorithm=HmacSHA256, Signature=
headers['X-Amzn-Authorization'] = 'AWS3-HTTPS '
headers['X-Amzn-Authorization'] << 'AWSAccessKeyId=' << @aws_access_key_id
headers['X-Amzn-Authorization'] << ', Algorithm=HmacSHA256'
headers['X-Amzn-Authorization'] << ', Signature=' << Base64.encode64(@hmac.sign(headers['Date'])).chomp!
body = ''
for key in params.keys.sort
unless (value = params[key]).nil?
body << "#{key}=#{CGI.escape(value.to_s).gsub(/\+/, '%20')}&"
end
end
body.chop! # remove trailing '&'
if @instrumentor
@instrumentor.instrument("#{@instrumentor_name}.request", params) do
_request(body, headers, idempotent, parser)
end
else
_request(body, headers, idempotent, parser)
end
end
def _request(body, headers, idempotent, parser)
@connection.request({
:body => body,
:expects => 200,
:headers => headers,
:idempotent => idempotent,
:host => @host,
:method => 'POST',
:parser => parser
})
rescue Excon::Errors::HTTPStatusError => error
match = Fog::AWS::Errors.match_error(error)
raise if match.empty?
raise case match[:code]
when 'MessageRejected'
Fog::AWS::SES::MessageRejected.slurp(error, match[:message])
when 'InvalidParameterValue'
Fog::AWS::SES::InvalidParameterError.slurp(error, match[:message])
else
Fog::AWS::SES::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/ 0000755 0000041 0000041 00000000000 12576636531 017123 5 ustar www-data www-data fog-aws-0.7.6/lib/fog/aws/requests/sts/ 0000755 0000041 0000041 00000000000 12576636531 017734 5 ustar www-data www-data fog-aws-0.7.6/lib/fog/aws/requests/sts/assume_role.rb 0000644 0000041 0000041 00000003602 12576636531 022600 0 ustar www-data www-data module Fog
module AWS
class STS
class Real
require 'fog/aws/parsers/sts/assume_role'
# Assume Role
#
# ==== Parameters
# * role_session_name<~String> - An identifier for the assumed role.
# * role_arn<~String> - The ARN of the role the caller is assuming.
# * external_id<~String> - An optional unique identifier required by the assuming role's trust identity.
# * policy<~String> - An optional JSON policy document
# * duration<~Integer> - Duration (of seconds) for the assumed role credentials to be valid (default 3600)
#
# ==== Returns
# * response<~Excon::Response>:
# * body<~Hash>:
# * 'Arn'<~String>: The ARN of the assumed role/user
# * 'AccessKeyId'<~String>: The AWS access key of the temporary credentials for the assumed role
# * 'SecretAccessKey'<~String>: The AWS secret key of the temporary credentials for the assumed role
# * 'SessionToken'<~String>: The AWS session token of the temporary credentials for the assumed role
# * 'Expiration'<~Time>: The expiration time of the temporary credentials for the assumed role
#
# ==== See Also
# http://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html
#
def assume_role(role_session_name, role_arn, external_id=nil, policy=nil, duration=3600)
request({
'Action' => 'AssumeRole',
'RoleSessionName' => role_session_name,
'RoleArn' => role_arn,
'Policy' => policy && Fog::JSON.encode(policy),
'DurationSeconds' => duration,
'ExternalId' => external_id,
:idempotent => true,
:parser => Fog::Parsers::AWS::STS::AssumeRole.new
})
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sts/get_session_token.rb 0000644 0000041 0000041 00000000672 12576636531 024010 0 ustar www-data www-data module Fog
module AWS
class STS
class Real
require 'fog/aws/parsers/sts/get_session_token'
def get_session_token(duration=43200)
request({
'Action' => 'GetSessionToken',
'DurationSeconds' => duration,
:idempotent => true,
:parser => Fog::Parsers::AWS::STS::GetSessionToken.new
})
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sts/assume_role_with_web_identity.rb 0000644 0000041 0000041 00000003164 12576636531 026404 0 ustar www-data www-data module Fog
module AWS
class STS
class Real
require 'fog/aws/parsers/sts/assume_role_with_web_identity'
def assume_role_with_web_identity(role_arn, web_identity_token, role_session_name, options={})
request_unsigned(
'Action' => 'AssumeRoleWithWebIdentity',
'RoleArn' => role_arn,
'RoleSessionName' => role_session_name,
'DurationSeconds' => options[:duration] || 3600,
:idempotent => true,
:parser => Fog::Parsers::AWS::STS::AssumeRoleWithWebIdentity.new
)
end
end
class Mock
def assume_role_with_web_identity(role_arn, web_identity_token, role_session_name, options={})
role = options[:iam].data[:roles].values.detect { |r| r[:arn] == role_arn }
Excon::Response.new.tap do |response|
response.body = {
'AssumedRoleUser' => {
'Arn' => role[:arn],
'AssumedRoleId' => role[:role_id]
},
'Audience' => 'fog',
'Credentials' => {
'AccessKeyId' => Fog::AWS::Mock.key_id(20),
'Expiration' => options[:expiration] || Time.now + 3600,
'SecretAccessKey' => Fog::AWS::Mock.key_id(40),
'SessionToken' => Fog::Mock.random_hex(8)
},
'Provider' => 'fog',
'SubjectFromWebIdentityToken' => Fog::Mock.random_hex(8)
}
response.status = 200
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sts/assume_role_with_saml.rb 0000644 0000041 0000041 00000003743 12576636531 024655 0 ustar www-data www-data module Fog
module AWS
class STS
class Real
require 'fog/aws/parsers/sts/assume_role_with_saml'
# Assume Role with SAML
#
# ==== Parameters
# * role_arn<~String> - The ARN of the role the caller is assuming.
# * principal_arn<~String> - The Amazon Resource Name (ARN) of the SAML provider in IAM that describes the IdP.
# * saml_assertion<~String> - The base-64 encoded SAML authentication response provided by the IdP.
# * policy<~String> - An optional JSON policy document
# * duration<~Integer> - Duration (of seconds) for the assumed role credentials to be valid (default 3600)
#
# ==== Returns
# * response<~Excon::Response>:
# * body<~Hash>:
# * 'Arn'<~String>: The ARN of the assumed role/user
# * 'AccessKeyId'<~String>: The AWS access key of the temporary credentials for the assumed role
# * 'SecretAccessKey'<~String>: The AWS secret key of the temporary credentials for the assumed role
# * 'SessionToken'<~String>: The AWS session token of the temporary credentials for the assumed role
# * 'Expiration'<~Time>: The expiration time of the temporary credentials for the assumed role
#
# ==== See Also
# http://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html
#
def assume_role_with_saml(role_arn, principal_arn, saml_assertion, policy=nil, duration=3600)
request_unsigned({
'Action' => 'AssumeRoleWithSAML',
'RoleArn' => role_arn,
'PrincipalArn' => principal_arn,
'SAMLAssertion' => saml_assertion,
'Policy' => policy && Fog::JSON.encode(policy),
'DurationSeconds' => duration,
:idempotent => true,
:parser => Fog::Parsers::AWS::STS::AssumeRoleWithSAML.new
})
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sts/get_federation_token.rb 0000644 0000041 0000041 00000004643 12576636531 024447 0 ustar www-data www-data module Fog
module AWS
class STS
class Real
require 'fog/aws/parsers/sts/get_session_token'
# Get federation token
#
# ==== Parameters
# * name<~String>: The name of the federated user.
# Minimum length of 2. Maximum length of 32.
# * policy<~String>: Optional policy that specifies the permissions
# that are granted to the federated user
# Minimum length of 1. Maximum length of 2048.
# * duration<~Integer>: Optional duration, in seconds, that the session
# should last.
# ==== Returns
# * response<~Excon::Response>:
# * body<~Hash>:
# * 'SessionToken'<~String> -
# * 'SecretAccessKey'<~String> -
# * 'Expiration'<~String> -
# * 'AccessKeyId'<~String> -
# * 'Arn'<~String> -
# * 'FederatedUserId'<~String> -
# * 'PackedPolicySize'<~String> -
# * 'RequestId'<~String> - Id of the request
#
# ==== See Also
# http://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html
def get_federation_token(name, policy, duration=43200)
request({
'Action' => 'GetFederationToken',
'Name' => name,
'Policy' => Fog::JSON.encode(policy),
'DurationSeconds' => duration,
:idempotent => true,
:parser => Fog::Parsers::AWS::STS::GetSessionToken.new
})
end
end
class Mock
def get_federation_token(name, policy, duration=43200)
Excon::Response.new.tap do |response|
response.status = 200
response.body = {
'SessionToken' => Fog::Mock.random_base64(580),
'SecretAccessKey' => Fog::Mock.random_base64(40),
'Expiration' => (DateTime.now + duration).strftime('%FT%TZ'),
'AccessKeyId' => Fog::AWS::Mock.key_id(20),
'Arn' => "arn:aws:sts::#{Fog::AWS::Mock.owner_id}:federated-user/#{name}",
'FederatedUserId' => "#{Fog::AWS::Mock.owner_id}:#{name}",
'PackedPolicySize' => Fog::Mock.random_numbers(2),
'RequestId' => Fog::AWS::Mock.request_id
}
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sqs/ 0000755 0000041 0000041 00000000000 12576636531 017731 5 ustar www-data www-data fog-aws-0.7.6/lib/fog/aws/requests/sqs/set_queue_attributes.rb 0000644 0000041 0000041 00000003250 12576636531 024523 0 ustar www-data www-data module Fog
module AWS
class SQS
class Real
require 'fog/aws/parsers/sqs/basic'
# Get attributes of a queue
#
# ==== Parameters
# * queue_url<~String> - Url of queue to get attributes for
# * attribute_name<~String> - Name of attribute to set, keys in ['MaximumMessageSize', 'MessageRetentionPeriod', 'Policy', 'VisibilityTimeout']
# * attribute_value<~String> - Value to set for attribute
#
# ==== See Also
# http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QuerySetQueueAttributes.html
#
def set_queue_attributes(queue_url, attribute_name, attribute_value)
request({
'Action' => 'SetQueueAttributes',
'Attribute.Name' => attribute_name,
'Attribute.Value' => attribute_value,
:path => path_from_queue_url(queue_url),
:parser => Fog::Parsers::AWS::SQS::Basic.new
})
end
end
class Mock
def set_queue_attributes(queue_url, attribute_name, attribute_value)
Excon::Response.new.tap do |response|
if (queue = data[:queues][queue_url])
response.status = 200
queue['Attributes'][attribute_name] = attribute_value
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
}
}
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sqs/delete_queue.rb 0000644 0000041 0000041 00000002306 12576636531 022725 0 ustar www-data www-data module Fog
module AWS
class SQS
class Real
require 'fog/aws/parsers/sqs/basic'
# Delete a queue
#
# ==== Parameters
# * queue_url<~String> - Url of queue to delete
#
# ==== See Also
# http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QueryDeleteQueue.html
#
def delete_queue(queue_url)
request({
'Action' => 'DeleteQueue',
:parser => Fog::Parsers::AWS::SQS::Basic.new,
:path => path_from_queue_url(queue_url),
})
end
end
class Mock
def delete_queue(queue_url)
Excon::Response.new.tap do |response|
if (queue = data[:queues][queue_url])
response.status = 200
data[:queues].delete(queue_url)
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
}
}
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sqs/list_queues.rb 0000644 0000041 0000041 00000002051 12576636531 022616 0 ustar www-data www-data module Fog
module AWS
class SQS
class Real
require 'fog/aws/parsers/sqs/list_queues'
# List queues
#
# ==== Parameters
# * options<~Hash>:
# * QueueNamePrefix<~String> - String used to filter results to only those with matching prefixes
#
# ==== See Also
# http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QueryListQueues.html
#
def list_queues(options = {})
request({
'Action' => 'ListQueues',
:parser => Fog::Parsers::AWS::SQS::ListQueues.new
}.merge!(options))
end
end
class Mock
def list_queues(options = {})
Excon::Response.new.tap do |response|
response.status = 200
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'QueueUrls' => data[:queues].keys
}
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sqs/create_queue.rb 0000644 0000041 0000041 00000004157 12576636531 022734 0 ustar www-data www-data module Fog
module AWS
class SQS
class Real
require 'fog/aws/parsers/sqs/create_queue'
# Create a queue
#
# ==== Parameters
# * name<~String> - Name of queue to create
# * options<~Hash>:
# * DefaultVisibilityTimeout<~String> - Time, in seconds, to hide a message after it has been received, in 0..43200, defaults to 30
#
# ==== See Also
# http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QueryCreateQueue.html
#
def create_queue(name, options = {})
request({
'Action' => 'CreateQueue',
'QueueName' => name,
:parser => Fog::Parsers::AWS::SQS::CreateQueue.new
}.merge!(options))
end
end
class Mock
def create_queue(name, options = {})
Excon::Response.new.tap do |response|
response.status = 200
now = Time.now
queue_url = "https://queue.amazonaws.com/#{data[:owner_id]}/#{name}"
queue = {
'QueueName' => name,
'Attributes' => {
'VisibilityTimeout' => 30,
'ApproximateNumberOfMessages' => 0,
'ApproximateNumberOfMessagesNotVisible' => 0,
'CreatedTimestamp' => now,
'LastModifiedTimestamp' => now,
'QueueArn' => Fog::AWS::Mock.arn('sqs', 'us-east-1', data[:owner_id], name),
'MaximumMessageSize' => 8192,
'MessageRetentionPeriod' => 345600
},
:messages => {},
:receipt_handles => {}
}
data[:queues][queue_url] = queue unless data[:queues][queue_url]
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'QueueUrl' => queue_url
}
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sqs/receive_message.rb 0000644 0000041 0000041 00000006224 12576636531 023410 0 ustar www-data www-data module Fog
module AWS
class SQS
class Real
require 'fog/aws/parsers/sqs/receive_message'
# Get a message from a queue (marks it as unavailable temporarily, but does not remove from queue, see delete_message)
#
# ==== Parameters
# * queue_url<~String> - Url of queue to get message from
# * options<~Hash>:
# * Attributes<~Array> - List of attributes to return, in ['All', 'ApproximateFirstReceiveTimestamp', 'ApproximateReceiveCount', 'SenderId', 'SentTimestamp'], defaults to 'All'
# * MaxNumberOfMessages<~Integer> - Maximum number of messages to return, defaults to 1
# * VisibilityTimeout<~Integer> - Duration, in seconds, to hide message from other receives. In 0..43200, defaults to visibility timeout for queue
#
# ==== See Also
# http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QueryReceiveMessage.html
#
def receive_message(queue_url, options = {})
request({
'Action' => 'ReceiveMessage',
'AttributeName' => 'All',
:path => path_from_queue_url(queue_url),
:parser => Fog::Parsers::AWS::SQS::ReceiveMessage.new
}.merge!(options))
end
end
class Mock
def receive_message(queue_url, options = {})
Excon::Response.new.tap do |response|
if (queue = data[:queues][queue_url])
max_number_of_messages = options['MaxNumberOfMessages'] || 1
now = Time.now
messages = []
queue[:messages].values.each do |m|
message_id = m['MessageId']
invisible = if (received_handles = queue[:receipt_handles][message_id])
visibility_timeout = m['Attributes']['VisibilityTimeout'] || queue['Attributes']['VisibilityTimeout']
received_handles.any? { |handle, time| now < time + visibility_timeout }
else
false
end
unless invisible
receipt_handle = Fog::Mock.random_base64(300)
queue[:receipt_handles][message_id] ||= {}
queue[:receipt_handles][message_id][receipt_handle] = now
m['Attributes'].tap do |attrs|
attrs['ApproximateFirstReceiveTimestamp'] ||= now
attrs['ApproximateReceiveCount'] = (attrs['ApproximateReceiveCount'] || 0) + 1
end
messages << m.merge({
'ReceiptHandle' => receipt_handle
})
break if messages.size >= max_number_of_messages
end
end
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'Message' => messages
}
response.status = 200
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sqs/delete_message.rb 0000644 0000041 0000041 00000003335 12576636531 023230 0 ustar www-data www-data module Fog
module AWS
class SQS
class Real
require 'fog/aws/parsers/sqs/basic'
# Delete a message from a queue
#
# ==== Parameters
# * queue_url<~String> - Url of queue to delete message from
# * receipt_handle<~String> - Token from previous recieve message
#
# ==== See Also
# http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QueryDeleteMessage.html
#
def delete_message(queue_url, receipt_handle)
request({
'Action' => 'DeleteMessage',
'ReceiptHandle' => receipt_handle,
:parser => Fog::Parsers::AWS::SQS::Basic.new,
:path => path_from_queue_url(queue_url),
})
end
end
class Mock
def delete_message(queue_url, receipt_handle)
Excon::Response.new.tap do |response|
if (queue = data[:queues][queue_url])
message_id, _ = queue[:receipt_handles].find { |msg_id, receipts|
receipts.key?(receipt_handle)
}
if message_id
queue[:receipt_handles].delete(message_id)
queue[:messages].delete(message_id)
queue['Attributes']['LastModifiedTimestamp'] = Time.now
end
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
}
}
response.status = 200
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sqs/send_message.rb 0000644 0000041 0000041 00000003705 12576636531 022720 0 ustar www-data www-data module Fog
module AWS
class SQS
class Real
require 'fog/aws/parsers/sqs/send_message'
# Add a message to a queue
#
# ==== Parameters
# * queue_url<~String> - Url of queue to add message to
# * message<~String> - Message to add to queue
#
# ==== See Also
# http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QuerySendMessage.html
#
def send_message(queue_url, message)
request({
'Action' => 'SendMessage',
'MessageBody' => message,
:path => path_from_queue_url(queue_url),
:parser => Fog::Parsers::AWS::SQS::SendMessage.new
})
end
end
class Mock
def send_message(queue_url, message)
Excon::Response.new.tap do |response|
if (queue = data[:queues][queue_url])
response.status = 200
now = Time.now
message_id = Fog::AWS::Mock.sqs_message_id
md5 = Digest::MD5.hexdigest(message)
queue[:messages][message_id] = {
'MessageId' => message_id,
'Body' => message,
'MD5OfBody' => md5,
'Attributes' => {
'SenderId' => Fog::AWS::Mock.sqs_message_id,
'SentTimestamp' => now
}
}
queue['Attributes']['LastModifiedTimestamp'] = now
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'MessageId' => message_id,
'MD5OfMessageBody' => md5
}
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sqs/get_queue_attributes.rb 0000644 0000041 0000041 00000003235 12576636531 024512 0 ustar www-data www-data module Fog
module AWS
class SQS
class Real
require 'fog/aws/parsers/sqs/get_queue_attributes'
# Get attributes of a queue
#
# ==== Parameters
# * queue_url<~String> - Url of queue to get attributes for
# * attribute_name<~Array> - Name of attribute to return, in ['All', 'ApproximateNumberOfMessages', 'ApproximateNumberOfMessagesNotVisible', 'CreatedTimestamp', 'LastModifiedTimestamp', 'MaximumMessageSize', 'MessageRetentionPeriod', 'Policy', 'QueueArn', 'VisibilityTimeout']
#
# ==== See Also
# http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QueryGetQueueAttributes.html
#
def get_queue_attributes(queue_url, attribute_name)
request({
'Action' => 'GetQueueAttributes',
'AttributeName' => attribute_name,
:path => path_from_queue_url(queue_url),
:parser => Fog::Parsers::AWS::SQS::GetQueueAttributes.new
})
end
end
class Mock
def get_queue_attributes(queue_url, attribute_name)
Excon::Response.new.tap do |response|
if (queue = data[:queues][queue_url])
response.status = 200
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'Attributes' => queue['Attributes']
}
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/sqs/change_message_visibility.rb 0000644 0000041 0000041 00000004021 12576636531 025453 0 ustar www-data www-data module Fog
module AWS
class SQS
class Real
require 'fog/aws/parsers/sqs/basic'
# Change visibility timeout for a message
#
# ==== Parameters
# * queue_url<~String> - Url of queue for message to update
# * receipt_handle<~String> - Token from previous recieve message
# * visibility_timeout<~Integer> - New visibility timeout in 0..43200
#
# ==== See Also
# http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QueryChangeMessageVisibility.html
#
def change_message_visibility(queue_url, receipt_handle, visibility_timeout)
request({
'Action' => 'ChangeMessageVisibility',
'ReceiptHandle' => receipt_handle,
'VisibilityTimeout' => visibility_timeout,
:parser => Fog::Parsers::AWS::SQS::Basic.new,
:path => path_from_queue_url(queue_url)
})
end
end
class Mock
def change_message_visibility(queue_url, receipt_handle, visibility_timeout)
Excon::Response.new.tap do |response|
if (queue = data[:queues][queue_url])
message_id, _ = queue[:receipt_handles].find { |message_id, receipts|
receipts.key?(receipt_handle)
}
if message_id
queue[:messages][message_id]['Attributes']['VisibilityTimeout'] = visibility_timeout
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
}
}
response.status = 200
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/ 0000755 0000041 0000041 00000000000 12576636531 020567 5 ustar www-data www-data fog-aws-0.7.6/lib/fog/aws/requests/storage/get_object_url.rb 0000644 0000041 0000041 00000002201 12576636531 024076 0 ustar www-data www-data module Fog
module Storage
class AWS
module GetObjectUrl
def get_object_url(bucket_name, object_name, expires, options = {})
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
unless object_name
raise ArgumentError.new('object_name is required')
end
signed_url(options.merge({
:bucket_name => bucket_name,
:object_name => object_name,
:method => 'GET'
}), expires)
end
end
class Real
# Get an expiring object url from S3
#
# @param bucket_name [String] Name of bucket containing object
# @param object_name [String] Name of object to get expiring url for
# @param expires [Time] An expiry time for this url
#
# @return [Excon::Response] response:
# * body [String] - url for object
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/dev/S3_QSAuth.html
include GetObjectUrl
end
class Mock # :nodoc:all
include GetObjectUrl
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/put_bucket_versioning.rb 0000644 0000041 0000041 00000004332 12576636531 025526 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Change versioning status for an S3 bucket
#
# @param bucket_name [String] name of bucket to modify
# @param status [String] Status to change to in ['Enabled', 'Suspended']
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTVersioningStatus.html
def put_bucket_versioning(bucket_name, status)
data =
<<-DATA
#{status}
DATA
request({
:body => data,
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:method => 'PUT',
:query => {'versioning' => nil}
})
end
end
class Mock
def put_bucket_versioning(bucket_name, status)
response = Excon::Response.new
bucket = self.data[:buckets][bucket_name]
if bucket
if ['Enabled', 'Suspended'].include?(status)
bucket[:versioning] = status
response.status = 200
else
response.status = 400
response.body = {
'Error' => {
'Code' => 'MalformedXML',
'Message' => 'The XML you provided was not well-formed or did not validate against our published schema',
'RequestId' => Fog::Mock.random_hex(16),
'HostId' => Fog::Mock.random_base64(65)
}
}
raise(Excon::Errors.status_error({:expects => 200}, response))
end
else
response.status = 404
response.body = {
'Error' => {
'Code' => 'NoSuchBucket',
'Message' => 'The specified bucket does not exist',
'BucketName' => bucket_name,
'RequestId' => Fog::Mock.random_hex(16),
'HostId' => Fog::Mock.random_base64(65)
}
}
raise(Excon::Errors.status_error({:expects => 200}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/put_request_payment.rb 0000644 0000041 0000041 00000002424 12576636531 025233 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Change who pays for requests to an S3 bucket
#
# @param bucket_name [String] name of bucket to modify
# @param payer [String] valid values are BucketOwner or Requester
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTrequestPaymentPUT.html
def put_request_payment(bucket_name, payer)
data =
<<-DATA
#{payer}
DATA
request({
:body => data,
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:method => 'PUT',
:query => {'requestPayment' => nil}
})
end
end
class Mock # :nodoc:all
def put_request_payment(bucket_name, payer)
response = Excon::Response.new
if bucket = self.data[:buckets][bucket_name]
response.status = 200
bucket['Payer'] = payer
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/put_bucket_lifecycle.rb 0000644 0000041 0000041 00000007173 12576636531 025310 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Change lifecycle configuration for an S3 bucket
#
# @param bucket_name [String] name of bucket to set lifecycle configuration for
# * lifecycle [Hash]:
# * Rules [Array] object expire rules
# * ID [String] Unique identifier for the rule
# * Prefix [String] Prefix identifying one or more objects to which the rule applies
# * Enabled [Boolean] if rule is currently being applied
# * Expiration [Hash] Container for the object expiration rule.
# * Days [Integer] lifetime, in days, of the objects that are subject to the rule
# * Date [Date] Indicates when the specific rule take effect.
# The date value must conform to the ISO 8601 format. The time is always midnight UTC.
# * Transition [Hash] Container for the transition rule that describes when objects transition
# to the Glacier storage class
# * Days [Integer] lifetime, in days, of the objects that are subject to the rule
# * Date [Date] Indicates when the specific rule take effect.
# The date value must conform to the ISO 8601 format. The time is always midnight UTC.
# * StorageClass [String] Indicates the Amazon S3 storage class to which you want the object
# to transition to.
#
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTlifecycle.html
#
def put_bucket_lifecycle(bucket_name, lifecycle)
builder = Nokogiri::XML::Builder.new do
LifecycleConfiguration {
lifecycle['Rules'].each do |rule|
Rule {
ID rule['ID']
Prefix rule['Prefix']
Status rule['Enabled'] ? 'Enabled' : 'Disabled'
unless (rule['Expiration'] or rule['Transition'])
Expiration { Days rule['Days'] }
else
if rule['Expiration']
if rule['Expiration']['Days']
Expiration { Days rule['Expiration']['Days'] }
elsif rule['Expiration']['Date']
Expiration { Date rule['Expiration']['Date'].is_a?(Time) ? rule['Expiration']['Date'].utc.iso8601 : Time.parse(rule['Expiration']['Date']).utc.iso8601 }
end
end
if rule['Transition']
Transition {
if rule['Transition']['Days']
Days rule['Transition']['Days']
elsif rule['Transition']['Date']
Date rule['Transition']['Date'].is_a?(Time) ? time.utc.iso8601 : Time.parse(time).utc.iso8601
end
StorageClass rule['Transition']['StorageClass'].nil? ? 'GLACIER' : rule['Transition']['StorageClass']
}
end
end
}
end
}
end
body = builder.to_xml
body.gsub! /<([^<>]+)\/>/, '<\1>'
request({
:body => body,
:expects => 200,
:headers => {'Content-MD5' => Base64.encode64(Digest::MD5.digest(body)).chomp!,
'Content-Type' => 'application/xml'},
:bucket_name => bucket_name,
:method => 'PUT',
:query => {'lifecycle' => nil}
})
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/put_bucket_notification.rb 0000644 0000041 0000041 00000006734 12576636531 026041 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Change notification configuration for an S3 bucket
#
# @param bucket_name [String] name of bucket to set notification configuration for
# * notications [Hash]:
# * Topics [Array] SNS topic configurations for the notification
# * ID [String] Unique identifier for the configuration
# * Topic [String] Amazon SNS topic ARN to which Amazon S3 will publish a message when it detects events of specified type
# * Event [String] Bucket event for which to send notifications
# * Queues [Array] SQS queue configurations for the notification
# * ID [String] Unique identifier for the configuration
# * Queue [String] Amazon SQS queue ARN to which Amazon S3 will publish a message when it detects events of specified type
# * Event [String] Bucket event for which to send notifications
# * CloudFunctions [Array] AWS Lambda notification configurations
# * ID [String] Unique identifier for the configuration
# * CloudFunction [String] Lambda cloud function ARN that Amazon S3 can invoke when it detects events of the specified type
# * InvocationRole [String] IAM role ARN that Amazon S3 can assume to invoke the specified cloud function on your behalf
# * Event [String] Bucket event for which to send notifications
#
# @see http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTnotification.html
#
def put_bucket_notification(bucket_name, notification)
builder = Nokogiri::XML::Builder.new do
NotificationConfiguration do
notification.fetch('Topics', []).each do |topic|
TopicConfiguration do
Id topic['Id']
Topic topic['Topic']
Event topic['Event']
end
end
notification.fetch('Queues', []).each do |queue|
QueueConfiguration do
Id queue['Id']
Queue queue['Queue']
Event queue['Event']
end
end
notification.fetch('CloudFunctions', []).each do |func|
CloudFunctionConfiguration do
Id func['Id']
CloudFunction func['CloudFunction']
InvocationRole func['InvocationRole']
Event func['Event']
end
end
end
end
body = builder.to_xml
body.gsub!(/<([^<>]+)\/>/, '<\1>')
request({
:body => body,
:expects => 200,
:headers => {'Content-MD5' => Base64.encode64(Digest::MD5.digest(body)).chomp!,
'Content-Type' => 'application/xml'},
:bucket_name => bucket_name,
:method => 'PUT',
:query => {'notification' => nil}
})
end
end
class Mock
def put_bucket_notification(bucket_name, notification)
response = Excon::Response.new
if self.data[:buckets][bucket_name]
self.data[:bucket_notifications][bucket_name] = notification
response.status = 204
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 204}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/put_object.rb 0000644 0000041 0000041 00000007436 12576636531 023264 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Create an object in an S3 bucket
#
# @param bucket_name [String] Name of bucket to create object in
# @param object_name [String] Name of object to create
# @param data [File||String] File or String to create object from
# @param options [Hash]
# @option options Cache-Control [String] Caching behaviour
# @option options Content-Disposition [String] Presentational information for the object
# @option options Content-Encoding [String] Encoding of object data
# @option options Content-Length [String] Size of object in bytes (defaults to object.read.length)
# @option options Content-MD5 [String] Base64 encoded 128-bit MD5 digest of message
# @option options Content-Type [String] Standard MIME type describing contents (defaults to MIME::Types.of.first)
# @option options Expires [String] Cache expiry
# @option options x-amz-acl [String] Permissions, must be in ['private', 'public-read', 'public-read-write', 'authenticated-read']
# @option options x-amz-storage-class [String] Default is 'STANDARD', set to 'REDUCED_REDUNDANCY' for non-critical, reproducable data
# @option options x-amz-meta-#{name} Headers to be returned with object, note total size of request without body must be less than 8 KB. Each name, value pair must conform to US-ASCII.
#
# @return [Excon::Response] response:
# * headers [Hash]:
# * ETag [String] etag of new object
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectPUT.html
def self.conforming_to_us_ascii!(keys, hash)
return if RUBY_VERSION =~ /^1\.8\./
keys.each do |k|
v = hash[k]
if !v.encode(::Encoding::US_ASCII, :undef => :replace).eql?(v)
raise Excon::Errors::BadRequest.new("invalid #{k} header: value must be us-ascii")
end
end
end
def put_object(bucket_name, object_name, data, options = {})
data = Fog::Storage.parse_data(data)
headers = data[:headers].merge!(options)
self.class.conforming_to_us_ascii! headers.keys.grep(/^x-amz-meta-/), headers
request({
:body => data[:body],
:expects => 200,
:headers => headers,
:bucket_name => bucket_name,
:object_name => object_name,
:idempotent => true,
:method => 'PUT',
})
end
end
class Mock # :nodoc:all
require 'fog/aws/requests/storage/shared_mock_methods'
include Fog::Storage::AWS::SharedMockMethods
def put_object(bucket_name, object_name, data, options = {})
define_mock_acl(bucket_name, object_name, options)
data = parse_mock_data(data)
headers = data[:headers].merge!(options)
Fog::Storage::AWS::Real.conforming_to_us_ascii! headers.keys.grep(/^x-amz-meta-/), headers
bucket = verify_mock_bucket_exists(bucket_name)
options['Content-Type'] ||= data[:headers]['Content-Type']
options['Content-Length'] ||= data[:headers]['Content-Length']
object = store_mock_object(bucket, object_name, data[:body], options)
response = Excon::Response.new
response.status = 200
response.headers = {
'Content-Length' => object['Content-Length'],
'Content-Type' => object['Content-Type'],
'ETag' => object['ETag'],
'Last-Modified' => object['Last-Modified'],
}
response.headers['x-amz-version-id'] = object['VersionId'] if object['VersionId'] != 'null'
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/acl_utils.rb 0000644 0000041 0000041 00000004243 12576636531 023076 0 ustar www-data www-data module Fog
module Storage
class AWS
require 'fog/aws/parsers/storage/access_control_list'
private
def self.hash_to_acl(acl)
data = "\n"
if acl['Owner'] && (acl['Owner']['ID'] || acl['Owner']['DisplayName'])
data << " \n"
data << " #{acl['Owner']['ID']} \n" if acl['Owner']['ID']
data << " #{acl['Owner']['DisplayName']} \n" if acl['Owner']['DisplayName']
data << " \n"
end
grants = [acl['AccessControlList']].flatten.compact
data << " \n" if grants.any?
grants.each do |grant|
data << " \n"
grantee = grant['Grantee']
type = case
when grantee.key?('ID')
'CanonicalUser'
when grantee.key?('EmailAddress')
'AmazonCustomerByEmail'
when grantee.key?('URI')
'Group'
end
data << " \n"
case type
when 'CanonicalUser'
data << " #{grantee['ID']} \n" if grantee['ID']
data << " #{grantee['DisplayName']} \n" if grantee['DisplayName']
when 'AmazonCustomerByEmail'
data << " #{grantee['EmailAddress']} \n" if grantee['EmailAddress']
when 'Group'
data << " #{grantee['URI']} \n" if grantee['URI']
end
data << " \n"
data << " #{grant['Permission']} \n"
data << " \n"
end
data << " \n" if grants.any?
data << " "
data
end
def self.acl_to_hash(acl_xml)
parser = Fog::Parsers::Storage::AWS::AccessControlList.new
Nokogiri::XML::SAX::Parser.new(parser).parse(acl_xml)
parser.response
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_object_torrent.rb 0000644 0000041 0000041 00000003064 12576636531 025001 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Get torrent for an S3 object
#
# @param bucket_name [String] name of bucket containing object
# @param object_name [String] name of object to get torrent for
#
# @return [Excon::Response] response:
# * body [Hash]:
# * AccessControlPolicy [Hash:
# * Owner [Hash]:
# * DisplayName [String] - Display name of object owner
# * ID [String] - Id of object owner
# * AccessControlList [Array]:
# * Grant [Hash]:
# * Grantee [Hash]:
# * DisplayName [String] - Display name of grantee
# * ID [String] - Id of grantee
# * Permission [String] - Permission, in [FULL_CONTROL, WRITE, WRITE_ACP, READ, READ_ACP]
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectGETtorrent.html
def get_object_torrent(bucket_name, object_name)
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
unless object_name
raise ArgumentError.new('object_name is required')
end
request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:object_name => object_name,
:idempotent => true,
:method => 'GET',
:query => {'torrent' => nil}
})
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/head_object.rb 0000644 0000041 0000041 00000005357 12576636531 023355 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Get headers for an object from S3
#
# @param bucket_name [String] Name of bucket to read from
# @param object_name [String] Name of object to read
# @param options [Hash]:
# @option options [String] If-Match Returns object only if its etag matches this value, otherwise returns 412 (Precondition Failed).
# @option options [Time] If-Modified-Since Returns object only if it has been modified since this time, otherwise returns 304 (Not Modified).
# @option options [String] If-None-Match Returns object only if its etag differs from this value, otherwise returns 304 (Not Modified)
# @option options [Time] If-Unmodified-Since Returns object only if it has not been modified since this time, otherwise returns 412 (Precodition Failed).
# @option options [String] Range Range of object to download
# @option options [String] versionId specify a particular version to retrieve
#
# @return [Excon::Response] response:
# * body [String] Contents of object
# * headers [Hash]:
# * Content-Length [String] - Size of object contents
# * Content-Type [String] - MIME type of object
# * ETag [String] - Etag of object
# * Last-Modified - [String] Last modified timestamp for object
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectHEAD.html
#
def head_object(bucket_name, object_name, options={})
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
unless object_name
raise ArgumentError.new('object_name is required')
end
if version_id = options.delete('versionId')
query = {'versionId' => version_id}
end
headers = {}
headers['If-Modified-Since'] = Fog::Time.at(options['If-Modified-Since'].to_i).to_date_header if options['If-Modified-Since']
headers['If-Unmodified-Since'] = Fog::Time.at(options['If-Unmodified-Since'].to_i).to_date_header if options['If-Modified-Since']
headers.merge!(options)
request({
:expects => 200,
:headers => headers,
:bucket_name => bucket_name,
:object_name => object_name,
:idempotent => true,
:method => 'HEAD',
:query => query
})
end
end
class Mock # :nodoc:all
def head_object(bucket_name, object_name, options = {})
response = get_object(bucket_name, object_name, options)
response.body = nil
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_object_acl.rb 0000644 0000041 0000041 00000005350 12576636531 024043 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/access_control_list'
# Get access control list for an S3 object
#
# @param bucket_name [String] name of bucket containing object
# @param object_name [String] name of object to get access control list for
# @param options [Hash]
# @option options versionId [String] specify a particular version to retrieve
#
# @return [Excon::Response] response:
# * body [Hash]:
# * [AccessControlPolicy [Hash]:
# * Owner [Hash]:
# * DisplayName [String] - Display name of object owner
# * ID [String] - Id of object owner
# * AccessControlList [Array]:
# * Grant [Hash]:
# * Grantee [Hash]:
# * DisplayName [String] - Display name of grantee
# * ID [String] - Id of grantee
# or
# * URI [String] - URI of group to grant access for
# * Permission [String] - Permission, in [FULL_CONTROL, WRITE, WRITE_ACP, READ, READ_ACP]
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectGETacl.html
def get_object_acl(bucket_name, object_name, options = {})
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
unless object_name
raise ArgumentError.new('object_name is required')
end
query = {'acl' => nil}
if version_id = options.delete('versionId')
query['versionId'] = version_id
end
request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:object_name => object_name,
:idempotent => true,
:method => 'GET',
:parser => Fog::Parsers::Storage::AWS::AccessControlList.new,
:query => query
})
end
end
class Mock # :nodoc:all
require 'fog/aws/requests/storage/acl_utils'
def get_object_acl(bucket_name, object_name, options = {})
response = Excon::Response.new
if acl = self.data[:acls][:object][bucket_name] && self.data[:acls][:object][bucket_name][object_name]
response.status = 200
if acl.is_a?(String)
response.body = Fog::Storage::AWS.acl_to_hash(acl)
else
response.body = acl
end
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_service.rb 0000644 0000041 0000041 00000002743 12576636531 023421 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/get_service'
# List information about S3 buckets for authorized user
#
# @return [Excon::Response] response:
# * body [Hash]:
# * Buckets [Hash]:
# * Name [String] - Name of bucket
# * CreationTime [Time] - Timestamp of bucket creation
# * Owner [Hash]:
# * DisplayName [String] - Display name of bucket owner
# * ID [String] - Id of bucket owner
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTServiceGET.html
#
def get_service
request({
:expects => 200,
:headers => {},
:host => @host,
:idempotent => true,
:method => 'GET',
:parser => Fog::Parsers::Storage::AWS::GetService.new
})
end
end
class Mock # :nodoc:all
def get_service
response = Excon::Response.new
response.headers['Status'] = 200
buckets = self.data[:buckets].values.map do |bucket|
bucket.reject do |key, value|
!['CreationDate', 'Name'].include?(key)
end
end
response.body = {
'Buckets' => buckets,
'Owner' => { 'DisplayName' => 'owner', 'ID' => 'some_id'}
}
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/put_bucket_website.rb 0000644 0000041 0000041 00000006457 12576636531 025017 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Change website configuration for an S3 bucket
#
# @param bucket_name [String] name of bucket to modify
# @param options [Hash]
# @option options RedirectAllRequestsTo [String] Host name to redirect all requests to - if this is set, other options are ignored
# @option options IndexDocument [String] suffix to append to requests for the bucket
# @option options ErrorDocument [String] key to use for 4XX class errors
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html
def put_bucket_website(bucket_name, options, options_to_be_deprecated = {})
options ||= {}
# Method used to be called with the suffix as the second parameter. Warn user that this is not the case any more and move on
if options.is_a?(String)
Fog::Logger.deprecation("put_bucket_website with #{options.class} param is deprecated, use put_bucket_website('#{bucket_name}', :IndexDocument => '#{options}') instead [light_black](#{caller.first})[/]")
options = { :IndexDocument => options }
end
# Parameter renamed from "key" to "ErrorDocument"
if options_to_be_deprecated[:key]
Fog::Logger.deprecation("put_bucket_website with three parameters is deprecated, use put_bucket_website('#{bucket_name}', :ErrorDocument => '#{options_to_be_deprecated[:key]}') instead [light_black](#{caller.first})[/]")
options[:ErrorDocument] = options_to_be_deprecated[:key]
end
options.merge!(options_to_be_deprecated) { |key, o1, o2| o1 }
data = ""
if options[:RedirectAllRequestsTo]
# Redirect precludes all other options
data << <<-DATA
#{options[:RedirectAllRequestsTo]}
DATA
else
if options[:IndexDocument]
data << <<-DATA
#{options[:IndexDocument]}
DATA
end
if options[:ErrorDocument]
data << <<-DATA
#{options[:ErrorDocument]}
DATA
end
end
data << ' '
request({
:body => data,
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:method => 'PUT',
:query => {'website' => nil}
})
end
end
class Mock # :nodoc:all
def put_bucket_website(bucket_name, suffix, options = {})
response = Excon::Response.new
if self.data[:buckets][bucket_name]
response.status = 200
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_bucket_cors.rb 0000644 0000041 0000041 00000005163 12576636531 024263 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/cors_configuration'
# Gets the CORS configuration for an S3 bucket
#
# @param bucket_name [String] name of bucket to get access control list for
#
# @return [Excon::Response] response:
# * body [Hash]:
# * CORSConfiguration [Array]:
# * CORSRule [Hash]:
# * AllowedHeader [String] - Which headers are allowed in a pre-flight OPTIONS request through the Access-Control-Request-Headers header.
# * AllowedMethod [String] - Identifies an HTTP method that the domain/origin specified in the rule is allowed to execute.
# * AllowedOrigin [String] - One or more response headers that you want customers to be able to access from their applications (for example, from a JavaScript XMLHttpRequest object).
# * ExposeHeader [String] - One or more headers in the response that you want customers to be able to access from their applications (for example, from a JavaScript XMLHttpRequest object).
# * ID [String] - An optional unique identifier for the rule. The ID value can be up to 255 characters long. The IDs help you find a rule in the configuration.
# * MaxAgeSeconds [Integer] - The time in seconds that your browser is to cache the preflight response for the specified resource.
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETcors.html
def get_bucket_cors(bucket_name)
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:idempotent => true,
:method => 'GET',
:parser => Fog::Parsers::Storage::AWS::CorsConfiguration.new,
:query => {'cors' => nil}
})
end
end
class Mock # :nodoc:all
require 'fog/aws/requests/storage/cors_utils'
def get_bucket_cors(bucket_name)
response = Excon::Response.new
if cors = self.data[:cors][:bucket][bucket_name]
response.status = 200
if cors.is_a?(String)
response.body = Fog::Storage::AWS.cors_to_hash(cors)
else
response.body = cors
end
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_bucket_tagging.rb 0000644 0000041 0000041 00000003024 12576636531 024727 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/get_bucket_tagging'
# Get tags for an S3 bucket
#
# @param bucket_name [String] name of bucket to get tags for
#
# @return [Excon::Response] response:
# * body [Hash]:
# * BucketTagging [Hash]:
# * Key [String] - tag key
# * Value [String] - tag value
# @see http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETtagging.html
def get_bucket_tagging(bucket_name)
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:idempotent => true,
:method => 'GET',
:parser => Fog::Parsers::Storage::AWS::GetBucketTagging.new,
:query => {'tagging' => nil}
})
end
end
class Mock # :nodoc:all
def get_bucket_tagging(bucket_name)
response = Excon::Response.new
if self.data[:buckets][bucket_name] && self.data[:bucket_tagging][bucket_name]
response.status = 200
response.body = {'BucketTagging' => self.data[:bucket_tagging][bucket_name]}
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_bucket_acl.rb 0000644 0000041 0000041 00000004242 12576636531 024051 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/access_control_list'
# Get access control list for an S3 bucket
#
# @param bucket_name [String] name of bucket to get access control list for
#
# @return [Excon::Response] response:
# * body [Hash]:
# * AccessControlPolicy [Hash]:
# * Owner [Hash]:
# * DisplayName [String] - Display name of object owner
# * ID [String] - Id of object owner
# * AccessControlList [Array]:
# * Grant [Hash]:
# * Grantee [Hash]:
# * DisplayName [String] - Display name of grantee
# * ID [String] - Id of grantee
# or
# * URI [String] - URI of group to grant access for
# * Permission [String] - Permission, in [FULL_CONTROL, WRITE, WRITE_ACP, READ, READ_ACP]
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETacl.html
def get_bucket_acl(bucket_name)
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:idempotent => true,
:method => 'GET',
:parser => Fog::Parsers::Storage::AWS::AccessControlList.new,
:query => {'acl' => nil}
})
end
end
class Mock # :nodoc:all
require 'fog/aws/requests/storage/acl_utils'
def get_bucket_acl(bucket_name)
response = Excon::Response.new
if acl = self.data[:acls][:bucket][bucket_name]
response.status = 200
if acl.is_a?(String)
response.body = Fog::Storage::AWS.acl_to_hash(acl)
else
response.body = acl
end
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_bucket_notification.rb 0000644 0000041 0000041 00000005223 12576636531 026000 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/get_bucket_notification'
# Get bucket notification configuration
#
# @param bucket_name [String] name of bucket to get notification configuration for
#
# @return [Excon::Response] response:
# * body [Hash]:
# * Topics [Array] SNS topic configurations for the notification
# * ID [String] Unique identifier for the configuration
# * Topic [String] Amazon SNS topic ARN to which Amazon S3 will publish a message when it detects events of specified type
# * Event [String] Bucket event for which to send notifications
# * Queues [Array] SQS queue configurations for the notification
# * ID [String] Unique identifier for the configuration
# * Queue [String] Amazon SQS queue ARN to which Amazon S3 will publish a message when it detects events of specified type
# * Event [String] Bucket event for which to send notifications
# * CloudFunctions [Array] AWS Lambda notification configurations
# * ID [String] Unique identifier for the configuration
# * CloudFunction [String] Lambda cloud function ARN that Amazon S3 can invoke when it detects events of the specified type
# * InvocationRole [String] IAM role ARN that Amazon S3 can assume to invoke the specified cloud function on your behalf
# * Event [String] Bucket event for which to send notifications
#
# @see http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETnotification.html
def get_bucket_notification(bucket_name)
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:idempotent => true,
:method => 'GET',
:parser => Fog::Parsers::Storage::AWS::GetBucketNotification.new,
:query => {'notification' => nil}
})
end
end
class Mock
def get_bucket_notification(bucket_name)
response = Excon::Response.new
if self.data[:buckets][bucket_name] && self.data[:bucket_notifications][bucket_name]
response.status = 200
response.body = self.data[:bucket_notifications][bucket_name]
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/initiate_multipart_upload.rb 0000644 0000041 0000041 00000005420 12576636531 026370 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/initiate_multipart_upload'
# Initiate a multipart upload to an S3 bucket
#
# @param bucket_name [String] Name of bucket to create object in
# @param object_name [String] Name of object to create
# @param options [Hash]:
# @option options [String] Cache-Control Caching behaviour
# @option options [String] Content-Disposition Presentational information for the object
# @option options [String] Content-Encoding Encoding of object data
# @option options [String] Content-MD5 Base64 encoded 128-bit MD5 digest of message (defaults to Base64 encoded MD5 of object.read)
# @option options [String] Content-Type Standard MIME type describing contents (defaults to MIME::Types.of.first)
# @option options [String] x-amz-acl Permissions, must be in ['private', 'public-read', 'public-read-write', 'authenticated-read']
# @option options [String] x-amz-meta-#{name} Headers to be returned with object, note total size of request without body must be less than 8 KB.
#
# @return [Excon::Response] response:
# * body [Hash]:
# * Bucket [String] - Bucket where upload was initiated
# * Key [String] - Object key where the upload was initiated
# * UploadId [String] - Id for initiated multipart upload
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadInitiate.html
#
def initiate_multipart_upload(bucket_name, object_name, options = {})
request({
:expects => 200,
:headers => options,
:bucket_name => bucket_name,
:object_name => object_name,
:method => 'POST',
:parser => Fog::Parsers::Storage::AWS::InitiateMultipartUpload.new,
:query => {'uploads' => nil}
})
end
end # Real
class Mock # :nodoc:all
require 'fog/aws/requests/storage/shared_mock_methods'
include Fog::Storage::AWS::SharedMockMethods
def initiate_multipart_upload(bucket_name, object_name, options = {})
verify_mock_bucket_exists(bucket_name)
upload_id = UUID.uuid
self.data[:multipart_uploads][bucket_name] ||= {}
self.data[:multipart_uploads][bucket_name][upload_id] = {
:parts => {},
:options => options,
}
response = Excon::Response.new
response.status = 200
response.body = {
"Bucket" => bucket_name,
"Key" => object_name,
"UploadId" => upload_id,
}
response
end
end # Mock
end # Storage
end # AWS
end # Fog
fog-aws-0.7.6/lib/fog/aws/requests/storage/put_bucket_policy.rb 0000644 0000041 0000041 00000002436 12576636531 024645 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Change bucket policy for an S3 bucket
#
# @param bucket_name [String] name of bucket to modify
# @param policy [Hash] policy document
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTpolicy.html
def put_bucket_policy(bucket_name, policy)
request({
:body => Fog::JSON.encode(policy),
:expects => 204,
:headers => {},
:bucket_name => bucket_name,
:method => 'PUT',
:query => {'policy' => nil}
})
end
end
class Mock
#FIXME: You can't actually use the credentials for anything elsewhere in Fog
#FIXME: Doesn't do any validation on the policy
def put_bucket_policy(bucket_name, policy)
if bucket = data[:buckets][bucket_name]
bucket[:policy] = policy
Excon::Response.new.tap do |response|
response.body = { 'RequestId' => Fog::AWS::Mock.request_id }
response.status = 200
end
else
raise Fog::AWS::IAM::NotFound.new("The bucket with name #{bucket_name} cannot be found.")
end
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_bucket_policy.rb 0000644 0000041 0000041 00000001633 12576636531 024612 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Get bucket policy for an S3 bucket
#
# @param bucket_name [String] name of bucket to get policy for
#
# @return [Excon::Response] response:
# * body [Hash] - policy document
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETpolicy.html
def get_bucket_policy(bucket_name)
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
response = request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:idempotent => true,
:method => 'GET',
:query => {'policy' => nil}
})
response.body = Fog::JSON.decode(response.body) unless response.body.nil?
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/cors_utils.rb 0000644 0000041 0000041 00000002021 12576636531 023275 0 ustar www-data www-data module Fog
module Storage
class AWS
require 'fog/aws/parsers/storage/cors_configuration'
private
def self.hash_to_cors(cors)
data = "\n"
[cors['CORSConfiguration']].flatten.compact.each do |rule|
data << " \n"
['ID', 'MaxAgeSeconds'].each do |key|
data << " <#{key}>#{rule[key]}\n" if rule[key]
end
['AllowedOrigin', 'AllowedMethod', 'AllowedHeader', 'ExposeHeader'].each do |key|
[rule[key]].flatten.compact.each do |value|
data << " <#{key}>#{value}\n"
end
end
data << " \n"
end
data << " "
data
end
def self.cors_to_hash(cors_xml)
parser = Fog::Parsers::Storage::AWS::CorsConfiguration.new
Nokogiri::XML::SAX::Parser.new(parser).parse(cors_xml)
parser.response
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/put_object_url.rb 0000644 0000041 0000041 00000002310 12576636531 024130 0 ustar www-data www-data module Fog
module Storage
class AWS
module PutObjectUrl
def put_object_url(bucket_name, object_name, expires, headers = {}, options = {})
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
unless object_name
raise ArgumentError.new('object_name is required')
end
signed_url(options.merge({
:bucket_name => bucket_name,
:object_name => object_name,
:method => 'PUT',
:headers => headers,
}), expires)
end
end
class Real
# Get an expiring object url from S3 for putting an object
#
# @param bucket_name [String] Name of bucket containing object
# @param object_name [String] Name of object to get expiring url for
# @param expires [Time] An expiry time for this url
#
# @return [Excon::Response] response:
# * body [String] url for object
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/dev/S3_QSAuth.html
include PutObjectUrl
end
class Mock # :nodoc:all
include PutObjectUrl
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_bucket_website.rb 0000644 0000041 0000041 00000002301 12576636531 024746 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/get_bucket_website'
# Get website configuration for an S3 bucket
#
#
# @param bucket_name [String] name of bucket to get website configuration for
#
# @return [Excon::Response] response:
# * body [Hash]:
# * IndexDocument [Hash]:
# * Suffix [String] - Suffix appended when directory is requested
# * ErrorDocument [Hash]:
# * Key [String] - Object key to return for 4XX class errors
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETwebsite.html
def get_bucket_website(bucket_name)
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:idempotent => true,
:method => 'GET',
:parser => Fog::Parsers::Storage::AWS::GetBucketWebsite.new,
:query => {'website' => nil}
})
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_bucket_location.rb 0000644 0000041 0000041 00000003212 12576636531 025116 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/get_bucket_location'
# Get location constraint for an S3 bucket
#
# @param bucket_name [String] name of bucket to get location constraint for
#
# @return [Excon::Response] response:
# * body [Hash]:
# * LocationConstraint [String] - Location constraint of the bucket
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETlocation.html
def get_bucket_location(bucket_name)
request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:idempotent => true,
:method => 'GET',
:parser => Fog::Parsers::Storage::AWS::GetBucketLocation.new,
:query => {'location' => nil},
:path_style => true
})
end
end
class Mock # :nodoc:all
def get_bucket_location(bucket_name)
response = Excon::Response.new
if bucket = self.data[:buckets][bucket_name]
location_constraint = case bucket['LocationConstraint']
when 'us-east-1'
nil
when 'eu-east-1'
'EU'
else
bucket['LocationConstraint']
end
response.status = 200
response.body = {'LocationConstraint' => location_constraint }
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/list_parts.rb 0000644 0000041 0000041 00000004544 12576636531 023307 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/list_parts'
# List parts for a multipart upload
#
# @param bucket_name [String] Name of bucket to list parts for
# @param object_name [String] Name of object to list parts for
# @param upload_id [String] upload id to list objects for
# @param options [Hash] config arguments for list. Defaults to {}.
# @option options max-parts [Integer] limits number of parts returned
# @option options part-number-marker [String] limits parts to only those that appear lexicographically after this part number.
#
# @return [Excon::Response] response:
# * body [Hash]:
# * Bucket [string] Bucket where the multipart upload was initiated
# * Initiator [Hash]:
# * DisplayName [String] Display name of upload initiator
# * ID [String] Id of upload initiator
# * IsTruncated [Boolean] Whether or not the listing is truncated
# * Key [String] Key where multipart upload was initiated
# * MaxParts [String] maximum number of replies alllowed in response
# * NextPartNumberMarker [String] last item in list, for further pagination
# * Part [Array]:
# * ETag [String] ETag of part
# * LastModified [Timestamp] Last modified for part
# * PartNumber [String] Part number for part
# * Size [Integer] Size of part
# * PartNumberMarker [String] Part number after which listing begins
# * StorageClass [String] Storage class of object
# * UploadId [String] upload id of upload containing part
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadListParts.html
#
def list_parts(bucket_name, object_name, upload_id, options = {})
options['uploadId'] = upload_id
request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:object_name => object_name,
:idempotent => true,
:method => 'GET',
:parser => Fog::Parsers::Storage::AWS::ListParts.new,
:query => options.merge!({'uploadId' => upload_id})
})
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/sync_clock.rb 0000644 0000041 0000041 00000001014 12576636531 023237 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Sync clock against S3 to avoid skew errors
#
def sync_clock
response = begin
get_service
rescue Excon::Errors::HTTPStatusError => error
error.response
end
Fog::Time.now = Time.parse(response.headers['Date'])
end
end # Real
class Mock # :nodoc:all
def sync_clock
true
end
end # Mock
end # Storage
end # AWS
end # Fog
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_object_http_url.rb 0000644 0000041 0000041 00000001566 12576636531 025152 0 ustar www-data www-data module Fog
module Storage
class AWS
module GetObjectHttpUrl
def get_object_http_url(bucket_name, object_name, expires, options = {})
get_object_url(bucket_name, object_name, expires, options.merge(:scheme => 'http'))
end
end
class Real
# Get an expiring object http url from S3
#
# @param bucket_name [String] Name of bucket containing object
# @param object_name [String] Name of object to get expiring url for
# @param expires [Time] An expiry time for this url
#
# @return [Excon::Response] response:
# * body [String] - url for object
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/dev/S3_QSAuth.html
include GetObjectHttpUrl
end
class Mock # :nodoc:all
include GetObjectHttpUrl
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/put_bucket_tagging.rb 0000644 0000041 0000041 00000002752 12576636531 024767 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Change tag set for an S3 bucket
#
# @param bucket_name [String] name of bucket to modify
# @param tags [Hash]:
# * Key [String]: tag key
# * Value [String]: tag value
#
# @see http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTtagging.html
def put_bucket_tagging(bucket_name, tags)
tagging = tags.map do |k,v|
"#{k} #{v}
#{tagging}
DATA
request({
:body => data,
:expects => 204,
:headers => {'Content-MD5' => Base64.encode64(Digest::MD5.digest(data)).chomp!, 'Content-Type' => 'application/xml'},
:bucket_name => bucket_name,
:method => 'PUT',
:query => {'tagging' => nil}
})
end
end
class Mock # :nodoc:all
def put_bucket_tagging(bucket_name, tags)
response = Excon::Response.new
if self.data[:buckets][bucket_name]
self.data[:bucket_tagging][bucket_name] = tags
response.status = 204
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 204}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/list_multipart_uploads.rb 0000644 0000041 0000041 00000004757 12576636531 025734 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/list_multipart_uploads'
# List multipart uploads for a bucket
#
# @param [String] bucket_name Name of bucket to list multipart uploads for
# @param [Hash] options config arguments for list. Defaults to {}.
# @option options [String] key-marker limits parts to only those that appear lexicographically after this key.
# @option options [Integer] max-uploads limits number of uploads returned
# @option options [String] upload-id-marker limits uploads to only those that appear lexicographically after this upload id.
#
# @return [Excon::Response] response:
# * body [Hash]:
# * Bucket [String] Bucket where the multipart upload was initiated
# * IsTruncated [Boolean] Whether or not the listing is truncated
# * KeyMarker [String] first key in list, only upload ids after this lexographically will appear
# * MaxUploads [Integer] Maximum results to return
# * NextKeyMarker [String] last key in list, for further pagination
# * NextUploadIdMarker [String] last key in list, for further pagination
# * Upload [Hash]:
# * Initiated [Time] Time when upload was initiated
# * Initiator [Hash]:
# * DisplayName [String] Display name of upload initiator
# * ID [String] Id of upload initiator
# * Key [String] Key where multipart upload was initiated
# * Owner [Hash]:
# * DisplayName [String] Display name of upload owner
# * ID [String] Id of upload owner
# * StorageClass [String] Storage class of object
# * UploadId [String] upload id of upload containing part
# * UploadIdMarker [String] first key in list, only upload ids after this lexographically will appear
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadListMPUpload.html
#
def list_multipart_uploads(bucket_name, options = {})
request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:idempotent => true,
:method => 'GET',
:parser => Fog::Parsers::Storage::AWS::ListMultipartUploads.new,
:query => options.merge!({'uploads' => nil})
})
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/delete_bucket.rb 0000644 0000041 0000041 00000002332 12576636531 023713 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Delete an S3 bucket
#
# @param bucket_name [String] name of bucket to delete
#
# @return [Excon::Response] response:
# * status [Integer] - 204
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETE.html
def delete_bucket(bucket_name)
request({
:expects => 204,
:headers => {},
:bucket_name => bucket_name,
:method => 'DELETE'
})
end
end
class Mock # :nodoc:all
def delete_bucket(bucket_name)
response = Excon::Response.new
if self.data[:buckets][bucket_name].nil?
response.status = 404
raise(Excon::Errors.status_error({:expects => 204}, response))
elsif self.data[:buckets][bucket_name] && !self.data[:buckets][bucket_name][:objects].empty?
response.status = 409
raise(Excon::Errors.status_error({:expects => 204}, response))
else
self.data[:buckets].delete(bucket_name)
response.status = 204
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/copy_object.rb 0000644 0000041 0000041 00000007141 12576636531 023417 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/copy_object'
# Copy an object from one S3 bucket to another
#
# @param source_bucket_name [String] Name of source bucket
# @param source_object_name [String] Name of source object
# @param target_bucket_name [String] Name of bucket to create copy in
# @param target_object_name [String] Name for new copy of object
#
# @param options [Hash]:
# @option options [String] x-amz-metadata-directive Specifies whether to copy metadata from source or replace with data in request. Must be in ['COPY', 'REPLACE']
# @option options [String] x-amz-copy_source-if-match Copies object if its etag matches this value
# @option options [Time] x-amz-copy_source-if-modified_since Copies object it it has been modified since this time
# @option options [String] x-amz-copy_source-if-none-match Copies object if its etag does not match this value
# @option options [Time] x-amz-copy_source-if-unmodified-since Copies object it it has not been modified since this time
# @option options [String] x-amz-storage-class Default is 'STANDARD', set to 'REDUCED_REDUNDANCY' for non-critical, reproducable data
#
#
# @return [Excon::Response]
# * body [Hash]:
# * ETag [String] - etag of new object
# * LastModified [Time] - date object was last modified
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectCOPY.html
#
def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {})
headers = { 'x-amz-copy-source' => "/#{source_bucket_name}#{object_to_path(source_object_name)}" }.merge!(options)
request({
:expects => 200,
:headers => headers,
:bucket_name => target_bucket_name,
:object_name => target_object_name,
:method => 'PUT',
:parser => Fog::Parsers::Storage::AWS::CopyObject.new,
})
end
end
class Mock # :nodoc:all
def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {})
response = Excon::Response.new
source_bucket = self.data[:buckets][source_bucket_name]
source_object = source_bucket && source_bucket[:objects][source_object_name] && source_bucket[:objects][source_object_name].first
target_bucket = self.data[:buckets][target_bucket_name]
acl = options['x-amz-acl'] || 'private'
if !['private', 'public-read', 'public-read-write', 'authenticated-read'].include?(acl)
raise Excon::Errors::BadRequest.new('invalid x-amz-acl')
else
self.data[:acls][:object][target_bucket_name] ||= {}
self.data[:acls][:object][target_bucket_name][target_object_name] = self.class.acls(acl)
end
if source_object && target_bucket
response.status = 200
target_object = source_object.dup
target_object.merge!({'Key' => target_object_name})
target_bucket[:objects][target_object_name] = [target_object]
response.body = {
'ETag' => target_object['ETag'],
'LastModified' => Time.parse(target_object['Last-Modified'])
}
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 200}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_bucket_versioning.rb 0000644 0000041 0000041 00000004074 12576636531 025500 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/get_bucket_versioning'
# Get versioning status for an S3 bucket
#
# @param bucket_name [String] name of bucket to get versioning status for
#
# @return [Excon::Response] response:
# * body [Hash]:
# * VersioningConfiguration [Hash]:
# * Status [String] - Versioning status in ['Enabled', 'Suspended', nil]
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETversioningStatus.html
def get_bucket_versioning(bucket_name)
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:idempotent => true,
:method => 'GET',
:parser => Fog::Parsers::Storage::AWS::GetBucketVersioning.new,
:query => {'versioning' => nil}
})
end
end
class Mock
def get_bucket_versioning(bucket_name)
response = Excon::Response.new
bucket = self.data[:buckets][bucket_name]
if bucket
response.status = 200
if bucket[:versioning]
response.body = { 'VersioningConfiguration' => { 'Status' => bucket[:versioning] } }
else
response.body = { 'VersioningConfiguration' => {} }
end
else
response.status = 404
response.body = {
'Error' => {
'Code' => 'NoSuchBucket',
'Message' => 'The specified bucket does not exist',
'BucketName' => bucket_name,
'RequestId' => Fog::Mock.random_hex(16),
'HostId' => Fog::Mock.random_base64(65)
}
}
raise(Excon::Errors.status_error({:expects => 200}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/get_bucket_object_versions.rb 0000644 0000041 0000041 00000016532 12576636531 026515 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
require 'fog/aws/parsers/storage/get_bucket_object_versions'
# List information about object versions in an S3 bucket
#
# @param bucket_name [String] name of bucket to list object keys from
# @param options [Hash] config arguments for list
# @option options delimiter [String] causes keys with the same string between the prefix value and the first occurence of delimiter to be rolled up
# @option options key-marker [String] limits object keys to only those that appear lexicographically after its value.
# @option options max-keys [Integer] limits number of object keys returned
# @option options prefix [String] limits object keys to those beginning with its value.
# @option options version-id-marker [String] limits object versions to only those that appear lexicographically after its value
#
# @return [Excon::Response] response:
# * body [Hash]:
# * Delimeter [String] - Delimiter specified for query
# * KeyMarker [String] - Key marker specified for query
# * MaxKeys [Integer] - Maximum number of keys specified for query
# * Name [String] - Name of the bucket
# * Prefix [String] - Prefix specified for query
# * VersionIdMarker [String] - Version id marker specified for query
# * IsTruncated [Boolean] - Whether or not this is the totality of the bucket
# * Versions [Array]:
# * DeleteMarker [Hash]:
# * IsLatest [Boolean] - Whether or not this is the latest version
# * Key [String] - Name of object
# * LastModified [String]: Timestamp of last modification of object
# * Owner [Hash]:
# * DisplayName [String] - Display name of object owner
# * ID [String] - Id of object owner
# * VersionId [String] - The id of this version
# or
# * Version [Hash]:
# * ETag [String]: Etag of object
# * IsLatest [Boolean] - Whether or not this is the latest version
# * Key [String] - Name of object
# * LastModified [String]: Timestamp of last modification of object
# * Owner [Hash]:
# * DisplayName [String] - Display name of object owner
# * ID [String] - Id of object owner
# * Size [Integer] - Size of object
# * StorageClass [String] - Storage class of object
# * VersionId [String] - The id of this version
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETVersion.html
def get_bucket_object_versions(bucket_name, options = {})
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
request({
:expects => 200,
:headers => {},
:bucket_name => bucket_name,
:idempotent => true,
:method => 'GET',
:parser => Fog::Parsers::Storage::AWS::GetBucketObjectVersions.new,
:query => {'versions' => nil}.merge!(options) })
end
end
class Mock
def get_bucket_object_versions(bucket_name, options = {})
delimiter, key_marker, max_keys, prefix, version_id_marker = \
options['delimiter'], options['key-marker'], options['max-keys'],options['prefix'],options['version-id-marker']
unless bucket_name
raise ArgumentError.new('bucket_name is required')
end
response = Excon::Response.new
# Invalid arguments.
if version_id_marker && !key_marker
response.status = 400
response.body = {
'Error' => {
'Code' => 'InvalidArgument',
'Message' => 'A version-id marker cannot be specified without a key marker.',
'ArgumentValue' => version_id_marker,
'RequestId' => Fog::Mock.random_hex(16),
'HostId' => Fog::Mock.random_base64(65)
}
}
# Valid case.
# TODO: (nirvdrum 12/15/11) It's not clear to me how to actually use version-id-marker, so I didn't implement it below.
elsif bucket = self.data[:buckets][bucket_name]
# We need to order results by S3 key, but since our data store is key => [versions], we want to ensure the integrity
# of the versions as well. So, sort the keys, then fetch the versions, and then combine them all as a sorted list by
# flattening the results.
contents = bucket[:objects].keys.sort.map { |key| bucket[:objects][key] }.flatten.reject do |object|
(prefix && object['Key'][0...prefix.length] != prefix) ||
(key_marker && object['Key'] <= key_marker) ||
(delimiter && object['Key'][(prefix ? prefix.length : 0)..-1].include?(delimiter) \
&& common_prefixes << object['Key'].sub(/^(#{prefix}[^#{delimiter}]+.).*/, '\1'))
end.map do |object|
if object.key?(:delete_marker)
tag_name = 'DeleteMarker'
extracted_attrs = ['Key', 'VersionId']
else
tag_name = 'Version'
extracted_attrs = ['ETag', 'Key', 'StorageClass', 'VersionId']
end
data = {}
data[tag_name] = object.reject { |key, value| !extracted_attrs.include?(key) }
data[tag_name].merge!({
'LastModified' => Time.parse(object['Last-Modified']),
'Owner' => bucket['Owner'],
'IsLatest' => object == bucket[:objects][object['Key']].first
})
data[tag_name]['Size'] = object['Content-Length'].to_i if tag_name == 'Version'
data
end
max_keys = max_keys || 1000
size = [max_keys, 1000].min
truncated_contents = contents[0...size]
response.status = 200
response.body = {
'Versions' => truncated_contents,
'IsTruncated' => truncated_contents.size != contents.size,
'KeyMarker' => key_marker,
'VersionIdMarker' => version_id_marker,
'MaxKeys' => max_keys,
'Name' => bucket['Name'],
'Prefix' => prefix
}
if max_keys && max_keys < response.body['Versions'].length
response.body['IsTruncated'] = true
response.body['Versions'] = response.body['Versions'][0...max_keys]
end
# Missing bucket case.
else
response.status = 404
response.body = {
'Error' => {
'Code' => 'NoSuchBucket',
'Message' => 'The specified bucket does not exist',
'BucketName' => bucket_name,
'RequestId' => Fog::Mock.random_hex(16),
'HostId' => Fog::Mock.random_base64(65)
}
}
raise(Excon::Errors.status_error({:expects => 200}, response))
end
response
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/post_object_restore.rb 0000644 0000041 0000041 00000003614 12576636531 025176 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Restore an object from Glacier to its original S3 path
#
# @param bucket_name [String] Name of bucket containing object
# @param object_name [String] Name of object to restore
# @option days [Integer] Number of days to restore object for. Defaults to 100000 (a very long time)
#
# @return [Excon::Response] response:
# * status [Integer] 200 (OK) Object is previously restored
# * status [Integer] 202 (Accepted) Object is not previously restored
# * status [Integer] 409 (Conflict) Restore is already in progress
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectPOSTrestore.html
#
def post_object_restore(bucket_name, object_name, days = 100000)
raise ArgumentError.new('bucket_name is required') unless bucket_name
raise ArgumentError.new('object_name is required') unless object_name
data = '' + days.to_s + ' ] parts Array of etags as Strings for parts
#
# @return [Excon::Response]
# * body [Hash]: (success)
# * Bucket [String] - bucket of new object
# * ETag [String] - etag of new object
# * Key [String] - key of new object
# * Location [String] - location of new object
# * body [Hash]: (failure)
# * Code [String] - Error status code
# * Message [String] - Error description
#
# @note This request could fail and still return +200 OK+, so it's important that you check the response.
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadComplete.html
#
def complete_multipart_upload(bucket_name, object_name, upload_id, parts)
data = ""
parts.each_with_index do |part, index|
data << ""
data << "#{index + 1} "
data << "#{part} "
data << " "
end
data << " "
request({
:body => data,
:expects => 200,
:headers => { 'Content-Length' => data.length },
:bucket_name => bucket_name,
:object_name => object_name,
:method => 'POST',
:parser => Fog::Parsers::Storage::AWS::CompleteMultipartUpload.new,
:query => {'uploadId' => upload_id}
})
end
end # Real
class Mock # :nodoc:all
require 'fog/aws/requests/storage/shared_mock_methods'
include Fog::Storage::AWS::SharedMockMethods
def complete_multipart_upload(bucket_name, object_name, upload_id, parts)
bucket = verify_mock_bucket_exists(bucket_name)
upload_info = get_upload_info(bucket_name, upload_id, true)
body = parts.map { |pid| upload_info[:parts][pid.to_i] }.join
object = store_mock_object(bucket, object_name, body, upload_info[:options])
response = Excon::Response.new
response.status = 200
response.body = {
'Location' => "http://#{bucket_name}.s3.amazonaws.com/#{object_name}",
'Bucket' => bucket_name,
'Key' => object_name,
'ETag' => object['ETag'],
}
response.headers['x-amz-version-id'] = object['VersionId'] if object['VersionId'] != 'null'
response
end
end # Mock
end # Storage
end # AWS
end # Fog
fog-aws-0.7.6/lib/fog/aws/requests/storage/delete_object.rb 0000644 0000041 0000041 00000010210 12576636531 023676 0 ustar www-data www-data module Fog
module Storage
class AWS
class Real
# Delete an object from S3
#
# @param bucket_name [String] Name of bucket containing object to delete
# @param object_name [String] Name of object to delete
#
# @return [Excon::Response] response:
# * status [Integer] - 204
#
# @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectDELETE.html
def delete_object(bucket_name, object_name, options = {})
if version_id = options.delete('versionId')
query = {'versionId' => version_id}
else
query = {}
end
headers = options
request({
:expects => 204,
:headers => headers,
:bucket_name => bucket_name,
:object_name => object_name,
:idempotent => true,
:method => 'DELETE',
:query => query
})
end
end
class Mock # :nodoc:all
def delete_object(bucket_name, object_name, options = {})
response = Excon::Response.new
if bucket = self.data[:buckets][bucket_name]
response.status = 204
version_id = options.delete('versionId')
if bucket[:versioning]
bucket[:objects][object_name] ||= []
if version_id
version = bucket[:objects][object_name].find { |object| object['VersionId'] == version_id}
# S3 special cases the 'null' value to not error out if no such version exists.
if version || (version_id == 'null')
bucket[:objects][object_name].delete(version)
bucket[:objects].delete(object_name) if bucket[:objects][object_name].empty?
response.headers['x-amz-delete-marker'] = 'true' if version[:delete_marker]
response.headers['x-amz-version-id'] = version_id
else
response.status = 400
response.body = invalid_version_id_payload(version_id)
raise(Excon::Errors.status_error({:expects => 200}, response))
end
else
delete_marker = {
:delete_marker => true,
'Key' => object_name,
'VersionId' => bucket[:versioning] == 'Enabled' ? Fog::Mock.random_base64(32) : 'null',
'Last-Modified' => Fog::Time.now.to_date_header
}
# When versioning is suspended, a delete marker is placed if the last object ID is not the value 'null',
# otherwise the last object is replaced.
if bucket[:versioning] == 'Suspended' && bucket[:objects][object_name].first['VersionId'] == 'null'
bucket[:objects][object_name].shift
end
bucket[:objects][object_name].unshift(delete_marker)
response.headers['x-amz-delete-marker'] = 'true'
response.headers['x-amz-version-id'] = delete_marker['VersionId']
end
else
if version_id && version_id != 'null'
response.status = 400
response.body = invalid_version_id_payload(version_id)
raise(Excon::Errors.status_error({:expects => 200}, response))
else
bucket[:objects].delete(object_name)
response.headers['x-amz-version-id'] = 'null'
end
end
else
response.status = 404
raise(Excon::Errors.status_error({:expects => 204}, response))
end
response
end
private
def invalid_version_id_payload(version_id)
{
'Error' => {
'Code' => 'InvalidArgument',
'Message' => 'Invalid version id specified',
'ArgumentValue' => version_id,
'ArgumentName' => 'versionId',
'RequestId' => Fog::Mock.random_hex(16),
'HostId' => Fog::Mock.random_base64(65)
}
}
end
end
end
end
end
fog-aws-0.7.6/lib/fog/aws/requests/storage/post_object_hidden_fields.rb 0000644 0000041 0000041 00000005640 12576636531 026275 0 ustar www-data www-data module Fog
module Storage
class AWS
module PostObjectHiddenFields
# Get a hash of hidden fields for form uploading to S3, in the form {:field_name => :field_value}
# Form should look like: