mirror of
https://github.com/tgstation/tgstation-server.git
synced 2026-08-26 14:37:44 +01:00
711 lines
21 KiB
C#
711 lines
21 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Security.Principal;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Description;
|
|
using TGS.Interface;
|
|
using TGS.Interface.Components;
|
|
using TGS.Server.Security;
|
|
|
|
namespace TGS.Server
|
|
{
|
|
/// <summary>
|
|
/// The windows service the application runs as
|
|
/// </summary>
|
|
[ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple, InstanceContextMode = InstanceContextMode.Single)]
|
|
public sealed class Server : ITGSService, ITGConnectivity, ITGLanding, ITGInstanceManager, IDisposable
|
|
{
|
|
/// <summary>
|
|
/// The logging ID used for <see cref="Server"/> events
|
|
/// </summary>
|
|
public const byte LoggingID = 0;
|
|
|
|
/// <summary>
|
|
/// The directory to use when importing a .NET settings based config
|
|
/// </summary>
|
|
public const string MigrationConfigDirectory = "C:\\TGSSettingUpgradeTempDir";
|
|
|
|
/// <summary>
|
|
/// The service version <see cref="string"/> based on the <see cref="AssemblyName"/>'s <see cref="System.Version"/>
|
|
/// </summary>
|
|
public static readonly string VersionString = String.Format("/tg/station 13 Server v{0}", Assembly.GetExecutingAssembly().GetName().Version);
|
|
|
|
/// <summary>
|
|
/// Singleton <see cref="ILogger"/>
|
|
/// </summary>
|
|
public static ILogger Logger { get; private set; }
|
|
|
|
/// <summary>
|
|
/// The <see cref="ServerConfig"/> for the <see cref="Server"/>
|
|
/// </summary>
|
|
public static ServerConfig Config { get; private set; }
|
|
|
|
/// <summary>
|
|
/// The directory to load and save <see cref="ServerConfig"/>s to
|
|
/// </summary>
|
|
static readonly string DefaultConfigDirectory = Directory.CreateDirectory(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "TGS.Server")).FullName;
|
|
|
|
/// <summary>
|
|
/// Begins user impersonation to allow proper restricted file access
|
|
/// </summary>
|
|
public static void BeginImpersonation()
|
|
{
|
|
WindowsIdentity.Impersonate(OperationContext.Current.ServiceSecurityContext.WindowsIdentity.Token);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cancels WCF's user impersonation to allow clean access to writing log files
|
|
/// </summary>
|
|
public static void CancelImpersonation()
|
|
{
|
|
WindowsIdentity.Impersonate(IntPtr.Zero);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks an <paramref name="instanceName"/> for illegal characters
|
|
/// </summary>
|
|
/// <param name="instanceName">The <see cref="Instance"/> name to check</param>
|
|
/// <returns><see langword="null"/> if <paramref name="instanceName"/> contains no illegal characters, error message otherwise</returns>
|
|
static string CheckInstanceName(string instanceName)
|
|
{
|
|
char[] bannedCharacters = { ';', '&', '=', '%' };
|
|
foreach (var I in bannedCharacters)
|
|
if (instanceName.Contains(I.ToString()))
|
|
return "Instance names may not contain the following characters: ';', '&', '=', or '%'";
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The WCF host that contains <see cref="ITGSService"/> connects to
|
|
/// </summary>
|
|
ServiceHost serviceHost;
|
|
/// <summary>
|
|
/// Map of <see cref="InstanceConfig.Name"/> to the respective <see cref="ServiceHost"/> hosting the <see cref="Instance"/>
|
|
/// </summary>
|
|
IDictionary<string, ServiceHost> hosts;
|
|
/// <summary>
|
|
/// List of <see cref="Instance.LoggingID"/>s in use
|
|
/// </summary>
|
|
IList<int> UsedLoggingIDs = new List<int>();
|
|
|
|
/// <summary>
|
|
/// Construct a <see cref="Server"/>
|
|
/// </summary>
|
|
/// <param name="args">Command line arguments for the <see cref="Server"/></param>
|
|
/// <param name="logger">The <see cref="ILogger"/> to use</param>
|
|
public Server(string[] args, ILogger logger)
|
|
{
|
|
Logger = logger;
|
|
|
|
Environment.CurrentDirectory = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), Assembly.GetExecutingAssembly().GetName().Name)).FullName; //MOVE THIS POINTER BECAUSE ONE TIME I ALMOST ACCIDENTALLY NUKED MYSELF BY REFACTORING! http://imgur.com/zvGEpJD.png
|
|
|
|
SetupConfig();
|
|
|
|
ChangePortFromCommandLine(args);
|
|
|
|
SetupService();
|
|
|
|
SetupInstances();
|
|
|
|
OnlineAllHosts();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerates configured <see cref="IInstanceConfig"/>s. Detaches those that fail to load
|
|
/// </summary>
|
|
/// <returns>Each configured <see cref="IInstanceConfig"/></returns>
|
|
IEnumerable<IInstanceConfig> GetInstanceConfigs()
|
|
{
|
|
var pathsToRemove = new List<string>();
|
|
lock (this)
|
|
{
|
|
var IPS = Config.InstancePaths;
|
|
foreach (var I in IPS)
|
|
{
|
|
IInstanceConfig ic;
|
|
try
|
|
{
|
|
ic = InstanceConfig.Load(I);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.WriteError(String.Format("Unable load instance config at path {0}. Error: {1} Detaching...", I, e.ToString()), EventID.InstanceInitializationFailure, LoggingID);
|
|
pathsToRemove.Add(I);
|
|
continue;
|
|
}
|
|
yield return ic;
|
|
}
|
|
foreach (var I in pathsToRemove)
|
|
IPS.Remove(I);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overrides and saves the configured <see cref="ServerConfig.RemoteAccessPort"/> if requested by command line parameters
|
|
/// </summary>
|
|
/// <param name="args">The command line parameters for the <see cref="Server"/></param>
|
|
void ChangePortFromCommandLine(string[] args)
|
|
{
|
|
for (var I = 0; I < args.Length - 1; ++I)
|
|
if (args[I].ToLower() == "-port")
|
|
{
|
|
try
|
|
{
|
|
var res = Convert.ToUInt16(args[I + 1]);
|
|
if (res == 0)
|
|
throw new Exception("Cannot bind to port 0");
|
|
Config.RemoteAccessPort = res;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new Exception("Invalid argument for \"-port\"", e);
|
|
}
|
|
Config.Save(DefaultConfigDirectory);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Upgrades up the service configuration
|
|
/// </summary>
|
|
void SetupConfig()
|
|
{
|
|
Directory.CreateDirectory(DefaultConfigDirectory);
|
|
try
|
|
{
|
|
Config = ServerConfig.Load(DefaultConfigDirectory);
|
|
}
|
|
catch
|
|
{
|
|
try
|
|
{
|
|
//assume we're upgrading
|
|
Config = ServerConfig.Load(MigrationConfigDirectory);
|
|
Config.Save(DefaultConfigDirectory);
|
|
Helpers.DeleteDirectory(MigrationConfigDirectory);
|
|
}
|
|
catch
|
|
{
|
|
//new baby
|
|
Config = new ServerConfig();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates the <see cref="ServiceHost"/> for <see cref="ITGSService"/>
|
|
/// </summary>
|
|
void SetupService()
|
|
{
|
|
serviceHost = CreateHost(this, Definitions.MasterInterfaceName);
|
|
AddEndpoint(serviceHost, typeof(ITGConnectivity));
|
|
AddEndpoint(serviceHost, typeof(ITGInstanceManager));
|
|
AddEndpoint(serviceHost, typeof(ITGLanding));
|
|
AddEndpoint(serviceHost, typeof(ITGSService));
|
|
serviceHost.Authorization.ServiceAuthorizationManager = new RootAuthorizationManager(); //only admins can diddle us
|
|
serviceHost.Authentication.ServiceAuthenticationManager = new AuthenticationHeaderDecoder();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Opens all created <see cref="ServiceHost"/>s
|
|
/// </summary>
|
|
void OnlineAllHosts()
|
|
{
|
|
serviceHost.Open();
|
|
foreach (var I in hosts)
|
|
I.Value.Open();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a <see cref="ServiceHost"/> for <paramref name="singleton"/> using the default pipe, CloseTimeout for the <see cref="ServiceHost"/>, and the configured <see cref="ServerConfig.RemoteAccessPort"/>
|
|
/// </summary>
|
|
/// <param name="singleton">The <see cref="ServiceHost.SingletonInstance"/></param>
|
|
/// <param name="endpointPostfix">The URL to access components on the <see cref="ServiceHost"/></param>
|
|
/// <returns>The created <see cref="ServiceHost"/></returns>
|
|
static ServiceHost CreateHost(object singleton, string endpointPostfix)
|
|
{
|
|
return new ServiceHost(singleton, new Uri[] { new Uri(String.Format("net.pipe://localhost/{0}", endpointPostfix)), new Uri(String.Format("https://localhost:{0}/{1}", Config.RemoteAccessPort, endpointPostfix)) })
|
|
{
|
|
CloseTimeout = new TimeSpan(0, 0, 5)
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates <see cref="ServiceHost"/>s for all <see cref="Instance"/>s as listed in <see cref="ServerConfig.InstancePaths"/>, detaches bad ones
|
|
/// </summary>
|
|
void SetupInstances()
|
|
{
|
|
hosts = new Dictionary<string, ServiceHost>();
|
|
var pathsToRemove = new List<string>();
|
|
var seenNames = new List<string>();
|
|
foreach (var I in GetInstanceConfigs())
|
|
{
|
|
if (seenNames.Contains(I.Name))
|
|
{
|
|
Logger.WriteError(String.Format("Instance at {0} has a duplicate name! Detaching...", I.Directory), EventID.InstanceInitializationFailure, LoggingID);
|
|
pathsToRemove.Add(I.Directory);
|
|
}
|
|
if (I.Enabled && SetupInstance(I) == null)
|
|
pathsToRemove.Add(I.Directory);
|
|
else
|
|
seenNames.Add(I.Name);
|
|
}
|
|
foreach (var I in pathsToRemove)
|
|
Config.InstancePaths.Remove(I);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unlocks a <see cref="Instance.LoggingID"/> acquired with <see cref="LockLoggingID"/>
|
|
/// </summary>
|
|
/// <param name="ID">The <see cref="Instance.LoggingID"/> to unlock</param>
|
|
void UnlockLoggingID(byte ID)
|
|
{
|
|
lock (UsedLoggingIDs)
|
|
{
|
|
UsedLoggingIDs.Remove(ID);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets and locks a <see cref="Instance.LoggingID"/>
|
|
/// </summary>
|
|
/// <returns>A logging ID for the <see cref="Instance"/> must be released using <see cref="UnlockLoggingID(byte)"/></returns>
|
|
byte LockLoggingID()
|
|
{
|
|
lock (UsedLoggingIDs)
|
|
{
|
|
for (byte I = 1; I < 100; ++I)
|
|
if (!UsedLoggingIDs.Contains(I))
|
|
{
|
|
UsedLoggingIDs.Add(I);
|
|
return I;
|
|
}
|
|
}
|
|
throw new Exception("All logging IDs in use!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates and starts a <see cref="ServiceHost"/> for a <see cref="Instance"/> at <paramref name="config"/>
|
|
/// </summary>
|
|
/// <param name="config">The <see cref="IInstanceConfig"/> for the <see cref="Instance"/></param>
|
|
/// <returns>The inactive <see cref="ServiceHost"/> on success, <see langword="null"/> on failure</returns>
|
|
ServiceHost SetupInstance(IInstanceConfig config)
|
|
{
|
|
Instance instance;
|
|
string instanceName;
|
|
try
|
|
{
|
|
if (hosts.ContainsKey(config.Directory))
|
|
{
|
|
var datInstance = ((Instance)hosts[config.Directory].SingletonInstance);
|
|
Logger.WriteError(String.Format("Unable to start instance at path {0}. Has the same name as instance at path {1}. Detaching...", config.Directory, datInstance.ServerDirectory()), EventID.InstanceInitializationFailure, LoggingID);
|
|
return null;
|
|
}
|
|
if (!config.Enabled)
|
|
return null;
|
|
var ID = LockLoggingID();
|
|
Logger.WriteInfo(String.Format("Instance {0} ({1}) assigned logging ID {2}", config.Name, config.Directory, ID), EventID.InstanceIDAssigned, ID);
|
|
instanceName = config.Name;
|
|
instance = new Instance(config, ID);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.WriteError(String.Format("Unable to start instance at path {0}. Detaching... Error: {1}", config.Directory, e.ToString()), EventID.InstanceInitializationFailure, LoggingID);
|
|
return null;
|
|
}
|
|
|
|
var host = CreateHost(instance, String.Format("{0}/{1}", Definitions.InstanceInterfaceName, instanceName));
|
|
hosts.Add(instanceName, host);
|
|
|
|
AddEndpoint(host, typeof(ITGConnectivity));
|
|
AddEndpoint(host, typeof(ITGAdministration));
|
|
AddEndpoint(host, typeof(ITGByond));
|
|
AddEndpoint(host, typeof(ITGChat));
|
|
AddEndpoint(host, typeof(ITGCompiler));
|
|
AddEndpoint(host, typeof(ITGConfig));
|
|
AddEndpoint(host, typeof(ITGDreamDaemon));
|
|
AddEndpoint(host, typeof(ITGInstance));
|
|
AddEndpoint(host, typeof(ITGInterop));
|
|
AddEndpoint(host, typeof(ITGRepository));
|
|
|
|
host.Authorization.ServiceAuthorizationManager = instance;
|
|
host.Authentication.ServiceAuthenticationManager = new AuthenticationHeaderDecoder();
|
|
return host;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a WCF endpoint for a component <paramref name="typetype"/>
|
|
/// </summary>
|
|
/// <param name="host">The service host to add the component to</param>
|
|
/// <param name="typetype">The type of the component</param>
|
|
void AddEndpoint(ServiceHost host, Type typetype)
|
|
{
|
|
var bindingName = typetype.Name;
|
|
var endpint = host.AddServiceEndpoint(typetype, new NetNamedPipeBinding() { SendTimeout = new TimeSpan(0, 0, 30), MaxReceivedMessageSize = Definitions.TransferLimitLocal }, bindingName);
|
|
foreach (OperationDescription od in endpint.Contract.Operations)
|
|
od.OperationBehaviors.Add(new AddCallLoggerBehavior());
|
|
var httpsBinding = new BasicHttpsBinding()
|
|
{
|
|
SendTimeout = new TimeSpan(0, 0, 40),
|
|
MaxReceivedMessageSize = Definitions.TransferLimitRemote
|
|
};
|
|
var requireAuth = typetype.Name != typeof(ITGConnectivity).Name;
|
|
host.AddServiceEndpoint(typetype, httpsBinding, bindingName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Shuts down all active <see cref="ServiceHost"/>s and calls <see cref="IDisposable.Dispose"/> on it's <see cref="Instance"/>
|
|
/// </summary>
|
|
void OnStop()
|
|
{
|
|
lock (this)
|
|
{
|
|
try
|
|
{
|
|
foreach (var I in hosts)
|
|
{
|
|
var host = I.Value;
|
|
var instance = (Instance)host.SingletonInstance;
|
|
host.Close();
|
|
instance.Dispose();
|
|
UnlockLoggingID(instance.LoggingID);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.WriteError(e.ToString(), EventID.ServiceShutdownFail, LoggingID);
|
|
}
|
|
serviceHost.Close();
|
|
}
|
|
Config.Save(DefaultConfigDirectory);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void VerifyConnection() { }
|
|
|
|
/// <inheritdoc />
|
|
public void PrepareForUpdate()
|
|
{
|
|
foreach (var I in hosts)
|
|
((Instance)I.Value.SingletonInstance).Reattach(false);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public ushort RemoteAccessPort()
|
|
{
|
|
return Config.RemoteAccessPort;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public string SetRemoteAccessPort(ushort port)
|
|
{
|
|
if (port == 0)
|
|
return "Cannot bind to port 0";
|
|
Config.RemoteAccessPort = port;
|
|
return null;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public string Version()
|
|
{
|
|
return VersionString;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool SetPythonPath(string path)
|
|
{
|
|
if (!Directory.Exists(path))
|
|
return false;
|
|
Config.PythonPath = Path.GetFullPath(path);
|
|
return true;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public string PythonPath()
|
|
{
|
|
return Config.PythonPath;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public IList<InstanceMetadata> ListInstances()
|
|
{
|
|
var result = new List<InstanceMetadata>();
|
|
lock (this)
|
|
foreach (var ic in GetInstanceConfigs())
|
|
result.Add(new InstanceMetadata
|
|
{
|
|
Name = ic.Name,
|
|
Path = ic.Directory,
|
|
Enabled = ic.Enabled,
|
|
LoggingID = (byte)(ic.Enabled ? ((Instance)hosts[ic.Name].SingletonInstance).LoggingID : 0)
|
|
});
|
|
return result;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public string CreateInstance(string Name, string path)
|
|
{
|
|
path = Helpers.NormalizePath(path);
|
|
var res = CheckInstanceName(Name);
|
|
if (res != null)
|
|
return res;
|
|
if (File.Exists(path) || Directory.Exists(path))
|
|
return "Cannot create instance at pre-existing path!";
|
|
lock (this)
|
|
{
|
|
if (Config.InstancePaths.Contains(path))
|
|
return String.Format("Instance at {0} already exists!", path);
|
|
foreach (var oic in GetInstanceConfigs())
|
|
if (Name == oic.Name)
|
|
return String.Format("Instance named {0} already exists!", oic.Name);
|
|
IInstanceConfig ic;
|
|
try
|
|
{
|
|
ic = new InstanceConfig(path)
|
|
{
|
|
Name = Name
|
|
};
|
|
Directory.CreateDirectory(path);
|
|
ic.Save();
|
|
Config.InstancePaths.Add(path);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return e.ToString();
|
|
}
|
|
return SetupOneInstance(ic);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Starts and onlines an instance located at <paramref name="config"/>
|
|
/// </summary>
|
|
/// <param name="config">The <see cref="IInstanceConfig"/> for the <see cref="Instance"/></param>
|
|
/// <returns><see langword="null"/> on success, error message on failure</returns>
|
|
string SetupOneInstance(IInstanceConfig config)
|
|
{
|
|
if (!config.Enabled)
|
|
return null;
|
|
try
|
|
{
|
|
var host = SetupInstance(config);
|
|
if (host != null)
|
|
host.Open();
|
|
else
|
|
lock (this)
|
|
Config.InstancePaths.Remove(config.Directory);
|
|
return null;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return "Instance set up but an error occurred while starting it: " + e.ToString();
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public string ImportInstance(string path)
|
|
{
|
|
path = Helpers.NormalizePath(path);
|
|
lock (this)
|
|
{
|
|
if (Config.InstancePaths.Contains(path))
|
|
return String.Format("Instance at {0} already exists!", path);
|
|
if(!Directory.Exists(path))
|
|
return String.Format("There is no instance located at {0}!", path);
|
|
IInstanceConfig ic;
|
|
try
|
|
{
|
|
ic = InstanceConfig.Load(path);
|
|
foreach(var oic in GetInstanceConfigs())
|
|
if(ic.Name == oic.Name)
|
|
return String.Format("Instance named {0} already exists!", oic.Name);
|
|
ic.Save();
|
|
Config.InstancePaths.Add(path);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return e.ToString();
|
|
}
|
|
return SetupOneInstance(ic);
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool InstanceEnabled(string Name)
|
|
{
|
|
lock(this)
|
|
{
|
|
return hosts.ContainsKey(Name);
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public string SetInstanceEnabled(string Name, bool enabled)
|
|
{
|
|
return SetInstanceEnabledImpl(Name, enabled, out string path);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Sets a <see cref="Instance"/>'s enabled status
|
|
/// </summary>
|
|
/// <param name="Name">The <see cref="Instance"/> whom's status should be changed</param>
|
|
/// <param name="enabled"><see langword="true"/> to enable the <see cref="Instance"/>, <see langword="false"/> to disable it</param>
|
|
/// <param name="path">The path to the modified <see cref="Instance"/></param>
|
|
/// <returns><see langword="null"/> on success, error message on failure</returns>
|
|
string SetInstanceEnabledImpl(string Name, bool enabled, out string path)
|
|
{
|
|
path = null;
|
|
lock (this)
|
|
{
|
|
var hostIsOnline = hosts.ContainsKey(Name);
|
|
if (enabled)
|
|
{
|
|
if (hostIsOnline)
|
|
return null;
|
|
foreach (var ic in GetInstanceConfigs())
|
|
if (ic.Name == Name)
|
|
{
|
|
path = ic.Directory;
|
|
ic.Enabled = true;
|
|
ic.Save();
|
|
return SetupOneInstance(ic);
|
|
}
|
|
return String.Format("Instance {0} does not exist!", Name);
|
|
}
|
|
else
|
|
{
|
|
if (!hostIsOnline)
|
|
return null;
|
|
var host = hosts[Name];
|
|
hosts.Remove(Name);
|
|
var inst = (Instance)host.SingletonInstance;
|
|
host.Close();
|
|
path = inst.ServerDirectory();
|
|
inst.Offline();
|
|
inst.Dispose();
|
|
UnlockLoggingID(inst.LoggingID);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public string RenameInstance(string name, string new_name)
|
|
{
|
|
if (name == new_name)
|
|
return null;
|
|
var res = CheckInstanceName(new_name);
|
|
if (res != null)
|
|
return res;
|
|
lock (this)
|
|
{
|
|
//we have to check em all anyway
|
|
IInstanceConfig the_droid_were_looking_for = null;
|
|
foreach (var ic in GetInstanceConfigs())
|
|
if (ic.Name == name)
|
|
{
|
|
the_droid_were_looking_for = ic;
|
|
break;
|
|
}
|
|
else if (ic.Name == new_name)
|
|
return String.Format("There is already another instance named {0}!", new_name);
|
|
if (the_droid_were_looking_for == null)
|
|
return String.Format("There is no instance named {0}!", name);
|
|
var ie = InstanceEnabled(name);
|
|
if(ie)
|
|
SetInstanceEnabled(name, false);
|
|
the_droid_were_looking_for.Name = new_name;
|
|
string result = "";
|
|
try
|
|
{
|
|
the_droid_were_looking_for.Save();
|
|
result = null;
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
result = "Could not save instance config! Error: " + e.ToString();
|
|
}
|
|
finally
|
|
{
|
|
if (ie)
|
|
{
|
|
var resRestore = SetInstanceEnabled(new_name, true);
|
|
if (resRestore != null)
|
|
result = (result + " " + resRestore).Trim();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public string DetachInstance(string name)
|
|
{
|
|
lock (this)
|
|
{
|
|
var res = SetInstanceEnabledImpl(name, false, out string path);
|
|
if (res != null)
|
|
return res;
|
|
if (path == null) //gotta find it ourselves
|
|
foreach (var ic in GetInstanceConfigs())
|
|
if (ic.Name == name)
|
|
{
|
|
path = ic.Directory;
|
|
break;
|
|
}
|
|
if (path == null)
|
|
return String.Format("No instance named {0} exists!", name);
|
|
Config.InstancePaths.Remove(path);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
#region IDisposable Support
|
|
/// <summary>
|
|
/// To detect redundant <see cref="Dispose()"/> calls
|
|
/// </summary>
|
|
private bool disposedValue = false;
|
|
|
|
/// <summary>
|
|
/// Implements the <see cref="IDisposable"/> pattern. Calls <see cref="OnStop"/>
|
|
/// </summary>
|
|
/// <param name="disposing"><see langword="true"/> if <see cref="Dispose()"/> was called manually, <see langword="false"/> if it was from the finalizer</param>
|
|
void Dispose(bool disposing)
|
|
{
|
|
if (!disposedValue)
|
|
{
|
|
if (disposing)
|
|
{
|
|
OnStop();
|
|
}
|
|
|
|
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
|
|
// TODO: set large fields to null.
|
|
|
|
disposedValue = true;
|
|
}
|
|
}
|
|
|
|
// TODO: override a finalizer only if Dispose(bool disposing) above has code to free unmanaged resources.
|
|
// ~Server() {
|
|
// // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
|
|
// Dispose(false);
|
|
// }
|
|
|
|
/// <summary>
|
|
/// Implements the <see cref="IDisposable"/> pattern
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
// Do not change this code. Put cleanup code in Dispose(bool disposing) above.
|
|
Dispose(true);
|
|
// TODO: uncomment the following line if the finalizer is overridden above.
|
|
// GC.SuppressFinalize(this);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|