pythonthings
diff --git a/‎src/robotremoteserver.py‎
Lines changed: 49 additions & 28 deletions b/‎src/robotremoteserver.py‎
Lines changed: 49 additions & 28 deletions
@@ -1,4 +1,4 @@
-#  Copyright 2008-2012 Nokia Siemens Networks Oyj
+#  Copyright 2008-2013 Nokia Siemens Networks Oyj
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -12,32 +12,38 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+import re
 import sys
 import inspect
 import traceback
 from StringIO import StringIO
 from SimpleXMLRPCServer import SimpleXMLRPCServer
+from xmlrpclib import Binary
 try:
     import signal
 except ImportError:
     signal = None
+try:
+    from collections import Mapping
+except ImportError:
+    Mapping = dict
 
 
-__version__ = 'devel'
+BINARY = re.compile('[\x00-\x08\x0B\x0C\x0E-\x1F]')
 
 
 class RobotRemoteServer(SimpleXMLRPCServer):
     allow_reuse_address = True
-    _generic_exceptions = (AssertionError, RuntimeError, Exception)
-    _fatal_exceptions = (SystemExit, KeyboardInterrupt)
 
-    def __init__(self, library, host='localhost', port=8270, allow_stop=True):
+    def __init__(self, library, host='127.0.0.1', port=8270, allow_stop=True):
         SimpleXMLRPCServer.__init__(self, (host, int(port)), logRequests=False)
         self._library = library
         self._allow_stop = allow_stop
+        self._shutdown = False
         self._register_functions()
         self._register_signal_handlers()
-        self._log('Robot Framework remote server starting at %s:%s' % (host, port))
+        self._log('Robot Framework remote server starting at %s:%s'
+                  % (host, port))
         self.serve_forever()
 
     def _register_functions(self):
@@ -57,7 +63,6 @@ def stop_with_signal(signum, frame):
             signal.signal(signal.SIGINT, stop_with_signal)
 
     def serve_forever(self):
-        self._shutdown = False
         while not self._shutdown:
             self.handle_request()
 
@@ -80,35 +85,46 @@ def get_keyword_names(self):
                      and inspect.isroutine(getattr(self._library, attr))]
         return names + ['stop_remote_server']
 
-    def run_keyword(self, name, args):
-        result = {'error': '', 'traceback': '', 'return': ''}
+    def run_keyword(self, name, args, kwargs=None):
+        args, kwargs = self._handle_binary_args(args, kwargs or {})
+        result = {'status': 'PASS', 'return': '', 'output': '',
+                  'error': '', 'traceback': ''}
         self._intercept_stdout()
         try:
-            return_value = self._get_keyword(name)(*args)
+            return_value = self._get_keyword(name)(*args, **kwargs)
         except:
             result['status'] = 'FAIL'
             result['error'], result['traceback'] = self._get_error_details()
         else:
-            result['status'] = 'PASS'
             result['return'] = self._handle_return_value(return_value)
         result['output'] = self._restore_stdout()
         return result
 
+    def _handle_binary_args(self, args, kwargs):
+        args = [self._handle_binary_arg(a) for a in args]
+        kwargs = dict([(k, self._handle_binary_arg(v)) for k, v in kwargs.items()])
+        return args, kwargs
+
+    def _handle_binary_arg(self, arg):
+        return arg if not isinstance(arg, Binary) else str(arg)
+
     def get_keyword_arguments(self, name):
         kw = self._get_keyword(name)
         if not kw:
             return []
         return self._arguments_from_kw(kw)
 
     def _arguments_from_kw(self, kw):
-        args, varargs, _, defaults = inspect.getargspec(kw)
+        args, varargs, kwargs, defaults = inspect.getargspec(kw)
         if inspect.ismethod(kw):
             args = args[1:]  # drop 'self'
         if defaults:
             args, names = args[:-len(defaults)], args[-len(defaults):]
             args += ['%s=%s' % (n, d) for n, d in zip(names, defaults)]
         if varargs:
             args.append('*%s' % varargs)
+        if kwargs:
+            args.append('**%s' % kwargs)
         return args
 
     def get_keyword_documentation(self, name):
@@ -128,43 +144,48 @@ def _get_keyword(self, name):
 
     def _get_error_details(self):
         exc_type, exc_value, exc_tb = sys.exc_info()
-        if exc_type in self._fatal_exceptions:
+        if exc_type in (SystemExit, KeyboardInterrupt):
             self._restore_stdout()
             raise
         return (self._get_error_message(exc_type, exc_value),
                 self._get_error_traceback(exc_tb))
 
     def _get_error_message(self, exc_type, exc_value):
         name = exc_type.__name__
-        message = self._get_message_from_exception(exc_value)
+        message = str(exc_value)
         if not message:
             return name
-        if exc_type in self._generic_exceptions:
+        if name in ('AssertionError', 'RuntimeError', 'Exception'):
             return message
         return '%s: %s' % (name, message)
 
-    def _get_message_from_exception(self, value):
-        # UnicodeError occurs below 2.6 and if message contains non-ASCII bytes
-        try:
-            return unicode(value)
-        except UnicodeError:
-            return ' '.join([unicode(a, errors='replace') for a in value.args])
-
     def _get_error_traceback(self, exc_tb):
         # Latest entry originates from this class so it can be removed
         entries = traceback.extract_tb(exc_tb)[1:]
         trace = ''.join(traceback.format_list(entries))
         return 'Traceback (most recent call last):\n' + trace
 
     def _handle_return_value(self, ret):
-        if isinstance(ret, (basestring, int, long, float)):
+        if isinstance(ret, basestring):
+            return self._handle_binary_result(ret)
+        if isinstance(ret, (int, long, float)):
             return ret
-        if isinstance(ret, (tuple, list)):
-            return [self._handle_return_value(item) for item in ret]
-        if isinstance(ret, dict):
+        if isinstance(ret, Mapping):
             return dict([(self._str(key), self._handle_return_value(value))
                          for key, value in ret.items()])
-        return self._str(ret)
+        try:
+            return [self._handle_return_value(item) for item in ret]
+        except TypeError:
+            return self._str(ret)
+
+    def _handle_binary_result(self, result):
+        if not BINARY.search(result):
+            return result
+        try:
+            result = str(result)
+        except UnicodeError:
+            raise ValueError("Cannot represent %r as binary." % result)
+        return Binary(result)
 
     def _str(self, item):
         if item is None:
@@ -179,7 +200,7 @@ def _restore_stdout(self):
         output = sys.stdout.getvalue()
         sys.stdout.close()
         sys.stdout = sys.__stdout__
-        return output
+        return self._handle_binary_result(output)
 
     def _log(self, msg, level=None):
         if level: