private RootContextLauncher(
AvroConfigurationSerializer serializer,
[Parameter(typeof(RootContextConfiguration))] string rootContextConfiguration,
[Parameter(typeof(RootServiceConfiguration))] string rootServiceConfiguration,
IInjector injector)
: this(serializer.FromString(rootContextConfiguration),
serializer.FromString(rootServiceConfiguration),
Optional<IConfiguration>.Empty(),
injector)
{
}
public GroupCommClient(
[Parameter(typeof(GroupCommConfigurationOptions.SerializedGroupConfigs))] ISet<string> groupConfigs,
[Parameter(typeof(TaskConfigurationOptions.Identifier))] string taskId,
StreamingNetworkService<GeneralGroupCommunicationMessage> networkService,
AvroConfigurationSerializer configSerializer,
IInjector injector)
{
_commGroups = new Dictionary<string, ICommunicationGroupClientInternal>();
_networkService = networkService;
foreach (string serializedGroupConfig in groupConfigs)
{
IConfiguration groupConfig = configSerializer.FromString(serializedGroupConfig);
IInjector groupInjector = injector.ForkInjector(groupConfig);
var commGroupClient = (ICommunicationGroupClientInternal)groupInjector.GetInstance<ICommunicationGroupClient>();
_commGroups[commGroupClient.GroupName] = commGroupClient;
}
networkService.Register(new StringIdentifier(taskId));
foreach (var group in _commGroups.Values)
{
group.WaitingForRegistration();
}
}
private GroupCommClient(
[Parameter(typeof(GroupCommConfigurationOptions.SerializedGroupConfigs))] ISet<string> groupConfigs,
[Parameter(typeof(TaskConfigurationOptions.Identifier))] string taskId,
NetworkService<GroupCommunicationMessage> networkService,
AvroConfigurationSerializer configSerializer,
IInjector injector)
{
_commGroups = new Dictionary<string, ICommunicationGroupClient>();
_networkService = networkService;
networkService.Register(new StringIdentifier(taskId));
foreach (string serializedGroupConfig in groupConfigs)
{
IConfiguration groupConfig = configSerializer.FromString(serializedGroupConfig);
IInjector groupInjector = injector.ForkInjector(groupConfig);
ICommunicationGroupClient commGroupClient = groupInjector.GetInstance<ICommunicationGroupClient>();
_commGroups[commGroupClient.GroupName] = commGroupClient;
}
}
private ConfigurationManager(
AvroConfigurationSerializer configurationSerializer,
[Parameter(typeof(SerializedMapConfiguration))] string mapConfig,
[Parameter(typeof(SerializedReduceConfiguration))] string reduceConfig,
[Parameter(typeof(SerializedUpdateConfiguration))] string updateConfig,
[Parameter(typeof(SerializedMapInputCodecConfiguration))] string mapInputCodecConfig,
[Parameter(typeof(SerializedUpdateFunctionCodecsConfiguration))] string updateFunctionCodecsConfig,
[Parameter(typeof(SerializedMapOutputPipelineDataConverterConfiguration))] string
mapOutputPipelineDataConverterConfiguration,
[Parameter(typeof(SerializedMapInputPipelineDataConverterConfiguration))] string
mapInputPipelineDataConverterConfiguration,
[Parameter(typeof(SerializedResultHandlerConfiguration))] string resultHandlerConfiguration)
{
try
{
_mapFunctionConfiguration = configurationSerializer.FromString(mapConfig);
}
catch (Exception e)
{
Exceptions.Throw(e, "Unable to deserialize map function configuration", Logger);
}
try
{
_reduceFunctionConfiguration = configurationSerializer.FromString(reduceConfig);
}
catch (Exception e)
{
Exceptions.Throw(e, "Unable to deserialize reduce function configuration", Logger);
}
try
{
_updateFunctionConfiguration = configurationSerializer.FromString(updateConfig);
}
catch (Exception e)
{
Exceptions.Throw(e, "Unable to deserialize update function configuration", Logger);
}
try
{
_updateFunctionCodecsConfiguration = configurationSerializer.FromString(updateFunctionCodecsConfig);
}
catch (Exception e)
{
Exceptions.Throw(e, "Unable to deserialize update function codec configuration", Logger);
}
try
{
_mapInputCodecConfiguration = configurationSerializer.FromString(mapInputCodecConfig);
}
catch (Exception e)
{
Exceptions.Throw(e, "Unable to deserialize map input codec configuration", Logger);
}
try
{
_mapOutputPipelineDataConverterConfiguration =
configurationSerializer.FromString(mapOutputPipelineDataConverterConfiguration);
}
catch (Exception e)
{
Exceptions.Throw(e, "Unable to deserialize map output pipeline data converter configuration", Logger);
}
try
{
_mapInputPipelineDataConverterConfiguration =
configurationSerializer.FromString(mapInputPipelineDataConverterConfiguration);
}
catch (Exception e)
{
Exceptions.Throw(e, "Unable to deserialize map input pipeline data converter configuration", Logger);
}
try
{
_resultHandlerConfiguration =
configurationSerializer.FromString(resultHandlerConfiguration);
Logger.Log(Level.Verbose, "Serialized result handler is " + resultHandlerConfiguration);
}
catch (Exception e)
{
Exceptions.Throw(e, "Unable to deserialize map input pipeline data converter configuration", Logger);
}
}
public void TestDeserializeEvaluatorContextServiceTaskWithAlias()
{
var serializer = new AvroConfigurationSerializer();
var config = DeserializeConfigWithAlias();
var evaluatorInjector = TangFactory.GetTang().NewInjector(config);
var evaluatorConfigString = evaluatorInjector.GetNamedInstance<EvaluatorConfiguration, string>();
var taskConfigString = evaluatorInjector.GetNamedInstance<InitialTaskConfiguration, string>();
var contextConfigString = evaluatorInjector.GetNamedInstance<RootContextConfiguration, string>();
var serviceConfigString = evaluatorInjector.GetNamedInstance<RootServiceConfiguration, string>();
var evaluatorClassHierarchy = TangFactory.GetTang().GetClassHierarchy(new string[]
{
typeof(DefaultLocalHttpDriverConnection).Assembly.GetName().Name
});
var evaluatorConfig = serializer.FromString(evaluatorConfigString, evaluatorClassHierarchy);
var fullEvaluatorInjector = evaluatorInjector.ForkInjector(evaluatorConfig);
Assert.True(fullEvaluatorInjector.GetInstance<IDriverConnection>() is DefaultLocalHttpDriverConnection);
var contextClassHierarchy = TangFactory.GetTang().GetClassHierarchy(new string[]
{
typeof(Common.Context.ContextConfigurationOptions.ContextIdentifier).Assembly.GetName().Name
});
var contextConfig = serializer.FromString(contextConfigString, contextClassHierarchy);
var taskClassHierarchy = TangFactory.GetTang().GetClassHierarchy(new string[]
{
typeof(ITask).Assembly.GetName().Name,
typeof(HelloTask).Assembly.GetName().Name
});
var taskConfig = serializer.FromString(taskConfigString, taskClassHierarchy);
var serviceClassHierarchy = TangFactory.GetTang().GetClassHierarchy(new string[]
{
typeof(ServiceConfiguration).Assembly.GetName().Name,
typeof(IStreamingCodec<>).Assembly.GetName().Name
});
var serviceConfig = serializer.FromString(serviceConfigString, serviceClassHierarchy);
var contextInjector = fullEvaluatorInjector.ForkInjector(contextConfig);
string contextId = contextInjector.GetNamedInstance<Common.Context.ContextConfigurationOptions.ContextIdentifier, string>();
Assert.True(contextId.StartsWith(ContextIdPrefix));
var serviceInjector = contextInjector.ForkInjector(serviceConfig);
var service = serviceInjector.GetInstance<TestService>();
Assert.NotNull(service);
var taskInjector = serviceInjector.ForkInjector(taskConfig);
var taskId = taskInjector.GetNamedInstance<TaskConfigurationOptions.Identifier, string>();
var task = taskInjector.GetInstance<ITask>();
Assert.True(taskId.StartsWith("HelloTask"));
Assert.True(task is HelloTask);
}
private EvaluatorSettings(
[Parameter(typeof(ApplicationIdentifier))] string applicationId,
[Parameter(typeof(EvaluatorIdentifier))] string evaluatorId,
[Parameter(typeof(EvaluatorHeartbeatPeriodInMs))] int heartbeatPeriodInMs,
[Parameter(typeof(HeartbeatMaxRetry))] int maxHeartbeatRetries,
[Parameter(typeof(RootContextConfiguration))] string rootContextConfigString,
AvroConfigurationSerializer serializer,
RuntimeClock clock,
IRemoteManagerFactory remoteManagerFactory,
REEFMessageCodec reefMessageCodec,
IInjector injector,
INameClient nameClient)
{
_serializer = serializer;
_injector = injector;
_applicationId = applicationId;
_evaluatorId = evaluatorId;
_heartBeatPeriodInMs = heartbeatPeriodInMs;
_maxHeartbeatRetries = maxHeartbeatRetries;
_clock = clock;
if (string.IsNullOrWhiteSpace(rootContextConfigString))
{
Utilities.Diagnostics.Exceptions.Throw(
new ArgumentException("empty or null rootContextConfigString"), Logger);
}
_rootContextConfig = _serializer.FromString(rootContextConfigString);
try
{
_rootContextId = injector.ForkInjector(_rootContextConfig).GetNamedInstance<ContextConfigurationOptions.ContextIdentifier, string>();
}
catch (InjectionException)
{
Logger.Log(Level.Info, "Using deprecated ContextConfiguration.");
// TODO[JIRA REEF-1167]: Remove this catch.
var deprecatedContextConfig = new Context.ContextConfiguration(rootContextConfigString);
_rootContextConfig = deprecatedContextConfig;
_rootContextId = deprecatedContextConfig.Id;
}
_rootTaskConfiguration = CreateTaskConfiguration();
_rootServiceConfiguration = CreateRootServiceConfiguration();
_remoteManager = remoteManagerFactory.GetInstance(reefMessageCodec);
_operationState = EvaluatorOperationState.OPERATIONAL;
_nameClient = nameClient;
}
public void TestDeserializationForContextAndTask()
{
AvroConfigurationSerializer serializer = new AvroConfigurationSerializer();
var classHierarchy = TangFactory.GetTang()
.GetClassHierarchy(new string[] { typeof(ApplicationIdentifier).Assembly.GetName().Name });
var config = serializer.FromFile("evaluator.conf", classHierarchy);
IInjector evaluatorInjector = TangFactory.GetTang().NewInjector(config);
string taskConfigString = evaluatorInjector.GetNamedInstance<InitialTaskConfiguration, string>();
string contextConfigString = evaluatorInjector.GetNamedInstance<RootContextConfiguration, string>();
var contextClassHierarchy = TangFactory.GetTang().GetClassHierarchy(new string[]
{
typeof(ContextConfigurationOptions.ContextIdentifier).Assembly.GetName().Name
});
var contextConfig = serializer.FromString(contextConfigString, contextClassHierarchy);
var taskClassHierarchy = TangFactory.GetTang().GetClassHierarchy(new string[]
{
typeof(ITask).Assembly.GetName().Name,
typeof(HelloTask).Assembly.GetName().Name
});
var taskConfig = serializer.FromString(taskConfigString, taskClassHierarchy);
var contextInjector = evaluatorInjector.ForkInjector(contextConfig);
string contextId = contextInjector.GetNamedInstance<ContextConfigurationOptions.ContextIdentifier, string>();
Assert.True(contextId.StartsWith(ContextIdPrefix));
var taskInjector = contextInjector.ForkInjector(taskConfig);
string taskId = taskInjector.GetNamedInstance<TaskConfigurationOptions.Identifier, string>();
ITask task = taskInjector.GetInstance<ITask>();
Assert.True(taskId.StartsWith("HelloTask"));
Assert.True(task is HelloTask);
}
public void TestDeserializationForServiceAndContext()
{
AvroConfigurationSerializer serializer = new AvroConfigurationSerializer();
var classHierarchy = TangFactory.GetTang()
.GetClassHierarchy(new string[] { typeof(ApplicationIdentifier).Assembly.GetName().Name });
var config = serializer.FromFile("evaluatorWithService.conf", classHierarchy);
IInjector evaluatorInjector = TangFactory.GetTang().NewInjector(config);
string contextConfigString = evaluatorInjector.GetNamedInstance<RootContextConfiguration, string>();
string rootServiceConfigString = evaluatorInjector.GetNamedInstance<RootServiceConfiguration, string>();
var contextClassHierarchy = TangFactory.GetTang().GetClassHierarchy(new string[]
{
typeof(ContextConfigurationOptions.ContextIdentifier).Assembly.GetName().Name
});
var contextConfig = serializer.FromString(contextConfigString, contextClassHierarchy);
var serviceClassHierarchy = TangFactory.GetTang().GetClassHierarchy(new string[]
{
typeof(ServicesConfigurationOptions).Assembly.GetName().Name,
typeof(IStreamingCodec<>).Assembly.GetName().Name
});
var rootServiceConfig = serializer.FromString(rootServiceConfigString, serviceClassHierarchy);
var contextInjector = evaluatorInjector.ForkInjector(contextConfig);
string contextId = contextInjector.GetNamedInstance<ContextConfigurationOptions.ContextIdentifier, string>();
Assert.True(contextId.StartsWith("MasterTaskContext"));
string serviceConfigString = TangFactory.GetTang().NewInjector(rootServiceConfig)
.GetNamedInstance<ServicesConfigurationOptions.ServiceConfigString, string>();
var serviceConfig = serializer.FromString(serviceConfigString, serviceClassHierarchy);
var serviceInjector = contextInjector.ForkInjector(serviceConfig);
var tcpCountRange = serviceInjector.GetNamedInstance<TcpPortRangeStart, int>();
var tcpCountCount = serviceInjector.GetNamedInstance<TcpPortRangeCount, int>();
Assert.True(tcpCountRange > 0);
Assert.True(tcpCountCount > 0);
}
public override IConfiguration RoundTrip(IConfiguration configuration)
{
AvroConfigurationSerializer serializer = new AvroConfigurationSerializer();
return serializer.FromString(serializer.ToString(configuration));
}