Merge lp:~mbruzek/charms/trusty/kubernetes/v1.0.0 into lp:~kubernetes/charms/trusty/kubernetes/trunk

[Matt Bruzek]

Vendoring the changes to the kubernetes charm for the v1.0.0 release of Kubernetes.

[Charles Butler (lazypower)]

LGTM

Nice callout on the ETCD changes before review. I think we have an opportunity to look into this in a lab env and see what else we can do wrt networking resolution outside of AWS and GCE

review: Approve

=== removed file 'charm-helpers.yaml'
--- charm-helpers.yaml	2015-01-27 17:31:57 +0000
+++ charm-helpers.yaml	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-destination: hooks/charmhelpers
-branch: lp:charmhelpers
-include:
-  - core
-  - fetch
 
=== removed file 'cli.txt'
--- cli.txt	2015-01-27 17:31:57 +0000
+++ cli.txt	1970-01-01 00:00:00 +0000
@@ -1,52 +0,0 @@
-$ ./kubelet -h
-Usage of ./kubelet:
-  -address=127.0.0.1: The IP address for the info server to serve on (set to 0.0.0.0 for all interfaces)
-  -allow_privileged=false: If true, allow containers to request privileged mode. [default=false]
-  -alsologtostderr=false: log to standard error as well as files
-  -config="": Path to the config file or directory of files
-  -docker_endpoint="": If non-empty, use this for the docker endpoint to communicate with
-  -enable_debugging_handlers=true: Enables server endpoints for log collection and local running of containers and commands
-  -enable_server=true: Enable the info server
-  -etcd_config="": The config file for the etcd client. Mutually exclusive with -etcd_servers
-  -etcd_servers=[]: List of etcd servers to watch (http://ip:port), comma separated. Mutually exclusive with -etcd_config
-  -file_check_frequency=20s: Duration between checking config files for new data
-  -hostname_override="": If non-empty, will use this string as identification instead of the actual hostname.
-  -http_check_frequency=20s: Duration between checking http for new data
-  -log_backtrace_at=:0: when logging hits line file:N, emit a stack trace
-  -log_dir="": If non-empty, write log files in this directory
-  -log_flush_frequency=5s: Maximum number of seconds between log flushes
-  -logtostderr=false: log to standard error instead of files
-  -manifest_url="": URL for accessing the container manifest
-  -network_container_image="kubernetes/pause:latest": The image that network containers in each pod will use.
-  -port=10250: The port for the info server to serve on
-  -registry_burst=10: Maximum size of a bursty pulls, temporarily allows pulls to burst to this number, while still not exceeding registry_qps.  Only used if --registry_qps > 0
-  -registry_qps=0: If > 0, limit registry pull QPS to this value.  If 0, unlimited. [default=0.0]
-  -root_dir="/var/lib/kubelet": Directory path for managing kubelet files (volume mounts,etc).
-  -runonce=false: If true, exit after spawning pods from local manifests or remote urls. Exclusive with --etcd_servers and --enable-server
-  -stderrthreshold=0: logs at or above this threshold go to stderr
-  -sync_frequency=10s: Max period between synchronizing running containers and config
-  -v=0: log level for V logs
-  -version=false: Print version information and quit
-  -vmodule=: comma-separated list of pattern=N settings for file-filtered logging
-
-
-$ ./proxy -h
-Usage of ./proxy:
-  -alsologtostderr=false: log to standard error as well as files
-  -api_version="": The API version to use when talking to the server
-  -bind_address=0.0.0.0: The address for the proxy server to serve on (set to 0.0.0.0 for all interfaces)
-  -certificate_authority="": Path to a cert. file for the certificate authority
-  -client_certificate="": Path to a client key file for TLS.
-  -client_key="": Path to a client key file for TLS.
-  -etcd_config="": The config file for the etcd client. Mutually exclusive with -etcd_servers
-  -etcd_servers=[]: List of etcd servers to watch (http://ip:port), comma separated (optional). Mutually exclusive with -etcd_config
-  -insecure_skip_tls_verify=false: If true, the server's certificate will not be checked for validity. This will make your HTTPS connections insecure.
-  -log_backtrace_at=:0: when logging hits line file:N, emit a stack trace
-  -log_dir="": If non-empty, write log files in this directory
-  -log_flush_frequency=5s: Maximum number of seconds between log flushes
-  -logtostderr=false: log to standard error instead of files
-  -master="": The address of the Kubernetes API server
-  -stderrthreshold=0: logs at or above this threshold go to stderr
-  -v=0: log level for V logs
-  -version=false: Print version information and quit
-  -vmodule=: comma-separated list of pattern=N settings for file-filtered logging
 
=== modified file 'copyright'
--- copyright	2015-01-27 17:31:57 +0000
+++ copyright	2015-07-17 20:16:05 +0000
@@ -1,13 +1,13 @@
-Copyright 2015 Canonical LTD
+Copyright 2015 Canonical Ltd. 
 
 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
+     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.
+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.
 
=== removed directory 'docs'
=== removed file 'docs/1-getting-started.md'
--- docs/1-getting-started.md	2015-01-27 17:31:57 +0000
+++ docs/1-getting-started.md	1970-01-01 00:00:00 +0000
@@ -1,81 +0,0 @@
-# Getting Started
-
-## Environment Considerations
-
-Kubernetes has specific cloud provider integration, and as of the current writing of this document that supported list includes the official Juju supported providers:
-
-- [Amazon AWS](https://jujucharms.com/docs/config-aws)
-- [Azure](https://jujucharms.com/docs/config-azure)
-- [Vagrant](https://jujucharms.com/docs/config-vagrant)
-
-Other providers available for use as a *juju manual environment* can be listed in the [Kubernetes Documentation](https://github.com/GoogleCloudPlatform/kubernetes/tree/master/docs/getting-started-guides)
-
-## Deployment
-
-The Kubernetes Charms are currently under heavy development. We encourage you to fork these charms and contribute back to the development effort! See our [contributing](contributing.md) doc for more information on this.
-
-#### Deploying the Preview Release charms
-
-    juju deploy cs:~hazmat/trusty/etcd
-    juju deploy cs:~hazmat/trusty/flannel
-    juju deploy local:trusty/kubernetes-master
-    juju deploy local:trusty/kubernetes
-
-    juju add-relation etcd flannel
-    juju add-relation etcd kubernetes
-    juju add-relation etcd kubernetes-master
-    juju add-relation kubernetes kubernetes-master
-
-#### Deploying the Development Release Charms
-
-> These charms are known to be unstable as they are tracking the current efforts of the community at enabling different features against Kubernetes. This includes the specifics for integration per cloud environment, and upgrading to the latest development version.
-
-    mkdir -p ~/charms/trusty
-    git clone https://github.com/whitmo/kubernetes-master.git ~/charms/trusty/kubernetes-master
-    git clone https://github.com/whitmo/kubernetes.git ~/charms/trusty/kubernetes
-
-##### Skipping the manual deployment after git clone
-
-> **Note:** This path requires the pre-requisite of juju-deployer. You can obtain juju-deployer via `apt-get install juju-deployer`
-
-    wget https://github.com/whitmo/bundle-kubernetes/blob/master/develop.yaml kubernetes-devel.yaml
-    juju-deployer kubernetes-devel.yaml
-
-
-## Verifying Deployment with the Kubernetes Agent
-
-You'll need the kubernetes command line client to utlize the created cluster. And this can be fetched from the [Releases](https://github.com/GoogleCloudPlatform/kubernetes/releases) page on the Kubernetes project. Make sure you're fetching a client library that matches what the charm is deploying.
-
-Grab the tarball and from the extracted release you can just directly use the cli binary at ./kubernetes/platforms/linux/amd64/kubecfg
-
-You'll need the address of the kubernetes master as environment variable :
-
-    juju status kubernetes-master/0
-
-Grab the public-address there and export it as KUBERNETES_MASTER environment variable :
-
-    export KUBERNETES_MASTER=$(juju status --format=oneline kubernetes-master | cut -d' ' -f3):8080
-
-And now you can run through the kubernetes examples per normal. :
-
-    kubecfg list minions
-
-
-## Scale Up
-
-If the default capacity of the bundle doesn't provide enough capacity for your workload(s) you can scale horizontially by adding a unit to the flannel and kubernetes services respectively.
-
-    juju add-unit flannel
-    juju add-unit kubernetes --to # (machine id of new flannel unit)
-
-## Known Issues / Limitations
-
-Kubernetes currently has platform specific functionality. For example load balancers and persistence volumes only work with the google compute provider atm.
-
-The Juju integration uses the kubernetes null provider. This means external load balancers and storage can't be directly driven through kubernetes config files.
-
-## Where to get help
-
-If you run into any issues, file a bug at our [issue tracker](http://github.com/whitmo/kubernetes-charm/issues), email the Juju Mailing List at <[e-mail]>, or feel free to join us in #juju on irc.freenode.net.
-
-
 
=== removed file 'docs/contributing.md'
--- docs/contributing.md	2015-01-27 17:31:57 +0000
+++ docs/contributing.md	1970-01-01 00:00:00 +0000
@@ -1,52 +0,0 @@
-
-#### Contributions are welcome, in any form. Whether that be Bugs, BugFixes, Documentation, or Features.
-
-### Submitting a bug
-
-1. Go to our [issue tracker](http://github.com/whitmo/kubernetes-charm/issues) on GitHub
-2. Search for existing issues using the search field at the top of the page
-3. File a new issue including the info listed below
-4. Thanks a ton for helping make the Kubernetes Charm higher quality!
-
-##### When filing a new bug, please include:
-
-- **Descriptive title** - use keywords so others can find your bug (avoiding duplicates)
-- **Steps to trigger the problem** - that are specific, and repeatable
-- **What happens** - when you follow the steps, and what you expected to happen instead.
-- Include the exact text of any error messages if applicable (or upload screenshots).
-- Kubernetes Charm version (or if you're pulling directly from Git, your current commit SHA - use git rev-parse HEAD) and the Juju Version output from `juju --version`.
-- Did this work in a previous charm version? If so, also provide the version that it worked in.
-- Any errors logged in `juju debug log` Console view
-
-### Can I help fix a bug?
-
-Yes please! But first...
-
-- Make sure no one else is already working on it -- if the bug has a milestone assigned or is tagged 'fix in progress', then it's already under way. Otherwise, post a comment on the bug to let others know you're starting to work on it.
-
-We use the Fork & Pull model for distributed development. For a more in-depth overview: consult with the github documentation on [Collaborative Development Models](https://help.github.com/articles/using-pull-requests/#before-you-begin).
-
-> ##### Fork & pull
->
-> The fork & pull model lets anyone fork an existing repository and push changes to their personal fork without requiring access be granted to the source repository. The changes must then be pulled into the source repository by the project maintainer. This model reduces the amount of friction for new contributors and is popular with open source projects because it allows people to work independently without upfront coordination.
-
-### Submitting a Bug Fix
-
-The following checklist will help developers not familiar with the fork and pull process of development. We appreciate your enthusiasm to make the Kubernetes Charm a High Quality experience! To Rapidly get started - follow the 8 steps below.
-
-1. [Fork the repository](https://help.github.com/articles/fork-a-repo/)
-2. Clone your fork `git clone [e-mail]/myusername/kubernetes-charm.git`
-3. Checkout your topic branch with `git checkout -b my-awesome-bugfix`
-4. Hack away at your feature/bugfix
-5. Validate your bugfix if possible in the amulet test(s) so we dont reintroduce it later.
-6. Validate your code meets guidelines by passing lint tests `make lint`
-6. Commit code `git commit -a -m 'i did all this work to fix #32'`
-7. Push your branch to your forks remote branch `git push origin my-awesome-bugfix`
-8. Create the [Pull Request](https://help.github.com/articles/using-pull-requests/#initiating-the-pull-request)
-9. Await Code Review
-10. Rejoice when Pull Request is accepted
-
-### Submitting a Feature
-
-The Steps are the same as [Submitting a Bug Fix](#submitting-a-bug-fix). If you want extra credit, make sure you [File an issue](http://github.com/whitmo/kubernetes-charm/issues) that covers the Feature you are working on - as kind of a courtesy heads up. And assign the issue to yourself so we know you are working on it.
-
 
=== modified file 'files/cadvisor.upstart.tmpl'
--- files/cadvisor.upstart.tmpl	2015-01-27 17:31:57 +0000
+++ files/cadvisor.upstart.tmpl	2015-07-17 20:16:05 +0000
@@ -11,6 +11,6 @@
   --volume=/var/run:/var/run:rw \
   --volume=/sys/fs/cgroup:/sys/fs/cgroup:ro \
   --volume=/var/lib/docker/:/var/lib/docker:ro \
-  --publish=127.0.0.1:4194:8080 \
+  --publish=127.0.0.1:4193:8080 \
   --name=cadvisor \
   google/cadvisor:latest
 
=== removed file 'files/create_kubernetes_tar.sh'
--- files/create_kubernetes_tar.sh	2015-01-27 17:31:57 +0000
+++ files/create_kubernetes_tar.sh	1970-01-01 00:00:00 +0000
@@ -1,59 +0,0 @@
-#!/bin/bash
-
-set -ex
-
-# This script downloads a Kubernetes release and creates a tar file with only
-# the files that are needed for this charm.
-
-# Usage: create_kubernetes_tar.sh VERSION ARCHITECTURE
-
-usage() {
-  echo "Build a tar file with only the files needed for the kubernetes charm."
-  echo "The script accepts two arguments version and desired architecture."
-  echo "$0 version architecture"
-}
-
-download_kubernetes() {
-  local VERSION=$1
-  URL_PREFIX="https://github.com/GoogleCloudPlatform/kubernetes"
-  KUBERNETES_URL="${URL_PREFIX}/releases/download/${VERSION}/kubernetes.tar.gz"
-  # Remove the previous temporary files to remain idempotent.
-  if [ -f /tmp/kubernetes.tar.gz ]; then
-    rm /tmp/kubernetes.tar.gz
-  fi
-  # Download the kubernetes release from the Internet.
-  wget --no-verbose --tries 2 -O /tmp/kubernetes.tar.gz $KUBERNETES_URL
-}
-
-extract_kubernetes() {
-  local ARCH=$1
-  # Untar the kubernetes release file.
-  tar -xvzf /tmp/kubernetes.tar.gz -C /tmp
-  # Untar the server linux amd64 package.
-  tar -xvzf /tmp/kubernetes/server/kubernetes-server-linux-$ARCH.tar.gz -C /tmp
-}
-
-create_charm_tar() {
-  local OUTPUT_FILE=${1:-"$PWD/kubernetes.tar.gz"}
-  local OUTPUT_DIR=`dirname $OUTPUT_FILE`
-  if [ ! -d $OUTPUT_DIR ]; then
-    mkdir -p $OUTPUT
-  fi
-
-  # Change to the directory the binaries are.
-  cd /tmp/kubernetes/server/bin/
-
-  # Create a tar file with the binaries that are needed for kubernetes minion.
-  tar -cvzf $OUTPUT_FILE kubelet kube-proxy
-}
-
-if [ $# -gt 2 ]; then
-  usage
-  exit 1
-fi
-VERSION=${1:-"v0.8.1"}
-ARCH=${2:-"amd64"}
-download_kubernetes $VERSION
-extract_kubernetes $ARCH
-TAR_FILE="$PWD/kubernetes-$VERSION-$ARCH.tar.gz"
-create_charm_tar $TAR_FILE
 
=== modified file 'files/kubelet.upstart.tmpl'
--- files/kubelet.upstart.tmpl	2015-04-10 20:43:29 +0000
+++ files/kubelet.upstart.tmpl	2015-07-17 20:16:05 +0000
@@ -9,6 +9,7 @@
 
 exec /usr/local/bin/kubelet \
      --address=%(kubelet_bind_addr)s \
-     --etcd_servers=%(etcd_servers)s \
+     --api_servers=%(kubeapi_server)s \
      --hostname_override=%(kubelet_bind_addr)s \
+     --cadvisor_port=4193 \
      --logtostderr=true
 
=== modified file 'files/proxy.upstart.tmpl'
--- files/proxy.upstart.tmpl	2015-04-10 20:43:29 +0000
+++ files/proxy.upstart.tmpl	2015-07-17 20:16:05 +0000
@@ -8,6 +8,5 @@
 kill timeout 60 # wait 60s between SIGTERM and SIGKILL.
 
 exec /usr/local/bin/proxy \
-     --etcd_servers=%(etcd_servers)s \
      --master=%(kubeapi_server)s \
      --logtostderr=true
 
=== removed directory 'hooks/charmhelpers'
=== removed file 'hooks/charmhelpers/__init__.py'
=== removed directory 'hooks/charmhelpers/core'
=== removed file 'hooks/charmhelpers/core/__init__.py'
=== removed file 'hooks/charmhelpers/core/hookenv.py'
--- hooks/charmhelpers/core/hookenv.py	2015-01-27 17:31:57 +0000
+++ hooks/charmhelpers/core/hookenv.py	1970-01-01 00:00:00 +0000
@@ -1,498 +0,0 @@
-"Interactions with the Juju environment"
-# Copyright 2013 Canonical Ltd.
-#
-# Authors:
-#  Charm Helpers Developers <[e-mail]>
-
-import os
-import json
-import yaml
-import subprocess
-import sys
-import UserDict
-from subprocess import CalledProcessError
-
-CRITICAL = "CRITICAL"
-ERROR = "ERROR"
-WARNING = "WARNING"
-INFO = "INFO"
-DEBUG = "DEBUG"
-MARKER = object()
-
-cache = {}
-
-
-def cached(func):
-    """Cache return values for multiple executions of func + args
-
-    For example:
-
-        @cached
-        def unit_get(attribute):
-            pass
-
-        unit_get('test')
-
-    will cache the result of unit_get + 'test' for future calls.
-    """
-    def wrapper(*args, **kwargs):
-        global cache
-        key = str((func, args, kwargs))
-        try:
-            return cache[key]
-        except KeyError:
-            res = func(*args, **kwargs)
-            cache[key] = res
-            return res
-    return wrapper
-
-
-def flush(key):
-    """Flushes any entries from function cache where the
-    key is found in the function+args """
-    flush_list = []
-    for item in cache:
-        if key in item:
-            flush_list.append(item)
-    for item in flush_list:
-        del cache[item]
-
-
-def log(message, level=None):
-    """Write a message to the juju log"""
-    command = ['juju-log']
-    if level:
-        command += ['-l', level]
-    command += [message]
-    subprocess.call(command)
-
-
-class Serializable(UserDict.IterableUserDict):
-    """Wrapper, an object that can be serialized to yaml or json"""
-
-    def __init__(self, obj):
-        # wrap the object
-        UserDict.IterableUserDict.__init__(self)
-        self.data = obj
-
-    def __getattr__(self, attr):
-        # See if this object has attribute.
-        if attr in ("json", "yaml", "data"):
-            return self.__dict__[attr]
-        # Check for attribute in wrapped object.
-        got = getattr(self.data, attr, MARKER)
-        if got is not MARKER:
-            return got
-        # Proxy to the wrapped object via dict interface.
-        try:
-            return self.data[attr]
-        except KeyError:
-            raise AttributeError(attr)
-
-    def __getstate__(self):
-        # Pickle as a standard dictionary.
-        return self.data
-
-    def __setstate__(self, state):
-        # Unpickle into our wrapper.
-        self.data = state
-
-    def json(self):
-        """Serialize the object to json"""
-        return json.dumps(self.data)
-
-    def yaml(self):
-        """Serialize the object to yaml"""
-        return yaml.dump(self.data)
-
-
-def execution_environment():
-    """A convenient bundling of the current execution context"""
-    context = {}
-    context['conf'] = config()
-    if relation_id():
-        context['reltype'] = relation_type()
-        context['relid'] = relation_id()
-        context['rel'] = relation_get()
-    context['unit'] = local_unit()
-    context['rels'] = relations()
-    context['env'] = os.environ
-    return context
-
-
-def in_relation_hook():
-    """Determine whether we're running in a relation hook"""
-    return 'JUJU_RELATION' in os.environ
-
-
-def relation_type():
-    """The scope for the current relation hook"""
-    return os.environ.get('JUJU_RELATION', None)
-
-
-def relation_id():
-    """The relation ID for the current relation hook"""
-    return os.environ.get('JUJU_RELATION_ID', None)
-
-
-def local_unit():
-    """Local unit ID"""
-    return os.environ['JUJU_UNIT_NAME']
-
-
-def remote_unit():
-    """The remote unit for the current relation hook"""
-    return os.environ['JUJU_REMOTE_UNIT']
-
-
-def service_name():
-    """The name service group this unit belongs to"""
-    return local_unit().split('/')[0]
-
-
-def hook_name():
-    """The name of the currently executing hook"""
-    return os.path.basename(sys.argv[0])
-
-
-class Config(dict):
-    """A Juju charm config dictionary that can write itself to
-    disk (as json) and track which values have changed since
-    the previous hook invocation.
-
-    Do not instantiate this object directly - instead call
-    ``hookenv.config()``
-
-    Example usage::
-
-        >>> # inside a hook
-        >>> from charmhelpers.core import hookenv
-        >>> config = hookenv.config()
-        >>> config['foo']
-        'bar'
-        >>> config['mykey'] = 'myval'
-        >>> config.save()
-
-
-        >>> # user runs `juju set mycharm foo=baz`
-        >>> # now we're inside subsequent config-changed hook
-        >>> config = hookenv.config()
-        >>> config['foo']
-        'baz'
-        >>> # test to see if this val has changed since last hook
-        >>> config.changed('foo')
-        True
-        >>> # what was the previous value?
-        >>> config.previous('foo')
-        'bar'
-        >>> # keys/values that we add are preserved across hooks
-        >>> config['mykey']
-        'myval'
-        >>> # don't forget to save at the end of hook!
-        >>> config.save()
-
-    """
-    CONFIG_FILE_NAME = '.juju-persistent-config'
-
-    def __init__(self, *args, **kw):
-        super(Config, self).__init__(*args, **kw)
-        self._prev_dict = None
-        self.path = os.path.join(charm_dir(), Config.CONFIG_FILE_NAME)
-        if os.path.exists(self.path):
-            self.load_previous()
-
-    def load_previous(self, path=None):
-        """Load previous copy of config from disk so that current values
-        can be compared to previous values.
-
-        :param path:
-
-            File path from which to load the previous config. If `None`,
-            config is loaded from the default location. If `path` is
-            specified, subsequent `save()` calls will write to the same
-            path.
-
-        """
-        self.path = path or self.path
-        with open(self.path) as f:
-            self._prev_dict = json.load(f)
-
-    def changed(self, key):
-        """Return true if the value for this key has changed since
-        the last save.
-
-        """
-        if self._prev_dict is None:
-            return True
-        return self.previous(key) != self.get(key)
-
-    def previous(self, key):
-        """Return previous value for this key, or None if there
-        is no "previous" value.
-
-        """
-        if self._prev_dict:
-            return self._prev_dict.get(key)
-        return None
-
-    def save(self):
-        """Save this config to disk.
-
-        Preserves items in _prev_dict that do not exist in self.
-
-        """
-        if self._prev_dict:
-            for k, v in self._prev_dict.iteritems():
-                if k not in self:
-                    self[k] = v
-        with open(self.path, 'w') as f:
-            json.dump(self, f)
-
-
-@cached
-def config(scope=None):
-    """Juju charm configuration"""
-    config_cmd_line = ['config-get']
-    if scope is not None:
-        config_cmd_line.append(scope)
-    config_cmd_line.append('--format=json')
-    try:
-        config_data = json.loads(subprocess.check_output(config_cmd_line))
-        if scope is not None:
-            return config_data
-        return Config(config_data)
-    except ValueError:
-        return None
-
-
-@cached
-def relation_get(attribute=None, unit=None, rid=None):
-    """Get relation information"""
-    _args = ['relation-get', '--format=json']
-    if rid:
-        _args.append('-r')
-        _args.append(rid)
-    _args.append(attribute or '-')
-    if unit:
-        _args.append(unit)
-    try:
-        return json.loads(subprocess.check_output(_args))
-    except ValueError:
-        return None
-    except CalledProcessError, e:
-        if e.returncode == 2:
-            return None
-        raise
-
-
-def relation_set(relation_id=None, relation_settings={}, **kwargs):
-    """Set relation information for the current unit"""
-    relation_cmd_line = ['relation-set']
-    if relation_id is not None:
-        relation_cmd_line.extend(('-r', relation_id))
-    for k, v in (relation_settings.items() + kwargs.items()):
-        if v is None:
-            relation_cmd_line.append('{}='.format(k))
-        else:
-            relation_cmd_line.append('{}={}'.format(k, v))
-    subprocess.check_call(relation_cmd_line)
-    # Flush cache of any relation-gets for local unit
-    flush(local_unit())
-
-
-@cached
-def relation_ids(reltype=None):
-    """A list of relation_ids"""
-    reltype = reltype or relation_type()
-    relid_cmd_line = ['relation-ids', '--format=json']
-    if reltype is not None:
-        relid_cmd_line.append(reltype)
-        return json.loads(subprocess.check_output(relid_cmd_line)) or []
-    return []
-
-
-@cached
-def related_units(relid=None):
-    """A list of related units"""
-    relid = relid or relation_id()
-    units_cmd_line = ['relation-list', '--format=json']
-    if relid is not None:
-        units_cmd_line.extend(('-r', relid))
-    return json.loads(subprocess.check_output(units_cmd_line)) or []
-
-
-@cached
-def relation_for_unit(unit=None, rid=None):
-    """Get the json represenation of a unit's relation"""
-    unit = unit or remote_unit()
-    relation = relation_get(unit=unit, rid=rid)
-    for key in relation:
-        if key.endswith('-list'):
-            relation[key] = relation[key].split()
-    relation['__unit__'] = unit
-    return relation
-
-
-@cached
-def relations_for_id(relid=None):
-    """Get relations of a specific relation ID"""
-    relation_data = []
-    relid = relid or relation_ids()
-    for unit in related_units(relid):
-        unit_data = relation_for_unit(unit, relid)
-        unit_data['__relid__'] = relid
-        relation_data.append(unit_data)
-    return relation_data
-
-
-@cached
-def relations_of_type(reltype=None):
-    """Get relations of a specific type"""
-    relation_data = []
-    reltype = reltype or relation_type()
-    for relid in relation_ids(reltype):
-        for relation in relations_for_id(relid):
-            relation['__relid__'] = relid
-            relation_data.append(relation)
-    return relation_data
-
-
-@cached
-def relation_types():
-    """Get a list of relation types supported by this charm"""
-    charmdir = os.environ.get('CHARM_DIR', '')
-    mdf = open(os.path.join(charmdir, 'metadata.yaml'))
-    md = yaml.safe_load(mdf)
-    rel_types = []
-    for key in ('provides', 'requires', 'peers'):
-        section = md.get(key)
-        if section:
-            rel_types.extend(section.keys())
-    mdf.close()
-    return rel_types
-
-
-@cached
-def relations():
-    """Get a nested dictionary of relation data for all related units"""
-    rels = {}
-    for reltype in relation_types():
-        relids = {}
-        for relid in relation_ids(reltype):
-            units = {local_unit(): relation_get(unit=local_unit(), rid=relid)}
-            for unit in related_units(relid):
-                reldata = relation_get(unit=unit, rid=relid)
-                units[unit] = reldata
-            relids[relid] = units
-        rels[reltype] = relids
-    return rels
-
-
-@cached
-def is_relation_made(relation, keys='private-address'):
-    '''
-    Determine whether a relation is established by checking for
-    presence of key(s).  If a list of keys is provided, they
-    must all be present for the relation to be identified as made
-    '''
-    if isinstance(keys, str):
-        keys = [keys]
-    for r_id in relation_ids(relation):
-        for unit in related_units(r_id):
-            context = {}
-            for k in keys:
-                context[k] = relation_get(k, rid=r_id,
-                                          unit=unit)
-            if None not in context.values():
-                return True
-    return False
-
-
-def open_port(port, protocol="TCP"):
-    """Open a service network port"""
-    _args = ['open-port']
-    _args.append('{}/{}'.format(port, protocol))
-    subprocess.check_call(_args)
-
-
-def close_port(port, protocol="TCP"):
-    """Close a service network port"""
-    _args = ['close-port']
-    _args.append('{}/{}'.format(port, protocol))
-    subprocess.check_call(_args)
-
-
-@cached
-def unit_get(attribute):
-    """Get the unit ID for the remote unit"""
-    _args = ['unit-get', '--format=json', attribute]
-    try:
-        return json.loads(subprocess.check_output(_args))
-    except ValueError:
-        return None
-
-
-def unit_private_ip():
-    """Get this unit's private IP address"""
-    return unit_get('private-address')
-
-
-class UnregisteredHookError(Exception):
-    """Raised when an undefined hook is called"""
-    pass
-
-
-class Hooks(object):
-    """A convenient handler for hook functions.
-
-    Example:
-        hooks = Hooks()
-
-        # register a hook, taking its name from the function name
-        @hooks.hook()
-        def install():
-            ...
-
-        # register a hook, providing a custom hook name
-        @hooks.hook("config-changed")
-        def config_changed():
-            ...
-
-        if __name__ == "__main__":
-            # execute a hook based on the name the program is called by
-            hooks.execute(sys.argv)
-    """
-
-    def __init__(self):
-        super(Hooks, self).__init__()
-        self._hooks = {}
-
-    def register(self, name, function):
-        """Register a hook"""
-        self._hooks[name] = function
-
-    def execute(self, args):
-        """Execute a registered hook based on args[0]"""
-        hook_name = os.path.basename(args[0])
-        if hook_name in self._hooks:
-            self._hooks[hook_name]()
-        else:
-            raise UnregisteredHookError(hook_name)
-
-    def hook(self, *hook_names):
-        """Decorator, registering them as hooks"""
-        def wrapper(decorated):
-            for hook_name in hook_names:
-                self.register(hook_name, decorated)
-            else:
-                self.register(decorated.__name__, decorated)
-                if '_' in decorated.__name__:
-                    self.register(
-                        decorated.__name__.replace('_', '-'), decorated)
-            return decorated
-        return wrapper
-
-
-def charm_dir():
-    """Return the root directory of the current charm"""
-    return os.environ.get('CHARM_DIR')
 
=== removed file 'hooks/charmhelpers/core/host.py'
--- hooks/charmhelpers/core/host.py	2015-01-27 17:31:57 +0000
+++ hooks/charmhelpers/core/host.py	1970-01-01 00:00:00 +0000
@@ -1,311 +0,0 @@
-"""Tools for working with the host system"""
-# Copyright 2012 Canonical Ltd.
-#
-# Authors:
-#  Nick Moffitt <[e-mail]>
-#  Matthew Wedgwood <[e-mail]>
-
-import os
-import pwd
-import grp
-import random
-import string
-import subprocess
-import hashlib
-import apt_pkg
-
-from collections import OrderedDict
-
-from hookenv import log
-
-
-def service_start(service_name):
-    """Start a system service"""
-    return service('start', service_name)
-
-
-def service_stop(service_name):
-    """Stop a system service"""
-    return service('stop', service_name)
-
-
-def service_restart(service_name):
-    """Restart a system service"""
-    return service('restart', service_name)
-
-
-def service_reload(service_name, restart_on_failure=False):
-    """Reload a system service, optionally falling back to restart if reload fails"""
-    service_result = service('reload', service_name)
-    if not service_result and restart_on_failure:
-        service_result = service('restart', service_name)
-    return service_result
-
-
-def service(action, service_name):
-    """Control a system service"""
-    cmd = ['service', service_name, action]
-    return subprocess.call(cmd) == 0
-
-
-def service_running(service):
-    """Determine whether a system service is running"""
-    try:
-        output = subprocess.check_output(['service', service, 'status'])
-    except subprocess.CalledProcessError:
-        return False
-    else:
-        if ("start/running" in output or "is running" in output):
-            return True
-        else:
-            return False
-
-
-def adduser(username, password=None, shell='/bin/bash', system_user=False):
-    """Add a user to the system"""
-    try:
-        user_info = pwd.getpwnam(username)
-        log('user {0} already exists!'.format(username))
-    except KeyError:
-        log('creating user {0}'.format(username))
-        cmd = ['useradd']
-        if system_user or password is None:
-            cmd.append('--system')
-        else:
-            cmd.extend([
-                '--create-home',
-                '--shell', shell,
-                '--password', password,
-            ])
-        cmd.append(username)
-        subprocess.check_call(cmd)
-        user_info = pwd.getpwnam(username)
-    return user_info
-
-
-def add_user_to_group(username, group):
-    """Add a user to a group"""
-    cmd = [
-        'gpasswd', '-a',
-        username,
-        group
-    ]
-    log("Adding user {} to group {}".format(username, group))
-    subprocess.check_call(cmd)
-
-
-def rsync(from_path, to_path, flags='-r', options=None):
-    """Replicate the contents of a path"""
-    options = options or ['--delete', '--executability']
-    cmd = ['/usr/bin/rsync', flags]
-    cmd.extend(options)
-    cmd.append(from_path)
-    cmd.append(to_path)
-    log(" ".join(cmd))
-    return subprocess.check_output(cmd).strip()
-
-
-def symlink(source, destination):
-    """Create a symbolic link"""
-    log("Symlinking {} as {}".format(source, destination))
-    cmd = [
-        'ln',
-        '-sf',
-        source,
-        destination,
-    ]
-    subprocess.check_call(cmd)
-
-
-def mkdir(path, owner='root', group='root', perms=0555, force=False):
-    """Create a directory"""
-    log("Making dir {} {}:{} {:o}".format(path, owner, group,
-                                          perms))
-    uid = pwd.getpwnam(owner).pw_uid
-    gid = grp.getgrnam(group).gr_gid
-    realpath = os.path.abspath(path)
-    if os.path.exists(realpath):
-        if force and not os.path.isdir(realpath):
-            log("Removing non-directory file {} prior to mkdir()".format(path))
-            os.unlink(realpath)
-    else:
-        os.makedirs(realpath, perms)
-    os.chown(realpath, uid, gid)
-
-
-def write_file(path, content, owner='root', group='root', perms=0444):
-    """Create or overwrite a file with the contents of a string"""
-    log("Writing file {} {}:{} {:o}".format(path, owner, group, perms))
-    uid = pwd.getpwnam(owner).pw_uid
-    gid = grp.getgrnam(group).gr_gid
-    with open(path, 'w') as target:
-        os.fchown(target.fileno(), uid, gid)
-        os.fchmod(target.fileno(), perms)
-        target.write(content)
-
-
-def mount(device, mountpoint, options=None, persist=False):
-    """Mount a filesystem at a particular mountpoint"""
-    cmd_args = ['mount']
-    if options is not None:
-        cmd_args.extend(['-o', options])
-    cmd_args.extend([device, mountpoint])
-    try:
-        subprocess.check_output(cmd_args)
-    except subprocess.CalledProcessError, e:
-        log('Error mounting {} at {}\n{}'.format(device, mountpoint, e.output))
-        return False
-    if persist:
-        # TODO: update fstab
-        pass
-    return True
-
-
-def umount(mountpoint, persist=False):
-    """Unmount a filesystem"""
-    cmd_args = ['umount', mountpoint]
-    try:
-        subprocess.check_output(cmd_args)
-    except subprocess.CalledProcessError, e:
-        log('Error unmounting {}\n{}'.format(mountpoint, e.output))
-        return False
-    if persist:
-        # TODO: update fstab
-        pass
-    return True
-
-
-def mounts():
-    """Get a list of all mounted volumes as [[mountpoint,device],[...]]"""
-    with open('/proc/mounts') as f:
-        # [['/mount/point','/dev/path'],[...]]
-        system_mounts = [m[1::-1] for m in [l.strip().split()
-                                            for l in f.readlines()]]
-    return system_mounts
-
-
-def file_hash(path):
-    """Generate a md5 hash of the contents of 'path' or None if not found """
-    if os.path.exists(path):
-        h = hashlib.md5()
-        with open(path, 'r') as source:
-            h.update(source.read())  # IGNORE:E1101 - it does have update
-        return h.hexdigest()
-    else:
-        return None
-
-
-def restart_on_change(restart_map, stopstart=False):
-    """Restart services based on configuration files changing
-
-    This function is used a decorator, for example
-
-        @restart_on_change({
-            '/etc/ceph/ceph.conf': [ 'cinder-api', 'cinder-volume' ]
-            })
-        def ceph_client_changed():
-            ...
-
-    In this example, the cinder-api and cinder-volume services
-    would be restarted if /etc/ceph/ceph.conf is changed by the
-    ceph_client_changed function.
-    """
-    def wrap(f):
-        def wrapped_f(*args):
-            checksums = {}
-            for path in restart_map:
-                checksums[path] = file_hash(path)
-            f(*args)
-            restarts = []
-            for path in restart_map:
-                if checksums[path] != file_hash(path):
-                    restarts += restart_map[path]
-            services_list = list(OrderedDict.fromkeys(restarts))
-            if not stopstart:
-                for service_name in services_list:
-                    service('restart', service_name)
-            else:
-                for action in ['stop', 'start']:
-                    for service_name in services_list:
-                        service(action, service_name)
-        return wrapped_f
-    return wrap
-
-
-def lsb_release():
-    """Return /etc/lsb-release in a dict"""
-    d = {}
-    with open('/etc/lsb-release', 'r') as lsb:
-        for l in lsb:
-            k, v = l.split('=')
-            d[k.strip()] = v.strip()
-    return d
-
-
-def pwgen(length=None):
-    """Generate a random pasword."""
-    if length is None:
-        length = random.choice(range(35, 45))
-    alphanumeric_chars = [
-        l for l in (string.letters + string.digits)
-        if l not in 'l0QD1vAEIOUaeiou']
-    random_chars = [
-        random.choice(alphanumeric_chars) for _ in range(length)]
-    return(''.join(random_chars))
-
-
-def list_nics(nic_type):
-    '''Return a list of nics of given type(s)'''
-    if isinstance(nic_type, basestring):
-        int_types = [nic_type]
-    else:
-        int_types = nic_type
-    interfaces = []
-    for int_type in int_types:
-        cmd = ['ip', 'addr', 'show', 'label', int_type + '*']
-        ip_output = subprocess.check_output(cmd).split('\n')
-        ip_output = (line for line in ip_output if line)
-        for line in ip_output:
-            if line.split()[1].startswith(int_type):
-                interfaces.append(line.split()[1].replace(":", ""))
-    return interfaces
-
-
-def set_nic_mtu(nic, mtu):
-    '''Set MTU on a network interface'''
-    cmd = ['ip', 'link', 'set', nic, 'mtu', mtu]
-    subprocess.check_call(cmd)
-
-
-def get_nic_mtu(nic):
-    cmd = ['ip', 'addr', 'show', nic]
-    ip_output = subprocess.check_output(cmd).split('\n')
-    mtu = ""
-    for line in ip_output:
-        words = line.split()
-        if 'mtu' in words:
-            mtu = words[words.index("mtu") + 1]
-    return mtu
-
-
-def get_nic_hwaddr(nic):
-    cmd = ['ip', '-o', '-0', 'addr', 'show', nic]
-    ip_output = subprocess.check_output(cmd)
-    hwaddr = ""
-    words = ip_output.split()
-    if 'link/ether' in words:
-        hwaddr = words[words.index('link/ether') + 1]
-    return hwaddr
-
-
-def cmp_pkgrevno(package, revno, pkgcache=None):
-    '''Compare supplied revno with the revno of the installed package
-       1 => Installed revno is greater than supplied arg
-       0 => Installed revno is the same as supplied arg
-      -1 => Installed revno is less than supplied arg
-    '''
-    if not pkgcache:
-        apt_pkg.init()
-        pkgcache = apt_pkg.Cache()
-    pkg = pkgcache[package]
-    return apt_pkg.version_compare(pkg.current_ver.ver_str, revno)
 
=== modified file 'hooks/hooks.py'
--- hooks/hooks.py	2015-04-10 20:43:29 +0000
+++ hooks/hooks.py	2015-07-17 20:16:05 +0000
@@ -1,4 +1,5 @@
-#!/usr/bin/python
+#!/usr/bin/env python
+
 """
 The main hook file that is called by Juju.
 """
@@ -15,6 +16,8 @@
 from kubernetes_installer import KubernetesInstaller
 from path import path
 
+from lib.registrator import Registrator
+
 hooks = hookenv.Hooks()
 
 
@@ -69,21 +72,21 @@
     # Check required keys
     for k in ('etcd_servers', 'kubeapi_server'):
         if not template_data.get(k):
-            print("Missing data for %s %s" % (k, template_data))
+            print('Missing data for %s %s' % (k, template_data))
             return
-    print("Running with\n%s" % template_data)
+    print('Running with\n%s' % template_data)
 
     # Setup kubernetes supplemental group
     setup_kubernetes_group()
 
-    # Register services
-    for n in ("cadvisor", "kubelet", "proxy"):
+    # Register upstart managed services
+    for n in ('kubelet', 'proxy'):
         if render_upstart(n, template_data) or not host.service_running(n):
-            print("Starting %s" % n)
+            print('Starting %s' % n)
             host.service_restart(n)
 
     # Register machine via api
-    print("Registering machine")
+    print('Registering machine')
     register_machine(template_data['kubeapi_server'])
 
     # Save the marker (for restarts to detect prev install)
@@ -93,7 +96,7 @@
 def get_template_data():
     rels = hookenv.relations()
     template_data = hookenv.Config()
-    template_data.CONFIG_FILE_NAME = ".unit-state"
+    template_data.CONFIG_FILE_NAME = '.unit-state'
 
     overlay_type = get_scoped_rel_attr('network', rels, 'overlay_type')
     etcd_servers = get_rel_hosts('etcd', rels, ('hostname', 'port'))
@@ -102,7 +105,7 @@
     # kubernetes master isn't ha yet.
     if api_servers:
         api_info = api_servers.pop()
-        api_servers = "http://%s:%s" % (api_info[0], api_info[1])
+        api_servers = 'http://%s:%s' % (api_info[0], api_info[1])
 
     template_data['overlay_type'] = overlay_type
     template_data['kubelet_bind_addr'] = _bind_addr(
@@ -110,7 +113,7 @@
     template_data['proxy_bind_addr'] = _bind_addr(
         hookenv.unit_get('public-address'))
     template_data['kubeapi_server'] = api_servers
-    template_data['etcd_servers'] = ",".join([
+    template_data['etcd_servers'] = ','.join([
         'http://%s:%s' % (s[0], s[1]) for s in sorted(etcd_servers)])
     template_data['identifier'] = os.environ['JUJU_UNIT_NAME'].replace(
         '/', '-')
@@ -123,7 +126,7 @@
     try:
         return socket.gethostbyname(addr)
     except socket.error:
-            raise ValueError("Could not resolve private address")
+            raise ValueError('Could not resolve private address')
 
 
 def _encode(d):
@@ -179,60 +182,36 @@
 
 def register_machine(apiserver, retry=False):
     parsed = urlparse.urlparse(apiserver)
-    headers = {"Content-type": "application/json",
-               "Accept": "application/json"}
     # identity = hookenv.local_unit().replace('/', '-')
     private_address = hookenv.unit_private_ip()
 
     with open('/proc/meminfo') as fh:
         info = fh.readline()
-        mem = info.strip().split(":")[1].strip().split()[0]
-    cpus = os.sysconf("SC_NPROCESSORS_ONLN")
-
-    request = _encode({
-        'Kind': 'Minion',
-        # These can only differ for cloud provider backed instances?
-        'ID': private_address,
-        'HostIP': private_address,
-        'metadata': {
-            'name': private_address,
-        },
-        'resources': {
-            'capacity': {
-                'mem': mem + ' K',
-                'cpu': cpus}}})
-
-    # print("Registration request %s" % request)
-    conn = httplib.HTTPConnection(parsed.hostname, parsed.port)
-    conn.request("POST", "/api/v1beta1/minions", json.dumps(request), headers)
-
-    response = conn.getresponse()
-    body = response.read()
-    print(body)
-    result = json.loads(body)
-    print("Response status:%s reason:%s body:%s" % (
-        response.status, response.reason, result))
-
-    if response.status in (200, 201):
-        print("Registered")
-    elif response.status in (409,):
-        print("Status conflict")
-        # The kubernetes API documentation suggests doing a put in this case:
-        # issue a PUT/update to modify the existing object
-        conn.request("PUT", "/api/v1beta1/minions", json.dumps(request),
-                     headers)
-    elif not retry and response.status in (500,) and result.get(
-            'message', '').startswith('The requested resource does not exist'):
-        # There's something fishy in the kube api here (0.4 dev), first time we
-        # go to register a new minion, we always seem to get this error.
-        # https://github.com/GoogleCloudPlatform/kubernetes/issues/1995
-        time.sleep(1)
-        print("Retrying registration...")
-        return register_machine(apiserver, retry=True)
-    else:
-        print("Registration error")
-        raise RuntimeError("Unable to register machine with %s" % request)
-
+        mem = info.strip().split(':')[1].strip().split()[0]
+    cpus = os.sysconf('SC_NPROCESSORS_ONLN')
+
+    registration_request = Registrator()
+    registration_request.data['Kind'] = 'Minion'
+    registration_request.data['id'] = private_address
+    registration_request.data['name'] = private_address
+    registration_request.data['metadata']['name'] = private_address
+    registration_request.data['spec']['capacity']['mem'] = mem + ' K'
+    registration_request.data['spec']['capacity']['cpu'] = cpus
+    registration_request.data['spec']['externalID'] = private_address
+    registration_request.data['status']['hostIP'] = private_address
+
+    response, result = registration_request.register(parsed.hostname,
+                                                     parsed.port,
+                                                     '/api/v1/nodes')
+
+    print(response)
+
+    try:
+        registration_request.command_succeeded(response, result)
+    except ValueError:
+        # This happens when we have already registered
+        # for now this is OK
+        pass
 
 def setup_kubernetes_group():
     output = subprocess.check_output(['groups', 'kubernetes'])
 
=== modified file 'hooks/kubernetes_installer.py'
--- hooks/kubernetes_installer.py	2015-04-10 20:43:29 +0000
+++ hooks/kubernetes_installer.py	2015-07-17 20:16:05 +0000
@@ -1,3 +1,5 @@
+#!/usr/bin/env python
+
 import subprocess
 from path import path
 
 
=== added directory 'hooks/lib'
=== added file 'hooks/lib/__init__.py'
--- hooks/lib/__init__.py	1970-01-01 00:00:00 +0000
+++ hooks/lib/__init__.py	2015-07-17 20:16:05 +0000
@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+
+
 
=== added file 'hooks/lib/registrator.py'
--- hooks/lib/registrator.py	1970-01-01 00:00:00 +0000
+++ hooks/lib/registrator.py	2015-07-17 20:16:05 +0000
@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+
+import httplib
+import json
+import time
+
+
+class Registrator:
+
+    def __init__(self):
+        self.ds ={
+          "creationTimestamp": "",
+          "kind": "Minion",
+          "name": "", # private_address
+          "metadata": {
+            "name": "", #private_address,
+          },
+          "spec": {
+            "externalID": "", #private_address
+            "capacity": {
+                "mem": "",  # mem + ' K',
+                "cpu": "",  # cpus
+            }
+          },
+          "status": {
+            "conditions": [],
+            "hostIP": "", #private_address
+          }
+        }
+
+    @property
+    def data(self):
+        ''' Returns a data-structure for population to make a request. '''
+        return self.ds
+
+    def register(self, hostname, port, api_path):
+        ''' Contact the API Server for a new registration '''
+        headers = {"Content-type": "application/json",
+                   "Accept": "application/json"}
+        connection = httplib.HTTPConnection(hostname, port)
+        print 'CONN {}'.format(connection)
+        connection.request("POST", api_path, json.dumps(self.data), headers)
+        response = connection.getresponse()
+        body = response.read()
+        print(body)
+        result = json.loads(body)
+        print("Response status:%s reason:%s body:%s" % \
+             (response.status, response.reason, result))
+        return response, result
+
+    def update(self):
+        ''' Contact the API Server to update a registration '''
+        # do a get on the API for the node
+        # repost to the API with any modified data
+        pass
+
+    def save(self):
+        ''' Marshall the registration data '''
+        # TODO
+        pass
+
+    def command_succeeded(self, response, result):
+        ''' Evaluate response data to determine if the command was successful '''
+        if response.status in [200, 201]:
+            print("Registered")
+            return True
+        elif response.status in [409,]:
+            print("Status Conflict")
+            # Suggested return a PUT instead of a POST with this response
+            # code, this predicates use of the UPDATE method
+            # TODO
+        elif response.status in (500,) and result.get(
+            'message', '').startswith('The requested resource does not exist'):
+            # There's something fishy in the kube api here (0.4 dev), first time we
+            # go to register a new minion, we always seem to get this error.
+            # https://github.com/GoogleCloudPlatform/kubernetes/issues/1995
+            time.sleep(1)
+            print("Retrying registration...")
+            raise ValueError("Registration returned 500, retry")
+            # return register_machine(apiserver, retry=True)
+        else:
+            print("Registration error")
+            # TODO - get request data
+            raise RuntimeError("Unable to register machine with")
 \ No newline at end of file
 
=== added directory 'unit_tests/lib'
=== added file 'unit_tests/lib/test_registrator.py'
--- unit_tests/lib/test_registrator.py	1970-01-01 00:00:00 +0000
+++ unit_tests/lib/test_registrator.py	2015-07-17 20:16:05 +0000
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+
+import json
+from mock import MagicMock, patch, call
+from path import Path
+import pytest
+import sys
+
+d = Path('__file__').parent.abspath() / 'hooks'
+sys.path.insert(0, d.abspath())
+
+from lib.registrator import Registrator
+
+class TestRegistrator():
+
+    def setup_method(self, method):
+        self.r = Registrator()
+
+    def test_data_type(self):
+        if type(self.r.data) is not dict:
+            pytest.fail("Invalid type")
+
+    @patch('json.loads')
+    @patch('httplib.HTTPConnection')
+    def test_register(self, httplibmock, jsonmock):
+        result = self.r.register('foo', 80, '/v1/test')
+
+        httplibmock.assert_called_with('foo', 80)
+        requestmock = httplibmock().request
+        requestmock.assert_called_with(
+                "POST", "/v1/test",
+                json.dumps(self.r.data),
+                {"Content-type": "application/json",
+                 "Accept": "application/json"})
+
+
+    def test_command_succeeded(self):
+        response = MagicMock()
+        result = json.loads('{"status": "Failure", "kind": "Status", "code": 409, "apiVersion": "v1", "reason": "AlreadyExists", "details": {"kind": "node", "name": "10.200.147.200"}, "message": "node \\"10.200.147.200\\" already exists", "creationTimestamp": null}')
+        response.status = 200
+        self.r.command_succeeded(response, result)
+        response.status = 500
+        with pytest.raises(RuntimeError):
+            self.r.command_succeeded(response, result)
+        response.status = 409
+        with pytest.raises(ValueError):
+            self.r.command_succeeded(response, result)
 
=== modified file 'unit_tests/test_hooks.py'
--- unit_tests/test_hooks.py	2015-04-10 20:43:29 +0000
+++ unit_tests/test_hooks.py	2015-07-17 20:16:05 +0000
@@ -1,3 +1,5 @@
+#!/usr/bin/env python
+
 # import pytest