| # find-owners: Cookbook for OWNERS files |
| |
| For the [find-owners](backend-find-owners.html) backend code owners are defined |
| in `OWNERS` files. This cookbook provides examples of `OWNERS` files for various |
| use cases. |
| |
| **NOTE:** The syntax of `OWNERS` files is described |
| [here](backend-find-owners.html#syntax). |
| |
| ### <a id="defineUsersAsCodeOwners">Define users as code owners |
| |
| To define a set of users as code owners, each user email must be placed in a |
| separate line: |
| |
| ``` |
| jane.roe@example.com |
| john.doe@example.com |
| richard.roe@example.com |
| ``` |
| \ |
| The order of the user emails is not important and doesn't have any effect, but |
| for consistency an alphabetical order is recommended. |
| |
| The listed users own all files that are contained in the directory that contains |
| this `OWNERS` file, except: |
| |
| * files in subdirectories that have an `OWNERS` file that disables inheriting |
| code owners from parent directories via the |
| [set noparent](backend-find-owners.html#setNoparent) file-level rule |
| ([example](#ignoreParentCodeOwners)) |
| * files that are matched by a path expression in a |
| [per-file](backend-find-owners.html#perFile) line that uses |
| [set noparent](backend-find-owners.html#setNoparent) (in this `OWNERS` file or |
| in any `OWNERS` file in a subdirectory, [example](#perFileWithSetNoparent)) |
| |
| In addition to the specified owners the files are also owned by the code owners |
| that are inherited from the parent directories. To prevent this the |
| [set noparent](backend-find-owners.html#setNoparent) file-level rule can be used |
| (see [next example](#ignoreParentCodeOwners)). |
| |
| ### <a id="ignoreParentCodeOwners">Ignore parent code owners |
| |
| To ignore code owners that are defined in the `OWNERS` file of the parent |
| directories the [set noparent](backend-find-owners.html#setNoparent) file-level |
| rule can be used: |
| |
| ``` |
| set noparent |
| jane.roe@example.com |
| john.doe@example.com |
| richard.roe@example.com |
| ``` |
| \ |
| **NOTE:** When the [set noparent](backend-find-owners.html#setNoparent) |
| file-level rule is used you should always define code owners which should be |
| used instead of the code owners from the parent directories. Otherwise the files |
| in the directory stay [without code owners](#noCodeOwners) and nobody can grant |
| code owner approval on them. To [exempt a directory from requiring code owner |
| approvals](#exemptFiles), assign the code ownership to [all |
| users](backend-find-owners.html#allUsers) instead ([example](#exemptFiles)). |
| |
| ### <a id="defineCodeOwnersForAFile">Define code owners for a certain file |
| |
| Using the [per-file](backend-find-owners.html#perFile) restriction prefix it is |
| possible to define code owners for a certain file, e.g. for the `BUILD` file in |
| the current directory: |
| |
| ``` |
| per-file BUILD=tina.toe@example.com |
| ``` |
| \ |
| Multiple code owners for the same file can be specified as comma-separated list: |
| |
| ``` |
| per-file BUILD=tina.toe@example.com,martha.moe@example.com |
| ``` |
| \ |
| Alternatively it's also possible to repeat the per-file line multiple times: |
| |
| ``` |
| per-file BUILD=tina.toe@example.com |
| per-file BUILD=martha.moe@example.com |
| ``` |
| \ |
| If a file is matched by the path expressions of multiple |
| [per-file](backend-find-owners.html#perFile) lines, the file is owned by all |
| users that are mentioned in these [per-file](backend-find-owners.html#perFile) |
| lines. |
| |
| If non-restricted code owners are present, the file is also owned by any |
| non-restricted code owners: |
| |
| ``` |
| jane.roe@example.com |
| john.doe@example.com |
| richard.roe@example.com |
| per-file BUILD=tina.toe@example.com,martha.moe@example.com |
| ``` |
| \ |
| In addition, the file is also owned by code owners that are inherited from |
| parent directories. |
| |
| #### <a id="perFileWithSetNoparent"> |
| Ignoring non-restricted code owners and inherited parent code owners for a file |
| is possible by using a matching [per-file](backend-find-owners.html#perFile) |
| line with [set noparent](backend-find-owners.html#setNoparent). |
| |
| ``` |
| jane.roe@example.com |
| john.doe@example.com |
| richard.roe@example.com |
| per-file BUILD=set noparent |
| per-file BUILD=tina.toe@example.com,martha.moe@example.com |
| ``` |
| \ |
| **NOTE:** When the [set noparent](backend-find-owners.html#setNoparent) rule is |
| used you should always define code owners which should be used instead of the |
| non-restricted code owners and the code owners from the parent directories. |
| Otherwise the matched files stay [without code owners](#noCodeOwners) and nobody |
| can grant code owner approval on them. To [exempt matched files from requiring |
| code owner approvals](#exemptFiles), assign the code ownership to [all |
| users](backend-find-owners.html#allUsers) instead ([example](#exemptFiles)). |
| |
| If files with a given name should be matched in the current directory and all |
| its subdirectories, the [per-file](backend-find-owners.html#perFile) line must |
| have path expression that matches these file: |
| |
| ``` |
| per-file {**/,}BUILD=tina.toe@example.com,martha.moe@example.com |
| ``` |
| \ |
| **NOTE:** The syntax for path expressions / globs is explained |
| [here](path-expressions.html#globs). |
| |
| ### <a id="defineCodeOwnersForAFileType">Define code owners for a certain file type |
| |
| This is the same as [defining code owners for a file](#defineCodeOwnersForAFile) |
| only that the [per-file](backend-find-owners.html#perFile) line must have a path |
| expression that matches all files of the wanted type, e.g. all '*.md' files: |
| |
| ``` |
| per-file *.md=tina.toe@example.com |
| ``` |
| \ |
| To match '*.md' in the current directory and all its subdirectories use: |
| |
| ``` |
| per-file **.md=tina.toe@example.com |
| ``` |
| \ |
| **NOTE:** The syntax for path expressions / globs is explained |
| [here](path-expressions.html#globs). |
| |
| ### <a id="defineCodeOwnersForAllFileInASubdirectory">Define code owners for all files in a subdirectory |
| |
| It is discouraged to use path expressions that explicitly name subdirectories |
| such as `my-subdir/**` as they will break when the subdirectory gets |
| renamed/moved. Instead prefer to define these code owners in `my-subdir/OWNERS` |
| so that the code owners for the subdirectory stay intact when the subdirectory |
| gets renamed/moved. |
| |
| Nontheless, it's possible to define code owners for all files in a subdirectory |
| using a [per-file](backend-find-owners.html#perFile) line. This is the same as |
| [defining code owners for a file](#defineCodeOwnersForAFile) only that the path |
| expression matches all files in the subdirectory: |
| |
| ``` |
| per-file my-subdir/**=tina.toe@example.com |
| ``` |
| |
| ### <a id="defineAGroupAsCodeOwner">Define a group as code owner |
| |
| Groups are not supported in `OWNERS` files and assigning code ownership to them |
| is not possible. |
| |
| Instead of using a group you may define a set of users in an `OWNERS` file with |
| a prefix (`<prefix>_OWNERS`) or an extension (`OWNERS_<extension>`) and then |
| [import](#importOtherOwnersFile) it into other `OWNERS` files via the |
| [file](backend-find-owners.html#fileKeyword) keyword. |
| |
| `/OWNERS_BUILD`: |
| ``` |
| jane.roe@example.com |
| john.doe@example.com |
| richard.roe@example.com |
| per-file BUILD=tina.toe@example.com |
| ``` |
| \ |
| other `OWNERS` file: |
| ``` |
| per-file BUILD=file:/OWNERS_BUILD |
| ``` |
| \ |
| This is equivalent to having: |
| |
| ``` |
| per-file BUILD=jane.roe@example.com,john.doe@example.com,richard.roe@example.com |
| ``` |
| \ |
| **NOTE:** The `per-file` line from `/OWNERS_BUILD` is not imported, since the |
| [file](backend-find-owners.html#fileKeyword) keyword only imports non-restricted |
| code owners. Using the [include](backend-find-owners.html#includeKeyword) |
| keyword, that would also consider per-file code owners, is not supported for |
| `per-file` lines. |
| |
| ### <a id="importOtherOwnersFile">Import code owners from other OWNERS file |
| |
| To import code owners from another `OWNERS` file the |
| [file](backend-find-owners.html#fileKeyword) or |
| [include](backend-find-owners.html#includeKeyword) keyword can be used: |
| |
| `java/com/example/foo/OWNERS`: |
| ``` |
| jane.roe@example.com |
| john.doe@example.com |
| richard.roe@example.com |
| per-file BUILD=tina.toe@example.com |
| ``` |
| \ |
| `javatests/com/example/foo/OWNERS`: |
| ``` |
| file:/java/com/example/foo/OWNERS |
| ``` |
| \ |
| This is equivalent to having: |
| |
| ``` |
| jane.roe@example.com |
| john.doe@example.com |
| richard.roe@example.com |
| ``` |
| \ |
| **NOTE:** The `per-file` line from `java/com/example/foo/OWNERS` is not |
| imported, since the [file](backend-find-owners.html#fileKeyword) keyword only |
| imports non-restricted code owners. If also `per-line` files should be imported |
| the [include](backend-find-owners.html#includeKeyword) keyword can be used |
| instead: |
| |
| `javatests/com/example/foo/OWNERS`: |
| ``` |
| include /java/com/example/foo/OWNERS |
| ``` |
| \ |
| This is equivalent to having: |
| |
| ``` |
| jane.roe@example.com |
| john.doe@example.com |
| richard.roe@example.com |
| per-file BUILD=tina.toe@example.com |
| ``` |
| |
| ### <a id="importFromOtherRepository">Import code owners from other repository |
| |
| To import code owners from an `OWNERS` file in another repository the |
| [file](backend-find-owners.html#fileKeyword) or |
| [include](backend-find-owners.html#includeKeyword) keyword can be used: |
| |
| `/OWNERS` in the `master` branch of respository `my-project`: |
| ``` |
| jane.roe@example.com |
| john.doe@example.com |
| richard.roe@example.com |
| ``` |
| \ |
| `/OWNERS` in the `master` branch of respository `my-project/plugin-foo`: |
| ``` |
| file:my-project:/OWNERS |
| ``` |
| \ |
| This way `my-project/plugin-foo` always has the same code owners as |
| `my-project`. |
| |
| **NOTE:** If a branch is not specified, the `OWNERS` file will always be |
| imported from the same branch, in which the importing `OWNERS` file is stored. |
| If `file:my-project:/OWNERS` is contained in an `OWNERS` file in the `master` |
| branch, `my-project:master:/OWNERS` is imported. If `file:my-project:/OWNERS` is |
| contained in an `OWNERS` file in the `stable-3.5` branch, |
| `my-project:stable-3.5:/OWNERS` is imported. |
| |
| ### <a id="importFromOtherBranch">Import code owners from other branch |
| |
| To import code owners from an `OWNERS` file in another branch the |
| [file](backend-find-owners.html#fileKeyword) or |
| [include](backend-find-owners.html#includeKeyword) keyword can be used: |
| |
| `/OWNERS` in the `master` branch of respository `my-project`: |
| ``` |
| jane.roe@example.com |
| john.doe@example.com |
| richard.roe@example.com |
| ``` |
| \ |
| `/OWNERS` in the `stable-3.5` branch of respository `my-project`: |
| ``` |
| file:my-project:master:/OWNERS |
| ``` |
| \ |
| This way the `stable-3.5` branch of `my-project` always has the same global code |
| owners as the `master` branch of `my-project`. |
| |
| **NOTE:** To import code owners from another branch it is mandatory to specify |
| the repository, even if it is the same repository that contains the importing |
| `OWNERS` file. |
| |
| ### <a id="exemptFiles">Exempt files from requiring code owner approval |
| |
| To exempt files from requiring code owner approval the code ownership can be |
| assigned to [all users](backend-find-owners.html#allUsers) by using '*' as |
| [user email](backend-find-owners.html#userEmails). Assigning the code ownership |
| to all users effectively exempts the directory (or the matches files if used in |
| combination with a [per-file](backend-find-owners.html#perFile) rule) from |
| requiring code owner approvals on submit. This is because a code owner approval |
| from the uploader is always implicit if the uploader is a code owner. |
| |
| `OWNERS` file that exempts the whole directory from requiring code owner |
| approvals: |
| ``` |
| * |
| ``` |
| \ |
| `OWNERS` files that exempts all '*.md' files (in the current directory and all |
| subdirectories) from requiring code owner approvals: |
| ``` |
| per-file **.md=* |
| ``` |
| \ |
| **NOTE:** Files that are not owned by anyone are **not** excluded from requiring |
| code ower approvals, see [next section](#noCodeOwners). |
| |
| ### <a id="noCodeOwners">Avoid that files are not owned by anyone |
| |
| Files that are not owned by anyone cannot be approved since there is no code |
| owner that can grant the approval. Hence submitting modifications to them is |
| only possible with an override approval. |
| |
| Due to this it is recommended to avoid code owner configurations that leave |
| files without code owners, e.g. the following configurations should be avoided: |
| |
| * an `OWNERS` file with only `set noparent` (ignores code owners from parent |
| directories, but doesn't define code owners that should be used instead) |
| * a `per-file` line with only `set noparent` (ignores non-restricted code owners |
| and code owners from parent directories, but doesn't define code owners that |
| should be used instead) |
| * no `OWNERS` file at root level |
| |
| **NOTE:** How to exempt files from requiring code owner approval is described |
| [here](#exemptFiles). |
| |
| --- |
| |
| Back to [@PLUGIN@ documentation index](index.html) |
| |
| Part of [Gerrit Code Review](../../../Documentation/index.html) |