OMGeeky/google-apis-rs
1
0
Fork 0
mirror of https://github.com/OMGeeky/google-apis-rs.git synced 2026-02-23 15:49:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

Bump version to 1.0.9; update JSON schemas; add new APIs

Browse Source
This commit is contained in:
Sebastian Thiel
2019-07-05 11:32:35 +08:00
parent 99e97ceece
commit e42ebc0c2b
2442 changed files with 190984 additions and 71186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
gen/monitoring3/src/cmn.rs
View File

@@ -748,6 +748,17 @@ pub fn remove_json_null_values(value: &mut json::value::Value) {
map.remove(key);
}
}
json::value::Value::Array(ref mut arr) => {
let mut i = 0;
while i < arr.len() {
if arr[i].is_null() {
arr.remove(i);
} else {
remove_json_null_values(&mut arr[i]);
i += 1;
}
}
}
_ => {}
}
}

46
gen/monitoring3/src/lib.rs
View File

@@ -2,7 +2,7 @@
// This file was generated automatically from 'src/mako/api/lib.rs.mako'
// DO NOT EDIT !
//! This documentation was generated from *Monitoring* crate version *1.0.8+20190331*, where *20190331* is the exact revision of the *monitoring:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v1.0.8*.
//! This documentation was generated from *Monitoring* crate version *1.0.9+20190629*, where *20190629* is the exact revision of the *monitoring:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v1.0.9*.
//!
//! Everything else about the *Monitoring* *v3* API can be found at the
//! [official documentation site](https://cloud.google.com/monitoring/api/).
@@ -220,9 +220,7 @@ use std::mem;
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};
pub use cmn::*;
// ##############
@@ -341,7 +339,7 @@ impl<'a, C, A> Monitoring<C, A>
Monitoring {
client: RefCell::new(client),
auth: RefCell::new(authenticator),
_user_agent: "google-api-rust-client/1.0.8".to_string(),
_user_agent: "google-api-rust-client/1.0.9".to_string(),
_base_url: "https://monitoring.googleapis.com/".to_string(),
_root_url: "https://monitoring.googleapis.com/".to_string(),
}
@@ -355,7 +353,7 @@ impl<'a, C, A> Monitoring<C, A>
}
/// Set the user-agent header field to use in all requests to the server.
/// It defaults to `google-api-rust-client/1.0.8`.
/// It defaults to `google-api-rust-client/1.0.9`.
///
/// Returns the previously set user-agent.
pub fn user_agent(&mut self, agent_name: String) -> String {
@@ -618,7 +616,7 @@ pub struct MetricDescriptorMetadata {
/// The delay of data points caused by ingestion. Data points older than this age are guaranteed to be ingested and available to be read, excluding data loss due to errors.
#[serde(rename="ingestDelay")]
pub ingest_delay: Option<String>,
/// The launch stage of the metric definition.
/// Deprecated. Please use the MetricDescriptor.launch_stage instead. The launch stage of the metric definition.
#[serde(rename="launchStage")]
pub launch_stage: Option<String>,
/// The sampling period of metric data points. For metrics which are written periodically, consecutive data points are stored at this time interval, excluding data loss due to errors. Metrics with a higher granularity have a smaller sampling period.
@@ -699,14 +697,7 @@ pub struct SendNotificationChannelVerificationCodeRequest { _never_set: Option<b
impl RequestValue for SendNotificationChannelVerificationCodeRequest {}
/// 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 needsOverviewThe 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 that can be used for common error conditions.Language mappingThe 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 usesThe 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.
/// 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.
/// 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). Each Status message contains three pieces of data: error code, error message, and error details.You can find out more about this error model and how to work with it in the API Design Guide (https://cloud.google.com/apis/design/errors).
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
@@ -897,7 +888,10 @@ pub struct Condition {
impl Part for Condition {}
/// A time interval extending just after a start time through an end time. The start time must not be later than the end time. The default start time is the end time, making the startTime value technically optional. Whether this is useful depends on the MetricKind. If the start and end times are the same, the interval represents a point in time. This is appropriate for GAUGE metrics, but not for DELTA and CUMULATIVE metrics, which cover a span of time.
/// A closed time interval. It extends from the start time to the end time, and includes both: [startTime, endTime]. Valid time intervals depend on the MetricKind of the metric value. In no case can the end time be earlier than the start time.
/// For a GAUGE metric, the startTime value is technically optional; if no value is specified, the start time defaults to the value of the end time, and the interval represents a single point in time. Such an interval is valid only for GAUGE metrics, which are point-in-time measurements.
/// For DELTA and CUMULATIVE metrics, the start time must be later than the end time.
/// In all cases, the start time of the next interval must be at least a microsecond after the end time of the previous interval. Because the interval is closed, if the start time of a new interval is the same as the end time of the previous interval, data written at the new start time could overwrite data written at the previous end time.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
@@ -1305,8 +1299,11 @@ pub struct MetricDescriptor {
pub value_type: Option<String>,
/// The set of labels that can be used to describe a specific instance of this metric type. For example, the appengine.googleapis.com/http/server/response_latencies metric type has a label for the HTTP response code, response_code, so you can look at latencies for successful responses or just for responses that failed.
pub labels: Option<Vec<LabelDescriptor>>,
/// The resource name of the metric descriptor.
pub name: Option<String>,
/// Optional. The launch stage of the metric definition.
#[serde(rename="launchStage")]
pub launch_stage: Option<String>,
/// Optional. Metadata which can be used to guide usage of the metric.
pub metadata: Option<MetricDescriptorMetadata>,
/// The metric type, including its DNS name prefix. The type is not URL-encoded. All user-defined metric types have the DNS name custom.googleapis.com or external.googleapis.com. Metric types should use a natural hierarchical grouping. For example:
/// "custom.googleapis.com/invoice/paid/amount"
/// "external.googleapis.com/prometheus/up"
@@ -1357,8 +1354,8 @@ pub struct MetricDescriptor {
/// 1 represents dimensionless value 1, such as in 1/s.
/// % represents dimensionless value 1/100, and annotates values giving a percentage.
pub unit: Option<String>,
/// Optional. Metadata which can be used to guide usage of the metric.
pub metadata: Option<MetricDescriptorMetadata>,
/// The resource name of the metric descriptor.
pub name: Option<String>,
}
impl RequestValue for MetricDescriptor {}
@@ -1475,13 +1472,16 @@ pub struct MonitoredResourceDescriptor {
/// Optional. A concise name for the monitored resource type that might be displayed in user interfaces. It should be a Title Cased Noun Phrase, without any article or other determiners. For example, "Google Cloud SQL Database".
#[serde(rename="displayName")]
pub display_name: Option<String>,
/// Optional. A detailed description of the monitored resource type that might be used in documentation.
pub description: Option<String>,
/// Required. A set of labels used to describe instances of this monitored resource type. For example, an individual Google Cloud SQL database is identified by values for the labels "database_id" and "zone".
pub labels: Option<Vec<LabelDescriptor>>,
/// Required. The monitored resource type. For example, the type "cloudsql_database" represents databases in Google Cloud SQL. The maximum length of this value is 256 characters.
#[serde(rename="type")]
pub type_: Option<String>,
/// Optional. A detailed description of the monitored resource type that might be used in documentation.
pub description: Option<String>,
/// Optional. The launch stage of the monitored resource definition.
#[serde(rename="launchStage")]
pub launch_stage: Option<String>,
/// Optional. The resource name of the monitored resource descriptor: "projects/{project_id}/monitoredResourceDescriptors/{type}" where {type} is the value of the type field in this object and {project_id} is a project ID that provides API-specific context for accessing the type. APIs that do not use project information can use the resource name format "monitoredResourceDescriptors/{type}".
pub name: Option<String>,
}
@@ -6912,7 +6912,7 @@ impl<'a, C, A> ProjectTimeSeryListCall<'a, C, A> where C: BorrowMut<hyper::Clien
}
/// A monitoring filter that specifies which time series should be returned. The filter must specify a single metric type, and can additionally specify metric labels and other information. For example:
/// metric.type = "compute.googleapis.com/instance/cpu/usage_time" AND
/// metric.label.instance_name = "my-instance-name"
/// metric.labels.instance_name = "my-instance-name"
///
///
/// Sets the *filter* query property to the given value.