public void Start(Channel channel, int numWorkerThreads)
{
channelReceiver = channelFactory.GetReceiver(channel.Type);
channelReceiver.DataReceived += DataReceivedOnChannel;
channelReceiver.Start(channel.Address,numWorkerThreads);
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink sink = null;
if (Next != null)
sink = Next.CreateSink(channel);
return new XmlRpcServerChannelSink(sink);
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink scs = null;
if (Next != null)
scs = Next.CreateSink(channel);
return new XmlRpcServerFormatterSink(scs);
}
public void SetUp()
{
testSender = MockRepository.GenerateStub<ISendMessages>();
messagePersister = new InMemoryPersistence();
HttpChannelReceiver = new HttpChannelReceiver(messagePersister)
{
ListenUrl = "http://localhost:8092/Gateway/",
ReturnAddress = "Gateway.Tests.Input"
};
HttpChannelReceiver.MessageReceived += httpChannel_MessageReceived;
HttpChannelReceiver.Start();
bus = Configure.With()
.DefaultBuilder()
.XmlSerializer()
.FileShareDataBus(DATABUS_DIRECTORY)
.InMemoryFaultManagement()
.UnicastBus()
.MsmqTransport()
.CreateBus()
.Start();
}
public void Start(Channel channel)
{
channelReceiver = (IChannelReceiver)builder.Build(channel.Receiver);
channelReceiver.DataReceived += DataReceivedOnChannel;
channelReceiver.Start(channel.ReceiveAddress, channel.NumWorkerThreads);
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink nextSink = null;
if(next != null)
nextSink = next.CreateSink(channel);
return new MethodRestrictionServerSink(this, nextSink);
}
public void SetUp()
{
testSender = MockRepository.GenerateStub <ISendMessages>();
messagePersister = new InMemoryPersistence();
dataBusForTheReceivingSide = new FileShareDataBus(DATABUS_DIRECTORY);
HttpChannelReceiver = new HttpChannelReceiver(messagePersister)
{
ListenUrl = "http://localhost:8092/Gateway/",
DataBus = dataBusForTheReceivingSide
};
HttpChannelReceiver.MessageReceived += httpChannel_MessageReceived;
HttpChannelReceiver.Start();
bus = Configure.With()
.DefaultBuilder()
.XmlSerializer()
.FileShareDataBus(DATABUS_DIRECTORY_FOR_THE_TEST_ENDPOINT)
.InMemoryFaultManagement()
.UnicastBus()
.MsmqTransport()
.CreateBus()
.Start();
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
if (null == channel)
{
throw new ArgumentNullException("channel");
}
IServerChannelSink nextSink = null;
if (_next != null)
{
nextSink = _next.CreateSink(channel);
}
BinaryServerFormatterSink.Protocol protocol =
BinaryServerFormatterSink.Protocol.Other;
// see if this is an http channel
String uri = channel.GetUrlsForUri("")[0];
if (String.Compare("http", 0, uri, 0, 4, StringComparison.OrdinalIgnoreCase) == 0)
{
protocol = BinaryServerFormatterSink.Protocol.Http;
}
BinaryServerFormatterSink sink = new BinaryServerFormatterSink(protocol, nextSink, channel);
sink.TypeFilterLevel = _formatterSecurityLevel;
sink.IncludeVersioning = _includeVersioning;
sink.StrictBinding = _strictBinding;
return(sink);
} // CreateSink
/// <summary>
/// factory method that create the concrete corresponding server sink object
/// </summary>
/// <param name="channel">The channel for which to create the channel sink chain. </param>
/// <returns>newly created CryptoRemotingServerSink object</returns>
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink nextSink;
nextSink = next.CreateSink(channel);
return(new CryptoRemotingServerSink(nextSink));
}
public static string[] GetUrlsForObject(MarshalByRefObject obj)
{
#if !DISABLE_REMOTING
string uri = RemotingServices.GetObjectUri(obj);
if (uri == null)
{
return(new string [0]);
}
ArrayList list = new ArrayList();
lock (registeredChannels.SyncRoot)
{
foreach (object chnl_obj in registeredChannels)
{
if (chnl_obj is CrossAppDomainChannel)
{
continue;
}
IChannelReceiver chnl = chnl_obj as IChannelReceiver;
if (chnl != null)
{
list.AddRange(chnl.GetUrlsForUri(uri));
}
}
}
return((string[])list.ToArray(typeof(string)));
#else
return(new string [0]);
#endif
}
internal static string FindFirstHttpUrlForObject(string objectUri)
{
if (objectUri == null)
{
return((string)null);
}
RegisteredChannelList registeredChannelList = ChannelServices.s_registeredChannels;
int count = registeredChannelList.Count;
for (int index = 0; index < count; ++index)
{
if (registeredChannelList.IsReceiver(index))
{
IChannelReceiver channelReceiver = (IChannelReceiver)registeredChannelList.GetChannel(index);
string fullName = channelReceiver.GetType().FullName;
if (string.CompareOrdinal(fullName, "System.Runtime.Remoting.Channels.Http.HttpChannel") == 0 || string.CompareOrdinal(fullName, "System.Runtime.Remoting.Channels.Http.HttpServerChannel") == 0)
{
string[] urlsForUri = channelReceiver.GetUrlsForUri(objectUri);
if (urlsForUri != null && urlsForUri.Length != 0)
{
return(urlsForUri[0]);
}
}
}
}
return((string)null);
}
/// <summary>Returns an array of all the URLs that can be used to reach the specified object.</summary>
/// <returns>An array of strings that contains the URLs that can be used to remotely identify the object, or null if none were found.</returns>
/// <param name="obj">The object to retrieve the URL array for. </param>
/// <exception cref="T:System.Security.SecurityException">The immediate caller does not have infrastructure permission. </exception>
/// <PermissionSet>
/// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="Infrastructure" />
/// </PermissionSet>
public static string[] GetUrlsForObject(MarshalByRefObject obj)
{
string objectUri = RemotingServices.GetObjectUri(obj);
if (objectUri == null)
{
return(new string[0]);
}
ArrayList arrayList = new ArrayList();
object syncRoot = ChannelServices.registeredChannels.SyncRoot;
lock (syncRoot)
{
foreach (object obj2 in ChannelServices.registeredChannels)
{
if (!(obj2 is CrossAppDomainChannel))
{
IChannelReceiver channelReceiver = obj2 as IChannelReceiver;
if (channelReceiver != null)
{
arrayList.AddRange(channelReceiver.GetUrlsForUri(objectUri));
}
}
}
}
return((string[])arrayList.ToArray(typeof(string)));
}
public static string[] GetUrlsForObject(MarshalByRefObject obj)
{
string uri = RemotingServices.GetObjectUri(obj);
if (uri == null)
{
return(new string [0]);
}
var list = new List <string> ();
lock (registeredChannels.SyncRoot)
{
foreach (object chnl_obj in registeredChannels)
{
if (chnl_obj is CrossAppDomainChannel)
{
continue;
}
IChannelReceiver chnl = chnl_obj as IChannelReceiver;
if (chnl != null)
{
list.AddRange(chnl.GetUrlsForUri(uri));
}
}
}
return(list.ToArray());
}
/// <summary>Unregisters a particular channel from the registered channels list.</summary>
/// <param name="chnl">The channel to unregister. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="chnl" /> parameter is null. </exception>
/// <exception cref="T:System.Runtime.Remoting.RemotingException">The channel is not registered. </exception>
/// <exception cref="T:System.Security.SecurityException">At least one of the callers higher in the callstack does not have permission to configure remoting types and channels. </exception>
/// <PermissionSet>
/// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="RemotingConfiguration" />
/// </PermissionSet>
public static void UnregisterChannel(IChannel chnl)
{
if (chnl == null)
{
throw new ArgumentNullException();
}
object syncRoot = ChannelServices.registeredChannels.SyncRoot;
lock (syncRoot)
{
for (int i = 0; i < ChannelServices.registeredChannels.Count; i++)
{
if (ChannelServices.registeredChannels[i] == chnl)
{
ChannelServices.registeredChannels.RemoveAt(i);
IChannelReceiver channelReceiver = chnl as IChannelReceiver;
if (channelReceiver != null)
{
channelReceiver.StopListening(null);
}
return;
}
}
throw new RemotingException("Channel not registered");
}
}
internal static string FindFirstHttpUrlForObject(string objectUri)
{
if (objectUri != null)
{
RegisteredChannelList list = s_registeredChannels;
int count = list.Count;
for (int i = 0; i < count; i++)
{
if (list.IsReceiver(i))
{
IChannelReceiver channel = (IChannelReceiver)list.GetChannel(i);
string fullName = channel.GetType().FullName;
if ((string.CompareOrdinal(fullName, "System.Runtime.Remoting.Channels.Http.HttpChannel") == 0) || (string.CompareOrdinal(fullName, "System.Runtime.Remoting.Channels.Http.HttpServerChannel") == 0))
{
string[] urlsForUri = channel.GetUrlsForUri(objectUri);
if ((urlsForUri != null) && (urlsForUri.Length > 0))
{
return(urlsForUri[0]);
}
}
}
}
}
return(null);
}
public void SetUp()
{
testSender = MockRepository.GenerateStub<ISendMessages>();
messagePersister = new InMemoryPersistence();
dataBusForTheReceivingSide = new FileShareDataBus(DATABUS_DIRECTORY);
HttpChannelReceiver = new HttpChannelReceiver(messagePersister)
{
ListenUrl = "http://localhost:8092/Gateway/",
DataBus = dataBusForTheReceivingSide
};
HttpChannelReceiver.MessageReceived += httpChannel_MessageReceived;
HttpChannelReceiver.Start();
bus = Configure.With()
.DefaultBuilder()
.XmlSerializer()
.FileShareDataBus(DATABUS_DIRECTORY_FOR_THE_TEST_ENDPOINT)
.InMemoryFaultManagement()
.UnicastBus()
.MsmqTransport()
.CreateBus()
.Start();
}
public void SetUp()
{
testSender = MockRepository.GenerateStub <ISendMessages>();
messagePersister = new InMemoryPersistence();
HttpChannelReceiver = new HttpChannelReceiver(messagePersister)
{
ListenUrl = "http://localhost:8092/Gateway/",
ReturnAddress = "Gateway.Tests.Input"
};
HttpChannelReceiver.MessageReceived += httpChannel_MessageReceived;
HttpChannelReceiver.Start();
bus = Configure.With()
.DefaultBuilder()
.XmlSerializer()
.FileShareDataBus(DATABUS_DIRECTORY)
.InMemoryFaultManagement()
.UnicastBus()
.MsmqTransport()
.CreateBus()
.Start();
}
static void ShowChannelProperties(IChannelReceiver channel)
{
Console.WriteLine("Name: {0}", channel.ChannelName);
Console.WriteLine("Priority: {0}", channel.ChannelPriority);
if (channel is TcpChannel)
{
TcpChannel tcpChannel = channel as TcpChannel;
Console.WriteLine("is secured: {0}", tcpChannel.IsSecured);
}
if (channel is HttpServerChannel)
{
HttpServerChannel httpChannel = channel as HttpServerChannel;
Console.WriteLine("Scheme: {0}", httpChannel.ChannelScheme);
}
ChannelDataStore data = (ChannelDataStore)channel.ChannelData;
if (data != null)
{
foreach (string uri in data.ChannelUris)
{
Console.WriteLine("URI: " + uri);
}
}
Console.WriteLine();
}
public SoapServerFormatterSink (SoapServerFormatterSink.Protocol protocol,
IServerChannelSink nextSink,
IChannelReceiver receiver)
{
this.next_sink = nextSink;
_receiver = receiver;
}
} // NotifyProfiler
// This is a helper used by UrlObjRef's.
// Finds an http channel and returns first url for this object.
internal static String FindFirstHttpUrlForObject(String objectUri)
{
if (objectUri == null)
{
return(null);
}
RegisteredChannelList regChnlList = s_registeredChannels;
int count = regChnlList.Count;
for (int i = 0; i < count; i++)
{
if (regChnlList.IsReceiver(i))
{
IChannelReceiver chnl = (IChannelReceiver)regChnlList.GetChannel(i);
String chnlType = chnl.GetType().FullName;
if ((String.CompareOrdinal(chnlType, "System.Runtime.Remoting.Channels.Http.HttpChannel") == 0) ||
(String.CompareOrdinal(chnlType, "System.Runtime.Remoting.Channels.Http.HttpServerChannel") == 0))
{
String[] urls = chnl.GetUrlsForUri(objectUri);
if ((urls != null) && (urls.Length > 0))
{
return(urls[0]);
}
}
}
}
return(null);
} // FindFirstHttpUrlForObject
/// <include file='doc\SdlChannelSink.uex' path='docs/doc[@for="SdlChannelSinkProvider.CreateSink"]/*' />
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink nextSink = null;
if (_next != null)
nextSink = _next.CreateSink(channel);
return new SdlChannelSink(channel, nextSink);
}
IServerChannelSink IServerChannelSinkProvider.CreateSink(IChannelReceiver channel)
{
IServerChannelSink nextSink = nextProvider.CreateSink(channel);
IServerChannelSink thisSink = new InvokeOnSTAServerChannelSink(nextSink);
return(thisSink);
}
public IpcChannel(IDictionary properties,
IClientChannelSinkProvider clientSinkProvider,
IServerChannelSinkProvider serverSinkProvider)
{
if (properties != null)
{
_portName = properties ["portName"] as string;
if (properties ["name"] != null)
{
_name = properties ["name"] as string;
}
else
{
properties ["name"] = _name;
}
if (properties ["priority"] != null)
{
_priority = Convert.ToInt32(properties ["priority"]);
}
}
if (_portName != null)
{
_serverChannel = new IpcServerChannel(properties, serverSinkProvider);
}
_clientChannel = new IpcClientChannel(properties, clientSinkProvider);
}
public SoapServerFormatterSink(SoapServerFormatterSink.Protocol protocol,
IServerChannelSink nextSink,
IChannelReceiver receiver)
{
this.next_sink = nextSink;
_receiver = receiver;
}
public void SetUp()
{
HttpChannelReceiver = new HttpChannelReceiver(new InMemoryPersistence())
{
ListenUrl = "http://localhost:8092/notused",
};
bus = Configure.With()
.DefaultBuilder()
.XmlSerializer()
.FileShareDataBus("./databus_test_receiver")
.InMemoryFaultManagement()
.UnicastBus()
.MsmqTransport()
.CreateBus()
.Start();
dispatcher = new MsmqChannelDispatcher(new HttpChannelSender(), MockRepository.GenerateStub <IMessageNotifier>())
{
InputQueue = TEST_INPUT_QUEUE,
RemoteAddress = "http://localhost:8090/Gateway/"
};
dispatcher.Start();
}
public StoreService()
{
InitializeComponent();
// Ensure the event log accepts messages from this service
if (!EventLog.SourceExists(eventLog.Source))
{
EventLog.CreateEventSource(eventLog.Source, eventLog.Log);
}
_serverChannel = new IpcServerChannel(
new Hashtable
{
{ "name", IpcStore.IpcPortName },
{ "portName", IpcStore.IpcPortName },
{ "secure", true }, { "impersonate", true } // Use identity of client in server threads
},
new BinaryServerFormatterSinkProvider {
TypeFilterLevel = TypeFilterLevel.Full
} // Allow deserialization of custom types
#if !__MonoCS__
, IpcStore.IpcAcl
#endif
);
_clientChannel = new IpcClientChannel(
new Hashtable
{
{ "name", IpcStore.IpcPortName + ".Callback" }
},
new BinaryClientFormatterSinkProvider());
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink chain = next.CreateSink(channel);
GuiDispatchServerSink sink = new GuiDispatchServerSink(chain, channel);
return(sink);
}
private static void ShowChannelProperties(IChannelReceiver channel)
{
Console.WriteLine("Name: {0}", channel.ChannelName);
Console.WriteLine("Priority: {0}", channel.ChannelPriority);
if (channel is TcpChannel)
{
var tcpChannel = channel as TcpChannel;
Console.WriteLine("Is secured: {0}", tcpChannel.IsSecured);
}
if (channel is HttpServerChannel)
{
var httpServerChannel = channel as HttpServerChannel;
Console.WriteLine("Scheme: {0}", httpServerChannel.ChannelScheme);
}
var channelDataStore = channel.ChannelData as ChannelDataStore;
if (channelDataStore != null)
{
foreach (string channelUri in channelDataStore.ChannelUris)
{
Console.WriteLine("URI: {0}", channelUri);
}
}
Console.WriteLine();
}
/// <summary>
/// Creates the sink.
/// </summary>
/// <param name="channel">The channel.</param>
/// <returns></returns>
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
//create other sinks in the chain
IServerChannelSink nextSink = nextProvider.CreateSink(channel);
return(new ClientIPInjectorSink(nextSink));
}
public static void UnregisterChannel(IChannel chnl)
{
if (chnl == null)
{
throw new ArgumentNullException();
}
lock (registeredChannels.SyncRoot)
{
for (int n = 0; n < registeredChannels.Count; n++)
{
if (registeredChannels [n] == (object)chnl)
{
registeredChannels.RemoveAt(n);
IChannelReceiver chnlReceiver = chnl as IChannelReceiver;
if (chnlReceiver != null)
{
chnlReceiver.StopListening(null);
}
return;
}
}
throw new RemotingException("Channel not registered");
}
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink sink = null;
if (Next != null)
sink = Next.CreateSink(channel);
return new WebServerChannelSink(sink, channel, _webServer);
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink nextSink = null;
if (this.m_NextProvider != null)
{
nextSink = this.m_NextProvider.CreateSink(channel);
}
IPFilterChannelSink sink2 = new IPFilterChannelSink(this.m_IsAccept, nextSink);
foreach (SinkProviderData data in this.m_ProviderData)
{
string ipString = (string) data.Properties["mask"];
string str2 = (string) data.Properties["ip"];
string hostName = (string) data.Properties["machine"];
IPAddress mask = null;
IPAddress ip = null;
if (str2 != null)
{
mask = IPAddress.Parse(ipString);
ip = IPAddress.Parse(str2);
}
else
{
mask = IPAddress.Parse("255.255.255.255");
ip = Dns.Resolve(hostName).AddressList[0];
}
sink2.AddFilter(mask, ip);
}
return sink2;
}
} // GetChannelData
/// <include file='doc\SoapFormatterSinks.uex' path='docs/doc[@for="SoapServerFormatterSinkProvider.CreateSink"]/*' />
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
if (null == channel)
{
throw new ArgumentNullException("channel");
}
IServerChannelSink nextSink = null;
if (_next != null)
{
nextSink = _next.CreateSink(channel);
}
SoapServerFormatterSink.Protocol protocol =
SoapServerFormatterSink.Protocol.Other;
// see if this is an http channel
String uri = channel.GetUrlsForUri("")[0];
if (String.Compare("http", 0, uri, 0, 4, true, CultureInfo.InvariantCulture) == 0)
{
protocol = SoapServerFormatterSink.Protocol.Http;
}
SoapServerFormatterSink sink = new SoapServerFormatterSink(protocol, nextSink, channel);
sink.IncludeVersioning = _includeVersioning;
sink.StrictBinding = _strictBinding;
return(sink);
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink nextSink = null;
if (nextProvider != null)
nextSink = nextProvider.CreateSink(channel);
return new ServerAuthenticationSink(nextSink, secMgr, contexts);
}
public DistributedEnrichedMemoryCache(EnrichedMemoryCache enrichedMemoryCache,
ReleaseCacheSender sender, ReleaseCacheReceiver receiver, ILogger <DistributedEnrichedMemoryCache> logger)
{
_sender = sender;
_receiver = receiver;
_enrichedMemoryCache = enrichedMemoryCache;
_logger = logger;
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink nextSink = null;
if (_nextProvider != null)
nextSink = _nextProvider.CreateSink(channel);
return new IpFixServerChannelSink(nextSink, _eventLink);
}
public IServerChannelSink CreateSink (IChannelReceiver channel)
{
IServerChannelSink chain = _next.CreateSink(channel);
SoapServerFormatterSink sinkFormatter = new SoapServerFormatterSink(SoapServerFormatterSink.Protocol.Http, chain, channel);
sinkFormatter.SoapCore = _soapCore;
return sinkFormatter;
}
public BinaryServerFormatterSink(BinaryServerFormatterSink.Protocol protocol,
IServerChannelSink nextSink,
IChannelReceiver receiver)
{
this.protocol = protocol;
this.next_sink = nextSink;
this.receiver = receiver;
}
public HathiServerChannelSink(IServerChannelSinkProvider Provider, IChannelReceiver channel)
{
IServerChannelSink nextServer = (IServerChannelSink)new BinaryServerFormatterSink(
BinaryServerFormatterSink.Protocol.Other, this.NextChannelSink, channel);
if (channel != null) m_channel = channel;
if (Provider != null) m_Provider = Provider as HathiServerSinkProvider;
m_NextIServerChannelSink = new HathiServerChannelSink(Provider, channel, nextServer);
}
public BinaryServerFormatterSink (BinaryServerFormatterSink.Protocol protocol,
IServerChannelSink nextSink,
IChannelReceiver receiver)
{
this.protocol = protocol;
this.next_sink = nextSink;
this.receiver = receiver;
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
if (Next == null)
{
throw new InvalidOperationException("Cannot create a sink without setting the next provider.");
}
return(new ObservableServerChannelSink(_currentMessageCounter, Next.CreateSink(channel)));
}
private void Initialize(IDictionary properties, IClientChannelSinkProvider clientSinkProvider, IServerChannelSinkProvider serverSinkProvider)
{
_clientChannel = new TcpClientChannel(properties, clientSinkProvider);
if ((properties != null) && (properties["port"] != null))
{
_serverChannel = new TcpServerChannel(properties, serverSinkProvider);
}
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
// create other sinks in the chain
IServerChannelSink next = _nextProvider.CreateSink(channel);
// put our sink on top of the chain and return it
return(new CompressionServerSink(next));
}
public CustomBinaryServerFormatterSink(IServerChannelSink nextSink, IChannelReceiver receiver)
{
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
this.nextSink = nextSink;
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink chain = _next.CreateSink(channel);
SoapServerFormatterSink sinkFormatter = new SoapServerFormatterSink(SoapServerFormatterSink.Protocol.Http, chain, channel);
sinkFormatter.SoapCore = _soapCore;
return(sinkFormatter);
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
if (channel == null)
{
throw new ArgumentNullException("channel");
}
return(new CustomBinaryServerFormatterSink(nextProvider.CreateSink(channel), channel));
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink nextSink = null;
if (_nextProvider != null)
{
nextSink = _nextProvider.CreateSink(channel);
}
return new ClientAddressServerChannelSink(nextSink);
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink next = null;
if (this.m_NextProvider != null)
{
next = this.m_NextProvider.CreateSink(channel);
}
return new PrincipalServerSink(next);
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink nextSink = null;
if (this._next != null)
{
nextSink = this._next.CreateSink(channel);
}
return new SdlChannelSink(channel, nextSink) { RemoteApplicationMetadataEnabled = this._bRemoteApplicationMetadataEnabled, MetadataEnabled = this._bMetadataEnabled };
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink next = null;
if (this._nextProvider != null)
{
next = this._nextProvider.CreateSink(channel);
}
return new ClientIPServerSink(next);
}
public IpcServerChannel (string name, string portName)
{
_portName = portName;
if (IpcChannel.IsUnix)
_innerChannel = new Unix.IpcServerChannel (name, portName);
else
_innerChannel = new Win32.IpcServerChannel (name, portName);
}
public IServerChannelSink CreateSink(
IChannelReceiver channel_in
) {
return new ClientIPAddressServerSink(
this.next_.CreateSink(
channel_in
)
);
}
public EnsoExtensionServer()
{
RemotingConfiguration.Configure(Application.ExecutablePath + ".config", false);
channel = (IChannelReceiver)ChannelServices.RegisteredChannels[0];
ensoProxy = XmlRpcProxyGen.Create<IEnso>();
ensoProxy.Url = ConfigurationManager.AppSettings["ensoUrl"];
InitializeComponent();
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
if (this.Next != null)
{
var nextChannelSink = Next.CreateSink(channel);
if (nextChannelSink != null)
return new JsonServerFormatterSink(nextChannelSink);
}
return null;
}
public SoapServerFormatterSink(Protocol protocol, IServerChannelSink nextSink, IChannelReceiver receiver)
{
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
this._nextSink = nextSink;
this._protocol = protocol;
this._receiver = receiver;
}
public IServerChannelSink CreateSink(
IChannelReceiver channel_in
) {
return new CompressionServerSink(
this.next_.CreateSink(
channel_in
),
this.mustdo_
);
}
/// <summary></summary>
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink nextSink = null;
if (Next != null)
{
nextSink = Next.CreateSink(channel);
}
return new ClientIPServerSink(nextSink);
}
public IpcServerChannel (string name, string portName,
IServerChannelSinkProvider sinkProvider)
{
_portName = portName;
if (IpcChannel.IsUnix)
_innerChannel = new Unix.IpcServerChannel (name, portName, sinkProvider);
else
_innerChannel = new Win32.IpcServerChannel (name, portName, sinkProvider);
}
public IServerChannelSink CreateSink(IChannelReceiver channel)
{
IServerChannelSink nextSink = null;
if (_next != null)
nextSink = _next.CreateSink(channel);
SdlChannelSink channelSink = new SdlChannelSink(channel, nextSink);
channelSink.RemoteApplicationMetadataEnabled = _bRemoteApplicationMetadataEnabled;
channelSink.MetadataEnabled = _bMetadataEnabled;
return channelSink;
}
public IpcServerChannel (IDictionary properties,
IServerChannelSinkProvider sinkProvider)
{
if (properties != null)
_portName = properties ["portName"] as string;
if (IpcChannel.IsUnix)
_innerChannel = new Unix.IpcServerChannel (properties, sinkProvider);
else
_innerChannel = new Win32.IpcServerChannel (properties, sinkProvider);
}
