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 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 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, "");
}
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 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 TC001_StartStopClient()
{
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.Start(natsEndpoint);
natsClient.Close();
}
}
public ReactorManager()
{
this.currentId = Constants.StartingId;
this.identifiableObjects = new Dictionary <int, IIdentifiable>();
this.reactors = new Dictionary <int, IReactor>();
this.modules = new Dictionary <int, IModule>();
this.reactorFactory = new ReactorFactory();
}
public void TC002_CheckState()
{
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.Start(natsEndpoint);
Assert.IsTrue(natsClient.Status == ConnectionStatus.Open);
natsClient.Close();
}
}
public void TC015_MultipleResponseCallback()
{
bool errorThrown = false;
List <int> expected = new List <int>();
List <int> response = new List <int>();
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);
SimpleCallback[] delegates = new SimpleCallback[] {
delegate() { response.Add(0); },
delegate() { response.Add(1); },
delegate() { response.Add(2); },
delegate() { response.Add(3); },
delegate() { response.Add(4); },
delegate() { response.Add(5); },
delegate() { response.Add(6); },
delegate() { response.Add(7); },
delegate() { response.Add(8); },
delegate() { response.Add(9); },
delegate() { response.Add(10); },
delegate() { response.Add(11); },
delegate() { response.Add(12); },
delegate() { response.Add(13); },
delegate() { response.Add(14); }
};
for (int i = 0; i < 15; i++)
{
expected.Add(i);
natsClient.Publish("foo", delegates[i]);
}
natsClient.Publish("foo", delegate()
{
resetEvent.Set();
});
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
for (int i = 0; i < 15; i++)
{
Assert.AreEqual(expected[i], response[i]);
}
}
public void TC008_ReciveSidRequest()
{
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.Start(natsEndpoint);
int mySid = natsClient.Request("foo");
natsClient.Close();
Assert.IsTrue(0 < mySid);
}
}
public static void Main()
{
IReader reader = new ConsoleReader();
IWriter writer = new ConsoleWriter();
IReactorFactory reactorFactory = new ReactorFactory();
IManager reactorManager = new ReactorManager(reactorFactory);
ICommandParser commandParser = new CommandParser(reactorManager);
IEngine engine = new Engine(reader, writer, commandParser);
engine.Run();
}
public static void Main()
{
//IReader reader = new ConsoleReader();
//IWriter writer = new ConsoleWriter();
//IManager reactorManager = new ReactorManager();
//ICommandParser commandParser = new CommandParser(reactorManager);
//IEngine engine = new Engine(reader, writer, commandParser);
//engine.Run();
IReactor reactor = new ReactorFactory().CreateReactor("Test", 5, new ModuleContainer(4), 56);
Console.WriteLine(reactor.GetType().Name);
}
/// <summary>
/// Starts the service using the specified options.
/// </summary>
/// <param name="options">The configuration options.</param>
public virtual void Start(ServiceElement options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
this.localIP = NetworkInterface.GetLocalIPAddress(options.LocalRoute);
Logger.Info(Strings.InitializingLogMessage, this.ServiceDescription());
this.nodeNats = ReactorFactory.GetReactor(typeof(Reactor));
this.nodeNats.OnError += new EventHandler <ReactorErrorEventArgs>(this.NatsErrorHandler);
this.nodeNats.Start(new Uri(options.MBus));
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;
TimerHelper.RecurringCall(
zInterval,
delegate
{
this.UpdateVarz();
});
// give service a chance to wake up
TimerHelper.DelayedCall(
5 * 1000,
delegate
{
this.UpdateVarz();
});
}
public void TC012_RecieveMessageOnUnsubscription()
{
bool errorThrown = false;
int receivedCount = 0;
object receivedCountLock = new object();
int sid = 0;
IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor));
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
});
natsClient.Start(natsEndpoint);
ManualResetEvent mre = new ManualResetEvent(false);
sid = natsClient.Subscribe("foo", delegate(string msg, string reply, string subject)
{
lock (receivedCountLock)
{
receivedCount++;
if (receivedCount == 2)
{
natsClient.Unsubscribe(sid);
mre.Set();
}
}
});
natsClient.Publish("foo", () =>
{
natsClient.Publish("foo", () =>
{
mre.WaitOne();
natsClient.Publish("foo", () => { }, "xxx");
}, "xxx");
}, "xxx");
Thread.Sleep(5000);
natsClient.Close();
Assert.IsFalse(errorThrown);
Assert.AreEqual(2, receivedCount);
}
public void TC021_PublishThreadSafe()
{
bool errorThrown = false;
object locker = new object();
int callbackNr = 0;
int sid = 0;
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
});
for (int i = 0; i < 40; i++)
{
string subject = Guid.NewGuid().ToString();
sid = natsClient.Subscribe(subject, delegate(string msg, string reply, string subj)
{
lock (locker)
{
callbackNr++;
}
});
Thread workerThread = new Thread(new ParameterizedThreadStart(delegate(object data)
{
natsClient.Publish((string)data);
}));
workerThread.Start(subject);
}
natsClient.Start(natsEndpoint);
while (callbackNr != 40 || errorThrown)
{
Thread.Sleep(1000);
}
natsClient.Close();
}
Assert.IsFalse(errorThrown);
}
public void TC018_UnsubscribeWithinBlocks()
{
bool errorThrown = false;
int receivedMessageCount = 0;
int sid = 0;
AutoResetEvent resetEvent = new AutoResetEvent(false);
object receivedMessageCountLock = new object();
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
sid = natsClient.Subscribe("foo", delegate(string msg, string reply, string subject)
{
lock (receivedMessageCountLock)
{
receivedMessageCount++;
natsClient.Unsubscribe(sid);
}
});
natsClient.Publish("foo", delegate()
{
natsClient.Publish("foo", delegate()
{
resetEvent.Set();
}, "xxx");
}, "xxx");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.AreEqual(1, receivedMessageCount);
}
public void TC004_CheckServerError()
{
bool errorThrown = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.Pedantic = true;
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Unsubscribe(10000);
natsClient.Publish("done");
resetEvent.WaitOne(10000);
natsClient.Close();
}
Assert.IsTrue(errorThrown);
}
public void TC017_RquestReplyMultipleConnections()
{
bool errorThrown = false;
string receivedMessage = "";
string receivedReply = "";
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("need_help", delegate(string msg, string reply, string subject)
{
receivedMessage = msg;
natsClient.Publish(reply, null, "help");
});
// todo: vladi: this doesn't work if no message is sent.
natsClient.Request("need_help", null, delegate(string msg, string reply, string subject)
{
receivedReply = msg;
resetEvent.Set();
}, "yyy");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.AreEqual(receivedMessage, "yyy");
Assert.AreEqual(receivedReply, "help");
}
public void TC019_ErrorHandlerNotPedantic()
{
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);
int sid = natsClient.Subscribe("foo");
natsClient.Unsubscribe(sid);
natsClient.Unsubscribe(sid);
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
}
/// <summary>
/// Initializes a new instance of the <see cref="VCAPReactor"/> class.
/// </summary>
public VCAPReactor()
{
this.NatsClient = ReactorFactory.GetReactor(typeof(Reactor));
this.NatsClient.OnError += this.OnNatsError;
}
public static Ship Construct(ShipSchema schema)
{
List <entity.parts.Reactor> reactors = schema.Reactors.Select(reactorSchema => ReactorFactory.Construct(reactorSchema)).ToList();
List <entity.parts.Shield> shields = schema.Shields.Select(shieldSchema => ShieldFactory.Construct(shieldSchema)).ToList();
List <entity.parts.Weapon.IWeapon> weapons = schema.Weapons.Select(weaponSchema => WeaponFactory.Construct(weaponSchema)).ToList();
List <entity.parts.Engine> engines = schema.Engines.Select(engineSchema => EngineFactory.Construct(engineSchema)).ToList();
List <entity.parts.CrewDeck> crewdecks = schema.CrewDecks.Select(crewDeckSchema => CrewDeckFactory.Construct(crewDeckSchema)).ToList();
return(new Ship(schema.Name, reactors, shields, weapons, engines, crewdecks));
}