|
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.PeerResolvers
{
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Net;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.Threading;
class PeerDefaultCustomResolverClient : PeerResolver
{
EndpointAddress address;
Binding binding;
TimeSpan defaultLifeTime;
ClientCredentials credentials;
Guid clientId;
Guid registrationId;
IOThreadTimer timer;
bool opened = false;
string meshId;
PeerNodeAddress nodeAddress;
ChannelFactory<IPeerResolverClient> channelFactory;
PeerReferralPolicy referralPolicy;
string bindingName, bindingConfigurationName;
bool? shareReferrals;
int updateSuccessful = 1;
internal PeerDefaultCustomResolverClient()
{
this.address = null;
this.binding = null;
this.defaultLifeTime = TimeSpan.FromHours(1);
clientId = Guid.NewGuid();
timer = new IOThreadTimer(new Action<object>(RegistrationExpired), this, false);
}
public override bool CanShareReferrals
{
get
{
if (this.shareReferrals.HasValue)
return shareReferrals.Value;
if (this.referralPolicy == PeerReferralPolicy.Service && opened)
{
IPeerResolverClient proxy = GetProxy();
try
{
ServiceSettingsResponseInfo settings = proxy.GetServiceSettings();
shareReferrals = !settings.ControlMeshShape;
proxy.Close();
}
finally
{
proxy.Abort();
}
}
else
{
shareReferrals = (PeerReferralPolicy.Share == this.referralPolicy);
}
return shareReferrals.Value;
}
}
public override void Initialize(EndpointAddress address, Binding binding, ClientCredentials credentials, PeerReferralPolicy referralPolicy)
{
this.address = address;
this.binding = binding;
this.credentials = credentials;
Validate();
channelFactory = new ChannelFactory<IPeerResolverClient>(binding, address);
channelFactory.Endpoint.Behaviors.Remove<ClientCredentials>();
if (credentials != null)
channelFactory.Endpoint.Behaviors.Add(credentials);
channelFactory.Open();
this.referralPolicy = referralPolicy;
opened = true;
}
IPeerResolverClient GetProxy()
{
return (IPeerResolverClient)channelFactory.CreateChannel();
}
void Validate()
{
if (address == null || binding == null)
PeerExceptionHelper.ThrowArgument_InsufficientResolverSettings();
}
// 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;
}
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);
}
}
// Unregister address for a node from the resolver service
public override void Unregister(object registrationId, TimeSpan timeout)
{
if (opened)
{
UnregisterInfo info = new UnregisterInfo(this.meshId, this.registrationId);
try
{
IPeerResolverClient proxy = GetProxy();
try
{
proxy.OperationTimeout = timeout;
proxy.Unregister(info);
proxy.Close();
}
finally
{
proxy.Abort();
}
}
catch (CommunicationException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
finally
{
opened = false;
timer.Cancel();
}
}
}
// Updates a node's registration with the resolver service.
public override void Update(object registrationId, PeerNodeAddress updatedNodeAddress, TimeSpan timeout)
{
if (opened)
{
UpdateInfo info = new UpdateInfo(this.registrationId, clientId, meshId, updatedNodeAddress);
this.nodeAddress = updatedNodeAddress;
SendUpdate(info, timeout);
}
}
void SendUpdate(UpdateInfo updateInfo, TimeSpan timeout)
{
try
{
RegisterResponseInfo response;
IPeerResolverClient proxy = GetProxy();
try
{
proxy.OperationTimeout = timeout;
response = proxy.Update(updateInfo);
proxy.Close();
this.registrationId = response.RegistrationId;
this.defaultLifeTime = response.RegistrationLifetime;
Interlocked.Exchange(ref this.updateSuccessful, 1);
timer.Set(this.defaultLifeTime);
}
finally
{
proxy.Abort();
}
}
catch (CommunicationException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
Interlocked.Exchange(ref this.updateSuccessful, 0);
}
catch (Exception e)
{
if (Fx.IsFatal(e)) throw;
Interlocked.Exchange(ref this.updateSuccessful, 0);
throw;
}
}
// Query the resolver service for addresses associated with a mesh ID
public override ReadOnlyCollection<PeerNodeAddress> Resolve(string meshId, int maxAddresses, TimeSpan timeout)
{
ResolveResponseInfo result = null;
IList<PeerNodeAddress> addresses = null;
List<PeerNodeAddress> output_addresses = new List<PeerNodeAddress>();
if (opened)
{
ResolveInfo info = new ResolveInfo(clientId, meshId, maxAddresses);
try
{
IPeerResolverClient proxy = GetProxy();
try
{
proxy.OperationTimeout = timeout;
result = proxy.Resolve(info);
proxy.Close();
}
finally
{
proxy.Abort();
}
// If addresses couldn't be obtained, return empty collection
if (result != null && result.Addresses != null)
addresses = result.Addresses;
}
catch (CommunicationException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
catch (Exception e)
{
if (Fx.IsFatal(e)) throw;
opened = false;
throw;
}
}
if (addresses != null)
{
foreach (PeerNodeAddress nodeaddr in addresses)
{
bool valid = true;
long scopeId = -1;
if (nodeaddr == null) continue;
foreach (IPAddress addr in nodeaddr.IPAddresses)
{
if (addr.IsIPv6LinkLocal)
{
if (scopeId == -1)
{
scopeId = addr.ScopeId;
}
else if (scopeId != addr.ScopeId)
{
valid = false;
break;
}
}
}
if (valid)
{
output_addresses.Add(nodeaddr);
}
}
}
return new ReadOnlyCollection<PeerNodeAddress>(output_addresses);
}
internal string BindingName
{
get { return bindingName; }
set { this.bindingName = value; }
}
internal string BindingConfigurationName
{
get { return bindingName; }
set { this.bindingConfigurationName = value; }
}
public override bool Equals(object other)
{
PeerDefaultCustomResolverClient that = other as PeerDefaultCustomResolverClient;
if ((that == null) ||
(this.referralPolicy != that.referralPolicy) || !this.address.Equals(that.address))
return false;
if (this.BindingName != null || this.BindingConfigurationName != null)
return ((this.BindingName == that.BindingName) && (this.BindingConfigurationName == that.BindingConfigurationName));
else
return this.binding.Equals(that.binding);
}
public override int GetHashCode()
{
return base.GetHashCode();
}
}
}
|