public override object Register(string meshId, PeerNodeAddress nodeAddress, TimeSpan timeout)
{
if (this.opened)
{
long scopeId = -1L;
bool flag = false;
if (nodeAddress.IPAddresses.Count == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.ServiceModel.SR.GetString("MustRegisterMoreThanZeroAddresses")));
}
foreach (IPAddress address in nodeAddress.IPAddresses)
{
if (address.IsIPv6LinkLocal)
{
if (scopeId == -1L)
{
scopeId = address.ScopeId;
}
else if (scopeId != address.ScopeId)
{
flag = true;
break;
}
}
}
List <IPAddress> list = new List <IPAddress>();
foreach (IPAddress address2 in nodeAddress.IPAddresses)
{
if (!flag || (!address2.IsIPv6LinkLocal && !address2.IsIPv6SiteLocal))
{
list.Add(address2);
}
}
if (list.Count == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("AmbiguousConnectivitySpec")));
}
ReadOnlyCollection <IPAddress> ipAddresses = new ReadOnlyCollection <IPAddress>(list);
this.meshId = meshId;
this.nodeAddress = new PeerNodeAddress(nodeAddress.EndpointAddress, ipAddresses);
RegisterInfo registerInfo = new RegisterInfo(this.clientId, meshId, this.nodeAddress);
IPeerResolverClient proxy = this.GetProxy();
try
{
proxy.OperationTimeout = timeout;
RegisterResponseInfo info2 = proxy.Register(registerInfo);
this.registrationId = info2.RegistrationId;
this.timer.Set(info2.RegistrationLifetime);
this.defaultLifeTime = info2.RegistrationLifetime;
proxy.Close();
}
finally
{
proxy.Abort();
}
}
return(this.registrationId);
}
void RegistrationExpired(object state)
{
if (!opened)
{
return;
}
try
{
IPeerResolverClient proxy = GetProxy();
RefreshResponseInfo response;
try
{
int oldValue = Interlocked.Exchange(ref this.updateSuccessful, 1);
if (oldValue == 0)
{
SendUpdate(new UpdateInfo(this.registrationId, this.clientId, this.meshId, this.nodeAddress), ServiceDefaults.SendTimeout);
return;
}
RefreshInfo info = new RefreshInfo(this.meshId, this.registrationId);
response = proxy.Refresh(info);
if (response.Result == RefreshResult.RegistrationNotFound)
{
RegisterInfo registerInfo = new RegisterInfo(clientId, meshId, nodeAddress);
RegisterResponseInfo registerResponse = proxy.Register(registerInfo);
registrationId = registerResponse.RegistrationId;
this.defaultLifeTime = registerResponse.RegistrationLifetime;
}
else
{
Fx.Assert(response.Result == RefreshResult.Success, "Unrecognized value!!");
}
proxy.Close();
}
finally
{
proxy.Abort();
timer.Set(this.defaultLifeTime);
}
}
catch (CommunicationException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
}
public virtual RegisterResponseInfo Register(RegisterInfo registerInfo)
{
if (registerInfo == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("registerInfo", System.ServiceModel.SR.GetString("PeerNullRegistrationInfo"));
}
this.ThrowIfClosed("Register");
if (!registerInfo.HasBody() || string.IsNullOrEmpty(registerInfo.MeshId))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("registerInfo", System.ServiceModel.SR.GetString("PeerInvalidMessageBody", new object[] { registerInfo }));
}
return(this.Register(registerInfo.ClientId, registerInfo.MeshId, registerInfo.NodeAddress));
}
public virtual RegisterResponseInfo Register(RegisterInfo registerInfo)
{
if (registerInfo == null)
{
throw new ArgumentException("Register info cannot be null.");
}
if (!opened)
{
throw new InvalidOperationException("The service has never been opened or it was closed previously.");
}
return(client.Register(registerInfo));
}
public virtual RegisterResponseInfo Register(RegisterInfo registerInfo)
{
if (registerInfo == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("registerInfo", SR.GetString(SR.PeerNullRegistrationInfo));
}
ThrowIfClosed("Register");
if (!registerInfo.HasBody() || String.IsNullOrEmpty(registerInfo.MeshId))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("registerInfo", SR.GetString(SR.PeerInvalidMessageBody, registerInfo));
}
return(Register(registerInfo.ClientId, registerInfo.MeshId, registerInfo.NodeAddress));
}
private void RegistrationExpired(object state)
{
if (this.opened)
{
try
{
IPeerResolverClient proxy = this.GetProxy();
try
{
if (Interlocked.Exchange(ref this.updateSuccessful, 1) == 0)
{
this.SendUpdate(new UpdateInfo(this.registrationId, this.clientId, this.meshId, this.nodeAddress), ServiceDefaults.SendTimeout);
}
else
{
RefreshInfo refreshInfo = new RefreshInfo(this.meshId, this.registrationId);
if (proxy.Refresh(refreshInfo).Result == RefreshResult.RegistrationNotFound)
{
RegisterInfo registerInfo = new RegisterInfo(this.clientId, this.meshId, this.nodeAddress);
RegisterResponseInfo info4 = proxy.Register(registerInfo);
this.registrationId = info4.RegistrationId;
this.defaultLifeTime = info4.RegistrationLifetime;
}
proxy.Close();
}
}
finally
{
proxy.Abort();
this.timer.Set(this.defaultLifeTime);
}
}
catch (CommunicationException exception)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Information);
}
catch (Exception exception2)
{
if (Fx.IsFatal(exception2))
{
throw;
}
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Information);
}
}
}
public RegisterResponseInfo Register(RegisterInfo registerInfo)
{
var r = registerInfo;
log.WriteLine("REQUEST: Register (Mesh: {0}, Client: {1}, NodeAddress: endpoint {2})", r.MeshId, r.ClientId, r.NodeAddress.EndpointAddress);
Mesh mesh;
if (!mesh_map.TryGetValue(r.MeshId, out mesh))
{
mesh = new Mesh(r.MeshId);
mesh_map.Add(r.MeshId, mesh);
}
var node = RegisterNode(mesh, r.ClientId, r.NodeAddress);
return(new RegisterResponseInfo()
{
RegistrationId = node.RegistrationId
});
}
void RegistrationExpired(object state)
{
if (!opened)
return;
try
{
IPeerResolverClient proxy = GetProxy();
RefreshResponseInfo response;
try
{
int oldValue = Interlocked.Exchange(ref this.updateSuccessful, 1);
if (oldValue == 0)
{
SendUpdate(new UpdateInfo(this.registrationId, this.clientId, this.meshId, this.nodeAddress), ServiceDefaults.SendTimeout);
return;
}
RefreshInfo info = new RefreshInfo(this.meshId, this.registrationId);
response = proxy.Refresh(info);
if (response.Result == RefreshResult.RegistrationNotFound)
{
RegisterInfo registerInfo = new RegisterInfo(clientId, meshId, nodeAddress);
RegisterResponseInfo registerResponse = proxy.Register(registerInfo);
registrationId = registerResponse.RegistrationId;
this.defaultLifeTime = registerResponse.RegistrationLifetime;
}
else
{
Fx.Assert(response.Result == RefreshResult.Success, "Unrecognized value!!");
}
proxy.Close();
}
finally
{
proxy.Abort();
timer.Set(this.defaultLifeTime);
}
}
catch (CommunicationException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
catch (Exception e)
{
if (Fx.IsFatal(e)) throw;
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
}
// Register address for a node participating in a mesh identified by meshId with the resolver service
public override object Register(string meshId, PeerNodeAddress nodeAddress, TimeSpan timeout)
{
if (opened)
{
long scopeId = -1;
bool multipleScopes = false;
if (nodeAddress.IPAddresses.Count == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.MustRegisterMoreThanZeroAddresses)));
}
foreach (IPAddress address in nodeAddress.IPAddresses)
{
if (address.IsIPv6LinkLocal)
{
if (scopeId == -1)
{
scopeId = address.ScopeId;
}
else if (scopeId != address.ScopeId)
{
multipleScopes = true;
break;
}
}
}
List<IPAddress> addresslist = new List<IPAddress>();
foreach (IPAddress address in nodeAddress.IPAddresses)
{
if (!multipleScopes || (!address.IsIPv6LinkLocal && !address.IsIPv6SiteLocal))
addresslist.Add(address);
}
if (addresslist.Count == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(SR.GetString(SR.AmbiguousConnectivitySpec)));
}
ReadOnlyCollection<IPAddress> addresses = new ReadOnlyCollection<IPAddress>(addresslist);
this.meshId = meshId;
this.nodeAddress = new PeerNodeAddress(nodeAddress.EndpointAddress, addresses);
RegisterInfo info = new RegisterInfo(clientId, meshId, this.nodeAddress);
IPeerResolverClient proxy = GetProxy();
try
{
proxy.OperationTimeout = timeout;
RegisterResponseInfo response = proxy.Register(info);
this.registrationId = response.RegistrationId;
timer.Set(response.RegistrationLifetime);
this.defaultLifeTime = response.RegistrationLifetime;
proxy.Close();
}
finally
{
proxy.Abort();
}
}
return registrationId;
}
public virtual new RegisterResponseInfo Register(RegisterInfo registerInfo)
{
return(default(RegisterResponseInfo));
}
// Register address for a node participating in a mesh identified by meshId with the resolver service
public override object Register(string meshId, PeerNodeAddress nodeAddress, TimeSpan timeout)
{
if (opened)
{
long scopeId = -1;
bool multipleScopes = false;
if (nodeAddress.IPAddresses.Count == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.MustRegisterMoreThanZeroAddresses)));
}
foreach (IPAddress address in nodeAddress.IPAddresses)
{
if (address.IsIPv6LinkLocal)
{
if (scopeId == -1)
{
scopeId = address.ScopeId;
}
else if (scopeId != address.ScopeId)
{
multipleScopes = true;
break;
}
}
}
List <IPAddress> addresslist = new List <IPAddress>();
foreach (IPAddress address in nodeAddress.IPAddresses)
{
if (!multipleScopes || (!address.IsIPv6LinkLocal && !address.IsIPv6SiteLocal))
{
addresslist.Add(address);
}
}
if (addresslist.Count == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(SR.GetString(SR.AmbiguousConnectivitySpec)));
}
ReadOnlyCollection <IPAddress> addresses = new ReadOnlyCollection <IPAddress>(addresslist);
this.meshId = meshId;
this.nodeAddress = new PeerNodeAddress(nodeAddress.EndpointAddress, addresses);
RegisterInfo info = new RegisterInfo(clientId, meshId, this.nodeAddress);
IPeerResolverClient proxy = GetProxy();
try
{
proxy.OperationTimeout = timeout;
RegisterResponseInfo response = proxy.Register(info);
this.registrationId = response.RegistrationId;
timer.Set(response.RegistrationLifetime);
this.defaultLifeTime = response.RegistrationLifetime;
proxy.Close();
}
finally
{
proxy.Abort();
}
}
return(registrationId);
}
public virtual RegisterResponseInfo Register (RegisterInfo registerInfo)
{
if (registerInfo == null)
throw new ArgumentException ("Register info cannot be null.");
if (! opened)
throw new InvalidOperationException ("The service has never been opened or it was closed previously.");
return client.Register (registerInfo);
}
