Since the cache is eventually consistent, there was a race condition
in which a GameServer could create more than one Pod backing it,
as the first one isn't found in the cache yet.

This sync's the cache before checking this value, so the cache
is up to date.

To be able to work locally, you need to be able to specify your
local `GameServer` configuration, as it likely will have application specific
configuration in it -- or maybe you want to specify what state it's in.

This commit allow you to specify the local resource as either yaml/json
through a `-f` or `--file` flag.

Closes #296

Previously the IP and Ports of the GameServer were populated only when
the GameServer is set to Ready.

This information may be needed by the GameServer process before the
process actually wants to mark itself as Ready.

Therefore, port and address population has been moved to the `Creating` state
processing, as that is where the Pod is created, and therefore we have both
address and port information.

`GameServer` events now look like this:

```
Events:
  Type    Reason          Age   From                   Message
  ----    ------          ----  ----                   -------
  Normal  PortAllocation  17s   gameserver-controller  Port allocated
  Normal  Creating        16s   gameserver-controller  Pod simple-udp-fcf44 created
  Normal  Starting        16s   gameserver-controller  Address and Port populated
  Normal  Ready           15s   gameserver-controller  SDK.Ready() executed
```

Closes #293

This implements new functions in the SDK:

- SetLabel(key, value) - that lets you set a label on the backing `GameServer`
- SetAnnotation(key, value) - that lets you set an annotation on the backing
`GameServer`

All keys are prefixed with "stable.agones.dev/sdk-" to maintain isolation.

Closes #279

This was missing, and wasn't versioned. It now is.

The REST api wasn't populating the metadata.namespace
whereas the kubectl command will when sending yaml - which
caused an issue when attempting to Fleet Allocate via REST.

We now pull the namespace from the AdmissionReview, which
solves this problem.

Also documented the workaround as well.

Closes #324

This test creates a gameserver and connect to it

update vendor with required lib for e2e
Adds the gcloud builder step to test it in a special e2e cluster
Updates build documentations with e2e instructions
Adds minikube e2e target

This commit fixes actually two bugs:

1) While we documented that you could disabled health checking we never
actually implemented it! This fixes that. Thankfully, the work that has been
done to retrieve `GameServer` details through the SDK makes this relatively
easy.

2) SDK Server sidecar never had the necessary RBAC permissions to send events
to the `GameServer` CRD. This is now fixed as well.

Reducing dependencies to working with the examples,
this has been converted into a multi stage Docker build.

This also removes the client, as nobody is using it,
as netcat works perfectly.

Getting this ready for 0.4.0

Let's use kubectl custom columns for the getting started guides -
also fixes the issues with multiple ports.
https://kubernetes.io/docs/reference/kubectl/overview/#custom-columns

This implements the gRPC system to send messages up to a unidirectional
stream from the sdk-server to the SDK.

This has been implemented in the Go, C++ and REST SDK.

Closes #277

I believe that this is starting at the same time as another
http server on the same port, and having a collision.

Removing the parrallel marker should fix this.

In the fleet allocation configuration you can add optional custom metadata that will be added to the game server in the moment of allocation

Generated files

This should hopefully reduce test flakiness.

Needed to set the changelog version.

Getting the following error in the logs.
`{"level":"error","msg":"agones.dev/agones/pkg/client/informers/externalversions/factory.go:74: Failed to watch *v1alpha1.GameServer: unknown (get gameservers.stable.agones.dev)","time":"2018-07-19T21:52:23Z"}`

Needed the `watch` permission to make it go away.

We aren't watching for events right now, so it's just noise,
but it's better with it gone.

Includes some tweaks to the release process as well.

Extended the gRPC SDK to include a `GameServer()` function for both Go, C++
and REST by extending the backing `sdk.proto` and implementing the functionality
in the sdk sidecar.

This is the start of work needed for #277.

Added information about project: https://github.com/dgkanatsios/AksNodePublicIPController

This allows the `GameServer` (and anything that uses it as a template,  such
as `Fleets`), to provide configuration and assignment of multiple ports to the
game server container.

For example:

```yaml
apiVersion: "stable.agones.dev/v1alpha1"
kind: GameServer
metadata:
  name: "simple-udp"
spec:
  ports:
  - name: default
    portPolicy: "dynamic"
    containerPort: 7654
  template:
    spec:
      containers:
      - name: simple-udp
        image: gcr.io/agones-images/udp-server:0.1
```

This also includes update to documentation - but in a separate bottom section
of each document, to allow for moving into the live version at release time.
(This is becoming a mess - a website can't come soon enough).

This also adjusts the `GameServer > Status`, to be able to handle multiple
ports. It now looks like this:

```
Status:
  Address:    192.168.99.100
  Node Name:  agones
  Ports:
    Name:  default
    Port:  7502
  State:   Ready
```

While this a breaking change (due to the change in `GameServer > status`, the
previous legacy configuration of still works (even thought it's no longer
documented), as it is automatically converted to the new version.

Plans are to remove this legacy conversion functionality in 0.4.0, since being
in alpha, we have a very low commitment to backward compatibility.

As an aside - versioning for CRDs is coming soon, so this will also solve this
type of problem long term.

It looks like the `foregroundDeletion` finalizer that gets added to the
GameServer when a deletion with foreground propogation is requested -
when it gets removed, by the Kubernetes system, the ResourceVersion/Generation
doesn't get incremented.

This means when we do an `Update` it will go through (usually it fails if the
ResourceVersion/Generation has changed since the last update), rather than
failing and going back to re-sync.

This can cause a race condition where the `Update` can basically put back
the `foregroundDeletion` finalizer, if it gets removed between retrieving the
`GameServer` object and doing the `Update()` operation.

We actually don't need the `foregroundDeletion` propogation on `Delete()`, as
we only want to keep the `GameServer` around until the backing `Pod` is gone,
so we can actually just turn this off instead in the code.

As a note - also explored using a `Patch()` operation to try and solve this
problem. AFAIK, a patch (and specifically a JSONPatch - other patch types
didn't seem better), can only do index based removal from a list of items.

This could just present other types of race conditions, as finalizers could
be added/removed by other systems at the same time as well, changing the index
to the finalizer we want at the same time.

Not sure if this is a bug in the Kubernetes system, or working as intended,
but this solves the issue.

Update codegen library to 1.10.5, and regen the CRD clients.

This may be the cause of #278 (but that change needed to happen anyway)

Keeping up with Kubernetes versions, as well as providing
us the functionality to do SubResources.

Also will enable tightening up of permissions re: #150

Found a line here that makes no sense.

Have working instructions for running Kubernetes 1.10 on top of
minikube 0.28.0 - including a workaround for non default profiles.

Since Agones works fine on k8s 1.10, figured it was worth making the move.

Implemented workerqueue for node modifications in the
PortAllocator, so that if the master happens to go
down, then the operations the PortAllocator has to do
to keep things in check will retry and result in a
correct state.

Closes #60

- (Conflict merge) Update Helm App Version
- update doc as requested

Implement grpc-gateway in front of the gRPC based sdk-server, so that
it can be access via HTTP+JSON.

This includes documentation and a swagger/openapi specificiation.

This also has been implemented such that the sdk-server is still a single
binary, and as such, the HTTP+JSON interface can still be used for local
development.

Closes #240