Merge lp:~smoser/maas/maas-cli into lp:maas/trunk

[Dave Walker]

[Julian Edwards (julian-edwards)]

This is going to be very useful! I know you said to ignore but here's some pre-review help:

 * the oauth code has been cargo culted from juju and still contains juju references
 * please don't pollute the top-level dir, add this to contrib/ instead.

[Scott Moser (smoser)]

On Wed, 11 Apr 2012, Julian Edwards wrote:

> This is going to be very useful! I know you said to ignore but here's some pre-review help:
>
> * the oauth code has been cargo culted from juju and still contains juju references

ok. i'll wipe that.

> * please don't pollute the top-level dir, add this to contrib/ instead.

yeah, i agree. I knew it wasn't right when I did it. but just started
somewhere.

Unmerged revisions

372. By Scott Moser on 2012-03-30

functional release node

371. By Scott Moser on 2012-03-30

fix maascli, removing twisted

370. By Scott Moser on 2012-03-30

change from twisted client to urllib2

369. By Scott Moser on 2012-03-30

merge trunk

368. By Scott Moser on 2012-03-29

initial commit of maas-cli

=== modified file '.bzrignore'
--- .bzrignore	2012-03-14 15:52:49 +0000
+++ .bzrignore	2012-04-10 20:11:22 +0000
@@ -20,3 +20,4 @@
 ./TAGS
 ./tags
 ./twisted/plugins/dropin.cache
+my.cfg

=== added directory 'maas-cli'
=== added file 'maas-cli/maascli.py'
--- maas-cli/maascli.py	1970-01-01 00:00:00 +0000
+++ maas-cli/maascli.py	2012-04-10 20:11:22 +0000
@@ -0,0 +1,116 @@
+#!/usr/bin/python
+
+import argparse
+import pprint
+from maasclient.maas import MAASClient
+
+def get_config(args):
+    """ takes in an args, returns the maas config,
+        handles command line overriding args.config """
+    cfg = {'maas-server': args.server, 'maas-oauth': args.oauth,
+           'admin-secret': args.secret}
+
+    if args.config:
+        import yaml
+        with open(args.config) as fp:
+            filecfg = yaml.load(fp)
+        for key in cfg.keys():
+            if key in filecfg and cfg[key] == None:
+                cfg[key] = filecfg[key]
+
+    # oauth is ':' delimited consumer_key, resource_token, resource_secret
+    cfg['maas-oauth'] = cfg['maas-oauth'].split(":")
+    return cfg
+
+def search_nodelist(match):
+    pass
+
+def print_nodes(result):
+    import pprint
+    pprint.pprint(result)
+
+
+def node_list_acquired(client, args):
+    """ list the nodes """
+    data = client.get_allocated_nodes(resource_uris=args.systems)
+    pprint.pprint(data)
+
+def node_list(client, args):
+    """ list the nodes """
+    print_nodes(client.get_nodes(resource_uris=args.systems))
+
+def node_create(client, args):
+    """ create a new node """
+    pass
+
+def node_release(client, args):
+    """ request/claim a node """
+    for sysuri in args.systems:
+        data = client.release_node(sysuri)
+        print data
+
+def node_release_all(client, args):
+    data = client.release_node()
+
+def node_start(client, args):
+    """ start an acuired node """
+    pass
+
+def node_acquire(client, args):
+    """ acquire a node """
+    print_nodes(client.acquire_node())
+
+def node_delete(client, args):
+    """ delete a node """
+    pass
+
+def main():
+    """
+    Call with single argument of directory or http or https url.
+    If url is given additional arguments are allowed, which will be
+    interpreted as consumer_key, token_key, token_secret, consumer_secret
+    """
+
+    parser = argparse.ArgumentParser(description='maas client')
+    parser.add_argument("--config", metavar="file",
+        help="specify yaml config file", default=None)
+    parser.add_argument("--server", metavar="url",
+        help="the maas server", default=None)
+    parser.add_argument("--oauth", metavar="oauth",
+        help="the oauth credentials string", default=None)
+    parser.add_argument("--secret", metavar="secret",
+        help="the admin secret", default=None)
+
+    subcmds = parser.add_subparsers(title="subcommands", dest="subcmd")
+
+    p_list = subcmds.add_parser('node-list', help="list nodes")
+    p_list.add_argument('systems', metavar='uri', nargs='*')
+    p_list.set_defaults(func=node_list)
+
+    p_list_acquired = subcmds.add_parser('node-list-acquired',
+        help="list aquired nodes")
+    p_list_acquired.add_argument('systems', metavar='uri', nargs='*')
+    p_list_acquired.set_defaults(func=node_list_acquired)
+
+    p_create = subcmds.add_parser('node-create', help="create a node")
+    p_create.set_defaults(func=node_create)
+
+    p_request = subcmds.add_parser('node-acquire', help="acquire a node")
+    p_request.set_defaults(func=node_acquire)
+
+    p_release = subcmds.add_parser('node-release', help="release a node")
+    p_release.add_argument('systems', metavar='uri', nargs='*')
+    p_release.set_defaults(func=node_release)
+
+    p_delete = subcmds.add_parser('node-delete', help="delete a node")
+    p_delete.add_argument('systems', metavar='uri', nargs='*')
+    p_delete.set_defaults(func=node_delete)
+
+    args = parser.parse_args()
+
+    client = MAASClient(get_config(args))
+    args.func(client, args)
+
+
+if __name__ == "__main__":
+    main()

=== added directory 'maas-cli/maasclient'
=== added file 'maas-cli/maasclient/__init__.py'
=== added file 'maas-cli/maasclient/auth.py'
--- maas-cli/maasclient/auth.py	1970-01-01 00:00:00 +0000
+++ maas-cli/maasclient/auth.py	2012-04-10 20:11:22 +0000
@@ -0,0 +1,60 @@
+# Copyright 2012 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""OAuth functions for authorisation against a maas server."""
+
+import oauth.oauth as oauth
+from urlparse import urlparse
+import urllib2
+
+
+def _ascii_url(url):
+    """Ensure that the given URL is ASCII, encoding if necessary."""
+    if isinstance(url, unicode):
+        urlparts = urlparse(url)
+        urlparts = urlparts._replace(
+            netloc=urlparts.netloc.encode("idna"))
+        url = urlparts.geturl()
+    return url.encode("ascii")
+
+
+class MAASOAuthConnection(object):
+    """Helper class to provide an OAuth auth'd connection to MAAS."""
+
+    def __init__(self, oauth_info):
+        consumer_key, resource_token, resource_secret = oauth_info
+        resource_tok_string = "oauth_token_secret=%s&oauth_token=%s" % (
+            resource_secret, resource_token)
+        self.resource_token = oauth.OAuthToken.from_string(resource_tok_string)
+        self.consumer_token = oauth.OAuthConsumer(consumer_key, "")
+
+    def oauth_sign_request(self, url, headers):
+        """Sign a request.
+
+        @param url: The URL to which the request is to be sent.
+        @param headers: The headers in the request.
+        """
+        oauth_request = oauth.OAuthRequest.from_consumer_and_token(
+            self.consumer_token, token=self.resource_token, http_url=url)
+        oauth_request.sign_request(
+            oauth.OAuthSignatureMethod_PLAINTEXT(), self.consumer_token,
+            self.resource_token)
+        headers.update(oauth_request.to_header())
+
+
+    def request(self, request_url, method="GET",
+                       data=None, headers=None):
+        """Dispatch an OAuth-signed request to L{request_url}.
+
+        @param request_url: The URL to which the request is to be sent.
+        @param method: The HTTP method, e.g. C{GET}, C{POST}, etc.
+        @param data: The data to send, if any.
+        @type data: A byte string.
+        @param headers: Headers to including in the request.
+        """
+        if headers is None:
+            headers = {}
+        self.oauth_sign_request(request_url, headers)
+        req = urllib2.Request(request_url,
+            data=data, headers=headers)
+        return(urllib2.urlopen(req).read())

=== added file 'maas-cli/maasclient/maas.py'
--- maas-cli/maasclient/maas.py	1970-01-01 00:00:00 +0000
+++ maas-cli/maasclient/maas.py	2012-04-10 20:11:22 +0000
@@ -0,0 +1,194 @@
+# Copyright 2012 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""MAAS API client for Juju"""
+
+from base64 import b64encode
+import json
+import random
+import string
+import re
+from urllib import urlencode
+from urlparse import urljoin
+
+from auth import MAASOAuthConnection
+
+
+def convert_unknown_error(error):
+    print "Error: %s" % error
+    return error
+
+CONSUMER_SECRET = ""
+
+
+_re_resource_uri = re.compile(
+    '/api/(?P<version>[^/]+)/nodes/(?P<system_id>[^/]+)/?')
+
+def _encode_field(field_name, data, boundary):
+    return ('--' + boundary,
+            'Content-Disposition: form-data; name="%s"' % field_name,
+            '', str(data))
+
+
+def _encode_file(name, fileObj, boundary):
+    return ('--' + boundary,
+            'Content-Disposition: form-data; name="%s"; filename="%s"' %
+                (name, name),
+            'Content-Type: %s' % _get_content_type(name),
+            '', fileObj.read())
+
+def _random_string(length):
+    return ''.join(random.choice(string.letters) for ii in range(length + 1))
+
+
+def encode_multipart_data(data, files):
+    """Create a MIME multipart payload from L{data} and L{files}.
+
+    @param data: A mapping of names (ASCII strings) to data (byte string).
+    @param files: A mapping of names (ASCII strings) to file objects ready to
+        be read.
+    @return: A 2-tuple of C{(body, headers)}, where C{body} is a a byte string
+        and C{headers} is a dict of headers to add to the enclosing request in
+        which this payload will travel.
+    """
+    boundary = _random_string(30)
+
+    lines = []
+    for name in data:
+        lines.extend(_encode_field(name, data[name], boundary))
+    for name in files:
+        lines.extend(_encode_file(name, files[name], boundary))
+    lines.extend(('--%s--' % boundary, ''))
+    body = '\r\n'.join(lines)
+
+    headers = {'content-type': 'multipart/form-data; boundary=' + boundary,
+               'content-length': str(len(body))}
+
+    return body, headers
+
+
+def extract_system_id(resource_uri):
+    """Extract a system ID from a resource URI.
+
+    This is fairly unforgiving; an exception is raised if the URI given does
+    not look like a MAAS node resource URI.
+
+    :param resource_uri: A URI that corresponds to a MAAS node resource.
+    :raises: :exc:`juju.errors.ProviderError` when `resource_uri` does not
+        resemble a MAAS node resource URI.
+    """
+    match = _re_resource_uri.search(resource_uri)
+    if match is None:
+        raise TypeError(
+            "%r does not resemble a MAAS resource URI." % (resource_uri,))
+    else:
+        return match.group("system_id")
+
+
+class MAASClient(MAASOAuthConnection):
+
+    def __init__(self, config):
+        """Initialise an API client for MAAS.
+
+        :param config: a dict of configuration values; must contain
+            'maas-server', 'maas-oauth', 'admin-secret'
+        """
+        self.url = config["maas-server"]
+        if not self.url.endswith('/'):
+            self.url += "/"
+        self.oauth_info = config["maas-oauth"]
+        self.admin_secret = config["admin-secret"]
+        super(MAASClient, self).__init__(self.oauth_info)
+
+    def get(self, path, params):
+        """Dispatch a C{GET} call to a MAAS server.
+
+        :param uri: The MAAS path for the endpoint to call.
+        :param params: A C{dict} of parameters - or sequence of 2-tuples - to
+            encode into the request.
+        :return: A Deferred which fires with the result of the call.
+        """
+        url = "%s?%s" % (urljoin(self.url, path), urlencode(params))
+        d = self.request(url)
+        return json.loads(self.request(url))
+
+    def post(self, path, params):
+        """Dispatch a C{POST} call to a MAAS server.
+
+        :param uri: The MAAS path for the endpoint to call.
+        :param params: A C{dict} of parameters to encode into the request.
+        :return: A Deferred which fires with the result of the call.
+        """
+        url = urljoin(self.url, path)
+        body, headers = encode_multipart_data(params, {})
+        return json.loads(
+            self.request(url, "POST", headers=headers, data=body))
+
+    def get_allocated_nodes(self, resource_uris=None):
+        """Ask MAAS to return a list of all the nodes it knows about.
+
+        :param resource_uris: The MAAS URIs for the nodes you want to get.
+        :return: A Deferred whose value is the list of nodes.
+        """
+        params = [("op", "list_allocated")]
+        if resource_uris is not None:
+            params.extend(
+                ("id", extract_system_id(resource_uri))
+                for resource_uri in resource_uris)
+        return self.get("api/1.0/nodes/", params)
+
+    def get_nodes(self, resource_uris=None):
+        """Ask MAAS to return a list of all the nodes it knows about.
+
+        :param resource_uris: The MAAS URIs for the nodes you want to get.
+        :return: A Deferred whose value is the list of nodes.
+        """
+        params = [("op", "list")]
+        if resource_uris is not None:
+            params.extend(
+                ("id", extract_system_id(resource_uri))
+                for resource_uri in resource_uris)
+        return self.get("api/1.0/nodes/", params)
+
+    def acquire_node(self):
+        """Ask MAAS to assign a node to us.
+
+        :return: A Deferred whose value is the resource URI to the node
+            that was acquired.
+        """
+        params = {"op": "acquire"}
+        return self.post("api/1.0/nodes/", params)
+
+    def start_node(self, resource_uri, user_data):
+        """Ask MAAS to start a node.
+
+        :param resource_uri: The MAAS URI for the node you want to start.
+        :param user_data: Any blob of data to be passed to MAAS. Must be
+            possible to encode as base64.
+        :return: A Deferred whose value is the resource data for the node
+            as returned by get_nodes().
+        """
+        assert isinstance(user_data, str), (
+            "User data must be a byte string.")
+        params = {"op": "start", "user_data": b64encode(user_data)}
+        return self.post(resource_uri, params)
+
+    def stop_node(self, resource_uri):
+        """Ask maas to shut down a node.
+
+        :param resource_uri: The MAAS URI for the node you want to stop.
+        :return: A Deferred whose value is the resource data for the node
+            as returned by get_nodes().
+        """
+        params = {"op": "stop"}
+        return self.post(resource_uri, params)
+
+    def release_node(self, resource_uri):
+        """Ask MAAS to release a node from our ownership.
+
+        :param resource_uri: The URI in MAAS for the node you want to release.
+        :return: A Deferred which fires with the resource data for the node
+            just released.
+        """
+        params = {"op": "release"}
+        return self.post(resource_uri, params)

=== added file 'maas-cli/my.cfg.example'
--- maas-cli/my.cfg.example	1970-01-01 00:00:00 +0000
+++ maas-cli/my.cfg.example	2012-04-10 20:11:22 +0000
@@ -0,0 +1,3 @@
+maas-server: 'http://localhost:5240'
+maas-oauth: 'vpxQGKsece8WVmT52b:KgaK2mEuq5kqJMVPuA:4KWMF4eWRGQWydccyxfMJwnqNWDjBz3z'
+admin-secret: 'nothing'

=== modified file 'src/maas/settings.py'
--- src/maas/settings.py	2012-04-02 07:06:37 +0000
+++ src/maas/settings.py	2012-04-10 20:11:22 +0000
@@ -22,7 +22,7 @@
 
 django.template.add_to_builtins('django.templatetags.future')
 
-DEBUG = False
+DEBUG = True
 
 # Used to set a prefix in front of every URL.
 FORCE_SCRIPT_NAME = None
@@ -171,6 +171,7 @@
     # Put strings here, like "/home/html/static" or "C:/www/django/static".
     # Always use forward slashes, even on Windows.
     # Don't forget to use absolute paths, not relative paths.
+    '/home/ubuntu/src/maas/maas/src/maasserver/static/',
 )
 
 # List of finder classes that know how to find static files in