public void TestOneWayCommunication()
{
IPAddress listeningAddress = IPAddress.Parse("127.0.0.1");
BlockingCollection <string> queue = new BlockingCollection <string>();
List <string> events = new List <string>();
using (var remoteManager1 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
using (var remoteManager2 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
{
var observer = Observer.Create <string>(queue.Add);
IPEndPoint endpoint1 = new IPEndPoint(listeningAddress, 0);
remoteManager2.RegisterObserver(endpoint1, observer);
var remoteObserver = remoteManager1.GetRemoteObserver(remoteManager2.LocalEndpoint);
remoteObserver.OnNext("abc");
remoteObserver.OnNext("def");
remoteObserver.OnNext("ghi");
events.Add(queue.Take());
events.Add(queue.Take());
events.Add(queue.Take());
}
Assert.AreEqual(3, events.Count);
}
public void TestOneWayCommunicationClientOnly()
{
int listeningPort = NetworkUtils.GenerateRandomPort(6000, 7000);
IPAddress listeningAddress = IPAddress.Parse("127.0.0.1");
BlockingCollection <string> queue = new BlockingCollection <string>();
List <string> events = new List <string>();
using (var remoteManager1 = new DefaultRemoteManager <string>(new StringCodec()))
using (var remoteManager2 = new DefaultRemoteManager <string>(listeningAddress, listeningPort, new StringCodec()))
{
IPEndPoint remoteEndpoint = new IPEndPoint(listeningAddress, 0);
var observer = Observer.Create <string>(queue.Add);
remoteManager2.RegisterObserver(remoteEndpoint, observer);
var remoteObserver = remoteManager1.GetRemoteObserver(remoteManager2.LocalEndpoint);
remoteObserver.OnNext("abc");
remoteObserver.OnNext("def");
remoteObserver.OnNext("ghi");
events.Add(queue.Take());
events.Add(queue.Take());
events.Add(queue.Take());
}
Assert.AreEqual(3, events.Count);
}
public void TestRegisterObserverByType()
{
IPAddress listeningAddress = IPAddress.Parse("127.0.0.1");
BlockingCollection <string> queue = new BlockingCollection <string>();
List <string> events = new List <string>();
using (var remoteManager1 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
using (var remoteManager2 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
{
// RemoteManager2 listens and records events of type IRemoteEvent<string>
var observer = Observer.Create <IRemoteMessage <string> >(message => queue.Add(message.Message));
remoteManager2.RegisterObserver(observer);
// Remote manager 1 sends 3 events to remote manager 2
var remoteObserver = remoteManager1.GetRemoteObserver(remoteManager2.LocalEndpoint);
remoteObserver.OnNext("abc");
remoteObserver.OnNext("def");
remoteObserver.OnNext("ghi");
events.Add(queue.Take());
events.Add(queue.Take());
events.Add(queue.Take());
}
Assert.AreEqual(3, events.Count);
}
public void TestCommunicationThreeNodesOneWay()
{
IPAddress listeningAddress = IPAddress.Parse("127.0.0.1");
BlockingCollection <string> queue = new BlockingCollection <string>();
List <string> events = new List <string>();
using (var remoteManager1 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
using (var remoteManager2 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
using (var remoteManager3 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
{
var remoteEndpoint = new IPEndPoint(listeningAddress, 0);
var observer = Observer.Create <string>(queue.Add);
remoteManager3.RegisterObserver(remoteEndpoint, observer);
var remoteObserver1 = remoteManager1.GetRemoteObserver(remoteManager3.LocalEndpoint);
var remoteObserver2 = remoteManager2.GetRemoteObserver(remoteManager3.LocalEndpoint);
remoteObserver2.OnNext("abc");
remoteObserver1.OnNext("def");
remoteObserver2.OnNext("ghi");
remoteObserver1.OnNext("jkl");
remoteObserver2.OnNext("mno");
for (int i = 0; i < 5; i++)
{
events.Add(queue.Take());
}
}
Assert.AreEqual(5, events.Count);
}
public void TestTwoWayCommunication()
{
IPAddress listeningAddress = IPAddress.Parse("127.0.0.1");
BlockingCollection <string> queue1 = new BlockingCollection <string>();
BlockingCollection <string> queue2 = new BlockingCollection <string>();
List <string> events1 = new List <string>();
List <string> events2 = new List <string>();
using (var remoteManager1 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
using (var remoteManager2 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
{
// Register observers for remote manager 1 and remote manager 2
var remoteEndpoint = new IPEndPoint(listeningAddress, 0);
var observer1 = Observer.Create <string>(queue1.Add);
var observer2 = Observer.Create <string>(queue2.Add);
remoteManager1.RegisterObserver(remoteEndpoint, observer1);
remoteManager2.RegisterObserver(remoteEndpoint, observer2);
// Remote manager 1 sends 3 events to remote manager 2
var remoteObserver1 = remoteManager1.GetRemoteObserver(remoteManager2.LocalEndpoint);
remoteObserver1.OnNext("abc");
remoteObserver1.OnNext("def");
remoteObserver1.OnNext("ghi");
// Remote manager 2 sends 4 events to remote manager 1
var remoteObserver2 = remoteManager2.GetRemoteObserver(remoteManager1.LocalEndpoint);
remoteObserver2.OnNext("jkl");
remoteObserver2.OnNext("mno");
remoteObserver2.OnNext("pqr");
remoteObserver2.OnNext("stu");
events1.Add(queue1.Take());
events1.Add(queue1.Take());
events1.Add(queue1.Take());
events1.Add(queue1.Take());
events2.Add(queue2.Take());
events2.Add(queue2.Take());
events2.Add(queue2.Take());
}
Assert.AreEqual(4, events1.Count);
Assert.AreEqual(3, events2.Count);
}
public void TestRemoteSenderCallback()
{
IPAddress listeningAddress = IPAddress.Parse("127.0.0.1");
BlockingCollection <string> queue = new BlockingCollection <string>();
List <string> events = new List <string>();
using (var remoteManager1 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
using (var remoteManager2 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
{
// Register handler for when remote manager 2 receives events; respond
// with an ack
var remoteEndpoint = new IPEndPoint(listeningAddress, 0);
var remoteObserver2 = remoteManager2.GetRemoteObserver(remoteManager1.LocalEndpoint);
var receiverObserver = Observer.Create <string>(
message => remoteObserver2.OnNext("received message: " + message));
remoteManager2.RegisterObserver(remoteEndpoint, receiverObserver);
// Register handler for remote manager 1 to record the ack
var senderObserver = Observer.Create <string>(queue.Add);
remoteManager1.RegisterObserver(remoteEndpoint, senderObserver);
// Begin to send messages
var remoteObserver1 = remoteManager1.GetRemoteObserver(remoteManager2.LocalEndpoint);
remoteObserver1.OnNext("hello");
remoteObserver1.OnNext("there");
remoteObserver1.OnNext("buddy");
events.Add(queue.Take());
events.Add(queue.Take());
events.Add(queue.Take());
}
Assert.AreEqual(3, events.Count);
Assert.AreEqual("received message: hello", events[0]);
Assert.AreEqual("received message: there", events[1]);
Assert.AreEqual("received message: buddy", events[2]);
}
public void TestCommunicationThreeNodesBothWays()
{
IPAddress listeningAddress = IPAddress.Parse("127.0.0.1");
BlockingCollection <string> queue1 = new BlockingCollection <string>();
BlockingCollection <string> queue2 = new BlockingCollection <string>();
BlockingCollection <string> queue3 = new BlockingCollection <string>();
List <string> events1 = new List <string>();
List <string> events2 = new List <string>();
List <string> events3 = new List <string>();
using (var remoteManager1 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
using (var remoteManager2 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
using (var remoteManager3 = new DefaultRemoteManager <string>(listeningAddress, 0, new StringCodec()))
{
var remoteEndpoint = new IPEndPoint(listeningAddress, 0);
var observer = Observer.Create <string>(queue1.Add);
remoteManager1.RegisterObserver(remoteEndpoint, observer);
var observer2 = Observer.Create <string>(queue2.Add);
remoteManager2.RegisterObserver(remoteEndpoint, observer2);
var observer3 = Observer.Create <string>(queue3.Add);
remoteManager3.RegisterObserver(remoteEndpoint, observer3);
var remoteObserver1 = remoteManager1.GetRemoteObserver(remoteManager3.LocalEndpoint);
var remoteObserver2 = remoteManager2.GetRemoteObserver(remoteManager3.LocalEndpoint);
// Observer 1 and 2 send messages to observer 3
remoteObserver1.OnNext("abc");
remoteObserver1.OnNext("abc");
remoteObserver1.OnNext("abc");
remoteObserver2.OnNext("def");
remoteObserver2.OnNext("def");
// Observer 3 sends messages back to observers 1 and 2
var remoteObserver3a = remoteManager3.GetRemoteObserver(remoteManager1.LocalEndpoint);
var remoteObserver3b = remoteManager3.GetRemoteObserver(remoteManager2.LocalEndpoint);
remoteObserver3a.OnNext("ghi");
remoteObserver3a.OnNext("ghi");
remoteObserver3b.OnNext("jkl");
remoteObserver3b.OnNext("jkl");
remoteObserver3b.OnNext("jkl");
events1.Add(queue1.Take());
events1.Add(queue1.Take());
events2.Add(queue2.Take());
events2.Add(queue2.Take());
events2.Add(queue2.Take());
events3.Add(queue3.Take());
events3.Add(queue3.Take());
events3.Add(queue3.Take());
events3.Add(queue3.Take());
events3.Add(queue3.Take());
}
Assert.AreEqual(2, events1.Count);
Assert.AreEqual(3, events2.Count);
Assert.AreEqual(5, events3.Count);
}
public static void Main(string[] args)
{
Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "START: {0} Evaluator::InitInjector.", DateTime.Now));
Stopwatch timer = new Stopwatch();
InitInjector();
SetCustomTraceListners();
timer.Stop();
Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "EXIT: {0} Evaluator::InitInjector. Duration: [{1}].", DateTime.Now, timer.Elapsed));
RuntimeClock clock;
using (_logger.LogScope("Evaluator::Main"))
{
string debugEnabledString = Environment.GetEnvironmentVariable("Org.Apache.Reef.EvaluatorDebug");
if (!string.IsNullOrWhiteSpace(debugEnabledString) &&
debugEnabledString.Equals("enabled", StringComparison.OrdinalIgnoreCase))
{
while (true)
{
if (Debugger.IsAttached)
{
break;
}
else
{
_logger.Log(Level.Info, "Evaluator in debug mode, waiting for debugger to be attached...");
Thread.Sleep(2000);
}
}
}
AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionHandler;
string heartbeatPeriodFromConfig = ConfigurationManager.AppSettings["EvaluatorHeartbeatPeriodInMs"];
int heartbeatPeriod = 0;
if (!string.IsNullOrWhiteSpace(heartbeatPeriodFromConfig) &&
int.TryParse(heartbeatPeriodFromConfig, out heartbeatPeriod))
{
_heartbeatPeriodInMs = heartbeatPeriod;
}
_logger.Log(Level.Verbose,
"Evaluator heartbeat period set to be " + _heartbeatPeriodInMs + " milliSeconds.");
int maxHeartbeatRetry = 0;
string heartbeatMaxRetryFromConfig = ConfigurationManager.AppSettings["EvaluatorHeartbeatRetryMaxTimes"];
if (!string.IsNullOrWhiteSpace(heartbeatMaxRetryFromConfig) &&
int.TryParse(heartbeatMaxRetryFromConfig, out maxHeartbeatRetry))
{
_heartbeatMaxRetry = maxHeartbeatRetry;
}
_logger.Log(Level.Verbose, "Evaluator heatrbeat max retry set to be " + _heartbeatMaxRetry + " times.");
if (args.Count() < 2)
{
var e = new InvalidOperationException("must supply at least the rId and evaluator config file");
Exceptions.Throw(e, _logger);
}
// remote driver Id
string rId = args[0];
// evaluator configuraiton file
string evaluatorConfigurationPath = args[1];
ICodec <REEFMessage> reefMessageCodec = new REEFMessageCodec();
_evaluatorConfig = new EvaluatorConfigurations(evaluatorConfigurationPath);
string rootContextConfigString = _evaluatorConfig.RootContextConfiguration;
if (string.IsNullOrWhiteSpace(rootContextConfigString))
{
Exceptions.Throw(new ArgumentException("empty or null rootContextConfigString"), _logger);
}
ContextConfiguration rootContextConfiguration = new ContextConfiguration(rootContextConfigString);
string taskConfig = _evaluatorConfig.TaskConfiguration;
Optional <TaskConfiguration> rootTaskConfig = string.IsNullOrEmpty(taskConfig)
? Optional <TaskConfiguration> .Empty()
: Optional <TaskConfiguration> .Of(
new TaskConfiguration(taskConfig));
string rootServiceConfigString = _evaluatorConfig.RootServiceConfiguration;
Optional <ServiceConfiguration> rootServiceConfig = string.IsNullOrEmpty(rootServiceConfigString)
? Optional <ServiceConfiguration> .Empty()
: Optional <ServiceConfiguration> .Of(
new ServiceConfiguration(
rootServiceConfigString));
// remoteManager used as client-only in evaluator
IRemoteManager <REEFMessage> remoteManager = new DefaultRemoteManager <REEFMessage>(reefMessageCodec);
IRemoteIdentifier remoteId = new SocketRemoteIdentifier(NetUtilities.ParseIpEndpoint(rId));
ConfigurationModule module = new ConfigurationModuleBuilder().Build();
IConfiguration clockConfiguraiton = module.Build();
clock =
TangFactory.GetTang().NewInjector(clockConfiguraiton).GetInstance <RuntimeClock>();
_logger.Log(Level.Info, "Application Id: " + _evaluatorConfig.ApplicationId);
EvaluatorSettings evaluatorSettings = new EvaluatorSettings(
_evaluatorConfig.ApplicationId,
_evaluatorConfig.EvaluatorId,
_heartbeatPeriodInMs,
_heartbeatMaxRetry,
rootContextConfiguration,
clock,
remoteManager,
_injector);
HeartBeatManager heartBeatManager = new HeartBeatManager(evaluatorSettings, remoteId);
ContextManager contextManager = new ContextManager(heartBeatManager, rootServiceConfig, rootTaskConfig);
EvaluatorRuntime evaluatorRuntime = new EvaluatorRuntime(contextManager, heartBeatManager);
// TODO: repalce with injectionFuture
heartBeatManager._evaluatorRuntime = evaluatorRuntime;
heartBeatManager._contextManager = contextManager;
SetRuntimeHanlders(evaluatorRuntime, clock);
}
Task evaluatorTask = Task.Run(new Action(clock.Run));
evaluatorTask.Wait();
}
