autoroll/go/proto/rpc.proto

syntax = "proto3";
package autoroll.rpc;
option go_package = "go.skia.org/infra/autoroll/go/proto";

import "google/protobuf/timestamp.proto";

// AutoRollService provides interactions with the AutoRoll frontend.
service AutoRollService {
  // GetRollers retrieves AutoRollMiniStatuses for all known rollers.
  rpc GetRollers(GetRollersRequest) returns (GetRollersResponse);
  // GetMiniStatus retrieves the AutoRollMiniStatus for one roller.
  rpc GetMiniStatus(GetMiniStatusRequest) returns (GetMiniStatusResponse);
  // GetStatus retrieves the AutoRollStatus for one roller.
  rpc GetStatus(GetStatusRequest) returns (GetStatusResponse);
  // SetMode sets the mode for a roller.
  rpc SetMode(SetModeRequest) returns (SetModeResponse);
  // SetStrategy sets the strategy for a roller.
  rpc SetStrategy(SetStrategyRequest) returns (SetStrategyResponse);
  // CreateManualRoll initiates the creation of a manual roll.
  rpc CreateManualRoll(CreateManualRollRequest) returns (CreateManualRollResponse);
  // Unthrottle clears any throttling of the roller, allowing it to roll again.
  rpc Unthrottle(UnthrottleRequest) returns (UnthrottleResponse);
  // GetConfig returns the given roller config.
  rpc GetConfig(GetConfigRequest) returns (GetConfigResponse);
  // PutConfig adds or updates the given roller config.
  rpc PutConfig(PutConfigRequest) returns (PutConfigResponse);
}

// Mode describes the valid operating modes of an autoroller.
// These must be kept in sync with autoroll/go/modes/modes.go.
enum Mode {
  // RUNNING is the typical operating mode of the autoroller. It will upload and
  // land CLs as new revisions appear in the Child.
  RUNNING = 0;
  // STOPPED prevents the autoroller from uploading any CLs.
  STOPPED = 1;
  // DRY_RUN is similar to RUNNING but does not land the roll CLs after the
  // commit queue finishes. Instead, the active roll is left open until new
  // revisions appear in the child, at which point the roll is closed and a new
  // one is uploaded.
  DRY_RUN = 2;
}

// Strategy describes the valid strategies for choosing the next revision to
// roll. These must be kept in sync with autoroll/go/strategy/strategies.go.
enum Strategy {
  // BATCH indicates that all not-yet-rolled revisions should be rolled in a
  // single CL.
  BATCH = 0;
  // N_BATCH is similar to BATCH but puts a limit on the number of revisions in
  // a single CL.
  N_BATCH = 1;
  // SINGLE indicates that a single revision is rolled in each CL.
  SINGLE = 2;
}

// AutoRollMiniStatus contains a subset of the information of AutoRollStatus.
message AutoRollMiniStatus {
  // roller_id is the unique ID for this roller.
  string roller_id = 1;
  // child_name is the display name of the child.
  string child_name = 2;
  // parent_name is the display name of the parent.
  string parent_name = 3;
  // mode is the currently-set operating mode of the roller.
  Mode mode = 4;
  // current_roll_rev is the ID of the child revision which is being rolled in
  // the active roll CL.
  string current_roll_rev = 5;
  // last_roll_rev is the ID of the child revision which is currently pinned by
  // the parent.
  string last_roll_rev = 6;
  // num_failed is the number of consecutive roll failures.
  int32 num_failed = 7;
  // num_behind is the number of not-yet-rolled revisions.
  int32 num_behind = 8;
}

message TryJob {
  // Result describes the possible results for a TryJob.
  // These must be kept in sync with go/autoroll/autoroll.go.
  enum Result {
    // UNKNOWN indicates that the result of the TryJob is unknown, ie. it has
    // not yet finished.
    UNKNOWN = 0;
    // SUCCESS indicates that that TryJob completed successfully.
    SUCCESS = 1;
    // FAILURE indicates that that TryJob failed.
    FAILURE = 2;
    // CANCELED indicates that that TryJob was canceled.
    CANCELED = 3;
  }

  // Status describes the lifecycle states of a TryJob.
  // These must be kept in sync with go/autoroll/autoroll.go.
  enum Status {
    // SCHEDULED indicates that the TryJob has been scheduled but has not yet
    // started.
    SCHEDULED = 0;
    // STARTED indicates that the TryJob is currently running.
    STARTED = 1;
    // COMPLETED indicates that the TryJob is finishes.
    COMPLETED = 2;
  }

  // name of the TryJob.
  string name = 1;
  // status of the TryJob.
  Status status = 2;
  // result of the TryJob.
  Result result = 3;
  // url where more details can be found about the TryJob.
  string url = 4;
  // category of the TryJob, eg. "cq".
  string category = 5;
}

// AutoRoll CL describes a CL uploaded by the autoroller.
message AutoRollCL {
  // Result describes the possible results for an AutoRollCL.
  enum Result {
    // IN_PROGRESS indicates that the commit queue is still running for this
    // AutoRollCL.
    IN_PROGRESS = 0;
    // SUCCESS indicates that this AutoRollCL landed successfully.
    SUCCESS = 1;
    // FAILURE indicates that the commit queue failed for  this AutoRollCL.
    FAILURE = 2;
    // DRY_RUN_IN_PROGRESS indicates that the commit queue dry run is still
    // running for this AutoRollCL.
    DRY_RUN_IN_PROGRESS = 3;
    // DRY_RUN_SUCCESS indicates that the commit queue dry run succeeded for
    // this AutoRollCL.
    DRY_RUN_SUCCESS = 4;
    // DRY_RUN_FAILURE indicates that the commit queue dry run failed for this
    // AutoRollCL.
    DRY_RUN_FAILURE = 5;
  }

  // id is the unique identifier for the CL.
  string id = 1;
  // result of the AutoRollCL.
  Result result = 2;
  // subject line of the commit message of the AutoRollCL.
  string subject = 3;
  // rolling_to is the ID of the revision being rolled.
  string rolling_to = 4;
  // rolling_from is the ID of the currently-pinned revision.
  string rolling_from = 5;
  // created is the timestamp at which the AutoRollCL was created.
  google.protobuf.Timestamp created = 6;
  // created is the timestamp at which the AutoRollCL was last modified.
  google.protobuf.Timestamp modified = 7;
  // try_jobs contains results of any try jobs for the AutoRollCL.
  repeated TryJob try_jobs = 8;
}

// Revision describes a single revision in a given Child. This may be a Git
// commit, CIPD package instance, a file uploaded to GCS, etc.
message Revision {
  // id is the unique identifier for the Revision.
  string id = 1;
  // display is a human-friendly display name for the Revision.
  string display = 2;
  // description is a longer description of the Revision.
  string description = 3;
  // time is the timestamp at which the Revision was created.
  google.protobuf.Timestamp time = 4;
  // url where more details can be found about the Revision.
  string url = 5;
}

// AutoRollConfig describes the configuration for a roller.
message AutoRollConfig {
  // parent_waterfall is the URL of the CI display for the parent repo.
  string parent_waterfall = 1;
  // roller_id is the unique identifier for the roller.
  string roller_id = 2;
  // supports_manual_rolls indicates whether this autoroller supports manually-
  // triggered rolls.
  bool supports_manual_rolls = 3;
  // time_window describes the limitations, if any, on when the autoroller is
  // allowed to upload roll CLs.
  string time_window = 4;
}

// ModeChange describes one instance of an autoroller's mode being changed.
message ModeChange {
  // roller_id is the unique identifier for the autoroller.
  string roller_id = 1;
  // mode is the operating mode of the autoroller which was set in this
  // ModeChange.
  Mode mode = 2;
  // user is the email address of the user who created this ModeChange.
  string user = 3;
  // time is the timestamp at which the ModeChange was created.
  google.protobuf.Timestamp time = 4;
  // message is a user-created message which describes the reason for changing
  // the mode.
  string message = 5;
}

// StrategyChange describes one instance of an autoroller's mode being changed.
message StrategyChange {
  // roller_id is the unique identifier for the autoroller.
  string roller_id = 1;
  // strategy is the strategy for choosing the next revision to roll which was
  // set in this StrategyChange.
  Strategy strategy = 2;
  // user is the email address of the user who created this StrategyChange.
  string user = 3;
  // time is the timestamp at which the StrategyChange was created.
  google.protobuf.Timestamp time = 4;
  // message is a user-created message which describes the reason for changing
  // the strategy.
  string message = 5;
}

// ManualRoll describes a manually-triggered roll and its results.
message ManualRoll {
  // Result describes the possible results for a manual roll.
  // These must be kept in sync with autoroll/go/manual/db.go.
  enum Result {
    // UNKNOWN indicates that the result of the ManualRoll is unknown, ie. it
    // has not yet finished.
    UNKNOWN = 0;
    // FAILURE indicates that the ManualRoll has failed.
    FAILURE = 1;
    // SUCCESS indicates that the ManualRoll landed successfully.
    SUCCESS = 2;
  }

  // Status describes the lifecycle states of a manual roll.
  // These must be kept in sync with autoroll/go/manual/db.go.
  enum Status {
    // PENDING indicates that the ManualRoll has been requested but no CL has
    // been uploaded.
    PENDING = 0;
    // STARTED indicates that a CL has been uploaded for this ManualRoll.
    STARTED = 1;
    // COMPLETED indicates that the ManualRoll has finished and either landed
    // successfully or failed.
    COMPLETED = 2;
  }

  // id is the unique identifier for this ManualRoll.
  string id = 1;
  // roller_id is the unique identifier for the autoroller on which this
  // ManualRoll was requested.
  string roller_id = 2;
  // revision is the ID of the revision to which this ManualRoll will roll.
  string revision = 3;
  // requester is the email address of the person who requested the ManualRoll.
  string requester = 4;
  // result of the ManualRoll.
  Result result = 5;
  // status of the ManualRoll.
  Status status = 6;
  // timestamp at which the ManualRoll was created.
  google.protobuf.Timestamp timestamp = 7;
  // url of the ManualRoll, if a roll has been uploaded.
  string url = 8;
  // dry_run indicates whether the ManualRoll should be performed as a dry run,
  // so that the commit queue runs but the CL is not landed.
  bool dry_run = 9;
  // no_email specifies that the requester and reviewers should not receive
  // email related to this ManualRoll.
  bool no_email = 10;
  // no_resolve_revision specifies that the autoroller should not attempt to
  // find the requested revision ID in the Child but should simply use it as
  // provided.
  bool no_resolve_revision = 11;
}

// AutoRollStatus describes the overall status of an autoroller.
message AutoRollStatus {
  // mini_status contains a subset of status information for the autoroller.
  AutoRollMiniStatus mini_status = 1;
  // status is the current status of the autoroller, as provided by the state
  // machine.
  string status = 2;
  // config provides configuration information for the autoroller.
  AutoRollConfig config = 3;
  // full_history_url is the URL where the autoroller's history may be viewed.
  string full_history_url = 4;
  // issue_url_base provides a base URL which can be used to construct URLs for
  // individual AutoRollCLs.
  string issue_url_base = 5;
  // mode is the current operating mode of the autoroller.
  ModeChange mode = 6;
  // strategy for choosing the next revision to roll.
  StrategyChange strategy = 7;
  // not_rolled_revisions are the revisions of the Child which have not yet been
  // rolled.
  repeated Revision not_rolled_revisions = 8;
  // current_roll is the active roll CL, if any.
  AutoRollCL current_roll = 9;
  // last_roll is the previous roll CL.
  AutoRollCL last_roll = 10;
  // recent_rolls contains a list of recent roll CLs.
  repeated AutoRollCL recent_rolls = 11;
  // manual_rolls contains a list of recent ManualRolls.
  repeated ManualRoll manual_rolls = 12;
  // error contains a detailed message if the autoroller is in an error state.
  string error = 13;
  // throttled_until is the timestamp at which the autoroller will no longer be
  // throttled, if the autoroller is currently throttled.
  google.protobuf.Timestamp throttled_until = 14;
}

// GetRollersRequest is a request to GetRollers.
message GetRollersRequest {}

// GetRollersResponse is a response returned by GetRollers.
message GetRollersResponse {
  // rollers contains status information for all known autorollers.
  repeated AutoRollMiniStatus rollers = 1;
}

// GetMiniStatusRequest is a request to GetMiniStatus.
message GetMiniStatusRequest {
  // roller_id is the unique identifier of the autoroller whose MiniStatus is to
  // be retrieved.
  string roller_id = 1;
}

// GetMiniStatusResponse is a response returned by GetMiniStatus.
message GetMiniStatusResponse {
  // status is a subset of status information for the autoroller in question.
  AutoRollMiniStatus status = 1;
}

// GetStatusRequest is a request to GetStatus.
message GetStatusRequest {
  // roller_id is the unique identifier of the autoroller whose Status is to be
  // retrieved.
  string roller_id = 1;
}

// GetStatusResponse is a response returned by GetStatus.
message GetStatusResponse {
  // status information about the autoroller in question.
  AutoRollStatus status = 1;
}

// SetModeRequest is a request to SetMode.
message SetModeRequest {
  // roller_id is the unique identifier of the autoroller whose mode is to be
  // changed.
  string roller_id = 1;
  // mode is the desired mode to set for the given autoroller.
  Mode mode = 2;
  // message describes the reason for changing the mode.
  string message = 4;
}

// SetModeResponse is a response returned by SetMode.
message SetModeResponse {
  // status is the updated status of the autoroller after changing its mode.
  AutoRollStatus status = 1;
}

// SetStrategyRequest is a request to SetStrategy.
message SetStrategyRequest {
  // roller_id is the unique identifier of the autoroller whose strategy is to
  // be changed.
  string roller_id = 1;
  // strategy is the desired strategy to set for the given autoroller.
  Strategy strategy = 2;
  // message describes the reason for changing the strategy.
  string message = 4;
}

// SetStrategyResponse is a response returned by SetStrategy.
message SetStrategyResponse {
  // status is the updated status of the autoroller after changing its strategy.
  AutoRollStatus status = 1;
}

// CreateManualRollRequest is a request to CreateManualRoll.
message CreateManualRollRequest {
  // roller_id is the unique identifier of the autoroller which should create
  // the manual roll.
  string roller_id = 1;
  // revision is the ID of the revision to be rolled.
  string revision = 2;
}

// CreateManualRollResponse is a response returned by CreateManualRoll.
message CreateManualRollResponse {
  // roll is the manual roll which was created.
  ManualRoll roll = 1;
}

// UnthrottleRequest is a request to Unthrottle.
message UnthrottleRequest {
  // roller_id is the unique identifier of the autoroller which should be
  // unthrottled.
  string roller_id = 1;
}

// UnthrottleResponse is a response returned by Unthrottle.
message UnthrottleResponse {}

// GetConfigRequest is a request to GetConfig.
message GetConfigRequest {
  // roller_id is the unique identifier of the autoroller whose config is to be
  // retrieved.
  string roller_id = 1;
}

// GetConfigResponse is a response returned by GetConfig.
message GetConfigResponse {
  // config is the config for the requested autoroller.
  Config config = 1;
}

// PutConfigRequest is a request to PutConfig.
message PutConfigRequest {
  // config is the new or updated config for a given roller.
  Config config = 1;
}

// PutConfigResponse is a response returned by PutConfig.
message PutConfigResponse {
  // cl is the URL of the generated CL to add or update the requested config.
  string cl = 1;
}

// Config provides configuration for one AutoRoller.
message Config {
  // roller_name is the name for this roller. It is used as the unique ID for
  // the roller.
  // TODO(borenet): Use an actual DB-generated ID for the roller.
  string roller_name = 1;
  // child_display_name is the human-readable display name of the child.
  string child_display_name = 2;
  // parent_display_name is the human-readable display name of the parent.
  string parent_display_name = 3;
  // parent_waterfall is the URL of the waterfall display of the parent repo.
  string parent_waterfall = 4;
  // owner_primary is the primary owner of this roller.
  string owner_primary = 5;
  // owner_secondary is the secondary owner of this roller.
  string owner_secondary = 6;
  // contacts is a list of email addresses of contacts for this roller, used
  // for sending PSAs, asking questions, etc.
  repeated string contacts = 7;
  // service_account is the full email address of the service account for this
  // roller.
  string service_account = 8;
  // is_internal indicates whether this roller is internal, ie. only visible
  // to Googlers.
  // TODO(borenet): Is this necessary?
  bool is_internal = 9;
  // reviewer are the email addresses to add as reviewers on rolls, or URL(s)
  // from which to obtain those email addresses.
  repeated string reviewer = 10;
  // reviewer_backup are backup email addresses to add as reviewers on rolls,
  // in case obtaining the email addresses from the URL fails. Only required
  // if a URL is specified for the reviewer.
  repeated string reviewer_backup = 11;
  // roll_cooldown is a period of time after a successful roll attempt during
  // which no new roll attempts will be created. Optional.
  string roll_cooldown = 12;
  // time_window in which the roller is allowed to upload roll CLs. See the
  // go/time_window package for supported format.
  string time_window = 13;
  // supports_manual_rolls indicates whether this roller supports manual
  // rolls.
  bool supports_manual_rolls = 14;
  // commit_msg provides configuration for the commit message.
  CommitMsgConfig commit_msg = 15;
  // code_review provides configuration for code review.
  oneof code_review {
      // gerrit provides configuration for code review using Gerrit.
      GerritConfig gerrit = 16;
      // github provides configuration for code review using GitHub.
      GitHubConfig github = 17;
      // google3 provides configuration for code review using Google3.
      Google3Config google3 = 18;
  }
  // kubernetes provides configuration for Kubernetes.
  KubernetesConfig kubernetes = 19;
  // repo_manager provides configuration for the repo manager.
  oneof repo_manager {
      ParentChildRepoManagerConfig parent_child_repo_manager = 20;
      AndroidRepoManagerConfig android_repo_manager = 21;
      CommandRepoManagerConfig command_repo_manager = 22;
      FreeTypeRepoManagerConfig freetype_repo_manager = 23;
      FuchsiaSDKAndroidRepoManagerConfig fuchsia_sdk_android_repo_manager = 24;
      Google3RepoManagerConfig google3_repo_manager = 25;
  }
  // notifiers configures any extra notifications used by this roller.
  repeated NotifierConfig notifiers = 26;
  // safety_throttle provides configuration for safety-throttling the roller
  // in case of persistent errors.
  ThrottleConfig safety_throttle = 27;
  // transitive_deps is an optional mapping of dependency ID (eg. repo URL)
// to the paths within the parent and child repo, respectively, where
  // those dependencies are versioned, eg. "DEPS".
  // TODO(borenet): Where is this used? Why isn't it nested within the repo
  // manager config?
  repeated TransitiveDepConfig transitive_deps = 28;
}

// CommitMsgConfig provides configuration for commit messages.
message CommitMsgConfig {
  // bug_project indicates which project (eg. in Monorail) the bugs attached
  // to various revisions are associated with.  If provided, any "Bug: " lines
  // from revisions in the roll which match the given project name will be
  // included in the roll itself.
  string bug_project = 1;
  // child_log_url_tmpl is a template for building log URLs using the IDs of
  // the from- and to-revisions of the child for a given roll.
  string child_log_url_tmpl = 2;
  // cq_extra_trybots are additional tryjobs to trigger as part of the commit
  // queue for every roll.
  repeated string cq_extra_trybots = 3;
  // cq_do_not_cancel_trybots indicates that the commit queue should not
  // cancel tryjobs from old patch sets when a new patch set is uploaded.
  bool cq_do_not_cancel_trybots = 4;
  // include_log indicates whether the list of revisions contained in the roll
  // should be included as part of the commit message.
  bool include_log = 5;
  // include_revision_count indicates whether the number of revisions
  // contained in the roll should be included in the subject line of the
  // commit message.
  bool include_revision_count = 6;
  // include_tbr_line indicates whether the "TBR:" line should be included in
  // the commit message. This is required for some commit queues.
  bool include_tbr_line = 7;
  // include_tests indicates whether the "Test: " lines from the revisions in
  // the roll should be propagated through to the roll itself.
  bool include_tests = 8;

  // BuiltIn lists the built-in commit message templates.
  enum BuiltIn {
      // DEFAULT is the default commit message template.
      DEFAULT = 0;
      // ANDROID is the commit message template used for Android rollers.
      ANDROID = 1;
  }

  // template specifies exactly how the commit message should be structured.
  // If not specified, the default template is used.
  oneof template {
      // built_in is the name of a built-in commit message template.
      BuiltIn built_in = 9;
      // custom is a full custom commit message template string.
      string custom = 10;
  }
}

// GerritConfig provides configuration for code review using Gerrit.
message GerritConfig {
  // url of the Gerrit host.
  string url = 1;
  // project name for uploaded CLs.
  string project = 2;

  // Config lists the built-in Gerrit configs, named for the projects which
  // use them.
  enum Config {
      ANDROID = 0;
      ANGLE = 1;
      CHROMIUM = 2;
      CHROMIUM_NO_CQ = 3;
      LIBASSISTANT = 4;
  }
  // config indicates the mode of operation used by the Gerrit host, which
  // informs the roller of, for example, which labels to set. See the
  // autoroll/go/codereview package for possible values.
  Config config = 3;
}

// GitHubConfig provides configuration for code review using GitHub.
message GitHubConfig {
  // repo_owner is the owner of the GitHub repo.
  string repo_owner = 1;
  // repo_name is the name of the GitHub repo.
  string repo_name = 2;
  // checks_wait_for indicates which GitHub checks must succeed before a pull
  // request may be merged. If they are failing, we wait for them to succeed
  // (eg. tree-status checks). Note: These checks are ignored during dry runs
  // because the PR is not going to be submitted so the tree-status checks
  // will not be important in that case.
  repeated string checks_wait_for = 3;
}

// Google3Config is an empty configuration object for Google3.
message Google3Config {}

// KubernetesConfig provides Kubernetes configuration for the autoroll backend
// service for this roller.
message KubernetesConfig {
  // cpu is the requested number of CPUs, eg. "250m".
  string cpu = 1;
  // memory is the requested memory, eg. "2Gi".
  string memory = 2;
  // readiness_failure_threshold indicates how many times the ready check may
  // fail.
  int32 readiness_failure_threshold = 3;
  // readiness_initial_delay_seconds indicates how long to wait before
  // performing the ready check for the first time.
  int32 readiness_initial_delay_seconds = 4;
  // readiness_period_seconds indicates how often to perform the ready check.
  int32 readiness_period_seconds = 5;
  // disk indicates the size of the requested persistent disk.  If not
  // specified, no persistent disk is used.
  string disk = 6;
  // secrets provided to the pod.
  repeated KubernetesSecret secrets = 7;
}

// KubernetesSecret provides configuration for a Kubernetes secret.
message KubernetesSecret {
  // name of the secret.
  string name = 1;
  // mount_path of the secret.
  string mount_path = 2;
}

// AndroidRepoManagerConfig provides configuration for a roller which rolls into
// Android.
message AndroidRepoManagerConfig {
  // ProjectMetadataFileConfig provides configuration for METADATA files in
  // the Android repo.
  message ProjectMetadataFileConfig {
      // file_path of the project metadata file within the repo.
      string file_path = 1;
      // name of the project.
      string name = 2;
      // description of the project.
      string description = 3;
      // home_page of the project.
      string home_page = 4;
      // git_url of the project.
      string git_url = 5;
      // license_type of the project.
      string license_type = 6;
  }

  // child_repo_url is the URL of the child repo.
  string child_repo_url = 1;
  // child_branch is the Git branch of the child repo to track.
  string child_branch = 2;
  // child_path is the path to the child repo within the parent.
  string child_path = 3;
  // parent_repo_url is the URL of the parent repo.
  string parent_repo_url = 4;
  // parent_branch is the Git branch of the parent repo to track.
  string parent_branch = 5;
  // child_rev_link_tmpl is a template used to create links to revisions of
  // the child repo. If not supplied, no links will be created.
  string child_rev_link_tmpl = 6;
  // child_subdir indicates the subdirectory of the working directory (not the
  // parent repo) in which the child_path should be rooted. In most cases this
  // should be empty, but if child_path is relative to the parent repo dir
  // (eg. when DEPS specifies use_relative_paths), then this is required.
  string child_subdir = 7;
  // pre_upload_steps are named steps to run before uploading roll CLs.
  repeated PreUploadStep pre_upload_steps = 8;
  // metadata about the child project which should be updated in a file
  // checked into the parent repo.
  ProjectMetadataFileConfig metadata = 9;
}

// CommandRepoManagerConfig provides configuration for a roller which runs
// specified commands to perform different functions.
message CommandRepoManagerConfig {
  message CommandConfig {
      // command to run. If this is the command used to update the revision of
      // the Child, this should be a text template which uses SetPinnedRevVars
      // to get the from- and to-revisions.
      repeated string command = 1;
      // dir is the relative path within the Git checkout to run the command.
      string dir = 2;
      // env are environment variables to supply to the command, in KEY=VALUE
      // format.
      repeated string env = 3;
  }

  // git_checkout configures the Git checkout of the parent repo.
  GitCheckoutConfig git_checkout = 1;
  // short_rev_regex is a regular expression used to shorten revision IDs for
  // display.
  string short_rev_regex = 2;
  // get_tip_rev is a command used to obtain the latest revision of the Child.
  CommandConfig get_tip_rev = 3;
  // get_pinned_rev is a command used to obtain the currently-pinned revision
  // of the Child.
  CommandConfig get_pinned_rev = 4;
  // set_pinned_rev is a command used to update the currently-pinned revision
  // of the Child.
  CommandConfig set_pinned_rev = 5;
}

// FreeTypeRepoManagerConfig provides configuration for the FreeType roller.
message FreeTypeRepoManagerConfig {
  FreeTypeParentConfig parent = 1;
  GitilesChildConfig child = 2;
}

// FuchsiaSDKAndroidRepoManagerConfig provides configuration for the Fuchsia SDK
// into Android roller.
message FuchsiaSDKAndroidRepoManagerConfig {
  GitCheckoutParentConfig parent = 1;
  FuchsiaSDKChildConfig child = 2;
  // gen_sdk_bp_repo is the repo URL for the generation script.
  string gen_sdk_bp_repo = 3;
  // gen_sdk_bp_branch is the branch of the generation script.
  string gen_sdk_bp_branch = 4;
}

// Google3RepoManagerConfig provides configuration for a roller into Google3.
message Google3RepoManagerConfig {
  // child_branch is the branch of the child repo to track.
  string child_branch = 1;
  // child_repo is the URL of the child repo.
  string child_repo = 2;
}

// ParentChildRepoManagerConfig provides configuration for a roller which
// combines a pre-defined Parent and Child type.
message ParentChildRepoManagerConfig {
  // parent is the entity which depends on the child and receives the rolls.
  oneof parent {
      CopyParentConfig copy_parent = 1;
      DEPSLocalGitHubParentConfig deps_local_github_parent = 2;
      DEPSLocalGerritParentConfig deps_local_gerrit_parent = 3;
      GitCheckoutGitHubFileParentConfig git_checkout_github_file_parent = 4;
      GitilesParentConfig gitiles_parent = 5;
  }
  // child is the entity which is depended on by the parent and is rolled.
  oneof child {
      CIPDChildConfig cipd_child = 6;
      FuchsiaSDKChildConfig fuchsia_sdk_child = 7;
      GitCheckoutChildConfig git_checkout_child = 8;
      GitCheckoutGitHubChildConfig git_checkout_github_child = 9;
      GitilesChildConfig gitiles_child = 10;
      SemVerGCSChildConfig semver_gcs_child = 11;
  }
  // revision_filter filters out revisions of the child which should not be
  // considered as roll candidates.
  oneof revision_filter {
      BuildbucketRevisionFilterConfig buildbucket_revision_filter = 12;
  }
}

// CopyParentConfig provides configuration for a Parent which copies the Child
// into itself. It uses Gitiles and Gerrit instead of a local checkout.
message CopyParentConfig {
  message CopyEntry {
      // src_rel_path is the relative path within the Child.
      string src_rel_path = 1;
      // dst_rel_path is the relative path within the Parent.
      string dst_rel_path = 2;
  }

  GitilesParentConfig gitiles = 1;
  repeated CopyEntry copies = 2;
}

// DEPSLocalGitHubParentConfig provides configuration for a Parent which uses a
// local Git checkout with DEPS and uploads pull requests to GitHub.
message DEPSLocalGitHubParentConfig {
  DEPSLocalParentConfig deps_local = 1;
  GitHubConfig github = 2;
  string fork_repo_url = 3;
}

// DEPSLocalGerritParentConfig provides configuration for a Parent which uses a
// local Git checkout with DEPS and uploads CLs to Gerrit.
message DEPSLocalGerritParentConfig {
  DEPSLocalParentConfig deps_local = 1;
  GerritConfig gerrit = 2;
}

// GitCheckoutGitHubParentConfig provides configuration for a Parent which
// uses a local Git checkout and uploads pull requests to GitHub.
// TODO(borenet): Why doesn't this contain the GitHubConfig? Is this even
// needed?
message GitCheckoutGitHubParentConfig {
  GitCheckoutParentConfig git_checkout = 1;
  string fork_repo_url = 2;
}

// GitCheckoutGitHubFileParentConfig provides configuration for a Parent which
// uses a local Git checkout and uploads pull requests to GitHub.
message GitCheckoutGitHubFileParentConfig {
  GitCheckoutGitHubParentConfig git_checkout = 1;
  repeated PreUploadStep pre_upload_steps = 2;
}

// GitilesParentConfig provides configuration for a Parent which uses Gitiles.
message GitilesParentConfig {
  GitilesConfig gitiles = 1;
  DependencyConfig dep = 2;
  GerritConfig gerrit = 3;
}

// GitilesConfig provides configuration for a Git repo in Gitiles.
message GitilesConfig {
  // branch to track.
  string branch = 1;
  // repo_url from which to load Git data.
  string repo_url = 2;
  // dependencies is an optional specification of dependencies to track.
  // Revisions generated by the checkout will contain the pinned versions of
  // these dependencies.
  repeated VersionFileConfig dependencies = 3;
}

// DEPSLocalConfig provides configuration for a Parent which uses a local
// checkout and DEPS to manage dependencies.
message DEPSLocalParentConfig {
  GitCheckoutParentConfig git_checkout = 1;
  // child_path is the path to the child repo within the parent.
  string child_path = 2;
  // child_subdir is the subdirectory of the workdir in which the child_path
  // should be rooted.  In most cases, this should be empty, but if child_path
  // is relative to the parent repo dir (eg. when DEPS specifies
  // use_relative_paths), then this is required.
  string child_subdir = 3;
  // checkout_path is the path to the repo within the checkout root
  string checkout_path = 4;
  // gclient_spec overrides the default gclient spec.
  string gclient_spec = 5;
  // pre_upload_steps are steps to run before uploading the CL.
  repeated PreUploadStep pre_upload_steps = 6;
  // run_hooks indicates whether to run "gclient runhooks" after syncing.
  bool run_hooks = 7;
}

// GitCheckoutParentConfig provides configuration for a Parent which uses a
// local checkout to create changes.
message GitCheckoutParentConfig {
  GitCheckoutConfig git_checkout = 1;
  DependencyConfig dep = 2;
}

// FreeTypeParentConfig provides configuration for the FreeType Parent.
message FreeTypeParentConfig {
  GitilesParentConfig gitiles = 1;
}

// CIPDChildConfig provides configuration for a CIPD package Child.
message CIPDChildConfig {
  // name of the package.
  string name = 1;
  // tag to track.
  string tag = 2;
}

// FuchsiaSDKChildConfig provides configuration for the Fuchsia SDK Child.
message FuchsiaSDKChildConfig {
  // include_mac_sdk indicates whether to also roll the version of the Mac
  // SDK. Note that the dependency is not tracked separately; the Mac SDK is
  // simply rolled to the newest available version.
  bool include_mac_sdk = 1;
}

// SemVerGCSChildConfig provides configuration for a Child in GCS which uses
// semantic versioning.
message SemVerGCSChildConfig {
  GCSChildConfig gcs = 1;
  // short_rev_regex is a regular expression string which indicates what part
  // of the revision ID string should be used as the shortened ID for display.
  // If not specified, the full ID string is used.
  string short_rev_regex = 2;
  // version_regex is a regular expression string containing one or more
// integer capture groups. The integers matched by the capture groups are
  // compared, in order, when comparing two revisions.
  string version_regex = 3;
}

// GCSChildConfig provides configuration for a Child in GCS.
message GCSChildConfig {
  // gcs_bucket used for finding Child revisions.
  string gcs_bucket = 1;
  // gcs_path within the bucket which contains child revisions.
  string gcs_path = 2;
}

// GitCheckoutChildConfig provides configuration for a Child which uses a local
// Git checkout.
message GitCheckoutChildConfig {
  GitCheckoutConfig git_checkout = 1;
}

// GitCheckoutGitHubChildConfig provides configuration for a Child which uses a
// local checkout of a GitHub repo.
message GitCheckoutGitHubChildConfig {
  GitCheckoutChildConfig git_checkout = 1;
  string repo_owner = 2;
  string repo_name = 3;
}

// GitilesChildConfig provides configuration for a Child which uses Gitiles.
message GitilesChildConfig {
  GitilesConfig gitiles = 1;
  // path indicates an optional single path of the repo to watch for changes;
  // all commits which do not change this path are ignored.  Note that this
  // may produce strange results if the Git history for the path is not
  // linear.
  string path = 2;
}

// PreUploadStep lists the known pre-upload steps which may be run before roll
// CLs are uploaded. These must be kept in sync with
// go/repo_manager/parent/pre_upload_steps.go.
enum PreUploadStep {
  ANGLE_CODE_GENERATION = 0;
  ANGLE_GN_TO_BP = 1;
  ANGLE_ROLL_CHROMIUM = 2;
  GO_GENERATE_CIPD = 3;
  FLUTTER_LICENSE_SCRIPTS = 4;
  FLUTTER_LICENSE_SCRIPTS_FOR_DART = 5;
  FLUTTER_LICENSE_SCRIPTS_FOR_FUCHSIA = 6;
  SKIA_GN_TO_BP = 7;
  TRAIN_INFRA = 8;
  UPDATE_FLUTTER_DEPS_FOR_DART = 9;
}


// NotifierConfig provides configuration for a notification system.
message NotifierConfig {
  // LogLevel categorizes messages similarly to log severity.
  enum LogLevel {
      SILENT = 0;
      ERROR = 1;
      WARNING = 2;
      INFO = 3;
      DEBUG = 4;
  }

  // MsgType categorizes notifications based on their type.
  enum MsgType {
      ISSUE_UPDATE = 0;
      LAST_N_FAILED = 1;
      MODE_CHANGE = 2;
      NEW_FAILURE = 3;
      NEW_SUCCESS = 4;
      ROLL_CREATION_FAILED = 5;
      SAFETY_THROTTLE = 6;
      STRATEGY_CHANGE = 7;
      SUCCESS_THROTTLE = 8;
  }

  // log_level allows all messages at and above the given severity to be
  // sent. Mutually exclusive with msg_type.
  LogLevel log_level = 1;
  // msg_type limits the notifier to only send messages of the given
  // types. Mutually exclusive with log_level.
  repeated MsgType msg_type = 2;

  // config provides configuration for the specific type of notifier.
  oneof config {
      EmailNotifierConfig email = 3;
      ChatNotifierConfig chat = 4;
      MonorailNotifierConfig monorail = 5;
      PubSubNotifierConfig pubsub = 6;
  }

  // subject indicates a subject line which overrides the default subject line
  // for every notification message, if provided.
  string subject = 7;
}

// EmailNotifierConfig provides configuration for email notifications.
message EmailNotifierConfig {
  // emails are the email addresses which should receive notifications.
  repeated string emails = 1;
}

// ChatNotifierConfig provides configuration for Google Chat notifications.
message ChatNotifierConfig {
  // room_id in which to post messages.
  string room_id = 1;
}

// MonorailNotifierConfig provides configuration for bug-filing "notifications"
// using Monorail.
message MonorailNotifierConfig {
  // project name under which to file bugs. Required.
  string project = 1;
  // owner of bugs filed in Monorail. Required.
  string owner = 2;
  // cc these email addresses on bugs filed in Monorail.
  repeated string cc = 3;
  // components to apply to bugs filed in Monorail.
  repeated string components = 4;
  // labels to apply to bugs filed in Monorail.
  repeated string labels = 5;
}

// PubSubNotifierConfig provides configuration for PubSub notifications.
message PubSubNotifierConfig {
  // topic under which to publish PubSub messages.
  string topic = 1;
}

// ThrottleConfig provides configuration for throttling.
message ThrottleConfig {
  // attempt_count indicates the number of failed attempts after which to
  // begin throttling.
  int32 attempt_count = 1;
  // time_window during which, if the number of failed attempts exceeds the
  // specified attempt_count, throttling is enabled.
  string time_window = 2;
}

// TransitiveDepConfig provides configuration for a dependency referenced by
// both the parent and child, to be updated in the parent to match the revision
// depended on by the child at the revision being rolled.
message TransitiveDepConfig {
  // child dependency information.
  VersionFileConfig child = 1;
  // parent dependency information.
  VersionFileConfig parent = 2;
}

// VersionFileConfig provides configuration for a dependency whose version is
// pinned within a particular file.
message VersionFileConfig {
  // id of the dependency to be rolled, eg. a repo URL.
  string id = 1;
  // path within the repo of the file which pins the dependency.
  string path = 2;
}

// DependencyConfig provides configuration for a dependency whose version is
// pinned in a file and which may have transitive dependencies.
message DependencyConfig {
  // primary dependency.
  VersionFileConfig primary = 1;
  // transitive dependencies.
  repeated TransitiveDepConfig transitive = 2;
}

// GitCheckoutConfig provides configuration for a Git checkout.
message GitCheckoutConfig {
  // branch to track.
  string branch = 1;
  // repo_url to check out.
  string repo_url = 2;
  // rev_link_tmpl is an optional template used for generating links to
  // revisions. If not specified, revisions generated by the checkout will not
  // have an associated URL.
  string rev_link_tmpl = 3;
  // dependencies is an optional specification of dependencies to track.
  // Revisions generated by the checkout will contain the pinned versions of
  // these dependencies.
  repeated VersionFileConfig dependencies = 4;
}

// BuildbucketRevisionFilterConfig provides configuration for a revision filter
// which uses Buildbucket.
message BuildbucketRevisionFilterConfig {
  string project = 1;
  string bucket = 2;
}