public SizedTcpReplyChannel(MessageEncoder encoder, BufferManager bufferManager, Uri localAddress, Socket socket, ChannelManagerBase channelManager)
: base(encoder, bufferManager, channelManager)
{
this.localAddress = localAddress;
this.socket = socket;
this.InitializeSocket(socket);
}
protected TransportOutputChannel(ChannelManagerBase channelManager, EndpointAddress to, Uri via, bool manualAddressing, System.ServiceModel.Channels.MessageVersion messageVersion) : base(channelManager)
{
this.manualAddressing = manualAddressing;
this.messageVersion = messageVersion;
this.to = to;
this.via = via;
if (!manualAddressing && (to != null))
{
Uri anonymousUri;
if (to.IsAnonymous)
{
anonymousUri = this.messageVersion.Addressing.AnonymousUri;
}
else if (to.IsNone)
{
anonymousUri = this.messageVersion.Addressing.NoneUri;
}
else
{
anonymousUri = to.Uri;
}
XmlDictionaryString dictionaryTo = new ToDictionary(anonymousUri.AbsoluteUri).To;
this.toHeader = ToHeader.Create(anonymousUri, dictionaryTo, messageVersion.Addressing);
this.anyHeadersToAdd = to.Headers.Count > 0;
}
}
public MockChannelBase(ChannelManagerBase manager, MessageEncoderFactory encoderFactory, EndpointAddress address)
: base(manager)
{
_address = address;
_manager = manager;
_encoder = encoderFactory.CreateSessionEncoder();
OpenAsyncResult = new MockAsyncResult();
CloseAsyncResult = new MockAsyncResult();
GetEndpointPropertyOverride = DefaultGetEndpointProperty;
// CommunicationObject overrides
DefaultCloseTimeoutOverride = DefaultDefaultCloseTimeout;
DefaultOpenTimeoutOverride = DefaultDefaultOpenTimeout;
OnAbortOverride = DefaultOnAbort;
OnOpenOverride = DefaultOnOpen;
OnCloseOverride = DefaultOnClose;
OnBeginOpenOverride = DefaultOnBeginOpen;
OnEndOpenOverride = DefaultOnEndOpen;
OnBeginCloseOverride = DefaultOnBeginClose;
OnEndCloseOverride = DefaultOnEndClose;
// All the virtuals
OnOpeningOverride = DefaultOnOpening;
OnOpenedOverride = DefaultOnOpened;
OnClosingOverride = DefaultOnClosing;
OnClosedOverride = DefaultOnClosed;
OnFaultedOverride = DefaultOnFaulted;
}
public MessageBusInputChannel(
BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent,
EndpointAddress localAddress,
IBus bus)
: base(bufferManager, encoder, parent)
{
_localAddress = localAddress;
_bus = bus;
_aLock = new object();
_tryReceiveDelegate = (TimeSpan timeout, out Message message) =>
{
message = null;
try
{
var requestMessage = _bus.Receive(true, null);
if (requestMessage != null)
{
message = GetWcfMessageFromString(requestMessage.Content);
OnAfterTryReceive(requestMessage);
}
}
catch (Exception ex)
{
throw new CommunicationException(ex.Message, ex);
}
return true;
};
_receiveDelegate = (TimeSpan timeout) =>
{
var requestMessage = _bus.Receive(false, ChannelID);
return GetWcfMessageFromString(requestMessage.Content);
};
}
public LayeredDuplexChannel(ChannelManagerBase channelManager, IInputChannel innerInputChannel, EndpointAddress localAddress, IOutputChannel innerOutputChannel) : base(channelManager, innerInputChannel)
{
this.localAddress = localAddress;
this.innerOutputChannel = innerOutputChannel;
this.onInnerOutputChannelFaulted = new EventHandler(this.OnInnerOutputChannelFaulted);
this.innerOutputChannel.Faulted += this.onInnerOutputChannelFaulted;
}
public MessageBusReplySessionChannel(
BufferManager bufferManager, MessageEncoderFactory encoderFactory, ChannelManagerBase parent,
EndpointAddress localAddress,
IBus bus)
: base(bufferManager, encoderFactory, parent, localAddress, bus)
{
}
/// <summary>
/// SerialChannel Base
/// </summary>
/// <param name="bufferManager">
/// Buffer manager created by factory and listener</param>
/// <param name="encoderFactory">
/// Referece to encoder factory as returned by encoder element</param>
/// <param name="address">Remote address</param>
/// <param name="portNumber">COM port number</param>
/// <param name="parent">reference to factory/listener</param>
/// <param name="maxReceivedMessageSize">
/// Some settings for transport channel</param>
public SerialChannelBase(BufferManager bufferManager,
MessageEncoderFactory encoderFactory,
EndpointAddress address,
string portNumber,
ChannelManagerBase parent,
long maxReceivedMessageSize)
: base(parent)
{
this.address = address;
this.bufferManager = bufferManager;
this.encoder = encoderFactory.CreateSessionEncoder();
this.maxReceivedMessageSize = maxReceivedMessageSize;
this.portNumber = portNumber;
// Create port
serialPort = new SerialPort();
// Set the appropriate properties.
serialPort.PortName = this.portNumber;
//TODO: Read these settings from configuration file
serialPort.BaudRate = 9600;
serialPort.Parity = Parity.None;
serialPort.DataBits = 8;
serialPort.StopBits = StopBits.One;
serialPort.Handshake = Handshake.None;
// Set the read/write timeouts
serialPort.ReadTimeout = 500;
serialPort.WriteTimeout = 500;
}
public ProtoBufMetaDataReplyChannel(EndpointAddress address,
ChannelManagerBase parent, IReplyChannel innerChannel) :
base(parent, innerChannel)
{
this._localAddress = address;
_innerChannel = innerChannel;
}
/// <summary>
/// Initializes a new channel instance
/// </summary>
/// <param name="manager">
/// Containing channel listener/factory
/// </param>
/// <param name="codec">
/// The channel message coder/decoder
/// </param>
public Channel(
ChannelManagerBase manager,
MessageCodec codec)
: base(manager)
{
this.codec = codec;
}
public InputChannel(ChannelManagerBase channelManager)
: base(channelManager)
{
var listener = channelManager as InputChannelListener;
if (listener == null) throw new ArgumentException("Invalid channel manager.", "channelManager");
this.LocalAddress = new EndpointAddress(listener.Uri);
}
/// <summary>
/// Initializes a new channel instance
/// </summary>
/// <param name="manager">
/// Containing channel listener/factory
/// </param>
/// <param name="session">
/// The current in-process session
/// </param>
/// <param name="address">
/// The server communication address
/// </param>
public Channel(
ChannelManagerBase manager,
Session session,
EndpointAddress address)
: base(manager, null, address, address)
{
this.session = session;
}
/// <summary>
/// Initializes a new channel instance
/// </summary>
/// <param name="manager">
/// Containing channel listener/factory
/// </param>
/// <param name="codec">
/// The channel message coder/decoder
/// </param>
/// <param name="localAddress">
/// The address of the local endpoint
/// </param>
/// <param name="remoteAddress">
/// The address of the remote endpoint
/// </param>
public DuplexSessionChannel(
ChannelManagerBase manager,
MessageCodec codec,
EndpointAddress localAddress,
EndpointAddress remoteAddress)
: base(manager, codec, localAddress, remoteAddress)
{
}
/// <summary>
/// Initializes a new channel instance
/// </summary>
/// <param name="manager">
/// Containing channel listener/factory
/// </param>
/// <param name="codec">
/// The channel message coder/decoder
/// </param>
/// <param name="localAddress">
/// The address of the local endpoint
/// </param>
public ReplyChannel(
ChannelManagerBase manager,
MessageCodec codec,
EndpointAddress localAddress)
: base(manager, codec)
{
this.localAddress = localAddress;
}
public StreamedFramingRequestChannel(ChannelManagerBase factory, IConnectionOrientedTransportChannelFactorySettings settings, EndpointAddress remoteAddresss, Uri via, IConnectionInitiator connectionInitiator, ConnectionPool connectionPool) : base(factory, remoteAddresss, via, settings.ManualAddressing)
{
this.settings = settings;
this.connectionInitiator = connectionInitiator;
this.connectionPool = connectionPool;
this.messageEncoder = settings.MessageEncoderFactory.Encoder;
this.upgrade = settings.Upgrade;
}
public OutputChannel(ChannelManagerBase channelManager, IQueue queue,
EndpointAddress remoteAddress, Uri via)
: base(channelManager)
{
this.queue = queue;
this.RemoteAddress = remoteAddress;
this.Via = via;
}
protected ZMQReceivingChannelBase(ChannelManagerBase channelManager, BindingContext bindingContext, Context context, Socket socket, SocketMode socketMode)
: base(channelManager, bindingContext, socket, socketMode)
{
_onReceiveHandler = Receive;
_onTryReceiveHandler = TryReceive;
_onWaitForMessageHandler = WaitForMessage;
_context = context;
}
public DurableInstanceContextReplyChannel(ChannelManagerBase channelManager,
ContextType contextType,
IReplyChannel innerChannel)
: base(channelManager, innerChannel)
{
this.contextType = contextType;
this.innerReplyChannel = innerChannel;
}
/// <summary>
/// Initializes a new channel instance
/// </summary>
/// <param name="manager">
/// Containing channel listener/factory
/// </param>
/// <param name="codec">
/// The channel message coder/decoder
/// </param>
/// <param name="remoteAddress">
/// The address of the remote endpoint
/// </param>
public OutputChannel(
ChannelManagerBase manager,
MessageCodec codec,
EndpointAddress remoteAddress)
: base(manager, codec)
{
this.remoteAddress = remoteAddress;
}
protected MessageBusChannelBase(BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent)
: base(parent)
{
_id = Guid.NewGuid();
_bufferManager = bufferManager;
_encoder = encoder.CreateSessionEncoder();
}
public MessageBusRequestSessionChannel(
BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent,
EndpointAddress remoteAddress, Uri via,
IBus bus)
: base(bufferManager, encoder, parent, remoteAddress, via, bus)
{
_session = new MessageBusOutputSession((new UniqueId()).ToString());
}
protected ThreadlessInputChannel(
ChannelManagerBase channelManager,
IHasBindingElement bindingElement,
EndpointAddress localAddress)
: base(channelManager, bindingElement)
{
LocalAddress = localAddress;
}
public MockRequestChannel(ChannelManagerBase manager, MessageEncoderFactory encoderFactory, EndpointAddress address, Uri via)
: base(manager, encoderFactory, address)
{
this._via = via;
RequestOverride = DefaultRequest;
BeginRequestOverride = DefaultBeginRequest;
EndRequestOverride = DefaultEndRequest;
}
public MessageBusDuplexSessionChannel(
BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent,
EndpointAddress remoteAddress, Uri via,
IBus bus,
bool isClient)
: base(bufferManager, encoder, remoteAddress, parent, via, bus, isClient)
{
_session = new MessageBusDuplexSession((new UniqueId()).ToString());
}
/// <summary>
/// Initializes a new channel instance
/// </summary>
/// <param name="manager">
/// Containing channel listener/factory
/// </param>
/// <param name="codec">
/// The channel message coder/decoder
/// </param>
/// <param name="remoteAddress">
/// The output address
/// </param>
/// <param name="socket">
/// The UDP channel socket
/// </param>
public OutputChannel(
ChannelManagerBase manager,
MessageCodec codec,
EndpointAddress remoteAddress,
UdpSocket socket)
: base(manager, codec, remoteAddress)
{
this.socket = socket;
}
/// <summary>
/// Initializes a new channel instance
/// </summary>
/// <param name="manager">
/// Containing channel listener/factory
/// </param>
/// <param name="codec">
/// The channel message coder/decoder
/// </param>
/// <param name="localAddress">
/// The input address
/// </param>
/// <param name="socket">
/// The datagram socket for this channel
/// </param>
public ReplyChannel(
ChannelManagerBase manager,
MessageCodec codec,
EndpointAddress localAddress,
UdpSocket socket)
: base(manager, codec, localAddress)
{
this.socket = socket;
}
public FileChannelBase(BufferManager bufferManager, MessageEncoderFactory encoderFactory, EndpointAddress address, ChannelManagerBase parent,
long maxReceivedMessageSize)
: base(parent)
{
this.address = address;
this.bufferManager = bufferManager;
this.encoder = encoderFactory.CreateSessionEncoder();
this.maxReceivedMessageSize = maxReceivedMessageSize;
}
public DurableInstanceContextReplySessionChannel(ChannelManagerBase channelManager,
ContextType contextType,
IReplySessionChannel innerChannel)
: base(channelManager, innerChannel)
{
this.contextType = contextType;
this.innerReplySessionChannel = innerChannel;
this.isFirstMessage = true;
this.stateLock = new object();
}
protected ThreadlessOutputChannel(
ChannelManagerBase channelManager,
IHasBindingElement bindingElement,
EndpointAddress remoteAddress,
Uri via)
: base(channelManager, bindingElement)
{
RemoteAddress = remoteAddress;
Via = via;
}
/// <summary>
/// Initializes a new channel instance
/// </summary>
/// <param name="manager">
/// Containing channel listener/factory
/// </param>
/// <param name="codec">
/// The channel message coder/decoder
/// </param>
/// <param name="localAddress">
/// The address of the local endpoint
/// </param>
/// <param name="remoteAddress">
/// The address of the remote endpoint
/// </param>
public DuplexChannel(
ChannelManagerBase manager,
MessageCodec codec,
EndpointAddress localAddress,
EndpointAddress remoteAddress)
: base(manager, codec)
{
this.localAddress = localAddress;
this.remoteAddress = remoteAddress;
}
public MessageBusOutputChannel(
BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent,
EndpointAddress remoteAddress,
Uri via, IBus bus)
: base(bufferManager, encoder, parent)
{
_bus = bus;
_via = via;
_remoteAddress = remoteAddress;
}
protected ContextInputChannelBase(ChannelManagerBase channelManager, TChannel innerChannel, ContextExchangeMechanism contextExchangeMechanism)
: base(channelManager, innerChannel)
{
this.contextExchangeMechanism = contextExchangeMechanism;
this.contextProtocol = new ServiceContextProtocol(contextExchangeMechanism);
}
protected DuplexChannel(ChannelManagerBase channelManager, EndpointAddress localAddress) : base(channelManager)
{
LocalAddress = localAddress;
}
public ReplySessionChannelWrapper(ChannelManagerBase channelManager, IReplySessionChannel innerChannel, RequestContext firstRequest) : base(channelManager, innerChannel, firstRequest)
{
}
protected ContextRequestChannelBase(ChannelManagerBase channelManager, TChannel innerChannel,
ContextExchangeMechanism contextExchangeMechanism, Uri callbackAddress, bool contextManagementEnabled)
: base(channelManager, innerChannel)
{
this.contextProtocol = new ClientContextProtocol(contextExchangeMechanism, innerChannel.Via, this, callbackAddress, contextManagementEnabled);
}
protected OutputChannel(ChannelManagerBase manager) : base(manager)
{
}
public TransportReplyChannel(ChannelManagerBase channelManager, EndpointAddress localAddress) : base(channelManager, localAddress)
{
}
public SecurityOutputSessionChannel(ChannelManagerBase factory, SecurityProtocolFactory securityProtocolFactory, IOutputSessionChannel innerChannel, EndpointAddress to, Uri via)
: base(factory, securityProtocolFactory, (IOutputChannel)innerChannel, to, via)
{
}
public ContextOutputChannel(ChannelManagerBase channelManager, IOutputChannel innerChannel, ContextExchangeMechanism contextExchangeMechanism, Uri callbackAddress, bool contextManagementEnabled) : base(channelManager, innerChannel)
{
this.contextProtocol = new ClientContextProtocol(contextExchangeMechanism, base.InnerChannel.Via, this, callbackAddress, contextManagementEnabled);
}
public ContextRequestChannel(ChannelManagerBase channelManager, IRequestChannel innerChannel, ContextExchangeMechanism contextExchangeMechanism, Uri callbackAddress, bool contextManagementEnabled) : base(channelManager, innerChannel, contextExchangeMechanism, callbackAddress, contextManagementEnabled)
{
}
public LayeredInputChannel(ChannelManagerBase channelManager, IInputChannel innerChannel)
: base(channelManager, innerChannel)
{
}
public SingletonChannelAcceptor(ChannelManagerBase channelManager)
: base(channelManager)
{
}
public DuplexSessionOneWayInputChannel(ChannelManagerBase channelManager, EndpointAddress localAddress) : base(channelManager, localAddress)
{
}
protected LayeredChannel(ChannelManagerBase channelManager, TInnerChannel innerChannel) : base(channelManager)
{
this.innerChannel = innerChannel;
this.onInnerChannelFaulted = new EventHandler(this.OnInnerChannelFaulted);
this.innerChannel.Faulted += this.onInnerChannelFaulted;
}
protected LayeredChannelAcceptor(ChannelManagerBase channelManager, IChannelListener <TInnerChannel> innerListener) : base(channelManager)
{
this.innerListener = innerListener;
}
private FramingDuplexSessionChannel(ChannelManagerBase manager, IConnectionOrientedTransportFactorySettings settings,
EndpointAddress localAddress, Uri localVia, EndpointAddress remoteAddresss, Uri via, bool exposeConnectionProperty)
: base(manager, settings, localAddress, localVia, remoteAddresss, via)
{
_exposeConnectionProperty = exposeConnectionProperty;
}
public PeerOutputChannel(PeerNodeImplementation peerNode, PeerNodeImplementation.Registration registration, ChannelManagerBase channelManager,
EndpointAddress localAddress, Uri via, MessageVersion messageVersion)
: base(channelManager, localAddress, via, false, messageVersion)
{
PeerNodeImplementation.ValidateVia(via);
if (registration != null)
{
peerNode = PeerNodeImplementation.Get(via, registration);
}
this.peerNode = new PeerNode(peerNode);
this.via = via;
this.channelManager = channelManager;
this.to = localAddress;
}
public InputChannel(ChannelManagerBase channelManager, EndpointAddress localAddress)
: base(channelManager)
{
this.localAddress = localAddress;
}
protected ChannelBase(ChannelManagerBase manager)
{
this.manager = manager;
}
public ServerUdpOutputChannel(ChannelManagerBase factory, MessageEncoder encoder, BufferManager bufferManager, UdpSocket[] sendSockets, UdpRetransmissionSettings retransmissionSettings, Uri via, bool isMulticast)
: base(factory, encoder, bufferManager, sendSockets, retransmissionSettings, via, isMulticast)
{
}
public ReplyOverDuplexChannel(ChannelManagerBase channelManager, IDuplexChannel innerChannel) : base(channelManager, innerChannel)
{
}
public PeerDuplexChannelAcceptor(PeerNodeImplementation peerNode, PeerNodeImplementation.Registration registration, ChannelManagerBase channelManager, EndpointAddress localAddress, Uri via) : base(channelManager)
{
this.registration = registration;
this.peerNode = peerNode;
this.localAddress = localAddress;
this.via = via;
PeerMessageDispatcher <IDuplexChannel, PeerDuplexChannel> .PeerMessageQueueAdapter queueHandler = new PeerMessageDispatcher <IDuplexChannel, PeerDuplexChannel> .PeerMessageQueueAdapter(this);
this.dispatcher = new PeerMessageDispatcher <IDuplexChannel, PeerDuplexChannel>(queueHandler, peerNode, base.ChannelManager, localAddress, via);
}
protected InputQueueChannel(ChannelManagerBase channelManager)
: base(channelManager)
{
this.inputQueue = TraceUtility.CreateInputQueue <TDisposable>();
}
protected override IInputSessionChannel CreateChannel(ChannelManagerBase channelManager, IInputSessionChannel innerChannel, Message firstMessage)
{
return(new InputSessionChannelWrapper(channelManager, innerChannel, firstMessage));
}
public ReliableOutputSessionChannelOverRequest(ChannelManagerBase factory, IReliableFactorySettings settings, IClientReliableChannelBinder binder, FaultHelper faultHelper, LateBoundChannelParameterCollection channelParameters) : base(factory, settings, binder, faultHelper, channelParameters)
{
this.binder = binder;
}
public InputSessionChannelWrapper(ChannelManagerBase channelManager, IInputSessionChannel innerChannel, Message firstMessage) : base(channelManager, innerChannel, firstMessage)
{
}
public ReplySessionOverDuplexSessionChannel(ChannelManagerBase channelManager, IDuplexSessionChannel innerChannel) : base(channelManager, innerChannel)
{
this.session = new ReplySessionOverDuplexSession(innerChannel.Session);
}
public SecurityRequestChannel(ChannelManagerBase factory, SecurityProtocolFactory securityProtocolFactory, IRequestChannel innerChannel, EndpointAddress to, Uri via)
: base(factory, securityProtocolFactory, innerChannel, to, via)
{
}
public SecurityDuplexSessionChannel(ChannelManagerBase factory, SecurityProtocolFactory securityProtocolFactory, IDuplexSessionChannel innerChannel, EndpointAddress to, Uri via)
: base(factory, securityProtocolFactory, innerChannel, to, via)
{
}
public ContextInputChannel(ChannelManagerBase channelManager, IInputChannel innerChannel, ContextExchangeMechanism contextExchangeMechanism) : base(channelManager, innerChannel, contextExchangeMechanism)
{
}
public ContextReplySessionChannel(ChannelManagerBase channelManager, IReplySessionChannel innerChannel, ContextExchangeMechanism contextExchangeMechanism) : base(channelManager, innerChannel)
{
this.contextProtocol = new ServiceContextProtocol(contextExchangeMechanism);
}
