/// <summary>
/// Hosts a WAMP meta-api service describing the given realm.
/// </summary>
/// <param name="hostedRealm">The given realm.</param>
/// <returns>A disposable: disposing it will unregister the hosted meta-api service.</returns>
public static IDisposable HostMetaApiService(this IWampHostedRealm hostedRealm)
{
WampRealmDescriptorService service = new WampRealmDescriptorService(hostedRealm);
CompositeDisposable disposable =
HostDisposableService(hostedRealm, service, CalleeRegistrationInterceptor.Default);
BrokerFeatures brokerFeatures = hostedRealm.Roles.Broker.Features;
DealerFeatures dealerFeatures = hostedRealm.Roles.Dealer.Features;
brokerFeatures.SessionMetaApi = true;
brokerFeatures.SubscriptionMetaApi = true;
dealerFeatures.SessionMetaApi = true;
dealerFeatures.RegistrationMetaApi = true;
IDisposable featureDisposable = Disposable.Create(() =>
{
brokerFeatures.SessionMetaApi = null;
brokerFeatures.SubscriptionMetaApi = null;
dealerFeatures.SessionMetaApi = null;
dealerFeatures.RegistrationMetaApi = null;
});
disposable.Add(featureDisposable);
return(disposable);
}
public IBrokerProcessor Create(
IReadableChannel <ITransportConnection> incomingConnections,
IProtocolSerializerFactory protocolSerializerFactory,
IInteropContext interopContext,
BrokerFeatures features)
{
return(new BrokerProcessor(
incomingConnections,
protocolSerializerFactory,
interopContext,
features));
}
public AuthenticationHandler(
IAppLifecycleManager connectionTracker,
IProtocolImplementation protocol,
IRegistryService registryService,
BrokerFeatures features)
{
_messageFactory = protocol.MessageFactory;
_serializer = protocol.Serializer;
_connectionTracker = connectionTracker;
_registryService = registryService;
_features = features;
}
public BrokerProcessor(
IReadableChannel <ITransportConnection> incomingConnections,
IProtocolSerializerFactory serializerFactory,
IInteropContext interopContext,
BrokerFeatures features)
{
_incomingConnections = incomingConnections;
var registryService = new RegistryService(interopContext.RegistryProvider);
var protocol = new ProtocolImplementation(DefaultProtocolMessageFactory, serializerFactory);
_appLifecycleManager = interopContext.AppLifecycleManager;
_authenticationHandler = new AuthenticationHandler(interopContext.AppLifecycleManager, protocol, registryService, features);
_clientRequestHandler = new ClientRequestHandler(interopContext.AppLifecycleManager, protocol, registryService, interopContext.InvocationEventProvider, interopContext.ContextLinkageManager);
}
public Broker(BrokerOptions options, IRegistryProvider registryProvider = null)
{
_features = EnvironmentHelper.GetBrokerFeatures();
Log.Info($"Broker features: {_features}");
var trustedLauncherId = EnvironmentHelper.GetLauncherAppInstanceId();
Log.Info($"App launcher application instance id: {trustedLauncherId}");
if (_features.HasFlag(BrokerFeatures.CheckAppInstanceId) && trustedLauncherId == null)
{
throw new BrokerException($"{EnvironmentHelper.LauncherId} must be defined if {BrokerFeatures.CheckAppInstanceId} set.");
}
_workingDir = Directory.GetCurrentDirectory();
var binDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var studioDir = Path.Combine(binDir, "studio");
Log.Info("Studio dir: {0}", studioDir);
var metadataDir = Path.GetFullPath(options.MetadataDir ?? Path.Combine(_workingDir, "metadata"));
Log.Info("Metadata dir: {0}", metadataDir);
var metadataFile = Path.Combine(metadataDir, "interop.json");
IReadOnlyDictionary <string, string> staticFileMapping = new Dictionary <string, string>
{
{ "/metadata/interop", metadataFile },
{ "/studio", studioDir }
};
var webSocketTransmissionServerOptions = new WebSocketTransmissionServerOptions(_workingDir, options.Port, staticFileMapping);
var transportServers = new List <ITransportServer>
{
TransportServerFactory.Instance.Create(
TransportType.Pipe,
PipeTransmissionServerFactory.Instance.Create(_workingDir),
DefaultTransportSerializationProvider),
TransportServerFactory.Instance.Create(
TransportType.Ws,
WebSocketTransmissionServerFactory.Instance.Create(webSocketTransmissionServerOptions),
DefaultTransportSerializationProvider),
};
if (_features.HasFlag(BrokerFeatures.UseWSS))
{
var certificate = GetCertificate();
if (certificate != null)
{
var wssTransmissionServerOptions = new WebSocketTransmissionServerOptions(_workingDir, options.WssPort, staticFileMapping);
var sslProtocols = EnvironmentHelper.GetSslProtocols();
Log.Info($"{EnvironmentHelper.SslProtocols}={sslProtocols}");
transportServers.Add(TransportServerFactory.Instance.Create(
TransportType.Wss,
WebSocketTransmissionServerFactory.Instance.CreateSecure(wssTransmissionServerOptions, certificate, sslProtocols),
DefaultTransportSerializationProvider));
}
}
_transportServers = transportServers;
_connectionListener = new ServerConnectionListener(_transportServers);
registryProvider = registryProvider ?? new JsonRegistryProvider(Path.Combine(metadataDir, "interop.json"));
_interopContext = InteropContextFactory.Instance.Create(trustedLauncherId ?? default, metadataDir, registryProvider);
_brokerProcessor = BrokerProcessorFactory.Instance.Create(
_connectionListener.In,
DefaultProtocolSerializationProvider,
_interopContext,
_features);
OnStop(_connectionListener.Stop);
}
