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 SessionProxyPair(SessionPrx p, SessionI s)
{
proxy = p;
session = s;
}
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);
}
