From acb5253cd11cd43cab93eb153d6e48ba0fa5303d Mon Sep 17 00:00:00 2001 From: Google APIs Date: Thu, 31 Jan 2019 07:53:43 -0800 Subject: [PATCH] Synchronize new proto/yaml changes. PiperOrigin-RevId: 231786007 --- google/cloud/irm/artman_irm_v1alpha2.yaml | 34 + google/cloud/irm/irm_v1alpha2.yaml | 12 + google/cloud/irm/v1alpha2/incidents.proto | 429 +++++++++ .../irm/v1alpha2/incidents_service.proto | 867 ++++++++++++++++++ google/cloud/irm/v1alpha2/irm_gapic.yaml | 603 ++++++++++++ 5 files changed, 1945 insertions(+) create mode 100644 google/cloud/irm/artman_irm_v1alpha2.yaml create mode 100644 google/cloud/irm/irm_v1alpha2.yaml create mode 100644 google/cloud/irm/v1alpha2/incidents.proto create mode 100644 google/cloud/irm/v1alpha2/incidents_service.proto create mode 100644 google/cloud/irm/v1alpha2/irm_gapic.yaml diff --git a/google/cloud/irm/artman_irm_v1alpha2.yaml b/google/cloud/irm/artman_irm_v1alpha2.yaml new file mode 100644 index 00000000..90ace2b9 --- /dev/null +++ b/google/cloud/irm/artman_irm_v1alpha2.yaml @@ -0,0 +1,34 @@ +common: + api_name: irm + api_version: v1alpha2 + organization_name: google-cloud + proto_deps: + - name: google-common-protos + src_proto_paths: + - v1alpha2 + service_yaml: irm_v1alpha2.yaml + gapic_yaml: v1alpha2/irm_gapic.yaml +artifacts: +- name: gapic_config + type: GAPIC_CONFIG +- name: java_gapic + type: GAPIC + language: JAVA +- name: python_gapic + type: GAPIC + language: PYTHON +- name: nodejs_gapic + type: GAPIC + language: NODEJS +- name: php_gapic + type: GAPIC + language: PHP +- name: go_gapic + type: GAPIC + language: GO +- name: ruby_gapic + type: GAPIC + language: RUBY +- name: csharp_gapic + type: GAPIC + language: CSHARP diff --git a/google/cloud/irm/irm_v1alpha2.yaml b/google/cloud/irm/irm_v1alpha2.yaml new file mode 100644 index 00000000..dd6a98be --- /dev/null +++ b/google/cloud/irm/irm_v1alpha2.yaml @@ -0,0 +1,12 @@ +type: google.api.Service +config_version: 3 +name: irm.googleapis.com +title: Stackdriver Incident Response & Management API + +apis: +- name: google.cloud.irm.v1alpha2.IncidentService + +documentation: + overview: |- + The Stackdriver Incident Response & Management API provides access to + incident data. diff --git a/google/cloud/irm/v1alpha2/incidents.proto b/google/cloud/irm/v1alpha2/incidents.proto new file mode 100644 index 00000000..4397a998 --- /dev/null +++ b/google/cloud/irm/v1alpha2/incidents.proto @@ -0,0 +1,429 @@ +// Copyright 2018 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.cloud.irm.v1alpha2; + +import "google/api/annotations.proto"; +import "google/monitoring/v3/metric_service.proto"; +import "google/protobuf/timestamp.proto"; + +option cc_enable_arenas = true; +option go_package = "google.golang.org/genproto/googleapis/cloud/irm/v1alpha2;irm"; +option java_multiple_files = true; +option java_package = "com.google.irm.service.v1alpha2.api"; + + +// A user of the IRM app. +message User { + // One of several ways to uniquely identify a user. + oneof user { + // Output only. User id that will allow to get additional information from + // People API. This field will be populated implicitly if the caller creates + // or edits a resource (e.g. posts an annotation). + string user_id = 1; + + // Email address of the user. This must be associated with a Google account. + // This field will be set if the user is explicitly identified (verbatim) by + // email address in an API request (potentially sometime in the past). It + // will not be populated based on the credentials of a caller of the API. + string email = 2; + } +} + +// A signal is a message calling attention to a (potential) incident. An example +// is a page based on a Stackdriver Alerting policy. +// go/irm-glossary#signal +message Signal { + // Describes whether the alerting condition is still firing. + enum State { + // Unspecified + STATE_UNSPECIFIED = 0; + + // Firing + STATE_OPEN = 1; + + // Non-firing + STATE_CLOSED = 2; + } + + // Resource name of the signal, e.g. + // "projects/{project_id}/signals/{signal_id}". + string name = 1; + + // Etag to validate the object is unchanged for a read-modify-write operation. + // An empty etag will overwrite other changes. + string etag = 2; + + // Resource name of the incident this signal is currently assigned to. + // May be empty if signal is unassigned. + string incident = 3; + + // Output only. Time this signal was created. + google.protobuf.Timestamp create_time = 4; + + // Output only. The user that created this signal for manually created + // signals. Empty if this signal was generated by a system (e.g. an + // alerting system). + User creator = 5; + + // One-line summary of the signal. + // Immutable. + string title = 6; + + // Content type string, e.g. 'text/plain' or'text/html'. + string content_type = 7; + + // Full message of the signal. + // Immutable. + string content = 8; + + // Output only. The state of this signal. + State signal_state = 9; +} + +// A text annotation by a user. +message Annotation { + // Resource name of the annotation, e.g. + // "projects/{project_id}/incidents/{incident_id}/annotations/{annotation_id}". + string name = 1; + + // Output only. Author of the annotation. + User author = 2; + + // Output only. Time the annotation was created. + google.protobuf.Timestamp create_time = 3; + + // Content of the annotation. Immutable. + string content = 4; +} + +// A tag by a user. +message Tag { + // Resource name of a tag, e.g., + // "projects/{project_id}/incidents/{incident_id}/tags/{tag_id}" + string name = 1; + + // Display name of the resource (e.g., "cause:rollout"). Immutable. + string display_name = 2; + + // Output only. For some tags (e.g., "bug:123"), provide a link to the + // underlying resource. Optional. + string url = 3; +} + +// Synopsis is a summary of an incident and it contains a textual content, +// an author and a last updated timestamp. +message Synopsis { + // Content type string, e.g. 'text/plain' or 'text/html'. + string content_type = 1; + + // Textual content of the synopsis. It can be plain text or markdown as + // indicated by the content_type. + string content = 2; + + // Last updated timestamp. + google.protobuf.Timestamp update_time = 3; + + // Author of the synopsis. + User author = 4; +} + +// Representation of an incident. +message Incident { + // Specifies the escalation level of this incident, within the IRM protocol + // for handling incidents. + enum EscalationLevel { + // The incident has not been escalated. This is the value used by all new + // and legacy incidents. + ESCALATION_LEVEL_UNSPECIFIED = 0; + + // The incident has been escalated to the organizational level. + ESCALATION_LEVEL_ORGANIZATION = 1; + } + + // Severity of an incident. + enum Severity { + // Severity is not specified. + SEVERITY_UNSPECIFIED = 0; + + // Huge incident. + SEVERITY_HUGE = 1; + + // Major incident. + SEVERITY_MAJOR = 2; + + // Medium incident. + SEVERITY_MEDIUM = 3; + + // Minor incident. + SEVERITY_MINOR = 4; + + // Negligible incident. + SEVERITY_NEGLIGIBLE = 5; + } + + // Stage of an incident. + enum Stage { + // This is the default value if no stage has been specified. + // Note: The caller of the API should set the stage to DETECTED. + STAGE_UNSPECIFIED = 0; + + // The incident has been detected. This is the initial stage of a new + // incident. + // Note: The caller still has to set the stage manually. + STAGE_DETECTED = 4; + + // This incident has been formally characterized. + STAGE_TRIAGED = 1; + + // This incident has been mitigated, i.e. does not affect the service level + // anymore. + STAGE_MITIGATED = 2; + + // This incident has been fully resolved, i.e. there are no immediate + // follow-up tasks. + STAGE_RESOLVED = 3; + + // Postmortem for the incident was written. + STAGE_DOCUMENTED = 5; + } + + // Output only. Resource name of the incident, e.g. + // "projects/{project_id}/incidents/{incident_id}". + string name = 1; + + // One-line summary of the incident. + string title = 2; + + // Escalation level of the incident. + EscalationLevel escalation_level = 3; + + // Etag to validate the object is unchanged for a read-modify-write operation. + // An empty etag will overwrite other changes. + string etag = 4; + + // Severity of the incident. + Severity severity = 5; + + // Stage of the incident. + Stage stage = 6; + + // Output only. Time this incident started. Used to measure the 'elapsed + // time'. Start time of an incident is the earliest creation time of any of + // its Signals or the create time of the incident if no Signals are assigned. + google.protobuf.Timestamp start_time = 7; + + // Output only. Synopsis of this incident. + Synopsis synopsis = 8; +} + +// Describes a role that can be assigned to an incident. +message IncidentRole { + // List of possible roles. + enum Type { + // The role is unspecified. + TYPE_UNSPECIFIED = 0; + + // Incident Commander: Manages response plan, near-term and long-term + // objectives, establishes priorities, and delegates tasks as needed. + TYPE_INCIDENT_COMMANDER = 1; + + // Communications Lead: Keeps everybody outside and within the response team + // informed. + TYPE_COMMUNICATIONS_LEAD = 2; + + // Operations Lead: Figures out what to do, and gets it done. + TYPE_OPERATIONS_LEAD = 3; + + // External Customer Communications Lead: Responsible for communicating + // incident details to customers/public. + TYPE_EXTERNAL_CUSTOMER_COMMUNICATIONS_LEAD = 4; + + // Primary Oncall: Responds to the initial page and handles all + // responsibilities for pre-escalated incidents. + TYPE_PRIMARY_ONCALL = 5; + + // Secondary Oncall: Helps the primary oncall if necessary; mostly useful + // for pre-escalated incidents. + TYPE_SECONDARY_ONCALL = 6; + + // User-specified roles. One example is a Planning Lead, who keeps track of + // the incident. Another is an assistant Incident Commander. + TYPE_OTHER = 7; + } + + // The type of role. The role type is immutable in role assignments. Each role + // type can only be used once per incident, except for TYPE_OTHER. + Type type = 1; + + // Output only unless TYPE_OTHER is used. Title of the role. For TYPE_OTHER, + // must be unique within an incident. + string title = 2; + + // Output only unless TYPE_OTHER is used. Description of the role. + string description = 3; +} + +// Stores the assignee of a role as well as the proposed next assignee. +message IncidentRoleAssignment { + // Output only. Resource name such as + // "projects/{project_id}/incidents/{incident_id}/role_assignments/{role_id}". + string name = 1; + + // Output only. Etag for this version of the resource. Must be specified in + // update requests and match the current version in storage. Must not be + // modified by the client. + string etag = 2; + + // The role that is or will be assigned. + IncidentRole role = 3; + + // The user this role is assigned to. This field can only be directly set + // during creation request. Subsequent updates are done via the + // IncidentRoleHandover methods. + User assignee = 4; + + // The recipient of a requested role handoff. This field can only be directly + // set during creation request. Subsequent updates are done via the + // IncidentRoleHandover methods. + // + // `assignee` is always the current role-holder, and `proposed_assignee` is + // used to track unfinished assignments and handoffs. Let's say Bob assigns + // Alice to a role. Then the fields are: + // `assignee`: nil, `proposed_assignee`: Alice + // If Alice accepts, then the fields are: + // `assignee`: Alice, `proposed_assignee`: nil + // If she cancels, then the RoleAssignment is deleted. + // Let's say Alice has the role. Then the fields are: + // `assignee`: Alice, `proposed_assignee`: nil + // If Alice is hit by a bus and Bob requests Carol to take over, then the + // fields are: + // `assignee`: Alice, `proposed_assignee`: Carol + // After Carol accepts the handover, the fields are: + // `assignee`: Carol, `proposed_assignee`: nil + // Or if Carol refuses the handover, the fields are: + // `assignee`: Alice, `proposed_assignee`: nil + User proposed_assignee = 5; +} + +// External artifact associated to an incident. +message Artifact { + // Possible types of an artifact. + enum Type { + // External type is unspecified. + TYPE_UNSPECIFIED = 0; + + // URL. + TYPE_URL = 1; + + // An issue. + TYPE_ISSUE = 2; + + // A source control change. + TYPE_SOURCE_CONTROL_CHANGE = 3; + + // A JIRA issue. + TYPE_JIRA_ISSUE = 4; + } + + // Output only. Resource name such as + // "projects/{project_id}/incidents/{incident_id}/artifacts/{artifact_id}". + string name = 1; + + // User provided name of an artifact. + string display_name = 2; + + // Output only. Etag for this version of the resource. Must be specified in + // update requests and match the current version in storage. Must not be + // modified by the client. + string etag = 3; + + // URL to access the artifact. + string url = 4; + + // Type of this artifact. + Type type = 5; +} + +// Communication Channels are mechanisms used to receive notifications +// about changes to incidents. +message CommunicationChannel { + // A communication channel that delivers messages to an email address. + message Email { + // The email address, e.g. "user@example.com". + string address = 1; + } + + // A communication channel that delivers messages to a Stackdriver + // notification channel. + message NotificationChannel { + // Stackdriver notification channel name. + string name = 1; + } + + // An endpoint describes how messages will be delivered. + oneof endpoint { + // Messages will be delivered via email. + Email email = 1; + + // Messages will be delivered via a Stackdriver notification channel. + NotificationChannel notification_channel = 2; + } +} + +// A subscription allows users to get notifications about changes to +// an incident. +message Subscription { + // Types of changes that users can subscribe to in an incident. + enum EventType { + // An event_type that's not specified is an error. + EVENT_TYPE_UNSPECIFIED = 0; + + // The incident's title has changed. + EVENT_TYPE_TITLE_CHANGE = 1; + + // The incident's synopsis has changed. + EVENT_TYPE_SYNOPSIS_CHANGE = 2; + + // The incident's stage has changed. + EVENT_TYPE_STAGE_CHANGE = 3; + + // The incident's severity has changed. + EVENT_TYPE_SEVERITY_CHANGE = 4; + + // A new annotation has been added to the incident. + EVENT_TYPE_ANNOTATION_ADD = 5; + + // An annotation has been modified. + EVENT_TYPE_ANNOTATION_CHANGE = 6; + } + + // Output only. Resource name such as + // "projects/{project_id}/incidents/{incident_id}/subscriptions/{subscription_id}". + string name = 1; + + // Output only. Etag for this version of the resource. Must be specified in + // update requests and match the current version in storage. Must not be + // modified by the client. + string etag = 2; + + // A communications channel to send subscription messages to. + CommunicationChannel subscription_channel = 3; + + // Types of events this subscription receives notifications for. + repeated EventType event_types = 4; +} diff --git a/google/cloud/irm/v1alpha2/incidents_service.proto b/google/cloud/irm/v1alpha2/incidents_service.proto new file mode 100644 index 00000000..b6c89393 --- /dev/null +++ b/google/cloud/irm/v1alpha2/incidents_service.proto @@ -0,0 +1,867 @@ +// Copyright 2018 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.cloud.irm.v1alpha2; + +import "google/api/annotations.proto"; +import "google/cloud/irm/v1alpha2/incidents.proto"; +import "google/protobuf/empty.proto"; +import "google/protobuf/field_mask.proto"; +import "google/protobuf/timestamp.proto"; + +option cc_enable_arenas = true; +option go_package = "google.golang.org/genproto/googleapis/cloud/irm/v1alpha2;irm"; +option java_multiple_files = true; +option java_package = "com.google.irm.service.v1alpha2.api"; + + +// The Incident API for Incident Response & Management. +service IncidentService { + // Creates a new incident. + rpc CreateIncident(CreateIncidentRequest) returns (Incident) { + option (google.api.http) = { + post: "/v1alpha2/{parent=projects/*}/incidents" + body: "incident" + }; + } + + // Returns an incident by name. + rpc GetIncident(GetIncidentRequest) returns (Incident) { + option (google.api.http) = { + get: "/v1alpha2/{name=projects/*/incidents/*}" + }; + } + + // Returns a list of incidents. + // Incidents are ordered by start time, with the most recent incidents first. + rpc SearchIncidents(SearchIncidentsRequest) returns (SearchIncidentsResponse) { + option (google.api.http) = { + get: "/v1alpha2/{parent=projects/*}/incidents:search" + }; + } + + // Updates an existing incident. + rpc UpdateIncident(UpdateIncidentRequest) returns (Incident) { + option (google.api.http) = { + patch: "/v1alpha2/{incident.name=projects/*/incidents/*}" + body: "incident" + }; + } + + // Returns a list of incidents that are "similar" to the specified incident + // or signal. This functionality is provided on a best-effort basis and the + // definition of "similar" is subject to change. + rpc SearchSimilarIncidents(SearchSimilarIncidentsRequest) returns (SearchSimilarIncidentsResponse) { + option (google.api.http) = { + get: "/v1alpha2/{name=projects/*/incidents/*}:searchSimilar" + additional_bindings { + get: "/v1alpha2/{name=projects/*/signals/*}:searchSimilarIncidents" + } + }; + } + + // Creates an annotation on an existing incident. Only 'text/plain' and + // 'text/markdown' annotations can be created via this method. + rpc CreateAnnotation(CreateAnnotationRequest) returns (Annotation) { + option (google.api.http) = { + post: "/v1alpha2/{parent=projects/*/incidents/*}/annotations" + body: "annotation" + }; + } + + // Lists annotations that are part of an incident. No assumptions should be + // made on the content-type of the annotation returned. + rpc ListAnnotations(ListAnnotationsRequest) returns (ListAnnotationsResponse) { + option (google.api.http) = { + get: "/v1alpha2/{parent=projects/*/incidents/*}/annotations" + }; + } + + // Updates an annotation on an existing incident. + rpc UpdateAnnotation(UpdateAnnotationRequest) returns (Annotation) { + option (google.api.http) = { + patch: "/v1alpha2/{annotation.name=projects/*/incidents/*/annotations/*}" + body: "annotation" + }; + } + + // Creates a tag on an existing incident. + rpc CreateTag(CreateTagRequest) returns (Tag) { + option (google.api.http) = { + post: "/v1alpha2/{parent=projects/*/incidents/*}/tags" + body: "tag" + }; + } + + // Deletes an existing tag. + rpc DeleteTag(DeleteTagRequest) returns (google.protobuf.Empty) { + option (google.api.http) = { + delete: "/v1alpha2/{name=projects/*/incidents/*/tags/*}" + }; + } + + // Lists tags that are part of an incident. + rpc ListTags(ListTagsRequest) returns (ListTagsResponse) { + option (google.api.http) = { + get: "/v1alpha2/{parent=projects/*/incidents/*}/tags" + }; + } + + // Creates a new signal. + rpc CreateSignal(CreateSignalRequest) returns (Signal) { + option (google.api.http) = { + post: "/v1alpha2/{parent=projects/*}/signals" + body: "signal" + }; + } + + // Lists signals that are part of an incident. + // Signals are returned in reverse chronological order. + rpc ListSignals(ListSignalsRequest) returns (ListSignalsResponse) { + option (google.api.http) = { + get: "/v1alpha2/{parent=projects/*}/signals" + }; + } + + // Returns a signal by name. + rpc GetSignal(GetSignalRequest) returns (Signal) { + option (google.api.http) = { + get: "/v1alpha2/{name=projects/*/signals/*}" + }; + } + + // Updates an existing signal (e.g. to assign/unassign it to an + // incident). + rpc UpdateSignal(UpdateSignalRequest) returns (Signal) { + option (google.api.http) = { + patch: "/v1alpha2/{signal.name=projects/*/signals/*}" + body: "signal" + }; + } + + // Acks a signal. This acknowledges the signal in the underlying system, + // indicating that the caller takes responsibility for looking into this. + rpc AcknowledgeSignal(AcknowledgeSignalRequest) returns (AcknowledgeSignalResponse) { + option (google.api.http) = { + post: "/v1alpha2/{name=projects/*/signals/*}:ack" + body: "*" + }; + } + + // Escalates an incident. + rpc EscalateIncident(EscalateIncidentRequest) returns (EscalateIncidentResponse) { + option (google.api.http) = { + post: "/v1alpha2/{incident.name=projects/*/incidents/*}:escalate" + body: "*" + }; + } + + // Creates a new artifact. + rpc CreateArtifact(CreateArtifactRequest) returns (Artifact) { + option (google.api.http) = { + post: "/v1alpha2/{parent=projects/*/incidents/*}/artifacts" + body: "artifact" + }; + } + + // Returns a list of artifacts for an incident. + rpc ListArtifacts(ListArtifactsRequest) returns (ListArtifactsResponse) { + option (google.api.http) = { + get: "/v1alpha2/{parent=projects/*/incidents/*}/artifacts" + }; + } + + // Updates an existing artifact. + rpc UpdateArtifact(UpdateArtifactRequest) returns (Artifact) { + option (google.api.http) = { + patch: "/v1alpha2/{artifact.name=projects/*/incidents/*/artifacts/*}" + body: "artifact" + }; + } + + // Deletes an existing artifact. + rpc DeleteArtifact(DeleteArtifactRequest) returns (google.protobuf.Empty) { + option (google.api.http) = { + delete: "/v1alpha2/{name=projects/*/incidents/*/artifacts/*}" + }; + } + + // Returns "presets" specific to shift handoff (see SendShiftHandoff), e.g. + // default values for handoff message fields. + rpc GetShiftHandoffPresets(GetShiftHandoffPresetsRequest) returns (ShiftHandoffPresets) { + option (google.api.http) = { + get: "/v1alpha2/{parent=projects/*}/shiftHandoffPresets" + }; + } + + // Sends a summary of the shift for oncall handoff. + rpc SendShiftHandoff(SendShiftHandoffRequest) returns (SendShiftHandoffResponse) { + option (google.api.http) = { + post: "/v1alpha2/{parent=projects/*}/shiftHandoff:send" + body: "*" + }; + } + + // Creates a new subscription. + // This will fail if: + // a. there are too many (50) subscriptions in the incident already + // b. a subscription using the given channel already exists + rpc CreateSubscription(CreateSubscriptionRequest) returns (Subscription) { + option (google.api.http) = { + post: "/v1alpha2/{parent=projects/*/incidents/*}/subscriptions" + body: "subscription" + }; + } + + // Returns a list of subscriptions for an incident. + rpc ListSubscriptions(ListSubscriptionsRequest) returns (ListSubscriptionsResponse) { + option (google.api.http) = { + get: "/v1alpha2/{parent=projects/*/incidents/*}/subscriptions" + }; + } + + // Deletes an existing subscription. + rpc DeleteSubscription(DeleteSubscriptionRequest) returns (google.protobuf.Empty) { + option (google.api.http) = { + delete: "/v1alpha2/{name=projects/*/incidents/*/subscriptions/*}" + }; + } + + // Creates a role assignment on an existing incident. Normally, the user field + // will be set when assigning a role to oneself, and the next field will be + // set when proposing another user as the assignee. Setting the next field + // directly to a user other than oneself is equivalent to proposing and + // force-assigning the role to the user. + rpc CreateIncidentRoleAssignment(CreateIncidentRoleAssignmentRequest) returns (IncidentRoleAssignment) { + option (google.api.http) = { + post: "/v1alpha2/{parent=projects/*/incidents/*}/roleAssignments" + body: "*" + }; + } + + // Deletes an existing role assignment. + rpc DeleteIncidentRoleAssignment(DeleteIncidentRoleAssignmentRequest) returns (google.protobuf.Empty) { + option (google.api.http) = { + delete: "/v1alpha2/{name=projects/*/incidents/*/roleAssignments/*}" + }; + } + + // Lists role assignments that are part of an incident. + rpc ListIncidentRoleAssignments(ListIncidentRoleAssignmentsRequest) returns (ListIncidentRoleAssignmentsResponse) { + option (google.api.http) = { + get: "/v1alpha2/{parent=projects/*/incidents/*}/roleAssignments" + }; + } + + // Starts a role handover. The proposed assignee will receive an email + // notifying them of the assignment. This will fail if a role handover is + // already pending. + rpc RequestIncidentRoleHandover(RequestIncidentRoleHandoverRequest) returns (IncidentRoleAssignment) { + option (google.api.http) = { + post: "/v1alpha2/{name=projects/*/incidents/*/roleAssignments/*}:requestHandover" + body: "*" + }; + } + + // Confirms a role handover. This will fail if the 'proposed_assignee' field + // of the IncidentRoleAssignment is not equal to the 'new_assignee' field of + // the request. If the caller is not the new_assignee, + // ForceIncidentRoleHandover should be used instead. + rpc ConfirmIncidentRoleHandover(ConfirmIncidentRoleHandoverRequest) returns (IncidentRoleAssignment) { + option (google.api.http) = { + post: "/v1alpha2/{name=projects/*/incidents/*/roleAssignments/*}:confirmHandover" + body: "*" + }; + } + + // Forces a role handover. This will fail if the 'proposed_assignee' field of + // the IncidentRoleAssignment is not equal to the 'new_assignee' field of the + // request. If the caller is the new_assignee, ConfirmIncidentRoleHandover + // should be used instead. + rpc ForceIncidentRoleHandover(ForceIncidentRoleHandoverRequest) returns (IncidentRoleAssignment) { + option (google.api.http) = { + post: "/v1alpha2/{name=projects/*/incidents/*/roleAssignments/*}:forceHandover" + body: "*" + }; + } + + // Cancels a role handover. This will fail if the 'proposed_assignee' field of + // the IncidentRoleAssignment is not equal to the 'new_assignee' field of the + // request. + rpc CancelIncidentRoleHandover(CancelIncidentRoleHandoverRequest) returns (IncidentRoleAssignment) { + option (google.api.http) = { + post: "/v1alpha2/{name=projects/*/incidents/*/roleAssignments/*}:cancelHandover" + body: "*" + }; + } +} + +// Request for the CreateIncident method. +message CreateIncidentRequest { + // The incident to create. + Incident incident = 1; + + // The resource name of the hosting Stackdriver project which the incident + // belongs to. + // The name is of the form `projects/{project_id_or_number}` + // . + string parent = 2; +} + +// Request for the GetIncident method. +message GetIncidentRequest { + // Resource name of the incident, e.g. + // "projects/{project_id}/incidents/{incident_id}". + string name = 1; +} + +// Request for the UpdateIncident method. +message UpdateIncidentRequest { + // The incident to update with the new values. + Incident incident = 1; + + // List of fields that should be updated. + google.protobuf.FieldMask update_mask = 2; +} + +// Request for the SearchSimilarIncidents method. +message SearchSimilarIncidentsRequest { + // Resource name of the incident or signal, e.g. + // "projects/{project_id}/incidents/{incident_id}". + string name = 1; + + // Number of similar incidents to return. + int32 page_size = 2; + + // Page token from an earlier query, as returned in 'next_page_token'. + string page_token = 3; +} + +// Response for the SearchSimilarIncidents method. +message SearchSimilarIncidentsResponse { + // A single search result, i.e. an incident with (potentially) additional + // information. + message Result { + // An incident that is "similar" to the incident or signal specified in the + // request. + Incident incident = 1; + } + + // The search results, ordered by descending relevance. + repeated Result results = 1; + + // Page token to fetch the next set of similar incidents. + string next_page_token = 2; +} + +// Request for the CreateAnnotation method. +message CreateAnnotationRequest { + // Resource name of the incident, e.g. + // "projects/{project_id}/incidents/{incident_id}". + string parent = 1; + + // Only annotation.content is an input argument. + Annotation annotation = 2; +} + +// Request for the ListAnnotations method. +message ListAnnotationsRequest { + // Resource name of the incident, e.g. + // "projects/{project_id}/incidents/{incident_id}". + string parent = 1; + + // Number of annotations to return. + int32 page_size = 2; + + // Page token from an earlier query, as returned in `next_page_token`. + string page_token = 3; +} + +// Response for the ListAnnotations method. +message ListAnnotationsResponse { + // List of annotations. + repeated Annotation annotations = 1; + + // Page token to fetch the next set of annotations. + string next_page_token = 2; +} + +// Request for the CreateTag method. +message CreateTagRequest { + // Resource name of the incident, e.g. + // "projects/{project_id}/incidents/{incident_id}". + string parent = 1; + + // Tag to create. Only tag.display_name is an input argument. + Tag tag = 2; +} + +// Request for the DeleteTag method. +message DeleteTagRequest { + // Resource name of the tag. + string name = 1; +} + +// Request for the ListTagsForIncident method. +message ListTagsRequest { + // Resource name of the incident, e.g. + // "projects/{project_id}/incidents/{incident_id}". + string parent = 1; + + // Number of tags to return. + int32 page_size = 2; + + // Page token from an earlier query, as returned in `next_page_token`. + string page_token = 3; +} + +// Response for the ListTagsForIncident method. +message ListTagsResponse { + // Tags. + repeated Tag tags = 1; + + // Page token to fetch the next set of tags. + string next_page_token = 2; +} + +// Request for the UpdateAnnotation method. +message UpdateAnnotationRequest { + // The annotation to update with the new values. + Annotation annotation = 1; + + // List of fields that should be updated. + google.protobuf.FieldMask update_mask = 2; +} + +// Request for the CreateSignal method. +message CreateSignalRequest { + // The resource name of the hosting Stackdriver project which requested + // signal belongs to. + string parent = 1; + + // The signal to create. + Signal signal = 2; +} + +// Request for the ListSignals method. +message ListSignalsRequest { + // The resource name of the hosting Stackdriver project which requested + // incidents belong to. + string parent = 1; + + // Filter to specify which signals should be returned. + string filter = 2; + + // Maximum number of `signals` to return in the response. + int32 page_size = 3; + + // Page token from an earlier query, as returned in `next_page_token`. All + // field values except for page_size and page_token should be the same as the + // original query (may return an error or unexpected data otherwise). + string page_token = 4; +} + +// Response for the ListSignals method. +message ListSignalsResponse { + // List of signals that have not been moved into an incident yet. + repeated Signal signals = 1; + + // Page token to fetch the next set of signals. + string next_page_token = 2; +} + +// Request for the GetSignal method. +message GetSignalRequest { + // Resource name of the Signal resource, e.g. + // "projects/{project_id}/signals/{signal_id}". + string name = 1; +} + +// Request for the UpdateSignal method. +message UpdateSignalRequest { + // The signal to update with the new values. + Signal signal = 1; + + // List of fields that should be updated. + google.protobuf.FieldMask update_mask = 2; +} + +// Request for the AcknowledgeSignal method. +message AcknowledgeSignalRequest { + // Resource name of the Signal resource, e.g. + // "projects/{project_id}/signals/{signal_id}". + string name = 1; +} + +// Response of the AcknowledgeSignal method. +message AcknowledgeSignalResponse { + +} + +// Request for the SearchIncidents method. +message SearchIncidentsRequest { + // The resource name of the hosting Stackdriver project which requested + // incidents belong to. + string parent = 1; + + // An expression that defines which incidents to return. + // + // Search atoms can be used to match certain specific fields. Otherwise, + // plain text will match text fields in the incident. + // + // Search atoms: + // * `start` - (timestamp) The time the incident started. + // * `stage` - The stage of the incident, one of detected, triaged, mitigated, + // resolved, documented, or duplicate (which correspond to values in the + // Incident.Stage enum). These are ordered, so `stagemedium`, `severity<=minor`, etc.). + // + // Timestamp formats: + // * yyyy-MM-dd - an absolute date, treated as a calendar-day-wide window. + // In other words, the "<" operator will match dates before that date, the + // ">" operator will match dates after that date, and the ":" or "=" + // operators will match the entire day. + // * Nd (e.g. 7d) - a relative number of days ago, treated as a moment in time + // (as opposed to a day-wide span) a multiple of 24 hours ago (as opposed to + // calendar days). In the case of daylight savings time, it will apply the + // current timezone to both ends of the range. Note that exact matching + // (e.g. `start:7d`) is unlikely to be useful because that would only match + // incidents created precisely at a particular instant in time. + // + // Examples: + // + // * `foo` - matches incidents containing the word "foo" + // * `"foo bar"` - matches incidents containing the phrase "foo bar" + // * `foo bar` or `foo AND bar` - matches incidents containing the words "foo" + // and "bar" + // * `foo -bar` or `foo AND NOT bar` - matches incidents containing the word + // "foo" but not the word "bar" + // * `foo OR bar` - matches incidents containing the word "foo" or the word + // "bar" + // * `start>2018-11-28` - matches incidents which started after November 11, + // 2018. + // * `start<=2018-11-28` - matches incidents which started on or before + // November 11, 2018. + // * `start:2018-11-28` - matches incidents which started on November 11, + // 2018. + // * `start>7d` - matches incidents which started after the point in time 7*24 + // hours ago + // * `start>180d` - similar to 7d, but likely to cross the daylight savings + // time boundary, so the end time will be 1 hour different from "now." + // * `foo AND start>90d AND stage