[Fact] void WritesExpectedDefauts() => WithValidPreflightChecks()
.AssertTask(
(m, s, fs) => new EditElasticsearchYamlTask(m, s, fs),
(m, t) =>
{
var dir = m.LocationsModel.ConfigDirectory;
var yaml = Path.Combine(dir, "elasticsearch.yml");
var yamlContents = t.FileSystem.File.ReadAllText(yaml);
yamlContents.Should().NotBeEmpty().And.NotBe("cluster.name: x");
var config = ElasticsearchYamlConfiguration.FromFolder(dir, t.FileSystem);
var s = config.Settings;
s.ClusterName.Should().Be(ConfigurationModel.DefaultClusterName);
s.NodeName.Should().Be(ConfigurationModel.DefaultNodeName);
s.MasterNode.Should().Be(ConfigurationModel.DefaultMasterNode);
s.DataNode.Should().Be(ConfigurationModel.DefaultDataNode);
s.IngestNode.Should().Be(ConfigurationModel.DefaultIngestNode);
s.MemoryLock.Should().Be(ConfigurationModel.DefaultMemoryLock);
s.LogsPath.Should().Be(LocationsModel.DefaultLogsDirectory);
s.DataPath.Should().Be(LocationsModel.DefaultDataDirectory);
//because install as service is enabled by default
s.MaxLocalStorageNodes.Should().Be(1);
s.NetworkHost.Should().BeNullOrEmpty();
s.HttpPortString.Should().Be("9200");
s.TransportTcpPortString.Should().Be("9300");
s.UnicastHosts.Should().BeNullOrEmpty();
}
);
[Fact] void DeselectingSecurityWritesFalseToYamlFile() => DefaultValidModelForTasks(s => s
.Elasticsearch(es => es
.EsConfigMachineVariable(LocationsModel.DefaultConfigDirectory)
)
.FileSystem(fs =>
{
fs.AddFile(Path.Combine(LocationsModel.DefaultConfigDirectory, "elasticsearch.yml"), new MockFileData(""));
return(fs);
})
)
.OnStep(m => m.XPackModel, s =>
{
s.XPackLicense = XPackLicenseMode.Trial;
s.XPackSecurityEnabled = false;
})
.AssertTask(
(m, s, fs) => new EditElasticsearchYamlTask(m, s, fs),
(m, t) =>
{
var dir = m.LocationsModel.ConfigDirectory;
var yaml = Path.Combine(dir, "elasticsearch.yml");
var yamlContents = t.FileSystem.File.ReadAllText(yaml);
yamlContents.Should().NotBeEmpty().And.NotBe("cluster.name: x");
var config = ElasticsearchYamlConfiguration.FromFolder(dir, t.FileSystem);
var s = config.Settings;
s.XPackLicenseSelfGeneratedType.Should().Be("trial");
s.XPackSecurityEnabled.Should().BeFalse();
}
);
void DefaultMaxLocalStorageNodesNotService() => WithValidPreflightChecks(s => s
.Elasticsearch(es => es
.EsConfigMachineVariable(LocationsModel.DefaultConfigDirectory)
)
.FileSystem(fs =>
{
fs.AddFile(Path.Combine(LocationsModel.DefaultConfigDirectory, "elasticsearch.yml"), new MockFileData(@""));
return(fs);
})
)
.OnStep(m => m.ServiceModel, s => s.InstallAsService = false)
.AssertTask(
(m, s, fs) => new EditElasticsearchYamlTask(m, s, fs),
(m, t) =>
{
var dir = m.LocationsModel.ConfigDirectory;
var yaml = Path.Combine(dir, "elasticsearch.yml");
var yamlContents = t.FileSystem.File.ReadAllText(yaml);
yamlContents.Should().NotBeEmpty().And.NotBe("cluster.name: x");
var config = ElasticsearchYamlConfiguration.FromFolder(dir, t.FileSystem);
var s = config.Settings;
//because we do not install as service
s.MaxLocalStorageNodes.Should().NotHaveValue();
}
);
[Fact] void SelectingTrialDoesNotWriteSecurityEnabled() => WithValidPreflightChecks(s => s
.Elasticsearch(es => es
.EsConfigMachineVariable(LocationsModel.DefaultConfigDirectory)
)
.FileSystem(fs =>
{
fs.AddFile(Path.Combine(LocationsModel.DefaultConfigDirectory, "elasticsearch.yml"), new MockFileData(@""));
return(fs);
})
)
.OnStep(m => m.PluginsModel, s => s.ChangeXPackSelection(true))
.OnStep(m => m.XPackModel, s => s.XPackLicense = XPackLicenseMode.Trial)
.AssertTask(
(m, s, fs) => new EditElasticsearchYamlTask(m, s, fs),
(m, t) =>
{
var dir = m.LocationsModel.ConfigDirectory;
var yaml = Path.Combine(dir, "elasticsearch.yml");
var yamlContents = t.FileSystem.File.ReadAllText(yaml);
yamlContents.Should().NotBeEmpty().And.NotBe("cluster.name: x");
var config = ElasticsearchYamlConfiguration.FromFolder(dir, t.FileSystem);
var s = config.Settings;
s.XPackLicenseSelfGeneratedType.Should().Be(nameof(XPackLicenseMode.Trial).ToLowerInvariant());
s.XPackSecurityEnabled.Should().BeNull();
}
);
[Fact] void XPackSettingsAlreadyInPlaceAreNotOverwritten() => DefaultValidModelForTasks(s => s
.Elasticsearch(es => es
.EsConfigMachineVariable(LocationsModel.DefaultConfigDirectory)
)
.FileSystem(fs =>
{
var yaml = $@"bootstrap.memory_lock: true
xpack.security.enabled: false
xpack.license.self_generated.type: trial
xpack.random_setting: something
";
fs.AddFile(Path.Combine(LocationsModel.DefaultConfigDirectory, "elasticsearch.yml"), yaml);
return(fs);
})
)
.AssertTask(
(m, s, fs) => new EditElasticsearchYamlTask(m, s, fs),
(m, t) =>
{
var dir = m.LocationsModel.ConfigDirectory;
var yaml = Path.Combine(dir, "elasticsearch.yml");
var config = ElasticsearchYamlConfiguration.FromFolder(dir, t.FileSystem);
var s = config.Settings;
s.MemoryLock.Should().BeTrue();
s.XPackLicenseSelfGeneratedType.Should().Be("trial");
s.XPackSecurityEnabled.Should().BeFalse();
//unknown x-pack setting is preserved
s.Keys.Where(k => k.StartsWith("xpack")).Should().HaveCount(1);
}
);
void PicksUpExistingConfiguration() => WithValidPreflightChecks(s => s
.Elasticsearch(e => e
.EsConfigMachineVariable(LocationsModel.DefaultConfigDirectory)
)
.FileSystem(fs =>
{
fs.AddDirectory(LocationsModel.DefaultConfigDirectory);
var yaml = Path.Combine(LocationsModel.DefaultConfigDirectory, "elasticsearch.yml");
fs.AddFile(yaml, new MockFileData(@"cluster.name: x"));
return(fs);
})
)
.AssertTask(
(m, s, fs) => new EditElasticsearchYamlTask(m, s, fs),
(m, t) =>
{
var dir = m.LocationsModel.ConfigDirectory;
var yaml = Path.Combine(dir, "elasticsearch.yml");
var yamlContents = t.FileSystem.File.ReadAllText(yaml);
yamlContents.Should().NotBeEmpty().And.NotBe("cluster.name: x");
var config = ElasticsearchYamlConfiguration.FromFolder(dir, t.FileSystem);
var s = config.Settings;
s.ClusterName.Should().Be("x");
s.NodeName.Should().Be(ConfigurationModel.DefaultNodeName);
}
);
[Fact] void RemovesXPackSettingsIfXPackIsNotBeingInstalled() => WithValidPreflightChecks(s => s
.Elasticsearch(es => es
.EsConfigMachineVariable(LocationsModel.DefaultConfigDirectory)
)
.FileSystem(fs =>
{
var yaml = $@"bootstrap.memory_lock: true
xpack.security.enabled = false
xpack.license.self_generated.type = trial
xpack.random_setting = something
";
fs.AddFile(Path.Combine(LocationsModel.DefaultConfigDirectory, "elasticsearch.yml"), new MockFileData(@""));
return(fs);
})
)
.OnStep(m => m.PluginsModel, s => s.ChangeXPackSelection(false))
.AssertTask(
(m, s, fs) => new EditElasticsearchYamlTask(m, s, fs),
(m, t) =>
{
var dir = m.LocationsModel.ConfigDirectory;
var yaml = Path.Combine(dir, "elasticsearch.yml");
var yamlContents = t.FileSystem.File.ReadAllText(yaml);
yamlContents.Should().NotBeEmpty().And.NotBe("cluster.name: x");
var config = ElasticsearchYamlConfiguration.FromFolder(dir, t.FileSystem);
var s = config.Settings;
s.XPackLicenseSelfGeneratedType.Should().BeNull();
s.XPackSecurityEnabled.Should().BeNull();
s.Keys.Where(k => k.StartsWith("xpack")).Should().HaveCount(0);
}
);
protected override bool ExecuteTask()
{
RestoreConfigDirectory();
RestoreXPackDirectory();
RestorePluginsDirectory();
// only delete config, logs and data if they were created by this installer operation
var configDirectoryExisted = this.Session.Get <bool>(LocationsModel.ConfigDirectoryExists);
var logsDirectoryExisted = this.Session.Get <bool>(LocationsModel.LogsDirectoryExists);
var dataDirectoryExisted = this.Session.Get <bool>(LocationsModel.DataDirectoryExists);
var configDirectory = this.InstallationModel.LocationsModel.ConfigDirectory;
if (!this.FileSystem.Directory.Exists(configDirectory))
{
this.Session.Log($"Config directory does not exist. skipping {configDirectory}");
}
else
{
var yamlConfiguration = ElasticsearchYamlConfiguration.FromFolder(configDirectory, this.FileSystem);
var dataDirectory = yamlConfiguration?.Settings?.DataPath ?? this.InstallationModel.LocationsModel.DataDirectory;
var logsDirectory = yamlConfiguration?.Settings?.LogsPath ?? this.InstallationModel.LocationsModel.LogsDirectory;
this.Session.SendActionStart(3000, ActionName, "Removing data, logs, and config directory, if created",
"Removing directories: [1]");
this.DeleteDirectoryIfExistsAndCreated(dataDirectory, !dataDirectoryExisted);
this.DumpElasticsearchLogOnRollback(logsDirectory);
this.DeleteDirectoryIfExistsAndCreated(logsDirectory, !logsDirectoryExisted);
this.DeleteDirectoryIfExistsAndCreated(configDirectory, !configDirectoryExisted);
}
return(true);
}
public InstallationModelTester(
MockWixStateProvider wixState,
MockJavaEnvironmentStateProvider javaState,
MockElasticsearchEnvironmentStateProvider esState,
NoopServiceStateProvider serviceState,
NoopPluginStateProvider pluginState,
MockFileSystem fileSystem,
NoopSession session,
string[] args)
{
if (wixState == null)
{
throw new ArgumentNullException(nameof(wixState));
}
if (javaState == null)
{
throw new ArgumentNullException(nameof(javaState));
}
if (esState == null)
{
throw new ArgumentNullException(nameof(esState));
}
this.JavaState = javaState;
this.EsState = esState;
this.PluginState = pluginState;
this.JavaConfig = new JavaConfiguration(javaState);
this.EsConfig = ElasticsearchYamlConfiguration.FromFolder(esState.ConfigDirectory, fileSystem);
this.JvmConfig = LocalJvmOptionsConfiguration.FromFolder(esState.ConfigDirectory, fileSystem);
this.InstallationModel = new InstallationModel(
wixState, JavaConfig, esState, serviceState, pluginState, EsConfig, JvmConfig, session, args);
this.FileSystem = fileSystem;
}
public LocationsModel(
ElasticsearchEnvironmentConfiguration elasticsearchEnvironmentConfiguration,
ElasticsearchYamlConfiguration yamlConfiguration,
VersionConfiguration versionConfig,
IFileSystem fileSystem)
{
this.IsRelevant = !versionConfig.ExistingVersionInstalled;
this.Header = "Locations";
this._elasticsearchEnvironmentConfiguration = elasticsearchEnvironmentConfiguration;
this._yamlConfiguration = yamlConfiguration;
this.CurrentVersion = versionConfig.CurrentVersion.ToString();
this.ExistingVersion = versionConfig.UpgradeFromVersion?.ToString();
this.FileSystem = fileSystem;
this.Refresh();
this._refreshing = true;
this.WhenAny(
vm => vm.LogsDirectory,
(c) => {
var v = c.GetValue();
return(this.FileSystem.Path.IsPathRooted(v)
? this.FileSystem.Path.Combine(v, "elasticsearch.log")
: null);
})
.ToProperty(this, vm => vm.ElasticsearchLog, out elasticsearchLog);
this.ThrownExceptions.Subscribe(e =>
{
});
//If install, config, logs or data dir are set force ConfigureLocations to true
this.WhenAny(
vm => vm.InstallDir,
vm => vm.ConfigDirectory,
vm => vm.LogsDirectory,
vm => vm.DataDirectory,
(i, c, l, d) => !this._refreshing
)
.Subscribe(x => { if (x)
{
this.ConfigureLocations = true;
}
});
this.WhenAny(
vm => vm.ConfigureLocations,
(c) => !this._refreshing && !c.Value
)
.Subscribe(x => { if (x)
{
this.Refresh();
}
});
this._refreshing = false;
}
[Fact] void InitialMasterNodesAreReadFromStringCommaSeparated()
{
var yaml = $@"cluster.initial_master_nodes: host1, host2";
var fs = FakeElasticsearchYaml(yaml);
var optsFile = new ElasticsearchYamlConfiguration(_path, fs);
var settings = optsFile.Settings;
settings.InitialMasterNodes.Should().NotBeEmpty().And.HaveCount(2);
optsFile.Save();
}
[Fact] void InitialMasterNodeAreRead()
{
var yaml = $@"InitialMasterNode: [host1, host2]";
var fs = FakeElasticsearchYaml(yaml);
var optsFile = new ElasticsearchYamlConfiguration(_path, fs);
var settings = optsFile.Settings;
settings.InitialMasterNodes.Should().NotBeEmpty().And.HaveCount(2);
optsFile.Save();
}
[Fact] void SeedHostsAreRead()
{
var yaml = $@"discovery.seed_hosts: [host1, host2]";
var fs = FakeElasticsearchYaml(yaml);
var optsFile = new ElasticsearchYamlConfiguration(_path, fs);
var settings = optsFile.Settings;
settings.SeedHosts.Should().NotBeEmpty().And.HaveCount(2);
optsFile.Save();
}
private void RecheckPrequisites()
{
var javaState = new JavaEnvironmentStateProvider();
var esState = new ElasticsearchEnvironmentStateProvider();
var javaConfig = new JavaConfiguration(javaState);
var esConfig = ElasticsearchYamlConfiguration.FromFolder(esState.ConfigDirectory);
this.ViewModel.BadElasticsearchYamlFile = esConfig.FoundButNotValid;
this.ViewModel.JavaInstalled = javaConfig.JavaInstalled;
this.ViewModel.JavaMisconfigured = javaConfig.JavaMisconfigured;
}
[Fact] void UnicastHostsAreStillRead()
{
var folder = @"C:\ProgramData\Elastic\Elasticsearch\";
var yaml = $@"discovery.zen.ping.unicast.hosts: [host1, host2]";
var fs = FakeElasticsearchYaml(yaml);
var optsFile = new ElasticsearchYamlConfiguration(_path, fs);
var settings = optsFile.Settings;
settings.UnicastHosts.Should().NotBeEmpty().And.HaveCount(2);
optsFile.Save();
}
[Fact] void CustomConfigValues() => DefaultValidModelForTasks(s => s
.Elasticsearch(es => es
.EsConfigMachineVariable(LocationsModel.DefaultConfigDirectory)
)
.FileSystem(fs =>
{
fs.AddFile(Path.Combine(LocationsModel.DefaultConfigDirectory, "elasticsearch.yml"), new MockFileData(@""));
return(fs);
})
)
.OnStep(m => m.ConfigurationModel, s =>
{
s.ClusterName = "x";
s.NodeName = "x";
s.MasterNode = false;
s.DataNode = false;
s.IngestNode = false;
s.LockMemory = false;
s.NetworkHost = "xyz";
s.HttpPort = 80;
s.TransportPort = 9300;
s.SeedHosts = new ReactiveUI.ReactiveList <string>
{
"localhost", "192.2.3.1:9301"
};
})
.AssertTask(
(m, s, fs) => new EditElasticsearchYamlTask(m, s, fs),
(m, t) =>
{
var dir = m.LocationsModel.ConfigDirectory;
var yaml = Path.Combine(dir, "elasticsearch.yml");
var yamlContents = t.FileSystem.File.ReadAllText(yaml);
yamlContents.Should().NotBeEmpty().And.NotBe("cluster.name: x");
var config = ElasticsearchYamlConfiguration.FromFolder(dir, t.FileSystem);
var s = config.Settings;
s.ClusterName.Should().Be("x");
s.NodeName.Should().Be("x");
s.MasterNode.Should().BeFalse();
s.IngestNode.Should().BeFalse();
s.MemoryLock.Should().BeFalse();
s.NetworkHost.Should().Be("xyz");
s.HttpPort.Should().Be(80);
s.HttpPortString.Should().Be("80");
s.TransportTcpPort.Should().Be(9300);
s.TransportTcpPortString.Should().Be("9300");
s.UnicastHosts.Should().BeNullOrEmpty();
s.SeedHosts.Should().BeEquivalentTo(new List <string>
{
"localhost", "192.2.3.1:9301"
});
}
);
public static InstallationModel Create(IWixStateProvider wixState, ISession session, params string[] args)
{
var javaConfig = JavaConfiguration.Default;
var esState = ElasticsearchEnvironmentStateProvider.Default;
var serviceState = ServiceStateProvider.FromSession(session);
var pluginState = PluginStateProvider.Default;
var esConfig = ElasticsearchYamlConfiguration.FromFolder(esState.ConfigDirectory);
var jvmConfig = LocalJvmOptionsConfiguration.FromFolder(esState.ConfigDirectory);
return(new InstallationModel(wixState, javaConfig, esState, serviceState, pluginState, esConfig, jvmConfig, session, args));
}
public ConfigurationModel(ElasticsearchYamlConfiguration yamlConfiguration,
LocalJvmOptionsConfiguration localJvmOptions, IObservable <bool> upgradingFrom6OrNewInstallation)
{
this.Header = "Configuration";
this._localJvmOptions = localJvmOptions;
this._yamlSettings = yamlConfiguration?.Settings;
upgradingFrom6OrNewInstallation.Subscribe(b => this.UpgradingFrom6OrNewInstallation = b);
this.Refresh();
this.AddSeedHost = ReactiveCommand.CreateAsyncTask(async _ => await this.AddSeedHostUserInterfaceTask());
this.WhenAnyObservable(vm => vm.AddSeedHost)
.Subscribe(x =>
{
if (string.IsNullOrWhiteSpace(x))
{
return;
}
var nodes = x
.Split(',')
.Select(node => node.Trim())
.Where(n => !string.IsNullOrEmpty(n))
.Distinct();
foreach (var n in nodes)
{
this.SeedHosts.Add(n);
}
});
this.WhenAny(
vm => vm.TotalPhysicalMemory,
(maxMemory) => Math.Min(maxMemory.Value / 2, CompressedOrdinaryPointersThreshold)
)
.ToProperty(this, vm => vm.MaxSelectedMemory, out maxSelectedMemory);
var canRemoveNode = this.WhenAny(vm => vm.SelectedSeedHost, (selected) => !string.IsNullOrWhiteSpace(selected.GetValue()));
this.RemoveSeedHost = ReactiveCommand.Create(canRemoveNode);
this.RemoveSeedHost.Subscribe(x =>
{
this.SeedHosts.Remove(this.SelectedSeedHost);
});
this.WhenAnyValue(vm => vm.MasterNode).Subscribe(b =>
{
// if we unset master node make sure InitialMaster is not set either.
if (!b)
{
this.InitialMaster = false;
}
});
}
public static ElasticsearchInstallationModel Create(IWixStateProvider wixState, ISession session, params string[] args)
{
var javaConfig = JavaConfiguration.Default;
var esEnvironmentConfig = ElasticsearchEnvironmentConfiguration.Default;
var serviceState = ServiceStateProvider.FromSession(session, "Elasticsearch");
var pluginState = PluginStateProviderBase.ElasticsearchDefault(session);
var esConfig = ElasticsearchYamlConfiguration.FromFolder(esEnvironmentConfig.ConfigDirectory);
var jvmConfig = LocalJvmOptionsConfiguration.FromFolder(esEnvironmentConfig.ConfigDirectory);
var tempDirConfig = new TempDirectoryConfiguration(session, ElasticsearchEnvironmentStateProvider.Default, null);
return(new ElasticsearchInstallationModel(wixState,
javaConfig, esEnvironmentConfig, serviceState, pluginState, esConfig, jvmConfig, tempDirConfig,
session, args));
}
[Fact] void UnderstandsObjectNotation()
{
var clusterName = "my-cluster";
var yaml = $"cluster:\r\n name: {clusterName}\r\n blocks:\r\n read_only: true";
var fs = FakeElasticsearchYaml(yaml);
var optsFile = new ElasticsearchYamlConfiguration(_path, fs);
optsFile.Settings.ClusterName.Should().Be(clusterName);
optsFile.Settings.ClusterName = "x";
optsFile.Settings["cluster.blocks.read_only"] = false;
optsFile.Save();
var fileContentsAfterSave = fs.File.ReadAllText(_path);
var updatedYaml = $"cluster.name: x\r\ncluster.blocks.read_only: false\r\n";
fileContentsAfterSave.Replace("\r\n", "").Should().Be(updatedYaml.Replace("\r\n", ""));
}
protected override bool ExecuteTask()
{
this.Session.SendActionStart(TotalTicks, ActionName, "Configuring Elasticsearch", "Configuring Elasticsearch: [1]");
var locations = this.InstallationModel.LocationsModel;
this.Session.SendProgress(1000, "reading elasticsearch.yml from " + locations.ConfigDirectory);
var yaml = ElasticsearchYamlConfiguration.FromFolder(locations.ConfigDirectory, this.FileSystem);
var settings = yaml.Settings;
this.ApplyConfigurationModel(settings);
this.ApplyLocationsModel(settings, locations);
this.ApplyServiceModel(settings);
this.ApplyXPackModel(settings);
yaml.Save();
this.Session.SendProgress(1000, "elasticsearch.yml updated");
return(true);
}
[Fact] void InitialMaster7SetsInitialMasterNodesIfNotSetPrior() =>
DefaultValidModelForTasks(s => s
.Elasticsearch(es => es.EsConfigMachineVariable(LocationsModel.DefaultConfigDirectory))
.FileSystem(fs =>
{
var yamlLocation = Path.Combine(LocationsModel.DefaultConfigDirectory, "elasticsearch.yml");
fs.AddFile(yamlLocation, new MockFileData(@"discovery.zen.minimum_master_nodes: 20"));
return(fs);
})
)
.OnStep(m => m.ConfigurationModel, s =>
{
s.ClusterName = "x";
s.NodeName = "nodex";
s.InitialMaster.Should().BeFalse();
s.InitialMaster = true;
})
.AssertTask(
(m, s, fs) =>
{
m.ToMsiParamsString().Should()
.Contain($"{nameof(ConfigurationModel.InitialMaster).ToUpperInvariant()}=\"true\"");
return(new EditElasticsearchYamlTask(m, s, fs));
},
(m, t) =>
{
var dir = m.LocationsModel.ConfigDirectory;
var yaml = Path.Combine(dir, "elasticsearch.yml");
var yamlContents = t.FileSystem.File.ReadAllText(yaml);
// validate we are writing the yaml file in 7.0 format
yamlContents.Should().NotBeEmpty()
// don't carry over minimum_master_nodes
.And.NotContain("discovery.zen.minimum_master_nodes")
.And.Contain("cluster.initial_master_nodes");
var config = ElasticsearchYamlConfiguration.FromFolder(dir, t.FileSystem);
var s = config.Settings;
s.ClusterName.Should().Be("x");
s.NodeName.Should().Be("nodex");
s.InitialMasterNodes.Should().BeEquivalentTo(new List <string> {
"nodex"
});
}
);
[Fact] void WritesSeedHostsFor7() =>
DefaultValidModelForTasks(s => s
.Elasticsearch(es => es.EsConfigMachineVariable(LocationsModel.DefaultConfigDirectory))
.FileSystem(fs =>
{
var yamlLocation = Path.Combine(LocationsModel.DefaultConfigDirectory, "elasticsearch.yml");
fs.AddFile(yamlLocation, new MockFileData(@"discovery.zen.ping.unicast.hosts: ['192.2.3.1:9200']"));
return(fs);
})
)
.OnStep(m => m.ConfigurationModel, s =>
{
s.ClusterName = "x";
s.NodeName = "x";
//we read unicast host from previous install into seed hosts
s.SeedHosts.Should().NotBeEmpty().And.Contain(h => h.Contains("9200"));
//simulate a user change
s.SeedHosts = new ReactiveUI.ReactiveList <string> {
"localhost", "192.2.3.1:9201"
};
})
.AssertTask(
(m, s, fs) => new EditElasticsearchYamlTask(m, s, fs),
(m, t) =>
{
var dir = m.LocationsModel.ConfigDirectory;
var yaml = Path.Combine(dir, "elasticsearch.yml");
var yamlContents = t.FileSystem.File.ReadAllText(yaml);
// validate we are writing the yaml file in 7.0 format
yamlContents.Should().NotBeEmpty()
.And.Contain("discovery.seed_hosts")
.And.Contain("192.2.3.1:9201")
.And.NotContain("discovery.zen.ping.unicast.hosts")
.And.NotContain("192.2.3.1:9200");
var config = ElasticsearchYamlConfiguration.FromFolder(dir, t.FileSystem);
var s = config.Settings;
s.ClusterName.Should().Be("x");
s.NodeName.Should().Be("x");
s.SeedHosts.Should().BeEquivalentTo(new List <string>
{
"localhost", "192.2.3.1:9201"
});
}
);
[Fact] void CustomConfigValues() => WithValidPreflightChecks()
.OnStep(m => m.ConfigurationModel, s =>
{
s.ClusterName = "x";
s.NodeName = "x";
s.MasterNode = false;
s.DataNode = false;
s.IngestNode = false;
s.LockMemory = false;
s.NetworkHost = "xyz";
s.HttpPort = 80;
s.TransportPort = 9300;
s.UnicastNodes = new ReactiveUI.ReactiveList <string>
{
"localhost", "192.2.3.1:9301"
};
})
.AssertTask(
(m, s, fs) => new EditElasticsearchYamlTask(m, s, fs),
(m, t) =>
{
var dir = m.LocationsModel.ConfigDirectory;
var yaml = Path.Combine(dir, "elasticsearch.yml");
var yamlContents = t.FileSystem.File.ReadAllText(yaml);
yamlContents.Should().NotBeEmpty().And.NotBe("cluster.name: x");
var config = ElasticsearchYamlConfiguration.FromFolder(dir, t.FileSystem);
var s = config.Settings;
s.ClusterName.Should().Be("x");
s.NodeName.Should().Be("x");
s.MasterNode.Should().BeFalse();
s.IngestNode.Should().BeFalse();
s.MemoryLock.Should().BeFalse();
s.NetworkHost.Should().Be("xyz");
s.HttpPort.Should().Be(80);
s.HttpPortString.Should().Be("80");
s.TransportTcpPort.Should().Be(9300);
s.TransportTcpPortString.Should().Be("9300");
s.UnicastHosts.Should().BeEquivalentTo(new List <string>
{
"localhost", "192.2.3.1:9301"
});
}
);
[Fact] void KnownSettingsAreReadCorrectly()
{
var nodeName = "DESKTOP-O4M5B2Q";
var clusterName = "my-cluster";
var networkHost = "127.0.0.1";
var folder = @"C:\ProgramData\Elastic\Elasticsearch\";
var yaml = $@"bootstrap.memory_lock: true
cluster.name: {clusterName}
network.host: {networkHost}
node.data: true
node.ingest: true
node.master: true
node.max_local_storage_nodes: 1
node.name: {nodeName}
path.data: {folder}data
path.logs: {folder}logs
xpack.license.self_generated.type: trial
xpack.security.enabled: false
xpack.random_setting: something
";
var fs = FakeElasticsearchYaml(yaml);
var optsFile = new ElasticsearchYamlConfiguration(_path, fs);
var settings = optsFile.Settings;
settings.NodeName.Should().Be(nodeName);
settings.ClusterName.Should().Be(clusterName);
settings.NetworkHost.Should().Be(networkHost);
settings.DataNode.Should().BeTrue();
settings.IngestNode.Should().BeTrue();
settings.MemoryLock.Should().BeTrue();
settings.DataPath.Should().Be(folder + "data");
settings.LogsPath.Should().Be(folder + "logs");
settings.MaxLocalStorageNodes.Should().Be(1);
settings.XPackSecurityEnabled.Should().BeFalse();
settings.XPackLicenseSelfGeneratedType.Should().Be(nameof(XPackLicenseMode.Trial).ToLowerInvariant());
settings.Keys.Where(k => k.StartsWith("xpack")).Should().HaveCount(1);
optsFile.Save();
var fileContentsAfterSave = fs.File.ReadAllText(_path);
fileContentsAfterSave.Replace("\r", "").Should().Be(yaml.Replace("\r", ""));
}
[Fact] void ReflectsChanges()
{
var clusterName = "my-cluster";
var yaml = $@"cluster.name: {clusterName}
some.plugin.setting: true
";
var fs = FakeElasticsearchYaml(yaml);
var optsFile = new ElasticsearchYamlConfiguration(_path, fs);
optsFile.Settings.ClusterName = "x";
optsFile.Settings["some.plugin.setting"] = false;
optsFile.Save();
var fileContentsAfterSave = fs.File.ReadAllText(_path);
var updatedYaml = $@"cluster.name: x
some.plugin.setting: false
";
fileContentsAfterSave.Replace("\r", "").Should().Be(updatedYaml.Replace("\r", ""));
}
[Fact] void UnknownSettingsAreNotLost()
{
var nodeName = "DESKTOP-O4M5B2Q";
var clusterName = "my-cluster";
var yaml = $@"cluster.name: {clusterName}
node.name: {nodeName}
some.plugin.setting: true
";
var fs = FakeElasticsearchYaml(yaml);
var optsFile = new ElasticsearchYamlConfiguration(_path, fs);
var settings = optsFile.Settings;
settings.NodeName.Should().Be(nodeName);
settings.ClusterName.Should().Be(clusterName);
optsFile.Save();
var fileContentsAfterSave = fs.File.ReadAllText(_path);
fileContentsAfterSave.Replace("\r", "").Should().Be(yaml.Replace("\r", ""));
}
public ConfigurationModel(ElasticsearchYamlConfiguration yamlConfiguration, LocalJvmOptionsConfiguration localJvmOptions)
{
this.Header = "Configuration";
this._localJvmOptions = localJvmOptions;
this._yamlSettings = yamlConfiguration?.Settings;
this.Refresh();
this.AddUnicastNode = ReactiveCommand.CreateAsyncTask(async _ => await this.AddUnicastNodeUITask());
this.WhenAnyObservable(vm => vm.AddUnicastNode)
.Subscribe(x =>
{
if (string.IsNullOrWhiteSpace(x))
{
return;
}
var nodes = x
.Split(',')
.Select(node => node.Trim())
.Where(n => !string.IsNullOrEmpty(n))
.Distinct();
foreach (var n in nodes)
{
this.UnicastNodes.Add(n);
}
});
this.WhenAny(
vm => vm.TotalPhysicalMemory,
(maxMemory) => Math.Min(maxMemory.Value / 2, CompressedOrdinaryPointersThreshold)
)
.ToProperty(this, vm => vm.MaxSelectedMemory, out maxSelectedMemory);
var canRemoveNode = this.WhenAny(vm => vm.SelectedUnicastNode, (selected) => !string.IsNullOrWhiteSpace(selected.GetValue()));
this.RemoveUnicastNode = ReactiveCommand.Create(canRemoveNode);
this.RemoveUnicastNode.Subscribe(x =>
{
this.UnicastNodes.Remove(this.SelectedUnicastNode);
});
}
protected override bool ExecuteTask()
{
this.Session.SendActionStart(TotalTicks, ActionName, "Configuring Elasticsearch", "Configuring Elasticsearch: [1]");
var locations = this.InstallationModel.LocationsModel;
var config = this.InstallationModel.ConfigurationModel;
this.Session.SendProgress(1000, "reading elasticsearch.yml from " + locations.ConfigDirectory);
var yaml = ElasticsearchYamlConfiguration.FromFolder(locations.ConfigDirectory, this.FileSystem);
this.Session.SendProgress(1000, "updating elasticsearch.yml");
var settings = yaml.Settings;
settings.ClusterName = config.ClusterName;
settings.NodeName = config.NodeName;
settings.MasterNode = config.MasterNode;
settings.DataNode = config.DataNode;
settings.IngestNode = config.IngestNode;
settings.MemoryLock = config.LockMemory;
settings.LogsPath = locations.LogsDirectory;
settings.DataPath = locations.DataDirectory;
settings.MaxLocalStorageNodes = this.InstallationModel.ServiceModel.InstallAsService ? (int?)1 : null;
settings.NetworkHost = !string.IsNullOrEmpty(config.NetworkHost) ? config.NetworkHost : null;
if (config.HttpPort.HasValue)
{
settings.HttpPortString = config.HttpPort.Value.ToString(CultureInfo.InvariantCulture);
}
if (config.TransportPort.HasValue)
{
settings.TransportTcpPortString = config.TransportPort.Value.ToString(CultureInfo.InvariantCulture);
}
var hosts = config.UnicastNodes;
settings.UnicastHosts = hosts.Any() ? hosts.ToList() : null;
yaml.Save();
this.Session.SendProgress(1000, "elasticsearch.yml updated");
return(true);
}
[Fact] void KnownSettingsAreReadCorrectly()
{
var nodeName = "DESKTOP-O4M5B2Q";
var clusterName = "my-cluster";
var networkHost = "127.0.0.1";
var folder = @"C:\ProgramData\Elastic\Elasticsearch\";
var yaml = $@"bootstrap.memory_lock: true
cluster.name: {clusterName}
network.host: {networkHost}
node.data: true
node.ingest: true
node.master: true
node.max_local_storage_nodes: 1
node.name: {nodeName}
path.data: {folder}data
path.logs: {folder}logs
";
var fs = FakeElasticsearchYaml(yaml);
var optsFile = new ElasticsearchYamlConfiguration(_path, fs);
var settings = optsFile.Settings;
settings.NodeName.Should().Be(nodeName);
settings.ClusterName.Should().Be(clusterName);
settings.NetworkHost.Should().Be(networkHost);
settings.DataNode.Should().BeTrue();
settings.IngestNode.Should().BeTrue();
settings.MemoryLock.Should().BeTrue();
settings.DataPath.Should().Be(folder + "data");
settings.LogsPath.Should().Be(folder + "logs");
settings.MaxLocalStorageNodes.Should().Be(1);
optsFile.Save();
var fileContentsAfterSave = fs.File.ReadAllText(_path);
fileContentsAfterSave.Replace("\r", "").Should().Be(yaml.Replace("\r", ""));
}
