Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

399 lines
14 KiB
C#

//------------------------------------------------------------
// 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();
}
}
}