Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / google-api-python-client / 7d5badbac4f925c1867e20b50cf0a1a70a5fb573 / . / docs / dyn / runtimeconfig_v1beta1.projects.configs.waiters.html
blob: b9c212fc63ce4e99147006d7210bc7ba336a1839 [file] [log] [blame]
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]1<html><body>
2<style>
3
4body, h1, h2, h3, div, span, p, pre, a {
5 margin: 0;
6 padding: 0;
7 border: 0;
8 font-weight: inherit;
9 font-style: inherit;
10 font-size: 100%;
11 font-family: inherit;
12 vertical-align: baseline;
13}
14
15body {
16 font-size: 13px;
17 padding: 1em;
18}
19
20h1 {
21 font-size: 26px;
22 margin-bottom: 1em;
23}
24
25h2 {
26 font-size: 24px;
27 margin-bottom: 1em;
28}
29
30h3 {
31 font-size: 20px;
32 margin-bottom: 1em;
33 margin-top: 1em;
34}
35
36pre, code {
37 line-height: 1.5;
38 font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
39}
40
41pre {
42 margin-top: 0.5em;
43}
44
45h1, h2, h3, p {
46 font-family: Arial, sans serif;
47}
48
49h1, h2, h3 {
50 border-bottom: solid #CCC 1px;
51}
52
53.toc_element {
54 margin-top: 0.5em;
55}
56
57.firstline {
58 margin-left: 2 em;
59}
60
61.method {
62 margin-top: 1em;
63 border: solid 1px #CCC;
64 padding: 1em;
65 background: #EEE;
66}
67
68.details {
69 font-weight: bold;
70 font-size: 14px;
71}
72
73</style>
74
75<h1><a href="runtimeconfig_v1beta1.html">Google Cloud RuntimeConfig API</a> . <a href="runtimeconfig_v1beta1.projects.html">projects</a> . <a href="runtimeconfig_v1beta1.projects.configs.html">configs</a> . <a href="runtimeconfig_v1beta1.projects.configs.waiters.html">waiters</a></h1>
76<h2>Instance Methods</h2>
77<p class="toc_element">
78 <code><a href="#create">create(parent=None, body, x__xgafv=None)</a></code></p>
79<p class="firstline">Creates a Waiter resource. This operation returns a long-running Operation</p>
80<p class="toc_element">
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]81 <code><a href="#delete">delete(name=None, x__xgafv=None)</a></code></p>
82<p class="firstline">Deletes the waiter with the specified name.</p>
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]83<p class="toc_element">
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]84 <code><a href="#get">get(name=None, x__xgafv=None)</a></code></p>
85<p class="firstline">Gets information about a single waiter.</p>
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]86<p class="toc_element">
87 <code><a href="#list">list(parent=None, pageToken=None, x__xgafv=None, pageSize=None)</a></code></p>
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]88<p class="firstline">List waiters within the given configuration.</p>
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]89<p class="toc_element">
90 <code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p>
91<p class="firstline">Retrieves the next page of results.</p>
92<h3>Method Details</h3>
93<div class="method">
94 <code class="details" id="create">create(parent=None, body, x__xgafv=None)</code>
95 <pre>Creates a Waiter resource. This operation returns a long-running Operation
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]96resource which can be polled for completion. However, a waiter with the
97given name will exist (and can be retrieved) prior to the operation
98completing. If the operation fails, the failed Waiter resource will
99still exist and must be deleted prior to subsequent creation attempts.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]100
101Args:
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]102 parent: string, The path to the configuration that will own the waiter.
103The configuration must exist beforehand; the path must by in the format:
104
105`projects/[PROJECT_ID]/configs/[CONFIG_NAME]`. (required)
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]106 body: object, The request body. (required)
107 The object takes the form of:
108
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]109{ # A Waiter resource waits for some end condition within a RuntimeConfig resource
110 # to be met before it returns. For example, assume you have a distributed
111 # system where each node writes to a Variable resource indidicating the node's
112 # readiness as part of the startup process.
113 #
114 # You then configure a Waiter resource with the success condition set to wait
115 # until some number of nodes have checked in. Afterwards, your application
116 # runs some arbitrary code after the condition has been met and the waiter
117 # returns successfully.
118 #
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]119 # Once created, a Waiter resource is immutable.
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]120 #
121 # To learn more about using waiters, read the
122 # [Creating a Waiter](/deployment-manager/runtime-configurator/creating-a-waiter)
123 # documentation.
124 "name": "A String", # The name of the Waiter resource, in the format:
125 #
126 # projects/[PROJECT_ID]/configs/[CONFIG_NAME]/waiters/[WAITER_NAME]
127 #
128 # The `[PROJECT_ID]` must be a valid Google Cloud project ID,
129 # the `[CONFIG_NAME]` must be a valid RuntimeConfig resource, the
130 # `[WAITER_NAME]` must match RFC 1035 segment specification, and the length
131 # of `[WAITER_NAME]` must be less than 64 bytes.
132 #
133 # After you create a Waiter resource, you cannot change the resource name.
134 "success": { # The condition that a Waiter resource is waiting for. # [Required] The success condition. If this condition is met, `done` will be
135 # set to `true` and the `error` value will remain unset. The failure condition
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]136 # takes precedence over the success condition. If both conditions are met, a
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]137 # failure will be indicated.
138 "cardinality": { # A Cardinality condition for the Waiter resource. A cardinality condition is # The cardinality of the `EndCondition`.
139 # met when the number of variables under a specified path prefix reaches a
140 # predefined number. For example, if you set a Cardinality condition where
141 # the `path` is set to `/foo` and the number of paths is set to 2, the
142 # following variables would meet the condition in a RuntimeConfig resource:
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]143 #
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]144 # + `/foo/variable1 = "value1"`
145 # + `/foo/variable2 = "value2"`
146 # + `/bar/variable3 = "value3"`
147 #
148 # It would not would not satisify the same condition with the `number` set to
149 # 3, however, because there is only 2 paths that start with `/foo`.
150 # Cardinality conditions are recursive; all subtrees under the specific
151 # path prefix are counted.
152 "path": "A String", # The root of the variable subtree to monitor. For example, `/foo`.
153 "number": 42, # The number variables under the `path` that must exist to meet this
154 # condition. Defaults to 1 if not specified.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]155 },
156 },
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]157 "failure": { # The condition that a Waiter resource is waiting for. # [Optional] The failure condition of this waiter. If this condition is met,
158 # `done` will be set to `true` and the `error` code will be set to `ABORTED`.
159 # The failure condition takes precedence over the success condition. If both
160 # conditions are met, a failure will be indicated. This value is optional; if
161 # no failure condition is set, the only failure scenario will be a timeout.
162 "cardinality": { # A Cardinality condition for the Waiter resource. A cardinality condition is # The cardinality of the `EndCondition`.
163 # met when the number of variables under a specified path prefix reaches a
164 # predefined number. For example, if you set a Cardinality condition where
165 # the `path` is set to `/foo` and the number of paths is set to 2, the
166 # following variables would meet the condition in a RuntimeConfig resource:
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]167 #
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]168 # + `/foo/variable1 = "value1"`
169 # + `/foo/variable2 = "value2"`
170 # + `/bar/variable3 = "value3"`
171 #
172 # It would not would not satisify the same condition with the `number` set to
173 # 3, however, because there is only 2 paths that start with `/foo`.
174 # Cardinality conditions are recursive; all subtrees under the specific
175 # path prefix are counted.
176 "path": "A String", # The root of the variable subtree to monitor. For example, `/foo`.
177 "number": 42, # The number variables under the `path` that must exist to meet this
178 # condition. Defaults to 1 if not specified.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]179 },
180 },
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]181 "done": True or False, # [Output Only] If the value is `false`, it means the waiter is still waiting
182 # for one of its conditions to be met.
183 #
184 # If true, the waiter has finished. If the waiter finished due to a timeout
185 # or failure, `error` will be set.
186 "timeout": "A String", # [Required] Specifies the timeout of the waiter in seconds, beginning from
187 # the instant that `waiters().create` method is called. If this time elapses
188 # before the success or failure conditions are met, the waiter fails and sets
189 # the `error` code to `DEADLINE_EXCEEDED`.
190 "error": { # The `Status` type defines a logical error model that is suitable for different # [Output Only] If the waiter ended due to a failure or timeout, this value
191 # will be set.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]192 # programming environments, including REST APIs and RPC APIs. It is used by
193 # [gRPC](https://github.com/grpc). The error model is designed to be:
194 #
195 # - Simple to use and understand for most users
196 # - Flexible enough to meet unexpected needs
197 #
198 # # Overview
199 #
200 # The `Status` message contains three pieces of data: error code, error message,
201 # and error details. The error code should be an enum value of
202 # google.rpc.Code, but it may accept additional error codes if needed. The
203 # error message should be a developer-facing English message that helps
204 # developers *understand* and *resolve* the error. If a localized user-facing
205 # error message is needed, put the localized message in the error details or
206 # localize it in the client. The optional error details may contain arbitrary
207 # information about the error. There is a predefined set of error detail types
208 # in the package `google.rpc` which can be used for common error conditions.
209 #
210 # # Language mapping
211 #
212 # The `Status` message is the logical representation of the error model, but it
213 # is not necessarily the actual wire format. When the `Status` message is
214 # exposed in different client libraries and different wire protocols, it can be
215 # mapped differently. For example, it will likely be mapped to some exceptions
216 # in Java, but more likely mapped to some error codes in C.
217 #
218 # # Other uses
219 #
220 # The error model and the `Status` message can be used in a variety of
221 # environments, either with or without APIs, to provide a
222 # consistent developer experience across different environments.
223 #
224 # Example uses of this error model include:
225 #
226 # - Partial errors. If a service needs to return partial errors to the client,
227 # it may embed the `Status` in the normal response to indicate the partial
228 # errors.
229 #
230 # - Workflow errors. A typical workflow has multiple steps. Each step may
231 # have a `Status` message for error reporting purpose.
232 #
233 # - Batch operations. If a client uses batch request and batch response, the
234 # `Status` message should be used directly inside batch response, one for
235 # each error sub-response.
236 #
237 # - Asynchronous operations. If an API call embeds asynchronous operation
238 # results in its response, the status of those operations should be
239 # represented directly using the `Status` message.
240 #
241 # - Logging. If some API errors are stored in logs, the message `Status` could
242 # be used directly after any stripping needed for security/privacy reasons.
243 "message": "A String", # A developer-facing error message, which should be in English. Any
244 # user-facing error message should be localized and sent in the
245 # google.rpc.Status.details field, or localized by the client.
246 "code": 42, # The status code, which should be an enum value of google.rpc.Code.
247 "details": [ # A list of messages that carry the error details. There will be a
248 # common set of message types for APIs to use.
249 {
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]250 "a_key": "", # Properties of the object. Contains field @type with type URL.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]251 },
252 ],
253 },
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]254 "createTime": "A String", # [Output Only] The instant at which this Waiter resource was created. Adding
255 # the value of `timeout` to this instant yields the timeout deadline for the
256 # waiter.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]257 }
258
259 x__xgafv: string, V1 error format.
260 Allowed values
261 1 - v1 error format
262 2 - v2 error format
263
264Returns:
265 An object of the form:
266
267 { # This resource represents a long-running operation that is the result of a
268 # network API call.
269 "metadata": { # Service-specific metadata associated with the operation. It typically
270 # contains progress information and common metadata such as create time.
271 # Some services might not provide such metadata. Any method that returns a
272 # long-running operation should document the metadata type, if any.
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]273 "a_key": "", # Properties of the object. Contains field @type with type URL.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]274 },
275 "done": True or False, # If the value is `false`, it means the operation is still in progress.
276 # If true, the operation is completed, and either `error` or `response` is
277 # available.
278 "response": { # The normal response of the operation in case of success. If the original
279 # method returns no data on success, such as `Delete`, the response is
280 # `google.protobuf.Empty`. If the original method is standard
281 # `Get`/`Create`/`Update`, the response should be the resource. For other
282 # methods, the response should have the type `XxxResponse`, where `Xxx`
283 # is the original method name. For example, if the original method name
284 # is `TakeSnapshot()`, the inferred response type is
285 # `TakeSnapshotResponse`.
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]286 "a_key": "", # Properties of the object. Contains field @type with type URL.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]287 },
288 "name": "A String", # The server-assigned name, which is only unique within the same service that
289 # originally returns it. If you use the default HTTP mapping, the
290 # `name` should have the format of `operations/some/unique/name`.
291 "error": { # The `Status` type defines a logical error model that is suitable for different # The error result of the operation in case of failure.
292 # programming environments, including REST APIs and RPC APIs. It is used by
293 # [gRPC](https://github.com/grpc). The error model is designed to be:
294 #
295 # - Simple to use and understand for most users
296 # - Flexible enough to meet unexpected needs
297 #
298 # # Overview
299 #
300 # The `Status` message contains three pieces of data: error code, error message,
301 # and error details. The error code should be an enum value of
302 # google.rpc.Code, but it may accept additional error codes if needed. The
303 # error message should be a developer-facing English message that helps
304 # developers *understand* and *resolve* the error. If a localized user-facing
305 # error message is needed, put the localized message in the error details or
306 # localize it in the client. The optional error details may contain arbitrary
307 # information about the error. There is a predefined set of error detail types
308 # in the package `google.rpc` which can be used for common error conditions.
309 #
310 # # Language mapping
311 #
312 # The `Status` message is the logical representation of the error model, but it
313 # is not necessarily the actual wire format. When the `Status` message is
314 # exposed in different client libraries and different wire protocols, it can be
315 # mapped differently. For example, it will likely be mapped to some exceptions
316 # in Java, but more likely mapped to some error codes in C.
317 #
318 # # Other uses
319 #
320 # The error model and the `Status` message can be used in a variety of
321 # environments, either with or without APIs, to provide a
322 # consistent developer experience across different environments.
323 #
324 # Example uses of this error model include:
325 #
326 # - Partial errors. If a service needs to return partial errors to the client,
327 # it may embed the `Status` in the normal response to indicate the partial
328 # errors.
329 #
330 # - Workflow errors. A typical workflow has multiple steps. Each step may
331 # have a `Status` message for error reporting purpose.
332 #
333 # - Batch operations. If a client uses batch request and batch response, the
334 # `Status` message should be used directly inside batch response, one for
335 # each error sub-response.
336 #
337 # - Asynchronous operations. If an API call embeds asynchronous operation
338 # results in its response, the status of those operations should be
339 # represented directly using the `Status` message.
340 #
341 # - Logging. If some API errors are stored in logs, the message `Status` could
342 # be used directly after any stripping needed for security/privacy reasons.
343 "message": "A String", # A developer-facing error message, which should be in English. Any
344 # user-facing error message should be localized and sent in the
345 # google.rpc.Status.details field, or localized by the client.
346 "code": 42, # The status code, which should be an enum value of google.rpc.Code.
347 "details": [ # A list of messages that carry the error details. There will be a
348 # common set of message types for APIs to use.
349 {
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]350 "a_key": "", # Properties of the object. Contains field @type with type URL.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]351 },
352 ],
353 },
354 }</pre>
355</div>
356
357<div class="method">
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]358 <code class="details" id="delete">delete(name=None, x__xgafv=None)</code>
359 <pre>Deletes the waiter with the specified name.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]360
361Args:
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]362 name: string, The Waiter resource to delete, in the format:
363
364 `projects/[PROJECT_ID]/configs/[CONFIG_NAME]/waiters/[WAITER_NAME]` (required)
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]365 x__xgafv: string, V1 error format.
366 Allowed values
367 1 - v1 error format
368 2 - v2 error format
369
370Returns:
371 An object of the form:
372
373 { # A generic empty message that you can re-use to avoid defining duplicated
374 # empty messages in your APIs. A typical example is to use it as the request
375 # or the response type of an API method. For instance:
376 #
377 # service Foo {
378 # rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
379 # }
380 #
381 # The JSON representation for `Empty` is empty JSON object `{}`.
382 }</pre>
383</div>
384
385<div class="method">
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]386 <code class="details" id="get">get(name=None, x__xgafv=None)</code>
387 <pre>Gets information about a single waiter.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]388
389Args:
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]390 name: string, The fully-qualified name of the Waiter resource object to retrieve, in the
391format:
392
393`projects/[PROJECT_ID]/configs/[CONFIG_NAME]/waiters/[WAITER_NAME]` (required)
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]394 x__xgafv: string, V1 error format.
395 Allowed values
396 1 - v1 error format
397 2 - v2 error format
398
399Returns:
400 An object of the form:
401
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]402 { # A Waiter resource waits for some end condition within a RuntimeConfig resource
403 # to be met before it returns. For example, assume you have a distributed
404 # system where each node writes to a Variable resource indidicating the node's
405 # readiness as part of the startup process.
406 #
407 # You then configure a Waiter resource with the success condition set to wait
408 # until some number of nodes have checked in. Afterwards, your application
409 # runs some arbitrary code after the condition has been met and the waiter
410 # returns successfully.
411 #
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]412 # Once created, a Waiter resource is immutable.
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]413 #
414 # To learn more about using waiters, read the
415 # [Creating a Waiter](/deployment-manager/runtime-configurator/creating-a-waiter)
416 # documentation.
417 "name": "A String", # The name of the Waiter resource, in the format:
418 #
419 # projects/[PROJECT_ID]/configs/[CONFIG_NAME]/waiters/[WAITER_NAME]
420 #
421 # The `[PROJECT_ID]` must be a valid Google Cloud project ID,
422 # the `[CONFIG_NAME]` must be a valid RuntimeConfig resource, the
423 # `[WAITER_NAME]` must match RFC 1035 segment specification, and the length
424 # of `[WAITER_NAME]` must be less than 64 bytes.
425 #
426 # After you create a Waiter resource, you cannot change the resource name.
427 "success": { # The condition that a Waiter resource is waiting for. # [Required] The success condition. If this condition is met, `done` will be
428 # set to `true` and the `error` value will remain unset. The failure condition
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]429 # takes precedence over the success condition. If both conditions are met, a
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]430 # failure will be indicated.
431 "cardinality": { # A Cardinality condition for the Waiter resource. A cardinality condition is # The cardinality of the `EndCondition`.
432 # met when the number of variables under a specified path prefix reaches a
433 # predefined number. For example, if you set a Cardinality condition where
434 # the `path` is set to `/foo` and the number of paths is set to 2, the
435 # following variables would meet the condition in a RuntimeConfig resource:
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]436 #
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]437 # + `/foo/variable1 = "value1"`
438 # + `/foo/variable2 = "value2"`
439 # + `/bar/variable3 = "value3"`
440 #
441 # It would not would not satisify the same condition with the `number` set to
442 # 3, however, because there is only 2 paths that start with `/foo`.
443 # Cardinality conditions are recursive; all subtrees under the specific
444 # path prefix are counted.
445 "path": "A String", # The root of the variable subtree to monitor. For example, `/foo`.
446 "number": 42, # The number variables under the `path` that must exist to meet this
447 # condition. Defaults to 1 if not specified.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]448 },
449 },
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]450 "failure": { # The condition that a Waiter resource is waiting for. # [Optional] The failure condition of this waiter. If this condition is met,
451 # `done` will be set to `true` and the `error` code will be set to `ABORTED`.
452 # The failure condition takes precedence over the success condition. If both
453 # conditions are met, a failure will be indicated. This value is optional; if
454 # no failure condition is set, the only failure scenario will be a timeout.
455 "cardinality": { # A Cardinality condition for the Waiter resource. A cardinality condition is # The cardinality of the `EndCondition`.
456 # met when the number of variables under a specified path prefix reaches a
457 # predefined number. For example, if you set a Cardinality condition where
458 # the `path` is set to `/foo` and the number of paths is set to 2, the
459 # following variables would meet the condition in a RuntimeConfig resource:
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]460 #
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]461 # + `/foo/variable1 = "value1"`
462 # + `/foo/variable2 = "value2"`
463 # + `/bar/variable3 = "value3"`
464 #
465 # It would not would not satisify the same condition with the `number` set to
466 # 3, however, because there is only 2 paths that start with `/foo`.
467 # Cardinality conditions are recursive; all subtrees under the specific
468 # path prefix are counted.
469 "path": "A String", # The root of the variable subtree to monitor. For example, `/foo`.
470 "number": 42, # The number variables under the `path` that must exist to meet this
471 # condition. Defaults to 1 if not specified.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]472 },
473 },
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]474 "done": True or False, # [Output Only] If the value is `false`, it means the waiter is still waiting
475 # for one of its conditions to be met.
476 #
477 # If true, the waiter has finished. If the waiter finished due to a timeout
478 # or failure, `error` will be set.
479 "timeout": "A String", # [Required] Specifies the timeout of the waiter in seconds, beginning from
480 # the instant that `waiters().create` method is called. If this time elapses
481 # before the success or failure conditions are met, the waiter fails and sets
482 # the `error` code to `DEADLINE_EXCEEDED`.
483 "error": { # The `Status` type defines a logical error model that is suitable for different # [Output Only] If the waiter ended due to a failure or timeout, this value
484 # will be set.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]485 # programming environments, including REST APIs and RPC APIs. It is used by
486 # [gRPC](https://github.com/grpc). The error model is designed to be:
487 #
488 # - Simple to use and understand for most users
489 # - Flexible enough to meet unexpected needs
490 #
491 # # Overview
492 #
493 # The `Status` message contains three pieces of data: error code, error message,
494 # and error details. The error code should be an enum value of
495 # google.rpc.Code, but it may accept additional error codes if needed. The
496 # error message should be a developer-facing English message that helps
497 # developers *understand* and *resolve* the error. If a localized user-facing
498 # error message is needed, put the localized message in the error details or
499 # localize it in the client. The optional error details may contain arbitrary
500 # information about the error. There is a predefined set of error detail types
501 # in the package `google.rpc` which can be used for common error conditions.
502 #
503 # # Language mapping
504 #
505 # The `Status` message is the logical representation of the error model, but it
506 # is not necessarily the actual wire format. When the `Status` message is
507 # exposed in different client libraries and different wire protocols, it can be
508 # mapped differently. For example, it will likely be mapped to some exceptions
509 # in Java, but more likely mapped to some error codes in C.
510 #
511 # # Other uses
512 #
513 # The error model and the `Status` message can be used in a variety of
514 # environments, either with or without APIs, to provide a
515 # consistent developer experience across different environments.
516 #
517 # Example uses of this error model include:
518 #
519 # - Partial errors. If a service needs to return partial errors to the client,
520 # it may embed the `Status` in the normal response to indicate the partial
521 # errors.
522 #
523 # - Workflow errors. A typical workflow has multiple steps. Each step may
524 # have a `Status` message for error reporting purpose.
525 #
526 # - Batch operations. If a client uses batch request and batch response, the
527 # `Status` message should be used directly inside batch response, one for
528 # each error sub-response.
529 #
530 # - Asynchronous operations. If an API call embeds asynchronous operation
531 # results in its response, the status of those operations should be
532 # represented directly using the `Status` message.
533 #
534 # - Logging. If some API errors are stored in logs, the message `Status` could
535 # be used directly after any stripping needed for security/privacy reasons.
536 "message": "A String", # A developer-facing error message, which should be in English. Any
537 # user-facing error message should be localized and sent in the
538 # google.rpc.Status.details field, or localized by the client.
539 "code": 42, # The status code, which should be an enum value of google.rpc.Code.
540 "details": [ # A list of messages that carry the error details. There will be a
541 # common set of message types for APIs to use.
542 {
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]543 "a_key": "", # Properties of the object. Contains field @type with type URL.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]544 },
545 ],
546 },
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]547 "createTime": "A String", # [Output Only] The instant at which this Waiter resource was created. Adding
548 # the value of `timeout` to this instant yields the timeout deadline for the
549 # waiter.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]550 }</pre>
551</div>
552
553<div class="method">
554 <code class="details" id="list">list(parent=None, pageToken=None, x__xgafv=None, pageSize=None)</code>
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]555 <pre>List waiters within the given configuration.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]556
557Args:
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]558 parent: string, The path to the configuration for which you want to get a list of waiters.
559The configuration must exist beforehand; the path must by in the format:
560
561`projects/[PROJECT_ID]/configs/[CONFIG_NAME]` (required)
562 pageToken: string, Specifies a page token to use. Set `pageToken` to a `nextPageToken`
563returned by a previous list request to get the next page of results.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]564 x__xgafv: string, V1 error format.
565 Allowed values
566 1 - v1 error format
567 2 - v2 error format
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]568 pageSize: integer, Specifies the number of results to return per page. If there are fewer
569elements than the specified number, returns all elements.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]570
571Returns:
572 An object of the form:
573
574 { # Response for the `ListWaiters()` method.
575 # Order of returned waiter objects is arbitrary.
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]576 "nextPageToken": "A String", # This token allows you to get the next page of results for list requests.
577 # If the number of results is larger than `pageSize`, use the `nextPageToken`
578 # as a value for the query parameter `pageToken` in the next list request.
579 # Subsequent list requests will have their own `nextPageToken` to continue
580 # paging through the results
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]581 "waiters": [ # Found waiters in the project.
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]582 { # A Waiter resource waits for some end condition within a RuntimeConfig resource
583 # to be met before it returns. For example, assume you have a distributed
584 # system where each node writes to a Variable resource indidicating the node's
585 # readiness as part of the startup process.
586 #
587 # You then configure a Waiter resource with the success condition set to wait
588 # until some number of nodes have checked in. Afterwards, your application
589 # runs some arbitrary code after the condition has been met and the waiter
590 # returns successfully.
591 #
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]592 # Once created, a Waiter resource is immutable.
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]593 #
594 # To learn more about using waiters, read the
595 # [Creating a Waiter](/deployment-manager/runtime-configurator/creating-a-waiter)
596 # documentation.
597 "name": "A String", # The name of the Waiter resource, in the format:
598 #
599 # projects/[PROJECT_ID]/configs/[CONFIG_NAME]/waiters/[WAITER_NAME]
600 #
601 # The `[PROJECT_ID]` must be a valid Google Cloud project ID,
602 # the `[CONFIG_NAME]` must be a valid RuntimeConfig resource, the
603 # `[WAITER_NAME]` must match RFC 1035 segment specification, and the length
604 # of `[WAITER_NAME]` must be less than 64 bytes.
605 #
606 # After you create a Waiter resource, you cannot change the resource name.
607 "success": { # The condition that a Waiter resource is waiting for. # [Required] The success condition. If this condition is met, `done` will be
608 # set to `true` and the `error` value will remain unset. The failure condition
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]609 # takes precedence over the success condition. If both conditions are met, a
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]610 # failure will be indicated.
611 "cardinality": { # A Cardinality condition for the Waiter resource. A cardinality condition is # The cardinality of the `EndCondition`.
612 # met when the number of variables under a specified path prefix reaches a
613 # predefined number. For example, if you set a Cardinality condition where
614 # the `path` is set to `/foo` and the number of paths is set to 2, the
615 # following variables would meet the condition in a RuntimeConfig resource:
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]616 #
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]617 # + `/foo/variable1 = "value1"`
618 # + `/foo/variable2 = "value2"`
619 # + `/bar/variable3 = "value3"`
620 #
621 # It would not would not satisify the same condition with the `number` set to
622 # 3, however, because there is only 2 paths that start with `/foo`.
623 # Cardinality conditions are recursive; all subtrees under the specific
624 # path prefix are counted.
625 "path": "A String", # The root of the variable subtree to monitor. For example, `/foo`.
626 "number": 42, # The number variables under the `path` that must exist to meet this
627 # condition. Defaults to 1 if not specified.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]628 },
629 },
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]630 "failure": { # The condition that a Waiter resource is waiting for. # [Optional] The failure condition of this waiter. If this condition is met,
631 # `done` will be set to `true` and the `error` code will be set to `ABORTED`.
632 # The failure condition takes precedence over the success condition. If both
633 # conditions are met, a failure will be indicated. This value is optional; if
634 # no failure condition is set, the only failure scenario will be a timeout.
635 "cardinality": { # A Cardinality condition for the Waiter resource. A cardinality condition is # The cardinality of the `EndCondition`.
636 # met when the number of variables under a specified path prefix reaches a
637 # predefined number. For example, if you set a Cardinality condition where
638 # the `path` is set to `/foo` and the number of paths is set to 2, the
639 # following variables would meet the condition in a RuntimeConfig resource:
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]640 #
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]641 # + `/foo/variable1 = "value1"`
642 # + `/foo/variable2 = "value2"`
643 # + `/bar/variable3 = "value3"`
644 #
645 # It would not would not satisify the same condition with the `number` set to
646 # 3, however, because there is only 2 paths that start with `/foo`.
647 # Cardinality conditions are recursive; all subtrees under the specific
648 # path prefix are counted.
649 "path": "A String", # The root of the variable subtree to monitor. For example, `/foo`.
650 "number": 42, # The number variables under the `path` that must exist to meet this
651 # condition. Defaults to 1 if not specified.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]652 },
653 },
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]654 "done": True or False, # [Output Only] If the value is `false`, it means the waiter is still waiting
655 # for one of its conditions to be met.
656 #
657 # If true, the waiter has finished. If the waiter finished due to a timeout
658 # or failure, `error` will be set.
659 "timeout": "A String", # [Required] Specifies the timeout of the waiter in seconds, beginning from
660 # the instant that `waiters().create` method is called. If this time elapses
661 # before the success or failure conditions are met, the waiter fails and sets
662 # the `error` code to `DEADLINE_EXCEEDED`.
663 "error": { # The `Status` type defines a logical error model that is suitable for different # [Output Only] If the waiter ended due to a failure or timeout, this value
664 # will be set.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]665 # programming environments, including REST APIs and RPC APIs. It is used by
666 # [gRPC](https://github.com/grpc). The error model is designed to be:
667 #
668 # - Simple to use and understand for most users
669 # - Flexible enough to meet unexpected needs
670 #
671 # # Overview
672 #
673 # The `Status` message contains three pieces of data: error code, error message,
674 # and error details. The error code should be an enum value of
675 # google.rpc.Code, but it may accept additional error codes if needed. The
676 # error message should be a developer-facing English message that helps
677 # developers *understand* and *resolve* the error. If a localized user-facing
678 # error message is needed, put the localized message in the error details or
679 # localize it in the client. The optional error details may contain arbitrary
680 # information about the error. There is a predefined set of error detail types
681 # in the package `google.rpc` which can be used for common error conditions.
682 #
683 # # Language mapping
684 #
685 # The `Status` message is the logical representation of the error model, but it
686 # is not necessarily the actual wire format. When the `Status` message is
687 # exposed in different client libraries and different wire protocols, it can be
688 # mapped differently. For example, it will likely be mapped to some exceptions
689 # in Java, but more likely mapped to some error codes in C.
690 #
691 # # Other uses
692 #
693 # The error model and the `Status` message can be used in a variety of
694 # environments, either with or without APIs, to provide a
695 # consistent developer experience across different environments.
696 #
697 # Example uses of this error model include:
698 #
699 # - Partial errors. If a service needs to return partial errors to the client,
700 # it may embed the `Status` in the normal response to indicate the partial
701 # errors.
702 #
703 # - Workflow errors. A typical workflow has multiple steps. Each step may
704 # have a `Status` message for error reporting purpose.
705 #
706 # - Batch operations. If a client uses batch request and batch response, the
707 # `Status` message should be used directly inside batch response, one for
708 # each error sub-response.
709 #
710 # - Asynchronous operations. If an API call embeds asynchronous operation
711 # results in its response, the status of those operations should be
712 # represented directly using the `Status` message.
713 #
714 # - Logging. If some API errors are stored in logs, the message `Status` could
715 # be used directly after any stripping needed for security/privacy reasons.
716 "message": "A String", # A developer-facing error message, which should be in English. Any
717 # user-facing error message should be localized and sent in the
718 # google.rpc.Status.details field, or localized by the client.
719 "code": 42, # The status code, which should be an enum value of google.rpc.Code.
720 "details": [ # A list of messages that carry the error details. There will be a
721 # common set of message types for APIs to use.
722 {
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]723 "a_key": "", # Properties of the object. Contains field @type with type URL.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]724 },
725 ],
726 },
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -0700[diff] [blame^]727 "createTime": "A String", # [Output Only] The instant at which this Waiter resource was created. Adding
728 # the value of `timeout` to this instant yields the timeout deadline for the
729 # waiter.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700[diff] [blame]730 },
731 ],
732 }</pre>
733</div>
734
735<div class="method">
736 <code class="details" id="list_next">list_next(previous_request, previous_response)</code>
737 <pre>Retrieves the next page of results.
738
739Args:
740 previous_request: The request for the previous page. (required)
741 previous_response: The response from the request for the previous page. (required)
742
743Returns:
744 A request object that you can call 'execute()' on to request the next
745 page. Returns None if there are no more items in the collection.
746 </pre>
747</div>
748
749</body></html>