1// Copyright 2021 Google LLC. 2// Use of this source code is governed by a BSD-style 3// license that can be found in the LICENSE file. 4 5// Code generated file. DO NOT EDIT. 6 7// Package clouddebugger provides access to the Cloud Debugger API. 8// 9// For product documentation, see: https://cloud.google.com/debugger 10// 11// Creating a client 12// 13// Usage example: 14// 15// import "google.golang.org/api/clouddebugger/v2" 16// ... 17// ctx := context.Background() 18// clouddebuggerService, err := clouddebugger.NewService(ctx) 19// 20// In this example, Google Application Default Credentials are used for authentication. 21// 22// For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials. 23// 24// Other authentication options 25// 26// By default, all available scopes (see "Constants") are used to authenticate. To restrict scopes, use option.WithScopes: 27// 28// clouddebuggerService, err := clouddebugger.NewService(ctx, option.WithScopes(clouddebugger.CloudDebuggerScope)) 29// 30// To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey: 31// 32// clouddebuggerService, err := clouddebugger.NewService(ctx, option.WithAPIKey("AIza...")) 33// 34// To use an OAuth token (e.g., a user token obtained via a three-legged OAuth flow), use option.WithTokenSource: 35// 36// config := &oauth2.Config{...} 37// // ... 38// token, err := config.Exchange(ctx, ...) 39// clouddebuggerService, err := clouddebugger.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token))) 40// 41// See https://godoc.org/google.golang.org/api/option/ for details on options. 42package clouddebugger // import "google.golang.org/api/clouddebugger/v2" 43 44import ( 45 "bytes" 46 "context" 47 "encoding/json" 48 "errors" 49 "fmt" 50 "io" 51 "net/http" 52 "net/url" 53 "strconv" 54 "strings" 55 56 googleapi "google.golang.org/api/googleapi" 57 gensupport "google.golang.org/api/internal/gensupport" 58 option "google.golang.org/api/option" 59 internaloption "google.golang.org/api/option/internaloption" 60 htransport "google.golang.org/api/transport/http" 61) 62 63// Always reference these packages, just in case the auto-generated code 64// below doesn't. 65var _ = bytes.NewBuffer 66var _ = strconv.Itoa 67var _ = fmt.Sprintf 68var _ = json.NewDecoder 69var _ = io.Copy 70var _ = url.Parse 71var _ = gensupport.MarshalJSON 72var _ = googleapi.Version 73var _ = errors.New 74var _ = strings.Replace 75var _ = context.Canceled 76var _ = internaloption.WithDefaultEndpoint 77 78const apiId = "clouddebugger:v2" 79const apiName = "clouddebugger" 80const apiVersion = "v2" 81const basePath = "https://clouddebugger.googleapis.com/" 82const mtlsBasePath = "https://clouddebugger.mtls.googleapis.com/" 83 84// OAuth2 scopes used by this API. 85const ( 86 // See, edit, configure, and delete your Google Cloud data and see the 87 // email address for your Google Account. 88 CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform" 89 90 // Use Stackdriver Debugger 91 CloudDebuggerScope = "https://www.googleapis.com/auth/cloud_debugger" 92) 93 94// NewService creates a new Service. 95func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) { 96 scopesOption := option.WithScopes( 97 "https://www.googleapis.com/auth/cloud-platform", 98 "https://www.googleapis.com/auth/cloud_debugger", 99 ) 100 // NOTE: prepend, so we don't override user-specified scopes. 101 opts = append([]option.ClientOption{scopesOption}, opts...) 102 opts = append(opts, internaloption.WithDefaultEndpoint(basePath)) 103 opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath)) 104 client, endpoint, err := htransport.NewClient(ctx, opts...) 105 if err != nil { 106 return nil, err 107 } 108 s, err := New(client) 109 if err != nil { 110 return nil, err 111 } 112 if endpoint != "" { 113 s.BasePath = endpoint 114 } 115 return s, nil 116} 117 118// New creates a new Service. It uses the provided http.Client for requests. 119// 120// Deprecated: please use NewService instead. 121// To provide a custom HTTP client, use option.WithHTTPClient. 122// If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead. 123func New(client *http.Client) (*Service, error) { 124 if client == nil { 125 return nil, errors.New("client is nil") 126 } 127 s := &Service{client: client, BasePath: basePath} 128 s.Controller = NewControllerService(s) 129 s.Debugger = NewDebuggerService(s) 130 return s, nil 131} 132 133type Service struct { 134 client *http.Client 135 BasePath string // API endpoint base URL 136 UserAgent string // optional additional User-Agent fragment 137 138 Controller *ControllerService 139 140 Debugger *DebuggerService 141} 142 143func (s *Service) userAgent() string { 144 if s.UserAgent == "" { 145 return googleapi.UserAgent 146 } 147 return googleapi.UserAgent + " " + s.UserAgent 148} 149 150func NewControllerService(s *Service) *ControllerService { 151 rs := &ControllerService{s: s} 152 rs.Debuggees = NewControllerDebuggeesService(s) 153 return rs 154} 155 156type ControllerService struct { 157 s *Service 158 159 Debuggees *ControllerDebuggeesService 160} 161 162func NewControllerDebuggeesService(s *Service) *ControllerDebuggeesService { 163 rs := &ControllerDebuggeesService{s: s} 164 rs.Breakpoints = NewControllerDebuggeesBreakpointsService(s) 165 return rs 166} 167 168type ControllerDebuggeesService struct { 169 s *Service 170 171 Breakpoints *ControllerDebuggeesBreakpointsService 172} 173 174func NewControllerDebuggeesBreakpointsService(s *Service) *ControllerDebuggeesBreakpointsService { 175 rs := &ControllerDebuggeesBreakpointsService{s: s} 176 return rs 177} 178 179type ControllerDebuggeesBreakpointsService struct { 180 s *Service 181} 182 183func NewDebuggerService(s *Service) *DebuggerService { 184 rs := &DebuggerService{s: s} 185 rs.Debuggees = NewDebuggerDebuggeesService(s) 186 return rs 187} 188 189type DebuggerService struct { 190 s *Service 191 192 Debuggees *DebuggerDebuggeesService 193} 194 195func NewDebuggerDebuggeesService(s *Service) *DebuggerDebuggeesService { 196 rs := &DebuggerDebuggeesService{s: s} 197 rs.Breakpoints = NewDebuggerDebuggeesBreakpointsService(s) 198 return rs 199} 200 201type DebuggerDebuggeesService struct { 202 s *Service 203 204 Breakpoints *DebuggerDebuggeesBreakpointsService 205} 206 207func NewDebuggerDebuggeesBreakpointsService(s *Service) *DebuggerDebuggeesBreakpointsService { 208 rs := &DebuggerDebuggeesBreakpointsService{s: s} 209 return rs 210} 211 212type DebuggerDebuggeesBreakpointsService struct { 213 s *Service 214} 215 216// AliasContext: An alias to a repo revision. 217type AliasContext struct { 218 // Kind: The alias kind. 219 // 220 // Possible values: 221 // "ANY" - Do not use. 222 // "FIXED" - Git tag 223 // "MOVABLE" - Git branch 224 // "OTHER" - OTHER is used to specify non-standard aliases, those not 225 // of the kinds above. For example, if a Git repo has a ref named 226 // "refs/foo/bar", it is considered to be of kind OTHER. 227 Kind string `json:"kind,omitempty"` 228 229 // Name: The alias name. 230 Name string `json:"name,omitempty"` 231 232 // ForceSendFields is a list of field names (e.g. "Kind") to 233 // unconditionally include in API requests. By default, fields with 234 // empty or default values are omitted from API requests. However, any 235 // non-pointer, non-interface field appearing in ForceSendFields will be 236 // sent to the server regardless of whether the field is empty or not. 237 // This may be used to include empty fields in Patch requests. 238 ForceSendFields []string `json:"-"` 239 240 // NullFields is a list of field names (e.g. "Kind") to include in API 241 // requests with the JSON null value. By default, fields with empty 242 // values are omitted from API requests. However, any field with an 243 // empty value appearing in NullFields will be sent to the server as 244 // null. It is an error if a field in this list has a non-empty value. 245 // This may be used to include null fields in Patch requests. 246 NullFields []string `json:"-"` 247} 248 249func (s *AliasContext) MarshalJSON() ([]byte, error) { 250 type NoMethod AliasContext 251 raw := NoMethod(*s) 252 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 253} 254 255// Breakpoint: 256// ---------------------------------------------------------------------- 257// -------- ## Breakpoint (the resource) Represents the breakpoint 258// specification, status and results. 259type Breakpoint struct { 260 // Action: Action that the agent should perform when the code at the 261 // breakpoint location is hit. 262 // 263 // Possible values: 264 // "CAPTURE" - Capture stack frame and variables and update the 265 // breakpoint. The data is only captured once. After that the breakpoint 266 // is set in a final state. 267 // "LOG" - Log each breakpoint hit. The breakpoint remains active 268 // until deleted or expired. 269 Action string `json:"action,omitempty"` 270 271 // CanaryExpireTime: The deadline for the breakpoint to stay in 272 // CANARY_ACTIVE state. The value is meaningless when the breakpoint is 273 // not in CANARY_ACTIVE state. 274 CanaryExpireTime string `json:"canaryExpireTime,omitempty"` 275 276 // Condition: Condition that triggers the breakpoint. The condition is a 277 // compound boolean expression composed using expressions in a 278 // programming language at the source location. 279 Condition string `json:"condition,omitempty"` 280 281 // CreateTime: Time this breakpoint was created by the server in seconds 282 // resolution. 283 CreateTime string `json:"createTime,omitempty"` 284 285 // EvaluatedExpressions: Values of evaluated expressions at breakpoint 286 // time. The evaluated expressions appear in exactly the same order they 287 // are listed in the `expressions` field. The `name` field holds the 288 // original expression text, the `value` or `members` field holds the 289 // result of the evaluated expression. If the expression cannot be 290 // evaluated, the `status` inside the `Variable` will indicate an error 291 // and contain the error text. 292 EvaluatedExpressions []*Variable `json:"evaluatedExpressions,omitempty"` 293 294 // Expressions: List of read-only expressions to evaluate at the 295 // breakpoint location. The expressions are composed using expressions 296 // in the programming language at the source location. If the breakpoint 297 // action is `LOG`, the evaluated expressions are included in log 298 // statements. 299 Expressions []string `json:"expressions,omitempty"` 300 301 // FinalTime: Time this breakpoint was finalized as seen by the server 302 // in seconds resolution. 303 FinalTime string `json:"finalTime,omitempty"` 304 305 // Id: Breakpoint identifier, unique in the scope of the debuggee. 306 Id string `json:"id,omitempty"` 307 308 // IsFinalState: When true, indicates that this is a final result and 309 // the breakpoint state will not change from here on. 310 IsFinalState bool `json:"isFinalState,omitempty"` 311 312 // Labels: A set of custom breakpoint properties, populated by the 313 // agent, to be displayed to the user. 314 Labels map[string]string `json:"labels,omitempty"` 315 316 // Location: Breakpoint source location. 317 Location *SourceLocation `json:"location,omitempty"` 318 319 // LogLevel: Indicates the severity of the log. Only relevant when 320 // action is `LOG`. 321 // 322 // Possible values: 323 // "INFO" - Information log message. 324 // "WARNING" - Warning log message. 325 // "ERROR" - Error log message. 326 LogLevel string `json:"logLevel,omitempty"` 327 328 // LogMessageFormat: Only relevant when action is `LOG`. Defines the 329 // message to log when the breakpoint hits. The message may include 330 // parameter placeholders `$0`, `$1`, etc. These placeholders are 331 // replaced with the evaluated value of the appropriate expression. 332 // Expressions not referenced in `log_message_format` are not logged. 333 // Example: `Message received, id = $0, count = $1` with `expressions` = 334 // `[ message.id, message.count ]`. 335 LogMessageFormat string `json:"logMessageFormat,omitempty"` 336 337 // StackFrames: The stack at breakpoint time, where stack_frames[0] 338 // represents the most recently entered function. 339 StackFrames []*StackFrame `json:"stackFrames,omitempty"` 340 341 // State: The current state of the breakpoint. 342 // 343 // Possible values: 344 // "STATE_UNSPECIFIED" - Breakpoint state UNSPECIFIED. 345 // "STATE_CANARY_PENDING_AGENTS" - Enabling canary but no agents are 346 // available. 347 // "STATE_CANARY_ACTIVE" - Enabling canary and successfully assigning 348 // canary agents. 349 // "STATE_ROLLING_TO_ALL" - Breakpoint rolling out to all agents. 350 // "STATE_IS_FINAL" - Breakpoint is hit/complete/failed. 351 State string `json:"state,omitempty"` 352 353 // Status: Breakpoint status. The status includes an error flag and a 354 // human readable message. This field is usually unset. The message can 355 // be either informational or an error message. Regardless, clients 356 // should always display the text message back to the user. Error status 357 // indicates complete failure of the breakpoint. Example (non-final 358 // state): `Still loading symbols...` Examples (final state): * `Invalid 359 // line number` referring to location * `Field f not found in class C` 360 // referring to condition 361 Status *StatusMessage `json:"status,omitempty"` 362 363 // UserEmail: E-mail address of the user that created this breakpoint 364 UserEmail string `json:"userEmail,omitempty"` 365 366 // VariableTable: The `variable_table` exists to aid with computation, 367 // memory and network traffic optimization. It enables storing a 368 // variable once and reference it from multiple variables, including 369 // variables stored in the `variable_table` itself. For example, the 370 // same `this` object, which may appear at many levels of the stack, can 371 // have all of its data stored once in this table. The stack frame 372 // variables then would hold only a reference to it. The variable 373 // `var_table_index` field is an index into this repeated field. The 374 // stored objects are nameless and get their name from the referencing 375 // variable. The effective variable is a merge of the referencing 376 // variable and the referenced variable. 377 VariableTable []*Variable `json:"variableTable,omitempty"` 378 379 // ForceSendFields is a list of field names (e.g. "Action") to 380 // unconditionally include in API requests. By default, fields with 381 // empty or default values are omitted from API requests. However, any 382 // non-pointer, non-interface field appearing in ForceSendFields will be 383 // sent to the server regardless of whether the field is empty or not. 384 // This may be used to include empty fields in Patch requests. 385 ForceSendFields []string `json:"-"` 386 387 // NullFields is a list of field names (e.g. "Action") to include in API 388 // requests with the JSON null value. By default, fields with empty 389 // values are omitted from API requests. However, any field with an 390 // empty value appearing in NullFields will be sent to the server as 391 // null. It is an error if a field in this list has a non-empty value. 392 // This may be used to include null fields in Patch requests. 393 NullFields []string `json:"-"` 394} 395 396func (s *Breakpoint) MarshalJSON() ([]byte, error) { 397 type NoMethod Breakpoint 398 raw := NoMethod(*s) 399 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 400} 401 402// CloudRepoSourceContext: A CloudRepoSourceContext denotes a particular 403// revision in a cloud repo (a repo hosted by the Google Cloud 404// Platform). 405type CloudRepoSourceContext struct { 406 // AliasContext: An alias, which may be a branch or tag. 407 AliasContext *AliasContext `json:"aliasContext,omitempty"` 408 409 // AliasName: The name of an alias (branch, tag, etc.). 410 AliasName string `json:"aliasName,omitempty"` 411 412 // RepoId: The ID of the repo. 413 RepoId *RepoId `json:"repoId,omitempty"` 414 415 // RevisionId: A revision ID. 416 RevisionId string `json:"revisionId,omitempty"` 417 418 // ForceSendFields is a list of field names (e.g. "AliasContext") to 419 // unconditionally include in API requests. By default, fields with 420 // empty or default values are omitted from API requests. However, any 421 // non-pointer, non-interface field appearing in ForceSendFields will be 422 // sent to the server regardless of whether the field is empty or not. 423 // This may be used to include empty fields in Patch requests. 424 ForceSendFields []string `json:"-"` 425 426 // NullFields is a list of field names (e.g. "AliasContext") to include 427 // in API requests with the JSON null value. By default, fields with 428 // empty values are omitted from API requests. However, any field with 429 // an empty value appearing in NullFields will be sent to the server as 430 // null. It is an error if a field in this list has a non-empty value. 431 // This may be used to include null fields in Patch requests. 432 NullFields []string `json:"-"` 433} 434 435func (s *CloudRepoSourceContext) MarshalJSON() ([]byte, error) { 436 type NoMethod CloudRepoSourceContext 437 raw := NoMethod(*s) 438 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 439} 440 441// CloudWorkspaceId: A CloudWorkspaceId is a unique identifier for a 442// cloud workspace. A cloud workspace is a place associated with a repo 443// where modified files can be stored before they are committed. 444type CloudWorkspaceId struct { 445 // Name: The unique name of the workspace within the repo. This is the 446 // name chosen by the client in the Source API's CreateWorkspace method. 447 Name string `json:"name,omitempty"` 448 449 // RepoId: The ID of the repo containing the workspace. 450 RepoId *RepoId `json:"repoId,omitempty"` 451 452 // ForceSendFields is a list of field names (e.g. "Name") to 453 // unconditionally include in API requests. By default, fields with 454 // empty or default values are omitted from API requests. However, any 455 // non-pointer, non-interface field appearing in ForceSendFields will be 456 // sent to the server regardless of whether the field is empty or not. 457 // This may be used to include empty fields in Patch requests. 458 ForceSendFields []string `json:"-"` 459 460 // NullFields is a list of field names (e.g. "Name") to include in API 461 // requests with the JSON null value. By default, fields with empty 462 // values are omitted from API requests. However, any field with an 463 // empty value appearing in NullFields will be sent to the server as 464 // null. It is an error if a field in this list has a non-empty value. 465 // This may be used to include null fields in Patch requests. 466 NullFields []string `json:"-"` 467} 468 469func (s *CloudWorkspaceId) MarshalJSON() ([]byte, error) { 470 type NoMethod CloudWorkspaceId 471 raw := NoMethod(*s) 472 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 473} 474 475// CloudWorkspaceSourceContext: A CloudWorkspaceSourceContext denotes a 476// workspace at a particular snapshot. 477type CloudWorkspaceSourceContext struct { 478 // SnapshotId: The ID of the snapshot. An empty snapshot_id refers to 479 // the most recent snapshot. 480 SnapshotId string `json:"snapshotId,omitempty"` 481 482 // WorkspaceId: The ID of the workspace. 483 WorkspaceId *CloudWorkspaceId `json:"workspaceId,omitempty"` 484 485 // ForceSendFields is a list of field names (e.g. "SnapshotId") to 486 // unconditionally include in API requests. By default, fields with 487 // empty or default values are omitted from API requests. However, any 488 // non-pointer, non-interface field appearing in ForceSendFields will be 489 // sent to the server regardless of whether the field is empty or not. 490 // This may be used to include empty fields in Patch requests. 491 ForceSendFields []string `json:"-"` 492 493 // NullFields is a list of field names (e.g. "SnapshotId") to include in 494 // API requests with the JSON null value. By default, fields with empty 495 // values are omitted from API requests. However, any field with an 496 // empty value appearing in NullFields will be sent to the server as 497 // null. It is an error if a field in this list has a non-empty value. 498 // This may be used to include null fields in Patch requests. 499 NullFields []string `json:"-"` 500} 501 502func (s *CloudWorkspaceSourceContext) MarshalJSON() ([]byte, error) { 503 type NoMethod CloudWorkspaceSourceContext 504 raw := NoMethod(*s) 505 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 506} 507 508// Debuggee: Represents the debugged application. The application may 509// include one or more replicated processes executing the same code. 510// Each of these processes is attached with a debugger agent, carrying 511// out the debugging commands. Agents attached to the same debuggee 512// identify themselves as such by using exactly the same Debuggee 513// message value when registering. 514type Debuggee struct { 515 // AgentVersion: Version ID of the agent. Schema: 516 // `domain/language-platform/vmajor.minor` (for example 517 // `google.com/java-gcp/v1.1`). 518 AgentVersion string `json:"agentVersion,omitempty"` 519 520 // CanaryMode: Used when setting breakpoint canary for this debuggee. 521 // 522 // Possible values: 523 // "CANARY_MODE_UNSPECIFIED" - CANARY_MODE_UNSPECIFIED is equivalent 524 // to CANARY_MODE_ALWAYS_DISABLED so that if the debuggee is not 525 // configured to use the canary feature, the feature will be disabled. 526 // "CANARY_MODE_ALWAYS_ENABLED" - Always enable breakpoint canary 527 // regardless of the value of breakpoint's canary option. 528 // "CANARY_MODE_ALWAYS_DISABLED" - Always disable breakpoint canary 529 // regardless of the value of breakpoint's canary option. 530 // "CANARY_MODE_DEFAULT_ENABLED" - Depends on the breakpoint's canary 531 // option. Enable canary by default if the breakpoint's canary option is 532 // not specified. 533 // "CANARY_MODE_DEFAULT_DISABLED" - Depends on the breakpoint's canary 534 // option. Disable canary by default if the breakpoint's canary option 535 // is not specified. 536 CanaryMode string `json:"canaryMode,omitempty"` 537 538 // Description: Human readable description of the debuggee. Including a 539 // human-readable project name, environment name and version information 540 // is recommended. 541 Description string `json:"description,omitempty"` 542 543 // ExtSourceContexts: References to the locations and revisions of the 544 // source code used in the deployed application. 545 ExtSourceContexts []*ExtendedSourceContext `json:"extSourceContexts,omitempty"` 546 547 // Id: Unique identifier for the debuggee generated by the controller 548 // service. 549 Id string `json:"id,omitempty"` 550 551 // IsDisabled: If set to `true`, indicates that the agent should disable 552 // itself and detach from the debuggee. 553 IsDisabled bool `json:"isDisabled,omitempty"` 554 555 // IsInactive: If set to `true`, indicates that Controller service does 556 // not detect any activity from the debuggee agents and the application 557 // is possibly stopped. 558 IsInactive bool `json:"isInactive,omitempty"` 559 560 // Labels: A set of custom debuggee properties, populated by the agent, 561 // to be displayed to the user. 562 Labels map[string]string `json:"labels,omitempty"` 563 564 // Project: Project the debuggee is associated with. Use project number 565 // or id when registering a Google Cloud Platform project. 566 Project string `json:"project,omitempty"` 567 568 // SourceContexts: References to the locations and revisions of the 569 // source code used in the deployed application. 570 SourceContexts []*SourceContext `json:"sourceContexts,omitempty"` 571 572 // Status: Human readable message to be displayed to the user about this 573 // debuggee. Absence of this field indicates no status. The message can 574 // be either informational or an error status. 575 Status *StatusMessage `json:"status,omitempty"` 576 577 // Uniquifier: Uniquifier to further distinguish the application. It is 578 // possible that different applications might have identical values in 579 // the debuggee message, thus, incorrectly identified as a single 580 // application by the Controller service. This field adds salt to 581 // further distinguish the application. Agents should consider seeding 582 // this field with value that identifies the code, binary, configuration 583 // and environment. 584 Uniquifier string `json:"uniquifier,omitempty"` 585 586 // ForceSendFields is a list of field names (e.g. "AgentVersion") to 587 // unconditionally include in API requests. By default, fields with 588 // empty or default values are omitted from API requests. However, any 589 // non-pointer, non-interface field appearing in ForceSendFields will be 590 // sent to the server regardless of whether the field is empty or not. 591 // This may be used to include empty fields in Patch requests. 592 ForceSendFields []string `json:"-"` 593 594 // NullFields is a list of field names (e.g. "AgentVersion") to include 595 // in API requests with the JSON null value. By default, fields with 596 // empty values are omitted from API requests. However, any field with 597 // an empty value appearing in NullFields will be sent to the server as 598 // null. It is an error if a field in this list has a non-empty value. 599 // This may be used to include null fields in Patch requests. 600 NullFields []string `json:"-"` 601} 602 603func (s *Debuggee) MarshalJSON() ([]byte, error) { 604 type NoMethod Debuggee 605 raw := NoMethod(*s) 606 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 607} 608 609// Empty: A generic empty message that you can re-use to avoid defining 610// duplicated empty messages in your APIs. A typical example is to use 611// it as the request or the response type of an API method. For 612// instance: service Foo { rpc Bar(google.protobuf.Empty) returns 613// (google.protobuf.Empty); } The JSON representation for `Empty` is 614// empty JSON object `{}`. 615type Empty struct { 616 // ServerResponse contains the HTTP response code and headers from the 617 // server. 618 googleapi.ServerResponse `json:"-"` 619} 620 621// ExtendedSourceContext: An ExtendedSourceContext is a SourceContext 622// combined with additional details describing the context. 623type ExtendedSourceContext struct { 624 // Context: Any source context. 625 Context *SourceContext `json:"context,omitempty"` 626 627 // Labels: Labels with user defined metadata. 628 Labels map[string]string `json:"labels,omitempty"` 629 630 // ForceSendFields is a list of field names (e.g. "Context") to 631 // unconditionally include in API requests. By default, fields with 632 // empty or default values are omitted from API requests. However, any 633 // non-pointer, non-interface field appearing in ForceSendFields will be 634 // sent to the server regardless of whether the field is empty or not. 635 // This may be used to include empty fields in Patch requests. 636 ForceSendFields []string `json:"-"` 637 638 // NullFields is a list of field names (e.g. "Context") to include in 639 // API requests with the JSON null value. By default, fields with empty 640 // values are omitted from API requests. However, any field with an 641 // empty value appearing in NullFields will be sent to the server as 642 // null. It is an error if a field in this list has a non-empty value. 643 // This may be used to include null fields in Patch requests. 644 NullFields []string `json:"-"` 645} 646 647func (s *ExtendedSourceContext) MarshalJSON() ([]byte, error) { 648 type NoMethod ExtendedSourceContext 649 raw := NoMethod(*s) 650 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 651} 652 653// FormatMessage: Represents a message with parameters. 654type FormatMessage struct { 655 // Format: Format template for the message. The `format` uses 656 // placeholders `$0`, `$1`, etc. to reference parameters. `$$` can be 657 // used to denote the `$` character. Examples: * `Failed to load '$0' 658 // which helps debug $1 the first time it is loaded. Again, $0 is very 659 // important.` * `Please pay $$10 to use $0 instead of $1.` 660 Format string `json:"format,omitempty"` 661 662 // Parameters: Optional parameters to be embedded into the message. 663 Parameters []string `json:"parameters,omitempty"` 664 665 // ForceSendFields is a list of field names (e.g. "Format") to 666 // unconditionally include in API requests. By default, fields with 667 // empty or default values are omitted from API requests. However, any 668 // non-pointer, non-interface field appearing in ForceSendFields will be 669 // sent to the server regardless of whether the field is empty or not. 670 // This may be used to include empty fields in Patch requests. 671 ForceSendFields []string `json:"-"` 672 673 // NullFields is a list of field names (e.g. "Format") to include in API 674 // requests with the JSON null value. By default, fields with empty 675 // values are omitted from API requests. However, any field with an 676 // empty value appearing in NullFields will be sent to the server as 677 // null. It is an error if a field in this list has a non-empty value. 678 // This may be used to include null fields in Patch requests. 679 NullFields []string `json:"-"` 680} 681 682func (s *FormatMessage) MarshalJSON() ([]byte, error) { 683 type NoMethod FormatMessage 684 raw := NoMethod(*s) 685 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 686} 687 688// GerritSourceContext: A SourceContext referring to a Gerrit project. 689type GerritSourceContext struct { 690 // AliasContext: An alias, which may be a branch or tag. 691 AliasContext *AliasContext `json:"aliasContext,omitempty"` 692 693 // AliasName: The name of an alias (branch, tag, etc.). 694 AliasName string `json:"aliasName,omitempty"` 695 696 // GerritProject: The full project name within the host. Projects may be 697 // nested, so "project/subproject" is a valid project name. The "repo 698 // name" is hostURI/project. 699 GerritProject string `json:"gerritProject,omitempty"` 700 701 // HostUri: The URI of a running Gerrit instance. 702 HostUri string `json:"hostUri,omitempty"` 703 704 // RevisionId: A revision (commit) ID. 705 RevisionId string `json:"revisionId,omitempty"` 706 707 // ForceSendFields is a list of field names (e.g. "AliasContext") to 708 // unconditionally include in API requests. By default, fields with 709 // empty or default values are omitted from API requests. However, any 710 // non-pointer, non-interface field appearing in ForceSendFields will be 711 // sent to the server regardless of whether the field is empty or not. 712 // This may be used to include empty fields in Patch requests. 713 ForceSendFields []string `json:"-"` 714 715 // NullFields is a list of field names (e.g. "AliasContext") to include 716 // in API requests with the JSON null value. By default, fields with 717 // empty values are omitted from API requests. However, any field with 718 // an empty value appearing in NullFields will be sent to the server as 719 // null. It is an error if a field in this list has a non-empty value. 720 // This may be used to include null fields in Patch requests. 721 NullFields []string `json:"-"` 722} 723 724func (s *GerritSourceContext) MarshalJSON() ([]byte, error) { 725 type NoMethod GerritSourceContext 726 raw := NoMethod(*s) 727 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 728} 729 730// GetBreakpointResponse: Response for getting breakpoint information. 731type GetBreakpointResponse struct { 732 // Breakpoint: Complete breakpoint state. The fields `id` and `location` 733 // are guaranteed to be set. 734 Breakpoint *Breakpoint `json:"breakpoint,omitempty"` 735 736 // ServerResponse contains the HTTP response code and headers from the 737 // server. 738 googleapi.ServerResponse `json:"-"` 739 740 // ForceSendFields is a list of field names (e.g. "Breakpoint") to 741 // unconditionally include in API requests. By default, fields with 742 // empty or default values are omitted from API requests. However, any 743 // non-pointer, non-interface field appearing in ForceSendFields will be 744 // sent to the server regardless of whether the field is empty or not. 745 // This may be used to include empty fields in Patch requests. 746 ForceSendFields []string `json:"-"` 747 748 // NullFields is a list of field names (e.g. "Breakpoint") to include in 749 // API requests with the JSON null value. By default, fields with empty 750 // values are omitted from API requests. However, any field with an 751 // empty value appearing in NullFields will be sent to the server as 752 // null. It is an error if a field in this list has a non-empty value. 753 // This may be used to include null fields in Patch requests. 754 NullFields []string `json:"-"` 755} 756 757func (s *GetBreakpointResponse) MarshalJSON() ([]byte, error) { 758 type NoMethod GetBreakpointResponse 759 raw := NoMethod(*s) 760 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 761} 762 763// GitSourceContext: A GitSourceContext denotes a particular revision in 764// a third party Git repository (e.g. GitHub). 765type GitSourceContext struct { 766 // RevisionId: Git commit hash. required. 767 RevisionId string `json:"revisionId,omitempty"` 768 769 // Url: Git repository URL. 770 Url string `json:"url,omitempty"` 771 772 // ForceSendFields is a list of field names (e.g. "RevisionId") to 773 // unconditionally include in API requests. By default, fields with 774 // empty or default values are omitted from API requests. However, any 775 // non-pointer, non-interface field appearing in ForceSendFields will be 776 // sent to the server regardless of whether the field is empty or not. 777 // This may be used to include empty fields in Patch requests. 778 ForceSendFields []string `json:"-"` 779 780 // NullFields is a list of field names (e.g. "RevisionId") to include in 781 // API requests with the JSON null value. By default, fields with empty 782 // values are omitted from API requests. However, any field with an 783 // empty value appearing in NullFields will be sent to the server as 784 // null. It is an error if a field in this list has a non-empty value. 785 // This may be used to include null fields in Patch requests. 786 NullFields []string `json:"-"` 787} 788 789func (s *GitSourceContext) MarshalJSON() ([]byte, error) { 790 type NoMethod GitSourceContext 791 raw := NoMethod(*s) 792 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 793} 794 795// ListActiveBreakpointsResponse: Response for listing active 796// breakpoints. 797type ListActiveBreakpointsResponse struct { 798 // Breakpoints: List of all active breakpoints. The fields `id` and 799 // `location` are guaranteed to be set on each breakpoint. 800 Breakpoints []*Breakpoint `json:"breakpoints,omitempty"` 801 802 // NextWaitToken: A token that can be used in the next method call to 803 // block until the list of breakpoints changes. 804 NextWaitToken string `json:"nextWaitToken,omitempty"` 805 806 // WaitExpired: If set to `true`, indicates that there is no change to 807 // the list of active breakpoints and the server-selected timeout has 808 // expired. The `breakpoints` field would be empty and should be 809 // ignored. 810 WaitExpired bool `json:"waitExpired,omitempty"` 811 812 // ServerResponse contains the HTTP response code and headers from the 813 // server. 814 googleapi.ServerResponse `json:"-"` 815 816 // ForceSendFields is a list of field names (e.g. "Breakpoints") to 817 // unconditionally include in API requests. By default, fields with 818 // empty or default values are omitted from API requests. However, any 819 // non-pointer, non-interface field appearing in ForceSendFields will be 820 // sent to the server regardless of whether the field is empty or not. 821 // This may be used to include empty fields in Patch requests. 822 ForceSendFields []string `json:"-"` 823 824 // NullFields is a list of field names (e.g. "Breakpoints") to include 825 // in API requests with the JSON null value. By default, fields with 826 // empty values are omitted from API requests. However, any field with 827 // an empty value appearing in NullFields will be sent to the server as 828 // null. It is an error if a field in this list has a non-empty value. 829 // This may be used to include null fields in Patch requests. 830 NullFields []string `json:"-"` 831} 832 833func (s *ListActiveBreakpointsResponse) MarshalJSON() ([]byte, error) { 834 type NoMethod ListActiveBreakpointsResponse 835 raw := NoMethod(*s) 836 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 837} 838 839// ListBreakpointsResponse: Response for listing breakpoints. 840type ListBreakpointsResponse struct { 841 // Breakpoints: List of breakpoints matching the request. The fields 842 // `id` and `location` are guaranteed to be set on each breakpoint. The 843 // fields: `stack_frames`, `evaluated_expressions` and `variable_table` 844 // are cleared on each breakpoint regardless of its status. 845 Breakpoints []*Breakpoint `json:"breakpoints,omitempty"` 846 847 // NextWaitToken: A wait token that can be used in the next call to 848 // `list` (REST) or `ListBreakpoints` (RPC) to block until the list of 849 // breakpoints has changes. 850 NextWaitToken string `json:"nextWaitToken,omitempty"` 851 852 // ServerResponse contains the HTTP response code and headers from the 853 // server. 854 googleapi.ServerResponse `json:"-"` 855 856 // ForceSendFields is a list of field names (e.g. "Breakpoints") to 857 // unconditionally include in API requests. By default, fields with 858 // empty or default values are omitted from API requests. However, any 859 // non-pointer, non-interface field appearing in ForceSendFields will be 860 // sent to the server regardless of whether the field is empty or not. 861 // This may be used to include empty fields in Patch requests. 862 ForceSendFields []string `json:"-"` 863 864 // NullFields is a list of field names (e.g. "Breakpoints") to include 865 // in API requests with the JSON null value. By default, fields with 866 // empty values are omitted from API requests. However, any field with 867 // an empty value appearing in NullFields will be sent to the server as 868 // null. It is an error if a field in this list has a non-empty value. 869 // This may be used to include null fields in Patch requests. 870 NullFields []string `json:"-"` 871} 872 873func (s *ListBreakpointsResponse) MarshalJSON() ([]byte, error) { 874 type NoMethod ListBreakpointsResponse 875 raw := NoMethod(*s) 876 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 877} 878 879// ListDebuggeesResponse: Response for listing debuggees. 880type ListDebuggeesResponse struct { 881 // Debuggees: List of debuggees accessible to the calling user. The 882 // fields `debuggee.id` and `description` are guaranteed to be set. The 883 // `description` field is a human readable field provided by agents and 884 // can be displayed to users. 885 Debuggees []*Debuggee `json:"debuggees,omitempty"` 886 887 // ServerResponse contains the HTTP response code and headers from the 888 // server. 889 googleapi.ServerResponse `json:"-"` 890 891 // ForceSendFields is a list of field names (e.g. "Debuggees") to 892 // unconditionally include in API requests. By default, fields with 893 // empty or default values are omitted from API requests. However, any 894 // non-pointer, non-interface field appearing in ForceSendFields will be 895 // sent to the server regardless of whether the field is empty or not. 896 // This may be used to include empty fields in Patch requests. 897 ForceSendFields []string `json:"-"` 898 899 // NullFields is a list of field names (e.g. "Debuggees") to include in 900 // API requests with the JSON null value. By default, fields with empty 901 // values are omitted from API requests. However, any field with an 902 // empty value appearing in NullFields will be sent to the server as 903 // null. It is an error if a field in this list has a non-empty value. 904 // This may be used to include null fields in Patch requests. 905 NullFields []string `json:"-"` 906} 907 908func (s *ListDebuggeesResponse) MarshalJSON() ([]byte, error) { 909 type NoMethod ListDebuggeesResponse 910 raw := NoMethod(*s) 911 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 912} 913 914// ProjectRepoId: Selects a repo using a Google Cloud Platform project 915// ID (e.g. winged-cargo-31) and a repo name within that project. 916type ProjectRepoId struct { 917 // ProjectId: The ID of the project. 918 ProjectId string `json:"projectId,omitempty"` 919 920 // RepoName: The name of the repo. Leave empty for the default repo. 921 RepoName string `json:"repoName,omitempty"` 922 923 // ForceSendFields is a list of field names (e.g. "ProjectId") to 924 // unconditionally include in API requests. By default, fields with 925 // empty or default values are omitted from API requests. However, any 926 // non-pointer, non-interface field appearing in ForceSendFields will be 927 // sent to the server regardless of whether the field is empty or not. 928 // This may be used to include empty fields in Patch requests. 929 ForceSendFields []string `json:"-"` 930 931 // NullFields is a list of field names (e.g. "ProjectId") to include in 932 // API requests with the JSON null value. By default, fields with empty 933 // values are omitted from API requests. However, any field with an 934 // empty value appearing in NullFields will be sent to the server as 935 // null. It is an error if a field in this list has a non-empty value. 936 // This may be used to include null fields in Patch requests. 937 NullFields []string `json:"-"` 938} 939 940func (s *ProjectRepoId) MarshalJSON() ([]byte, error) { 941 type NoMethod ProjectRepoId 942 raw := NoMethod(*s) 943 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 944} 945 946// RegisterDebuggeeRequest: Request to register a debuggee. 947type RegisterDebuggeeRequest struct { 948 // Debuggee: Required. Debuggee information to register. The fields 949 // `project`, `uniquifier`, `description` and `agent_version` of the 950 // debuggee must be set. 951 Debuggee *Debuggee `json:"debuggee,omitempty"` 952 953 // ForceSendFields is a list of field names (e.g. "Debuggee") to 954 // unconditionally include in API requests. By default, fields with 955 // empty or default values are omitted from API requests. However, any 956 // non-pointer, non-interface field appearing in ForceSendFields will be 957 // sent to the server regardless of whether the field is empty or not. 958 // This may be used to include empty fields in Patch requests. 959 ForceSendFields []string `json:"-"` 960 961 // NullFields is a list of field names (e.g. "Debuggee") to include in 962 // API requests with the JSON null value. By default, fields with empty 963 // values are omitted from API requests. However, any field with an 964 // empty value appearing in NullFields will be sent to the server as 965 // null. It is an error if a field in this list has a non-empty value. 966 // This may be used to include null fields in Patch requests. 967 NullFields []string `json:"-"` 968} 969 970func (s *RegisterDebuggeeRequest) MarshalJSON() ([]byte, error) { 971 type NoMethod RegisterDebuggeeRequest 972 raw := NoMethod(*s) 973 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 974} 975 976// RegisterDebuggeeResponse: Response for registering a debuggee. 977type RegisterDebuggeeResponse struct { 978 // AgentId: A unique ID generated for the agent. Each RegisterDebuggee 979 // request will generate a new agent ID. 980 AgentId string `json:"agentId,omitempty"` 981 982 // Debuggee: Debuggee resource. The field `id` is guaranteed to be set 983 // (in addition to the echoed fields). If the field `is_disabled` is set 984 // to `true`, the agent should disable itself by removing all 985 // breakpoints and detaching from the application. It should however 986 // continue to poll `RegisterDebuggee` until reenabled. 987 Debuggee *Debuggee `json:"debuggee,omitempty"` 988 989 // ServerResponse contains the HTTP response code and headers from the 990 // server. 991 googleapi.ServerResponse `json:"-"` 992 993 // ForceSendFields is a list of field names (e.g. "AgentId") to 994 // unconditionally include in API requests. By default, fields with 995 // empty or default values are omitted from API requests. However, any 996 // non-pointer, non-interface field appearing in ForceSendFields will be 997 // sent to the server regardless of whether the field is empty or not. 998 // This may be used to include empty fields in Patch requests. 999 ForceSendFields []string `json:"-"` 1000 1001 // NullFields is a list of field names (e.g. "AgentId") to include in 1002 // API requests with the JSON null value. By default, fields with empty 1003 // values are omitted from API requests. However, any field with an 1004 // empty value appearing in NullFields will be sent to the server as 1005 // null. It is an error if a field in this list has a non-empty value. 1006 // This may be used to include null fields in Patch requests. 1007 NullFields []string `json:"-"` 1008} 1009 1010func (s *RegisterDebuggeeResponse) MarshalJSON() ([]byte, error) { 1011 type NoMethod RegisterDebuggeeResponse 1012 raw := NoMethod(*s) 1013 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 1014} 1015 1016// RepoId: A unique identifier for a cloud repo. 1017type RepoId struct { 1018 // ProjectRepoId: A combination of a project ID and a repo name. 1019 ProjectRepoId *ProjectRepoId `json:"projectRepoId,omitempty"` 1020 1021 // Uid: A server-assigned, globally unique identifier. 1022 Uid string `json:"uid,omitempty"` 1023 1024 // ForceSendFields is a list of field names (e.g. "ProjectRepoId") to 1025 // unconditionally include in API requests. By default, fields with 1026 // empty or default values are omitted from API requests. However, any 1027 // non-pointer, non-interface field appearing in ForceSendFields will be 1028 // sent to the server regardless of whether the field is empty or not. 1029 // This may be used to include empty fields in Patch requests. 1030 ForceSendFields []string `json:"-"` 1031 1032 // NullFields is a list of field names (e.g. "ProjectRepoId") to include 1033 // in API requests with the JSON null value. By default, fields with 1034 // empty values are omitted from API requests. However, any field with 1035 // an empty value appearing in NullFields will be sent to the server as 1036 // null. It is an error if a field in this list has a non-empty value. 1037 // This may be used to include null fields in Patch requests. 1038 NullFields []string `json:"-"` 1039} 1040 1041func (s *RepoId) MarshalJSON() ([]byte, error) { 1042 type NoMethod RepoId 1043 raw := NoMethod(*s) 1044 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 1045} 1046 1047// SetBreakpointResponse: Response for setting a breakpoint. 1048type SetBreakpointResponse struct { 1049 // Breakpoint: Breakpoint resource. The field `id` is guaranteed to be 1050 // set (in addition to the echoed fields). 1051 Breakpoint *Breakpoint `json:"breakpoint,omitempty"` 1052 1053 // ServerResponse contains the HTTP response code and headers from the 1054 // server. 1055 googleapi.ServerResponse `json:"-"` 1056 1057 // ForceSendFields is a list of field names (e.g. "Breakpoint") to 1058 // unconditionally include in API requests. By default, fields with 1059 // empty or default values are omitted from API requests. However, any 1060 // non-pointer, non-interface field appearing in ForceSendFields will be 1061 // sent to the server regardless of whether the field is empty or not. 1062 // This may be used to include empty fields in Patch requests. 1063 ForceSendFields []string `json:"-"` 1064 1065 // NullFields is a list of field names (e.g. "Breakpoint") to include in 1066 // API requests with the JSON null value. By default, fields with empty 1067 // values are omitted from API requests. However, any field with an 1068 // empty value appearing in NullFields will be sent to the server as 1069 // null. It is an error if a field in this list has a non-empty value. 1070 // This may be used to include null fields in Patch requests. 1071 NullFields []string `json:"-"` 1072} 1073 1074func (s *SetBreakpointResponse) MarshalJSON() ([]byte, error) { 1075 type NoMethod SetBreakpointResponse 1076 raw := NoMethod(*s) 1077 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 1078} 1079 1080// SourceContext: A SourceContext is a reference to a tree of files. A 1081// SourceContext together with a path point to a unique revision of a 1082// single file or directory. 1083type SourceContext struct { 1084 // CloudRepo: A SourceContext referring to a revision in a cloud repo. 1085 CloudRepo *CloudRepoSourceContext `json:"cloudRepo,omitempty"` 1086 1087 // CloudWorkspace: A SourceContext referring to a snapshot in a cloud 1088 // workspace. 1089 CloudWorkspace *CloudWorkspaceSourceContext `json:"cloudWorkspace,omitempty"` 1090 1091 // Gerrit: A SourceContext referring to a Gerrit project. 1092 Gerrit *GerritSourceContext `json:"gerrit,omitempty"` 1093 1094 // Git: A SourceContext referring to any third party Git repo (e.g. 1095 // GitHub). 1096 Git *GitSourceContext `json:"git,omitempty"` 1097 1098 // ForceSendFields is a list of field names (e.g. "CloudRepo") to 1099 // unconditionally include in API requests. By default, fields with 1100 // empty or default values are omitted from API requests. However, any 1101 // non-pointer, non-interface field appearing in ForceSendFields will be 1102 // sent to the server regardless of whether the field is empty or not. 1103 // This may be used to include empty fields in Patch requests. 1104 ForceSendFields []string `json:"-"` 1105 1106 // NullFields is a list of field names (e.g. "CloudRepo") to include in 1107 // API requests with the JSON null value. By default, fields with empty 1108 // values are omitted from API requests. However, any field with an 1109 // empty value appearing in NullFields will be sent to the server as 1110 // null. It is an error if a field in this list has a non-empty value. 1111 // This may be used to include null fields in Patch requests. 1112 NullFields []string `json:"-"` 1113} 1114 1115func (s *SourceContext) MarshalJSON() ([]byte, error) { 1116 type NoMethod SourceContext 1117 raw := NoMethod(*s) 1118 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 1119} 1120 1121// SourceLocation: Represents a location in the source code. 1122type SourceLocation struct { 1123 // Column: Column within a line. The first column in a line as the value 1124 // `1`. Agents that do not support setting breakpoints on specific 1125 // columns ignore this field. 1126 Column int64 `json:"column,omitempty"` 1127 1128 // Line: Line inside the file. The first line in the file has the value 1129 // `1`. 1130 Line int64 `json:"line,omitempty"` 1131 1132 // Path: Path to the source file within the source context of the target 1133 // binary. 1134 Path string `json:"path,omitempty"` 1135 1136 // ForceSendFields is a list of field names (e.g. "Column") to 1137 // unconditionally include in API requests. By default, fields with 1138 // empty or default values are omitted from API requests. However, any 1139 // non-pointer, non-interface field appearing in ForceSendFields will be 1140 // sent to the server regardless of whether the field is empty or not. 1141 // This may be used to include empty fields in Patch requests. 1142 ForceSendFields []string `json:"-"` 1143 1144 // NullFields is a list of field names (e.g. "Column") to include in API 1145 // requests with the JSON null value. By default, fields with empty 1146 // values are omitted from API requests. However, any field with an 1147 // empty value appearing in NullFields will be sent to the server as 1148 // null. It is an error if a field in this list has a non-empty value. 1149 // This may be used to include null fields in Patch requests. 1150 NullFields []string `json:"-"` 1151} 1152 1153func (s *SourceLocation) MarshalJSON() ([]byte, error) { 1154 type NoMethod SourceLocation 1155 raw := NoMethod(*s) 1156 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 1157} 1158 1159// StackFrame: Represents a stack frame context. 1160type StackFrame struct { 1161 // Arguments: Set of arguments passed to this function. Note that this 1162 // might not be populated for all stack frames. 1163 Arguments []*Variable `json:"arguments,omitempty"` 1164 1165 // Function: Demangled function name at the call site. 1166 Function string `json:"function,omitempty"` 1167 1168 // Locals: Set of local variables at the stack frame location. Note that 1169 // this might not be populated for all stack frames. 1170 Locals []*Variable `json:"locals,omitempty"` 1171 1172 // Location: Source location of the call site. 1173 Location *SourceLocation `json:"location,omitempty"` 1174 1175 // ForceSendFields is a list of field names (e.g. "Arguments") to 1176 // unconditionally include in API requests. By default, fields with 1177 // empty or default values are omitted from API requests. However, any 1178 // non-pointer, non-interface field appearing in ForceSendFields will be 1179 // sent to the server regardless of whether the field is empty or not. 1180 // This may be used to include empty fields in Patch requests. 1181 ForceSendFields []string `json:"-"` 1182 1183 // NullFields is a list of field names (e.g. "Arguments") to include in 1184 // API requests with the JSON null value. By default, fields with empty 1185 // values are omitted from API requests. However, any field with an 1186 // empty value appearing in NullFields will be sent to the server as 1187 // null. It is an error if a field in this list has a non-empty value. 1188 // This may be used to include null fields in Patch requests. 1189 NullFields []string `json:"-"` 1190} 1191 1192func (s *StackFrame) MarshalJSON() ([]byte, error) { 1193 type NoMethod StackFrame 1194 raw := NoMethod(*s) 1195 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 1196} 1197 1198// StatusMessage: Represents a contextual status message. The message 1199// can indicate an error or informational status, and refer to specific 1200// parts of the containing object. For example, the `Breakpoint.status` 1201// field can indicate an error referring to the 1202// `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`. 1203type StatusMessage struct { 1204 // Description: Status message text. 1205 Description *FormatMessage `json:"description,omitempty"` 1206 1207 // IsError: Distinguishes errors from informational messages. 1208 IsError bool `json:"isError,omitempty"` 1209 1210 // RefersTo: Reference to which the message applies. 1211 // 1212 // Possible values: 1213 // "UNSPECIFIED" - Status doesn't refer to any particular input. 1214 // "BREAKPOINT_SOURCE_LOCATION" - Status applies to the breakpoint and 1215 // is related to its location. 1216 // "BREAKPOINT_CONDITION" - Status applies to the breakpoint and is 1217 // related to its condition. 1218 // "BREAKPOINT_EXPRESSION" - Status applies to the breakpoint and is 1219 // related to its expressions. 1220 // "BREAKPOINT_AGE" - Status applies to the breakpoint and is related 1221 // to its age. 1222 // "BREAKPOINT_CANARY_FAILED" - Status applies to the breakpoint when 1223 // the breakpoint failed to exit the canary state. 1224 // "VARIABLE_NAME" - Status applies to the entire variable. 1225 // "VARIABLE_VALUE" - Status applies to variable value (variable name 1226 // is valid). 1227 RefersTo string `json:"refersTo,omitempty"` 1228 1229 // ForceSendFields is a list of field names (e.g. "Description") to 1230 // unconditionally include in API requests. By default, fields with 1231 // empty or default values are omitted from API requests. However, any 1232 // non-pointer, non-interface field appearing in ForceSendFields will be 1233 // sent to the server regardless of whether the field is empty or not. 1234 // This may be used to include empty fields in Patch requests. 1235 ForceSendFields []string `json:"-"` 1236 1237 // NullFields is a list of field names (e.g. "Description") to include 1238 // in API requests with the JSON null value. By default, fields with 1239 // empty values are omitted from API requests. However, any field with 1240 // an empty value appearing in NullFields will be sent to the server as 1241 // null. It is an error if a field in this list has a non-empty value. 1242 // This may be used to include null fields in Patch requests. 1243 NullFields []string `json:"-"` 1244} 1245 1246func (s *StatusMessage) MarshalJSON() ([]byte, error) { 1247 type NoMethod StatusMessage 1248 raw := NoMethod(*s) 1249 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 1250} 1251 1252// UpdateActiveBreakpointRequest: Request to update an active 1253// breakpoint. 1254type UpdateActiveBreakpointRequest struct { 1255 // Breakpoint: Required. Updated breakpoint information. The field `id` 1256 // must be set. The agent must echo all Breakpoint specification fields 1257 // in the update. 1258 Breakpoint *Breakpoint `json:"breakpoint,omitempty"` 1259 1260 // ForceSendFields is a list of field names (e.g. "Breakpoint") to 1261 // unconditionally include in API requests. By default, fields with 1262 // empty or default values are omitted from API requests. However, any 1263 // non-pointer, non-interface field appearing in ForceSendFields will be 1264 // sent to the server regardless of whether the field is empty or not. 1265 // This may be used to include empty fields in Patch requests. 1266 ForceSendFields []string `json:"-"` 1267 1268 // NullFields is a list of field names (e.g. "Breakpoint") to include in 1269 // API requests with the JSON null value. By default, fields with empty 1270 // values are omitted from API requests. However, any field with an 1271 // empty value appearing in NullFields will be sent to the server as 1272 // null. It is an error if a field in this list has a non-empty value. 1273 // This may be used to include null fields in Patch requests. 1274 NullFields []string `json:"-"` 1275} 1276 1277func (s *UpdateActiveBreakpointRequest) MarshalJSON() ([]byte, error) { 1278 type NoMethod UpdateActiveBreakpointRequest 1279 raw := NoMethod(*s) 1280 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 1281} 1282 1283// UpdateActiveBreakpointResponse: Response for updating an active 1284// breakpoint. The message is defined to allow future extensions. 1285type UpdateActiveBreakpointResponse struct { 1286 // ServerResponse contains the HTTP response code and headers from the 1287 // server. 1288 googleapi.ServerResponse `json:"-"` 1289} 1290 1291// Variable: Represents a variable or an argument possibly of a compound 1292// object type. Note how the following variables are represented: 1) A 1293// simple variable: int x = 5 { name: "x", value: "5", type: "int" } // 1294// Captured variable 2) A compound object: struct T { int m1; int m2; }; 1295// T x = { 3, 7 }; { // Captured variable name: "x", type: "T", members 1296// { name: "m1", value: "3", type: "int" }, members { name: "m2", value: 1297// "7", type: "int" } } 3) A pointer where the pointee was captured: T x 1298// = { 3, 7 }; T* p = &x; { // Captured variable name: "p", type: "T*", 1299// value: "0x00500500", members { name: "m1", value: "3", type: "int" }, 1300// members { name: "m2", value: "7", type: "int" } } 4) A pointer where 1301// the pointee was not captured: T* p = new T; { // Captured variable 1302// name: "p", type: "T*", value: "0x00400400" status { is_error: true, 1303// description { format: "unavailable" } } } The status should describe 1304// the reason for the missing value, such as ``, ``, ``. Note that a 1305// null pointer should not have members. 5) An unnamed value: int* p = 1306// new int(7); { // Captured variable name: "p", value: "0x00500500", 1307// type: "int*", members { value: "7", type: "int" } } 6) An unnamed 1308// pointer where the pointee was not captured: int* p = new int(7); 1309// int** pp = &p; { // Captured variable name: "pp", value: 1310// "0x00500500", type: "int**", members { value: "0x00400400", type: 1311// "int*" status { is_error: true, description: { format: "unavailable" 1312// } } } } } To optimize computation, memory and network traffic, 1313// variables that repeat in the output multiple times can be stored once 1314// in a shared variable table and be referenced using the 1315// `var_table_index` field. The variables stored in the shared table are 1316// nameless and are essentially a partition of the complete variable. To 1317// reconstruct the complete variable, merge the referencing variable 1318// with the referenced variable. When using the shared variable table, 1319// the following variables: T x = { 3, 7 }; T* p = &x; T& r = x; { name: 1320// "x", var_table_index: 3, type: "T" } // Captured variables { name: 1321// "p", value "0x00500500", type="T*", var_table_index: 3 } { name: "r", 1322// type="T&", var_table_index: 3 } { // Shared variable table entry #3: 1323// members { name: "m1", value: "3", type: "int" }, members { name: 1324// "m2", value: "7", type: "int" } } Note that the pointer address is 1325// stored with the referencing variable and not with the referenced 1326// variable. This allows the referenced variable to be shared between 1327// pointers and references. The type field is optional. The debugger 1328// agent may or may not support it. 1329type Variable struct { 1330 // Members: Members contained or pointed to by the variable. 1331 Members []*Variable `json:"members,omitempty"` 1332 1333 // Name: Name of the variable, if any. 1334 Name string `json:"name,omitempty"` 1335 1336 // Status: Status associated with the variable. This field will usually 1337 // stay unset. A status of a single variable only applies to that 1338 // variable or expression. The rest of breakpoint data still remains 1339 // valid. Variables might be reported in error state even when 1340 // breakpoint is not in final state. The message may refer to variable 1341 // name with `refers_to` set to `VARIABLE_NAME`. Alternatively 1342 // `refers_to` will be set to `VARIABLE_VALUE`. In either case variable 1343 // value and members will be unset. Example of error message applied to 1344 // name: `Invalid expression syntax`. Example of information message 1345 // applied to value: `Not captured`. Examples of error message applied 1346 // to value: * `Malformed string`, * `Field f not found in class C` * 1347 // `Null pointer dereference` 1348 Status *StatusMessage `json:"status,omitempty"` 1349 1350 // Type: Variable type (e.g. `MyClass`). If the variable is split with 1351 // `var_table_index`, `type` goes next to `value`. The interpretation of 1352 // a type is agent specific. It is recommended to include the dynamic 1353 // type rather than a static type of an object. 1354 Type string `json:"type,omitempty"` 1355 1356 // Value: Simple value of the variable. 1357 Value string `json:"value,omitempty"` 1358 1359 // VarTableIndex: Reference to a variable in the shared variable table. 1360 // More than one variable can reference the same variable in the table. 1361 // The `var_table_index` field is an index into `variable_table` in 1362 // Breakpoint. 1363 VarTableIndex int64 `json:"varTableIndex,omitempty"` 1364 1365 // ForceSendFields is a list of field names (e.g. "Members") to 1366 // unconditionally include in API requests. By default, fields with 1367 // empty or default values are omitted from API requests. However, any 1368 // non-pointer, non-interface field appearing in ForceSendFields will be 1369 // sent to the server regardless of whether the field is empty or not. 1370 // This may be used to include empty fields in Patch requests. 1371 ForceSendFields []string `json:"-"` 1372 1373 // NullFields is a list of field names (e.g. "Members") to include in 1374 // API requests with the JSON null value. By default, fields with empty 1375 // values are omitted from API requests. However, any field with an 1376 // empty value appearing in NullFields will be sent to the server as 1377 // null. It is an error if a field in this list has a non-empty value. 1378 // This may be used to include null fields in Patch requests. 1379 NullFields []string `json:"-"` 1380} 1381 1382func (s *Variable) MarshalJSON() ([]byte, error) { 1383 type NoMethod Variable 1384 raw := NoMethod(*s) 1385 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 1386} 1387 1388// method id "clouddebugger.controller.debuggees.register": 1389 1390type ControllerDebuggeesRegisterCall struct { 1391 s *Service 1392 registerdebuggeerequest *RegisterDebuggeeRequest 1393 urlParams_ gensupport.URLParams 1394 ctx_ context.Context 1395 header_ http.Header 1396} 1397 1398// Register: Registers the debuggee with the controller service. All 1399// agents attached to the same application must call this method with 1400// exactly the same request content to get back the same stable 1401// `debuggee_id`. Agents should call this method again whenever 1402// `google.rpc.Code.NOT_FOUND` is returned from any controller method. 1403// This protocol allows the controller service to disable debuggees, 1404// recover from data loss, or change the `debuggee_id` format. Agents 1405// must handle `debuggee_id` value changing upon re-registration. 1406func (r *ControllerDebuggeesService) Register(registerdebuggeerequest *RegisterDebuggeeRequest) *ControllerDebuggeesRegisterCall { 1407 c := &ControllerDebuggeesRegisterCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1408 c.registerdebuggeerequest = registerdebuggeerequest 1409 return c 1410} 1411 1412// Fields allows partial responses to be retrieved. See 1413// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1414// for more information. 1415func (c *ControllerDebuggeesRegisterCall) Fields(s ...googleapi.Field) *ControllerDebuggeesRegisterCall { 1416 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1417 return c 1418} 1419 1420// Context sets the context to be used in this call's Do method. Any 1421// pending HTTP request will be aborted if the provided context is 1422// canceled. 1423func (c *ControllerDebuggeesRegisterCall) Context(ctx context.Context) *ControllerDebuggeesRegisterCall { 1424 c.ctx_ = ctx 1425 return c 1426} 1427 1428// Header returns an http.Header that can be modified by the caller to 1429// add HTTP headers to the request. 1430func (c *ControllerDebuggeesRegisterCall) Header() http.Header { 1431 if c.header_ == nil { 1432 c.header_ = make(http.Header) 1433 } 1434 return c.header_ 1435} 1436 1437func (c *ControllerDebuggeesRegisterCall) doRequest(alt string) (*http.Response, error) { 1438 reqHeaders := make(http.Header) 1439 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210830") 1440 for k, v := range c.header_ { 1441 reqHeaders[k] = v 1442 } 1443 reqHeaders.Set("User-Agent", c.s.userAgent()) 1444 var body io.Reader = nil 1445 body, err := googleapi.WithoutDataWrapper.JSONReader(c.registerdebuggeerequest) 1446 if err != nil { 1447 return nil, err 1448 } 1449 reqHeaders.Set("Content-Type", "application/json") 1450 c.urlParams_.Set("alt", alt) 1451 c.urlParams_.Set("prettyPrint", "false") 1452 urls := googleapi.ResolveRelative(c.s.BasePath, "v2/controller/debuggees/register") 1453 urls += "?" + c.urlParams_.Encode() 1454 req, err := http.NewRequest("POST", urls, body) 1455 if err != nil { 1456 return nil, err 1457 } 1458 req.Header = reqHeaders 1459 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1460} 1461 1462// Do executes the "clouddebugger.controller.debuggees.register" call. 1463// Exactly one of *RegisterDebuggeeResponse or error will be non-nil. 1464// Any non-2xx status code is an error. Response headers are in either 1465// *RegisterDebuggeeResponse.ServerResponse.Header or (if a response was 1466// returned at all) in error.(*googleapi.Error).Header. Use 1467// googleapi.IsNotModified to check whether the returned error was 1468// because http.StatusNotModified was returned. 1469func (c *ControllerDebuggeesRegisterCall) Do(opts ...googleapi.CallOption) (*RegisterDebuggeeResponse, error) { 1470 gensupport.SetOptions(c.urlParams_, opts...) 1471 res, err := c.doRequest("json") 1472 if res != nil && res.StatusCode == http.StatusNotModified { 1473 if res.Body != nil { 1474 res.Body.Close() 1475 } 1476 return nil, &googleapi.Error{ 1477 Code: res.StatusCode, 1478 Header: res.Header, 1479 } 1480 } 1481 if err != nil { 1482 return nil, err 1483 } 1484 defer googleapi.CloseBody(res) 1485 if err := googleapi.CheckResponse(res); err != nil { 1486 return nil, err 1487 } 1488 ret := &RegisterDebuggeeResponse{ 1489 ServerResponse: googleapi.ServerResponse{ 1490 Header: res.Header, 1491 HTTPStatusCode: res.StatusCode, 1492 }, 1493 } 1494 target := &ret 1495 if err := gensupport.DecodeResponse(target, res); err != nil { 1496 return nil, err 1497 } 1498 return ret, nil 1499 // { 1500 // "description": "Registers the debuggee with the controller service. All agents attached to the same application must call this method with exactly the same request content to get back the same stable `debuggee_id`. Agents should call this method again whenever `google.rpc.Code.NOT_FOUND` is returned from any controller method. This protocol allows the controller service to disable debuggees, recover from data loss, or change the `debuggee_id` format. Agents must handle `debuggee_id` value changing upon re-registration.", 1501 // "flatPath": "v2/controller/debuggees/register", 1502 // "httpMethod": "POST", 1503 // "id": "clouddebugger.controller.debuggees.register", 1504 // "parameterOrder": [], 1505 // "parameters": {}, 1506 // "path": "v2/controller/debuggees/register", 1507 // "request": { 1508 // "$ref": "RegisterDebuggeeRequest" 1509 // }, 1510 // "response": { 1511 // "$ref": "RegisterDebuggeeResponse" 1512 // }, 1513 // "scopes": [ 1514 // "https://www.googleapis.com/auth/cloud-platform", 1515 // "https://www.googleapis.com/auth/cloud_debugger" 1516 // ] 1517 // } 1518 1519} 1520 1521// method id "clouddebugger.controller.debuggees.breakpoints.list": 1522 1523type ControllerDebuggeesBreakpointsListCall struct { 1524 s *Service 1525 debuggeeId string 1526 urlParams_ gensupport.URLParams 1527 ifNoneMatch_ string 1528 ctx_ context.Context 1529 header_ http.Header 1530} 1531 1532// List: Returns the list of all active breakpoints for the debuggee. 1533// The breakpoint specification (`location`, `condition`, and 1534// `expressions` fields) is semantically immutable, although the field 1535// values may change. For example, an agent may update the location line 1536// number to reflect the actual line where the breakpoint was set, but 1537// this doesn't change the breakpoint semantics. This means that an 1538// agent does not need to check if a breakpoint has changed when it 1539// encounters the same breakpoint on a successive call. Moreover, an 1540// agent should remember the breakpoints that are completed until the 1541// controller removes them from the active list to avoid setting those 1542// breakpoints again. 1543// 1544// - debuggeeId: Identifies the debuggee. 1545func (r *ControllerDebuggeesBreakpointsService) List(debuggeeId string) *ControllerDebuggeesBreakpointsListCall { 1546 c := &ControllerDebuggeesBreakpointsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1547 c.debuggeeId = debuggeeId 1548 return c 1549} 1550 1551// AgentId sets the optional parameter "agentId": Identifies the agent. 1552// This is the ID returned in the RegisterDebuggee response. 1553func (c *ControllerDebuggeesBreakpointsListCall) AgentId(agentId string) *ControllerDebuggeesBreakpointsListCall { 1554 c.urlParams_.Set("agentId", agentId) 1555 return c 1556} 1557 1558// SuccessOnTimeout sets the optional parameter "successOnTimeout": If 1559// set to `true` (recommended), returns `google.rpc.Code.OK` status and 1560// sets the `wait_expired` response field to `true` when the 1561// server-selected timeout has expired. If set to `false` (deprecated), 1562// returns `google.rpc.Code.ABORTED` status when the server-selected 1563// timeout has expired. 1564func (c *ControllerDebuggeesBreakpointsListCall) SuccessOnTimeout(successOnTimeout bool) *ControllerDebuggeesBreakpointsListCall { 1565 c.urlParams_.Set("successOnTimeout", fmt.Sprint(successOnTimeout)) 1566 return c 1567} 1568 1569// WaitToken sets the optional parameter "waitToken": A token that, if 1570// specified, blocks the method call until the list of active 1571// breakpoints has changed, or a server-selected timeout has expired. 1572// The value should be set from the `next_wait_token` field in the last 1573// response. The initial value should be set to "init". 1574func (c *ControllerDebuggeesBreakpointsListCall) WaitToken(waitToken string) *ControllerDebuggeesBreakpointsListCall { 1575 c.urlParams_.Set("waitToken", waitToken) 1576 return c 1577} 1578 1579// Fields allows partial responses to be retrieved. See 1580// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1581// for more information. 1582func (c *ControllerDebuggeesBreakpointsListCall) Fields(s ...googleapi.Field) *ControllerDebuggeesBreakpointsListCall { 1583 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1584 return c 1585} 1586 1587// IfNoneMatch sets the optional parameter which makes the operation 1588// fail if the object's ETag matches the given value. This is useful for 1589// getting updates only after the object has changed since the last 1590// request. Use googleapi.IsNotModified to check whether the response 1591// error from Do is the result of In-None-Match. 1592func (c *ControllerDebuggeesBreakpointsListCall) IfNoneMatch(entityTag string) *ControllerDebuggeesBreakpointsListCall { 1593 c.ifNoneMatch_ = entityTag 1594 return c 1595} 1596 1597// Context sets the context to be used in this call's Do method. Any 1598// pending HTTP request will be aborted if the provided context is 1599// canceled. 1600func (c *ControllerDebuggeesBreakpointsListCall) Context(ctx context.Context) *ControllerDebuggeesBreakpointsListCall { 1601 c.ctx_ = ctx 1602 return c 1603} 1604 1605// Header returns an http.Header that can be modified by the caller to 1606// add HTTP headers to the request. 1607func (c *ControllerDebuggeesBreakpointsListCall) Header() http.Header { 1608 if c.header_ == nil { 1609 c.header_ = make(http.Header) 1610 } 1611 return c.header_ 1612} 1613 1614func (c *ControllerDebuggeesBreakpointsListCall) doRequest(alt string) (*http.Response, error) { 1615 reqHeaders := make(http.Header) 1616 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210830") 1617 for k, v := range c.header_ { 1618 reqHeaders[k] = v 1619 } 1620 reqHeaders.Set("User-Agent", c.s.userAgent()) 1621 if c.ifNoneMatch_ != "" { 1622 reqHeaders.Set("If-None-Match", c.ifNoneMatch_) 1623 } 1624 var body io.Reader = nil 1625 c.urlParams_.Set("alt", alt) 1626 c.urlParams_.Set("prettyPrint", "false") 1627 urls := googleapi.ResolveRelative(c.s.BasePath, "v2/controller/debuggees/{debuggeeId}/breakpoints") 1628 urls += "?" + c.urlParams_.Encode() 1629 req, err := http.NewRequest("GET", urls, body) 1630 if err != nil { 1631 return nil, err 1632 } 1633 req.Header = reqHeaders 1634 googleapi.Expand(req.URL, map[string]string{ 1635 "debuggeeId": c.debuggeeId, 1636 }) 1637 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1638} 1639 1640// Do executes the "clouddebugger.controller.debuggees.breakpoints.list" call. 1641// Exactly one of *ListActiveBreakpointsResponse or error will be 1642// non-nil. Any non-2xx status code is an error. Response headers are in 1643// either *ListActiveBreakpointsResponse.ServerResponse.Header or (if a 1644// response was returned at all) in error.(*googleapi.Error).Header. Use 1645// googleapi.IsNotModified to check whether the returned error was 1646// because http.StatusNotModified was returned. 1647func (c *ControllerDebuggeesBreakpointsListCall) Do(opts ...googleapi.CallOption) (*ListActiveBreakpointsResponse, error) { 1648 gensupport.SetOptions(c.urlParams_, opts...) 1649 res, err := c.doRequest("json") 1650 if res != nil && res.StatusCode == http.StatusNotModified { 1651 if res.Body != nil { 1652 res.Body.Close() 1653 } 1654 return nil, &googleapi.Error{ 1655 Code: res.StatusCode, 1656 Header: res.Header, 1657 } 1658 } 1659 if err != nil { 1660 return nil, err 1661 } 1662 defer googleapi.CloseBody(res) 1663 if err := googleapi.CheckResponse(res); err != nil { 1664 return nil, err 1665 } 1666 ret := &ListActiveBreakpointsResponse{ 1667 ServerResponse: googleapi.ServerResponse{ 1668 Header: res.Header, 1669 HTTPStatusCode: res.StatusCode, 1670 }, 1671 } 1672 target := &ret 1673 if err := gensupport.DecodeResponse(target, res); err != nil { 1674 return nil, err 1675 } 1676 return ret, nil 1677 // { 1678 // "description": "Returns the list of all active breakpoints for the debuggee. The breakpoint specification (`location`, `condition`, and `expressions` fields) is semantically immutable, although the field values may change. For example, an agent may update the location line number to reflect the actual line where the breakpoint was set, but this doesn't change the breakpoint semantics. This means that an agent does not need to check if a breakpoint has changed when it encounters the same breakpoint on a successive call. Moreover, an agent should remember the breakpoints that are completed until the controller removes them from the active list to avoid setting those breakpoints again.", 1679 // "flatPath": "v2/controller/debuggees/{debuggeeId}/breakpoints", 1680 // "httpMethod": "GET", 1681 // "id": "clouddebugger.controller.debuggees.breakpoints.list", 1682 // "parameterOrder": [ 1683 // "debuggeeId" 1684 // ], 1685 // "parameters": { 1686 // "agentId": { 1687 // "description": "Identifies the agent. This is the ID returned in the RegisterDebuggee response.", 1688 // "location": "query", 1689 // "type": "string" 1690 // }, 1691 // "debuggeeId": { 1692 // "description": "Required. Identifies the debuggee.", 1693 // "location": "path", 1694 // "required": true, 1695 // "type": "string" 1696 // }, 1697 // "successOnTimeout": { 1698 // "description": "If set to `true` (recommended), returns `google.rpc.Code.OK` status and sets the `wait_expired` response field to `true` when the server-selected timeout has expired. If set to `false` (deprecated), returns `google.rpc.Code.ABORTED` status when the server-selected timeout has expired.", 1699 // "location": "query", 1700 // "type": "boolean" 1701 // }, 1702 // "waitToken": { 1703 // "description": "A token that, if specified, blocks the method call until the list of active breakpoints has changed, or a server-selected timeout has expired. The value should be set from the `next_wait_token` field in the last response. The initial value should be set to `\"init\"`.", 1704 // "location": "query", 1705 // "type": "string" 1706 // } 1707 // }, 1708 // "path": "v2/controller/debuggees/{debuggeeId}/breakpoints", 1709 // "response": { 1710 // "$ref": "ListActiveBreakpointsResponse" 1711 // }, 1712 // "scopes": [ 1713 // "https://www.googleapis.com/auth/cloud-platform", 1714 // "https://www.googleapis.com/auth/cloud_debugger" 1715 // ] 1716 // } 1717 1718} 1719 1720// method id "clouddebugger.controller.debuggees.breakpoints.update": 1721 1722type ControllerDebuggeesBreakpointsUpdateCall struct { 1723 s *Service 1724 debuggeeId string 1725 id string 1726 updateactivebreakpointrequest *UpdateActiveBreakpointRequest 1727 urlParams_ gensupport.URLParams 1728 ctx_ context.Context 1729 header_ http.Header 1730} 1731 1732// Update: Updates the breakpoint state or mutable fields. The entire 1733// Breakpoint message must be sent back to the controller service. 1734// Updates to active breakpoint fields are only allowed if the new value 1735// does not change the breakpoint specification. Updates to the 1736// `location`, `condition` and `expressions` fields should not alter the 1737// breakpoint semantics. These may only make changes such as 1738// canonicalizing a value or snapping the location to the correct line 1739// of code. 1740// 1741// - debuggeeId: Identifies the debuggee being debugged. 1742// - id: Breakpoint identifier, unique in the scope of the debuggee. 1743func (r *ControllerDebuggeesBreakpointsService) Update(debuggeeId string, id string, updateactivebreakpointrequest *UpdateActiveBreakpointRequest) *ControllerDebuggeesBreakpointsUpdateCall { 1744 c := &ControllerDebuggeesBreakpointsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1745 c.debuggeeId = debuggeeId 1746 c.id = id 1747 c.updateactivebreakpointrequest = updateactivebreakpointrequest 1748 return c 1749} 1750 1751// Fields allows partial responses to be retrieved. See 1752// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1753// for more information. 1754func (c *ControllerDebuggeesBreakpointsUpdateCall) Fields(s ...googleapi.Field) *ControllerDebuggeesBreakpointsUpdateCall { 1755 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1756 return c 1757} 1758 1759// Context sets the context to be used in this call's Do method. Any 1760// pending HTTP request will be aborted if the provided context is 1761// canceled. 1762func (c *ControllerDebuggeesBreakpointsUpdateCall) Context(ctx context.Context) *ControllerDebuggeesBreakpointsUpdateCall { 1763 c.ctx_ = ctx 1764 return c 1765} 1766 1767// Header returns an http.Header that can be modified by the caller to 1768// add HTTP headers to the request. 1769func (c *ControllerDebuggeesBreakpointsUpdateCall) Header() http.Header { 1770 if c.header_ == nil { 1771 c.header_ = make(http.Header) 1772 } 1773 return c.header_ 1774} 1775 1776func (c *ControllerDebuggeesBreakpointsUpdateCall) doRequest(alt string) (*http.Response, error) { 1777 reqHeaders := make(http.Header) 1778 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210830") 1779 for k, v := range c.header_ { 1780 reqHeaders[k] = v 1781 } 1782 reqHeaders.Set("User-Agent", c.s.userAgent()) 1783 var body io.Reader = nil 1784 body, err := googleapi.WithoutDataWrapper.JSONReader(c.updateactivebreakpointrequest) 1785 if err != nil { 1786 return nil, err 1787 } 1788 reqHeaders.Set("Content-Type", "application/json") 1789 c.urlParams_.Set("alt", alt) 1790 c.urlParams_.Set("prettyPrint", "false") 1791 urls := googleapi.ResolveRelative(c.s.BasePath, "v2/controller/debuggees/{debuggeeId}/breakpoints/{id}") 1792 urls += "?" + c.urlParams_.Encode() 1793 req, err := http.NewRequest("PUT", urls, body) 1794 if err != nil { 1795 return nil, err 1796 } 1797 req.Header = reqHeaders 1798 googleapi.Expand(req.URL, map[string]string{ 1799 "debuggeeId": c.debuggeeId, 1800 "id": c.id, 1801 }) 1802 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1803} 1804 1805// Do executes the "clouddebugger.controller.debuggees.breakpoints.update" call. 1806// Exactly one of *UpdateActiveBreakpointResponse or error will be 1807// non-nil. Any non-2xx status code is an error. Response headers are in 1808// either *UpdateActiveBreakpointResponse.ServerResponse.Header or (if a 1809// response was returned at all) in error.(*googleapi.Error).Header. Use 1810// googleapi.IsNotModified to check whether the returned error was 1811// because http.StatusNotModified was returned. 1812func (c *ControllerDebuggeesBreakpointsUpdateCall) Do(opts ...googleapi.CallOption) (*UpdateActiveBreakpointResponse, error) { 1813 gensupport.SetOptions(c.urlParams_, opts...) 1814 res, err := c.doRequest("json") 1815 if res != nil && res.StatusCode == http.StatusNotModified { 1816 if res.Body != nil { 1817 res.Body.Close() 1818 } 1819 return nil, &googleapi.Error{ 1820 Code: res.StatusCode, 1821 Header: res.Header, 1822 } 1823 } 1824 if err != nil { 1825 return nil, err 1826 } 1827 defer googleapi.CloseBody(res) 1828 if err := googleapi.CheckResponse(res); err != nil { 1829 return nil, err 1830 } 1831 ret := &UpdateActiveBreakpointResponse{ 1832 ServerResponse: googleapi.ServerResponse{ 1833 Header: res.Header, 1834 HTTPStatusCode: res.StatusCode, 1835 }, 1836 } 1837 target := &ret 1838 if err := gensupport.DecodeResponse(target, res); err != nil { 1839 return nil, err 1840 } 1841 return ret, nil 1842 // { 1843 // "description": "Updates the breakpoint state or mutable fields. The entire Breakpoint message must be sent back to the controller service. Updates to active breakpoint fields are only allowed if the new value does not change the breakpoint specification. Updates to the `location`, `condition` and `expressions` fields should not alter the breakpoint semantics. These may only make changes such as canonicalizing a value or snapping the location to the correct line of code.", 1844 // "flatPath": "v2/controller/debuggees/{debuggeeId}/breakpoints/{id}", 1845 // "httpMethod": "PUT", 1846 // "id": "clouddebugger.controller.debuggees.breakpoints.update", 1847 // "parameterOrder": [ 1848 // "debuggeeId", 1849 // "id" 1850 // ], 1851 // "parameters": { 1852 // "debuggeeId": { 1853 // "description": "Required. Identifies the debuggee being debugged.", 1854 // "location": "path", 1855 // "required": true, 1856 // "type": "string" 1857 // }, 1858 // "id": { 1859 // "description": "Breakpoint identifier, unique in the scope of the debuggee.", 1860 // "location": "path", 1861 // "required": true, 1862 // "type": "string" 1863 // } 1864 // }, 1865 // "path": "v2/controller/debuggees/{debuggeeId}/breakpoints/{id}", 1866 // "request": { 1867 // "$ref": "UpdateActiveBreakpointRequest" 1868 // }, 1869 // "response": { 1870 // "$ref": "UpdateActiveBreakpointResponse" 1871 // }, 1872 // "scopes": [ 1873 // "https://www.googleapis.com/auth/cloud-platform", 1874 // "https://www.googleapis.com/auth/cloud_debugger" 1875 // ] 1876 // } 1877 1878} 1879 1880// method id "clouddebugger.debugger.debuggees.list": 1881 1882type DebuggerDebuggeesListCall struct { 1883 s *Service 1884 urlParams_ gensupport.URLParams 1885 ifNoneMatch_ string 1886 ctx_ context.Context 1887 header_ http.Header 1888} 1889 1890// List: Lists all the debuggees that the user has access to. 1891func (r *DebuggerDebuggeesService) List() *DebuggerDebuggeesListCall { 1892 c := &DebuggerDebuggeesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1893 return c 1894} 1895 1896// ClientVersion sets the optional parameter "clientVersion": Required. 1897// The client version making the call. Schema: `domain/type/version` 1898// (e.g., `google.com/intellij/v1`). 1899func (c *DebuggerDebuggeesListCall) ClientVersion(clientVersion string) *DebuggerDebuggeesListCall { 1900 c.urlParams_.Set("clientVersion", clientVersion) 1901 return c 1902} 1903 1904// IncludeInactive sets the optional parameter "includeInactive": When 1905// set to `true`, the result includes all debuggees. Otherwise, the 1906// result includes only debuggees that are active. 1907func (c *DebuggerDebuggeesListCall) IncludeInactive(includeInactive bool) *DebuggerDebuggeesListCall { 1908 c.urlParams_.Set("includeInactive", fmt.Sprint(includeInactive)) 1909 return c 1910} 1911 1912// Project sets the optional parameter "project": Required. Project 1913// number of a Google Cloud project whose debuggees to list. 1914func (c *DebuggerDebuggeesListCall) Project(project string) *DebuggerDebuggeesListCall { 1915 c.urlParams_.Set("project", project) 1916 return c 1917} 1918 1919// Fields allows partial responses to be retrieved. See 1920// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1921// for more information. 1922func (c *DebuggerDebuggeesListCall) Fields(s ...googleapi.Field) *DebuggerDebuggeesListCall { 1923 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1924 return c 1925} 1926 1927// IfNoneMatch sets the optional parameter which makes the operation 1928// fail if the object's ETag matches the given value. This is useful for 1929// getting updates only after the object has changed since the last 1930// request. Use googleapi.IsNotModified to check whether the response 1931// error from Do is the result of In-None-Match. 1932func (c *DebuggerDebuggeesListCall) IfNoneMatch(entityTag string) *DebuggerDebuggeesListCall { 1933 c.ifNoneMatch_ = entityTag 1934 return c 1935} 1936 1937// Context sets the context to be used in this call's Do method. Any 1938// pending HTTP request will be aborted if the provided context is 1939// canceled. 1940func (c *DebuggerDebuggeesListCall) Context(ctx context.Context) *DebuggerDebuggeesListCall { 1941 c.ctx_ = ctx 1942 return c 1943} 1944 1945// Header returns an http.Header that can be modified by the caller to 1946// add HTTP headers to the request. 1947func (c *DebuggerDebuggeesListCall) Header() http.Header { 1948 if c.header_ == nil { 1949 c.header_ = make(http.Header) 1950 } 1951 return c.header_ 1952} 1953 1954func (c *DebuggerDebuggeesListCall) doRequest(alt string) (*http.Response, error) { 1955 reqHeaders := make(http.Header) 1956 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210830") 1957 for k, v := range c.header_ { 1958 reqHeaders[k] = v 1959 } 1960 reqHeaders.Set("User-Agent", c.s.userAgent()) 1961 if c.ifNoneMatch_ != "" { 1962 reqHeaders.Set("If-None-Match", c.ifNoneMatch_) 1963 } 1964 var body io.Reader = nil 1965 c.urlParams_.Set("alt", alt) 1966 c.urlParams_.Set("prettyPrint", "false") 1967 urls := googleapi.ResolveRelative(c.s.BasePath, "v2/debugger/debuggees") 1968 urls += "?" + c.urlParams_.Encode() 1969 req, err := http.NewRequest("GET", urls, body) 1970 if err != nil { 1971 return nil, err 1972 } 1973 req.Header = reqHeaders 1974 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1975} 1976 1977// Do executes the "clouddebugger.debugger.debuggees.list" call. 1978// Exactly one of *ListDebuggeesResponse or error will be non-nil. Any 1979// non-2xx status code is an error. Response headers are in either 1980// *ListDebuggeesResponse.ServerResponse.Header or (if a response was 1981// returned at all) in error.(*googleapi.Error).Header. Use 1982// googleapi.IsNotModified to check whether the returned error was 1983// because http.StatusNotModified was returned. 1984func (c *DebuggerDebuggeesListCall) Do(opts ...googleapi.CallOption) (*ListDebuggeesResponse, error) { 1985 gensupport.SetOptions(c.urlParams_, opts...) 1986 res, err := c.doRequest("json") 1987 if res != nil && res.StatusCode == http.StatusNotModified { 1988 if res.Body != nil { 1989 res.Body.Close() 1990 } 1991 return nil, &googleapi.Error{ 1992 Code: res.StatusCode, 1993 Header: res.Header, 1994 } 1995 } 1996 if err != nil { 1997 return nil, err 1998 } 1999 defer googleapi.CloseBody(res) 2000 if err := googleapi.CheckResponse(res); err != nil { 2001 return nil, err 2002 } 2003 ret := &ListDebuggeesResponse{ 2004 ServerResponse: googleapi.ServerResponse{ 2005 Header: res.Header, 2006 HTTPStatusCode: res.StatusCode, 2007 }, 2008 } 2009 target := &ret 2010 if err := gensupport.DecodeResponse(target, res); err != nil { 2011 return nil, err 2012 } 2013 return ret, nil 2014 // { 2015 // "description": "Lists all the debuggees that the user has access to.", 2016 // "flatPath": "v2/debugger/debuggees", 2017 // "httpMethod": "GET", 2018 // "id": "clouddebugger.debugger.debuggees.list", 2019 // "parameterOrder": [], 2020 // "parameters": { 2021 // "clientVersion": { 2022 // "description": "Required. The client version making the call. Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).", 2023 // "location": "query", 2024 // "type": "string" 2025 // }, 2026 // "includeInactive": { 2027 // "description": "When set to `true`, the result includes all debuggees. Otherwise, the result includes only debuggees that are active.", 2028 // "location": "query", 2029 // "type": "boolean" 2030 // }, 2031 // "project": { 2032 // "description": "Required. Project number of a Google Cloud project whose debuggees to list.", 2033 // "location": "query", 2034 // "type": "string" 2035 // } 2036 // }, 2037 // "path": "v2/debugger/debuggees", 2038 // "response": { 2039 // "$ref": "ListDebuggeesResponse" 2040 // }, 2041 // "scopes": [ 2042 // "https://www.googleapis.com/auth/cloud-platform", 2043 // "https://www.googleapis.com/auth/cloud_debugger" 2044 // ] 2045 // } 2046 2047} 2048 2049// method id "clouddebugger.debugger.debuggees.breakpoints.delete": 2050 2051type DebuggerDebuggeesBreakpointsDeleteCall struct { 2052 s *Service 2053 debuggeeId string 2054 breakpointId string 2055 urlParams_ gensupport.URLParams 2056 ctx_ context.Context 2057 header_ http.Header 2058} 2059 2060// Delete: Deletes the breakpoint from the debuggee. 2061// 2062// - breakpointId: ID of the breakpoint to delete. 2063// - debuggeeId: ID of the debuggee whose breakpoint to delete. 2064func (r *DebuggerDebuggeesBreakpointsService) Delete(debuggeeId string, breakpointId string) *DebuggerDebuggeesBreakpointsDeleteCall { 2065 c := &DebuggerDebuggeesBreakpointsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2066 c.debuggeeId = debuggeeId 2067 c.breakpointId = breakpointId 2068 return c 2069} 2070 2071// ClientVersion sets the optional parameter "clientVersion": Required. 2072// The client version making the call. Schema: `domain/type/version` 2073// (e.g., `google.com/intellij/v1`). 2074func (c *DebuggerDebuggeesBreakpointsDeleteCall) ClientVersion(clientVersion string) *DebuggerDebuggeesBreakpointsDeleteCall { 2075 c.urlParams_.Set("clientVersion", clientVersion) 2076 return c 2077} 2078 2079// Fields allows partial responses to be retrieved. See 2080// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2081// for more information. 2082func (c *DebuggerDebuggeesBreakpointsDeleteCall) Fields(s ...googleapi.Field) *DebuggerDebuggeesBreakpointsDeleteCall { 2083 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2084 return c 2085} 2086 2087// Context sets the context to be used in this call's Do method. Any 2088// pending HTTP request will be aborted if the provided context is 2089// canceled. 2090func (c *DebuggerDebuggeesBreakpointsDeleteCall) Context(ctx context.Context) *DebuggerDebuggeesBreakpointsDeleteCall { 2091 c.ctx_ = ctx 2092 return c 2093} 2094 2095// Header returns an http.Header that can be modified by the caller to 2096// add HTTP headers to the request. 2097func (c *DebuggerDebuggeesBreakpointsDeleteCall) Header() http.Header { 2098 if c.header_ == nil { 2099 c.header_ = make(http.Header) 2100 } 2101 return c.header_ 2102} 2103 2104func (c *DebuggerDebuggeesBreakpointsDeleteCall) doRequest(alt string) (*http.Response, error) { 2105 reqHeaders := make(http.Header) 2106 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210830") 2107 for k, v := range c.header_ { 2108 reqHeaders[k] = v 2109 } 2110 reqHeaders.Set("User-Agent", c.s.userAgent()) 2111 var body io.Reader = nil 2112 c.urlParams_.Set("alt", alt) 2113 c.urlParams_.Set("prettyPrint", "false") 2114 urls := googleapi.ResolveRelative(c.s.BasePath, "v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}") 2115 urls += "?" + c.urlParams_.Encode() 2116 req, err := http.NewRequest("DELETE", urls, body) 2117 if err != nil { 2118 return nil, err 2119 } 2120 req.Header = reqHeaders 2121 googleapi.Expand(req.URL, map[string]string{ 2122 "debuggeeId": c.debuggeeId, 2123 "breakpointId": c.breakpointId, 2124 }) 2125 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2126} 2127 2128// Do executes the "clouddebugger.debugger.debuggees.breakpoints.delete" call. 2129// Exactly one of *Empty or error will be non-nil. Any non-2xx status 2130// code is an error. Response headers are in either 2131// *Empty.ServerResponse.Header or (if a response was returned at all) 2132// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to 2133// check whether the returned error was because http.StatusNotModified 2134// was returned. 2135func (c *DebuggerDebuggeesBreakpointsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) { 2136 gensupport.SetOptions(c.urlParams_, opts...) 2137 res, err := c.doRequest("json") 2138 if res != nil && res.StatusCode == http.StatusNotModified { 2139 if res.Body != nil { 2140 res.Body.Close() 2141 } 2142 return nil, &googleapi.Error{ 2143 Code: res.StatusCode, 2144 Header: res.Header, 2145 } 2146 } 2147 if err != nil { 2148 return nil, err 2149 } 2150 defer googleapi.CloseBody(res) 2151 if err := googleapi.CheckResponse(res); err != nil { 2152 return nil, err 2153 } 2154 ret := &Empty{ 2155 ServerResponse: googleapi.ServerResponse{ 2156 Header: res.Header, 2157 HTTPStatusCode: res.StatusCode, 2158 }, 2159 } 2160 target := &ret 2161 if err := gensupport.DecodeResponse(target, res); err != nil { 2162 return nil, err 2163 } 2164 return ret, nil 2165 // { 2166 // "description": "Deletes the breakpoint from the debuggee.", 2167 // "flatPath": "v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}", 2168 // "httpMethod": "DELETE", 2169 // "id": "clouddebugger.debugger.debuggees.breakpoints.delete", 2170 // "parameterOrder": [ 2171 // "debuggeeId", 2172 // "breakpointId" 2173 // ], 2174 // "parameters": { 2175 // "breakpointId": { 2176 // "description": "Required. ID of the breakpoint to delete.", 2177 // "location": "path", 2178 // "required": true, 2179 // "type": "string" 2180 // }, 2181 // "clientVersion": { 2182 // "description": "Required. The client version making the call. Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).", 2183 // "location": "query", 2184 // "type": "string" 2185 // }, 2186 // "debuggeeId": { 2187 // "description": "Required. ID of the debuggee whose breakpoint to delete.", 2188 // "location": "path", 2189 // "required": true, 2190 // "type": "string" 2191 // } 2192 // }, 2193 // "path": "v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}", 2194 // "response": { 2195 // "$ref": "Empty" 2196 // }, 2197 // "scopes": [ 2198 // "https://www.googleapis.com/auth/cloud-platform", 2199 // "https://www.googleapis.com/auth/cloud_debugger" 2200 // ] 2201 // } 2202 2203} 2204 2205// method id "clouddebugger.debugger.debuggees.breakpoints.get": 2206 2207type DebuggerDebuggeesBreakpointsGetCall struct { 2208 s *Service 2209 debuggeeId string 2210 breakpointId string 2211 urlParams_ gensupport.URLParams 2212 ifNoneMatch_ string 2213 ctx_ context.Context 2214 header_ http.Header 2215} 2216 2217// Get: Gets breakpoint information. 2218// 2219// - breakpointId: ID of the breakpoint to get. 2220// - debuggeeId: ID of the debuggee whose breakpoint to get. 2221func (r *DebuggerDebuggeesBreakpointsService) Get(debuggeeId string, breakpointId string) *DebuggerDebuggeesBreakpointsGetCall { 2222 c := &DebuggerDebuggeesBreakpointsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2223 c.debuggeeId = debuggeeId 2224 c.breakpointId = breakpointId 2225 return c 2226} 2227 2228// ClientVersion sets the optional parameter "clientVersion": Required. 2229// The client version making the call. Schema: `domain/type/version` 2230// (e.g., `google.com/intellij/v1`). 2231func (c *DebuggerDebuggeesBreakpointsGetCall) ClientVersion(clientVersion string) *DebuggerDebuggeesBreakpointsGetCall { 2232 c.urlParams_.Set("clientVersion", clientVersion) 2233 return c 2234} 2235 2236// Fields allows partial responses to be retrieved. See 2237// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2238// for more information. 2239func (c *DebuggerDebuggeesBreakpointsGetCall) Fields(s ...googleapi.Field) *DebuggerDebuggeesBreakpointsGetCall { 2240 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2241 return c 2242} 2243 2244// IfNoneMatch sets the optional parameter which makes the operation 2245// fail if the object's ETag matches the given value. This is useful for 2246// getting updates only after the object has changed since the last 2247// request. Use googleapi.IsNotModified to check whether the response 2248// error from Do is the result of In-None-Match. 2249func (c *DebuggerDebuggeesBreakpointsGetCall) IfNoneMatch(entityTag string) *DebuggerDebuggeesBreakpointsGetCall { 2250 c.ifNoneMatch_ = entityTag 2251 return c 2252} 2253 2254// Context sets the context to be used in this call's Do method. Any 2255// pending HTTP request will be aborted if the provided context is 2256// canceled. 2257func (c *DebuggerDebuggeesBreakpointsGetCall) Context(ctx context.Context) *DebuggerDebuggeesBreakpointsGetCall { 2258 c.ctx_ = ctx 2259 return c 2260} 2261 2262// Header returns an http.Header that can be modified by the caller to 2263// add HTTP headers to the request. 2264func (c *DebuggerDebuggeesBreakpointsGetCall) Header() http.Header { 2265 if c.header_ == nil { 2266 c.header_ = make(http.Header) 2267 } 2268 return c.header_ 2269} 2270 2271func (c *DebuggerDebuggeesBreakpointsGetCall) doRequest(alt string) (*http.Response, error) { 2272 reqHeaders := make(http.Header) 2273 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210830") 2274 for k, v := range c.header_ { 2275 reqHeaders[k] = v 2276 } 2277 reqHeaders.Set("User-Agent", c.s.userAgent()) 2278 if c.ifNoneMatch_ != "" { 2279 reqHeaders.Set("If-None-Match", c.ifNoneMatch_) 2280 } 2281 var body io.Reader = nil 2282 c.urlParams_.Set("alt", alt) 2283 c.urlParams_.Set("prettyPrint", "false") 2284 urls := googleapi.ResolveRelative(c.s.BasePath, "v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}") 2285 urls += "?" + c.urlParams_.Encode() 2286 req, err := http.NewRequest("GET", urls, body) 2287 if err != nil { 2288 return nil, err 2289 } 2290 req.Header = reqHeaders 2291 googleapi.Expand(req.URL, map[string]string{ 2292 "debuggeeId": c.debuggeeId, 2293 "breakpointId": c.breakpointId, 2294 }) 2295 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2296} 2297 2298// Do executes the "clouddebugger.debugger.debuggees.breakpoints.get" call. 2299// Exactly one of *GetBreakpointResponse or error will be non-nil. Any 2300// non-2xx status code is an error. Response headers are in either 2301// *GetBreakpointResponse.ServerResponse.Header or (if a response was 2302// returned at all) in error.(*googleapi.Error).Header. Use 2303// googleapi.IsNotModified to check whether the returned error was 2304// because http.StatusNotModified was returned. 2305func (c *DebuggerDebuggeesBreakpointsGetCall) Do(opts ...googleapi.CallOption) (*GetBreakpointResponse, error) { 2306 gensupport.SetOptions(c.urlParams_, opts...) 2307 res, err := c.doRequest("json") 2308 if res != nil && res.StatusCode == http.StatusNotModified { 2309 if res.Body != nil { 2310 res.Body.Close() 2311 } 2312 return nil, &googleapi.Error{ 2313 Code: res.StatusCode, 2314 Header: res.Header, 2315 } 2316 } 2317 if err != nil { 2318 return nil, err 2319 } 2320 defer googleapi.CloseBody(res) 2321 if err := googleapi.CheckResponse(res); err != nil { 2322 return nil, err 2323 } 2324 ret := &GetBreakpointResponse{ 2325 ServerResponse: googleapi.ServerResponse{ 2326 Header: res.Header, 2327 HTTPStatusCode: res.StatusCode, 2328 }, 2329 } 2330 target := &ret 2331 if err := gensupport.DecodeResponse(target, res); err != nil { 2332 return nil, err 2333 } 2334 return ret, nil 2335 // { 2336 // "description": "Gets breakpoint information.", 2337 // "flatPath": "v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}", 2338 // "httpMethod": "GET", 2339 // "id": "clouddebugger.debugger.debuggees.breakpoints.get", 2340 // "parameterOrder": [ 2341 // "debuggeeId", 2342 // "breakpointId" 2343 // ], 2344 // "parameters": { 2345 // "breakpointId": { 2346 // "description": "Required. ID of the breakpoint to get.", 2347 // "location": "path", 2348 // "required": true, 2349 // "type": "string" 2350 // }, 2351 // "clientVersion": { 2352 // "description": "Required. The client version making the call. Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).", 2353 // "location": "query", 2354 // "type": "string" 2355 // }, 2356 // "debuggeeId": { 2357 // "description": "Required. ID of the debuggee whose breakpoint to get.", 2358 // "location": "path", 2359 // "required": true, 2360 // "type": "string" 2361 // } 2362 // }, 2363 // "path": "v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}", 2364 // "response": { 2365 // "$ref": "GetBreakpointResponse" 2366 // }, 2367 // "scopes": [ 2368 // "https://www.googleapis.com/auth/cloud-platform", 2369 // "https://www.googleapis.com/auth/cloud_debugger" 2370 // ] 2371 // } 2372 2373} 2374 2375// method id "clouddebugger.debugger.debuggees.breakpoints.list": 2376 2377type DebuggerDebuggeesBreakpointsListCall struct { 2378 s *Service 2379 debuggeeId string 2380 urlParams_ gensupport.URLParams 2381 ifNoneMatch_ string 2382 ctx_ context.Context 2383 header_ http.Header 2384} 2385 2386// List: Lists all breakpoints for the debuggee. 2387// 2388// - debuggeeId: ID of the debuggee whose breakpoints to list. 2389func (r *DebuggerDebuggeesBreakpointsService) List(debuggeeId string) *DebuggerDebuggeesBreakpointsListCall { 2390 c := &DebuggerDebuggeesBreakpointsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2391 c.debuggeeId = debuggeeId 2392 return c 2393} 2394 2395// ActionValue sets the optional parameter "action.value": Only 2396// breakpoints with the specified action will pass the filter. 2397// 2398// Possible values: 2399// "CAPTURE" - Capture stack frame and variables and update the 2400// breakpoint. The data is only captured once. After that the breakpoint 2401// is set in a final state. 2402// "LOG" - Log each breakpoint hit. The breakpoint remains active 2403// until deleted or expired. 2404func (c *DebuggerDebuggeesBreakpointsListCall) ActionValue(actionValue string) *DebuggerDebuggeesBreakpointsListCall { 2405 c.urlParams_.Set("action.value", actionValue) 2406 return c 2407} 2408 2409// ClientVersion sets the optional parameter "clientVersion": Required. 2410// The client version making the call. Schema: `domain/type/version` 2411// (e.g., `google.com/intellij/v1`). 2412func (c *DebuggerDebuggeesBreakpointsListCall) ClientVersion(clientVersion string) *DebuggerDebuggeesBreakpointsListCall { 2413 c.urlParams_.Set("clientVersion", clientVersion) 2414 return c 2415} 2416 2417// IncludeAllUsers sets the optional parameter "includeAllUsers": When 2418// set to `true`, the response includes the list of breakpoints set by 2419// any user. Otherwise, it includes only breakpoints set by the caller. 2420func (c *DebuggerDebuggeesBreakpointsListCall) IncludeAllUsers(includeAllUsers bool) *DebuggerDebuggeesBreakpointsListCall { 2421 c.urlParams_.Set("includeAllUsers", fmt.Sprint(includeAllUsers)) 2422 return c 2423} 2424 2425// IncludeInactive sets the optional parameter "includeInactive": When 2426// set to `true`, the response includes active and inactive breakpoints. 2427// Otherwise, it includes only active breakpoints. 2428func (c *DebuggerDebuggeesBreakpointsListCall) IncludeInactive(includeInactive bool) *DebuggerDebuggeesBreakpointsListCall { 2429 c.urlParams_.Set("includeInactive", fmt.Sprint(includeInactive)) 2430 return c 2431} 2432 2433// StripResults sets the optional parameter "stripResults": This field 2434// is deprecated. The following fields are always stripped out of the 2435// result: `stack_frames`, `evaluated_expressions` and `variable_table`. 2436func (c *DebuggerDebuggeesBreakpointsListCall) StripResults(stripResults bool) *DebuggerDebuggeesBreakpointsListCall { 2437 c.urlParams_.Set("stripResults", fmt.Sprint(stripResults)) 2438 return c 2439} 2440 2441// WaitToken sets the optional parameter "waitToken": A wait token that, 2442// if specified, blocks the call until the breakpoints list has changed, 2443// or a server selected timeout has expired. The value should be set 2444// from the last response. The error code `google.rpc.Code.ABORTED` 2445// (RPC) is returned on wait timeout, which should be called again with 2446// the same `wait_token`. 2447func (c *DebuggerDebuggeesBreakpointsListCall) WaitToken(waitToken string) *DebuggerDebuggeesBreakpointsListCall { 2448 c.urlParams_.Set("waitToken", waitToken) 2449 return c 2450} 2451 2452// Fields allows partial responses to be retrieved. See 2453// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2454// for more information. 2455func (c *DebuggerDebuggeesBreakpointsListCall) Fields(s ...googleapi.Field) *DebuggerDebuggeesBreakpointsListCall { 2456 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2457 return c 2458} 2459 2460// IfNoneMatch sets the optional parameter which makes the operation 2461// fail if the object's ETag matches the given value. This is useful for 2462// getting updates only after the object has changed since the last 2463// request. Use googleapi.IsNotModified to check whether the response 2464// error from Do is the result of In-None-Match. 2465func (c *DebuggerDebuggeesBreakpointsListCall) IfNoneMatch(entityTag string) *DebuggerDebuggeesBreakpointsListCall { 2466 c.ifNoneMatch_ = entityTag 2467 return c 2468} 2469 2470// Context sets the context to be used in this call's Do method. Any 2471// pending HTTP request will be aborted if the provided context is 2472// canceled. 2473func (c *DebuggerDebuggeesBreakpointsListCall) Context(ctx context.Context) *DebuggerDebuggeesBreakpointsListCall { 2474 c.ctx_ = ctx 2475 return c 2476} 2477 2478// Header returns an http.Header that can be modified by the caller to 2479// add HTTP headers to the request. 2480func (c *DebuggerDebuggeesBreakpointsListCall) Header() http.Header { 2481 if c.header_ == nil { 2482 c.header_ = make(http.Header) 2483 } 2484 return c.header_ 2485} 2486 2487func (c *DebuggerDebuggeesBreakpointsListCall) doRequest(alt string) (*http.Response, error) { 2488 reqHeaders := make(http.Header) 2489 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210830") 2490 for k, v := range c.header_ { 2491 reqHeaders[k] = v 2492 } 2493 reqHeaders.Set("User-Agent", c.s.userAgent()) 2494 if c.ifNoneMatch_ != "" { 2495 reqHeaders.Set("If-None-Match", c.ifNoneMatch_) 2496 } 2497 var body io.Reader = nil 2498 c.urlParams_.Set("alt", alt) 2499 c.urlParams_.Set("prettyPrint", "false") 2500 urls := googleapi.ResolveRelative(c.s.BasePath, "v2/debugger/debuggees/{debuggeeId}/breakpoints") 2501 urls += "?" + c.urlParams_.Encode() 2502 req, err := http.NewRequest("GET", urls, body) 2503 if err != nil { 2504 return nil, err 2505 } 2506 req.Header = reqHeaders 2507 googleapi.Expand(req.URL, map[string]string{ 2508 "debuggeeId": c.debuggeeId, 2509 }) 2510 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2511} 2512 2513// Do executes the "clouddebugger.debugger.debuggees.breakpoints.list" call. 2514// Exactly one of *ListBreakpointsResponse or error will be non-nil. Any 2515// non-2xx status code is an error. Response headers are in either 2516// *ListBreakpointsResponse.ServerResponse.Header or (if a response was 2517// returned at all) in error.(*googleapi.Error).Header. Use 2518// googleapi.IsNotModified to check whether the returned error was 2519// because http.StatusNotModified was returned. 2520func (c *DebuggerDebuggeesBreakpointsListCall) Do(opts ...googleapi.CallOption) (*ListBreakpointsResponse, error) { 2521 gensupport.SetOptions(c.urlParams_, opts...) 2522 res, err := c.doRequest("json") 2523 if res != nil && res.StatusCode == http.StatusNotModified { 2524 if res.Body != nil { 2525 res.Body.Close() 2526 } 2527 return nil, &googleapi.Error{ 2528 Code: res.StatusCode, 2529 Header: res.Header, 2530 } 2531 } 2532 if err != nil { 2533 return nil, err 2534 } 2535 defer googleapi.CloseBody(res) 2536 if err := googleapi.CheckResponse(res); err != nil { 2537 return nil, err 2538 } 2539 ret := &ListBreakpointsResponse{ 2540 ServerResponse: googleapi.ServerResponse{ 2541 Header: res.Header, 2542 HTTPStatusCode: res.StatusCode, 2543 }, 2544 } 2545 target := &ret 2546 if err := gensupport.DecodeResponse(target, res); err != nil { 2547 return nil, err 2548 } 2549 return ret, nil 2550 // { 2551 // "description": "Lists all breakpoints for the debuggee.", 2552 // "flatPath": "v2/debugger/debuggees/{debuggeeId}/breakpoints", 2553 // "httpMethod": "GET", 2554 // "id": "clouddebugger.debugger.debuggees.breakpoints.list", 2555 // "parameterOrder": [ 2556 // "debuggeeId" 2557 // ], 2558 // "parameters": { 2559 // "action.value": { 2560 // "description": "Only breakpoints with the specified action will pass the filter.", 2561 // "enum": [ 2562 // "CAPTURE", 2563 // "LOG" 2564 // ], 2565 // "enumDescriptions": [ 2566 // "Capture stack frame and variables and update the breakpoint. The data is only captured once. After that the breakpoint is set in a final state.", 2567 // "Log each breakpoint hit. The breakpoint remains active until deleted or expired." 2568 // ], 2569 // "location": "query", 2570 // "type": "string" 2571 // }, 2572 // "clientVersion": { 2573 // "description": "Required. The client version making the call. Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).", 2574 // "location": "query", 2575 // "type": "string" 2576 // }, 2577 // "debuggeeId": { 2578 // "description": "Required. ID of the debuggee whose breakpoints to list.", 2579 // "location": "path", 2580 // "required": true, 2581 // "type": "string" 2582 // }, 2583 // "includeAllUsers": { 2584 // "description": "When set to `true`, the response includes the list of breakpoints set by any user. Otherwise, it includes only breakpoints set by the caller.", 2585 // "location": "query", 2586 // "type": "boolean" 2587 // }, 2588 // "includeInactive": { 2589 // "description": "When set to `true`, the response includes active and inactive breakpoints. Otherwise, it includes only active breakpoints.", 2590 // "location": "query", 2591 // "type": "boolean" 2592 // }, 2593 // "stripResults": { 2594 // "description": "This field is deprecated. The following fields are always stripped out of the result: `stack_frames`, `evaluated_expressions` and `variable_table`.", 2595 // "location": "query", 2596 // "type": "boolean" 2597 // }, 2598 // "waitToken": { 2599 // "description": "A wait token that, if specified, blocks the call until the breakpoints list has changed, or a server selected timeout has expired. The value should be set from the last response. The error code `google.rpc.Code.ABORTED` (RPC) is returned on wait timeout, which should be called again with the same `wait_token`.", 2600 // "location": "query", 2601 // "type": "string" 2602 // } 2603 // }, 2604 // "path": "v2/debugger/debuggees/{debuggeeId}/breakpoints", 2605 // "response": { 2606 // "$ref": "ListBreakpointsResponse" 2607 // }, 2608 // "scopes": [ 2609 // "https://www.googleapis.com/auth/cloud-platform", 2610 // "https://www.googleapis.com/auth/cloud_debugger" 2611 // ] 2612 // } 2613 2614} 2615 2616// method id "clouddebugger.debugger.debuggees.breakpoints.set": 2617 2618type DebuggerDebuggeesBreakpointsSetCall struct { 2619 s *Service 2620 debuggeeId string 2621 breakpoint *Breakpoint 2622 urlParams_ gensupport.URLParams 2623 ctx_ context.Context 2624 header_ http.Header 2625} 2626 2627// Set: Sets the breakpoint to the debuggee. 2628// 2629// - debuggeeId: ID of the debuggee where the breakpoint is to be set. 2630func (r *DebuggerDebuggeesBreakpointsService) Set(debuggeeId string, breakpoint *Breakpoint) *DebuggerDebuggeesBreakpointsSetCall { 2631 c := &DebuggerDebuggeesBreakpointsSetCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2632 c.debuggeeId = debuggeeId 2633 c.breakpoint = breakpoint 2634 return c 2635} 2636 2637// CanaryOption sets the optional parameter "canaryOption": The canary 2638// option set by the user upon setting breakpoint. 2639// 2640// Possible values: 2641// "CANARY_OPTION_UNSPECIFIED" - Depends on the canary_mode of the 2642// debuggee. 2643// "CANARY_OPTION_TRY_ENABLE" - Enable the canary for this breakpoint 2644// if the canary_mode of the debuggee is not CANARY_MODE_ALWAYS_ENABLED 2645// or CANARY_MODE_ALWAYS_DISABLED. 2646// "CANARY_OPTION_TRY_DISABLE" - Disable the canary for this 2647// breakpoint if the canary_mode of the debuggee is not 2648// CANARY_MODE_ALWAYS_ENABLED or CANARY_MODE_ALWAYS_DISABLED. 2649func (c *DebuggerDebuggeesBreakpointsSetCall) CanaryOption(canaryOption string) *DebuggerDebuggeesBreakpointsSetCall { 2650 c.urlParams_.Set("canaryOption", canaryOption) 2651 return c 2652} 2653 2654// ClientVersion sets the optional parameter "clientVersion": Required. 2655// The client version making the call. Schema: `domain/type/version` 2656// (e.g., `google.com/intellij/v1`). 2657func (c *DebuggerDebuggeesBreakpointsSetCall) ClientVersion(clientVersion string) *DebuggerDebuggeesBreakpointsSetCall { 2658 c.urlParams_.Set("clientVersion", clientVersion) 2659 return c 2660} 2661 2662// Fields allows partial responses to be retrieved. See 2663// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2664// for more information. 2665func (c *DebuggerDebuggeesBreakpointsSetCall) Fields(s ...googleapi.Field) *DebuggerDebuggeesBreakpointsSetCall { 2666 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2667 return c 2668} 2669 2670// Context sets the context to be used in this call's Do method. Any 2671// pending HTTP request will be aborted if the provided context is 2672// canceled. 2673func (c *DebuggerDebuggeesBreakpointsSetCall) Context(ctx context.Context) *DebuggerDebuggeesBreakpointsSetCall { 2674 c.ctx_ = ctx 2675 return c 2676} 2677 2678// Header returns an http.Header that can be modified by the caller to 2679// add HTTP headers to the request. 2680func (c *DebuggerDebuggeesBreakpointsSetCall) Header() http.Header { 2681 if c.header_ == nil { 2682 c.header_ = make(http.Header) 2683 } 2684 return c.header_ 2685} 2686 2687func (c *DebuggerDebuggeesBreakpointsSetCall) doRequest(alt string) (*http.Response, error) { 2688 reqHeaders := make(http.Header) 2689 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210830") 2690 for k, v := range c.header_ { 2691 reqHeaders[k] = v 2692 } 2693 reqHeaders.Set("User-Agent", c.s.userAgent()) 2694 var body io.Reader = nil 2695 body, err := googleapi.WithoutDataWrapper.JSONReader(c.breakpoint) 2696 if err != nil { 2697 return nil, err 2698 } 2699 reqHeaders.Set("Content-Type", "application/json") 2700 c.urlParams_.Set("alt", alt) 2701 c.urlParams_.Set("prettyPrint", "false") 2702 urls := googleapi.ResolveRelative(c.s.BasePath, "v2/debugger/debuggees/{debuggeeId}/breakpoints/set") 2703 urls += "?" + c.urlParams_.Encode() 2704 req, err := http.NewRequest("POST", urls, body) 2705 if err != nil { 2706 return nil, err 2707 } 2708 req.Header = reqHeaders 2709 googleapi.Expand(req.URL, map[string]string{ 2710 "debuggeeId": c.debuggeeId, 2711 }) 2712 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2713} 2714 2715// Do executes the "clouddebugger.debugger.debuggees.breakpoints.set" call. 2716// Exactly one of *SetBreakpointResponse or error will be non-nil. Any 2717// non-2xx status code is an error. Response headers are in either 2718// *SetBreakpointResponse.ServerResponse.Header or (if a response was 2719// returned at all) in error.(*googleapi.Error).Header. Use 2720// googleapi.IsNotModified to check whether the returned error was 2721// because http.StatusNotModified was returned. 2722func (c *DebuggerDebuggeesBreakpointsSetCall) Do(opts ...googleapi.CallOption) (*SetBreakpointResponse, error) { 2723 gensupport.SetOptions(c.urlParams_, opts...) 2724 res, err := c.doRequest("json") 2725 if res != nil && res.StatusCode == http.StatusNotModified { 2726 if res.Body != nil { 2727 res.Body.Close() 2728 } 2729 return nil, &googleapi.Error{ 2730 Code: res.StatusCode, 2731 Header: res.Header, 2732 } 2733 } 2734 if err != nil { 2735 return nil, err 2736 } 2737 defer googleapi.CloseBody(res) 2738 if err := googleapi.CheckResponse(res); err != nil { 2739 return nil, err 2740 } 2741 ret := &SetBreakpointResponse{ 2742 ServerResponse: googleapi.ServerResponse{ 2743 Header: res.Header, 2744 HTTPStatusCode: res.StatusCode, 2745 }, 2746 } 2747 target := &ret 2748 if err := gensupport.DecodeResponse(target, res); err != nil { 2749 return nil, err 2750 } 2751 return ret, nil 2752 // { 2753 // "description": "Sets the breakpoint to the debuggee.", 2754 // "flatPath": "v2/debugger/debuggees/{debuggeeId}/breakpoints/set", 2755 // "httpMethod": "POST", 2756 // "id": "clouddebugger.debugger.debuggees.breakpoints.set", 2757 // "parameterOrder": [ 2758 // "debuggeeId" 2759 // ], 2760 // "parameters": { 2761 // "canaryOption": { 2762 // "description": "The canary option set by the user upon setting breakpoint.", 2763 // "enum": [ 2764 // "CANARY_OPTION_UNSPECIFIED", 2765 // "CANARY_OPTION_TRY_ENABLE", 2766 // "CANARY_OPTION_TRY_DISABLE" 2767 // ], 2768 // "enumDescriptions": [ 2769 // "Depends on the canary_mode of the debuggee.", 2770 // "Enable the canary for this breakpoint if the canary_mode of the debuggee is not CANARY_MODE_ALWAYS_ENABLED or CANARY_MODE_ALWAYS_DISABLED.", 2771 // "Disable the canary for this breakpoint if the canary_mode of the debuggee is not CANARY_MODE_ALWAYS_ENABLED or CANARY_MODE_ALWAYS_DISABLED." 2772 // ], 2773 // "location": "query", 2774 // "type": "string" 2775 // }, 2776 // "clientVersion": { 2777 // "description": "Required. The client version making the call. Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).", 2778 // "location": "query", 2779 // "type": "string" 2780 // }, 2781 // "debuggeeId": { 2782 // "description": "Required. ID of the debuggee where the breakpoint is to be set.", 2783 // "location": "path", 2784 // "required": true, 2785 // "type": "string" 2786 // } 2787 // }, 2788 // "path": "v2/debugger/debuggees/{debuggeeId}/breakpoints/set", 2789 // "request": { 2790 // "$ref": "Breakpoint" 2791 // }, 2792 // "response": { 2793 // "$ref": "SetBreakpointResponse" 2794 // }, 2795 // "scopes": [ 2796 // "https://www.googleapis.com/auth/cloud-platform", 2797 // "https://www.googleapis.com/auth/cloud_debugger" 2798 // ] 2799 // } 2800 2801} 2802