public void Sequential_Send_Success()
{
var expectedSequence = new List <object>();
var resultSequence = new List <object>();
using (var synchronizationContext = new ThreadSynchronizationContext(ApartmentState.MTA))
{
for (var i = 0; i < 5; i++)
{
expectedSequence.Add(i);
void SendOrPostCallback(object state)
{
lock (resultSequence)
{
resultSequence.Add(state);
}
}
synchronizationContext.Send(SendOrPostCallback, i);
}
}
CollectionAssert.AreEqual(expectedSequence, resultSequence);
}
protected void InitializeTaskManager()
{
TaskManager = new TaskManager();
SyncContext = new ThreadSynchronizationContext(TaskManager.Token);
TaskManager.UIScheduler = new SynchronizationContextTaskScheduler(SyncContext);
ApplicationManager = new ApplicationManagerBase(SyncContext, Environment);
}
public void OneTimeSetup()
{
Logging.LogAdapter = new ConsoleLogAdapter();
//Logging.TracingEnabled = true;
TaskManager = new TaskManager();
var syncContext = new ThreadSynchronizationContext(Token);
TaskManager.UIScheduler = new SynchronizationContextTaskScheduler(syncContext);
var env = new DefaultEnvironment();
TestBasePath = NPath.CreateTempDirectory("integration-tests");
env.FileSystem.SetCurrentDirectory(TestBasePath);
var repo = Substitute.For <IRepository>();
repo.LocalPath.Returns(TestBasePath);
env.Repository = repo;
var platform = new Platform(env);
ProcessManager = new ProcessManager(env, platform.GitEnvironment, Token);
var processEnv = platform.GitEnvironment;
var path = new ProcessTask <NPath>(TaskManager.Token, new FirstLineIsPathOutputProcessor())
.Configure(ProcessManager, env.IsWindows ? "where" : "which", "git")
.Start().Result;
env.GitExecutablePath = path ?? "git".ToNPath();
}
public void Sequential_PostSendInsert_Success()
{
var expectedSequence = new List <object>();
var resultSequence = new List <object>();
using (var synchronizationContext = new ThreadSynchronizationContext(ApartmentState.MTA))
{
for (var i = 0; i < 5; i++)
{
expectedSequence.Add(i);
void SendOrPostCallback(object state)
{
lock (resultSequence)
{
resultSequence.Add(state);
}
Thread.Sleep(100);
}
synchronizationContext.Post(SendOrPostCallback, i);
}
var finishEvent = new ManualResetEvent(false);
synchronizationContext.Post(state => finishEvent.Set(), null);
synchronizationContext.Send(state => CollectionAssert.AreNotEqual(expectedSequence, resultSequence), null);
finishEvent.WaitOne();
}
CollectionAssert.AreEqual(expectedSequence, resultSequence);
}
public void OneTimeSetup()
{
GitHub.Unity.Guard.InUnitTestRunner = true;
LogHelper.LogAdapter = new MultipleLogAdapter(new FileLogAdapter($"..\\{DateTime.UtcNow.ToString("yyyyMMddHHmmss")}-tasksystem-tests.log"));
//LogHelper.TracingEnabled = true;
TaskManager = new TaskManager();
var syncContext = new ThreadSynchronizationContext(Token);
TaskManager.UIScheduler = new SynchronizationContextTaskScheduler(syncContext);
var env = new DefaultEnvironment();
TestBasePath = NPath.CreateTempDirectory("integration-tests");
env.FileSystem.SetCurrentDirectory(TestBasePath);
var repo = Substitute.For <IRepository>();
repo.LocalPath.Returns(TestBasePath);
env.Repository = repo;
var platform = new Platform(env);
ProcessManager = new ProcessManager(env, platform.GitEnvironment, Token);
var processEnv = platform.GitEnvironment;
var path = new ProcessTask <NPath>(TaskManager.Token, new FirstLineIsPathOutputProcessor())
.Configure(ProcessManager, env.IsWindows ? "where" : "which", "git")
.Start().Result;
env.GitExecutablePath = path.IsInitialized ? path : "git".ToNPath();
}
public void OneTimeSetup()
{
GitHub.Unity.Guard.InUnitTestRunner = true;
LogHelper.LogAdapter = new MultipleLogAdapter(new FileLogAdapter($"..\\{DateTime.UtcNow.ToString("yyyyMMddHHmmss")}-tasksystem-tests.log"));
//LogHelper.TracingEnabled = true;
TaskManager = new TaskManager();
var syncContext = new ThreadSynchronizationContext(Token);
TaskManager.UIScheduler = new SynchronizationContextTaskScheduler(syncContext);
var env = new DefaultEnvironment(new CacheContainer());
TestBasePath = NPath.CreateTempDirectory("integration tests");
env.FileSystem.SetCurrentDirectory(TestBasePath);
env.Initialize("5.6", TestBasePath, TestBasePath, TestBasePath, TestBasePath.Combine("Assets"));
var repo = Substitute.For <IRepository>();
repo.LocalPath.Returns(TestBasePath);
env.Repository = repo;
var platform = new Platform(env);
ProcessManager = new ProcessManager(env, platform.GitEnvironment, Token);
var processEnv = platform.GitEnvironment;
var installer = new GitInstaller(env, ProcessManager, TaskManager.Token);
var state = installer.FindSystemGit(new GitInstaller.GitInstallationState());
env.GitInstallationState = state;
}
internal static IStardustContext CreateScope()
{
var id = Guid.NewGuid();
var ctx = ThreadSynchronizationContext.BeginContext(id);
lock (StateStorage)
{
if (!StateStorage.TryAdd(id.ToString(), new StardustContextProvider()))
{
Logging.DebugMessage("Unable to initialize context");
}
if (DoLogging)
{
Logging.DebugMessage("creating scope storage for {0}", id);
}
}
ContainerFactory.Current.Bind(typeof(Guid?), id, Scope.Context);
var runtime = RuntimeFactory.CreateRuntime(Scope.PerRequest);
ContainerFactory.Current.Bind(typeof(IRuntime), runtime, Scope.Context);
ContainerFactory.Current.Bind(runtime.GetType(), runtime, Scope.Context);
ContainerFactory.Current.Bind(typeof(InvokationMarker), new InvokationMarker(DateTime.UtcNow), Scope.Context);
ContainerFactory.Current.Bind(typeof(TraceHandler), new TraceHandler(), Scope.Context);
ctx.SetDisconnectorAction(CurrentContextOnOperationCompleted);
return(ctx);
}
protected async Task <IEnvironment> Initialize(NPath repoPath, NPath environmentPath = null,
bool enableEnvironmentTrace = false, bool initializeRepository = true, Action <RepositoryManager> onRepositoryManagerCreated = null)
{
TaskManager = new TaskManager();
SyncContext = new ThreadSynchronizationContext(TaskManager.Token);
TaskManager.UIScheduler = new SynchronizationContextTaskScheduler(SyncContext);
//TODO: Mock CacheContainer
ICacheContainer cacheContainer = Substitute.For <ICacheContainer>();
Environment = new IntegrationTestEnvironment(cacheContainer, repoPath, SolutionDirectory, environmentPath, enableEnvironmentTrace);
var gitSetup = new GitInstaller(Environment, TaskManager.Token);
await gitSetup.SetupIfNeeded();
Environment.GitExecutablePath = gitSetup.GitExecutablePath;
Platform = new Platform(Environment);
GitEnvironment = Platform.GitEnvironment;
ProcessManager = new ProcessManager(Environment, GitEnvironment, TaskManager.Token);
Platform.Initialize(ProcessManager, TaskManager);
GitClient = new GitClient(Environment, ProcessManager, TaskManager);
var repositoryManager = GitHub.Unity.RepositoryManager.CreateInstance(Platform, TaskManager, GitClient, repoPath);
onRepositoryManagerCreated?.Invoke(repositoryManager);
RepositoryManager = repositoryManager;
RepositoryManager.Initialize();
if (initializeRepository)
{
Environment.Repository = new Repository(repoPath, cacheContainer);
Environment.Repository.Initialize(RepositoryManager);
}
RepositoryManager.Start();
DotGitPath = repoPath.Combine(".git");
if (DotGitPath.FileExists())
{
DotGitPath =
DotGitPath.ReadAllLines()
.Where(x => x.StartsWith("gitdir:"))
.Select(x => x.Substring(7).Trim().ToNPath())
.First();
}
BranchesPath = DotGitPath.Combine("refs", "heads");
RemotesPath = DotGitPath.Combine("refs", "remotes");
DotGitIndex = DotGitPath.Combine("index");
DotGitHead = DotGitPath.Combine("HEAD");
DotGitConfig = DotGitPath.Combine("config");
return(Environment);
}
public void ThrowException_Send_Failed()
{
var expectedException = new Exception();
using (var synchronizationContext = new ThreadSynchronizationContext(ApartmentState.MTA))
{
var resultException = Assert.Catch(expectedException.GetType(), () => synchronizationContext.Send(state => throw expectedException, null));
Assert.AreEqual(expectedException, resultException);
}
}
public void ThrowException_Post_Success()
{
var expectedException = new Exception();
using (var synchronizationContext = new ThreadSynchronizationContext(ApartmentState.MTA))
{
synchronizationContext.Post(state => throw expectedException, null);
Thread.Sleep(1000);
}
}
public TService(ThreadSynchronizationContext threadSynchronizationContext, IPEndPoint ipEndPoint, ServiceType serviceType)
{
this.ServiceType = serviceType;
this.ThreadSynchronizationContext = threadSynchronizationContext;
this.acceptor = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
this.acceptor.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
this.innArgs.Completed += this.OnComplete;
this.acceptor.Bind(ipEndPoint);
this.acceptor.Listen(1000);
this.ThreadSynchronizationContext.PostNext(this.AcceptAsync);
}
protected async Task <IEnvironment> Initialize(NPath repoPath, NPath environmentPath = null,
bool enableEnvironmentTrace = false)
{
TaskManager = new TaskManager();
SyncContext = new ThreadSynchronizationContext(TaskManager.Token);
TaskManager.UIScheduler = new SynchronizationContextTaskScheduler(SyncContext);
Environment = new IntegrationTestEnvironment(repoPath, SolutionDirectory, environmentPath, enableEnvironmentTrace);
var gitSetup = new GitInstaller(Environment, TaskManager.Token);
await gitSetup.SetupIfNeeded();
Environment.GitExecutablePath = gitSetup.GitExecutablePath;
Platform = new Platform(Environment);
GitEnvironment = Platform.GitEnvironment;
ProcessManager = new ProcessManager(Environment, GitEnvironment, TaskManager.Token);
Platform.Initialize(ProcessManager, TaskManager);
GitClient = new GitClient(Environment, ProcessManager, Platform.CredentialManager, TaskManager);
var usageTracker = new NullUsageTracker();
var repositoryManagerFactory = new RepositoryManagerFactory();
RepositoryManager = repositoryManagerFactory.CreateRepositoryManager(Platform, TaskManager, usageTracker, GitClient, repoPath);
await RepositoryManager.Initialize();
RepositoryManager.Start();
Environment.Repository = RepositoryManager.Repository;
DotGitPath = repoPath.Combine(".git");
if (DotGitPath.FileExists())
{
DotGitPath =
DotGitPath.ReadAllLines()
.Where(x => x.StartsWith("gitdir:"))
.Select(x => x.Substring(7).Trim().ToNPath())
.First();
}
BranchesPath = DotGitPath.Combine("refs", "heads");
RemotesPath = DotGitPath.Combine("refs", "remotes");
DotGitIndex = DotGitPath.Combine("index");
DotGitHead = DotGitPath.Combine("HEAD");
DotGitConfig = DotGitPath.Combine("config");
return(Environment);
}
internal static IStardustContext CreateScope()
{
var id = Guid.NewGuid();
var ctx = ThreadSynchronizationContext.BeginContext(id);
ContainerFactory.Current.Bind(typeof(Guid?), id, Scope.Context);
var runtime = RuntimeFactory.CreateRuntime(Scope.PerRequest);
ContainerFactory.Current.Bind(typeof(IRuntime), runtime, Scope.Context);
ContainerFactory.Current.Bind(typeof(InvokationMarker), new InvokationMarker(DateTime.UtcNow), Scope.Context);
ContainerFactory.Current.Bind(typeof(TraceHandler), new TraceHandler(), Scope.Context);
ctx.Disposing += CurrentContextOnOperationCompleted;
return(ctx);
}
public IEnumerator CustomScheduler_ChainRunsOnTheSameScheduler()
{
using (var test = StartTest())
{
using (var context = new ThreadSynchronizationContext(test.TaskManager.Token))
using (var scheduler = new SynchronizationContextTaskScheduler(context))
{
int expected = 0;
scheduler.Context.Send(_ => expected = Thread.CurrentThread.ManagedThreadId, null);
var task = test.TaskManager
.With(s => {
s.Add(Thread.CurrentThread.ManagedThreadId);
return(s);
}, new List <int>(), TaskAffinity.Custom)
.ThenInUI(s => {
s.Add(Thread.CurrentThread.ManagedThreadId);
return(s);
})
.Then(s => {
s.Add(Thread.CurrentThread.ManagedThreadId);
return(s);
}, TaskAffinity.Custom)
.Finally((s, e, ret) => {
if (!s)
{
e.Rethrow();
}
return(ret);
});
task.Start(scheduler);
foreach (var frame in WaitForCompletion(task))
{
yield return(frame);
}
if (!task.Successful)
{
task.Exception.Rethrow();
}
var actual = task.Result;
actual.Matches(new[] { expected, test.TaskManager.UIThread, expected });
}
}
}
private static StardustContextProvider GetStardustContextProvider(IStardustContext currentContext)
{
try
{
if (currentContext == null)
{
Logging.DebugMessage("WTF??");
currentContext = ThreadSynchronizationContext.BeginContext(Guid.NewGuid());
}
return(((ThreadSynchronizationContext)currentContext).StateContainer);
}
catch (Exception ex)
{
Logging.Exception(ex);
throw;
}
}
public KService(ThreadSynchronizationContext threadSynchronizationContext, ServiceType serviceType)
{
this.ServiceType = serviceType;
this.ThreadSynchronizationContext = threadSynchronizationContext;
this.StartTime = TimeHelper.ClientNow();
this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
// 作为客户端不需要修改发送跟接收缓冲区大小
this.socket.Bind(new IPEndPoint(IPAddress.Any, 0));
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
const uint IOC_IN = 0x80000000;
const uint IOC_VENDOR = 0x18000000;
uint SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12;
this.socket.IOControl((int) SIO_UDP_CONNRESET, new[] { Convert.ToByte(false) }, null);
}
}
public KService(ThreadSynchronizationContext threadSynchronizationContext, IPEndPoint ipEndPoint, ServiceType serviceType)
{
this.ServiceType = serviceType;
this.ThreadSynchronizationContext = threadSynchronizationContext;
this.StartTime = TimeHelper.ClientNow();
this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
this.socket.SendBufferSize = Kcp.OneM * 64;
this.socket.ReceiveBufferSize = Kcp.OneM * 64;
}
this.socket.Bind(ipEndPoint);
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
const uint IOC_IN = 0x80000000;
const uint IOC_VENDOR = 0x18000000;
uint SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12;
this.socket.IOControl((int) SIO_UDP_CONNRESET, new[] { Convert.ToByte(false) }, null);
}
}
public IEnumerator CustomScheduler_Works()
{
using (var test = StartTest())
{
using (var context = new ThreadSynchronizationContext(test.TaskManager.Token))
using (var scheduler = new SynchronizationContextTaskScheduler(context))
{
int expected = 0;
scheduler.Context.Send(_ => expected = Thread.CurrentThread.ManagedThreadId, null);
var task = test.TaskManager.With(() => Thread.CurrentThread.ManagedThreadId, TaskAffinity.Custom);
task.Start(scheduler);
foreach (var frame in StartAndWaitForCompletion(task))
{
yield return(frame);
}
Assert.Greater(task.Result, 1);
task.Result.Matches(expected);
}
}
}
public async Task CustomScopeContextHandler()
{
second = Guid.NewGuid();
try
{
Guid main;
using (var maincs = ThreadSynchronizationContext.BeginContext() as ThreadSynchronizationContext)
{
Console.WriteLine("managed thread id {0}", Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(maincs.Id.ToString());
main = maincs.Id;
var myvalue = await CreateTestTask();
Console.WriteLine("managed thread id {0}", Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(maincs.Id.ToString());
Assert.AreEqual("myNewItem", myvalue);
}
Assert.AreEqual(main, second);
}
catch (Exception ex)
{
Assert.Fail();
}
}
public static async Task <int> Main(string[] args)
{
// monitoring when the ipc host shuts down
var exiting = new ManualResetEventSlim();
var configuration = GetConfiguration(args);
if (configuration.Debug)
{
if (!Debugger.IsAttached)
{
Debugger.Launch();
}
else
{
Debugger.Break();
}
}
var taskManager = new TaskManager();
var syncContext = new ThreadSynchronizationContext(taskManager.Token);
taskManager.Initialize(syncContext);
var environment = new UnityEnvironment("Process Manager")
.Initialize(configuration.ProjectPath, configuration.UnityVersion,
configuration.UnityApplicationPath, configuration.UnityContentsPath);
var host = new RpcHostedServer(configuration)
.AddRemoteProxy <IServerNotifications>()
.AddRemoteProxy <IProcessNotifications>()
.AddLocalTarget <ProcessServer.Implementation>()
.AddLocalScoped <ProcessRunner.Implementation>()
;
host.Stopping(s => {
s.GetService <ProcessRunner>().Shutdown();
s.GetService <ProcessServer>().Shutdown();
exiting.Set();
})
.ClientConnecting(s => {
// keep track of clients so we can broadcast notifications to them
s.GetService <ProcessServer>().ClientConnecting(s.GetRequestContext());
})
.ClientDisconnecting((s, disconnected) => {
s.GetService <ProcessRunner>().ClientDisconnecting(s.GetRequestContext());
s.GetService <ProcessServer>().ClientDisconnecting(s.GetRequestContext());
});
// set up a logger
var logLevelSwitch = new LoggingLevelSwitch {
MinimumLevel = LogEventLevel.Debug
};
host.UseSerilog((context, config) =>
config.MinimumLevel.ControlledBy(logLevelSwitch)
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Console());
host.ConfigureServices(services => {
// register the log switch so it can be retrieved and changed by any code
services.AddSingleton(logLevelSwitch);
// make the configuration available to everyone
services.AddSingleton(configuration);
services.AddSingleton <ITaskManager>(taskManager);
services.AddSingleton <IEnvironment>(environment);
services.AddSingleton <IProcessEnvironment>(s => s.GetService <IProcessManager>().DefaultProcessEnvironment);
services.AddSingleton <IProcessManager, ProcessManager>();
services.AddSingleton <ProcessRunner>();
services.AddSingleton <ProcessServer>();
});
host.UseConsoleLifetime();
await host.Start();
Console.WriteLine($"Port:{host.Rpc.Configuration.Port}");
try
{
await host.Run();
} catch {}
// wait until all stop events have completed
exiting.Wait();
syncContext.Dispose();
return(0);
}
public TService(ThreadSynchronizationContext threadSynchronizationContext, ServiceType serviceType)
{
this.ServiceType = serviceType;
this.ThreadSynchronizationContext = threadSynchronizationContext;
}
public BroadcastService()
{
_subscriptions = new Dictionary <Type, List <Delegate> >();
_enqueueSynchronizationContext = new ThreadSynchronizationContext(ApartmentState.MTA);
}
public IEnumerator CustomScheduler_AsyncKeepsOrder()
{
using (var test = StartTest())
{
using (var context = new ThreadSynchronizationContext(test.TaskManager.Token))
using (var scheduler = new SynchronizationContextTaskScheduler(context))
{
int expected = 0;
scheduler.Context.Send(_ => expected = Thread.CurrentThread.ManagedThreadId, null);
var order = new List <int>();
var task1 = test.TaskManager
.WithAsync(async s => {
await Task.Delay(10);
s.Add(1);
return(s);
}, order, TaskAffinity.Custom)
.Finally((s, e, ret) => {
if (!s)
{
e.Rethrow();
}
return(ret);
});
var task2 = test.TaskManager.WithAsync(async s => {
await Task.Yield();
s.Add(2);
return(s);
}, order, TaskAffinity.Custom)
.Finally((s, e, ret) => {
if (!s)
{
e.Rethrow();
}
return(ret);
});
var task3 = test.TaskManager.WithAsync(async s => {
s.Add(3);
await Task.Yield();
return(s);
}, order, TaskAffinity.Custom)
.Finally((s, e, ret) => {
if (!s)
{
e.Rethrow();
}
return(ret);
});
task1.Start(scheduler);
task2.Start(scheduler);
task3.Start(scheduler);
foreach (var frame in WaitForCompletion(task1, task2, task3))
{
yield return(frame);
}
order.Matches(new int[] { 1, 2, 3 });
}
}
}
protected void InitializeTaskManager()
{
TaskManager = new TaskManager();
SyncContext = new ThreadSynchronizationContext(TaskManager.Token);
TaskManager.UIScheduler = new SynchronizationContextTaskScheduler(SyncContext);
}
public VideoRenderingEngine(AsyncTripleBufferingSystem <VideoFrameData> .ConsumerSideBufferProvider bufferProvider)
{
this.bufferProvider = bufferProvider;
this.renderingContext = new ThreadSynchronizationContext(LoopRender, "Rendering Engine");
}
