public SessionRefreshThread(Ice.Logger logger, int timeout, SessionPrx session) { _logger = logger; _session = session; _timeout = timeout; _terminated = false; }
public void add(SessionPrx proxy, SessionI session) { lock(this) { _sessions.Add(new SessionProxyPair(proxy, session)); } }
public void add(SessionPrx proxy, SessionI session) { #if COMPACT _m.Lock(); try { _sessions.Add(new SessionProxyPair(proxy, session)); } finally { _m.Unlock(); } #else lock(this) { _sessions.Add(new SessionProxyPair(proxy, session)); } #endif }
connected(RouterPrx router, SessionPrx session) { // // Remote invocation should be done without acquiring a mutex lock. // Debug.Assert(router != null); Ice.Connection conn = router.ice_getCachedConnection(); string category = router.getCategoryForClient(); int acmTimeout = 0; try { acmTimeout = router.getACMTimeout(); } catch(Ice.OperationNotExistException) { } if(acmTimeout <= 0) { acmTimeout = (int)router.getSessionTimeout(); } // // We create the callback object adapter here because createObjectAdapter internally // makes synchronous RPCs to the router. We can't create the OA on-demand when the // client calls objectAdapter() or addWithUUID() because they can be called from the // GUI thread. // if(_useCallbacks) { Debug.Assert(_adapter == null); _adapter = _communicator.createObjectAdapterWithRouter("", router); _adapter.activate(); } lock(this) { _router = router; if(_destroy) { // // Run destroyInternal in a thread because it makes remote invocations. // Thread t = new Thread(new ThreadStart(destroyInternal)); t.Start(); return; } // // Cache the category. // _category = category; // // Assign the session after _destroy is checked. // _session = session; _connected = true; if(acmTimeout > 0) { Ice.Connection connection = _router.ice_getCachedConnection(); Debug.Assert(connection != null); connection.setACM(acmTimeout, Ice.Util.None, Ice.ACMHeartbeat.HeartbeatAlways); connection.setCloseCallback(_ => destroy()); } } dispatchCallback(() => { try { _callback.connected(this); } catch(Glacier2.SessionNotExistException) { destroy(); } }, conn); }
connected(RouterPrx router, SessionPrx session) { string category = router.getCategoryForClient(); long sessionTimeout = router.getSessionTimeout(); int acmTimeout = 0; try { acmTimeout = router.getACMTimeout(); } catch(Ice.OperationNotExistException) { } Ice.Connection conn = router.ice_getCachedConnection(); lock(this) { _router = router; if(_destroy) { // // Run the destroyInternal in a thread. This is because it // destroyInternal makes remote invocations. // Thread t = new Thread(new ThreadStart(destroyInternal)); t.Start(); return; } // // Cache the category. // _category = category; // // Assign the session after _destroy is checked. // _session = session; _connected = true; if(acmTimeout > 0) { Ice.Connection connection = _router.ice_getCachedConnection(); Debug.Assert(connection != null); connection.setACM(acmTimeout, Ice.Util.None, Ice.ACMHeartbeat.HeartbeatAlways); connection.setCallback(new ConnectionCallbackI(this)); } else if(sessionTimeout > 0) { IceInternal.Timer timer = IceInternal.Util.getInstance(communicator()).timer(); timer.scheduleRepeated(new SessionRefreshTask(this, _router), (sessionTimeout * 1000)/2); } } dispatchCallback(() => { try { _callback.connected(this); } catch(Glacier2.SessionNotExistException) { destroy(); } }, conn); }
public SessionProxyPair(SessionPrx p, SessionI s) { proxy = p; session = s; }
connected(RouterPrx router, SessionPrx session) { string category = router.getCategoryForClient(); long timeout = router.getSessionTimeout(); Ice.Connection conn = router.ice_getCachedConnection(); lock(this) { _router = router; if(_destroy) { // // Run the destroyInternal in a thread. This is because it // destroyInternal makes remote invocations. // Thread t = new Thread(new ThreadStart(destroyInternal)); t.Start(); return; } // // Cache the category. // _category = category; // // Assign the session after _destroy is checked. // _session = session; _connected = true; Debug.Assert(_sessionRefresh == null); if(timeout > 0) { _sessionRefresh = new SessionRefreshThread(this, _router, (int)(timeout * 1000)/2); _refreshThread = new Thread(new ThreadStart(_sessionRefresh.run)); _refreshThread.Start(); } } dispatchCallback(delegate() { try { _callback.connected(this); } catch(Glacier2.SessionNotExistException) { destroy(); } }, conn); }
public static void write(Ice.OutputStream outS__, SessionPrx v__) { outS__.writeProxy(v__); }
public static void write__(IceInternal.BasicStream os__, SessionPrx v__) { os__.writeProxy(v__); }
connectImpl(ConnectStrategy factory) { Debug.Assert(!_destroy); try { _communicator = Ice.Util.initialize(_initData); } catch (Ice.LocalException ex) { _destroy = true; new Thread( new ThreadStart(() => { dispatchCallback(() => { _callback.connectFailed(this, ex); }, null); })).Start(); return; } Ice.RouterFinderPrx finder = Ice.RouterFinderPrxHelper.uncheckedCast(_communicator.stringToProxy(_finderStr)); new Thread(new ThreadStart(() => { if (_communicator.getDefaultRouter() == null) { try { _communicator.setDefaultRouter(finder.getRouter()); } catch (Ice.CommunicatorDestroyedException ex) { dispatchCallback(() => { _callback.connectFailed(this, ex); }, null); return; } catch (Exception) { // // In case of error getting router identity from RouterFinder use default identity. // Ice.Identity ident = new Ice.Identity("router", "Glacier2"); _communicator.setDefaultRouter(Ice.RouterPrxHelper.uncheckedCast(finder.ice_identity(ident))); } } try { dispatchCallbackAndWait(() => { _callback.createdCommunicator(this); }); RouterPrx routerPrx = RouterPrxHelper.uncheckedCast(_communicator.getDefaultRouter()); SessionPrx session = factory(routerPrx); connected(routerPrx, session); } catch (Exception ex) { _communicator.destroy(); dispatchCallback(() => { _callback.connectFailed(this, ex); }, null); } })).Start(); }
connected(RouterPrx router, SessionPrx session) { // // Remote invocation should be done without acquiring a mutex lock. // Debug.Assert(router != null); Ice.Connection conn = router.ice_getCachedConnection(); string category = router.getCategoryForClient(); int acmTimeout = 0; try { acmTimeout = router.getACMTimeout(); } catch (Ice.OperationNotExistException) { } if (acmTimeout <= 0) { acmTimeout = (int)router.getSessionTimeout(); } // // We create the callback object adapter here because createObjectAdapter internally // makes synchronous RPCs to the router. We can't create the OA on-demand when the // client calls objectAdapter() or addWithUUID() because they can be called from the // GUI thread. // if (_useCallbacks) { Debug.Assert(_adapter == null); _adapter = _communicator.createObjectAdapterWithRouter("", router); _adapter.activate(); } lock (this) { _router = router; if (_destroy) { // // Run destroyInternal in a thread because it makes remote invocations. // Thread t = new Thread(new ThreadStart(destroyInternal)); t.Start(); return; } // // Cache the category. // _category = category; // // Assign the session after _destroy is checked. // _session = session; _connected = true; if (acmTimeout > 0) { Ice.Connection connection = _router.ice_getCachedConnection(); Debug.Assert(connection != null); connection.setACM(acmTimeout, Ice.Util.None, Ice.ACMHeartbeat.HeartbeatAlways); connection.setCloseCallback(_ => destroy()); } } dispatchCallback(() => { try { _callback.connected(this); } catch (SessionNotExistException) { destroy(); } }, conn); }
public override int run(string[] args) { if (args.Length > 0) { Console.Error.WriteLine(appName() + ": too many arguments"); return(1); } string name; do { Console.Out.Write("Please enter your name ==> "); Console.Out.Flush(); name = Console.In.ReadLine(); if (name == null) { return(1); } name = name.Trim(); }while(name.Length == 0); Ice.ObjectPrx basePrx = communicator().propertyToProxy("SessionFactory.Proxy"); SessionFactoryPrx factory = SessionFactoryPrxHelper.checkedCast(basePrx); if (factory == null) { Console.Error.WriteLine("invalid proxy"); return(1); } SessionPrx session = factory.create(name); SessionRefreshThread refresh = new SessionRefreshThread(communicator().getLogger(), 5000, session); Thread refreshThread = new Thread(new ThreadStart(refresh.run)); refreshThread.Start(); List <HelloPrx> hellos = new List <HelloPrx>(); menu(); try { bool destroy = true; bool shutdown = false; while (true) { Console.Out.Write("==> "); Console.Out.Flush(); string line = Console.In.ReadLine(); if (line == null) { break; } if (line.Length > 0 && Char.IsDigit(line[0])) { int index = Int32.Parse(line); if (index < hellos.Count) { HelloPrx hello = hellos[index]; hello.sayHello(); } else { Console.Out.WriteLine("Index is too high. " + hellos.Count + " hello objects exist so far.\n" + "Use `c' to create a new hello object."); } } else if (line.Equals("c")) { hellos.Add(session.createHello()); Console.Out.WriteLine("Created hello object " + (hellos.Count - 1)); } else if (line.Equals("s")) { destroy = false; shutdown = true; break; } else if (line.Equals("x")) { break; } else if (line.Equals("t")) { destroy = false; break; } else if (line.Equals("?")) { menu(); } else { Console.Out.WriteLine("Unknown command `" + line + "'."); menu(); } } // // The refresher thread must be terminated before destroy is // called, otherwise it might get ObjectNotExistException. refresh // is set to 0 so that if session.destroy() raises an exception // the thread will not be re-terminated and re-joined. // refresh.terminate(); refreshThread.Join(); refresh = null; if (destroy) { session.destroy(); } if (shutdown) { factory.shutdown(); } } catch (System.Exception) { // // The refresher thread must be terminated in the event of a // failure. // if (refresh != null) { refresh.terminate(); refreshThread.Join(); refresh = null; } throw; } return(0); }