talksik/nirvana-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
talksik
2021-12-29 01:57:42 -08:00
commit ce39a60b42
4634 changed files with 997667 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
node_modules/google-gax/protos/google/monitoring/v3/uptime.proto
Generated Vendored
+403
View File
@@ -0,0 +1,403 @@
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";
package google.monitoring.v3;
import "google/api/monitored_resource.proto";
import "google/api/resource.proto";
import "google/protobuf/duration.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "UptimeProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
option ruby_package = "Google::Cloud::Monitoring::V3";
// The regions from which an Uptime check can be run.
enum UptimeCheckRegion {
// Default value if no region is specified. Will result in Uptime checks
// running from all regions.
REGION_UNSPECIFIED = 0;
// Allows checks to run from locations within the United States of America.
USA = 1;
// Allows checks to run from locations within the continent of Europe.
EUROPE = 2;
// Allows checks to run from locations within the continent of South
// America.
SOUTH_AMERICA = 3;
// Allows checks to run from locations within the Asia Pacific area (ex:
// Singapore).
ASIA_PACIFIC = 4;
}
// An internal checker allows Uptime checks to run on private/internal GCP
// resources.
message InternalChecker {
option deprecated = true;
// Operational states for an internal checker.
enum State {
// An internal checker should never be in the unspecified state.
UNSPECIFIED = 0;
// The checker is being created, provisioned, and configured. A checker in
// this state can be returned by `ListInternalCheckers` or
// `GetInternalChecker`, as well as by examining the [long running
// Operation](https://cloud.google.com/apis/design/design_patterns#long_running_operations)
// that created it.
CREATING = 1;
// The checker is running and available for use. A checker in this state
// can be returned by `ListInternalCheckers` or `GetInternalChecker` as
// well as by examining the [long running
// Operation](https://cloud.google.com/apis/design/design_patterns#long_running_operations)
// that created it.
// If a checker is being torn down, it is neither visible nor usable, so
// there is no "deleting" or "down" state.
RUNNING = 2;
}
// A unique resource name for this InternalChecker. The format is:
//
// projects/[PROJECT_ID_OR_NUMBER]/internalCheckers/[INTERNAL_CHECKER_ID]
//
// `[PROJECT_ID_OR_NUMBER]` is the Stackdriver Workspace project for the
// Uptime check config associated with the internal checker.
string name = 1;
// The checker's human-readable name. The display name
// should be unique within a Stackdriver Workspace in order to make it easier
// to identify; however, uniqueness is not enforced.
string display_name = 2;
// The [GCP VPC network](https://cloud.google.com/vpc/docs/vpc) where the
// internal resource lives (ex: "default").
string network = 3;
// The GCP zone the Uptime check should egress from. Only respected for
// internal Uptime checks, where internal_network is specified.
string gcp_zone = 4;
// The GCP project ID where the internal checker lives. Not necessary
// the same as the Workspace project.
string peer_project_id = 6;
// The current operational state of the internal checker.
State state = 7;
}
// This message configures which resources and services to monitor for
// availability.
message UptimeCheckConfig {
option (google.api.resource) = {
type: "monitoring.googleapis.com/UptimeCheckConfig"
pattern: "projects/{project}/uptimeCheckConfigs/{uptime_check_config}"
pattern: "organizations/{organization}/uptimeCheckConfigs/{uptime_check_config}"
pattern: "folders/{folder}/uptimeCheckConfigs/{uptime_check_config}"
pattern: "*"
};
// The resource submessage for group checks. It can be used instead of a
// monitored resource, when multiple resources are being monitored.
message ResourceGroup {
// The group of resources being monitored. Should be only the `[GROUP_ID]`,
// and not the full-path
// `projects/[PROJECT_ID_OR_NUMBER]/groups/[GROUP_ID]`.
string group_id = 1;
// The resource type of the group members.
GroupResourceType resource_type = 2;
}
// Information involved in an HTTP/HTTPS Uptime check request.
message HttpCheck {
// The authentication parameters to provide to the specified resource or
// URL that requires a username and password. Currently, only
// [Basic HTTP authentication](https://tools.ietf.org/html/rfc7617) is
// supported in Uptime checks.
message BasicAuthentication {
// The username to use when authenticating with the HTTP server.
string username = 1;
// The password to use when authenticating with the HTTP server.
string password = 2;
}
// The HTTP request method options.
enum RequestMethod {
// No request method specified.
METHOD_UNSPECIFIED = 0;
// GET request.
GET = 1;
// POST request.
POST = 2;
}
// Header options corresponding to the content type of a HTTP request body.
enum ContentType {
// No content type specified.
TYPE_UNSPECIFIED = 0;
// `body` is in URL-encoded form. Equivalent to setting the `Content-Type`
// to `application/x-www-form-urlencoded` in the HTTP request.
URL_ENCODED = 1;
}
// The HTTP request method to use for the check. If set to
// `METHOD_UNSPECIFIED` then `request_method` defaults to `GET`.
RequestMethod request_method = 8;
// If `true`, use HTTPS instead of HTTP to run the check.
bool use_ssl = 1;
// Optional (defaults to "/"). The path to the page against which to run
// the check. Will be combined with the `host` (specified within the
// `monitored_resource`) and `port` to construct the full URL. If the
// provided path does not begin with "/", a "/" will be prepended
// automatically.
string path = 2;
// Optional (defaults to 80 when `use_ssl` is `false`, and 443 when
// `use_ssl` is `true`). The TCP port on the HTTP server against which to
// run the check. Will be combined with host (specified within the
// `monitored_resource`) and `path` to construct the full URL.
int32 port = 3;
// The authentication information. Optional when creating an HTTP check;
// defaults to empty.
BasicAuthentication auth_info = 4;
// Boolean specifying whether to encrypt the header information.
// Encryption should be specified for any headers related to authentication
// that you do not wish to be seen when retrieving the configuration. The
// server will be responsible for encrypting the headers.
// On Get/List calls, if `mask_headers` is set to `true` then the headers
// will be obscured with `******.`
bool mask_headers = 5;
// The list of headers to send as part of the Uptime check request.
// If two headers have the same key and different values, they should
// be entered as a single header, with the value being a comma-separated
// list of all the desired values as described at
// https://www.w3.org/Protocols/rfc2616/rfc2616.txt (page 31).
// Entering two separate headers with the same key in a Create call will
// cause the first to be overwritten by the second.
// The maximum number of headers allowed is 100.
map<string, string> headers = 6;
// The content type header to use for the check. The following
// configurations result in errors:
// 1. Content type is specified in both the `headers` field and the
// `content_type` field.
// 2. Request method is `GET` and `content_type` is not `TYPE_UNSPECIFIED`
// 3. Request method is `POST` and `content_type` is `TYPE_UNSPECIFIED`.
// 4. Request method is `POST` and a "Content-Type" header is provided via
// `headers` field. The `content_type` field should be used instead.
ContentType content_type = 9;
// Boolean specifying whether to include SSL certificate validation as a
// part of the Uptime check. Only applies to checks where
// `monitored_resource` is set to `uptime_url`. If `use_ssl` is `false`,
// setting `validate_ssl` to `true` has no effect.
bool validate_ssl = 7;
// The request body associated with the HTTP POST request. If `content_type`
// is `URL_ENCODED`, the body passed in must be URL-encoded. Users can
// provide a `Content-Length` header via the `headers` field or the API will
// do so. If the `request_method` is `GET` and `body` is not empty, the API
// will return an error. The maximum byte size is 1 megabyte. Note: As with
// all `bytes` fields, JSON representations are base64 encoded. e.g.:
// "foo=bar" in URL-encoded form is "foo%3Dbar" and in base64 encoding is
// "Zm9vJTI1M0RiYXI=".
bytes body = 10;
}
// Information required for a TCP Uptime check request.
message TcpCheck {
// The TCP port on the server against which to run the check. Will be
// combined with host (specified within the `monitored_resource`) to
// construct the full URL. Required.
int32 port = 1;
}
// Optional. Used to perform content matching. This allows matching based on
// substrings and regular expressions, together with their negations. Only the
// first 4&nbsp;MB of an HTTP or HTTPS check's response (and the first
// 1&nbsp;MB of a TCP check's response) are examined for purposes of content
// matching.
message ContentMatcher {
// Options to perform content matching.
enum ContentMatcherOption {
// No content matcher type specified (maintained for backward
// compatibility, but deprecated for future use).
// Treated as `CONTAINS_STRING`.
CONTENT_MATCHER_OPTION_UNSPECIFIED = 0;
// Selects substring matching. The match succeeds if the output contains
// the `content` string. This is the default value for checks without
// a `matcher` option, or where the value of `matcher` is
// `CONTENT_MATCHER_OPTION_UNSPECIFIED`.
CONTAINS_STRING = 1;
// Selects negation of substring matching. The match succeeds if the
// output does _NOT_ contain the `content` string.
NOT_CONTAINS_STRING = 2;
// Selects regular-expression matching. The match succeeds of the output
// matches the regular expression specified in the `content` string.
// Regex matching is only supported for HTTP/HTTPS checks.
MATCHES_REGEX = 3;
// Selects negation of regular-expression matching. The match succeeds if
// the output does _NOT_ match the regular expression specified in the
// `content` string. Regex matching is only supported for HTTP/HTTPS
// checks.
NOT_MATCHES_REGEX = 4;
}
// String or regex content to match. Maximum 1024 bytes. An empty `content`
// string indicates no content matching is to be performed.
string content = 1;
// The type of content matcher that will be applied to the server output,
// compared to the `content` string when the check is run.
ContentMatcherOption matcher = 2;
}
// A unique resource name for this Uptime check configuration. The format is:
//
// projects/[PROJECT_ID_OR_NUMBER]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
//
// `[PROJECT_ID_OR_NUMBER]` is the Workspace host project associated with the
// Uptime check.
//
// This field should be omitted when creating the Uptime check configuration;
// on create, the resource name is assigned by the server and included in the
// response.
string name = 1;
// A human-friendly name for the Uptime check configuration. The display name
// should be unique within a Stackdriver Workspace in order to make it easier
// to identify; however, uniqueness is not enforced. Required.
string display_name = 2;
// The resource the check is checking. Required.
oneof resource {
// The [monitored
// resource](https://cloud.google.com/monitoring/api/resources) associated
// with the configuration.
// The following monitored resource types are valid for this field:
// `uptime_url`,
// `gce_instance`,
// `gae_app`,
// `aws_ec2_instance`,
// `aws_elb_load_balancer`
// `k8s_service`
google.api.MonitoredResource monitored_resource = 3;
// The group resource associated with the configuration.
ResourceGroup resource_group = 4;
}
// The type of Uptime check request.
oneof check_request_type {
// Contains information needed to make an HTTP or HTTPS check.
HttpCheck http_check = 5;
// Contains information needed to make a TCP check.
TcpCheck tcp_check = 6;
}
// How often, in seconds, the Uptime check is performed.
// Currently, the only supported values are `60s` (1 minute), `300s`
// (5 minutes), `600s` (10 minutes), and `900s` (15 minutes). Optional,
// defaults to `60s`.
google.protobuf.Duration period = 7;
// The maximum amount of time to wait for the request to complete (must be
// between 1 and 60 seconds). Required.
google.protobuf.Duration timeout = 8;
// The content that is expected to appear in the data returned by the target
// server against which the check is run. Currently, only the first entry
// in the `content_matchers` list is supported, and additional entries will
// be ignored. This field is optional and should only be specified if a
// content match is required as part of the/ Uptime check.
repeated ContentMatcher content_matchers = 9;
// The list of regions from which the check will be run.
// Some regions contain one location, and others contain more than one.
// If this field is specified, enough regions must be provided to include a
// minimum of 3 locations. Not specifying this field will result in Uptime
// checks running from all available regions.
repeated UptimeCheckRegion selected_regions = 10;
// If this is `true`, then checks are made only from the 'internal_checkers'.
// If it is `false`, then checks are made only from the 'selected_regions'.
// It is an error to provide 'selected_regions' when is_internal is `true`,
// or to provide 'internal_checkers' when is_internal is `false`.
bool is_internal = 15 [deprecated = true];
// The internal checkers that this check will egress from. If `is_internal` is
// `true` and this list is empty, the check will egress from all the
// InternalCheckers configured for the project that owns this
// `UptimeCheckConfig`.
repeated InternalChecker internal_checkers = 14 [deprecated = true];
}
// Contains the region, location, and list of IP
// addresses where checkers in the location run from.
message UptimeCheckIp {
// A broad region category in which the IP address is located.
UptimeCheckRegion region = 1;
// A more specific location within the region that typically encodes
// a particular city/town/metro (and its containing state/province or country)
// within the broader umbrella region category.
string location = 2;
// The IP address from which the Uptime check originates. This is a fully
// specified IP address (not an IP address range). Most IP addresses, as of
// this publication, are in IPv4 format; however, one should not rely on the
// IP addresses being in IPv4 format indefinitely, and should support
// interpreting this field in either IPv4 or IPv6 format.
string ip_address = 3;
}
// The supported resource types that can be used as values of
// `group_resource.resource_type`.
// `INSTANCE` includes `gce_instance` and `aws_ec2_instance` resource types.
// The resource types `gae_app` and `uptime_url` are not valid here because
// group checks on App Engine modules and URLs are not allowed.
enum GroupResourceType {
// Default value (not valid).
RESOURCE_TYPE_UNSPECIFIED = 0;
// A group of instances from Google Cloud Platform (GCP) or
// Amazon Web Services (AWS).
INSTANCE = 1;
// A group of Amazon ELB load balancers.
AWS_ELB_LOAD_BALANCER = 2;
}