Added virtual env

Author: jcsombria

.gitignore

@@ -0,0 +1,3 @@
+*.pyc
+.project
+.pydevproject

__init__.py

@@ -0,0 +1,92 @@
+'''
+Created on 20/10/2015
+
+@author: jcsombria
+'''
+import os.path
+
+from jsonrpc.JsonRpcServer import JsonRpcServer
+from app.MatlabConnector import CommandBuilder, MatlabConnector
+from app.SimulinkConnector import SimulinkConnector
+
+import matlab.engine
+
+class RIPMatlab(JsonRpcServer):
+  '''
+  classdocs
+  '''
+
+  def __init__(self):
+    '''
+    Constructor
+    '''
+    super().__init__()
+    self.on('connect', 0, self._connect)
+    self.on('disconnect', 0, self._disconnect)
+    self.on('get', 1, self._get)
+    self.on('set', 2, self._set)
+    self.on('eval', 1, self._eval)
+    self.on('open', 1, self._open)
+    self.on('step', 1, self._step)
+    self.commandBuilder = CommandBuilder()
+    self.matlab = MatlabConnector()
+    self.simulink = SimulinkConnector()
+  
+  def _connect(self):
+    self._matlab = matlab.engine.start_matlab('-desktop')
+    self.simulink.set
+    return True
+
+
+  def _disconnect(self):
+    self._matlab.quit()
+
+
+  def _set(self, variables, values):
+    self.matlab.set(variables, values)
+
+
+  def _get(self, variables):
+    return self.matlab.get(variables)
+
+
+
+
+  def _eval(self, command):
+    try:
+      result = self._matlab.eval(command, nargout=0)
+    except:
+      pass
+    return result
+
+
+  def _open(self, path):
+    try:
+      #open
+      dirname = os.path.dirname(path)
+      cd = self.commandBuilder.cd(dirname)
+      model = os.path.basename(path)
+      load_system = self.commandBuilder.load_system(model)
+      command = cd + load_system
+      result = self._matlab.eval(command, nargout=0)
+      #addEjsSubsystem
+      _load_model(model)
+      
+    except:
+      return None
+    return result
+
+  def _load_model(self, model):
+    command = self.commandBuilder.addEjsSubblock(model) + \
+      self.commandBuilder.addPauseBlock(model) + \
+      self.commandBuilder.set_param(model, "StartTime", "0") + \
+      self.commandBuilder.set_param(model, "StopTime", "inf")
+    self._matlab.eval(command)
+    
+    
+  def _step(self, command):
+    try:
+      result = self._matlab.eval(command, nargout=0)
+    except:
+      return None
+    return result

app/RIPMatlab.py

@@ -0,0 +1,81 @@
+# JSON-RPC Builder
+# author: Jesús Chacón <jcsombria@gmail.com>
+#
+# Copyright (C) 2013 Jesús Chacón
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+import ujson
+
+class JsonRpcBuilder(object):
+  """A helper class to build JSON-RPC v2.0 objects."""
+  def request(self, method, params=None, request_id=None):
+    request = {
+      'jsonrpc': '2.0',
+      'method': method,
+    }
+    if(params != None):
+      request['params'] = params
+    if(request_id != None):
+      request['id'] = request_id
+    return request
+
+  def response(self, result, request_id=None):
+    ''' Build a jsonrpc response object
+    '''
+    if(request_id != None):
+      return {
+        'jsonrpc': '2.0',
+        'result': result,
+        'id': request_id
+      }
+    else:
+      return {
+        'jsonrpc': '2.0',
+        'result': result,
+      }
+
+  def error_response(self, error, request_id=None):
+    ''' Build a jsonrpc error response object
+    '''
+    return {
+      'jsonrpc': '2.0',
+      'error': error,
+      'id': request_id
+    }
+
+  def error(self, code, message, data=None):
+    ''' Build a jsonrpc error object
+    '''
+    if(data != None):
+      return {
+        'code': code, 
+        'message': message, 
+        'data': data
+      }
+    else:
+      return {
+        'code': code, 
+        'message': message, 
+      }
+
+  def parseResponse(self, message):
+    response = None
+    try:
+      response = ujson.loads(message);
+    except ValueError:
+      print(error);
+    return response.get('result') if response != None else None
+    
+#def _add_if_defined():
+  

app/__init__.py

@@ -0,0 +1,168 @@
+# JSON-RPC Server
+# author: Jesús Chacón <jcsombria@gmail.com>
+#
+# Copyright (C) 2013 Jesús Chacón
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+import ujson
+from jsonrpc.JsonRpcBuilder import JsonRpcBuilder
+
+class JsonRpcServer(object):
+  """Base class for defining a JSON-RPC v2.0 server."""
+
+  PARSE_ERROR = {
+    'code': -32700,
+    'message': 'Invalid JSON was received by the server.',
+  }
+  INVALID_REQUEST = {
+    'code': -32600,
+    'message': 'The JSON sent is not a valid Request object.',
+  }
+  METHOD_NOT_FOUND = {
+    'code': -32601,
+    'message': 'Method not found. The method does not exist / is not available.',
+  }
+  INVALID_PARAMS = {
+    'code': -32602,
+    'message': 'Invalid params',
+  }
+  INTERNAL_ERROR = {
+    'code': -32603,
+    'message':'Internal JSON-RPC error.',
+  }
+  ERRORS = {
+    'PARSE_ERROR': PARSE_ERROR,
+    'INVALID_REQUEST': INVALID_REQUEST,
+    'METHOD_NOT_FOUND': METHOD_NOT_FOUND,
+    'INVALID_PARAMS': INVALID_PARAMS,
+    'INTERNAL_ERROR': INTERNAL_ERROR,
+    # -32000 to -32099 server error:
+    #   Reserved for implementation-defined server-errors.
+  }
+
+  def __init__(self):
+    self.builder = JsonRpcBuilder()
+    self.methods = {}
+
+  def parse(self, jsonrpc):
+    try:
+      methodCall = ujson.loads(jsonrpc)
+    except ValueError:
+      return self._response_with_error('PARSE_ERROR')
+    isBatchMode = isinstance(methodCall, list)
+    if(isBatchMode):
+      if(len(methodCall) == 0):
+        return self._response_with_error('INVALID_REQUEST')
+      result = []
+      for request in methodCall:
+        response = self.process(request)
+        if(response):
+          result.append(response)
+    else:
+      result = self.process(methodCall)
+    return result
+
+  def process(self, request):
+    """ Process a JSON-RPC request:
+      if the method exists in the server, invoke and return the result.
+      if not, an error is returned.
+    """
+    request_id = None
+    try:
+      (method, params, request_id) = self._check_fields(request)
+      server_method = self.methods.get(method)
+      if not server_method:
+        raise InvocationException('METHOD_NOT_FOUND')
+      result = self._invoke(method, params)
+      if request_id:
+        return self.builder.response(result, request_id)
+    except InvocationException as error:
+      return self._response_with_error(error.code, request_id)
+  
+  def _check_fields(self, request):
+    # jsonrpc must be 2.0, method must always exists. 'id' and 'params' may be omitted
+    try:
+      jsonrpc = request['jsonrpc']
+      method = request['method']
+      request_id = request.get('id')
+      params = request.get('params')
+    except:
+      raise InvocationException('INVALID_REQUEST')
+    
+    return (method, params, request_id)
+
+  def _invoke(self, method, params):
+    theMethod = self.methods.get(method)
+    if not theMethod:
+      raise InvocationException('METHOD_NOT_FOUND')
+    return theMethod.invoke(params)
+
+  def _response_with_error(self, error_name, request_id=None):
+    error_info = self.ERRORS[error_name]
+    error = self.builder.error(
+      error_info['code'],
+      error_info['message'],
+    )
+    return self.builder.error_response(error, request_id)
+
+  def on(self, method, expected, handler):
+    if not isinstance(expected, (int, set, list)):
+      return False
+    self.methods[method] = Method(handler, expected)
+
+
+class InvocationException(Exception):
+  """Exception raised for an error occurred during the invocation of a method
+  Attributes:
+    code -- an code describing the error
+  """
+  def __init__(self, code):
+    self.code = code
+
+
+class Method(object):
+  """Helper class to invoke a method and check the params
+  """
+  def __init__(self, handler, params):
+    self._handler = handler
+    self._params = params
+
+  def invoke(self, params):
+    if not self._expect_params():
+      return self._handler()
+    elif self._check_params_by_position(params):
+      return self._handler(*params)
+    elif self._check_params_by_name(params):
+      return self._handler(**params)
+    raise InvocationException('INVALID_PARAMS')
+
+  def _expect_params(self):
+    try:
+      return self._params != None and not self._params == 0
+    except:
+      return False
+    
+
+  def _check_params_by_position(self, params):
+    try:
+      expectedByPosition = len(self._params)
+    except:
+      expectedByPosition = self._params
+    return expectedByPosition == 0 or (isinstance(params, list) and len(params) == expectedByPosition)
+
+  def _check_params_by_name(self, params):
+    for name in params:
+      if name not in self._params:
+        return False
+    return True

jsonrpc/JsonRpcBuilder.py

@@ -0,0 +1,8 @@
+import unittest
+from test.testJsonRpcBuilder import JsonRpcBuilderTest
+from test.testJsonRpcServer import JsonRpcServerTest
+#from test.testRIPMatlab import RIPMatlabTest
+#from test.testCommandBuilder import SimulinkConnectorTest
+
+if __name__ == '__main__':
+  unittest.main()