A small csharp project intended to contribute some design ideas around synchronizing contexts and in-memory data stores

.dockerignore

@@ -12,13 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-.git
-
 # Binaries for programs and plugins
 *.exe
 *.exe~
 *.dll
-*.nupkg
 *.so
 *.dylib
 
@@ -33,6 +30,10 @@
 *swo
 *~
 
+# Load testing residuals
+test/stress/*.csv
+test/stress/__pycache__
+
 # Ping data files
 *.ping
 *.pings
@@ -48,8 +49,6 @@ detritus/
 
 # Dotnet Core ignores
 *.swp
-*.pdb
-*.deps.json
 *.*~
 project.lock.json
 .DS_Store
@@ -80,9 +79,6 @@ bld/
 msbuild.log
 msbuild.err
 msbuild.wrn
-csharp/OpenMatch/obj
-Chart.lock
-
 
 # Visual Studio 2015
 .vs/
@@ -105,33 +101,17 @@ install/yaml/
 # Temp Directories
 tmp/
 
-# Terraform context
-.terraform
-*.tfstate
-*.tfstate.backup
-
-# Credential Files
-creds.json
-
 # Open Match Binaries
 cmd/backend/backend
 cmd/frontend/frontend
-cmd/query/query
-cmd/synchronizer/synchronizer
+cmd/mmlogic/mmlogic
+cmd/evaluator/evaluator
 cmd/minimatch/minimatch
-cmd/swaggerui/swaggerui
 tools/certgen/certgen
-examples/demo/demo
-examples/functions/golang/soloduel/soloduel
-test/evaluator/evaluator
-test/matchfunction/matchfunction
-tools/reaper/reaper
+examples/functions/golang/simple/simple
 
 # Open Match Build Directory
 build/
 
 # Secrets Directories
 install/helm/open-match/secrets/
-
-# Helm tar charts
-install/helm/open-match/charts/

.github/CODEOWNERS

@@ -1 +0,0 @@
-* @laremere @aLekSer @HazWard @calebatwd @syntxerror @sawagh @amg84 @scosgrave @mridulji @markmandel @joeholley

.github/ISSUE_TEMPLATE/apichange.md

@@ -1,25 +0,0 @@
----
-name: Breaking API change
-about: Details of a breaking API change proposal.
-title: 'API change: <>'
-labels: breaking api change
-assignees: ''
----
-
-## Overview
-
-<High level description of this change>
-
-## Motivation
-
-<What is the primary motivation for this API change>
-
-## Impact
-
-<What usage does this impact? Add details here such that a consumer of Open
-Match API can clearly tell if this will impact them>
-
-## Change Proto
-
-<Add snippet of the proposed change proto>
-

.github/ISSUE_TEMPLATE/bugreport.md

@@ -1,30 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: kind/bug
-assignees: ''
-
----
-
-<!-- Please use this template while reporting a bug and provide as much info as possible. Not doing so may result in your bug not being addressed in a timely manner. Thanks!
-
-If the matter is security related, please disclose it privately via 
--->
-
-
-**What happened**:
-
-**What you expected to happen**:
-
-**How to reproduce it (as minimally and precisely as possible)**:
-
-**Anything else we need to know?**:
-
-**Output of `kubectl version`**:
-
-**Cloud Provider/Platform (AKS, GKE, Minikube etc.)**: 
-
-**Open Match Release Version**:
-
-**Install Method(yaml/helm)**:

.github/ISSUE_TEMPLATE/featurerequest.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: kind/feature
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/release.md

@@ -1,5 +1,5 @@
 ---
-name: Publish a Release
+name: release
 about: Instructions and checklist for creating a release.
 title: 'Release X.Y.Z-rc.N'
 labels: kind/release
@@ -8,168 +8,153 @@ assignees: ''
 
 # Open Match Release Process
 
-Follow these instructions to create an Open Match release. The output of the
+Follow these instructions to create an Open Match release.  The output of the
 release process is new images and new configuration.
 
 ## Getting setup
 
-**NOTE: The instructions below are NOT strictly copy-pastable and assume 0.5**
-**release. Please update the version number for your commands.**
+*note: the commands below are pasted from the 0.5 release.  make the necessary
+changes to match your naming & environment.*
 
 The Git flow for pushing a new release is similar to the development process
 but there are some small differences.
 
-### 1. Clone Repository
+**1. Clone your fork of the Open Match repository.**
 
 ```shell
-# Clone your fork of the Open Match repository.
 git clone git@github.com:afeddersen/open-match.git
-# Change directory to the git repository.
+```
+**2. Move into the new open-match directory.**
+
+```shell
 cd open-match
-# Add a remote, you'll be pushing to this.
+```
+
+**3. Configure a remote that points to the upstream repository. This is required to sync changes you make in a fork with the original repository.  Note: Upstream is the gatekeeper of the project or the source of truth to which you wish to contribute.**
+
+```shell
 git remote add upstream https://github.com/googleforgames/open-match.git
 ```
 
-### 2. Release Branch
-
-If you're creating the first release of the version, that would be `0.5.0-rc.1`
-then you'll need to create the release branch.
+**3. Fetch the branches and their respective commits from the upstream repo.**
 
 ```shell
-# Create a local release branch.
-git checkout -b release-0.5 upstream/main
-# Push the branch upstream.
-git push upstream release-0.5
+git fetch upstream
 ```
 
-otherwise there should already be a `release-0.5` branch so run,
+**4.  Create a local release branch that tracks upstream and check it out.**
 
 ```shell
-# Checkout the release branch.
 git checkout -b release-0.5 upstream/release-0.5
 ```
 
-**NOTE: The branch name must be in the format, `release-X.Y` otherwise**
-**some artifacts will not be pushed.**
-
 ## Releases & Versions
 
-Open Match uses Semantic Versioning 2.0.0. If you're not familiar please
+
+Open Match uses Semantic Versioning 2.0.0.  If you're not familiar please
 see the documentation - [https://semver.org/](https://semver.org/).
 
 Full Release / Stable Release:
 
-* The final software product. Stable, reliable, etc...
-* Example: 1.0.0, 1.1.0
+* The final software product.  Stable, reliable, etc...
+* Naming example: 1.0.0
 
 Release Candidate (RC):
 
 * A release candidate (RC) is a version with the potential to be the final
   product but it hasn't validated by automated and/or manual tests.
-* Example: 1.0.0-rc.1
+* Naming example: 1.0.0-rc.1
 
 Hot Fixes:
 
 * Code developed to correct a major software bug or fault
   that's been discovered after the full release.
-* Example: 1.0.1
-
-Preview:
-
-* Rare, a one off release cut from the main branch to provide early access
-  to APIs or some other major change.
-* **NOTE: There's no branch for this release.** 
-* Example: 0.5-preview.1
-
-**NOTE: Semantic versioning is enforced by `go mod`. A non-compliant version**
-**tag will cause `go get` to break for users.**
+* Naming example: 1.0.1
 
 # Detailed Instructions
 
+
 ## Find and replace
 
-Below this point you will see {version} used as a placeholder for future
-releases. Find {version} and replace with the current release (e.g. 0.5.0)
 
-## Create a release branch in the upstream open-match repository
+Below this point you will see {version} used as a placeholder for future
+releases.  Find {version} and replace with the current release (e.g. 0.5.0)
+
+## Create a release branch in the upstream repository
+
 
 **Note: This step is performed by the person who starts the release.  It is
 only required once.**
 
 - [ ] Create the branch in the **upstream** repository. It should be named
   release-X.Y. Example: release-0.5. At this point there's effectively a code
-  freeze for this version and all work on main will be included in a future
-  version. If you're on the branch that you created in the *getting setup*
+  freeze for this version and all work on master will be included in a future
+  version.  If you're on the branch that you created in the *getting setup*
   section above you should be able to push upstream.
 
 ```shell
 git push origin release-0.5
 ```
 
-- [ ] Announce a PR freeze on release-X.Y branch on [open-match-discuss@](https://groups.google.com/forum/#!forum/open-match-discuss).
+- [ ] Announce a PR freeze on release-X.Y branch on [open-match-discuss@](mailing-list-post).
 - [ ] Open the [`Makefile`](makefile-version) and change BASE_VERSION entry.
-- [ ] Open the [`install/helm/open-match/Chart.yaml`](om-chart-yaml-version) and change the `appVersion` and `version` entries.
-- [ ] Open the [`install/helm/open-match/values.yaml`](om-values-yaml-version) and change the `tag` entries.
+- [ ] Open the [`install/helm/open-match/Chart.yaml`](om-chart-yaml-version) and [`install/helm/open-match-example/Chart.yaml`](om-example-chart-yaml-version) and change the `appVersion` and `version` entries.
+- [ ] Open the [`install/helm/open-match/values.yaml`](om-values-yaml-version) and [`install/helm/open-match-example/values.yaml`](om-example-values-yaml-version) and change the `tag` entries.
+- [ ] Open the [`site/config.toml`] and change the `release_branch` and `release_version` entries.
 - [ ] Open the [`cloudbuild.yaml`] and change the `_OM_VERSION` entry.
+- [ ] Run `make clean release`
 - [ ] There might be additional references to the old version but be careful not to change it for places that have it for historical purposes.
-- [ ] Update usage requirements in the Installation doc - e.g. supported minikube version, kubectl version, golang version, etc.
-- [ ] Create a PR with the changes, include the release candidate name, and point it to the release branch.
-- [ ] Go to [open-match-build](https://pantheon.corp.google.com/cloud-build/triggers?project=open-match-build) and update all *post submit* triggers' `_GCB_LATEST_VERSION` value to the `X.Y` of the release. This value should only increase as it's used to determine the latest stable version.
-- [ ] Merge your changes once the PR is approved. Note: the helm chart is not published to the public registry until the merge is complete (it's a second cloud build trigger upon merge), so you won't be able to do final release testing until after all checks/approvals are finished!
-
-## Create a release branch in the upstream open-match-docs repository
-- [ ] Open [`Makefile`](makefile-version) and change BASE_VERSION entry.
-- [ ] Open [`cloudbuild.yaml`] and change the `_OM_VERSION` entry.
-- [ ] Open [`site/config.toml`] and change the `release_version` entry.
-- [ ] Open [`site/static/swaggerui/config.json`] and change the `api/VERSION/...` entries
-- [ ] Create a PR with the changes, include the release candidate name, and point it to the release branch.
+- [ ] Create a PR with the changes and include the release candidate name.
+- [ ] Merge your changes once the PR is approved.
 
 ## Complete Milestone
 
-**Note: This step is performed by the person who starts the release. It is
+
+**Note: This step is performed by the person who starts the release.  It is
 only required once.**
 - [ ] Create the next [version milestone](https://github.com/googleforgames/open-match/milestones) and use [semantic versioning](https://semver.org/) when naming it to be consistent with the [Go community](https://blog.golang.org/versioning-proposal).
-- [ ] Create a *draft* [release](https://github.com/googleforgames/open-match/releases).  Note that github has both "Pre-release" and "draft" as different concepts for a release.  Until the release is finalized, only use "Save draft", and do not use "Publish release".
-- [ ] Use the [release template](https://github.com/googleforgames/open-match/blob/main/docs/governance/templates/release.md)
-  - [ ] `Tag = v{version}` (Example: v0.5.0. Append -rc.# for release candidates. Example: v0.5.0-rc.1.)
-  - [ ] `Target = release-X.Y` (Example: release-0.5.)
-  - [ ] `Release Title = v{version}` (Must match `Tag`)
-  - [ ] `Write` section will contain the contents from the [release template](https://github.com/googleforgames/open-match/blob/main/docs/governance/templates/release.md).
-- [ ] Add the milestone to all PRs and issues that were merged since the last milestone. Look at the [releases page](https://github.com/googleforgames/open-match/releases) and look for the "X commits to main since this release" for the diff.
+- [ ] Create a *draft* [release](https://github.com/googleforgames/open-match/releases).
+- [ ] Use the [release template](https://github.com/googleforgames/open-match/blob/master/docs/governance/templates/release.md)
+  - [ ] `Tag` = v{version}. Example: v0.5.0. Append -rc.# for release candidates. Example: v0.5.0-rc.1.
+  - [ ] `Target` = release-X.Y. Example: release-0.5.
+  - [ ] `Release Title` = `Tag`
+  - [ ] `Write` section will contain the contents from the [release template](https://github.com/googleforgames/open-match/blob/master/docs/governance/templates/release.md).
+- [ ] Add the milestone to all PRs and issues that were merged since the last milestone. Look at the [releases page](https://github.com/googleforgames/open-match/releases) and look for the "X commits to master since this release" for the diff.
+- [ ] Review all [milestone-less closed issues](https://github.com/googleforgames/open-match/issues?q=is%3Aissue+is%3Aclosed+no%3Amilestone) and assign the appropriate milestone.
+- [ ] Review all [issues in milestone](https://github.com/googleforgames/open-match/milestones) for proper [labels](https://github.com/googleforgames/open-match/labels) (ex: area/build).
 - [ ] Review all [milestone-less closed PRs](https://github.com/googleforgames/open-match/pulls?q=is%3Apr+is%3Aclosed+no%3Amilestone) and assign the appropriate milestone.
 - [ ] Review all [PRs in milestone](https://github.com/googleforgames/open-match/milestones) for proper [labels](https://github.com/googleforgames/open-match/labels) (ex: area/build).
 - [ ] View all open entries in milestone and move them to a future milestone if they aren't getting closed in time. https://github.com/googleforgames/open-match/milestones/v{version}
 - [ ] Review all closed PRs against the milestone. Put the user visible changes into the release notes using the suggested format. https://github.com/googleforgames/open-match/pulls?utf8=%E2%9C%93&q=is%3Apr+is%3Aclosed+is%3Amerged+milestone%3Av{version}
 - [ ] Review all closed issues against the milestone. Put the user visible changes into the release notes using the suggested format. https://github.com/googleforgames/open-match/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aclosed+milestone%3Av{version}
-- [ ] Verify everything in the [milestone](https://github.com/googleforgames/open-match/milestones) is complete with the exception of the release issue itself.
+- [ ] Verify the [milestone](https://github.com/googleforgames/open-match/milestones) is effectively 100% at this point with the exception of the release issue itself.
 
-## Build And Test Artifacts
+TODO: Add guidelines for labeling issues.
 
-- [ ] Navigate to the [Cloud Console](https://console.cloud.google.com) in a browser and open the [Cloud Build History section](https://console.cloud.google.com/cloud-build/builds?project=open-match-build) and find the latest "Post Submit" build (trigger id: 9a451c7a-197b-4a38-a612-21f4c53c42fd) of the merged commit. The build may still be running, if so wait for it to finish. If it failed, fix the error and repeat this section. Open the build details and click on step 12, "Build: Docker Images". Take note of the docker image version tag near the top of the build log. This is the "{source version tag}" referenced in various commands below. Example: `0.5.0-a4706cb`.
+## Build Artifacts
+
+- [ ] Go to [Cloud Build](https://pantheon.corp.google.com/cloud-build/triggers?project=open-match-build), under Post Submit click "Run Trigger".
+- [ ] Go to the History section and find the "Post Submit" build that's running. Wait for it to go Green. If it's red, fix error repeat this section. Take note of the docker image version tag for next step. Example: 0.5.0-a4706cb.
 - [ ] Run `./docs/governance/templates/release.sh {source version tag} {version}` to copy the images to open-match-public-images.
-- [ ] If this is not a release candidate or preview but a full release, run `./docs/governance/templates/release.sh {source version tag} latest` to tag these public images as the default version to pull from the registry.
-- [ ] Once the images have successfully been pushed to the registry, modify the line `open-match.dev/open-match v0.0.0-dev` in all `go.mod` files in the [Tutorials] (https://github.com/googleforgames/open-match/tree/main/tutorials) directory to use the current release version for the remainder of your local release testing. This includes all solution subdirectories as well. This change is local only and doesn't get committed to git.
-- [ ] Copy the installation files named `{sequence_number}-{component}.yaml` (example: `01-open-match-core.yaml`) from the [build folder in the private open-match-build-artifacts GCS bucket https://storage.mtls.cloud.google.com/open-match-build-artifacts/{version}](https://console.cloud.google.com/storage/browser/open-match-build-artifacts?project=open-match-build) to the release draft you created. Download them to your local machine, and then attach them to the draft using the Github UI. Note: the `05-jaeger.yaml` file no longer exists after release 1.8, so don't be surprised if that number is missing.
-- [ ] Update the [Slack invitation link](https://slack.com/help/articles/201330256-invite-new-members-to-your-workspace#share-an-invite-link) in [open-match.dev](https://open-match.dev/site/docs/contribute/#get-involved).
-- [ ] Test Open Match installation under GKE and Minikube enviroment using the YAML files attached to the release and the latest Helm chart, pulled from the public helm repo (not your local copy from github). Follow the [First Match](https://development.open-match.dev/site/docs/getting-started/first_match/) guide, run `make proxy-demo`, and open `localhost:51507` to make sure everything works.
-  - [ ] Minikube: Run `make create-mini-cluster` to create a local cluster with latest Kubernetes API version.
-  - [ ] GKE: Run `make create-gke-cluster` to create a GKE cluster.
-  - [ ] Helm: Run `helm install open-match -n open-match open-match/open-match`. Note, the helm chart for the release is not public until the PR has been merged, so you cannot complete this step until after the PR is closed and the 'Tagged Build' trigger (trigger ID: 083adc1a-fcac-4033-bc38-b9f6eadcb75d) has completed, which publishes the helm chart.
-
-## Finalize
-
-- [ ] Make sure your release draft reflects all steps up to this point, and is saved (so contributors can review it).
-- [ ] Circulate the draft release to active contributors.  Where reasonable, get everyone's ok on the release notes before continuing.
-- [ ] Publish the [Release](om-release) in Github.  This will notify repository watchers.
-- [ ] Publish the [Release](om-release) on Open Match [Blog](https://open-match.dev/site/blog/).
+- [ ] If this is a new minor version in the newest major version then run `./docs/governance/templates/release.sh {source version tag} latest`.
+- [ ] Copy the files from `build/release/` generated from `make release` to the release draft you created.  You can drag and drop the files using the Github UI.
+- [ ] Run `make REGISTRY=gcr.io/open-match-public-images TAG={version} delete-gke-cluster create-gke-cluster push-helm sleep-10 install-chart install-demo-chart` and verify that the demo runs correctly.
+- [ ] Run `make delete-gke-cluster create-gke-cluster` and run through the instructions under the [README](readme-deploy), verify the pods are healthy. You'll need to adjust the path to the `build/release/install.yaml` and `build/release/install-demo.yaml` in your local clone since you haven't published them yet.
+- [ ] Open the [`README.md`](readme-deploy) update the version references and submit. (Release candidates can ignore this step.)
+- [ ] Publish the [Release](om-release) in Github.
 
 ## Announce
 
-- [ ] Send an email to the [mailing list](https://groups.google.com/forum/#!newtopic/open-match-discuss) with the release details (copy-paste the release blog post)
-- [ ] Send a chat on the [Slack channel](https://open-match.slack.com/). "Open Match {version} has been released! Check it out at {release url}."
+- [ ] Send an email to the [mailing list](mailing-list-post) with the release details (copy-paste the release blog post)
+- [ ] Send a chat on the [Slack channel](om-slack). "Open Match {version} has been released! Check it out at {release url}."
 
-[makefile-version]: https://github.com/googleforgames/open-match/blob/main/Makefile#L53
-[om-chart-yaml-version]: https://github.com/googleforgames/open-match/blob/main/install/helm/open-match/Chart.yaml#L16
-[om-values-yaml-version]: https://github.com/googleforgames/open-match/blob/main/install/helm/open-match/values.yaml#L16
+[om-slack]: https://open-match.slack.com/
+[mailing-list-post]: https://groups.google.com/forum/#!newtopic/open-match-discuss
+[release-template]: https://github.com/googleforgames/open-match/blob/master/docs/governance/templates/release.md
+[makefile-version]: https://github.com/googleforgames/open-match/blob/master/Makefile#L53
+[om-example-chart-yaml-version]: https://github.com/googleforgames/open-match/blob/master/install/helm/open-match/Chart.yaml#L16
+[om-example-values-yaml-version]: https://github.com/googleforgames/open-match/blob/master/install/helm/open-match/values.yaml#L16
+[om-example-chart-yaml-version]: https://github.com/googleforgames/open-match/blob/master/install/helm/open-match-example/Chart.yaml#L16
+[om-example-values-yaml-version]: https://github.com/googleforgames/open-match/blob/master/install/helm/open-match-example/values.yaml#L16
 [om-release]: https://github.com/googleforgames/open-match/releases/new
-[readme-deploy]: https://github.com/googleforgames/open-match/blob/main/README.md#deploy-to-kubernetes
+[readme-deploy]: https://github.com/googleforgames/open-match/blob/master/README.md#deploy-to-kubernetes

.github/pull_request_template.md

@@ -1,16 +0,0 @@
-<!--  Thanks for sending a pull request!  Here are some tips for you:
-If this is your first time, please read our contributor guidelines: https://github.com/googleforgames/open-match/blob/master/CONTRIBUTING.md and developer guide https://github.com/googleforgames/open-match/blob/master/docs/development.md
--->
-
-**What this PR does / Why we need it**:
-
-**Which issue(s) this PR fixes**:
-<!--
-*Automatically closes linked issue when PR is merged.
-Usage: `Closes #<issue number>`, or `Closes (paste link of issue)`.
--->
-Closes #
-
-**Special notes for your reviewer**:
-
-

.gitignore

@@ -16,7 +16,6 @@
 *.exe
 *.exe~
 *.dll
-*.nupkg
 *.so
 *.dylib
 
@@ -31,6 +30,10 @@
 *swo
 *~
 
+# Load testing residuals
+test/stress/*.csv
+test/stress/__pycache__
+
 # Ping data files
 *.ping
 *.pings
@@ -46,8 +49,6 @@ detritus/
 
 # Dotnet Core ignores
 *.swp
-*.pdb
-*.deps.json
 *.*~
 project.lock.json
 .DS_Store
@@ -78,8 +79,6 @@ bld/
 msbuild.log
 msbuild.err
 msbuild.wrn
-csharp/OpenMatch/obj
-Chart.lock
 
 # Visual Studio 2015
 .vs/
@@ -102,29 +101,14 @@ install/yaml/
 # Temp Directories
 tmp/
 
-# Terraform context
-.terraform
-*.tfstate.backup
-
-# Credential Files
-creds.json
-
 # Open Match Binaries
 cmd/backend/backend
 cmd/frontend/frontend
-cmd/query/query
-cmd/synchronizer/synchronizer
+cmd/mmlogic/mmlogic
+cmd/evaluator/evaluator
 cmd/minimatch/minimatch
-cmd/swaggerui/swaggerui
 tools/certgen/certgen
-examples/demo/demo
-examples/functions/golang/soloduel/soloduel
-test/evaluator/evaluator
-test/matchfunction/matchfunction
-tools/reaper/reaper
+examples/functions/golang/simple/simple
 
 # Secrets Directories
 install/helm/open-match/secrets/
-
-# Helm tar charts
-install/helm/open-match/charts/

.golangci.yaml

@@ -16,8 +16,6 @@
 # with their default values.
 
 # https://github.com/golangci/golangci-lint#config-file
-service:
-  golangci-lint-version: 1.18.0
 
 # options for analysis running
 run:
@@ -47,7 +45,7 @@ run:
   # won't be reported. Default value is empty list, but there is
   # no need to include all autogenerated files, we confidently recognize
   # autogenerated files. If it's not please let us know.
-  skip-files: '.*\.gw\.go'
+  skip-files:
 
 # output configuration options
 output:
@@ -73,7 +71,7 @@ linters-settings:
 
   govet:
     # report about shadowed variables
-    check-shadowing: true
+    check-shadowing: false
 
     # settings per analyzer
     settings:
@@ -167,15 +165,18 @@ linters-settings:
 linters:
   enable-all: true
   disable:
+    - goimports
+    - stylecheck
+    - gocritic
     - dupl
-    - funlen
-    - gochecknoglobals
-    - goconst
     - gocyclo
     - gosec
-    - interfacer # deprecated - "A tool that suggests interfaces is prone to bad suggestions"
     - lll
-    - typecheck
+    - staticcheck
+    - scopelint
+    - prealloc
+    - gofmt
+    - interfacer # deprecated - "A tool that suggests interfaces is prone to bad suggestions"
 
 #linters:
 #  enable-all: true
@@ -190,11 +191,32 @@ issues:
 
   # Excluding configuration per-path, per-linter, per-text and per-source
   exclude-rules:
-    # Exclude some linters from running on test files
+    - path: internal[/\\]config[/\\]
+      linters:
+        - gochecknoglobals
+    # Exclue some linters from running on test files
     - path: _test\.go
       linters:
         - errcheck
-        - bodyclose
+    # The following are allowed global variable patterns.
+    # Generally it's ok to have constants or variables that effectively act as constants such as a static logger or flag values.
+    # The filters below specify the source code pattern that's allowed when declaring a global
+    # 'source: "flag."' will match 'var destFlag = flag.String("dest", "", "")'
+    - source: "flag."
+      linters:
+        - gochecknoglobals
+    - source: "View."
+      linters:
+        - gochecknoglobals
+    - source: "tag."
+      linters:
+        - gochecknoglobals
+    - source: "logrus."
+      linters:
+        - gochecknoglobals
+    - source: "stats."
+      linters:
+        - gochecknoglobals
 
     # Exclude known linters from partially hard-vendored code,
     # which is impossible to exclude via "nolint" comments.

CHANGELOG.md

@@ -0,0 +1,60 @@
+# Release history
+
+## v0.4.0 (alpha)
+
+### Release notes
+- Thanks to completion of Issues [#42](issues/42) and [#45](issues/45), there is no longer a need to use the `openmatch-base` image when building components of Open Match.  Each stand alone appliation now is self-contained in its `Dockerfile` and `cloudbuild.yaml` files, and builds have been substantially simplified.  **Note**: The default `Dockerfile` and `cloudbuild.yaml` now tag their images with the version number, not `dev`, and the YAML files in the `install` directory now reflect this.
+ - This paves the way for CI/CD in an upcoming version.  
+ - This paves the way for public images in an upcoming version!
+
+## v0.3.0 (alpha)
+  This update is focused on the Frontend API and Player Records, including more robust code for indexing, deindexing, reading, writing, and expiring player requests from Open Match state storage.  All Frontend API function argument have changed, although many only slightly. Please join the [Slack channel](https://open-match.slack.com/) if you need help ([Signup link](https://join.slack.com/t/open-match/shared_invite/enQtNDM1NjcxNTY4MTgzLWQzMzE1MGY5YmYyYWY3ZjE2MjNjZTdmYmQ1ZTQzMmNiNGViYmQyN2M4ZmVkMDY2YzZlOTUwMTYwMzI1Y2I2MjU))!
+
+### Release notes
+- The Frontend API calls have all be changed to reflect the fact that they operate on Players in state storage.  To queue a game client, 'CreatePlayer' in Open Match, to get updates 'GetUpdates', and to stop matching, 'DeletePlayer'. The calls are now much more obviously related to how Open Match sees players: they are database records that it creates on demand, updates using MMFs and the Backend API, and deletes when the player is no longer looking for a match.  
+- The Player record in state storage has changed to a more complete hash format, and it no longer makes sense to remove a player's assignment from the Frontend as a separate action to removing their record entirely.  `DeleteAssignment()` has therefore been removed.  Just use `DeletePlayer` instead; you'll always want the client to re-request matching with its latest attributes anyway.
+- There is now a module for [indexing and deindexing players in state storage](internal/statestorage/redis/playerindices/playerindices.go).  This is a *much* more efficient, as well as being cleaner and more maintainable than the previous implementation which was **hard-coded to index everything** you passed in to the Frontend API at a specific JSON object depth.
+    - This paves the way for dynamically choosing your indicies without restarting the matchmaker.  This will be implemented if there is demand.  Pull Requests are welcome!
+    - Two internal timestamp-based indices have replaced the previous `timestamp` index. `created` is used to calculate how long a player has been waiting for a match, `accessed` is used to determine when a player needs to be expired out of state storage.  Both are prefixed by the string `OM_METADATA` so it should be easy to spot them.
+- A call to the Frontend API `GetUpdates()` gRPC endpoint returns a stream of player messages. This is used to send updates to state storage for the `Assignment`, `Status`, and `Error` Player fields in near-realtime. **It is the responsibility of the game client to disconnect** from the stream when it has gotten the results it was waiting for!
+- Moved the rest of the gRPC messages into a shared [`messages.proto` file](api/protobuf-spec/messages.proto).
+- Added documentation to Frontend API gRPC calls to the [`frontend.proto` file](api/protobuf-spec/frontend.proto).
+- [Issue #41](https://github.com/googleforgames/open-match/issues/41)|[PR #48](https://github.com/googleforgames/open-match/pull/48) There is now a HA Redis install available in `install/yaml/01-redis-failover.yaml`.  This would be used as a drop-in replacement for a single-instance Redis configuration in `install/yaml/01-redis.yaml`.  The HA configuration requires that you install the [Redis Operator](https://github.com/spotahome/redis-operator) (note: **currently alpha**, use at your own risk) in your Kubernetes cluster.
+    - As part of this change, the kubernetes service name is now `redis` not `redis-sentinel` to denote that it is accessed using a standard Redis client.
+- Open Match uses a new feature of the go module [logrus](github.com/sirupsen/logrus) to include filenames and line numbers.  If you have an older version in your local build environment, you may need to delete the module and `go get github.com/sirupsen/logrus` again.  When building using the provided `cloudbuild.yaml` and `Dockerfile`s this is handled for you.
+- The program that was formerly in `examples/frontendclient` has been expanded and has been moved to the `test` directory under (`test/cmd/frontendclient/`)[test/cmd/frontendclient/].
+- The client load generator program has been moved from `test/cmd/client` to (`test/cmd/clientloadgen/`)[test/cmd/clientloadgen/] to better reflect what it does.
+- [Issue #45](https://github.com/googleforgames/open-match/issues/45) The process for moving the build files (`Dockerfile` and `cloudbuild.yaml`) for each component, example, and test program to their respective directories and out of the repository root has started but won't be completed until a future version.
+- Put some basic notes in the [production guide](docs/production.md)
+- Added a basic [roadmap](docs/roadmap.md)
+
+## v0.2.0 (alpha)
+  This is a pretty large update.  Custom MMFs or evaluators from 0.1.0 may need some tweaking to work with this version. Some Backend API function arguments have changed. Please join the [Slack channel](https://open-match.slack.com/) if you need help ([Signup link](https://join.slack.com/t/open-match/shared_invite/enQtNDM1NjcxNTY4MTgzLWQzMzE1MGY5YmYyYWY3ZjE2MjNjZTdmYmQ1ZTQzMmNiNGViYmQyN2M4ZmVkMDY2YzZlOTUwMTYwMzI1Y2I2MjU))!
+
+  v0.2.0 focused on adding additional functionality to Backend API calls and on **reducing the amount of boilerplate code required to make a custom Matchmaking Function**.  For this, a new internal API for use by MMFs called the [Matchmaking Logic API (MMLogic API)](README.md#matchmaking-logic-mmlogic-api) has been added.  Many of the core components and examples had to be updated to use the new Backend API arguments and the modules to support them, so we recommend you rebuild and redeploy all the components to use v0.2.0. 
+
+### Release notes
+- MMLogic API is now available.  Deploy it to kubernetes using the [appropriate json file]() and check out the [gRPC API specification](api/protobuf-spec/mmlogic.proto) to see how to use it.  To write a client against this API, you'll need to compile the protobuf files to your language of choice. There is an associated cloudbuild.yaml file and Dockerfile for it in the root directory.
+    - When using the MMLogic API to filter players into pools, it will attempt to report back the number of players that matched the filters and how long the filters took to query state storage.
+    - An [example MMF](examples/functions/python3/mmlogic-simple/harness.py) using it has been written in Python3. There is an associated cloudbuild.yaml file and Dockerfile for it in the root directory. By default the [example backend client](examples/backendclient/main.go) is now configured to use this MMF, so make sure you have it avaiable before you try to run the latest backend client.
+    - An [example MMF](examples/functions/php/mmlogic-simple/harness.py) using it has been contributed by Ilya Hrankouski in PHP (thanks!).   - The API specs have been split into separate files per API and the protobuf messages are in a separate file.  Things were renamed slightly as a result, and you will need to update your API clients. The Frontend API hasn't had it's messages moved to the shared messages file yet, but this will happen in an upcoming version.
+    - The [example golang MMF](examples/functions/golang/manual-simple/) has been updated to use the latest data schemas for MatchObjects, and renamed to `manual-simple` to denote that it is manually manipulating Redis, not using the MMLogic API.
+    - The API specs have been split into separate files per API and the protobuf messages are in a separate file.  Things were renamed slightly as a result, and you will need to update your API clients. The Frontend API hasn't had it's messages moved to the shared messages file yet, but this will happen in an upcoming version.
+- The message model for using the Backend API has changed slightly - for calls that make MatchObjects, the expectation is that you will provide a MatchObject with a few fields populated, and it will then be shuttled along through state storage to your MMF and back out again, with various processes 'filling in the blanks' of your MatchObject, which is then returned to your code calling the Backend API.  Read the[gRPC API specification](api/protobuf-spec/backend.proto) for more information.
+    - As part of this, compiled protobuf golang modules now live in the [`internal/pb`](internal/pb) directory.  There's a handy [bash script](api/protoc-go.sh) for compiling them from the `api/protobuf-spec` directory into this new `internal/pb` directory for development in your local golang environment if you need it.  
+    - As part of this Backend API message shift and the advent of the MMLogic API, 'player pools' and 'rosters' are now first-class data structures in MatchObjects for those who wish to use them. You can ignore them if you like, but if you want to use some of the MMLogic API calls to automate tasks for you - things like filtering a pool of players according attributes or adding all the players in your rosters to the ignorelist so other MMFs don't try to grab them - you'll need to put your data into the [protobuf messages](api/protobuf-spec/messages.proto) so Open Match knows how to read them.  The sample backend client [test profile JSON](examples/backendclient/profiles/testprofile.json)has been updated to use this format if you want to see an example.
+- Rosters were formerly space-delimited lists of player IDs.  They are now first-class repeated protobuf message fields in the [Roster message format](api/protobuf-spec/messages.proto). That means that in most languages, you can access the roster as a list of players using your native language data structures (more info can be found in the [guide for using protocol buffers in your langauge of choice](https://developers.google.com/protocol-buffers/docs/reference/overview)).  If you don't care about the new fields or the new functionality, you can just leave all the other fields but the player ID unset.
+ - Open Match is transitioning to using [protocol buffer messages](https://developers.google.com/protocol-buffers/) as its internal data format. There is now a Redis state storage [golang module](internal/statestorage/redis/redispb/) for marshaling and unmarshaling MatchObject messages to and from Redis. It isn't very clean code right now but will get worked on for the next couple releases.
+ - Ignorelists now exist, and have a Redis state storage [golang module](internal/statestorage/redis/ignorelist/) for CRUD access.  Currently three ignorelists are defined in the [config file](config/matchmaker_config.json) with their respective parameters. These are implemented as [Sorted Sets in Redis](https://redis.io/commands#sorted_set).
+ - For those who only want to stand up Open Match and aren't interested in individually tweaking the required kubernetes resources, there are now [three YAML files](install/yaml) that can be used to install Redis, install Open Match, and (optionally) install Prometheus. You'll still need the `sed` [instructions from the Developer Guide](docs/development.md#running-open-match-in-a-development-environment) to substitute in the name of your Docker container registry.
+ - A super-simple module has been created for doing instersections, unions, and differences of lists of player IDs.  It lives in `internal/set/set.go`.  
+
+
+### Roadmap 
+- It has become clear from talking to multiple users that the software they write to talk to the Backend API needs a name.  'Backend API Client' is technically correct, but given how many APIs are in Open Match and the overwhelming use of 'Client' to refer to a Game Client in the industry, we're currently calling this a 'Director', as its primary purpose is to 'direct' which profiles are sent to the backend, and 'direct' the resulting MatchObjects to game servers.  Further discussion / suggestions are welcome.
+- We'll be entering the design stage on longer-running MMFs before the end of the year. We'll get a proposal together and on the github repo as a request for comments, so please keep your eye out for that.
+- Match profiles providing multiple MMFs to run isn't planned anymore.  Just send multiple copies of the profile with different MMFs specified via the backendapi. 
+- Redis Sentinel will likely not be supported.  Instead, replicated instances and HAProxy may be the HA solution of choice. There's an [outstanding issue to investigate and implement](https://github.com/googleforgames/open-match/issues/41) if it fills our needs, feel free to contribute!
+
+## v0.1.0 (alpha)
+ Initial release.

CS_SyncContext/CS_SyncContext.sln

@@ -0,0 +1,22 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Logic", "Logic\Logic.csproj", "{1EF89BE7-709C-420A-9FDE-6AED2D0FBF2E}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Data", "Data\Data.csproj", "{0687300A-A514-43FE-924C-29E9203EBD50}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{1EF89BE7-709C-420A-9FDE-6AED2D0FBF2E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1EF89BE7-709C-420A-9FDE-6AED2D0FBF2E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1EF89BE7-709C-420A-9FDE-6AED2D0FBF2E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1EF89BE7-709C-420A-9FDE-6AED2D0FBF2E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0687300A-A514-43FE-924C-29E9203EBD50}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0687300A-A514-43FE-924C-29E9203EBD50}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0687300A-A514-43FE-924C-29E9203EBD50}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0687300A-A514-43FE-924C-29E9203EBD50}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

CS_SyncContext/Data/Data.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netcoreapp2.1</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
+    </ItemGroup>
+
+</Project>

CS_SyncContext/Data/Filter.cs

@@ -0,0 +1,32 @@
+using System;
+
+namespace Data
+{
+    /// <summary>
+    /// A generic range-based filter for querying data in ITicketData
+    /// </summary>
+    public class Filter
+    {
+        public Filter(string key, double min, double max)
+        {
+            Key = key;
+            Min = min;
+            Max = max;
+        }
+
+        /// <summary>
+        /// The attribute to query
+        /// </summary>
+        public string Key { get; set; }
+
+        /// <summary>
+        /// The minimum value [inclusive] of the range 
+        /// </summary>
+        public double Min { get; set; }
+
+        /// <summary>
+        /// The maximum value [exclusive] of the range 
+        /// </summary>
+        public double Max { get; set; }
+    }
+}

CS_SyncContext/Data/ITicketData.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Data
+{
+    /// <summary>
+    /// An interface for creating, deleting, querying, and updating ticket information
+    /// </summary>
+    public interface ITicketData
+    {
+        /// <summary>
+        /// Marks the provided ticket ids as ignorable in queries for a period of time
+        /// </summary>
+        /// <param name="ticketIds">The ticket ids to be ignored by queries</param>
+        /// <param name="durationMs"></param>
+        Task AwaitingAssignmentAsync(IEnumerable<Guid> ticketIds, long durationMs);
+
+        /// <summary>
+        /// Populates the assignment field of the target tickets
+        /// </summary>
+        /// <param name="ticketIds">A list of ticket ids to be assigned</param>
+        /// <param name="assignment">A string containing the assignment of the tickets</param>
+        /// <returns></returns>
+        Task AssignTicketsAsync(IEnumerable<Guid> ticketIds, string assignment);
+
+        /// <summary>
+        /// Executes a collection of queries on the ticket data and returns the union of the results
+        /// </summary>
+        /// <param name="query">The query to execute</param>
+        /// <returns>A collection of tickets union of the results</returns>
+        Task<IEnumerable<Ticket>> QueryTicketsAsync(Query query);
+
+        /// <summary>
+        /// Creates a ticket and adds it to the ticket datastore
+        /// </summary>
+        /// <param name="ticket">The ticket to create</param>
+        /// <remarks>This may create indexes for the data in the ticket to make it queryable</remarks>
+        Task CreateTicketAsync(Ticket ticket);
+
+        /// <summary>
+        /// Returns a ticket by id
+        /// </summary>
+        /// <param name="id">The id of the ticket</param>
+        /// <returns>The requested ticket if it exists</returns>
+        Task<Ticket> GetTicketAsync(Guid id);
+
+        /// <summary>
+        /// Deletes a ticket by id
+        /// </summary>
+        /// <param name="id">The id of the ticket</param>
+        /// <remarks>This may delete indexes for the data in the ticket</remarks>
+        Task DeleteTicketAsync(Guid id);
+    }
+}

CS_SyncContext/Data/MemoryData.cs

@@ -0,0 +1,202 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Data
+{
+    public class MemoryData : ITicketData
+    {
+        private const string awaitingIndex = "awaitingAssignment";
+
+        private const string createdIndex = "created";
+
+        protected ConcurrentDictionary<Guid, Ticket> m_Tickets = new ConcurrentDictionary<Guid, Ticket>();
+
+        protected ConcurrentDictionary<string, SortedDictionary<Guid, double>> m_Indexes = new ConcurrentDictionary<string, SortedDictionary<Guid, double>>();
+
+        public Task AssignTicketsAsync(IEnumerable<Guid> ticketIds, string assignment)
+        {
+            foreach (var ticketId in ticketIds)
+            {
+                Ticket ticket = m_Tickets[ticketId];
+                RemoveTicketIndexes(ticket);
+                ticket.Assignment = assignment;
+            }
+
+            return Task.CompletedTask;
+        }
+
+        public Task AwaitingAssignmentAsync(IEnumerable<Guid> ticketIds, long durationMs)
+        {
+            long unixNowMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+            AddOrCreateIndex(ticketIds, new KeyValuePair<string, double>(awaitingIndex, unixNowMs + durationMs));
+            return Task.CompletedTask;
+        }
+
+        public Task<IEnumerable<Ticket>> QueryTicketsAsync(Query query)
+        {
+            // Validate the query
+            if (query.Filters == null || query.Filters.Count < 1) throw new ArgumentException("Must specify at least 1 filter");
+            
+            // Get a copy of the indexes and tickets
+            Dictionary<string, SortedDictionary<Guid, double>> indexes = new Dictionary<string, SortedDictionary<Guid, double>>();
+            foreach (var keyValueIndex in m_Indexes)
+            {
+                lock (keyValueIndex.Value)
+                {
+                    indexes.Add(keyValueIndex.Key, new SortedDictionary<Guid, double>(keyValueIndex.Value));
+                }
+            }
+
+            List<List<Guid>> hits = new List<List<Guid>>();
+            foreach (var filter in query.Filters)
+            {
+                if (indexes.ContainsKey(filter.Key))
+                {
+                    IEnumerable<Guid> hit = indexes[filter.Key]
+                        .Where(i => i.Value >= filter.Min && i.Value <= filter.Max)
+                        .Select(k => k.Key);
+                    hits.Add(hit.ToList());
+                }
+            }
+
+            List<Guid> pool = hits.FirstOrDefault();
+            if (pool == null)
+                return Task.FromResult<IEnumerable<Ticket>>(new List<Ticket>());
+
+            for (int i = 1; i < hits.Count; i++)
+            {
+                pool = pool.Intersect(hits[i]).ToList();
+            }
+
+            // Built-in ignore index
+            if (indexes.ContainsKey(awaitingIndex))
+            {
+                long unixNowMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+                IEnumerable<Guid> ignore = indexes[awaitingIndex].Where(i => i.Value >= unixNowMs).Select(k => k.Key);
+                pool = pool.Except(ignore).ToList(); // TODO: the list is ordered and except doesn't take advantage of that
+            }
+
+            List<Ticket> ticketList = new List<Ticket>();
+            foreach (var guid in pool)
+            {
+                ticketList.Add(m_Tickets[guid]);
+            }
+
+            return Task.FromResult<IEnumerable<Ticket>>(ticketList);
+        }
+
+        public Task CreateTicketAsync(Ticket ticket)
+        {
+            // Validate the ticket
+            if (ticket == null) throw new ArgumentNullException(nameof(ticket));
+            if (ticket.Attributes == null) throw new ArgumentNullException(paramName: "ticketAttributes");
+            if (ticket.Attributes.Count == 0) throw new ArgumentException("There must be at least 1 attribute to index", paramName: "ticketAttributes");
+            
+            Ticket newTicket = new Ticket()
+            {
+                Id = ticket.Id,
+                Attributes = new Dictionary<string, double>(ticket.Attributes),
+                Properties = ticket.Properties,
+                Created = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                Assignment = string.IsNullOrEmpty(ticket.Assignment) ? string.Empty : ticket.Assignment
+            };
+
+            AddTicketIndexes(newTicket);
+            m_Tickets.TryAdd(newTicket.Id, newTicket);
+            return Task.CompletedTask;
+        }
+
+        public Task<Ticket> GetTicketAsync(Guid id)
+        {
+            if (m_Tickets.TryGetValue(id, out Ticket ticket))
+            {
+                return Task.FromResult(ticket);
+            }
+
+            throw new Exception("Not Found");
+        }
+
+        public Task DeleteTicketAsync(Guid id)
+        {
+            Ticket ticket = m_Tickets[id];
+            RemoveTicketIndexes(ticket);
+            m_Tickets.TryRemove(id, out ticket);
+            return Task.CompletedTask;
+        }
+
+        private void AddTicketIndexes(Ticket ticket)
+        {
+            foreach (var attribute in ticket.Attributes)
+            {
+                AddOrCreateIndex(ticket.Id, attribute);
+            }
+
+            // Built-in indexes
+            AddOrCreateIndex(ticket.Id, new KeyValuePair<string, double>(createdIndex, ticket.Created));
+        }
+
+        /// <summary>
+        /// The bulk version for reducing locks when updating lots of records at once with the same attribute
+        /// </summary>
+        private void AddOrCreateIndex(IEnumerable<Guid> ids, KeyValuePair<string, double> attribute)
+        {
+            if (!m_Indexes.ContainsKey(attribute.Key))
+            {
+                m_Indexes.TryAdd(attribute.Key, new SortedDictionary<Guid, double>());
+            }
+
+            lock (m_Indexes[attribute.Key])
+            {
+                foreach (var id in ids)
+                {
+                    m_Indexes[attribute.Key].Add(id, attribute.Value);
+                }
+            }
+        }
+
+        private void AddOrCreateIndex(Guid id, KeyValuePair<string, double> attribute)
+        {
+            if (m_Indexes.ContainsKey(attribute.Key))
+            {
+                lock (m_Indexes[attribute.Key])
+                {
+                    m_Indexes[attribute.Key].Add(id, attribute.Value);
+                }
+            }
+            else
+            {
+                m_Indexes.TryAdd(attribute.Key, new SortedDictionary<Guid, double>() { { id, attribute.Value } });
+            }
+        }
+
+        private void RemoveTicketIndexes(Ticket ticket)
+        {
+            foreach (var attribute in ticket.Attributes)
+            {
+                DeleteIndex(ticket.Id, attribute.Key);
+            }
+        }
+
+        private void DeleteIndex(Guid id, string attributeKey)
+        {
+            if (m_Indexes.ContainsKey(attributeKey))
+            {
+                lock (m_Indexes[attributeKey])
+                {
+                    m_Indexes[attributeKey].Remove(id);
+                }
+            }
+        }
+
+        public async Task CreateTicketsAsync(IEnumerable<Ticket> tickets)
+        {
+            foreach (var ticket in tickets)
+            {
+                await CreateTicketAsync(ticket);
+            }
+        }
+    }
+}

CS_SyncContext/Data/Query.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+
+namespace Data
+{
+    /// <summary>
+    /// Captures a searching behavior for ITicketData 
+    /// </summary>
+    public class Query
+    {
+        public Query()
+        {
+
+        }
+
+        public Query(List<Filter> filters)
+        {
+            Filters = filters;
+        }
+        /// <summary>
+        /// A list of hard filters to be applied to the provided searchable attributes
+        /// </summary>
+        public List<Filter> Filters { get; set; }
+    }
+}

CS_SyncContext/Data/Ticket.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
+
+namespace Data
+{
+    /// <summary>
+    /// Intended to be used as a data model abstraction for handling groups of players organized into indexable tickets
+    /// </summary>
+    public class Ticket
+    {
+        /// <summary>
+        /// The identifier of the ticket tracked by clients
+        /// </summary>
+        public Guid Id { get; set; }
+        
+        /// <summary>
+        /// A contract for allowing a backend to provide assignment information
+        /// </summary>
+        public string Assignment { get; set; }
+        
+        /// <summary>
+        /// Range indexes
+        /// </summary>
+        public IDictionary<string, double> Attributes { get; set; }
+
+        /// <summary>
+        /// The milliseconds in unix utc representing when this ticket was created
+        /// </summary>
+        public long Created {get;set;}
+        
+        /// <summary>
+        /// Custom data provided by the ticket creator
+        /// </summary>
+        public JObject Properties { get; set; }
+    }
+}

CS_SyncContext/Logic/FunctionClientResolver.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Net.Http;
+using Data;
+using Logic.InternalContracts;
+using Microsoft.Extensions.Logging;
+
+namespace Logic
+{
+    public class FunctionClientResolver
+    {
+        readonly HttpClient m_HttpClient;
+
+        ILoggerFactory m_LoggerFactory;
+
+        public FunctionClientResolver(IServiceProvider serviceProvider, HttpClient httpClient, ITicketData ticketData, ILoggerFactory loggerFactory)
+        {
+            m_HttpClient = httpClient;
+            m_LoggerFactory = loggerFactory;
+        }
+
+        public IFunctionClient GetFunctionClientByTarget(TargetFunction target)
+        {
+            switch (target.Kind)
+            {
+                case FunctionKind.Rest:
+                    return new FunctionRestClient(m_HttpClient, target, m_LoggerFactory.CreateLogger<FunctionRestClient>());
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+    }
+}

CS_SyncContext/Logic/FunctionRestClient.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Logic.InternalContracts;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+
+namespace Logic
+{
+    public class FunctionRestClient : IFunctionClient
+    {
+        HttpClient m_Client;
+
+        string m_Address;
+
+        ILogger<FunctionRestClient> m_Log;
+
+        public FunctionRestClient(HttpClient client, TargetFunction targetFunction, ILogger<FunctionRestClient> log)
+        {
+            m_Log = log;
+            m_Client = client;
+            IPHostEntry dns = Dns.GetHostEntry(targetFunction.Name);
+            m_Address = dns.AddressList[0].ToString();
+        }
+
+        public async Task<IEnumerable<Match>> RunAsync(MatchSpec spec, CancellationToken cancellationToken)
+        {
+            FunctionRestParams context = new FunctionRestParams()
+            {
+                Pools = new List<Pool>(),
+                Config = spec.Config
+            };
+
+            foreach (var specPool in spec.Pools)
+            {
+                context.Pools.Add(new Pool() { Name = specPool.Key, Filters = specPool.Value });
+            }
+
+            string json = JsonConvert.SerializeObject(context);
+            string url = "http://" + m_Address + ":8080" + "/api/function";
+            m_Log.LogDebug("Calling {Url} with body {Body}", url, json);
+
+            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, url);
+            request.Content = new StringContent(json);
+            request.Content.Headers.Clear();
+            request.Content.Headers.Add("Content-Type", "application/json");
+
+            HttpResponseMessage message = await m_Client.SendAsync(request, cancellationToken);
+            if (!message.IsSuccessStatusCode)
+            {
+                m_Log.LogWarning("{StatusCode} received from function {Url}. {Reason}", message.StatusCode, m_Address, message.ReasonPhrase);
+            }
+
+            string body = await message.Content.ReadAsStringAsync();
+
+            return JsonConvert.DeserializeObject<List<Match>>(body);
+        }
+    }
+}

CS_SyncContext/Logic/IEvaluator.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Logic.InternalContracts;
+
+namespace Logic
+{
+    public interface IEvaluator
+    {
+        Task<List<Match>> Evaluate(List<Match> Matches);
+    }
+}

CS_SyncContext/Logic/IFunctionClient.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Logic.InternalContracts;
+
+namespace Logic
+{
+    public interface IFunctionClient
+    {
+        Task<IEnumerable<Match>> RunAsync(MatchSpec config, CancellationToken cancellationToken);
+    }
+}

CS_SyncContext/Logic/IMatchmakingBackend.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Logic.InternalContracts;
+
+namespace Logic
+{
+    public interface IMatchmakingBackend
+    {
+        Task<List<Match>> GetMatchesAsync(List<MatchSpec> matchSpecs, CancellationToken cancellationToken);
+    }
+}

CS_SyncContext/Logic/InternalContracts/FunctionRestParams.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
+
+namespace Logic.InternalContracts
+{
+    public class FunctionRestParams
+    {
+        public JObject Config { get; set; }
+
+        public List<Pool> Pools { get; set; }
+    }
+}

CS_SyncContext/Logic/InternalContracts/Match.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using Data;
+using Newtonsoft.Json.Linq;
+
+namespace Logic.InternalContracts
+{
+    public class Match
+    {
+        public Guid Id { get; set; }
+        
+        public List<Ticket> Tickets { get; set; }
+        
+        public JObject Properties { get; set; }
+    }
+}

CS_SyncContext/Logic/InternalContracts/MatchSpec.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using Data;
+using Newtonsoft.Json.Linq;
+
+namespace Logic.InternalContracts
+{
+    public class MatchSpec
+    {
+        public TargetFunction Target { get; set; }
+        
+        public JObject Config { get; set; }
+        
+        public IDictionary<string, List<Filter>> Pools { get; set; }
+    }
+}

CS_SyncContext/Logic/InternalContracts/Pool.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using Data;
+
+namespace Logic.InternalContracts
+{
+    /// <summary>
+    /// A generalized matchmaking "hard" filtering description. Consists of sets of filters
+    /// </summary>
+    public class Pool
+    {
+        /// <summary>
+        /// A friendly name identifier for the pool
+        /// </summary>
+        public string Name { get; set; }
+        
+        /// <summary>
+        /// The collection of generic filters for performing query logic
+        /// </summary>
+        public List<Filter> Filters { get; set; }
+    }
+}

CS_SyncContext/Logic/InternalContracts/TargetFunction.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace Logic.InternalContracts
+{
+    public class TargetFunction
+    {
+        public string Name { get; set; }
+
+        public string Version { get; set; }
+
+        public FunctionKind Kind { get; set; }
+    }
+    
+    public enum FunctionKind
+    {
+        None,
+        Rest,
+        Grpc,
+        Memory
+    }
+}

CS_SyncContext/Logic/Logic.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netcoreapp2.1</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Data\Data.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="2.2.0" />
+      <PackageReference Include="Microsoft.Extensions.Options" Version="2.2.0" />
+    </ItemGroup>
+
+</Project>

CS_SyncContext/Logic/MatchmakingBackend.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Data;
+using Logic.InternalContracts;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json.Linq;
+
+namespace Logic
+{
+    public class MatchmakingBackend : IMatchmakingBackend
+    {
+        ITicketData m_TicketData;
+
+        SynchronizationContext m_SyncContext;
+        
+        ILogger<MatchmakingBackend> m_Logger;
+
+        FunctionClientResolver m_FunctionClientResolver;
+        
+        public MatchmakingBackend(ITicketData ticketData, ILogger<MatchmakingBackend> logger, FunctionClientResolver resolver, SynchronizationContext syncContext)
+        {
+            m_TicketData = ticketData;
+            m_Logger = logger;
+            m_FunctionClientResolver = resolver;
+            m_SyncContext = syncContext;
+        }
+
+        public async Task<List<Match>> GetMatchesAsync(List<MatchSpec> matchSpecs, CancellationToken cancellationToken)
+        {
+            // Generate a cancellation time for all the functions. TODO: Make the global timeout configurable
+            CancellationToken token = AddTimeCancellationToken(cancellationToken, 60000);
+            Guid contextRegistrationId = await m_SyncContext.AcquireContext();
+
+            // Execute functions in parallel
+            Stopwatch watch = Stopwatch.StartNew();
+            List<Task<IEnumerable<Match>>> tasks = new List<Task<IEnumerable<Match>>>();
+            foreach (var matchSpec in matchSpecs)
+            {
+                IFunctionClient client = m_FunctionClientResolver.GetFunctionClientByTarget(matchSpec.Target);
+                m_Logger.LogInformation("Running target {Target} as {Kind}", matchSpec.Target.Name, matchSpec.Target.Kind);
+                tasks.Add(Task.Run(() => client.RunAsync(matchSpec, token)));
+            }
+
+            // Wait for all the Matches to come back in
+            List<Match> Matches = (await Task.WhenAll(tasks)).SelectMany(r => r.AsEnumerable()).ToList();
+            m_Logger.LogInformation("Function run time {ElapsedMs}ms. Submitting {MatchCount} Matches for evaluation.", watch.ElapsedMilliseconds, Matches.Count);
+            watch.Restart();
+
+            // Send the Matches to the evaluator, which will automatically synchronize the Matches
+            List<Match> goodMatches = await m_SyncContext.EvaluateAsync(contextRegistrationId, Matches);
+            m_Logger.LogDebug("Evaluator waiting time {ElapsedMs}ms", watch.ElapsedMilliseconds);
+
+            // Tell the data api so it can start de-indexing those players
+            List<Match> matches = new List<Match>();
+            foreach (var Match in goodMatches)
+            {
+                matches.Add(new Match()
+                {
+                    Properties = JObject.FromObject(Match.Properties),
+                    Tickets = Match.Tickets,
+                    // MatchSpec = null TODO: Maybe re-associate the original matchSpec
+                });
+            }
+
+            return matches;
+        }
+        
+        static CancellationToken AddTimeCancellationToken(CancellationToken token, int ms)
+        {
+            CancellationTokenSource cts = new CancellationTokenSource(ms);
+            return CancellationTokenSource.CreateLinkedTokenSource(token, cts.Token).Token;
+        }
+    }
+}

CS_SyncContext/Logic/ScoreEvaluator.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Logic.InternalContracts;
+using Microsoft.Extensions.Logging;
+
+namespace Logic
+{
+    /// <summary>
+    /// A Match de-collider takes non-colliding Matches in descending score order
+    /// </summary>
+    public class ScoreEvaluator : IEvaluator
+    {
+        ILogger<ScoreEvaluator> m_Log { get; }
+
+        public ScoreEvaluator(ILogger<ScoreEvaluator> log)
+        {
+            m_Log = log;
+        }
+
+        public Task<List<Match>> Evaluate(List<Match> Matches)
+        {
+            m_Log.LogDebug("{MatchCount} Matches to be evaluated", Matches.Count);
+
+            // Sort the Matches by score
+            Matches = Matches.OrderByDescending(p => p.Properties["score"]).ToList();
+
+            List<Match> goodMatches = new List<Match>();
+            HashSet<Guid> ticketsPresent = new HashSet<Guid>();
+            foreach (var nextMatch in Matches)
+            {
+                // Optimize by converting the prop tickets to a hashset
+                var propTickets = nextMatch.Tickets.Select(t => t.Id).ToHashSet();
+
+                // Check if any of the tickets in the Match are already spoken for
+                if (ticketsPresent.Overlaps(propTickets))
+                    continue;
+
+                // If not, the Match is a good match and mark the tickets as spoken for
+                goodMatches.Add(nextMatch);
+                foreach (var ticketId in propTickets)
+                {
+                    ticketsPresent.Add(ticketId);
+                }
+            }
+
+            m_Log.LogDebug("{MatchesApproved} Matches approved in evaluation. {TicketsApproved} tickets approved", goodMatches.Count, ticketsPresent.Count);
+
+            return Task.FromResult(goodMatches);
+        }
+    }
+}

CS_SyncContext/Logic/SynchronizationContext.cs

@@ -0,0 +1,252 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Data;
+using Logic.InternalContracts;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace Logic
+{
+    /// <summary>
+    /// A threadsafe way to run an evaluator. Intended to be used as a singleton, or shared context behind a service
+    /// </summary>
+    public class SynchronizationContext
+    {
+        int m_MinRunMs;
+
+        int m_MaxRunMs;
+
+        ITicketData m_TicketData;
+
+        IEvaluator m_Evaluator;
+
+        ILogger<SynchronizationContext> m_Logger;
+
+        ConcurrentDictionary<Guid, List<Match>> m_ContextMatches = new ConcurrentDictionary<Guid, List<Match>>();
+
+        ConcurrentDictionary<Guid, List<Guid>> m_ContextResults = new ConcurrentDictionary<Guid, List<Guid>>();
+
+        ConcurrentDictionary<Guid, bool> m_ExistingContexts = new ConcurrentDictionary<Guid, bool>();
+
+        ManualResetEvent m_NewContextsAvailable = new ManualResetEvent(false);
+
+        ManualResetEvent m_ResultsAvailable = new ManualResetEvent(false);
+
+        bool m_AcceptingMatches = false;
+
+        Timer m_Timer;
+
+        Stopwatch m_Watch = new Stopwatch();
+
+        Task m_EvalTask = null;
+
+        SyncState m_State = SyncState.NotRunning;
+        
+        object startLock = new object();
+
+        enum SyncState
+        {
+            NotRunning,
+            AcceptingContexts,
+            AcceptingMatches,
+            Evaluating
+        }
+
+        public SynchronizationContext(ILogger<SynchronizationContext> logger, ITicketData ticketData, IEvaluator evaluator, IOptions<SynchronizationOptions> options)
+        {
+            m_Logger = logger;
+            m_MinRunMs = options.Value.MinWindowSizeMs;
+            m_MaxRunMs = options.Value.MaxWindowSizeMs;
+            m_Evaluator = evaluator;
+            m_TicketData = ticketData;
+
+            // TODO: Make the loop event schedulable instead of loop driven
+            m_Timer = new Timer(
+                UpdateState,
+                new AutoResetEvent(true),
+                options.Value.StateMachineUpdateMs,
+                options.Value.StateMachineUpdateMs
+            );
+        }
+
+        /// <summary>
+        /// Thread safe way to acquire a contextId and register for the evaluator
+        /// </summary>
+        /// <returns>A contextId</returns>
+        public async Task<Guid> AcquireContext()
+        {
+            Stopwatch watch = Stopwatch.StartNew();
+            Guid contextId = await WaitRegisterContextAsync();
+            m_Logger.LogDebug("{ElapsedMs}ms to acquire context", watch.ElapsedMilliseconds);
+            return contextId;
+        }
+
+        /// <summary>
+        /// Thread safe way to let the evaluator de-collide the passed in Matches with other contexts
+        /// </summary>
+        /// <param name="contextId">The id of this context</param>
+        /// <param name="Matches">Matches to de-collide</param>
+        /// <returns>A list of de-collided Matches</returns>
+        /// <exception cref="Exception"></exception>
+        public async Task<List<Match>> EvaluateAsync(Guid contextId, List<Match> Matches)
+        {
+            Stopwatch watch = Stopwatch.StartNew();
+
+            // Try to register the Matches with the machine
+            if (TryRegisterMatches(contextId, Matches))
+            {
+                m_Logger.LogDebug("{ElapsedMs}ms to register Matches", watch.ElapsedMilliseconds);
+                watch.Restart();
+
+                // Wait for the machine to run and return my results
+                List<Guid> good = await WaitResultsAsync(contextId);
+                m_Logger.LogDebug("{ElapsedMs}ms evaluation results available", watch.ElapsedMilliseconds);
+                List<Match> goodMatches = new List<Match>();
+                foreach (var prop in Matches)
+                {
+                    if (good.Contains(prop.Id))
+                    {
+                        goodMatches.Add(prop);
+                    }
+                }
+
+                return goodMatches;
+            }
+
+            throw new Exception("Match registration failed");
+        }
+
+        /// <summary>
+        /// Attempt to wait for context acquisition to become available and register for one. If the evaluator
+        /// is not running, it will set the state machine into a runnable state
+        /// </summary>
+        /// <returns></returns>
+        private Task<Guid> WaitRegisterContextAsync()
+        {
+            // If the machine isn't started, try to start it
+            if (m_State == SyncState.NotRunning)
+            {
+                lock(startLock)
+                {
+                    // Make sure this call got the lock in time, otherwise bail
+                    if (m_State == SyncState.NotRunning)
+                    {
+                        // The machine isn't running so clear the current results, any registrations, and any Matches
+                        m_ContextResults.Clear();
+                        m_ExistingContexts.Clear();
+                        m_ContextMatches.Clear();
+
+                        // Allow new contexts to register, allow new Matches, and disallow results reading
+                        m_State = SyncState.AcceptingContexts;
+                        m_NewContextsAvailable.Set();
+                        m_ResultsAvailable.Reset();
+                        m_AcceptingMatches = true;
+                        m_Watch = Stopwatch.StartNew();
+                    }
+                }
+            }
+
+            m_NewContextsAvailable.WaitOne(5000); // TODO: Make this wait timeout automated
+            Guid newId = Guid.NewGuid();
+            m_ExistingContexts.TryAdd(newId, false);
+            return Task.FromResult(newId);
+        }
+
+        private Task<List<Guid>> WaitResultsAsync(Guid contextId)
+        {
+            m_ResultsAvailable.WaitOne(5000); // TODO: Make this wait timeout automated
+            return Task.FromResult(m_ContextResults[contextId]);
+        }
+
+        private bool TryRegisterMatches(Guid contextId, List<Match> Matches)
+        {
+            if (!m_ExistingContexts.ContainsKey(contextId)) return false;
+            if (!m_AcceptingMatches) return false;
+
+            m_ExistingContexts[contextId] = true;
+            m_ContextResults.TryAdd(contextId, new List<Guid>());
+
+            return m_ContextMatches.TryAdd(contextId, Matches);
+        }
+
+        private void UpdateState(object state)
+        {
+            switch (m_State)
+            {
+                case SyncState.NotRunning:
+                    break;
+                case SyncState.AcceptingContexts:
+                    if (m_Watch.ElapsedMilliseconds > m_MinRunMs)
+                    {
+                        m_Logger.LogDebug("Min window passed at {ElapsedMs}ms", m_Watch.ElapsedMilliseconds);
+                        m_State = SyncState.AcceptingMatches;
+                        m_NewContextsAvailable.Reset();
+                        UpdateState(state); // Just go ahead and check the accepting state
+                    }
+
+                    break;
+                case SyncState.AcceptingMatches:
+                    bool maxWindowExceeded = m_Watch.ElapsedMilliseconds > m_MaxRunMs;
+                    bool allIn = m_ExistingContexts.Values.All(b => b);
+                    if (m_Watch.ElapsedMilliseconds > m_MaxRunMs || m_ExistingContexts.Values.All(b => b))
+                    {
+                        if (maxWindowExceeded) m_Logger.LogDebug("Max window exceeded. Moving to eval at {ElapsedMs}ms", m_Watch.ElapsedMilliseconds);
+                        if (allIn) m_Logger.LogDebug("All contexts reported in. Moving to eval at {ElapsedMs}ms", m_Watch.ElapsedMilliseconds);
+                        m_State = SyncState.Evaluating;
+                        m_AcceptingMatches = false;
+                        m_EvalTask = Task.Run(async () =>
+                        {
+                            // Run the evaluator in parallel to this state system
+                            await RunEvaluation(m_Evaluator);
+
+                            // Once done, clear the other threads to read from the results. Set the machine back to doing nothing
+                            m_State = SyncState.NotRunning;
+                            m_ResultsAvailable.Set();
+                            m_Logger.LogDebug("Evaluation completed at {ElapsedMs}ms", m_Watch.ElapsedMilliseconds);
+                            m_Watch.Reset();
+                        });
+                    }
+
+                    break;
+                case SyncState.Evaluating:
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        private async Task RunEvaluation(IEvaluator evaluator)
+        {
+            // Create a reverse map of context to Match (to rebuild the results at the end)
+            Dictionary<Guid, Guid> MatchIdToContextId = new Dictionary<Guid, Guid>();
+            List<Match> allMatches = new List<Match>();
+            foreach (var contextMatch in m_ContextMatches)
+            {
+                foreach (var Match in contextMatch.Value)
+                {
+                    allMatches.Add(Match);
+                    MatchIdToContextId.Add(Match.Id, contextMatch.Key);
+                }
+            }
+
+            // Run the evaluator
+            List<Match> matches = await evaluator.Evaluate(allMatches);
+
+            // Flag the selected tickets as un-queryable for a set period of time. // TODO: Make configurable
+            List<Guid> ticketsTaken = matches.SelectMany(m => m.Tickets.Select(t => t.Id)).ToList();
+            await m_TicketData.AwaitingAssignmentAsync(ticketsTaken, 60000);
+
+            // Put the match results into the proper results context. TODO: Failure handled good enough by unqueryable timeout?
+            foreach (var match in matches)
+            {
+                Guid contextId = MatchIdToContextId[match.Id];
+                m_ContextResults[contextId].Add(match.Id);
+            }
+        }
+    }
+}

CS_SyncContext/Logic/SynchronizationOptions.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace Logic
+{
+    public class SynchronizationOptions
+    {
+        public const string SectionName = "SynchronizationOptions";
+        
+        public int MinWindowSizeMs { get; set; }
+        
+        public int MaxWindowSizeMs { get; set; }
+        
+        public int StateMachineUpdateMs { get; set; }
+    }
+}

Dockerfile.base-build

@@ -12,16 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# When updating Go version, update Dockerfile.ci, Dockerfile.base-build, and go.mod
-FROM golang:1.21.0
+FROM golang:latest
+ENV GO111MODULE=on
 
 WORKDIR /go/src/open-match.dev/open-match
-
-# First copy only the go.sum and go.mod then download dependencies. Docker
-# caching is [in]validated by the input files changes.  So when the dependencies
-# for the project don't change, the previous image layer can be re-used.  go.sum
-# is included as its hashing verifies the expected files are downloaded.
-COPY go.sum go.mod ./
+COPY . .
 RUN go mod download
 
-COPY . .

Dockerfile.ci

@@ -11,65 +11,45 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-FROM debian:bookworm
 
-# set env vars
-ARG DEBIAN_FRONTEND=noninteractive
-ENV OPEN_MATCH_CI_MODE=1
-ENV KUBECONFIG=$HOME/.kube/config
-ENV GOPATH=/go
-ENV PATH=$GOPATH/bin:/usr/local/go/bin:$PATH
+FROM debian
 
-RUN apt-get update -y \
- && apt-get install -y -qq --no-install-recommends \
-            apt-utils \
-            git \
-            make \
-            python3 \
-            virtualenv \
-            curl \
-            sudo \
-            unzip \
-            apt-transport-https \
-            ca-certificates \
-            curl \
-            software-properties-common \
-            gnupg2 \
-            libc6 \
-            build-essential
-RUN mkdir -p /usr/share/keyrings/
+RUN apt-get update
+RUN apt-get install -y -qq git make python3 virtualenv curl sudo unzip apt-transport-https ca-certificates curl software-properties-common gnupg2
 
 # Docker
-RUN echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/debian bookworm stable" | tee -a /etc/apt/sources.list.d/docker.list \
- && curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /usr/share/keyrings/docker.gpg \
- && apt-get update -y \ 
- && apt-get install -y -qq \
-            docker-ce \
-            docker-ce-cli \
-            containerd.io
+RUN curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
+RUN sudo apt-key fingerprint 0EBFCD88
+RUN  sudo add-apt-repository \
+   "deb [arch=amd64] https://download.docker.com/linux/debian \
+   stretch \
+   stable"
+RUN sudo apt-get update
+RUN sudo apt-get install -y -qq docker-ce docker-ce-cli containerd.io
 
 # Cloud SDK
-RUN echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] http://packages.cloud.google.com/apt cloud-sdk main" | tee -a /etc/apt/sources.list.d/google-cloud-sdk.list \
- && curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key --keyring /usr/share/keyrings/cloud.google.gpg add - \
- && apt-get update -y \
- && apt-get install -y -qq \
-            google-cloud-cli \
-            google-cloud-sdk-gke-gcloud-auth-plugin
+RUN export CLOUD_SDK_REPO="cloud-sdk-stretch" && \
+    echo "deb http://packages.cloud.google.com/apt $CLOUD_SDK_REPO main" | tee -a /etc/apt/sources.list.d/google-cloud-sdk.list && \
+    curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add - && \
+    apt-get update -y && apt-get install google-cloud-sdk google-cloud-sdk-app-engine-go -y -qq
 
 # Install Golang
+# https://github.com/docker-library/golang/blob/fd272b2b72db82a0bd516ce3d09bba624651516c/1.12/stretch/Dockerfile
+
 RUN mkdir -p /toolchain/golang
 WORKDIR /toolchain/golang
-RUN rm -rf /usr/local/go/
+RUN sudo rm -rf /usr/local/go/
+RUN curl -L https://storage.googleapis.com/golang/go1.12.1.linux-amd64.tar.gz | sudo tar -C /usr/local -xz
 
-# When updating Go version, update Dockerfile.ci, Dockerfile.base-build, and go.mod
-# reference: https://github.com/docker-library/golang/blob/master/1.20/bookworm/Dockerfile
-RUN curl -L https://golang.org/dl/go1.21.0.linux-amd64.tar.gz | tar -C /usr/local -xz
-RUN mkdir -p "$GOPATH/src" "$GOPATH/bin" \
- && chmod -R 777 "$GOPATH"
+ENV GOPATH /go
+ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH
+
+RUN sudo mkdir -p "$GOPATH/src" "$GOPATH/bin" \
+  && sudo chmod -R 777 "$GOPATH"
+
+# Prepare toolchain and workspace
+RUN mkdir -p /toolchain
+RUN mkdir -p /workspace
 
-# Prepare toolchain, workspace, homedir
-RUN mkdir -p \
-    /toolchain \
-    /workspace \
-    $HOME/.kube/
 WORKDIR /workspace
+ENV ALLOW_BUILD_WITH_SUDO=1

Dockerfile.cmd

@@ -1,62 +0,0 @@
-# Copyright 2019 Google LLC
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-FROM open-match-base-build as builder
-
-WORKDIR /go/src/open-match.dev/open-match
-
-ARG IMAGE_TITLE
-
-RUN --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=cache,target=/root/.cache/go-build \
-    make "build/cmd/${IMAGE_TITLE}"
-
-FROM gcr.io/distroless/static:nonroot
-ARG IMAGE_TITLE
-WORKDIR /app/
-
-COPY --from=builder --chown=nonroot "/go/src/open-match.dev/open-match/build/cmd/${IMAGE_TITLE}/" "/app/"
-
-ENTRYPOINT ["/app/run"]
-
-# Docker Image Arguments
-ARG BUILD_DATE
-ARG VCS_REF
-ARG BUILD_VERSION
-
-# Standardized Docker Image Labels
-# https://github.com/opencontainers/image-spec/blob/master/annotations.md
-LABEL \
-    org.opencontainers.image.created="${BUILD_TIME}" \
-    org.opencontainers.image.authors="Google LLC <open-match-discuss@googlegroups.com>" \
-    org.opencontainers.image.url="https://open-match.dev/" \
-    org.opencontainers.image.documentation="https://open-match.dev/site/docs/" \
-    org.opencontainers.image.source="https://github.com/googleforgames/open-match" \
-    org.opencontainers.image.version="${BUILD_VERSION}" \
-    org.opencontainers.image.revision="1" \
-    org.opencontainers.image.vendor="Google LLC" \
-    org.opencontainers.image.licenses="Apache-2.0" \
-    org.opencontainers.image.ref.name="" \
-    org.opencontainers.image.title="${IMAGE_TITLE}" \
-    org.opencontainers.image.description="Flexible, extensible, and scalable video game matchmaking." \
-    org.label-schema.schema-version="1.0" \
-    org.label-schema.build-date=$BUILD_DATE \
-    org.label-schema.url="http://open-match.dev/" \
-    org.label-schema.vcs-url="https://github.com/googleforgames/open-match" \
-    org.label-schema.version=$BUILD_VERSION \
-    org.label-schema.vcs-ref=$VCS_REF \
-    org.label-schema.vendor="Google LLC" \
-    org.label-schema.name="${IMAGE_TITLE}" \
-    org.label-schema.description="Flexible, extensible, and scalable video game matchmaking." \
-    org.label-schema.usage="https://open-match.dev/site/docs/"

README.md

@@ -1,4 +1,4 @@
-![Open Match](https://github.com/googleforgames/open-match-docs/blob/master/site/static/images/logo-with-name.png)
+![Open Match](site/static/images/logo-with-name.png)
 
 [![GoDoc](https://godoc.org/open-match.dev/open-match?status.svg)](https://godoc.org/open-match.dev/open-match)
 [![Go Report Card](https://goreportcard.com/badge/open-match.dev/open-match)](https://goreportcard.com/report/open-match.dev/open-match)
@@ -6,27 +6,23 @@
 [![GitHub release](https://img.shields.io/github/release-pre/googleforgames/open-match.svg)](https://github.com/googleforgames/open-match/releases)
 [![Follow on Twitter](https://img.shields.io/twitter/follow/Open_Match.svg?style=social&logo=twitter)](https://twitter.com/intent/follow?screen_name=Open_Match)
 
-Open Match is an open source game matchmaking framework that simplifies building
-a scalable and extensible Matchmaker. It is designed to give the game developer
-full control over how to make matches while removing the burden of dealing with
-the challenges of running a production service at scale.
+Open Match is a flexible, extensible, and scalable game matchmaking framework.
 
-Please visit [Open Match website](https://open-match.dev/site/docs/) for user
-documentation, demo instructions etc.
+Open Match replaces the complex plumbing parts of matchmaking and allows you to
+focus on the details of making a good match based on your game.
 
-## Contributing to Open Match
+## Disclaimer
 
-Open Match is in active development and we would love your contribution! Please
-read the [contributing guide](CONTRIBUTING.md) for guidelines on contributing to
-Open Match.
+This software is currently alpha, and subject to change. Although Open Match has
+already been used to run [production workloads within Google](https://cloud.google.com/blog/topics/inside-google-cloud/no-tricks-just-treats-globally-scaling-the-halloween-multiplayer-doodle-with-open-match-on-google-cloud).
 
-The [Open Match Development guide](docs/development.md) has detailed instructions
-on getting the source code, making changes, testing and submitting a pull request
-to Open Match.
+## Usage
+
+Documentation can be found on the [Open Match website](https://open-match.dev/site/docs/).
 
 ## Support
 
-* [Slack Channel](https://open-match.slack.com/) ([Signup](https://join.slack.com/t/open-match/shared_invite/zt-5k57lph3-Oe0WdatzL32xv6tPG3PfzQ))
+* [Slack Channel](https://open-match.slack.com/) ([Signup](https://join.slack.com/t/open-match/shared_invite/enQtNDM1NjcxNTY4MTgzLWQzMzE1MGY5YmYyYWY3ZjE2MjNjZTdmYmQ1ZTQzMmNiNGViYmQyN2M4ZmVkMDY2YzZlOTUwMTYwMzI1Y2I2MjU))
 * [File an Issue](https://github.com/googleforgames/open-match/issues/new)
 * [Mailing list](https://groups.google.com/forum/#!forum/open-match-discuss)
 
@@ -34,6 +30,27 @@ to Open Match.
 
 Participation in this project comes under the [Contributor Covenant Code of Conduct](code-of-conduct.md)
 
+## Documentation
+
+Here are some useful links to additional documentation:
+
+* [Get Started](https://open-match.dev/site/docs/installation/)
+* [Development Guide](docs/development.md)
+* [Future Roadmap](docs/roadmap.md)
+* [Open Match Concepts](docs/concepts.md)
+* [Open Match Integrations](docs/integrations.md)
+* [References](docs/references.md)
+
+For more information on the technical underpinnings of Open Match you can refer to the [docs/](docs/) directory.
+
+## Contributing
+
+Please read the [contributing](CONTRIBUTING.md) guide for directions on submitting Pull Requests to Open Match.
+
+See the [Development guide](docs/development.md) for documentation for development and building Open Match from source.
+
+Open Match is in active development - we would love your help in shaping its future!
+
 ## License
 
 Apache 2.0

api/README.md

@@ -6,10 +6,4 @@ gRPC has first-class support for [many languages](https://grpc.io/docs/) and pro
 
 For HTTP/HTTPS Open Match uses a gRPC proxy to serve the API. Since HTTP does not provide a structure for request/responses we use Swagger to provide a schema. You can view the Swagger docs for each service in this directory's `*.swagger.json` files. In addition each server will host it's swagger doc via `GET /swagger.json` if you want to dynamically load them at runtime.
 
-Lastly, Open Match supports insecure and TLS mode for serving the API. It's strongly preferred to use TLS mode in production but insecure mode can be used for test and local development. To help with certificates management see `tools/certgen` to create self-signed certificates.
-
-# Open Match API Development Guide
-
-Open Match proto comments follow the same format as [this file](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/example/example.proto)
-
-If you plan to change the proto definitions, please update the comments and run `make api/api.md` to reflect the latest changes in open-match-docs.
+Lastly, Open Match supports insecure and TLS mode for serving the API. It's strongly preferred to use TLS mode in production but insecure mode can be used for test and local development. To help with certificates management see `tools/certgen` to create self-signed certificates.

api/backend.proto

@@ -13,15 +13,14 @@
 // limitations under the License.
 
 syntax = "proto3";
-package openmatch;
-option go_package = "open-match.dev/open-match/pkg/pb";
-option csharp_namespace = "OpenMatch";
+package api;
+option go_package = "internal/pb";
 
 import "api/messages.proto";
 import "google/api/annotations.proto";
-import "protoc-gen-openapiv2/options/annotations.proto";
+import "protoc-gen-swagger/options/annotations.proto";
 
-option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
+option (grpc.gateway.protoc_gen_swagger.options.openapiv2_swagger) = {
   info: {
     title: "Backend"
     version: "1.0"
@@ -55,114 +54,73 @@ option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
   // https://github.com/grpc-ecosystem/grpc-gateway/blob/master/examples/proto/examplepb/a_bit_of_everything.proto
 };
 
-// FunctionConfig specifies a MMF address and client type for Backend to establish connections with the MMF
-message FunctionConfig {
+// Configuration for a GRPC Match Function
+message GrpcFunctionConfig {
   string host = 1;
   int32 port = 2;
-  Type type = 3;
-  enum Type {
-    GRPC = 0;
-    REST = 1;
+}
+
+// Configuration for a REST Match Function.
+message RestFunctionConfig {
+  string host = 1;
+  int32 port = 2;
+}
+
+// Configuration for the Match Function to be triggered by Open Match to
+// generate proposals.
+message FunctionConfig {
+  // A developer-chosen human-readable name for this Match Function.
+  string name = 1;
+
+  // Properties for the type of this function.
+  oneof type {
+    GrpcFunctionConfig grpc = 10001;
+    RestFunctionConfig rest = 10002;
   }
 }
 
 message FetchMatchesRequest {
-  // A configuration for the MatchFunction server of this FetchMatches call.
+  // Configuration of the MatchFunction to be executed for the given list of MatchProfiles
   FunctionConfig config = 1;
 
-  // A MatchProfile that will be sent to the MatchFunction server of this FetchMatches call.
-  MatchProfile profile = 2;
+  // MatchProfiles for which this MatchFunction should be executed.
+  repeated MatchProfile profile = 2;
 }
 
 message FetchMatchesResponse {
-  // A Match generated by the user-defined MMF with the specified MatchProfiles.
-  // A valid Match response will contain at least one ticket.
+  // Result Match for the requested MatchProfile.
   Match match = 1;
 }
 
-message ReleaseTicketsRequest{
-  // TicketIds is a list of string representing Open Match generated Ids to be re-enabled for MMF querying
-  // because they are no longer awaiting assignment from a previous match result
-  repeated string ticket_ids = 1;
-}
+message AssignTicketsRequest {
+  // List of Ticket IDs for which the Assignment is to be made.
+  repeated string ticket_id = 1;
 
-message ReleaseTicketsResponse {}
-
-message ReleaseAllTicketsRequest{}
-
-message ReleaseAllTicketsResponse {}
-
-// AssignmentGroup contains an Assignment and the Tickets to which it should be applied. 
-message AssignmentGroup {
-  // TicketIds is a list of strings representing Open Match generated Ids which apply to an Assignment.
-  repeated string ticket_ids = 1;
-
-  // An Assignment specifies game connection related information to be associated with the TicketIds.
+  // Assignment to be associated with the Ticket IDs.
   Assignment assignment = 2;
 }
 
-// AssignmentFailure contains the id of the Ticket that failed the Assignment and the failure status.
-message AssignmentFailure {
-  enum Cause {
-    UNKNOWN = 0;
-    TICKET_NOT_FOUND = 1;
-  }
+message AssignTicketsResponse {}
 
-  string ticket_id = 1;
-  Cause cause = 2;
-}
-
-message AssignTicketsRequest {
-  // Assignments is a list of assignment groups that contain assignment and the Tickets to which they should be applied.
-  repeated AssignmentGroup assignments = 1;
-}
-
-message AssignTicketsResponse {
-  // Failures is a list of all the Tickets that failed assignment along with the cause of failure. 
-  repeated AssignmentFailure failures = 1;
-}
-
-// The BackendService implements APIs to generate matches and handle ticket assignments.
-service BackendService {
-  // FetchMatches triggers a MatchFunction with the specified MatchProfile and
-  // returns a set of matches generated by the Match Making Function, and
-  // accepted by the evaluator.
-  // Tickets in matches returned by FetchMatches are moved from active to
-  // pending, and will not be returned by query.
+// The service implementing the Backent API that is called to generate matches
+// and make assignments for Tickets.
+service Backend {
+  // FetchMatch triggers execution of the specfied MatchFunction for each of the
+  // specified MatchProfiles. Each MatchFunction execution returns a set of
+  // proposals which are then evaluated to generate results. FetchMatch method
+  // streams these results back to the caller.
   rpc FetchMatches(FetchMatchesRequest) returns (stream FetchMatchesResponse) {
     option (google.api.http) = {
-      post: "/v1/backendservice/matches:fetch"
+      post: "/v1/backend/matches:fetch"
       body: "*"
     };
   }
 
-  // AssignTickets overwrites the Assignment field of the input TicketIds.
+  // AssignTickets sets the specified Assignment on the Tickets for the Ticket
+  // IDs passed.
   rpc AssignTickets(AssignTicketsRequest) returns (AssignTicketsResponse) {
     option (google.api.http) = {
-      post: "/v1/backendservice/tickets:assign"
-      body: "*"
-    };
-  }
-
-  // ReleaseTickets moves tickets from the pending state, to the active state.
-  // This enables them to be returned by query, and find different matches.
-  // BETA FEATURE WARNING:  This call and the associated Request and Response
-  // messages are not finalized and still subject to possible change or removal.
-  rpc ReleaseTickets(ReleaseTicketsRequest) returns (ReleaseTicketsResponse) {
-    option (google.api.http) = {
-      post: "/v1/backendservice/tickets:release"
-      body: "*"
-    };
-  }
-
-  // ReleaseAllTickets moves all tickets from the pending state, to the active
-  // state. This enables them to be returned by query, and find different
-  // matches.
-  // BETA FEATURE WARNING:  This call and the associated Request and Response
-  // messages are not finalized and still subject to possible change or removal.
-  rpc ReleaseAllTickets(ReleaseAllTicketsRequest) returns (ReleaseAllTicketsResponse) {
-    option (google.api.http) = {
-      post: "/v1/backendservice/tickets:releaseall"
+      post: "/v1/backend/tickets:assign"
       body: "*"
     };
   }

api/backend.swagger.json

@@ -13,11 +13,6 @@
       "url": "https://github.com/googleforgames/open-match/blob/master/LICENSE"
     }
   },
-  "tags": [
-    {
-      "name": "BackendService"
-    }
-  ],
   "schemes": [
     "http",
     "https"
@@ -29,38 +24,22 @@
     "application/json"
   ],
   "paths": {
-    "/v1/backendservice/matches:fetch": {
+    "/v1/backend/matches:fetch": {
       "post": {
-        "summary": "FetchMatches triggers a MatchFunction with the specified MatchProfile and\nreturns a set of matches generated by the Match Making Function, and\naccepted by the evaluator.\nTickets in matches returned by FetchMatches are moved from active to\npending, and will not be returned by query.",
-        "operationId": "BackendService_FetchMatches",
+        "summary": "FetchMatch triggers execution of the specfied MatchFunction for each of the\nspecified MatchProfiles. Each MatchFunction execution returns a set of\nproposals which are then evaluated to generate results. FetchMatch method\nstreams these results back to the caller.",
+        "operationId": "FetchMatches",
         "responses": {
           "200": {
             "description": "A successful response.(streaming responses)",
             "schema": {
-              "type": "object",
-              "properties": {
-                "result": {
-                  "$ref": "#/definitions/openmatchFetchMatchesResponse"
-                },
-                "error": {
-                  "$ref": "#/definitions/rpcStatus"
-                }
-              },
-              "title": "Stream result of openmatchFetchMatchesResponse"
+              "$ref": "#/x-stream-definitions/apiFetchMatchesResponse"
             }
           },
           "404": {
             "description": "Returned when the resource does not exist.",
             "schema": {
-              "type": "string",
               "format": "string"
             }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
           }
         },
         "parameters": [
@@ -69,38 +48,31 @@
             "in": "body",
             "required": true,
             "schema": {
-              "$ref": "#/definitions/openmatchFetchMatchesRequest"
+              "$ref": "#/definitions/apiFetchMatchesRequest"
             }
           }
         ],
         "tags": [
-          "BackendService"
+          "Backend"
         ]
       }
     },
-    "/v1/backendservice/tickets:assign": {
+    "/v1/backend/tickets:assign": {
       "post": {
-        "summary": "AssignTickets overwrites the Assignment field of the input TicketIds.",
-        "operationId": "BackendService_AssignTickets",
+        "summary": "AssignTickets sets the specified Assignment on the Tickets for the Ticket\nIDs passed.",
+        "operationId": "AssignTickets",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "$ref": "#/definitions/openmatchAssignTicketsResponse"
+              "$ref": "#/definitions/apiAssignTicketsResponse"
             }
           },
           "404": {
             "description": "Returned when the resource does not exist.",
             "schema": {
-              "type": "string",
               "format": "string"
             }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
           }
         },
         "parameters": [
@@ -109,273 +81,116 @@
             "in": "body",
             "required": true,
             "schema": {
-              "$ref": "#/definitions/openmatchAssignTicketsRequest"
+              "$ref": "#/definitions/apiAssignTicketsRequest"
             }
           }
         ],
         "tags": [
-          "BackendService"
-        ]
-      }
-    },
-    "/v1/backendservice/tickets:release": {
-      "post": {
-        "summary": "ReleaseTickets moves tickets from the pending state, to the active state.\nThis enables them to be returned by query, and find different matches.\nBETA FEATURE WARNING:  This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal.",
-        "operationId": "BackendService_ReleaseTickets",
-        "responses": {
-          "200": {
-            "description": "A successful response.",
-            "schema": {
-              "$ref": "#/definitions/openmatchReleaseTicketsResponse"
-            }
-          },
-          "404": {
-            "description": "Returned when the resource does not exist.",
-            "schema": {
-              "type": "string",
-              "format": "string"
-            }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
-          }
-        },
-        "parameters": [
-          {
-            "name": "body",
-            "in": "body",
-            "required": true,
-            "schema": {
-              "$ref": "#/definitions/openmatchReleaseTicketsRequest"
-            }
-          }
-        ],
-        "tags": [
-          "BackendService"
-        ]
-      }
-    },
-    "/v1/backendservice/tickets:releaseall": {
-      "post": {
-        "summary": "ReleaseAllTickets moves all tickets from the pending state, to the active\nstate. This enables them to be returned by query, and find different\nmatches.\nBETA FEATURE WARNING:  This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal.",
-        "operationId": "BackendService_ReleaseAllTickets",
-        "responses": {
-          "200": {
-            "description": "A successful response.",
-            "schema": {
-              "$ref": "#/definitions/openmatchReleaseAllTicketsResponse"
-            }
-          },
-          "404": {
-            "description": "Returned when the resource does not exist.",
-            "schema": {
-              "type": "string",
-              "format": "string"
-            }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
-          }
-        },
-        "parameters": [
-          {
-            "name": "body",
-            "in": "body",
-            "required": true,
-            "schema": {
-              "$ref": "#/definitions/openmatchReleaseAllTicketsRequest"
-            }
-          }
-        ],
-        "tags": [
-          "BackendService"
+          "Backend"
         ]
       }
     }
   },
   "definitions": {
-    "AssignmentFailureCause": {
-      "type": "string",
-      "enum": [
-        "UNKNOWN",
-        "TICKET_NOT_FOUND"
-      ],
-      "default": "UNKNOWN"
-    },
-    "DoubleRangeFilterExclude": {
-      "type": "string",
-      "enum": [
-        "NONE",
-        "MIN",
-        "MAX",
-        "BOTH"
-      ],
-      "default": "NONE",
-      "title": "- NONE: No bounds should be excluded when evaluating the filter, i.e.: MIN \u003c= x \u003c= MAX\n - MIN: Only the minimum bound should be excluded when evaluating the filter, i.e.: MIN \u003c x \u003c= MAX\n - MAX: Only the maximum bound should be excluded when evaluating the filter, i.e.: MIN \u003c= x \u003c MAX\n - BOTH: Both bounds should be excluded when evaluating the filter, i.e.: MIN \u003c x \u003c MAX"
-    },
-    "openmatchAssignTicketsRequest": {
+    "apiAssignTicketsRequest": {
       "type": "object",
       "properties": {
-        "assignments": {
+        "ticket_id": {
           "type": "array",
           "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchAssignmentGroup"
+            "type": "string"
           },
-          "description": "Assignments is a list of assignment groups that contain assignment and the Tickets to which they should be applied."
+          "description": "List of Ticket IDs for which the Assignment is to be made."
+        },
+        "assignment": {
+          "$ref": "#/definitions/apiAssignment",
+          "description": "Assignment to be associated with the Ticket IDs."
         }
       }
     },
-    "openmatchAssignTicketsResponse": {
-      "type": "object",
-      "properties": {
-        "failures": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchAssignmentFailure"
-          },
-          "description": "Failures is a list of all the Tickets that failed assignment along with the cause of failure."
-        }
-      }
+    "apiAssignTicketsResponse": {
+      "type": "object"
     },
-    "openmatchAssignment": {
+    "apiAssignment": {
       "type": "object",
       "properties": {
         "connection": {
           "type": "string",
           "description": "Connection information for this Assignment."
         },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
-        }
-      },
-      "description": "An Assignment represents a game server assignment associated with a Ticket.\nOpen Match does not require or inspect any fields on assignment."
-    },
-    "openmatchAssignmentFailure": {
-      "type": "object",
-      "properties": {
-        "ticket_id": {
-          "type": "string"
+        "properties": {
+          "type": "string",
+          "description": "Other details to be sent to the players. (Optional)\nOpen Match does not interpret these properties."
         },
-        "cause": {
-          "$ref": "#/definitions/AssignmentFailureCause"
+        "error": {
+          "type": "string",
+          "description": "Error when finding an Assignment for this Ticket."
         }
       },
-      "description": "AssignmentFailure contains the id of the Ticket that failed the Assignment and the failure status."
+      "description": "An Assignment object represents the assignment associated with a Ticket."
     },
-    "openmatchAssignmentGroup": {
+    "apiFetchMatchesRequest": {
       "type": "object",
       "properties": {
-        "ticket_ids": {
+        "config": {
+          "$ref": "#/definitions/apiFunctionConfig",
+          "title": "Configuration of the MatchFunction to be executed for the given list of MatchProfiles"
+        },
+        "profile": {
           "type": "array",
           "items": {
-            "type": "string"
+            "$ref": "#/definitions/apiMatchProfile"
           },
-          "description": "TicketIds is a list of strings representing Open Match generated Ids which apply to an Assignment."
-        },
-        "assignment": {
-          "$ref": "#/definitions/openmatchAssignment",
-          "description": "An Assignment specifies game connection related information to be associated with the TicketIds."
+          "description": "MatchProfiles for which this MatchFunction should be executed."
         }
-      },
-      "description": "AssignmentGroup contains an Assignment and the Tickets to which it should be applied."
+      }
     },
-    "openmatchBackfill": {
+    "apiFetchMatchesResponse": {
       "type": "object",
       "properties": {
-        "id": {
-          "type": "string",
-          "description": "Id represents an auto-generated Id issued by Open Match."
-        },
-        "search_fields": {
-          "$ref": "#/definitions/openmatchSearchFields",
-          "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
-        },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by\nthe Match Function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
-        },
-        "persistent_field": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be kept persistent \nthroughout the life-cycle of a backfill. \nOptional, depending on the requirements of the connected systems."
-        },
-        "create_time": {
-          "type": "string",
-          "format": "date-time",
-          "description": "Create time is the time the Ticket was created. It is populated by Open\nMatch at the time of Ticket creation."
-        },
-        "generation": {
-          "type": "string",
-          "format": "int64",
-          "description": "Generation gets incremented on GameServers update operations.\nPrevents the MMF from overriding a newer version from the game server.\nDo NOT read or write to this field, it is for internal tracking, and changing the value will cause bugs."
+        "match": {
+          "$ref": "#/definitions/apiMatch",
+          "description": "Result Match for the requested MatchProfile."
         }
-      },
-      "description": "Represents a backfill entity which is used to fill partially full matches.\n\nBETA FEATURE WARNING:  This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal."
+      }
     },
-    "openmatchDoubleRangeFilter": {
+    "apiFilter": {
       "type": "object",
       "properties": {
-        "double_arg": {
+        "attribute": {
           "type": "string",
-          "description": "Name of the ticket's search_fields.double_args this Filter operates on."
+          "description": "Name of the ticket attribute this Filter operates on."
         },
         "max": {
           "type": "number",
           "format": "double",
-          "description": "Maximum value."
+          "description": "Maximum value. Defaults to positive infinity (any value above minv)."
         },
         "min": {
           "type": "number",
           "format": "double",
-          "description": "Minimum value."
-        },
-        "exclude": {
-          "$ref": "#/definitions/DoubleRangeFilterExclude",
-          "description": "Defines the bounds to apply when filtering tickets by their search_fields.double_args value.\nBETA FEATURE WARNING: This field and the associated values are\nnot finalized and still subject to possible change or removal."
+          "description": "Minimum value. Defaults to 0."
         }
       },
-      "title": "Filters numerical values to only those within a range.\n  double_arg: \"foo\"\n  max: 10\n  min: 5\nmatches:\n  {\"foo\": 5}\n  {\"foo\": 7.5}\n  {\"foo\": 10}\ndoes not match:\n  {\"foo\": 4}\n  {\"foo\": 10.01}\n  {\"foo\": \"7.5\"}\n  {}"
+      "description": "A hard filter used to query a subset of Tickets meeting the filtering\ncriteria."
     },
-    "openmatchFetchMatchesRequest": {
+    "apiFunctionConfig": {
       "type": "object",
       "properties": {
-        "config": {
-          "$ref": "#/definitions/openmatchFunctionConfig",
-          "description": "A configuration for the MatchFunction server of this FetchMatches call."
+        "name": {
+          "type": "string",
+          "description": "A developer-chosen human-readable name for this Match Function."
         },
-        "profile": {
-          "$ref": "#/definitions/openmatchMatchProfile",
-          "description": "A MatchProfile that will be sent to the MatchFunction server of this FetchMatches call."
+        "grpc": {
+          "$ref": "#/definitions/apiGrpcFunctionConfig"
+        },
+        "rest": {
+          "$ref": "#/definitions/apiRestFunctionConfig"
         }
-      }
+      },
+      "description": "Configuration for the Match Function to be triggered by Open Match to\ngenerate proposals."
     },
-    "openmatchFetchMatchesResponse": {
-      "type": "object",
-      "properties": {
-        "match": {
-          "$ref": "#/definitions/openmatchMatch",
-          "description": "A Match generated by the user-defined MMF with the specified MatchProfiles.\nA valid Match response will contain at least one ticket."
-        }
-      }
-    },
-    "openmatchFunctionConfig": {
+    "apiGrpcFunctionConfig": {
       "type": "object",
       "properties": {
         "host": {
@@ -384,22 +199,11 @@
         "port": {
           "type": "integer",
           "format": "int32"
-        },
-        "type": {
-          "$ref": "#/definitions/openmatchFunctionConfigType"
         }
       },
-      "title": "FunctionConfig specifies a MMF address and client type for Backend to establish connections with the MMF"
+      "title": "Configuration for a GRPC Match Function"
     },
-    "openmatchFunctionConfigType": {
-      "type": "string",
-      "enum": [
-        "GRPC",
-        "REST"
-      ],
-      "default": "GRPC"
-    },
-    "openmatchMatch": {
+    "apiMatch": {
       "type": "object",
       "properties": {
         "match_id": {
@@ -414,240 +218,238 @@
           "type": "string",
           "description": "Name of the match function that generated this Match."
         },
-        "tickets": {
+        "ticket": {
           "type": "array",
           "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchTicket"
+            "$ref": "#/definitions/apiTicket"
           },
           "description": "Tickets belonging to this match."
         },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
+        "roster": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/apiRoster"
           },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
+          "title": "Set of Rosters that comprise this Match"
         },
-        "backfill": {
-          "$ref": "#/definitions/openmatchBackfill",
-          "description": "Backfill request which contains additional information to the match\nand contains an association to a GameServer.\nBETA FEATURE WARNING: This field is not finalized and still subject\nto possible change or removal."
-        },
-        "allocate_gameserver": {
-          "type": "boolean",
-          "description": "AllocateGameServer signalise Director that Backfill is new and it should \nallocate a GameServer, this Backfill would be assigned.\nBETA FEATURE WARNING: This field is not finalized and still subject\nto possible change or removal."
+        "properties": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Match properties for this Match. Open Match does not interpret this field."
         }
       },
-      "description": "A Match is used to represent a completed match object. It can be generated by\na MatchFunction as a proposal or can be returned by OpenMatch as a result in\nresponse to the FetchMatches call.\nWhen a match is returned by the FetchMatches call, it should contain at least\none ticket to be considered as valid."
+      "description": "A Match is used to represent a completed match object. It can be generated by\na MatchFunction as a proposal or can be returned by OpenMatch as a result in\nresponse to the FetchMatches call."
     },
-    "openmatchMatchProfile": {
+    "apiMatchProfile": {
       "type": "object",
       "properties": {
         "name": {
           "type": "string",
           "description": "Name of this match profile."
         },
-        "pools": {
+        "properties": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Set of properties associated with this MatchProfile. (Optional)\nOpen Match does not interpret these properties but passes them through to\nthe MatchFunction."
+        },
+        "pool": {
           "type": "array",
           "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchPool"
+            "$ref": "#/definitions/apiPool"
           },
-          "description": "Set of pools to be queried when generating a match for this MatchProfile."
+          "description": "Set of pools to be queried when generating a match for this MatchProfile.\nThe pool names can be used in empty Rosters to specify composition of a\nmatch."
         },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
+        "roster": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/apiRoster"
           },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
+          "description": "Set of Rosters for this match request. Could be empty Rosters used to\nindicate the composition of the generated Match or they could be partially\npre-populated Ticket list to be used in scenarios such as backfill / join\nin progress."
         }
       },
       "description": "A MatchProfile is Open Match's representation of a Match specification. It is\nused to indicate the criteria for selecting players for a match. A\nMatchProfile is the input to the API to get matches and is passed to the\nMatchFunction. It contains all the information required by the MatchFunction\nto generate match proposals."
     },
-    "openmatchPool": {
+    "apiPool": {
       "type": "object",
       "properties": {
         "name": {
           "type": "string",
           "description": "A developer-chosen human-readable name for this Pool."
         },
-        "double_range_filters": {
+        "filter": {
           "type": "array",
           "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchDoubleRangeFilter"
+            "$ref": "#/definitions/apiFilter"
           },
-          "description": "Set of Filters indicating the filtering criteria. Selected tickets must\nmatch every Filter."
-        },
-        "string_equals_filters": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchStringEqualsFilter"
-          }
-        },
-        "tag_present_filters": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchTagPresentFilter"
-          }
-        },
-        "created_before": {
-          "type": "string",
-          "format": "date-time",
-          "description": "If specified, only Tickets created before the specified time are selected."
-        },
-        "created_after": {
-          "type": "string",
-          "format": "date-time",
-          "description": "If specified, only Tickets created after the specified time are selected."
-        }
-      },
-      "description": "Pool specfies a set of criteria that are used to select a subset of Tickets\nthat meet all the criteria."
-    },
-    "openmatchReleaseAllTicketsRequest": {
-      "type": "object"
-    },
-    "openmatchReleaseAllTicketsResponse": {
-      "type": "object"
-    },
-    "openmatchReleaseTicketsRequest": {
-      "type": "object",
-      "properties": {
-        "ticket_ids": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "title": "TicketIds is a list of string representing Open Match generated Ids to be re-enabled for MMF querying\nbecause they are no longer awaiting assignment from a previous match result"
+          "description": "Set of Filters indicating the filtering criteria. Selected players must\nmatch every Filter."
         }
       }
     },
-    "openmatchReleaseTicketsResponse": {
-      "type": "object"
-    },
-    "openmatchSearchFields": {
+    "apiRestFunctionConfig": {
       "type": "object",
       "properties": {
-        "double_args": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "number",
-            "format": "double"
-          },
-          "description": "Float arguments.  Filterable on ranges."
+        "host": {
+          "type": "string"
         },
-        "string_args": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "string"
-          },
-          "description": "String arguments.  Filterable on equality."
+        "port": {
+          "type": "integer",
+          "format": "int32"
+        }
+      },
+      "description": "Configuration for a REST Match Function."
+    },
+    "apiRoster": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "A developer-chosen human-readable name for this Roster."
         },
-        "tags": {
+        "ticket_id": {
           "type": "array",
           "items": {
             "type": "string"
           },
-          "description": "Filterable on presence or absence of given value."
+          "description": "Tickets belonging to this Roster."
         }
       },
-      "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
+      "description": "A Roster is a named collection of Ticket IDs. It exists so that a Tickets\nassociated with a Match can be labelled to belong to a team, sub-team etc. It\ncan also be used to represent the current state of a Match in scenarios such\nas backfill, join-in-progress etc."
     },
-    "openmatchStringEqualsFilter": {
-      "type": "object",
-      "properties": {
-        "string_arg": {
-          "type": "string",
-          "description": "Name of the ticket's search_fields.string_args this Filter operates on."
-        },
-        "value": {
-          "type": "string"
-        }
-      },
-      "title": "Filters strings exactly equaling a value.\n  string_arg: \"foo\"\n  value: \"bar\"\nmatches:\n  {\"foo\": \"bar\"}\ndoes not match:\n  {\"foo\": \"baz\"}\n  {\"bar\": \"foo\"}\n  {}"
-    },
-    "openmatchTagPresentFilter": {
-      "type": "object",
-      "properties": {
-        "tag": {
-          "type": "string"
-        }
-      },
-      "title": "Filters to the tag being present on the search_fields.\n  tag: \"foo\"\nmatches:\n  [\"foo\"]\n  [\"bar\",\"foo\"]\ndoes not match:\n  [\"bar\"]\n  []"
-    },
-    "openmatchTicket": {
+    "apiTicket": {
       "type": "object",
       "properties": {
         "id": {
           "type": "string",
-          "description": "Id represents an auto-generated Id issued by Open Match."
+          "description": "The Ticket ID generated by Open Match."
+        },
+        "properties": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Properties contains custom info about the ticket.  Top level values can be\nused in indexing and filtering to find tickets."
         },
         "assignment": {
-          "$ref": "#/definitions/openmatchAssignment",
-          "description": "An Assignment represents a game server assignment associated with a Ticket,\nor whatever finalized matched state means for your use case.\nOpen Match does not require or inspect any fields on Assignment."
-        },
-        "search_fields": {
-          "$ref": "#/definitions/openmatchSearchFields",
-          "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
-        },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
-        },
-        "persistent_field": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be kept persistent \nthroughout the life-cycle of a ticket. \nOptional, depending on the requirements of the connected systems."
-        },
-        "create_time": {
-          "type": "string",
-          "format": "date-time",
-          "description": "Create time is the time the Ticket was created. It is populated by Open\nMatch at the time of Ticket creation."
+          "$ref": "#/definitions/apiAssignment",
+          "description": "Assignment associated with the Ticket."
         }
       },
-      "description": "A Ticket is a basic matchmaking entity in Open Match. A Ticket may represent\nan individual 'Player', a 'Group' of players, or any other concepts unique to\nyour use case. Open Match will not interpret what the Ticket represents but\njust treat it as a matchmaking unit with a set of SearchFields. Open Match\nstores the Ticket in state storage and enables an Assignment to be set on the\nTicket."
+      "description": "A Ticket is a basic matchmaking entity in Open Match. In order to enter\nmatchmaking using Open Match, the client should generate a Ticket, passing in\nthe properties to be associated with this Ticket. Open Match will generate an\nID for a Ticket during creation. A Ticket could be used to represent an\nindividual 'Player' or a 'Group' of players. Open Match will not interpret\nwhat the Ticket represents but just treat it as a matchmaking unit with a set\nof properties. Open Match stores the Ticket in state storage and enables an\nAssignment to be associated with this Ticket."
     },
     "protobufAny": {
       "type": "object",
       "properties": {
-        "@type": {
+        "type_url": {
           "type": "string",
-          "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n  value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n  URL, or have them precompiled into a binary to avoid any\n  lookup. Therefore, binary compatibility needs to be preserved\n  on changes to types. (Use versioned type names to manage\n  breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics."
+          "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n  value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n  URL, or have them precompiled into a binary to avoid any\n  lookup. Therefore, binary compatibility needs to be preserved\n  on changes to types. (Use versioned type names to manage\n  breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics."
+        },
+        "value": {
+          "type": "string",
+          "format": "byte",
+          "description": "Must be a valid serialized protocol buffer of the above specified type."
         }
       },
-      "additionalProperties": {},
-      "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n    Foo foo = ...;\n    Any any;\n    any.PackFrom(foo);\n    ...\n    if (any.UnpackTo(\u0026foo)) {\n      ...\n    }\n\nExample 2: Pack and unpack a message in Java.\n\n    Foo foo = ...;\n    Any any = Any.pack(foo);\n    ...\n    if (any.is(Foo.class)) {\n      foo = any.unpack(Foo.class);\n    }\n    // or ...\n    if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n      foo = any.unpack(Foo.getDefaultInstance());\n    }\n\n Example 3: Pack and unpack a message in Python.\n\n    foo = Foo(...)\n    any = Any()\n    any.Pack(foo)\n    ...\n    if any.Is(Foo.DESCRIPTOR):\n      any.Unpack(foo)\n      ...\n\n Example 4: Pack and unpack a message in Go\n\n     foo := \u0026pb.Foo{...}\n     any, err := anypb.New(foo)\n     if err != nil {\n       ...\n     }\n     ...\n     foo := \u0026pb.Foo{}\n     if err := any.UnmarshalTo(foo); err != nil {\n       ...\n     }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n    package google.profile;\n    message Person {\n      string first_name = 1;\n      string last_name = 2;\n    }\n\n    {\n      \"@type\": \"type.googleapis.com/google.profile.Person\",\n      \"firstName\": \u003cstring\u003e,\n      \"lastName\": \u003cstring\u003e\n    }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n    {\n      \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n      \"value\": \"1.212s\"\n    }"
+      "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n    Foo foo = ...;\n    Any any;\n    any.PackFrom(foo);\n    ...\n    if (any.UnpackTo(\u0026foo)) {\n      ...\n    }\n\nExample 2: Pack and unpack a message in Java.\n\n    Foo foo = ...;\n    Any any = Any.pack(foo);\n    ...\n    if (any.is(Foo.class)) {\n      foo = any.unpack(Foo.class);\n    }\n\n Example 3: Pack and unpack a message in Python.\n\n    foo = Foo(...)\n    any = Any()\n    any.Pack(foo)\n    ...\n    if any.Is(Foo.DESCRIPTOR):\n      any.Unpack(foo)\n      ...\n\n Example 4: Pack and unpack a message in Go\n\n     foo := \u0026pb.Foo{...}\n     any, err := ptypes.MarshalAny(foo)\n     ...\n     foo := \u0026pb.Foo{}\n     if err := ptypes.UnmarshalAny(any, foo); err != nil {\n       ...\n     }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n    package google.profile;\n    message Person {\n      string first_name = 1;\n      string last_name = 2;\n    }\n\n    {\n      \"@type\": \"type.googleapis.com/google.profile.Person\",\n      \"firstName\": \u003cstring\u003e,\n      \"lastName\": \u003cstring\u003e\n    }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n    {\n      \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n      \"value\": \"1.212s\"\n    }"
     },
-    "rpcStatus": {
+    "protobufListValue": {
       "type": "object",
       "properties": {
-        "code": {
+        "values": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/protobufValue"
+          },
+          "description": "Repeated field of dynamically typed values."
+        }
+      },
+      "description": "`ListValue` is a wrapper around a repeated field of values.\n\nThe JSON representation for `ListValue` is JSON array."
+    },
+    "protobufNullValue": {
+      "type": "string",
+      "enum": [
+        "NULL_VALUE"
+      ],
+      "default": "NULL_VALUE",
+      "description": "`NullValue` is a singleton enumeration to represent the null value for the\n`Value` type union.\n\n The JSON representation for `NullValue` is JSON `null`.\n\n - NULL_VALUE: Null value."
+    },
+    "protobufStruct": {
+      "type": "object",
+      "properties": {
+        "fields": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/protobufValue"
+          },
+          "description": "Unordered map of dynamically typed values."
+        }
+      },
+      "description": "`Struct` represents a structured data value, consisting of fields\nwhich map to dynamically typed values. In some languages, `Struct`\nmight be supported by a native representation. For example, in\nscripting languages like JS a struct is represented as an\nobject. The details of that representation are described together\nwith the proto support for the language.\n\nThe JSON representation for `Struct` is JSON object."
+    },
+    "protobufValue": {
+      "type": "object",
+      "properties": {
+        "null_value": {
+          "$ref": "#/definitions/protobufNullValue",
+          "description": "Represents a null value."
+        },
+        "number_value": {
+          "type": "number",
+          "format": "double",
+          "description": "Represents a double value."
+        },
+        "string_value": {
+          "type": "string",
+          "description": "Represents a string value."
+        },
+        "bool_value": {
+          "type": "boolean",
+          "format": "boolean",
+          "description": "Represents a boolean value."
+        },
+        "struct_value": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Represents a structured value."
+        },
+        "list_value": {
+          "$ref": "#/definitions/protobufListValue",
+          "description": "Represents a repeated `Value`."
+        }
+      },
+      "description": "`Value` represents a dynamically typed value which can be either\nnull, a number, a string, a boolean, a recursive struct value, or a\nlist of values. A producer of value is expected to set one of that\nvariants, absence of any variant indicates an error.\n\nThe JSON representation for `Value` is JSON value."
+    },
+    "runtimeStreamError": {
+      "type": "object",
+      "properties": {
+        "grpc_code": {
           "type": "integer",
-          "format": "int32",
-          "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]."
+          "format": "int32"
+        },
+        "http_code": {
+          "type": "integer",
+          "format": "int32"
         },
         "message": {
-          "type": "string",
-          "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client."
+          "type": "string"
+        },
+        "http_status": {
+          "type": "string"
         },
         "details": {
           "type": "array",
           "items": {
-            "type": "object",
             "$ref": "#/definitions/protobufAny"
-          },
-          "description": "A list of messages that carry the error details.  There is a common set of\nmessage types for APIs to use."
+          }
+        }
+      }
+    }
+  },
+  "x-stream-definitions": {
+    "apiFetchMatchesResponse": {
+      "type": "object",
+      "properties": {
+        "result": {
+          "$ref": "#/definitions/apiFetchMatchesResponse"
+        },
+        "error": {
+          "$ref": "#/definitions/runtimeStreamError"
         }
       },
-      "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)."
+      "title": "Stream result of apiFetchMatchesResponse"
     }
   },
   "externalDocs": {

api/evaluator.proto

@@ -13,15 +13,14 @@
 // limitations under the License.
 
 syntax = "proto3";
-package openmatch;
-option go_package = "open-match.dev/open-match/pkg/pb";
-option csharp_namespace = "OpenMatch";
+package api;
+option go_package = "internal/pb";
 
 import "api/messages.proto";
 import "google/api/annotations.proto";
-import "protoc-gen-openapiv2/options/annotations.proto";
+import "protoc-gen-swagger/options/annotations.proto";
 
-option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
+option (grpc.gateway.protoc_gen_swagger.options.openapiv2_swagger) = {
   info: {
     title: "Evaluator"
     version: "1.0"
@@ -52,26 +51,26 @@ option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
   }
   // TODO Add annotations for security_defintiions.
   // See
-  // https://github.com/grpc-ecosystem/grpc-gateway/blob/master/examples/internal/proto/examplepb/a_bit_of_everything.proto
+  // https://github.com/grpc-ecosystem/grpc-gateway/blob/master/examples/proto/examplepb/a_bit_of_everything.proto
 };
 
 message EvaluateRequest {
-  // A Matches proposed by the Match Function representing a candidate of the final results.
-  Match match = 1;
+  // List of Matches to evaluate.
+  repeated Match match = 1;
 }
 
 message EvaluateResponse {
-  // A Match ID representing a shortlisted match returned by the evaluator as the final result.
-  string match_id = 2;
-
-  // Deprecated fields
-  reserved 1;
+  // Accepted list of Matches.
+  repeated Match match = 1;
 }
 
-// The Evaluator service implements APIs used to evaluate and shortlist matches proposed by MMFs.
+// The service implementing the Evaluator API that is called to evaluate
+// matches generated by MMFs and shortlist them to accepted results.
 service Evaluator {
-  // Evaluate evaluates a list of proposed matches based on quality, collision status, and etc, then shortlist the matches and returns the final results.
-  rpc Evaluate(stream EvaluateRequest) returns (stream EvaluateResponse) {
+  // Evaluate accepts a list of matches, triggers the user configured evaluation
+  // function with these and other matches in the evaluation window and returns
+  // matches that are accepted by the Evaluator as valid results.
+  rpc Evaluate(EvaluateRequest) returns (EvaluateResponse) {
     option (google.api.http) = {
       post: "/v1/evaluator/matches:evaluate"
       body: "*"

api/evaluator.swagger.json

@@ -13,11 +13,6 @@
       "url": "https://github.com/googleforgames/open-match/blob/master/LICENSE"
     }
   },
-  "tags": [
-    {
-      "name": "Evaluator"
-    }
-  ],
   "schemes": [
     "http",
     "https"
@@ -31,46 +26,29 @@
   "paths": {
     "/v1/evaluator/matches:evaluate": {
       "post": {
-        "summary": "Evaluate evaluates a list of proposed matches based on quality, collision status, and etc, then shortlist the matches and returns the final results.",
-        "operationId": "Evaluator_Evaluate",
+        "summary": "Evaluate accepts a list of matches, triggers the user configured evaluation\nfunction with these and other matches in the evaluation window and returns\nmatches that are accepted by the Evaluator as valid results.",
+        "operationId": "Evaluate",
         "responses": {
           "200": {
-            "description": "A successful response.(streaming responses)",
+            "description": "A successful response.",
             "schema": {
-              "type": "object",
-              "properties": {
-                "result": {
-                  "$ref": "#/definitions/openmatchEvaluateResponse"
-                },
-                "error": {
-                  "$ref": "#/definitions/rpcStatus"
-                }
-              },
-              "title": "Stream result of openmatchEvaluateResponse"
+              "$ref": "#/definitions/apiEvaluateResponse"
             }
           },
           "404": {
             "description": "Returned when the resource does not exist.",
             "schema": {
-              "type": "string",
               "format": "string"
             }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
           }
         },
         "parameters": [
           {
             "name": "body",
-            "description": " (streaming inputs)",
             "in": "body",
             "required": true,
             "schema": {
-              "$ref": "#/definitions/openmatchEvaluateRequest"
+              "$ref": "#/definitions/apiEvaluateRequest"
             }
           }
         ],
@@ -81,80 +59,49 @@
     }
   },
   "definitions": {
-    "openmatchAssignment": {
+    "apiAssignment": {
       "type": "object",
       "properties": {
         "connection": {
           "type": "string",
           "description": "Connection information for this Assignment."
         },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
+        "properties": {
+          "type": "string",
+          "description": "Other details to be sent to the players. (Optional)\nOpen Match does not interpret these properties."
+        },
+        "error": {
+          "type": "string",
+          "description": "Error when finding an Assignment for this Ticket."
         }
       },
-      "description": "An Assignment represents a game server assignment associated with a Ticket.\nOpen Match does not require or inspect any fields on assignment."
+      "description": "An Assignment object represents the assignment associated with a Ticket."
     },
-    "openmatchBackfill": {
-      "type": "object",
-      "properties": {
-        "id": {
-          "type": "string",
-          "description": "Id represents an auto-generated Id issued by Open Match."
-        },
-        "search_fields": {
-          "$ref": "#/definitions/openmatchSearchFields",
-          "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
-        },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by\nthe Match Function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
-        },
-        "persistent_field": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be kept persistent \nthroughout the life-cycle of a backfill. \nOptional, depending on the requirements of the connected systems."
-        },
-        "create_time": {
-          "type": "string",
-          "format": "date-time",
-          "description": "Create time is the time the Ticket was created. It is populated by Open\nMatch at the time of Ticket creation."
-        },
-        "generation": {
-          "type": "string",
-          "format": "int64",
-          "description": "Generation gets incremented on GameServers update operations.\nPrevents the MMF from overriding a newer version from the game server.\nDo NOT read or write to this field, it is for internal tracking, and changing the value will cause bugs."
-        }
-      },
-      "description": "Represents a backfill entity which is used to fill partially full matches.\n\nBETA FEATURE WARNING:  This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal."
-    },
-    "openmatchEvaluateRequest": {
+    "apiEvaluateRequest": {
       "type": "object",
       "properties": {
         "match": {
-          "$ref": "#/definitions/openmatchMatch",
-          "description": "A Matches proposed by the Match Function representing a candidate of the final results."
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/apiMatch"
+          },
+          "description": "List of Matches to evaluate."
         }
       }
     },
-    "openmatchEvaluateResponse": {
+    "apiEvaluateResponse": {
       "type": "object",
       "properties": {
-        "match_id": {
-          "type": "string",
-          "description": "A Match ID representing a shortlisted match returned by the evaluator as the final result."
+        "match": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/apiMatch"
+          },
+          "description": "Accepted list of Matches."
         }
       }
     },
-    "openmatchMatch": {
+    "apiMatch": {
       "type": "object",
       "properties": {
         "match_id": {
@@ -169,130 +116,127 @@
           "type": "string",
           "description": "Name of the match function that generated this Match."
         },
-        "tickets": {
+        "ticket": {
           "type": "array",
           "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchTicket"
+            "$ref": "#/definitions/apiTicket"
           },
           "description": "Tickets belonging to this match."
         },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
+        "roster": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/apiRoster"
           },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
+          "title": "Set of Rosters that comprise this Match"
         },
-        "backfill": {
-          "$ref": "#/definitions/openmatchBackfill",
-          "description": "Backfill request which contains additional information to the match\nand contains an association to a GameServer.\nBETA FEATURE WARNING: This field is not finalized and still subject\nto possible change or removal."
-        },
-        "allocate_gameserver": {
-          "type": "boolean",
-          "description": "AllocateGameServer signalise Director that Backfill is new and it should \nallocate a GameServer, this Backfill would be assigned.\nBETA FEATURE WARNING: This field is not finalized and still subject\nto possible change or removal."
+        "properties": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Match properties for this Match. Open Match does not interpret this field."
         }
       },
-      "description": "A Match is used to represent a completed match object. It can be generated by\na MatchFunction as a proposal or can be returned by OpenMatch as a result in\nresponse to the FetchMatches call.\nWhen a match is returned by the FetchMatches call, it should contain at least\none ticket to be considered as valid."
+      "description": "A Match is used to represent a completed match object. It can be generated by\na MatchFunction as a proposal or can be returned by OpenMatch as a result in\nresponse to the FetchMatches call."
     },
-    "openmatchSearchFields": {
+    "apiRoster": {
       "type": "object",
       "properties": {
-        "double_args": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "number",
-            "format": "double"
-          },
-          "description": "Float arguments.  Filterable on ranges."
+        "name": {
+          "type": "string",
+          "description": "A developer-chosen human-readable name for this Roster."
         },
-        "string_args": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "string"
-          },
-          "description": "String arguments.  Filterable on equality."
-        },
-        "tags": {
+        "ticket_id": {
           "type": "array",
           "items": {
             "type": "string"
           },
-          "description": "Filterable on presence or absence of given value."
+          "description": "Tickets belonging to this Roster."
         }
       },
-      "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
+      "description": "A Roster is a named collection of Ticket IDs. It exists so that a Tickets\nassociated with a Match can be labelled to belong to a team, sub-team etc. It\ncan also be used to represent the current state of a Match in scenarios such\nas backfill, join-in-progress etc."
     },
-    "openmatchTicket": {
+    "apiTicket": {
       "type": "object",
       "properties": {
         "id": {
           "type": "string",
-          "description": "Id represents an auto-generated Id issued by Open Match."
+          "description": "The Ticket ID generated by Open Match."
+        },
+        "properties": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Properties contains custom info about the ticket.  Top level values can be\nused in indexing and filtering to find tickets."
         },
         "assignment": {
-          "$ref": "#/definitions/openmatchAssignment",
-          "description": "An Assignment represents a game server assignment associated with a Ticket,\nor whatever finalized matched state means for your use case.\nOpen Match does not require or inspect any fields on Assignment."
-        },
-        "search_fields": {
-          "$ref": "#/definitions/openmatchSearchFields",
-          "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
-        },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
-        },
-        "persistent_field": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be kept persistent \nthroughout the life-cycle of a ticket. \nOptional, depending on the requirements of the connected systems."
-        },
-        "create_time": {
-          "type": "string",
-          "format": "date-time",
-          "description": "Create time is the time the Ticket was created. It is populated by Open\nMatch at the time of Ticket creation."
+          "$ref": "#/definitions/apiAssignment",
+          "description": "Assignment associated with the Ticket."
         }
       },
-      "description": "A Ticket is a basic matchmaking entity in Open Match. A Ticket may represent\nan individual 'Player', a 'Group' of players, or any other concepts unique to\nyour use case. Open Match will not interpret what the Ticket represents but\njust treat it as a matchmaking unit with a set of SearchFields. Open Match\nstores the Ticket in state storage and enables an Assignment to be set on the\nTicket."
+      "description": "A Ticket is a basic matchmaking entity in Open Match. In order to enter\nmatchmaking using Open Match, the client should generate a Ticket, passing in\nthe properties to be associated with this Ticket. Open Match will generate an\nID for a Ticket during creation. A Ticket could be used to represent an\nindividual 'Player' or a 'Group' of players. Open Match will not interpret\nwhat the Ticket represents but just treat it as a matchmaking unit with a set\nof properties. Open Match stores the Ticket in state storage and enables an\nAssignment to be associated with this Ticket."
     },
-    "protobufAny": {
+    "protobufListValue": {
       "type": "object",
       "properties": {
-        "@type": {
-          "type": "string",
-          "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n  value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n  URL, or have them precompiled into a binary to avoid any\n  lookup. Therefore, binary compatibility needs to be preserved\n  on changes to types. (Use versioned type names to manage\n  breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics."
-        }
-      },
-      "additionalProperties": {},
-      "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n    Foo foo = ...;\n    Any any;\n    any.PackFrom(foo);\n    ...\n    if (any.UnpackTo(\u0026foo)) {\n      ...\n    }\n\nExample 2: Pack and unpack a message in Java.\n\n    Foo foo = ...;\n    Any any = Any.pack(foo);\n    ...\n    if (any.is(Foo.class)) {\n      foo = any.unpack(Foo.class);\n    }\n    // or ...\n    if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n      foo = any.unpack(Foo.getDefaultInstance());\n    }\n\n Example 3: Pack and unpack a message in Python.\n\n    foo = Foo(...)\n    any = Any()\n    any.Pack(foo)\n    ...\n    if any.Is(Foo.DESCRIPTOR):\n      any.Unpack(foo)\n      ...\n\n Example 4: Pack and unpack a message in Go\n\n     foo := \u0026pb.Foo{...}\n     any, err := anypb.New(foo)\n     if err != nil {\n       ...\n     }\n     ...\n     foo := \u0026pb.Foo{}\n     if err := any.UnmarshalTo(foo); err != nil {\n       ...\n     }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n    package google.profile;\n    message Person {\n      string first_name = 1;\n      string last_name = 2;\n    }\n\n    {\n      \"@type\": \"type.googleapis.com/google.profile.Person\",\n      \"firstName\": \u003cstring\u003e,\n      \"lastName\": \u003cstring\u003e\n    }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n    {\n      \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n      \"value\": \"1.212s\"\n    }"
-    },
-    "rpcStatus": {
-      "type": "object",
-      "properties": {
-        "code": {
-          "type": "integer",
-          "format": "int32",
-          "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]."
-        },
-        "message": {
-          "type": "string",
-          "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client."
-        },
-        "details": {
+        "values": {
           "type": "array",
           "items": {
-            "type": "object",
-            "$ref": "#/definitions/protobufAny"
+            "$ref": "#/definitions/protobufValue"
           },
-          "description": "A list of messages that carry the error details.  There is a common set of\nmessage types for APIs to use."
+          "description": "Repeated field of dynamically typed values."
         }
       },
-      "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)."
+      "description": "`ListValue` is a wrapper around a repeated field of values.\n\nThe JSON representation for `ListValue` is JSON array."
+    },
+    "protobufNullValue": {
+      "type": "string",
+      "enum": [
+        "NULL_VALUE"
+      ],
+      "default": "NULL_VALUE",
+      "description": "`NullValue` is a singleton enumeration to represent the null value for the\n`Value` type union.\n\n The JSON representation for `NullValue` is JSON `null`.\n\n - NULL_VALUE: Null value."
+    },
+    "protobufStruct": {
+      "type": "object",
+      "properties": {
+        "fields": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/protobufValue"
+          },
+          "description": "Unordered map of dynamically typed values."
+        }
+      },
+      "description": "`Struct` represents a structured data value, consisting of fields\nwhich map to dynamically typed values. In some languages, `Struct`\nmight be supported by a native representation. For example, in\nscripting languages like JS a struct is represented as an\nobject. The details of that representation are described together\nwith the proto support for the language.\n\nThe JSON representation for `Struct` is JSON object."
+    },
+    "protobufValue": {
+      "type": "object",
+      "properties": {
+        "null_value": {
+          "$ref": "#/definitions/protobufNullValue",
+          "description": "Represents a null value."
+        },
+        "number_value": {
+          "type": "number",
+          "format": "double",
+          "description": "Represents a double value."
+        },
+        "string_value": {
+          "type": "string",
+          "description": "Represents a string value."
+        },
+        "bool_value": {
+          "type": "boolean",
+          "format": "boolean",
+          "description": "Represents a boolean value."
+        },
+        "struct_value": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Represents a structured value."
+        },
+        "list_value": {
+          "$ref": "#/definitions/protobufListValue",
+          "description": "Represents a repeated `Value`."
+        }
+      },
+      "description": "`Value` represents a dynamically typed value which can be either\nnull, a number, a string, a boolean, a recursive struct value, or a\nlist of values. A producer of value is expected to set one of that\nvariants, absence of any variant indicates an error.\n\nThe JSON representation for `Value` is JSON value."
     }
   },
   "externalDocs": {

api/extensions.proto

@@ -1,24 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-syntax = "proto3";
-package openmatch;
-option go_package = "open-match.dev/open-match/pkg/pb";
-option csharp_namespace = "OpenMatch";
-
-// A DefaultEvaluationCriteria is used for a match's evaluation_input when using
-// the default evaluator.
-message DefaultEvaluationCriteria {
-  double score = 1;
-}

api/frontend.proto

@@ -13,16 +13,14 @@
 // limitations under the License.
 
 syntax = "proto3";
-package openmatch;
-option go_package = "open-match.dev/open-match/pkg/pb";
-option csharp_namespace = "OpenMatch";
+package api;
+option go_package = "internal/pb";
 
 import "api/messages.proto";
 import "google/api/annotations.proto";
-import "protoc-gen-openapiv2/options/annotations.proto";
-import "google/protobuf/empty.proto";
+import "protoc-gen-swagger/options/annotations.proto";
 
-option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
+option (grpc.gateway.protoc_gen_swagger.options.openapiv2_swagger) = {
   info: {
     title: "Frontend"
     version: "1.0"
@@ -53,170 +51,78 @@ option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
   }
   // TODO Add annotations for security_defintiions.
   // See
-  // https://github.com/grpc-ecosystem/grpc-gateway/blob/master/examples/internal/proto/examplepb/a_bit_of_everything.proto
+  // https://github.com/grpc-ecosystem/grpc-gateway/blob/master/examples/proto/examplepb/a_bit_of_everything.proto
 };
 
 message CreateTicketRequest {
-  // A Ticket object with SearchFields defined.
+  // Ticket object with the properties of the Ticket to be created.
+  Ticket ticket = 1;
+}
+
+message CreateTicketResponse {
+  // Ticket object for the created Ticket - with the ticket ID populated.
   Ticket ticket = 1;
 }
 
 message DeleteTicketRequest {
-  // A TicketId of a generated Ticket to be deleted.
+  // Ticket ID of the Ticket to be deleted.
   string ticket_id = 1;
 }
 
+message DeleteTicketResponse {}
+
 message GetTicketRequest {
-  // A TicketId of a generated Ticket.
+  // Ticket ID of the Ticket to fetch.
   string ticket_id = 1;
 }
 
-message WatchAssignmentsRequest {
-  // A TicketId of a generated Ticket to get updates on.
+message GetAssignmentsRequest {
+  // Ticket ID of the Ticket to get updates on.
   string ticket_id = 1;
 }
 
-message WatchAssignmentsResponse {
-  // An updated Assignment of the requested Ticket.
+message GetAssignmentsResponse {
+  // The updated Ticket object.
   Assignment assignment = 1;
 }
 
-// BETA FEATURE WARNING: This Request message is not finalized and still subject
-// to possible change or removal.
-message AcknowledgeBackfillRequest {
-  // An existing ID of Backfill to acknowledge.
-  string backfill_id = 1;
-
-  // An updated Assignment of the requested Backfill.
-  Assignment assignment = 2;
-}
-
-// BETA FEATURE WARNING: This Request message is not finalized and still subject
-// to possible change or removal.
-message AcknowledgeBackfillResponse {
-  // The Backfill that was acknowledged.
-  Backfill backfill = 1;
-
-  // All of the Tickets that were successfully assigned
-  repeated Ticket tickets = 2;
-}
-
-// BETA FEATURE WARNING: This Request message is not finalized and still subject
-// to possible change or removal.
-message CreateBackfillRequest {
-  // An empty Backfill object.
-  Backfill backfill = 1;
-}
-
-// BETA FEATURE WARNING: This Request message is not finalized and still subject
-// to possible change or removal.
-message DeleteBackfillRequest {
-  // An existing ID of Backfill to delete.
-  string backfill_id = 1;
-}
-
-// BETA FEATURE WARNING: This Request message is not finalized and still subject
-// to possible change or removal.
-message GetBackfillRequest {
-  // An existing ID of Backfill to retrieve.
-  string backfill_id = 1;
-}
-
-// UpdateBackfillRequest - update searchFields, extensions and set assignment.
-// 
-// BETA FEATURE WARNING: This Request message is not finalized and still subject
-// to possible change or removal.
-message UpdateBackfillRequest {
-  // A Backfill object with ID set and fields to update.
-  Backfill backfill = 1;
-}
-
-
-// The FrontendService implements APIs to manage and query status of a Tickets.
-service FrontendService {
-  // CreateTicket assigns an unique TicketId to the input Ticket and record it in state storage.
-  // A ticket is considered as ready for matchmaking once it is created.
-  //   - If a TicketId exists in a Ticket request, an auto-generated TicketId will override this field.
-  //   - If SearchFields exist in a Ticket, CreateTicket will also index these fields such that one can query the ticket with query.QueryTickets function.
-  rpc CreateTicket(CreateTicketRequest) returns (Ticket) {
+// The Frontend service enables creating Tickets for matchmaking and fetching
+// the status of these Tickets.
+service Frontend {
+  // CreateTicket will create a new ticket, assign a Ticket ID to it and put the
+  // Ticket in state storage. It will then look through the 'properties' field
+  // for the attributes defined as indices the matchmakaking config. If the
+  // attributes exist and are valid integers, they will be indexed. Creating a
+  // ticket adds the Ticket to the pool of Tickets considered for matchmaking.
+  rpc CreateTicket(CreateTicketRequest) returns (CreateTicketResponse) {
     option (google.api.http) = {
-      post: "/v1/frontendservice/tickets"
+      post: "/v1/frontend/tickets"
       body: "*"
     };
   }
 
-  // DeleteTicket immediately stops Open Match from using the Ticket for matchmaking and removes the Ticket from state storage.
-  // The client should delete the Ticket when finished matchmaking with it. 
-  rpc DeleteTicket(DeleteTicketRequest) returns (google.protobuf.Empty) {
+  // DeleteTicket removes the Ticket from state storage and from corresponding
+  // configured indices. Deleting the ticket stops the ticket from being
+  // considered for future matchmaking requests.
+  rpc DeleteTicket(DeleteTicketRequest) returns (DeleteTicketResponse) {
     option (google.api.http) = {
-      delete: "/v1/frontendservice/tickets/{ticket_id}"
+      delete: "/v1/frontend/tickets/{ticket_id}"
     };
   }
 
-  // GetTicket get the Ticket associated with the specified TicketId.
+  // GetTicket fetches the ticket associated with the specified Ticket ID.
   rpc GetTicket(GetTicketRequest) returns (Ticket) {
     option (google.api.http) = {
-      get: "/v1/frontendservice/tickets/{ticket_id}"
+      get: "/v1/frontend/tickets/{ticket_id}"
     };
   }
 
-  // WatchAssignments stream back Assignment of the specified TicketId if it is updated.
-  //   - If the Assignment is not updated, GetAssignment will retry using the configured backoff strategy. 
-  rpc WatchAssignments(WatchAssignmentsRequest)
-      returns (stream WatchAssignmentsResponse) {
+  // GetAssignments streams matchmaking results from Open Match for the
+  // provided Ticket ID.
+  rpc GetAssignments(GetAssignmentsRequest)
+      returns (stream GetAssignmentsResponse) {
     option (google.api.http) = {
-      get: "/v1/frontendservice/tickets/{ticket_id}/assignments"
-    };
-  }
-
-  // AcknowledgeBackfill is used to notify OpenMatch about GameServer connection info
-  // This triggers an assignment process.
-  // BETA FEATURE WARNING: This call and the associated Request and Response
-  // messages are not finalized and still subject to possible change or removal.
-  rpc AcknowledgeBackfill(AcknowledgeBackfillRequest) returns (AcknowledgeBackfillResponse) {
-    option (google.api.http) = {
-      post: "/v1/frontendservice/backfills/{backfill_id}/acknowledge"
-      body: "*"
-    };
-  }
-
-  // CreateBackfill creates a new Backfill object.
-  // BETA FEATURE WARNING:  This call and the associated Request and Response
-  // messages are not finalized and still subject to possible change or removal.
-  rpc CreateBackfill(CreateBackfillRequest) returns (Backfill) {
-    option (google.api.http) = {
-      post: "/v1/frontendservice/backfills"
-      body: "*"
-    };
-  }
-
-  // DeleteBackfill receives a backfill ID and deletes its resource.
-  // Any tickets waiting for this backfill will be returned to the active pool, no longer pending.
-  // BETA FEATURE WARNING:  This call and the associated Request and Response
-  // messages are not finalized and still subject to possible change or removal.
-  rpc DeleteBackfill(DeleteBackfillRequest) returns (google.protobuf.Empty) {
-    option (google.api.http) = {
-      delete: "/v1/frontendservice/backfills/{backfill_id}"
-    };
-  }
-
-  // GetBackfill returns a backfill object by its ID.
-  // BETA FEATURE WARNING:  This call and the associated Request and Response
-  // messages are not finalized and still subject to possible change or removal.
-  rpc GetBackfill(GetBackfillRequest) returns (Backfill) {
-    option (google.api.http) = {
-      get: "/v1/frontendservice/backfills/{backfill_id}"
-    };
-  }
-  
-  // UpdateBackfill updates search_fields and extensions for the backfill with the provided id.
-  // Any tickets waiting for this backfill will be returned to the active pool, no longer pending.
-  // BETA FEATURE WARNING:  This call and the associated Request and Response
-  // messages are not finalized and still subject to possible change or removal.
-  rpc UpdateBackfill(UpdateBackfillRequest) returns (Backfill) {
-    option (google.api.http) = {
-      patch: "/v1/frontendservice/backfills"
-      body: "*"
+      get: "/v1/frontend/tickets/{ticket_id}/assignments"
     };
   }
 }

api/frontend.swagger.json

@@ -13,11 +13,6 @@
       "url": "https://github.com/googleforgames/open-match/blob/master/LICENSE"
     }
   },
-  "tags": [
-    {
-      "name": "FrontendService"
-    }
-  ],
   "schemes": [
     "http",
     "https"
@@ -29,593 +24,320 @@
     "application/json"
   ],
   "paths": {
-    "/v1/frontendservice/backfills": {
+    "/v1/frontend/tickets": {
       "post": {
-        "summary": "CreateBackfill creates a new Backfill object.\nBETA FEATURE WARNING:  This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal.",
-        "operationId": "FrontendService_CreateBackfill",
+        "summary": "CreateTicket will create a new ticket, assign a Ticket ID to it and put the\nTicket in state storage. It will then look through the 'properties' field\nfor the attributes defined as indices the matchmakaking config. If the\nattributes exist and are valid integers, they will be indexed. Creating a\nticket adds the Ticket to the pool of Tickets considered for matchmaking.",
+        "operationId": "CreateTicket",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "$ref": "#/definitions/openmatchBackfill"
+              "$ref": "#/definitions/apiCreateTicketResponse"
             }
           },
           "404": {
             "description": "Returned when the resource does not exist.",
             "schema": {
-              "type": "string",
               "format": "string"
             }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
           }
         },
         "parameters": [
           {
             "name": "body",
-            "description": "BETA FEATURE WARNING: This Request message is not finalized and still subject\nto possible change or removal.",
             "in": "body",
             "required": true,
             "schema": {
-              "$ref": "#/definitions/openmatchCreateBackfillRequest"
+              "$ref": "#/definitions/apiCreateTicketRequest"
             }
           }
         ],
         "tags": [
-          "FrontendService"
-        ]
-      },
-      "patch": {
-        "summary": "UpdateBackfill updates search_fields and extensions for the backfill with the provided id.\nAny tickets waiting for this backfill will be returned to the active pool, no longer pending.\nBETA FEATURE WARNING:  This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal.",
-        "operationId": "FrontendService_UpdateBackfill",
-        "responses": {
-          "200": {
-            "description": "A successful response.",
-            "schema": {
-              "$ref": "#/definitions/openmatchBackfill"
-            }
-          },
-          "404": {
-            "description": "Returned when the resource does not exist.",
-            "schema": {
-              "type": "string",
-              "format": "string"
-            }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
-          }
-        },
-        "parameters": [
-          {
-            "name": "body",
-            "description": "UpdateBackfillRequest - update searchFields, extensions and set assignment.\n\nBETA FEATURE WARNING: This Request message is not finalized and still subject\nto possible change or removal.",
-            "in": "body",
-            "required": true,
-            "schema": {
-              "$ref": "#/definitions/openmatchUpdateBackfillRequest"
-            }
-          }
-        ],
-        "tags": [
-          "FrontendService"
+          "Frontend"
         ]
       }
     },
-    "/v1/frontendservice/backfills/{backfill_id}": {
+    "/v1/frontend/tickets/{ticket_id}": {
       "get": {
-        "summary": "GetBackfill returns a backfill object by its ID.\nBETA FEATURE WARNING:  This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal.",
-        "operationId": "FrontendService_GetBackfill",
+        "summary": "GetTicket fetches the ticket associated with the specified Ticket ID.",
+        "operationId": "GetTicket",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "$ref": "#/definitions/openmatchBackfill"
+              "$ref": "#/definitions/apiTicket"
             }
           },
           "404": {
             "description": "Returned when the resource does not exist.",
             "schema": {
-              "type": "string",
               "format": "string"
             }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
-          }
-        },
-        "parameters": [
-          {
-            "name": "backfill_id",
-            "description": "An existing ID of Backfill to retrieve.",
-            "in": "path",
-            "required": true,
-            "type": "string"
-          }
-        ],
-        "tags": [
-          "FrontendService"
-        ]
-      },
-      "delete": {
-        "summary": "DeleteBackfill receives a backfill ID and deletes its resource.\nAny tickets waiting for this backfill will be returned to the active pool, no longer pending.\nBETA FEATURE WARNING:  This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal.",
-        "operationId": "FrontendService_DeleteBackfill",
-        "responses": {
-          "200": {
-            "description": "A successful response.",
-            "schema": {
-              "type": "object",
-              "properties": {}
-            }
-          },
-          "404": {
-            "description": "Returned when the resource does not exist.",
-            "schema": {
-              "type": "string",
-              "format": "string"
-            }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
-          }
-        },
-        "parameters": [
-          {
-            "name": "backfill_id",
-            "description": "An existing ID of Backfill to delete.",
-            "in": "path",
-            "required": true,
-            "type": "string"
-          }
-        ],
-        "tags": [
-          "FrontendService"
-        ]
-      }
-    },
-    "/v1/frontendservice/backfills/{backfill_id}/acknowledge": {
-      "post": {
-        "summary": "AcknowledgeBackfill is used to notify OpenMatch about GameServer connection info\nThis triggers an assignment process.\nBETA FEATURE WARNING: This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal.",
-        "operationId": "FrontendService_AcknowledgeBackfill",
-        "responses": {
-          "200": {
-            "description": "A successful response.",
-            "schema": {
-              "$ref": "#/definitions/openmatchAcknowledgeBackfillResponse"
-            }
-          },
-          "404": {
-            "description": "Returned when the resource does not exist.",
-            "schema": {
-              "type": "string",
-              "format": "string"
-            }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
-          }
-        },
-        "parameters": [
-          {
-            "name": "backfill_id",
-            "description": "An existing ID of Backfill to acknowledge.",
-            "in": "path",
-            "required": true,
-            "type": "string"
-          },
-          {
-            "name": "body",
-            "in": "body",
-            "required": true,
-            "schema": {
-              "type": "object",
-              "properties": {
-                "assignment": {
-                  "$ref": "#/definitions/openmatchAssignment",
-                  "description": "An updated Assignment of the requested Backfill."
-                }
-              },
-              "description": "BETA FEATURE WARNING: This Request message is not finalized and still subject\nto possible change or removal."
-            }
-          }
-        ],
-        "tags": [
-          "FrontendService"
-        ]
-      }
-    },
-    "/v1/frontendservice/tickets": {
-      "post": {
-        "summary": "CreateTicket assigns an unique TicketId to the input Ticket and record it in state storage.\nA ticket is considered as ready for matchmaking once it is created.\n  - If a TicketId exists in a Ticket request, an auto-generated TicketId will override this field.\n  - If SearchFields exist in a Ticket, CreateTicket will also index these fields such that one can query the ticket with query.QueryTickets function.",
-        "operationId": "FrontendService_CreateTicket",
-        "responses": {
-          "200": {
-            "description": "A successful response.",
-            "schema": {
-              "$ref": "#/definitions/openmatchTicket"
-            }
-          },
-          "404": {
-            "description": "Returned when the resource does not exist.",
-            "schema": {
-              "type": "string",
-              "format": "string"
-            }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
-          }
-        },
-        "parameters": [
-          {
-            "name": "body",
-            "in": "body",
-            "required": true,
-            "schema": {
-              "$ref": "#/definitions/openmatchCreateTicketRequest"
-            }
-          }
-        ],
-        "tags": [
-          "FrontendService"
-        ]
-      }
-    },
-    "/v1/frontendservice/tickets/{ticket_id}": {
-      "get": {
-        "summary": "GetTicket get the Ticket associated with the specified TicketId.",
-        "operationId": "FrontendService_GetTicket",
-        "responses": {
-          "200": {
-            "description": "A successful response.",
-            "schema": {
-              "$ref": "#/definitions/openmatchTicket"
-            }
-          },
-          "404": {
-            "description": "Returned when the resource does not exist.",
-            "schema": {
-              "type": "string",
-              "format": "string"
-            }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
           }
         },
         "parameters": [
           {
             "name": "ticket_id",
-            "description": "A TicketId of a generated Ticket.",
+            "description": "Ticket ID of the Ticket to fetch.",
             "in": "path",
             "required": true,
             "type": "string"
           }
         ],
         "tags": [
-          "FrontendService"
+          "Frontend"
         ]
       },
       "delete": {
-        "summary": "DeleteTicket immediately stops Open Match from using the Ticket for matchmaking and removes the Ticket from state storage.\nThe client should delete the Ticket when finished matchmaking with it.",
-        "operationId": "FrontendService_DeleteTicket",
+        "summary": "DeleteTicket removes the Ticket from state storage and from corresponding\nconfigured indices. Deleting the ticket stops the ticket from being\nconsidered for future matchmaking requests.",
+        "operationId": "DeleteTicket",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "type": "object",
-              "properties": {}
+              "$ref": "#/definitions/apiDeleteTicketResponse"
             }
           },
           "404": {
             "description": "Returned when the resource does not exist.",
             "schema": {
-              "type": "string",
               "format": "string"
             }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
           }
         },
         "parameters": [
           {
             "name": "ticket_id",
-            "description": "A TicketId of a generated Ticket to be deleted.",
+            "description": "Ticket ID of the Ticket to be deleted.",
             "in": "path",
             "required": true,
             "type": "string"
           }
         ],
         "tags": [
-          "FrontendService"
+          "Frontend"
         ]
       }
     },
-    "/v1/frontendservice/tickets/{ticket_id}/assignments": {
+    "/v1/frontend/tickets/{ticket_id}/assignments": {
       "get": {
-        "summary": "WatchAssignments stream back Assignment of the specified TicketId if it is updated.\n  - If the Assignment is not updated, GetAssignment will retry using the configured backoff strategy.",
-        "operationId": "FrontendService_WatchAssignments",
+        "summary": "GetAssignments streams matchmaking results from Open Match for the\nprovided Ticket ID.",
+        "operationId": "GetAssignments",
         "responses": {
           "200": {
             "description": "A successful response.(streaming responses)",
             "schema": {
-              "type": "object",
-              "properties": {
-                "result": {
-                  "$ref": "#/definitions/openmatchWatchAssignmentsResponse"
-                },
-                "error": {
-                  "$ref": "#/definitions/rpcStatus"
-                }
-              },
-              "title": "Stream result of openmatchWatchAssignmentsResponse"
+              "$ref": "#/x-stream-definitions/apiGetAssignmentsResponse"
             }
           },
           "404": {
             "description": "Returned when the resource does not exist.",
             "schema": {
-              "type": "string",
               "format": "string"
             }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
           }
         },
         "parameters": [
           {
             "name": "ticket_id",
-            "description": "A TicketId of a generated Ticket to get updates on.",
+            "description": "Ticket ID of the Ticket to get updates on.",
             "in": "path",
             "required": true,
             "type": "string"
           }
         ],
         "tags": [
-          "FrontendService"
+          "Frontend"
         ]
       }
     }
   },
   "definitions": {
-    "openmatchAcknowledgeBackfillResponse": {
-      "type": "object",
-      "properties": {
-        "backfill": {
-          "$ref": "#/definitions/openmatchBackfill",
-          "description": "The Backfill that was acknowledged."
-        },
-        "tickets": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchTicket"
-          },
-          "title": "All of the Tickets that were successfully assigned"
-        }
-      },
-      "description": "BETA FEATURE WARNING: This Request message is not finalized and still subject\nto possible change or removal."
-    },
-    "openmatchAssignment": {
+    "apiAssignment": {
       "type": "object",
       "properties": {
         "connection": {
           "type": "string",
           "description": "Connection information for this Assignment."
         },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
+        "properties": {
+          "type": "string",
+          "description": "Other details to be sent to the players. (Optional)\nOpen Match does not interpret these properties."
+        },
+        "error": {
+          "type": "string",
+          "description": "Error when finding an Assignment for this Ticket."
         }
       },
-      "description": "An Assignment represents a game server assignment associated with a Ticket.\nOpen Match does not require or inspect any fields on assignment."
+      "description": "An Assignment object represents the assignment associated with a Ticket."
     },
-    "openmatchBackfill": {
-      "type": "object",
-      "properties": {
-        "id": {
-          "type": "string",
-          "description": "Id represents an auto-generated Id issued by Open Match."
-        },
-        "search_fields": {
-          "$ref": "#/definitions/openmatchSearchFields",
-          "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
-        },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by\nthe Match Function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
-        },
-        "persistent_field": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be kept persistent \nthroughout the life-cycle of a backfill. \nOptional, depending on the requirements of the connected systems."
-        },
-        "create_time": {
-          "type": "string",
-          "format": "date-time",
-          "description": "Create time is the time the Ticket was created. It is populated by Open\nMatch at the time of Ticket creation."
-        },
-        "generation": {
-          "type": "string",
-          "format": "int64",
-          "description": "Generation gets incremented on GameServers update operations.\nPrevents the MMF from overriding a newer version from the game server.\nDo NOT read or write to this field, it is for internal tracking, and changing the value will cause bugs."
-        }
-      },
-      "description": "Represents a backfill entity which is used to fill partially full matches.\n\nBETA FEATURE WARNING:  This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal."
-    },
-    "openmatchCreateBackfillRequest": {
-      "type": "object",
-      "properties": {
-        "backfill": {
-          "$ref": "#/definitions/openmatchBackfill",
-          "description": "An empty Backfill object."
-        }
-      },
-      "description": "BETA FEATURE WARNING: This Request message is not finalized and still subject\nto possible change or removal."
-    },
-    "openmatchCreateTicketRequest": {
+    "apiCreateTicketRequest": {
       "type": "object",
       "properties": {
         "ticket": {
-          "$ref": "#/definitions/openmatchTicket",
-          "description": "A Ticket object with SearchFields defined."
+          "$ref": "#/definitions/apiTicket",
+          "description": "Ticket object with the properties of the Ticket to be created."
         }
       }
     },
-    "openmatchSearchFields": {
+    "apiCreateTicketResponse": {
       "type": "object",
       "properties": {
-        "double_args": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "number",
-            "format": "double"
-          },
-          "description": "Float arguments.  Filterable on ranges."
-        },
-        "string_args": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "string"
-          },
-          "description": "String arguments.  Filterable on equality."
-        },
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "Filterable on presence or absence of given value."
+        "ticket": {
+          "$ref": "#/definitions/apiTicket",
+          "description": "Ticket object for the created Ticket - with the ticket ID populated."
         }
-      },
-      "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
+      }
     },
-    "openmatchTicket": {
+    "apiDeleteTicketResponse": {
+      "type": "object"
+    },
+    "apiGetAssignmentsResponse": {
+      "type": "object",
+      "properties": {
+        "assignment": {
+          "$ref": "#/definitions/apiAssignment",
+          "description": "The updated Ticket object."
+        }
+      }
+    },
+    "apiTicket": {
       "type": "object",
       "properties": {
         "id": {
           "type": "string",
-          "description": "Id represents an auto-generated Id issued by Open Match."
+          "description": "The Ticket ID generated by Open Match."
+        },
+        "properties": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Properties contains custom info about the ticket.  Top level values can be\nused in indexing and filtering to find tickets."
         },
         "assignment": {
-          "$ref": "#/definitions/openmatchAssignment",
-          "description": "An Assignment represents a game server assignment associated with a Ticket,\nor whatever finalized matched state means for your use case.\nOpen Match does not require or inspect any fields on Assignment."
-        },
-        "search_fields": {
-          "$ref": "#/definitions/openmatchSearchFields",
-          "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
-        },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
-        },
-        "persistent_field": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be kept persistent \nthroughout the life-cycle of a ticket. \nOptional, depending on the requirements of the connected systems."
-        },
-        "create_time": {
-          "type": "string",
-          "format": "date-time",
-          "description": "Create time is the time the Ticket was created. It is populated by Open\nMatch at the time of Ticket creation."
+          "$ref": "#/definitions/apiAssignment",
+          "description": "Assignment associated with the Ticket."
         }
       },
-      "description": "A Ticket is a basic matchmaking entity in Open Match. A Ticket may represent\nan individual 'Player', a 'Group' of players, or any other concepts unique to\nyour use case. Open Match will not interpret what the Ticket represents but\njust treat it as a matchmaking unit with a set of SearchFields. Open Match\nstores the Ticket in state storage and enables an Assignment to be set on the\nTicket."
-    },
-    "openmatchUpdateBackfillRequest": {
-      "type": "object",
-      "properties": {
-        "backfill": {
-          "$ref": "#/definitions/openmatchBackfill",
-          "description": "A Backfill object with ID set and fields to update."
-        }
-      },
-      "description": "UpdateBackfillRequest - update searchFields, extensions and set assignment.\n\nBETA FEATURE WARNING: This Request message is not finalized and still subject\nto possible change or removal."
-    },
-    "openmatchWatchAssignmentsResponse": {
-      "type": "object",
-      "properties": {
-        "assignment": {
-          "$ref": "#/definitions/openmatchAssignment",
-          "description": "An updated Assignment of the requested Ticket."
-        }
-      }
+      "description": "A Ticket is a basic matchmaking entity in Open Match. In order to enter\nmatchmaking using Open Match, the client should generate a Ticket, passing in\nthe properties to be associated with this Ticket. Open Match will generate an\nID for a Ticket during creation. A Ticket could be used to represent an\nindividual 'Player' or a 'Group' of players. Open Match will not interpret\nwhat the Ticket represents but just treat it as a matchmaking unit with a set\nof properties. Open Match stores the Ticket in state storage and enables an\nAssignment to be associated with this Ticket."
     },
     "protobufAny": {
       "type": "object",
       "properties": {
-        "@type": {
+        "type_url": {
           "type": "string",
-          "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n  value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n  URL, or have them precompiled into a binary to avoid any\n  lookup. Therefore, binary compatibility needs to be preserved\n  on changes to types. (Use versioned type names to manage\n  breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics."
+          "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n  value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n  URL, or have them precompiled into a binary to avoid any\n  lookup. Therefore, binary compatibility needs to be preserved\n  on changes to types. (Use versioned type names to manage\n  breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics."
+        },
+        "value": {
+          "type": "string",
+          "format": "byte",
+          "description": "Must be a valid serialized protocol buffer of the above specified type."
         }
       },
-      "additionalProperties": {},
-      "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n    Foo foo = ...;\n    Any any;\n    any.PackFrom(foo);\n    ...\n    if (any.UnpackTo(\u0026foo)) {\n      ...\n    }\n\nExample 2: Pack and unpack a message in Java.\n\n    Foo foo = ...;\n    Any any = Any.pack(foo);\n    ...\n    if (any.is(Foo.class)) {\n      foo = any.unpack(Foo.class);\n    }\n    // or ...\n    if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n      foo = any.unpack(Foo.getDefaultInstance());\n    }\n\n Example 3: Pack and unpack a message in Python.\n\n    foo = Foo(...)\n    any = Any()\n    any.Pack(foo)\n    ...\n    if any.Is(Foo.DESCRIPTOR):\n      any.Unpack(foo)\n      ...\n\n Example 4: Pack and unpack a message in Go\n\n     foo := \u0026pb.Foo{...}\n     any, err := anypb.New(foo)\n     if err != nil {\n       ...\n     }\n     ...\n     foo := \u0026pb.Foo{}\n     if err := any.UnmarshalTo(foo); err != nil {\n       ...\n     }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n    package google.profile;\n    message Person {\n      string first_name = 1;\n      string last_name = 2;\n    }\n\n    {\n      \"@type\": \"type.googleapis.com/google.profile.Person\",\n      \"firstName\": \u003cstring\u003e,\n      \"lastName\": \u003cstring\u003e\n    }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n    {\n      \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n      \"value\": \"1.212s\"\n    }"
+      "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n    Foo foo = ...;\n    Any any;\n    any.PackFrom(foo);\n    ...\n    if (any.UnpackTo(\u0026foo)) {\n      ...\n    }\n\nExample 2: Pack and unpack a message in Java.\n\n    Foo foo = ...;\n    Any any = Any.pack(foo);\n    ...\n    if (any.is(Foo.class)) {\n      foo = any.unpack(Foo.class);\n    }\n\n Example 3: Pack and unpack a message in Python.\n\n    foo = Foo(...)\n    any = Any()\n    any.Pack(foo)\n    ...\n    if any.Is(Foo.DESCRIPTOR):\n      any.Unpack(foo)\n      ...\n\n Example 4: Pack and unpack a message in Go\n\n     foo := \u0026pb.Foo{...}\n     any, err := ptypes.MarshalAny(foo)\n     ...\n     foo := \u0026pb.Foo{}\n     if err := ptypes.UnmarshalAny(any, foo); err != nil {\n       ...\n     }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n    package google.profile;\n    message Person {\n      string first_name = 1;\n      string last_name = 2;\n    }\n\n    {\n      \"@type\": \"type.googleapis.com/google.profile.Person\",\n      \"firstName\": \u003cstring\u003e,\n      \"lastName\": \u003cstring\u003e\n    }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n    {\n      \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n      \"value\": \"1.212s\"\n    }"
     },
-    "rpcStatus": {
+    "protobufListValue": {
       "type": "object",
       "properties": {
-        "code": {
+        "values": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/protobufValue"
+          },
+          "description": "Repeated field of dynamically typed values."
+        }
+      },
+      "description": "`ListValue` is a wrapper around a repeated field of values.\n\nThe JSON representation for `ListValue` is JSON array."
+    },
+    "protobufNullValue": {
+      "type": "string",
+      "enum": [
+        "NULL_VALUE"
+      ],
+      "default": "NULL_VALUE",
+      "description": "`NullValue` is a singleton enumeration to represent the null value for the\n`Value` type union.\n\n The JSON representation for `NullValue` is JSON `null`.\n\n - NULL_VALUE: Null value."
+    },
+    "protobufStruct": {
+      "type": "object",
+      "properties": {
+        "fields": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/protobufValue"
+          },
+          "description": "Unordered map of dynamically typed values."
+        }
+      },
+      "description": "`Struct` represents a structured data value, consisting of fields\nwhich map to dynamically typed values. In some languages, `Struct`\nmight be supported by a native representation. For example, in\nscripting languages like JS a struct is represented as an\nobject. The details of that representation are described together\nwith the proto support for the language.\n\nThe JSON representation for `Struct` is JSON object."
+    },
+    "protobufValue": {
+      "type": "object",
+      "properties": {
+        "null_value": {
+          "$ref": "#/definitions/protobufNullValue",
+          "description": "Represents a null value."
+        },
+        "number_value": {
+          "type": "number",
+          "format": "double",
+          "description": "Represents a double value."
+        },
+        "string_value": {
+          "type": "string",
+          "description": "Represents a string value."
+        },
+        "bool_value": {
+          "type": "boolean",
+          "format": "boolean",
+          "description": "Represents a boolean value."
+        },
+        "struct_value": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Represents a structured value."
+        },
+        "list_value": {
+          "$ref": "#/definitions/protobufListValue",
+          "description": "Represents a repeated `Value`."
+        }
+      },
+      "description": "`Value` represents a dynamically typed value which can be either\nnull, a number, a string, a boolean, a recursive struct value, or a\nlist of values. A producer of value is expected to set one of that\nvariants, absence of any variant indicates an error.\n\nThe JSON representation for `Value` is JSON value."
+    },
+    "runtimeStreamError": {
+      "type": "object",
+      "properties": {
+        "grpc_code": {
           "type": "integer",
-          "format": "int32",
-          "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]."
+          "format": "int32"
+        },
+        "http_code": {
+          "type": "integer",
+          "format": "int32"
         },
         "message": {
-          "type": "string",
-          "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client."
+          "type": "string"
+        },
+        "http_status": {
+          "type": "string"
         },
         "details": {
           "type": "array",
           "items": {
-            "type": "object",
             "$ref": "#/definitions/protobufAny"
-          },
-          "description": "A list of messages that carry the error details.  There is a common set of\nmessage types for APIs to use."
+          }
+        }
+      }
+    }
+  },
+  "x-stream-definitions": {
+    "apiGetAssignmentsResponse": {
+      "type": "object",
+      "properties": {
+        "result": {
+          "$ref": "#/definitions/apiGetAssignmentsResponse"
+        },
+        "error": {
+          "$ref": "#/definitions/runtimeStreamError"
         }
       },
-      "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)."
+      "title": "Stream result of apiGetAssignmentsResponse"
     }
   },
   "externalDocs": {

api/matchfunction.proto

@@ -13,15 +13,14 @@
 // limitations under the License.
 
 syntax = "proto3";
-package openmatch;
-option go_package = "open-match.dev/open-match/pkg/pb";
-option csharp_namespace = "OpenMatch";
+package api;
+option go_package = "internal/pb";
 
 import "api/messages.proto";
 import "google/api/annotations.proto";
-import "protoc-gen-openapiv2/options/annotations.proto";
+import "protoc-gen-swagger/options/annotations.proto";
 
-option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
+option (grpc.gateway.protoc_gen_swagger.options.openapiv2_swagger) = {
   info: {
     title: "Match Function"
     version: "1.0"
@@ -56,23 +55,22 @@ option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
 };
 
 message RunRequest {
-  // A MatchProfile defines constraints of Tickets in a Match and shapes the Match proposed by the MatchFunction.
+  // The MatchProfile that describes the Match that this MatchFunction needs to
+  // generate proposals for.
   MatchProfile profile = 1;
 }
 
 message RunResponse {
-  // A Proposal represents a Match candidate that satifies the constraints defined in the input Profile.
-  // A valid Proposal response will contain at least one ticket.
-  Match proposal = 1;
+  // The proposal generated by this MatchFunction Run.
+  repeated Match proposal = 1;
 }
 
-// The MatchFunction service implements APIs to run user-defined matchmaking logics.
+// This proto defines the API for running Match Functions as long-lived,
+// 'serving' functions.
 service MatchFunction {
-  // DO NOT CALL THIS FUNCTION MANUALLY. USE backend.FetchMatches INSTEAD.
-  // Run pulls Tickets that satisfy Profile constraints from QueryService,
-  // runs matchmaking logic against them, then constructs and streams back
-  // match candidates to the Backend service.
-  rpc Run(RunRequest) returns (stream RunResponse) {
+  // This is the function that is executed when by the Open Match backend to
+  // generate Match proposals.
+  rpc Run(RunRequest) returns (RunResponse) {
     option (google.api.http) = {
       post: "/v1/matchfunction:run"
       body: "*"

api/matchfunction.swagger.json

@@ -13,11 +13,6 @@
       "url": "https://github.com/googleforgames/open-match/blob/master/LICENSE"
     }
   },
-  "tags": [
-    {
-      "name": "MatchFunction"
-    }
-  ],
   "schemes": [
     "http",
     "https"
@@ -31,36 +26,20 @@
   "paths": {
     "/v1/matchfunction:run": {
       "post": {
-        "summary": "DO NOT CALL THIS FUNCTION MANUALLY. USE backend.FetchMatches INSTEAD.\nRun pulls Tickets that satisfy Profile constraints from QueryService,\nruns matchmaking logic against them, then constructs and streams back\nmatch candidates to the Backend service.",
-        "operationId": "MatchFunction_Run",
+        "summary": "This is the function that is executed when by the Open Match backend to\ngenerate Match proposals.",
+        "operationId": "Run",
         "responses": {
           "200": {
-            "description": "A successful response.(streaming responses)",
+            "description": "A successful response.",
             "schema": {
-              "type": "object",
-              "properties": {
-                "result": {
-                  "$ref": "#/definitions/openmatchRunResponse"
-                },
-                "error": {
-                  "$ref": "#/definitions/rpcStatus"
-                }
-              },
-              "title": "Stream result of openmatchRunResponse"
+              "$ref": "#/definitions/apiRunResponse"
             }
           },
           "404": {
             "description": "Returned when the resource does not exist.",
             "schema": {
-              "type": "string",
               "format": "string"
             }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
           }
         },
         "parameters": [
@@ -69,7 +48,7 @@
             "in": "body",
             "required": true,
             "schema": {
-              "$ref": "#/definitions/openmatchRunRequest"
+              "$ref": "#/definitions/apiRunRequest"
             }
           }
         ],
@@ -80,97 +59,45 @@
     }
   },
   "definitions": {
-    "DoubleRangeFilterExclude": {
-      "type": "string",
-      "enum": [
-        "NONE",
-        "MIN",
-        "MAX",
-        "BOTH"
-      ],
-      "default": "NONE",
-      "title": "- NONE: No bounds should be excluded when evaluating the filter, i.e.: MIN \u003c= x \u003c= MAX\n - MIN: Only the minimum bound should be excluded when evaluating the filter, i.e.: MIN \u003c x \u003c= MAX\n - MAX: Only the maximum bound should be excluded when evaluating the filter, i.e.: MIN \u003c= x \u003c MAX\n - BOTH: Both bounds should be excluded when evaluating the filter, i.e.: MIN \u003c x \u003c MAX"
-    },
-    "openmatchAssignment": {
+    "apiAssignment": {
       "type": "object",
       "properties": {
         "connection": {
           "type": "string",
           "description": "Connection information for this Assignment."
         },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
+        "properties": {
+          "type": "string",
+          "description": "Other details to be sent to the players. (Optional)\nOpen Match does not interpret these properties."
+        },
+        "error": {
+          "type": "string",
+          "description": "Error when finding an Assignment for this Ticket."
         }
       },
-      "description": "An Assignment represents a game server assignment associated with a Ticket.\nOpen Match does not require or inspect any fields on assignment."
+      "description": "An Assignment object represents the assignment associated with a Ticket."
     },
-    "openmatchBackfill": {
+    "apiFilter": {
       "type": "object",
       "properties": {
-        "id": {
+        "attribute": {
           "type": "string",
-          "description": "Id represents an auto-generated Id issued by Open Match."
-        },
-        "search_fields": {
-          "$ref": "#/definitions/openmatchSearchFields",
-          "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
-        },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by\nthe Match Function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
-        },
-        "persistent_field": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be kept persistent \nthroughout the life-cycle of a backfill. \nOptional, depending on the requirements of the connected systems."
-        },
-        "create_time": {
-          "type": "string",
-          "format": "date-time",
-          "description": "Create time is the time the Ticket was created. It is populated by Open\nMatch at the time of Ticket creation."
-        },
-        "generation": {
-          "type": "string",
-          "format": "int64",
-          "description": "Generation gets incremented on GameServers update operations.\nPrevents the MMF from overriding a newer version from the game server.\nDo NOT read or write to this field, it is for internal tracking, and changing the value will cause bugs."
-        }
-      },
-      "description": "Represents a backfill entity which is used to fill partially full matches.\n\nBETA FEATURE WARNING:  This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal."
-    },
-    "openmatchDoubleRangeFilter": {
-      "type": "object",
-      "properties": {
-        "double_arg": {
-          "type": "string",
-          "description": "Name of the ticket's search_fields.double_args this Filter operates on."
+          "description": "Name of the ticket attribute this Filter operates on."
         },
         "max": {
           "type": "number",
           "format": "double",
-          "description": "Maximum value."
+          "description": "Maximum value. Defaults to positive infinity (any value above minv)."
         },
         "min": {
           "type": "number",
           "format": "double",
-          "description": "Minimum value."
-        },
-        "exclude": {
-          "$ref": "#/definitions/DoubleRangeFilterExclude",
-          "description": "Defines the bounds to apply when filtering tickets by their search_fields.double_args value.\nBETA FEATURE WARNING: This field and the associated values are\nnot finalized and still subject to possible change or removal."
+          "description": "Minimum value. Defaults to 0."
         }
       },
-      "title": "Filters numerical values to only those within a range.\n  double_arg: \"foo\"\n  max: 10\n  min: 5\nmatches:\n  {\"foo\": 5}\n  {\"foo\": 7.5}\n  {\"foo\": 10}\ndoes not match:\n  {\"foo\": 4}\n  {\"foo\": 10.01}\n  {\"foo\": \"7.5\"}\n  {}"
+      "description": "A hard filter used to query a subset of Tickets meeting the filtering\ncriteria."
     },
-    "openmatchMatch": {
+    "apiMatch": {
       "type": "object",
       "properties": {
         "match_id": {
@@ -185,237 +112,192 @@
           "type": "string",
           "description": "Name of the match function that generated this Match."
         },
-        "tickets": {
+        "ticket": {
           "type": "array",
           "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchTicket"
+            "$ref": "#/definitions/apiTicket"
           },
           "description": "Tickets belonging to this match."
         },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
+        "roster": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/apiRoster"
           },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
+          "title": "Set of Rosters that comprise this Match"
         },
-        "backfill": {
-          "$ref": "#/definitions/openmatchBackfill",
-          "description": "Backfill request which contains additional information to the match\nand contains an association to a GameServer.\nBETA FEATURE WARNING: This field is not finalized and still subject\nto possible change or removal."
-        },
-        "allocate_gameserver": {
-          "type": "boolean",
-          "description": "AllocateGameServer signalise Director that Backfill is new and it should \nallocate a GameServer, this Backfill would be assigned.\nBETA FEATURE WARNING: This field is not finalized and still subject\nto possible change or removal."
+        "properties": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Match properties for this Match. Open Match does not interpret this field."
         }
       },
-      "description": "A Match is used to represent a completed match object. It can be generated by\na MatchFunction as a proposal or can be returned by OpenMatch as a result in\nresponse to the FetchMatches call.\nWhen a match is returned by the FetchMatches call, it should contain at least\none ticket to be considered as valid."
+      "description": "A Match is used to represent a completed match object. It can be generated by\na MatchFunction as a proposal or can be returned by OpenMatch as a result in\nresponse to the FetchMatches call."
     },
-    "openmatchMatchProfile": {
+    "apiMatchProfile": {
       "type": "object",
       "properties": {
         "name": {
           "type": "string",
           "description": "Name of this match profile."
         },
-        "pools": {
+        "properties": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Set of properties associated with this MatchProfile. (Optional)\nOpen Match does not interpret these properties but passes them through to\nthe MatchFunction."
+        },
+        "pool": {
           "type": "array",
           "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchPool"
+            "$ref": "#/definitions/apiPool"
           },
-          "description": "Set of pools to be queried when generating a match for this MatchProfile."
+          "description": "Set of pools to be queried when generating a match for this MatchProfile.\nThe pool names can be used in empty Rosters to specify composition of a\nmatch."
         },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
+        "roster": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/apiRoster"
           },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
+          "description": "Set of Rosters for this match request. Could be empty Rosters used to\nindicate the composition of the generated Match or they could be partially\npre-populated Ticket list to be used in scenarios such as backfill / join\nin progress."
         }
       },
       "description": "A MatchProfile is Open Match's representation of a Match specification. It is\nused to indicate the criteria for selecting players for a match. A\nMatchProfile is the input to the API to get matches and is passed to the\nMatchFunction. It contains all the information required by the MatchFunction\nto generate match proposals."
     },
-    "openmatchPool": {
+    "apiPool": {
       "type": "object",
       "properties": {
         "name": {
           "type": "string",
           "description": "A developer-chosen human-readable name for this Pool."
         },
-        "double_range_filters": {
+        "filter": {
           "type": "array",
           "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchDoubleRangeFilter"
+            "$ref": "#/definitions/apiFilter"
           },
-          "description": "Set of Filters indicating the filtering criteria. Selected tickets must\nmatch every Filter."
+          "description": "Set of Filters indicating the filtering criteria. Selected players must\nmatch every Filter."
+        }
+      }
+    },
+    "apiRoster": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "A developer-chosen human-readable name for this Roster."
         },
-        "string_equals_filters": {
+        "ticket_id": {
           "type": "array",
           "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchStringEqualsFilter"
-          }
-        },
-        "tag_present_filters": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchTagPresentFilter"
-          }
-        },
-        "created_before": {
-          "type": "string",
-          "format": "date-time",
-          "description": "If specified, only Tickets created before the specified time are selected."
-        },
-        "created_after": {
-          "type": "string",
-          "format": "date-time",
-          "description": "If specified, only Tickets created after the specified time are selected."
+            "type": "string"
+          },
+          "description": "Tickets belonging to this Roster."
         }
       },
-      "description": "Pool specfies a set of criteria that are used to select a subset of Tickets\nthat meet all the criteria."
+      "description": "A Roster is a named collection of Ticket IDs. It exists so that a Tickets\nassociated with a Match can be labelled to belong to a team, sub-team etc. It\ncan also be used to represent the current state of a Match in scenarios such\nas backfill, join-in-progress etc."
     },
-    "openmatchRunRequest": {
+    "apiRunRequest": {
       "type": "object",
       "properties": {
         "profile": {
-          "$ref": "#/definitions/openmatchMatchProfile",
-          "description": "A MatchProfile defines constraints of Tickets in a Match and shapes the Match proposed by the MatchFunction."
+          "$ref": "#/definitions/apiMatchProfile",
+          "description": "The MatchProfile that describes the Match that this MatchFunction needs to\ngenerate proposals for."
         }
       }
     },
-    "openmatchRunResponse": {
+    "apiRunResponse": {
       "type": "object",
       "properties": {
         "proposal": {
-          "$ref": "#/definitions/openmatchMatch",
-          "description": "A Proposal represents a Match candidate that satifies the constraints defined in the input Profile.\nA valid Proposal response will contain at least one ticket."
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/apiMatch"
+          },
+          "description": "The proposal generated by this MatchFunction Run."
         }
       }
     },
-    "openmatchSearchFields": {
-      "type": "object",
-      "properties": {
-        "double_args": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "number",
-            "format": "double"
-          },
-          "description": "Float arguments.  Filterable on ranges."
-        },
-        "string_args": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "string"
-          },
-          "description": "String arguments.  Filterable on equality."
-        },
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "Filterable on presence or absence of given value."
-        }
-      },
-      "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
-    },
-    "openmatchStringEqualsFilter": {
-      "type": "object",
-      "properties": {
-        "string_arg": {
-          "type": "string",
-          "description": "Name of the ticket's search_fields.string_args this Filter operates on."
-        },
-        "value": {
-          "type": "string"
-        }
-      },
-      "title": "Filters strings exactly equaling a value.\n  string_arg: \"foo\"\n  value: \"bar\"\nmatches:\n  {\"foo\": \"bar\"}\ndoes not match:\n  {\"foo\": \"baz\"}\n  {\"bar\": \"foo\"}\n  {}"
-    },
-    "openmatchTagPresentFilter": {
-      "type": "object",
-      "properties": {
-        "tag": {
-          "type": "string"
-        }
-      },
-      "title": "Filters to the tag being present on the search_fields.\n  tag: \"foo\"\nmatches:\n  [\"foo\"]\n  [\"bar\",\"foo\"]\ndoes not match:\n  [\"bar\"]\n  []"
-    },
-    "openmatchTicket": {
+    "apiTicket": {
       "type": "object",
       "properties": {
         "id": {
           "type": "string",
-          "description": "Id represents an auto-generated Id issued by Open Match."
+          "description": "The Ticket ID generated by Open Match."
+        },
+        "properties": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Properties contains custom info about the ticket.  Top level values can be\nused in indexing and filtering to find tickets."
         },
         "assignment": {
-          "$ref": "#/definitions/openmatchAssignment",
-          "description": "An Assignment represents a game server assignment associated with a Ticket,\nor whatever finalized matched state means for your use case.\nOpen Match does not require or inspect any fields on Assignment."
-        },
-        "search_fields": {
-          "$ref": "#/definitions/openmatchSearchFields",
-          "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
-        },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
-        },
-        "persistent_field": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be kept persistent \nthroughout the life-cycle of a ticket. \nOptional, depending on the requirements of the connected systems."
-        },
-        "create_time": {
-          "type": "string",
-          "format": "date-time",
-          "description": "Create time is the time the Ticket was created. It is populated by Open\nMatch at the time of Ticket creation."
+          "$ref": "#/definitions/apiAssignment",
+          "description": "Assignment associated with the Ticket."
         }
       },
-      "description": "A Ticket is a basic matchmaking entity in Open Match. A Ticket may represent\nan individual 'Player', a 'Group' of players, or any other concepts unique to\nyour use case. Open Match will not interpret what the Ticket represents but\njust treat it as a matchmaking unit with a set of SearchFields. Open Match\nstores the Ticket in state storage and enables an Assignment to be set on the\nTicket."
+      "description": "A Ticket is a basic matchmaking entity in Open Match. In order to enter\nmatchmaking using Open Match, the client should generate a Ticket, passing in\nthe properties to be associated with this Ticket. Open Match will generate an\nID for a Ticket during creation. A Ticket could be used to represent an\nindividual 'Player' or a 'Group' of players. Open Match will not interpret\nwhat the Ticket represents but just treat it as a matchmaking unit with a set\nof properties. Open Match stores the Ticket in state storage and enables an\nAssignment to be associated with this Ticket."
     },
-    "protobufAny": {
+    "protobufListValue": {
       "type": "object",
       "properties": {
-        "@type": {
-          "type": "string",
-          "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n  value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n  URL, or have them precompiled into a binary to avoid any\n  lookup. Therefore, binary compatibility needs to be preserved\n  on changes to types. (Use versioned type names to manage\n  breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics."
-        }
-      },
-      "additionalProperties": {},
-      "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n    Foo foo = ...;\n    Any any;\n    any.PackFrom(foo);\n    ...\n    if (any.UnpackTo(\u0026foo)) {\n      ...\n    }\n\nExample 2: Pack and unpack a message in Java.\n\n    Foo foo = ...;\n    Any any = Any.pack(foo);\n    ...\n    if (any.is(Foo.class)) {\n      foo = any.unpack(Foo.class);\n    }\n    // or ...\n    if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n      foo = any.unpack(Foo.getDefaultInstance());\n    }\n\n Example 3: Pack and unpack a message in Python.\n\n    foo = Foo(...)\n    any = Any()\n    any.Pack(foo)\n    ...\n    if any.Is(Foo.DESCRIPTOR):\n      any.Unpack(foo)\n      ...\n\n Example 4: Pack and unpack a message in Go\n\n     foo := \u0026pb.Foo{...}\n     any, err := anypb.New(foo)\n     if err != nil {\n       ...\n     }\n     ...\n     foo := \u0026pb.Foo{}\n     if err := any.UnmarshalTo(foo); err != nil {\n       ...\n     }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n    package google.profile;\n    message Person {\n      string first_name = 1;\n      string last_name = 2;\n    }\n\n    {\n      \"@type\": \"type.googleapis.com/google.profile.Person\",\n      \"firstName\": \u003cstring\u003e,\n      \"lastName\": \u003cstring\u003e\n    }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n    {\n      \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n      \"value\": \"1.212s\"\n    }"
-    },
-    "rpcStatus": {
-      "type": "object",
-      "properties": {
-        "code": {
-          "type": "integer",
-          "format": "int32",
-          "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]."
-        },
-        "message": {
-          "type": "string",
-          "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client."
-        },
-        "details": {
+        "values": {
           "type": "array",
           "items": {
-            "type": "object",
-            "$ref": "#/definitions/protobufAny"
+            "$ref": "#/definitions/protobufValue"
           },
-          "description": "A list of messages that carry the error details.  There is a common set of\nmessage types for APIs to use."
+          "description": "Repeated field of dynamically typed values."
         }
       },
-      "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)."
+      "description": "`ListValue` is a wrapper around a repeated field of values.\n\nThe JSON representation for `ListValue` is JSON array."
+    },
+    "protobufNullValue": {
+      "type": "string",
+      "enum": [
+        "NULL_VALUE"
+      ],
+      "default": "NULL_VALUE",
+      "description": "`NullValue` is a singleton enumeration to represent the null value for the\n`Value` type union.\n\n The JSON representation for `NullValue` is JSON `null`.\n\n - NULL_VALUE: Null value."
+    },
+    "protobufStruct": {
+      "type": "object",
+      "properties": {
+        "fields": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/protobufValue"
+          },
+          "description": "Unordered map of dynamically typed values."
+        }
+      },
+      "description": "`Struct` represents a structured data value, consisting of fields\nwhich map to dynamically typed values. In some languages, `Struct`\nmight be supported by a native representation. For example, in\nscripting languages like JS a struct is represented as an\nobject. The details of that representation are described together\nwith the proto support for the language.\n\nThe JSON representation for `Struct` is JSON object."
+    },
+    "protobufValue": {
+      "type": "object",
+      "properties": {
+        "null_value": {
+          "$ref": "#/definitions/protobufNullValue",
+          "description": "Represents a null value."
+        },
+        "number_value": {
+          "type": "number",
+          "format": "double",
+          "description": "Represents a double value."
+        },
+        "string_value": {
+          "type": "string",
+          "description": "Represents a string value."
+        },
+        "bool_value": {
+          "type": "boolean",
+          "format": "boolean",
+          "description": "Represents a boolean value."
+        },
+        "struct_value": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Represents a structured value."
+        },
+        "list_value": {
+          "$ref": "#/definitions/protobufListValue",
+          "description": "Represents a repeated `Value`."
+        }
+      },
+      "description": "`Value` represents a dynamically typed value which can be either\nnull, a number, a string, a boolean, a recursive struct value, or a\nlist of values. A producer of value is expected to set one of that\nvariants, absence of any variant indicates an error.\n\nThe JSON representation for `Value` is JSON value."
     }
   },
   "externalDocs": {

api/messages.proto

@@ -13,172 +13,76 @@
 // limitations under the License.
 
 syntax = "proto3";
-package openmatch;
-option go_package = "open-match.dev/open-match/pkg/pb";
-option csharp_namespace = "OpenMatch";
+package api;
+option go_package = "internal/pb";
 
-import "google/rpc/status.proto";
-import "google/protobuf/any.proto";
-import "google/protobuf/timestamp.proto";
+import "google/protobuf/struct.proto";
 
-// A Ticket is a basic matchmaking entity in Open Match. A Ticket may represent
-// an individual 'Player', a 'Group' of players, or any other concepts unique to
-// your use case. Open Match will not interpret what the Ticket represents but
-// just treat it as a matchmaking unit with a set of SearchFields. Open Match
-// stores the Ticket in state storage and enables an Assignment to be set on the
-// Ticket.
+// A Ticket is a basic matchmaking entity in Open Match. In order to enter
+// matchmaking using Open Match, the client should generate a Ticket, passing in
+// the properties to be associated with this Ticket. Open Match will generate an
+// ID for a Ticket during creation. A Ticket could be used to represent an
+// individual 'Player' or a 'Group' of players. Open Match will not interpret
+// what the Ticket represents but just treat it as a matchmaking unit with a set
+// of properties. Open Match stores the Ticket in state storage and enables an
+// Assignment to be associated with this Ticket.
 message Ticket {
-  // Id represents an auto-generated Id issued by Open Match.
+  // The Ticket ID generated by Open Match.
   string id = 1;
 
-  // An Assignment represents a game server assignment associated with a Ticket,
-  // or whatever finalized matched state means for your use case.
-  // Open Match does not require or inspect any fields on Assignment.
+  // Properties contains custom info about the ticket.  Top level values can be
+  // used in indexing and filtering to find tickets.
+  google.protobuf.Struct properties = 2;
+
+  // Assignment associated with the Ticket.
   Assignment assignment = 3;
-
-  // Search fields are the fields which Open Match is aware of, and can be used
-  // when specifying filters.
-  SearchFields search_fields = 4;
-
-  // Customized information not inspected by Open Match, to be used by the match
-  // making function, evaluator, and components making calls to Open Match.
-  // Optional, depending on the requirements of the connected systems.
-  map<string, google.protobuf.Any> extensions = 5;
-
-  // Customized information not inspected by Open Match, to be kept persistent 
-  // throughout the life-cycle of a ticket. 
-  // Optional, depending on the requirements of the connected systems.
-  map<string, google.protobuf.Any> persistent_field = 6;
-
-  // Create time is the time the Ticket was created. It is populated by Open
-  // Match at the time of Ticket creation.
-  google.protobuf.Timestamp create_time = 7;
-
-  // Deprecated fields.
-  reserved 2;
 }
 
-// Search fields are the fields which Open Match is aware of, and can be used
-// when specifying filters.
-message SearchFields {
-  // Float arguments.  Filterable on ranges.
-  map<string, double> double_args = 1;
-
-  // String arguments.  Filterable on equality.
-  map<string, string> string_args = 2;
-
-  // Filterable on presence or absence of given value.
-  repeated string tags = 3;
-}
-
-// An Assignment represents a game server assignment associated with a Ticket.
-// Open Match does not require or inspect any fields on assignment.
+// An Assignment object represents the assignment associated with a Ticket.
 message Assignment {
   // Connection information for this Assignment.
   string connection = 1;
 
-  // Customized information not inspected by Open Match, to be used by the match
-  // making function, evaluator, and components making calls to Open Match.
-  // Optional, depending on the requirements of the connected systems.
-  map<string, google.protobuf.Any> extensions = 4;
+  // Other details to be sent to the players. (Optional)
+  // Open Match does not interpret these properties.
+  string properties = 2;
 
-  // Deprecated fields.
-  reserved 2, 3;
+  // Error when finding an Assignment for this Ticket.
+  string error = 3;
 }
 
-// Filters numerical values to only those within a range.
-//   double_arg: "foo"
-//   max: 10
-//   min: 5
-// matches:
-//   {"foo": 5}
-//   {"foo": 7.5}
-//   {"foo": 10}
-// does not match:
-//   {"foo": 4}
-//   {"foo": 10.01}
-//   {"foo": "7.5"}
-//   {}
-message DoubleRangeFilter {
-  // Name of the ticket's search_fields.double_args this Filter operates on.
-  string double_arg = 1;
+// A hard filter used to query a subset of Tickets meeting the filtering
+// criteria.
+message Filter {
+  // Name of the ticket attribute this Filter operates on.
+  string attribute = 1;
 
-  // Maximum value.
+  // Maximum value. Defaults to positive infinity (any value above minv).
   double max = 2;
 
-  // Minimum value.
+  // Minimum value. Defaults to 0.
   double min = 3;
-
-  enum Exclude {
-    // No bounds should be excluded when evaluating the filter, i.e.: MIN <= x <= MAX
-    NONE = 0;
-
-    // Only the minimum bound should be excluded when evaluating the filter, i.e.: MIN < x <= MAX
-    MIN = 1;
-
-    // Only the maximum bound should be excluded when evaluating the filter, i.e.: MIN <= x < MAX
-    MAX = 2;
-
-    // Both bounds should be excluded when evaluating the filter, i.e.: MIN < x < MAX
-    BOTH = 3;
-  }
-
-  // Defines the bounds to apply when filtering tickets by their search_fields.double_args value.
-  // BETA FEATURE WARNING: This field and the associated values are
-  // not finalized and still subject to possible change or removal.
-  Exclude exclude = 4;
 }
 
-// Filters strings exactly equaling a value.
-//   string_arg: "foo"
-//   value: "bar"
-// matches:
-//   {"foo": "bar"}
-// does not match:
-//   {"foo": "baz"}
-//   {"bar": "foo"}
-//   {}
-message StringEqualsFilter {
-  // Name of the ticket's search_fields.string_args this Filter operates on.
-  string string_arg = 1;
-
-  string value = 2;
-}
-
-// Filters to the tag being present on the search_fields.
-//   tag: "foo"
-// matches:
-//   ["foo"]
-//   ["bar","foo"]
-// does not match:
-//   ["bar"]
-//   []
-message TagPresentFilter {
-  string tag = 1;
-}
-
-// Pool specfies a set of criteria that are used to select a subset of Tickets
-// that meet all the criteria.
 message Pool {
   // A developer-chosen human-readable name for this Pool.
   string name = 1;
 
-  // Set of Filters indicating the filtering criteria. Selected tickets must
+  // Set of Filters indicating the filtering criteria. Selected players must
   // match every Filter.
-  repeated DoubleRangeFilter double_range_filters = 2;
+  repeated Filter filter = 2;
+}
 
-  repeated StringEqualsFilter string_equals_filters = 4;
+// A Roster is a named collection of Ticket IDs. It exists so that a Tickets
+// associated with a Match can be labelled to belong to a team, sub-team etc. It
+// can also be used to represent the current state of a Match in scenarios such
+// as backfill, join-in-progress etc.
+message Roster {
+  // A developer-chosen human-readable name for this Roster.
+  string name = 1;
 
-  repeated TagPresentFilter tag_present_filters = 5;
-
-  // If specified, only Tickets created before the specified time are selected.
-  google.protobuf.Timestamp created_before = 6;
-
-  // If specified, only Tickets created after the specified time are selected.
-  google.protobuf.Timestamp created_after = 7;
-
-  // Deprecated fields.
-  reserved 3;
+  // Tickets belonging to this Roster.
+  repeated string ticket_id = 2;
 }
 
 // A MatchProfile is Open Match's representation of a Match specification. It is
@@ -190,23 +94,26 @@ message MatchProfile {
   // Name of this match profile.
   string name = 1;
 
+  // Set of properties associated with this MatchProfile. (Optional)
+  // Open Match does not interpret these properties but passes them through to
+  // the MatchFunction.
+  google.protobuf.Struct properties = 2;
+
   // Set of pools to be queried when generating a match for this MatchProfile.
-  repeated Pool pools = 3;
+  // The pool names can be used in empty Rosters to specify composition of a
+  // match.
+  repeated Pool pool = 3;
 
-  // Customized information not inspected by Open Match, to be used by the match
-  // making function, evaluator, and components making calls to Open Match.
-  // Optional, depending on the requirements of the connected systems.
-  map<string, google.protobuf.Any> extensions = 5;
-
-  // Deprecated fields.
-  reserved 2, 4;
+  // Set of Rosters for this match request. Could be empty Rosters used to
+  // indicate the composition of the generated Match or they could be partially
+  // pre-populated Ticket list to be used in scenarios such as backfill / join
+  // in progress.
+  repeated Roster roster = 4;
 }
 
 // A Match is used to represent a completed match object. It can be generated by
 // a MatchFunction as a proposal or can be returned by OpenMatch as a result in
 // response to the FetchMatches call.
-// When a match is returned by the FetchMatches call, it should contain at least
-// one ticket to be considered as valid.
 message Match {
   // A Match ID that should be passed through the stack for tracing.
   string match_id = 1;
@@ -218,57 +125,11 @@ message Match {
   string match_function = 3;
 
   // Tickets belonging to this match.
-  repeated Ticket tickets = 4;
+  repeated Ticket ticket = 4;
 
-  // Customized information not inspected by Open Match, to be used by the match
-  // making function, evaluator, and components making calls to Open Match.
-  // Optional, depending on the requirements of the connected systems.
-  map<string, google.protobuf.Any> extensions = 7;
+  // Set of Rosters that comprise this Match
+  repeated Roster roster = 5;
 
-  // Backfill request which contains additional information to the match
-  // and contains an association to a GameServer.
-  // BETA FEATURE WARNING: This field is not finalized and still subject
-  // to possible change or removal.
-  Backfill backfill = 8;
-
-  // AllocateGameServer signalise Director that Backfill is new and it should 
-  // allocate a GameServer, this Backfill would be assigned.
-  // BETA FEATURE WARNING: This field is not finalized and still subject
-  // to possible change or removal.
-  bool allocate_gameserver = 9;
-
-  // Deprecated fields.
-  reserved 5, 6;
+  // Match properties for this Match. Open Match does not interpret this field.
+  google.protobuf.Struct properties = 6;
 }
-
-// Represents a backfill entity which is used to fill partially full matches.
-// 
-// BETA FEATURE WARNING:  This call and the associated Request and Response
-// messages are not finalized and still subject to possible change or removal.
-message Backfill {
-  // Id represents an auto-generated Id issued by Open Match.
-  string id = 1;
-
-  // Search fields are the fields which Open Match is aware of, and can be used
-  // when specifying filters.
-  SearchFields search_fields = 2;
-
-  // Customized information not inspected by Open Match, to be used by
-  // the Match Function, evaluator, and components making calls to Open Match.
-  // Optional, depending on the requirements of the connected systems.
-  map<string, google.protobuf.Any> extensions = 3;
-
-  // Customized information not inspected by Open Match, to be kept persistent 
-  // throughout the life-cycle of a backfill. 
-  // Optional, depending on the requirements of the connected systems.
-  map<string, google.protobuf.Any> persistent_field = 4;
-
-  // Create time is the time the Ticket was created. It is populated by Open
-  // Match at the time of Ticket creation.
-  google.protobuf.Timestamp create_time = 5;
-
-  // Generation gets incremented on GameServers update operations.
-  // Prevents the MMF from overriding a newer version from the game server.
-  // Do NOT read or write to this field, it is for internal tracking, and changing the value will cause bugs.
-  int64 generation = 6;
-}

api/mmlogic.proto

@@ -0,0 +1,78 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+package api;
+option go_package = "internal/pb";
+
+import "api/messages.proto";
+import "google/api/annotations.proto";
+import "protoc-gen-swagger/options/annotations.proto";
+
+option (grpc.gateway.protoc_gen_swagger.options.openapiv2_swagger) = {
+  info: {
+    title: "MM Logic (Data Layer)"
+    version: "1.0"
+    contact: {
+      name: "Open Match"
+      url: "https://open-match.dev"
+      email: "open-match-discuss@googlegroups.com"
+    }
+    license: {
+      name: "Apache 2.0 License"
+      url: "https://github.com/googleforgames/open-match/blob/master/LICENSE"
+    }
+  }
+  external_docs: {
+    url: "https://open-match.dev/site/docs/"
+    description: "Open Match Documentation"
+  }
+  schemes: HTTP
+  schemes: HTTPS
+  consumes: "application/json"
+  produces: "application/json"
+  responses: {
+    key: "404"
+    value: {
+      description: "Returned when the resource does not exist."
+      schema: { json_schema: { type: STRING } }
+    }
+  }
+  // TODO Add annotations for security_defintiions.
+  // See
+  // https://github.com/grpc-ecosystem/grpc-gateway/blob/master/examples/proto/examplepb/a_bit_of_everything.proto
+};
+
+message QueryTicketsRequest {
+  // The Pool representing the set of Filters to be queried.
+  Pool pool = 1;
+}
+
+message QueryTicketsResponse {
+  // The Tickets that meet the Filter criteria requested by the Pool.
+  repeated Ticket ticket = 1;
+}
+
+// The MMLogic API provides utility functions for common MMF functionality such
+// as retreiving Tickets from state storage.
+service MmLogic {
+  // QueryTickets gets the list of Tickets that match every Filter in the
+  // specified Pool.
+  rpc QueryTickets(QueryTicketsRequest) returns (stream QueryTicketsResponse) {
+    option (google.api.http) = {
+      post: "/v1/mmlogic/tickets:query"
+      body: "*"
+    };
+  }
+}

api/mmlogic.swagger.json

@@ -0,0 +1,280 @@
+{
+  "swagger": "2.0",
+  "info": {
+    "title": "MM Logic (Data Layer)",
+    "version": "1.0",
+    "contact": {
+      "name": "Open Match",
+      "url": "https://open-match.dev",
+      "email": "open-match-discuss@googlegroups.com"
+    },
+    "license": {
+      "name": "Apache 2.0 License",
+      "url": "https://github.com/googleforgames/open-match/blob/master/LICENSE"
+    }
+  },
+  "schemes": [
+    "http",
+    "https"
+  ],
+  "consumes": [
+    "application/json"
+  ],
+  "produces": [
+    "application/json"
+  ],
+  "paths": {
+    "/v1/mmlogic/tickets:query": {
+      "post": {
+        "summary": "QueryTickets gets the list of Tickets that match every Filter in the\nspecified Pool.",
+        "operationId": "QueryTickets",
+        "responses": {
+          "200": {
+            "description": "A successful response.(streaming responses)",
+            "schema": {
+              "$ref": "#/x-stream-definitions/apiQueryTicketsResponse"
+            }
+          },
+          "404": {
+            "description": "Returned when the resource does not exist.",
+            "schema": {
+              "format": "string"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "body",
+            "in": "body",
+            "required": true,
+            "schema": {
+              "$ref": "#/definitions/apiQueryTicketsRequest"
+            }
+          }
+        ],
+        "tags": [
+          "MmLogic"
+        ]
+      }
+    }
+  },
+  "definitions": {
+    "apiAssignment": {
+      "type": "object",
+      "properties": {
+        "connection": {
+          "type": "string",
+          "description": "Connection information for this Assignment."
+        },
+        "properties": {
+          "type": "string",
+          "description": "Other details to be sent to the players. (Optional)\nOpen Match does not interpret these properties."
+        },
+        "error": {
+          "type": "string",
+          "description": "Error when finding an Assignment for this Ticket."
+        }
+      },
+      "description": "An Assignment object represents the assignment associated with a Ticket."
+    },
+    "apiFilter": {
+      "type": "object",
+      "properties": {
+        "attribute": {
+          "type": "string",
+          "description": "Name of the ticket attribute this Filter operates on."
+        },
+        "max": {
+          "type": "number",
+          "format": "double",
+          "description": "Maximum value. Defaults to positive infinity (any value above minv)."
+        },
+        "min": {
+          "type": "number",
+          "format": "double",
+          "description": "Minimum value. Defaults to 0."
+        }
+      },
+      "description": "A hard filter used to query a subset of Tickets meeting the filtering\ncriteria."
+    },
+    "apiPool": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "A developer-chosen human-readable name for this Pool."
+        },
+        "filter": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/apiFilter"
+          },
+          "description": "Set of Filters indicating the filtering criteria. Selected players must\nmatch every Filter."
+        }
+      }
+    },
+    "apiQueryTicketsRequest": {
+      "type": "object",
+      "properties": {
+        "pool": {
+          "$ref": "#/definitions/apiPool",
+          "description": "The Pool representing the set of Filters to be queried."
+        }
+      }
+    },
+    "apiQueryTicketsResponse": {
+      "type": "object",
+      "properties": {
+        "ticket": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/apiTicket"
+          },
+          "description": "The Tickets that meet the Filter criteria requested by the Pool."
+        }
+      }
+    },
+    "apiTicket": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The Ticket ID generated by Open Match."
+        },
+        "properties": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Properties contains custom info about the ticket.  Top level values can be\nused in indexing and filtering to find tickets."
+        },
+        "assignment": {
+          "$ref": "#/definitions/apiAssignment",
+          "description": "Assignment associated with the Ticket."
+        }
+      },
+      "description": "A Ticket is a basic matchmaking entity in Open Match. In order to enter\nmatchmaking using Open Match, the client should generate a Ticket, passing in\nthe properties to be associated with this Ticket. Open Match will generate an\nID for a Ticket during creation. A Ticket could be used to represent an\nindividual 'Player' or a 'Group' of players. Open Match will not interpret\nwhat the Ticket represents but just treat it as a matchmaking unit with a set\nof properties. Open Match stores the Ticket in state storage and enables an\nAssignment to be associated with this Ticket."
+    },
+    "protobufAny": {
+      "type": "object",
+      "properties": {
+        "type_url": {
+          "type": "string",
+          "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n  value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n  URL, or have them precompiled into a binary to avoid any\n  lookup. Therefore, binary compatibility needs to be preserved\n  on changes to types. (Use versioned type names to manage\n  breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics."
+        },
+        "value": {
+          "type": "string",
+          "format": "byte",
+          "description": "Must be a valid serialized protocol buffer of the above specified type."
+        }
+      },
+      "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n    Foo foo = ...;\n    Any any;\n    any.PackFrom(foo);\n    ...\n    if (any.UnpackTo(\u0026foo)) {\n      ...\n    }\n\nExample 2: Pack and unpack a message in Java.\n\n    Foo foo = ...;\n    Any any = Any.pack(foo);\n    ...\n    if (any.is(Foo.class)) {\n      foo = any.unpack(Foo.class);\n    }\n\n Example 3: Pack and unpack a message in Python.\n\n    foo = Foo(...)\n    any = Any()\n    any.Pack(foo)\n    ...\n    if any.Is(Foo.DESCRIPTOR):\n      any.Unpack(foo)\n      ...\n\n Example 4: Pack and unpack a message in Go\n\n     foo := \u0026pb.Foo{...}\n     any, err := ptypes.MarshalAny(foo)\n     ...\n     foo := \u0026pb.Foo{}\n     if err := ptypes.UnmarshalAny(any, foo); err != nil {\n       ...\n     }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n    package google.profile;\n    message Person {\n      string first_name = 1;\n      string last_name = 2;\n    }\n\n    {\n      \"@type\": \"type.googleapis.com/google.profile.Person\",\n      \"firstName\": \u003cstring\u003e,\n      \"lastName\": \u003cstring\u003e\n    }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n    {\n      \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n      \"value\": \"1.212s\"\n    }"
+    },
+    "protobufListValue": {
+      "type": "object",
+      "properties": {
+        "values": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/protobufValue"
+          },
+          "description": "Repeated field of dynamically typed values."
+        }
+      },
+      "description": "`ListValue` is a wrapper around a repeated field of values.\n\nThe JSON representation for `ListValue` is JSON array."
+    },
+    "protobufNullValue": {
+      "type": "string",
+      "enum": [
+        "NULL_VALUE"
+      ],
+      "default": "NULL_VALUE",
+      "description": "`NullValue` is a singleton enumeration to represent the null value for the\n`Value` type union.\n\n The JSON representation for `NullValue` is JSON `null`.\n\n - NULL_VALUE: Null value."
+    },
+    "protobufStruct": {
+      "type": "object",
+      "properties": {
+        "fields": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/protobufValue"
+          },
+          "description": "Unordered map of dynamically typed values."
+        }
+      },
+      "description": "`Struct` represents a structured data value, consisting of fields\nwhich map to dynamically typed values. In some languages, `Struct`\nmight be supported by a native representation. For example, in\nscripting languages like JS a struct is represented as an\nobject. The details of that representation are described together\nwith the proto support for the language.\n\nThe JSON representation for `Struct` is JSON object."
+    },
+    "protobufValue": {
+      "type": "object",
+      "properties": {
+        "null_value": {
+          "$ref": "#/definitions/protobufNullValue",
+          "description": "Represents a null value."
+        },
+        "number_value": {
+          "type": "number",
+          "format": "double",
+          "description": "Represents a double value."
+        },
+        "string_value": {
+          "type": "string",
+          "description": "Represents a string value."
+        },
+        "bool_value": {
+          "type": "boolean",
+          "format": "boolean",
+          "description": "Represents a boolean value."
+        },
+        "struct_value": {
+          "$ref": "#/definitions/protobufStruct",
+          "description": "Represents a structured value."
+        },
+        "list_value": {
+          "$ref": "#/definitions/protobufListValue",
+          "description": "Represents a repeated `Value`."
+        }
+      },
+      "description": "`Value` represents a dynamically typed value which can be either\nnull, a number, a string, a boolean, a recursive struct value, or a\nlist of values. A producer of value is expected to set one of that\nvariants, absence of any variant indicates an error.\n\nThe JSON representation for `Value` is JSON value."
+    },
+    "runtimeStreamError": {
+      "type": "object",
+      "properties": {
+        "grpc_code": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "http_code": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "message": {
+          "type": "string"
+        },
+        "http_status": {
+          "type": "string"
+        },
+        "details": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/protobufAny"
+          }
+        }
+      }
+    }
+  },
+  "x-stream-definitions": {
+    "apiQueryTicketsResponse": {
+      "type": "object",
+      "properties": {
+        "result": {
+          "$ref": "#/definitions/apiQueryTicketsResponse"
+        },
+        "error": {
+          "$ref": "#/definitions/runtimeStreamError"
+        }
+      },
+      "title": "Stream result of apiQueryTicketsResponse"
+    }
+  },
+  "externalDocs": {
+    "description": "Open Match Documentation",
+    "url": "https://open-match.dev/site/docs/"
+  }
+}

api/query.proto

@@ -1,125 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-syntax = "proto3";
-package openmatch;
-option go_package = "open-match.dev/open-match/pkg/pb";
-option csharp_namespace = "OpenMatch";
-
-import "api/messages.proto";
-import "google/api/annotations.proto";
-import "protoc-gen-openapiv2/options/annotations.proto";
-
-option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
-  info: {
-    title: "MM Logic (Data Layer)"
-    version: "1.0"
-    contact: {
-      name: "Open Match"
-      url: "https://open-match.dev"
-      email: "open-match-discuss@googlegroups.com"
-    }
-    license: {
-      name: "Apache 2.0 License"
-      url: "https://github.com/googleforgames/open-match/blob/master/LICENSE"
-    }
-  }
-  external_docs: {
-    url: "https://open-match.dev/site/docs/"
-    description: "Open Match Documentation"
-  }
-  schemes: HTTP
-  schemes: HTTPS
-  consumes: "application/json"
-  produces: "application/json"
-  responses: {
-    key: "404"
-    value: {
-      description: "Returned when the resource does not exist."
-      schema: { json_schema: { type: STRING } }
-    }
-  }
-  // TODO Add annotations for security_defintiions.
-  // See
-  // https://github.com/grpc-ecosystem/grpc-gateway/blob/master/examples/internal/proto/examplepb/a_bit_of_everything.proto
-};
-
-message QueryTicketsRequest {
-  // The Pool representing the set of Filters to be queried.
-  Pool pool = 1;
-}
-
-message QueryTicketsResponse {
-  // Tickets that meet all the filtering criteria requested by the pool.
-  repeated Ticket tickets = 1;
-}
-
-message QueryTicketIdsRequest {
-  // The Pool representing the set of Filters to be queried.
-  Pool pool = 1;
-}
-
-message QueryTicketIdsResponse {
-  // TicketIDs that meet all the filtering criteria requested by the pool.
-  repeated string ids = 1;
-}
-
-// BETA FEATURE WARNING:  This Request messages are not finalized and 
-// still subject to possible change or removal.
-message QueryBackfillsRequest {
-  // The Pool representing the set of Filters to be queried.
-  Pool pool = 1;
-}
-
-// BETA FEATURE WARNING:  This Request messages are not finalized and 
-// still subject to possible change or removal.
-message QueryBackfillsResponse {
-  // Backfills that meet all the filtering criteria requested by the pool.
-  repeated Backfill backfills = 1;
-}
-
-// The QueryService service implements helper APIs for Match Function to query Tickets from state storage.
-service QueryService {
-  // QueryTickets gets a list of Tickets that match all Filters of the input Pool.
-  //   - If the Pool contains no Filters, QueryTickets will return all Tickets in the state storage.
-  // QueryTickets pages the Tickets by `queryPageSize` and stream back responses.
-  //   - queryPageSize is default to 1000 if not set, and has a minimum of 10 and maximum of 10000.
-  rpc QueryTickets(QueryTicketsRequest) returns (stream QueryTicketsResponse) {
-    option (google.api.http) = {
-      post: "/v1/queryservice/tickets:query"
-      body: "*"
-    };
-  }
-
-  // QueryTicketIds gets the list of TicketIDs that meet all the filtering criteria requested by the pool.
-  //   - If the Pool contains no Filters, QueryTicketIds will return all TicketIDs in the state storage.
-  // QueryTicketIds pages the TicketIDs by `queryPageSize` and stream back responses.
-  //   - queryPageSize is default to 1000 if not set, and has a minimum of 10 and maximum of 10000.
-  rpc QueryTicketIds(QueryTicketIdsRequest) returns (stream QueryTicketIdsResponse) {
-    option (google.api.http) = {
-      post: "/v1/queryservice/ticketids:query"
-      body: "*"
-    };
-  }
-
-  // QueryBackfills gets a list of Backfills.
-  // BETA FEATURE WARNING:  This call and the associated Request and Response
-  // messages are not finalized and still subject to possible change or removal.
-  rpc QueryBackfills(QueryBackfillsRequest) returns (stream QueryBackfillsResponse) {
-    option (google.api.http) = {
-      post: "/v1/queryservice/backfills:query"
-      body: "*"
-    };
-  }
-}

api/query.swagger.json

@@ -1,507 +0,0 @@
-{
-  "swagger": "2.0",
-  "info": {
-    "title": "MM Logic (Data Layer)",
-    "version": "1.0",
-    "contact": {
-      "name": "Open Match",
-      "url": "https://open-match.dev",
-      "email": "open-match-discuss@googlegroups.com"
-    },
-    "license": {
-      "name": "Apache 2.0 License",
-      "url": "https://github.com/googleforgames/open-match/blob/master/LICENSE"
-    }
-  },
-  "tags": [
-    {
-      "name": "QueryService"
-    }
-  ],
-  "schemes": [
-    "http",
-    "https"
-  ],
-  "consumes": [
-    "application/json"
-  ],
-  "produces": [
-    "application/json"
-  ],
-  "paths": {
-    "/v1/queryservice/backfills:query": {
-      "post": {
-        "summary": "QueryBackfills gets a list of Backfills.\nBETA FEATURE WARNING:  This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal.",
-        "operationId": "QueryService_QueryBackfills",
-        "responses": {
-          "200": {
-            "description": "A successful response.(streaming responses)",
-            "schema": {
-              "type": "object",
-              "properties": {
-                "result": {
-                  "$ref": "#/definitions/openmatchQueryBackfillsResponse"
-                },
-                "error": {
-                  "$ref": "#/definitions/rpcStatus"
-                }
-              },
-              "title": "Stream result of openmatchQueryBackfillsResponse"
-            }
-          },
-          "404": {
-            "description": "Returned when the resource does not exist.",
-            "schema": {
-              "type": "string",
-              "format": "string"
-            }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
-          }
-        },
-        "parameters": [
-          {
-            "name": "body",
-            "description": "BETA FEATURE WARNING:  This Request messages are not finalized and \nstill subject to possible change or removal.",
-            "in": "body",
-            "required": true,
-            "schema": {
-              "$ref": "#/definitions/openmatchQueryBackfillsRequest"
-            }
-          }
-        ],
-        "tags": [
-          "QueryService"
-        ]
-      }
-    },
-    "/v1/queryservice/ticketids:query": {
-      "post": {
-        "summary": "QueryTicketIds gets the list of TicketIDs that meet all the filtering criteria requested by the pool.\n  - If the Pool contains no Filters, QueryTicketIds will return all TicketIDs in the state storage.\nQueryTicketIds pages the TicketIDs by `queryPageSize` and stream back responses.\n  - queryPageSize is default to 1000 if not set, and has a minimum of 10 and maximum of 10000.",
-        "operationId": "QueryService_QueryTicketIds",
-        "responses": {
-          "200": {
-            "description": "A successful response.(streaming responses)",
-            "schema": {
-              "type": "object",
-              "properties": {
-                "result": {
-                  "$ref": "#/definitions/openmatchQueryTicketIdsResponse"
-                },
-                "error": {
-                  "$ref": "#/definitions/rpcStatus"
-                }
-              },
-              "title": "Stream result of openmatchQueryTicketIdsResponse"
-            }
-          },
-          "404": {
-            "description": "Returned when the resource does not exist.",
-            "schema": {
-              "type": "string",
-              "format": "string"
-            }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
-          }
-        },
-        "parameters": [
-          {
-            "name": "body",
-            "in": "body",
-            "required": true,
-            "schema": {
-              "$ref": "#/definitions/openmatchQueryTicketIdsRequest"
-            }
-          }
-        ],
-        "tags": [
-          "QueryService"
-        ]
-      }
-    },
-    "/v1/queryservice/tickets:query": {
-      "post": {
-        "summary": "QueryTickets gets a list of Tickets that match all Filters of the input Pool.\n  - If the Pool contains no Filters, QueryTickets will return all Tickets in the state storage.\nQueryTickets pages the Tickets by `queryPageSize` and stream back responses.\n  - queryPageSize is default to 1000 if not set, and has a minimum of 10 and maximum of 10000.",
-        "operationId": "QueryService_QueryTickets",
-        "responses": {
-          "200": {
-            "description": "A successful response.(streaming responses)",
-            "schema": {
-              "type": "object",
-              "properties": {
-                "result": {
-                  "$ref": "#/definitions/openmatchQueryTicketsResponse"
-                },
-                "error": {
-                  "$ref": "#/definitions/rpcStatus"
-                }
-              },
-              "title": "Stream result of openmatchQueryTicketsResponse"
-            }
-          },
-          "404": {
-            "description": "Returned when the resource does not exist.",
-            "schema": {
-              "type": "string",
-              "format": "string"
-            }
-          },
-          "default": {
-            "description": "An unexpected error response.",
-            "schema": {
-              "$ref": "#/definitions/rpcStatus"
-            }
-          }
-        },
-        "parameters": [
-          {
-            "name": "body",
-            "in": "body",
-            "required": true,
-            "schema": {
-              "$ref": "#/definitions/openmatchQueryTicketsRequest"
-            }
-          }
-        ],
-        "tags": [
-          "QueryService"
-        ]
-      }
-    }
-  },
-  "definitions": {
-    "DoubleRangeFilterExclude": {
-      "type": "string",
-      "enum": [
-        "NONE",
-        "MIN",
-        "MAX",
-        "BOTH"
-      ],
-      "default": "NONE",
-      "title": "- NONE: No bounds should be excluded when evaluating the filter, i.e.: MIN \u003c= x \u003c= MAX\n - MIN: Only the minimum bound should be excluded when evaluating the filter, i.e.: MIN \u003c x \u003c= MAX\n - MAX: Only the maximum bound should be excluded when evaluating the filter, i.e.: MIN \u003c= x \u003c MAX\n - BOTH: Both bounds should be excluded when evaluating the filter, i.e.: MIN \u003c x \u003c MAX"
-    },
-    "openmatchAssignment": {
-      "type": "object",
-      "properties": {
-        "connection": {
-          "type": "string",
-          "description": "Connection information for this Assignment."
-        },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
-        }
-      },
-      "description": "An Assignment represents a game server assignment associated with a Ticket.\nOpen Match does not require or inspect any fields on assignment."
-    },
-    "openmatchBackfill": {
-      "type": "object",
-      "properties": {
-        "id": {
-          "type": "string",
-          "description": "Id represents an auto-generated Id issued by Open Match."
-        },
-        "search_fields": {
-          "$ref": "#/definitions/openmatchSearchFields",
-          "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
-        },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by\nthe Match Function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
-        },
-        "persistent_field": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be kept persistent \nthroughout the life-cycle of a backfill. \nOptional, depending on the requirements of the connected systems."
-        },
-        "create_time": {
-          "type": "string",
-          "format": "date-time",
-          "description": "Create time is the time the Ticket was created. It is populated by Open\nMatch at the time of Ticket creation."
-        },
-        "generation": {
-          "type": "string",
-          "format": "int64",
-          "description": "Generation gets incremented on GameServers update operations.\nPrevents the MMF from overriding a newer version from the game server.\nDo NOT read or write to this field, it is for internal tracking, and changing the value will cause bugs."
-        }
-      },
-      "description": "Represents a backfill entity which is used to fill partially full matches.\n\nBETA FEATURE WARNING:  This call and the associated Request and Response\nmessages are not finalized and still subject to possible change or removal."
-    },
-    "openmatchDoubleRangeFilter": {
-      "type": "object",
-      "properties": {
-        "double_arg": {
-          "type": "string",
-          "description": "Name of the ticket's search_fields.double_args this Filter operates on."
-        },
-        "max": {
-          "type": "number",
-          "format": "double",
-          "description": "Maximum value."
-        },
-        "min": {
-          "type": "number",
-          "format": "double",
-          "description": "Minimum value."
-        },
-        "exclude": {
-          "$ref": "#/definitions/DoubleRangeFilterExclude",
-          "description": "Defines the bounds to apply when filtering tickets by their search_fields.double_args value.\nBETA FEATURE WARNING: This field and the associated values are\nnot finalized and still subject to possible change or removal."
-        }
-      },
-      "title": "Filters numerical values to only those within a range.\n  double_arg: \"foo\"\n  max: 10\n  min: 5\nmatches:\n  {\"foo\": 5}\n  {\"foo\": 7.5}\n  {\"foo\": 10}\ndoes not match:\n  {\"foo\": 4}\n  {\"foo\": 10.01}\n  {\"foo\": \"7.5\"}\n  {}"
-    },
-    "openmatchPool": {
-      "type": "object",
-      "properties": {
-        "name": {
-          "type": "string",
-          "description": "A developer-chosen human-readable name for this Pool."
-        },
-        "double_range_filters": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchDoubleRangeFilter"
-          },
-          "description": "Set of Filters indicating the filtering criteria. Selected tickets must\nmatch every Filter."
-        },
-        "string_equals_filters": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchStringEqualsFilter"
-          }
-        },
-        "tag_present_filters": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchTagPresentFilter"
-          }
-        },
-        "created_before": {
-          "type": "string",
-          "format": "date-time",
-          "description": "If specified, only Tickets created before the specified time are selected."
-        },
-        "created_after": {
-          "type": "string",
-          "format": "date-time",
-          "description": "If specified, only Tickets created after the specified time are selected."
-        }
-      },
-      "description": "Pool specfies a set of criteria that are used to select a subset of Tickets\nthat meet all the criteria."
-    },
-    "openmatchQueryBackfillsRequest": {
-      "type": "object",
-      "properties": {
-        "pool": {
-          "$ref": "#/definitions/openmatchPool",
-          "description": "The Pool representing the set of Filters to be queried."
-        }
-      },
-      "description": "BETA FEATURE WARNING:  This Request messages are not finalized and \nstill subject to possible change or removal."
-    },
-    "openmatchQueryBackfillsResponse": {
-      "type": "object",
-      "properties": {
-        "backfills": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchBackfill"
-          },
-          "description": "Backfills that meet all the filtering criteria requested by the pool."
-        }
-      },
-      "description": "BETA FEATURE WARNING:  This Request messages are not finalized and \nstill subject to possible change or removal."
-    },
-    "openmatchQueryTicketIdsRequest": {
-      "type": "object",
-      "properties": {
-        "pool": {
-          "$ref": "#/definitions/openmatchPool",
-          "description": "The Pool representing the set of Filters to be queried."
-        }
-      }
-    },
-    "openmatchQueryTicketIdsResponse": {
-      "type": "object",
-      "properties": {
-        "ids": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "TicketIDs that meet all the filtering criteria requested by the pool."
-        }
-      }
-    },
-    "openmatchQueryTicketsRequest": {
-      "type": "object",
-      "properties": {
-        "pool": {
-          "$ref": "#/definitions/openmatchPool",
-          "description": "The Pool representing the set of Filters to be queried."
-        }
-      }
-    },
-    "openmatchQueryTicketsResponse": {
-      "type": "object",
-      "properties": {
-        "tickets": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "$ref": "#/definitions/openmatchTicket"
-          },
-          "description": "Tickets that meet all the filtering criteria requested by the pool."
-        }
-      }
-    },
-    "openmatchSearchFields": {
-      "type": "object",
-      "properties": {
-        "double_args": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "number",
-            "format": "double"
-          },
-          "description": "Float arguments.  Filterable on ranges."
-        },
-        "string_args": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "string"
-          },
-          "description": "String arguments.  Filterable on equality."
-        },
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "Filterable on presence or absence of given value."
-        }
-      },
-      "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
-    },
-    "openmatchStringEqualsFilter": {
-      "type": "object",
-      "properties": {
-        "string_arg": {
-          "type": "string",
-          "description": "Name of the ticket's search_fields.string_args this Filter operates on."
-        },
-        "value": {
-          "type": "string"
-        }
-      },
-      "title": "Filters strings exactly equaling a value.\n  string_arg: \"foo\"\n  value: \"bar\"\nmatches:\n  {\"foo\": \"bar\"}\ndoes not match:\n  {\"foo\": \"baz\"}\n  {\"bar\": \"foo\"}\n  {}"
-    },
-    "openmatchTagPresentFilter": {
-      "type": "object",
-      "properties": {
-        "tag": {
-          "type": "string"
-        }
-      },
-      "title": "Filters to the tag being present on the search_fields.\n  tag: \"foo\"\nmatches:\n  [\"foo\"]\n  [\"bar\",\"foo\"]\ndoes not match:\n  [\"bar\"]\n  []"
-    },
-    "openmatchTicket": {
-      "type": "object",
-      "properties": {
-        "id": {
-          "type": "string",
-          "description": "Id represents an auto-generated Id issued by Open Match."
-        },
-        "assignment": {
-          "$ref": "#/definitions/openmatchAssignment",
-          "description": "An Assignment represents a game server assignment associated with a Ticket,\nor whatever finalized matched state means for your use case.\nOpen Match does not require or inspect any fields on Assignment."
-        },
-        "search_fields": {
-          "$ref": "#/definitions/openmatchSearchFields",
-          "description": "Search fields are the fields which Open Match is aware of, and can be used\nwhen specifying filters."
-        },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be used by the match\nmaking function, evaluator, and components making calls to Open Match.\nOptional, depending on the requirements of the connected systems."
-        },
-        "persistent_field": {
-          "type": "object",
-          "additionalProperties": {
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "Customized information not inspected by Open Match, to be kept persistent \nthroughout the life-cycle of a ticket. \nOptional, depending on the requirements of the connected systems."
-        },
-        "create_time": {
-          "type": "string",
-          "format": "date-time",
-          "description": "Create time is the time the Ticket was created. It is populated by Open\nMatch at the time of Ticket creation."
-        }
-      },
-      "description": "A Ticket is a basic matchmaking entity in Open Match. A Ticket may represent\nan individual 'Player', a 'Group' of players, or any other concepts unique to\nyour use case. Open Match will not interpret what the Ticket represents but\njust treat it as a matchmaking unit with a set of SearchFields. Open Match\nstores the Ticket in state storage and enables an Assignment to be set on the\nTicket."
-    },
-    "protobufAny": {
-      "type": "object",
-      "properties": {
-        "@type": {
-          "type": "string",
-          "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n  value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n  URL, or have them precompiled into a binary to avoid any\n  lookup. Therefore, binary compatibility needs to be preserved\n  on changes to types. (Use versioned type names to manage\n  breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics."
-        }
-      },
-      "additionalProperties": {},
-      "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n    Foo foo = ...;\n    Any any;\n    any.PackFrom(foo);\n    ...\n    if (any.UnpackTo(\u0026foo)) {\n      ...\n    }\n\nExample 2: Pack and unpack a message in Java.\n\n    Foo foo = ...;\n    Any any = Any.pack(foo);\n    ...\n    if (any.is(Foo.class)) {\n      foo = any.unpack(Foo.class);\n    }\n    // or ...\n    if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n      foo = any.unpack(Foo.getDefaultInstance());\n    }\n\n Example 3: Pack and unpack a message in Python.\n\n    foo = Foo(...)\n    any = Any()\n    any.Pack(foo)\n    ...\n    if any.Is(Foo.DESCRIPTOR):\n      any.Unpack(foo)\n      ...\n\n Example 4: Pack and unpack a message in Go\n\n     foo := \u0026pb.Foo{...}\n     any, err := anypb.New(foo)\n     if err != nil {\n       ...\n     }\n     ...\n     foo := \u0026pb.Foo{}\n     if err := any.UnmarshalTo(foo); err != nil {\n       ...\n     }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n    package google.profile;\n    message Person {\n      string first_name = 1;\n      string last_name = 2;\n    }\n\n    {\n      \"@type\": \"type.googleapis.com/google.profile.Person\",\n      \"firstName\": \u003cstring\u003e,\n      \"lastName\": \u003cstring\u003e\n    }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n    {\n      \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n      \"value\": \"1.212s\"\n    }"
-    },
-    "rpcStatus": {
-      "type": "object",
-      "properties": {
-        "code": {
-          "type": "integer",
-          "format": "int32",
-          "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]."
-        },
-        "message": {
-          "type": "string",
-          "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client."
-        },
-        "details": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "$ref": "#/definitions/protobufAny"
-          },
-          "description": "A list of messages that carry the error details.  There is a common set of\nmessage types for APIs to use."
-        }
-      },
-      "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)."
-    }
-  },
-  "externalDocs": {
-    "description": "Open Match Documentation",
-    "url": "https://open-match.dev/site/docs/"
-  }
-}

cloudbuild.yaml

@@ -16,9 +16,15 @@
 #                   Open Match Script for Google Cloud Build                   #
 ################################################################################
 
-# example command-line invocation:
+# To run this locally:
+# cloud-build-local --config=cloudbuild.yaml --dryrun=false --substitutions=_OM_VERSION=DEV .
+# To run this remotely:
 # gcloud builds submit --config=cloudbuild.yaml --substitutions=_OM_VERSION=DEV .
 
+# Requires gcloud to be installed to work. (https://cloud.google.com/sdk/)
+# gcloud auth login
+# gcloud components install cloud-build-local
+
 # This YAML contains all the build steps for building Open Match.
 # All PRs are verified against this script to prevent build breakages and regressions.
 
@@ -32,11 +38,8 @@
 #   Setup: Read-Write, similar to generate but steps that run before any other step.
 
 # Some useful things to know about Cloud Build.
-# When your build executes, Cloud Build copies the contents of your repository to /workspace, the default working directory for Cloud Build. 
-# Learn more about working directories on the Build configuration overview page https://cloud.google.com/build/docs/build-config-file-schema
-#   - Modifications that occur within /workspace are persisted between build steps.
-#   - If you want to replicate the build process from this file locally, you'll need to
-#     clone the open match github repo and set HEAD to the commit you're trying to build. 
+# The root of this repository is always stored in /workspace.
+#    Any modifications that occur within /workspace are persisted between builds anything else is forgotten.
 # If a build step has intermediate files that need to be persisted for a future step then use volumes.
 #    An example of this is the go-vol which is where the pkg/ data for go mod is stored.
 #    More information here: https://cloud.google.com/cloud-build/docs/build-config#build_steps
@@ -45,154 +48,132 @@
 
 steps:
 - id: 'Docker Image: open-match-build'
-  name: gcr.io/kaniko-project/executor:latest
-  args: [
-    "--destination=gcr.io/$PROJECT_ID/open-match-build", 
-    "--dockerfile=Dockerfile.ci",
-    "--cache=true",
-    "--cache-ttl=3600h",
-  ]
+  name: gcr.io/kaniko-project/executor
+  args: ['--destination=gcr.io/$PROJECT_ID/open-match-build', '--cache=true', '--cache-ttl=48h', '--dockerfile=Dockerfile.ci', '.']
   waitFor: ['-']
-  #name: gcr.io/cloud-builders/docker
-  #args: ['build', '-t', 'gcr.io/$PROJECT_ID/open-match-build', '-f', 'Dockerfile.ci', '.']
-  #waitFor: ['-']
-
-- id: 'Build: Clean'
-  name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', 'clean-third-party', 'clean-protos', 'clean-swagger-docs']
-  waitFor: ['Docker Image: open-match-build']
 
 - id: 'Test: Markdown'
   name: 'gcr.io/$PROJECT_ID/open-match-build'
   args: ['make', 'md-test']
-  waitFor: ['Build: Clean']
+  waitFor: ['Docker Image: open-match-build']
 
-- id: 'Setup: Clean Go Dependencies'
+- id: 'Build: Clean'
   name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', 'clean-deps']
-  volumes:
-  - name: 'go-vol'
-    path: '/go'
-  waitFor: ['Build: Clean']
+  args: ['make', 'clean']
+  waitFor: ['Docker Image: open-match-build']
 
-- id: 'Build: Initialize Toolchain'
-  name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', 'install-toolchain']
-  volumes:
-  - name: 'go-vol'
-    path: '/go'
-  waitFor: ['Setup: Clean Go Dependencies']
-
-- id: 'Build: Compile Protos'
-  name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', 'golang-protos']
-  volumes:
-  - name: 'go-vol'
-    path: '/go'
-  waitFor: ['Build: Initialize Toolchain']
-
-- id: 'Setup: Download Go Dependencies'
+- id: 'Setup: Download Dependencies'
   name: 'gcr.io/$PROJECT_ID/open-match-build'
   args: ['make', 'sync-deps']
   volumes:
   - name: 'go-vol'
     path: '/go'
-  waitFor: ['Build: Compile Protos']
+  waitFor: ['Build: Clean']
 
-- id: 'Build: Deployment Configs'
+- id: 'Build: Install Toolchain'
   name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', 'SHORT_SHA=${SHORT_SHA}', 'update-chart-deps', 'install/yaml/']
-  waitFor: ['Setup: Download Go Dependencies']
-
-- id: 'Test: Terraform Configuration'
-  name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', 'terraform-test']
-  waitFor: ['Setup: Download Go Dependencies']
+  args: ['make', 'install-toolchain']
+  volumes:
+  - name: 'go-vol'
+    path: '/go'
+  waitFor: ['Setup: Download Dependencies']
 
 - id: 'Build: Assets'
   name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', '_CHARTS_BUCKET=${_CHARTS_BUCKET}', 'assets', '-j12']
+  args: ['make', 'all-protos', 'tls-certs', '-j8']
   volumes:
   - name: 'go-vol'
     path: '/go'
-  waitFor: ['Build: Deployment Configs']
+  waitFor: ['Build: Install Toolchain']
 
 - id: 'Build: Binaries'
   name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', '_CHARTS_BUCKET=${_CHARTS_BUCKET}', 'build', 'all', '-j12']
+  args: ['make', 'GOPROXY=off', 'all', '-j8']
   volumes:
   - name: 'go-vol'
     path: '/go'
   waitFor: ['Build: Assets']
-
-- id: 'Test: Services'
+- id: 'Test: Core'
   name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', 'GOLANG_TEST_COUNT=3', 'test']
-  # When debugging failing tests, enable verbose 'go test' output, run additional passes
-  #args: ['make', 'GOLANG_EXTRA_TEST_FLAGS=-v', 'GOLANG_TEST_COUNT=10', 'test']
+  args: ['make', 'GOPROXY=off', 'ci-test']
   volumes:
   - name: 'go-vol'
     path: '/go'
   waitFor: ['Build: Assets']
-
 - id: 'Build: Docker Images'
   name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', '_GCB_POST_SUBMIT=${_GCB_POST_SUBMIT}', '_GCB_LATEST_VERSION=${_GCB_LATEST_VERSION}', 'SHORT_SHA=${SHORT_SHA}', 'BRANCH_NAME=${BRANCH_NAME}', 'push-images', '-j8']
+  args: ['make', 'VERSION_SUFFIX=$SHORT_SHA', 'push-images', '-j8']
   waitFor: ['Build: Assets']
 
+- id: 'Build: Deployment Configs'
+  name: 'gcr.io/$PROJECT_ID/open-match-build'
+  args: ['make', 'VERSION_SUFFIX=$SHORT_SHA', 'clean-install-yaml', 'install/yaml/']
+  waitFor: ['Build: Install Toolchain']
+
 - id: 'Lint: Format, Vet, Charts'
   name: 'gcr.io/$PROJECT_ID/open-match-build'
   args: ['make', 'lint']
   volumes:
   - name: 'go-vol'
     path: '/go'
-  waitFor: ['Build: Assets']
+  waitFor: ['Build: Assets', 'Build: Deployment Configs']
 
-- id: 'Test: Deploy Open Match'
+- id: 'Build: Website'
   name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', 'SHORT_SHA=${SHORT_SHA}', 'OPEN_MATCH_KUBERNETES_NAMESPACE=open-match-${BUILD_ID}', 'OPEN_MATCH_RELEASE_NAME=open-match-${BUILD_ID}', 'auth-gke-cluster', 'delete-chart', 'ci-reap-namespaces', 'install-ci-chart']
-  waitFor: ['Build: Docker Images']
+  args: ['make', 'build/site/']
+  waitFor: ['Build: Install Toolchain']
+
+- id: 'Test: Website'
+  name: 'gcr.io/$PROJECT_ID/open-match-build'
+  args: ['make', 'site-test']
+  waitFor: ['Build: Website']
+
+- id: 'Deploy: Website'
+  name: 'gcr.io/$PROJECT_ID/open-match-build'
+  args: ['make', '_GCB_POST_SUBMIT=${_GCB_POST_SUBMIT}', '_GCB_LATEST_VERSION=${_GCB_LATEST_VERSION}', VERSION_SUFFIX=$SHORT_SHA', 'BRANCH_NAME=$BRANCH_NAME', 'ci-deploy-site']
+  waitFor: ['Test: Website', 'Build: Binaries']
+  volumes:
+  - name: 'go-vol'
+    path: '/go'
 
 - id: 'Deploy: Deployment Configs'
   name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', '_GCB_POST_SUBMIT=${_GCB_POST_SUBMIT}', '_GCB_LATEST_VERSION=${_GCB_LATEST_VERSION}', 'SHORT_SHA=${SHORT_SHA}', 'BRANCH_NAME=${BRANCH_NAME}', '_CHARTS_BUCKET=${_CHARTS_BUCKET}',  'ci-deploy-artifacts']
-  waitFor: ['Lint: Format, Vet, Charts', 'Test: Deploy Open Match']
+  args: ['make', '_GCB_POST_SUBMIT=${_GCB_POST_SUBMIT}', '_GCB_LATEST_VERSION=${_GCB_LATEST_VERSION}', VERSION_SUFFIX=$SHORT_SHA', 'BRANCH_NAME=$BRANCH_NAME', 'ci-deploy-artifacts']
+  waitFor: ['Lint: Format, Vet, Charts', 'Build: Binaries']
   volumes:
   - name: 'go-vol'
     path: '/go'
 
-- id: 'Test: End-to-End Cluster'
-  name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', 'GOPROXY=off', 'SHORT_SHA=${SHORT_SHA}', 'OPEN_MATCH_KUBERNETES_NAMESPACE=open-match-${BUILD_ID}', 'test-e2e-cluster']
-  waitFor: ['Test: Deploy Open Match', 'Build: Assets']
-  volumes:
-  - name: 'go-vol'
-    path: '/go'
-
-- id: 'Test: Delete Open Match'
-  name: 'gcr.io/$PROJECT_ID/open-match-build'
-  args: ['make', 'GCLOUD_EXTRA_FLAGS=--async', 'SHORT_SHA=${SHORT_SHA}', 'OPEN_MATCH_KUBERNETES_NAMESPACE=open-match-${BUILD_ID}', 'OPEN_MATCH_RELEASE_NAME=open-match-${BUILD_ID}', 'GCP_PROJECT_ID=${PROJECT_ID}', 'delete-chart']
-  waitFor: ['Test: End-to-End Cluster']
-
 artifacts:
     objects:
-        location: '${_ARTIFACTS_BUCKET}${_OM_VERSION}'
+        location: gs://open-match-build-artifacts/output/
         paths:
-            - install/yaml/*.yaml
-            - pkg/pb/*.pb.go
-            - pkg/pb/*.pb.gw.go
-            - internal/ipb/*.pb.go
-            - api/*.swagger.json
-            
+            - cmd/backend/backend
+            - cmd/frontend/frontend
+            - cmd/mmlogic/mmlogic
+            - cmd/evaluator/evaluator
+            - cmd/minimatch/minimatch
+            - install/yaml/install.yaml
+            - install/yaml/install-demo.yaml
+            - install/yaml/01-redis-chart.yaml
+            - install/yaml/02-open-match.yaml
+            - install/yaml/03-prometheus-chart.yaml
+            - install/yaml/04-grafana-chart.yaml
+            - install/yaml/05-jaeger-chart.yaml
+            - examples/functions/golang/simple/simple
+images:
+- 'gcr.io/$PROJECT_ID/openmatch-backend:${_OM_VERSION}-${SHORT_SHA}'
+- 'gcr.io/$PROJECT_ID/openmatch-frontend:${_OM_VERSION}-${SHORT_SHA}'
+- 'gcr.io/$PROJECT_ID/openmatch-mmlogic:${_OM_VERSION}-${SHORT_SHA}'
+- 'gcr.io/$PROJECT_ID/openmatch-evaluator:${_OM_VERSION}-${SHORT_SHA}'
+- 'gcr.io/$PROJECT_ID/openmatch-minimatch:${_OM_VERSION}-${SHORT_SHA}'
+- 'gcr.io/$PROJECT_ID/openmatch-mmf-go-simple:${_OM_VERSION}-${SHORT_SHA}'
 substitutions:
-    _OM_VERSION: "1.8.0"
+    _OM_VERSION: "0.0.0-dev"
     _GCB_POST_SUBMIT: "0"
     _GCB_LATEST_VERSION: "undefined"
-    _ARTIFACTS_BUCKET: "gs://open-match-build-artifacts/"
-    _LOGS_BUCKET: "gs://open-match-build-logs/"
-    _CHARTS_BUCKET: "gs://open-match-chart"
-logsBucket: '${_LOGS_BUCKET}'
+logsBucket: 'gs://open-match-build-logs/'
 options:
   sourceProvenanceHash: ['SHA256']
   machineType: 'N1_HIGHCPU_32'
-timeout: 2500s
+timeout: 1200s

cmd/backend/Dockerfile

@@ -0,0 +1,55 @@
+# Copyright 2019 Google LLC
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FROM open-match-base-build as builder
+
+WORKDIR /go/src/open-match.dev/open-match/cmd/backend/
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo .
+
+FROM gcr.io/distroless/static
+COPY --from=builder /go/src/open-match.dev/open-match/cmd/backend/backend .
+
+ENTRYPOINT ["/backend"]
+
+# Docker Image Arguments
+ARG BUILD_DATE
+ARG VCS_REF
+ARG BUILD_VERSION
+ARG IMAGE_TITLE="Open Match Backend API"
+
+# Standardized Docker Image Labels
+# https://github.com/opencontainers/image-spec/blob/master/annotations.md
+LABEL \
+    org.opencontainers.image.created="${BUILD_TIME}" \
+    org.opencontainers.image.authors="Google LLC <open-match-discuss@googlegroups.com>" \
+    org.opencontainers.image.url="https://open-match.dev/" \
+    org.opencontainers.image.documentation="https://open-match.dev/site/docs/" \
+    org.opencontainers.image.source="https://github.com/googleforgames/open-match" \
+    org.opencontainers.image.version="${BUILD_VERSION}" \
+    org.opencontainers.image.revision="1" \
+    org.opencontainers.image.vendor="Google LLC" \
+    org.opencontainers.image.licenses="Apache-2.0" \
+    org.opencontainers.image.ref.name="" \
+    org.opencontainers.image.title="${IMAGE_TITLE}" \
+    org.opencontainers.image.description="Flexible, extensible, and scalable video game matchmaking." \
+    org.label-schema.schema-version="1.0" \
+    org.label-schema.build-date=$BUILD_DATE \
+    org.label-schema.url="http://open-match.dev/" \
+    org.label-schema.vcs-url="https://github.com/googleforgames/open-match" \
+    org.label-schema.version=$BUILD_VERSION \
+    org.label-schema.vcs-ref=$VCS_REF \
+    org.label-schema.vendor="Google LLC" \
+    org.label-schema.name="${IMAGE_TITLE}" \
+    org.label-schema.description="Flexible, extensible, and scalable video game matchmaking." \
+    org.label-schema.usage="https://open-match.dev/site/docs/"

cmd/backend/backend.go

@@ -17,9 +17,8 @@ package main
 
 import (
 	"open-match.dev/open-match/internal/app/backend"
-	"open-match.dev/open-match/internal/appmain"
 )
 
 func main() {
-	appmain.RunApplication("backend", backend.BindService)
+	backend.RunApplication()
 }

cmd/default-evaluator/main.go

@@ -1,24 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-import (
-	"open-match.dev/open-match/internal/app/evaluator/defaulteval"
-	"open-match.dev/open-match/internal/appmain"
-)
-
-func main() {
-	appmain.RunApplication("evaluator", defaulteval.BindService)
-}

cmd/demo-first-match/main.go

@@ -1,31 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-import (
-	"open-match.dev/open-match/examples/demo"
-	"open-match.dev/open-match/examples/demo/components"
-	"open-match.dev/open-match/examples/demo/components/clients"
-	"open-match.dev/open-match/examples/demo/components/director"
-	"open-match.dev/open-match/examples/demo/components/uptime"
-)
-
-func main() {
-	demo.Run(map[string]func(*components.DemoShared){
-		"uptime":   uptime.Run,
-		"clients":  clients.Run,
-		"director": director.Run,
-	})
-}

cmd/evaluator/Dockerfile

@@ -0,0 +1,55 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FROM open-match-base-build as builder
+
+WORKDIR /go/src/open-match.dev/open-match/cmd/evaluator/
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo .
+
+FROM gcr.io/distroless/static
+COPY --from=builder /go/src/open-match.dev/open-match/cmd/evaluator/evaluator .
+
+ENTRYPOINT ["/evaluator"]
+
+# Docker Image Arguments
+ARG BUILD_DATE
+ARG VCS_REF
+ARG BUILD_VERSION
+ARG IMAGE_TITLE="Open Match Evaluator API"
+
+# Standardized Docker Image Labels
+# https://github.com/opencontainers/image-spec/blob/master/annotations.md
+LABEL \
+    org.opencontainers.image.created="${BUILD_TIME}" \
+    org.opencontainers.image.authors="Google LLC <open-match-discuss@googlegroups.com>" \
+    org.opencontainers.image.url="https://open-match.dev/" \
+    org.opencontainers.image.documentation="https://open-match.dev/site/docs/" \
+    org.opencontainers.image.source="https://github.com/googleforgames/open-match" \
+    org.opencontainers.image.version="${BUILD_VERSION}" \
+    org.opencontainers.image.revision="1" \
+    org.opencontainers.image.vendor="Google LLC" \
+    org.opencontainers.image.licenses="Apache-2.0" \
+    org.opencontainers.image.ref.name="" \
+    org.opencontainers.image.title="${IMAGE_TITLE}" \
+    org.opencontainers.image.description="Flexible, extensible, and scalable video game matchmaking." \
+    org.label-schema.schema-version="1.0" \
+    org.label-schema.build-date=$BUILD_DATE \
+    org.label-schema.url="http://open-match.dev/" \
+    org.label-schema.vcs-url="https://github.com/googleforgames/open-match" \
+    org.label-schema.version=$BUILD_VERSION \
+    org.label-schema.vcs-ref=$VCS_REF \
+    org.label-schema.vendor="Google LLC" \
+    org.label-schema.name="${IMAGE_TITLE}" \
+    org.label-schema.description="Flexible, extensible, and scalable video game matchmaking." \
+    org.label-schema.usage="https://open-match.dev/site/docs/"

cmd/evaluator/evaluator.go

@@ -0,0 +1,29 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package main is the evaluator service for Open Match.
+package main
+
+import (
+	"open-match.dev/open-match/internal/app/evaluator"
+	"open-match.dev/open-match/internal/pb"
+)
+
+func main() {
+	evaluator.RunApplication(&evaluator.FunctionSettings{Func: evaluate})
+}
+
+func evaluate(candidates []*pb.Match) []*pb.Match {
+	return candidates
+}

cmd/frontend/Dockerfile

@@ -0,0 +1,55 @@
+# Copyright 2019 Google LLC
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FROM open-match-base-build as builder
+
+WORKDIR /go/src/open-match.dev/open-match/cmd/frontend/
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo .
+
+FROM gcr.io/distroless/static
+COPY --from=builder /go/src/open-match.dev/open-match/cmd/frontend/frontend .
+
+ENTRYPOINT ["/frontend"]
+
+# Docker Image Arguments
+ARG BUILD_DATE
+ARG VCS_REF
+ARG BUILD_VERSION
+ARG IMAGE_TITLE="Open Match Frontend API"
+
+# Standardized Docker Image Labels
+# https://github.com/opencontainers/image-spec/blob/master/annotations.md
+LABEL \
+    org.opencontainers.image.created="${BUILD_TIME}" \
+    org.opencontainers.image.authors="Google LLC <open-match-discuss@googlegroups.com>" \
+    org.opencontainers.image.url="https://open-match.dev/" \
+    org.opencontainers.image.documentation="https://open-match.dev/site/docs/" \
+    org.opencontainers.image.source="https://github.com/googleforgames/open-match" \
+    org.opencontainers.image.version="${BUILD_VERSION}" \
+    org.opencontainers.image.revision="1" \
+    org.opencontainers.image.vendor="Google LLC" \
+    org.opencontainers.image.licenses="Apache-2.0" \
+    org.opencontainers.image.ref.name="" \
+    org.opencontainers.image.title="${IMAGE_TITLE}" \
+    org.opencontainers.image.description="Flexible, extensible, and scalable video game matchmaking." \
+    org.label-schema.schema-version="1.0" \
+    org.label-schema.build-date=$BUILD_DATE \
+    org.label-schema.url="http://open-match.dev/" \
+    org.label-schema.vcs-url="https://github.com/googleforgames/open-match" \
+    org.label-schema.version=$BUILD_VERSION \
+    org.label-schema.vcs-ref=$VCS_REF \
+    org.label-schema.vendor="Google LLC" \
+    org.label-schema.name="${IMAGE_TITLE}" \
+    org.label-schema.description="Flexible, extensible, and scalable video game matchmaking." \
+    org.label-schema.usage="https://open-match.dev/site/docs/"

cmd/frontend/frontend.go

@@ -17,9 +17,8 @@ package main
 
 import (
 	"open-match.dev/open-match/internal/app/frontend"
-	"open-match.dev/open-match/internal/appmain"
 )
 
 func main() {
-	appmain.RunApplication("frontend", frontend.BindService)
+	frontend.RunApplication()
 }

cmd/minimatch/Dockerfile

@@ -0,0 +1,55 @@
+# Copyright 2019 Google LLC
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FROM open-match-base-build as builder
+
+WORKDIR /go/src/open-match.dev/open-match/cmd/minimatch/
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo .
+
+FROM gcr.io/distroless/static
+COPY --from=builder /go/src/open-match.dev/open-match/cmd/minimatch/minimatch .
+
+ENTRYPOINT ["/minimatch"]
+
+# Docker Image Arguments
+ARG BUILD_DATE
+ARG VCS_REF
+ARG BUILD_VERSION
+ARG IMAGE_TITLE="Mini Match"
+
+# Standardized Docker Image Labels
+# https://github.com/opencontainers/image-spec/blob/master/annotations.md
+LABEL \
+    org.opencontainers.image.created="${BUILD_TIME}" \
+    org.opencontainers.image.authors="Google LLC <open-match-discuss@googlegroups.com>" \
+    org.opencontainers.image.url="https://open-match.dev/" \
+    org.opencontainers.image.documentation="https://open-match.dev/site/docs/" \
+    org.opencontainers.image.source="https://github.com/googleforgames/open-match" \
+    org.opencontainers.image.version="${BUILD_VERSION}" \
+    org.opencontainers.image.revision="1" \
+    org.opencontainers.image.vendor="Google LLC" \
+    org.opencontainers.image.licenses="Apache-2.0" \
+    org.opencontainers.image.ref.name="" \
+    org.opencontainers.image.title="${IMAGE_TITLE}" \
+    org.opencontainers.image.description="Flexible, extensible, and scalable video game matchmaking." \
+    org.label-schema.schema-version="1.0" \
+    org.label-schema.build-date=$BUILD_DATE \
+    org.label-schema.url="http://open-match.dev/" \
+    org.label-schema.vcs-url="https://github.com/googleforgames/open-match" \
+    org.label-schema.version=$BUILD_VERSION \
+    org.label-schema.vcs-ref=$VCS_REF \
+    org.label-schema.vendor="Google LLC" \
+    org.label-schema.name="${IMAGE_TITLE}" \
+    org.label-schema.description="Flexible, extensible, and scalable video game matchmaking." \
+    org.label-schema.usage="https://open-match.dev/site/docs/"

cmd/minimatch/main.go

@@ -17,9 +17,8 @@ package main
 
 import (
 	"open-match.dev/open-match/internal/app/minimatch"
-	"open-match.dev/open-match/internal/appmain"
 )
 
 func main() {
-	appmain.RunApplication("minimatch", minimatch.BindService)
+	minimatch.RunApplication()
 }

cmd/mmlogic/Dockerfile

@@ -0,0 +1,55 @@
+# Copyright 2019 Google LLC
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FROM open-match-base-build as builder
+
+WORKDIR /go/src/open-match.dev/open-match/cmd/mmlogic/
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo .
+
+FROM gcr.io/distroless/static
+COPY --from=builder /go/src/open-match.dev/open-match/cmd/mmlogic/mmlogic .
+
+ENTRYPOINT ["/mmlogic"]
+
+# Docker Image Arguments
+ARG BUILD_DATE
+ARG VCS_REF
+ARG BUILD_VERSION
+ARG IMAGE_TITLE="Open Match Data API"
+
+# Standardized Docker Image Labels
+# https://github.com/opencontainers/image-spec/blob/master/annotations.md
+LABEL \
+    org.opencontainers.image.created="${BUILD_TIME}" \
+    org.opencontainers.image.authors="Google LLC <open-match-discuss@googlegroups.com>" \
+    org.opencontainers.image.url="https://open-match.dev/" \
+    org.opencontainers.image.documentation="https://open-match.dev/site/docs/" \
+    org.opencontainers.image.source="https://github.com/googleforgames/open-match" \
+    org.opencontainers.image.version="${BUILD_VERSION}" \
+    org.opencontainers.image.revision="1" \
+    org.opencontainers.image.vendor="Google LLC" \
+    org.opencontainers.image.licenses="Apache-2.0" \
+    org.opencontainers.image.ref.name="" \
+    org.opencontainers.image.title="${IMAGE_TITLE}" \
+    org.opencontainers.image.description="Flexible, extensible, and scalable video game matchmaking." \
+    org.label-schema.schema-version="1.0" \
+    org.label-schema.build-date=$BUILD_DATE \
+    org.label-schema.url="http://open-match.dev/" \
+    org.label-schema.vcs-url="https://github.com/googleforgames/open-match" \
+    org.label-schema.version=$BUILD_VERSION \
+    org.label-schema.vcs-ref=$VCS_REF \
+    org.label-schema.vendor="Google LLC" \
+    org.label-schema.name="${IMAGE_TITLE}" \
+    org.label-schema.description="Flexible, extensible, and scalable video game matchmaking." \
+    org.label-schema.usage="https://open-match.dev/site/docs/"

cmd/mmlogic/mmlogic.go

@@ -0,0 +1,24 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package main is the mmlogic service for Open Match.
+package main
+
+import (
+	"open-match.dev/open-match/internal/app/mmlogic"
+)
+
+func main() {
+	mmlogic.RunApplication()
+}

cmd/query/query.go

@@ -1,25 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package main is the query service for Open Match.
-package main
-
-import (
-	"open-match.dev/open-match/internal/app/query"
-	"open-match.dev/open-match/internal/appmain"
-)
-
-func main() {
-	appmain.RunApplication("query", query.BindService)
-}

cmd/scale-backend/main.go

@@ -1,24 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-import (
-	"open-match.dev/open-match/examples/scale/backend"
-	"open-match.dev/open-match/internal/appmain"
-)
-
-func main() {
-	appmain.RunApplication("scale", backend.BindService)
-}

cmd/scale-evaluator/main.go

@@ -1,22 +0,0 @@
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-import (
-	scaleEvaluator "open-match.dev/open-match/examples/scale/evaluator"
-)
-
-func main() {
-	scaleEvaluator.Run()
-}

cmd/scale-frontend/main.go

@@ -1,24 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-import (
-	"open-match.dev/open-match/examples/scale/frontend"
-	"open-match.dev/open-match/internal/appmain"
-)
-
-func main() {
-	appmain.RunApplication("scale", frontend.BindService)
-}

cmd/scale-mmf/main.go

@@ -1,23 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-import (
-	scaleMmf "open-match.dev/open-match/examples/scale/mmf"
-)
-
-func main() {
-	scaleMmf.Run()
-}

cmd/swaggerui/config.json

@@ -1,10 +0,0 @@
-{
-    "urls": [
-        {"name": "Frontend", "url": "https://open-match.dev/api/v0.0.0-dev/frontend.swagger.json"},
-        {"name": "Backend", "url": "https://open-match.dev/api/v0.0.0-dev/backend.swagger.json"},
-        {"name": "Query", "url": "https://open-match.dev/api/v0.0.0-dev/query.swagger.json"},
-        {"name": "MatchFunction", "url": "https://open-match.dev/api/v0.0.0-dev/matchfunction.swagger.json"},
-        {"name": "Synchronizer", "url": "https://open-match.dev/api/v0.0.0-dev/synchronizer.swagger.json"},
-        {"name": "Evaluator", "url": "https://open-match.dev/api/v0.0.0-dev/evaluator.swagger.json"}
-    ]
-}

cmd/swaggerui/swaggerui.go

@@ -1,24 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package main is a simple webserver for hosting Open Match Swagger UI.
-package main
-
-import (
-	"open-match.dev/open-match/internal/app/swaggerui"
-)
-
-func main() {
-	swaggerui.RunApplication()
-}

cmd/synchronizer/synchronizer.go

@@ -1,25 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package main is the synchronizer service for Open Match.
-package main
-
-import (
-	"open-match.dev/open-match/internal/app/synchronizer"
-	"open-match.dev/open-match/internal/appmain"
-)
-
-func main() {
-	appmain.RunApplication("synchronizer", synchronizer.BindService)
-}

docs/concepts.md

@@ -0,0 +1,114 @@
+# Core Concepts
+
+[Watch the introduction of Open Match at Unite Berlin 2018 on YouTube](https://youtu.be/qasAmy_ko2o)
+
+Open Match is designed to support massively concurrent matchmaking, and to be scalable to player populations of hundreds of millions or more. It attempts to apply stateless web tech microservices patterns to game matchmaking. If you're not sure what that means, that's okay — it is fully open source and designed to be customizable to fit into your online game architecture — so have a look a the code and modify it as you see fit.
+
+## Glossary
+
+### General
+
+* **DGS** — Dedicated game server
+* **Client** — The game client program the player uses when playing the game
+* **Session** — In Open Match, players are matched together, then assigned to a server which hosts the game _session_.  Depending on context, this may be referred to as a _match_, _map_, or just _game_ elsewhere in the industry.
+
+### Open Match
+
+* **Component** — One of the discrete processes in an Open Match deployment. Open Match is composed of multiple scalable microservices called _components_.
+* **State Storage** — The storage software used by Open Match to hold all the matchmaking state. Open Match ships with [Redis](https://redis.io/) as the default state storage.
+* **MMF** — Matchmaking function. This is the customizable matchmaking logic.
+* **Function Harness** — A GRPC serving harness that triggers the Match function.
+* **Evaluator** — Customizable evaluation logic that analyzes match proposals and approves / rejects matches.
+* **MMLogic API** — An API that provides MMF SDK functionality.
+* **Director** — The software you (as a developer) write against the Open Match Backend API. The _Director_ decides which MMFs to run, and is responsible for sending MMF results to a DGS to host the session.
+
+### Data Model
+
+* **Player** — An ID and list of attributes with values for a player who wants to participate in matchmaking.
+* **Roster** — A list of player objects.  Used to hold all the players on a single team.
+* **Filter** — A _filter_ is used to narrow down the players to only those who have an attribute value within a certain integer range.  All attributes are integer values in Open Match because [that is how indices are implemented](internal/statestorage/redis/playerindices/playerindices.go). A _filter_ is defined in a _player pool_.
+* **Player Pool** — A list of all the players who fit all the _filters_ defined in the pool.
+* **Match Object** — A protobuffer message format that contains the _profile_ and the results of the matchmaking function. Sent to the backend API from your game backend with the _roster_(s) empty and then returned from your MMF with the matchmaking results filled in.
+* **Profile** — The json blob containing all the parameters used by your MMF to select which players go into a roster together.
+* **Assignment** — Refers to assigning a player or group of players to a dedicated game server instance. Open Match offers a path to send dedicated game server connection details from your backend to your game clients after a match has been made.
+* **Ignore List** — Removing players from matchmaking consideration is accomplished using _ignore lists_.  They contain lists of player IDs that your MMF should not include when making matches.
+
+## Requirements
+
+* [Kubernetes](https://kubernetes.io/) cluster — tested with version 1.11.7.
+* [Redis 4+](https://redis.io/) — tested with 4.0.11.
+* Open Match is compiled against the latest release of [Golang](https://golang.org/) — tested with 1.11.5.
+
+## Components
+
+Open Match is a set of processes designed to run on Kubernetes. It contains these **core** components:
+
+* Frontend API
+* Backend API
+* Matchmaking Logic (MMLogic) API
+
+It also depends on these two **customizable** components.
+
+* Match Function (MMF)
+* Evaluator
+
+While **core** components are fully open source and _can_ be modified, they are designed to support the majority of matchmaking scenarios *without need to change the source code*. The Open Match repository ships with simple **customizable** MMF and Evaluator examples, but it is expected that most users will want full control over the logic in these, so they have been designed to be as easy to modify or replace as possible.
+
+### Frontend API
+
+The Frontend API accepts the player data and puts it in state storage so your Matchmaking Function (MMF) can access it.
+
+The Frontend API is a server application that implements the [gRPC](https://grpc.io/) service defined in `api/protobuf-spec/frontend.proto`. At the most basic level, it expects clients to connect and send:
+* A **unique ID** for the group of players (the group can contain any number of players, including only one).
+* A **json blob** containing all player-related data you want to use in your matchmaking function.
+
+The client is expected to maintain a connection, waiting for an update from the API that contains the details required to connect to a dedicated game server instance (an 'assignment'). There are also basic functions for removing an ID from the matchmaking pool or an existing match.
+
+### Backend API
+
+The Backend API writes match objects to state storage which the Matchmaking Functions (MMFs) access to decide which players should be matched. It returns the results from those MMFs.
+
+The Backend API is a server application that implements the [gRPC](https://grpc.io/) service defined in `api/protobuf-spec/backend.proto`. At the most basic level, it expects to be connected to your online infrastructure (probably to your server scaling manager or **director**, or even directly to a dedicated game server), and to receive:
+* A **unique ID** for a matchmaking profile.
+* A **json blob** containing all the matching-related data and filters you want to use in your matchmaking function.
+* An optional list of **roster**s to hold the resulting teams chosen by your matchmaking function.
+* An optional set of **filters** that define player pools your matchmaking function will choose players from.
+
+Your game backend is expected to maintain a connection, waiting for 'filled' match objects containing a roster of players. The Backend API also provides a return path for your game backend to return dedicated game server connection details (an 'assignment') to the game client, and to delete these 'assignments'.
+
+### Matchmaking Logic (MMLogic) API
+
+The MMLogic API provides a series of gRPC functions that act as a Matchmaking Function SDK.  Much of the basic, boilerplate code for an MMF is the same regardless of what players you want to match together.  The MMLogic API offers a gRPC interface for many common MMF tasks, such as:
+
+1. Reading a profile from state storage.
+1. Running filters on players in state strorage. It automatically removes players on ignore lists as well!
+1. Removing chosen players from consideration by other MMFs (by adding them to an ignore list). It does it automatically for you when writing your results!
+1. Writing the matchmaking results to state storage.
+1. (Optional, NYI) Exporting MMF stats for metrics collection.
+
+More details about the available gRPC calls can be found in the [API Specification](api/protobuf-spec/messages.proto).
+
+**Note**: using the MMLogic API is **optional**.  It tries to simplify the development of MMFs, but if you want to take care of these tasks on your own, you can make few or no calls to the MMLogic API as long as your MMF still completes all the required tasks.  Read the [Matchmaking Functions section](#matchmaking-functions-mmfs) for more details of what work an MMF must do.
+
+### Evaluator
+
+The Evaluator resolves conflicts when multiple MMFs select the same player(s). Evaluator is provided by the developer (sample included in Open Match).
+
+The Evaluator runs forever, looping over a configured interval, checking if MMFs have completed execution or if certain time interval has passed. Upon reaching those conditions, the Evaluator calls the Evaluation Function (to be modified by the user) with the proposals to choose from. The sample Evaluation function looks at all the proposals, and if multiple proposals contain the same player(s), it breaks the tie. In many simple matchmaking setups with only a few game modes and well-tuned matchmaking functions, the Evaluator may functionally be a no-op or first-in-first-out algorithm. In complex matchmaking setups where, for example, a player can queue for multiple types of matches, the Evaluator provides the critical customizability to evaluate all available proposals and approve those that will passed to your game servers.
+
+Large-scale concurrent matchmaking functions is a complex topic, and users who wish to do this are encouraged to engage with the [Open Match community](https://github.com/googleforgames/open-match#get-involved) about patterns and best practices.
+
+### Matchmaking Functions (MMFs)
+
+Matchmaking Functions (MMFs) are implemented by the developer and are hosted as a gRPC service. Open Match provides a harness (currently for golang) that handles the broiler-plate Open Match communitation, gRPC server setup etc., so that the user only has to write a function that accepts a set of player pools and a match profile and returns a proposal based on some core match making logic. An MMF is called each time a request to generate a match is received. At a high level, an MMF needs to generate a proposal using the given players, match profile and its custom match making logic and return the proposal to the calling harness.
+**Note**: Currently Open Match only has a golang harness. To add an MMF in any other language, a harness needs to be implemented in that language.
+
+## Example Tooling
+
+To see Open Match, in action, here are some basic tools that are provided as samples:
+
+* `test/cmd/clientloadgen/` is a (VERY) basic client load simulation tool.  It endlessly writes players into state storage so you can test your backend integration, and run your custom MMFs and Evaluators (which are only triggered when there are players in the pool).
+
+* `examples/backendclient` is a fake client for the Backend API.  It pretends to be a dedicated game server backend connecting to Open Match and sending in a match profile to fill and receives completed matches. It can call Create / List matches.
+
+* `test/cmd/frontendclient/` is a fake client for the Frontend API.  It pretends to be group of real game clients connecting to Open Match.  It requests a game, then dumps out the results each player receives to the screen.

docs/development.md

@@ -1,20 +1,26 @@
 # Development Guide
 
-Open Match is a collection of [Go](https://golang.org/) gRPC services that run
+Open Match is a collection of [Go](https://golang.org/) applications that run
 within [Kubernetes](https://kubernetes.io).
 
+If you're not familiar with either that's ok, you can checkout the
+[reference material](references.md). Knowledge of these tools is not
+required to setup your environment.
+
 ## Install Prerequisites
 
 To build Open Match you'll need the following applications installed.
 
  * [Git](https://git-scm.com/downloads)
  * [Go](https://golang.org/doc/install)
+ * [Python3 with virtualenv](https://wiki.python.org/moin/BeginnersGuide/Download)
  * Make (Mac: install [XCode](https://itunes.apple.com/us/app/xcode/id497799835))
  * [Docker](https://docs.docker.com/install/) including the
    [post-install steps](https://docs.docker.com/install/linux/linux-postinstall/).
 
 Optional Software
 
+ * [Google Cloud Platform](gcloud.md)
  * [Visual Studio Code](https://code.visualstudio.com/Download) for IDE.
    Vim and Emacs work to.
  * [VirtualBox](https://www.virtualbox.org/wiki/Downloads) recommended for
@@ -25,7 +31,8 @@ running:
 
 ```bash
 sudo apt-get update
-sudo apt-get install -y -q make google-cloud-sdk git unzip tar
+sudo apt-get install -y -q python3 python3-virtualenv virtualenv make \
+  google-cloud-sdk git unzip tar
 ```
 
 *It's recommended that you install Go using their instructions because package
@@ -46,13 +53,15 @@ make
 
 *Typically for contributing you'll want to
 [create a fork](https://help.github.com/en/articles/fork-a-repo) and use that
-but for purpose of this guide we'll be using the upstream/main.*
+but for purpose of this guide we'll be using the upstream/master.*
 
-## Building code and images
+## Building
 
 ```bash
 # Reset workspace
 make clean
+# Compile all the binaries
+make all -j$(nproc)
 # Run tests
 make test
 # Build all the images.
@@ -61,8 +70,6 @@ make build-images -j$(nproc)
 make push-images -j$(nproc)
 # Push images to Docker Hub
 make REGISTRY=mydockerusername push-images -j$(nproc)
-# Generate Kubernetes installation YAML files (Note that the trailing '/' is needed here)
-make install/yaml/
 ```
 
 _**-j$(nproc)** is a flag to tell make to parallelize the commands based on
@@ -82,9 +89,11 @@ default context the Makefile will honor that._
 # GKE cluster: make create-gke-cluster/delete-gke-cluster
 # or create a local Minikube cluster
 make create-gke-cluster
-# Step 2: Build and Push Open Match Images to gcr.io
+# Step 2: Download helm and install Tiller in the cluster
+make push-helm
+# Step 3: Build and Push Open Match Images to gcr.io
 make push-images -j$(nproc)
-# Step 3: Install Open Match in the cluster.
+# Install Open Match in the cluster.
 make install-chart
 
 # Create a proxy to Open Match pods so that you can access them locally.
@@ -98,39 +107,6 @@ make proxy
 make delete-chart
 ```
 
-## Iterating
-While iterating on the project, you may need to:
-1. Install/Run everything
-2. Make some code changes
-3. Make sure the changes compile by running `make test`
-4. Build and push Docker images to your personal registry by running `make push-images -j$(nproc)`
-5. Deploy the code change by running `make install-chart`
-6. Verify it's working by [looking at the logs](#accessing-logs) or looking at the monitoring dashboard by running `make proxy-grafana`
-7. Tear down Open Match by running `make delete-chart`
-
-## Accessing logs
-To look at Open Match core services' logs, run:
-```bash
-# Replace open-match-frontend with the service name that you would like to access
-kubectl logs -n open-match svc/open-match-frontend
-```
-
-## API References
-While integrating with Open Match you may want to understand its API surface concepts or interact with it and get a feel for how it works.
-
-The APIs are defined in `proto` format under the `api/` folder, with references available at [open-match.dev](https://open-match.dev/site/docs/reference/api/).
-
-You can also run `make proxy-ui` to exposes the Swagger UI for Open Match locally on your computer after [deploying it to Kubernetes](#deploying-to-kubernetes), then go to http://localhost:51500 and view the REST APIs as well as interactively call Open Match.
-
-By default you will be talking to the frontend server but you can change the target API url to any of the following:
-
- * api/frontend.swagger.json
- * api/backend.swagger.json
- * api/synchronizer.swagger.json
- * api/query.swagger.json
-
-For a more current list refer to the api/ directory of this repository. Also matchfunction.swagger.json is not supported.
-
 ## IDE Support
 
 Open Match is a standard Go project so any IDE that understands that should
@@ -154,9 +130,55 @@ export GOPATH=$HOME/workspace/
 
 ## Pull Requests
 
-If you want to submit a Pull Request, `make presubmit` can catch most of the issues your change can run into.
+If you want to submit a Pull Request there's some tools to help prepare your
+change.
+
+```bash
+# Runs code generators, tests, and linters.
+make presubmit
+```
+
+`make presubmit` catches most of the issues your change can run into. If the
+submit checks fail you can run it locally via,
+
+```bash
+make local-cloud-build
+```
 
 Our [continuous integration](https://console.cloud.google.com/cloud-build/builds?project=open-match-build)
 runs against all PRs. In order to see your build results you'll need to
 become a member of
 [open-match-discuss@googlegroups.com](https://groups.google.com/forum/#!forum/open-match-discuss).
+
+
+## Makefile
+
+The Makefile is the core of Open Match's build process. There's a lot of
+commands but here's a list of the important ones and patterns to remember them.
+
+```bash
+# Help
+make
+
+# Reset workspace (delete all build artifacts)
+make clean
+# Delete auto-generated protobuf code and swagger API docs.
+make clean-protos clean-swagger-docs
+# make clean-* deletes some part of the build outputs.
+
+# Build all Docker images
+make build-images
+# Build frontend docker image.
+make build-frontend-image
+
+# Formats, Vets, and tests the codebase.
+make fmt vet test
+# Same as above also regenerates autogen files.
+make presubmit
+
+# Run website on http://localhost:8080
+make run-site
+
+# Proxy all Open Match processes to view them.
+make proxy
+```

docs/gcloud.md

@@ -0,0 +1,26 @@
+# Create a GKE Cluster
+
+Below are the steps to create a GKE cluster in Google Cloud Platform.
+
+* Create a GCP project via [Google Cloud Console](https://console.cloud.google.com/).
+* Billing must be enabled. If you're a new customer you can get some [free credits](https://cloud.google.com/free/).
+* When you create a project you'll need to set a Project ID, if you forget it you can see it here, https://console.cloud.google.com/iam-admin/settings/project.
+* Install [Google Cloud SDK](https://cloud.google.com/sdk/) which is the command line tool to work against your project.
+
+Here are the next steps using the gcloud tool.  
+
+```bash
+# Login to your Google Account for GCP
+gcloud auth login
+gcloud config set project $YOUR_GCP_PROJECT_ID
+
+# Enable necessary GCP services
+gcloud services enable containerregistry.googleapis.com
+gcloud services enable container.googleapis.com
+
+# Test that everything is good, this command should work.
+gcloud compute zones list
+
+# Create a GKE Cluster in this project
+gcloud container clusters create --machine-type n1-standard-2 open-match-dev-cluster --zone us-west1-a --tags open-match
+```

docs/governance/templates/release.md

@@ -2,49 +2,44 @@
 
 This is the {version} release of Open Match.
 
-Check the [official website](https://open-match.dev) for details on features, installation and usage.
+Check the [README](https://github.com/googleforgames/open-match/tree/release-{version}) for details on features, installation and usage.
 
 Release Notes
 -------------
 
-**Feature Highlights**
-{ highlight here the most notable changes and themes at a high level}
+{ insert enhancements from the changelog and/or security and breaking changes }
 
 **Breaking Changes**
-{ detail any behaviors or API surfaces which worked in a previous version which will no longer work correctly }
-
-> Future releases towards 1.0.0 may still have breaking changes.
-
-**Security Fixes**
-{ list any changes which fix vulnerabilities in open match }
+ * API Changed #PR
 
 **Enhancements**
-{ go into details on improvements and changes }
+ * New Harness #PR
 
-Usage Requirements
--------------
-* Tested against Kubernetes Version { a list of k8s versions}
-* Golang Version = v{ required golang version }
+**Security Fixes**
+ * Reduced privileges required for MMF. #PR
+
+See [CHANGELOG](https://github.com/googleforgames/open-match/blob/release-{version}/CHANGELOG.md) for more details on changes.
 
 Images
 ------
 
 ```bash
 # Servers
-docker pull gcr.io/open-match-public-images/openmatch-backend:{version}
-docker pull gcr.io/open-match-public-images/openmatch-frontend:{version}
-docker pull gcr.io/open-match-public-images/openmatch-query:{version}
-docker pull gcr.io/open-match-public-images/openmatch-synchronizer:{version}
+docker pull gcr.io/open-match-public-images/openmatch-backendapi:{version}
+docker pull gcr.io/open-match-public-images/openmatch-frontendapi:{version}
+docker pull gcr.io/open-match-public-images/openmatch-mmforc:{version}
+docker pull gcr.io/open-match-public-images/openmatch-mmlogicapi:{version}
 
 # Evaluators
-docker pull gcr.io/open-match-public-images/openmatch-evaluator-go-simple:{version}
+docker pull gcr.io/open-match-public-images/openmatch-evaluator-serving:{version}
 
 # Sample Match Making Functions
-docker pull gcr.io/open-match-public-images/openmatch-mmf-go-soloduel:{version}
-docker pull gcr.io/open-match-public-images/openmatch-mmf-go-pool:{version}
+docker pull gcr.io/open-match-public-images/openmatch-mmf-go-simple:{version}
 
 # Test Clients
-docker pull gcr.io/open-match-public-images/openmatch-demo-first-match:{version}
+docker pull gcr.io/open-match-public-images/openmatch-backendclient:{version}
+docker pull gcr.io/open-match-public-images/openmatch-clientloadgen:{version}
+docker pull gcr.io/open-match-public-images/openmatch-frontendclient:{version}
 ```
 
 _This software is currently alpha, and subject to change. Not to be used in production systems._
@@ -52,10 +47,15 @@ _This software is currently alpha, and subject to change. Not to be used in prod
 Installation
 ------------
 
-* Follow [Open Match Installation Guide](https://open-match.dev/site/docs/installation/) to setup Open Match in your cluster.
+To deploy Open Match in your Kubernetes cluster run the following commands:
 
-API Definitions
-------------
-
-- gRPC API Definitions are available in [API references](https://open-match.dev/site/docs/reference/api/) - _Preferred_
-- HTTP API Definitions are available in [SwaggerUI](https://open-match.dev/site/swaggerui/index.html)
+```bash
+# Grant yourself cluster-admin permissions so that you can deploy service accounts.
+kubectl create clusterrolebinding myname-cluster-admin-binding --clusterrole=cluster-admin --user=$(YOUR_KUBERNETES_USER_NAME)
+# Place all Open Match components in their own namespace.
+kubectl create namespace open-match
+# Install Open Match and monitoring services.
+kubectl apply -f https://github.com/googleforgames/open-match/releases/download/v{version}/install.yaml --namespace open-match
+# Install the demo.
+kubectl apply -f https://github.com/googleforgames/open-match/releases/download/v{version}/install-demo.yaml --namespace open-match
+```

docs/governance/templates/release.sh

@@ -12,13 +12,24 @@ SOURCE_VERSION=$1
 DEST_VERSION=$2
 SOURCE_PROJECT_ID=open-match-build
 DEST_PROJECT_ID=open-match-public-images
-IMAGE_NAMES=$(make list-images)
+IMAGE_NAMES="openmatch-backendapi openmatch-frontendapi openmatch-mmforc openmatch-mmlogicapi openmatch-evaluator-serving openmatch-mmf-go-simple openmatch-backendclient openmatch-clientloadgen openmatch-frontendclient"
 
 for name in $IMAGE_NAMES
 do
-    source_image=gcr.io/$SOURCE_PROJECT_ID/openmatch-$name:$SOURCE_VERSION
-    dest_image=gcr.io/$DEST_PROJECT_ID/openmatch-$name:$DEST_VERSION
+    source_image=gcr.io/$SOURCE_PROJECT_ID/$name:$SOURCE_VERSION
+    dest_image=gcr.io/$DEST_PROJECT_ID/$name:$DEST_VERSION
     docker pull $source_image
     docker tag $source_image $dest_image
     docker push $dest_image
 done
+
+echo "=============================================================="
+echo "=============================================================="
+echo "=============================================================="
+echo "=============================================================="
+
+echo "Add these lines to your release notes:"
+for name in $IMAGE_NAMES
+do
+    echo "docker pull gcr.io/$DEST_PROJECT_ID/$name:$DEST_VERSION"
+done

docs/hugo_apiheader.txt

@@ -1,7 +0,0 @@
----
-title: "Open Match API References" 
-linkTitle: "Open Match API References" 
-weight: 2 
-description: 
-  This document provides API references for Open Match services. 
----

docs/integrations.md

@@ -0,0 +1,17 @@
+## Open Source Software integrations
+
+### Structured Logging - Logrus
+
+Logging for Open Match uses the [Golang logrus module](https://github.com/sirupsen/logrus) to provide structured logs. Logs are output to `stdout` in each component, as expected by Docker and Kubernetes. Level and format are configurable via config/matchmaker_config.json. If you have a specific log aggregator as your final destination, we recommend you have a look at the logrus documentation as there is probably a log formatter that plays nicely with your stack.
+
+### Instrumentation - OpenCensus
+
+Open Match uses [OpenCensus](https://opencensus.io/) for metrics instrumentation. The [gRPC](https://grpc.io/) integrations are built-in, and Golang redigo module integrations are incoming, but [haven't been merged into the official repo](https://github.com/opencensus-integrations/redigo/pull/1). All of the core components expose HTTP `/metrics` endpoints on the port defined in `config/matchmaker_config.json` (default: 9555) for Prometheus to scrape. If you would like to export to a different metrics aggregation platform, we suggest you have a look at the OpenCensus documentation — there may be one written for you already, and switching to it may be as simple as changing a few lines of code.
+
+**Note:** A standard for instrumentation of MMFs is planned.
+
+### State Storage - Redis
+
+By default, Open Match expects you to run Redis *somewhere*. Connection information can be put in the config file (`matchmaker_config.json`) for any Redis instance reachable from the [Kubernetes namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/). By default, Open Match sensibly runs in the Kubernetes `default` namespace. In most instances, we expect users will run a copy of Redis in a pod in Kubernetes, with a service pointing to it.
+
+* HA configurations for Redis aren't implemented by the provided Kubernetes resource definition files, but Open Match expects the Redis service to be named `redis`, which provides an easier path to multi-instance deployments.

docs/knative.md

@@ -0,0 +1,57 @@
+# Knative instructions
+This describes the basic installation of knative (and istio) for serverless match functions.
+It also provides experimental instructions for setting up you function host and endpoint.
+
+## New cluster deploy instructions
+Primarily taken from this [https://knative.dev/docs/install/] guide 
+### Install Istio
+Download and apply the istio manifests
+```
+curl -L https://git.io/getLatestIstio | sh -
+cd istio-1.0.5/
+kubectl apply -f install/kubernetes/helm/istio/templates/crds.yaml
+kubectl apply -f install/kubernetes/istio-demo-auth.yaml
+```
+
+Wait for `kubectl get pods --namespace istio-system` to complete
+
+Don't forget, you'll need to apply istio-injection label for any namespace you deploy to
+`kubectl label namespace default istio-injection=enabled`
+
+### Install Knative
+You may need to give your gcp user cluster admin privs to get through this part
+`kubectl create clusterrolebinding cluster-admin-binding --clusterrole=cluster-admin --user="{your user}"`
+
+To install knative, promethus + grafana (metrics), elk (logging), and zipkin (tracing), run. See the linked custom installation guide for more options
+```
+k apply -f https://github.com/knative/serving/releases/download/v0.3.0/serving.yaml /
+        -f https://github.com/knative/serving/releases/download/v0.3.0/monitoring.yaml
+```
+
+Wait for `kubectl get pods --namespace knative-serving` to complete
+
+## Serving
+To use the knative serverless flow for match functions...
+1. Create a host-harness for running your function as a hosted service at `/api/function` (roadmap v0.4 and v0.6 for something more official)
+2. Modify the provided knative serving manifest example at /deployments/k8s/knative_sample.yaml with your image name
+3. Run `kubectl apply -f knative_sample.yaml` to start up an instance of the function on your knative installation
+4. Using the configurable Http/1.1 REST pattern in open match (in review calebatwd/knative-rest-mmf), specify a `{..."hostName": "{knative service name}", "port": 8080}` in your match object properties when calling CreateMatch. The default port is 8080 in knative, but you can use whatever you like.
+5. This should tell open match mmforc to call your function via hostname discovery in kubernetes over the knative ingress. You should see logs from your mmf function.
+
+### Other Notes
+- After 5 minutes of inactivity, knative will spin down your function. Subsequent calls will have a warm-up period of a few seconds depending on your function and host.
+- The default port for knative is 8080, but you can use whatever you like so long as the intended port is Docker EXPOSED, knative will bind on that
+- Dns discovery over knative has been problematic via the ingress. If you experience issues, considering updating the dns host discovery in mmforc to resolve on the full name `function-name.default.svc.cluster.local`
+- Http2 is currently not supported in knative, so GRPC is not currently usable.
+- The REST contract for the function can be found in cmd/mmforc/main.go as 
+
+```
+	type Profile struct {
+		JobName   string
+		ProfId    string
+		MoId      string
+		PropId    string
+		ResultsId string
+		Timestamp string
+	}
+```

docs/references.md

@@ -0,0 +1,10 @@
+## Additional References
+
+### Docker
+- [Docker's official "Getting Started" guide](https://docs.docker.com/get-started/)
+
+### Kubernetes
+- [You should totally read this comic, and interactive tutorial](https://cloud.google.com/kubernetes-engine/kubernetes-comic/)
+
+### Prometheus
+- [Prometheus Operator spec](https://github.com/coreos/prometheus-operator/blob/master/Documentation/api.md)

docs/roadmap.md

@@ -0,0 +1,68 @@
+# Open Match Roadmap
+
+Open Match is currently at release 0.4.0. Open Match 0.5.0 currently has a Release Candidate and we are targeting to cut the release on 04/25/2019.
+
+Releases can be found on the [releases page](https://github.com/googleforgames/open-match/releases).
+
+Below sections detail the themes and the roadmap for the future releases. The tasks listed for the 0.6.0 release have been finalized and are well understood. As for the 0.7.0 and beyond, the tasks currently identified are listed. These are subject to change as we make our way through 0.6.0 release and get more feedback from the community.
+
+## 0.5.0 - Usability
+
+The primary focus of the 0.5 release is usability. The goal for this release is to make Open Match easy to build and deploy and have solid supporting documentation. Users should be able to try Open Match 0.5.0 functionality and experiment with its features, MMFs etc. Here are some planned features for this release:
+
+- [X] Add support to invoke MMFs as a gRPC function call.
+- [X] Provide a gRPC serving harness and an example MMF built using this harness. (golang based).
+- [X] Provide a evaluation harness and a sample evaluator using this harness (golang based)
+- [X] Deprecate the k8s based job scheduling mechanism for MMFs, Evaluator in favor of hosted MMFs, Evaluator.
+- [X] Switch all core Open Match services to use gRPC style request / response protos.
+- [X] Documentation: Add basic user, developer documentation and set up the Open Match website.
+- [X] Create and document a formal release process.
+- [X] Improve developer experience (simplify compiling, deploying and validating)
+
+## 0.6.0 - API changes, Maturity
+
+In 0.6.0 release, we are revisiting the Data Model and the API surface exposed by Open Match. The goal of this release is to front-load a major API refactoring that will facilitate achieving scale and other productionizing goals in forthcoming releases. Although breaking chagnes can happen any time till 1.0, the goal is to implement any major breaking changes in 0.6.0 so that future chagnes if any are relatively minor. Customer should be able to start building their Match Makers using the 0.6.0 API surface.
+
+Here are the tasks planned for 0.6.0 release:
+
+- [ ] Implement the new Data model and the API changes for the Frontend, Backend and MMLogic API [Change Proposal](https://github.com/googleforgames/open-match/issues/279)
+- [ ] Accept multiple proposals per MMF execution.
+- [ ] Remove persistance of matches and proposals from Open Match state storage.
+- [ ] Implement synchronized evaluation to eliminate use of state storage during evaluation.
+- [ ] Introduce test framework for unit testing, Component testing and E2E testing.
+- [ ] Add unit tests, component tests and integration tests for Open Match core components and examples.
+- [ ] Update harness, evaluator, mmf samples etc., to reflect the API changes.
+- [ ] Update documentation, website to reflect 0.6.0 API changes.
+
+## 0.7.0 - Scale, Operationalizing
+
+Features for 0.7.0 are targeted to enable Open Match to be productionizable. Note that as we identify more feature work past 0.6.0, these tasks may get pushed to future releases. However, these are core tasks that need to be addressed before Open Match reaches 1.0.
+
+- [ ] Introduce Test framework for load, performance testing
+- [ ] Automated Load / performance / scale tests
+- [ ] Test results Dashboard
+- [ ] Add support for Instrumentation, Monitoring, Dashboards
+- [ ] Add support or Metrics collection, Analytics, Dashboards
+- [ ] Identify Autoscaling patterns for each component and configure them.
+
+## Other Features
+
+Below are additional features that are not tied to a specific release but will be added incrementally across releases:
+
+- [ ] Harness support for Python, PHP, C#, C++
+- [ ] User Guide for Open Match, Tutorials
+- [ ] Developer Guide for Open Match
+- [ ] APIs & Reference
+- [ ] Concept Documentation
+- [ ] Website Improvements
+
+## 1.1.0
+
+Below are the features that have been identified but are not considered critical for Open Match (as a match making framework) to itself reach 1.0. Any other features that are related to Open Match ecosystem but not a part of the framework itself can be listed here. These features may not necessarily wait for Open Match 1.0 and can be implemented before that - but any of the currently identified 1.0 tasks are higher in priority than these to make Open Match production ready.
+
+- [ ] Canonical usable examples out of box.
+- [ ] KNative support to run MMFs
+- [ ] OSS Director to integrate with Agones, other DGS backends
+
+### Special Thanks
+- Thanks to https://jbt.github.io/markdown-editor/ for help in marking this document down.

examples/demo/bytesub/bytesub.go

@@ -1,81 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package bytesub provides the ability for many clients to subscribe to the
-// latest value of a byte array.
-package bytesub
-
-import (
-	"context"
-	"errors"
-	"io"
-	"sync"
-)
-
-var partialWriteError = errors.New("ByteSub subscriber didn't consume the whole message.")
-
-type ByteSub struct {
-	nextReady chan struct{}
-	b         []byte
-	r         sync.RWMutex
-}
-
-func New() *ByteSub {
-	return &ByteSub{
-		nextReady: make(chan struct{}),
-	}
-}
-
-// AnnounceLatest writes b to all of the subscribers, with caveats listed in Subscribe.
-func (s *ByteSub) AnnounceLatest(b []byte) {
-	s.r.Lock()
-	defer s.r.Unlock()
-	close(s.nextReady)
-	s.nextReady = make(chan struct{})
-	s.b = b
-}
-
-func (s *ByteSub) get() (b []byte, nextReady chan struct{}) {
-	s.r.RLock()
-	defer s.r.RUnlock()
-	return s.b, s.nextReady
-}
-
-// Subscribe writes the latest value in a single call to w.Write.  It does not
-// guarantee that all values published to AnnounceLatest will be written.
-// However once things catch up, it will write the latest value.  If no values
-// have been announced, waits for a value before writing.
-func (s *ByteSub) Subscribe(ctx context.Context, w io.Writer) error {
-	nextReady := make(chan struct{})
-	close(nextReady)
-
-	for {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		case <-nextReady:
-			var b []byte
-			b, nextReady = s.get()
-			if b != nil {
-				l, err := w.Write(b)
-				if err != nil {
-					return err
-				}
-				if l != len(b) {
-					return partialWriteError
-				}
-			}
-		}
-	}
-}

examples/demo/bytesub/bytesub_test.go

@@ -1,131 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package bytesub provides the ability for many clients to subscribe to the
-// latest value of a byte array.
-package bytesub
-
-import (
-	"context"
-	"errors"
-	"testing"
-)
-
-// TestFastAndSlow ensures that if a slow subscriber is blocked, faster subscribers
-// nor publishers aren't blocked.  It also ensures that values published while slow
-// wasn't listening are skipped.
-func TestFastAndSlow(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	fast := make(chan string)
-	slow := make(chan string)
-
-	s := New()
-
-	go func() {
-		s.Subscribe(ctx, chanWriter{fast})
-		close(fast)
-	}()
-	go func() {
-		s.Subscribe(ctx, chanWriter{slow})
-		close(slow)
-	}()
-
-	for _, i := range []string{"0", "1", "2", "3"} {
-		s.AnnounceLatest([]byte(i))
-		if v := <-fast; v != i {
-			t.Errorf("Expected \"%s\", got \"%s\"", i, v)
-		}
-	}
-
-	for count := 0; true; count++ {
-		if v := <-slow; v == "3" {
-			if count > 1 {
-				t.Error("Expected to receive at most 1 other value on slow before receiving the latest value.")
-			}
-			break
-		}
-	}
-
-	cancel()
-	_, ok := <-fast
-	if ok {
-		t.Error("Expected subscribe to return and fast to be closed")
-	}
-	_, ok = <-slow
-	if ok {
-		t.Error("Expected subscribe to return and slow to be closed")
-	}
-}
-
-func TestBadWriter(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	s := New()
-	s.AnnounceLatest([]byte{0, 1, 2})
-	err := s.Subscribe(ctx, writerFunc(func(b []byte) (int, error) {
-		return 1, nil
-	}))
-
-	if err != partialWriteError {
-		t.Errorf("Expected partialWriteError, got %s", err)
-	}
-}
-
-func TestErrorReturned(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	expected := errors.New("Hello there.")
-
-	s := New()
-	s.AnnounceLatest([]byte{0, 1, 2})
-	err := s.Subscribe(ctx, writerFunc(func(b []byte) (int, error) {
-		return 0, expected
-	}))
-
-	if err != expected {
-		t.Errorf("Expected returned error, got %s", err)
-	}
-}
-
-func TestContextError(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	s := New()
-	s.AnnounceLatest([]byte{0, 1, 2})
-	err := s.Subscribe(ctx, writerFunc(func(b []byte) (int, error) {
-		return len(b), nil
-	}))
-
-	if err != context.Canceled {
-		t.Errorf("Expected context canceled error, got %s", err)
-	}
-}
-
-type chanWriter struct {
-	c chan string
-}
-
-func (cw chanWriter) Write(b []byte) (int, error) {
-	cw.c <- string(b)
-	return len(b), nil
-}
-
-type writerFunc func(b []byte) (int, error)
-
-func (w writerFunc) Write(b []byte) (int, error) {
-	return w(b)
-}

examples/demo/components/clients/clients.go

@@ -1,141 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package clients
-
-import (
-	"context"
-	"fmt"
-	"math/rand"
-	"time"
-
-	"google.golang.org/grpc"
-
-	"open-match.dev/open-match/examples/demo/components"
-	"open-match.dev/open-match/examples/demo/updater"
-	"open-match.dev/open-match/pkg/pb"
-)
-
-func Run(ds *components.DemoShared) {
-	u := updater.NewNested(ds.Ctx, ds.Update)
-
-	for i := 0; i < 5; i++ {
-		name := fmt.Sprintf("fakeplayer_%d", i)
-		go func() {
-			for !isContextDone(ds.Ctx) {
-				runScenario(ds.Ctx, name, u.ForField(name))
-			}
-		}()
-	}
-}
-
-func isContextDone(ctx context.Context) bool {
-	select {
-	case <-ctx.Done():
-		return true
-	default:
-		return false
-	}
-}
-
-type status struct {
-	Status     string
-	Assignment *pb.Assignment
-}
-
-func runScenario(ctx context.Context, name string, update updater.SetFunc) {
-	defer func() {
-		r := recover()
-		if r != nil {
-			err, ok := r.(error)
-			if !ok {
-				err = fmt.Errorf("pkg: %v", r)
-			}
-
-			update(status{Status: fmt.Sprintf("Encountered error: %s", err.Error())})
-			time.Sleep(time.Second * 10)
-		}
-	}()
-
-	s := status{}
-
-	//////////////////////////////////////////////////////////////////////////////
-	s.Status = "Main Menu"
-	update(s)
-
-	time.Sleep(time.Duration(rand.Int63()) % (time.Second * 15))
-
-	//////////////////////////////////////////////////////////////////////////////
-	s.Status = "Connecting to Open Match frontend"
-	update(s)
-
-	// See https://open-match.dev/site/docs/guides/api/
-	conn, err := grpc.Dial("open-match-frontend.open-match.svc.cluster.local:50504", grpc.WithInsecure())
-	if err != nil {
-		panic(err)
-	}
-	defer conn.Close()
-	fe := pb.NewFrontendServiceClient(conn)
-
-	//////////////////////////////////////////////////////////////////////////////
-	s.Status = "Creating Open Match Ticket"
-	update(s)
-
-	var ticketId string
-	{
-		req := &pb.CreateTicketRequest{
-			Ticket: &pb.Ticket{},
-		}
-
-		resp, err := fe.CreateTicket(ctx, req)
-		if err != nil {
-			panic(err)
-		}
-		ticketId = resp.Id
-	}
-
-	//////////////////////////////////////////////////////////////////////////////
-	s.Status = fmt.Sprintf("Waiting match with ticket Id %s", ticketId)
-	update(s)
-
-	var assignment *pb.Assignment
-	{
-		req := &pb.WatchAssignmentsRequest{
-			TicketId: ticketId,
-		}
-
-		stream, err := fe.WatchAssignments(ctx, req)
-		for assignment.GetConnection() == "" {
-			resp, err := stream.Recv()
-			if err != nil {
-				// For now we don't expect to get EOF, so that's still an error worthy of panic.
-				panic(err)
-			}
-
-			assignment = resp.Assignment
-		}
-
-		err = stream.CloseSend()
-		if err != nil {
-			panic(err)
-		}
-	}
-
-	//////////////////////////////////////////////////////////////////////////////
-	s.Status = "Sleeping (pretend this is playing a match...)"
-	s.Assignment = assignment
-	update(s)
-
-	time.Sleep(time.Second * 10)
-}

examples/demo/components/components.go

@@ -1,26 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package components
-
-import (
-	"context"
-
-	"open-match.dev/open-match/examples/demo/updater"
-)
-
-type DemoShared struct {
-	Ctx    context.Context
-	Update updater.SetFunc
-}

examples/demo/components/director/director.go

@@ -1,157 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package director
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"math/rand"
-	"time"
-
-	"google.golang.org/grpc"
-
-	"open-match.dev/open-match/examples/demo/components"
-	"open-match.dev/open-match/pkg/pb"
-)
-
-func Run(ds *components.DemoShared) {
-	for !isContextDone(ds.Ctx) {
-		run(ds)
-	}
-}
-
-func isContextDone(ctx context.Context) bool {
-	select {
-	case <-ctx.Done():
-		return true
-	default:
-		return false
-	}
-}
-
-type status struct {
-	Status        string
-	LatestMatches []*pb.Match
-}
-
-func run(ds *components.DemoShared) {
-	defer func() {
-		r := recover()
-		if r != nil {
-			err, ok := r.(error)
-			if !ok {
-				err = fmt.Errorf("pkg: %v", r)
-			}
-
-			ds.Update(status{Status: fmt.Sprintf("Encountered error: %s", err.Error())})
-			time.Sleep(time.Second * 10)
-		}
-	}()
-
-	s := status{}
-
-	//////////////////////////////////////////////////////////////////////////////
-	s.Status = "Connecting to backend"
-	ds.Update(s)
-
-	// See https://open-match.dev/site/docs/guides/api/
-	conn, err := grpc.Dial("open-match-backend.open-match.svc.cluster.local:50505", grpc.WithInsecure())
-	if err != nil {
-		panic(err)
-	}
-	defer conn.Close()
-	be := pb.NewBackendServiceClient(conn)
-
-	//////////////////////////////////////////////////////////////////////////////
-	s.Status = "Match Match: Sending Request"
-	ds.Update(s)
-
-	var matches []*pb.Match
-	{
-		req := &pb.FetchMatchesRequest{
-			Config: &pb.FunctionConfig{
-				Host: "om-function.open-match-demo.svc.cluster.local",
-				Port: 50502,
-				Type: pb.FunctionConfig_GRPC,
-			},
-			Profile: &pb.MatchProfile{
-				Name: "1v1",
-				Pools: []*pb.Pool{
-					{
-						Name: "Everyone",
-					},
-				},
-			},
-		}
-
-		stream, err := be.FetchMatches(ds.Ctx, req)
-		if err != nil {
-			panic(err)
-		}
-
-		for {
-			resp, err := stream.Recv()
-			if err == io.EOF {
-				break
-			}
-			if err != nil {
-				panic(err)
-			}
-			matches = append(matches, resp.GetMatch())
-		}
-	}
-
-	//////////////////////////////////////////////////////////////////////////////
-	s.Status = "Matches Found"
-	s.LatestMatches = matches
-	ds.Update(s)
-
-	//////////////////////////////////////////////////////////////////////////////
-	s.Status = "Assigning Players"
-	ds.Update(s)
-
-	for _, match := range matches {
-		ids := []string{}
-
-		for _, t := range match.Tickets {
-			ids = append(ids, t.Id)
-		}
-
-		req := &pb.AssignTicketsRequest{
-			Assignments: []*pb.AssignmentGroup{
-				{
-					TicketIds: ids,
-					Assignment: &pb.Assignment{
-						Connection: fmt.Sprintf("%d.%d.%d.%d:2222", rand.Intn(256), rand.Intn(256), rand.Intn(256), rand.Intn(256)),
-					},
-				},
-			},
-		}
-
-		resp, err := be.AssignTickets(ds.Ctx, req)
-		if err != nil {
-			panic(err)
-		}
-
-		_ = resp
-	}
-
-	//////////////////////////////////////////////////////////////////////////////
-	s.Status = "Sleeping"
-	ds.Update(s)
-
-	time.Sleep(time.Second * 5)
-}

examples/demo/components/uptime/uptime.go

@@ -1,37 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package uptime
-
-import (
-	"time"
-
-	"open-match.dev/open-match/examples/demo/components"
-)
-
-func Run(ds *components.DemoShared) {
-	t := time.NewTicker(time.Second)
-	i := 0
-	for {
-		select {
-		case <-t.C:
-			ds.Update(i)
-			i++
-		case <-ds.Ctx.Done():
-			t.Stop()
-			ds.Update(nil)
-			return
-		}
-	}
-}

examples/demo/demo.go

@@ -1,77 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package demo contains the core startup code for running a demo.
-package demo
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net/http"
-
-	"golang.org/x/net/websocket"
-	"open-match.dev/open-match/examples/demo/bytesub"
-	"open-match.dev/open-match/examples/demo/components"
-	"open-match.dev/open-match/examples/demo/updater"
-	"open-match.dev/open-match/internal/telemetry"
-)
-
-// Run starts the provided components, and hosts a webserver for observing the
-// output of those components.
-func Run(comps map[string]func(*components.DemoShared)) {
-	log.Print("Initializing Server")
-
-	fileServe := http.FileServer(http.Dir("/app/static"))
-	http.Handle("/static/", http.StripPrefix("/static/", fileServe))
-	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/" {
-			http.NotFound(w, r)
-			return
-		}
-		fileServe.ServeHTTP(w, r)
-	})
-
-	http.Handle(telemetry.HealthCheckEndpoint, telemetry.NewAlwaysReadyHealthCheck())
-
-	bs := bytesub.New()
-	u := updater.New(context.Background(), func(b []byte) {
-		var out bytes.Buffer
-		err := json.Indent(&out, b, "", "  ")
-		if err == nil {
-			bs.AnnounceLatest(out.Bytes())
-		} else {
-			bs.AnnounceLatest(b)
-		}
-	})
-
-	http.Handle("/connect", websocket.Handler(func(ws *websocket.Conn) {
-		bs.Subscribe(ws.Request().Context(), ws)
-	}))
-
-	log.Print("Starting Server")
-
-	for name, f := range comps {
-		go f(&components.DemoShared{
-			Ctx:    context.Background(),
-			Update: u.ForField(name),
-		})
-	}
-
-	address := fmt.Sprintf(":%d", 51507)
-	err := http.ListenAndServe(address, nil)
-	log.Printf("HTTP server closed: %s", err.Error())
-}

examples/demo/static/dashboard.js

@@ -1,44 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-window.onload = function() {
-  let protocol = "ws://";
-  if (window.location.protocol == "https:") {
-    protocol = "wss://";
-  }
-  const ws = new WebSocket(protocol + window.location.host + "/connect");
-
-  ws.onopen = function (event) {
-    return false;
-  }
-
-  ws.onmessage = function (event) {    
-    document.getElementById("content").textContent = event.data;
-    return false;
-  }
-
-  ws.onerror = function (event) {
-    console.log("ERROR!");
-    console.log(event);
-    document.getElementById("error").textContent = event.toString();
-    return false;
-  }
-
-  ws.onclose = function (event) {
-    console.log("WS CLOSED!");
-    console.log(event);
-    document.getElementById("error").textContent = event.toString();
-    return false;
-  }
-}

examples/demo/static/index.html

@@ -1,22 +0,0 @@
-<!-- 
-Copyright 2019 Google LLC
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. -->
-
-<!DOCTYPE html>
-<html>
-  <head>
-    <script src="/static/dashboard.js"></script>
-  </head>
-  <body>
-    <pre id="error" style="background-color: #FAA"></pre>
-    <pre id="content"></pre>
-  </body>
-</html>

examples/demo/updater/updater.go

@@ -1,137 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package updater provides the ability for concurrently running demo pieces to
-// update a shared json object.
-package updater
-
-import (
-	"context"
-	"encoding/json"
-)
-
-// Updater is like a json object, with each field allowed to be updated
-// concurrently by a different process.  After processing updates, Updater will
-// call a provided method with the json serialized value of all of its fields.
-type Updater struct {
-	ctx      context.Context
-	children map[string]*json.RawMessage
-	updates  chan update
-	set      SetFunc
-}
-
-// SetFunc serializes the value passed in into json and sets the associated field
-// to that value.  If nil is passed (BUT NOT a nil value of an interface), the
-// field will be removed from the Updater's json object.
-type SetFunc func(v interface{})
-
-// New creates an Updater.  Set is called when fields update, using the json
-// serialized value of Updater's tree.  All updates after ctx is canceled are
-// ignored.
-func New(ctx context.Context, set func([]byte)) *Updater {
-	f := func(v interface{}) {
-		set([]byte(*forceMarshalJson(v)))
-	}
-	return NewNested(ctx, SetFunc(f))
-}
-
-// NewNested creates an updater based on a field in another updater.  This
-// allows for grouping of related demo pieces into a single conceptual group.
-func NewNested(ctx context.Context, set SetFunc) *Updater {
-	u := create(ctx, set)
-	go u.start()
-	return u
-}
-
-func create(ctx context.Context, set SetFunc) *Updater {
-	return &Updater{
-		ctx:      ctx,
-		children: make(map[string]*json.RawMessage),
-		updates:  make(chan update),
-		set:      set,
-	}
-}
-
-// ForField returns a function to set the latest value of that demo piece.
-func (u *Updater) ForField(field string) SetFunc {
-	return SetFunc(func(v interface{}) {
-		var r *json.RawMessage
-		if v != nil {
-			r = forceMarshalJson(v)
-		}
-
-		select {
-		case <-u.ctx.Done():
-		case u.updates <- update{field, r}:
-		}
-	})
-}
-
-func (u *Updater) start() {
-	for {
-		u.set(u.children)
-
-		select {
-		case <-u.ctx.Done():
-			u.set(nil)
-			return
-		case up := <-u.updates:
-			if up.value == nil {
-				delete(u.children, up.field)
-			} else {
-				u.children[up.field] = up.value
-			}
-		}
-
-	applyAllWaitingUpdates:
-		for {
-			select {
-			case up := <-u.updates:
-				if up.value == nil {
-					delete(u.children, up.field)
-				} else {
-					u.children[up.field] = up.value
-				}
-			default:
-				break applyAllWaitingUpdates
-			}
-		}
-	}
-}
-
-type update struct {
-	field string
-	value *json.RawMessage
-}
-
-// forceMarshalJson is like json.Marshal, but cannot fail.  It will instead
-// encode any error encountered into the json object on the field Error.
-func forceMarshalJson(v interface{}) *json.RawMessage {
-	b, err := json.Marshal(v)
-	if err != nil {
-		e := struct {
-			Error string
-		}{
-			err.Error(),
-		}
-
-		b, err = json.Marshal(e)
-		if err != nil {
-			b = []byte("{\"Error\":\"There was an error encoding the json message, additional there was an error encoding that error message.\"}")
-		}
-	}
-
-	r := json.RawMessage(b)
-	return &r
-}

examples/demo/updater/updater_test.go

@@ -1,131 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package updater
-
-import (
-	"context"
-	"encoding/json"
-	"strconv"
-	"sync"
-	"testing"
-)
-
-func TestUpdater(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	latest := make(chan string)
-
-	base := New(ctx, func(b []byte) {
-		latest <- string(b)
-	})
-
-	l := <-latest
-	if l != "{}" {
-		t.Errorf("Got %s, expected %s", l, "{}")
-	}
-
-	child := NewNested(ctx, base.ForField("Foo"))
-
-	l = <-latest
-	if l != "{\"Foo\":{}}" {
-		t.Errorf("Got %s, expected %s", l, "{\"Foo\":{}}")
-	}
-
-	child.ForField("Bar")(interface{}((*int)(nil)))
-
-	l = <-latest
-	if l != "{\"Foo\":{\"Bar\":null}}" {
-		t.Errorf("Got %s, expected %s", l, "{\"Foo\":{\"Bar\":null}}")
-	}
-
-	child.ForField("Bar")(nil)
-
-	l = <-latest
-	if l != "{\"Foo\":{}}" {
-		t.Errorf("Got %s, expected %s", l, "{\"Foo\":{}}")
-	}
-}
-
-// Fully testing the updater's logic is difficult because it combines multiple
-// calls.  This test method creates 100 different go routines all trying to
-// update a value to force the logic to be invoked.
-func TestUpdaterInternal(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-
-	var wg sync.WaitGroup
-	wg.Add(100)
-
-	go func() {
-		wg.Wait()
-		cancel()
-	}()
-
-	latest := ""
-
-	set := SetFunc(func(v interface{}) {
-		if v != nil {
-			latest = string(*forceMarshalJson(v))
-		}
-	})
-
-	u := create(ctx, set)
-
-	for i := 0; i < 100; i++ {
-		set := u.ForField(strconv.Itoa(i))
-		go func() {
-			set("Hi")
-			wg.Done()
-		}()
-	}
-
-	// Blocking call ensures that canceling the context will clean up the internal go routine.
-	u.start()
-
-	expectedMap := make(map[string]string)
-	for i := 0; i < 100; i++ {
-		expectedMap[strconv.Itoa(i)] = "Hi"
-	}
-	// Not using forceMashal because it by design hides errors, and is used in the
-	// code being tested.
-	expectedB, err := json.Marshal(expectedMap)
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected := string(expectedB)
-
-	if latest != expected {
-		t.Errorf("latest value is wrong.  Expected '%s', got '%s'", expected, latest)
-	}
-}
-
-var marshalTests = []struct {
-	in  interface{}
-	out string
-}{
-	{map[string]int{"hi": 1}, "{\"hi\":1}"},
-	{make(chan int), "{\"Error\":\"json: unsupported type: chan int\"}"},
-}
-
-func TestForceMarshalJson(t *testing.T) {
-	for _, tt := range marshalTests {
-		t.Run(tt.out, func(t *testing.T) {
-			s := string(*forceMarshalJson(tt.in))
-			if s != tt.out {
-				t.Errorf("got %s, want %s", s, tt.out)
-			}
-		})
-	}
-}

examples/functions/golang/backfill/Dockerfile

@@ -1,24 +0,0 @@
-# Copyright 2020 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-FROM open-match-base-build as builder
-
-WORKDIR /go/src/open-match.dev/open-match/examples/functions/golang/backfill
-RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o matchfunction .
-
-FROM gcr.io/distroless/static:nonroot
-WORKDIR /app/
-COPY --from=builder --chown=nonroot /go/src/open-match.dev/open-match/examples/functions/golang/backfill/matchfunction /app/
-
-ENTRYPOINT ["/app/matchfunction"]

examples/functions/golang/backfill/main.go

@@ -1,33 +0,0 @@
-// Copyright 2020 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package main defines a sample match function that uses the GRPC harness to set up
-// the match making function as a service. This sample is a reference
-// to demonstrate the usage of the GRPC harness and should only be used as
-// a starting point for your match function. You will need to modify the
-// matchmaking logic in this function based on your game's requirements.
-package main
-
-import (
-	"open-match.dev/open-match/examples/functions/golang/backfill/mmf"
-)
-
-const (
-	queryServiceAddr = "open-match-query.open-match.svc.cluster.local:50503" // Address of the QueryService endpoint.
-	serverPort       = 50502                                                 // The port for hosting the Match Function.
-)
-
-func main() {
-	mmf.Start(queryServiceAddr, serverPort)
-}

examples/functions/golang/backfill/mmf/matchfunction.go

@@ -1,297 +0,0 @@
-// Copyright 2020 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package mmf provides a sample match function that uses the GRPC harness to set up 1v1 matches.
-// This sample is a reference to demonstrate the usage of backfill and should only be used as
-// a starting point for your match function. You will need to modify the
-// matchmaking logic in this function based on your game's requirements.
-package mmf
-
-import (
-	"fmt"
-	"time"
-
-	"log"
-
-	"google.golang.org/grpc"
-	"google.golang.org/protobuf/types/known/anypb"
-	"google.golang.org/protobuf/types/known/timestamppb"
-	"google.golang.org/protobuf/types/known/wrapperspb"
-	"open-match.dev/open-match/pkg/matchfunction"
-	"open-match.dev/open-match/pkg/pb"
-)
-
-const (
-	playersPerMatch = 2
-	openSlotsKey    = "open-slots"
-	matchName       = "backfill-matchfunction"
-)
-
-// matchFunctionService implements pb.MatchFunctionServer, the server generated
-// by compiling the protobuf, by fulfilling the pb.MatchFunctionServer interface.
-type matchFunctionService struct {
-	grpc               *grpc.Server
-	queryServiceClient pb.QueryServiceClient
-	port               int
-}
-
-func (s *matchFunctionService) Run(req *pb.RunRequest, stream pb.MatchFunction_RunServer) error {
-	log.Printf("Generating proposals for function %v", req.GetProfile().GetName())
-
-	var proposals []*pb.Match
-	profile := req.GetProfile()
-	pools := profile.GetPools()
-
-	for _, p := range pools {
-		tickets, err := matchfunction.QueryPool(stream.Context(), s.queryServiceClient, p)
-		if err != nil {
-			log.Printf("Failed to query tickets for the given pool, got %s", err.Error())
-			return err
-		}
-
-		backfills, err := matchfunction.QueryBackfillPool(stream.Context(), s.queryServiceClient, p)
-		if err != nil {
-			log.Printf("Failed to query backfills for the given pool, got %s", err.Error())
-			return err
-		}
-
-		matches, err := makeMatches(profile, p, tickets, backfills)
-		if err != nil {
-			log.Printf("Failed to generate matches, got %s", err.Error())
-			return err
-		}
-
-		proposals = append(proposals, matches...)
-	}
-
-	log.Printf("Streaming %v proposals to Open Match", len(proposals))
-	// Stream the generated proposals back to Open Match.
-	for _, proposal := range proposals {
-		if err := stream.Send(&pb.RunResponse{Proposal: proposal}); err != nil {
-			log.Printf("Failed to stream proposals to Open Match, got %s", err.Error())
-			return err
-		}
-	}
-
-	return nil
-}
-
-// makeMatches tries to handle backfills at first, then it makes full matches, at the end it makes a match with backfill
-// if tickets left
-func makeMatches(profile *pb.MatchProfile, pool *pb.Pool, tickets []*pb.Ticket, backfills []*pb.Backfill) ([]*pb.Match, error) {
-	var matches []*pb.Match
-	newMatches, remainingTickets, err := handleBackfills(profile, tickets, backfills, len(matches))
-	if err != nil {
-		return nil, err
-	}
-
-	matches = append(matches, newMatches...)
-	newMatches, remainingTickets = makeFullMatches(profile, remainingTickets, len(matches))
-	matches = append(matches, newMatches...)
-
-	if len(remainingTickets) > 0 {
-		match, err := makeMatchWithBackfill(profile, pool, remainingTickets, len(matches))
-		if err != nil {
-			return nil, err
-		}
-
-		matches = append(matches, match)
-	}
-
-	return matches, nil
-}
-
-// handleBackfills looks at each backfill's openSlots which is a number of required tickets,
-// acquires that tickets, decreases openSlots in backfill and makes a match with updated backfill and associated tickets.
-func handleBackfills(profile *pb.MatchProfile, tickets []*pb.Ticket, backfills []*pb.Backfill, lastMatchId int) ([]*pb.Match, []*pb.Ticket, error) {
-	matchId := lastMatchId
-	var matches []*pb.Match
-
-	for _, b := range backfills {
-		openSlots, err := getOpenSlots(b)
-		if err != nil {
-			return nil, tickets, err
-		}
-
-		var matchTickets []*pb.Ticket
-		for openSlots > 0 && len(tickets) > 0 {
-			matchTickets = append(matchTickets, tickets[0])
-			tickets = tickets[1:]
-			openSlots--
-		}
-
-		if len(matchTickets) > 0 {
-			err := setOpenSlots(b, openSlots)
-			if err != nil {
-				return nil, tickets, err
-			}
-
-			matchId++
-			match := newMatch(matchId, profile.Name, matchTickets, b)
-			matches = append(matches, &match)
-		}
-	}
-
-	return matches, tickets, nil
-}
-
-// makeMatchWithBackfill makes not full match, creates backfill for it with openSlots = playersPerMatch-len(tickets).
-func makeMatchWithBackfill(profile *pb.MatchProfile, pool *pb.Pool, tickets []*pb.Ticket, lastMatchId int) (*pb.Match, error) {
-	if len(tickets) == 0 {
-		return nil, fmt.Errorf("tickets are required")
-	}
-
-	if len(tickets) >= playersPerMatch {
-		return nil, fmt.Errorf("too many tickets")
-	}
-
-	matchId := lastMatchId
-	searchFields := newSearchFields(pool)
-	backfill, err := newBackfill(searchFields, playersPerMatch-len(tickets))
-	if err != nil {
-		return nil, err
-	}
-
-	matchId++
-	match := newMatch(matchId, profile.Name, tickets, backfill)
-	// indicates that it is a new match and new game server should be allocated for it
-	match.AllocateGameserver = true
-
-	return &match, nil
-}
-
-// makeFullMatches makes matches without backfill
-func makeFullMatches(profile *pb.MatchProfile, tickets []*pb.Ticket, lastMatchId int) ([]*pb.Match, []*pb.Ticket) {
-	ticketNum := 0
-	matchId := lastMatchId
-	var matches []*pb.Match
-
-	for ticketNum < playersPerMatch && len(tickets) >= playersPerMatch {
-		ticketNum++
-
-		if ticketNum == playersPerMatch {
-			matchId++
-
-			match := newMatch(matchId, profile.Name, tickets[:playersPerMatch], nil)
-			matches = append(matches, &match)
-
-			tickets = tickets[playersPerMatch:]
-			ticketNum = 0
-		}
-	}
-
-	return matches, tickets
-}
-
-// newSearchFields creates search fields based on pool's search criteria. This is just example of how it can be done.
-func newSearchFields(pool *pb.Pool) *pb.SearchFields {
-	searchFields := pb.SearchFields{}
-	rangeFilters := pool.GetDoubleRangeFilters()
-
-	if rangeFilters != nil {
-		doubleArgs := make(map[string]float64)
-		for _, f := range rangeFilters {
-			doubleArgs[f.DoubleArg] = (f.Max - f.Min) / 2
-		}
-
-		if len(doubleArgs) > 0 {
-			searchFields.DoubleArgs = doubleArgs
-		}
-	}
-
-	stringFilters := pool.GetStringEqualsFilters()
-
-	if stringFilters != nil {
-		stringArgs := make(map[string]string)
-		for _, f := range stringFilters {
-			stringArgs[f.StringArg] = f.Value
-		}
-
-		if len(stringArgs) > 0 {
-			searchFields.StringArgs = stringArgs
-		}
-	}
-
-	tagFilters := pool.GetTagPresentFilters()
-
-	if tagFilters != nil {
-		tags := make([]string, len(tagFilters))
-		for _, f := range tagFilters {
-			tags = append(tags, f.Tag)
-		}
-
-		if len(tags) > 0 {
-			searchFields.Tags = tags
-		}
-	}
-
-	return &searchFields
-}
-
-func newBackfill(searchFields *pb.SearchFields, openSlots int) (*pb.Backfill, error) {
-	b := pb.Backfill{
-		SearchFields: searchFields,
-		Generation:   0,
-		CreateTime:   timestamppb.Now(),
-	}
-
-	err := setOpenSlots(&b, int32(openSlots))
-	return &b, err
-}
-
-func newMatch(num int, profile string, tickets []*pb.Ticket, b *pb.Backfill) pb.Match {
-	t := time.Now().Format("2006-01-02T15:04:05.00")
-
-	return pb.Match{
-		MatchId:       fmt.Sprintf("profile-%s-time-%s-num-%d", profile, t, num),
-		MatchProfile:  profile,
-		MatchFunction: matchName,
-		Tickets:       tickets,
-		Backfill:      b,
-	}
-}
-
-func setOpenSlots(b *pb.Backfill, val int32) error {
-	if b.Extensions == nil {
-		b.Extensions = make(map[string]*anypb.Any)
-	}
-
-	any, err := anypb.New(&wrapperspb.Int32Value{Value: val})
-	if err != nil {
-		return err
-	}
-
-	b.Extensions[openSlotsKey] = any
-	return nil
-}
-
-func getOpenSlots(b *pb.Backfill) (int32, error) {
-	if b == nil {
-		return 0, fmt.Errorf("expected backfill is not nil")
-	}
-
-	if b.Extensions != nil {
-		if any, ok := b.Extensions[openSlotsKey]; ok {
-			var val wrapperspb.Int32Value
-			err := any.UnmarshalTo(&val)
-			if err != nil {
-				return 0, err
-			}
-
-			return val.Value, nil
-		}
-	}
-
-	return playersPerMatch, nil
-}

examples/functions/golang/backfill/mmf/matchfunction_test.go

@@ -1,141 +0,0 @@
-// Copyright 2020 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//	http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package mmf
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-	"google.golang.org/protobuf/types/known/anypb"
-	"google.golang.org/protobuf/types/known/wrapperspb"
-	"open-match.dev/open-match/pkg/pb"
-)
-
-func TestHandleBackfills(t *testing.T) {
-	for _, tc := range []struct {
-		name              string
-		tickets           []*pb.Ticket
-		backfills         []*pb.Backfill
-		lastMatchId       int
-		expectedMatchLen  int
-		expectedTicketLen int
-		expectedOpenSlots int32
-		expectedErr       bool
-	}{
-		{name: "returns no matches when no backfills specified", expectedMatchLen: 0, expectedTicketLen: 0},
-		{name: "returns no matches when no tickets specified", expectedMatchLen: 0, expectedTicketLen: 0},
-		{name: "returns a match with open slots decreased", tickets: []*pb.Ticket{{Id: "1"}}, backfills: []*pb.Backfill{withOpenSlots(1)}, expectedMatchLen: 1, expectedTicketLen: 0, expectedOpenSlots: playersPerMatch - 2},
-	} {
-		testCase := tc
-		t.Run(testCase.name, func(t *testing.T) {
-			t.Parallel()
-
-			profile := pb.MatchProfile{Name: "matchProfile"}
-			matches, tickets, err := handleBackfills(&profile, testCase.tickets, testCase.backfills, testCase.lastMatchId)
-			require.Equal(t, testCase.expectedErr, err != nil)
-			require.Equal(t, testCase.expectedTicketLen, len(tickets))
-
-			if err != nil {
-				require.Equal(t, 0, len(matches))
-			} else {
-				for _, m := range matches {
-					require.NotNil(t, m.Backfill)
-
-					openSlots, err := getOpenSlots(m.Backfill)
-					require.NoError(t, err)
-					require.Equal(t, testCase.expectedOpenSlots, openSlots)
-				}
-			}
-		})
-	}
-}
-
-func TestMakeMatchWithBackfill(t *testing.T) {
-	for _, testCase := range []struct {
-		name              string
-		tickets           []*pb.Ticket
-		lastMatchId       int
-		expectedOpenSlots int32
-		expectedErr       bool
-	}{
-		{name: "returns an error when length of tickets is greater then playerPerMatch", tickets: []*pb.Ticket{{Id: "1"}, {Id: "2"}, {Id: "3"}, {Id: "4"}, {Id: "5"}}, expectedErr: true},
-		{name: "returns an error when length of tickets is equal to playerPerMatch", tickets: []*pb.Ticket{{Id: "1"}, {Id: "2"}, {Id: "3"}, {Id: "4"}}, expectedErr: true},
-		{name: "returns an error when no tickets are provided", expectedErr: true},
-		{name: "returns a match with backfill", tickets: []*pb.Ticket{{Id: "1"}}, expectedOpenSlots: playersPerMatch - 1},
-	} {
-		testCase := testCase
-		t.Run(testCase.name, func(t *testing.T) {
-			t.Parallel()
-
-			pool := pb.Pool{}
-			profile := pb.MatchProfile{Name: "matchProfile"}
-			match, err := makeMatchWithBackfill(&profile, &pool, testCase.tickets, testCase.lastMatchId)
-			require.Equal(t, testCase.expectedErr, err != nil)
-
-			if err == nil {
-				require.NotNil(t, match)
-				require.NotNil(t, match.Backfill)
-				require.True(t, match.AllocateGameserver)
-				require.Equal(t, "", match.Backfill.Id)
-
-				openSlots, err := getOpenSlots(match.Backfill)
-				require.Nil(t, err)
-				require.Equal(t, testCase.expectedOpenSlots, openSlots)
-			}
-		})
-
-	}
-}
-
-func TestMakeFullMatches(t *testing.T) {
-	for _, testCase := range []struct {
-		name              string
-		tickets           []*pb.Ticket
-		lastMatchId       int
-		expectedMatchLen  int
-		expectedTicketLen int
-	}{
-		{name: "returns no matches when there are no tickets", tickets: []*pb.Ticket{}, expectedMatchLen: 0, expectedTicketLen: 0},
-		{name: "returns no matches when length of tickets is less then playersPerMatch", tickets: []*pb.Ticket{{Id: "1"}}, expectedMatchLen: 0, expectedTicketLen: 1},
-		{name: "returns a match when length of tickets is greater then playersPerMatch", tickets: []*pb.Ticket{{Id: "1"}, {Id: "2"}}, expectedMatchLen: 1, expectedTicketLen: 0},
-	} {
-		testCase := testCase
-		t.Run(testCase.name, func(t *testing.T) {
-			t.Parallel()
-			profile := pb.MatchProfile{Name: "matchProfile"}
-			matches, tickets := makeFullMatches(&profile, testCase.tickets, testCase.lastMatchId)
-
-			require.Equal(t, testCase.expectedMatchLen, len(matches))
-			require.Equal(t, testCase.expectedTicketLen, len(tickets))
-
-			for _, m := range matches {
-				require.Nil(t, m.Backfill)
-				require.Equal(t, playersPerMatch, len(m.Tickets))
-			}
-		})
-	}
-}
-
-func withOpenSlots(openSlots int) *pb.Backfill {
-	val, err := anypb.New(&wrapperspb.Int32Value{Value: int32(openSlots)})
-	if err != nil {
-		panic(err)
-	}
-
-	return &pb.Backfill{
-		Extensions: map[string]*anypb.Any{
-			openSlotsKey: val,
-		},
-	}
-}

examples/functions/golang/backfill/mmf/server.go

@@ -1,59 +0,0 @@
-// Copyright 2020 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package mmf provides a sample match function that uses the GRPC harness to set up 1v1 matches.
-// This sample is a reference to demonstrate the usage of backfill and should only be used as
-// a starting point for your match function. You will need to modify the
-// matchmaking logic in this function based on your game's requirements.
-package mmf
-
-import (
-	"fmt"
-	"log"
-	"net"
-
-	"google.golang.org/grpc"
-	"open-match.dev/open-match/pkg/pb"
-)
-
-func Start(queryServiceAddr string, serverPort int) {
-	// Connect to QueryService.
-	conn, err := grpc.Dial(queryServiceAddr, grpc.WithInsecure())
-
-	if err != nil {
-		log.Fatalf("Failed to connect to Open Match, got %s", err.Error())
-	}
-
-	defer conn.Close()
-
-	mmfService := matchFunctionService{
-		queryServiceClient: pb.NewQueryServiceClient(conn),
-	}
-
-	// Create and host a new gRPC service on the configured port.
-	server := grpc.NewServer()
-	pb.RegisterMatchFunctionServer(server, &mmfService)
-	ln, err := net.Listen("tcp", fmt.Sprintf(":%d", serverPort))
-
-	if err != nil {
-		log.Fatalf("TCP net listener initialization failed for port %v, got %s", serverPort, err.Error())
-	}
-
-	log.Printf("TCP net listener initialized for port %v", serverPort)
-	err = server.Serve(ln)
-
-	if err != nil {
-		log.Fatalf("gRPC serve failed, got %s", err.Error())
-	}
-}

examples/functions/golang/simple/Dockerfile

@@ -0,0 +1,23 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FROM open-match-base-build as builder
+
+WORKDIR /go/src/open-match.dev/open-match/examples/functions/golang/simple
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o matchfunction .
+
+FROM gcr.io/distroless/static
+COPY --from=builder /go/src/open-match.dev/open-match/examples/functions/golang/simple/matchfunction .
+
+ENTRYPOINT ["/matchfunction"]