public static async Task FetchBuild(string path, string version)
{
string ZipDir = $@"{Program.ServiceDirectory}\Server\MCSFiles\Update_{version}.zip";
if (!Directory.Exists($@"{Program.ServiceDirectory}\Server\MCSFiles"))
{
Directory.CreateDirectory($@"{Program.ServiceDirectory}\Server\MCSFiles");
}
if (File.Exists(ZipDir))
{
File.Delete(ZipDir);
}
if ((string)InstanceProvider.GetHostInfo().GetGlobalValue("AcceptedMojangLic") == "false")
{
InstanceProvider.GetServiceLogger().AppendLine("------First time download detected------\n");
InstanceProvider.GetServiceLogger().AppendLine("You will need to agree to the Minecraft End User License Agreement");
InstanceProvider.GetServiceLogger().AppendLine("in order to continue. Visit https://account.mojang.com/terms");
InstanceProvider.GetServiceLogger().AppendLine("to view terms. Type \"Yes\" and press enter to confirm that");
InstanceProvider.GetServiceLogger().AppendLine("you agree to said terms.");
Console.Write("Do you agree to the terms? ");
Console.Out.Flush();
if (Console.ReadLine() != "Yes")
{
return;
}
InstanceProvider.GetHostInfo().SetGlobalProperty("AcceptedMojangLic", "true");
InstanceProvider.GetConfigManager().SaveGlobalFile();
InstanceProvider.GetServiceLogger().AppendLine("Now downloading latest build of Minecraft Bedrock Server. Please wait...");
}
using (var httpClient = new HttpClient())
{
using (var request = new HttpRequestMessage(HttpMethod.Get, path))
{
using (Stream contentStream = await(await httpClient.SendAsync(request)).Content.ReadAsStreamAsync(), stream = new FileStream(ZipDir, FileMode.Create, FileAccess.Write, FileShare.None, 256000, true))
{
try
{
await contentStream.CopyToAsync(stream);
}
catch (Exception e)
{
InstanceProvider.GetServiceLogger().AppendLine($"Download zip resulted in error: {e.StackTrace}");
}
httpClient.Dispose();
request.Dispose();
contentStream.Dispose();
}
}
}
}
public void SaveGlobalFile()
{
string[] output = new string[InstanceProvider.GetHostInfo().GetGlobals().Count + 3];
int index = 0;
output[index++] = "#Globals";
output[index++] = string.Empty;
foreach (Property prop in InstanceProvider.GetHostInfo().GetGlobals())
{
output[index++] = $"{prop.KeyName}={prop.Value}";
}
output[index++] = string.Empty;
File.WriteAllLines(globalFile, output);
}
public bool LoadConfigs()
{
bool loading = true;
if (!Directory.Exists(configDir))
{
Directory.CreateDirectory(configDir);
}
if (File.Exists($@"{configDir}\..\bedrock_ver.ini"))
{
loadedVersion = File.ReadAllText($@"{configDir}\..\bedrock_ver.ini");
}
string[] files = Directory.GetFiles(configDir, "*.conf");
string globFileResult = null;
foreach (string file in files)
{
if (file.EndsWith("Globals.conf"))
{
globFileResult = file;
InstanceProvider.GetServiceLogger().AppendLine("Loading Globals...");
InstanceProvider.GetHostInfo().SetGlobalsDefault();
string[] lines = File.ReadAllLines(file);
foreach (string line in lines)
{
if (!line.StartsWith("#") && !string.IsNullOrEmpty(line))
{
string[] split = line.Split('=');
if (split.Length == 1)
{
split[1] = "";
}
InstanceProvider.GetHostInfo().GetGlobals().First(prop => prop.KeyName == split[0]).Value = split[1];
}
}
}
}
if (globFileResult == null)
{
InstanceProvider.GetHostInfo().SetGlobalsDefault();
InstanceProvider.GetServiceLogger().AppendLine("Globals.conf was not found. Loaded defaults and saved to file.");
SaveGlobalFile();
}
InstanceProvider.GetHostInfo().ClearServerInfos();
ServerInfo serverInfo = new ServerInfo();
serverInfo.InitDefaults();
while (loading)
{
foreach (string file in files)
{
FileInfo FInfo = new FileInfo(file);
if (FInfo.Name == "Globals.conf")
{
continue;
}
serverInfo = new ServerInfo();
serverInfo.InitDefaults();
serverInfo.FileName = FInfo.Name;
serverInfo.ServerVersion = loadedVersion;
string[] linesArray = File.ReadAllLines(file);
foreach (string line in linesArray)
{
if (!line.StartsWith("#") && !string.IsNullOrEmpty(line))
{
string[] split = line.Split('=');
if (split.Length == 1)
{
split = new string[] { split[0], "" };
}
Property SrvProp = serverInfo.ServerPropList.FirstOrDefault(prop => prop.KeyName == split[0]);
if (SrvProp != null)
{
serverInfo.SetServerProp(split[0], split[1]);
}
switch (split[0])
{
case "server-name":
InstanceProvider.GetServiceLogger().AppendLine($"Loading ServerInfo for server {split[1]}...");
serverInfo.ServerName = split[1];
LoadPlayerDatabase(serverInfo);
LoadRegisteredPlayers(serverInfo);
break;
case "AddStartCmd":
serverInfo.StartCmds.Add(new StartCmdEntry(split[1]));
break;
case "ServerPath":
serverInfo.ServerPath.Value = split[1];
break;
case "ServerExeName":
serverInfo.ServerExeName.Value = split[1];
break;
case "BackupPath":
serverInfo.BackupPath.Value = split[1];
break;
case "LogToFile":
serverInfo.LogToFileEnabled.Value = split[1];
break;
case "AdvancedBackup":
serverInfo.AdvancedBackup.Value = split[1];
break;
case "MaxBackupCount":
serverInfo.MaxBackupCount.Value = split[1];
break;
}
}
}
InstanceProvider.GetHostInfo().GetServerInfos().Add(serverInfo);
}
if (InstanceProvider.GetHostInfo().GetServerInfos().Count == 0)
{
SaveServerProps(serverInfo, true);
files = Directory.GetFiles(configDir, "*.conf");
}
else
{
loading = false;
}
}
return(true);
}
private void IncomingListener()
{
keepalive = true;
InstanceProvider.GetServiceLogger().AppendLine("Established connection! Listening for incoming packets!");
int AvailBytes = 0;
int byteCount = 0;
while (InstanceProvider.GetClientServiceAlive())
{
try
{
byte[] buffer = new byte[4];
AvailBytes = client.Client.Available;
while (AvailBytes != 0) // Recieve data from client.
{
byteCount = stream.Read(buffer, 0, 4);
int expectedLen = BitConverter.ToInt32(buffer, 0);
buffer = new byte[expectedLen];
byteCount = stream.Read(buffer, 0, expectedLen);
NetworkMessageSource msgSource = (NetworkMessageSource)buffer[0];
NetworkMessageDestination msgDest = (NetworkMessageDestination)buffer[1];
NetworkMessageTypes msgType = (NetworkMessageTypes)buffer[2];
NetworkMessageStatus msgStatus = (NetworkMessageStatus)buffer[3];
string data = GetOffsetString(buffer);
string[] dataSplit = null;
switch (msgDest)
{
case NetworkMessageDestination.Server:
JsonParser message;
switch (msgType)
{
case NetworkMessageTypes.PropUpdate:
message = JsonParser.Deserialize(data);
List <Property> propList = message.Value.ToObject <List <Property> >();
Property prop = propList.First(p => p.KeyName == "server-name");
InstanceProvider.GetBedrockServer(prop.Value).serverInfo.ServerPropList = propList;
InstanceProvider.GetConfigManager().SaveServerProps(InstanceProvider.GetBedrockServer(prop.Value).serverInfo, true);
InstanceProvider.GetConfigManager().LoadConfigs();
InstanceProvider.GetBedrockServer(prop.Value).CurrentServerStatus = BedrockServer.ServerStatus.Stopping;
while (InstanceProvider.GetBedrockServer(prop.Value).CurrentServerStatus == BedrockServer.ServerStatus.Stopping)
{
Thread.Sleep(100);
}
InstanceProvider.GetBedrockServer(prop.Value).StartControl(InstanceProvider.GetBedrockService()._hostControl);
SendData(NetworkMessageSource.Server, NetworkMessageDestination.Client, NetworkMessageTypes.PropUpdate);
break;
case NetworkMessageTypes.Restart:
RestartServer(data, false);
break;
case NetworkMessageTypes.Backup:
RestartServer(data, true);
break;
case NetworkMessageTypes.Command:
dataSplit = data.Split(';');
InstanceProvider.GetBedrockServer(dataSplit[0]).StdInStream.WriteLine(dataSplit[1]);
InstanceProvider.GetServiceLogger().AppendLine($"Sent command {dataSplit[1]} to stdInput stream");
break;
}
break;
case NetworkMessageDestination.Service:
switch (msgType)
{
case NetworkMessageTypes.Connect:
InstanceProvider.GetHostInfo().ServiceLog = InstanceProvider.GetServiceLogger().Log;
string jsonString = JsonParser.Serialize(JsonParser.FromValue(InstanceProvider.GetHostInfo()));
byte[] stringAsBytes = GetBytes(jsonString);
SendData(stringAsBytes, NetworkMessageSource.Service, NetworkMessageDestination.Client, NetworkMessageTypes.Connect);
heartbeatRecieved = false;
break;
case NetworkMessageTypes.Disconnect:
DisconnectClient();
break;
case NetworkMessageTypes.Heartbeat:
if (InstanceProvider.GetHeartbeatThreadAlive())
{
heartbeatRecieved = true;
}
else
{
InstanceProvider.InitHeartbeatThread(new ThreadStart(SendBackHeatbeatSignal)).Start();
Thread.Sleep(500);
heartbeatRecieved = true;
}
break;
case NetworkMessageTypes.ConsoleLogUpdate:
StringBuilder srvString = new StringBuilder();
string[] split = data.Split('|');
for (int i = 0; i < split.Length; i++)
{
dataSplit = split[i].Split(';');
string srvName = dataSplit[0];
int srvTextLen;
int clientCurLen;
int loop;
if (srvName != "Service")
{
ServerLogger srvText = InstanceProvider.GetBedrockServer(srvName).serverInfo.ConsoleBuffer;
srvTextLen = srvText.Count();
clientCurLen = int.Parse(dataSplit[1]);
loop = clientCurLen;
while (loop < srvTextLen)
{
srvString.Append($"{srvName};{srvText.FromIndex(loop)};{loop}|");
loop++;
}
}
else
{
ServiceLogger srvText = InstanceProvider.GetServiceLogger();
srvTextLen = srvText.Count();
clientCurLen = int.Parse(dataSplit[1]);
loop = clientCurLen;
while (loop < srvTextLen)
{
srvString.Append($"{srvName};{srvText.FromIndex(loop)};{loop}|");
loop++;
}
}
}
if (srvString.Length > 1)
{
srvString.Remove(srvString.Length - 1, 1);
stringAsBytes = GetBytes(srvString.ToString());
SendData(stringAsBytes, NetworkMessageSource.Server, NetworkMessageDestination.Client, NetworkMessageTypes.ConsoleLogUpdate);
}
break;
}
break;
}
AvailBytes = client.Client.Available;
}
Thread.Sleep(200);
}
catch (OutOfMemoryException)
{
InstanceProvider.GetServiceLogger().AppendLine("");
}
catch (ObjectDisposedException e)
{
InstanceProvider.GetServiceLogger().AppendLine("Client was disposed! Killing thread...");
break;
}
catch (ThreadAbortException) { }
catch (JsonException e)
{
InstanceProvider.GetServiceLogger().AppendLine($"Error parsing json array: {e.Message}");
InstanceProvider.GetServiceLogger().AppendLine($"Stacktrace: {e.InnerException}");
}
catch (Exception e)
{
//InstanceProvider.GetServiceLogger().AppendLine($"Error: {e.Message} {e.StackTrace}");
//InstanceProvider.GetServiceLogger().AppendLine($"Error: {e.Message}: {AvailBytes}, {byteCount}\n{e.StackTrace}");
}
AvailBytes = client.Client.Available;
if (InstanceProvider.GetClientService().ThreadState == ThreadState.Aborted)
{
keepalive = false;
}
}
InstanceProvider.GetServiceLogger().AppendLine("IncomingListener thread exited.");
}
