public void addProxy(Ice.ObjectPrx proxy)
{
Debug.Assert(proxy != null);
lock(this)
{
if(_identities.Contains(proxy.ice_getIdentity()))
{
//
// Only add the proxy to the router if it's not already in our local map.
//
return;
}
}
addAndEvictProxies(proxy, _router.addProxies(new Ice.ObjectPrx[] { proxy }));
}
public bool addProxy(Ice.ObjectPrx proxy, AddProxyCallback callback)
{
Debug.Assert(proxy != null);
lock(this)
{
if(_identities.Contains(proxy.ice_getIdentity()))
{
//
// Only add the proxy to the router if it's not already in our local map.
//
return true;
}
}
_router.begin_addProxies(new Ice.ObjectPrx[] { proxy }).whenCompleted(
(Ice.ObjectPrx[] evictedProxies) =>
{
addAndEvictProxies(proxy, evictedProxies);
callback.addedProxy();
},
(Ice.Exception ex) =>
{
Debug.Assert(ex is Ice.LocalException);
callback.setException((Ice.LocalException)ex);
});
return false;
}
public void foundLocator(Ice.LocatorPrx locator)
{
lock(this)
{
if(locator == null ||
(_instanceName.Length > 0 && !locator.ice_getIdentity().category.Equals(_instanceName)))
{
return;
}
//
// If we already have a locator assigned, ensure the given locator
// has the same identity, otherwise ignore it.
//
if(_locator != null && !locator.ice_getIdentity().category.Equals(_locator.ice_getIdentity().category))
{
if(!_warned)
{
_warned = true; // Only warn once
locator.ice_getCommunicator().getLogger().warning(
"received Ice locator with different instance name:\n" +
"using = `" + _locator.ice_getIdentity().category + "'\n" +
"received = `" + locator.ice_getIdentity().category + "'\n" +
"This is typically the case if multiple Ice locators with different " +
"instance names are deployed and the property `IceLocatorDiscovery.InstanceName'" +
"is not set.");
}
return;
}
if(_pendingRetryCount > 0) // No need to retry, we found a locator
{
_timer.cancel(this);
_pendingRetryCount = 0;
}
if(_locator != null)
{
//
// We found another locator replica, append its endpoints to the
// current locator proxy endpoints.
//
List<Ice.Endpoint> newEndpoints = new List<Ice.Endpoint>(_locator.ice_getEndpoints());
foreach(Ice.Endpoint p in locator.ice_getEndpoints())
{
//
// Only add endpoints if not already in the locator proxy endpoints
//
bool found = false;
foreach(Ice.Endpoint q in newEndpoints)
{
if(p.Equals(q))
{
found = true;
break;
}
}
if(!found)
{
newEndpoints.Add(p);
}
}
_locator = (Ice.LocatorPrx) _locator.ice_endpoints(newEndpoints.ToArray());
}
else
{
_locator = locator;
if(_instanceName.Length == 0)
{
_instanceName = _locator.ice_getIdentity().category; // Stick to the first locator
}
}
//
// Send pending requests if any.
//
foreach(Request req in _pendingRequests)
{
req.invoke(_locator);
}
_pendingRequests.Clear();
}
}
private void addAndEvictProxies(Ice.ObjectPrx proxy, Ice.ObjectPrx[] evictedProxies)
{
lock(this)
{
//
// Check if the proxy hasn't already been evicted by a
// concurrent addProxies call. If it's the case, don't
// add it to our local map.
//
int index = _evictedIdentities.IndexOf(proxy.ice_getIdentity());
if(index >= 0)
{
_evictedIdentities.RemoveAt(index);
}
else
{
//
// If we successfully added the proxy to the router,
// we add it to our local map.
//
_identities.Add(proxy.ice_getIdentity());
}
//
// We also must remove whatever proxies the router evicted.
//
for(int i = 0; i < evictedProxies.Length; ++i)
{
if(!_identities.Remove(evictedProxies[i].ice_getIdentity()))
{
//
// It's possible for the proxy to not have been
// added yet in the local map if two threads
// concurrently call addProxies.
//
_evictedIdentities.Add(evictedProxies[i].ice_getIdentity());
}
}
}
}
public override void addObject(Ice.ObjectPrx obj, Ice.Current current)
{
_objects[obj.ice_getIdentity()] = obj;
}
private bool removeRemoteLogger(Ice.RemoteLoggerPrx remoteLogger)
{
lock(this)
{
return _remoteLoggerMap.Remove(remoteLogger.ice_getIdentity());
}
}
public bool addProxy(Ice.ObjectPrx proxy, AddProxyCallback callback)
{
Debug.Assert(proxy != null);
lock(this)
{
if(_identities.Contains(proxy.ice_getIdentity()))
{
//
// Only add the proxy to the router if it's not already in our local map.
//
return true;
}
}
_router.addProxiesAsync(new Ice.ObjectPrx[] { proxy }).ContinueWith(
(t) =>
{
try
{
addAndEvictProxies(proxy, t.Result);
callback.addedProxy();
}
catch(System.AggregateException ae)
{
Debug.Assert(ae.InnerException is Ice.LocalException);
callback.setException((Ice.LocalException)ae.InnerException);
}
});
return false;
}
static void testAttribute(IceMX.MetricsAdminPrx metrics,
Ice.PropertiesAdminPrx props,
UpdateCallbackI update,
string map,
string attr,
string value,
System.Action func)
{
Dictionary<string, string> dict = new Dictionary<string, string>();
dict.Add("IceMX.Metrics.View.Map." + map + ".GroupBy", attr);
if(props.ice_getIdentity().category.Equals("client"))
{
props.setProperties(getClientProps(props, dict, map));
update.waitForUpdate();
}
else
{
props.setProperties(getServerProps(props, dict, map));
props.setProperties(new Dictionary<string, string>());
}
func();
long timestamp;
Dictionary<string, IceMX.Metrics[]> view = metrics.getMetricsView("View", out timestamp);
if(!view.ContainsKey(map) || view[map].Length == 0)
{
if(value.Length > 0)
{
WriteLine("no map `" + map + "' for group by = `" + attr + "'");
test(false);
}
}
else if(!view[map][0].id.Equals(value))
{
WriteLine("invalid attribute value: " + attr + " = " + value + " got " + view[map][0].id);
test(false);
}
dict.Clear();
if(props.ice_getIdentity().category.Equals("client"))
{
props.setProperties(getClientProps(props, dict, map));
update.waitForUpdate();
}
else
{
props.setProperties(getServerProps(props, dict, map));
props.setProperties(new Dictionary<string, string>());
}
}
public bool addProxy(Ice.ObjectPrx proxy, AddProxyCallback callback)
{
Debug.Assert(proxy != null);
lock(this)
{
if(_identities.Contains(proxy.ice_getIdentity()))
{
//
// Only add the proxy to the router if it's not already in our local map.
//
return true;
}
}
_router.addProxies_async(new AddProxiesCallback(this, proxy, callback), new Ice.ObjectPrx[] { proxy });
return false;
}
