Dockerfile

@@ -1,8 +0,0 @@
-FROM python:2.7.11-alpine
-
-RUN apk update && apk add ca-certificates
-
-ADD . /sdk
-WORKDIR sdk
-RUN python setup.py install
-

MANIFEST.in

@@ -1,4 +1,3 @@
 include LICENSE
 include requirements.txt
-include test-requirements.txt
 include README.md

Makefile

@@ -0,0 +1,13 @@
+test:prepare
+	venv/bin/python setup.py test
+
+clean:
+	rm -rf venv build dist *.egg-info
+	find . -name '*.pyc' -delete
+
+prepare:clean
+	set -ex
+	virtualenv venv
+	venv/bin/pip install mock
+	venv/bin/pip install -r requirements.txt
+	venv/bin/python setup.py install

README.md

@@ -29,19 +29,6 @@ The authentication can be configured in the following ways:
 		export DOCKERCLOUD_USER=username
 		export DOCKERCLOUD_APIKEY=apikey
 
-## Namespace
-
-To support teams and orgs, you can specify the namespace in the following ways:
-
-* Set it in the Python code:
-
-        import dockercloud
-        dockercloud.namespace = "yourteam"
-
-* Set it in the environment variable:
-
-        export DOCKERCLOUD_NAMESPACE=yourteam
-
 ## Errors
 
 Errors in the HTTP API will be returned with status codes in the 4xx and 5xx ranges.

docker-compose.test.yml

@@ -1,3 +0,0 @@
-sut:
-  build: .
-  command: python setup.py test

dockercloud/__init__.py

@@ -25,7 +25,7 @@ from dockercloud.api.utils import Utils
 from dockercloud.api.events import Events
 from dockercloud.api.nodeaz import AZ
 
-__version__ = '1.0.9'
+__version__ = '1.0.2'
 
 dockercloud_auth = os.environ.get('DOCKERCLOUD_AUTH')
 basic_auth = auth.load_from_file("~/.docker/config.json")
@@ -38,8 +38,6 @@ if os.environ.get('DOCKERCLOUD_USER') and os.environ.get('DOCKERCLOUD_APIKEY'):
 rest_host = os.environ.get("DOCKERCLOUD_REST_HOST") or 'https://cloud.docker.com/'
 stream_host = os.environ.get("DOCKERCLOUD_STREAM_HOST") or 'wss://ws.cloud.docker.com/'
 
-namespace = os.environ.get('DOCKERCLOUD_NAMESPACE')
-
 user_agent = None
 
 logging.basicConfig()

dockercloud/api/action.py

@@ -6,7 +6,6 @@ from .base import Immutable, StreamingLog
 class Action(Immutable):
     subsystem = 'audit'
     endpoint = "/action"
-    namespaced = False
 
     @classmethod
     def _pk_key(cls):

dockercloud/api/auth.py

@@ -3,14 +3,12 @@ from __future__ import absolute_import
 import base64
 import json
 import os
-import subprocess
 
 from requests.auth import HTTPBasicAuth
 
 import dockercloud
 from .http import send_request
 
-HUB_INDEX = "https://index.docker.io/v1/"
 
 def authenticate(username, password):
     verify_credential(username, password)
@@ -45,29 +43,11 @@ def load_from_file(f="~/.docker/config.json"):
     try:
         with open(os.path.expanduser(f)) as config_file:
             data = json.load(config_file)
-    except:
+
+        return data.get("auths", {}).get("https://index.docker.io/v1/", {}).get("auth", None)
+    except Exception:
         return None
 
-    creds_store = data.get("credsStore", None)
-    if creds_store:
-        try:
-            cmd = "docker-credential-" + creds_store
-            p = subprocess.Popen([cmd, 'get'], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.STDOUT)
-            out = p.communicate(input=HUB_INDEX)[0]
-        except:
-            raise dockercloud.AuthError('error getting credentials - err: exec: "%s": executable file not found in $PATH, out: ``' % cmd)
-
-        try:
-            credential = json.loads(out)
-            username = credential.get("Username")
-            password = credential.get("Secret")
-            return base64.b64encode("%s:%s" % (username, password))
-        except:
-            return None
-
-    else:
-        return data.get("auths", {}).get(HUB_INDEX, {}).get("auth", None)
-
 
 def get_auth_header():
     try:

dockercloud/api/base.py

@@ -22,7 +22,6 @@ class BasicObject(object):
 
 class Restful(BasicObject):
     _detail_uri = None
-    namespaced = True
 
     def __init__(self, **kwargs):
         """Simply reflect all the values in kwargs"""
@@ -59,10 +58,6 @@ class Restful(BasicObject):
         assert subsystem, "Subsystem not specified for %s" % self.__class__.__name__
         for k, v in list(dict.items()):
             setattr(self, k, v)
-        if self.namespaced and dockercloud.namespace:
-            self._detail_uri = "/".join(["api", subsystem, self._api_version, dockercloud.namespace,
-                                         endpoint.strip("/"), self.pk])
-        else:
         self._detail_uri = "/".join(["api", subsystem, self._api_version, endpoint.strip("/"), self.pk])
         self.__setchanges__([])
 
@@ -131,9 +126,6 @@ class Immutable(Restful):
         subsystem = getattr(cls, 'subsystem', None)
         assert endpoint, "Endpoint not specified for %s" % cls.__name__
         assert subsystem, "Subsystem not specified for %s" % cls.__name__
-        if cls.namespaced and dockercloud.namespace:
-            detail_uri = "/".join(["api", subsystem, cls._api_version, dockercloud.namespace, endpoint.strip("/"), pk])
-        else:
         detail_uri = "/".join(["api", subsystem, cls._api_version, endpoint.strip("/"), pk])
         json = send_request('GET', detail_uri)
         if json:
@@ -149,9 +141,6 @@ class Immutable(Restful):
         assert endpoint, "Endpoint not specified for %s" % cls.__name__
         assert subsystem, "Subsystem not specified for %s" % cls.__name__
 
-        if cls.namespaced and dockercloud.namespace:
-            detail_uri = "/".join(["api", subsystem, cls._api_version, dockercloud.namespace, endpoint.strip("/")])
-        else:
         detail_uri = "/".join(["api", subsystem, cls._api_version, endpoint.strip("/")])
         objects = []
         while True:
@@ -230,9 +219,6 @@ class Mutable(Immutable):
             # Figure out whether we should do a create or update
             if not self._detail_uri:
                 action = "POST"
-                if cls.namespaced and dockercloud.namespace:
-                    path = "/".join(["api", subsystem, self._api_version, dockercloud.namespace, endpoint.lstrip("/")])
-                else:
                 path = "/".join(["api", subsystem, self._api_version, endpoint.lstrip("/")])
             else:
                 action = "PATCH"
@@ -267,14 +253,18 @@ class Triggerable(BasicObject):
 
 class StreamingAPI(BasicObject):
     def __init__(self, url):
+        self._ws_init(url)
+
+    def _ws_init(self, url):
         self.url = url
+
         user_agent = 'python-dockercloud/%s' % dockercloud.__version__
         if dockercloud.user_agent:
             user_agent = "%s %s" % (dockercloud.user_agent, user_agent)
         header = {'User-Agent': user_agent}
         header.update(dockercloud.auth.get_auth_header())
         self.header = [": ".join([key, value]) for key, value in header.items()]
-        logger.info("Websocket: %s %s" % (self.url, self.header))
+        logger.info("websocket: %s %s" % (self.url, self.header))
         self.open_handler = None
         self.message_handler = None
         self.error_handler = None
@@ -318,7 +308,7 @@ class StreamingAPI(BasicObject):
                                         on_message=self._on_message,
                                         on_error=self._on_error,
                                         on_close=self._on_close)
-            ws.run_forever(ping_interval=10, ping_timeout=5, *args, **kwargs)
+            ws.run_forever(ping_interval=5, ping_timeout=5, *args, **kwargs)
 
 
 class StreamingLog(StreamingAPI):
@@ -326,12 +316,7 @@ class StreamingLog(StreamingAPI):
         endpoint = "%s/%s/logs/?follow=%s" % (resource, uuid, str(follow).lower())
         if tail:
             endpoint = "%s&tail=%d" % (endpoint, tail)
-        if dockercloud.namespace:
-            url = "/".join([dockercloud.stream_host.rstrip("/"), "api", subsystem, self._api_version,
-                            dockercloud.namespace, endpoint.lstrip("/")])
-        else:
-            url = "/".join([dockercloud.stream_host.rstrip("/"), "api", subsystem, self._api_version,
-                            endpoint.lstrip("/")])
+        url = "/".join([dockercloud.stream_host.rstrip("/"), "api", subsystem, self._api_version, endpoint.lstrip("/")])
         super(self.__class__, self).__init__(url)
 
     @staticmethod
@@ -344,16 +329,12 @@ class StreamingLog(StreamingAPI):
                                     on_message=self._on_message,
                                     on_error=self._on_error,
                                     on_close=self._on_close)
-        ws.run_forever(ping_interval=10, ping_timeout=5, *args, **kwargs)
+        ws.run_forever(ping_interval=5, ping_timeout=5, *args, **kwargs)
 
 
 class Exec(StreamingAPI):
     def __init__(self, uuid, cmd='sh'):
         endpoint = "container/%s/exec/?command=%s" % (uuid, urllib.quote_plus(cmd))
-        if dockercloud.namespace:
-            url = "/".join([dockercloud.stream_host.rstrip("/"), "api", "app", self._api_version,
-                            dockercloud.namespace, endpoint.lstrip("/")])
-        else:
         url = "/".join([dockercloud.stream_host.rstrip("/"), "api", "app", self._api_version, endpoint.lstrip("/")])
         super(self.__class__, self).__init__(url)
 
@@ -367,4 +348,4 @@ class Exec(StreamingAPI):
                                     on_message=self._on_message,
                                     on_error=self._on_error,
                                     on_close=self._on_close)
-        ws.run_forever(ping_interval=10, ping_timeout=5, *args, **kwargs)
+        ws.run_forever(ping_interval=5, ping_timeout=5, *args, **kwargs)

dockercloud/api/events.py

@@ -1,7 +1,6 @@
 from __future__ import absolute_import
 
 import json
-import logging
 
 import websocket
 
@@ -9,47 +8,35 @@ import dockercloud
 from .base import StreamingAPI
 from .exceptions import AuthError
 
-logger = logging.getLogger("python-dockercloud")
-
 
 class Events(StreamingAPI):
     def __init__(self):
         endpoint = "events"
-        if dockercloud.namespace:
-            url = "/".join([dockercloud.stream_host.rstrip("/"), "api", "audit", self._api_version,
-                            dockercloud.namespace, endpoint.lstrip("/")])
-        else:
-            url = "/".join([dockercloud.stream_host.rstrip("/"), "api", "audit", self._api_version,
-                            endpoint.lstrip("/")])
+        url = "/".join([dockercloud.stream_host.rstrip("/"), "api", "audit", self._api_version, endpoint.lstrip("/")])
         super(self.__class__, self).__init__(url)
 
     def _on_message(self, ws, message):
-        logger.info("Websocket Message: %s" % message)
         try:
             event = json.loads(message)
         except ValueError:
             return
+
+        if event.get("type") == "error" and event.get("data", {}).get("errorMessage") == "UNAUTHORIZED":
+            self.auth_error = True
+            raise AuthError("Not authorized")
         if event.get("type") == "auth":
             return
 
         if self.message_handler:
             self.message_handler(message)
 
-    def _on_error(self, ws, e):
-        if isinstance(e, websocket._exceptions.WebSocketBadStatusException) and getattr(e, "status_code") == 401:
-            self.auth_error = True
-
-        super(self.__class__, self)._on_error(ws, e)
-
     def run_forever(self, *args, **kwargs):
         while True:
             if self.auth_error:
-                self.auth_error = False
-                raise AuthError("Not Authorized")
-
+                raise AuthError("Not authorized")
             ws = websocket.WebSocketApp(self.url, header=self.header,
                                         on_open=self._on_open,
                                         on_message=self._on_message,
                                         on_error=self._on_error,
                                         on_close=self._on_close)
-            ws.run_forever(ping_interval=10, ping_timeout=5, *args, **kwargs)
+            ws.run_forever(ping_interval=5, ping_timeout=5, *args, **kwargs)

dockercloud/api/http.py

@@ -47,15 +47,14 @@ def send_request(method, path, inject_header=True, **kwargs):
 
     # construct request
     s = get_session()
-    request = Request(method, url, headers=headers, **kwargs)
+    req = Request(method, url, headers=headers, **kwargs)
     # get environment proxies
     env_proxies = utils.get_environ_proxies(url) or {}
     kw_args = {'proxies': env_proxies}
 
     # make the request
-    req = s.prepare_request(request)
-    logger.info("Prepared Request: %s, %s, %s, %s" % (req.method, req.url, req.headers, kwargs))
-    response = s.send(req, **kw_args)
+    logger.info("Request: %s, %s, %s, %s, %s" % (method, url, headers, s.cookies, kwargs))
+    response = s.send(req.prepare(), **kw_args)
     status_code = getattr(response, 'status_code', None)
     logger.info("Response: Status %s, %s, %s" % (str(status_code), response.headers, response.text))
 

dockercloud/api/nodeaz.py

@@ -6,7 +6,6 @@ from .base import Immutable
 class AZ(Immutable):
     subsystem = "infra"
     endpoint = "/az"
-    namespaced = False
 
     @classmethod
     def _pk_key(cls):

dockercloud/api/nodeprovider.py

@@ -6,7 +6,6 @@ from .base import Immutable
 class Provider(Immutable):
     subsystem = "infra"
     endpoint = "/provider"
-    namespaced = False
 
     @classmethod
     def _pk_key(cls):

dockercloud/api/noderegion.py

@@ -6,7 +6,6 @@ from .base import Immutable
 class Region(Immutable):
     subsystem = "infra"
     endpoint = "/region"
-    namespaced = False
 
     @classmethod
     def _pk_key(cls):

dockercloud/api/nodetype.py

@@ -6,7 +6,6 @@ from .base import Immutable
 class NodeType(Immutable):
     subsystem = "infra"
     endpoint = "/nodetype"
-    namespaced = False
 
     @classmethod
     def _pk_key(cls):

hooks/push

@@ -1,2 +0,0 @@
-#!/bin/sh
-echo "Skipping push the image"

requirements.txt

@@ -1,4 +1,5 @@
+backports.ssl-match-hostname==3.4.0.2
 future==0.15.0
 requests==2.7.0
 six==1.9.0
-websocket-client==0.37.0
+websocket-client==0.32.0

setup.py

@@ -4,13 +4,6 @@ import re
 
 from setuptools import setup, find_packages
 
-requirements =[
-    "future >= 0.15.0, < 1",
-    "requests >= 2.5.2, < 3",
-    "six >= 1.3.0, < 2",
-    "websocket-client >= 0.32.0, < 1"
-]
-
 
 def read(*parts):
     path = os.path.join(os.path.dirname(__file__), *parts)
@@ -26,16 +19,15 @@ def find_version(*file_paths):
         return version_match.group(1)
     raise RuntimeError('Unable to find version string.')
 
-with open('./test-requirements.txt') as test_reqs_txt:
-    test_requirements = [line for line in test_reqs_txt]
 
+with open('requirements.txt') as f:
+    install_requires = f.read().splitlines()
 
 setup(
         name="python-dockercloud",
         version=find_version('dockercloud', '__init__.py'),
         packages=find_packages(),
-        install_requires=requirements,
-        tests_require=test_requirements,
+        install_requires=install_requires,
         provides=['docker'],
         include_package_data=True,
         author="Docker, Inc.",

test-requirements.txt

@@ -1,3 +0,0 @@
-mock==1.0.1
-coverage==4.0.3
-nose==1.3.7