public RoomManager(ConnectionsHandler connectionHandler, SettingsLoader settings)
{
Rooms = new List<Room>();
SettingsLoader = settings;
ConnectionsHandler = connectionHandler;
ConnectionsHandler.AddMessageListener(this);
}
public Room(ConnectionsHandler connections, Player owner, SettingsLoader settings, string password = "")
{
ConnectionsHandler = connections;
connections.AddMessageListener(this);
Settings = settings;
Settings.OnSettingsChanged += OnSettingsChanged;
Owner = owner;
RoomIdPool = new IdPool(MaxPlayers);
RoomData = new RoomData();
RoomData.ID = Guid.NewGuid().ToString().Substring(0, GuidSize);
RoomData.Password = password;
RoomData.Players = new List<PlayerData>();
RoomData.Owner = Owner.Data;
RoomData.MinPlayers = settings.Values.Server.MinPlayers;
Players = new List<Player>();
if (string.IsNullOrEmpty(password))
{
Logger.Log(this, "Creating room for {0}", Owner.Data.Name);
}
else
{
Logger.Log(this, "Creating room for {0} with password {1}", Owner.Data.Name, password);
}
Join(Owner);
}
public Server()
{
SettingsLoader = new SettingsLoader();
LoadSettings();
CommandHandler = new CommandHandler();
CommandHandler.AddCommand(new CommandHandler.Command("quit", () => Stop()));
CommandHandler.AddCommand(new CommandHandler.Command("reloadsettings", () => LoadSettings()));
}
public PicasaWrapper(SessionProvider sessionProvider)
{
var oauth2ParametersStorage = OAuth2ParametersStorageFactory.StorageDatabase(sessionProvider);
//var gdataAuth = new GoogleDataOAuth2Service(OAuth2ParametersStorageFactory.StorageJsonFile(ApplicationId));
var gdataAuth = new GoogleDataOAuth2Service(oauth2ParametersStorage);
var picasaFactory = new PicasaServiceFactory(gdataAuth.GetRequestDataFactoryInstance("https://picasaweb.google.com/data"));
Service = picasaFactory.GetService();
Settings = new SettingsLoader<List<GdataPhotosSettings>>(sessionProvider, "GdataPhotosSettings_List.json").Get();
PicasaRequest = new PicasaRequest(new RequestSettings("x", gdataAuth.GetValidOAuth2Parameters()));
}
public TemplateInvocationAndAcquisitionCoordinator(SettingsLoader settingsLoader, INewCommandInput commandInput, TemplateCreator templateCreator, IHostSpecificDataLoader hostDataLoader, ITelemetryLogger telemetryLogger, string defaultLanguage, string commandName, Func <string> inputGetter, New3Callbacks callbacks)
{
_settingsLoader = settingsLoader;
_environment = _settingsLoader.EnvironmentSettings;
_commandInput = commandInput;
_templateCreator = templateCreator;
_hostDataLoader = hostDataLoader;
_telemetryLogger = telemetryLogger;
_defaultLanguage = defaultLanguage;
_commandName = commandName;
_inputGetter = inputGetter;
_callbacks = callbacks;
}
public MainViewModel()
{
SearchIndexed = true;
SearchPaths = new ObservableCollection <PathItem>(SettingsLoader.Paths);
SearchResults = new ConcurrentList <ISearchItem>();
SearchResultsWPF = new ObservableCollection <ISearchItem>();
SearchConditions = new ObservableCollection <SearchConditionViewModel>();
DateFilterFrom = DateFilterTo = DateNow;
SizeRange = new SizeRange();
ProgressBarVisibility = Visibility.Hidden;
SearchPaths.CollectionChanged += (sender, args) => SettingsLoader.Save(SearchPaths);
HandleCommandLineArgs();
}
public void IncludeByRelativePath()
{
var loader = new SettingsLoader();
loader.XmlFileByExtension();
var systemSettings = new XmlSystemSettings("ExtConfigure");
var settings = loader.LoadSettings(systemSettings).Joined.ToAppSettings();
var cfg = settings.Get <MyXmlConfig>("MyCfg2");
Assert.AreEqual("2", cfg.AttrField);
Assert.IsNull(cfg.ElemField);
}
public SettingsViewModel()
{
_settingsLoader = SettingsLoader.Load();
ProgramSettings = _settingsLoader.GetSettings();
_organizationManager = Directory.GetOrganizationManager();
_communicationTypeManager = Directory.GetCommunicationTypeManager();
OrganizationViewModel = new OrganizationViewModel();
CommunicationTypeViewModel = new CommunicationTypeViewModel();
AddedOrganization = new Organization();
AddedCommunicationType = new CommunicationType();
}
/// <summary>
/// Create a new StartContext with the given options.
/// If the given options do not define any settings, then settings will be loaded from the config.
/// </summary>
/// <param name="options"></param>
public StartContext(StartOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (options.Settings.Count == 0)
{
SettingsLoader.LoadFromConfig(options.Settings);
}
Options = options;
EnvironmentData = new List <KeyValuePair <string, object> >();
}
public void LoadOptionsFromFile_CaseInsensitive()
{
var options = new StartOptions();
SettingsLoader.LoadFromSettingsFile("Settings.txt", options.Settings);
IDictionary <string, string> settings = options.Settings;
string value;
Assert.True(settings.TryGetValue("UpperCase", out value));
Assert.True(string.Equals("UpperCaseValue", value, StringComparison.Ordinal));
Assert.True(settings.TryGetValue("uppercase", out value));
Assert.True(string.Equals("UpperCaseValue", value, StringComparison.Ordinal));
}
private static ICombinableAppSettings loadSettings()
{
var strConv = new StringConverter();
var deserializer = new GenericDeserializer();
var xmlFileLoader = new XmlFileSettingsLoader(deserializer, strConv);
var loader = new SettingsLoader(xmlFileLoader);
loader.LoadSettings(new XmlSystemSettings("ExtConfigure", strConv, deserializer));
var result = loader.Settings;
return(new CombinableAppSettings(result));
}
public void LoadOptionsFromConfig_CaseInsensitive()
{
var options = new StartOptions();
SettingsLoader.LoadFromConfig(options.Settings);
IDictionary <string, string> settings = options.Settings;
string value;
Assert.True(settings.TryGetValue("UpperCase", out value));
Assert.Equal("UpperCaseValue", value, StringComparer.Ordinal);
Assert.True(settings.TryGetValue("uppercase", out value));
Assert.Equal("UpperCaseValue", value, StringComparer.Ordinal);
}
public SettingsPage()
{
InitializeComponent();
var settingsLoader = new SettingsLoader();
TextBoxUserName.Text = settingsLoader.GetSettingAsync(Setting.ACCOUNT_NAME).Result?.Value;
TextBoxPassword.Password = settingsLoader.GetSettingAsync(Setting.ACCOUNT_PASSWORD).Result?.Value;
NumericMaxVideosPerPage.Value = double.Parse(settingsLoader.GetSettingAsync(Setting.MAXVIDEOSPERPAGE).Result?.Value ?? "50");
ThumpnailSizeSlider.Value = double.Parse(settingsLoader.GetSettingAsync(Setting.THUMPNAILSIZE).Result?.Value ?? "320");
TextBoxArtistFolderPath.Text = settingsLoader.GetSettingAsync(Setting.VIDEOPATH).Result?.Value;
}
public void SettingAttributesWithTypeConverterLoadTest()
{
var settings = SettingsLoader.Create <PathTypeConverterSettings>("TypeConverter");
//Simple
// Array
Assert.That(settings, Is.DeepEqualTo(
new PathTypeConverterSettings()
{
Upload = @"C:\Foo\Bar\Upload\",
Download = @"E:\Download\",
Sub = @"C:\Foo\Bar\Upload\Sub\",
}));
}
public void IpSettingOneValueTest()
{
var ip = "192.168.1.42";
// Setup mock value provider
var settingsLoader = new SettingsLoader(new DictionaryValueProvider(new Dictionary <string, string>()
{
{ nameof(IPSettingTest.IpAddress), ip },
}));
var result = settingsLoader.Create <IPSettingTest>();
Assert.That(result.IpAddress, Is.EqualTo(IPAddress.Parse(ip)));
Assert.That(result.OptionalIpAddress, Is.Null);
}
public void SimpleLoadTest()
{
var settings = SettingsLoader.Create <SimpleSettings>();
//Simple
Assert.That(settings.Enum, Is.EqualTo(BindingFlags.NonPublic | BindingFlags.Static));
Assert.That(settings.String, Is.EqualTo("Hello world"));
Assert.That(settings.DateTime, Is.EqualTo(new DateTime(2004, 07, 17, 9, 0, 0, DateTimeKind.Local)));
Assert.That(settings.TimeSpan, Is.EqualTo(new TimeSpan(11, 22, 33, 44, 560)));
Assert.That(settings.Type, Is.EqualTo(typeof(System.Data.IDbConnection)));
Assert.That(settings.Uri, Is.EqualTo(new Uri("Http://hello.eu")));
Assert.That(settings.Guid, Is.EqualTo(Guid.Parse("DCFA0942-0BEC-43E4-8D77-57BA63C7BF7B")));
Assert.That(settings.IPAddress, Is.EqualTo(IPAddress.Parse("192.168.0.42")));
}
private async Task <Setting> GetVideoPathSettings()
{
SettingsLoader settingsLoader = new SettingsLoader();
var videoPathSetting = await settingsLoader.GetSettingAsync(Setting.VIDEOPATH);
if (videoPathSetting == null)
{
var msgBox = System.Windows.MessageBox.Show("First time starting Iwara Media Manager", "Please select a video folder.");
videoPathSetting = await SetVideoPathDialogAsync();
}
return(videoPathSetting);
}
public SettingsWindowViewModel()
{
var settings = SettingsLoader.LoadSettings();
Categories = new ObservableCollection <SettingsCategory>(settings);
OKCommand = new DelegateCommand(() => { ApplySettings(); Hide(); });
ApplyCommand = new DelegateCommand(ApplySettings);
SettingsWindow = new SettingsWindow();
SettingsWindow.Closing += (s, e) => { e.Cancel = true; Hide(); };
SettingsWindow.DataContext = this;
}
public void GetMongoConfiguration_WhenFileDoesNotExist_ThrowsSettingsManagerException()
{
// Arrange
var fakeFileSystem = Substitute.For <IFileSystem>();
fakeFileSystem
.FileExists(Arg.Any <string>())
.Returns(false);
var classUnderTest = new SettingsLoader(fakeFileSystem);
// Act / Assert
Assert.Throws <SettingsLoaderException>(
() => classUnderTest.GetMongoConfiguration("anyFilePath.json"));
}
public void DefaultLoadTest()
{
var settings = SettingsLoader.Create <DefaultSettings>();
// Defaults
Assert.That(settings.DefaultString, Is.EqualTo("Default Hello World"));
Assert.That(settings.DefaultEnum, Is.EqualTo(BindingFlags.Instance | BindingFlags.Public));
Assert.That(settings.DefaultDateTime, Is.EqualTo(new DateTime(1966, 6, 11, 13, 34, 56, DateTimeKind.Local).AddMilliseconds(789)));
Assert.That(settings.DefaultTimeSpan, Is.EqualTo(new TimeSpan(1, 2, 3, 4)));
Assert.That(settings.DefaultType, Is.EqualTo(typeof(AccessViolationException)));
Assert.That(settings.DefaultUri, Is.EqualTo(new Uri("https://foo.bar")));
Assert.That(settings.DefaultGuid, Is.EqualTo(Guid.Parse("EE58EE2B-4CE6-44A4-8773-EC4E283146EB")));
Assert.That(settings.DefaultIp, Is.EqualTo(IPAddress.Parse("10.42.42.42")));
Assert.That(settings.DefaultArray, Is.EqualTo(new[] { "foo", "bar" }));
}
public void IncludeByFixedPathOwner()
{
var localPath = "".ResolveTestPath();
var systemSettings = new XmlSystemSettings("ExtConfigure", localPath); // fix for R# test runner
var loader = new SettingsLoader();
loader.XmlFileByExtension();
var settings = loader.LoadSettings(systemSettings).Joined.ToAppSettings();
var cfg = settings.Get <MyXmlConfig>("MyCfg2");
Assert.AreEqual("2", cfg.AttrField);
Assert.IsNull(cfg.ElemField);
}
public void TestLoadFromEnv()
{
Environment.SetEnvironmentVariable("FOO_SOME_API_KEY", "api-key-from-env");
Environment.SetEnvironmentVariable("FOO_THIS_IS_AN_INT", "512");
Environment.SetEnvironmentVariable("FOO_FIELD_SHOULD_BE_SET", "they are");
var settings = new SettingsLoader <TestSettings>()
.UseEnvironmentVariables("FOO_")
.LoadSettings();
Assert.That(settings.SomeApiKey, Is.EqualTo("api-key-from-env"));
Assert.That(settings.ThisIsAnInt, Is.EqualTo(512));
Assert.That(settings.SomethingElse, Is.Null);
Assert.That(settings.FieldShouldBeSet, Is.EqualTo("they are"));
}
public void NestedLoadTest()
{
var settings = SettingsLoader.Create <NestedSettings>();
// Nested
Assert.That(settings, Is.DeepEqualTo(
new NestedSettings
{
MyNestedProperty = new Nested()
{
Foo = "Foo string",
Bar = 42
}
}));
}
public void EmptyValueTest1()
{
var key = "Foo";
// Setup mock value provider
var settingsLoader = new SettingsLoader(new DictionaryValueProvider(new Dictionary <string, string>()
{
{ key, "" }
}));
Assert.That(
() => settingsLoader.Create <IPAddress>(key),
Throws.Exception.TypeOf <SettingsException>()
.With.Message.EqualTo(string.Format(Resources.ConvertValueErrorFormat, "", typeof(IPAddress).FullName)));
}
private void Start()
{
if (agent == null)
{
agent = GetComponent <NavMeshAgent>();
}
var settings = SettingsLoader.LoadSettings <FootmanSettings>();
movement = new ChasingMovement(settings, agent);
attack = new TouchAttack(settings, ShootAt.player);
MaxHealth = settings.Health;
CurrentHealth = MaxHealth;
}
public void IpSettingEmptyNoValueTest()
{
var ip = "";
// Setup mock value provider
var settingsLoader = new SettingsLoader(new DictionaryValueProvider(new Dictionary <string, string>()
{
{ nameof(IPSettingTest.IpAddress), ip },
{ nameof(IPSettingTest.OptionalIpAddress), ip }
}));
Assert.That(
() => settingsLoader.Create <IPSettingTest>(),
Throws.Exception.TypeOf <SettingsException>()
.With.Message.EqualTo(string.Format(Resources.MissingValueFormat, typeof(IPAddress).FullName, nameof(IPSettingTest.IpAddress))));
}
public void FileAnnotationTest()
{
// Setup mock value provider with type
var settingsLoader = new SettingsLoader(new DictionaryValueProvider(new Dictionary <string, string>
{
{ "Drive", "C:\\" },
{ "Folder", "Windows" },
{ "FileName", "notepad.exe" },
}));
var settings = settingsLoader.Create <FileAnnotationSettings>();
// Defaults
Assert.That(settings.FullName, Is.Not.Null);
Assert.That(settings.FullName.FullName, Is.EqualTo(@"C:\Windows\notepad.exe"));
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
State = GameState.Initializing;
InitState = InitializationState.Initializing;
SettingsLoader.LoadInitialSettings();
RegisterCallbacks();
InitState = InitializationState.Ready;
}
else
{
Destroy(gameObject);
}
}
public void IpSettingTwoValuesTest()
{
var ip1 = "192.168.1.42";
var ip2 = "87.65.43.210";
// Setup mock value provider
var settingsLoader = new SettingsLoader(new DictionaryValueProvider(new Dictionary <string, string>()
{
{ nameof(IPSettingTest.IpAddress), ip1 },
{ nameof(IPSettingTest.OptionalIpAddress), ip2 },
}));
var result = settingsLoader.Create <IPSettingTest>();
Assert.That(result.IpAddress, Is.EqualTo(IPAddress.Parse(ip1)));
Assert.That(result.OptionalIpAddress, Is.EqualTo(IPAddress.Parse(ip2)));
}
private void UpdateLedger()
{
FileInfo file = new FileInfo(_localFullPath);
var settings = SettingsLoader.LoadSettings();
var ledgerRowModel = new LedgerRowModel
{
UploadDateTime = DateTime.Now,
FileIdentifier = FileIdGenerator.GetIdentifier(),
FileName = file.Name,
LastDownloadDateTime = DateTime.MinValue,
Username = settings.FtpUsername
};
LedgerManager.GetManager().AddDatabaseToLedger(ledgerRowModel);
LedgerManager.SaveLedger();
}
public EngineEnvironmentSettings(
ITemplateEngineHost host,
bool virtualizeSettings = false,
Action <IEngineEnvironmentSettings>?onFirstRun = null,
string?settingsLocation = null,
IEnvironment?environment = null)
{
Host = host ?? throw new ArgumentNullException(nameof(host));
Environment = environment ?? new DefaultEnvironment();
SettingsLoader = new SettingsLoader(this, onFirstRun);
Paths = new DefaultPathInfo(this, settingsLocation);
if (virtualizeSettings)
{
Host.VirtualizeDirectory(Paths.GlobalSettingsDir);
}
}
public void InlineLoadTest()
{
var settings = SettingsLoader.Create <InlineSettings>();
// Nested
Assert.That(settings, Is.DeepEqualTo(
new InlineSettings
{
MyNestedProperty = new Nested()
{
Foo = "Inline Foo string",
Bar = 21
},
Baz = TimeSpan.Parse("01:02:03")
}));
}
public void Test1()
{
var key = "FooIp";
var ip = "42.41.40.39";
// Setup mock value provider
var settingsLoader = new SettingsLoader(new DictionaryValueProvider(new Dictionary <string, string>
{
{ key, ip }
}));
var ipAddress = settingsLoader.Create <IPAddress>(key);
Assert.That(ipAddress, Is.Not.Null);
Assert.That(ipAddress, Is.EqualTo(IPAddress.Parse(ip)));
}
public void RebuildCacheIfForceRebuildScansAll()
{
_fixture.Customizations.Add(new MountPointInfoBuilder());
List <MountPointInfo> mountPoints = _fixture.CreateMany <MountPointInfo>().ToList();
List <TemplateInfo> templates = TemplatesFromMountPoints(mountPoints);
SetupUserSettings(isCurrentVersion: true, mountPoints: mountPoints);
SetupTemplates(templates);
SettingsLoader subject = new SettingsLoader(_environmentSettings);
subject.RebuildCacheFromSettingsIfNotCurrent(true);
// All mount points should have been scanned
AssertMountPointsWereScanned(mountPoints);
}
public override bool StopServer(SettingsLoader.ServerChild ServerData, AutoResetEvent ResetEvent)
{
Process thisProcess = null;
foreach( var tProcess in _ProcessDict )
{
if( tProcess.Value != ServerData ) continue;
thisProcess = tProcess.Key;
}
if( thisProcess == null ) return false;
thisProcess.Exited += new EventHandler( (object sender, EventArgs e) => {
ResetEvent.Set();
});
File.Delete(string.Format("{0}\\server.pid", ServerData.GameServerPath));
thisProcess.CloseMainWindow();
return true;
}
public override bool BackupServer(SettingsLoader.ServerChild ServerData)
{
string BackupFrom = string.Format("{0}\\ShooterGame\\Saved\\", ServerData.GameServerPath);
string BackupTo = ServerData.BackupDirectory;
if( !Directory.Exists(BackupFrom) )
{
_Parent.Log.ConsolePrint(LogLevel.Warning, @"Unable to Backup server, directory ShooterGame\Saved is missing. If this is the first startup then ignore this message");
return false;
}
else if( (BackupTo.Length <= 0) || !Directory.Exists(BackupTo) )
{
_Parent.Log.ConsolePrint(LogLevel.Warning, @"Unable to Backup server, Specified backup directory does not exist or is not set.");
return false;
}
_Parent.Log.ConsolePrint(LogLevel.Info, "Starting backup of server {0}", ServerData.GameServerName);
if( _Parent.ARKConfiguration.Messages.ServerBackupBroadcast.Length >= 1 )
{
using( var RCONClient = new ArkRCON("127.0.0.1", ServerData.RCONPort) )
{
try
{
RCONClient.Authenticate(ServerData.ServerAdminPassword);
RCONClient.ExecuteCommand(string.Format("serverchat {0}", _Parent.ARKConfiguration.Messages.ServerBackupBroadcast));
} catch( QueryException ) {}
}
}
// Use 7zipSharp to compress the backup directory
SevenZipCompressor.SetLibraryPath("7za.dll");
var Compressor = new SevenZipCompressor()
{
CompressionLevel = CompressionLevel.Normal,
ArchiveFormat = OutArchiveFormat.SevenZip,
IncludeEmptyDirectories = true,
};
string BackupPath = string.Format("{0}\\Backup-{1}.7z", BackupTo, Helpers.CurrentUnixStamp);
Compressor.CompressDirectory(BackupFrom, BackupPath);
_Parent.Log.ConsolePrint(LogLevel.Success, "Backup of server {0} complete", ServerData.GameServerName);
return true;
}
// Update is called once per frame
void Update()
{
Camera cam = gameObject.GetComponent<Camera> ();
GameObject plane = GameObject.Find ("Root");
if(!loaded)
{
loaded = true;
SettingsLoader loader = new SettingsLoader();
Settings settings = loader.Load();
if(settings != null)
{
cam.fieldOfView = settings.cameraFOV;
gameObject.transform.position = settings.getPosition();
Quaternion rot = new Quaternion();
rot.eulerAngles = settings.getRotation();
plane.transform.rotation = rot;
}
else{
Debug.Log ("Loading failed");
}
}
if (Input.GetButton ("PS4_PS")) {
Application.Quit();
}
if (Input.GetButton ("PS4_Square")) {
if (!squarePressed) {
squarePressed = true;
SettingsLoader loader = new SettingsLoader();
Settings settings = new Settings();
settings.cameraFOV = cam.fieldOfView;
settings.setPosition(gameObject.transform.position);
settings.setRotation(plane.transform.rotation.eulerAngles);
loader.Save(settings);
}
} else {
squarePressed = false;
}
// Depth of field.
float dpadX = Input.GetAxis ("PS4_DPadX");
cam.fieldOfView += dpadX;
// Translate camera.
float leftX = Input.GetAxis ("PS4_LeftStickX");
float leftY = Input.GetAxis ("PS4_LeftStickY");
// Zoom camera.
float l2 = Input.GetAxis ("PS4_L2");
float r2 = Input.GetAxis ("PS4_R2");
// Rot camera.
float rightX = Input.GetAxis ("PS4_RightStickX");
float rightY = Input.GetAxis ("PS4_RightStickY");
// Debug.LogFormat ("{0} {1}", rightX, rightY);
float dz = 0;
// L2 pressed
if (l2 > 0) {
dz+=l2;
}
if (r2 > 0) {
dz -= r2;
}
Vector3 newPos = gameObject.transform.position;
newPos.x += leftX;
newPos.y +=dz;
newPos.z -= leftY;
gameObject.transform.position = newPos;
Quaternion newPlaneRot = plane.transform.rotation;
Vector3 angles = plane.transform.rotation.eulerAngles;
angles.x += (rightY*2.0f);
angles.z += (rightX*2.0f);
// HACK
if(angles.x == 90)
{
angles.x+=1;
}
newPlaneRot.eulerAngles = angles;
plane.transform.rotation = newPlaneRot;
// at.x += rightX;
// at.z += rightY;
// gameObject.transform.LookAt (at);
//
// if (rightX!=0f || rightY!=0f) {
// Vector3 newRot = gameObject.transform.rotation.eulerAngles;
// newRot.z += rightX;
// newRot.y += rightY;
//
// Quaternion r = gameObject.transform.rotation;
// r.eulerAngles = newRot;
//
// gameObject.transform.rotation = r;
// }
}
public ServerClass(SettingsLoader.ServerChild Data)
{
this.ProcessID = 0;
this.MinutesRemaining = -1;
this.LastUpdated = 0;
this.LastBackedUp = 0;
this.ServerData = Data;
}
public override bool ServerRunning(SettingsLoader.ServerChild ServerData)
{
var ProcessID = _ReadProcessFile(ServerData.GameServerPath);
if( ProcessID != -1 )
{
try
{
var Proc = Process.GetProcessById(ProcessID);
if( !Proc.HasExited && (Proc.Id == ProcessID) )
{
return true;
}
} catch( System.ArgumentException ) {}
}
return false;
}
public override int StartServer(SettingsLoader.ServerChild ServerData)
{
throw new NotImplementedException();
}
public override bool StopServer(SettingsLoader.ServerChild ServerData, AutoResetEvent ResetEvent)
{
throw new NotImplementedException();
}
public override bool CleanBackups(SettingsLoader.ServerChild ServerData)
{
try
{
var BackupFiles = Directory.GetFiles(ServerData.BackupDirectory, "*.7z", SearchOption.TopDirectoryOnly);
if( BackupFiles.Length > _Parent.ARKConfiguration.Backup.NumberOfBackupsToKeepPerServer )
{
var Dict = new Dictionary<string, long>();
foreach( var tFile in BackupFiles )
{
Dict.Add(tFile, File.GetCreationTime(tFile).Ticks);
}
var KeepItems = Dict.OrderByDescending( x => x.Value ).Take( _Parent.ARKConfiguration.Backup.NumberOfBackupsToKeepPerServer ).ToDictionary( x => x.Key );
foreach( var tFile in BackupFiles )
{
if( KeepItems.ContainsKey(tFile) ) continue; // Keep this file
_Parent.Log.ConsolePrint(LogLevel.Debug, "Deleting backup file '{0}' from server '{1}'", tFile, ServerData.GameServerName);
File.Delete(tFile);
}
}
}
catch( Exception )
{
return false;
}
return true;
}
public List<GdataPhotosSettings> GetPhotosSettings()
{
var x = new SettingsLoader<List<GdataPhotosSettings>>(SessionProvider, "GdataPhotosSettings_List.json").Get();
return x ?? new List<GdataPhotosSettings>();
}
public abstract bool ServerRunning(SettingsLoader.ServerChild ServerData);
public abstract bool StopServer(SettingsLoader.ServerChild ServerData, AutoResetEvent ResetEvent);
public override bool CleanBackups(SettingsLoader.ServerChild ServerData)
{
throw new NotImplementedException();
}
public abstract bool CleanBackups(SettingsLoader.ServerChild ServerData);
public abstract bool BackupServer(SettingsLoader.ServerChild ServerData);
public ARKUpdater()
{
this._Sleeper = new ManualResetEvent(false);
this._Running = true;
// Initialise Console Logging
this.Log = new ConsoleLogger(LogLevel.Debug);
this.Log.ConsolePrint(LogLevel.Info, "ARKUpdater Starting (Version: {0})", Helpers.GetApplicationVersion());
// Load configuration from settings.json
this.ARKConfiguration = SettingsLoader.LoadConfiguration("settings.json", Log);
if( this.ARKConfiguration == null )
{
Helpers.ExitWithError();
}
// Configure Logger
if( this.ARKConfiguration.LogLevel.Length > 0 )
{
try
{
var LogValue = (LogLevel) Enum.Parse(typeof(LogLevel), this.ARKConfiguration.LogLevel, true);
this.Log.SetLogLevel(LogValue);
}
catch( ArgumentException )
{
this.Log.ConsolePrint(LogLevel.Error, "Invalid LogLevel in settings.json, using default (DEBUG)");
}
}
// Configure Servers
var TempList = new List<ServerClass>();
foreach( var ServerData in this.ARKConfiguration.Servers )
{
TempList.Add( new ServerClass(ServerData) );
this.Log.ConsolePrint(LogLevel.Debug, "Loaded server '{0}' from configuration", ServerData.GameServerName);
}
this.Servers = TempList.ToArray();
// Initialise Interfaces
if( Helpers.IsUnixPlatform() )
{
this.ServerInt = new ServerInterfaceUnix(this);
this.BackupInt = new BackupInterfaceUnix(this);
this.SteamInt = new SteamInterfaceUnix(this);
}
else
{
this.ServerInt = new ServerInterfaceWindows(this);
this.BackupInt = new BackupInterfaceWindows(this);
this.SteamInt = new SteamInterfaceWindows(this);
}
// Verify path to SteamCMD
if( !this.SteamInt.VerifySteamPath(this.ARKConfiguration.SteamCMDPath) )
{
this.Log.ConsolePrint(LogLevel.Error, "Unable to find SteamCMD in provided path, please check the SteamCMD path in settings.json");
Helpers.ExitWithError();
}
}
public abstract int StartServer(SettingsLoader.ServerChild ServerData);
public override bool ServerRunning(SettingsLoader.ServerChild ServerData)
{
throw new NotImplementedException();
}
public ConnectionsHandler(SettingsLoader settings)
{
SettingsLoader = settings;
Handlers = new List<IConnectionMessageHandler>();
}
public override int StartServer(SettingsLoader.ServerChild ServerData)
{
// Check for existing process
var ProcessID = _ReadProcessFile(ServerData.GameServerPath);
if( ProcessID != -1 )
{
try
{
var Proc = Process.GetProcessById(ProcessID);
if( !Proc.HasExited && (Proc.Id == ProcessID) )
{
// Listener for Exit Event
_ProcessDict.Add(Proc, ServerData);
Proc.EnableRaisingEvents = true;
Proc.Exited += new EventHandler(_ProcessExited);
_Parent.Log.ConsolePrint(LogLevel.Debug, "Re-used existing Server Process with ID {0} (From PID File)", Proc.Id);
return Proc.Id;
}
} catch( System.ArgumentException ) {}
}
// Start new process
var QueryString = new StringBuilder();
QueryString.Append(string.Format("{0}?listen?MaxPlayers={1}?QueryPort={2}?RCONEnabled=true?RCONPort={3}?Port={4}?ServerAdminPassword={5}?ServerPVE={6}",
ServerData.GameServerMap,
ServerData.MaxPlayers,
ServerData.QueryPort,
ServerData.RCONPort,
ServerData.Port,
ServerData.ServerAdminPassword,
ServerData.ServerPVE
));
if( ServerData.ServerPassword.Length > 1 ) QueryString.Append("?ServerPassword="******"?ServerName="+ServerData.GameServerName);
if( ServerData.ServerParameters.Count >= 1 )
{
foreach( var Param in ServerData.ServerParameters )
{
QueryString.Append(string.Format("?{0}={1}", Param.Key, Param.Value));
}
}
var ProcessData = new ProcessStartInfo()
{
WorkingDirectory = string.Format("{0}\\ShooterGame\\Binaries\\Win64", ServerData.GameServerPath),
FileName = "ShooterGameServer.exe",
Arguments = QueryString.ToString(),
CreateNoWindow = false,
UseShellExecute = true
};
try
{
// Write process to pid file
var Proc = Process.Start(ProcessData);
_WriteProcessFile(ServerData.GameServerPath, Proc.Id);
// Listener for Exit Event
_ProcessDict.Add(Proc, ServerData);
Proc.EnableRaisingEvents = true;
Proc.Exited += new EventHandler(_ProcessExited);
// Set Window Title
Task tResult = this._UpdateWindow(Proc, string.Format("ARK: {0} (Managed by ARKUpdater)", ServerData.GameServerName));
// Return with Process ID
_Parent.Log.ConsolePrint(LogLevel.Debug, "Spawned new Server Process with ID {0}", Proc.Id);
return Proc.Id;
}
catch( Exception Ex )
{
_Parent.Log.ConsolePrint(LogLevel.Error, "Unable to spawn new server process: {0}", Ex.Message);
return -1;
}
}
