private async void Start(PackageViewModel package, CancellationToken cancellationToken)
{
// Load existing effect log
try
{
// Connect to effect compiler server
await routerLaunchedTask;
var effectCompilerServerSocket = await RouterClient.RequestServer($"/service/Stride.EffectCompilerServer/{StrideVersion.NuGetVersion}/Stride.EffectCompilerServer.exe?mode=gamestudio&packagename={package.Package.Meta.Name}");
// Cancellation by closing the socket handle
cancellationToken.Register(effectCompilerServerSocket.Dispose);
var effectCompilerMessageLayer = new SocketMessageLayer(effectCompilerServerSocket, false);
// Load existing asset
dispatcher.Invoke(() => CheckEffectLogAsset(package));
effectCompilerMessageLayer.AddPacketHandler <RemoteEffectCompilerEffectRequested>(packet => HandleEffectCompilerRequestedPacket(packet, package));
// Run main socket loop
Task.Run(() => effectCompilerMessageLayer.MessageLoop());
}
catch
{
// TODO: Log error
}
}
private static void ConnectToImageServer()
{
// Use connection router to connect back to image tester
// Connect during startup, so that first test timing is not affected by initial connection
try
{
var imageServerSocket = RouterClient.RequestServer($"/redirect/{ImageTester.XenkoImageServerHost}/{ImageTester.XenkoImageServerPort}").Result;
ImageTester.Connect(imageServerSocket);
}
catch (Exception e)
{
Logger.Error("Error connecting to image tester server: {0}", e);
}
}
private static async Task RunRouterTest()
{
Console.WriteLine("Starting router tests!");
Console.WriteLine("");
var textSettings = await File.ReadAllTextAsync("appsettings.json").ConfigureAwait(false);
var settings = JsonConvert.DeserializeObject <AppSettings>(textSettings);
var sensorData = await File.ReadAllTextAsync(settings.SensorIdPath).ConfigureAwait(false);
var sensors = JsonConvert.DeserializeObject <IList <string> >(sensorData);
var generator = new MeasurementGenerator(sensors);
var client = new RouterClient(settings.RouterHostname, settings.RouterPort);
await client.RunAsync(generator, settings.BatchSize).ConfigureAwait(false);
}
public async Task <SocketMessageLayer> Connect(Guid?packageId, CancellationToken cancellationToken)
{
var url = string.Format("/service/{0}/SiliconStudio.Xenko.EffectCompilerServer.exe", XenkoVersion.NuGetVersion);
if (packageId.HasValue)
{
url += string.Format("?packageid={0}", packageId.Value);
}
var socketContext = await RouterClient.RequestServer(url, cancellationToken);
var socketMessageLayer = new SocketMessageLayer(socketContext, false);
// Register network VFS
NetworkVirtualFileProvider.RegisterServer(socketMessageLayer);
Task.Run(() => socketMessageLayer.MessageLoop());
return(socketMessageLayer);
}
public async Task <SocketMessageLayer> Connect(string packageName, CancellationToken cancellationToken)
{
var url = $"/service/Xenko.EffectCompilerServer/{XenkoVersion.NuGetVersion}/Xenko.EffectCompilerServer.exe";
if (packageName != null)
{
url += string.Format("?packagename={0}", packageName);
}
var socketContext = await RouterClient.RequestServer(url, cancellationToken);
var socketMessageLayer = new SocketMessageLayer(socketContext, false);
// Register network VFS
NetworkVirtualFileProvider.RegisterServer(socketMessageLayer);
Task.Run(() => socketMessageLayer.MessageLoop());
return(socketMessageLayer);
}
public async Task <SocketMessageLayer> Connect(Guid?packageId)
{
var url = string.Format("/service/{0}/SiliconStudio.Paradox.EffectCompilerServer.exe", ParadoxVersion.CurrentAsText);
if (packageId.HasValue)
{
url += string.Format("?packageid={0}", packageId.Value);
}
var socketContext = await RouterClient.RequestServer(url);
var socketMessageLayer = new SocketMessageLayer(socketContext, false);
// Register network VFS
NetworkVirtualFileProvider.RegisterServer(socketMessageLayer);
Task.Run(() => socketMessageLayer.MessageLoop());
return(socketMessageLayer);
}
public override async void Initialize()
{
var game = (Game)Game;
var url = $"/service/{XenkoVersion.CurrentAsText}/SiliconStudio.Xenko.SamplesTestServer.exe";
var socketContext = await RouterClient.RequestServer(url);
socketMessageLayer = new SocketMessageLayer(socketContext, false);
socketMessageLayer.AddPacketHandler <KeySimulationRequest>(request =>
{
if (request.Down)
{
game.Input.SimulateKeyDown(request.Key);
}
else
{
game.Input.SimulateKeyUp(request.Key);
}
});
socketMessageLayer.AddPacketHandler <TapSimulationRequest>(request =>
{
switch (request.State)
{
case PointerState.Down:
game.Input.SimulateTapDown(request.Coords);
break;
case PointerState.Up:
game.Input.SimulateTapUp(request.Coords, request.CoordsDelta, request.Delta);
break;
case PointerState.Move:
game.Input.SimulateTapMove(request.Coords, request.CoordsDelta, request.Delta);
break;
}
});
socketMessageLayer.AddPacketHandler <ScreenshotRequest>(request =>
{
drawActions.Enqueue(() =>
{
SaveTexture(game.GraphicsDevice.BackBuffer, request.Filename);
});
});
socketMessageLayer.AddPacketHandler <TestEndedRequest>(request =>
{
socketMessageLayer.Context.Dispose();
game.Exit();
Quit();
});
Task.Run(() => socketMessageLayer.MessageLoop());
drawActions.Enqueue(async() =>
{
await socketMessageLayer.Send(new TestRegistrationRequest {
GameAssembly = game.Settings.PackageName, Tester = false, Platform = (int)Platform.Type
});
});
Initialized = true;
#if SILICONSTUDIO_PLATFORM_IOS || SILICONSTUDIO_PLATFORM_ANDROID || SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP
Console.WriteLine(@"Test initialized, waiting to start...");
#endif
}
public GameTestingClient(string gamePath, PlatformType platform)
{
GameTestingSystem.Initialized = true; //prevent time-outs from test side!!
if (gamePath == null)
{
throw new ArgumentNullException(nameof(gamePath));
}
xenkoDir = Environment.GetEnvironmentVariable("SiliconStudioXenkoDir");
if (xenkoDir.IsNullOrEmpty())
{
throw new NullReferenceException("Could not find SiliconStudioXenkoDir, make sure the environment variable is set.");
}
gameName = Path.GetFileNameWithoutExtension(gamePath);
switch (platform)
{
case PlatformType.Windows:
platformName = "Windows";
break;
case PlatformType.Android:
platformName = "Android";
break;
case PlatformType.iOS:
platformName = "iOS";
break;
case PlatformType.UWP:
platformName = "UWP";
break;
default:
platformName = "";
break;
}
var url = $"/service/{XenkoVersion.CurrentAsText}/SiliconStudio.Xenko.SamplesTestServer.exe";
var socketContext = RouterClient.RequestServer(url).Result;
var success = false;
var message = "";
var ev = new AutoResetEvent(false);
socketMessageLayer = new SocketMessageLayer(socketContext, false);
socketMessageLayer.AddPacketHandler <StatusMessageRequest>(request =>
{
success = !request.Error;
message = request.Message;
ev.Set();
});
socketMessageLayer.AddPacketHandler <LogRequest>(request => { Console.WriteLine(request.Message); });
socketMessageLayer.AddPacketHandler <ScreenshotStored>(request =>
{
screenshotEvent.Set();
});
var runTask = Task.Run(() => socketMessageLayer.MessageLoop());
var cmd = platform == PlatformType.Windows ? xenkoDir + "\\" + gamePath : "";
socketMessageLayer.Send(new TestRegistrationRequest
{
Platform = (int)platform, Tester = true, Cmd = cmd, GameAssembly = gameName
}).Wait();
var waitMs = 10000;
switch (platform)
{
case PlatformType.Android:
waitMs = 20000;
break;
case PlatformType.iOS:
waitMs = 40000;
break;
}
if (!ev.WaitOne(waitMs))
{
socketMessageLayer.Send(new TestAbortedRequest()).Wait();
throw new Exception("Time out while launching the game");
}
if (!success)
{
throw new Exception("Failed: " + message);
}
Console.WriteLine(@"Game started. (message: " + message + @")");
}
public override async void Initialize()
{
var game = (Game)Game;
var url = $"/service/Stride.SamplesTestServer/{StrideVersion.NuGetVersion}/Stride.SamplesTestServer.exe";
var socketContext = await RouterClient.RequestServer(url);
socketMessageLayer = new SocketMessageLayer(socketContext, false);
socketMessageLayer.AddPacketHandler <KeySimulationRequest>(request =>
{
drawActions.Enqueue(() =>
{
if (request.Down)
{
keyboardSimulated.SimulateDown(request.Key);
}
else
{
keyboardSimulated.SimulateUp(request.Key);
}
});
});
socketMessageLayer.AddPacketHandler <TapSimulationRequest>(request =>
{
drawActions.Enqueue(() =>
{
mouseSimulated.SimulatePointer(request.EventType, request.Coords);
});
});
socketMessageLayer.AddPacketHandler <ScreenshotRequest>(request =>
{
drawActions.Enqueue(() =>
{
SaveTexture(game.GraphicsDevice.Presenter.BackBuffer, request.Filename);
});
});
socketMessageLayer.AddPacketHandler <TestEndedRequest>(request =>
{
socketMessageLayer.Context.Dispose();
game.Exit();
Quit();
});
var t = Task.Run(() => socketMessageLayer.MessageLoop());
drawActions.Enqueue(async() =>
{
await socketMessageLayer.Send(new TestRegistrationRequest {
GameAssembly = game.Settings.PackageName, Tester = false, Platform = (int)Platform.Type
});
});
Initialized = true;
Console.WriteLine(@"Test initialized, waiting to start...");
}
private void RunTests()
{
AppDomain.CurrentDomain.UnhandledException += (a, e) =>
{
var exception = e.ExceptionObject as Exception;
if (exception != null)
{
var exceptionText = exception.ToString();
stringBuilder.Append($"Tests fatal failure: {exceptionText}");
Logger.Debug($"Unhandled fatal exception: {exception.ToString()}");
EndTesting(true);
}
};
var xenkoVersion = Intent.GetStringExtra(TestRunner.XenkoVersion);
var buildNumber = Parse(Intent.GetStringExtra(TestRunner.XenkoBuildNumber) ?? "-1");
var branchName = Intent.GetStringExtra(TestRunner.XenkoBranchName) ?? "";
// Remove extra (if activity is recreated)
Intent.RemoveExtra(TestRunner.XenkoVersion);
Intent.RemoveExtra(TestRunner.XenkoBuildNumber);
Intent.RemoveExtra(TestRunner.XenkoBranchName);
Logger.Info(@"*******************************************************************************************************************************");
Logger.Info(@"date: " + DateTime.Now);
Logger.Info(@"*******************************************************************************************************************************");
// Connect to server right away to let it know we're alive
//var client = Connect(serverAddresses, serverPort);
var url = "/task/SiliconStudio.Xenko.TestRunner.exe";
socketContext = RouterClient.RequestServer(url).Result;
socketBinaryWriter = new BinaryWriter(socketContext.WriteStream);
// Update build number (if available)
ImageTester.ImageTestResultConnection.BuildNumber = buildNumber;
ImageTester.ImageTestResultConnection.BranchName = branchName ?? "";
ConnectToImageServer();
// Start unit test
var cachePath = CacheDir.AbsolutePath;
var timeNow = DateTime.Now;
// Generate result file name
resultFile = Path.Combine(cachePath, $"TestResult-{timeNow:yyyy-MM-dd_hh-mm-ss-tt}.xml");
Logger.Debug(@"Execute tests");
stringBuilder = new StringBuilder();
var stringWriter = new StringWriter(stringBuilder);
try
{
new TextUI(stringWriter)
{
TestListener = this
}.Execute(new[] { "-format:nunit2", $"-result:{resultFile}" });
}
catch (Exception ex)
{
stringBuilder.Append($"Tests fatal failure: {ex}");
Logger.Error($"Tests fatal failure: {ex}");
}
EndTesting(false);
}
public GameTestingClient(string gamePath, PlatformType platform)
{
GameTestingSystem.Initialized = true; //prevent time-outs from test side!!
this.gamePath = gamePath ?? throw new ArgumentNullException(nameof(gamePath));
gameName = Path.GetFileName(gamePath);
switch (platform)
{
case PlatformType.Windows:
platformName = "Windows";
break;
case PlatformType.Android:
platformName = "Android";
break;
case PlatformType.iOS:
platformName = "iOS";
break;
case PlatformType.UWP:
platformName = "UWP";
break;
default:
platformName = "";
break;
}
var url = $"/service/Stride.SamplesTestServer/{StrideVersion.NuGetVersion}/Stride.SamplesTestServer.exe";
var socketContext = RouterClient.RequestServer(url).Result;
var success = false;
var message = "";
var ev = new AutoResetEvent(false);
socketMessageLayer = new SocketMessageLayer(socketContext, false);
socketMessageLayer.AddPacketHandler <StatusMessageRequest>(request =>
{
success = !request.Error;
message = request.Message;
ev.Set();
});
socketMessageLayer.AddPacketHandler <LogRequest>(request => { Console.WriteLine(request.Message); });
socketMessageLayer.AddPacketHandler <ScreenshotStored>(request =>
{
screenshotEvent.Set();
});
var runTask = Task.Run(() => socketMessageLayer.MessageLoop());
var cmd = platform == PlatformType.Windows ? Path.Combine(Environment.CurrentDirectory, gamePath, "Bin\\Windows\\Debug", gameName + ".Windows.exe") : "";
socketMessageLayer.Send(new TestRegistrationRequest
{
Platform = (int)platform, Tester = true, Cmd = cmd, GameAssembly = gameName + ".Game"
}).Wait();
// Wait up to one minute
var waitMs = 60 * 1000;
switch (platform)
{
case PlatformType.Android:
waitMs *= 2;
break;
case PlatformType.iOS:
waitMs *= 2;
break;
}
if (!ev.WaitOne(waitMs))
{
socketMessageLayer.Send(new TestAbortedRequest()).Wait();
throw new Exception("Time out while launching the game");
}
if (!success)
{
throw new Exception("Failed: " + message);
}
Console.WriteLine(@"Game started. (message: " + message + @")");
}
