aws-sdk-ecs 1.0.0.rc1 → 1.0.0.rc2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. checksums.yaml +4 -4
  2. data/lib/aws-sdk-ecs.rb +1 -1
  3. data/lib/aws-sdk-ecs/client.rb +3074 -2386
  4. data/lib/aws-sdk-ecs/client_api.rb +1127 -995
  5. data/lib/aws-sdk-ecs/errors.rb +4 -13
  6. data/lib/aws-sdk-ecs/resource.rb +12 -14
  7. data/lib/aws-sdk-ecs/types.rb +4003 -3355
  8. data/lib/aws-sdk-ecs/waiters.rb +173 -174
  9. metadata +2 -2
data/lib/aws-sdk-ecs/waiters.rb CHANGED
@@ -1,200 +1,199 @@
1
1
  # WARNING ABOUT GENERATED CODE
2
2
  #
3
- # This file is generated. See the contributing for info on making contributions:
3
+ # This file is generated. See the contributing guide for more information:
4
4
  # https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
5
5
  #
6
6
  # WARNING ABOUT GENERATED CODE
7
7
 
8
8
  require 'aws-sdk-core/waiters'
9
9
 
10
- module Aws
11
- module ECS
12
- module Waiters
13
- class TasksRunning
14
-
15
- # @param [Hash] options
16
- # @option options [required, Client] :client
17
- # @option options [Integer] :max_attempts (100)
18
- # @option options [Integer] :delay (6)
19
- # @option options [Proc] :before_attempt
20
- # @option options [Proc] :before_wait
21
- def initialize(options)
22
- @client = options.fetch(:client)
23
- @waiter = Aws::Waiters::Waiter.new({
24
- max_attempts: 100,
25
- delay: 6,
26
- poller: Aws::Waiters::Poller.new(
27
- operation_name: :describe_tasks,
28
- acceptors: [
29
- {
30
- "expected" => "STOPPED",
31
- "matcher" => "pathAny",
32
- "state" => "failure",
33
- "argument" => "tasks[].last_status"
34
- },
35
- {
36
- "expected" => "MISSING",
37
- "matcher" => "pathAny",
38
- "state" => "failure",
39
- "argument" => "failures[].reason"
40
- },
41
- {
42
- "expected" => "RUNNING",
43
- "matcher" => "pathAll",
44
- "state" => "success",
45
- "argument" => "tasks[].last_status"
46
- }
47
- ]
48
- )
49
- }.merge(options))
50
- end
51
-
52
- # @option (see Client#describe_tasks)
53
- # @return (see Client#describe_tasks)
54
- def wait(params = {})
55
- @waiter.wait(client: @client, params: params)
56
- end
57
-
58
- # @api private
59
- attr_reader :waiter
10
+ module Aws::ECS
11
+ module Waiters
12
+
13
+ class ServicesInactive
14
+
15
+ # @param [Hash] options
16
+ # @option options [required, Client] :client
17
+ # @option options [Integer] :max_attempts (40)
18
+ # @option options [Integer] :delay (15)
19
+ # @option options [Proc] :before_attempt
20
+ # @option options [Proc] :before_wait
21
+ def initialize(options)
22
+ @client = options.fetch(:client)
23
+ @waiter = Aws::Waiters::Waiter.new({
24
+ max_attempts: 40,
25
+ delay: 15,
26
+ poller: Aws::Waiters::Poller.new(
27
+ operation_name: :describe_services,
28
+ acceptors: [
29
+ {
30
+ "expected" => "MISSING",
31
+ "matcher" => "pathAny",
32
+ "state" => "failure",
33
+ "argument" => "failures[].reason"
34
+ },
35
+ {
36
+ "expected" => "INACTIVE",
37
+ "matcher" => "pathAny",
38
+ "state" => "success",
39
+ "argument" => "services[].status"
40
+ }
41
+ ]
42
+ )
43
+ }.merge(options))
44
+ end
45
+
46
+ # @option (see Client#describe_services)
47
+ # @return (see Client#describe_services)
48
+ def wait(params = {})
49
+ @waiter.wait(client: @client, params: params)
50
+ end
51
+
52
+ # @api private
53
+ attr_reader :waiter
54
+
55
+ end
56
+
57
+ class ServicesStable
58
+
59
+ # @param [Hash] options
60
+ # @option options [required, Client] :client
61
+ # @option options [Integer] :max_attempts (40)
62
+ # @option options [Integer] :delay (15)
63
+ # @option options [Proc] :before_attempt
64
+ # @option options [Proc] :before_wait
65
+ def initialize(options)
66
+ @client = options.fetch(:client)
67
+ @waiter = Aws::Waiters::Waiter.new({
68
+ max_attempts: 40,
69
+ delay: 15,
70
+ poller: Aws::Waiters::Poller.new(
71
+ operation_name: :describe_services,
72
+ acceptors: [
73
+ {
74
+ "expected" => "MISSING",
75
+ "matcher" => "pathAny",
76
+ "state" => "failure",
77
+ "argument" => "failures[].reason"
78
+ },
79
+ {
80
+ "expected" => "DRAINING",
81
+ "matcher" => "pathAny",
82
+ "state" => "failure",
83
+ "argument" => "services[].status"
84
+ },
85
+ {
86
+ "expected" => "INACTIVE",
87
+ "matcher" => "pathAny",
88
+ "state" => "failure",
89
+ "argument" => "services[].status"
90
+ },
91
+ {
92
+ "expected" => true,
93
+ "matcher" => "path",
94
+ "state" => "success",
95
+ "argument" => "length(services[?!(length(deployments) == `1` && running_count == desired_count)]) == `0`"
96
+ }
97
+ ]
98
+ )
99
+ }.merge(options))
100
+ end
60
101
 
102
+ # @option (see Client#describe_services)
103
+ # @return (see Client#describe_services)
104
+ def wait(params = {})
105
+ @waiter.wait(client: @client, params: params)
61
106
  end
62
107
 
63
- class TasksStopped
64
-
65
- # @param [Hash] options
66
- # @option options [required, Client] :client
67
- # @option options [Integer] :max_attempts (100)
68
- # @option options [Integer] :delay (6)
69
- # @option options [Proc] :before_attempt
70
- # @option options [Proc] :before_wait
71
- def initialize(options)
72
- @client = options.fetch(:client)
73
- @waiter = Aws::Waiters::Waiter.new({
74
- max_attempts: 100,
75
- delay: 6,
76
- poller: Aws::Waiters::Poller.new(
77
- operation_name: :describe_tasks,
78
- acceptors: [{
108
+ # @api private
109
+ attr_reader :waiter
110
+
111
+ end
112
+
113
+ class TasksRunning
114
+
115
+ # @param [Hash] options
116
+ # @option options [required, Client] :client
117
+ # @option options [Integer] :max_attempts (100)
118
+ # @option options [Integer] :delay (6)
119
+ # @option options [Proc] :before_attempt
120
+ # @option options [Proc] :before_wait
121
+ def initialize(options)
122
+ @client = options.fetch(:client)
123
+ @waiter = Aws::Waiters::Waiter.new({
124
+ max_attempts: 100,
125
+ delay: 6,
126
+ poller: Aws::Waiters::Poller.new(
127
+ operation_name: :describe_tasks,
128
+ acceptors: [
129
+ {
79
130
  "expected" => "STOPPED",
131
+ "matcher" => "pathAny",
132
+ "state" => "failure",
133
+ "argument" => "tasks[].last_status"
134
+ },
135
+ {
136
+ "expected" => "MISSING",
137
+ "matcher" => "pathAny",
138
+ "state" => "failure",
139
+ "argument" => "failures[].reason"
140
+ },
141
+ {
142
+ "expected" => "RUNNING",
80
143
  "matcher" => "pathAll",
81
144
  "state" => "success",
82
145
  "argument" => "tasks[].last_status"
83
- }]
84
- )
85
- }.merge(options))
86
- end
146
+ }
147
+ ]
148
+ )
149
+ }.merge(options))
150
+ end
87
151
 
88
- # @option (see Client#describe_tasks)
89
- # @return (see Client#describe_tasks)
90
- def wait(params = {})
91
- @waiter.wait(client: @client, params: params)
92
- end
152
+ # @option (see Client#describe_tasks)
153
+ # @return (see Client#describe_tasks)
154
+ def wait(params = {})
155
+ @waiter.wait(client: @client, params: params)
156
+ end
93
157
 
94
- # @api private
95
- attr_reader :waiter
158
+ # @api private
159
+ attr_reader :waiter
96
160
 
97
- end
161
+ end
98
162
 
99
- class ServicesStable
100
-
101
- # @param [Hash] options
102
- # @option options [required, Client] :client
103
- # @option options [Integer] :max_attempts (40)
104
- # @option options [Integer] :delay (15)
105
- # @option options [Proc] :before_attempt
106
- # @option options [Proc] :before_wait
107
- def initialize(options)
108
- @client = options.fetch(:client)
109
- @waiter = Aws::Waiters::Waiter.new({
110
- max_attempts: 40,
111
- delay: 15,
112
- poller: Aws::Waiters::Poller.new(
113
- operation_name: :describe_services,
114
- acceptors: [
115
- {
116
- "expected" => "MISSING",
117
- "matcher" => "pathAny",
118
- "state" => "failure",
119
- "argument" => "failures[].reason"
120
- },
121
- {
122
- "expected" => "DRAINING",
123
- "matcher" => "pathAny",
124
- "state" => "failure",
125
- "argument" => "services[].status"
126
- },
127
- {
128
- "expected" => "INACTIVE",
129
- "matcher" => "pathAny",
130
- "state" => "failure",
131
- "argument" => "services[].status"
132
- },
133
- {
134
- "expected" => true,
135
- "matcher" => "path",
136
- "state" => "success",
137
- "argument" => "length(services[?!(length(deployments) == `1` && running_count == desired_count)]) == `0`"
138
- }
139
- ]
140
- )
141
- }.merge(options))
142
- end
143
-
144
- # @option (see Client#describe_services)
145
- # @return (see Client#describe_services)
146
- def wait(params = {})
147
- @waiter.wait(client: @client, params: params)
148
- end
149
-
150
- # @api private
151
- attr_reader :waiter
163
+ class TasksStopped
164
+
165
+ # @param [Hash] options
166
+ # @option options [required, Client] :client
167
+ # @option options [Integer] :max_attempts (100)
168
+ # @option options [Integer] :delay (6)
169
+ # @option options [Proc] :before_attempt
170
+ # @option options [Proc] :before_wait
171
+ def initialize(options)
172
+ @client = options.fetch(:client)
173
+ @waiter = Aws::Waiters::Waiter.new({
174
+ max_attempts: 100,
175
+ delay: 6,
176
+ poller: Aws::Waiters::Poller.new(
177
+ operation_name: :describe_tasks,
178
+ acceptors: [{
179
+ "expected" => "STOPPED",
180
+ "matcher" => "pathAll",
181
+ "state" => "success",
182
+ "argument" => "tasks[].last_status"
183
+ }]
184
+ )
185
+ }.merge(options))
186
+ end
152
187
 
188
+ # @option (see Client#describe_tasks)
189
+ # @return (see Client#describe_tasks)
190
+ def wait(params = {})
191
+ @waiter.wait(client: @client, params: params)
153
192
  end
154
193
 
155
- class ServicesInactive
156
-
157
- # @param [Hash] options
158
- # @option options [required, Client] :client
159
- # @option options [Integer] :max_attempts (40)
160
- # @option options [Integer] :delay (15)
161
- # @option options [Proc] :before_attempt
162
- # @option options [Proc] :before_wait
163
- def initialize(options)
164
- @client = options.fetch(:client)
165
- @waiter = Aws::Waiters::Waiter.new({
166
- max_attempts: 40,
167
- delay: 15,
168
- poller: Aws::Waiters::Poller.new(
169
- operation_name: :describe_services,
170
- acceptors: [
171
- {
172
- "expected" => "MISSING",
173
- "matcher" => "pathAny",
174
- "state" => "failure",
175
- "argument" => "failures[].reason"
176
- },
177
- {
178
- "expected" => "INACTIVE",
179
- "matcher" => "pathAny",
180
- "state" => "success",
181
- "argument" => "services[].status"
182
- }
183
- ]
184
- )
185
- }.merge(options))
186
- end
187
-
188
- # @option (see Client#describe_services)
189
- # @return (see Client#describe_services)
190
- def wait(params = {})
191
- @waiter.wait(client: @client, params: params)
192
- end
193
-
194
- # @api private
195
- attr_reader :waiter
194
+ # @api private
195
+ attr_reader :waiter
196
196
 
197
- end
198
197
  end
199
198
  end
200
199
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: aws-sdk-ecs
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.0.0.rc1
4
+ version: 1.0.0.rc2
5
5
  platform: ruby
6
6
  authors:
7
7
  - Amazon Web Services
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2016-12-05 00:00:00.000000000 Z
11
+ date: 2017-01-24 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: aws-sdk-core