/// An OS Config resource representing a guest configuration policy. These /// policies represent the desired state for VM instance guest environments /// including packages to install or remove, package repository configurations, /// and software to install. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GuestPolicy { /// Required. Unique name of the resource in this project using one of the following /// forms: /// `projects/{project_number}/guestPolicies/{guest_policy_id}`. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Description of the guest policy. Length of the description is limited /// to 1024 characters. #[prost(string, tag = "2")] pub description: ::prost::alloc::string::String, /// Output only. Time this guest policy was created. #[prost(message, optional, tag = "3")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. Last time this guest policy was updated. #[prost(message, optional, tag = "4")] pub update_time: ::core::option::Option<::prost_types::Timestamp>, /// Required. Specifies the VM instances that are assigned to this policy. This allows /// you to target sets or groups of VM instances by different parameters such /// as labels, names, OS, or zones. /// /// If left empty, all VM instances underneath this policy are targeted. /// /// At the same level in the resource hierarchy (that is within a project), the /// service prevents the creation of multiple policies that conflict with /// each other. For more information, see how the service [handles assignment /// conflicts](/compute/docs/os-config-management/create-guest-policy#handle-conflicts). #[prost(message, optional, tag = "6")] pub assignment: ::core::option::Option, /// The software packages to be managed by this policy. #[prost(message, repeated, tag = "7")] pub packages: ::prost::alloc::vec::Vec, /// A list of package repositories to configure on the VM instance. This is /// done before any other configs are applied so they can use these repos. /// Package repositories are only configured if the corresponding package /// manager(s) are available. #[prost(message, repeated, tag = "8")] pub package_repositories: ::prost::alloc::vec::Vec, /// A list of Recipes to install on the VM instance. #[prost(message, repeated, tag = "9")] pub recipes: ::prost::alloc::vec::Vec, /// The etag for this guest policy. /// If this is provided on update, it must match the server's etag. #[prost(string, tag = "10")] pub etag: ::prost::alloc::string::String, } /// An assignment represents the group or groups of VM instances that the policy /// applies to. /// /// If an assignment is empty, it applies to all VM instances. Otherwise, the /// targeted VM instances must meet all the criteria specified. So if both /// labels and zones are specified, the policy applies to VM instances with those /// labels and in those zones. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Assignment { /// Targets instances matching at least one of these label sets. This allows /// an assignment to target disparate groups, for example "env=prod or /// env=staging". #[prost(message, repeated, tag = "1")] pub group_labels: ::prost::alloc::vec::Vec, /// Targets instances in any of these zones. Leave empty to target instances /// in any zone. /// /// Zonal targeting is uncommon and is supported to facilitate the management /// of changes by zone. #[prost(string, repeated, tag = "2")] pub zones: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Targets any of the instances specified. Instances are specified by their /// URI in the form `zones/\[ZONE]/instances/[INSTANCE_NAME\]`. /// /// Instance targeting is uncommon and is supported to facilitate the /// management of changes by the instance or to target specific VM instances /// for development and testing. /// /// Only supported for project-level policies and must reference instances /// within this project. #[prost(string, repeated, tag = "3")] pub instances: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Targets VM instances whose name starts with one of these prefixes. /// /// Like labels, this is another way to group VM instances when targeting /// configs, for example prefix="prod-". /// /// Only supported for project-level policies. #[prost(string, repeated, tag = "4")] pub instance_name_prefixes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Targets VM instances matching at least one of the following OS types. /// /// VM instances must match all supplied criteria for a given OsType to be /// included. #[prost(message, repeated, tag = "5")] pub os_types: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `Assignment`. pub mod assignment { /// Represents a group of VM intances that can be identified as having all /// these labels, for example "env=prod and app=web". #[derive(Clone, PartialEq, ::prost::Message)] pub struct GroupLabel { /// Google Compute Engine instance labels that must be present for an /// instance to be included in this assignment group. #[prost(map = "string, string", tag = "1")] pub labels: ::std::collections::HashMap< ::prost::alloc::string::String, ::prost::alloc::string::String, >, } /// Defines the criteria for selecting VM Instances by OS type. #[derive(Clone, PartialEq, ::prost::Message)] pub struct OsType { /// Targets VM instances with OS Inventory enabled and having the following /// OS short name, for example "debian" or "windows". #[prost(string, tag = "1")] pub os_short_name: ::prost::alloc::string::String, /// Targets VM instances with OS Inventory enabled and having the following /// following OS version. #[prost(string, tag = "2")] pub os_version: ::prost::alloc::string::String, /// Targets VM instances with OS Inventory enabled and having the following /// OS architecture. #[prost(string, tag = "3")] pub os_architecture: ::prost::alloc::string::String, } } /// Package is a reference to the software package to be installed or removed. /// The agent on the VM instance uses the system package manager to apply the /// config. /// /// /// These are the commands that the agent uses to install or remove /// packages. /// /// Apt /// install: `apt-get update && apt-get -y install package1 package2 package3` /// remove: `apt-get -y remove package1 package2 package3` /// /// Yum /// install: `yum -y install package1 package2 package3` /// remove: `yum -y remove package1 package2 package3` /// /// Zypper /// install: `zypper install package1 package2 package3` /// remove: `zypper rm package1 package2` /// /// Googet /// install: `googet -noconfirm install package1 package2 package3` /// remove: `googet -noconfirm remove package1 package2 package3` #[derive(Clone, PartialEq, ::prost::Message)] pub struct Package { /// Required. The name of the package. A package is uniquely identified for conflict /// validation by checking the package name and the manager(s) that the /// package targets. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The desired_state the agent should maintain for this package. The /// default is to ensure the package is installed. #[prost(enumeration = "DesiredState", tag = "2")] pub desired_state: i32, /// Type of package manager that can be used to install this package. /// If a system does not have the package manager, the package is not /// installed or removed no error message is returned. By default, /// or if you specify `ANY`, /// the agent attempts to install and remove this package using the default /// package manager. This is useful when creating a policy that applies to /// different types of systems. /// /// The default behavior is ANY. #[prost(enumeration = "package::Manager", tag = "3")] pub manager: i32, } /// Nested message and enum types in `Package`. pub mod package { /// Types of package managers that may be used to manage this package. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Manager { /// The default behavior is ANY. Unspecified = 0, /// Apply this package config using the default system package manager. Any = 1, /// Apply this package config only if Apt is available on the system. Apt = 2, /// Apply this package config only if Yum is available on the system. Yum = 3, /// Apply this package config only if Zypper is available on the system. Zypper = 4, /// Apply this package config only if GooGet is available on the system. Goo = 5, } } /// Represents a single Apt package repository. This repository is added to /// a repo file that is stored at /// `/etc/apt/sources.list.d/google_osconfig.list`. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AptRepository { /// Type of archive files in this repository. The default behavior is DEB. #[prost(enumeration = "apt_repository::ArchiveType", tag = "1")] pub archive_type: i32, /// Required. URI for this repository. #[prost(string, tag = "2")] pub uri: ::prost::alloc::string::String, /// Required. Distribution of this repository. #[prost(string, tag = "3")] pub distribution: ::prost::alloc::string::String, /// Required. List of components for this repository. Must contain at least one item. #[prost(string, repeated, tag = "4")] pub components: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// URI of the key file for this repository. The agent maintains /// a keyring at `/etc/apt/trusted.gpg.d/osconfig_agent_managed.gpg` containing /// all the keys in any applied guest policy. #[prost(string, tag = "5")] pub gpg_key: ::prost::alloc::string::String, } /// Nested message and enum types in `AptRepository`. pub mod apt_repository { /// Type of archive. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ArchiveType { /// Unspecified. Unspecified = 0, /// DEB indicates that the archive contains binary files. Deb = 1, /// DEB_SRC indicates that the archive contains source files. DebSrc = 2, } } /// Represents a single Yum package repository. This repository is added to a /// repo file that is stored at `/etc/yum.repos.d/google_osconfig.repo`. #[derive(Clone, PartialEq, ::prost::Message)] pub struct YumRepository { /// Required. A one word, unique name for this repository. This is /// the `repo id` in the Yum config file and also the `display_name` if /// `display_name` is omitted. This id is also used as the unique identifier /// when checking for guest policy conflicts. #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, /// The display name of the repository. #[prost(string, tag = "2")] pub display_name: ::prost::alloc::string::String, /// Required. The location of the repository directory. #[prost(string, tag = "3")] pub base_url: ::prost::alloc::string::String, /// URIs of GPG keys. #[prost(string, repeated, tag = "4")] pub gpg_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Represents a single Zypper package repository. This repository is added to a /// repo file that is stored at `/etc/zypp/repos.d/google_osconfig.repo`. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ZypperRepository { /// Required. A one word, unique name for this repository. This is /// the `repo id` in the zypper config file and also the `display_name` if /// `display_name` is omitted. This id is also used as the unique identifier /// when checking for guest policy conflicts. #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, /// The display name of the repository. #[prost(string, tag = "2")] pub display_name: ::prost::alloc::string::String, /// Required. The location of the repository directory. #[prost(string, tag = "3")] pub base_url: ::prost::alloc::string::String, /// URIs of GPG keys. #[prost(string, repeated, tag = "4")] pub gpg_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Represents a Goo package repository. These is added to a repo file /// that is stored at C:/ProgramData/GooGet/repos/google_osconfig.repo. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GooRepository { /// Required. The name of the repository. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Required. The url of the repository. #[prost(string, tag = "2")] pub url: ::prost::alloc::string::String, } /// A package repository. #[derive(Clone, PartialEq, ::prost::Message)] pub struct PackageRepository { /// A specific type of repository. #[prost(oneof = "package_repository::Repository", tags = "1, 2, 3, 4")] pub repository: ::core::option::Option, } /// Nested message and enum types in `PackageRepository`. pub mod package_repository { /// A specific type of repository. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Repository { /// An Apt Repository. #[prost(message, tag = "1")] Apt(super::AptRepository), /// A Yum Repository. #[prost(message, tag = "2")] Yum(super::YumRepository), /// A Zypper Repository. #[prost(message, tag = "3")] Zypper(super::ZypperRepository), /// A Goo Repository. #[prost(message, tag = "4")] Goo(super::GooRepository), } } /// A software recipe is a set of instructions for installing and configuring a /// piece of software. It consists of a set of artifacts that are /// downloaded, and a set of steps that install, configure, and/or update the /// software. /// /// Recipes support installing and updating software from artifacts in the /// following formats: /// Zip archive, Tar archive, Windows MSI, Debian package, and RPM package. /// /// Additionally, recipes support executing a script (either defined in a file or /// directly in this api) in bash, sh, cmd, and powershell. /// /// Updating a software recipe /// /// If a recipe is assigned to an instance and there is a recipe with the same /// name but a lower version already installed and the assigned state /// of the recipe is `INSTALLED_KEEP_UPDATED`, then the recipe is updated to /// the new version. /// /// Script Working Directories /// /// Each script or execution step is run in its own temporary directory which /// is deleted after completing the step. #[derive(Clone, PartialEq, ::prost::Message)] pub struct SoftwareRecipe { /// Required. Unique identifier for the recipe. Only one recipe with a given name is /// installed on an instance. /// /// Names are also used to identify resources which helps to determine whether /// guest policies have conflicts. This means that requests to create multiple /// recipes with the same name and version are rejected since they /// could potentially have conflicting assignments. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The version of this software recipe. Version can be up to 4 period /// separated numbers (e.g. 12.34.56.78). #[prost(string, tag = "2")] pub version: ::prost::alloc::string::String, /// Resources available to be used in the steps in the recipe. #[prost(message, repeated, tag = "3")] pub artifacts: ::prost::alloc::vec::Vec, /// Actions to be taken for installing this recipe. On failure it stops /// executing steps and does not attempt another installation. Any steps taken /// (including partially completed steps) are not rolled back. #[prost(message, repeated, tag = "4")] pub install_steps: ::prost::alloc::vec::Vec, /// Actions to be taken for updating this recipe. On failure it stops /// executing steps and does not attempt another update for this recipe. Any /// steps taken (including partially completed steps) are not rolled back. #[prost(message, repeated, tag = "5")] pub update_steps: ::prost::alloc::vec::Vec, /// Default is INSTALLED. The desired state the agent should maintain for this /// recipe. /// /// INSTALLED: The software recipe is installed on the instance but /// won't be updated to new versions. /// INSTALLED_KEEP_UPDATED: The software recipe is installed on the /// instance. The recipe is updated to a higher /// version, if a higher version of the recipe is /// assigned to this instance. /// REMOVE: Remove is unsupported for software recipes and attempts to /// create or update a recipe to the REMOVE state is rejected. #[prost(enumeration = "DesiredState", tag = "6")] pub desired_state: i32, } /// Nested message and enum types in `SoftwareRecipe`. pub mod software_recipe { /// Specifies a resource to be used in the recipe. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Artifact { /// Required. Id of the artifact, which the installation and update steps of this /// recipe can reference. Artifacts in a recipe cannot have the same id. #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, /// Defaults to false. When false, recipes are subject to validations /// based on the artifact type: /// /// Remote: A checksum must be specified, and only protocols with /// transport-layer security are permitted. /// GCS: An object generation number must be specified. #[prost(bool, tag = "4")] pub allow_insecure: bool, /// A specific type of artifact. #[prost(oneof = "artifact::Artifact", tags = "2, 3")] pub artifact: ::core::option::Option, } /// Nested message and enum types in `Artifact`. pub mod artifact { /// Specifies an artifact available via some URI. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Remote { /// URI from which to fetch the object. It should contain both the protocol /// and path following the format {protocol}://{location}. #[prost(string, tag = "1")] pub uri: ::prost::alloc::string::String, /// Must be provided if `allow_insecure` is `false`. /// SHA256 checksum in hex format, to compare to the checksum of the /// artifact. If the checksum is not empty and it doesn't match the /// artifact then the recipe installation fails before running any of the /// steps. #[prost(string, tag = "2")] pub checksum: ::prost::alloc::string::String, } /// Specifies an artifact available as a Google Cloud Storage object. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Gcs { /// Bucket of the Google Cloud Storage object. /// Given an example URL: /// ` /// this value would be `my-bucket`. #[prost(string, tag = "1")] pub bucket: ::prost::alloc::string::String, /// Name of the Google Cloud Storage object. /// As specified \[here\] /// () /// Given an example URL: /// ` /// this value would be `foo/bar`. #[prost(string, tag = "2")] pub object: ::prost::alloc::string::String, /// Must be provided if allow_insecure is false. /// Generation number of the Google Cloud Storage object. /// ` /// this value would be `1234567`. #[prost(int64, tag = "3")] pub generation: i64, } /// A specific type of artifact. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Artifact { /// A generic remote artifact. #[prost(message, tag = "2")] Remote(Remote), /// A Google Cloud Storage artifact. #[prost(message, tag = "3")] Gcs(Gcs), } } /// An action that can be taken as part of installing or updating a recipe. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Step { /// A specific type of step. #[prost(oneof = "step::Step", tags = "1, 2, 3, 4, 5, 6, 7")] pub step: ::core::option::Option, } /// Nested message and enum types in `Step`. pub mod step { /// Copies the artifact to the specified path on the instance. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CopyFile { /// Required. The id of the relevant artifact in the recipe. #[prost(string, tag = "1")] pub artifact_id: ::prost::alloc::string::String, /// Required. The absolute path on the instance to put the file. #[prost(string, tag = "2")] pub destination: ::prost::alloc::string::String, /// Whether to allow this step to overwrite existing files. If this is /// false and the file already exists the file is not overwritten /// and the step is considered a success. Defaults to false. #[prost(bool, tag = "3")] pub overwrite: bool, /// Consists of three octal digits which represent, in /// order, the permissions of the owner, group, and other users for the /// file (similarly to the numeric mode used in the linux chmod utility). /// Each digit represents a three bit number with the 4 bit /// corresponding to the read permissions, the 2 bit corresponds to the /// write bit, and the one bit corresponds to the execute permission. /// Default behavior is 755. /// /// Below are some examples of permissions and their associated values: /// read, write, and execute: 7 /// read and execute: 5 /// read and write: 6 /// read only: 4 #[prost(string, tag = "4")] pub permissions: ::prost::alloc::string::String, } /// Extracts an archive of the type specified in the specified directory. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ExtractArchive { /// Required. The id of the relevant artifact in the recipe. #[prost(string, tag = "1")] pub artifact_id: ::prost::alloc::string::String, /// Directory to extract archive to. /// Defaults to `/` on Linux or `C:\` on Windows. #[prost(string, tag = "2")] pub destination: ::prost::alloc::string::String, /// Required. The type of the archive to extract. #[prost(enumeration = "extract_archive::ArchiveType", tag = "3")] pub r#type: i32, } /// Nested message and enum types in `ExtractArchive`. pub mod extract_archive { /// Specifying the type of archive. #[derive( Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration, )] #[repr(i32)] pub enum ArchiveType { /// Indicates that the archive type isn't specified. Unspecified = 0, /// Indicates that the archive is a tar archive with no encryption. Tar = 1, /// Indicates that the archive is a tar archive with gzip encryption. TarGzip = 2, /// Indicates that the archive is a tar archive with bzip encryption. TarBzip = 3, /// Indicates that the archive is a tar archive with lzma encryption. TarLzma = 4, /// Indicates that the archive is a tar archive with xz encryption. TarXz = 5, /// Indicates that the archive is a zip archive. Zip = 11, } } /// Installs an MSI file. #[derive(Clone, PartialEq, ::prost::Message)] pub struct InstallMsi { /// Required. The id of the relevant artifact in the recipe. #[prost(string, tag = "1")] pub artifact_id: ::prost::alloc::string::String, /// The flags to use when installing the MSI /// defaults to \["/i"\] (i.e. the install flag). #[prost(string, repeated, tag = "2")] pub flags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Return codes that indicate that the software installed or updated /// successfully. Behaviour defaults to \[0\] #[prost(int32, repeated, tag = "3")] pub allowed_exit_codes: ::prost::alloc::vec::Vec, } /// Installs a deb via dpkg. #[derive(Clone, PartialEq, ::prost::Message)] pub struct InstallDpkg { /// Required. The id of the relevant artifact in the recipe. #[prost(string, tag = "1")] pub artifact_id: ::prost::alloc::string::String, } /// Installs an rpm file via the rpm utility. #[derive(Clone, PartialEq, ::prost::Message)] pub struct InstallRpm { /// Required. The id of the relevant artifact in the recipe. #[prost(string, tag = "1")] pub artifact_id: ::prost::alloc::string::String, } /// Executes an artifact or local file. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ExecFile { /// Arguments to be passed to the provided executable. #[prost(string, repeated, tag = "3")] pub args: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Defaults to \[0\]. A list of possible return values that the program /// can return to indicate a success. #[prost(int32, repeated, tag = "4")] pub allowed_exit_codes: ::prost::alloc::vec::Vec, /// Location of the file to execute. #[prost(oneof = "exec_file::LocationType", tags = "1, 2")] pub location_type: ::core::option::Option, } /// Nested message and enum types in `ExecFile`. pub mod exec_file { /// Location of the file to execute. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum LocationType { /// The id of the relevant artifact in the recipe. #[prost(string, tag = "1")] ArtifactId(::prost::alloc::string::String), /// The absolute path of the file on the local filesystem. #[prost(string, tag = "2")] LocalPath(::prost::alloc::string::String), } } /// Runs a script through an interpreter. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RunScript { /// Required. The shell script to be executed. #[prost(string, tag = "1")] pub script: ::prost::alloc::string::String, /// Return codes that indicate that the software installed or updated /// successfully. Behaviour defaults to \[0\] #[prost(int32, repeated, tag = "2")] pub allowed_exit_codes: ::prost::alloc::vec::Vec, /// The script interpreter to use to run the script. If no interpreter is /// specified the script is executed directly, which likely /// only succeed for scripts with /// [shebang lines]()). #[prost(enumeration = "run_script::Interpreter", tag = "3")] pub interpreter: i32, } /// Nested message and enum types in `RunScript`. pub mod run_script { /// The interpreter used to execute a script. #[derive( Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration, )] #[repr(i32)] pub enum Interpreter { /// Default value for ScriptType. Unspecified = 0, /// Indicates that the script is run with `/bin/sh` on Linux and `cmd` /// on windows. Shell = 1, /// Indicates that the script is run with powershell. Powershell = 3, } } /// A specific type of step. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Step { /// Copies a file onto the instance. #[prost(message, tag = "1")] FileCopy(CopyFile), /// Extracts an archive into the specified directory. #[prost(message, tag = "2")] ArchiveExtraction(ExtractArchive), /// Installs an MSI file. #[prost(message, tag = "3")] MsiInstallation(InstallMsi), /// Installs a deb file via dpkg. #[prost(message, tag = "4")] DpkgInstallation(InstallDpkg), /// Installs an rpm file via the rpm utility. #[prost(message, tag = "5")] RpmInstallation(InstallRpm), /// Executes an artifact or local file. #[prost(message, tag = "6")] FileExec(ExecFile), /// Runs commands in a shell. #[prost(message, tag = "7")] ScriptRun(RunScript), } } } /// A request message for creating a guest policy. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateGuestPolicyRequest { /// Required. The resource name of the parent using one of the following forms: /// `projects/{project_number}`. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The logical name of the guest policy in the project /// with the following restrictions: /// /// * Must contain only lowercase letters, numbers, and hyphens. /// * Must start with a letter. /// * Must be between 1-63 characters. /// * Must end with a number or a letter. /// * Must be unique within the project. #[prost(string, tag = "2")] pub guest_policy_id: ::prost::alloc::string::String, /// Required. The GuestPolicy to create. #[prost(message, optional, tag = "3")] pub guest_policy: ::core::option::Option, } /// A request message for retrieving a guest policy. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetGuestPolicyRequest { /// Required. The resource name of the guest policy using one of the following forms: /// `projects/{project_number}/guestPolicies/{guest_policy_id}`. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// A request message for listing guest policies. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListGuestPoliciesRequest { /// Required. The resource name of the parent using one of the following forms: /// `projects/{project_number}`. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// The maximum number of guest policies to return. #[prost(int32, tag = "2")] pub page_size: i32, /// A pagination token returned from a previous call to `ListGuestPolicies` /// that indicates where this listing should continue from. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, } /// A response message for listing guest policies. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListGuestPoliciesResponse { /// The list of GuestPolicies. #[prost(message, repeated, tag = "1")] pub guest_policies: ::prost::alloc::vec::Vec, /// A pagination token that can be used to get the next page /// of guest policies. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, } /// A request message for updating a guest policy. #[derive(Clone, PartialEq, ::prost::Message)] pub struct UpdateGuestPolicyRequest { /// Required. The updated GuestPolicy. #[prost(message, optional, tag = "1")] pub guest_policy: ::core::option::Option, /// Field mask that controls which fields of the guest policy should be /// updated. #[prost(message, optional, tag = "2")] pub update_mask: ::core::option::Option<::prost_types::FieldMask>, } /// A request message for deleting a guest policy. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteGuestPolicyRequest { /// Required. The resource name of the guest policy using one of the following forms: /// `projects/{project_number}/guestPolicies/{guest_policy_id}`. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// A request message for getting the effective guest policy assigned to the /// instance. #[derive(Clone, PartialEq, ::prost::Message)] pub struct LookupEffectiveGuestPolicyRequest { /// Required. The VM instance whose policies are being looked up. #[prost(string, tag = "1")] pub instance: ::prost::alloc::string::String, /// Short name of the OS running on the instance. The OS Config agent only /// provides this field for targeting if OS Inventory is enabled for that /// instance. #[prost(string, tag = "2")] pub os_short_name: ::prost::alloc::string::String, /// Version of the OS running on the instance. The OS Config agent only /// provides this field for targeting if OS Inventory is enabled for that /// VM instance. #[prost(string, tag = "3")] pub os_version: ::prost::alloc::string::String, /// Architecture of OS running on the instance. The OS Config agent only /// provides this field for targeting if OS Inventory is enabled for that /// instance. #[prost(string, tag = "4")] pub os_architecture: ::prost::alloc::string::String, } /// The effective guest policy that applies to a VM instance. #[derive(Clone, PartialEq, ::prost::Message)] pub struct EffectiveGuestPolicy { /// List of package configurations assigned to the VM instance. #[prost(message, repeated, tag = "1")] pub packages: ::prost::alloc::vec::Vec, /// List of package repository configurations assigned to the VM instance. #[prost(message, repeated, tag = "2")] pub package_repositories: ::prost::alloc::vec::Vec, /// List of recipes assigned to the VM instance. #[prost(message, repeated, tag = "3")] pub software_recipes: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `EffectiveGuestPolicy`. pub mod effective_guest_policy { /// A guest policy package including its source. #[derive(Clone, PartialEq, ::prost::Message)] pub struct SourcedPackage { /// Name of the guest policy providing this config. #[prost(string, tag = "1")] pub source: ::prost::alloc::string::String, /// A software package to configure on the VM instance. #[prost(message, optional, tag = "2")] pub package: ::core::option::Option, } /// A guest policy package repository including its source. #[derive(Clone, PartialEq, ::prost::Message)] pub struct SourcedPackageRepository { /// Name of the guest policy providing this config. #[prost(string, tag = "1")] pub source: ::prost::alloc::string::String, /// A software package repository to configure on the VM instance. #[prost(message, optional, tag = "2")] pub package_repository: ::core::option::Option, } /// A guest policy recipe including its source. #[derive(Clone, PartialEq, ::prost::Message)] pub struct SourcedSoftwareRecipe { /// Name of the guest policy providing this config. #[prost(string, tag = "1")] pub source: ::prost::alloc::string::String, /// A software recipe to configure on the VM instance. #[prost(message, optional, tag = "2")] pub software_recipe: ::core::option::Option, } } /// The desired state that the OS Config agent maintains on the VM instance. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum DesiredState { /// The default is to ensure the package is installed. Unspecified = 0, /// The agent ensures that the package is installed. Installed = 1, /// The agent ensures that the package is installed and /// periodically checks for and install any updates. Updated = 2, /// The agent ensures that the package is not installed and uninstall it /// if detected. Removed = 3, } /// A request message to initiate patching across Google Compute Engine /// instances. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ExecutePatchJobRequest { /// Required. The project in which to run this patch in the form `projects/*` #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Description of the patch job. Length of the description is limited /// to 1024 characters. #[prost(string, tag = "2")] pub description: ::prost::alloc::string::String, /// Required. Instances to patch, either explicitly or filtered by some criteria such /// as zone or labels. #[prost(message, optional, tag = "7")] pub instance_filter: ::core::option::Option, /// Patch configuration being applied. If omitted, instances are /// patched using the default configurations. #[prost(message, optional, tag = "4")] pub patch_config: ::core::option::Option, /// Duration of the patch job. After the duration ends, the patch job /// times out. #[prost(message, optional, tag = "5")] pub duration: ::core::option::Option<::prost_types::Duration>, /// If this patch is a dry-run only, instances are contacted but /// will do nothing. #[prost(bool, tag = "6")] pub dry_run: bool, /// Display name for this patch job. This does not have to be unique. #[prost(string, tag = "8")] pub display_name: ::prost::alloc::string::String, } /// Request to get an active or completed patch job. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetPatchJobRequest { /// Required. Name of the patch in the form `projects/*/patchJobs/*` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request to list details for all instances that are part of a patch job. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListPatchJobInstanceDetailsRequest { /// Required. The parent for the instances are in the form of `projects/*/patchJobs/*`. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// The maximum number of instance details records to return. Default is 100. #[prost(int32, tag = "2")] pub page_size: i32, /// A pagination token returned from a previous call /// that indicates where this listing should continue from. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, /// A filter expression that filters results listed in the response. This /// field supports filtering results by instance zone, name, state, or /// `failure_reason`. #[prost(string, tag = "4")] pub filter: ::prost::alloc::string::String, } /// A response message for listing the instances details for a patch job. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListPatchJobInstanceDetailsResponse { /// A list of instance status. #[prost(message, repeated, tag = "1")] pub patch_job_instance_details: ::prost::alloc::vec::Vec, /// A pagination token that can be used to get the next page of results. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, } /// Patch details for a VM instance. For more information about reviewing VM /// instance details, see /// [Listing all VM instance details for a specific patch /// job](/compute/docs/os-patch-management/manage-patch-jobs#list-instance-details). #[derive(Clone, PartialEq, ::prost::Message)] pub struct PatchJobInstanceDetails { /// The instance name in the form `projects/*/zones/*/instances/*` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The unique identifier for the instance. This identifier is /// defined by the server. #[prost(string, tag = "2")] pub instance_system_id: ::prost::alloc::string::String, /// Current state of instance patch. #[prost(enumeration = "instance::PatchState", tag = "3")] pub state: i32, /// If the patch fails, this field provides the reason. #[prost(string, tag = "4")] pub failure_reason: ::prost::alloc::string::String, /// The number of times the agent that the agent attempts to apply the patch. #[prost(int64, tag = "5")] pub attempt_count: i64, } /// A request message for listing patch jobs. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListPatchJobsRequest { /// Required. In the form of `projects/*` #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// The maximum number of instance status to return. #[prost(int32, tag = "2")] pub page_size: i32, /// A pagination token returned from a previous call /// that indicates where this listing should continue from. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, /// If provided, this field specifies the criteria that must be met by patch /// jobs to be included in the response. /// Currently, filtering is only available on the patch_deployment field. #[prost(string, tag = "4")] pub filter: ::prost::alloc::string::String, } /// A response message for listing patch jobs. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListPatchJobsResponse { /// The list of patch jobs. #[prost(message, repeated, tag = "1")] pub patch_jobs: ::prost::alloc::vec::Vec, /// A pagination token that can be used to get the next page of results. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, } /// A high level representation of a patch job that is either in progress /// or has completed. /// /// Instances details are not included in the job. To paginate through instance /// details, use ListPatchJobInstanceDetails. /// /// For more information about patch jobs, see /// [Creating patch jobs](/compute/docs/os-patch-management/create-patch-job). #[derive(Clone, PartialEq, ::prost::Message)] pub struct PatchJob { /// Unique identifier for this patch job in the form /// `projects/*/patchJobs/*` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Display name for this patch job. This is not a unique identifier. #[prost(string, tag = "14")] pub display_name: ::prost::alloc::string::String, /// Description of the patch job. Length of the description is limited /// to 1024 characters. #[prost(string, tag = "2")] pub description: ::prost::alloc::string::String, /// Time this patch job was created. #[prost(message, optional, tag = "3")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// Last time this patch job was updated. #[prost(message, optional, tag = "4")] pub update_time: ::core::option::Option<::prost_types::Timestamp>, /// The current state of the PatchJob . #[prost(enumeration = "patch_job::State", tag = "5")] pub state: i32, /// Instances to patch. #[prost(message, optional, tag = "13")] pub instance_filter: ::core::option::Option, /// Patch configuration being applied. #[prost(message, optional, tag = "7")] pub patch_config: ::core::option::Option, /// Duration of the patch job. After the duration ends, the /// patch job times out. #[prost(message, optional, tag = "8")] pub duration: ::core::option::Option<::prost_types::Duration>, /// Summary of instance details. #[prost(message, optional, tag = "9")] pub instance_details_summary: ::core::option::Option, /// If this patch job is a dry run, the agent reports that it has /// finished without running any updates on the VM instance. #[prost(bool, tag = "10")] pub dry_run: bool, /// If this patch job failed, this message provides information about the /// failure. #[prost(string, tag = "11")] pub error_message: ::prost::alloc::string::String, /// Reflects the overall progress of the patch job in the range of /// 0.0 being no progress to 100.0 being complete. #[prost(double, tag = "12")] pub percent_complete: f64, /// Output only. Name of the patch deployment that created this patch job. #[prost(string, tag = "15")] pub patch_deployment: ::prost::alloc::string::String, } /// Nested message and enum types in `PatchJob`. pub mod patch_job { /// A summary of the current patch state across all instances that this patch /// job affects. Contains counts of instances in different states. These states /// map to `InstancePatchState`. List patch job instance details to see the /// specific states of each instance. #[derive(Clone, PartialEq, ::prost::Message)] pub struct InstanceDetailsSummary { /// Number of instances pending patch job. #[prost(int64, tag = "1")] pub pending_instance_count: i64, /// Number of instances that are inactive. #[prost(int64, tag = "2")] pub inactive_instance_count: i64, /// Number of instances notified about patch job. #[prost(int64, tag = "3")] pub notified_instance_count: i64, /// Number of instances that have started. #[prost(int64, tag = "4")] pub started_instance_count: i64, /// Number of instances that are downloading patches. #[prost(int64, tag = "5")] pub downloading_patches_instance_count: i64, /// Number of instances that are applying patches. #[prost(int64, tag = "6")] pub applying_patches_instance_count: i64, /// Number of instances rebooting. #[prost(int64, tag = "7")] pub rebooting_instance_count: i64, /// Number of instances that have completed successfully. #[prost(int64, tag = "8")] pub succeeded_instance_count: i64, /// Number of instances that require reboot. #[prost(int64, tag = "9")] pub succeeded_reboot_required_instance_count: i64, /// Number of instances that failed. #[prost(int64, tag = "10")] pub failed_instance_count: i64, /// Number of instances that have acked and will start shortly. #[prost(int64, tag = "11")] pub acked_instance_count: i64, /// Number of instances that exceeded the time out while applying the patch. #[prost(int64, tag = "12")] pub timed_out_instance_count: i64, /// Number of instances that are running the pre-patch step. #[prost(int64, tag = "13")] pub pre_patch_step_instance_count: i64, /// Number of instances that are running the post-patch step. #[prost(int64, tag = "14")] pub post_patch_step_instance_count: i64, /// Number of instances that do not appear to be running the agent. Check to /// ensure that the agent is installed, running, and able to communicate with /// the service. #[prost(int64, tag = "15")] pub no_agent_detected_instance_count: i64, } /// Enumeration of the various states a patch job passes through as it /// executes. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { /// State must be specified. Unspecified = 0, /// The patch job was successfully initiated. Started = 1, /// The patch job is looking up instances to run the patch on. InstanceLookup = 2, /// Instances are being patched. Patching = 3, /// Patch job completed successfully. Succeeded = 4, /// Patch job completed but there were errors. CompletedWithErrors = 5, /// The patch job was canceled. Canceled = 6, /// The patch job timed out. TimedOut = 7, } } /// Patch configuration specifications. Contains details on how to apply the /// patch(es) to a VM instance. #[derive(Clone, PartialEq, ::prost::Message)] pub struct PatchConfig { /// Post-patch reboot settings. #[prost(enumeration = "patch_config::RebootConfig", tag = "1")] pub reboot_config: i32, /// Apt update settings. Use this setting to override the default `apt` patch /// rules. #[prost(message, optional, tag = "3")] pub apt: ::core::option::Option, /// Yum update settings. Use this setting to override the default `yum` patch /// rules. #[prost(message, optional, tag = "4")] pub yum: ::core::option::Option, /// Goo update settings. Use this setting to override the default `goo` patch /// rules. #[prost(message, optional, tag = "5")] pub goo: ::core::option::Option, /// Zypper update settings. Use this setting to override the default `zypper` /// patch rules. #[prost(message, optional, tag = "6")] pub zypper: ::core::option::Option, /// Windows update settings. Use this override the default windows patch rules. #[prost(message, optional, tag = "7")] pub windows_update: ::core::option::Option, /// The `ExecStep` to run before the patch update. #[prost(message, optional, tag = "8")] pub pre_step: ::core::option::Option, /// The `ExecStep` to run after the patch update. #[prost(message, optional, tag = "9")] pub post_step: ::core::option::Option, } /// Nested message and enum types in `PatchConfig`. pub mod patch_config { /// Post-patch reboot settings. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum RebootConfig { /// The default behavior is DEFAULT. Unspecified = 0, /// The agent decides if a reboot is necessary by checking signals such as /// registry keys on Windows or `/var/run/reboot-required` on APT based /// systems. On RPM based systems, a set of core system package install times /// are compared with system boot time. Default = 1, /// Always reboot the machine after the update completes. Always = 2, /// Never reboot the machine after the update completes. Never = 3, } } /// Namespace for instance state enums. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Instance {} /// Nested message and enum types in `Instance`. pub mod instance { /// Patch state of an instance. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum PatchState { /// Unspecified. Unspecified = 0, /// The instance is not yet notified. Pending = 1, /// Instance is inactive and cannot be patched. Inactive = 2, /// The instance is notified that it should be patched. Notified = 3, /// The instance has started the patching process. Started = 4, /// The instance is downloading patches. DownloadingPatches = 5, /// The instance is applying patches. ApplyingPatches = 6, /// The instance is rebooting. Rebooting = 7, /// The instance has completed applying patches. Succeeded = 8, /// The instance has completed applying patches but a reboot is required. SucceededRebootRequired = 9, /// The instance has failed to apply the patch. Failed = 10, /// The instance acked the notification and will start shortly. Acked = 11, /// The instance exceeded the time out while applying the patch. TimedOut = 12, /// The instance is running the pre-patch step. RunningPrePatchStep = 13, /// The instance is running the post-patch step. RunningPostPatchStep = 14, /// The service could not detect the presence of the agent. Check to ensure /// that the agent is installed, running, and able to communicate with the /// service. NoAgentDetected = 15, } } /// Message for canceling a patch job. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CancelPatchJobRequest { /// Required. Name of the patch in the form `projects/*/patchJobs/*` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Apt patching is completed by executing `apt-get update && apt-get /// upgrade`. Additional options can be set to control how this is executed. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AptSettings { /// By changing the type to DIST, the patching is performed /// using `apt-get dist-upgrade` instead. #[prost(enumeration = "apt_settings::Type", tag = "1")] pub r#type: i32, /// List of packages to exclude from update. These packages will be excluded #[prost(string, repeated, tag = "2")] pub excludes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// An exclusive list of packages to be updated. These are the only packages /// that will be updated. If these packages are not installed, they will be /// ignored. This field cannot be specified with any other patch configuration /// fields. #[prost(string, repeated, tag = "3")] pub exclusive_packages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Nested message and enum types in `AptSettings`. pub mod apt_settings { /// Apt patch type. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Type { /// By default, upgrade will be performed. Unspecified = 0, /// Runs `apt-get dist-upgrade`. Dist = 1, /// Runs `apt-get upgrade`. Upgrade = 2, } } /// Yum patching is performed by executing `yum update`. Additional options /// can be set to control how this is executed. /// /// Note that not all settings are supported on all platforms. #[derive(Clone, PartialEq, ::prost::Message)] pub struct YumSettings { /// Adds the `--security` flag to `yum update`. Not supported on /// all platforms. #[prost(bool, tag = "1")] pub security: bool, /// Will cause patch to run `yum update-minimal` instead. #[prost(bool, tag = "2")] pub minimal: bool, /// List of packages to exclude from update. These packages are excluded by /// using the yum `--exclude` flag. #[prost(string, repeated, tag = "3")] pub excludes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// An exclusive list of packages to be updated. These are the only packages /// that will be updated. If these packages are not installed, they will be /// ignored. This field must not be specified with any other patch /// configuration fields. #[prost(string, repeated, tag = "4")] pub exclusive_packages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Googet patching is performed by running `googet update`. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GooSettings {} /// Zypper patching is performed by running `zypper patch`. /// See also #[derive(Clone, PartialEq, ::prost::Message)] pub struct ZypperSettings { /// Adds the `--with-optional` flag to `zypper patch`. #[prost(bool, tag = "1")] pub with_optional: bool, /// Adds the `--with-update` flag, to `zypper patch`. #[prost(bool, tag = "2")] pub with_update: bool, /// Install only patches with these categories. /// Common categories include security, recommended, and feature. #[prost(string, repeated, tag = "3")] pub categories: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Install only patches with these severities. /// Common severities include critical, important, moderate, and low. #[prost(string, repeated, tag = "4")] pub severities: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// List of patches to exclude from update. #[prost(string, repeated, tag = "5")] pub excludes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// An exclusive list of patches to be updated. These are the only patches /// that will be installed using 'zypper patch patch:' command. /// This field must not be used with any other patch configuration fields. #[prost(string, repeated, tag = "6")] pub exclusive_patches: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Windows patching is performed using the Windows Update Agent. #[derive(Clone, PartialEq, ::prost::Message)] pub struct WindowsUpdateSettings { /// Only apply updates of these windows update classifications. If empty, all /// updates are applied. #[prost(enumeration = "windows_update_settings::Classification", repeated, tag = "1")] pub classifications: ::prost::alloc::vec::Vec, /// List of KBs to exclude from update. #[prost(string, repeated, tag = "2")] pub excludes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// An exclusive list of kbs to be updated. These are the only patches /// that will be updated. This field must not be used with other /// patch configurations. #[prost(string, repeated, tag = "3")] pub exclusive_patches: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Nested message and enum types in `WindowsUpdateSettings`. pub mod windows_update_settings { /// Microsoft Windows update classifications as defined in /// \[1\] /// #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Classification { /// Invalid. If classifications are included, they must be specified. Unspecified = 0, /// "A widely released fix for a specific problem that addresses a critical, /// non-security-related bug." \[1\] Critical = 1, /// "A widely released fix for a product-specific, security-related /// vulnerability. Security vulnerabilities are rated by their severity. The /// severity rating is indicated in the Microsoft security bulletin as /// critical, important, moderate, or low." \[1\] Security = 2, /// "A widely released and frequent software update that contains additions /// to a product's definition database. Definition databases are often used /// to detect objects that have specific attributes, such as malicious code, /// phishing websites, or junk mail." \[1\] Definition = 3, /// "Software that controls the input and output of a device." \[1\] Driver = 4, /// "New product functionality that is first distributed outside the context /// of a product release and that is typically included in the next full /// product release." \[1\] FeaturePack = 5, /// "A tested, cumulative set of all hotfixes, security updates, critical /// updates, and updates. Additionally, service packs may contain additional /// fixes for problems that are found internally since the release of the /// product. Service packs my also contain a limited number of /// customer-requested design changes or features." \[1\] ServicePack = 6, /// "A utility or feature that helps complete a task or set of tasks." \[1\] Tool = 7, /// "A tested, cumulative set of hotfixes, security updates, critical /// updates, and updates that are packaged together for easy deployment. A /// rollup generally targets a specific area, such as security, or a /// component of a product, such as Internet Information Services (IIS)." \[1\] UpdateRollup = 8, /// "A widely released fix for a specific problem. An update addresses a /// noncritical, non-security-related bug." \[1\] Update = 9, } } /// A step that runs an executable for a PatchJob. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ExecStep { /// The ExecStepConfig for all Linux VMs targeted by the PatchJob. #[prost(message, optional, tag = "1")] pub linux_exec_step_config: ::core::option::Option, /// The ExecStepConfig for all Windows VMs targeted by the PatchJob. #[prost(message, optional, tag = "2")] pub windows_exec_step_config: ::core::option::Option, } /// Common configurations for an ExecStep. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ExecStepConfig { /// Defaults to \[0\]. A list of possible return values that the /// execution can return to indicate a success. #[prost(int32, repeated, tag = "3")] pub allowed_success_codes: ::prost::alloc::vec::Vec, /// The script interpreter to use to run the script. If no interpreter is /// specified the script will be executed directly, which will likely /// only succeed for scripts with [shebang lines] /// ()). #[prost(enumeration = "exec_step_config::Interpreter", tag = "4")] pub interpreter: i32, /// Location of the executable. #[prost(oneof = "exec_step_config::Executable", tags = "1, 2")] pub executable: ::core::option::Option, } /// Nested message and enum types in `ExecStepConfig`. pub mod exec_step_config { /// The interpreter used to execute the a file. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Interpreter { /// Invalid for a Windows ExecStepConfig. For a Linux ExecStepConfig, the /// interpreter will be parsed from the shebang line of the script if /// unspecified. Unspecified = 0, /// Indicates that the script is run with `/bin/sh` on Linux and `cmd` /// on Windows. Shell = 1, /// Indicates that the file is run with PowerShell flags /// `-NonInteractive`, `-NoProfile`, and `-ExecutionPolicy Bypass`. Powershell = 2, } /// Location of the executable. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Executable { /// An absolute path to the executable on the VM. #[prost(string, tag = "1")] LocalPath(::prost::alloc::string::String), /// A Google Cloud Storage object containing the executable. #[prost(message, tag = "2")] GcsObject(super::GcsObject), } } /// Google Cloud Storage object representation. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GcsObject { /// Required. Bucket of the Google Cloud Storage object. #[prost(string, tag = "1")] pub bucket: ::prost::alloc::string::String, /// Required. Name of the Google Cloud Storage object. #[prost(string, tag = "2")] pub object: ::prost::alloc::string::String, /// Required. Generation number of the Google Cloud Storage object. This is used to /// ensure that the ExecStep specified by this PatchJob does not change. #[prost(int64, tag = "3")] pub generation_number: i64, } /// A filter to target VM instances for patching. The targeted /// VMs must meet all criteria specified. So if both labels and zones are /// specified, the patch job targets only VMs with those labels and in those /// zones. #[derive(Clone, PartialEq, ::prost::Message)] pub struct PatchInstanceFilter { /// Target all VM instances in the project. If true, no other criteria is /// permitted. #[prost(bool, tag = "1")] pub all: bool, /// Targets VM instances matching at least one of these label sets. This allows /// targeting of disparate groups, for example "env=prod or env=staging". #[prost(message, repeated, tag = "2")] pub group_labels: ::prost::alloc::vec::Vec, /// Targets VM instances in ANY of these zones. Leave empty to target VM /// instances in any zone. #[prost(string, repeated, tag = "3")] pub zones: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Targets any of the VM instances specified. Instances are specified by their /// URI in the form `zones/\[ZONE]/instances/[INSTANCE_NAME\]`, /// `projects/\[PROJECT_ID]/zones/[ZONE]/instances/[INSTANCE_NAME\]`, or /// ` #[prost(string, repeated, tag = "4")] pub instances: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Targets VMs whose name starts with one of these prefixes. Similar to /// labels, this is another way to group VMs when targeting configs, for /// example prefix="prod-". #[prost(string, repeated, tag = "5")] pub instance_name_prefixes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Nested message and enum types in `PatchInstanceFilter`. pub mod patch_instance_filter { /// Represents a group of VMs that can be identified as having all these /// labels, for example "env=prod and app=web". #[derive(Clone, PartialEq, ::prost::Message)] pub struct GroupLabel { /// Google Compute Engine instance labels that must be present for a VM /// instance to be targeted by this filter. #[prost(map = "string, string", tag = "1")] pub labels: ::std::collections::HashMap< ::prost::alloc::string::String, ::prost::alloc::string::String, >, } } /// Patch deployments are configurations that individual patch jobs use to /// complete a patch. These configurations include instance filter, package /// repository settings, and a schedule. For more information about creating and /// managing patch deployments, see [Scheduling patch /// jobs](/compute/docs/os-patch-management/schedule-patch-jobs). #[derive(Clone, PartialEq, ::prost::Message)] pub struct PatchDeployment { /// Unique name for the patch deployment resource in a project. The patch /// deployment name is in the form: /// `projects/{project_id}/patchDeployments/{patch_deployment_id}`. /// This field is ignored when you create a new patch deployment. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Optional. Description of the patch deployment. Length of the description is limited /// to 1024 characters. #[prost(string, tag = "2")] pub description: ::prost::alloc::string::String, /// Required. VM instances to patch. #[prost(message, optional, tag = "3")] pub instance_filter: ::core::option::Option, /// Optional. Patch configuration that is applied. #[prost(message, optional, tag = "4")] pub patch_config: ::core::option::Option, /// Optional. Duration of the patch. After the duration ends, the patch times out. #[prost(message, optional, tag = "5")] pub duration: ::core::option::Option<::prost_types::Duration>, /// Output only. Time the patch deployment was created. Timestamp is in /// target="_blank">RFC3339 /// text format. #[prost(message, optional, tag = "8")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. Time the patch deployment was last updated. Timestamp is in /// target="_blank">RFC3339 /// text format. #[prost(message, optional, tag = "9")] pub update_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The last time a patch job was started by this deployment. /// Timestamp is in /// target="_blank">RFC3339 /// text format. #[prost(message, optional, tag = "10")] pub last_execute_time: ::core::option::Option<::prost_types::Timestamp>, /// Schedule for the patch. #[prost(oneof = "patch_deployment::Schedule", tags = "6, 7")] pub schedule: ::core::option::Option, } /// Nested message and enum types in `PatchDeployment`. pub mod patch_deployment { /// Schedule for the patch. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Schedule { /// Required. Schedule a one-time execution. #[prost(message, tag = "6")] OneTimeSchedule(super::OneTimeSchedule), /// Required. Schedule recurring executions. #[prost(message, tag = "7")] RecurringSchedule(super::RecurringSchedule), } } /// Sets the time for a one time patch deployment. Timestamp is in /// target="_blank">RFC3339 /// text format. #[derive(Clone, PartialEq, ::prost::Message)] pub struct OneTimeSchedule { /// Required. The desired patch job execution time. #[prost(message, optional, tag = "1")] pub execute_time: ::core::option::Option<::prost_types::Timestamp>, } /// Sets the time for recurring patch deployments. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RecurringSchedule { /// Required. Defines the time zone that `time_of_day` is relative to. /// The rules for daylight saving time are determined by the chosen time zone. #[prost(message, optional, tag = "1")] pub time_zone: ::core::option::Option, /// Optional. The time that the recurring schedule becomes effective. /// Defaults to `create_time` of the patch deployment. #[prost(message, optional, tag = "2")] pub start_time: ::core::option::Option<::prost_types::Timestamp>, /// Optional. The end time at which a recurring patch deployment schedule is no longer /// active. #[prost(message, optional, tag = "3")] pub end_time: ::core::option::Option<::prost_types::Timestamp>, /// Required. Time of the day to run a recurring deployment. #[prost(message, optional, tag = "4")] pub time_of_day: ::core::option::Option, /// Required. The frequency unit of this recurring schedule. #[prost(enumeration = "recurring_schedule::Frequency", tag = "5")] pub frequency: i32, /// Output only. The time the last patch job ran successfully. #[prost(message, optional, tag = "9")] pub last_execute_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The time the next patch job is scheduled to run. #[prost(message, optional, tag = "10")] pub next_execute_time: ::core::option::Option<::prost_types::Timestamp>, /// Configurations for this recurring schedule. /// Configurations must match frequency. #[prost(oneof = "recurring_schedule::ScheduleConfig", tags = "6, 7")] pub schedule_config: ::core::option::Option, } /// Nested message and enum types in `RecurringSchedule`. pub mod recurring_schedule { /// Specifies the frequency of the recurring patch deployments. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Frequency { /// Invalid. A frequency must be specified. Unspecified = 0, /// Indicates that the frequency should be expressed in terms of /// weeks. Weekly = 1, /// Indicates that the frequency should be expressed in terms of /// months. Monthly = 2, /// Indicates that the frequency should be expressed in terms of /// days. Daily = 3, } /// Configurations for this recurring schedule. /// Configurations must match frequency. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum ScheduleConfig { /// Required. Schedule with weekly executions. #[prost(message, tag = "6")] Weekly(super::WeeklySchedule), /// Required. Schedule with monthly executions. #[prost(message, tag = "7")] Monthly(super::MonthlySchedule), } } /// Represents a weekly schedule. #[derive(Clone, PartialEq, ::prost::Message)] pub struct WeeklySchedule { /// Required. Day of the week. #[prost(enumeration = "super::super::super::r#type::DayOfWeek", tag = "1")] pub day_of_week: i32, } /// Represents a monthly schedule. An example of a valid monthly schedule is /// "on the third Tuesday of the month" or "on the 15th of the month". #[derive(Clone, PartialEq, ::prost::Message)] pub struct MonthlySchedule { /// One day in a month. #[prost(oneof = "monthly_schedule::DayOfMonth", tags = "1, 2")] pub day_of_month: ::core::option::Option, } /// Nested message and enum types in `MonthlySchedule`. pub mod monthly_schedule { /// One day in a month. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum DayOfMonth { /// Required. Week day in a month. #[prost(message, tag = "1")] WeekDayOfMonth(super::WeekDayOfMonth), /// Required. One day of the month. 1-31 indicates the 1st to the 31st day. -1 /// indicates the last day of the month. /// Months without the target day will be skipped. For example, a schedule to /// run "every month on the 31st" will not run in February, April, June, etc. #[prost(int32, tag = "2")] MonthDay(i32), } } /// Represents one week day in a month. An example is "the 4th Sunday". #[derive(Clone, PartialEq, ::prost::Message)] pub struct WeekDayOfMonth { /// Required. Week number in a month. 1-4 indicates the 1st to 4th week of the month. -1 /// indicates the last week of the month. #[prost(int32, tag = "1")] pub week_ordinal: i32, /// Required. A day of the week. #[prost(enumeration = "super::super::super::r#type::DayOfWeek", tag = "2")] pub day_of_week: i32, } /// A request message for creating a patch deployment. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreatePatchDeploymentRequest { /// Required. The project to apply this patch deployment to in the form `projects/*`. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. A name for the patch deployment in the project. When creating a name /// the following rules apply: /// * Must contain only lowercase letters, numbers, and hyphens. /// * Must start with a letter. /// * Must be between 1-63 characters. /// * Must end with a number or a letter. /// * Must be unique within the project. #[prost(string, tag = "2")] pub patch_deployment_id: ::prost::alloc::string::String, /// Required. The patch deployment to create. #[prost(message, optional, tag = "3")] pub patch_deployment: ::core::option::Option, } /// A request message for retrieving a patch deployment. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetPatchDeploymentRequest { /// Required. The resource name of the patch deployment in the form /// `projects/*/patchDeployments/*`. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// A request message for listing patch deployments. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListPatchDeploymentsRequest { /// Required. The resource name of the parent in the form `projects/*`. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Optional. The maximum number of patch deployments to return. Default is 100. #[prost(int32, tag = "2")] pub page_size: i32, /// Optional. A pagination token returned from a previous call to ListPatchDeployments /// that indicates where this listing should continue from. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, } /// A response message for listing patch deployments. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListPatchDeploymentsResponse { /// The list of patch deployments. #[prost(message, repeated, tag = "1")] pub patch_deployments: ::prost::alloc::vec::Vec, /// A pagination token that can be used to get the next page of patch /// deployments. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, } /// A request message for deleting a patch deployment. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeletePatchDeploymentRequest { /// Required. The resource name of the patch deployment in the form /// `projects/*/patchDeployments/*`. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } #[doc = r" Generated client implementations."] pub mod os_config_service_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; #[doc = " OS Config API"] #[doc = ""] #[doc = " The OS Config service is a server-side component that you can use to"] #[doc = " manage package installations and patch jobs for virtual machine instances."] #[derive(Debug, Clone)] pub struct OsConfigServiceClient { inner: tonic::client::Grpc, } impl OsConfigServiceClient where T: tonic::client::GrpcService, T::ResponseBody: Body + Send + 'static, T::Error: Into, ::Error: Into + Send, { pub fn new(inner: T) -> Self { let inner = tonic::client::Grpc::new(inner); Self { inner } } pub fn with_interceptor( inner: T, interceptor: F, ) -> OsConfigServiceClient> where F: tonic::service::Interceptor, T: tonic::codegen::Service< http::Request, Response = http::Response< >::ResponseBody, >, >, >>::Error: Into + Send + Sync, { OsConfigServiceClient::new(InterceptedService::new(inner, interceptor)) } #[doc = r" Compress requests with `gzip`."] #[doc = r""] #[doc = r" This requires the server to support it otherwise it might respond with an"] #[doc = r" error."] pub fn send_gzip(mut self) -> Self { self.inner = self.inner.send_gzip(); self } #[doc = r" Enable decompressing responses with `gzip`."] pub fn accept_gzip(mut self) -> Self { self.inner = self.inner.accept_gzip(); self } #[doc = " Patch VM instances by creating and running a patch job."] pub async fn execute_patch_job( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/ExecutePatchJob", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Get the patch job. This can be used to track the progress of an"] #[doc = " ongoing patch job or review the details of completed jobs."] pub async fn get_patch_job( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/GetPatchJob", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Cancel a patch job. The patch job must be active. Canceled patch jobs"] #[doc = " cannot be restarted."] pub async fn cancel_patch_job( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/CancelPatchJob", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Get a list of patch jobs."] pub async fn list_patch_jobs( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/ListPatchJobs", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Get a list of instance details for a given patch job."] pub async fn list_patch_job_instance_details( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/ListPatchJobInstanceDetails", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Create an OS Config patch deployment."] pub async fn create_patch_deployment( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/CreatePatchDeployment", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Get an OS Config patch deployment."] pub async fn get_patch_deployment( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/GetPatchDeployment", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Get a page of OS Config patch deployments."] pub async fn list_patch_deployments( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/ListPatchDeployments", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Delete an OS Config patch deployment."] pub async fn delete_patch_deployment( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/DeletePatchDeployment", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Create an OS Config guest policy."] pub async fn create_guest_policy( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/CreateGuestPolicy", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Get an OS Config guest policy."] pub async fn get_guest_policy( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/GetGuestPolicy", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Get a page of OS Config guest policies."] pub async fn list_guest_policies( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/ListGuestPolicies", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Update an OS Config guest policy."] pub async fn update_guest_policy( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/UpdateGuestPolicy", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Delete an OS Config guest policy."] pub async fn delete_guest_policy( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/DeleteGuestPolicy", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lookup the effective guest policy that applies to a VM instance. This"] #[doc = " lookup merges all policies that are assigned to the instance ancestry."] pub async fn lookup_effective_guest_policy( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.osconfig.v1beta.OsConfigService/LookupEffectiveGuestPolicy", ); self.inner.unary(request.into_request(), path, codec).await } } }