Done remote <-> remote IMC

5 files changed, 368 insertions, 98 deletions

diff --git a/src/py/backend_server.py b/src/py/backend_server.py
index 7c07f50..35ebf4f 100644
--- a/src/py/backend_server.py
+++ b/src/py/backend_server.py
@@ -4,30 +4,73 @@ import socket
 import json
 import datetime
 import time
+import random
 from multiprocessing import Process
 
 import tornado.iostream
 import tornado.ioloop
+import tornado.tcpserver
 import tornado.httpserver
 import tornado.websocket
 
 import netio
 import imc.nonblock
-from imc.proxy import Proxy,Connection,imc_call,imc_register_call
+from imc.proxy import Proxy,Connection,imc_call,imc_call_async,imc_register_call
 
-class BackendWorker():
+class BackendWorker(tornado.tcpserver.TCPServer):
     def __init__(self,center_addr,ws_port):
-        self.ioloop = tornado.ioloop.IOLoop.current()
+        super().__init__()
+
+        self._ioloop = tornado.ioloop.IOLoop.current()
         self.center_addr = center_addr
         self.linkclass = 'backend'
-        self.linkid = None
+        self._linkid = None
+        self.sock_addr = None
         self.ws_port = ws_port
 
+        self._iden = None
+        self._pendconn_linkidmap = {}
         self._client_linkidmap = {}
 
     def start(self):
+        sock_port = random.randrange(4096,8192)
+        self.listen(sock_port)
+        self.sock_addr = ('127.0.0.1',sock_port)
         self._conn_center()
 
+    def handle_stream(self,stream,address):
+        def _recv_conn_info(data):
+            def __send_back(stat):
+                netio.send_pack(stream,bytes(json.dumps(stat),'utf-8'))
+
+            linkid = json.loads(data.decode('utf-8'))['linkid']
+
+            conn = Proxy.instance.get_conn(linkid)
+            if conn != None:
+                return
+
+            if linkid not in self._pendconn_linkidmap:
+                __send_back(True)
+
+                conn = netio.SocketConnection(linkid,stream)
+                Proxy.instance.add_conn(conn)
+
+            else:
+                if self._linkid > linkid:
+                    __send_back(True)
+
+                    conn = netio.SocketConnection(linkid,stream)
+                    Proxy.instance.add_conn(conn)
+
+                    pends = self._pendconn_linkidmap.pop(linkid)
+                    for callback in pends:
+                        callback(conn)
+
+                else:
+                    __send_back(False)
+
+        netio.recv_pack(stream,_recv_conn_info)
+
     def add_client(self,linkid,handler):
         self._client_linkidmap[linkid] = {}
 
@@ -35,52 +78,121 @@ class BackendWorker():
         conn.add_close_callback(lambda conn : self.del_client(conn.linkid))
         Proxy.instance.add_conn(conn)
 
+        imc_call_async(self._iden,'/center/' + self.center_conn.linkid + '/','add_client',{'worker_linkid':self._linkid,'client_linkid':linkid})
+
         return conn
 
     def del_client(self,linkid):
         del self._client_linkidmap[linkid]
 
+        imc_call_async(self._iden,'/center/' + self.center_conn.linkid + '/','del_client',linkid)
+
     def _conn_center(self):
         def __retry():
             print('retry connect center')
-            self.ioloop.add_timeout(datetime.timedelta(seconds = 5),self._conn_center)
+            self._ioloop.add_timeout(datetime.timedelta(seconds = 5),self._conn_center)
 
         def __send_worker_info():
             def ___recv_info_cb(data):
                 info = json.loads(data.decode('utf-8'))
 
-                self.linkid = info['linkid']
-                Proxy(self.linkid)
+                self._linkid = info['linkid']
+                self._iden = {'linkclass':'backend','linkid':self._linkid}
 
                 self.center_conn = netio.SocketConnection(info['center_linkid'],stream)
+                Proxy(self._linkid,self._connect_linkid,self.center_conn)
+
                 self.center_conn.add_close_callback(lambda conn : __retry())
                 Proxy.instance.add_conn(self.center_conn)
 
-                print('/backend/' + self.linkid)
+                print('/backend/' + self._linkid)
 
 
                 imc_register_call('','test_dst',self._test_dst)
-                self._test_call(None)
+                time.sleep(0.5)
 
+                x = int(self._linkid) - (int(self._linkid) - 2) % 4
+                self._test_call(None,str(x))
+                self._test_call(None,str(x + 1))
+
+            sock_ip,sock_port = self.sock_addr
             netio.send_pack(stream,bytes(json.dumps({
                 'linkclass':self.linkclass,
-                'ws_addr':('210.70.137.215',self.ws_port)
+                'sock_ip':sock_ip,
+                'sock_port':sock_port,
+                'ws_ip':'210.70.137.215',
+                'ws_port':self.ws_port
             }),'utf-8'))
             netio.recv_pack(stream,___recv_info_cb)
 
         stream = tornado.iostream.IOStream(socket.socket(socket.AF_INET,socket.SOCK_STREAM,0))
         stream.set_close_callback(__retry)
-        stream.connect(self.center_addr,lambda : __send_worker_info())
+        stream.connect(self.center_addr,__send_worker_info)
 
     @imc.nonblock.func
-    def _test_call(self,param):
-        print(time.perf_counter())
-        ret = (yield imc_call(self.linkid,'/backend/' + self.center_conn.linkid,'test_dst','Hello'))
-        print(time.perf_counter())
-        print(ret)
+    def _connect_linkid(self,linkid,callback):
+        def __handle_pend(conn):
+            pends = self._pendconn_linkidmap.pop(worker_linkid)
+            for callback in pends:
+                callback(conn)
+
+        def __send_info():
+            def ___recv_cb(data):
+                stat = json.loads(data.decode('utf-8'))
+
+                if stat == True:
+                    conn = netio.SocketConnection(worker_linkid,stream)
+                    Proxy.instance.add_conn(conn)
+                    __handle_pend(conn)
+
+                else:
+                    stream.set_close_callback(None)
+                    stream.close()
+
+            conn = Proxy.instance.get_conn(worker_linkid)
+            if conn != None:
+                __handle_pend(conn)
+                stream.set_close_callback(None)
+                stream.close()
+            
+            else:
+                netio.send_pack(stream,bytes(json.dumps({
+                    'linkid':self._linkid
+                }),'utf-8'))
+                netio.recv_pack(stream,___recv_cb)
+
+        stat,ret = (yield imc_call({'linkclass':'backend','linkid':self._linkid},'/center/' + self.center_conn.linkid + '/','lookup_linkid',linkid))
+        
+        if stat == False or ret == None:
+            callback(None)
+
+        else:
+            worker_linkid = ret['worker_linkid']
+
+            conn = Proxy.instance.get_conn(worker_linkid)
+            if conn != None:
+                callback(conn)
+
+            elif worker_linkid in self._pendconn_linkidmap:
+                self._pendconn_linkidmap[worker_linkid].append(tornado.stack_context.wrap(callback))
+
+            else:
+                self._pendconn_linkidmap[worker_linkid] = [tornado.stack_context.wrap(callback)]
+
+                stream = tornado.iostream.IOStream(socket.socket(socket.AF_INET,socket.SOCK_STREAM,0))
+                stream.set_close_callback(lambda : __handle_pend(None))
+                stream.connect((ret['sock_ip'],ret['sock_port']),__send_info)
+        
+    @imc.nonblock.func
+    def _test_call(self,iden,param):
+        #print(time.perf_counter())
+        stat,ret = (yield imc_call({'linkclass':'backend','linkid':self._linkid},'/backend/' + param + '/','test_dst','Hello'))
+        #print(time.perf_counter())
+        if stat == True:
+            print(stat,ret)
 
     @imc.nonblock.func
-    def _test_dst(self,param):
+    def _test_dst(self,iden,param):
         return param + ' Too'
 
 class WebSocketConnHandler(tornado.websocket.WebSocketHandler):
@@ -94,10 +206,16 @@ class WebSocketConnHandler(tornado.websocket.WebSocketHandler):
             self.worker_conn.recv_msg(msg)
         
         else:
-            info = json.loads(msg)
-            self.worker_conn = backend_worker.add_client(info['client_linkid'],self)
+            try:
+                info = json.loads(msg)
+                self.worker_conn = backend_worker.add_client(info['client_linkid'],self)
+
+            except Exception:
+                self.close()
 
     def on_close(self):
+        global backend_worker
+
         if hasattr(self,'worker_conn'):
             self.worker_conn.close()
 
@@ -119,6 +237,8 @@ if __name__ == '__main__':
 
     worker_list.append(Process(target = start_backend_worker,args = (81, )))
     worker_list.append(Process(target = start_backend_worker,args = (82, )))
+    #worker_list.append(Process(target = start_backend_worker,args = (181, )))
+    #worker_list.append(Process(target = start_backend_worker,args = (182, )))
 
     for proc in worker_list:
         proc.start()
diff --git a/src/py/center_server.py b/src/py/center_server.py
index 54ffdc6..7871b00 100644
--- a/src/py/center_server.py
+++ b/src/py/center_server.py
@@ -14,13 +14,13 @@ import imc.nonblock
 from imc.proxy import Proxy,Connection,imc_call,imc_register_call
 
 class Worker:
-    def __init__(self,stream,linkclass,linkid,worker_ip):
+    def __init__(self,stream,linkclass,linkid,worker_info):
         global center_serv
 
         self.stream = stream
         self.linkclass = linkclass
         self.linkid = linkid
-        self.worker_ip = worker_ip
+        self.sock_addr = (worker_info['sock_ip'],worker_info['sock_port'])
 
         netio.send_pack(self.stream,bytes(json.dumps({
             'linkid':self.linkid,
@@ -35,11 +35,11 @@ class Worker:
         pass
 
 class BackendWorker(Worker):
-    def __init__(self,stream,linkid,worker_ip,worker_info):
+    def __init__(self,stream,linkid,worker_info):
         global center_serv
 
-        super().__init__(stream,'backend',linkid,worker_ip)
-        self.ws_addr = worker_info['ws_addr']
+        super().__init__(stream,'backend',linkid,worker_info)
+        self.ws_addr = (worker_info['ws_ip'],worker_info['ws_port'])
 
         center_serv.add_backend_worker(self)
 
@@ -56,8 +56,10 @@ class CenterServer(tornado.tcpserver.TCPServer):
     def __init__(self):
         super().__init__()
 
-        self.linkid_usemap = {}
-        self.backend_workerlist = []
+        self._linkid_usemap = {}
+        self._worker_linkidmap = {}
+        self._client_linkidmap = {}
+        self._backend_workerlist = []
 
         self.linkclass = 'center'
         self.linkid = self._create_linkid()
@@ -65,6 +67,10 @@ class CenterServer(tornado.tcpserver.TCPServer):
 
         print('/center/' + self.linkid)
 
+        imc_register_call('','lookup_linkid',self._lookup_linkid)
+        imc_register_call('','add_client',self._add_client)
+        imc_register_call('','del_client',self._del_client)
+
         imc_register_call('','test_dst',self._test_dst)
         imc_register_call('','test_dstb',self._test_dstb)
 
@@ -75,47 +81,89 @@ class CenterServer(tornado.tcpserver.TCPServer):
             linkclass = worker_info['linkclass']
             if linkclass == 'backend':
                 linkid = self._create_linkid()
-                worker_ip,worker_port = address 
-                worker = BackendWorker(stream,linkid,worker_ip,worker_info)
+                worker = BackendWorker(stream,linkid,worker_info)
 
         netio.recv_pack(stream,_recv_worker_info)
 
     def add_backend_worker(self,worker):
-        self.backend_workerlist.append(worker)
+        self._worker_linkidmap[worker.linkid] = worker
+        self._backend_workerlist.append(worker)
     
     def del_backend_worker(self,worker):
-        self.backend_workerlist.remove(worker)
+        self._worker_linkidmap.pop(worker.linkid,None)
+        self._backend_workerlist.remove(worker)
 
     def add_client(self):
-        size = len(self.backend_workerlist)
+        size = len(self._backend_workerlist)
         if size == 0:
             return None
 
         linkid = self._create_linkid()
-        worker = self.backend_workerlist[random.randrange(size)]
+        worker = self._backend_workerlist[random.randrange(size)]
         ws_ip,ws_port = worker.add_client(linkid)
 
         return (linkid,worker.linkid,ws_ip,ws_port)
 
     def _create_linkid(self):
         linkid = uuid.uuid4()
-        while linkid in self.linkid_usemap:
+        while linkid in self._linkid_usemap:
             linkid = uuid.uuid4()
         
         linkid = str(linkid)
-        self.linkid_usemap[linkid] = True
+        self._linkid_usemap[linkid] = True
 
-        linkid = str(len(self.linkid_usemap))
+        linkid = str(len(self._linkid_usemap))
         
         return linkid
 
     @imc.nonblock.func
-    def _test_dst(self,param):
-        stat,ret = (yield imc_call(self.linkid,'/center/' + self.linkid,'test_dstb','Hello X'))
-        return ret + ' Too'
+    def _lookup_linkid(self,iden,param):
+        linkid = param
+
+        try:
+            worker = self._worker_linkidmap[linkid]
+            if iden['linkclass'] != 'client':
+                sock_ip,sock_port = worker.sock_addr
+                return {'worker_linkid':worker.linkid,'sock_ip':sock_ip,'sock_port':sock_port}
+
+        except KeyError:
+            return None
+        
+    @imc.nonblock.func
+    def _add_client(self,iden,param):
+        worker_linkid = param['worker_linkid']
+        client_linkid = param['client_linkid']
+
+        self._client_linkidmap[client_linkid] = True
+        conn = Proxy.instance.get_conn(worker_linkid)
+        Proxy.instance.link_conn(client_linkid,conn)
+
+    @imc.nonblock.func
+    def _del_client(self,iden,param):
+        client_linkid = param
+
+        del self._client_linkidmap[client_linkid]
+        conn = Proxy.instance.get_conn(client_linkid)
+        Proxy.instance.unlink_conn(client_linkid)
+
+    @imc.nonblock.func
+    def _test_dst(self,iden,param):
+        #stat,ret = (yield imc_call(
+        #    {'linkclass':'center','linkid':self.linkid},
+        #    '/center/' + self.linkid + '/',
+        #    'test_dstb',
+        #    'Hello X'
+        #))
+
+        linkidlist = []
+        linkids = self._client_linkidmap.keys()
+        for linkid in linkids:
+            linkidlist.append(linkid)
+
+        return linkidlist
 
     @imc.nonblock.func
-    def _test_dstb(self,param):
+    def _test_dstb(self,iden,param):
         return param + ' World'
 
 class WebConnHandler(tornado.web.RequestHandler):
diff --git a/src/py/imc/proxy.py b/src/py/imc/proxy.py
index 0887b7d..87f57f0 100755
--- a/src/py/imc/proxy.py
+++ b/src/py/imc/proxy.py
@@ -9,6 +9,7 @@ from imc import nonblock
 class Connection:
     def __init__(self,linkid):
         self.linkid = linkid
+        self.link_linkidmap = {}
         self._close_callback = []
 
     def send_msg(self,data):
@@ -25,9 +26,11 @@ class Connection:
             callback(self)
 
 class Proxy:
-    def __init__(self,linkid):
+    def __init__(self,linkid,connect_linkid = None,center_conn = None):
         self._ioloop = tornado.ioloop.IOLoop.instance()
         self._linkid = linkid
+        self._connect_linkid = connect_linkid
+        self._center_conn = center_conn
 
         self._conn_linkidmap = {}
         self._caller_retidmap = {self._linkid:{}}
@@ -36,7 +39,6 @@ class Proxy:
 
         self.MSGTYPE_CALL = 'call'
         self.MSGTYPE_RET = 'ret'
-        self.RETTYPE_GENID = 'genid'
 
         self._check_waitcaller_timer = tornado.ioloop.PeriodicCallback(self._check_waitcaller,1000)
         self._check_waitcaller_timer.start()
@@ -44,40 +46,73 @@ class Proxy:
         Proxy.instance = self 
 
     def add_conn(self,conn):
+        assert conn.linkid not in self._conn_linkidmap 
+
         self._conn_linkidmap[conn.linkid] = conn
         self._caller_retidmap[conn.linkid] = {}
 
         conn.add_close_callback(self._conn_close_cb)
         conn.start_recvloop(self._recvloop_dispatch)
 
+    def link_conn(self,linkid,conn):
+        assert conn.linkid in self._conn_linkidmap 
+
+        conn.link_linkidmap[linkid] = True
+        self._conn_linkidmap[linkid] = conn
+    
+    def unlink_conn(self,linkid):
+        assert linkid in self._conn_linkidmap 
+
+        conn = self._conn_linkidmap.pop(linkid)
+        del conn.link_linkidmap[linkid]
+
     def del_conn(self,conn):
         wait_map = self._caller_retidmap[conn.linkid]
         wait_retids = wait_map.keys()
         for retid in wait_retids:
             wait_map[retid]['fail_callback'](retid,'Eclose')
 
+        linkids = conn.link_linkidmap.keys()
+        link_del = []
+        for linkid in linkids:
+            link_del.append(linkid)
+
+        for linkid in link_del:
+            self.unlink_conn(linkid)
+
         del self._conn_linkidmap[conn.linkid]
         del self._caller_retidmap[conn.linkid]
 
     def get_conn(self,linkid):
-        if linkid not in self._conn_linkidmap:
+        try:
+            return self._conn_linkidmap[linkid]
+
+        except KeyError:
             return None
 
-        return self._conn_linkidmap[linkid]
+    def request_conn(self,linkid,callback,*args):
+        def _connect_cb(conn):
+            if conn != None and conn.linkid != linkid:
+                self.link_conn(linkid,conn)
 
-    def request_conn(self,linkid,callback):
-        self._route_call()
+            callback(conn,*args)
+
+        if linkid in self._conn_linkidmap:
+            callback(self._conn_linkidmap[linkid],*args)
+
+        else:
+            self._connect_linkid(linkid,_connect_cb)
 
     def register_call(self,path,func_name,func):
-        self._call_pathmap[''.join([path,'/',func_name])] = func
+        self._call_pathmap[''.join([path,func_name])] = func
 
     def call(self,caller_genid,timeout,iden,dst,func_name,param):
-        caller_retid = ''.join([self._linkid,'/',self.RETTYPE_GENID,'_',caller_genid])
+        caller_retid = ''.join([self._linkid,'/',caller_genid])
         self._route_call(caller_retid,timeout,iden,dst,func_name,param)
 
     def _route_call(self,caller_retid,timeout,iden,dst,func_name,param):
-        def __add_wait_caller(callee_linkid,caller_retid,timeout,fail_callback):
-            self._caller_retidmap[callee_linkid][caller_retid] = {
+        def __add_wait_caller(conn_linkid,caller_retid,timeout,fail_callback):
+            self._caller_retidmap[conn_linkid][caller_retid] = {
                 'timeout':timeout,
                 'fail_callback':tornado.stack_context.wrap(fail_callback)
             }
@@ -88,22 +123,39 @@ class Proxy:
                 'caller_retid':caller_retid,
             }
 
+        def __local_send_remote(conn,caller_linkid,caller_retid,timeout,iden,dst,func_name,param):
+            if conn != None:
+                __add_wait_caller(conn.linkid,caller_retid,timeout,__local_fail_cb)
+                self._send_msg_call(conn,caller_retid,timeout,iden,dst,func_name,param)
+            else:
+                __local_fail_cb(caller_retid,'Enoexist')
+
+        def __remote_send_remote(conn,caller_linkid,caller_retid,timeout,iden,dst,func_name,param):
+            if conn != None:
+                self._send_msg_call(conn,caller_retid,timeout,iden,dst,func_name,param)
+            else:
+                __remote_fail_cb(caller_retid,'Enoexist')
+
+        def __send_ret(conn,caller_linkid,caller_retid,result):
+            if conn != None:
+                self._send_msg_ret(conn,caller_linkid,caller_retid,result)
+        
         def __local_fail_cb(retid,err):
             self._ret_call(self._linkid,retid,(False,err))
 
         def __remote_fail_cb(retid,err):
             print('Opps')
 
-        dst_part = dst.split('/')[1:]
-        linkid = dst_part[1]
-        path = ''.join(dst_part[2:])
+        dst_part = dst.split('/',3)
+        linkid = dst_part[2]
+        path = dst_part[3]
 
-        caller_linkid = iden
+        caller_linkid = iden['linkid']
         assert caller_retid.split('/',1)[0] == caller_linkid
 
         if linkid == self._linkid:
             try:
-                stat,data = self._call_pathmap[''.join([path,'/',func_name])](param)
+                stat,data = self._call_pathmap[''.join([path,func_name])](iden,param)
 
             except KeyError:
                 raise
@@ -112,58 +164,46 @@ class Proxy:
                 if caller_linkid == self._linkid:
                     self._ioloop.add_callback(self._ret_call,caller_linkid,caller_retid,(True,data))
                 else:
-                    caller_conn = self.get_conn(caller_linkid)
-                    if caller_conn == None:
-                        pass
-
-                    self._send_msg_ret(caller_conn,caller_linkid,caller_retid,(True,data))
+                    self.request_conn(caller_linkid,__send_ret,caller_linkid,caller_retid,(True,data))
 
             else:
                 if caller_linkid == self._linkid:
-                    __add_wait_caller(linkid,caller_retid,timeout,__local_fail_cb)
+                    __add_wait_caller(self._linkid,caller_retid,timeout,__local_fail_cb)
                 else:
-                    __add_wait_caller(linkid,caller_retid,timeout,__remote_fail_cb)
+                    __add_wait_caller(self._linkid,caller_retid,timeout,__remote_fail_cb)
 
-                __add_wait_retcall(''.join([self._linkid,'/',self.RETTYPE_GENID,'_',data]),caller_linkid,caller_retid) 
+                __add_wait_retcall(''.join([self._linkid,'/',data]),caller_linkid,caller_retid) 
 
         else:
-            callee_conn = self.get_conn(linkid)
-            if callee_conn == None:
-                pass
-
             if caller_linkid == self._linkid:
-                __add_wait_caller(callee_conn.linkid,caller_retid,timeout,__local_fail_cb)
-                self._send_msg_call(callee_conn,caller_retid,timeout,iden,dst,func_name,param)
+                self.request_conn(linkid,__local_send_remote,caller_linkid,caller_retid,timeout,iden,dst,func_name,param)
 
             else:
-                pass
+                self.request_conn(linkid,__remote_send_remote,caller_linkid,caller_retid,timeout,iden,dst,func_name,param)
+
+    def _ret_call(self,caller_linkid,caller_retid,result):
+        def __send_ret(conn,caller_linkid,caller_retid,result):
+            if conn != None:
+                self._send_msg_ret(conn,caller_linkid,caller_retid,result)
 
-    def _ret_call(self,caller_linkid,caller_retid,retvalue):
         if caller_linkid == self._linkid:
-            part = caller_retid.split('/',1)[1].split('_')
-            ret_type = part[0]
-            retid = part[1]
+            retid = caller_retid.split('/',1)[1]
 
-            if ret_type == self.RETTYPE_GENID:
-                stat,data = nonblock.retcall(retid,retvalue)
-                if stat == True:
-                    try:
-                        ret = self._retcall_retidmap.pop(caller_retid)
-                        linkid = ret['caller_linkid']
-                        retid = ret['caller_retid']
+            stat,data = nonblock.retcall(retid,result)
+            if stat == True:
+                try:
+                    ret = self._retcall_retidmap.pop(caller_retid)
+                    linkid = ret['caller_linkid']
+                    retid = ret['caller_retid']
 
-                        del self._caller_retidmap[caller_linkid][retid]
-                        self._ret_call(linkid,retid,data)
+                    del self._caller_retidmap[caller_linkid][retid]
+                    self._ret_call(linkid,retid,data)
 
-                    except KeyError:
-                        pass
+                except KeyError:
+                    pass
 
         else:
-            caller_conn = self.get_conn(caller_linkid)
-            if caller_conn == None:
-                pass
-
-            self._send_msg_ret(caller_conn,caller_linkid,caller_retid,retvalue)
+            self.request_conn(caller_linkid,__send_ret,caller_linkid,caller_retid,result)
 
     def _recvloop_dispatch(self,conn,data):
         msg = json.loads(data.decode('utf-8'))
@@ -215,33 +255,45 @@ class Proxy:
 
         self._route_call(caller_retid,timeout,iden,dst,func_name,param)
 
-    def _send_msg_ret(self,conn,caller_linkid,caller_retid,retvalue):
+    def _send_msg_ret(self,conn,caller_linkid,caller_retid,result):
+        stat,data = result
         msg = {
             'type':self.MSGTYPE_RET,
             'caller_linkid':caller_linkid,
             'caller_retid':caller_retid,
-            'retvalue':retvalue
+            'result':{'stat':stat,'data':data}
         }
         conn.send_msg(bytes(json.dumps(msg),'utf-8'))
 
     def _recv_msg_ret(self,conn,msg):
         caller_linkid = msg['caller_linkid']
         caller_retid = msg['caller_retid']
-        retvalue = msg['retvalue']
+        data = msg['result']
+        result = (data['stat'],data['data'])
 
         if caller_linkid == self._linkid:
             try:
                 del self._caller_retidmap[conn.linkid][caller_retid]
-                self._ret_call(caller_linkid,caller_retid,retvalue)
+                self._ret_call(caller_linkid,caller_retid,result)
 
             except KeyError:
                 pass
+
         else:
-            pass
+            self._ret_call(caller_linkid,caller_retid,result)
 
 @nonblock.call
 def imc_call(iden,dst,func_name,param,_genid):
     Proxy.instance.call(_genid,5000,iden,dst,func_name,param)
 
+def imc_call_async(iden,dst,func_name,param,callback = None):
+    @nonblock.func
+    def func():
+        result = (yield imc_call(iden,dst,func_name,param))
+        if callback != None:
+            callback(result)
+
+    func()
+
 def imc_register_call(path,func_name,func):
     Proxy.instance.register_call(path,func_name,func)
diff --git a/src/test/imc.js b/src/test/imc.js
new file mode 100644
index 0000000..fb7def8
--- /dev/null
+++ b/src/test/imc.js
@@ -0,0 +1,38 @@
+var imc = new function(){
+    this.proxy = function(linkid){
+        var that = this;
+        var conn_linkidmap = {};
+        var caller_retidmap = {};
+        var call_pathmap = {};
+
+        var route_call = function(caller_retid,iden,dst,func_name,param){
+            var i;
+
+            part = dst.split('/');
+            dst_linkid = part[1];
+            dst_path = part.slice(2).join('/');
+
+            caller_linkid = iden.linkid
+            if(caller_retid.split('/')[0] != caller_linkid){
+                return false;
+            }
+
+            if(caller_linkid == linkid){
+
+            }else{
+
+            }
+        };
+
+        that.call = function(iden,dst,func_name,param,callback){
+            route_call(1234,iden,dst,func_name,param);
+        };
+
+        imc.proxy.instance = that;
+    };
+
+};
+
+var imc_call = function(iden,dst,func_name,param,callback){
+    imc.proxy.instance.call(iden,dst,func_name,param,callback) 
+};
diff --git a/src/test/wstest.html b/src/test/wstest.html
index ba6622d..23b0598 100644
--- a/src/test/wstest.html
+++ b/src/test/wstest.html
@@ -8,6 +8,7 @@
 
 <script src="/jquery-2.0.0.min.js"></script>
 <script src="/bootstrap/js/bootstrap.min.js"></script>
+<script src="/imc.js"></script>
 <script src="/wstest.js"></script>
 
 <script type="text/javascript">
@@ -20,12 +21,23 @@ $(document).ready(function(){
 </head>
 <body>
 
-<div class="container">
+<div class="container" style="padding:32px 0px 32px 0px;">
     <div class="row">
-        <div class="span2">
-            adasd
+        <div class="span2 slide">
+            <table class="table">
+                <thead>
+                    <tr>
+                        <th>Name</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        <td>sfsdf</td>
+                    </tr>
+                </tbody>
+            </table>
         </div>
-        <div class="span10">
+        <div class="span10 main">
             sdfsdf
         </div>
     </div>