public static void RegisterServer(SocketMessageLayer socketMessageLayer)
{
socketMessageLayer.AddPacketHandler<DownloadFileQuery>(
async (packet) =>
{
var stream = await VirtualFileSystem.OpenStreamAsync(packet.Url, VirtualFileMode.Open, VirtualFileAccess.Read);
var data = new byte[stream.Length];
await stream.ReadAsync(data, 0, data.Length);
stream.Dispose();
socketMessageLayer.Send(new DownloadFileAnswer { StreamId = packet.StreamId, Data = data });
});
socketMessageLayer.AddPacketHandler<UploadFilePacket>(
async (packet) =>
{
var stream = await VirtualFileSystem.OpenStreamAsync(packet.Url, VirtualFileMode.Create, VirtualFileAccess.Write);
await stream.WriteAsync(packet.Data, 0, packet.Data.Length);
stream.Dispose();
});
socketMessageLayer.AddPacketHandler<FileExistsQuery>(
async (packet) =>
{
var fileExists = await VirtualFileSystem.FileExistsAsync(packet.Url);
socketMessageLayer.Send(new FileExistsAnswer { StreamId = packet.StreamId, FileExists = fileExists });
});
}
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
}
}
public NetworkVirtualFileProvider(SocketMessageLayer socketMessageLayer, string remoteUrl) : base(null)
{
this.socketMessageLayer = socketMessageLayer;
RemoteUrl = remoteUrl;
if (!RemoteUrl.EndsWith(VirtualFileSystem.DirectorySeparatorChar.ToString()))
RemoteUrl += VirtualFileSystem.DirectorySeparatorChar;
}
public NetworkWriteStream(SocketMessageLayer socketMessageLayer, string url)
: base(new MemoryStream())
{
this.memoryStream = (MemoryStream)InternalStream;
this.url = url;
this.socketMessageLayer = socketMessageLayer;
}
public static void RegisterServer(SocketMessageLayer socketMessageLayer)
{
socketMessageLayer.AddPacketHandler <DownloadFileQuery>(
async(packet) =>
{
var stream = await VirtualFileSystem.OpenStreamAsync(packet.Url, VirtualFileMode.Open, VirtualFileAccess.Read);
var data = new byte[stream.Length];
await stream.ReadAsync(data, 0, data.Length);
stream.Dispose();
socketMessageLayer.Send(new DownloadFileAnswer {
StreamId = packet.StreamId, Data = data
});
});
socketMessageLayer.AddPacketHandler <UploadFilePacket>(
async(packet) =>
{
var stream = await VirtualFileSystem.OpenStreamAsync(packet.Url, VirtualFileMode.Create, VirtualFileAccess.Write);
await stream.WriteAsync(packet.Data, 0, packet.Data.Length);
stream.Dispose();
});
socketMessageLayer.AddPacketHandler <FileExistsQuery>(
async(packet) =>
{
var fileExists = await VirtualFileSystem.FileExistsAsync(packet.Url);
socketMessageLayer.Send(new FileExistsAnswer {
StreamId = packet.StreamId, FileExists = fileExists
});
});
}
public NetworkVirtualFileProvider(SocketMessageLayer socketMessageLayer, string remoteUrl) : base(null)
{
this.socketMessageLayer = socketMessageLayer;
RemoteUrl = remoteUrl;
if (!RemoteUrl.EndsWith(VirtualFileSystem.DirectorySeparatorChar.ToString()))
{
RemoteUrl += VirtualFileSystem.DirectorySeparatorChar;
}
}
private static async Task ShaderCompilerRequestHandler(SocketMessageLayer socketMessageLayer, EffectCompiler effectCompiler, RemoteEffectCompilerEffectRequest remoteEffectCompilerEffectRequest)
{
// Yield so that this socket can continue its message loop to answer to shader file request
// TODO: maybe not necessary anymore with RouterServiceServer?
await Task.Yield();
Console.WriteLine($"Compiling shader: {remoteEffectCompilerEffectRequest.MixinTree.Name}");
// A shader has been requested, compile it (asynchronously)!
var precompiledEffectShaderPass = await effectCompiler.Compile(remoteEffectCompilerEffectRequest.MixinTree, remoteEffectCompilerEffectRequest.EffectParameters, null).AwaitResult();
// Send compiled shader
await socketMessageLayer.Send(new RemoteEffectCompilerEffectAnswer { StreamId = remoteEffectCompilerEffectRequest.StreamId, EffectBytecode = precompiledEffectShaderPass.Bytecode });
}
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 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);
}
private static async Task ShaderCompilerRequestHandler(SocketMessageLayer socketMessageLayer, EffectLogStore recordedEffectCompile, EffectCompiler effectCompiler, RemoteEffectCompilerEffectRequest remoteEffectCompilerEffectRequest)
{
// Yield so that this socket can continue its message loop to answer to shader file request
// TODO: maybe not necessary anymore with RouterServiceServer?
await Task.Yield();
Console.WriteLine("Compiling shader");
// Restore MixinTree.UsedParameters (since it is DataMemberIgnore)
remoteEffectCompilerEffectRequest.MixinTree.UsedParameters = remoteEffectCompilerEffectRequest.UsedParameters;
// A shader has been requested, compile it (asynchronously)!
var precompiledEffectShaderPass = await effectCompiler.Compile(remoteEffectCompilerEffectRequest.MixinTree, null).AwaitResult();
// Record compilation to asset file (only if parent)
recordedEffectCompile[new EffectCompileRequest(remoteEffectCompilerEffectRequest.MixinTree.Name, remoteEffectCompilerEffectRequest.MixinTree.UsedParameters)] = true;
// Send compiled shader
socketMessageLayer.Send(new RemoteEffectCompilerEffectAnswer {
StreamId = remoteEffectCompilerEffectRequest.StreamId, EffectBytecode = precompiledEffectShaderPass.Bytecode
});
}
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 + @")");
}
public override async void Initialize()
{
var game = (Game)Game;
//Quit after 1 minute anyway!
Task.Run(async () =>
{
await Task.Delay(60000);
Quit(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 =>
{
Quit(game);
});
Task.Run(() => socketMessageLayer.MessageLoop());
drawActions.Enqueue(async () =>
{
await socketMessageLayer.Send(new TestRegistrationRequest { GameAssembly = game.Settings.PackageName, Tester = false, Platform = (int)Platform.Type });
});
}
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...");
}
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
}
private static async Task ShaderCompilerRequestHandler(SocketMessageLayer socketMessageLayer, EffectCompiler effectCompiler, RemoteEffectCompilerEffectRequest remoteEffectCompilerEffectRequest)
{
// Yield so that this socket can continue its message loop to answer to shader file request
// TODO: maybe not necessary anymore with RouterServiceServer?
await Task.Yield();
Console.WriteLine($"Compiling shader: {remoteEffectCompilerEffectRequest.MixinTree.Name}");
// A shader has been requested, compile it (asynchronously)!
var precompiledEffectShaderPass = await effectCompiler.Compile(remoteEffectCompilerEffectRequest.MixinTree, remoteEffectCompilerEffectRequest.EffectParameters, null).AwaitResult();
// Send compiled shader
await socketMessageLayer.Send(new RemoteEffectCompilerEffectAnswer { StreamId = remoteEffectCompilerEffectRequest.StreamId, EffectBytecode = precompiledEffectShaderPass.Bytecode });
}
public NetworkWriteStream(SocketMessageLayer socketMessageLayer, string url)
: base(new MemoryStream())
{
this.memoryStream = (MemoryStream)InternalStream;
this.url = url;
this.socketMessageLayer = socketMessageLayer;
}
/// <inheritdoc/>
protected override async void HandleClient(SimpleSocket clientSocket, string url)
{
string[] urlSegments;
string urlParameters;
RouterHelper.ParseUrl(url, out urlSegments, out urlParameters);
var parameters = RouterHelper.ParseQueryString(urlParameters);
var mode = parameters["mode"];
// We accept everything
await AcceptConnection(clientSocket);
var socketMessageLayer = new SocketMessageLayer(clientSocket, true);
Guid? packageId = null;
{
Guid packageIdParsed;
if (Guid.TryParse(parameters["packageid"], out packageIdParsed))
packageId = packageIdParsed;
}
if (mode == "gamestudio")
{
Console.WriteLine("GameStudio mode started!");
if (!packageId.HasValue)
return;
lock (gameStudioPerPackageId)
{
gameStudioPerPackageId[packageId.Value] = socketMessageLayer;
}
}
else
{
// Create an effect compiler per connection
var effectCompiler = new EffectCompiler();
Console.WriteLine("Client connected");
// TODO: Properly close the file, and choose where to copy/move it?
var recordedEffectCompile = new EffectLogStore(new MemoryStream());
// TODO: This should come from an "init" packet
effectCompiler.SourceDirectories.Add(EffectCompilerBase.DefaultSourceShaderFolder);
// Make a VFS that will access remotely the DatabaseFileProvider
// TODO: Is that how we really want to do that in the future?
var networkVFS = new NetworkVirtualFileProvider(socketMessageLayer, "/asset");
VirtualFileSystem.RegisterProvider(networkVFS);
effectCompiler.FileProvider = networkVFS;
socketMessageLayer.AddPacketHandler<RemoteEffectCompilerEffectRequest>((packet) => ShaderCompilerRequestHandler(socketMessageLayer, recordedEffectCompile, effectCompiler, packet));
socketMessageLayer.AddPacketHandler<RemoteEffectCompilerEffectRequested>((packet) =>
{
if (!packageId.HasValue)
return;
SocketMessageLayer gameStudio;
lock (gameStudioPerPackageId)
{
if (!gameStudioPerPackageId.TryGetValue(packageId.Value, out gameStudio))
return;
}
// Forward to game studio
gameStudio.Send(packet);
});
}
Task.Run(() => socketMessageLayer.MessageLoop());
}
protected override async void HandleClient(SimpleSocket clientSocket, string url)
{
await AcceptConnection(clientSocket);
var socketMessageLayer = new SocketMessageLayer(clientSocket, true);
socketMessageLayer.AddPacketHandler<TestRegistrationRequest>(request =>
{
if (request.Tester)
{
switch (request.Platform)
{
case (int)PlatformType.Windows:
{
Process process = null;
var debugInfo = "";
try
{
var start = new ProcessStartInfo
{
WorkingDirectory = Path.GetDirectoryName(request.Cmd),
FileName = request.Cmd,
};
start.EnvironmentVariables["SiliconStudioXenkoDir"] = Environment.GetEnvironmentVariable("SiliconStudioXenkoDir");
start.UseShellExecute = false;
debugInfo = "Starting process " + start.FileName + " with path " + start.WorkingDirectory;
socketMessageLayer.Send(new LogRequest { Message = debugInfo }).Wait();
process = Process.Start(start);
}
catch (Exception ex)
{
socketMessageLayer.Send(new StatusMessageRequest { Error = true, Message = "Launch exception: " + ex.Message }).Wait();
}
if (process == null)
{
socketMessageLayer.Send(new StatusMessageRequest { Error = true, Message = "Failed to start game process. " + debugInfo }).Wait();
}
else
{
processes[request.GameAssembly] = new TestProcess { Process = process, TesterSocket = socketMessageLayer };
socketMessageLayer.Send(new LogRequest { Message = "Process created, id: " + process.Id.ToString() }).Wait();
}
break;
}
case (int)PlatformType.Android:
{
Process process = null;
var debugInfo = "";
try
{
process = Process.Start("cmd.exe", $"/C adb shell monkey -p {request.GameAssembly}.{request.GameAssembly} -c android.intent.category.LAUNCHER 1");
}
catch (Exception ex)
{
socketMessageLayer.Send(new StatusMessageRequest { Error = true, Message = "Launch exception: " + ex.Message }).Wait();
}
if (process == null)
{
socketMessageLayer.Send(new StatusMessageRequest { Error = true, Message = "Failed to start game process. " + debugInfo }).Wait();
}
else
{
processes[request.GameAssembly] = new TestProcess { Process = process, TesterSocket = socketMessageLayer };
socketMessageLayer.Send(new LogRequest { Message = "Process created, id: " + process.Id.ToString() }).Wait();
}
break;
}
}
}
else //Game process
{
TestProcess process;
if (processes.TryGetValue(request.GameAssembly, out process))
{
process.GameSocket = socketMessageLayer;
testerToGame[process.TesterSocket] = process.GameSocket;
gameToTester[process.GameSocket] = process.TesterSocket;
process.TesterSocket.Send(new StatusMessageRequest { Error = false, Message = "Start" }).Wait();
}
}
});
socketMessageLayer.AddPacketHandler<KeySimulationRequest>(request =>
{
var game = testerToGame[socketMessageLayer];
game.Send(request).Wait();
});
socketMessageLayer.AddPacketHandler<TapSimulationRequest>(request =>
{
var game = testerToGame[socketMessageLayer];
game.Send(request).Wait();
});
socketMessageLayer.AddPacketHandler<ScreenshotRequest>(request =>
{
var game = testerToGame[socketMessageLayer];
game.Send(request).Wait();
});
socketMessageLayer.AddPacketHandler<TestEndedRequest>(request =>
{
var game = testerToGame[socketMessageLayer];
game.Send(request).Wait();
testerToGame.Remove(socketMessageLayer);
});
socketMessageLayer.AddPacketHandler<ScreenShotPayload>(request =>
{
var tester = gameToTester[socketMessageLayer];
var imageData = new TestResultImage();
var stream = new MemoryStream(request.Data);
imageData.Read(new BinaryReader(stream));
stream.Dispose();
var resultFileStream = File.OpenWrite(request.FileName);
imageData.Image.Save(resultFileStream, ImageFileType.Png);
resultFileStream.Dispose();
tester.Send(new ScreenshotStored()).Wait();
});
Task.Run(() => socketMessageLayer.MessageLoop());
}
protected override async void HandleClient(SimpleSocket clientSocket, string url)
{
await AcceptConnection(clientSocket);
var socketMessageLayer = new SocketMessageLayer(clientSocket, true);
socketMessageLayer.AddPacketHandler <TestRegistrationRequest>(async request =>
{
if (request.Tester)
{
switch (request.Platform)
{
case (int)PlatformType.Windows:
{
Process process = null;
var debugInfo = "";
try
{
var workingDir = Path.GetDirectoryName(request.Cmd);
if (workingDir != null)
{
var start = new ProcessStartInfo
{
WorkingDirectory = workingDir,
FileName = request.Cmd
};
start.UseShellExecute = false;
start.RedirectStandardError = true;
start.RedirectStandardOutput = true;
debugInfo = "Starting process " + start.FileName + " with path " + start.WorkingDirectory;
await socketMessageLayer.Send(new LogRequest {
Message = debugInfo
});
process = Process.Start(start);
}
}
catch (Exception ex)
{
await socketMessageLayer.Send(new StatusMessageRequest {
Error = true, Message = "Launch exception: " + ex.Message
});
}
if (process == null)
{
await socketMessageLayer.Send(new StatusMessageRequest {
Error = true, Message = "Failed to start game process. " + debugInfo
});
}
else
{
process.OutputDataReceived += async(sender, args) =>
{
try
{
if (args.Data != null)
{
await socketMessageLayer.Send(new LogRequest {
Message = $"STDIO: {args.Data}"
});
}
}
catch
{
}
};
process.ErrorDataReceived += async(sender, args) =>
{
try
{
if (args.Data != null)
{
await socketMessageLayer.Send(new LogRequest {
Message = $"STDERR: {args.Data}"
});
}
}
catch
{
}
};
process.BeginOutputReadLine();
process.BeginErrorReadLine();
var currenTestPair = new TestPair {
TesterSocket = socketMessageLayer, GameName = request.GameAssembly, Process = process
};
lock (processes)
{
processes[request.GameAssembly] = currenTestPair;
testerToGame[socketMessageLayer] = currenTestPair;
}
await socketMessageLayer.Send(new LogRequest {
Message = "Process created, id: " + process.Id.ToString()
});
}
break;
}
case (int)PlatformType.Android:
{
Process process = null;
try
{
process = Process.Start("cmd.exe", $"/C adb shell monkey -p {request.GameAssembly}.{request.GameAssembly} -c android.intent.category.LAUNCHER 1");
}
catch (Exception ex)
{
await socketMessageLayer.Send(new StatusMessageRequest {
Error = true, Message = "Launch exception: " + ex.Message
});
}
if (process == null)
{
await socketMessageLayer.Send(new StatusMessageRequest {
Error = true, Message = "Failed to start game process."
});
}
else
{
lock (loggerLock)
{
currentTester = socketMessageLayer;
}
var currenTestPair = new TestPair
{
TesterSocket = socketMessageLayer,
GameName = request.GameAssembly,
Process = process,
TestEndAction = () =>
{
// force stop - only works for Android 3.0 and above.
Process.Start("cmd.exe", $"/C adb shell am force-stop {request.GameAssembly}.{request.GameAssembly}");
}
};
lock (processes)
{
processes[request.GameAssembly] = currenTestPair;
testerToGame[socketMessageLayer] = currenTestPair;
}
await socketMessageLayer.Send(new LogRequest {
Message = "Process created, id: " + process.Id.ToString()
});
}
break;
}
case (int)PlatformType.iOS:
{
Process process = null;
var debugInfo = "";
try
{
Thread.Sleep(5000); //ios processes might be slow to close, we must make sure that we start clean
var start = new ProcessStartInfo
{
FileName = $"idevicedebug.exe",
Arguments = $"run com.your-company.{request.GameAssembly}",
UseShellExecute = false
};
debugInfo = "Starting process " + start.FileName + " with path " + start.WorkingDirectory;
process = Process.Start(start);
}
catch (Exception ex)
{
await socketMessageLayer.Send(new StatusMessageRequest {
Error = true, Message = $"Launch exception: {ex.Message} info: {debugInfo}"
});
}
if (process == null)
{
await socketMessageLayer.Send(new StatusMessageRequest {
Error = true, Message = "Failed to start game process. " + debugInfo
});
}
else
{
lock (loggerLock)
{
currentTester = socketMessageLayer;
}
var currenTestPair = new TestPair {
TesterSocket = socketMessageLayer, GameName = request.GameAssembly, Process = process
};
lock (processes)
{
processes[request.GameAssembly] = currenTestPair;
testerToGame[socketMessageLayer] = currenTestPair;
}
await socketMessageLayer.Send(new LogRequest {
Message = "Process created, id: " + process.Id.ToString()
});
}
break;
}
}
}
else //Game process
{
TestPair pair;
lock (processes)
{
if (!processes.TryGetValue(request.GameAssembly, out pair))
{
return;
}
pair.GameSocket = socketMessageLayer;
testerToGame[pair.TesterSocket] = pair;
gameToTester[pair.GameSocket] = pair;
}
await pair.TesterSocket.Send(new StatusMessageRequest {
Error = false, Message = "Start"
});
Console.WriteLine($"Starting test {request.GameAssembly}");
}
});
socketMessageLayer.AddPacketHandler <KeySimulationRequest>(async request =>
{
TestPair game;
lock (processes)
{
game = testerToGame[socketMessageLayer];
}
await game.GameSocket.Send(request);
});
socketMessageLayer.AddPacketHandler <TapSimulationRequest>(async request =>
{
TestPair game;
lock (processes)
{
game = testerToGame[socketMessageLayer];
}
await game.GameSocket.Send(request);
});
socketMessageLayer.AddPacketHandler <ScreenshotRequest>(async request =>
{
TestPair game;
lock (processes)
{
game = testerToGame[socketMessageLayer];
}
await game.GameSocket.Send(request);
});
socketMessageLayer.AddPacketHandler <TestEndedRequest>(async request =>
{
TestPair game;
lock (processes)
{
game = testerToGame[socketMessageLayer];
}
await game.GameSocket.Send(request);
lock (processes)
{
testerToGame.Remove(socketMessageLayer);
gameToTester.Remove(game.GameSocket);
processes.Remove(game.GameName);
}
socketMessageLayer.Context.Dispose();
game.GameSocket.Context.Dispose();
game.Process.Kill();
game.Process.Dispose();
lock (loggerLock)
{
currentTester = null;
}
game.TestEndAction?.Invoke();
Console.WriteLine($"Finished test {game.GameName}");
});
socketMessageLayer.AddPacketHandler <TestAbortedRequest>(request =>
{
TestPair game;
lock (processes)
{
game = testerToGame[socketMessageLayer];
testerToGame.Remove(socketMessageLayer);
processes.Remove(game.GameName);
}
socketMessageLayer.Context.Dispose();
game.Process.Kill();
game.Process.Dispose();
lock (loggerLock)
{
currentTester = null;
}
game.TestEndAction?.Invoke();
Console.WriteLine($"Aborted test {game.GameName}");
});
socketMessageLayer.AddPacketHandler <ScreenShotPayload>(async request =>
{
TestPair tester;
lock (processes)
{
tester = gameToTester[socketMessageLayer];
}
var imageData = new TestResultImage();
var stream = new MemoryStream(request.Data);
imageData.Read(new BinaryReader(stream));
stream.Dispose();
// Ensure directory exists
Directory.CreateDirectory(Path.GetDirectoryName(request.FileName));
var resultFileStream = File.OpenWrite(request.FileName);
imageData.Image.Save(resultFileStream, ImageFileType.Png);
resultFileStream.Dispose();
await tester.TesterSocket.Send(new ScreenshotStored());
});
Task.Run(async() =>
{
try
{
await socketMessageLayer.MessageLoop();
}
catch
{
}
});
}
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 GameTestingClient(string gamePath, PlatformType platform)
{
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.WindowsPhone:
platformName = "WindowsPhone";
break;
case PlatformType.WindowsStore:
platformName = "WindowsStore";
break;
case PlatformType.Android:
platformName = "Android";
break;
case PlatformType.iOS:
platformName = "iOS";
break;
case PlatformType.Windows10:
platformName = "Windows10";
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();
if (!ev.WaitOne(platform == PlatformType.Windows ? 10000 : 20000))
{
throw new Exception("Time out while launching the game");
}
if (!success)
{
throw new Exception("Failed: " + message);
}
Console.WriteLine(@"Game started. (message: " + message + @")");
}
/// <inheritdoc/>
protected override async void HandleClient(SimpleSocket clientSocket, string url)
{
string[] urlSegments;
string urlParameters;
RouterHelper.ParseUrl(url, out urlSegments, out urlParameters);
var parameters = RouterHelper.ParseQueryString(urlParameters);
var mode = parameters["mode"];
// We accept everything
await AcceptConnection(clientSocket);
var socketMessageLayer = new SocketMessageLayer(clientSocket, true);
Guid?packageId = null;
{
Guid packageIdParsed;
if (Guid.TryParse(parameters["packageid"], out packageIdParsed))
{
packageId = packageIdParsed;
}
}
if (mode == "gamestudio")
{
Console.WriteLine(@"GameStudio mode started!");
if (!packageId.HasValue)
{
return;
}
lock (gameStudioPerPackageId)
{
gameStudioPerPackageId[packageId.Value] = socketMessageLayer;
}
}
else
{
// Create an effect compiler per connection
var effectCompiler = new EffectCompiler();
Console.WriteLine(@"Client connected");
// TODO: This should come from an "init" packet
effectCompiler.SourceDirectories.Add(EffectCompilerBase.DefaultSourceShaderFolder);
// Make a VFS that will access remotely the DatabaseFileProvider
// TODO: Is that how we really want to do that in the future?
var networkVFS = new NetworkVirtualFileProvider(socketMessageLayer, "/asset");
VirtualFileSystem.RegisterProvider(networkVFS);
effectCompiler.FileProvider = networkVFS;
socketMessageLayer.AddPacketHandler <RemoteEffectCompilerEffectRequest>(packet => ShaderCompilerRequestHandler(socketMessageLayer, effectCompiler, packet));
socketMessageLayer.AddPacketHandler <RemoteEffectCompilerEffectRequested>(packet =>
{
if (!packageId.HasValue)
{
return;
}
SocketMessageLayer gameStudio;
lock (gameStudioPerPackageId)
{
if (!gameStudioPerPackageId.TryGetValue(packageId.Value, out gameStudio))
{
return;
}
}
// Forward to game studio
gameStudio.Send(packet);
});
}
Task.Run(() => socketMessageLayer.MessageLoop());
}
protected override async void HandleClient(SimpleSocket clientSocket, string url)
{
await AcceptConnection(clientSocket);
var socketMessageLayer = new SocketMessageLayer(clientSocket, true);
socketMessageLayer.AddPacketHandler<TestRegistrationRequest>(request =>
{
if (request.Tester)
{
switch (request.Platform)
{
case (int)PlatformType.Windows:
{
Process process = null;
var debugInfo = "";
try
{
var workingDir = Path.GetDirectoryName(request.Cmd);
if (workingDir != null)
{
var start = new ProcessStartInfo
{
WorkingDirectory = workingDir,
FileName = request.Cmd
};
start.EnvironmentVariables["SiliconStudioXenkoDir"] = Environment.GetEnvironmentVariable("SiliconStudioXenkoDir");
start.UseShellExecute = false;
start.RedirectStandardError = true;
start.RedirectStandardOutput = true;
debugInfo = "Starting process " + start.FileName + " with path " + start.WorkingDirectory;
socketMessageLayer.Send(new LogRequest { Message = debugInfo }).Wait();
process = Process.Start(start);
}
}
catch (Exception ex)
{
socketMessageLayer.Send(new StatusMessageRequest { Error = true, Message = "Launch exception: " + ex.Message }).Wait();
}
if (process == null)
{
socketMessageLayer.Send(new StatusMessageRequest { Error = true, Message = "Failed to start game process. " + debugInfo }).Wait();
}
else
{
process.OutputDataReceived += (sender, args) =>
{
try
{
socketMessageLayer.Send(new LogRequest { Message = $"STDIO: {args.Data}" }).Wait();
}
catch
{
}
};
process.ErrorDataReceived += (sender, args) =>
{
try
{
socketMessageLayer.Send(new LogRequest { Message = $"STDERR: {args.Data}" }).Wait();
}
catch
{
}
};
process.BeginOutputReadLine();
process.BeginErrorReadLine();
var currenTestPair = new TestPair { TesterSocket = socketMessageLayer, GameName = request.GameAssembly, Process = process };
processes[request.GameAssembly] = currenTestPair;
testerToGame[socketMessageLayer] = currenTestPair;
socketMessageLayer.Send(new LogRequest { Message = "Process created, id: " + process.Id.ToString() }).Wait();
}
break;
}
case (int)PlatformType.Android:
{
Process process = null;
try
{
process = Process.Start("cmd.exe", $"/C adb shell monkey -p {request.GameAssembly}.{request.GameAssembly} -c android.intent.category.LAUNCHER 1");
}
catch (Exception ex)
{
socketMessageLayer.Send(new StatusMessageRequest { Error = true, Message = "Launch exception: " + ex.Message }).Wait();
}
if (process == null)
{
socketMessageLayer.Send(new StatusMessageRequest { Error = true, Message = "Failed to start game process." }).Wait();
}
else
{
lock (loggerLock)
{
currentTester = socketMessageLayer;
}
var currenTestPair = new TestPair
{
TesterSocket = socketMessageLayer,
GameName = request.GameAssembly,
Process = process,
TestEndAction = () =>
{
// force stop - only works for Android 3.0 and above.
Process.Start("cmd.exe", $"/C adb shell am force-stop {request.GameAssembly}.{request.GameAssembly}");
}
};
processes[request.GameAssembly] = currenTestPair;
testerToGame[socketMessageLayer] = currenTestPair;
socketMessageLayer.Send(new LogRequest { Message = "Process created, id: " + process.Id.ToString() }).Wait();
}
break;
}
case (int)PlatformType.iOS:
{
Process process = null;
var debugInfo = "";
try
{
Thread.Sleep(5000); //ios processes might be slow to close, we must make sure that we start clean
var start = new ProcessStartInfo
{
WorkingDirectory = $"{Environment.GetEnvironmentVariable("SiliconStudioXenkoDir")}\\Bin\\Windows-Direct3D11\\",
FileName = $"{Environment.GetEnvironmentVariable("SiliconStudioXenkoDir")}\\Bin\\Windows-Direct3D11\\idevicedebug.exe",
Arguments = $"run com.your-company.{request.GameAssembly}",
UseShellExecute = false
};
debugInfo = "Starting process " + start.FileName + " with path " + start.WorkingDirectory;
process = Process.Start(start);
}
catch (Exception ex)
{
socketMessageLayer.Send(new StatusMessageRequest { Error = true, Message = $"Launch exception: {ex.Message} info: {debugInfo}" }).Wait();
}
if (process == null)
{
socketMessageLayer.Send(new StatusMessageRequest { Error = true, Message = "Failed to start game process. " + debugInfo }).Wait();
}
else
{
lock (loggerLock)
{
currentTester = socketMessageLayer;
}
var currenTestPair = new TestPair { TesterSocket = socketMessageLayer, GameName = request.GameAssembly, Process = process };
processes[request.GameAssembly] = currenTestPair;
testerToGame[socketMessageLayer] = currenTestPair;
socketMessageLayer.Send(new LogRequest { Message = "Process created, id: " + process.Id.ToString() }).Wait();
}
break;
}
}
}
else //Game process
{
TestPair pair;
if (!processes.TryGetValue(request.GameAssembly, out pair)) return;
pair.GameSocket = socketMessageLayer;
testerToGame[pair.TesterSocket] = pair;
gameToTester[pair.GameSocket] = pair;
pair.TesterSocket.Send(new StatusMessageRequest { Error = false, Message = "Start" }).Wait();
Console.WriteLine($"Starting test {request.GameAssembly}");
}
});
socketMessageLayer.AddPacketHandler<KeySimulationRequest>(request =>
{
var game = testerToGame[socketMessageLayer];
game.GameSocket.Send(request).Wait();
});
socketMessageLayer.AddPacketHandler<TapSimulationRequest>(request =>
{
var game = testerToGame[socketMessageLayer];
game.GameSocket.Send(request).Wait();
});
socketMessageLayer.AddPacketHandler<ScreenshotRequest>(request =>
{
var game = testerToGame[socketMessageLayer];
game.GameSocket.Send(request).Wait();
});
socketMessageLayer.AddPacketHandler<TestEndedRequest>(request =>
{
var game = testerToGame[socketMessageLayer];
game.GameSocket.Send(request).Wait();
testerToGame.Remove(socketMessageLayer);
gameToTester.Remove(game.GameSocket);
processes.Remove(game.GameName);
socketMessageLayer.Context.Dispose();
game.GameSocket.Context.Dispose();
game.Process.Kill();
game.Process.Dispose();
lock (loggerLock)
{
currentTester = null;
}
game.TestEndAction?.Invoke();
Console.WriteLine($"Finished test {game.GameName}");
});
socketMessageLayer.AddPacketHandler<TestAbortedRequest>(request =>
{
var game = testerToGame[socketMessageLayer];
testerToGame.Remove(socketMessageLayer);
processes.Remove(game.GameName);
socketMessageLayer.Context.Dispose();
game.Process.Kill();
game.Process.Dispose();
lock (loggerLock)
{
currentTester = null;
}
game.TestEndAction?.Invoke();
Console.WriteLine($"Aborted test {game.GameName}");
});
socketMessageLayer.AddPacketHandler<ScreenShotPayload>(request =>
{
var tester = gameToTester[socketMessageLayer];
var imageData = new TestResultImage();
var stream = new MemoryStream(request.Data);
imageData.Read(new BinaryReader(stream));
stream.Dispose();
var resultFileStream = File.OpenWrite(request.FileName);
imageData.Image.Save(resultFileStream, ImageFileType.Png);
resultFileStream.Dispose();
tester.TesterSocket.Send(new ScreenshotStored()).Wait();
});
Task.Run(async () =>
{
try
{
await socketMessageLayer.MessageLoop();
}
catch
{
}
});
}
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
}
private static async Task ShaderCompilerRequestHandler(SocketMessageLayer socketMessageLayer, EffectLogStore recordedEffectCompile, EffectCompiler effectCompiler, RemoteEffectCompilerEffectRequest remoteEffectCompilerEffectRequest)
{
// Yield so that this socket can continue its message loop to answer to shader file request
// TODO: maybe not necessary anymore with RouterServiceServer?
await Task.Yield();
Console.WriteLine("Compiling shader");
// Restore MixinTree.UsedParameters (since it is DataMemberIgnore)
remoteEffectCompilerEffectRequest.MixinTree.UsedParameters = remoteEffectCompilerEffectRequest.UsedParameters;
// A shader has been requested, compile it (asynchronously)!
var precompiledEffectShaderPass = await effectCompiler.Compile(remoteEffectCompilerEffectRequest.MixinTree, null).AwaitResult();
// Record compilation to asset file (only if parent)
recordedEffectCompile[new EffectCompileRequest(remoteEffectCompilerEffectRequest.MixinTree.Name, remoteEffectCompilerEffectRequest.MixinTree.UsedParameters)] = true;
// Send compiled shader
socketMessageLayer.Send(new RemoteEffectCompilerEffectAnswer { StreamId = remoteEffectCompilerEffectRequest.StreamId, EffectBytecode = precompiledEffectShaderPass.Bytecode });
}
