//====================================
// ChannelReaderConsumer
//====================================
public void Consume(RawMessage message)
{
var incoming = message.AsTextMessage();
var serviceRegistered = ServiceRegistered.From(incoming);
if (serviceRegistered.IsValid && _interest.InterestedIn(serviceRegistered.Name.Value))
{
_interest.InformDiscovered(
new ServiceRegistrationInfo(serviceRegistered.Name.Value,
Location.From(serviceRegistered.Addresses)));
}
else
{
var serviceUnregistered = ServiceUnregistered.From(incoming);
if (serviceUnregistered.IsValid && _interest.InterestedIn(serviceUnregistered.Name.Value))
{
_interest.InformUnregistered(serviceUnregistered.Name.Value);
}
else
{
ManageDirectoryChannel(incoming);
}
}
}
internal bool Register(ServiceDescription service)
{
bool isRegistered = false;
lock (_catalog)
{
List <ServiceDescription> services;
if (!_catalog.TryGetValue(service.WellKnownName, out services))
{
services = new List <ServiceDescription>();
_catalog.Add(service.WellKnownName, services);
}
if (services.All(existingService => existingService.InstanceId != service.InstanceId))
{
services.Add(service);
isRegistered = true;
}
}
if (isRegistered)
{
ServiceRegistered?.Invoke(service);
}
return(isRegistered);
}
internal SshService RegisterService(string serviceName, UserAuthArgs auth = null)
{
Contract.Requires(serviceName != null);
SshService service = null;
switch (serviceName)
{
case "ssh-userauth":
if (GetService <UserAuthService>() == null)
{
service = new UserAuthService(this);
}
break;
case "ssh-connection":
if (auth != null && GetService <ConnectionService>() == null)
{
service = new ConnectionService(this, auth);
}
break;
}
if (service != null)
{
ServiceRegistered?.Invoke(this, service);
_services.Add(service);
}
return(service);
}
/// <summary>
/// Register a service to this provider.
/// </summary>
/// <typeparam name="T">The type of the service.</typeparam>
/// <param name="service">The service instance.</param>
public void RegisterService <T>(T service)
{
if (_registeredServices.ContainsKey(typeof(T)))
{
return;
}
_registeredServices.Add(typeof(T), service);
ServiceRegistered?.Invoke();
}
public void Register(InvokableServiceContext invokableServiceContext)
{
lock (synchronization) {
if (serviceContextsByGuid.TryAdd(invokableServiceContext.Guid, invokableServiceContext))
{
ServiceRegistered?.Invoke(invokableServiceContext);
}
}
}
private void PublishService(string name)
{
var addresses = new List <Address>();
foreach (var attribute in _attributesClient.AllOf(name))
{
addresses.Add(Vlingo.Wire.Node.Address.From(attribute.ToStringValue(), AddressType.Main));
}
_publisher.Send(RawMessage.From(0, 0, ServiceRegistered.As(Named(_serviceNamePrefix, name), addresses).ToString()));
}
public void TestValidity()
{
var registerService = new ServiceRegistered(Name.Of("test-service"),
new[]
{
Address.From(Host.Of("1.2.3.4"), 111, AddressType.Main),
Address.From(Host.Of("1.2.3.45"), 222, AddressType.Main),
});
Assert.True(registerService.IsValid);
Assert.False(ServiceRegistered.From("blah").IsValid);
Assert.True(ServiceRegistered.From(_textMessage).IsValid);
}
public void TestMessage()
{
var registerService = new ServiceRegistered(Name.Of("test-service"),
new[]
{
Address.From(Host.Of("1.2.3.4"), 111, AddressType.Main),
Address.From(Host.Of("1.2.3.45"), 222, AddressType.Main),
});
Assert.Equal(2, registerService.Addresses.Count());
Assert.Equal(_textMessage, registerService.ToString());
}
/// <inheritdoc/>
public void RegisterService(object service)
{
if (service == null)
{
throw new ArgumentNullException(nameof(service));
}
if (services.Any(x => x.GetType() == service.GetType()))
{
throw new InvalidOperationException("A service of the same type has already been registered.");
}
services.Add(service);
ServiceRegistered?.Invoke(this, new ServiceRegistrationEventArgs(service));
}
private static void AddServiceRegistration(IServiceCollection services, IRpcServiceRegistration registration, Action <RpcServerOptions>?configureOptions)
{
// Could have been added as transient, since it's only used once during initialization. However,
// that would cause a factory delegate to be kept in memory, which probably consumes as much memory as
// the RpcServiceRegistration instance.
services.AddSingleton(registration);
// Avoid getting service types unless someone is interested in the registered services
// Enumerating services may be slow.
if (configureOptions != null)
{
foreach (var registeredType in registration.GetServiceTypes(RpcServiceDefinitionSide.Server))
{
List <RpcServiceInfo> allServices = RpcBuilderUtil.GetAllServices(registeredType.ServiceType, RpcServiceDefinitionSide.Server, true);
foreach (var rpcService in allServices)
{
var configOptionsMethod = ConfigureOptionsMethod.MakeGenericMethod(rpcService.Type);
configOptionsMethod.Invoke(null, new object[] { services, configureOptions });
ServiceRegistered?.Invoke(null, new ServiceRegistrationEventArgs(services, rpcService.Type));
}
}
}
}
internal static void NotifyServiceRegistered <TService>(IServiceCollection services)
{
ServiceRegistered?.Invoke(null, new ServiceRegistrationEventArgs(services, typeof(TService)));
}
