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

350 lines
14 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Net;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Diagnostics;
using System.ServiceModel.Dispatcher;
// What the connector interface needs to looks like
interface IPeerConnectorContract
{
void Connect(IPeerNeighbor neighbor, ConnectInfo connectInfo);
void Disconnect(IPeerNeighbor neighbor, DisconnectInfo disconnectInfo);
void Refuse(IPeerNeighbor neighbor, RefuseInfo refuseInfo);
void Welcome(IPeerNeighbor neighbor, WelcomeInfo welcomeInfo);
}
// Implemented by flooder / service uses this to delegate service invocations
interface IPeerFlooderContract<TFloodContract, TLinkContract>
{
//invoked by the peerservice
IAsyncResult OnFloodedMessage(IPeerNeighbor neighbor, TFloodContract floodedInfo, AsyncCallback callback, object state);
void EndFloodMessage(IAsyncResult result);
void ProcessLinkUtility(IPeerNeighbor neighbor, TLinkContract utilityInfo);
}
// Class that implements IPeerService contract for incoming neighbor sessions and messages.
// WARNING: This class is not synchronized. Expects the using class to synchronize access
[ServiceBehavior(
ConcurrencyMode = ConcurrencyMode.Multiple,
InstanceContextMode = InstanceContextMode.Single,
UseSynchronizationContext = false)]
class PeerService : IPeerService, IServiceBehavior, IChannelInitializer
{
public delegate bool ChannelCallback(IClientChannel channel);
public delegate IPeerNeighbor GetNeighborCallback(IPeerProxy channel);
Binding binding;
PeerNodeConfig config;
ChannelCallback newChannelCallback;
GetNeighborCallback getNeighborCallback;
ServiceHost serviceHost; // To listen for incoming neighbor sessions
IPeerConnectorContract connector;
IPeerFlooderContract<Message, UtilityInfo> flooder;
IPeerNodeMessageHandling messageHandler;
public PeerService(PeerNodeConfig config,
ChannelCallback channelCallback,
GetNeighborCallback getNeighborCallback,
Dictionary<Type, object> services)
: this(config, channelCallback, getNeighborCallback, services, null) { }
public PeerService(PeerNodeConfig config,
ChannelCallback channelCallback,
GetNeighborCallback getNeighborCallback,
Dictionary<Type, object> services,
IPeerNodeMessageHandling messageHandler)
{
this.config = config;
this.newChannelCallback = channelCallback;
Fx.Assert(getNeighborCallback != null, "getNeighborCallback must be passed to PeerService constructor");
this.getNeighborCallback = getNeighborCallback;
this.messageHandler = messageHandler;
if (services != null)
{
object reply = null;
services.TryGetValue(typeof(IPeerConnectorContract), out reply);
connector = reply as IPeerConnectorContract;
Fx.Assert(connector != null, "PeerService must be created with a connector implementation");
reply = null;
services.TryGetValue(typeof(IPeerFlooderContract<Message, UtilityInfo>), out reply);
flooder = reply as IPeerFlooderContract<Message, UtilityInfo>;
Fx.Assert(flooder != null, "PeerService must be created with a flooder implementation");
}
this.serviceHost = new ServiceHost(this);
// Add throttling
ServiceThrottlingBehavior throttle = new ServiceThrottlingBehavior();
throttle.MaxConcurrentCalls = this.config.MaxPendingIncomingCalls;
throttle.MaxConcurrentSessions = this.config.MaxConcurrentSessions;
this.serviceHost.Description.Behaviors.Add(throttle);
}
public void Abort()
{
this.serviceHost.Abort();
}
public Binding Binding
{
get { return this.binding; }
}
// Create the binding using user specified config. The stacking is
// BinaryMessageEncoder/TCP
void CreateBinding()
{
Collection<BindingElement> bindingElements = new Collection<BindingElement>();
BindingElement security = this.config.SecurityManager.GetSecurityBindingElement();
if (security != null)
{
bindingElements.Add(security);
}
TcpTransportBindingElement transport = new TcpTransportBindingElement();
transport.MaxReceivedMessageSize = this.config.MaxReceivedMessageSize;
transport.MaxBufferPoolSize = this.config.MaxBufferPoolSize;
transport.TeredoEnabled = true;
MessageEncodingBindingElement encoder = null;
if (messageHandler != null)
encoder = messageHandler.EncodingBindingElement;
if (encoder == null)
{
BinaryMessageEncodingBindingElement bencoder = new BinaryMessageEncodingBindingElement();
this.config.ReaderQuotas.CopyTo(bencoder.ReaderQuotas);
bindingElements.Add(bencoder);
}
else
{
bindingElements.Add(encoder);
}
bindingElements.Add(transport);
this.binding = new CustomBinding(bindingElements);
this.binding.ReceiveTimeout = TimeSpan.MaxValue;
}
// Returns the address that the serviceHost is listening on.
public EndpointAddress GetListenAddress()
{
IChannelListener listener = this.serviceHost.ChannelDispatchers[0].Listener;
return new EndpointAddress(listener.Uri, listener.GetProperty<EndpointIdentity>());
}
IPeerNeighbor GetNeighbor()
{
IPeerNeighbor neighbor = (IPeerNeighbor)getNeighborCallback(OperationContext.Current.GetCallbackChannel<IPeerProxy>());
if (neighbor == null || neighbor.State == PeerNeighborState.Closed)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.PeerNeighborNotFound,
SR.GetString(SR.TraceCodePeerNeighborNotFound),
new PeerNodeTraceRecord(config.NodeId),
OperationContext.Current.IncomingMessage);
}
return null;
}
if (DiagnosticUtility.ShouldTraceVerbose)
{
PeerNeighborState state = neighbor.State;
PeerNodeAddress listenAddr = null;
IPAddress connectIPAddr = null;
if (state >= PeerNeighborState.Opened && state <= PeerNeighborState.Connected)
{
listenAddr = config.GetListenAddress(true);
connectIPAddr = config.ListenIPAddress;
}
PeerNeighborTraceRecord record = new PeerNeighborTraceRecord(neighbor.NodeId,
this.config.NodeId, listenAddr, connectIPAddr, neighbor.GetHashCode(),
neighbor.IsInitiator, state.ToString(), null, null,
OperationContext.Current.IncomingMessage.Headers.Action);
TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.PeerNeighborMessageReceived, SR.GetString(SR.TraceCodePeerNeighborMessageReceived), record, this, null);
}
return neighbor;
}
public void Open(TimeSpan timeout)
{
// Create the neighbor binding
CreateBinding();
this.serviceHost.Description.Endpoints.Clear();
ServiceEndpoint endPoint = this.serviceHost.AddServiceEndpoint(typeof(IPeerService), this.binding, config.GetMeshUri());
endPoint.ListenUri = config.GetSelfUri();
endPoint.ListenUriMode = (this.config.Port > 0) ? ListenUriMode.Explicit : ListenUriMode.Unique;
/*
Uncomment this to allow the retrieval of metadata
using the command:
\binaries.x86chk\svcutil http://localhost /t:metadata
ServiceMetadataBehavior mex = new ServiceMetadataBehavior();
mex.HttpGetEnabled = true;
mex.HttpGetUrl = new Uri("http://localhost");
mex.HttpsGetEnabled = true;
mex.HttpsGetUrl = new Uri("https://localhost");
this.serviceHost.Description.Behaviors.Add(mex);
*/
this.config.SecurityManager.ApplyServiceSecurity(this.serviceHost.Description);
this.serviceHost.Open(timeout);
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.PeerServiceOpened,
SR.GetString(SR.TraceCodePeerServiceOpened, this.GetListenAddress()), this);
}
}
//
// IContractBehavior and IChannelInitializer implementation.
// Used to register for incoming channel notification.
//
void IServiceBehavior.Validate(ServiceDescription description, ServiceHostBase serviceHost)
{
}
void IServiceBehavior.AddBindingParameters(ServiceDescription description, ServiceHostBase serviceHost, Collection<ServiceEndpoint> endpoints, BindingParameterCollection parameters)
{
}
void IServiceBehavior.ApplyDispatchBehavior(ServiceDescription description, ServiceHostBase serviceHost)
{
for (int i = 0; i < serviceHost.ChannelDispatchers.Count; i++)
{
ChannelDispatcher channelDispatcher = serviceHost.ChannelDispatchers[i] as ChannelDispatcher;
if (channelDispatcher != null)
{
bool addedChannelInitializer = false;
foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints)
{
if (!endpointDispatcher.IsSystemEndpoint)
{
if (!addedChannelInitializer)
{
channelDispatcher.ChannelInitializers.Add(this);
addedChannelInitializer = true;
}
endpointDispatcher.DispatchRuntime.OperationSelector = new OperationSelector(this.messageHandler);
}
}
}
}
}
void IChannelInitializer.Initialize(IClientChannel channel)
{
newChannelCallback(channel);
}
void IPeerServiceContract.Connect(ConnectInfo connectInfo)
{
IPeerNeighbor neighbor = GetNeighbor();
if (neighbor != null)
{
connector.Connect(neighbor, connectInfo);
}
}
void IPeerServiceContract.Disconnect(DisconnectInfo disconnectInfo)
{
IPeerNeighbor neighbor = GetNeighbor();
if (neighbor != null)
{
connector.Disconnect(neighbor, disconnectInfo);
}
}
void IPeerServiceContract.Refuse(RefuseInfo refuseInfo)
{
IPeerNeighbor neighbor = GetNeighbor();
if (neighbor != null)
{
connector.Refuse(neighbor, refuseInfo);
}
}
void IPeerServiceContract.Welcome(WelcomeInfo welcomeInfo)
{
IPeerNeighbor neighbor = GetNeighbor();
if (neighbor != null)
{
connector.Welcome(neighbor, welcomeInfo);
}
}
IAsyncResult IPeerServiceContract.BeginFloodMessage(Message floodedInfo, AsyncCallback callback, object state)
{
IPeerNeighbor neighbor = GetNeighbor();
if (neighbor != null)
{
return flooder.OnFloodedMessage(neighbor, floodedInfo, callback, state);
}
else
return new CompletedAsyncResult(callback, state);
}
void IPeerServiceContract.EndFloodMessage(IAsyncResult result)
{
flooder.EndFloodMessage(result);
}
void IPeerServiceContract.LinkUtility(UtilityInfo utilityInfo)
{
IPeerNeighbor neighbor = GetNeighbor();
if (neighbor != null)
{
flooder.ProcessLinkUtility(neighbor, utilityInfo);
}
}
Message IPeerServiceContract.ProcessRequestSecurityToken(Message message)
{
IPeerNeighbor neighbor = GetNeighbor();
if (neighbor == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(typeof(IPeerNeighbor).ToString()));
Message reply = this.config.SecurityManager.ProcessRequest(neighbor, message);
if (reply == null)
{
OperationContext current = OperationContext.Current;
current.RequestContext.Close();
current.RequestContext = null;
}
return reply;
}
void IPeerServiceContract.Fault(Message message)
{
IPeerNeighbor neighbor = GetNeighbor();
if (neighbor == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(typeof(IPeerNeighbor).ToString()));
neighbor.Abort(PeerCloseReason.Faulted, PeerCloseInitiator.RemoteNode);
}
void IPeerServiceContract.Ping(Message message)
{
}
}
}