public void ImportSettings(string filename)
{
var jsonText = File.ReadAllText(filename);
var newSettings = PartialObject <BindableSettings> .Create(jsonText);
// Todo: This probably isn't the best way of doing this
// - should probably have some method of denoting if a setting is importable, then it should run automatically
newSettings.MergeItem((BindableSettings x) => x.RefreshInterval, _settings);
// Note: This is a little hacky but I'm not sure how to trigger a refresh on the binding when replacing the entire list
var servers = new Servers();
newSettings.MergeItem(x => x.Servers, ref servers);
if (servers.Any())
{
_settings.Servers.Clear();
//_settings.CurrentServer = 0; Deprecated
foreach (var server in servers)
{
_settings.Servers.Add(server);
}
}
}
private IEnumerable <TestVariant> Build()
{
if (!Servers.Any())
{
throw new ArgumentException("No servers were specified.");
}
// TFMs.
if (!Tfms.Any())
{
throw new ArgumentException("No TFMs were specified.");
}
ResolveDefaultArchitecture();
if (!ApplicationTypes.Any())
{
ApplicationTypes.Add(ApplicationType.Portable);
}
if (!HostingModels.Any())
{
HostingModels.Add(HostingModel.OutOfProcess);
}
var variants = new List <TestVariant>();
VaryByServer(variants);
CheckForSkips(variants);
return(variants);
}
public Server(string name, string fileName, bool autoReload, PSHost host, int port, bool https)
{
if (string.IsNullOrEmpty(name))
{
Name = $"Dashboard{_lastId}";
_lastId++;
}
else
{
Name = name;
}
FileName = fileName;
Port = port;
_reloadKey = Guid.NewGuid().ToString();
if (_reloader == null)
{
_reloader = new AutoReloader(host);
}
if (autoReload)
{
_reloader.StartWatchingFile(fileName, Port, _reloadKey, https);
}
if (Servers.Any(m => m.Name.Equals(Name, StringComparison.OrdinalIgnoreCase)))
{
throw new Exception($"Server with name {Name} already exists.");
}
}
void SetSelectedEnvironment()
{
if (_bindToActiveEnvironment)
{
if (_mainViewModel == null)
{
return;
}
var server = Servers.FirstOrDefault(c => c.EnvironmentModel.IsLocalHost);
if (server == null)
{
return;
}
_selectedServerIndex = Servers.IndexOf(server);
SelectedServer = server;
_connectControlSingleton.Refresh(server.EnvironmentModel.ID);
_mainViewModel.SetActiveEnvironment(server.EnvironmentModel);
}
else
{
if (SelectedServer == null && Servers.Any())
{
var selectedServerIndex = Servers.ToList().FindIndex(c => c.EnvironmentModel.IsLocalHost);
if (selectedServerIndex >= 0)
{
SelectedServerIndex = selectedServerIndex;
}
}
}
}
protected async Task <(RavenServer, Dictionary <RavenServer, ProxyServer>)> CreateRaftClusterWithProxiesAndGetLeader(int numberOfNodes, bool shouldRunInMemory = true, int?leaderIndex = null, bool useSsl = false, int delay = 0)
{
leaderIndex = leaderIndex ?? _random.Next(0, numberOfNodes);
RavenServer leader = null;
var serversToPorts = new Dictionary <RavenServer, string>();
var serversToProxies = new Dictionary <RavenServer, ProxyServer>();
for (var i = 0; i < numberOfNodes; i++)
{
string serverUrl;
var customSettings = GetServerSettingsForPort(useSsl, out serverUrl);
int proxyPort = 10000;
var co = new ServerCreationOptions
{
CustomSettings = customSettings,
RunInMemory = shouldRunInMemory,
RegisterForDisposal = false
};
var server = GetNewServer(co);
var proxy = new ProxyServer(ref proxyPort, Convert.ToInt32(server.ServerStore.GetNodeHttpServerUrl()), delay);
serversToProxies.Add(server, proxy);
if (Servers.Any(s => s.WebUrl.Equals(server.WebUrl, StringComparison.OrdinalIgnoreCase)) == false)
{
Servers.Add(server);
}
serversToPorts.Add(server, serverUrl);
if (i == leaderIndex)
{
server.ServerStore.EnsureNotPassive();
leader = server;
}
}
for (var i = 0; i < numberOfNodes; i++)
{
if (i == leaderIndex)
{
continue;
}
var follower = Servers[i];
// ReSharper disable once PossibleNullReferenceException
await leader.ServerStore.AddNodeToClusterAsync(serversToPorts[follower]);
await follower.ServerStore.WaitForTopology(Leader.TopologyModification.Voter);
}
// ReSharper disable once PossibleNullReferenceException
var condition = await leader.ServerStore.WaitForState(RachisState.Leader, CancellationToken.None).WaitAsync(numberOfNodes * _electionTimeoutInMs * 5);
var states = string.Empty;
if (condition == false)
{
states = GetLastStatesFromAllServersOrderedByTime();
}
Assert.True(condition, "The leader has changed while waiting for cluster to become stable. All nodes status: " + states);
return(leader, serversToProxies);
}
private void Regist(string aAddress, int aPort)
{
if (Servers.Any(p => p.Key == aAddress && p.Value == aPort))
{
return;
}
Servers.Add(new KeyValuePair <string, int>(aAddress, aPort));
Host.Logger.WriteLine("Added server {0}:{1}.", aAddress, aPort);
}
public void AddGtaServers()
{
if (Servers.Any(server => server.ServerIp == "164.132.200.53" || server.ServerIp == "164.132.202.63" || server.ServerIp == "TS.grandtheftarma.com:9987"))
{
return;
}
Servers.Add(new ServersModel()
{
ContentButton = "Join Server",
IsJoinButtonEnabled = false,
ServerInfo = "Loading...",
ServerInfoToolTip = @"Server Address: 164.132.200.53
Server Query Port: 2302",
ServerIp = "164.132.200.53",
ServerQueryPort = "2302"
});
Servers.Add(new ServersModel()
{
ContentButton = "Join Server",
IsJoinButtonEnabled = false,
ServerInfo = "Loading...",
ServerInfoToolTip = @"Server Address: 164.132.202.63
Server Query Port: 2302",
ServerIp = "164.132.202.63",
ServerQueryPort = "2302"
});
Servers.Add(new ServersModel()
{
ContentButton = "Join TeamSpeak",
IsJoinButtonEnabled = false,
JoinServerToolTip = $@"Join: {_tsViewModel.TsChannelNameText}
Password: {_tsViewModel.TsChannelPasswordText}",
ServerInfo = "Loading...",
ServerInfoToolTip = @"Server Address: TS.grandtheftarma.com:9987
TeamSpeak Selector: #ipsLayout_sidebar > div > ul > li:nth-child(2) > div > div:nth-child(3) > span
TeamSpeak Selector URL: http://grandtheftarma.com/",
ServerIp = "TS.grandtheftarma.com:9987",
TsSelector = "#ipsLayout_sidebar > div > ul > li:nth-child(2) > div > div:nth-child(3) > span",
TsSelectorUrl = "http://grandtheftarma.com/"
});
}
void Configure(IServer server)
{
server.OnStarted += (s, e) => {
Logger.WriteLine("Server '" + ((Server.Server)s).Name + "' started");
AnyRunning = true;
EventHandlerExtensions.Invoke(OnServerStarted, this, new ServerStartedEventArgs((Server.Server)s));
};
server.OnStopped += (s, e) => {
Logger.WriteLine("Server '" + ((Server.Server)s).Name + "' stopped");
AnyRunning = Servers.Any(x => x.Running);
EventHandlerExtensions.Invoke(OnServerStopped, this, new ServerStoppedEventArgs((Server.Server)s));
};
server.OnClientRequestingConnection += (s, e) => EventHandlerExtensions.Invoke(OnClientRequestingConnection, this, e);
}
public T RunCommand <T>(Func <PrincipalContext, T> command, int retries = 3)
{
if (Servers != null && Servers.Any())
{
foreach (var s in Servers) // try all servers in order, the first success will win
{
try
{
using (var pc = UserAuth
? new PrincipalContext(ContextType.Domain, s, AuthUser, AuthPassword)
: new PrincipalContext(ContextType.Domain, s))
return(command(pc));
}
catch (Exception ex)
{
Current.LogException("Couldn't contact AD server: " + s, ex);
}
}
Current.LogException(new SecurityException("Couldn't read any configured Active Directory servers."));
}
else
{
// try the current domain
try
{
using (var pc = new PrincipalContext(ContextType.Domain))
return(command(pc));
}
catch (Exception ex)
{
if (retries > 0)
{
Thread.Sleep(1000);
RunCommand(command, retries - 1);
}
else
{
Current.LogException("Couldn't contact current AD", ex);
}
}
}
return(default(T));
}
public async Task <bool> JoinServer(Invite invite)
{
try
{
if (Servers.Any(s => s.Id == invite.Server.Id))
{
// Already joined the server
return(true);
}
await invite.Accept();
return(true);
}
catch (Exception ex)
{
TShock.Log.ConsoleError(ex.Message);
TShock.Log.Error(ex.ToString());
return(false);
}
}
private async void AddServer(object param)
{
if (param == null ||
string.IsNullOrEmpty(param.ToString()))
{
return;
}
var serverName = param.ToString();
if (Servers.Any(s => s.Name.Equals(serverName)))
{
ShowMessage(new Message {
MessageType = MessageType.Info, Text = $"A server with the name {serverName} already exists."
});
return;
}
try
{
IsLoading = true;
var server = new Server {
Name = serverName
};
await serverService.SaveServer(server);
Servers.Add(server);
}
catch (Exception ex)
{
ShowMessage(new Message {
MessageType = MessageType.Error, Text = ex.Message
});
}
finally
{
IsLoading = false;
}
}
public void Init(string notificationSettingsString)
{
var dict = ParseValue(notificationSettingsString);
if (!dict.TryGetValue("groupid", out var _groupId))
{
throw new ArgumentException($"Не указан groupid для подключения к Kafka", "groupid");
}
GroupId = _groupId;
dict.TryGetValue("clientid", out var _clientId);
ClientId = _clientId;
string server = string.Empty;
if (dict.TryGetValue("servers", out server))
{
Servers = server.Split(',').Select(n => n.Trim());
}
else
{
throw new ArgumentException($"Не указан servers для подключения к Kafka", "servers");
}
if (!Servers.Any())
{
throw new ArgumentException($"Не удалось распарсить servers для подключения к Kafka (формат поля: 'servername1:port1, servername2:port2, servername3:port3.....')");
}
dict.TryGetValue("securityprotocol", out var _securityProtocol);
SecurityProtocol = _securityProtocol;
switch (SecurityProtocol?.ToUpper())
{
case "SASL_PLAINTEXT":
SaslConfig = new SaslConfig();
SaslConfig.Init(dict);
break;
}
}
public void ImportSettings(string filename)
{
var jsonText = File.ReadAllText(filename);
var newSettings = PartialObject<BindableSettings>.Create(jsonText);
// Todo: This probably isn't the best way of doing this
// - should probably have some method of denoting if a setting is importable, then it should run automatically
newSettings.MergeItem((BindableSettings x) => x.RefreshInterval, _settings);
// Note: This is a little hacky but I'm not sure how to trigger a refresh on the binding when replacing the entire list
var servers = new Servers();
newSettings.MergeItem(x => x.Servers, ref servers);
if (servers.Any())
{
_settings.Servers.Clear();
//_settings.CurrentServer = 0; Deprecated
foreach (var server in servers)
{
_settings.Servers.Add(server);
}
}
}
/// <summary>
/// Loads the most updated configuration creating any resources as needed.
/// </summary>
/// <param name="bucketConfig">The latest <see cref="IBucketConfig"/>
/// that will drive the recreation if the configuration context.</param>
public override void LoadConfig(IBucketConfig bucketConfig, bool force = false)
{
try
{
Lock.EnterWriteLock();
if (bucketConfig == null)
{
throw new ArgumentNullException("bucketConfig");
}
if (BucketConfig == null || !BucketConfig.Nodes.AreEqual <Node>(bucketConfig.Nodes) || !Servers.Any() ||
force)
{
Log.Info(m => m("o1-Creating the Servers {0} list using rev#{1}", Servers.Count(), bucketConfig.Rev));
var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name];
var servers = new List <IServer>();
var nodes = bucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = IPEndPointExtensions.GetEndPoint(adapter, clientBucketConfig, BucketConfig);
try
{
var poolConfiguration = ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration;
var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint);
var ioStrategy = IOStrategyFactory(connectionPool);
var saslMechanism = SaslFactory(bucketConfig.Name, bucketConfig.Password, ioStrategy, Converter);
ioStrategy.SaslMechanism = saslMechanism;
var server = new Core.Server(ioStrategy, adapter, ClientConfig, bucketConfig);
servers.Add(server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
var old = Interlocked.Exchange(ref Servers, servers);
if (old != null)
{
old.ForEach(x => x.Dispose());
old.Clear();
}
}
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev));
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
Interlocked.Exchange(ref KeyMapper, new VBucketKeyMapper(Servers, _bucketConfig.VBucketServerMap)
{
Rev = _bucketConfig.Rev
});
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
Lock.ExitWriteLock();
}
}
/// <summary>
/// Loads the most updated configuration creating any resources as needed.
/// </summary>
/// <param name="bucketConfig">The latest <see cref="IBucketConfig"/>
/// that will drive the recreation if the configuration context.</param>
/// <param name="force">True to force the reconfiguration.</param>
public override void LoadConfig(IBucketConfig bucketConfig, bool force = false)
{
try
{
Lock.EnterWriteLock();
var nodes = bucketConfig.GetNodes();
if (BucketConfig == null || !nodes.AreEqual(BucketConfig.GetNodes()) || !Servers.Any() || force)
{
Log.Info("o1-Creating the Servers {0} list using rev#{1}", nodes.Count, bucketConfig.Rev);
var searchUris = new ConcurrentBag <FailureCountingUri>();
var queryUris = new ConcurrentBag <FailureCountingUri>();
var analyticsUris = new ConcurrentBag <FailureCountingUri>();
var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name];
var servers = new Dictionary <IPEndPoint, IServer>();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
//The node does not have to be created or swapped out so reuse the existing mode
if (Servers.TryGetValue(endpoint, out IServer cachedServer))
{
Log.Info("Reusing node {0} for rev#{1}", endpoint, bucketConfig.Rev);
servers.Add(endpoint, cachedServer);
}
else
{
Log.Info("Creating node {0} for rev#{1}", endpoint, bucketConfig.Rev);
IServer server;
if (adapter.IsDataNode) //a data node so create a connection pool
{
var uri = UrlUtil.GetBaseUri(adapter, clientBucketConfig);
var poolConfiguration = ClientConfig.BucketConfigs[BucketConfig.Name]
.ClonePoolConfiguration(uri);
var ioService = CreateIOService(poolConfiguration, endpoint);
server = new Core.Server(ioService, adapter, Transcoder, QueryCache, this);
SupportsEnhancedDurability = ioService.SupportsEnhancedDurability;
SupportsSubdocXAttributes = ioService.SupportsSubdocXAttributes;
SupportsEnhancedAuthentication = ioService.SupportsEnhancedAuthentication;
SupportsKvErrorMap = ioService.SupportsKvErrorMap;
}
else
{
server = new Core.Server(null, adapter, Transcoder, QueryCache, this);
}
servers.Add(endpoint, server);
}
if (adapter.IsSearchNode)
{
var uri = UrlUtil.GetFailureCountinSearchBaseUri(adapter, clientBucketConfig);
searchUris.Add(uri);
}
if (adapter.IsQueryNode)
{
var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig);
queryUris.Add(uri);
}
if (adapter.IsAnalyticsNode)
{
var uri = UrlUtil.GetFailureCountingAnalyticsUri(adapter, clientBucketConfig);
analyticsUris.Add(uri);
}
}
catch (Exception e)
{
Log.Error("Could not add server {0} for rev#{1}. Exception: {2}", endpoint, bucketConfig.Rev, e);
}
}
UpdateServices(servers);
//for caching uri's
Interlocked.Exchange(ref QueryUris, queryUris);
Interlocked.Exchange(ref SearchUris, searchUris);
Interlocked.Exchange(ref AnalyticsUris, analyticsUris);
SwapServers(servers);
Log.Info("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev);
var vBucketKeyMapper = new VBucketKeyMapper(Servers,
bucketConfig.GetBucketServerMap(clientBucketConfig.UseSsl),
bucketConfig.Rev,
bucketConfig.Name);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
}
else
{
if (BucketConfig == null || !BucketConfig.IsVBucketServerMapEqual(bucketConfig) || force)
{
Log.Info("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev);
var vBucketKeyMapper = new VBucketKeyMapper(Servers,
bucketConfig.GetBucketServerMap(ClientConfig.BucketConfigs[bucketConfig.Name].UseSsl),
bucketConfig.Rev,
bucketConfig.Name);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
}
//only the revision changed so update to it
if (bucketConfig.Rev > BucketConfig.Rev)
{
Log.Info("Only the revision changed from using rev#{0} to rev#{1}", BucketConfig.Rev, bucketConfig.Rev);
BucketConfig.Rev = bucketConfig.Rev;
}
}
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
Lock.ExitWriteLock();
}
}
/// <summary>
/// Loads the most updated configuration creating any resources as needed.
/// </summary>
/// <param name="bucketConfig">The latest <see cref="IBucketConfig"/>
/// that will drive the recreation if the configuration context.</param>
/// <param name="force">True to force the reconfiguration.</param>
public override void LoadConfig(IBucketConfig bucketConfig, bool force = false)
{
try
{
Lock.EnterWriteLock();
var nodes = bucketConfig.GetNodes();
if (BucketConfig == null || !nodes.AreEqual(_bucketConfig.GetNodes()) || !Servers.Any() || force)
{
Log.InfoFormat("o1-Creating the Servers {0} list using rev#{1}", nodes.Count, bucketConfig.Rev);
var queryUris = new ConcurrentBag <FailureCountingUri>();
var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name];
var servers = new Dictionary <IPAddress, IServer>();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
Log.InfoFormat("Creating node {0} for rev#{1}", endpoint, bucketConfig.Rev);
IServer server;
if (adapter.IsQueryNode)
{
var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig);
uri.ConfigureServicePoint(ClientConfig);
queryUris.Add(uri);
}
if (adapter.IsDataNode) //a data node so create a connection pool
{
var poolConfiguration = ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration;
var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint);
var ioStrategy = IOStrategyFactory(connectionPool);
server = new Core.Server(ioStrategy, adapter, ClientConfig, bucketConfig, Transcoder, QueryCache)
{
SaslFactory = SaslFactory
};
server.CreateSaslMechanismIfNotExists();
SupportsEnhancedDurability = ioStrategy.SupportsEnhancedDurability;
}
else
{
server = new Core.Server(null, adapter, ClientConfig, bucketConfig, Transcoder, QueryCache);
}
servers.Add(endpoint.Address, server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0} for rev#{1}. Exception: {2}", endpoint, bucketConfig.Rev, e);
}
}
UpdateServices(servers);
//for caching uri's
Interlocked.Exchange(ref QueryUris, queryUris);
var old = Interlocked.Exchange(ref Servers, servers);
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev));
var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap, bucketConfig.Rev);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
if (old != null)
{
foreach (var server in old.Values)
{
Log.InfoFormat("Disposing node {0} from rev#{1}", server.EndPoint, server.Revision);
server.Dispose();
}
old.Clear();
}
}
else
{
if (BucketConfig == null || !BucketConfig.IsVBucketServerMapEqual(bucketConfig) || force)
{
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev));
var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap,
bucketConfig.Rev);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
}
}
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
Lock.ExitWriteLock();
}
}
/// <summary>
/// Loads the most updated configuration creating any resources as needed.
/// </summary>
/// <param name="bucketConfig">The latest <see cref="IBucketConfig"/>
/// that will drive the recreation if the configuration context.</param>
/// <param name="force">True to force the reconfiguration.</param>
public override void LoadConfig(IBucketConfig bucketConfig, bool force = false)
{
try
{
Lock.EnterWriteLock();
var nodes = bucketConfig.GetNodes();
if (BucketConfig == null || !nodes.AreEqual(_bucketConfig.GetNodes()) || !Servers.Any() || force)
{
Log.Info("o1-Creating the Servers {0} list using rev#{1}", nodes.Count, bucketConfig.Rev);
var searchUris = new ConcurrentBag <FailureCountingUri>();
var queryUris = new ConcurrentBag <FailureCountingUri>();
var analyticsUris = new ConcurrentBag <FailureCountingUri>();
var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name];
var servers = new Dictionary <IPAddress, IServer>();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
Log.Info("Creating node {0} for rev#{1}", endpoint, bucketConfig.Rev);
IServer server;
if (adapter.IsSearchNode)
{
var uri = UrlUtil.GetFailureCountinSearchBaseUri(adapter, clientBucketConfig);
searchUris.Add(uri);
}
if (adapter.IsQueryNode)
{
var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig);
queryUris.Add(uri);
}
if (adapter.IsAnalyticsNode)
{
var uri = UrlUtil.GetFailureCountingAnalyticsUri(adapter, clientBucketConfig);
analyticsUris.Add(uri);
}
if (adapter.IsDataNode) //a data node so create a connection pool
{
var uri = UrlUtil.GetBaseUri(adapter, clientBucketConfig);
var poolConfiguration = ClientConfig.BucketConfigs[BucketConfig.Name].ClonePoolConfiguration(uri);
var connectionPool = ConnectionPoolFactory(poolConfiguration.Clone(uri), endpoint);
connectionPool.SaslMechanism = SaslFactory(BucketConfig.Name, BucketConfig.Password, connectionPool, Transcoder);
connectionPool.Initialize();
var ioService = IOServiceFactory(connectionPool);
server = new Core.Server(ioService, adapter, ClientConfig, bucketConfig, Transcoder, QueryCache);
SupportsEnhancedDurability = ioService.SupportsEnhancedDurability;
SupportsSubdocXAttributes = ioService.SupportsSubdocXAttributes;
SupportsEnhancedAuthentication = ioService.SupportsEnhancedAuthentication;
SupportsKvErrorMap = ioService.SupportsKvErrorMap;
}
else
{
server = new Core.Server(null, adapter, ClientConfig, bucketConfig, Transcoder, QueryCache);
}
servers.Add(endpoint.Address, server);
}
catch (Exception e)
{
Log.Error("Could not add server {0} for rev#{1}. Exception: {2}", endpoint, bucketConfig.Rev, e);
}
}
UpdateServices(servers);
//for caching uri's
Interlocked.Exchange(ref QueryUris, queryUris);
Interlocked.Exchange(ref SearchUris, searchUris);
Interlocked.Exchange(ref AnalyticsUris, analyticsUris);
var old = Interlocked.Exchange(ref Servers, servers);
Log.Info("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev);
var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap, bucketConfig.Rev, bucketConfig.Name);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
if (old != null)
{
foreach (var server in old.Values)
{
Log.Info("Disposing node {0} from rev#{1}", server.EndPoint, server.Revision);
server.Dispose();
}
old.Clear();
}
}
else
{
if (BucketConfig == null || !BucketConfig.IsVBucketServerMapEqual(bucketConfig) || force)
{
Log.Info("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev);
var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap,
bucketConfig.Rev, bucketConfig.Name);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
}
//only the revision changed so update to it
if (bucketConfig.Rev > BucketConfig.Rev)
{
Log.Info("Only the revision changed from using rev#{0} to rev#{1}", BucketConfig.Rev, bucketConfig.Rev);
BucketConfig.Rev = bucketConfig.Rev;
}
}
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
Lock.ExitWriteLock();
}
}
/// <summary>
/// Starts scanning for Maple servers
/// </summary>
public async Task StartScanningForAdvertisingServers()
{
//var hostList = new List<ServerModel>();
var listener = new UdpClient(ListenPort);
var ipEndPoint = new IPEndPoint(IPAddress.Any, ListenPort);
string[] delimeter = new string[] { "::" };
var timeoutTask = UdpTimeoutTask();
try
{
while (timeoutTask.IsCompleted == false)
{
//Console.WriteLine("Waiting for broadcast");
// create two tasks, one that will timeout after a while
var tasks = new Task <UdpReceiveResult>[] {
timeoutTask,
listener.ReceiveAsync()
};
int index = 0;
await Task.Run(() => index = Task.WaitAny(tasks));
var results = tasks[index].Result;
if (results.RemoteEndPoint == null)
{
break;
}
string host = Encoding.UTF8.GetString(results.Buffer, 0, results.Buffer.Length);
string hostIp = host.Split(delimeter, StringSplitOptions.None)[1];
//Console.WriteLine($"Raw:{host}, ip:{hostIp}");
//Console.WriteLine("Received broadcast from {0} :\n {1}\n", hostIp, host);
var server = new ServerModel()
{
Name = host.Split(delimeter, StringSplitOptions.None)[0],
IpAddress = host.Split(delimeter, StringSplitOptions.None)[1]
};
// if the server doesn't already exist in the list
if (!Servers.Any(s => s.IpAddress == hostIp))
{ // add it
//Console.WriteLine($"Found a server. Name: '{server.Name}', IP: {server.IpAddress} ");
Servers.Add(server);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
listener.Dispose();
}
}
public static void Main()
{
AppDomain.CurrentDomain.ProcessExit += OnExit;
Headless = GetFlagFromArgs("headless", "h");
string serverIdArg = GetParamFromArgs("server-id", "id");
string configArg = GetParamFromArgs("config", "c");
portArg = uint.TryParse(GetParamFromArgs("port", "p"), out uint port) ? (uint?)port : null;
Server server = null;
if (!string.IsNullOrEmpty(serverIdArg) || !string.IsNullOrEmpty(configArg))
{
server = new Server(serverIdArg, configArg, portArg);
InstantiatedServers.Add(server);
}
else
{
if (Servers.Any())
{
Server[] autoStartServers = AutoStartServers;
if (autoStartServers.Any())
{
Write("Starting this instance in multi server mode...");
for (int i = 0; i < autoStartServers.Length; i++)
{
if (i == 0)
{
server = autoStartServers[i];
InstantiatedServers.Add(server);
}
else
{
StartServer(autoStartServers[i]);
}
}
}
else
{
Write("No servers are set to automatically start, please enter a Server ID to start:");
InputThread.InputPrefix?.Write();
server = new Server(Console.ReadLine(), port: portArg);
InstantiatedServers.Add(server);
}
}
else
{
server = new Server(port: portArg);
InstantiatedServers.Add(server);
}
}
if (server != null)
{
if (!string.IsNullOrEmpty(server.serverId) && !string.IsNullOrEmpty(server.configLocation))
{
Write($"Starting this instance with Server ID: \"{server.serverId}\" and config directory: \"{server.configLocation}\"...");
}
else if (!string.IsNullOrEmpty(server.serverId))
{
Write($"Starting this instance with Server ID: \"{server.serverId}\"...");
}
else if (!string.IsNullOrEmpty(server.configLocation))
{
Write($"Starting this instance with config directory: \"{server.configLocation}\"...");
}
else
{
Write("Starting this instance in single server mode...");
}
server.StartServer();
}
}
/// <summary>
/// Loads the most updated configuration creating any resources as needed.
/// </summary>
/// <param name="bucketConfig">The latest <see cref="IBucketConfig"/>
/// that will drive the recreation if the configuration context.</param>
/// <param name="force">True to force the reconfiguration.</param>
public override void LoadConfig(IBucketConfig bucketConfig, bool force = false)
{
try
{
Lock.EnterWriteLock();
var nodes = bucketConfig.GetNodes();
if (BucketConfig == null || !nodes.AreEqual(_bucketConfig.GetNodes()) || !Servers.Any() || force)
{
var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name];
var servers = new Dictionary <IPAddress, IServer>();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
Log.Info(
m =>
m("o1-Creating the Servers {0} list using rev#{1}", Servers.Count(),
bucketConfig.Rev));
var poolConfiguration = ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration;
var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint);
var ioStrategy = IOStrategyFactory(connectionPool);
var server = new Core.Server(ioStrategy, adapter, ClientConfig, bucketConfig, Transcoder, QueryCache)
{
SaslFactory = SaslFactory
};
server.CreateSaslMechanismIfNotExists();
SupportsEnhancedDurability = ioStrategy.SupportsEnhancedDurability;
servers.Add(endpoint.Address, server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
UpdateServices(servers);
var old = Interlocked.Exchange(ref Servers, servers);
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev));
var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap, bucketConfig.Rev);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
if (old != null)
{
foreach (var server in old.Values)
{
server.Dispose();
}
old.Clear();
}
}
else
{
if (BucketConfig == null || !BucketConfig.IsVBucketServerMapEqual(bucketConfig) || force)
{
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev));
var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap,
bucketConfig.Rev);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
}
}
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
Lock.ExitWriteLock();
}
}
