mirror of
https://github.com/OMGeeky/google-apis-rs.git
synced 2026-02-23 15:49:49 +01:00
3014 lines
142 KiB
Rust
3014 lines
142 KiB
Rust
// DO NOT EDIT !
|
||
// This file was generated automatically from 'src/mako/api/lib.rs.in.mako'
|
||
// DO NOT EDIT !
|
||
|
||
#[cfg(feature = "nightly")]
|
||
#[macro_use]
|
||
extern crate serde_derive;
|
||
|
||
extern crate hyper;
|
||
extern crate serde;
|
||
extern crate serde_json;
|
||
extern crate yup_oauth2 as oauth2;
|
||
extern crate mime;
|
||
extern crate url;
|
||
|
||
mod cmn;
|
||
|
||
use std::collections::HashMap;
|
||
use std::cell::RefCell;
|
||
use std::borrow::BorrowMut;
|
||
use std::default::Default;
|
||
use std::collections::BTreeMap;
|
||
use serde_json as json;
|
||
use std::io;
|
||
use std::fs;
|
||
use std::thread::sleep;
|
||
use std::time::Duration;
|
||
|
||
pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, Hub, ReadSeek, Part,
|
||
ResponseResult, RequestValue, NestedType, Delegate, DefaultDelegate, MethodsBuilder,
|
||
Resource, ErrorResponse, remove_json_null_values};
|
||
|
||
|
||
// ##############
|
||
// UTILITIES ###
|
||
// ############
|
||
|
||
/// Identifies the an OAuth2 authorization scope.
|
||
/// A scope is needed when requesting an
|
||
/// [authorization token](https://developers.google.com/youtube/v3/guides/authentication).
|
||
#[derive(PartialEq, Eq, Hash)]
|
||
pub enum Scope {
|
||
/// View and manage your data across Google Cloud Platform services
|
||
CloudPlatform,
|
||
|
||
/// View your data across Google Cloud Platform services
|
||
CloudPlatformReadOnly,
|
||
}
|
||
|
||
impl AsRef<str> for Scope {
|
||
fn as_ref(&self) -> &str {
|
||
match *self {
|
||
Scope::CloudPlatform => "https://www.googleapis.com/auth/cloud-platform",
|
||
Scope::CloudPlatformReadOnly => "https://www.googleapis.com/auth/cloud-platform.read-only",
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Default for Scope {
|
||
fn default() -> Scope {
|
||
Scope::CloudPlatform
|
||
}
|
||
}
|
||
|
||
|
||
|
||
// ########
|
||
// HUB ###
|
||
// ######
|
||
|
||
/// Central instance to access all CloudResourceManager related resource activities
|
||
///
|
||
/// # Examples
|
||
///
|
||
/// Instantiate a new hub
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// extern crate hyper;
|
||
/// extern crate yup_oauth2 as oauth2;
|
||
/// extern crate google_cloudresourcemanager1 as cloudresourcemanager1;
|
||
/// use cloudresourcemanager1::{Result, Error};
|
||
/// # #[test] fn egal() {
|
||
/// use std::default::Default;
|
||
/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
|
||
/// use cloudresourcemanager1::CloudResourceManager;
|
||
///
|
||
/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and
|
||
/// // `client_secret`, among other things.
|
||
/// let secret: ApplicationSecret = Default::default();
|
||
/// // Instantiate the authenticator. It will choose a suitable authentication flow for you,
|
||
/// // unless you replace `None` with the desired Flow.
|
||
/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about
|
||
/// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and
|
||
/// // retrieve them from storage.
|
||
/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
|
||
/// hyper::Client::new(),
|
||
/// <MemoryStorage as Default>::default(), None);
|
||
/// let mut hub = CloudResourceManager::new(hyper::Client::new(), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().list()
|
||
/// .page_token("sed")
|
||
/// .page_size(-85)
|
||
/// .filter("dolores")
|
||
/// .doit();
|
||
///
|
||
/// match result {
|
||
/// Err(e) => match e {
|
||
/// // The Error enum provides details about what exactly happened.
|
||
/// // You can also just use its `Debug`, `Display` or `Error` traits
|
||
/// Error::HttpError(_)
|
||
/// |Error::MissingAPIKey
|
||
/// |Error::MissingToken(_)
|
||
/// |Error::Cancelled
|
||
/// |Error::UploadSizeLimitExceeded(_, _)
|
||
/// |Error::Failure(_)
|
||
/// |Error::BadRequest(_)
|
||
/// |Error::FieldClash(_)
|
||
/// |Error::JsonDecodeError(_, _) => println!("{}", e),
|
||
/// },
|
||
/// Ok(res) => println!("Success: {:?}", res),
|
||
/// }
|
||
/// # }
|
||
/// ```
|
||
pub struct CloudResourceManager<C, A> {
|
||
client: RefCell<C>,
|
||
auth: RefCell<A>,
|
||
_user_agent: String,
|
||
}
|
||
|
||
impl<'a, C, A> Hub for CloudResourceManager<C, A> {}
|
||
|
||
impl<'a, C, A> CloudResourceManager<C, A>
|
||
where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
|
||
|
||
pub fn new(client: C, authenticator: A) -> CloudResourceManager<C, A> {
|
||
CloudResourceManager {
|
||
client: RefCell::new(client),
|
||
auth: RefCell::new(authenticator),
|
||
_user_agent: "google-api-rust-client/1.0.0".to_string(),
|
||
}
|
||
}
|
||
|
||
pub fn operations(&'a self) -> OperationMethods<'a, C, A> {
|
||
OperationMethods { hub: &self }
|
||
}
|
||
pub fn projects(&'a self) -> ProjectMethods<'a, C, A> {
|
||
ProjectMethods { hub: &self }
|
||
}
|
||
|
||
/// Set the user-agent header field to use in all requests to the server.
|
||
/// It defaults to `google-api-rust-client/1.0.0`.
|
||
///
|
||
/// Returns the previously set user-agent.
|
||
pub fn user_agent(&mut self, agent_name: String) -> String {
|
||
let prev = self._user_agent.clone();
|
||
self._user_agent = agent_name;
|
||
prev
|
||
}
|
||
}
|
||
|
||
|
||
// ############
|
||
// SCHEMAS ###
|
||
// ##########
|
||
/// The request sent to the UndeleteProject method.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [undelete projects](struct.ProjectUndeleteCall.html) (request)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct UndeleteProjectRequest { _never_set: Option<bool> }
|
||
|
||
impl RequestValue for UndeleteProjectRequest {}
|
||
|
||
|
||
/// The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). The error model is designed to be: - Simple to use and understand for most users - Flexible enough to meet unexpected needs # Overview The `Status` message contains three pieces of data: error code, error message, and error details. The error code should be an enum value of google.rpc.Code, but it may accept additional error codes if needed. The error message should be a developer-facing English message that helps developers *understand* and *resolve* the error. If a localized user-facing error message is needed, put the localized message in the error details or localize it in the client. The optional error details may contain arbitrary information about the error. There is a predefined set of error detail types in the package `google.rpc` which can be used for common error conditions. # Language mapping The `Status` message is the logical representation of the error model, but it is not necessarily the actual wire format. When the `Status` message is exposed in different client libraries and different wire protocols, it can be mapped differently. For example, it will likely be mapped to some exceptions in Java, but more likely mapped to some error codes in C. # Other uses The error model and the `Status` message can be used in a variety of environments, either with or without APIs, to provide a consistent developer experience across different environments. Example uses of this error model include: - Partial errors. If a service needs to return partial errors to the client, it may embed the `Status` in the normal response to indicate the partial errors. - Workflow errors. A typical workflow has multiple steps. Each step may have a `Status` message for error reporting purpose. - Batch operations. If a client uses batch request and batch response, the `Status` message should be used directly inside batch response, one for each error sub-response. - Asynchronous operations. If an API call embeds asynchronous operation results in its response, the status of those operations should be represented directly using the `Status` message. - Logging. If some API errors are stored in logs, the message `Status` could be used directly after any stripping needed for security/privacy reasons.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Status {
|
||
/// A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
|
||
pub message: Option<String>,
|
||
/// The status code, which should be an enum value of google.rpc.Code.
|
||
pub code: Option<i32>,
|
||
/// A list of messages that carry the error details. There will be a common set of message types for APIs to use.
|
||
pub details: Option<Vec<HashMap<String, String>>>,
|
||
}
|
||
|
||
impl Part for Status {}
|
||
|
||
|
||
/// Response message for `TestIamPermissions` method.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [test iam permissions projects](struct.ProjectTestIamPermissionCall.html) (response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct TestIamPermissionsResponse {
|
||
/// A subset of `TestPermissionsRequest.permissions` that the caller is allowed.
|
||
pub permissions: Option<Vec<String>>,
|
||
}
|
||
|
||
impl ResponseResult for TestIamPermissionsResponse {}
|
||
|
||
|
||
/// Request message for `GetIamPolicy` method.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [get iam policy projects](struct.ProjectGetIamPolicyCall.html) (request)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct GetIamPolicyRequest { _never_set: Option<bool> }
|
||
|
||
impl RequestValue for GetIamPolicyRequest {}
|
||
|
||
|
||
/// Request message for `TestIamPermissions` method.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [test iam permissions projects](struct.ProjectTestIamPermissionCall.html) (request)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct TestIamPermissionsRequest {
|
||
/// The set of permissions to check for the `resource`. Permissions with wildcards (such as '*' or 'storage.*') are not allowed. For more information see IAM Overview.
|
||
pub permissions: Option<Vec<String>>,
|
||
}
|
||
|
||
impl RequestValue for TestIamPermissionsRequest {}
|
||
|
||
|
||
/// Request message for `SetIamPolicy` method.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [set iam policy projects](struct.ProjectSetIamPolicyCall.html) (request)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct SetIamPolicyRequest {
|
||
/// REQUIRED: The complete policy to be applied to the `resource`. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Cloud Platform services (such as Projects) might reject them.
|
||
pub policy: Option<Policy>,
|
||
}
|
||
|
||
impl RequestValue for SetIamPolicyRequest {}
|
||
|
||
|
||
/// A container to reference an id for any resource type. A `resource` in Google Cloud Platform is a generic term for something you (a developer) may want to interact with through one of our API's. Some examples are an AppEngine app, a Compute Engine instance, a Cloud SQL database, and so on.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct ResourceId {
|
||
/// Required field representing the resource type this id is for. At present, the only valid type is "organization".
|
||
#[serde(rename="type")]
|
||
pub type_: Option<String>,
|
||
/// Required field for the type-specific id. This should correspond to the id used in the type-specific API's.
|
||
pub id: Option<String>,
|
||
}
|
||
|
||
impl Part for ResourceId {}
|
||
|
||
|
||
/// Associates `members` with a `role`.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Binding {
|
||
/// Role that is assigned to `members`. For example, `roles/viewer`, `roles/editor`, or `roles/owner`. Required
|
||
pub role: Option<String>,
|
||
/// Specifies the identities requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@gmail.com` or `joe@example.com`. * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain}`: A Google Apps domain name that represents all the users of that domain. For example, `google.com` or `example.com`.
|
||
pub members: Option<Vec<String>>,
|
||
}
|
||
|
||
impl Part for Binding {}
|
||
|
||
|
||
/// A Project is a high-level Google Cloud Platform entity. It is a container for ACLs, APIs, AppEngine Apps, VMs, and other Google Cloud Platform resources.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [get projects](struct.ProjectGetCall.html) (response)
|
||
/// * [undelete projects](struct.ProjectUndeleteCall.html) (none)
|
||
/// * [set iam policy projects](struct.ProjectSetIamPolicyCall.html) (none)
|
||
/// * [test iam permissions projects](struct.ProjectTestIamPermissionCall.html) (none)
|
||
/// * [update projects](struct.ProjectUpdateCall.html) (request|response)
|
||
/// * [get iam policy projects](struct.ProjectGetIamPolicyCall.html) (none)
|
||
/// * [delete projects](struct.ProjectDeleteCall.html) (none)
|
||
/// * [list projects](struct.ProjectListCall.html) (none)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Project {
|
||
/// The user-assigned display name of the Project. It must be 4 to 30 characters. Allowed characters are: lowercase and uppercase letters, numbers, hyphen, single-quote, double-quote, space, and exclamation point. Example: My Project Read-write.
|
||
pub name: Option<String>,
|
||
/// An optional reference to a parent Resource. The only supported parent type is "organization". Once set, the parent cannot be modified. Read-write.
|
||
pub parent: Option<ResourceId>,
|
||
/// The unique, user-assigned ID of the Project. It must be 6 to 30 lowercase letters, digits, or hyphens. It must start with a letter. Trailing hyphens are prohibited. Example: tokyo-rain-123 Read-only after creation.
|
||
#[serde(rename="projectId")]
|
||
pub project_id: Option<String>,
|
||
/// The labels associated with this Project. Label keys must be between 1 and 63 characters long and must conform to the following regular expression: \[a-z\](\[-a-z0-9\]*\[a-z0-9\])?. Label values must be between 0 and 63 characters long and must conform to the regular expression (\[a-z\](\[-a-z0-9\]*\[a-z0-9\])?)?. No more than 256 labels can be associated with a given resource. Clients should store labels in a representation such as JSON that does not depend on specific characters being disallowed. Example: "environment" : "dev" Read-write.
|
||
pub labels: Option<HashMap<String, String>>,
|
||
/// The number uniquely identifying the project. Example: 415104041262 Read-only.
|
||
#[serde(rename="projectNumber")]
|
||
pub project_number: Option<String>,
|
||
/// Creation time. Read-only.
|
||
#[serde(rename="createTime")]
|
||
pub create_time: Option<String>,
|
||
/// The Project lifecycle state. Read-only.
|
||
#[serde(rename="lifecycleState")]
|
||
pub lifecycle_state: Option<String>,
|
||
}
|
||
|
||
impl RequestValue for Project {}
|
||
impl Resource for Project {}
|
||
impl ResponseResult for Project {}
|
||
|
||
|
||
/// Defines an Identity and Access Management (IAM) policy. It is used to specify access control policies for Cloud Platform resources. A `Policy` consists of a list of `bindings`. A `Binding` binds a list of `members` to a `role`, where the members can be user accounts, Google groups, Google domains, and service accounts. A `role` is a named list of permissions defined by IAM. **Example** { "bindings": [ { "role": "roles/owner", "members": [ "user:mike@example.com", "group:admins@example.com", "domain:google.com", "serviceAccount:my-other-app@appspot.gserviceaccount.com", ] }, { "role": "roles/viewer", "members": ["user:sean@example.com"] } ] } For a description of IAM and its features, see the [IAM developer's guide](https://cloud.google.com/iam).
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [set iam policy projects](struct.ProjectSetIamPolicyCall.html) (response)
|
||
/// * [get iam policy projects](struct.ProjectGetIamPolicyCall.html) (response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Policy {
|
||
/// Associates a list of `members` to a `role`. Multiple `bindings` must not be specified for the same `role`. `bindings` with no members will result in an error.
|
||
pub bindings: Option<Vec<Binding>>,
|
||
/// Version of the `Policy`. The default version is 0.
|
||
pub version: Option<i32>,
|
||
/// `etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. If no `etag` is provided in the call to `setIamPolicy`, then the existing policy is overwritten blindly.
|
||
pub etag: Option<String>,
|
||
}
|
||
|
||
impl ResponseResult for Policy {}
|
||
|
||
|
||
/// This resource represents a long-running operation that is the result of a network API call.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [get operations](struct.OperationGetCall.html) (response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Operation {
|
||
/// Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.
|
||
pub metadata: Option<HashMap<String, String>>,
|
||
/// If the value is `false`, it means the operation is still in progress. If true, the operation is completed, and either `error` or `response` is available.
|
||
pub done: Option<bool>,
|
||
/// The normal response of the operation in case of success. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
|
||
pub response: Option<HashMap<String, String>>,
|
||
/// The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should have the format of `operations/some/unique/name`.
|
||
pub name: Option<String>,
|
||
/// The error result of the operation in case of failure.
|
||
pub error: Option<Status>,
|
||
}
|
||
|
||
impl Resource for Operation {}
|
||
impl ResponseResult for Operation {}
|
||
|
||
|
||
/// A page of the response received from the ListProjects method. A paginated response where more pages are available has `next_page_token` set. This token can be used in a subsequent request to retrieve the next request page.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [list projects](struct.ProjectListCall.html) (response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct ListProjectsResponse {
|
||
/// Pagination token. If the result set is too large to fit in a single response, this token is returned. It encodes the position of the current result cursor. Feeding this value into a new list request with the `page_token` parameter gives the next page of the results. When `next_page_token` is not filled in, there is no next page and the list returned is the last page in the result set. Pagination tokens have a limited lifetime.
|
||
#[serde(rename="nextPageToken")]
|
||
pub next_page_token: Option<String>,
|
||
/// The list of Projects that matched the list filter. This list can be paginated.
|
||
pub projects: Option<Vec<Project>>,
|
||
}
|
||
|
||
impl ResponseResult for ListProjectsResponse {}
|
||
|
||
|
||
/// A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON representation for `Empty` is empty JSON object `{}`.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [delete projects](struct.ProjectDeleteCall.html) (response)
|
||
/// * [undelete projects](struct.ProjectUndeleteCall.html) (response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Empty { _never_set: Option<bool> }
|
||
|
||
impl ResponseResult for Empty {}
|
||
|
||
|
||
|
||
// ###################
|
||
// MethodBuilders ###
|
||
// #################
|
||
|
||
/// A builder providing access to all methods supported on *operation* resources.
|
||
/// It is not used directly, but through the `CloudResourceManager` hub.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// extern crate hyper;
|
||
/// extern crate yup_oauth2 as oauth2;
|
||
/// extern crate google_cloudresourcemanager1 as cloudresourcemanager1;
|
||
///
|
||
/// # #[test] fn egal() {
|
||
/// use std::default::Default;
|
||
/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
|
||
/// use cloudresourcemanager1::CloudResourceManager;
|
||
///
|
||
/// let secret: ApplicationSecret = Default::default();
|
||
/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
|
||
/// hyper::Client::new(),
|
||
/// <MemoryStorage as Default>::default(), None);
|
||
/// let mut hub = CloudResourceManager::new(hyper::Client::new(), auth);
|
||
/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
|
||
/// // like `get(...)`
|
||
/// // to build up your call.
|
||
/// let rb = hub.operations();
|
||
/// # }
|
||
/// ```
|
||
pub struct OperationMethods<'a, C, A>
|
||
where C: 'a, A: 'a {
|
||
|
||
hub: &'a CloudResourceManager<C, A>,
|
||
}
|
||
|
||
impl<'a, C, A> MethodsBuilder for OperationMethods<'a, C, A> {}
|
||
|
||
impl<'a, C, A> OperationMethods<'a, C, A> {
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `name` - The name of the operation resource.
|
||
pub fn get(&self, name: &str) -> OperationGetCall<'a, C, A> {
|
||
OperationGetCall {
|
||
hub: self.hub,
|
||
_name: name.to_string(),
|
||
_delegate: Default::default(),
|
||
_scopes: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/// A builder providing access to all methods supported on *project* resources.
|
||
/// It is not used directly, but through the `CloudResourceManager` hub.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// extern crate hyper;
|
||
/// extern crate yup_oauth2 as oauth2;
|
||
/// extern crate google_cloudresourcemanager1 as cloudresourcemanager1;
|
||
///
|
||
/// # #[test] fn egal() {
|
||
/// use std::default::Default;
|
||
/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
|
||
/// use cloudresourcemanager1::CloudResourceManager;
|
||
///
|
||
/// let secret: ApplicationSecret = Default::default();
|
||
/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
|
||
/// hyper::Client::new(),
|
||
/// <MemoryStorage as Default>::default(), None);
|
||
/// let mut hub = CloudResourceManager::new(hyper::Client::new(), auth);
|
||
/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
|
||
/// // like `delete(...)`, `get(...)`, `get_iam_policy(...)`, `list(...)`, `set_iam_policy(...)`, `test_iam_permissions(...)`, `undelete(...)` and `update(...)`
|
||
/// // to build up your call.
|
||
/// let rb = hub.projects();
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectMethods<'a, C, A>
|
||
where C: 'a, A: 'a {
|
||
|
||
hub: &'a CloudResourceManager<C, A>,
|
||
}
|
||
|
||
impl<'a, C, A> MethodsBuilder for ProjectMethods<'a, C, A> {}
|
||
|
||
impl<'a, C, A> ProjectMethods<'a, C, A> {
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Returns permissions that a caller has on the specified Project.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `request` - No description provided.
|
||
/// * `resource` - REQUIRED: The resource for which the policy detail is being requested. `resource` is usually specified as a path, such as `projects/*project*/zones/*zone*/disks/*disk*`. The format for the path specified in this value is resource specific and is specified in the `testIamPermissions` documentation.
|
||
pub fn test_iam_permissions(&self, request: TestIamPermissionsRequest, resource: &str) -> ProjectTestIamPermissionCall<'a, C, A> {
|
||
ProjectTestIamPermissionCall {
|
||
hub: self.hub,
|
||
_request: request,
|
||
_resource: resource.to_string(),
|
||
_delegate: Default::default(),
|
||
_scopes: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Restores the Project identified by the specified `project_id` (for example, `my-project-123`). You can only use this method for a Project that has a lifecycle state of DELETE_REQUESTED. After deletion starts, the Project cannot be restored. The caller must have modify permissions for this Project.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `request` - No description provided.
|
||
/// * `projectId` - The project ID (for example, `foo-bar-123`). Required.
|
||
pub fn undelete(&self, request: UndeleteProjectRequest, project_id: &str) -> ProjectUndeleteCall<'a, C, A> {
|
||
ProjectUndeleteCall {
|
||
hub: self.hub,
|
||
_request: request,
|
||
_project_id: project_id.to_string(),
|
||
_delegate: Default::default(),
|
||
_scopes: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Sets the IAM access control policy for the specified Project. Replaces any existing policy. The following constraints apply when using `setIamPolicy()`: + Project does not support `allUsers` and `allAuthenticatedUsers` as `members` in a `Binding` of a `Policy`. + The owner role can be granted only to `user` and `serviceAccount`. + Service accounts can be made owners of a project directly without any restrictions. However, to be added as an owner, a user must be invited via Cloud Platform console and must accept the invitation. + A user cannot be granted the owner role using `setIamPolicy()`. The user must be granted the owner role using the Cloud Platform Console and must explicitly accept the invitation. + Invitations to grant the owner role cannot be sent using `setIamPolicy()`; they must be sent only using the Cloud Platform Console. + Membership changes that leave the project without any owners that have accepted the Terms of Service (ToS) will be rejected. + Members cannot be added to more than one role in the same policy. + There must be at least one owner who has accepted the Terms of Service (ToS) agreement in the policy. Calling `setIamPolicy()` to to remove the last ToS-accepted owner from the policy will fail. This restriction also applies to legacy projects that no longer have owners who have accepted the ToS. Edits to IAM policies will be rejected until the lack of a ToS-accepting owner is rectified. + Calling this method requires enabling the App Engine Admin API. Note: Removing service accounts from policies or changing their roles can render services completely inoperable. It is important to understand how the service account is being used before removing or updating its roles.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `request` - No description provided.
|
||
/// * `resource` - REQUIRED: The resource for which the policy is being specified. `resource` is usually specified as a path, such as `projects/*project*/zones/*zone*/disks/*disk*`. The format for the path specified in this value is resource specific and is specified in the `setIamPolicy` documentation.
|
||
pub fn set_iam_policy(&self, request: SetIamPolicyRequest, resource: &str) -> ProjectSetIamPolicyCall<'a, C, A> {
|
||
ProjectSetIamPolicyCall {
|
||
hub: self.hub,
|
||
_request: request,
|
||
_resource: resource.to_string(),
|
||
_delegate: Default::default(),
|
||
_scopes: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Retrieves the Project identified by the specified `project_id` (for example, `my-project-123`). The caller must have read permissions for this Project.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `projectId` - The Project ID (for example, `my-project-123`). Required.
|
||
pub fn get(&self, project_id: &str) -> ProjectGetCall<'a, C, A> {
|
||
ProjectGetCall {
|
||
hub: self.hub,
|
||
_project_id: project_id.to_string(),
|
||
_delegate: Default::default(),
|
||
_scopes: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Returns the IAM access control policy for the specified Project. Permission is denied if the policy or the resource does not exist.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `request` - No description provided.
|
||
/// * `resource` - REQUIRED: The resource for which the policy is being requested. `resource` is usually specified as a path, such as `projects/*project*/zones/*zone*/disks/*disk*`. The format for the path specified in this value is resource specific and is specified in the `getIamPolicy` documentation.
|
||
pub fn get_iam_policy(&self, request: GetIamPolicyRequest, resource: &str) -> ProjectGetIamPolicyCall<'a, C, A> {
|
||
ProjectGetIamPolicyCall {
|
||
hub: self.hub,
|
||
_request: request,
|
||
_resource: resource.to_string(),
|
||
_delegate: Default::default(),
|
||
_scopes: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Updates the attributes of the Project identified by the specified `project_id` (for example, `my-project-123`). The caller must have modify permissions for this Project.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `request` - No description provided.
|
||
/// * `projectId` - The project ID (for example, `my-project-123`). Required.
|
||
pub fn update(&self, request: Project, project_id: &str) -> ProjectUpdateCall<'a, C, A> {
|
||
ProjectUpdateCall {
|
||
hub: self.hub,
|
||
_request: request,
|
||
_project_id: project_id.to_string(),
|
||
_delegate: Default::default(),
|
||
_scopes: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Marks the Project identified by the specified `project_id` (for example, `my-project-123`) for deletion. This method will only affect the Project if the following criteria are met: + The Project does not have a billing account associated with it. + The Project has a lifecycle state of ACTIVE. This method changes the Project's lifecycle state from ACTIVE to DELETE_REQUESTED. The deletion starts at an unspecified time, at which point the Project is no longer accessible. Until the deletion completes, you can check the lifecycle state checked by retrieving the Project with GetProject, and the Project remains visible to ListProjects. However, you cannot update the project. After the deletion completes, the Project is not retrievable by the GetProject and ListProjects methods. The caller must have modify permissions for this Project.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `projectId` - The Project ID (for example, `foo-bar-123`). Required.
|
||
pub fn delete(&self, project_id: &str) -> ProjectDeleteCall<'a, C, A> {
|
||
ProjectDeleteCall {
|
||
hub: self.hub,
|
||
_project_id: project_id.to_string(),
|
||
_delegate: Default::default(),
|
||
_scopes: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Lists Projects that are visible to the user and satisfy the specified filter. This method returns Projects in an unspecified order. New Projects do not necessarily appear at the end of the list.
|
||
pub fn list(&self) -> ProjectListCall<'a, C, A> {
|
||
ProjectListCall {
|
||
hub: self.hub,
|
||
_page_token: Default::default(),
|
||
_page_size: Default::default(),
|
||
_filter: Default::default(),
|
||
_delegate: Default::default(),
|
||
_scopes: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
// ###################
|
||
// CallBuilders ###
|
||
// #################
|
||
|
||
/// Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.
|
||
///
|
||
/// A builder for the *get* method supported by a *operation* resource.
|
||
/// It is not used directly, but through a `OperationMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate yup_oauth2 as oauth2;
|
||
/// # extern crate google_cloudresourcemanager1 as cloudresourcemanager1;
|
||
/// # #[test] fn egal() {
|
||
/// # use std::default::Default;
|
||
/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
|
||
/// # use cloudresourcemanager1::CloudResourceManager;
|
||
///
|
||
/// # let secret: ApplicationSecret = Default::default();
|
||
/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
|
||
/// # hyper::Client::new(),
|
||
/// # <MemoryStorage as Default>::default(), None);
|
||
/// # let mut hub = CloudResourceManager::new(hyper::Client::new(), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.operations().get("name")
|
||
/// .doit();
|
||
/// # }
|
||
/// ```
|
||
pub struct OperationGetCall<'a, C, A>
|
||
where C: 'a, A: 'a {
|
||
|
||
hub: &'a CloudResourceManager<C, A>,
|
||
_name: String,
|
||
_delegate: Option<&'a mut Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeMap<String, ()>
|
||
}
|
||
|
||
impl<'a, C, A> CallBuilder for OperationGetCall<'a, C, A> {}
|
||
|
||
impl<'a, C, A> OperationGetCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub fn doit(mut self) -> Result<(hyper::client::Response, Operation)> {
|
||
use url::percent_encoding::{percent_encode, DEFAULT_ENCODE_SET};
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
|
||
let mut dd = DefaultDelegate;
|
||
let mut dlg: &mut Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(MethodInfo { id: "cloudresourcemanager.operations.get",
|
||
http_method: hyper::method::Method::Get });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity((3 + self._additional_params.len()));
|
||
params.push(("name", self._name.to_string()));
|
||
for &field in ["alt", "name"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(Error::FieldClash(field));
|
||
}
|
||
}
|
||
for (name, value) in self._additional_params.iter() {
|
||
params.push((&name, value.clone()));
|
||
}
|
||
|
||
params.push(("alt", "json".to_string()));
|
||
|
||
let mut url = "https://cloudresourcemanager.googleapis.com/v1/{+name}".to_string();
|
||
if self._scopes.len() == 0 {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string(), ());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+name}", "name")].iter() {
|
||
let mut replace_with = String::new();
|
||
for &(name, ref value) in params.iter() {
|
||
if name == param_name {
|
||
replace_with = value.to_string();
|
||
break;
|
||
}
|
||
}
|
||
if find_this.as_bytes()[1] == '+' as u8 {
|
||
replace_with = percent_encode(replace_with.as_bytes(), DEFAULT_ENCODE_SET);
|
||
}
|
||
url = url.replace(find_this, &replace_with);
|
||
}
|
||
{
|
||
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(1);
|
||
for param_name in ["name"].iter() {
|
||
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
|
||
indices_for_removal.push(index);
|
||
}
|
||
}
|
||
for &index in indices_for_removal.iter() {
|
||
params.remove(index);
|
||
}
|
||
}
|
||
|
||
if params.len() > 0 {
|
||
url.push('?');
|
||
url.push_str(&url::form_urlencoded::serialize(params));
|
||
}
|
||
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
|
||
Ok(token) => token,
|
||
Err(err) => {
|
||
match dlg.token(&*err) {
|
||
Some(token) => token,
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(Error::MissingToken(err))
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let auth_header = Authorization(Bearer { token: token.access_token });
|
||
let mut req_result = {
|
||
let mut client = &mut *self.hub.client.borrow_mut();
|
||
let mut req = client.borrow_mut().request(hyper::method::Method::Get, &url)
|
||
.header(UserAgent(self.hub._user_agent.clone()))
|
||
.header(auth_header.clone());
|
||
|
||
dlg.pre_request();
|
||
req.send()
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status.is_success() {
|
||
let mut json_err = String::new();
|
||
res.read_to_string(&mut json_err).unwrap();
|
||
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
|
||
json::from_str(&json_err).ok(),
|
||
json::from_str(&json_err).ok()) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return match json::from_str::<ErrorResponse>(&json_err){
|
||
Err(_) => Err(Error::Failure(res)),
|
||
Ok(serr) => Err(Error::BadRequest(serr))
|
||
}
|
||
}
|
||
let result_value = {
|
||
let mut json_response = String::new();
|
||
res.read_to_string(&mut json_response).unwrap();
|
||
match json::from_str(&json_response) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&json_response, &err);
|
||
return Err(Error::JsonDecodeError(json_response, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// The name of the operation resource.
|
||
///
|
||
/// Sets the *name* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn name(mut self, new_value: &str) -> OperationGetCall<'a, C, A> {
|
||
self._name = new_value.to_string();
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperationGetCall<'a, C, A> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known paramters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *bearer_token* (query-string) - OAuth bearer token.
|
||
/// * *pp* (query-boolean) - Pretty-print response.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
pub fn param<T>(mut self, name: T, value: T) -> OperationGetCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
|
||
/// `Scope::CloudPlatform`.
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<T>(mut self, scope: T) -> OperationGetCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._scopes.insert(scope.as_ref().to_string(), ());
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Returns permissions that a caller has on the specified Project.
|
||
///
|
||
/// A builder for the *testIamPermissions* method supported by a *project* resource.
|
||
/// It is not used directly, but through a `ProjectMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate yup_oauth2 as oauth2;
|
||
/// # extern crate google_cloudresourcemanager1 as cloudresourcemanager1;
|
||
/// use cloudresourcemanager1::TestIamPermissionsRequest;
|
||
/// # #[test] fn egal() {
|
||
/// # use std::default::Default;
|
||
/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
|
||
/// # use cloudresourcemanager1::CloudResourceManager;
|
||
///
|
||
/// # let secret: ApplicationSecret = Default::default();
|
||
/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
|
||
/// # hyper::Client::new(),
|
||
/// # <MemoryStorage as Default>::default(), None);
|
||
/// # let mut hub = CloudResourceManager::new(hyper::Client::new(), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = TestIamPermissionsRequest::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().test_iam_permissions(req, "resource")
|
||
/// .doit();
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectTestIamPermissionCall<'a, C, A>
|
||
where C: 'a, A: 'a {
|
||
|
||
hub: &'a CloudResourceManager<C, A>,
|
||
_request: TestIamPermissionsRequest,
|
||
_resource: String,
|
||
_delegate: Option<&'a mut Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeMap<String, ()>
|
||
}
|
||
|
||
impl<'a, C, A> CallBuilder for ProjectTestIamPermissionCall<'a, C, A> {}
|
||
|
||
impl<'a, C, A> ProjectTestIamPermissionCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub fn doit(mut self) -> Result<(hyper::client::Response, TestIamPermissionsResponse)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
|
||
let mut dd = DefaultDelegate;
|
||
let mut dlg: &mut Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(MethodInfo { id: "cloudresourcemanager.projects.testIamPermissions",
|
||
http_method: hyper::method::Method::Post });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len()));
|
||
params.push(("resource", self._resource.to_string()));
|
||
for &field in ["alt", "resource"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(Error::FieldClash(field));
|
||
}
|
||
}
|
||
for (name, value) in self._additional_params.iter() {
|
||
params.push((&name, value.clone()));
|
||
}
|
||
|
||
params.push(("alt", "json".to_string()));
|
||
|
||
let mut url = "https://cloudresourcemanager.googleapis.com/v1/projects/{resource}:testIamPermissions".to_string();
|
||
if self._scopes.len() == 0 {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string(), ());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{resource}", "resource")].iter() {
|
||
let mut replace_with: Option<&str> = None;
|
||
for &(name, ref value) in params.iter() {
|
||
if name == param_name {
|
||
replace_with = Some(value);
|
||
break;
|
||
}
|
||
}
|
||
url = url.replace(find_this, replace_with.expect("to find substitution value in params"));
|
||
}
|
||
{
|
||
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(1);
|
||
for param_name in ["resource"].iter() {
|
||
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
|
||
indices_for_removal.push(index);
|
||
}
|
||
}
|
||
for &index in indices_for_removal.iter() {
|
||
params.remove(index);
|
||
}
|
||
}
|
||
|
||
if params.len() > 0 {
|
||
url.push('?');
|
||
url.push_str(&url::form_urlencoded::serialize(params));
|
||
}
|
||
|
||
let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default());
|
||
let mut request_value_reader =
|
||
{
|
||
let mut value = json::value::to_value(&self._request);
|
||
remove_json_null_values(&mut value);
|
||
let mut dst = io::Cursor::new(Vec::with_capacity(128));
|
||
json::to_writer(&mut dst, &value).unwrap();
|
||
dst
|
||
};
|
||
let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap();
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
|
||
Ok(token) => token,
|
||
Err(err) => {
|
||
match dlg.token(&*err) {
|
||
Some(token) => token,
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(Error::MissingToken(err))
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let auth_header = Authorization(Bearer { token: token.access_token });
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
let mut req_result = {
|
||
let mut client = &mut *self.hub.client.borrow_mut();
|
||
let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url)
|
||
.header(UserAgent(self.hub._user_agent.clone()))
|
||
.header(auth_header.clone())
|
||
.header(ContentType(json_mime_type.clone()))
|
||
.header(ContentLength(request_size as u64))
|
||
.body(&mut request_value_reader);
|
||
|
||
dlg.pre_request();
|
||
req.send()
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status.is_success() {
|
||
let mut json_err = String::new();
|
||
res.read_to_string(&mut json_err).unwrap();
|
||
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
|
||
json::from_str(&json_err).ok(),
|
||
json::from_str(&json_err).ok()) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return match json::from_str::<ErrorResponse>(&json_err){
|
||
Err(_) => Err(Error::Failure(res)),
|
||
Ok(serr) => Err(Error::BadRequest(serr))
|
||
}
|
||
}
|
||
let result_value = {
|
||
let mut json_response = String::new();
|
||
res.read_to_string(&mut json_response).unwrap();
|
||
match json::from_str(&json_response) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&json_response, &err);
|
||
return Err(Error::JsonDecodeError(json_response, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
///
|
||
/// Sets the *request* property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn request(mut self, new_value: TestIamPermissionsRequest) -> ProjectTestIamPermissionCall<'a, C, A> {
|
||
self._request = new_value;
|
||
self
|
||
}
|
||
/// REQUIRED: The resource for which the policy detail is being requested. `resource` is usually specified as a path, such as `projects/*project*/zones/*zone*/disks/*disk*`. The format for the path specified in this value is resource specific and is specified in the `testIamPermissions` documentation.
|
||
///
|
||
/// Sets the *resource* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn resource(mut self, new_value: &str) -> ProjectTestIamPermissionCall<'a, C, A> {
|
||
self._resource = new_value.to_string();
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTestIamPermissionCall<'a, C, A> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known paramters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *bearer_token* (query-string) - OAuth bearer token.
|
||
/// * *pp* (query-boolean) - Pretty-print response.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectTestIamPermissionCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
|
||
/// `Scope::CloudPlatform`.
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<T>(mut self, scope: T) -> ProjectTestIamPermissionCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._scopes.insert(scope.as_ref().to_string(), ());
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Restores the Project identified by the specified `project_id` (for example, `my-project-123`). You can only use this method for a Project that has a lifecycle state of DELETE_REQUESTED. After deletion starts, the Project cannot be restored. The caller must have modify permissions for this Project.
|
||
///
|
||
/// A builder for the *undelete* method supported by a *project* resource.
|
||
/// It is not used directly, but through a `ProjectMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate yup_oauth2 as oauth2;
|
||
/// # extern crate google_cloudresourcemanager1 as cloudresourcemanager1;
|
||
/// use cloudresourcemanager1::UndeleteProjectRequest;
|
||
/// # #[test] fn egal() {
|
||
/// # use std::default::Default;
|
||
/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
|
||
/// # use cloudresourcemanager1::CloudResourceManager;
|
||
///
|
||
/// # let secret: ApplicationSecret = Default::default();
|
||
/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
|
||
/// # hyper::Client::new(),
|
||
/// # <MemoryStorage as Default>::default(), None);
|
||
/// # let mut hub = CloudResourceManager::new(hyper::Client::new(), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = UndeleteProjectRequest::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().undelete(req, "projectId")
|
||
/// .doit();
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectUndeleteCall<'a, C, A>
|
||
where C: 'a, A: 'a {
|
||
|
||
hub: &'a CloudResourceManager<C, A>,
|
||
_request: UndeleteProjectRequest,
|
||
_project_id: String,
|
||
_delegate: Option<&'a mut Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeMap<String, ()>
|
||
}
|
||
|
||
impl<'a, C, A> CallBuilder for ProjectUndeleteCall<'a, C, A> {}
|
||
|
||
impl<'a, C, A> ProjectUndeleteCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub fn doit(mut self) -> Result<(hyper::client::Response, Empty)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
|
||
let mut dd = DefaultDelegate;
|
||
let mut dlg: &mut Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(MethodInfo { id: "cloudresourcemanager.projects.undelete",
|
||
http_method: hyper::method::Method::Post });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len()));
|
||
params.push(("projectId", self._project_id.to_string()));
|
||
for &field in ["alt", "projectId"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(Error::FieldClash(field));
|
||
}
|
||
}
|
||
for (name, value) in self._additional_params.iter() {
|
||
params.push((&name, value.clone()));
|
||
}
|
||
|
||
params.push(("alt", "json".to_string()));
|
||
|
||
let mut url = "https://cloudresourcemanager.googleapis.com/v1/projects/{projectId}:undelete".to_string();
|
||
if self._scopes.len() == 0 {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string(), ());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{projectId}", "projectId")].iter() {
|
||
let mut replace_with: Option<&str> = None;
|
||
for &(name, ref value) in params.iter() {
|
||
if name == param_name {
|
||
replace_with = Some(value);
|
||
break;
|
||
}
|
||
}
|
||
url = url.replace(find_this, replace_with.expect("to find substitution value in params"));
|
||
}
|
||
{
|
||
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(1);
|
||
for param_name in ["projectId"].iter() {
|
||
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
|
||
indices_for_removal.push(index);
|
||
}
|
||
}
|
||
for &index in indices_for_removal.iter() {
|
||
params.remove(index);
|
||
}
|
||
}
|
||
|
||
if params.len() > 0 {
|
||
url.push('?');
|
||
url.push_str(&url::form_urlencoded::serialize(params));
|
||
}
|
||
|
||
let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default());
|
||
let mut request_value_reader =
|
||
{
|
||
let mut value = json::value::to_value(&self._request);
|
||
remove_json_null_values(&mut value);
|
||
let mut dst = io::Cursor::new(Vec::with_capacity(128));
|
||
json::to_writer(&mut dst, &value).unwrap();
|
||
dst
|
||
};
|
||
let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap();
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
|
||
Ok(token) => token,
|
||
Err(err) => {
|
||
match dlg.token(&*err) {
|
||
Some(token) => token,
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(Error::MissingToken(err))
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let auth_header = Authorization(Bearer { token: token.access_token });
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
let mut req_result = {
|
||
let mut client = &mut *self.hub.client.borrow_mut();
|
||
let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url)
|
||
.header(UserAgent(self.hub._user_agent.clone()))
|
||
.header(auth_header.clone())
|
||
.header(ContentType(json_mime_type.clone()))
|
||
.header(ContentLength(request_size as u64))
|
||
.body(&mut request_value_reader);
|
||
|
||
dlg.pre_request();
|
||
req.send()
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status.is_success() {
|
||
let mut json_err = String::new();
|
||
res.read_to_string(&mut json_err).unwrap();
|
||
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
|
||
json::from_str(&json_err).ok(),
|
||
json::from_str(&json_err).ok()) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return match json::from_str::<ErrorResponse>(&json_err){
|
||
Err(_) => Err(Error::Failure(res)),
|
||
Ok(serr) => Err(Error::BadRequest(serr))
|
||
}
|
||
}
|
||
let result_value = {
|
||
let mut json_response = String::new();
|
||
res.read_to_string(&mut json_response).unwrap();
|
||
match json::from_str(&json_response) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&json_response, &err);
|
||
return Err(Error::JsonDecodeError(json_response, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
///
|
||
/// Sets the *request* property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn request(mut self, new_value: UndeleteProjectRequest) -> ProjectUndeleteCall<'a, C, A> {
|
||
self._request = new_value;
|
||
self
|
||
}
|
||
/// The project ID (for example, `foo-bar-123`). Required.
|
||
///
|
||
/// Sets the *project id* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn project_id(mut self, new_value: &str) -> ProjectUndeleteCall<'a, C, A> {
|
||
self._project_id = new_value.to_string();
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectUndeleteCall<'a, C, A> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known paramters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *bearer_token* (query-string) - OAuth bearer token.
|
||
/// * *pp* (query-boolean) - Pretty-print response.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectUndeleteCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
|
||
/// `Scope::CloudPlatform`.
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<T>(mut self, scope: T) -> ProjectUndeleteCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._scopes.insert(scope.as_ref().to_string(), ());
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Sets the IAM access control policy for the specified Project. Replaces any existing policy. The following constraints apply when using `setIamPolicy()`: + Project does not support `allUsers` and `allAuthenticatedUsers` as `members` in a `Binding` of a `Policy`. + The owner role can be granted only to `user` and `serviceAccount`. + Service accounts can be made owners of a project directly without any restrictions. However, to be added as an owner, a user must be invited via Cloud Platform console and must accept the invitation. + A user cannot be granted the owner role using `setIamPolicy()`. The user must be granted the owner role using the Cloud Platform Console and must explicitly accept the invitation. + Invitations to grant the owner role cannot be sent using `setIamPolicy()`; they must be sent only using the Cloud Platform Console. + Membership changes that leave the project without any owners that have accepted the Terms of Service (ToS) will be rejected. + Members cannot be added to more than one role in the same policy. + There must be at least one owner who has accepted the Terms of Service (ToS) agreement in the policy. Calling `setIamPolicy()` to to remove the last ToS-accepted owner from the policy will fail. This restriction also applies to legacy projects that no longer have owners who have accepted the ToS. Edits to IAM policies will be rejected until the lack of a ToS-accepting owner is rectified. + Calling this method requires enabling the App Engine Admin API. Note: Removing service accounts from policies or changing their roles can render services completely inoperable. It is important to understand how the service account is being used before removing or updating its roles.
|
||
///
|
||
/// A builder for the *setIamPolicy* method supported by a *project* resource.
|
||
/// It is not used directly, but through a `ProjectMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate yup_oauth2 as oauth2;
|
||
/// # extern crate google_cloudresourcemanager1 as cloudresourcemanager1;
|
||
/// use cloudresourcemanager1::SetIamPolicyRequest;
|
||
/// # #[test] fn egal() {
|
||
/// # use std::default::Default;
|
||
/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
|
||
/// # use cloudresourcemanager1::CloudResourceManager;
|
||
///
|
||
/// # let secret: ApplicationSecret = Default::default();
|
||
/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
|
||
/// # hyper::Client::new(),
|
||
/// # <MemoryStorage as Default>::default(), None);
|
||
/// # let mut hub = CloudResourceManager::new(hyper::Client::new(), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = SetIamPolicyRequest::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().set_iam_policy(req, "resource")
|
||
/// .doit();
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectSetIamPolicyCall<'a, C, A>
|
||
where C: 'a, A: 'a {
|
||
|
||
hub: &'a CloudResourceManager<C, A>,
|
||
_request: SetIamPolicyRequest,
|
||
_resource: String,
|
||
_delegate: Option<&'a mut Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeMap<String, ()>
|
||
}
|
||
|
||
impl<'a, C, A> CallBuilder for ProjectSetIamPolicyCall<'a, C, A> {}
|
||
|
||
impl<'a, C, A> ProjectSetIamPolicyCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub fn doit(mut self) -> Result<(hyper::client::Response, Policy)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
|
||
let mut dd = DefaultDelegate;
|
||
let mut dlg: &mut Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(MethodInfo { id: "cloudresourcemanager.projects.setIamPolicy",
|
||
http_method: hyper::method::Method::Post });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len()));
|
||
params.push(("resource", self._resource.to_string()));
|
||
for &field in ["alt", "resource"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(Error::FieldClash(field));
|
||
}
|
||
}
|
||
for (name, value) in self._additional_params.iter() {
|
||
params.push((&name, value.clone()));
|
||
}
|
||
|
||
params.push(("alt", "json".to_string()));
|
||
|
||
let mut url = "https://cloudresourcemanager.googleapis.com/v1/projects/{resource}:setIamPolicy".to_string();
|
||
if self._scopes.len() == 0 {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string(), ());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{resource}", "resource")].iter() {
|
||
let mut replace_with: Option<&str> = None;
|
||
for &(name, ref value) in params.iter() {
|
||
if name == param_name {
|
||
replace_with = Some(value);
|
||
break;
|
||
}
|
||
}
|
||
url = url.replace(find_this, replace_with.expect("to find substitution value in params"));
|
||
}
|
||
{
|
||
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(1);
|
||
for param_name in ["resource"].iter() {
|
||
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
|
||
indices_for_removal.push(index);
|
||
}
|
||
}
|
||
for &index in indices_for_removal.iter() {
|
||
params.remove(index);
|
||
}
|
||
}
|
||
|
||
if params.len() > 0 {
|
||
url.push('?');
|
||
url.push_str(&url::form_urlencoded::serialize(params));
|
||
}
|
||
|
||
let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default());
|
||
let mut request_value_reader =
|
||
{
|
||
let mut value = json::value::to_value(&self._request);
|
||
remove_json_null_values(&mut value);
|
||
let mut dst = io::Cursor::new(Vec::with_capacity(128));
|
||
json::to_writer(&mut dst, &value).unwrap();
|
||
dst
|
||
};
|
||
let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap();
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
|
||
Ok(token) => token,
|
||
Err(err) => {
|
||
match dlg.token(&*err) {
|
||
Some(token) => token,
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(Error::MissingToken(err))
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let auth_header = Authorization(Bearer { token: token.access_token });
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
let mut req_result = {
|
||
let mut client = &mut *self.hub.client.borrow_mut();
|
||
let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url)
|
||
.header(UserAgent(self.hub._user_agent.clone()))
|
||
.header(auth_header.clone())
|
||
.header(ContentType(json_mime_type.clone()))
|
||
.header(ContentLength(request_size as u64))
|
||
.body(&mut request_value_reader);
|
||
|
||
dlg.pre_request();
|
||
req.send()
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status.is_success() {
|
||
let mut json_err = String::new();
|
||
res.read_to_string(&mut json_err).unwrap();
|
||
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
|
||
json::from_str(&json_err).ok(),
|
||
json::from_str(&json_err).ok()) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return match json::from_str::<ErrorResponse>(&json_err){
|
||
Err(_) => Err(Error::Failure(res)),
|
||
Ok(serr) => Err(Error::BadRequest(serr))
|
||
}
|
||
}
|
||
let result_value = {
|
||
let mut json_response = String::new();
|
||
res.read_to_string(&mut json_response).unwrap();
|
||
match json::from_str(&json_response) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&json_response, &err);
|
||
return Err(Error::JsonDecodeError(json_response, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
///
|
||
/// Sets the *request* property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn request(mut self, new_value: SetIamPolicyRequest) -> ProjectSetIamPolicyCall<'a, C, A> {
|
||
self._request = new_value;
|
||
self
|
||
}
|
||
/// REQUIRED: The resource for which the policy is being specified. `resource` is usually specified as a path, such as `projects/*project*/zones/*zone*/disks/*disk*`. The format for the path specified in this value is resource specific and is specified in the `setIamPolicy` documentation.
|
||
///
|
||
/// Sets the *resource* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn resource(mut self, new_value: &str) -> ProjectSetIamPolicyCall<'a, C, A> {
|
||
self._resource = new_value.to_string();
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSetIamPolicyCall<'a, C, A> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known paramters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *bearer_token* (query-string) - OAuth bearer token.
|
||
/// * *pp* (query-boolean) - Pretty-print response.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectSetIamPolicyCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
|
||
/// `Scope::CloudPlatform`.
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<T>(mut self, scope: T) -> ProjectSetIamPolicyCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._scopes.insert(scope.as_ref().to_string(), ());
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Retrieves the Project identified by the specified `project_id` (for example, `my-project-123`). The caller must have read permissions for this Project.
|
||
///
|
||
/// A builder for the *get* method supported by a *project* resource.
|
||
/// It is not used directly, but through a `ProjectMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate yup_oauth2 as oauth2;
|
||
/// # extern crate google_cloudresourcemanager1 as cloudresourcemanager1;
|
||
/// # #[test] fn egal() {
|
||
/// # use std::default::Default;
|
||
/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
|
||
/// # use cloudresourcemanager1::CloudResourceManager;
|
||
///
|
||
/// # let secret: ApplicationSecret = Default::default();
|
||
/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
|
||
/// # hyper::Client::new(),
|
||
/// # <MemoryStorage as Default>::default(), None);
|
||
/// # let mut hub = CloudResourceManager::new(hyper::Client::new(), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().get("projectId")
|
||
/// .doit();
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectGetCall<'a, C, A>
|
||
where C: 'a, A: 'a {
|
||
|
||
hub: &'a CloudResourceManager<C, A>,
|
||
_project_id: String,
|
||
_delegate: Option<&'a mut Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeMap<String, ()>
|
||
}
|
||
|
||
impl<'a, C, A> CallBuilder for ProjectGetCall<'a, C, A> {}
|
||
|
||
impl<'a, C, A> ProjectGetCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub fn doit(mut self) -> Result<(hyper::client::Response, Project)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
|
||
let mut dd = DefaultDelegate;
|
||
let mut dlg: &mut Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(MethodInfo { id: "cloudresourcemanager.projects.get",
|
||
http_method: hyper::method::Method::Get });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity((3 + self._additional_params.len()));
|
||
params.push(("projectId", self._project_id.to_string()));
|
||
for &field in ["alt", "projectId"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(Error::FieldClash(field));
|
||
}
|
||
}
|
||
for (name, value) in self._additional_params.iter() {
|
||
params.push((&name, value.clone()));
|
||
}
|
||
|
||
params.push(("alt", "json".to_string()));
|
||
|
||
let mut url = "https://cloudresourcemanager.googleapis.com/v1/projects/{projectId}".to_string();
|
||
if self._scopes.len() == 0 {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string(), ());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{projectId}", "projectId")].iter() {
|
||
let mut replace_with: Option<&str> = None;
|
||
for &(name, ref value) in params.iter() {
|
||
if name == param_name {
|
||
replace_with = Some(value);
|
||
break;
|
||
}
|
||
}
|
||
url = url.replace(find_this, replace_with.expect("to find substitution value in params"));
|
||
}
|
||
{
|
||
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(1);
|
||
for param_name in ["projectId"].iter() {
|
||
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
|
||
indices_for_removal.push(index);
|
||
}
|
||
}
|
||
for &index in indices_for_removal.iter() {
|
||
params.remove(index);
|
||
}
|
||
}
|
||
|
||
if params.len() > 0 {
|
||
url.push('?');
|
||
url.push_str(&url::form_urlencoded::serialize(params));
|
||
}
|
||
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
|
||
Ok(token) => token,
|
||
Err(err) => {
|
||
match dlg.token(&*err) {
|
||
Some(token) => token,
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(Error::MissingToken(err))
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let auth_header = Authorization(Bearer { token: token.access_token });
|
||
let mut req_result = {
|
||
let mut client = &mut *self.hub.client.borrow_mut();
|
||
let mut req = client.borrow_mut().request(hyper::method::Method::Get, &url)
|
||
.header(UserAgent(self.hub._user_agent.clone()))
|
||
.header(auth_header.clone());
|
||
|
||
dlg.pre_request();
|
||
req.send()
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status.is_success() {
|
||
let mut json_err = String::new();
|
||
res.read_to_string(&mut json_err).unwrap();
|
||
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
|
||
json::from_str(&json_err).ok(),
|
||
json::from_str(&json_err).ok()) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return match json::from_str::<ErrorResponse>(&json_err){
|
||
Err(_) => Err(Error::Failure(res)),
|
||
Ok(serr) => Err(Error::BadRequest(serr))
|
||
}
|
||
}
|
||
let result_value = {
|
||
let mut json_response = String::new();
|
||
res.read_to_string(&mut json_response).unwrap();
|
||
match json::from_str(&json_response) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&json_response, &err);
|
||
return Err(Error::JsonDecodeError(json_response, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// The Project ID (for example, `my-project-123`). Required.
|
||
///
|
||
/// Sets the *project id* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn project_id(mut self, new_value: &str) -> ProjectGetCall<'a, C, A> {
|
||
self._project_id = new_value.to_string();
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectGetCall<'a, C, A> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known paramters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *bearer_token* (query-string) - OAuth bearer token.
|
||
/// * *pp* (query-boolean) - Pretty-print response.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectGetCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
|
||
/// `Scope::CloudPlatform`.
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<T>(mut self, scope: T) -> ProjectGetCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._scopes.insert(scope.as_ref().to_string(), ());
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Returns the IAM access control policy for the specified Project. Permission is denied if the policy or the resource does not exist.
|
||
///
|
||
/// A builder for the *getIamPolicy* method supported by a *project* resource.
|
||
/// It is not used directly, but through a `ProjectMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate yup_oauth2 as oauth2;
|
||
/// # extern crate google_cloudresourcemanager1 as cloudresourcemanager1;
|
||
/// use cloudresourcemanager1::GetIamPolicyRequest;
|
||
/// # #[test] fn egal() {
|
||
/// # use std::default::Default;
|
||
/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
|
||
/// # use cloudresourcemanager1::CloudResourceManager;
|
||
///
|
||
/// # let secret: ApplicationSecret = Default::default();
|
||
/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
|
||
/// # hyper::Client::new(),
|
||
/// # <MemoryStorage as Default>::default(), None);
|
||
/// # let mut hub = CloudResourceManager::new(hyper::Client::new(), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = GetIamPolicyRequest::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().get_iam_policy(req, "resource")
|
||
/// .doit();
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectGetIamPolicyCall<'a, C, A>
|
||
where C: 'a, A: 'a {
|
||
|
||
hub: &'a CloudResourceManager<C, A>,
|
||
_request: GetIamPolicyRequest,
|
||
_resource: String,
|
||
_delegate: Option<&'a mut Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeMap<String, ()>
|
||
}
|
||
|
||
impl<'a, C, A> CallBuilder for ProjectGetIamPolicyCall<'a, C, A> {}
|
||
|
||
impl<'a, C, A> ProjectGetIamPolicyCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub fn doit(mut self) -> Result<(hyper::client::Response, Policy)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
|
||
let mut dd = DefaultDelegate;
|
||
let mut dlg: &mut Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(MethodInfo { id: "cloudresourcemanager.projects.getIamPolicy",
|
||
http_method: hyper::method::Method::Post });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len()));
|
||
params.push(("resource", self._resource.to_string()));
|
||
for &field in ["alt", "resource"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(Error::FieldClash(field));
|
||
}
|
||
}
|
||
for (name, value) in self._additional_params.iter() {
|
||
params.push((&name, value.clone()));
|
||
}
|
||
|
||
params.push(("alt", "json".to_string()));
|
||
|
||
let mut url = "https://cloudresourcemanager.googleapis.com/v1/projects/{resource}:getIamPolicy".to_string();
|
||
if self._scopes.len() == 0 {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string(), ());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{resource}", "resource")].iter() {
|
||
let mut replace_with: Option<&str> = None;
|
||
for &(name, ref value) in params.iter() {
|
||
if name == param_name {
|
||
replace_with = Some(value);
|
||
break;
|
||
}
|
||
}
|
||
url = url.replace(find_this, replace_with.expect("to find substitution value in params"));
|
||
}
|
||
{
|
||
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(1);
|
||
for param_name in ["resource"].iter() {
|
||
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
|
||
indices_for_removal.push(index);
|
||
}
|
||
}
|
||
for &index in indices_for_removal.iter() {
|
||
params.remove(index);
|
||
}
|
||
}
|
||
|
||
if params.len() > 0 {
|
||
url.push('?');
|
||
url.push_str(&url::form_urlencoded::serialize(params));
|
||
}
|
||
|
||
let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default());
|
||
let mut request_value_reader =
|
||
{
|
||
let mut value = json::value::to_value(&self._request);
|
||
remove_json_null_values(&mut value);
|
||
let mut dst = io::Cursor::new(Vec::with_capacity(128));
|
||
json::to_writer(&mut dst, &value).unwrap();
|
||
dst
|
||
};
|
||
let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap();
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
|
||
Ok(token) => token,
|
||
Err(err) => {
|
||
match dlg.token(&*err) {
|
||
Some(token) => token,
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(Error::MissingToken(err))
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let auth_header = Authorization(Bearer { token: token.access_token });
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
let mut req_result = {
|
||
let mut client = &mut *self.hub.client.borrow_mut();
|
||
let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url)
|
||
.header(UserAgent(self.hub._user_agent.clone()))
|
||
.header(auth_header.clone())
|
||
.header(ContentType(json_mime_type.clone()))
|
||
.header(ContentLength(request_size as u64))
|
||
.body(&mut request_value_reader);
|
||
|
||
dlg.pre_request();
|
||
req.send()
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status.is_success() {
|
||
let mut json_err = String::new();
|
||
res.read_to_string(&mut json_err).unwrap();
|
||
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
|
||
json::from_str(&json_err).ok(),
|
||
json::from_str(&json_err).ok()) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return match json::from_str::<ErrorResponse>(&json_err){
|
||
Err(_) => Err(Error::Failure(res)),
|
||
Ok(serr) => Err(Error::BadRequest(serr))
|
||
}
|
||
}
|
||
let result_value = {
|
||
let mut json_response = String::new();
|
||
res.read_to_string(&mut json_response).unwrap();
|
||
match json::from_str(&json_response) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&json_response, &err);
|
||
return Err(Error::JsonDecodeError(json_response, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
///
|
||
/// Sets the *request* property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn request(mut self, new_value: GetIamPolicyRequest) -> ProjectGetIamPolicyCall<'a, C, A> {
|
||
self._request = new_value;
|
||
self
|
||
}
|
||
/// REQUIRED: The resource for which the policy is being requested. `resource` is usually specified as a path, such as `projects/*project*/zones/*zone*/disks/*disk*`. The format for the path specified in this value is resource specific and is specified in the `getIamPolicy` documentation.
|
||
///
|
||
/// Sets the *resource* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn resource(mut self, new_value: &str) -> ProjectGetIamPolicyCall<'a, C, A> {
|
||
self._resource = new_value.to_string();
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectGetIamPolicyCall<'a, C, A> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known paramters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *bearer_token* (query-string) - OAuth bearer token.
|
||
/// * *pp* (query-boolean) - Pretty-print response.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectGetIamPolicyCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
|
||
/// `Scope::CloudPlatform`.
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<T>(mut self, scope: T) -> ProjectGetIamPolicyCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._scopes.insert(scope.as_ref().to_string(), ());
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Updates the attributes of the Project identified by the specified `project_id` (for example, `my-project-123`). The caller must have modify permissions for this Project.
|
||
///
|
||
/// A builder for the *update* method supported by a *project* resource.
|
||
/// It is not used directly, but through a `ProjectMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate yup_oauth2 as oauth2;
|
||
/// # extern crate google_cloudresourcemanager1 as cloudresourcemanager1;
|
||
/// use cloudresourcemanager1::Project;
|
||
/// # #[test] fn egal() {
|
||
/// # use std::default::Default;
|
||
/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
|
||
/// # use cloudresourcemanager1::CloudResourceManager;
|
||
///
|
||
/// # let secret: ApplicationSecret = Default::default();
|
||
/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
|
||
/// # hyper::Client::new(),
|
||
/// # <MemoryStorage as Default>::default(), None);
|
||
/// # let mut hub = CloudResourceManager::new(hyper::Client::new(), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = Project::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().update(req, "projectId")
|
||
/// .doit();
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectUpdateCall<'a, C, A>
|
||
where C: 'a, A: 'a {
|
||
|
||
hub: &'a CloudResourceManager<C, A>,
|
||
_request: Project,
|
||
_project_id: String,
|
||
_delegate: Option<&'a mut Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeMap<String, ()>
|
||
}
|
||
|
||
impl<'a, C, A> CallBuilder for ProjectUpdateCall<'a, C, A> {}
|
||
|
||
impl<'a, C, A> ProjectUpdateCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub fn doit(mut self) -> Result<(hyper::client::Response, Project)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
|
||
let mut dd = DefaultDelegate;
|
||
let mut dlg: &mut Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(MethodInfo { id: "cloudresourcemanager.projects.update",
|
||
http_method: hyper::method::Method::Put });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len()));
|
||
params.push(("projectId", self._project_id.to_string()));
|
||
for &field in ["alt", "projectId"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(Error::FieldClash(field));
|
||
}
|
||
}
|
||
for (name, value) in self._additional_params.iter() {
|
||
params.push((&name, value.clone()));
|
||
}
|
||
|
||
params.push(("alt", "json".to_string()));
|
||
|
||
let mut url = "https://cloudresourcemanager.googleapis.com/v1/projects/{projectId}".to_string();
|
||
if self._scopes.len() == 0 {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string(), ());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{projectId}", "projectId")].iter() {
|
||
let mut replace_with: Option<&str> = None;
|
||
for &(name, ref value) in params.iter() {
|
||
if name == param_name {
|
||
replace_with = Some(value);
|
||
break;
|
||
}
|
||
}
|
||
url = url.replace(find_this, replace_with.expect("to find substitution value in params"));
|
||
}
|
||
{
|
||
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(1);
|
||
for param_name in ["projectId"].iter() {
|
||
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
|
||
indices_for_removal.push(index);
|
||
}
|
||
}
|
||
for &index in indices_for_removal.iter() {
|
||
params.remove(index);
|
||
}
|
||
}
|
||
|
||
if params.len() > 0 {
|
||
url.push('?');
|
||
url.push_str(&url::form_urlencoded::serialize(params));
|
||
}
|
||
|
||
let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default());
|
||
let mut request_value_reader =
|
||
{
|
||
let mut value = json::value::to_value(&self._request);
|
||
remove_json_null_values(&mut value);
|
||
let mut dst = io::Cursor::new(Vec::with_capacity(128));
|
||
json::to_writer(&mut dst, &value).unwrap();
|
||
dst
|
||
};
|
||
let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap();
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
|
||
Ok(token) => token,
|
||
Err(err) => {
|
||
match dlg.token(&*err) {
|
||
Some(token) => token,
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(Error::MissingToken(err))
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let auth_header = Authorization(Bearer { token: token.access_token });
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
let mut req_result = {
|
||
let mut client = &mut *self.hub.client.borrow_mut();
|
||
let mut req = client.borrow_mut().request(hyper::method::Method::Put, &url)
|
||
.header(UserAgent(self.hub._user_agent.clone()))
|
||
.header(auth_header.clone())
|
||
.header(ContentType(json_mime_type.clone()))
|
||
.header(ContentLength(request_size as u64))
|
||
.body(&mut request_value_reader);
|
||
|
||
dlg.pre_request();
|
||
req.send()
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status.is_success() {
|
||
let mut json_err = String::new();
|
||
res.read_to_string(&mut json_err).unwrap();
|
||
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
|
||
json::from_str(&json_err).ok(),
|
||
json::from_str(&json_err).ok()) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return match json::from_str::<ErrorResponse>(&json_err){
|
||
Err(_) => Err(Error::Failure(res)),
|
||
Ok(serr) => Err(Error::BadRequest(serr))
|
||
}
|
||
}
|
||
let result_value = {
|
||
let mut json_response = String::new();
|
||
res.read_to_string(&mut json_response).unwrap();
|
||
match json::from_str(&json_response) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&json_response, &err);
|
||
return Err(Error::JsonDecodeError(json_response, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
///
|
||
/// Sets the *request* property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn request(mut self, new_value: Project) -> ProjectUpdateCall<'a, C, A> {
|
||
self._request = new_value;
|
||
self
|
||
}
|
||
/// The project ID (for example, `my-project-123`). Required.
|
||
///
|
||
/// Sets the *project id* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn project_id(mut self, new_value: &str) -> ProjectUpdateCall<'a, C, A> {
|
||
self._project_id = new_value.to_string();
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectUpdateCall<'a, C, A> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known paramters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *bearer_token* (query-string) - OAuth bearer token.
|
||
/// * *pp* (query-boolean) - Pretty-print response.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectUpdateCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
|
||
/// `Scope::CloudPlatform`.
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<T>(mut self, scope: T) -> ProjectUpdateCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._scopes.insert(scope.as_ref().to_string(), ());
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Marks the Project identified by the specified `project_id` (for example, `my-project-123`) for deletion. This method will only affect the Project if the following criteria are met: + The Project does not have a billing account associated with it. + The Project has a lifecycle state of ACTIVE. This method changes the Project's lifecycle state from ACTIVE to DELETE_REQUESTED. The deletion starts at an unspecified time, at which point the Project is no longer accessible. Until the deletion completes, you can check the lifecycle state checked by retrieving the Project with GetProject, and the Project remains visible to ListProjects. However, you cannot update the project. After the deletion completes, the Project is not retrievable by the GetProject and ListProjects methods. The caller must have modify permissions for this Project.
|
||
///
|
||
/// A builder for the *delete* method supported by a *project* resource.
|
||
/// It is not used directly, but through a `ProjectMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate yup_oauth2 as oauth2;
|
||
/// # extern crate google_cloudresourcemanager1 as cloudresourcemanager1;
|
||
/// # #[test] fn egal() {
|
||
/// # use std::default::Default;
|
||
/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
|
||
/// # use cloudresourcemanager1::CloudResourceManager;
|
||
///
|
||
/// # let secret: ApplicationSecret = Default::default();
|
||
/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
|
||
/// # hyper::Client::new(),
|
||
/// # <MemoryStorage as Default>::default(), None);
|
||
/// # let mut hub = CloudResourceManager::new(hyper::Client::new(), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().delete("projectId")
|
||
/// .doit();
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectDeleteCall<'a, C, A>
|
||
where C: 'a, A: 'a {
|
||
|
||
hub: &'a CloudResourceManager<C, A>,
|
||
_project_id: String,
|
||
_delegate: Option<&'a mut Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeMap<String, ()>
|
||
}
|
||
|
||
impl<'a, C, A> CallBuilder for ProjectDeleteCall<'a, C, A> {}
|
||
|
||
impl<'a, C, A> ProjectDeleteCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub fn doit(mut self) -> Result<(hyper::client::Response, Empty)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
|
||
let mut dd = DefaultDelegate;
|
||
let mut dlg: &mut Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(MethodInfo { id: "cloudresourcemanager.projects.delete",
|
||
http_method: hyper::method::Method::Delete });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity((3 + self._additional_params.len()));
|
||
params.push(("projectId", self._project_id.to_string()));
|
||
for &field in ["alt", "projectId"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(Error::FieldClash(field));
|
||
}
|
||
}
|
||
for (name, value) in self._additional_params.iter() {
|
||
params.push((&name, value.clone()));
|
||
}
|
||
|
||
params.push(("alt", "json".to_string()));
|
||
|
||
let mut url = "https://cloudresourcemanager.googleapis.com/v1/projects/{projectId}".to_string();
|
||
if self._scopes.len() == 0 {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string(), ());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{projectId}", "projectId")].iter() {
|
||
let mut replace_with: Option<&str> = None;
|
||
for &(name, ref value) in params.iter() {
|
||
if name == param_name {
|
||
replace_with = Some(value);
|
||
break;
|
||
}
|
||
}
|
||
url = url.replace(find_this, replace_with.expect("to find substitution value in params"));
|
||
}
|
||
{
|
||
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(1);
|
||
for param_name in ["projectId"].iter() {
|
||
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
|
||
indices_for_removal.push(index);
|
||
}
|
||
}
|
||
for &index in indices_for_removal.iter() {
|
||
params.remove(index);
|
||
}
|
||
}
|
||
|
||
if params.len() > 0 {
|
||
url.push('?');
|
||
url.push_str(&url::form_urlencoded::serialize(params));
|
||
}
|
||
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
|
||
Ok(token) => token,
|
||
Err(err) => {
|
||
match dlg.token(&*err) {
|
||
Some(token) => token,
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(Error::MissingToken(err))
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let auth_header = Authorization(Bearer { token: token.access_token });
|
||
let mut req_result = {
|
||
let mut client = &mut *self.hub.client.borrow_mut();
|
||
let mut req = client.borrow_mut().request(hyper::method::Method::Delete, &url)
|
||
.header(UserAgent(self.hub._user_agent.clone()))
|
||
.header(auth_header.clone());
|
||
|
||
dlg.pre_request();
|
||
req.send()
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status.is_success() {
|
||
let mut json_err = String::new();
|
||
res.read_to_string(&mut json_err).unwrap();
|
||
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
|
||
json::from_str(&json_err).ok(),
|
||
json::from_str(&json_err).ok()) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return match json::from_str::<ErrorResponse>(&json_err){
|
||
Err(_) => Err(Error::Failure(res)),
|
||
Ok(serr) => Err(Error::BadRequest(serr))
|
||
}
|
||
}
|
||
let result_value = {
|
||
let mut json_response = String::new();
|
||
res.read_to_string(&mut json_response).unwrap();
|
||
match json::from_str(&json_response) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&json_response, &err);
|
||
return Err(Error::JsonDecodeError(json_response, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// The Project ID (for example, `foo-bar-123`). Required.
|
||
///
|
||
/// Sets the *project id* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn project_id(mut self, new_value: &str) -> ProjectDeleteCall<'a, C, A> {
|
||
self._project_id = new_value.to_string();
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectDeleteCall<'a, C, A> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known paramters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *bearer_token* (query-string) - OAuth bearer token.
|
||
/// * *pp* (query-boolean) - Pretty-print response.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectDeleteCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
|
||
/// `Scope::CloudPlatform`.
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<T>(mut self, scope: T) -> ProjectDeleteCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._scopes.insert(scope.as_ref().to_string(), ());
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Lists Projects that are visible to the user and satisfy the specified filter. This method returns Projects in an unspecified order. New Projects do not necessarily appear at the end of the list.
|
||
///
|
||
/// A builder for the *list* method supported by a *project* resource.
|
||
/// It is not used directly, but through a `ProjectMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate yup_oauth2 as oauth2;
|
||
/// # extern crate google_cloudresourcemanager1 as cloudresourcemanager1;
|
||
/// # #[test] fn egal() {
|
||
/// # use std::default::Default;
|
||
/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
|
||
/// # use cloudresourcemanager1::CloudResourceManager;
|
||
///
|
||
/// # let secret: ApplicationSecret = Default::default();
|
||
/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
|
||
/// # hyper::Client::new(),
|
||
/// # <MemoryStorage as Default>::default(), None);
|
||
/// # let mut hub = CloudResourceManager::new(hyper::Client::new(), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().list()
|
||
/// .page_token("nonumy")
|
||
/// .page_size(-19)
|
||
/// .filter("gubergren")
|
||
/// .doit();
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectListCall<'a, C, A>
|
||
where C: 'a, A: 'a {
|
||
|
||
hub: &'a CloudResourceManager<C, A>,
|
||
_page_token: Option<String>,
|
||
_page_size: Option<i32>,
|
||
_filter: Option<String>,
|
||
_delegate: Option<&'a mut Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeMap<String, ()>
|
||
}
|
||
|
||
impl<'a, C, A> CallBuilder for ProjectListCall<'a, C, A> {}
|
||
|
||
impl<'a, C, A> ProjectListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub fn doit(mut self) -> Result<(hyper::client::Response, ListProjectsResponse)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
|
||
let mut dd = DefaultDelegate;
|
||
let mut dlg: &mut Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(MethodInfo { id: "cloudresourcemanager.projects.list",
|
||
http_method: hyper::method::Method::Get });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity((5 + self._additional_params.len()));
|
||
if let Some(value) = self._page_token {
|
||
params.push(("pageToken", value.to_string()));
|
||
}
|
||
if let Some(value) = self._page_size {
|
||
params.push(("pageSize", value.to_string()));
|
||
}
|
||
if let Some(value) = self._filter {
|
||
params.push(("filter", value.to_string()));
|
||
}
|
||
for &field in ["alt", "pageToken", "pageSize", "filter"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(Error::FieldClash(field));
|
||
}
|
||
}
|
||
for (name, value) in self._additional_params.iter() {
|
||
params.push((&name, value.clone()));
|
||
}
|
||
|
||
params.push(("alt", "json".to_string()));
|
||
|
||
let mut url = "https://cloudresourcemanager.googleapis.com/v1/projects".to_string();
|
||
if self._scopes.len() == 0 {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string(), ());
|
||
}
|
||
|
||
|
||
if params.len() > 0 {
|
||
url.push('?');
|
||
url.push_str(&url::form_urlencoded::serialize(params));
|
||
}
|
||
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
|
||
Ok(token) => token,
|
||
Err(err) => {
|
||
match dlg.token(&*err) {
|
||
Some(token) => token,
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(Error::MissingToken(err))
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let auth_header = Authorization(Bearer { token: token.access_token });
|
||
let mut req_result = {
|
||
let mut client = &mut *self.hub.client.borrow_mut();
|
||
let mut req = client.borrow_mut().request(hyper::method::Method::Get, &url)
|
||
.header(UserAgent(self.hub._user_agent.clone()))
|
||
.header(auth_header.clone());
|
||
|
||
dlg.pre_request();
|
||
req.send()
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status.is_success() {
|
||
let mut json_err = String::new();
|
||
res.read_to_string(&mut json_err).unwrap();
|
||
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
|
||
json::from_str(&json_err).ok(),
|
||
json::from_str(&json_err).ok()) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return match json::from_str::<ErrorResponse>(&json_err){
|
||
Err(_) => Err(Error::Failure(res)),
|
||
Ok(serr) => Err(Error::BadRequest(serr))
|
||
}
|
||
}
|
||
let result_value = {
|
||
let mut json_response = String::new();
|
||
res.read_to_string(&mut json_response).unwrap();
|
||
match json::from_str(&json_response) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&json_response, &err);
|
||
return Err(Error::JsonDecodeError(json_response, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// A pagination token returned from a previous call to ListProjects that indicates from where listing should continue. Optional.
|
||
///
|
||
/// Sets the *page token* query property to the given value.
|
||
pub fn page_token(mut self, new_value: &str) -> ProjectListCall<'a, C, A> {
|
||
self._page_token = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The maximum number of Projects to return in the response. The server can return fewer Projects than requested. If unspecified, server picks an appropriate default. Optional.
|
||
///
|
||
/// Sets the *page size* query property to the given value.
|
||
pub fn page_size(mut self, new_value: i32) -> ProjectListCall<'a, C, A> {
|
||
self._page_size = Some(new_value);
|
||
self
|
||
}
|
||
/// An expression for filtering the results of the request. Filter rules are case insensitive. The fields eligible for filtering are: + `name` + `id` + labels.key where *key* is the name of a label Some examples of using labels as filters: |Filter|Description| |------|-----------| |name:*|The project has a name.| |name:Howl|The project's name is `Howl` or `howl`.| |name:HOWL|Equivalent to above.| |NAME:howl|Equivalent to above.| |labels.color:*|The project has the label `color`.| |labels.color:red|The project's label `color` has the value `red`.| |labels.color:red label.size:big|The project's label `color` has the value `red` and its label `size` has the value `big`. Optional.
|
||
///
|
||
/// Sets the *filter* query property to the given value.
|
||
pub fn filter(mut self, new_value: &str) -> ProjectListCall<'a, C, A> {
|
||
self._filter = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectListCall<'a, C, A> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known paramters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *bearer_token* (query-string) - OAuth bearer token.
|
||
/// * *pp* (query-boolean) - Pretty-print response.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectListCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
|
||
/// `Scope::CloudPlatform`.
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<T>(mut self, scope: T) -> ProjectListCall<'a, C, A>
|
||
where T: AsRef<str> {
|
||
self._scopes.insert(scope.as_ref().to_string(), ());
|
||
self
|
||
}
|
||
}
|
||
|
||
|