public void TestNameCantBindSubclassOfArgumentAsDefault()
{
ns = TangFactory.GetTang().GetClassHierarchy(new string[] { FileNames.Examples, FileNames.Common, FileNames.Tasks });
INode node = ns.GetNode(typeof(GoodNameForGeneric).AssemblyQualifiedName);
Assert.Equal(node.GetFullName(), typeof(GoodNameForGeneric).AssemblyQualifiedName);
}
public void TestDeserializedConfigMerge()
{
Type activityInterfaceType = typeof(ITask);
ITang tang = TangFactory.GetTang();
ICsConfigurationBuilder cb1 = tang.NewConfigurationBuilder();
cb1.BindImplementation(GenericType <ITask> .Class, GenericType <HelloTask> .Class);
cb1.BindNamedParameter <TaskConfigurationOptions.Identifier, string>(
GenericType <TaskConfigurationOptions.Identifier> .Class, "Hello Task");
IConfiguration conf1 = cb1.Build();
var serializer = new AvroConfigurationSerializer();
serializer.ToFile(conf1, "task.config");
ICsConfigurationBuilder cb2 = tang.NewConfigurationBuilder();
cb2.BindNamedParameter <Timer.Seconds, int>(GenericType <Timer.Seconds> .Class, "2");
IConfiguration conf2 = cb2.Build();
serializer.ToFile(conf2, "timer.config");
ProtocolBufferClassHierarchy.Serialize("TaskTimer.bin", conf1.GetClassHierarchy());
IClassHierarchy ns = ProtocolBufferClassHierarchy.DeSerialize("TaskTimer.bin");
AvroConfiguration taskAvroconfiguration = serializer.AvroDeserializeFromFile("task.config");
IConfiguration taskConfiguration = serializer.FromAvro(taskAvroconfiguration, ns);
AvroConfiguration timerAvroconfiguration = serializer.AvroDeserializeFromFile("timer.config");
IConfiguration timerConfiguration = serializer.FromAvro(timerAvroconfiguration, ns);
IConfiguration merged = Configurations.MergeDeserializedConfs(taskConfiguration, timerConfiguration);
var b = merged.newBuilder().Build();
}
public void TestSerializeClassHierarchy()
{
IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { @"Com.Microsoft.Tang.Examples" });
IClassNode timerClassNode = (IClassNode)ns.GetNode("Com.Microsoft.Tang.Examples.Timer");
ProtocolBufferClassHierarchy.Serialize("node.bin", ns);
}
public TestClassHierarchy()
{
if (ns == null)
{
ns = TangFactory.GetTang().GetClassHierarchy(new string[] { FileNames.Examples, FileNames.Common, FileNames.Tasks });
}
}
public IClassHierarchy Merge(IClassHierarchy ch)
{
if (this == ch)
{
return(this);
}
if (!(ch is ClassHierarchyImpl))
{
Org.Apache.Reef.Utilities.Diagnostics.Exceptions.Throw(new NotSupportedException("Can't merge java and non-java class hierarchies yet!"), LOGGER);
}
if (this.assemblies.Count == 0)
{
return(ch);
}
ClassHierarchyImpl chi = (ClassHierarchyImpl)ch;
MonotonicHashSet <string> otherJars = new MonotonicHashSet <string>();
otherJars.AddAll(chi.assemblies);
MonotonicHashSet <string> myJars = new MonotonicHashSet <string>();
myJars.AddAll(this.assemblies);
if (myJars.ContainsAll(otherJars))
{
return(this);
}
if (otherJars.ContainsAll(myJars))
{
return(ch);
}
myJars.AddAll(otherJars);
return(new ClassHierarchyImpl(myJars.ToArray()));
}
public void TestToTextFileForTask()
{
IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { typeof(HelloTask).Assembly.GetName().Name });
_serializer.ToTextFile(ns, "avroTask.bin");
Assert.True(File.Exists("avroTask.bin"));
}
public void TestToString()
{
IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { typeof(HelloTask).Assembly.GetName().Name });
string s = _serializer.ToString(ns);
Assert.NotNull(s);
}
/// <summary>
/// Serialize a ClassHierarchy into a Json string
/// </summary>
/// <param name="c"></param>
/// <returns></returns>
public string ToString(IClassHierarchy c)
{
AvroNode obj = ToAvroNode(c);
string s = JsonConvert.SerializeObject(obj, Formatting.Indented);
return(s);
}
public void TestDeSerializeClassHierarchyAndBind()
{
Type streamTask1Type = typeof(StreamTask1);
Type helloTaskType = typeof(HelloTask);
IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { typeof(HelloTask).Assembly.GetName().Name });
IClassNode StreamTask1ClassNode = (IClassNode)ns.GetNode(streamTask1Type.AssemblyQualifiedName);
IClassNode HelloTaskClassNode = (IClassNode)ns.GetNode(helloTaskType.AssemblyQualifiedName);
ProtocolBufferClassHierarchy.Serialize("task.bin", ns);
IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize("task.bin");
IClassNode StreamTask1ClassNode2 = (IClassNode)ch.GetNode(streamTask1Type.AssemblyQualifiedName);
IClassNode HelloTaskClassNode2 = (IClassNode)ch.GetNode(helloTaskType.AssemblyQualifiedName);
Assert.Equal(StreamTask1ClassNode.GetName(), StreamTask1ClassNode2.GetName());
Assert.Equal(HelloTaskClassNode.GetName(), HelloTaskClassNode2.GetName());
// have to use original class hierarchy for the merge. ClassHierarchy from ProtoBuffer doesn't support merge.
IConfigurationBuilder cb = TangFactory.GetTang()
.NewConfigurationBuilder(ns);
cb.AddConfiguration(TaskConfiguration.ConfigurationModule
.Set(TaskConfiguration.Identifier, "Hello_From_Streaming1")
.Set(TaskConfiguration.Task, GenericType <StreamTask1> .Class)
.Build());
IConfiguration taskConfiguration = cb.Build();
StreamTask1 st = TangFactory.GetTang().NewInjector(taskConfiguration).GetInstance <StreamTask1>();
Assert.NotNull(st);
}
/// <summary>
/// Serialize a ClassHierarchy into a text file as Json string
/// </summary>
/// <param name="c"></param>
/// <param name="fileName"></param>
public void ToTextFile(IClassHierarchy c, string fileName)
{
var fp = new StreamWriter(fileName);
fp.WriteLine(ToString(c));
fp.Close();
}
public void TestDeSerializeClassHierarchy()
{
Type timerType = typeof(Timer);
Type SecondType = typeof(Timer.Seconds);
Type simpleCOnstuctorType = typeof(SimpleConstructors);
IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { typeof(Timer).Assembly.GetName().Name });
IClassNode timerClassNode = (IClassNode)ns.GetNode(timerType.AssemblyQualifiedName);
INode secondNode = (INode)ns.GetNode(SecondType.AssemblyQualifiedName);
IClassNode SimpleConstructorsClassNode = (IClassNode)ns.GetNode(simpleCOnstuctorType.AssemblyQualifiedName);
ProtocolBufferClassHierarchy.Serialize("node.bin", ns);
IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize("node.bin");
IClassNode timerClassNode2 = (IClassNode)ch.GetNode(timerType.AssemblyQualifiedName);
INode secondNode2 = ch.GetNode(SecondType.AssemblyQualifiedName);
IClassNode SimpleConstructorsClassNode2 = (IClassNode)ch.GetNode(simpleCOnstuctorType.AssemblyQualifiedName);
Assert.Equal(timerClassNode.GetFullName(), timerClassNode2.GetFullName());
Assert.Equal(secondNode.GetFullName(), secondNode2.GetFullName());
Assert.Equal(SimpleConstructorsClassNode.GetFullName(), SimpleConstructorsClassNode2.GetFullName());
Assert.True(SimpleConstructorsClassNode2.GetChildren().Count == 0);
IList <IConstructorDef> def = SimpleConstructorsClassNode2.GetInjectableConstructors();
Assert.Equal(3, def.Count);
}
public static InjectionPlan Deserialize(IClassHierarchy ch, InjectionPlanProto.InjectionPlan ip)
{
string fullName = ip.name;
if (ip.constructor != null)
{
InjectionPlanProto.Constructor cons = ip.constructor;
IClassNode cn = (IClassNode)ch.GetNode(fullName);
InjectionPlanProto.InjectionPlan[] protoBufArgs = cons.args.ToArray();
IClassNode[] cnArgs = new IClassNode[protoBufArgs.Length];
for (int i = 0; i < protoBufArgs.Length; i++)
{
INode no = ch.GetNode(protoBufArgs[i].name);
if (no is IClassNode)
{
cnArgs[i] = (IClassNode)no;
}
else if (no is INamedParameterNode)
{
INamedParameterNode np = (INamedParameterNode)no;
cnArgs[i] = (IClassNode)ch.GetNode(np.GetFullArgName());
}
}
InjectionPlan[] ipArgs = new InjectionPlan[protoBufArgs.Length];
for (int i = 0; i < protoBufArgs.Length; i++)
{
ipArgs[i] = (InjectionPlan)Deserialize(ch, protoBufArgs[i]);
}
IConstructorDef constructor = cn.GetConstructorDef(cnArgs);
return(new Constructor(cn, constructor, ipArgs));
}
if (ip.instance != null)
{
InjectionPlanProto.Instance ins = ip.instance;
object instance = Parse(ip.name, ins.value);
return(new CsInstance(ch.GetNode(ip.name), instance));
}
if (ip.subplan != null)
{
InjectionPlanProto.Subplan subplan = ip.subplan;
InjectionPlanProto.InjectionPlan[] protoBufPlans = subplan.plans.ToArray();
InjectionPlan[] subPlans = new InjectionPlan[protoBufPlans.Length];
for (int i = 0; i < protoBufPlans.Length; i++)
{
subPlans[i] = (InjectionPlan)Deserialize(ch, protoBufPlans[i]);
}
INode n = ch.GetNode(fullName);
return(new Subplan(n, subPlans));
}
Org.Apache.Reef.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Encountered unknown type of InjectionPlan: " + ip), LOGGER);
return(null);
}
public void TestDeSerializeClassHierarchyFromJava()
{
//the file comes from Java TestClassHierarchyRoundTrip SetUp3 testSimpleConstructors
IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize("simpleConstructorJavaProto.bin");
IClassNode simpleConstructorNode = (IClassNode)ch.GetNode("org.apache.reef.tang.implementation.SimpleConstructors");
Assert.AreEqual(simpleConstructorNode.GetChildren().Count, 0);
Assert.AreEqual(simpleConstructorNode.GetInjectableConstructors().Count, 3);
}
public void TestSerializeClassHierarchyForAvro()
{
IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { typeof(Microsoft.Hadoop.Avro.AvroSerializer).Assembly.GetName().Name });
Assert.IsNotNull(ns);
ProtocolBufferClassHierarchy.Serialize("avro.bin", ns);
IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize("avro.bin");
Assert.IsNotNull(ch);
}
protected ConfigurationBuilderImpl(string[] assemblies, IConfiguration[] confs, Type[] parsers)
{
this.ClassHierarchy = TangFactory.GetTang().GetDefaultClassHierarchy(assemblies, parsers);
foreach (IConfiguration tc in confs)
{
AddConfiguration(((ConfigurationImpl) tc));
}
}
protected ConfigurationBuilderImpl(string[] assemblies, IConfiguration[] confs, Type[] parsers)
{
this.ClassHierarchy = TangFactory.GetTang().GetDefaultClassHierarchy(assemblies, parsers);
foreach (IConfiguration tc in confs)
{
AddConfiguration(((ConfigurationImpl)tc));
}
}
public static void Serialize(string fileName, IClassHierarchy classHierarchy)
{
Org.Apache.REEF.Tang.Protobuf.Node node = Serialize(classHierarchy);
using (var file = File.Create(fileName))
{
Serializer.Serialize <Org.Apache.REEF.Tang.Protobuf.Node>(file, node);
}
}
public IClassHierarchy Merge(IClassHierarchy ch)
{
if (this.assemblies.Count == 0)
{
return(ch);
}
return(ch);//TODO
}
/// <summary>
/// Serialize a ClassHierarchy into a text file as Json string
/// </summary>
/// <param name="c"></param>
/// <param name="fileName"></param>
public void ToTextFile(IClassHierarchy c, string fileName)
{
using (FileStream fs = File.Open(fileName, FileMode.Create))
{
var fp = new StreamWriter(fs);
fp.WriteLine(ToString(c));
fp.Dispose();
}
}
public static void Serialize(string fileName, IClassHierarchy classHierarchy)
{
Org.Apache.REEF.Tang.Protobuf.Node node = Serialize(classHierarchy);
using (var file = File.Create(fileName))
{
Serializer.Serialize<Org.Apache.REEF.Tang.Protobuf.Node>(file, node);
}
}
public static void Serialize(string fileName, IClassHierarchy classHierarchy)
{
Node node = Serialize(classHierarchy);
using (var file = File.Create(fileName))
{
Serializer.Serialize<Node>(file, node);
}
}
public static void Serialize(string fileName, IClassHierarchy classHierarchy)
{
Node node = Serialize(classHierarchy);
using (var file = File.Create(fileName))
{
Serializer.Serialize <Node>(file, node);
}
}
public IClassHierarchy Merge(IClassHierarchy ch)
{
if (this == ch)
{
return(this);
}
throw new UnsupportedOperationException(
"Cannot merge ExternalClassHierarchies yet!");
}
private void AddConfiguration(IClassHierarchy ns, ConfigurationBuilderImpl builder)
{
this.ClassHierarchy = this.ClassHierarchy.Merge(ns);
//TODO
//((ClassHierarchyImpl) ClassHierarchy).parameterParser
// .mergeIn(((ClassHierarchyImpl) namespace).parameterParser);
foreach (IClassNode cn in builder.BoundImpls.Keys)
{
IClassNode n = null;
builder.BoundImpls.TryGetValue(cn, out n);
if (n != null)
{
Bind(cn.GetFullName(), n.GetFullName());
}
}
foreach (IClassNode cn in builder.BoundConstructors.Keys)
{
IClassNode n = null;
builder.BoundConstructors.TryGetValue(cn, out n);
if (n != null)
{
Bind(cn.GetFullName(), n.GetFullName());
}
}
// The namedParameters set contains the strings that can be used to
// instantiate new
// named parameter instances. Create new ones where we can.
foreach (INamedParameterNode np in builder.NamedParameters.Keys)
{
string v = null;
builder.NamedParameters.TryGetValue(np, out v);
Bind(np.GetFullName(), v);
}
foreach (IClassNode cn in builder.LegacyConstructors.Keys)
{
IConstructorDef cd = null;
builder.LegacyConstructors.TryGetValue(cn, out cd);
//RegisterLegacyConstructor(cn, cd.GetArgs()); TODO
}
//for (Entry<NamedParameterNode<Set<?>>, Object> e: builder.boundSetEntries) {
// String name = ((NamedParameterNode<Set<T>>)(NamedParameterNode<?>)e.getKey()).getFullName();
// if(e.getValue() instanceof Node) {
// bindSetEntry(name, (Node)e.getValue());
// } else if(e.getValue() instanceof String) {
// bindSetEntry(name, (String)e.getValue());
// } else {
// throw new IllegalStateException();
// }
//}
}
public static void GenerateClassHierarchy(ISet <string> clrDlls)
{
using (LOGGER.LogFunction("ClrHandlerHelper::GenerateClassHierarchy"))
{
IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(clrDlls.ToArray());
ProtocolBufferClassHierarchy.Serialize(Constants.ClassHierarchyBin, ns);
LOGGER.Log(Level.Info, "Class hierarchy written to [{0}].", Path.Combine(Directory.GetCurrentDirectory(), Constants.ClassHierarchyBin));
}
}
public ConfigurationBuilderImpl(ConfigurationBuilderImpl t)
{
this.ClassHierarchy = t.GetClassHierarchy();
try {
AddConfiguration(t.GetClassHierarchy(), t);
}
catch (BindException e)
{
throw new IllegalStateException("Could not copy builder", e);
}
}
public static InjectionPlan DeSerialize(string fileName, IClassHierarchy ch)
{
InjectionPlanProto.InjectionPlan protoPlan;
using (var file = File.OpenRead(fileName))
{
protoPlan = Serializer.Deserialize<InjectionPlanProto.InjectionPlan>(file);
}
return Deserialize(ch, protoPlan);
}
public static InjectionPlan DeSerialize(string fileName, IClassHierarchy ch)
{
InjectionPlanProto.InjectionPlan protoPlan;
using (var file = File.OpenRead(fileName))
{
protoPlan = Serializer.Deserialize <InjectionPlanProto.InjectionPlan>(file);
}
return(Deserialize(ch, protoPlan));
}
public void TestGenericClass()
{
IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { typeof(Timer).Assembly.GetName().Name });
Type t = typeof(Timer);
IClassNode EventClassNode = (IClassNode)ns.GetNode(t.AssemblyQualifiedName);
ProtocolBufferClassHierarchy.Serialize("event.bin", ns);
IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize("event.bin");
IClassNode EventClassNode1 = (IClassNode)ns.GetNode(t.AssemblyQualifiedName);
Assert.AreEqual(EventClassNode.GetName(), EventClassNode1.GetName());
}
public ConfigurationBuilderImpl(ConfigurationBuilderImpl t)
{
this.ClassHierarchy = t.GetClassHierarchy();
try {
AddConfiguration(t.GetClassHierarchy(), t);
}
catch (BindException e)
{
throw new IllegalStateException("Could not copy builder", e);
}
}
public ConfigurationBuilderImpl(ConfigurationBuilderImpl t)
{
this.ClassHierarchy = t.GetClassHierarchy();
try {
AddConfiguration(t.GetClassHierarchy(), t);
}
catch (BindException e)
{
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Could not copy builder", e), LOGGER);
}
}
public ConfigurationBuilderImpl(ConfigurationBuilderImpl t)
{
this.ClassHierarchy = t.GetClassHierarchy();
try {
AddConfiguration(t.GetClassHierarchy(), t);
}
catch (BindException e)
{
Org.Apache.Reef.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
Org.Apache.Reef.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Could not copy builder", e), LOGGER);
}
}
public static InjectionPlan Deserialize(IClassHierarchy ch, InjectionPlanProto.InjectionPlan ip)
{
string fullName = ip.name;
if (ip.constructor != null)
{
InjectionPlanProto.Constructor cons = ip.constructor;
IClassNode cn = (IClassNode)ch.GetNode(fullName);
InjectionPlanProto.InjectionPlan[] protoBufArgs = cons.args.ToArray();
INode[] cnArgs = new INode[protoBufArgs.Length];
for (int i = 0; i < protoBufArgs.Length; i++)
{
cnArgs[i] = (INode)ch.GetNode(protoBufArgs[i].name);
}
InjectionPlan[] ipArgs = new InjectionPlan[protoBufArgs.Length];
for (int i = 0; i < protoBufArgs.Length; i++)
{
ipArgs[i] = (InjectionPlan)Deserialize(ch, protoBufArgs[i]);
}
IConstructorDef constructor = cn.GetConstructorDef(cnArgs);
return(new Constructor(cn, constructor, ipArgs));
}
else if (ip.instance != null)
{
InjectionPlanProto.Instance ins = ip.instance;
object instance = Parse(ip.name, ins.value);
return(new CsInstance(ch.GetNode(ip.name), instance));
}
else if (ip.subplan != null)
{
InjectionPlanProto.Subplan subplan = ip.subplan;
InjectionPlanProto.InjectionPlan[] protoBufPlans = subplan.plans.ToArray();
InjectionPlan[] subPlans = new InjectionPlan[protoBufPlans.Length];
for (int i = 0; i < protoBufPlans.Length; i++)
{
subPlans[i] = (InjectionPlan)Deserialize(ch, protoBufPlans[i]);
}
INode n = ch.GetNode(fullName);
return(new Subplan(n, subPlans));
}
else
{
throw new IllegalStateException("Encountered unknown type of injection plan: " + ip);
}
}
/// <summary>
/// This program generates class hierarchy bin file for the list of dlls, plus a defalut list
/// The default list include: ITask, StreamTask1, HelloTask and ShellTask, please remove if not needed
/// </summary>
/// <param name="args"> additional dlls needed to build class hierarchy </param>
public static void Main(string[] args)
{
const string DllSubfix = ".dll";
const string ClassHierarchyBinFileName = "task.bin";
List <string> taskDlls = new List <string>();
foreach (string arg in args)
{
string assemblyName = arg;
if (!arg.EndsWith(DllSubfix, StringComparison.OrdinalIgnoreCase))
{
assemblyName += DllSubfix;
}
if (!File.Exists(assemblyName))
{
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "invalid argument: assembly {0} cannot be found", assemblyName));
}
taskDlls.Add(arg);
}
taskDlls.Add(GetAssemblyName(typeof(ITask)));
taskDlls.Add(GetAssemblyName(typeof(HelloTask)));
taskDlls.Add(GetAssemblyName(typeof(ShellTask)));
taskDlls.Add(GetAssemblyName(typeof(StreamTask1)));
IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(taskDlls.ToArray());
// the following is verification only
// to verify that a class indeeded has been added to the class hierarchy, check the class name
IClassNode streamTaskClassNode = (IClassNode)ns.GetNode(typeof(StreamTask1).AssemblyQualifiedName);
IClassNode helloTaskClassNode = (IClassNode)ns.GetNode(typeof(HelloTask).AssemblyQualifiedName);
IClassNode shellTaskClassNode = (IClassNode)ns.GetNode(typeof(ShellTask).AssemblyQualifiedName);
ProtocolBufferClassHierarchy.Serialize(ClassHierarchyBinFileName, ns);
IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize(ClassHierarchyBinFileName);
IClassNode retrievedStreamTaskClassNode = (IClassNode)ch.GetNode(typeof(StreamTask1).AssemblyQualifiedName);
IClassNode retrievedHelloTaskClassNode = (IClassNode)ch.GetNode(typeof(HelloTask).AssemblyQualifiedName);
IClassNode retrievedShellTaskClassNode = (IClassNode)ch.GetNode(typeof(ShellTask).AssemblyQualifiedName);
if (!streamTaskClassNode.GetFullName().Equals(retrievedStreamTaskClassNode.GetFullName()) ||
!helloTaskClassNode.GetFullName().Equals(retrievedHelloTaskClassNode.GetFullName()) ||
!shellTaskClassNode.GetFullName().Equals(retrievedShellTaskClassNode.GetFullName()))
{
Console.WriteLine("Node deseriliazed is not equal");
}
else
{
Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "Class hierarchy written to [{0}].", Directory.GetCurrentDirectory()));
}
}
protected ConfigurationBuilderImpl(string[] assemblies, IConfiguration[] confs, Type[] parsers)
{
this.ClassHierarchy = TangFactory.GetTang().GetDefaultClassHierarchy(assemblies, parsers);
foreach (IConfiguration tc in confs)
{
if (tc == null)
{
throw new ArgumentNullException("One of specified configurations is null");
}
AddConfiguration((ConfigurationImpl)tc);
}
}
protected ConfigurationBuilderImpl(string[] assemblies, IConfiguration[] confs, Type[] parsers)
{
this.ClassHierarchy = TangFactory.GetTang().GetDefaultClassHierarchy(assemblies, parsers);
foreach (IConfiguration tc in confs)
{
if (tc == null)
{
throw new ArgumentNullException("One of specified configurations is null");
}
AddConfiguration((ConfigurationImpl)tc);
}
}
public static InjectionPlan Deserialize(IClassHierarchy ch, InjectionPlanProto.InjectionPlan ip)
{
string fullName = ip.name;
if (ip.constructor != null)
{
InjectionPlanProto.Constructor cons = ip.constructor;
IClassNode cn = (IClassNode) ch.GetNode(fullName);
InjectionPlanProto.InjectionPlan[] protoBufArgs = cons.args.ToArray();
INode[] cnArgs = new INode[protoBufArgs.Length];
for (int i = 0; i < protoBufArgs.Length; i++)
{
cnArgs[i] = (INode) ch.GetNode(protoBufArgs[i].name);
}
InjectionPlan[] ipArgs = new InjectionPlan[protoBufArgs.Length];
for (int i = 0; i < protoBufArgs.Length; i++)
{
ipArgs[i] = (InjectionPlan) Deserialize(ch, protoBufArgs[i]);
}
IConstructorDef constructor = cn.GetConstructorDef(cnArgs);
return new Constructor(cn, constructor, ipArgs);
}
else if (ip.instance != null)
{
InjectionPlanProto.Instance ins = ip.instance;
object instance = Parse(ip.name, ins.value);
return new CsInstance(ch.GetNode(ip.name), instance);
}
else if (ip.subplan != null)
{
InjectionPlanProto.Subplan subplan = ip.subplan;
InjectionPlanProto.InjectionPlan[] protoBufPlans = subplan.plans.ToArray();
InjectionPlan[] subPlans = new InjectionPlan[protoBufPlans.Length];
for (int i = 0; i < protoBufPlans.Length; i++)
{
subPlans[i] = (InjectionPlan) Deserialize(ch, protoBufPlans[i]);
}
INode n = ch.GetNode(fullName);
return new Subplan(n, subPlans);
}
else
{
throw new IllegalStateException("Encountered unknown type of injection plan: " + ip);
}
}
public IClassHierarchy Merge(IClassHierarchy ch)
{
if (this == ch)
{
return(this);
}
if (!(ch is ProtocolBufferClassHierarchy))
{
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new NotSupportedException(
"Cannot merge ExternalClassHierarchies yet!"), LOGGER);
}
ProtocolBufferClassHierarchy pch = (ProtocolBufferClassHierarchy)ch;
foreach (var pair in pch.lookupTable)
{
if (!this.lookupTable.ContainsKey(pair.Key))
{
this.lookupTable.Add(pair);
}
}
foreach (INode n in ch.GetNamespace().GetChildren())
{
if (!rootNode.Contains(n.GetFullName()))
{
if (n is INamedParameterNode)
{
INamedParameterNode np = (INamedParameterNode)n;
new NamedParameterNodeImpl(this.rootNode, np.GetName(),
np.GetFullName(), np.GetFullArgName(), np.GetSimpleArgName(),
np.IsSet(), np.IsList(), np.GetDocumentation(), np.GetShortName(),
np.GetDefaultInstanceAsStrings().ToArray());
}
else if (n is IClassNode)
{
IClassNode cn = (IClassNode)n;
new ClassNodeImpl(rootNode, cn.GetName(), cn.GetFullName(),
cn.IsUnit(), cn.IsInjectionCandidate(),
cn.IsExternalConstructor(), cn.GetInjectableConstructors(),
cn.GetAllConstructors(), cn.GetDefaultImplementation());
}
}
}
return(this);
}
/// <summary>
/// Serialize a ClassHierarchy into a file
/// </summary>
/// <param name="c"></param>
/// <param name="fileName"></param>
public void ToFile(IClassHierarchy c, string fileName)
{
var avronNodeData = ToAvroNode(c);
using (var buffer = new MemoryStream())
{
using (var w = AvroContainer.CreateWriter<AvroNode>(buffer, Codec.Null))
{
using (var writer = new SequentialWriter<AvroNode>(w, 24))
{
writer.Write(avronNodeData);
}
}
if (!WriteFile(buffer, fileName))
{
var e = new ApplicationException("Error during file operation. Quitting method: " + fileName);
Utilities.Diagnostics.Exceptions.Throw(e, LOGGER);
}
}
}
public IClassHierarchy Merge(IClassHierarchy ch)
{
if (this.assemblies.Count == 0)
{
return ch;
}
return ch;//TODO
}
public static Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan DeSerialize(string fileName, IClassHierarchy ch)
{
Org.Apache.REEF.Tang.Protobuf.InjectionPlan protoPlan;
using (var file = File.OpenRead(fileName))
{
protoPlan = Serializer.Deserialize<Org.Apache.REEF.Tang.Protobuf.InjectionPlan>(file);
}
return Deserialize(ch, protoPlan);
}
public IConfiguration FromFile(string fileName, IClassHierarchy classHierarchy)
{
AvroConfiguration avroConf = AvroDeserializeFromFile(fileName);
return FromAvro(avroConf, classHierarchy);
}
public IConfiguration FromString(string josonString, IClassHierarchy ch)
{
AvroConfiguration avroConf = JsonConvert.DeserializeObject<AvroConfiguration>(josonString);
return FromAvro(avroConf, ch);
}
protected ConfigurationBuilderImpl()
{
this.ClassHierarchy = TangFactory.GetTang().GetDefaultClassHierarchy();
}
public ConfigurationBuilderImpl(IClassHierarchy classHierarchy)
{
this.ClassHierarchy = classHierarchy;
}
/// <summary>
/// Merge two Class Hierarchy
/// </summary>
/// <param name="ch"></param>
/// <returns></returns>
public IClassHierarchy Merge(IClassHierarchy ch)
{
if (this == ch)
{
return this;
}
if (!(ch is AvroClassHierarchy))
{
Utilities.Diagnostics.Exceptions.Throw(new NotSupportedException(
"Cannot merge ExternalClassHierarchies yet!"), LOGGER);
}
AvroClassHierarchy ach = (AvroClassHierarchy)ch;
foreach (var pair in ach._lookupTable)
{
if (!this._lookupTable.ContainsKey(pair.Key))
{
this._lookupTable.Add(pair);
}
}
foreach (INode n in ch.GetNamespace().GetChildren())
{
if (!_rootNode.Contains(n.GetFullName()))
{
if (n is INamedParameterNode)
{
INamedParameterNode np = (INamedParameterNode)n;
new NamedParameterNodeImpl(this._rootNode, np.GetName(),
np.GetFullName(), np.GetFullArgName(), np.GetSimpleArgName(),
np.IsSet(), np.IsList(), np.GetDocumentation(), np.GetShortName(),
np.GetDefaultInstanceAsStrings().ToArray());
}
else if (n is IClassNode)
{
IClassNode cn = (IClassNode)n;
new ClassNodeImpl(_rootNode, cn.GetName(), cn.GetFullName(),
cn.IsUnit(), cn.IsInjectionCandidate(),
cn.IsExternalConstructor(), cn.GetInjectableConstructors(),
cn.GetAllConstructors(), cn.GetDefaultImplementation());
}
}
}
return this;
}
public static Node Serialize(IClassHierarchy classHierarchy)
{
return SerializeNode(classHierarchy.GetNamespace());
}
public IClassHierarchy Merge(IClassHierarchy ch)
{
if (this == ch)
{
return this;
}
if (!(ch is ClassHierarchyImpl))
{
Utilities.Diagnostics.Exceptions.Throw(new NotSupportedException("Can't merge java and non-java class hierarchies yet!"), LOGGER);
}
if (this.assemblies.Count == 0)
{
return ch;
}
lock (_mergeLock)
{
ClassHierarchyImpl chi = (ClassHierarchyImpl)ch;
MonotonicHashSet<string> otherJars = new MonotonicHashSet<string>();
otherJars.AddAll(chi.assemblies);
MonotonicHashSet<string> myJars = new MonotonicHashSet<string>();
myJars.AddAll(this.assemblies);
if (myJars.ContainsAll(otherJars))
{
return this;
}
if (otherJars.ContainsAll(myJars))
{
return ch;
}
myJars.Union(otherJars);
return new ClassHierarchyImpl(myJars.ToArray());
}
}
public IConfiguration FromAvro(AvroConfiguration avroConfiguration, IClassHierarchy classHierarchy)
{
IConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder(classHierarchy);
return AddFromAvro(cb, avroConfiguration);
}
/// <summary>
/// Serialize a ClassHierarchy into a text file as Json string
/// </summary>
/// <param name="c"></param>
/// <param name="fileName"></param>
public void ToTextFile(IClassHierarchy c, string fileName)
{
using (FileStream fs = File.Open(fileName, FileMode.Create))
{
var fp = new StreamWriter(fs);
fp.WriteLine(ToString(c));
fp.Dispose();
}
}
private void AddConfiguration(IClassHierarchy ns, ConfigurationBuilderImpl builder)
{
this.ClassHierarchy = this.ClassHierarchy.Merge(ns);
//TODO
//((ClassHierarchyImpl) ClassHierarchy).parameterParser
// .mergeIn(((ClassHierarchyImpl) namespace).parameterParser);
foreach (IClassNode cn in builder.BoundImpls.Keys)
{
IClassNode n = null;
builder.BoundImpls.TryGetValue(cn, out n);
if (n != null)
{
Bind(cn.GetFullName(), n.GetFullName());
}
}
foreach (IClassNode cn in builder.BoundConstructors.Keys)
{
IClassNode n = null;
builder.BoundConstructors.TryGetValue(cn, out n);
if (n != null)
{
Bind(cn.GetFullName(), n.GetFullName());
}
}
// The namedParameters set contains the strings that can be used to
// instantiate new
// named parameter instances. Create new ones where we can.
foreach (INamedParameterNode np in builder.NamedParameters.Keys)
{
string v = null;
builder.NamedParameters.TryGetValue(np, out v);
Bind(np.GetFullName(), v);
}
foreach (IClassNode cn in builder.LegacyConstructors.Keys)
{
IConstructorDef cd = null;
builder.LegacyConstructors.TryGetValue(cn, out cd);
//RegisterLegacyConstructor(cn, cd.GetArgs()); TODO
}
//for (Entry<NamedParameterNode<Set<?>>, Object> e: builder.boundSetEntries) {
// String name = ((NamedParameterNode<Set<T>>)(NamedParameterNode<?>)e.getKey()).getFullName();
// if(e.getValue() instanceof Node) {
// bindSetEntry(name, (Node)e.getValue());
// } else if(e.getValue() instanceof String) {
// bindSetEntry(name, (String)e.getValue());
// } else {
// throw new IllegalStateException();
// }
//}
}
public static Org.Apache.REEF.Tang.Protobuf.Node Serialize(IClassHierarchy classHierarchy)
{
return SerializeNode(classHierarchy.GetNamespace());
}
/// <summary>
/// erialize a ClassHierarchy into a byte array
/// </summary>
/// <param name="c"></param>
/// <returns></returns>
public byte[] ToByteArray(IClassHierarchy c)
{
AvroNode obj = ToAvroNode(c);
return AvroSerialize(obj);
}
/// <summary>
/// Serialize a ClassHierarchy into a Json string
/// </summary>
/// <param name="c"></param>
/// <returns></returns>
public string ToString(IClassHierarchy c)
{
AvroNode obj = ToAvroNode(c);
string s = JsonConvert.SerializeObject(obj, Formatting.Indented);
return s;
}
/// <summary>
/// Serialize a ClassHierarchy into AvroNode object
/// </summary>
/// <param name="ch"></param>
/// <returns></returns>
public AvroNode ToAvroNode(IClassHierarchy ch)
{
return NewAvroNode(ch.GetNamespace());
}
private void AddConfiguration(IClassHierarchy ns, ConfigurationBuilderImpl builder)
{
this.ClassHierarchy = this.ClassHierarchy.Merge(ns);
if (ClassHierarchy is ClassHierarchyImpl || builder.ClassHierarchy is ClassHierarchyImpl)
{
if (ClassHierarchy is ClassHierarchyImpl && builder.ClassHierarchy is ClassHierarchyImpl)
{
((ClassHierarchyImpl)ClassHierarchy).Parameterparser.MergeIn(((ClassHierarchyImpl)builder.ClassHierarchy).Parameterparser);
}
else
{
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new ArgumentException("Attempt to merge Java and non-Java class hierarchy! Not supported."), LOGGER);
}
}
foreach (IClassNode cn in builder.BoundImpls.Keys)
{
IClassNode n = null;
builder.BoundImpls.TryGetValue(cn, out n);
if (n != null)
{
Bind(cn.GetFullName(), n.GetFullName());
}
}
foreach (IClassNode cn in builder.BoundConstructors.Keys)
{
IClassNode n = null;
builder.BoundConstructors.TryGetValue(cn, out n);
if (n != null)
{
Bind(cn.GetFullName(), n.GetFullName());
}
}
// The namedParameters set contains the strings that can be used to
// instantiate new
// named parameter instances. Create new ones where we can.
foreach (INamedParameterNode np in builder.NamedParameters.Keys)
{
string v = null;
builder.NamedParameters.TryGetValue(np, out v);
Bind(np.GetFullName(), v);
}
foreach (IClassNode cn in builder.LegacyConstructors.Keys)
{
IConstructorDef cd = null;
builder.LegacyConstructors.TryGetValue(cn, out cd);
RegisterLegacyConstructor(cn, cd.GetArgs());
}
foreach (KeyValuePair<INamedParameterNode, object> e in builder.BoundSetEntries)
{
string name = ((INamedParameterNode)e.Key).GetFullName();
if (e.Value is INode)
{
BindSetEntry(name, (INode)e.Value);
}
else if (e.Value is string)
{
BindSetEntry(name, (string)e.Value);
}
else
{
var ex = new IllegalStateException(string.Format(CultureInfo.CurrentCulture, "The value {0} set to the named parameter {1} is illegel.", e.Value, name));
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER);
}
}
foreach (var p in builder.BoundLists)
{
BoundLists.Add(p.Key, p.Value);
}
}
/// <summary>
/// Serialize a ClassHierarchy into a text file as Json string
/// </summary>
/// <param name="c"></param>
/// <param name="fileName"></param>
public void ToTextFile(IClassHierarchy c, string fileName)
{
var fp = new StreamWriter(fileName);
fp.WriteLine(ToString(c));
fp.Close();
}
public IConfigurationBuilder NewConfigurationBuilder(IClassHierarchy classHierarchy)
{
return new ConfigurationBuilderImpl(classHierarchy);
}
public static void ClassSetup(TestContext context)
{
ns = TangFactory.GetTang().GetClassHierarchy(new string[] {file, file2, file3});
//ns = new ClassHierarchyImpl(@"Com.Microsoft.Tang.Examples.dll");
}
public static Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan Deserialize(IClassHierarchy ch, Org.Apache.REEF.Tang.Protobuf.InjectionPlan ip)
{
string fullName = ip.name;
if (ip.constructor != null)
{
Org.Apache.REEF.Tang.Protobuf.Constructor cons = ip.constructor;
IClassNode cn = (IClassNode) ch.GetNode(fullName);
Org.Apache.REEF.Tang.Protobuf.InjectionPlan[] protoBufArgs = cons.args.ToArray();
IClassNode[] cnArgs = new IClassNode[protoBufArgs.Length];
for (int i = 0; i < protoBufArgs.Length; i++)
{
INode no = ch.GetNode(protoBufArgs[i].name);
if (no is IClassNode)
{
cnArgs[i] = (IClassNode)no;
}
else if (no is INamedParameterNode)
{
INamedParameterNode np = (INamedParameterNode)no;
cnArgs[i] = (IClassNode)ch.GetNode(np.GetFullArgName());
}
}
Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan[] ipArgs = new Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan[protoBufArgs.Length];
for (int i = 0; i < protoBufArgs.Length; i++)
{
ipArgs[i] = (Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan)Deserialize(ch, protoBufArgs[i]);
}
IConstructorDef constructor = cn.GetConstructorDef(cnArgs);
return new Org.Apache.REEF.Tang.Implementations.InjectionPlan.Constructor(cn, constructor, ipArgs);
}
if (ip.instance != null)
{
Org.Apache.REEF.Tang.Protobuf.Instance ins = ip.instance;
object instance = Parse(ip.name, ins.value);
return new CsInstance(ch.GetNode(ip.name), instance);
}
if (ip.subplan != null)
{
Org.Apache.REEF.Tang.Protobuf.Subplan subplan = ip.subplan;
Org.Apache.REEF.Tang.Protobuf.InjectionPlan[] protoBufPlans = subplan.plans.ToArray();
Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan[] subPlans = new Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan[protoBufPlans.Length];
for (int i = 0; i < protoBufPlans.Length; i++)
{
subPlans[i] = (Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan)Deserialize(ch, protoBufPlans[i]);
}
INode n = ch.GetNode(fullName);
return new Org.Apache.REEF.Tang.Implementations.InjectionPlan.Subplan(n, subPlans);
}
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Encountered unknown type of InjectionPlan: " + ip), LOGGER);
return null;
}
