private void ReloadNodesIfNeeded()
{
var config = GetConfig();
if (_lastConfig != config)
{
lock (_updateLocker)
{
if (_lastConfig != config)
{
if (!config.Services.TryGetValue(_serviceName, out var serviceConfig))
{
serviceConfig = new ServiceDiscoveryConfig();
}
var newNodes = (serviceConfig.Hosts ?? string.Empty).Replace("\r", "").Replace("\n", "").Split(',')
.Select(_ => _.Trim()).Where(_ => !string.IsNullOrEmpty(_)).OrderBy(k => k).Select(_ => CreateNode(_, serviceConfig)).ToArray();
if (_nodes == null || !_nodes.SequenceEqual(newNodes))
{
_nodes = newNodes;
Log.Debug(_ => _("Loaded nodes from config.", unencryptedTags: new
{
configPath = $"Discovery.{_serviceName}.Hosts",
serviceName = _serviceName,
nodes = string.Join(",", _nodes.Select(n => n.ToString()))
}));
}
_lastConfig = config;
}
}
}
}
internal void Reload(DiscoveryConfig config)
{
Reload(new List <DiscoveryConfig>()
{
config
});
}
public async Task Setup()
{
IDiscovery discovery = Substitute.For <IDiscovery>();
_discoveryConfig = new DiscoveryConfig {
Services = new ServiceDiscoveryCollection(new Dictionary <string, ServiceDiscoveryConfig>(), new ServiceDiscoveryConfig(), new PortAllocationConfig())
};
Dictionary <string, string> configDic = new Dictionary <string, string>();
_currentEnvironment = Prod;
var environment = Substitute.For <IEnvironment>();
environment.DeploymentEnvironment.Returns(_ => _currentEnvironment);
_unitTestingKernel = new TestingKernel <ConsoleLog>(mockConfig: configDic);
_unitTestingKernel.Rebind <IEnvironment>().ToConstant(environment);
_unitTestingKernel.Rebind <IDiscovery>().ToConstant(discovery);
_unitTestingKernel.Rebind <Func <DiscoveryConfig> >().ToMethod(_ => () => _discoveryConfig);
_loadBalancerByEnvironment = new Dictionary <string, ILoadBalancer>();
_loadBalancerByEnvironment.Add(Prod, new MasterLoadBalancer());
_loadBalancerByEnvironment.Add(Staging, new StagingLoadBalancer());
_loadBalancerByEnvironment.Add(Canary, new PreferredEnvironmentLoadBalancer());
discovery.CreateLoadBalancer(Arg.Any <DeploymentIdentifier>(), Arg.Any <ReachabilityCheck>(), TrafficRoutingStrategy.RandomByRequestID)
.ReturnsForAnyArgs(c => _loadBalancerByEnvironment[c.Arg <DeploymentIdentifier>().DeploymentEnvironment]);
_serviceDiscovery = _unitTestingKernel.Get <Func <string, ReachabilityCheck, IMultiEnvironmentServiceDiscovery> >()(ServiceName, (x, y) => new Task(null));
TracingContext.SetPreferredEnvironment(null);
}
public void Initialize()
{
NetworkNodeDecoder.Init();
var privateKey = new PrivateKey(TestPrivateKeyHex);
_publicKey = privateKey.PublicKey;
var logManager = NullLogManager.Instance;
IDiscoveryConfig discoveryConfig = new DiscoveryConfig();
discoveryConfig.PongTimeout = 100;
IStatsConfig statsConfig = new StatsConfig();
_messageSender = Substitute.For <IMessageSender>();
var calculator = new NodeDistanceCalculator(discoveryConfig);
_nodeTable = new NodeTable(calculator, discoveryConfig, logManager);
_nodeTable.Initialize(TestItem.PublicKeyA);
_timestamp = new Timestamp();
var evictionManager = new EvictionManager(_nodeTable, logManager);
var lifecycleFactory = new NodeLifecycleManagerFactory(_nodeTable, new DiscoveryMessageFactory(_timestamp), evictionManager, new NodeStatsManager(statsConfig, logManager), discoveryConfig, logManager);
_nodes = new[] { new Node("192.168.1.18", 1), new Node("192.168.1.19", 2) };
IFullDb nodeDb = new SimpleFilePublicKeyDb("test_db", logManager);
_discoveryManager = new DiscoveryManager(lifecycleFactory, _nodeTable, new NetworkStorage(nodeDb, logManager), discoveryConfig, logManager);
_discoveryManager.MessageSender = _messageSender;
}
public void Initialize()
{
NetworkNodeDecoder.Init();
var privateKey = new PrivateKey(TestPrivateKeyHex);
_publicKey = privateKey.PublicKey;
var logManager = LimboLogs.Instance;
IDiscoveryConfig discoveryConfig = new DiscoveryConfig();
discoveryConfig.PongTimeout = 100;
_messageSender = Substitute.For <IMessageSender>();
var calculator = new NodeDistanceCalculator(discoveryConfig);
_networkConfig.ExternalIp = "99.10.10.66";
_networkConfig.LocalIp = "10.0.0.5";
_nodeTable = new NodeTable(calculator, discoveryConfig, _networkConfig, logManager);
_nodeTable.Initialize(TestItem.PublicKeyA);
_timestamper = Timestamper.Default;
_ipResolver = new IPResolver(_networkConfig, logManager);
var evictionManager = new EvictionManager(_nodeTable, logManager);
var lifecycleFactory = new NodeLifecycleManagerFactory(_nodeTable, new DiscoveryMessageFactory(_timestamper), evictionManager, new NodeStatsManager(logManager), discoveryConfig, logManager);
_nodes = new[] { new Node("192.168.1.18", 1), new Node("192.168.1.19", 2) };
IFullDb nodeDb = new SimpleFilePublicKeyDb("Test", "test_db", logManager);
_discoveryManager = new DiscoveryManager(lifecycleFactory, _nodeTable, new NetworkStorage(nodeDb, logManager), discoveryConfig, logManager, _ipResolver);
_discoveryManager.MessageSender = _messageSender;
}
public void TestRegisterServiceChangeListener()
{
DiscoveryConfig discoveryConfig = Constants.NewDiscoveryConfig();
_serviceRepository.RegisterServiceChangeListener(discoveryConfig, new DefaultServiceChangeListener());
Assert.IsTrue(_serviceRepository.ContainsService(discoveryConfig.ServiceId));
}
public void Initialize()
{
NetworkNodeDecoder.Init();
PrivateKey privateKey = new(TestPrivateKeyHex);
_publicKey = privateKey.PublicKey;
LimboLogs?logManager = LimboLogs.Instance;
IDiscoveryConfig discoveryConfig = new DiscoveryConfig();
discoveryConfig.PongTimeout = 100;
_msgSender = Substitute.For <IMsgSender>();
NodeDistanceCalculator calculator = new(discoveryConfig);
_networkConfig.ExternalIp = "99.10.10.66";
_networkConfig.LocalIp = "10.0.0.5";
_nodeTable = new NodeTable(calculator, discoveryConfig, _networkConfig, logManager);
_nodeTable.Initialize(TestItem.PublicKeyA);
EvictionManager evictionManager = new(_nodeTable, logManager);
ITimerFactory timerFactory = Substitute.For <ITimerFactory>();
NodeLifecycleManagerFactory lifecycleFactory = new(_nodeTable, evictionManager,
new NodeStatsManager(timerFactory, logManager), new NodeRecord(), discoveryConfig, Timestamper.Default, logManager);
_nodes = new[] { new Node(TestItem.PublicKeyA, "192.168.1.18", 1), new Node(TestItem.PublicKeyB, "192.168.1.19", 2) };
IFullDb nodeDb = new SimpleFilePublicKeyDb("Test", "test_db", logManager);
_discoveryManager = new DiscoveryManager(lifecycleFactory, _nodeTable, new NetworkStorage(nodeDb, logManager), discoveryConfig, logManager);
_discoveryManager.MsgSender = _msgSender;
}
public void TestRegisterServiceChangeListener()
{
Dictionary <String, DefaultServiceChangeListener> registerServices = new Dictionary <string, DefaultServiceChangeListener>();
string serviceId = Constants.NewServiceId();
registerServices.Add("framework.soa.v1.registryservice", new DefaultServiceChangeListener());
registerServices.Add("framework.soa.testservice.v2.testservice", new DefaultServiceChangeListener());
registerServices.Add("framework.soa.test.v1.testportal", new DefaultServiceChangeListener());
registerServices.Add(serviceId, new DefaultServiceChangeListener());
foreach (string key in registerServices.Keys)
{
DiscoveryConfig discoveryConfig = new DiscoveryConfig()
{
ServiceId = key
};
_discoveryClientImpl.RegisterServiceChangeListener(discoveryConfig, registerServices[key]);
}
foreach (string key in registerServices.Keys)
{
List <ServiceChangeEvent> serviceChangeEvents = registerServices[key].ServiceChangeEvents;
Assert.AreEqual(0, serviceChangeEvents.Count);
}
}
public void testSubscribe()
{
ServiceRepository serviceRepository = new ServiceRepository(Constants.DiscoveryClientConfig);
String serviceId = Constants.NewServiceId();
DiscoveryConfig discoveryConfig = new DiscoveryConfig()
{
ServiceId = serviceId
};
Instance[] instances = new Instance[]
{
Constants.NewInstance(serviceId),
Constants.NewInstance(serviceId)
};
CustomServiceChangeListener customServiceChangeListener = new CustomServiceChangeListener();
serviceRepository.RegisterServiceChangeListener(discoveryConfig, customServiceChangeListener);
Threads.Sleep(2000); // wait service discovery websocket session created.
InstanceRepository instanceRepository = new InstanceRepository(Constants.RegistryClientConfig);
instanceRepository.Register(instances);
Assert.IsTrue(customServiceChangeListener.AwaitAdd(2, 5000));
instanceRepository.Unregister(instances);
Assert.IsTrue(customServiceChangeListener.AwaitDelete(2, 5000));
Assert.IsTrue(2 * instances.Length <= customServiceChangeListener.ServiceChangeEvents.Count);
}
public void TestReload()
{
ServiceRepository serviceRepository = new ServiceRepository(Constants.DiscoveryClientConfig);
List <Service> services = new List <Service>();
Assert.AreEqual(0, services.Count);
HashSet <String> serviceKeys = new HashSet <String>()
{
Constants.RegistryServiceKey, Constants.JavaRegistryServiceKey
};
Dictionary <String, ServiceChangeListener> serviceChangeListeners = new Dictionary <string, ServiceChangeListener>();
foreach (String serviceKey in serviceKeys)
{
DefaultServiceChangeListener listener = new DefaultServiceChangeListener();
DiscoveryConfig discoveryConfig = new DiscoveryConfig()
{
ServiceId = serviceKey
};
serviceChangeListeners.Add(serviceKey, listener);
serviceRepository.RegisterServiceChangeListener(discoveryConfig, listener);
serviceRepository._serviceDiscovery.Reload(discoveryConfig);
Threads.Sleep(100);
Assert.IsTrue(listener.ServiceChangeEvents.Count >= 1);
foreach (ServiceChangeEvent e in listener.ServiceChangeEvents)
{
Assert.AreEqual(InstanceChange.CHANGE_TYPE.RELOAD, e.ChangeType);
Assert.AreEqual(serviceKey, e.ChangedService.ServiceId);
}
}
}
public void SetUp()
{
_networkConfig = new NetworkConfig();
_discoveryConfig = new DiscoveryConfig();
_statsManager = Substitute.For <INodeStatsManager>();
_peerStorage = Substitute.For <INetworkStorage>();
_loader = new PeerLoader(_networkConfig, _discoveryConfig, _statsManager, _peerStorage, LimboLogs.Instance);
}
public ServicesConfig()
{
MqttConfig = new MqttConfig();
IoTConfig = new IoTConfig();
DiscoveryConfig = new DiscoveryConfig();
ScriptEngineConfig = new ScriptEngineConfig();
PluginsConfig = new PluginsConfig();
}
public void TestGetService()
{
DiscoveryConfig discoveryConfig = Constants.NewDiscoveryConfig();
string serviceId = discoveryConfig.ServiceId;
Service service = _serviceRepository.GetService(discoveryConfig);
Assert.AreEqual(serviceId, service.ServiceId);
Assert.IsTrue(_serviceRepository.ContainsService(serviceId));
}
public DiscoveryCommand(ILogger <DiscoveryCommand> log,
IAuthentication authentication,
Func <DiscoveryRequest, IMessageDiscovery> discoveryFactory,
DiscoveryConfig config)
{
this.log = log ?? throw new ArgumentNullException(nameof(log));
this.discoveryFactory = discoveryFactory ?? throw new ArgumentNullException(nameof(discoveryFactory));
this.config = config ?? throw new ArgumentNullException(nameof(config));
auth = authentication ?? throw new ArgumentNullException(nameof(authentication));
}
public DiscoveryService(ILogger <DiscoveryService> logger, NeonConfig neonConfig, ISchedulerService schedulerService, List <DiscoveryListenerData> discoveryListeners, INeonManager neonManager)
{
_neonManager = neonManager;
_uuid = neonConfig.EngineConfig.Uuid;
_discoveryListeners = discoveryListeners;
_discoveryConfig = neonConfig.ServicesConfig.DiscoveryConfig;
_schedulerService = schedulerService;
_logger = logger;
DiscoveredDevices = new ObservableCollection <DiscoveryDevice>();
}
public void TestGetService()
{
DiscoveryConfig discoveryConfig = new DiscoveryConfig()
{
ServiceId = Constants.NewServiceId()
};
Service service = _discoveryClientImpl.GetService(discoveryConfig);
Assert.AreEqual(discoveryConfig.ServiceId, service.ServiceId);
}
private async Task SetConfigHosts(string hosts)
{
_discoveryConfig = new DiscoveryConfig {
Services = new ServiceDiscoveryCollection(new Dictionary <string, ServiceDiscoveryConfig>(), new ServiceDiscoveryConfig(), new PortAllocationConfig())
};
if (hosts != null)
{
_discoveryConfig.Services[ServiceName].Hosts = hosts;
}
}
public ServiceContext(DiscoveryConfig discoveryConfig)
{
Preconditions.CheckArgument(discoveryConfig != null, "discoveryConfig");
Preconditions.CheckArgument(!string.IsNullOrWhiteSpace(discoveryConfig.ServiceId), "serviceId");
_discoveryConfig = discoveryConfig;
_serviceId = discoveryConfig.ServiceId.ToLower();
_listeners = new HashSet <ServiceChangeListener>();
_service = new Service()
{
ServiceId = discoveryConfig.ServiceId
};
}
/// <summary>
/// Convert back to service model
/// </summary>
/// <returns></returns>
public SupervisorUpdateModel ToServiceModel()
{
return(new SupervisorUpdateModel {
SiteId = SiteId,
LogLevel = LogLevel,
Discovery = Discovery,
DiscoveryConfig = DiscoveryConfig?.ToServiceModel(),
DiscoveryCallbacks = DiscoveryCallbacks?
.Select(c => c.ToServiceModel()).ToList(),
RemoveDiscoveryCallbacks = RemoveDiscoveryCallbacks
});
}
private async Task ReloadRemoteHost(DiscoveryConfig newConfig)
{
var newServiceConfig = newConfig.Services[_serviceName];
lock (_locker)
{
if (newServiceConfig.Equals(LastServiceConfig) &&
newConfig.EnvironmentFallbackEnabled == LastConfig.EnvironmentFallbackEnabled &&
newConfig.EnvironmentFallbackTarget == LastConfig.EnvironmentFallbackTarget)
{
return;
}
}
var originatingSource = await GetDiscoverySource(_originatingDeployment, newServiceConfig).ConfigureAwait(false);
var fallbackTarget = newConfig.EnvironmentFallbackTarget ?? DefaultEnvironmentFallbackTarget;
var masterDeployment = new DeploymentIdentifier(_serviceName, fallbackTarget, _environment);
var shouldCreateMasterPool = newConfig.EnvironmentFallbackEnabled &&
newServiceConfig.Scope == ServiceScope.Environment &&
originatingSource.SupportsFallback &&
_originatingDeployment.Equals(masterDeployment) == false;
IServiceDiscoverySource masterSource = null;
if (shouldCreateMasterPool)
{
masterSource = await GetDiscoverySource(masterDeployment, newServiceConfig).ConfigureAwait(false);
}
lock (_locker)
{
_suppressNotifications = true;
LastConfig = newConfig;
LastServiceConfig = newServiceConfig;
RemoveOriginatingPool();
OriginatingEnvironmentPool = CreatePool(_originatingDeployment, _originatingEnvironmentLinks, originatingSource);
RemoveMasterPool();
if (masterSource != null)
{
MasterEnvironmentPool = CreatePool(masterDeployment, _masterEnvironmentLinks, masterSource);
}
_suppressNotifications = false;
GetRelevantPool();
}
}
private static String get(DiscoveryConfig config, String key)
{
if (config == null)
{
return(null);
}
if (config.DiscoveryData == null)
{
return(null);
}
return(config.DiscoveryData[key]);
}
/// <summary>
/// Convert back to service model
/// </summary>
/// <returns></returns>
public SupervisorModel ToServiceModel()
{
return(new SupervisorModel {
Id = Id,
SiteId = SiteId,
LogLevel = LogLevel,
Discovery = Discovery,
Certificate = Certificate,
DiscoveryConfig = DiscoveryConfig?.ToServiceModel(),
OutOfSync = OutOfSync,
Connected = Connected
});
}
public void Setup()
{
_dateTimeFake = new DateTimeFake();
_createdNodeSources = new List <Type>();
SetupConsulNodeSource();
SetupSlowNodeSource();
_discoveryConfig = new DiscoveryConfig();
_discoveryConfig.Services = new ServiceDiscoveryCollection(new Dictionary <string, ServiceDiscoveryConfig>(), new ServiceDiscoveryConfig(), new PortAllocationConfig());
_discovery = _kernel.Get <IDiscovery>();
_deploymentIdentifier = new DeploymentIdentifier(ServiceName, Env, Substitute.For <IEnvironment>());
}
public Service GetService(DiscoveryConfig discoveryConfig)
{
Preconditions.CheckArgument(discoveryConfig != null, "discoveryConfig");
List <Service> services = GetServices(new List <DiscoveryConfig>()
{
discoveryConfig
});
if (services.Count > 0)
{
return(services[0]);
}
throw new Exception("not found any service by discoveyConfig:" + discoveryConfig);
}
public SystemPeersDiscoveryService(ILogger logger, ICluster cluster, DiscoveryConfig config)
{
IDataMapperFactory mapper = new PocoDataMapperFactory();
_peerFactory = mapper.Create <DiscoveredPeer>();
_logger = logger;
_cluster = cluster;
_timer = new Timer(config.Interval * 1000);
_timer.Elapsed += (s, e) => TryDiscover();
_timer.AutoReset = true;
_timer.Start();
TryDiscover();
}
private static void set(DiscoveryConfig config, String key, String value)
{
Preconditions.NotNull(config, "config");
Preconditions.NotNull(key, "key");
Preconditions.NotNullOrWhiteSpace(value, "value");
Dictionary <string, string> data = config.DiscoveryData;
if (data == null)
{
data = new Dictionary <string, string>();
config.DiscoveryData = data;
}
data[key] = value;
}
internal void Reload(List <DiscoveryConfig> configs)
{
try
{
if (Conditions.IsNullOrEmpty(configs))
{
return;
}
_log.Info("start reload services.");
List <Service> services = _discoveryHttpClient.GetServices(configs);
DiscoveryConfig config = new DiscoveryConfig();
foreach (Service service in services)
{
if (service == null)
{
continue;
}
string serviceId = service.ServiceId;
if (string.IsNullOrWhiteSpace(serviceId))
{
continue;
}
OnServiceChange(service);
_reloadFailedDiscoveryConfigs.TryRemove(serviceId.ToLower(), out config);
}
_lastUpdateTime = DateTimeUtils.CurrentTimeInMilliseconds;
_log.Info("end reload services");
}
catch (Exception e)
{
foreach (DiscoveryConfig config in configs)
{
if (config == null)
{
continue;
}
string serviceId = config.ServiceId;
if (string.IsNullOrWhiteSpace(serviceId))
{
continue;
}
_reloadFailedDiscoveryConfigs[serviceId.ToLower()] = config;
}
throw e;
}
}
private async Task ReloadRemoteHost(DiscoveryConfig newConfig)
{
var newServiceConfig = newConfig.Services[_serviceName];
lock (_locker)
{
if (newServiceConfig.Equals(LastConfig))
{
return;
}
}
var shouldCreateMasterPool = newConfig.EnvironmentFallbackEnabled &&
newServiceConfig.SupportsFallback &&
_originatingDeployment.Equals(_masterDeployment) == false;
ServiceDiscoverySourceBase masterSource = null;
var originatingSource = await GetServiceDiscoverySource(_originatingDeployment, newServiceConfig).ConfigureAwait(false);
if (shouldCreateMasterPool)
{
masterSource = await GetServiceDiscoverySource(_masterDeployment, newServiceConfig).ConfigureAwait(false);
}
lock (_locker)
{
_suppressNotifications = true;
LastConfig = newServiceConfig;
RemoveOriginatingPool();
OriginatingEnvironmentPool = CreatePool(_originatingDeployment, _originatingEnvironmentLinks, originatingSource);
RemoveMasterPool();
if (masterSource != null)
{
MasterEnvironmentPool = CreatePool(_masterDeployment, _masterEnvironmentLinks, masterSource);
}
_suppressNotifications = false;
GetRelevantPool();
}
}
public void TestUpdate_Service()
{
for (int i = 0; i < 5; i++)
{
DiscoveryConfig discoveryConfig = Constants.NewDiscoveryConfig();
string serviceId = discoveryConfig.ServiceId;
DefaultServiceChangeListener listener = new DefaultServiceChangeListener();
_serviceRepository.RegisterServiceChangeListener(discoveryConfig, listener);
Assert.IsTrue(_serviceRepository.ContainsService(serviceId));
Service service1 = new Service()
{
ServiceId = serviceId,
Instances = new List <Instance>()
{
Constants.NewInstance(serviceId)
}
};
Service service2 = new Service()
{
ServiceId = serviceId,
Instances = new List <Instance>()
{
Constants.NewInstance(serviceId), Constants.NewInstance(serviceId)
}
};
_serviceRepository.Update(service1);
_serviceRepository.Update(service2);
_serviceRepository.Update(new Service()
{
ServiceId = serviceId + "1"
});
Threads.Sleep(100);
Assert.AreEqual(2, listener.ServiceChangeEvents.Count);
foreach (ServiceChangeEvent e in listener.ServiceChangeEvents)
{
Assert.AreEqual(InstanceChange.CHANGE_TYPE.RELOAD, e.ChangeType);
}
}
}
public Service GetService(DiscoveryConfig discoveryConfig)
{
if (discoveryConfig == null)
{
return(new Service());
}
string serviceId = discoveryConfig.ServiceId;
if (string.IsNullOrWhiteSpace(serviceId))
{
return(new Service());
}
if (!this.ContainsService(serviceId))
{
RegisterService(discoveryConfig);
}
return(_services[serviceId.ToLower()].newService());
}
