public override async Task <BackupResponse> Backup(Backup backup, BackupRequest request)
{
var bucket = $"backups-service-{backup.ServiceId}";
var service = new Service(backup.ServiceId);
var server = new Server(service.ServerId);
var fileSystemService = server.FileSystemService;
var combinePath = FileSystem.FixAbsoluteFilePath(
FileSystem.CombinePath(server.OperatingSystem, service.RootDirectory, request.Path,
Compress(backup, request)), server.OperatingSystem);
var fileSize = fileSystemService.GetFileSize(combinePath);
BackupManagerController.ThrowExceedQuota(backup, request, fileSize);
backup.FileSize = fileSize;
if (!await MinioClient.BucketExistsAsync(bucket))
{
await MinioClient.MakeBucketAsync(bucket, _region);
}
var contents = fileSystemService.ReadBinary(combinePath);
Stream stream = new MemoryStream(contents);
await MinioClient.PutObjectAsync(bucket, backup.ZipFullName, stream, stream.Length, "application/zip");
return(new BackupResponse(true));
}
public FileSystemUtilities(VirtualDirectorySecurity vds, Server server, Service service, CommandContext ctx)
{
FileSystem = server.FileSystemService;
VirtualDirectorySecurity = vds;
Server = server;
Service = service;
CommandContext = ctx;
}
public FileManagerDirectory(CommandContext commandContext, Server server,
VirtualDirectorySecurity vds, DirectoryListing listing, string currentDirectory)
{
CommandContext = commandContext;
FileSystem = server.FileSystemService;
Listing = listing;
CurrentDirectory = currentDirectory;
VirtualDirectorySecurity = vds;
}
private void AddToOrCreateDictionary(Datacenter dc, Server server)
{
if (_serversDown.TryGetValue(dc, out var servers))
{
servers.Add(server);
return;
}
_serversDown.Add(dc, new List <Server> {
server
});
}
public FileSystemUtilities(VirtualDirectorySecurity vds, Server server, CommandContext ctx)
{
FileSystem = server.FileSystemService;
VirtualDirectorySecurity = vds;
Server = server;
Service = new Service
{
WorkingDirectory = "/",
RootDirectory = "/",
Executable = "/"
};
CommandContext = ctx;
}
public static T Request <T>(string commandName, Server server,
object arguments, out CommandResponse commandResponse, bool waitForResponse = true,
ProxyRequestType requestType = ProxyRequestType.Xml, JsonSerializerSettings settings = null)
{
try
{
commandResponse = new CommandResponse();
if (requestType == ProxyRequestType.Json)
{
arguments = JsonConvert.SerializeObject(arguments);
}
if (!server.ModuleApiGateway.ExecuteModuleCommand(commandName, arguments, ref commandResponse,
waitForResponse))
{
throw new Exception("Proxy command execution failed.");
}
switch (requestType)
{
case ProxyRequestType.Xml:
{
var xmlToObject = (T)ObjectXml.XmlToObject(commandResponse.Response.ToString(), typeof(T));
return(xmlToObject);
}
case ProxyRequestType.Json:
if (settings == null)
{
settings = Utilities.NoErrorJsonSettings;
}
Console.WriteLine("Respoinse = " + commandResponse.Response);
return(JsonConvert.DeserializeObject <T>(commandResponse.Response.ToString()));
default:
throw new ArgumentOutOfRangeException(nameof(requestType), requestType, null);
}
}
catch (Exception e)
{
Logger.Fatal(e);
commandResponse = new CommandResponse {
SerializedException = e.Message
};
return(Activator.CreateInstance <T>());
}
}
private string GetOperationalString(Server server)
{
var serversOperationalStatus = string.Empty;
try
{
serversOperationalStatus +=
$"***{server.Name}*** **[{server.PrimaryIp}] (Stock: {(server.NumberOfServices >= server.MaxServices ? "Not Available" : "Available")})** | **{(server.MonitorVersion != null ? "Operational!" : "Down!")}**\n";
}
catch
{
AddToOrCreateDictionary(new Datacenter(server.DatacenterId), server);
serversOperationalStatus +=
$"***{server.Name}*** **[{server.PrimaryIp}] (Stock: {(server.NumberOfServices >= server.MaxServices ? "Not Available" : "Available")})** | **Unknown**\n";
}
return(serversOperationalStatus);
}
public async System.Threading.Tasks.Task DownloadFile(FileInfo file)
{
var server = new Server(Service.ServerId);
var directorySecurity = new TCAdmin.SDK.VirtualFileSystem.VirtualDirectorySecurity
{
Permissions = Permission.Read | Permission.Write | Permission.Delete,
PermissionType = PermissionType.Root,
RelativeExecutable =
Strings.ReplaceCaseInsensitive(Service.Executable, Service.RootDirectory, string.Empty),
VirtualDirectoryName = Service.ConnectionInfo,
RootPhysicalPath = Service.RootDirectory,
RealPhysicalPath =
TCAdmin.SDK.Misc.FileSystem.FixAbsoluteFilePath(Service.RootDirectory, server.OperatingSystem),
ServerId = server.ServerId
};
var download = new RemoteDownload(server)
{
DirectorySecurity = directorySecurity,
FileName = file.FullName
};
if (file.Length / 1024 > 8)
{
await CommandContext.RespondAsync(
embed : EmbedTemplates.CreateSuccessEmbed(
$"[<{download.GetDownloadUrl()}>](**Click here to download {file.Name}**)"));
}
else
{
using (var client = new WebClient())
{
client.DownloadFileCompleted += delegate { CommandContext.RespondWithFileAsync(file.Name); };
client.DownloadFileAsync(new Uri(download.GetDownloadUrl()), file.Name);
}
}
await System.Threading.Tasks.Task.Delay(3000);
File.Delete(file.Name);
}
private static Dictionary <Datacenter, List <Server> > GetLocationsDictionary()
{
var dictionary = new Dictionary <Datacenter, List <Server> >();
foreach (Datacenter dc in Datacenter.GetDatacenters())
{
if (dc.DatacenterId == 27 || dc.DatacenterId == 9)
{
continue;
}
var servers = new List <Server>();
foreach (Server server in Server.GetServersFromDatacenter(dc.DatacenterId))
{
servers.Add(server);
}
dictionary.Add(dc, servers);
}
return(dictionary);
}
public static string ReplaceVariables(this string query, Service service = null, User user = null, Server server = null, Datacenter datacenter = null)
{
var input = new TCAdmin.SDK.Scripting.InputParser(query);
service?.ReplacePropertyValues(input);
service?.ReplaceCustomVariables(new TCAdmin.GameHosting.SDK.Objects.Game(service.GameId).CustomVariables, service.Variables, input);
user?.ReplacePropertyValues(input);
server?.ReplacePropertyValues(input);
datacenter?.ReplacePropertyValues(input);
var output = input.GetOutput();
return(output);
}
private void InstallModpack()
{
var modpackinfo = (ModpackInfo)TCAdmin.SDK.Misc.ObjectXml.XmlToObject(this.Arguments.Arguments, typeof(ModpackInfo));
var service = new TCAdmin.GameHosting.SDK.Objects.Service(modpackinfo.ServiceId);
var original_status = service.Status;
try
{
if (original_status.ServiceStatus == TCAdmin.Interfaces.Server.ServiceStatus.Running)
{
service.Stop("Modpack installation");
}
var install_data = System.IO.Path.Combine(service.RootDirectory, String.Format("Modpack-{0}.data", modpackinfo.ModpackId));
if (System.IO.File.Exists(install_data))
{
UninstallModpack();
}
var server = new TCAdmin.GameHosting.SDK.Objects.Server(service.ServerId);
var provider = new TCAdminCustomMods.Providers.MinecraftModpacksProvider();
MinecraftModpacksBrowser genericMod = (MinecraftModpacksBrowser)provider.GetMod(modpackinfo.ModpackId.ToString(), Providers.ModSearchType.Id);
var filepath = "Shared/bin-extensions/MinecraftModpack-Install-Script.txt";
var script = string.Empty;
var utility = service.GetScriptUtility();
utility.ScriptEngineManager.AddVariable("Script.WorkingDirectory", service.RootDirectory);
utility.AddObject("ThisModpackInfo", modpackinfo);
utility.AddObject("ThisApiInfo", genericMod);
utility.AddObject("ThisTaskStep", this);
if (System.IO.File.Exists(filepath))
{
script = System.IO.File.ReadAllText(filepath);
}
else
{
script = PythonScripts.MinecraftModpack_Install_Script;
}
utility.ScriptEngineManager.SetScript("ipy", script, null);
DeleteModpackCmdLines(service);
var createdfiles = new List <string>();
using (var filewatcher = new System.IO.FileSystemWatcher(service.RootDirectory, "*"))
{
filewatcher.InternalBufferSize = 32768;
filewatcher.IncludeSubdirectories = true;
filewatcher.Created += (object sender, System.IO.FileSystemEventArgs e) =>
{
createdfiles.Add(e.FullPath);
};
filewatcher.EnableRaisingEvents = true;
utility.ScriptEngineManager.Execute();
provider.PostInstallMod(service, genericMod);
}
createdfiles.Reverse();
using (var file = System.IO.File.OpenWrite(install_data))
{
using (var writer = new System.IO.StreamWriter(file))
{
var i = 0;
foreach (var createdfile in createdfiles)
{
i += 1;
if (i > 1)
{
writer.Write("\n");
}
writer.Write(TCAdmin.SDK.Misc.Strings.ReplaceCaseInsensitive(createdfile, service.RootDirectory, string.Empty));
}
}
}
//remove current version if it exists
foreach (var installed in provider.GetInstalledPlugins(service))
{
var packid = int.Parse(installed.Split(':')[0].Replace("MCMP", string.Empty));
if (packid == modpackinfo.ModpackId)
{
var verid = int.Parse(installed.Split(':')[1]);
provider.RemoveInstalledPlugin(service, packid, verid);
}
}
provider.AddInstalledPlugin(service, modpackinfo.ModpackId, modpackinfo.VersionId);
//Repair permissions
this.WriteLog("Setting file permissions...");
var usercfgfile = string.Format("Services/{0}/User.cfg", service.ServiceId);
if (System.IO.File.Exists(usercfgfile))
{
var usercfg = new TCAdmin.SDK.Database.XmlField();
usercfg.LoadFromFile(usercfgfile);
switch (server.OperatingSystem)
{
case TCAdmin.SDK.Objects.OperatingSystem.Linux:
TCAdmin.SDK.Misc.Linux.SetDirectoryOwner(service.RootDirectory, usercfg["Service.User"].ToString(), true);
break;
case TCAdmin.SDK.Objects.OperatingSystem.Windows:
server.GameHostingUtilitiesService.ConfigureGameAccountPermissions(usercfg["Service.User"].ToString(), service.RootDirectory);
break;
default:
throw new NotImplementedException(server.OperatingSystem.ToString());
}
}
service.Configure();
var responsedata = new TCAdmin.SDK.Database.XmlField();
responsedata.SetValue("Task.RedirectUrl", modpackinfo.RedirectUrl);
responsedata.SetValue("Task.RedirectUrlMvc", modpackinfo.RedirectUrl);
this.SetResponse(responsedata.ToString());
this.UpdateProgress(100);
}
finally
{
if (original_status.ServiceStatus == TCAdmin.Interfaces.Server.ServiceStatus.Running)
{
service.Start("Modpack installation");
}
}
}
