Changeset 202

Timestamp:

08/01/12 21:17:29 (12 years ago)

Author:

atzm

Message:

• support JSON-RPC 2.0

File:

• etherws/trunk/etherws.py (modified) (18 diffs)

etherws/trunk/etherws.py

@@ -393 +393 @@
     def open(self):
         if not self.closed:
-            raise ValueError('already opened')
+            raise ValueError('Already opened')
         self._tap = TunTapDevice(self._dev, IFF_TAP | IFF_NO_PI)
         self._tap.up()
@@ -464 +464 @@
 
         if not self.closed:
-            raise websocket.WebSocketException('already opened')
+            raise websocket.WebSocketException('Already opened')
 
         if self._ssl:
@@ -480 +480 @@
     def close(self):
         if self.closed:
-            raise websocket.WebSocketException('already closed')
+            raise websocket.WebSocketException('Already closed')
         self._switch.unregister_port(self)
         self._ioloop.remove_handler(self.fileno())
@@ -489 +489 @@
     def fileno(self):
         if self.closed:
-            raise websocket.WebSocketException('closed socket')
+            raise websocket.WebSocketException('Closed socket')
         return self._sock.io_sock.fileno()
 
     def write_message(self, message, binary=False):
         if self.closed:
-            raise websocket.WebSocketException('closed socket')
+            raise websocket.WebSocketException('Closed socket')
         if binary:
             flag = websocket.ABNF.OPCODE_BINARY
@@ -527 +527 @@
 
     def post(self):
-        id_ = None
-
-        try:
-            req = json.loads(self.request.body)
-            method = req['method']
-            params = req['params']
-            id_ = req.get('id')
-
+        try:
+            request = json.loads(self.request.body)
+        except Exception as e:
+            return self._jsonrpc_response(error={
+                'code':    0 - 32700,
+                'message': 'Parse error',
+                'data':    '%s: %s' % (e.__class__.__name__, str(e)),
+            })
+
+        try:
+            id_ = request.get('id')
+            params = request.get('params')
+            version = request['jsonrpc']
+            method = request['method']
+            if version != '2.0':
+                raise ValueError('Invalid JSON-RPC version: %s' % version)
+        except Exception as e:
+            return self._jsonrpc_response(id_=id_, error={
+                'code':    0 - 32600,
+                'message': 'Invalid Request',
+                'data':    '%s: %s' % (e.__class__.__name__, str(e)),
+            })
+
+        try:
             if not method.startswith(self.NAMESPACE + '.'):
-                raise ValueError('invalid method: %s' % method)
-
-            if not isinstance(params, list):
-                raise ValueError('invalid params: %s' % params)
-
+                raise ValueError('Invalid method namespace: %s' % method)
             handler = 'handle_' + method[len(self.NAMESPACE) + 1:]
-            result = getattr(self, handler)(params)
-            self.finish({'result': result, 'error': None, 'id': id_})
-
+            handler = getattr(self, handler)
+        except Exception as e:
+            return self._jsonrpc_response(id_=id_, error={
+                'code':    0 - 32601,
+                'message': 'Method not found',
+                'data':    '%s: %s' % (e.__class__.__name__, str(e)),
+            })
+
+        try:
+            return self._jsonrpc_response(id_=id_, result=handler(params))
         except Exception as e:
             traceback.print_exc()
-            msg = '%s: %s' % (e.__class__.__name__, str(e))
-            self.finish({'result': None, 'error': {'message': msg}, 'id': id_})
+            return self._jsonrpc_response(id_=id_, error={
+                'code':    0 - 32602,
+                'message': 'Invalid params',
+                'data':     '%s: %s' % (e.__class__.__name__, str(e)),
+            })
 
     def handle_listFdb(self, params):
@@ -565 +587 @@
 
     def handle_listPort(self, params):
-        list_ = [self._portstat(p) for p in self._switch.portlist]
-        return {'entries': list_}
+        return {'entries': [self._portstat(p) for p in self._switch.portlist]}
 
     def handle_addPort(self, params):
-        list_ = []
-        for p in params:
-            type_ = p['type']
-            target = p['target']
-            options = getattr(self, '_optparse_' + type_)(p.get('options', {}))
-            klass = self.IFTYPES[type_]
-            interface = klass(self._ioloop, self._switch, target, **options)
-            portnum = interface.open()
-            list_.append(self._portstat(self._switch.get_port(portnum)))
-        return {'entries': list_}
+        type_ = params['type']
+        target = params['target']
+        opts = getattr(self, '_optparse_' + type_)(params.get('options', {}))
+        cls = self.IFTYPES[type_]
+        interface = cls(self._ioloop, self._switch, target, **opts)
+        portnum = interface.open()
+        return {'entries': [self._portstat(self._switch.get_port(portnum))]}
 
     def handle_delPort(self, params):
-        list_ = []
-        for p in params:
-            port = self._switch.get_port(int(p['port']))
-            list_.append(self._portstat(port))
-            port.interface.close()
-        return {'entries': list_}
+        port = self._switch.get_port(int(params['port']))
+        port.interface.close()
+        return {'entries': [self._portstat(port)]}
 
     def handle_shutPort(self, params):
-        list_ = []
-        for p in params:
-            port = self._switch.get_port(int(p['port']))
-            port.shut = bool(p['shut'])
-            list_.append(self._portstat(port))
-        return {'entries': list_}
+        port = self._switch.get_port(int(params['port']))
+        port.shut = bool(params['shut'])
+        return {'entries': [self._portstat(port)]}
 
     def _optparse_tap(self, opt):
@@ -606 +618 @@
         cred = {'user': opt.get('user'), 'passwd': opt.get('passwd')}
         return {'ssl_': ssl_, 'cred': cred, 'debug': self._debug}
+
+    def _jsonrpc_response(self, id_=None, result=None, error=None):
+        res = {'jsonrpc': '2.0', 'id': id_}
+        if result:
+            res['result'] = result
+        if error:
+            res['error'] = error
+        self.finish(res)
 
     @staticmethod
@@ -647 +667 @@
         val = getattr(ns, path, '')
         if not val.startswith('/'):
-            raise ValueError('invalid %: %s' % (path, val))
+            raise ValueError('Invalid %: %s' % (path, val))
 
     def getsslopt(ns, key, cert):
@@ -655 +675 @@
             return {'keyfile': kval, 'certfile': cval}
         elif kval or cval:
-            raise ValueError('both %s and %s are required' % (key, cert))
+            raise ValueError('Both %s and %s are required' % (key, cert))
         return None
 
@@ -673 +693 @@
             return setattr(ns, port, 80)
         if not (0 <= val <= 65535):
-            raise ValueError('invalid %s: %s' % (port, val))
+            raise ValueError('Invalid %s: %s' % (port, val))
 
     def sethtpasswd(ns, htpasswd):
@@ -684 +704 @@
 
     if args.ageout <= 0:
-        raise ValueError('invalid ageout: %s' % args.ageout)
+        raise ValueError('Invalid ageout: %s' % args.ageout)
 
     setrealpath(args, 'htpasswd', 'sslkey', 'sslcert')
@@ -707 +727 @@
     if args.port == args.ctlport and args.host == args.ctlhost:
         if args.path == args.ctlpath:
-            raise ValueError('same path/ctlpath on same host')
+            raise ValueError('Same path/ctlpath on same host')
         if args.sslkey != args.ctlsslkey:
-            raise ValueError('different sslkey/ctlsslkey on same host')
+            raise ValueError('Different sslkey/ctlsslkey on same host')
         if args.sslcert != args.ctlsslcert:
-            raise ValueError('different sslcert/ctlsslcert on same host')
+            raise ValueError('Different sslcert/ctlsslcert on same host')
 
         app = Application([
@@ -754 +774 @@
 
 def start_ctl(args):
-    def request(args, method, params):
-        method = '.'.join([EtherWebSocketControlHandler.NAMESPACE, method])
-        data = json.dumps({'method': method, 'params': params})
+    def request(args, method, params=None, id_=0):
         req = urllib2.Request(args.ctlurl)
         req.add_header('Content-type', 'application/json')
@@ -764 +782 @@
             token = base64.b64encode('%s:%s' % (args.ctluser, args.ctlpasswd))
             req.add_header('Authorization', 'Basic %s' % token)
-        return json.loads(urllib2.urlopen(req, data).read())
+        method = '.'.join([EtherWebSocketControlHandler.NAMESPACE, method])
+        data = {'jsonrpc': '2.0', 'method': method, 'id': id_}
+        if params is not None:
+            data['params'] = params
+        return json.loads(urllib2.urlopen(req, json.dumps(data)).read())
 
     def maxlen(dict_, key, min_):
@@ -786 +808 @@
                   (r['port'], r['type'], shut, r['rx'], r['tx'], r['target']))
 
+    def print_error(error):
+        print('  %s (%s)' % (error['message'], error['code']))
+        print('    %s' % error['data'])
+
     def handle_ctl_addport(args):
-        params = [{
+        result = request(args, 'addPort', {
             'type':    args.type,
             'target':  args.target,
@@ -795 +821 @@
                 'user':     args.user,
                 'passwd':   args.passwd,
-            }
-        }]
-        result = request(args, 'addPort', params)
-        if result['error']:
-            print(result['error']['message'])
+            },
+        })
+        if 'error' in result:
+            print_error(result['error'])
         else:
             print_portlist(result['result']['entries'])
@@ -805 +830 @@
     def handle_ctl_shutport(args):
         if args.port <= 0:
-            raise ValueError('invalid port: %d' % args.port)
-        params = [{'port': args.port, 'shut': args.no}]
-        result = request(args, 'shutPort', params)
-        if result['error']:
-            print(result['error']['message'])
+            raise ValueError('Invalid port: %d' % args.port)
+        result = request(args, 'shutPort', {
+            'port': args.port,
+            'shut': args.no,
+        })
+        if 'error' in result:
+            print_error(result['error'])
         else:
             print_portlist(result['result']['entries'])
@@ -815 +842 @@
     def handle_ctl_delport(args):
         if args.port <= 0:
-            raise ValueError('invalid port: %d' % args.port)
-        params = [{'port': args.port}]
-        result = request(args, 'delPort', params)
-        if result['error']:
-            print(result['error']['message'])
+            raise ValueError('Invalid port: %d' % args.port)
+        result = request(args, 'delPort', {'port': args.port})
+        if 'error' in result:
+            print_error(result['error'])
         else:
             print_portlist(result['result']['entries'])
 
     def handle_ctl_listport(args):
-        result = request(args, 'listPort', [])
-        if result['error']:
-            print(result['error']['message'])
+        result = request(args, 'listPort')
+        if 'error' in result:
+            print_error(result['error'])
         else:
             print_portlist(result['result']['entries'])
 
     def handle_ctl_listfdb(args):
-        result = request(args, 'listFdb', [])
-        if result['error']:
-            print(result['error']['message'])
-            return
+        result = request(args, 'listFdb')
+        if 'error' in result:
+            return print_error(result['error'])
         result = result['result']['entries']
         pmax = maxlen(result, 'port', 4)