public override void Connect(IReadOnlyCollection <Component> instanceComponents)
{
Logger.Instance.Log(LogLevel.Info, "\nConfiguring component ({0}) to work with component({1}):\n", VaultComponentId, DatabaseComponentId);
VaultComponent vaultComponent = instanceComponents.Single(c => c.Id == VaultComponentId) as VaultComponent;
DatabaseComponent databaseComponent = instanceComponents.Single(c => c.Id == DatabaseComponentId) as DatabaseComponent;
HttpServerConnection connection = ServerConnectionFactory.GetServerConnection(databaseComponent);
Innovator innovator = new Innovator(connection);
Item vaultItem = innovator.newItem("Vault", "merge");
vaultItem.setAttribute("where", string.Format(CultureInfo.InvariantCulture, "[name]='{0}'", vaultComponent.Name));
vaultItem.setProperty("name", vaultComponent.Name);
vaultItem.setProperty("vault_url_pattern", vaultComponent.VaultServerAspxUrl);
vaultItem = vaultItem.apply();
if (vaultItem.isError())
{
throw new ConnectException(
string.Format(CultureInfo.InvariantCulture, "Couldn't connect vault component '{0}' with database '{1}'. {2}",
VaultComponentId,
DatabaseComponentId,
vaultItem.ToString()));
}
vaultComponent.TargetFileSystem.XmlHelper.XmlPoke(vaultComponent.PathToConfig, "/configuration/appSettings/add[@key = 'InnovatorServerUrl']/@value", databaseComponent.InnovatorServerAspxUrl);
}
public override void Connect(IReadOnlyCollection <Component> instanceComponents)
{
Logger.Instance.Log(LogLevel.Info, "\nConfiguring component ({0}) to work with component({1}):\n", ConversionComponentId, DatabaseComponentId);
ConversionComponent conversionComponent = instanceComponents.Single(c => c.Id == ConversionComponentId) as ConversionComponent;
DatabaseComponent databaseComponent = instanceComponents.Single(c => c.Id == DatabaseComponentId) as DatabaseComponent;
HttpServerConnection connection = ServerConnectionFactory.GetServerConnection(databaseComponent);
Innovator innovator = new Innovator(connection);
Item conversionItem = innovator.newItem("ConversionServer", "merge");
conversionItem.setAttribute("where", string.Format(CultureInfo.InvariantCulture, "[name]='{0}'", conversionComponent.Name));
conversionItem.setProperty("name", conversionComponent.Name);
conversionItem.setProperty("url", conversionComponent.ConversionServiceAsmxUrl);
conversionItem.setProperty("impersonation_user_id", "EB2D5AA617FB41A28F081345B8B5FECB");
conversionItem = conversionItem.apply();
if (conversionItem.isError())
{
throw new ConnectException(
string.Format(CultureInfo.InvariantCulture, "Couldn't connect conversion component '{0}' with database '{1}'. {2}",
ConversionComponentId,
DatabaseComponentId,
conversionItem.ToString()));
}
conversionComponent.TargetFileSystem.XmlHelper.XmlPoke(conversionComponent.PathToConfig, "/configuration/ConversionServer/InnovatorServer/@url", databaseComponent.InnovatorServerAspxUrl);
}
public override void Connect(IReadOnlyCollection <Component> instanceComponents)
{
Logger.Instance.Log(LogLevel.Info, "\nConfiguring components ({0}, {1}, {2}, {3}) to work with component({4}):\n", ESAgentComponentId, ESIndexComponentId, ESZookeeperComponentId, ESFileProcessorComponentId, DatabaseComponentId);
ESAgentComponent esAgent = instanceComponents.Single(c => c.Id == ESAgentComponentId) as ESAgentComponent;
ESIndexComponent esIndex = instanceComponents.Single(c => c.Id == ESIndexComponentId) as ESIndexComponent;
ESZooKeeperComponent esZooKeeper = instanceComponents.Single(c => c.Id == ESZookeeperComponentId) as ESZooKeeperComponent;
ESFileProcessorComponent esFileProcessor = instanceComponents.Single(c => c.Id == ESFileProcessorComponentId) as ESFileProcessorComponent;
DatabaseComponent databaseComponent = instanceComponents.Single(c => c.Id == DatabaseComponentId) as DatabaseComponent;
DropSolrIndex(esIndex);
string serviceNameXPath = "/configuration/ServiceName";
esFileProcessor.ServiceName = FileSystemFactory.GetFileSystem(esFileProcessor.ServerName).XmlHelper.XmlPeek(esFileProcessor.PathToConfig, serviceNameXPath);
WindowsServiceHelper.StopService(esFileProcessor.ServerName, esFileProcessor.ServiceName);
esAgent.ServiceName = FileSystemFactory.GetFileSystem(esAgent.ServerName).XmlHelper.XmlPeek(esAgent.PathToConfig, serviceNameXPath);
WindowsServiceHelper.StopService(esAgent.ServerName, esAgent.ServiceName);
esIndex.ServiceName = FileSystemFactory.GetFileSystem(esIndex.ServerName).XmlHelper.XmlPeek(esIndex.PathToConfig, serviceNameXPath);
WindowsServiceHelper.StopService(esIndex.ServerName, esIndex.ServiceName);
esZooKeeper.ServiceName = FileSystemFactory.GetFileSystem(esZooKeeper.ServerName).XmlHelper.XmlPeek(esZooKeeper.PathToConfig, serviceNameXPath);
WindowsServiceHelper.StopService(esZooKeeper.ServerName, esZooKeeper.ServiceName);
//Wait Until services are stopped for 30 seconds
Thread.Sleep(30000);
HttpServerConnection connection = IomFactory.CreateHttpServerConnection(databaseComponent.InnovatorUrl, databaseComponent.DatabaseName, databaseComponent.LoginOfRootInnovatorUser, databaseComponent.PasswordOfRootInnovatorUser.Value);
try
{
connection.Login();
Innovator innovator = new Innovator(connection);
EditVariable(innovator, "ES_SolrUrl", esIndex.ESAIClusterUrl);
EditVariable(innovator, "ES_AIClusterUrl", esIndex.ESAIClusterUrl);
EditCryptoPwd(innovator, esAgent);
}
finally
{
connection.Logout();
}
UpdateESZooKeeperServiceConfig(esZooKeeper, databaseComponent);
WindowsServiceHelper.StartService(esZooKeeper.ServerName, esZooKeeper.ServiceName);
UpdateESIndexServiceConfig(esIndex, databaseComponent);
WindowsServiceHelper.StartService(esIndex.ServerName, esIndex.ServiceName);
UpdateESAgentServiceConfig(esAgent, databaseComponent);
WindowsServiceHelper.StartService(esAgent.ServerName, esAgent.ServiceName);
UpdateESFileProcessorServiceConfig(esFileProcessor, databaseComponent);
WindowsServiceHelper.StartService(esFileProcessor.ServerName, esFileProcessor.ServiceName);
ReloadSolrCollection(esIndex);
}
private void RunLanguageTool(string pathtoLanguagePacks, DatabaseComponent databaseComponent)
{
if (Directory.Exists(pathtoLanguagePacks))
{
Logger.Instance.Log(LogLevel.Info, "\nApplying language packs to ({0}):\n", databaseComponent.Id);
foreach (string languageCodeFolder in Directory.GetDirectories(pathtoLanguagePacks))
{
string languageCode = languageCodeFolder.Substring(languageCodeFolder.LastIndexOf('\\') + 1);
foreach (string pathToLanguageToolConfig in Directory.GetFiles(languageCodeFolder, "ImportConfig.xml", SearchOption.AllDirectories))
{
string pathToLanguagePacksXmlDir = Path.Combine(Path.GetDirectoryName(pathToLanguageToolConfig), "xml");
int languageToolResultCode = ProcessWrapper.Execute(LogLevel.None, Properties.PathToLanguageTool,
"-import -config_file:\"{0}\" -folder:\"{1}\" -language_code:\"{2}\" -server:\"{3}\" -db:\"{4}\" -login:\"{5}\" -pwd:\"{6}\"",
pathToLanguageToolConfig,
pathToLanguagePacksXmlDir,
languageCode,
databaseComponent.SqlServer,
databaseComponent.DatabaseName,
databaseComponent.InnovatorLogin,
databaseComponent.InnovatorPassword.Value);
if (languageToolResultCode != 0)
{
throw new Exception(string.Format(CultureInfo.InvariantCulture, "Failed to apply Language packs from {0}, LangugeTool.exe returned exit code {1}.", pathtoLanguagePacks, languageToolResultCode));
}
}
}
}
}
public RootUserEnabler(DatabaseComponent databaseComponent)
{
_databaseComponent = databaseComponent;
string rootUserLogonEnabled = RetrieveRootLogonEnabled();
_preservedRootUserLogonEnabled = rootUserLogonEnabled.Equals("1", StringComparison.OrdinalIgnoreCase) ? true : false;
}
void OnClick()
{
Debug.Log("Refreshing List");
ScreenLogger.Instance.clearText();
DatabaseComponent databaseComponent = databaseComponentGO.GetComponent <DatabaseComponent>();
StartCoroutine(databaseComponent.testDatabases());
optionsPanelGO.SetActive(false);
}
private void CreateLMInfos(DatabaseComponent database)
{
foreach (var item in database.LMCommands)
{
lmCommandList.Add(new LMCommandPara(item));
}
foreach (var item in database.LMHDParas)
{
lmHDParaList.Add(new LMHDPara(item));
}
foreach (var item in database.LMVInfos)
{
LMVInfo lmVInfo = new LMVInfo(item);
var lmDivFres = database.LMDivFres.Where(o => o.ChannelID == item.ChannelID).ToArray();
foreach (var lmDivfre in lmDivFres)
{
lmVInfo.DivFres.Add(new LMDivFre(lmDivfre));
}
lmVInfoList.Add(lmVInfo);
}
foreach (var item in database.LMAnInfos)
{
lmAnInfoList.Add(new LMAnInfo(item));
if (item.SignalType == 2)
{
int slotnum = item.SlotNum;
}
}
foreach (var item in database.LMVideos)
{
lmVideos.Add(new LMVedio(item));
}
foreach (var item in database.TrdDataContracts)
{
trdDataMapperList.Add(new ThirdDataMapper(item));
}
var availableRS = LMAnInfos.Where(o => o.SignalType == SignalType.Digital).GroupBy(o => o.IP);
foreach (var item in availableRS)
{
var availableRSlotNums = item.Select(o => o.SlotNum).Distinct().ToArray();
var availableRChaNs = item.Select(o => o.ChaN).Distinct().ToArray();
foreach (var lmHD in LMHDParas.Where(o => o.IP == item.Key))
{
lmHD.AvailableRSlotNums = availableRSlotNums;
lmHD.AvailableRChaNs = availableRChaNs;
}
foreach (var lmVInfo in LMVInfos.Where(o => o.IP == item.Key))
{
lmVInfo.AvailableRSlotNums = availableRSlotNums;
lmVInfo.AvailableRChaNs = availableRChaNs;
}
}
}
private static void UpdateESAgentServiceConfig(ESAgentComponent esAgent, DatabaseComponent databaseComponent)
{
string innovatorUrlXPath = "/configuration/Aras_Innovator_URL";
string innovatorDBPath = "/configuration/Aras_Innovator_DB";
IFileSystem targetFileSystem = FileSystemFactory.GetFileSystem(esAgent.ServerName);
targetFileSystem.XmlHelper.XmlPoke(esAgent.PathToConfig, innovatorUrlXPath, databaseComponent.InnovatorUrl);
targetFileSystem.XmlHelper.XmlPoke(esAgent.PathToConfig, innovatorDBPath, databaseComponent.DatabaseName);
}
public override void Connect(IReadOnlyCollection <Component> instanceComponents)
{
Logger.Instance.Log(LogLevel.Info, "\nConfiguring component ({0}) to work with component({1}):\n", DatabaseComponentId, AgentComponentId);
DatabaseComponent databaseComponent = instanceComponents.Single(c => c.Id == DatabaseComponentId) as DatabaseComponent;
AgentComponent agentComponent = instanceComponents.Single(c => c.Id == AgentComponentId) as AgentComponent;
SetupConversionTasksForAgentService(agentComponent, databaseComponent);
agentComponent.TargetFileSystem.XmlHelper.XmlPoke(agentComponent.PathToConfig, "/configuration/appSettings/add[@key='InnovatorServer']/@value", databaseComponent.InnovatorServerAspxUrl);
}
public override void Connect(IReadOnlyCollection <Component> instanceComponents)
{
Logger.Instance.Log(LogLevel.Info, "\nConfiguring component ({0}) to work with component({1}):\n", DatabaseComponentId, InnovatorComponentId);
DatabaseComponent databaseComponent = instanceComponents.Single(c => c.Id == DatabaseComponentId) as DatabaseComponent;
InnovatorComponent innovatorComponent = instanceComponents.Single(c => c.Id == InnovatorComponentId) as InnovatorComponent;
innovatorComponent.TargetFileSystem.XmlHelper.AppendFragment(
GetDBConnectionString(databaseComponent),
innovatorComponent.TargetFileSystem.XmlHelper.GetNode(innovatorComponent.PathToConfig, "/Innovator"));
}
private string GetConnectionString(DatabaseComponent databaseComponent)
{
const string dbConnectionTemplate = "Data Source={0};Initial Catalog={1};Persist Security Info=True;Pooling=False;User ID={2};Password={3};";
return(string.Format(
CultureInfo.InvariantCulture,
dbConnectionTemplate,
databaseComponent.SqlServer,
databaseComponent.DatabaseName,
databaseComponent.InnovatorLogin,
databaseComponent.InnovatorPassword.Value));
}
private string GetDBConnectionString(DatabaseComponent databaseComponent)
{
const string dbConnectionTemplate = "<DB-Connection dbType=\"SQL Server\" provider=\"MSDASQL\" driver=\"{{SQL Server}}\" id=\"{0}\" server=\"{1}\" database=\"{2}\" dbo_uid=\"{3}\" dbo_pwd=\"{4}\" regular_uid=\"{5}\" regular_pwd=\"{6}\" />";
return(string.Format(
CultureInfo.InvariantCulture,
dbConnectionTemplate,
databaseComponent.DatabaseName,
databaseComponent.SqlServer,
databaseComponent.DatabaseName,
databaseComponent.InnovatorLogin,
databaseComponent.InnovatorPassword.Value,
databaseComponent.InnovatorRegularLogin,
databaseComponent.InnovatorRegularPassword.Value));
}
public override void Connect(IReadOnlyCollection <Component> instanceComponents)
{
Logger.Instance.Log(LogLevel.Info, "\nConfiguring component ({0}) to work with component({1}):\n", DatabaseComponentId, SchedulerComponentId);
DatabaseComponent databaseComponent = instanceComponents.Single(c => c.Id == DatabaseComponentId) as DatabaseComponent;
SchedulerComponent schedulerComponent = instanceComponents.Single(c => c.Id == SchedulerComponentId) as SchedulerComponent;
XmlDocument innovatorServiceConfig = schedulerComponent.TargetFileSystem.XmlHelper.OpenDocument(schedulerComponent.PathToConfig);
XmlNodeList innovatorNodes = innovatorServiceConfig.SelectNodes("/innovators/innovator");
for (int i = 0; i < innovatorNodes.Count; i++)
{
XmlNode innovatorNode = innovatorNodes[i];
XmlNode serverNode = innovatorNode.SelectSingleNode("server");
XmlNode databaseNode = innovatorNode.SelectSingleNode("database");
XmlNode usernameNode = innovatorNode.SelectSingleNode("username");
XmlNode passwordNode = innovatorNode.SelectSingleNode("password");
Logger.Instance.Log(LogLevel.Info, "\tSetting the '{0}' value for innovator[{1}]/server node.", databaseComponent.InnovatorUrl, i);
serverNode.InnerText = databaseComponent.InnovatorUrl;
Logger.Instance.Log(LogLevel.Info, "\tSetting the '{0}' value for innovator[{1}]/database node.", databaseComponent.DatabaseName, i);
databaseNode.InnerText = databaseComponent.DatabaseName;
if (string.Equals(usernameNode.InnerText, "{user}", StringComparison.OrdinalIgnoreCase))
{
Logger.Instance.Log(LogLevel.Info, "\tSetting the '{0}' value for innovator[{1}]/username node.", SchedulerManagerUser, i);
usernameNode.InnerText = SchedulerManagerUser;
}
if (string.Equals(passwordNode.InnerText, "{password}", StringComparison.OrdinalIgnoreCase))
{
Logger.Instance.Log(LogLevel.Info, "\tSetting the '{0}' value for innovator[{1}]/password node.", SchedulerManagerPassword.Value, i);
passwordNode.InnerText = SchedulerManagerPassword.Value;
}
}
schedulerComponent.TargetFileSystem.XmlHelper.SaveXmlDocument(innovatorServiceConfig);
}
public override void ApplyToDatabaseComponent(DatabaseComponent databaseComponent)
{
Logger.Instance.Log(LogLevel.Info, "\nDeploying component ({0}):\n", databaseComponent.Id);
if (FeatureLicenses != null && FeatureLicenses.Count > 0)
{
Logger.Instance.Log(LogLevel.Info, "\t Applying feature licenses to {0}...", databaseComponent.Id);
FeatureLicenseManager featureLicenseManager = new FeatureLicenseManager(
databaseComponent.InnovatorUrl,
databaseComponent.DatabaseName,
databaseComponent.LoginOfRootInnovatorUser,
databaseComponent.PasswordOfRootInnovatorUser.Value);
foreach (SecretString featureLicense in FeatureLicenses)
{
featureLicenseManager.ImportFeatureLicense(featureLicense.Value);
}
}
string pathToPreAmlDeploymentScripts = Path.Combine(PathToDeploymentPackage, databaseComponent.PreAmlDeploymentScriptsDirectoryName);
if (Directory.Exists(pathToPreAmlDeploymentScripts))
{
Logger.Instance.Log(LogLevel.Info, "\nApplying pre-deployment AML script to ({0}):\n", databaseComponent.Id);
databaseComponent.ApplyAmlsFromFolderRecursively(pathToPreAmlDeploymentScripts);
}
RunConsoleUpgrade(Path.Combine(PathToDeploymentPackage, databaseComponent.AmlPackagesDirectoryName), databaseComponent);
RunLanguageTool(Path.Combine(PathToDeploymentPackage, databaseComponent.LanguagePacksDirectoryName), databaseComponent);
string pathToPostAmlDeploymentScripts = Path.Combine(PathToDeploymentPackage, databaseComponent.PostAmlDeploymentScriptsDirectoryName);
if (Directory.Exists(pathToPostAmlDeploymentScripts))
{
Logger.Instance.Log(LogLevel.Info, "\nApplying post-deployment AML script to ({0}):\n", databaseComponent.Id);
databaseComponent.ApplyAmlsFromFolderRecursively(pathToPostAmlDeploymentScripts);
}
foreach (Variable variable in Variables)
{
databaseComponent.ApplyAml(variable.Aml);
}
}
private void PrintInstanceUrls()
{
Logger.Instance.Log(LogLevel.Info, "\n\nPrint.Url.Of.Installed.Innovator:\n");
Logger.Instance.Log(LogLevel.Info, "********************************************************************************");
HashSet <string> printedUrls = new HashSet <string>();
foreach (Component component in Components)
{
DatabaseComponent databaseComponent = component as DatabaseComponent;
if (databaseComponent != null && printedUrls.Add(databaseComponent.InnovatorUrl))
{
Logger.Instance.Log(LogLevel.Info, "URL of configured Innovator is: {0}", databaseComponent.InnovatorUrl);
}
}
Logger.Instance.Log(LogLevel.Info, "********************************************************************************");
}
internal static void CheckAmlApplicability(DatabaseComponent databaseComponent)
{
Logger.Instance.Log(LogLevel.Info, "Checking that we can apply AML to '{0}' component", databaseComponent.Id);
HttpServerConnection connection = ServerConnectionFactory.GetServerConnection(databaseComponent);
Innovator innovator = new Innovator(connection);
string aml = "<AML />";
Item result = innovator.applyAML(aml);
if (result.isError())
{
Logger.Instance.Log(LogLevel.Error, result.ToString());
throw new ValidationException(string.Format(CultureInfo.InvariantCulture, "Failed to apply AML: {0}.", aml));
}
Logger.Instance.Log(LogLevel.Info, "OK");
}
internal static HttpServerConnection GetServerConnection(DatabaseComponent databaseComponent)
{
if (Instance._usedServerConnections.ContainsKey(databaseComponent.Id))
{
return(Instance._usedServerConnections[databaseComponent.Id]);
}
HttpServerConnection serverConnection = IomFactory.CreateHttpServerConnection(
databaseComponent.InnovatorUrl,
databaseComponent.DatabaseName,
databaseComponent.LoginOfRootInnovatorUser,
databaseComponent.PasswordOfRootInnovatorUser.Value);
serverConnection.Login();
Instance._usedServerConnections.Add(databaseComponent.Id, serverConnection);
return(serverConnection);
}
public override void Connect(IReadOnlyCollection <Component> instanceComponents)
{
Logger.Instance.Log(LogLevel.Info, "\nConfiguring component ({0}) to work with component({1}):\n", DatabaseComponentId, SelfServiceReportingComponentId);
DatabaseComponent databaseComponent = instanceComponents.Single(c => c.Id == DatabaseComponentId) as DatabaseComponent;
SelfServiceReportingComponent selfServiceReportingComponent = instanceComponents.Single(c => c.Id == SelfServiceReportingComponentId) as SelfServiceReportingComponent;
selfServiceReportingComponent.TargetFileSystem.XmlHelper.AppendFragment(
GetConnectionString(databaseComponent),
selfServiceReportingComponent.TargetFileSystem.XmlHelper.GetNode(selfServiceReportingComponent.PathToConfig,
"/configuration/connectionStrings/add/@connectionString"));
selfServiceReportingComponent.TargetFileSystem.XmlHelper.AppendFragment(
databaseComponent.DatabaseName,
selfServiceReportingComponent.TargetFileSystem.XmlHelper.GetNode(selfServiceReportingComponent.PathToConfig,
"/configuration/connectionStrings/add/@name"));
selfServiceReportingComponent.TargetFileSystem.XmlHelper.XmlPoke(
selfServiceReportingComponent.PathToConfig,
"/configuration/appSettings/add[@key = 'inn_server_url']/@value",
databaseComponent.InnovatorServerAspxUrl);
}
private void RunConsoleUpgrade(string pathToAmlPackages, DatabaseComponent databaseComponent)
{
if (Directory.Exists(pathToAmlPackages))
{
Logger.Instance.Log(LogLevel.Info, "\nApplying AML packages to ({0}):\n", databaseComponent.Id);
int consoleUpgradeResultCode = ProcessWrapper.Execute(LogLevel.None, Properties.PathToConsoleUpgrade,
"database=\"{0}\" server=\"{1}\" login=\"root\" password=\"{2}\" release=\"{3}\" mfFile=\"{4}\" import verbose merge dir=\"{5}\" log=\"{6}\" timeout=\"1000000\"",
databaseComponent.DatabaseName,
databaseComponent.InnovatorUrl,
databaseComponent.PasswordOfRootInnovatorUser.Value,
Properties.InnovatorVersion, Path.Combine(pathToAmlPackages, databaseComponent.AmlPackagesManifest),
pathToAmlPackages,
databaseComponent.PathToConsoleUpgradeLogFile);
if (consoleUpgradeResultCode != 0)
{
throw new Exception(string.Format(CultureInfo.InvariantCulture, "Failed to apply AML packages from {0}, consoleUpgrade.exe returned exit code {1}.", pathToAmlPackages, consoleUpgradeResultCode));
}
}
}
public override void ApplyToDatabaseComponent(DatabaseComponent databaseComponent)
{
Dictionary <string, string> propertyNameMapper = new Dictionary <string, string>
{
{ nameof(databaseComponent.InnovatorUrl), "Innovator.URL" },
{ nameof(databaseComponent.DatabaseName), "Innovator.DB" },
{ nameof(databaseComponent.LoginOfRootInnovatorUser), "Innovator.Username" },
{ nameof(databaseComponent.PasswordOfRootInnovatorUser), "Innovator.Password" },
{ nameof(databaseComponent.PreAmlDeploymentScriptsDirectoryName), "Pre.Aml.Deployment.Scripts.Name" },
{ nameof(databaseComponent.PostAmlDeploymentScriptsDirectoryName), "Post.Aml.Deployment.Scripts.Name" },
{ nameof(databaseComponent.SqlServer), "Server" },
{ nameof(databaseComponent.InnovatorLogin), "Language.Pack.Innovator.Username" },
{ nameof(databaseComponent.InnovatorPassword), "Language.Pack.Innovator.Password" }
};
const string pathToLanguagePackKey = "Path.To.Language.Packs";
_commonProperties.Add(pathToLanguagePackKey, Path.Combine(PathToDeploymentPackage, databaseComponent.LanguagePacksDirectoryName));
RunArasUpdateCmdForComponent(databaseComponent, propertyNameMapper);
_commonProperties.Remove(pathToLanguagePackKey);
}
private static void UpdateESFileProcessorServiceConfig(ESFileProcessorComponent esFileProcessor, DatabaseComponent databaseComponent)
{
string innovatorUrlXPath = "/configuration/FileProcessor/ArasInnovatorURL";
string innovatorDBPath = "/configuration/FileProcessor/ArasInnovatorDB";
IFileSystem targetFileSystem = FileSystemFactory.GetFileSystem(esFileProcessor.ServerName);
targetFileSystem.XmlHelper.XmlPoke(esFileProcessor.PathToConfig, innovatorUrlXPath, databaseComponent.InnovatorUrl);
targetFileSystem.XmlHelper.XmlPoke(esFileProcessor.PathToConfig, innovatorDBPath, databaseComponent.DatabaseName);
}
public virtual void Visit(DatabaseComponent cmp)
{
}
internal async Task Start()
{
Logger.Server = this;
Events = new EventManager();
Players = new List <Player>();
Levels = new List <Level>();
// Setup server
Console.BackgroundColor = ConsoleColor.Black;
Console.Clear();
start = DateTime.Now;
input = string.Empty;
clear = new string(' ', Console.WindowWidth);
var stopwatch = Stopwatch.StartNew();
Logger.WriteLine($"{Constants.Strings.ServerTitle}");
Logger.WriteLine($"Server is starting now, on {DateTime.Now.ToString("U", new CultureInfo("en-US"))}");
// Initialize Properties
Commands = CommandParser.CreateNew().UsePrefix(string.Empty).OnError(OnParseError);
RegisterCommands();
// Initialize Components
IO = new IOComponent(this);
Plugins = new PluginComponent(this);
Database = new DatabaseComponent(this);
Net = new NetworkComponent(this);
await IO.Init();
await Plugins.Init();
await Database.Init();
await Net.Init();
// Create save timer
saveTimer = new Timer(IO.Config.Server.AutoSaveTime * 1000 * 60);
saveTimer.Elapsed += async(sender, args) => await SaveAll();
saveTimer.Start();
stopwatch.Stop();
Logger.WriteBreak();
Logger.WriteLine("Ready. ({0}s) Type /help for commands.", Math.Round(stopwatch.Elapsed.TotalSeconds, 2));
Logger.WriteBreak();
WriteHeader();
while (true) // Parse commands now that messaging has been handed off to another thread
{
input = string.Empty;
WriteCommandCursor();
// Read input and parse commands
while (true)
{
var key = Console.ReadKey(true);
if (key.Key == ConsoleKey.Backspace)
{
if (input.Length - 1 >= 0)
{
input = input.Substring(0, input.Length - 1);
Console.CursorLeft = 3 + input.Length - 1;
Console.Write(' ');
Console.CursorLeft = 3 + input.Length - 1;
}
continue;
}
if (key.Key == ConsoleKey.Enter)
{
Console.WriteLine("");
break;
}
input += key.KeyChar;
Console.Write(key.KeyChar);
}
Commands.Parse(input.Trim());
WriteHeader();
}
// ReSharper disable once FunctionNeverReturns
}
public abstract void ApplyToDatabaseComponent(DatabaseComponent databaseComponent);
public override void Visit(DatabaseComponent cmp)
{
VisitComponent(cmp);
}
private void SetupConversionTasksForAgentService(AgentComponent agentComponent, DatabaseComponent databaseComponent)
{
XmlDocument conversionConfig = agentComponent.TargetFileSystem.XmlHelper.OpenDocument(agentComponent.PathToConversionConfig);
foreach (XmlNode cycleNode in conversionConfig.SelectNodes("/configuration/Innovator/Conversion/ProcessingCycles/cycle"))
{
XmlNode dbAttribute = cycleNode.SelectSingleNode("@DB");
XmlNode userAttribute = cycleNode.SelectSingleNode("@User");
XmlNode passwordAttribute = cycleNode.SelectSingleNode("@Password");
Logger.Instance.Log(LogLevel.Info, "\tSetting the '{0}' value for @DB attribute for cycle element.", databaseComponent.DatabaseName);
dbAttribute.InnerText = databaseComponent.DatabaseName;
if (string.Equals(userAttribute.InnerText, "{user}", StringComparison.OrdinalIgnoreCase))
{
Logger.Instance.Log(LogLevel.Info, "\tSetting the '{0}' value for @User attribute for cycle element.", agentComponent.ConversionManagerUser);
userAttribute.InnerText = agentComponent.ConversionManagerUser;
}
if (passwordAttribute != null && string.Equals(passwordAttribute.InnerText, "{password}", StringComparison.OrdinalIgnoreCase))
{
Logger.Instance.Log(LogLevel.Info, "\tSetting the '{0}' value for @Password attribute for cycle element.", agentComponent.ConversionManagerPassword);
passwordAttribute.InnerText = agentComponent.ConversionManagerPassword;
}
}
agentComponent.TargetFileSystem.XmlHelper.SaveXmlDocument(conversionConfig);
}
public override void OnInspectorGUI()
{
_databaseComponent = target as DatabaseComponent;
#region ReloadAll
if (GUILayout.Button("ReloadAll"))
{
// read all categories
var categories = ServerEditor.Get <List <Category> >(@"Categories", "Download categories", "Download");
if (categories == null)
{
return;
}
_databaseComponent.SetCategories(categories);
// read all puzzles
List <Puzzle> puzzles = ServerEditor.Get <List <Puzzle> >(@"Puzzles", "Download puzzles", "Download");
if (puzzles == null)
{
return;
}
_databaseComponent.SetPuzzles(puzzles);
// create game objects
_databaseComponent.ReloadAll();
}
#endregion
#region UpdateData All
if (GUILayout.Button("UpdateData All"))
{
// Update categories
var categoryComponents = _databaseComponent.GetComponentsInChildren <CategoryComponent>();
foreach (var categoryComponent in categoryComponents)
{
if (categoryComponent.Dirty)
{
CategoryEditor.UpdateServer(categoryComponent);
}
}
//Update puzzles
var puzzleComponents = _databaseComponent.GetComponentsInChildren <PuzzleComponent>();
foreach (var puzzleComponent in puzzleComponents)
{
if (puzzleComponent.Dirty)
{
PuzzleEditor.UpdateServer(puzzleComponent);
}
}
}
#endregion
#region Sync localDB
if (GUILayout.Button("Sync All with localDB"))
{
// read all categories
var categories = ServerEditor.Get <List <Category> >(@"Categories", "Download categories", "Download");
if (categories == null)
{
return;
}
// read all puzzles
List <Puzzle> puzzles = ServerEditor.Get <List <Puzzle> >(@"Puzzles", "Download puzzles", "Download");
if (puzzles == null)
{
return;
}
LocalDBController.DeleteAll <Category>();
LocalDBController.DeleteAll <Puzzle>();
foreach (Category category in categories)
{
LocalDBController.InsertOrReplace(category);
}
foreach (Puzzle puzzle in puzzles)
{
LocalDBController.InsertOrReplace(puzzle);
}
}
#endregion
}
public override void Visit(DatabaseComponent cmp)
{
LinePointMoved(cmp);
}
public void SetComponent(DatabaseComponent rectComponent)
{
this.rectComponent = rectComponent;
this.Component = rectComponent;
this.rectComponent.View = this;
}
