/// <summary>
/// Download requested Spring version, then call SetEnginePath() after finishes.
/// Parameter "forSpringPaths" allow you to set a custom SpringPath for which to call SetEnginePath()
/// on behalf off (is useful for Autohost which run multiple Spring version but is sharing single downloader)
/// </summary>
public Download GetAndSwitchEngine(string version, SpringPaths forSpringPaths = null)
{
if (forSpringPaths == null)
{
forSpringPaths = SpringPaths;
}
lock (downloads) {
downloads.RemoveAll(x => x.IsAborted || x.IsComplete != null); // remove already completed downloads from list}
var existing = downloads.SingleOrDefault(x => x.Name == version);
if (existing != null)
{
return(existing);
}
if (SpringPaths.HasEngineVersion(version))
{
forSpringPaths.SetEnginePath(SpringPaths.GetEngineFolderByVersion(version));
return(null);
}
else
{
var down = new EngineDownload(version, forSpringPaths);
downloads.Add(down);
DownloadAdded.RaiseAsyncEvent(this, new EventArgs <Download>(down));
down.Start();
return(down);
}
}
}
public UnitSync(SpringPaths springPaths, string engine)
{
lock (unitsyncInitLocker)
{
paths = springPaths;
originalDirectory = Directory.GetCurrentDirectory();
var unitSyncPath = paths.GetEngineFolderByVersion(engine);
Trace.TraceInformation("UnitSync: Directory: {0}", unitSyncPath);
Trace.TraceInformation("UnitSync: ZKL: {0}", originalDirectory);
originalPathVariable = Environment.GetEnvironmentVariable("PATH");
if (originalPathVariable?.Contains(unitSyncPath) != true)
Environment.SetEnvironmentVariable("PATH",
$"{originalPathVariable}{(Environment.OSVersion.Platform == PlatformID.Unix ? ":" : ";")}{unitSyncPath}",
EnvironmentVariableTarget.Process);
//Directory.SetCurrentDirectory(paths.UnitSyncDirectory);
Environment.CurrentDirectory = unitSyncPath;
var settingsPath = Path.Combine(unitSyncPath, "springsettings.cfg");
File.WriteAllText(settingsPath, $"SpringData={paths.GetJoinedDataDirectoriesWithEngine(engine)}\n");
if (!NativeMethods.Init(false, 666)) throw new UnitSyncException("Unitsync initialization failed. " + NativeMethods.GetNextError());
Version = NativeMethods.GetSpringVersion();
UnitsyncWritableFolder = NativeMethods.GetWritableDataDirectory();
var read = NativeMethods.GetDataDirectories();
Trace.TraceInformation("UnitSync version: {0}", Version);
Trace.TraceInformation("UnitSync READ: {0}", string.Join(",", read));
Trace.TraceInformation("UnitSync WRITE: {0}", UnitsyncWritableFolder);
TraceErrors();
Trace.TraceInformation("UnitSync Initialized");
}
}
public Dictionary <string, EngineConfigEntry> GetEngineConfigOptions(SpringPaths paths, string engine)
{
Trace.TraceInformation("Extracting configuration from Spring located in {0}", paths.GetEngineFolderByVersion(engine));
var sb = new StringBuilder();
var p = new Process();
p.StartInfo.CreateNoWindow = true;
p.StartInfo.UseShellExecute = false;
p.StartInfo.Arguments += string.Format("--list-config-vars");
p.StartInfo.EnvironmentVariables["SPRING_DATADIR"] = paths.WritableDirectory;
p.StartInfo.EnvironmentVariables.Remove("SPRING_ISOLATED");
p.StartInfo.FileName = paths.GetSpringExecutablePath(engine);
p.StartInfo.WorkingDirectory = Path.GetDirectoryName(paths.GetSpringExecutablePath(engine));
p.StartInfo.RedirectStandardOutput = true;
p.OutputDataReceived += (sender, args) => sb.AppendLine(args.Data);
p.Start();
p.BeginOutputReadLine();
p.WaitForExit(3000);
sb.AppendLine(); //append terminator
var text = sb.ToString();
int whereIsTable = text.IndexOf('{');
text = text.Substring(whereIsTable); // skip empty line or other info (if exist). Compatibility with Spring 94+
var data = JsonConvert.DeserializeObject <Dictionary <string, EngineConfigEntry> >(text);
return(data);
}
public UnitSync(SpringPaths springPaths) {
lock (unitsyncInitLocker)
{
paths = springPaths;
//Getting the directory of this application instead of the non-constant currentDirectory. Reference: http://stackoverflow.com/questions/52797/how-do-i-get-the-path-of-the-assembly-the-code-is-in
originalDirectory = springPaths.WritableDirectory;
Trace.TraceInformation("UnitSync: Directory: {0}", paths.UnitSyncDirectory);
Trace.TraceInformation("UnitSync: ZKL: {0}", originalDirectory);
originalPathVariable = Environment.GetEnvironmentVariable("PATH");
if (originalPathVariable?.Contains(paths.UnitSyncDirectory) != true) Environment.SetEnvironmentVariable("PATH",
$"{originalPathVariable}{(Environment.OSVersion.Platform == PlatformID.Unix ? ":" : ";")}{paths.UnitSyncDirectory}", EnvironmentVariableTarget.Process);
//Directory.SetCurrentDirectory(paths.UnitSyncDirectory);
Environment.CurrentDirectory = paths.UnitSyncDirectory;
var settingsPath = Path.Combine(paths.UnitSyncDirectory, "springsettings.cfg");
File.WriteAllText(settingsPath, $"SpringData={paths.DataDirectoriesJoined}\n");
if (!NativeMethods.Init(false, 666)) throw new UnitSyncException("Unitsync initialization failed. " + NativeMethods.GetNextError());
Version = NativeMethods.GetSpringVersion();
UnitsyncWritableFolder = NativeMethods.GetWritableDataDirectory();
var read = NativeMethods.GetDataDirectories();
Trace.TraceInformation("UnitSync version: {0}", Version);
Trace.TraceInformation("UnitSync READ: {0}", string.Join(",", read));
Trace.TraceInformation("UnitSync WRITE: {0}", UnitsyncWritableFolder);
TraceErrors();
Trace.TraceInformation("UnitSync Initialized");
}
}
public Main(string path)
{
RootWorkPath = path;
LoadConfig();
Config.RestartCounter++;
if (Config.RestartCounter > 3)
{
Config.RestartCounter = 0;
}
SaveConfig();
paths = new SpringPaths(Path.GetDirectoryName(Config.ExecutableName), writableFolderOverride: Config.DataDir);
if (!string.IsNullOrEmpty(Config.ExecutableName))
{
paths.OverrideDedicatedServer(Config.ExecutableName);
}
paths.MakeFolders();
MetaCache = new MetaDataCache(paths, null);
timer = new Timer(30000);
timer.Elapsed += timer_Elapsed;
timer.AutoReset = true;
timer.Start();
Downloader = new PlasmaDownloader.PlasmaDownloader(Config, null, paths);
}
public PlasmaDownloader(IResourcePresenceChecker checker, SpringPaths paths)
{
SpringPaths = paths;
this.scanner = checker;
//torrentDownloader = new TorrentDownloader(this);
packageDownloader = new PackageDownloader(this);
}
public ZkLobbyServer(string geoIPpath, IPlanetwarsEventCreator creator, ITopPlayerProvider topPlayerProvider)
{
RatingSystems.Init();
TopPlayerProvider = topPlayerProvider;
PlanetWarsEventCreator = creator;
var entry = Assembly.GetExecutingAssembly();
Version = entry.GetName().Version.ToString();
Engine = MiscVar.DefaultEngine;
SpringPaths = new SpringPaths(GlobalConst.SpringieDataDir, false, false);
Downloader = new PlasmaDownloader.PlasmaDownloader(null, SpringPaths);
Downloader.GetResource(DownloadType.ENGINE, MiscVar.DefaultEngine);
Downloader.PackageDownloader.DoMasterRefresh();
Game = Downloader.PackageDownloader.GetByTag(GlobalConst.DefaultZkTag).InternalName;
LoginChecker = new LoginChecker(this, geoIPpath);
SteamWebApi = new SteamWebApi(GlobalConst.SteamAppID, new Secrets().GetSteamWebApiKey());
chatRelay = new ChatRelay(this, new List <string>()
{
"zkdev", "sy", "moddev", "weblobbydev", "ai", "zk", "zkmap", "springboard", GlobalConst.ModeratorChannel, GlobalConst.CoreChannel
});
textCommands = new ServerTextCommands(this);
ChannelManager = new ChannelManager(this);
MatchMaker = new MatchMaker(this);
battleListUpdater = new BattleListUpdater(this);
PartyManager = new PartyManager(this);
PlanetWarsMatchMaker = new PlanetWarsMatchMaker(this);
}
public MemoryStream ReadFile(SpringPaths paths, string namePath)
{
var sdpPath = Path.Combine(paths.WritableDirectory, "packages", $"{Hash}.sdp");
var sdpZkPath = Path.ChangeExtension(sdpPath, "sdpzk");
return(ReadFileFromSdp(paths, namePath, sdpPath) ?? ReadFileFromSdp(paths, namePath, sdpZkPath));
}
static void Main()
{
Trace.Listeners.Add(new ConsoleTraceListener());
Paths = new SpringPaths(null);
Scanner = new SpringScanner(Paths);
Scanner.LocalResourceAdded += (s, e) => Trace.TraceInformation("New resource found: {0}", e.Item.InternalName);
Scanner.LocalResourceRemoved += (s, e) => Trace.TraceInformation("Resource removed: {0}", e.Item.InternalName);
SpringScanner.MapRegistered += (s, e) => Trace.TraceInformation("Map registered: {0}", e.MapName);
SpringScanner.ModRegistered += (s, e) => Trace.TraceInformation("Mod registered: {0}", e.Data.Name);
Scanner.Start();
Downloader = new PlasmaDownloader.PlasmaDownloader(new Config(), Scanner, Paths);
Downloader.DownloadAdded += (s, e) => Trace.TraceInformation("Download started: {0}", e.Data.Name);
Downloader.GetAndSwitchEngine(GlobalConst.DefaultEngineOverride); //for ZKL equivalent, see PlasmaShared/GlobalConst.cs
Downloader.PackagesChanged += Downloader_PackagesChanged;
while (true)
{
Thread.Sleep(10000);
}
/*Application.EnableVisualStyles();
* Application.SetCompatibleTextRenderingDefault(false);
* Application.Run(new Form1());*/
}
public static Batch Load(string path, SpringPaths springPaths)
{
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
var batch = JsonConvert.DeserializeObject <Batch>(File.ReadAllText(path));
batch.PostLoad(springPaths);
return(batch);
}
public PlasmaDownloader(IPlasmaDownloaderConfig config, SpringScanner scanner, SpringPaths springPaths)
{
SpringPaths = springPaths;
Config = config;
this.scanner = scanner;
//torrentDownloader = new TorrentDownloader(this);
packageDownloader = new PackageDownloader(this);
}
public static void DeployAndResetConfigs(SpringPaths paths, PackageDownloader.Version ver)
{
if (ver != null)
{
var oldVers = LoadFromDisk(paths) ?? new ConfigVersions();
var newVers = LoadFromChobby(ver, paths);
bool hasError = false;
if (newVers != null)
{
foreach (
var versionEntry in newVers.Versions.Where(x => string.IsNullOrEmpty(x.Platform) || x.Platform == paths.Platform.ToString()))
{
try
{
var target = Path.Combine(paths.WritableDirectory, versionEntry.TargetPath);
if (
!oldVers.Versions.Any(
x =>
x.TargetPath == versionEntry.TargetPath && x.VersionNumber >= versionEntry.VersionNumber &&
x.Platform == versionEntry.Platform) || !File.Exists(target))
{
var dirName = Path.GetDirectoryName(target);
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
var content = ver.ReadFile(paths, versionEntry.SourcePath);
if (content != null)
{
var targetBytes = content.ToArray();
if (!File.Exists(target) || !Hash.ByteArrayEquals(File.ReadAllBytes(target), targetBytes))
{
File.WriteAllBytes(target, targetBytes);
}
}
else
{
File.Delete(target);
}
}
}
catch (Exception ex)
{
hasError = true;
Trace.TraceError("Error processing file deployment {0} : {1}", versionEntry.SourcePath, ex);
}
}
}
if (!hasError)
{
(newVers ?? oldVers).SaveToDisk(paths);
}
}
}
public Chobbyla(string rootPath, string chobbyTagOverride, string engineOverride)
{
paths = new SpringPaths(rootPath, false, true);
chobbyTag = chobbyTagOverride ?? GlobalConst.DefaultChobbyTag;
isDev = (chobbyTag == "dev") || (chobbyTag == "chobby:dev") || (chobbyTag == "zkmenu:dev");
IsSteam = File.Exists(Path.Combine(paths.WritableDirectory, "steamfolder.txt"));
engine = engineOverride;
downloader = new PlasmaDownloader.PlasmaDownloader(null, paths);
}
private static ConfigVersions LoadFromChobby(PackageDownloader.Version ver, SpringPaths paths)
{
var ms = ver?.ReadFile(paths, FilePathInChobby);
if (ms != null)
{
return(TryDeserialize(Encoding.UTF8.GetString(ms.ToArray())));
}
return(null);
}
public PackageDownload(string urlRoot, string displayName, Hash hash, SpringPaths paths)
{
this.paths = paths;
this.urlRoot = urlRoot;
pool = new Pool(paths);
PackageHash = hash;
Name = displayName;
fileListWebGet = new WebDownload();
}
private static ConfigVersions LoadFromDisk(SpringPaths paths)
{
var filePath = Path.Combine(paths.WritableDirectory, FilePathOnDisk);
if (File.Exists(filePath))
{
return(TryDeserialize(File.ReadAllText(filePath)));
}
return(null);
}
public ServerImagesHandler(SpringPaths springPaths, TasClient tas)
{
basePath = Utils.MakePath(springPaths.WritableDirectory, "LuaUI", "Configs");
tas.BattleUserJoined += (sender, args) =>
{
// preload avatar images on user join battle so that they are available ingame
User us;
if (tas.ExistingUsers.TryGetValue(args.UserName, out us))
{
GetAvatarImage(us);
GetClanOrFactionImage(us);
}
};
}
public void ConvertSdp2Sdz(SpringPaths paths, Hash sdpHash, string targetSdz, Action <double> progressIndicator = null)
{
var sdpPath = Path.Combine(paths.WritableDirectory, "packages", sdpHash + ".sdp");
var tempSdz = Path.Combine(paths.WritableDirectory, "temp", sdpHash + ".sdz");
SdpArchive fileList;
using (var fs = new FileStream(sdpPath, FileMode.Open)) fileList = new SdpArchive(new System.IO.Compression.GZipStream(fs, System.IO.Compression.CompressionMode.Decompress));
GenerateSdz(paths, fileList, tempSdz, progressIndicator);
tempSdz.RenameWithOverwrite(targetSdz);
sdpPath.RenameWithOverwrite(Path.ChangeExtension(sdpPath, "sdpzk")); // rename sdp -> sdpzk
}
public MainForm(SpringPaths paths = null, SpringScanner scanner = null, PlasmaDownloader.PlasmaDownloader downloader = null)
{
InitializeComponent();
if (paths != null)
{
springPaths = paths;
}
else
{
springPaths = new SpringPaths(null, writableFolderOverride: null);
}
if (scanner != null)
{
springScanner = scanner;
}
else
{
springScanner = new SpringScanner(springPaths);
springScanner.Start();
}
if (downloader != null)
{
springDownloader = downloader;
}
else
{
springDownloader = new PlasmaDownloader.PlasmaDownloader(new PlasmaConfig(), springScanner, springPaths);
}
var timer = new Timer();
timer.Tick += (sender, args) =>
{
tbDownloads.Clear();
foreach (var d in springDownloader.Downloads.Where(x => x.IsComplete == null))
{
tbDownloads.AppendText(string.Format("{1:F0}% {0} ETA: {2} {3}\n",
d.Name,
d.TotalProgress,
d.TimeRemaining,
d.IsComplete));
}
};
timer.Interval = 1000;
timer.Enabled = true;
tbEngine.Text = springPaths.SpringVersion;
}
public static IEnumerable <Config> GetConfigs(SpringPaths paths, bool refresh = false)
{
if (refresh)
{
allConfigs = null;
}
if (allConfigs != null)
{
return(allConfigs);
}
allConfigs = new List <Config>();
allConfigs = Batch.GetBenchmarkFolders(paths, "Configs").SelectMany(x => x.GetDirectories().Select(y => new Config(y.FullName))).ToList();
return(allConfigs);
}
internal static void LoadConfig()
{
var curConfPath = Path.Combine(StartupPath, Config.ConfigFileName);
if (File.Exists(curConfPath))
{
Conf = Config.Load(curConfPath);
}
else
{
Conf = Config.Load(Path.Combine(SpringPaths.GetMySpringDocPath(), Config.ConfigFileName));
Conf.IsFirstRun = true; // treat import as a first run
}
}
public UnitSyncer(SpringPaths npaths, string nengine)
{
Paths = npaths;
Engine = nengine;
if (string.IsNullOrEmpty(Engine) || !Paths.HasEngineVersion(Engine))
{
Trace.TraceWarning("UnitSyncer: Engine {0} not found, trying backup", Engine);
Engine = Paths.GetEngineList().FirstOrDefault();
if (Engine == null)
{
throw new Exception("UnitSyncer: No engine found for unitsync");
}
}
}
/// <summary>
/// Gets all benchamrks and caches them. Looks for folder Benchmarks and traverses paths up until found
/// </summary>
public static List <Benchmark> GetBenchmarks(SpringPaths paths, bool refresh = false)
{
if (refresh)
{
allBenchmarks = null;
}
if (allBenchmarks != null)
{
return(allBenchmarks);
}
allBenchmarks = new List <Benchmark>();
allBenchmarks = Batch.GetBenchmarkFolders(paths, "games").SelectMany(x => x.GetDirectories("*.sdd").Select(y => new Benchmark(y.FullName))).ToList();
return(allBenchmarks);
}
public static IEnumerable <StartScript> GetStartScripts(SpringPaths paths, bool refresh = false)
{
if (refresh)
{
allStartScripts = null;
}
if (allStartScripts != null)
{
return(allStartScripts);
}
allStartScripts = new List <StartScript>();
allStartScripts =
Batch.GetBenchmarkFolders(paths, "Scripts").SelectMany(x => x.GetFiles("*.txt").Select(y => new StartScript(y.FullName))).ToList();
return(allStartScripts);
}
private static MemoryStream ReadFileFromSdp(SpringPaths paths, string namePath, string sdpPath)
{
if (File.Exists(sdpPath))
{
SdpArchive sdp;
using (var fs = new FileStream(sdpPath, FileMode.Open)) sdp = new SdpArchive(new GZipStream(fs, CompressionMode.Decompress));
var entry = sdp.Files.FirstOrDefault(x => x.Name.ToLower() == namePath.Replace('\\', '/').ToLower());
if (entry != null)
{
return(new Pool(paths).ReadFromStorageDecompressed(entry.Hash));
}
}
return(null);
}
public ZkLobbyServer(string geoIPpath, IPlanetwarsEventCreator creator)
{
RatingSystems.Init();
MapRatings.Init();
PlanetWarsEventCreator = creator;
var entry = Assembly.GetExecutingAssembly();
Version = entry.GetName().Version.ToString();
Engine = MiscVar.DefaultEngine;
SpringPaths = new SpringPaths(GlobalConst.SpringieDataDir, false, false);
Downloader = new PlasmaDownloader.PlasmaDownloader(null, SpringPaths);
Downloader.GetResource(DownloadType.ENGINE, MiscVar.DefaultEngine);
Downloader.PackageDownloader.DoMasterRefresh();
Game = MiscVar.LastRegisteredZkVersion;
LoginChecker = new LoginChecker(this, geoIPpath);
SteamWebApi = new SteamWebApi(GlobalConst.SteamAppID, new Secrets().GetSteamWebApiKey());
chatRelay = new ChatRelay(this, new List <string>()
{
"zkdev", "sy", "moddev", "weblobbydev", "ai", "zk", "zkmap", "springboard", GlobalConst.ModeratorChannel, GlobalConst.CoreChannel, "off-topic", "support", "modding", "crashreports"
});
textCommands = new ServerTextCommands(this);
ChannelManager = new ChannelManager(this);
MatchMaker = new MatchMaker(this);
battleListUpdater = new BattleListUpdater(this);
PartyManager = new PartyManager(this);
PlanetWarsMatchMaker = new PlanetWarsMatchMaker(this);
NewsListManager = new NewsListManager(this);
LadderListManager = new LadderListManager(this);
ForumListManager = new ForumListManager(this);
SpawnAutohosts();
RatingSystems.GetRatingSystems().ForEach(x => x.RatingsUpdated += (sender, data) =>
{
var db = new ZkDataContext();
var updatedUsers = ConnectedUsers.Select(c => c.Value.User.AccountID).Intersect(data.affectedPlayers).ToHashSet();
db.Accounts.Where(acc => updatedUsers.Contains(acc.AccountID)).ForEach(p =>
{
PublishAccountUpdate(p);
PublishUserProfileUpdate(p);
});
});
}
/// <summary>
/// Generates sdz archive from pool and file list
/// </summary>
private void GenerateSdz(SpringPaths paths, SdpArchive fileList, string tempSdz, Action <double> progressIndicator)
{
var pool = new Pool(paths);
var dir = Path.GetDirectoryName(tempSdz);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
if (File.Exists(tempSdz))
{
File.Delete(tempSdz);
}
long uncompressedTotalSize = fileList.Files.Sum(x => x.UncompressedSize);
long uncompressedProgress = 0;
using (var fs = new FileStream(tempSdz, FileMode.Create, FileAccess.Write, FileShare.None))
using (var zip = new ZipOutputStream(fs, false))
{
zip.CompressionLevel = CompressionLevel.BestSpeed;
zip.ParallelDeflateThreshold = 0;
foreach (var fl in fileList.Files)
{
zip.PutNextEntry(fl.Name);
// 0 means paralell deflate is used, -1 means it is disabled
if (fl.UncompressedSize > paralellZipForFilesAboveSize)
{
zip.ParallelDeflateThreshold = 0;
}
else
{
zip.ParallelDeflateThreshold = -1;
}
using (var itemStream = pool.ReadFromStorageDecompressed(fl.Hash)) itemStream.CopyTo(zip);
uncompressedProgress += fl.UncompressedSize;
progressIndicator?.Invoke((double)uncompressedProgress / uncompressedTotalSize);
}
}
}
void PostLoad(SpringPaths paths)
{
Benchmarks =
Benchmarks.Select(
x =>
Benchmark.GetBenchmarks(paths).SingleOrDefault(y => y.BenchmarkPath == x.BenchmarkPath) ??
Benchmark.GetBenchmarks(paths).First(y => y.Name == x.Name)).ToList();
foreach (var tr in TestCases)
{
tr.Config = Config.GetConfigs(paths).SingleOrDefault(x => x.ConfigPath == tr.Config.ConfigPath) ??
Config.GetConfigs(paths).First(x => x.Name == tr.Config.Name);
tr.StartScript = StartScript.GetStartScripts(paths).SingleOrDefault(x => x.ScriptPath == tr.StartScript.ScriptPath) ??
StartScript.GetStartScripts(paths).First(x => x.Name == tr.StartScript.Name);
}
}
public MemoryStream ReadFile(SpringPaths paths, string namePath)
{
var sdpPath = Path.Combine(paths.WritableDirectory, "packages", $"{Hash}.sdp");
if (File.Exists(sdpPath))
{
SdpArchive sdp;
using (var fs = new FileStream(sdpPath, FileMode.Open)) sdp = new SdpArchive(new GZipStream(fs, CompressionMode.Decompress));
var entry = sdp.Files.FirstOrDefault(x => x.Name.ToLower() == namePath.Replace('\\', '/').ToLower());
if (entry != null)
{
return(new Pool(paths).ReadFromStorageDecompressed(entry.Hash));
}
}
return(null);
}
private async Task <bool> LaunchChobby(SpringPaths paths, string internalName, string engineVersion, int loopbackPort, TextWriter writer)
{
process = new Process {
StartInfo = { CreateNoWindow = false, UseShellExecute = false }
};
paths.SetDefaultEnvVars(process.StartInfo, engineVersion);
var widgetFolder = Path.Combine(paths.WritableDirectory); //, "LuaMenu", "Widgets");
if (!Directory.Exists(widgetFolder))
{
Directory.CreateDirectory(widgetFolder);
}
File.WriteAllText(Path.Combine(widgetFolder, "chobby_wrapper_port.txt"), loopbackPort.ToString());
process.StartInfo.FileName = paths.GetSpringExecutablePath(engineVersion);
process.StartInfo.WorkingDirectory = Path.GetDirectoryName(paths.GetSpringExecutablePath(engineVersion));
process.StartInfo.Arguments = $"--menu \"{internalName}\"";
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.OutputDataReceived += (sender, args) => { writer.WriteLine(args.Data); };
process.ErrorDataReceived += (sender, args) => { writer.WriteLine(args.Data); };
var tcs = new TaskCompletionSource <bool>();
process.Exited += (sender, args) =>
{
var isCrash = process.ExitCode != 0;
var isHangKilled = (process.ExitCode == -805306369); // hanged, drawn and quartered
if (isCrash)
{
Trace.TraceWarning("Spring exit code is: {0}, {1}", process.ExitCode, isHangKilled ? "user-killed during hang" : "assuming crash");
}
tcs.TrySetResult(!isCrash || isHangKilled);
};
process.EnableRaisingEvents = true;
process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();
return(await tcs.Task);
}
public void RunTests(SpringPaths paths)
{
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
isAborted = false;
var result = new BatchRunResult();
bool usingOptirun = !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("OPTIRUN"));
foreach (var tr in TestCases)
{
foreach (var b in Benchmarks)
{
if (isAborted)
{
return;
}
b.ModifyModInfo(tr);
string log = null;
try {
run = new SpringRun();
log = run.Start(paths, tr, b);
} catch (Exception ex) {
Trace.TraceError(ex.ToString());
} finally {
b.RestoreModInfo();
}
try {
if (usingOptirun) // leave some time for optimus/primus to rest
{
Thread.Sleep(5000);
}
result.AddRun(tr, b, log);
RunCompleted(tr, b, log);
} catch (Exception ex) {
Trace.TraceError(ex.ToString());
}
}
}
if (isAborted)
{
return;
}
AllCompleted(result);
}
public MainForm(SpringPaths paths, IResourcePresenceChecker scanner = null, PlasmaDownloader.PlasmaDownloader downloader = null)
{
InitializeComponent();
springPaths = paths;
if (scanner != null)
{
springScanner = scanner;
}
else
{
var pl = new PlasmaResourceChecker(springPaths);
springScanner = pl;
pl.Start();
}
if (downloader != null)
{
springDownloader = downloader;
}
else
{
springDownloader = new PlasmaDownloader.PlasmaDownloader(springScanner, springPaths);
}
timer = new Timer();
timer.Tick += (sender, args) =>
{
tbDownloads.Clear();
foreach (var d in springDownloader.Downloads.Where(x => x.IsComplete == null))
{
tbDownloads.AppendText(string.Format("{1:F0}% {0} ETA: {2} {3}\n",
d.Name,
d.TotalProgress,
d.TimeRemaining,
d.IsComplete));
}
};
timer.Interval = 1000;
timer.Enabled = true;
tbEngine.Text = GlobalConst.DefaultEngineOverride;
}
