private void HandleAccpetNewEvent(IReactor reactor)
{
if (this.OnAcceptNew != null)
{
this.OnAcceptNew(reactor);
}
}
public IDisposable Chain <T>(IReactor <T> another) where T : IRxn
{
var resources = new CompositeDisposable();
Input.Subscribe(e => another.Input.OnNext((T)e), e => ReportExceptions.OnNext(new LogMessage <Exception>()
{
Reporter = another.ReporterName, Level = LogLevel.Error, Message = e
})).DisposedBy(resources);
another.Output.Subscribe(r => Output.OnNext(r), e => ReportExceptions.OnNext(new LogMessage <Exception>()
{
Reporter = another.ReporterName, Level = LogLevel.Error, Message = e
})).DisposedBy(resources);
another.Errors.Subscribe(ReportExceptions).DisposedBy(_resources);//only report errors so we can see error state
var health = AttachHealthMonitorIf(another);
_molecules.Add(another);
OnInformation("Chained to '{0}'", another.Name);
return(new CompositeDisposable(resources, new DisposableAction(() =>
{
if (health != null)
{
health.Dispose();
}
OnInformation("Unchained '{0}'", another.Name);
_molecules.Remove(another);
}))
.DisposedBy(_resources));
}
internal StreamConnection(IReactor dispatcher, IProtocol protocol, TcpClient tcpClient, int bufferSize)
: base(dispatcher, protocol)
{
_tcpClient = tcpClient;
_readBuffer = new Byte[bufferSize];
_remoteEndPoint = _tcpClient.Client.RemoteEndPoint as IPEndPoint;
}
public string ModuleCommand(IList <string> arguments)
{
int reactorId = int.Parse(arguments[0]);
string moduleType = arguments[1];
int additionalParameter = int.Parse(arguments[2]);
IModule module = moduleFactory.CreateModule(moduleType, currentId++, additionalParameter);
this.modules.Add(module.Id, module);
this.identifiableObjects.Add(module.Id, module);
IReactor reactor = this.reactors[reactorId];
if (module is IEnergyModule energyModule)
{
reactor.AddEnergyModule(energyModule);
}
else if (module is IAbsorbingModule absorbingModule)
{
reactor.AddAbsorbingModule(absorbingModule);
}
string result = string.Format(Constants.ModuleCreateMessage, moduleType, module.Id, reactorId);
return(result);
}
static void Main(string[] args)
{
Port = args.Length < 1 ? DEFAULT_PORT : Int32.Parse(args[0]);
var ip = IPAddress.Any;
Console.WriteLine("Starting echo server...");
Console.WriteLine("Will begin listening for requests on {0}:{1}", ip, Port);
var bootstrapper =
new ServerBootstrap()
.WorkerThreads(2)
.SetTransport(TransportType.Udp)
.Build();
IReactor reactor = bootstrapper.NewReactor(NodeBuilder.BuildNode().Host(ip).WithPort(Port));
reactor.OnConnection += (node, connection) =>
{
ServerPrint(node,
string.Format("Accepting connection from... {0}:{1}", node.Host, node.Port));
connection.BeginReceive(Receive);
};
reactor.OnDisconnection += (reason, address) => ServerPrint(address.RemoteHost,
string.Format("Closed connection to... {0}:{1} [Reason:{2}]", address.RemoteHost.Host, address.RemoteHost.Port, reason.Type));
reactor.Start();
Console.ReadKey();
}
internal StreamConnection(IReactor dispatcher, IProtocol protocol, TcpClient tcpClient, int bufferSize)
: base(dispatcher, protocol)
{
_tcpClient = tcpClient;
_readBuffer = new Byte[bufferSize];
_remoteEndPoint = _tcpClient.Client.RemoteEndPoint as IPEndPoint;
}
public async Task DispatchEventStreamAsync(IReactor reactor, IEventStream stream)
{
foreach (EventMessage eventMessage in stream.CommittedEvents)
{
await DispatchPayloadAsync(reactor, eventMessage.Body);
}
}
public static Property <T> Create <T>(this IReactor reactor, string name, T defaultValue = default(T))
{
return(new Property <T>(reactor, name)
{
Value = defaultValue
});
}
public ReactorAcceptorTest(IPAddress acceptorAddress, int acceptorPort,
int reactorTimerMicroSeconds, int pendingConnections, bool keepAlive, bool isStream)
{
reactor = new ReactorSocketImpl();
reactorTimeout = reactorTimerMicroSeconds;
connectionList = new List <IServiceHandler>();
IPEndPoint endpoint = new IPEndPoint(acceptorAddress, acceptorPort);
if (keepAlive && !isStream)
{
acceptor = new Tcp_SocketAcceptor(endpoint, reactor, pendingConnections, true, 5000, false);
}
else if (!keepAlive && !isStream)
{
acceptor = new Tcp_SocketAcceptor(endpoint, reactor, pendingConnections, false, 0, false);
}
else if (isStream)
{
acceptor = new Tcp_SocketAcceptor(endpoint, reactor, pendingConnections, false, 0, true);
}
acceptor.AcceptNotification += AcceptNotification;
ThreadStart threadStart = new ThreadStart(Run);
reactorThread = new Thread(threadStart);
running = true;
reactorThread.Start();
}
/// <summary>
/// Dispatches the eventstream to the reactor
/// </summary>
/// <param name="storeEvents"></param>
/// <returns>int The last streamrevision that was dispatched</returns>
public static async Task <int> DispatchEventStreamAsync(this IReactor reactor, IStoreEvents storeEvents, ConventionalReactionDispatcher dispatcher, Guid aggregateId, int streamRevision = 1)
{
var stream = storeEvents.OpenStream(aggregateId, streamRevision);
await dispatcher.DispatchEventStreamAsync(reactor, stream);
return(stream.StreamRevision);
}
public void TC005_PublishWithoudPayload()
{
bool errorThrown = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Publish("foo");
natsClient.Publish("foo", null, "hello");
natsClient.Publish("foo", null, "hello", "reply");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
}
public void TC014_PublishCallback()
{
bool errorThrown = false;
bool done = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Publish("foo", delegate()
{
done = true;
resetEvent.Set();
});
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.IsTrue(done);
}
public void TC023_ReciveGiantMessageForSubscription()
{
bool errorThrown = false;
string receivedMessage = "";
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Subscribe("foo", delegate(string msg, string reply, string subject)
{
receivedMessage = msg;
resetEvent.Set();
});
ASCIIEncoding ascii = new ASCIIEncoding();
natsClient.Publish("foo", null, ascii.GetString(new byte[90000]));
resetEvent.WaitOne(10000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.AreEqual(receivedMessage.Length, 90000);
}
public void TC006_PublishNil()
{
bool errorThrown = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
// todo: vladi: check to see if nil in Ruby evaluates to boolean true
natsClient.Publish(null);
natsClient.Publish(null, null, "hello");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
}
public void TC011_ReciveMessageIfWildcardSubscription()
{
string errorThrown = null;
string receivedMessage = "";
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = args.Message == null ? String.Empty : args.Message;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
// todo: vladi: if not testing agains an empty server, this subscription may fail
natsClient.Subscribe("*", delegate(string msg, string reply, string subject)
{
receivedMessage = msg;
resetEvent.Set();
});
natsClient.Publish("foo", null, "xxx");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsTrue(errorThrown == null, errorThrown);
Assert.AreEqual(receivedMessage, "xxx");
}
public void TC010_ReciveEmptyMessage()
{
bool errorThrown = false;
string receivedMessage = "xxx";
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Subscribe("foo", delegate(string msg, string reply, string subject)
{
receivedMessage = msg;
resetEvent.Set();
});
natsClient.Publish("foo", null, "");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.AreEqual(receivedMessage, "");
}
internal static Property <T> Create <T>(this IReactor reactor, string name, Func <T> valueFunc, params IProperty[] fromProperties)
{
var property = reactor.Create <T>(name, valueFunc());
reactor.WhenPropertiesChange(fromProperties).Subscribe(coll => property.Value = valueFunc());
return(property);
}
public string ReactorCommand(IList <string> arguments)
{
string reactorType = arguments[0];
int additionalParameter = int.Parse(arguments[1]);
int moduleCapacity = int.Parse(arguments[2]);
IContainer container = new ModuleContainer(moduleCapacity);
IReactor reactor = null;
switch (reactorType)
{
case "Cryo":
//reactor = new CryoReactor(this.currentId, container, additionalParameter);
reactor = reactorFactory.CreateReactor(reactorType, this.currentId, container, additionalParameter);
break;
case "Heat":
//reactor = new HeatReactor(this.currentId, container, additionalParameter);
reactor = reactorFactory.CreateReactor(reactorType, this.currentId, container, additionalParameter);
break;
}
this.currentId++;
this.reactors.Add(reactor.Id, reactor);
this.identifiableObjects.Add(reactor.Id, reactor);
string result = string.Format(Constants.ReactorCreateMessage, reactorType, reactor.Id);
return(result);
}
public Server(string address, int port, IClientListener <Request, Response> listener, ISerializeProcessor sp, bool isIPAddressAny)
{
this._address = address;
this._port = port;
this._lisenter = listener;
this.SP = sp;
this.isAnyIPAddress = isIPAddressAny || string.IsNullOrEmpty(_address);
var excutor = new TryCatchExecutor((e) =>
{
//Console.Write(e);
});
var bootStrapper = new ServerBootstrap()
.Executor(excutor)
.SetTransport(System.Net.TransportType.Tcp)
.Build();
_server = bootStrapper.NewReactor(
NodeBuilder.BuildNode()
.Host(isIPAddressAny? IPAddress.Any:IPAddress.Parse(_address))
.WithPort(port)
);
_server.OnConnection += _server_OnConnection;;
_server.OnDisconnection += TempServer_OnDisconnection;
}
public AbstractSocketAcceptor(EndPoint localEndPoint,
IReactor reactor,
int pendingConnections)
{
this.reactor = reactor;
Open(localEndPoint, pendingConnections);
}
public static IObservable <T> WhenPropertyChanges <T>(this IReactor reactor, IProperty property)
{
var stream = Observable.FromEvent <IProperty>(
h => reactor.RxPropertyChanged += h,
h => reactor.RxPropertyChanged -= h);
return(stream.Where(p => p == property).Select(p => (T)p.Value));
}
public void TC001_StartStopClient()
{
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.Start(natsEndpoint);
natsClient.Close();
}
}
public void Stop()
{
if (this._reactor != null)
{
this._reactor.Stop();
this._reactor = null;
}
}
public Tcp_SocketAcceptor(EndPoint localEndPoint, IReactor reactor, int pendingConnections,
bool keepServiceOpen, int keepAliveTimerVal, bool makeStream)
: base(localEndPoint, reactor, pendingConnections)
{
serviceKeepAlive = keepServiceOpen;
serviceKeepAliveTimerVal = keepAliveTimerVal;
isConnectionStream = makeStream;
}
internal static LazyProperty <T> CreateLazy <T>(this IReactor reactor, string name, IObservable <Unit> changeStream, Func <T> valueGetter)
{
var property = new LazyProperty <T>(reactor, name, valueGetter);
changeStream.Subscribe(unit => property.Invalidate());
return(property);
}
public void OnAccept(IReactor reactor)
{
Logger.LogInfo("Accepted new client", new object[0]);
if (this.OnAcceptNew != null)
{
this.OnAcceptNew(reactor);
}
}
public static IObservable <object> WhenPropertiesChange(this IReactor reactor, params IProperty[] properties)
{
var stream = Observable.FromEvent <IProperty>(
h => reactor.RxPropertyChanged += h,
h => reactor.RxPropertyChanged -= h);
return(stream.Where(p => Array.IndexOf(properties, p) >= 0));
}
public void StartReaction(IBall original)
{
var config = Di.Get <IGameConfig>();
var all = new List <IBall>(GameController.BallCollection.Where(x => x.MaterialName == original.MaterialName));
var consumables = new List <IBall>();
var consumed = new List <IBall>();
consumables.Add(original);
all.Remove(original);
while (consumables.Count > 0)
{
var tester = consumables[0];
consumables.RemoveAt(0);
consumed.Add(tester);
for (int i = all.Count - 1; i > -1; i--)
{
var b = all[i];
var distance = Vector3.Distance(tester.TransformPosition, b.TransformPosition);
if (distance > config.BallTouchRange)
{
continue;
}
consumables.Add(b);
all.Remove(b);
}
}
var score = 0f;
var triggerIn = 0f;
var reactorChoice = config.GetReactor();
IReactor reactor = null;
foreach (var b in consumed)
{
if (reactorChoice == ReactorTypes.Fade)
{
reactor = b.GetComponent <IFadeReactor>();
}
if (reactorChoice == ReactorTypes.Shrink)
{
reactor = b.GetComponent <IShrinkReactor>();
}
if (reactorChoice == ReactorTypes.Slip)
{
reactor = b.GetComponent <ISlipReactor>();
}
reactor.ActivateDestructionIn(triggerIn);
triggerIn += config.TimeBetweenReactions;
score += config.ScorePerBall;
score *= config.CountMultiplier;
}
Di.Get <IScore>().TotalScore += (int)score;
}
public static LazyProperty <T> CreateLazy <T>(this IReactor reactor, string name, Expression <Func <T> > valueExpression)
{
Func <T> compiled = valueExpression.Compile();
UsedPropertyChain[] properties = ExpressionHelper.GetUsedPropertiesAndAttachListeners(valueExpression);
IObservable <Unit> changeStream = React.WhenAnyPropertyChanges(properties);
return(CreateLazy <T>(reactor, name, changeStream, compiled));
}
private void Acceptor_OnAcceptNew(IReactor reactor)
{
ClientSession session = this.CreateClientSession(this._sessionBase, reactor);
session.OnReceive += new SessionReceivedDelegate(this.HandlePackages);
session.OnSessionDisconnected += new SessionDisconnectedDelegate(this.ClientDisconnected);
this._clients[this._sessionBase] = session;
Interlocked.Increment(ref this._sessionBase);
}
public static IReactor GetDefaultReactor()
{
if (_defaultReactor == null)
{
_defaultReactor = new Reactor("DefaultReactor");
}
return(_defaultReactor);
}
void IPeerConnector.Bind(IReactor dispatcher, IProtocolFactory factory, IPEndPoint localEP, IPEndPoint remoteEP, int bufferSize)
{
_factory = factory;
_dispatcher = dispatcher;
_bufferSize = bufferSize;
var tcpClient = new TcpClient(localEP);
var ar = tcpClient.BeginConnect(remoteEP.Address, remoteEP.Port, null, tcpClient);
_dispatcher.AddResult(ar, (iar, state) => { this.PeerConnectCallback(iar); }, tcpClient);
}
void IConnector.Bind(IReactor dispatcher, IProtocolFactory factory, IPEndPoint localEP, int bufferSize)
{
_factory = factory;
_dispatcher = dispatcher;
_bufferSize = bufferSize;
_tcpListener = new TcpListener(localEP);
_tcpListener.Start();
this.StartAccept();
}
void IConnector.Bind(IReactor dispatcher, IProtocolFactory factory, IPEndPoint localEP, int bufferSize)
{
_udpClient = new UdpClient(localEP);
_udpClient.Client.ReceiveBufferSize = bufferSize;
var protocol = factory.Create();
var connection = new DatagramConnection(dispatcher, protocol, _udpClient);
connection.Start(true);
protocol.Bind(connection);
protocol.Connected();
}
public void Initialize(IReactor reactor, IDaemon daemon)
{
reactor.Daemon = daemon;
daemon.Schedule(reactor.Initialize);
}
internal DatagramConnection(IReactor dispatcher, IProtocol protocol, UdpClient udpClient)
: base(dispatcher, protocol)
{
_udpClient = udpClient;
}
/// <summary>
/// Starts the service using the specified options.
/// </summary>
/// <param name="options">The configuration options.</param>
public virtual void Start(Options options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
this.localIP = NetworkInterface.GetLocalIPAddress();
Logger.Info(Strings.InitializingLogMessage, this.ServiceDescription());
this.OrphanInstancesHash = new Dictionary<string, object>();
this.OrphanBindingHash = new Dictionary<string, object>();
this.nodeNats = ReactorFactory.GetReactor(typeof(Reactor));
this.nodeNats.OnError += new EventHandler<ReactorErrorEventArgs>(this.NatsErrorHandler);
this.NodeNats.Start(options.Uri);
this.OnConnectNode();
this.vcapComponent = new VCAPComponent();
this.vcapComponent.Register(
new Dictionary<string, object>
{
{ "nats", this.NodeNats },
{ "type", this.ServiceDescription() },
{ "host", this.localIP },
{ "index", options.Index },
{ "config", options },
{ "statusPort", options.StatusPort }
});
int zInterval = options.ZInterval;
// give service a chance to wake up
TimerHelper.DelayedCall(
5000,
delegate
{
this.UpdateVarz();
});
TimerHelper.RecurringCall(
zInterval,
delegate
{
this.UpdateVarz();
});
// give service a chance to wake up
TimerHelper.DelayedCall(
5000,
delegate
{
this.UpdateHealthz();
});
TimerHelper.RecurringCall(
zInterval,
delegate
{
this.UpdateHealthz();
});
}
protected Connection(IReactor reactor, Protocol protocol)
{
_reactor = reactor;
_protocol = protocol;
}
public void ConnectReactor(IReactor reactor)
{
this.reactor = reactor;
}
internal StreamConnection(IReactor reactor, Protocol protocol)
: base(reactor, protocol)
{
}
public void Close(IServiceHost host)
{
_controlConnector.Close();
_reactor = null;
}
internal static void BindTcp(IReactor reactor, IProtocolFactory protocolFactory, IPEndPoint localEP, int bufferSize = 8192)
{
IConnector connector = new StreamConnector();
connector.Bind(reactor, protocolFactory, localEP, bufferSize);
}
internal static void ConnectUdp(IReactor reactor, IProtocolFactory protocolFactory, IPEndPoint localEP, IPEndPoint remoteEP, int bufferSize = 524288)
{
IPeerConnector connector = new DatagramPeerConnector();
connector.Bind(reactor, protocolFactory, localEP, remoteEP, bufferSize);
}
public ServiceHostImplementation(IReactor reactor, Dictionary<string, object> environment, IList<IService> servicesListOrNull)
{
_reactor = reactor;
_environment = environment;
_servicesListOrNull = servicesListOrNull;
}
private Context()
{
this.reactor = new Reactor();
this.Start();
}
private void Run()
{
var bootstrapper =
new ServerBootstrap()
.WorkerThreads(4)
.SetTransport(TransportType.Udp)
.Build();
_reactor = bootstrapper.NewReactor(
NodeBuilder.BuildNode()
.Host(HostIp)
.WithPort(HostPort));
_reactor.OnConnection += (node, connection) =>
{
//ServerPrint(node,
// string.Format("Accepting connection from... {0}:{1}", node.Host, node.Port));
connection.BeginReceive(UdpPackerReceiveCallback);
};
//reactor.OnDisconnection += (reason, address) => ServerPrint(address.RemoteHost,
// string.Format("Closed connection to... {0}:{1} [Reason:{2}]", address.RemoteHost.Host, address.RemoteHost.Port, reason.Type));
_reactor.Start();
}
public void Open(IServiceHost host)
{
_reactor = host.Reactor;
_controlConnector = host.Reactor.ListenStream(new RemoteCaptureProtocolFactory(this), _listenPort);
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (this.nodeNats != null)
{
this.nodeNats.Dispose();
this.nodeNats = null;
}
if (this.vcapComponent != null)
{
this.vcapComponent.Dispose();
this.vcapComponent = null;
}
}
}
