protected virtual CodeTypeDeclaration GetStateClass(
GrainInterfaceData grainInterfaceData,
Action <Type> referred,
string stateClassBaseName,
string stateClassName,
out bool hasStateClass)
{
var sourceType = grainInterfaceData.Type;
stateClassName = FixupTypeName(stateClassName);
CodeTypeParameterCollection genericTypeParams = grainInterfaceData.GenericTypeParams;
Func <Type, bool> nonamespace = t => CurrentNamespace == t.Namespace || ReferencedNamespaces.Contains(t.Namespace);
Type persistentInterface = GetPersistentInterface(sourceType);
if (persistentInterface != null)
{
if (!persistentInterface.IsInterface)
{
hasStateClass = false;
return(null);
}
else
{
ConsoleText.WriteError(String.Format("Warning: Usage of grain state interfaces as type arguments for Grain<T> has been deprecated. " +
"Define an equivalent class with automatic properties instead of the state interface for {0}.", sourceType.FullName));
}
}
Dictionary <string, PropertyInfo> asyncProperties = GrainInterfaceData.GetPersistentProperties(persistentInterface)
.ToDictionary(p => p.Name.Substring(p.Name.LastIndexOf('.') + 1), p => p);
Dictionary <string, string> properties = asyncProperties.ToDictionary(p => p.Key,
p => GetGenericTypeName(GrainInterfaceData.GetPromptType(p.Value.PropertyType), referred, nonamespace));
var stateClass = new CodeTypeDeclaration(stateClassBaseName);
if (genericTypeParams != null)
{
stateClass.TypeParameters.AddRange(genericTypeParams);
}
stateClass.IsClass = true;
if (persistentInterface != null)
{
stateClass.TypeAttributes = persistentInterface.IsPublic ? TypeAttributes.Public : TypeAttributes.NotPublic;
}
else
{
stateClass.TypeAttributes = TypeAttributes.Public;
}
stateClass.BaseTypes.Add(new CodeTypeReference(typeof(GrainState), CodeTypeReferenceOptions.GlobalReference));
MarkAsGeneratedCode(stateClass);
referred(typeof(GrainState));
if (persistentInterface != null)
{
stateClass.BaseTypes.Add(new CodeTypeReference(GetGenericTypeName(persistentInterface, referred, nonamespace)));
}
stateClass.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(SerializableAttribute).Name));
stateClass.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(GrainStateAttribute), CodeTypeReferenceOptions.GlobalReference),
new CodeAttributeArgument(new CodePrimitiveExpression(grainInterfaceData.Type.Namespace + "." + TypeUtils.GetParameterizedTemplateName(grainInterfaceData.Type, language: language)))));
referred(typeof(SerializableAttribute));
referred(typeof(OnDeserializedAttribute));
var initStateFields = new CodeMemberMethod {
Name = "InitStateFields"
};
initStateFields.Attributes = (initStateFields.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Private;
foreach (var peoperty in asyncProperties)
{
Type propertyType = peoperty.Value.PropertyType;
bool noCreateNew = propertyType.IsPrimitive || typeof(string).IsAssignableFrom(propertyType) || // Primative types
propertyType.IsAbstract || propertyType.IsInterface || propertyType.IsGenericParameter || // No concrete implementation
propertyType.GetConstructor(Type.EmptyTypes) == null; // No default constructor
var initExpression = noCreateNew // Pre-initialize this type to default value
? (CodeExpression) new CodeDefaultValueExpression(new CodeTypeReference(GetGenericTypeName(propertyType, referred, nonamespace)))
: new CodeObjectCreateExpression(new CodeTypeReference(GetGenericTypeName(propertyType, referred, nonamespace)));
initStateFields.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), peoperty.Key),
initExpression));
}
hasStateClass = properties.Count > 0;
if (hasStateClass)
{
foreach (var pair in properties)
{
GenerateStateClassProperty(stateClass, asyncProperties[pair.Key], pair.Key, pair.Value);
}
var returnType = new CodeTypeReference("System.Collections.Generic.IDictionary",
new CodeTypeReference(typeof(string)), new CodeTypeReference(typeof(object)));
var concreteType = new CodeTypeReference("System.Collections.Generic.Dictionary",
new CodeTypeReference(typeof(string)), new CodeTypeReference(typeof(object)));
var asDictionary = new CodeMemberMethod
{
Name = "AsDictionary",
Attributes = MemberAttributes.Public | MemberAttributes.Override,
ReturnType = returnType
};
asDictionary.Statements.Add(new CodeVariableDeclarationStatement(concreteType, "result", new CodeObjectCreateExpression(concreteType)));
foreach (var pair in properties)
{
asDictionary.Statements.Add(new CodeAssignStatement(
new CodeIndexerExpression(new CodeVariableReferenceExpression("result"), new CodePrimitiveExpression(pair.Key)),
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), pair.Key)));
}
asDictionary.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("result")));
stateClass.Members.Add(asDictionary);
GenerateSetAll(stateClass, properties);
GenerateToString(stateClass, stateClassName, properties);
}
// Copier, serializer, and deserializer for the state class
var copier = SerializerGenerationUtilities.GenerateCopier("_Copier", stateClassName, genericTypeParams);
var serializer = SerializerGenerationUtilities.GenerateSerializer("_Serializer", stateClassName, genericTypeParams);
var deserializer = SerializerGenerationUtilities.GenerateDeserializer("_Deserializer", stateClassName, genericTypeParams);
var ctor = new CodeConstructor {
Attributes = (copier.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public
};
ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(TypeUtils.GetFullName(grainInterfaceData.Type, language)));
ctor.Statements.Add(new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
"InitStateFields"));
copier.Statements.Add(new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("input"), "DeepCopy")));
serializer.Statements.Add(
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("input"),
"SerializeTo", new CodeArgumentReferenceExpression("stream")));
deserializer.Statements.Add(new CodeVariableDeclarationStatement(stateClassName, "result",
new CodeObjectCreateExpression(stateClassName)));
deserializer.Statements.Add(new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("result"),
"DeserializeFrom",
new CodeArgumentReferenceExpression("stream")));
deserializer.Statements.Add(new CodeMethodReturnStatement(
new CodeVariableReferenceExpression("result")));
stateClass.Members.Add(ctor);
stateClass.Members.Add(initStateFields);
stateClass.Members.Add(copier);
stateClass.Members.Add(serializer);
stateClass.Members.Add(deserializer);
return(stateClass);
}
internal bool OnKey(ConsoleKeyInfo arg, ConsoleText line, ref int cursorIndex)
{
bool resetMap = true;
bool resetCompletion = true;
try
{
bool hasShift = (arg.Modifiers & ConsoleModifiers.Shift) != 0;
// For now, we discard SHIFT entirely, as it is handled separately for range selection
// TODO: we should handle them not differently from ctrl/alt, but it's complicated
arg = new ConsoleKeyInfo(arg.KeyChar, arg.Key, false, (arg.Modifiers & ConsoleModifiers.Alt) != 0, (arg.Modifiers & ConsoleModifiers.Control) != 0);
KalkConsoleKey kalkKey = arg;
if (cursorIndex >= 0 && cursorIndex <= line.Count)
{
if (_currentShortcutKeyMap.TryGetValue(kalkKey, out var value))
{
if (value is KalkShortcutKeyMap map)
{
_currentShortcutKeyMap = map;
resetMap = false; // we don't reset if
}
else
{
var expression = (ScriptExpression)value;
var result = EvaluateExpression(expression);
if (result is KalkActionObject command)
{
// Particular case the completion action, we handle it here
if (command.Action == "completion")
{
// In case of shift we go backward
if (OnCompletionRequested(hasShift, line, ref cursorIndex))
{
resetCompletion = false;
return(true);
}
}
else if (OnAction != null)
{
command.Call(OnAction);
}
}
else if (result != null)
{
var resultStr = ObjectToString(result);
line.Insert(cursorIndex, resultStr);
cursorIndex += resultStr.Length;
}
}
return(true);
}
}
}
finally
{
if (resetMap)
{
// Restore the root key map in case of an error.
_currentShortcutKeyMap = Shortcuts.ShortcutKeyMap;
}
if (resetCompletion)
{
ResetCompletion();
}
}
return(false);
}
public void SetCheckpoint(Vector3 position)
{
currentCheckpointPosition = position;
ConsoleText.getInstance().ShowMessage("Checkpoint Reached!");
player.ResetEnergy();
}
/// <summary>
/// Generate all the necessary logic for serialization of payload types used by grain interfaces.
/// </summary>
internal static void GenerateSerializationForClass(Assembly grainAssembly, Type t, CodeNamespace container, HashSet <string> referencedNamespaces, Language language)
{
var generateSerializers = !CheckForCustomSerialization(t);
var generateCopier = !CheckForCustomCopier(t);
if (!generateSerializers && !generateCopier)
{
return; // If the class declares all custom implementations, then we don't need to do anything...
}
bool notVB = (language != Language.VisualBasic);
var openGenerics = notVB ? "<" : "(Of ";
var closeGenerics = notVB ? ">" : ")";
// Add the class's namespace to this namespace's imports, as well as some other imports we use
container.Imports.Add(new CodeNamespaceImport("System"));
container.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
container.Imports.Add(new CodeNamespaceImport("System.Reflection"));
container.Imports.Add(new CodeNamespaceImport("Orleans.Serialization"));
if (!string.IsNullOrEmpty(t.Namespace))
{
container.Imports.Add(new CodeNamespaceImport(t.Namespace));
}
// Create the class declaration, including any required generic parameters
// At one time this was a struct, not a class, so all the variable names are "structFoo". Too bad.
// Note that we need to replace any periods in the type name with _ to properly handle nested classes
var className = TypeUtils.GetSimpleTypeName(TypeUtils.GetFullName(t));
var serializationClassName = className.Replace('.', '_') + SERIALIZER_CLASS_NAME_SUFFIX;
var serializationClassOpenName = serializationClassName;
var classDecl = new CodeTypeDeclaration(serializationClassName)
{
IsClass = true
};
classDecl.Attributes = (classDecl.Attributes & ~MemberAttributes.ScopeMask) | MemberAttributes.Static;
classDecl.TypeAttributes = TypeAttributes.NotPublic;
CodeGeneratorBase.MarkAsGeneratedCode(classDecl);
if (!t.IsGenericType)
{
classDecl.CustomAttributes.Add(
new CodeAttributeDeclaration(new CodeTypeReference(typeof(RegisterSerializerAttribute),
CodeTypeReferenceOptions.GlobalReference)));
}
if (t.IsGenericType)
{
className += openGenerics;
serializationClassOpenName += openGenerics;
bool first = true;
foreach (var genericParameter in t.GetGenericTypeDefinition().GetGenericArguments())
{
var param = new CodeTypeParameter(genericParameter.Name);
if ((genericParameter.GenericParameterAttributes & GenericParameterAttributes.ReferenceTypeConstraint) != GenericParameterAttributes.None)
{
param.Constraints.Add(" class");
}
if ((genericParameter.GenericParameterAttributes & GenericParameterAttributes.NotNullableValueTypeConstraint) != GenericParameterAttributes.None)
{
param.Constraints.Add(" struct");
}
var constraints = genericParameter.GetGenericParameterConstraints();
foreach (var constraintType in constraints)
{
param.Constraints.Add(new CodeTypeReference(TypeUtils.GetParameterizedTemplateName(constraintType)));
}
if ((genericParameter.GenericParameterAttributes & GenericParameterAttributes.DefaultConstructorConstraint) != GenericParameterAttributes.None)
{
param.HasConstructorConstraint = true;
}
classDecl.TypeParameters.Add(param);
if (!first)
{
className += ", ";
serializationClassOpenName += ",";
}
className += genericParameter.Name;
first = false;
}
className += closeGenerics;
serializationClassOpenName += closeGenerics;
}
// A couple of repeatedly-used CodeDom snippets
var classType = new CodeTypeOfExpression(className);
var classTypeReference = new CodeTypeReference(className);
var objectTypeReference = new CodeTypeReference(typeof(object));
var serMgrRefExp = new CodeTypeReferenceExpression(typeof(SerializationManager));
var currentSerialzationContext = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(SerializationContext)), "Current");
// Static DeepCopyInner method:
var copier = new CodeMemberMethod();
if (generateCopier)
{
classDecl.Members.Add(copier);
}
copier.Attributes = (copier.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
copier.Attributes = (copier.Attributes & ~MemberAttributes.ScopeMask) | MemberAttributes.Static;
copier.Name = "DeepCopier";
copier.Parameters.Add(new CodeParameterDeclarationExpression(objectTypeReference, "original"));
bool shallowCopyable = t.IsOrleansShallowCopyable();
if (shallowCopyable)
{
copier.Statements.Add(new CodeMethodReturnStatement(new CodeArgumentReferenceExpression("original")));
}
else
{
copier.Statements.Add(new CodeVariableDeclarationStatement(classTypeReference, "input",
new CodeCastExpression(classTypeReference, new CodeArgumentReferenceExpression("original"))));
}
copier.ReturnType = objectTypeReference;
// Static serializer method:
var serializer = new CodeMemberMethod();
if (generateSerializers)
{
classDecl.Members.Add(serializer);
}
serializer.Attributes = (serializer.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
serializer.Attributes = (serializer.Attributes & ~MemberAttributes.ScopeMask) | MemberAttributes.Static;
serializer.Name = "Serializer";
serializer.Parameters.Add(new CodeParameterDeclarationExpression(objectTypeReference, "untypedInput"));
serializer.Parameters.Add(new CodeParameterDeclarationExpression(typeof(BinaryTokenStreamWriter), "stream"));
serializer.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Type), "expected"));
serializer.ReturnType = new CodeTypeReference(typeof(void));
serializer.Statements.Add(new CodeVariableDeclarationStatement(classTypeReference, "input",
new CodeCastExpression(classTypeReference, new CodeArgumentReferenceExpression("untypedInput"))));
// Static deserializer method; note that this will never get called for null values or back references
var deserializer = new CodeMemberMethod();
if (generateSerializers)
{
classDecl.Members.Add(deserializer);
}
deserializer.Attributes = (deserializer.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
deserializer.Attributes = (deserializer.Attributes & ~MemberAttributes.ScopeMask) | MemberAttributes.Static;
deserializer.Name = "Deserializer";
deserializer.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Type), "expected"));
deserializer.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(BinaryTokenStreamReader), CodeTypeReferenceOptions.GlobalReference), "stream"));
deserializer.ReturnType = objectTypeReference;
// Static constructor, which just calls the Init method
var staticConstructor = new CodeTypeConstructor();
classDecl.Members.Add(staticConstructor);
staticConstructor.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(null, "Register")));
// Init method, which registers the type with the serialization manager, and later may get some static FieldInfo initializers
var init = new CodeMemberMethod();
classDecl.Members.Add(init);
init.Name = "Register";
init.Attributes = (init.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
init.Attributes = (init.Attributes & ~MemberAttributes.ScopeMask) | MemberAttributes.Static;
if (generateCopier && generateSerializers)
{
init.Statements.Add(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(new CodeTypeReference(typeof(SerializationManager), CodeTypeReferenceOptions.GlobalReference)), "Register", classType,
new CodeMethodReferenceExpression(null, notVB ? "DeepCopier" : "AddressOf DeepCopier"),
new CodeMethodReferenceExpression(null, notVB ? "Serializer" : "AddressOf Serializer"),
new CodeMethodReferenceExpression(null, notVB ? "Deserializer" : "AddressOf Deserializer")));
}
else if (generateCopier)
{
init.Statements.Add(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(new CodeTypeReference(typeof(SerializationManager), CodeTypeReferenceOptions.GlobalReference)), "Register", classType,
new CodeMethodReferenceExpression(null, notVB ? "DeepCopier" : "AddressOf DeepCopier"),
null,
null));
}
else
{
init.Statements.Add(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(new CodeTypeReference(typeof(SerializationManager), CodeTypeReferenceOptions.GlobalReference)), "Register", classType,
null,
new CodeMethodReferenceExpression(null, notVB ? "Serializer" : "AddressOf Serializer"),
new CodeMethodReferenceExpression(null, notVB ? "Deserializer" : "AddressOf Deserializer")));
}
CodeStatement constructor;
var consInfo = t.GetConstructor(Type.EmptyTypes);
if (consInfo != null)
{
if (!t.ContainsGenericParameters)
{
constructor = new CodeVariableDeclarationStatement(classTypeReference, "result", new CodeObjectCreateExpression(t));
}
else
{
var typeName = TypeUtils.GetParameterizedTemplateName(t, tt => tt.Namespace != container.Name && !referencedNamespaces.Contains(tt.Namespace), true);
if (language == Language.VisualBasic)
{
typeName = typeName.Replace("<", "(Of ").Replace(">", ")");
}
constructor = new CodeVariableDeclarationStatement(classTypeReference, "result",
new CodeObjectCreateExpression(typeName));
}
}
else if (t.IsValueType)
{
constructor = !t.ContainsGenericParameters
? new CodeVariableDeclarationStatement(classTypeReference, "result", new CodeDefaultValueExpression(new CodeTypeReference(t)))
: new CodeVariableDeclarationStatement(classTypeReference, "result", new CodeDefaultValueExpression(new CodeTypeReference(TypeUtils.GetTemplatedName(t))));
}
else
{
if (!t.ContainsGenericParameters)
{
constructor = new CodeVariableDeclarationStatement(classTypeReference, "result",
new CodeCastExpression(className, new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(System.Runtime.Serialization.FormatterServices)),
"GetUninitializedObject", new CodeTypeOfExpression(t))));
}
else
{
constructor = new CodeVariableDeclarationStatement(classTypeReference, "result",
new CodeCastExpression(className, new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(System.Runtime.Serialization.FormatterServices)),
"GetUninitializedObject", new CodeTypeOfExpression(TypeUtils.GetTemplatedName(t)))));
}
}
if (!shallowCopyable)
{
copier.Statements.Add(constructor);
copier.Statements.Add(new CodeMethodInvokeExpression(currentSerialzationContext, "RecordObject",
new CodeVariableReferenceExpression("original"),
new CodeVariableReferenceExpression("result")));
}
deserializer.Statements.Add(constructor);
// For structs, once we encounter a field that we have to use reflection to set, we need to switch to a boxed representation and reflection
// for the rest of the fields in the struct while setting. This flag indicates that we're in that mode.
bool usingBoxedReflection = false;
// For every field in the class:
int counter = 0;
List <FieldInfo> fields = GetAllFields(t).ToList();
fields.Sort(new FieldNameComparer());
foreach (var fld in fields)
{
if (fld.IsNotSerialized || fld.IsLiteral)
{
continue;
}
var fldType = fld.FieldType;
if (TypeUtilities.IsTypeIsInaccessibleForSerialization(fldType, t.Module, grainAssembly))
{
ConsoleText.WriteStatus("Skipping generation of serializer for {0} because one of it's field {1} is of a private/internal type {2}.", t.FullName, fld.Name, fldType);
return; // We cannot deserialize a class with a field of non-public type. Need to add a proper reporting here.
}
// Import the namespace for the field's type (and any of its parameters), just in case it's not already added
ImportFieldNamespaces(fld.FieldType, container.Imports);
SerializerGenerationManager.RecordTypeToGenerate(fld.FieldType);
counter++;
// Add the statements moving to and from a class instance, to the instance creation method and the non-default constructor
// Getter and setter for this field's value from a class object
CodeExpression getter = null;
SetterGenerator setter = null;
var name = fld.Name;
// Normalize the field name -- strip trailing @ (F#) and look for automatic properties
var normalizedName = name.TrimEnd('@');
if (name.StartsWith("<"))
{
// Backing field for an automatic property; see if it's public so we can use it
var propertyName = name.Substring(1, name.IndexOf('>') - 1).TrimEnd('@');
var property = t.GetProperty(propertyName);
// If the property is public and not hidden...
if ((property != null) && property.DeclaringType == fld.DeclaringType)
{
if (property.GetGetMethod() != null)
{
getter = new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("input"),
propertyName);
}
if (!usingBoxedReflection && (property.GetSetMethod() != null))
{
setter = value =>
{
var s = new CodeAssignStatement
{
Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("result"), propertyName),
Right = value
};
return(new CodeStatementCollection(new CodeStatement[] { s }));
};
}
}
}
var typeName = TypeUtils.GetTemplatedName(fld.FieldType, _ => !_.IsGenericParameter, language);
// See if it's a public field
if ((getter == null) || (setter == null))
{
if (fld.Attributes.HasFlag(FieldAttributes.Public))
{
if (getter == null)
{
getter = new CodeFieldReferenceExpression(new CodeArgumentReferenceExpression("input"), normalizedName);
}
if (!usingBoxedReflection && (setter == null) && !fld.IsInitOnly)
{
setter = value =>
{
var s = new CodeAssignStatement
{
Left = new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("result"), normalizedName),
Right = value
};
return(new CodeStatementCollection(new CodeStatement[] { s }));
};
}
}
}
// Have to use reflection
if ((getter == null) || (setter == null))
{
// Add a static field for the FieldInfo, and a static constructor
string infoName = "fieldInfo" + counter;
var info = new CodeMemberField(typeof(FieldInfo), infoName);
info.Attributes |= MemberAttributes.Private | MemberAttributes.Static;
classDecl.Members.Add(info);
CodeTypeOfExpression fieldAccessType;
if (fld.DeclaringType == t)
{
fieldAccessType = classType;
}
else
{
FieldInfo fld2 = t.GetField(fld.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if ((fld2 != null) && fld2.DeclaringType == fld.DeclaringType)
{
fieldAccessType = classType;
}
else
{
fieldAccessType = fld.DeclaringType.IsGenericType
? new CodeTypeOfExpression(TypeUtils.GetTemplatedName(fld.DeclaringType))
: new CodeTypeOfExpression(fld.DeclaringType);
}
}
init.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(null, infoName),
new CodeMethodInvokeExpression(fieldAccessType, "GetField", new CodePrimitiveExpression(name),
new CodeBinaryOperatorExpression(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "Instance"),
CodeBinaryOperatorType.BitwiseOr,
new CodeBinaryOperatorExpression(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "Public"),
CodeBinaryOperatorType.BitwiseOr,
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "NonPublic"))))));
// Build the getter and setter
if (getter == null)
{
getter = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeFieldReferenceExpression(null, infoName), "GetValue"),
new CodeArgumentReferenceExpression("input"));
}
if (setter == null)
{
// If the type is a struct, then the setter becomes somewhat more complicated, so first treat non-structs
if (t.IsByRef)
{
setter = value =>
{
var s = new CodeExpressionStatement
{
Expression =
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeFieldReferenceExpression(null, infoName), "SetValue"),
new CodeVariableReferenceExpression("result"), value)
};
return(new CodeStatementCollection(new CodeStatement[] { s }));
};
}
else
{
// If this is the first field to use setting by reflection in a struct, we need to box the struct before we can continue
if (!usingBoxedReflection)
{
usingBoxedReflection = true;
// NOTE: object objResult = (object)result;
if (!shallowCopyable)
{
copier.Statements.Add(new CodeVariableDeclarationStatement(typeof(object), "objResult",
new CodeCastExpression(typeof(object), new CodeVariableReferenceExpression("result"))));
}
deserializer.Statements.Add(new CodeVariableDeclarationStatement(typeof(object), "objResult",
new CodeCastExpression(typeof(object), new CodeVariableReferenceExpression("result"))));
}
var temp = "temp" + counter;
setter = value =>
{
var s1 = new CodeVariableDeclarationStatement(typeof(object), temp, value);
var s2 = new CodeExpressionStatement
{
Expression = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(new CodeFieldReferenceExpression(null, infoName), "SetValue"),
new CodeVariableReferenceExpression("objResult"),
new CodeVariableReferenceExpression(temp))
};
return(new CodeStatementCollection(new CodeStatement[] { s1, s2 }));
};
}
}
}
// Copy this field, if needed
if (!shallowCopyable)
{
if (fld.FieldType.IsOrleansShallowCopyable())
{
copier.Statements.AddRange(setter(getter));
}
else
{
copier.Statements.AddRange(fld.FieldType == typeof(object)
? setter(new CodeMethodInvokeExpression(serMgrRefExp, "DeepCopyInner", getter))
: setter(new CodeCastExpression(typeName,
new CodeMethodInvokeExpression(serMgrRefExp, "DeepCopyInner", getter))));
}
}
// Serialize this field
serializer.Statements.Add(new CodeMethodInvokeExpression(serMgrRefExp, "SerializeInner", getter, new CodeArgumentReferenceExpression("stream"),
new CodeTypeOfExpression(typeName)));
// Deserialize this field
deserializer.Statements.AddRange(setter(new CodeCastExpression(typeName,
new CodeMethodInvokeExpression(serMgrRefExp, "DeserializeInner",
new CodeTypeOfExpression(typeName), new CodeArgumentReferenceExpression("stream")))));
}
// Add return statements, as needed
if (!shallowCopyable)
{
copier.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(usingBoxedReflection ? "objResult" : "result")));
}
deserializer.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(usingBoxedReflection ? "objResult" : "result")));
// Special processing for generic types, necessary so that the appropriate closed types will get generated at run-time
if (t.IsGenericType)
{
var masterClassName = TypeUtils.GetSimpleTypeName(t) + "GenericMaster";
var masterClass = new CodeTypeDeclaration(masterClassName);
container.Types.Add(masterClass);
masterClass.IsClass = true;
masterClass.Attributes |= MemberAttributes.Static | MemberAttributes.Assembly | MemberAttributes.Final;
masterClass.TypeAttributes = TypeAttributes.NotPublic;
masterClass.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(RegisterSerializerAttribute), CodeTypeReferenceOptions.GlobalReference)));
var masterInit = AddInitMethod(masterClass);
masterInit.Statements.Add(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(new CodeTypeReference(typeof(SerializationManager), CodeTypeReferenceOptions.GlobalReference)), "Register",
new CodeTypeOfExpression(t),
new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(notVB ? masterClassName : "AddressOf " + masterClassName), "GenericCopier"),
new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(notVB ? masterClassName : "AddressOf " + masterClassName), "GenericSerializer"),
new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(notVB ? masterClassName : "AddressOf " + masterClassName), "GenericDeserializer")));
var initClosed = new CodeMethodInvokeExpression
{
Method = new CodeMethodReferenceExpression
{
MethodName = "Invoke",
TargetObject =
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression
("closed"), "GetMethod",
new CodePrimitiveExpression(
"Register"))
}
};
initClosed.Parameters.Add(new CodePrimitiveExpression(null));
initClosed.Parameters.Add(new CodeArrayCreateExpression(typeof(object), 0));
var create = new CodeMemberMethod();
masterClass.Members.Add(create);
create.Attributes = (create.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
create.Attributes = (create.Attributes & ~MemberAttributes.ScopeMask) | MemberAttributes.Static;
create.Name = "CreateConcreteType";
create.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Type[]), "typeParams"));
create.ReturnType = new CodeTypeReference(typeof(Type));
create.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeTypeOfExpression(serializationClassOpenName),
"MakeGenericType", new CodeArgumentReferenceExpression("typeParams"))));
var cop = new CodeMemberMethod();
masterClass.Members.Add(cop);
cop.Attributes = (cop.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
cop.Attributes = (cop.Attributes & ~MemberAttributes.ScopeMask) | MemberAttributes.Static;
cop.Name = "GenericCopier";
cop.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "obj"));
cop.ReturnType = new CodeTypeReference(typeof(object));
cop.Statements.Add(new CodeVariableDeclarationStatement(typeof(Type), "t",
new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(masterClassName), "CreateConcreteType",
new CodeMethodInvokeExpression(new CodeMethodInvokeExpression(new CodeArgumentReferenceExpression("obj"), "GetType"), "GetGenericArguments"))));
cop.Statements.Add(new CodeVariableDeclarationStatement(typeof(MethodInfo), "f",
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"), "GetMethod", new CodePrimitiveExpression("DeepCopier"))));
cop.Statements.Add(new CodeVariableDeclarationStatement(typeof(object[]), "args",
new CodeArrayCreateExpression(typeof(object), new CodeExpression[] { new CodeArgumentReferenceExpression("obj") })));
cop.Statements.Add(new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("f"), "Invoke", new CodePrimitiveExpression(),
new CodeVariableReferenceExpression("args"))));
var ser = new CodeMemberMethod();
masterClass.Members.Add(ser);
ser.Attributes = (ser.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
ser.Attributes = (ser.Attributes & ~MemberAttributes.ScopeMask) | MemberAttributes.Static;
ser.Name = "GenericSerializer";
ser.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "input"));
ser.Parameters.Add(new CodeParameterDeclarationExpression(typeof(BinaryTokenStreamWriter), "stream"));
ser.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Type), "expected"));
ser.ReturnType = new CodeTypeReference(typeof(void));
ser.Statements.Add(new CodeVariableDeclarationStatement(typeof(Type), "t",
new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(masterClassName), "CreateConcreteType",
new CodeMethodInvokeExpression(new CodeMethodInvokeExpression(new CodeArgumentReferenceExpression("input"), "GetType"), "GetGenericArguments"))));
ser.Statements.Add(new CodeVariableDeclarationStatement(typeof(MethodInfo), "f",
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"), "GetMethod", new CodePrimitiveExpression("Serializer"))));
ser.Statements.Add(new CodeVariableDeclarationStatement(typeof(object[]), "args",
new CodeArrayCreateExpression(typeof(object), new CodeArgumentReferenceExpression("input"), new CodeArgumentReferenceExpression("stream"), new CodeArgumentReferenceExpression("expected"))));
ser.Statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("f"), "Invoke", new CodePrimitiveExpression(),
new CodeVariableReferenceExpression("args")));
var deser = new CodeMemberMethod();
masterClass.Members.Add(deser);
deser.Attributes = (deser.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
deser.Attributes = (deser.Attributes & ~MemberAttributes.ScopeMask) | MemberAttributes.Static;
deser.Name = "GenericDeserializer";
deser.ReturnType = new CodeTypeReference(typeof(object));
deser.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Type), "expected"));
deser.Parameters.Add(new CodeParameterDeclarationExpression(typeof(BinaryTokenStreamReader), "stream"));
deser.ReturnType = new CodeTypeReference(typeof(object));
deser.Statements.Add(new CodeVariableDeclarationStatement(typeof(Type), "t",
new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(masterClassName), "CreateConcreteType",
new CodeMethodInvokeExpression(new CodeArgumentReferenceExpression("expected"), "GetGenericArguments"))));
deser.Statements.Add(new CodeVariableDeclarationStatement(typeof(MethodInfo), "f",
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"), "GetMethod", new CodePrimitiveExpression("Deserializer"))));
deser.Statements.Add(new CodeVariableDeclarationStatement(typeof(object[]), "args",
new CodeArrayCreateExpression(typeof(object), new CodeArgumentReferenceExpression("expected"), new CodeArgumentReferenceExpression("stream"))));
deser.Statements.Add(new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("f"), "Invoke", new CodePrimitiveExpression(),
new CodeVariableReferenceExpression("args"))));
}
container.Types.Add(classDecl);
}
/// <summary>
/// Updates the source file in the project if required.
/// </summary>
/// <param name="sourceFileToBeUpdated">Path to file to be updated.</param>
/// <param name="outputFileGenerated">File that was updated.</param>
private static void UpdateIntellisenseFile(string sourceFileToBeUpdated, string outputFileGenerated)
{
if (string.IsNullOrEmpty(sourceFileToBeUpdated))
{
throw new ArgumentNullException("sourceFileToBeUpdated", "Output file must not be blank");
}
if (string.IsNullOrEmpty(outputFileGenerated))
{
throw new ArgumentNullException("outputFileGenerated", "Generated file must already exist");
}
var sourceToUpdateFileInfo = new FileInfo(sourceFileToBeUpdated);
var generatedFileInfo = new FileInfo(outputFileGenerated);
if (!generatedFileInfo.Exists)
{
throw new Exception("Generated file must already exist");
}
if (File.Exists(sourceFileToBeUpdated))
{
bool filesMatch = CheckFilesMatch(generatedFileInfo, sourceToUpdateFileInfo);
if (filesMatch)
{
ConsoleText.WriteStatus(
"Orleans-CodeGen - No changes to the generated file {0}",
sourceFileToBeUpdated);
return;
}
// we come here only if files don't match
sourceToUpdateFileInfo.Attributes = sourceToUpdateFileInfo.Attributes & (~FileAttributes.ReadOnly);
// remove read only attribute
ConsoleText.WriteStatus(
"Orleans-CodeGen - copying file {0} to {1}",
outputFileGenerated,
sourceFileToBeUpdated);
File.Copy(outputFileGenerated, sourceFileToBeUpdated, true);
filesMatch = CheckFilesMatch(generatedFileInfo, sourceToUpdateFileInfo);
ConsoleText.WriteStatus(
"Orleans-CodeGen - After copying file {0} to {1} Matchs={2}",
outputFileGenerated,
sourceFileToBeUpdated,
filesMatch);
}
else
{
var dir = Path.GetDirectoryName(sourceFileToBeUpdated);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
ConsoleText.WriteStatus(
"Orleans-CodeGen - copying file {0} to {1}",
outputFileGenerated,
sourceFileToBeUpdated);
File.Copy(outputFileGenerated, sourceFileToBeUpdated, true);
bool filesMatch = CheckFilesMatch(generatedFileInfo, sourceToUpdateFileInfo);
ConsoleText.WriteStatus(
"Orleans-CodeGen - After copying file {0} to {1} Matchs={2}",
outputFileGenerated,
sourceFileToBeUpdated,
filesMatch);
}
}
/// <summary>
/// Generates a syntax tree for the provided assemblies.
/// </summary>
/// <param name="assemblies">The assemblies to generate code for.</param>
/// <param name="runtime">Whether or not runtime code generation is being performed.</param>
/// <returns>The generated syntax tree.</returns>
private static GeneratedSyntax GenerateForAssemblies(List <Assembly> assemblies, bool runtime)
{
if (Logger.IsVerbose)
{
Logger.Verbose(
"Generating code for assemblies: {0}",
string.Join(", ", assemblies.Select(_ => _.FullName)));
}
Assembly targetAssembly;
HashSet <Type> ignoredTypes;
if (runtime)
{
// Ignore types which have already been accounted for.
ignoredTypes = CodeGeneratorCommon.GetTypesWithImplementations(
typeof(MethodInvokerAttribute),
typeof(GrainReferenceAttribute),
typeof(GrainStateAttribute),
typeof(SerializerAttribute));
targetAssembly = null;
}
else
{
ignoredTypes = new HashSet <Type>();
targetAssembly = assemblies.FirstOrDefault();
}
var members = new List <MemberDeclarationSyntax>();
// Get types from assemblies which reference Orleans and are not generated assemblies.
var includedTypes = new HashSet <Type>();
foreach (var type in assemblies.SelectMany(_ => _.GetTypes()))
{
// The module containing the serializer.
var module = runtime ? null : type.Module;
// Every type which is encountered must be considered for serialization.
if (!type.IsNested && !type.IsGenericParameter && type.IsSerializable)
{
// If a type was encountered which can be accessed, process it for serialization.
var isAccessibleForSerialization =
!TypeUtilities.IsTypeIsInaccessibleForSerialization(type, module, targetAssembly);
if (isAccessibleForSerialization)
{
includedTypes.Add(type);
SerializerGenerationManager.RecordTypeToGenerate(type);
}
}
// Collect the types which require code generation.
if (GrainInterfaceData.IsGrainInterface(type))
{
if (Logger.IsVerbose2)
{
Logger.Verbose2("Will generate code for: {0}", type.GetParseableName());
}
includedTypes.Add(type);
}
}
includedTypes.RemoveWhere(_ => ignoredTypes.Contains(_));
// Group the types by namespace and generate the required code in each namespace.
foreach (var group in includedTypes.GroupBy(_ => CodeGeneratorCommon.GetGeneratedNamespace(_)))
{
var namespaceMembers = new List <MemberDeclarationSyntax>();
foreach (var type in group)
{
// The module containing the serializer.
var module = runtime ? null : type.Module;
// Every type which is encountered must be considered for serialization.
Action <Type> onEncounteredType = encounteredType =>
{
// If a type was encountered which can be accessed, process it for serialization.
var isAccessibleForSerialization =
!TypeUtilities.IsTypeIsInaccessibleForSerialization(encounteredType, module, targetAssembly);
if (isAccessibleForSerialization)
{
SerializerGenerationManager.RecordTypeToGenerate(encounteredType);
}
};
if (Logger.IsVerbose2)
{
Logger.Verbose2("Generating code for: {0}", type.GetParseableName());
}
if (GrainInterfaceData.IsGrainInterface(type))
{
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating GrainReference and MethodInvoker for {0}",
type.GetParseableName());
}
namespaceMembers.Add(GrainReferenceGenerator.GenerateClass(type, onEncounteredType));
namespaceMembers.Add(GrainMethodInvokerGenerator.GenerateClass(type));
}
// Generate serializers.
var first = true;
Type toGen;
while (SerializerGenerationManager.GetNextTypeToProcess(out toGen))
{
// Filter types which are inaccessible by the serialzation module/assembly.
var skipSerialzerGeneration =
toGen.GetAllFields()
.Any(
field =>
TypeUtilities.IsTypeIsInaccessibleForSerialization(
field.FieldType,
module,
targetAssembly));
if (skipSerialzerGeneration)
{
continue;
}
if (!runtime)
{
if (first)
{
ConsoleText.WriteStatus("ClientGenerator - Generating serializer classes for types:");
first = false;
}
ConsoleText.WriteStatus(
"\ttype " + toGen.FullName + " in namespace " + toGen.Namespace
+ " defined in Assembly " + toGen.Assembly.GetName());
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating & Registering Serializer for Type {0}",
toGen.GetParseableName());
}
namespaceMembers.AddRange(SerializerGenerator.GenerateClass(toGen, onEncounteredType));
}
}
if (namespaceMembers.Count == 0)
{
if (Logger.IsVerbose)
{
Logger.Verbose2("Skipping namespace: {0}", group.Key);
}
continue;
}
members.Add(
SF.NamespaceDeclaration(SF.ParseName(group.Key))
.AddUsings(
TypeUtils.GetNamespaces(typeof(TaskUtility), typeof(GrainExtensions))
.Select(_ => SF.UsingDirective(SF.ParseName(_)))
.ToArray())
.AddMembers(namespaceMembers.ToArray()));
}
return(new GeneratedSyntax
{
SourceAssemblies = assemblies,
Syntax = members.Count > 0 ? SF.CompilationUnit().AddMembers(members.ToArray()) : null
});
}
/// <summary>
/// Makes warnings visible in VS and MSBuild by prefixing error message with "Warning"
/// </summary>
/// <param name="warning">Warning message</param>
internal static void ReportWarning(string warning)
{
ConsoleText.WriteWarning("Warning: " + warning);
}
public KalkEngine() : base(new KalkObjectWithAlias())
{
FileService = new DefaultFileService();
KalkSettings.Initialize();
KalkEngineFolder = AppContext.BaseDirectory;
// Enforce UTF8 encoding
Console.OutputEncoding = Encoding.UTF8;
EnableEngineOutput = true;
EchoEnabled = true;
DisplayVersion = true;
CurrentDisplay = KalkDisplayMode.Standard;
KalkUserFolder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile, Environment.SpecialFolderOption.DoNotVerify), ".kalk");
HighlightOutput = new ConsoleText();
InputReader = Console.In;
OutputWriter = Console.Out;
ErrorWriter = Console.Error;
IsOutputSupportHighlighting = ConsoleHelper.SupportEscapeSequences;
// Fetch version
var assemblyInfoVersion = (AssemblyInformationalVersionAttribute)typeof(KalkEngine).Assembly.GetCustomAttribute(typeof(AssemblyInformationalVersionAttribute));
Version = assemblyInfoVersion.InformationalVersion;
Builtins = BuiltinObject;
((KalkObjectWithAlias)Builtins).Engine = this;
Units = new KalkUnits(this);
Shortcuts = new KalkShortcuts();
Aliases = new KalkAliases();
_currentShortcutKeyMap = Shortcuts.ShortcutKeyMap;
_completionMatchingList = new List <string>();
Config = new KalkConfig();
Variables = new ScriptVariables(this);
Descriptors = new Dictionary <string, KalkDescriptor>();
EnableRelaxedMemberAccess = false;
_modules = new Dictionary <Type, KalkModule>();
TryConverters = new List <TryToObjectDelegate>();
ErrorForStatementFunctionAsExpression = true;
StrictVariables = true;
UseScientific = true;
LoopLimit = int.MaxValue; // no limits for loops
RecursiveLimit = int.MaxValue; // no limits (still guarded by Scriban)
// Setup default clipboard methods
_localClipboard = string.Empty;
GetClipboardText = GetClipboardTextImpl;
SetClipboardText = SetClipboardTextImpl;
_cancellationTokenSource = new CancellationTokenSource();
PushGlobal(Units);
PushGlobal(Variables);
_parserOptions = new ParserOptions();
_lexerOptions = new LexerOptions()
{
KeepTrivia = true,
Mode = ScriptMode.ScriptOnly,
Lang = ScriptLang.Scientific
};
_lexerInterpolatedOptions = new LexerOptions()
{
KeepTrivia = true,
Mode = ScriptMode.Default,
Lang = ScriptLang.Scientific
};
_tempOutputHighlight = new ConsoleText();
// Init last result with 0
_lastResult = 0;
HistoryList = new List <string>();
_isInitializing = true;
RegisterFunctions();
_isInitializing = false;
}
/// <summary>
/// </summary>
/// <param name="args">
/// </param>
/// <exception cref="ArgumentNullException">
/// </exception>
private static void Main(string[] args)
{
LogUtil.SetupConsoleLogging(LogLevel.Debug);
LogUtil.SetupFileLogging("${basedir}/LoginEngineLog.txt", LogLevel.Trace);
SettingsOverride.LoadCustomSettings("NBug.LoginEngine.Config");
Settings.WriteLogToDisk = true;
AppDomain.CurrentDomain.UnhandledException += Handler.UnhandledException;
TaskScheduler.UnobservedTaskException += Handler.UnobservedTaskException;
Console.Title = "CellAO " + AssemblyInfoclass.Title + " Console. Version: " + AssemblyInfoclass.Description
+ " " + AssemblyInfoclass.AssemblyVersion + " " + AssemblyInfoclass.Trademark;
var ct = new ConsoleText();
ct.TextRead("main.txt");
Console.Write("Loading ");
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.Write(AssemblyInfoclass.Title + " ");
Console.ForegroundColor = ConsoleColor.White;
Console.Write(AssemblyInfoclass.Description);
Console.ResetColor();
Console.WriteLine("...");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("[OK]");
Console.ResetColor();
// Sying helped figure all this code out, about 5 yearts ago! :P
bool processedargs = false;
loginServer = Container.GetInstance <LoginServer>();
bool TCPEnable = true;
bool UDPEnable = false;
int Port = Convert.ToInt32(Config.Instance.CurrentConfig.LoginPort);
try
{
if (Config.Instance.CurrentConfig.ListenIP == "0.0.0.0")
{
loginServer.TcpEndPoint = new IPEndPoint(IPAddress.Any, Port);
}
else
{
loginServer.TcpIP = IPAddress.Parse(Config.Instance.CurrentConfig.ListenIP);
}
}
catch
{
ct.TextRead("ip_config_parse_error.txt");
Console.ReadKey();
return;
}
// TODO: ADD More Handlers.
loginServer.MaximumPendingConnections = 100;
#region Console Commands
// Andyzweb: Added checks for start and stop
// also added a running command to return status of the server
// and added Console.Write("\nServer Command >>"); to login server
string consoleCommand;
ct.TextRead("login_consolecommands.txt");
while (true)
{
if (!processedargs)
{
if (args.Length == 1)
{
if (args[0].ToLower() == "/autostart")
{
ct.TextRead("autostart.txt");
loginServer.Start(TCPEnable, UDPEnable);
}
}
processedargs = true;
}
Console.Write("\nServer Command >>");
consoleCommand = Console.ReadLine();
string temp = string.Empty;
while (temp != consoleCommand)
{
temp = consoleCommand;
consoleCommand = consoleCommand.Replace(" ", " ");
}
consoleCommand = consoleCommand.Trim();
switch (consoleCommand.ToLower())
{
case "start":
if (loginServer.IsRunning)
{
Console.ForegroundColor = ConsoleColor.Red;
ct.TextRead("loginisrunning.txt");
Console.ResetColor();
break;
}
loginServer.Start(TCPEnable, UDPEnable);
break;
case "stop":
if (!loginServer.IsRunning)
{
Console.ForegroundColor = ConsoleColor.Red;
ct.TextRead("loginisnotrunning.txt");
Console.ResetColor();
break;
}
loginServer.Stop();
break;
case "exit":
Process.GetCurrentProcess().Kill();
break;
case "running":
if (loginServer.IsRunning)
{
// Console.WriteLine("Login Server is running");
ct.TextRead("loginisrunning.txt");
break;
}
// Console.WriteLine("Login Server not running");
ct.TextRead("loginisnotrunning.txt");
break;
#region Help Commands....
case "help":
ct.TextRead("logincmdhelp.txt");
break;
case "help start":
ct.TextRead("helpstart.txt");
break;
case "help exit":
ct.TextRead("helpstop.txt");
break;
case "help running":
ct.TextRead("loginhelpcmdrunning.txt");
break;
case "help Adduser":
ct.TextRead("logincmdadduserhelp.txt");
break;
case "help setpass":
ct.TextRead("logincmdhelpsetpass.txt");
break;
#endregion
default:
#region Adduser
// This section handles the command for adding a user to the database
if (consoleCommand.ToLower().StartsWith("adduser"))
{
string[] parts = consoleCommand.Split(' ');
if (parts.Length < 9)
{
Console.WriteLine(
"Invalid command syntax.\nPlease use:\nAdduser <username> <password> <number of characters> <expansion> <gm level> <email> <FirstName> <LastName>");
break;
}
string username = parts[1];
string password = parts[2];
int numChars = 0;
try
{
numChars = int.Parse(parts[3]);
}
catch
{
Console.WriteLine("Error: <number of characters> must be a number (duh!)");
break;
}
int expansions = 0;
try
{
expansions = int.Parse(parts[4]);
}
catch
{
Console.WriteLine("Error: <expansions> must be a number between 0 and 2047!");
break;
}
if (expansions < 0 || expansions > 2047)
{
Console.WriteLine("Error: <expansions> must be a number between 0 and 2047!");
break;
}
int gm = 0;
try
{
gm = int.Parse(parts[5]);
}
catch
{
Console.WriteLine("Error: <GM Level> must be number (duh!)");
break;
}
string email = parts[6];
if (email == null)
{
email = string.Empty;
}
if (!TestEmailRegex(email))
{
Console.WriteLine("Error: <Email> You must supply an email address for this account");
break;
}
string firstname = parts[7];
try
{
if (firstname == null)
{
throw new ArgumentNullException();
}
}
catch
{
Console.WriteLine("Error: <FirstName> You must supply a first name for this accout");
break;
}
string lastname = parts[8];
try
{
if (lastname == null)
{
throw new ArgumentNullException();
}
}
catch
{
Console.WriteLine("Error: <LastName> You must supply a last name for this account");
break;
}
DBLoginData login = new DBLoginData
{
Username = username,
AccountFlags = 0,
Allowed_Characters = numChars,
CreationDate = DateTime.Now,
Email = email,
Expansions = expansions,
FirstName = firstname,
LastName = lastname,
GM = gm,
Flags = 0,
Password = new LoginEncryption().GeneratePasswordHash(password)
};
try
{
LoginDataDao.WriteLoginData(login);
}
catch (Exception ex)
{
Console.WriteLine(
"An error occured while trying to add a new user account:\n{0}", ex.Message);
break;
}
Console.WriteLine("User added successfully.");
break;
}
#endregion
#region Hashpass
// This function just hashes the string you enter using the loginencryption method
if (consoleCommand.ToLower().StartsWith("hash"))
{
string Syntax =
"The Syntax for this command is \"hash <String to hash>\" alphanumeric no spaces";
string[] parts = consoleCommand.Split(' ');
if (parts.Length != 2)
{
Console.WriteLine(Syntax);
break;
}
string pass = parts[1];
var le = new LoginEncryption();
string hashed = le.GeneratePasswordHash(pass);
Console.WriteLine(hashed);
break;
}
#endregion
#region setpass
// sets the password for the given username
// Added by Andyzweb
// Still TODO add exception and error handling
if (consoleCommand.ToLower().StartsWith("setpass"))
{
string Syntax =
"The syntax for this command is \"setpass <account username> <newpass>\" where newpass is alpha numeric no spaces";
string[] parts = consoleCommand.Split(' ');
if (parts.Length != 3)
{
Console.WriteLine(Syntax);
break;
}
string username = parts[1];
string newpass = parts[2];
var le = new LoginEncryption();
string hashed = le.GeneratePasswordHash(newpass);
try
{
LoginDataDao.WriteNewPassword(
new DBLoginData {
Username = username, Password = hashed
});
}
// yeah this part here, some kind of exception handling for mysql errors
catch (Exception ex)
{
Console.WriteLine("Could not set new Password\r\n" + ex.Message);
LogUtil.ErrorException(ex);
}
}
#endregion
ct.TextRead("login_consolecmdsdefault.txt");
break;
}
}
#endregion
}
/// <summary>
/// Generates a syntax tree for the provided assemblies.
/// </summary>
/// <param name="assemblies">The assemblies to generate code for.</param>
/// <param name="runtime">Whether or not runtime code generation is being performed.</param>
/// <returns>The generated syntax tree.</returns>
private GeneratedSyntax GenerateForAssemblies(List <Assembly> assemblies, bool runtime)
{
if (Logger.IsVerbose)
{
Logger.Verbose(
"Generating code for assemblies: {0}",
string.Join(", ", assemblies.Select(_ => _.FullName)));
}
Assembly targetAssembly;
HashSet <Type> ignoredTypes;
if (runtime)
{
// Ignore types which have already been accounted for.
ignoredTypes = GetTypesWithGeneratedSupportClasses();
targetAssembly = null;
}
else
{
ignoredTypes = new HashSet <Type>();
targetAssembly = assemblies.FirstOrDefault();
}
var members = new List <MemberDeclarationSyntax>();
// Include assemblies which are marked as included.
var knownAssemblyAttributes = new Dictionary <Assembly, KnownAssemblyAttribute>();
var knownAssemblies = new HashSet <Assembly>();
foreach (var attribute in assemblies.SelectMany(asm => asm.GetCustomAttributes <KnownAssemblyAttribute>()))
{
knownAssemblyAttributes[attribute.Assembly] = attribute;
knownAssemblies.Add(attribute.Assembly);
}
if (knownAssemblies.Count > 0)
{
knownAssemblies.UnionWith(assemblies);
assemblies = knownAssemblies.ToList();
}
// Get types from assemblies which reference Orleans and are not generated assemblies.
var includedTypes = new HashSet <Type>();
for (var i = 0; i < assemblies.Count; i++)
{
var assembly = assemblies[i];
foreach (var attribute in assembly.GetCustomAttributes <ConsiderForCodeGenerationAttribute>())
{
ConsiderType(attribute.Type, runtime, targetAssembly, includedTypes, considerForSerialization: true);
if (attribute.ThrowOnFailure && !serializerGenerationManager.IsTypeRecorded(attribute.Type))
{
throw new CodeGenerationException(
$"Found {attribute.GetType().Name} for type {attribute.Type.GetParseableName()}, but code"
+ " could not be generated. Ensure that the type is accessible.");
}
}
KnownAssemblyAttribute knownAssemblyAttribute;
var considerAllTypesForSerialization = knownAssemblyAttributes.TryGetValue(assembly, out knownAssemblyAttribute) &&
knownAssemblyAttribute.TreatTypesAsSerializable;
foreach (var type in TypeUtils.GetDefinedTypes(assembly, Logger))
{
var considerForSerialization = considerAllTypesForSerialization || type.IsSerializable;
ConsiderType(type.AsType(), runtime, targetAssembly, includedTypes, considerForSerialization);
}
}
includedTypes.RemoveWhere(_ => ignoredTypes.Contains(_));
// Group the types by namespace and generate the required code in each namespace.
foreach (var group in includedTypes.GroupBy(_ => CodeGeneratorCommon.GetGeneratedNamespace(_)))
{
var namespaceMembers = new List <MemberDeclarationSyntax>();
foreach (var type in group)
{
// The module containing the serializer.
var module = runtime ? null : type.GetTypeInfo().Module;
// Every type which is encountered must be considered for serialization.
Action <Type> onEncounteredType = encounteredType =>
{
// If a type was encountered which can be accessed, process it for serialization.
serializerGenerationManager.RecordTypeToGenerate(encounteredType, module, targetAssembly);
};
if (Logger.IsVerbose2)
{
Logger.Verbose2("Generating code for: {0}", type.GetParseableName());
}
if (GrainInterfaceUtils.IsGrainInterface(type))
{
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating GrainReference and MethodInvoker for {0}",
type.GetParseableName());
}
GrainInterfaceUtils.ValidateInterfaceRules(type);
namespaceMembers.Add(GrainReferenceGenerator.GenerateClass(type, onEncounteredType));
namespaceMembers.Add(GrainMethodInvokerGenerator.GenerateClass(type));
}
// Generate serializers.
var first = true;
Type toGen;
while (serializerGenerationManager.GetNextTypeToProcess(out toGen))
{
if (!runtime)
{
if (first)
{
ConsoleText.WriteStatus("ClientGenerator - Generating serializer classes for types:");
first = false;
}
ConsoleText.WriteStatus(
"\ttype " + toGen.FullName + " in namespace " + toGen.Namespace
+ " defined in Assembly " + toGen.GetTypeInfo().Assembly.GetName());
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating & Registering Serializer for Type {0}",
toGen.GetParseableName());
}
namespaceMembers.Add(SerializerGenerator.GenerateClass(toGen, onEncounteredType));
}
}
if (namespaceMembers.Count == 0)
{
if (Logger.IsVerbose)
{
Logger.Verbose2("Skipping namespace: {0}", group.Key);
}
continue;
}
members.Add(
SF.NamespaceDeclaration(SF.ParseName(group.Key))
.AddUsings(
TypeUtils.GetNamespaces(typeof(TaskUtility), typeof(GrainExtensions), typeof(IntrospectionExtensions))
.Select(_ => SF.UsingDirective(SF.ParseName(_)))
.ToArray())
.AddMembers(namespaceMembers.ToArray()));
}
return(new GeneratedSyntax
{
SourceAssemblies = assemblies,
Syntax = members.Count > 0 ? SF.CompilationUnit().AddMembers(members.ToArray()) : null
});
}
/// <summary>
/// 선택지를 표시한 후 선택된 원소의 번호를 반환합니다.
/// </summary>
/// <returns>선택된 원소의 번호</returns>
public int GetSelect(bool isKeep = false)
{
int currentSelectedNumber = 0;
ConsoleText item = UpdateElementColor(currentSelectedNumber, this.SelectedForegroundColor, this.SelectedBackgroundColor);
textBox.Present();
Console.SetCursorPosition(item.Left + item.asciiLength, item.Top);
while (true)
{
inputMgr.KeyCheck();
switch (inputMgr.KeyInfo.Key)
{
case ConsoleKey.UpArrow:
if (currentSelectedNumber > 0)
{
item = UpdateElementColor(currentSelectedNumber--, this.ForegroundColor, this.BackgroundColor);
item.Present();
item = UpdateElementColor(currentSelectedNumber, this.SelectedForegroundColor, this.SelectedBackgroundColor);
item.Present();
Console.SetCursorPosition(item.Left + item.asciiLength, item.Top);
}
break;
case ConsoleKey.DownArrow:
if (currentSelectedNumber + 1 < textBox.Row)
{
item = UpdateElementColor(currentSelectedNumber++, this.ForegroundColor, this.BackgroundColor);
item.Present();
item = UpdateElementColor(currentSelectedNumber, this.SelectedForegroundColor, this.SelectedBackgroundColor);
item.Present();
Console.SetCursorPosition(item.Left + item.asciiLength, item.Top);
}
break;
case ConsoleKey.Enter:
if (!isKeep)
{
textBox.ForegroundColor = this.ForegroundColor;
textBox.BackgroundColor = this.BackgroundColor;
textBox.Depresent();
}
Console.SetCursorPosition(0, textBox.Top + textBox.ConsoleTexts.Length);
return(currentSelectedNumber);
case ConsoleKey.F1:
case ConsoleKey.D1:
if (InputNumber(0, ref currentSelectedNumber))
{
goto case ConsoleKey.Enter;
}
else
{
break;
}
case ConsoleKey.F2:
case ConsoleKey.D2:
if (InputNumber(1, ref currentSelectedNumber))
{
goto case ConsoleKey.Enter;
}
else
{
break;
}
case ConsoleKey.F3:
case ConsoleKey.D3:
if (InputNumber(2, ref currentSelectedNumber))
{
goto case ConsoleKey.Enter;
}
else
{
break;
}
case ConsoleKey.F4:
case ConsoleKey.D4:
if (InputNumber(3, ref currentSelectedNumber))
{
goto case ConsoleKey.Enter;
}
else
{
break;
}
case ConsoleKey.F5:
case ConsoleKey.D5:
if (InputNumber(4, ref currentSelectedNumber))
{
goto case ConsoleKey.Enter;
}
else
{
break;
}
case ConsoleKey.F6:
case ConsoleKey.D6:
if (InputNumber(5, ref currentSelectedNumber))
{
goto case ConsoleKey.Enter;
}
else
{
break;
}
case ConsoleKey.F7:
case ConsoleKey.D7:
if (InputNumber(6, ref currentSelectedNumber))
{
goto case ConsoleKey.Enter;
}
else
{
break;
}
case ConsoleKey.F8:
case ConsoleKey.D8:
if (InputNumber(7, ref currentSelectedNumber))
{
goto case ConsoleKey.Enter;
}
else
{
break;
}
case ConsoleKey.F9:
case ConsoleKey.D9:
if (InputNumber(8, ref currentSelectedNumber))
{
goto case ConsoleKey.Enter;
}
else
{
break;
}
case ConsoleKey.F10:
case ConsoleKey.D0:
if (InputNumber(9, ref currentSelectedNumber))
{
goto case ConsoleKey.Enter;
}
else
{
break;
}
case ConsoleKey.F11:
if (InputNumber(10, ref currentSelectedNumber))
{
goto case ConsoleKey.Enter;
}
else
{
break;
}
case ConsoleKey.F12:
if (InputNumber(11, ref currentSelectedNumber))
{
goto case ConsoleKey.Enter;
}
else
{
break;
}
}
Thread.Sleep(1);
}
}
void ConsoleAddString(string str)
{
ConsoleText.Add(str);
}
private static void Main(string[] args)
{
bool processedargs = false;
// Please dont kill the commented out lines below for the moment -NV
//Misc.Playfields.Instance.playfields[0].districts.Add(new ZoneEngine.Misc.DistrictInfo());
//Misc.Playfields.Instance.playfields[0].districts[0].districtName = "some district";
//Misc.Playfields.Instance.playfields[0].districts.Add(new ZoneEngine.Misc.DistrictInfo());
//Misc.Playfields.Instance.playfields[0].districts[1].districtName = "some other district";
//Misc.DistrictInfo.DumpXML(@"C:\list.xml", Misc.Playfields.Instance.playfields[0]);
#region Console Text...
Console.Title = "CellAO " + AssemblyInfoclass.Title + " Console. Version: " + AssemblyInfoclass.Description
+ " " + AssemblyInfoclass.AssemblyVersion + " " + AssemblyInfoclass.Trademark;
ConsoleText ct = new ConsoleText();
ct.TextRead("main.txt");
Console.WriteLine("Loading " + AssemblyInfoclass.Title + "...");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Using ISComm v1.0");
Console.WriteLine("[OK]");
Console.ResetColor();
#endregion
#region Delete old SqlError.log, so it doesnt get too big
if (File.Exists("sqlerror.log"))
{
File.Delete("sqlerror.log");
}
#endregion
#region ISComm Code Area...
Console.WriteLine("[ISComm] Waiting for Link...");
ChatCom.StartLink(Config.Instance.CurrentConfig.CommPort);
//System.Console.WriteLine("[ISComm] Linked Successfully! :D");
#endregion
zoneServer = new Server {
EnableTCP = true, EnableUDP = false
};
#region Script Loading Code Area..
csc = new ScriptCompiler();
#endregion
try
{
zoneServer.TcpIP = IPAddress.Parse(Config.Instance.CurrentConfig.ListenIP);
}
catch
{
ct.TextRead("ip_config_parse_error.txt");
Console.ReadKey();
return;
}
try
{
zoneServer.UdpIP = IPAddress.Parse(Config.Instance.CurrentConfig.ListenIP);
}
catch
{
ct.TextRead("ip_config_parse_error.txt");
Console.ReadKey();
return;
}
zoneServer.TcpPort = Convert.ToInt32(Config.Instance.CurrentConfig.ZonePort);
#region NLog
LoggingConfiguration config = new LoggingConfiguration();
ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget();
consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}";
FileTarget fileTarget = new FileTarget();
config.AddTarget("file", fileTarget);
fileTarget.FileName = "${basedir}/ZoneEngineLog.txt";
fileTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}";
LoggingRule rule1 = new LoggingRule("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(rule1);
LoggingRule rule2 = new LoggingRule("*", LogLevel.Trace, fileTarget);
config.LoggingRules.Add(rule2);
LogManager.Configuration = config;
#endregion
#region NBug
SettingsOverride.LoadCustomSettings("NBug.ZoneEngine.Config");
NBug.Settings.WriteLogToDisk = true;
AppDomain.CurrentDomain.UnhandledException += Handler.UnhandledException;
TaskScheduler.UnobservedTaskException += Handler.UnobservedTaskException;
//TODO: ADD More Handlers.
#endregion
FunctionC.ReadFunctions();
Console.WriteLine("Registered " + FunctionC.NumberofRegisteredFunctions().ToString() + " Functions");
#region Console Commands...
string consoleCommand;
ct.TextRead("zone_consolecommands.txt");
// removed CheckDBs here, added commands check and updatedb (updatedb will change to a versioning
while (true)
{
if (!processedargs)
{
if (args.Length == 1)
{
if (args[0].ToLower() == "/autostart")
{
ct.TextRead("autostart.txt");
csc.Compile(false);
StartTheServer();
}
}
processedargs = true;
}
Console.Write("\nServer Command >>");
consoleCommand = Console.ReadLine();
switch (consoleCommand.ToLower())
{
case "start":
if (zoneServer.Running)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Zone Server is already running");
Console.ResetColor();
break;
}
//TODO: Add Sql Check.
csc.Compile(false);
StartTheServer();
break;
case "startm": // Multiple dll compile
if (zoneServer.Running)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Zone Server is already running");
Console.ResetColor();
break;
}
//TODO: Add Sql Check.
csc.Compile(true);
StartTheServer();
break;
case "stop":
if (!zoneServer.Running)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Zone Server is not running");
Console.ResetColor();
break;
}
zoneServer.Stop();
ThreadMgr.Stop();
break;
case "check":
case "updatedb":
using (SqlWrapper sqltester = new SqlWrapper())
{
sqltester.CheckDBs();
Console.ResetColor();
}
break;
case "exit":
case "quit":
if (zoneServer.Running)
{
zoneServer.Stop();
ThreadMgr.Stop();
}
Process.GetCurrentProcess().Kill();
break;
case "ls": //list all available scripts, dont remove it since it does what it should
Console.WriteLine("Available scripts");
/* Old Lua way
* string[] files = Directory.GetFiles("Scripts");*/
string[] files = Directory.GetFiles("Scripts\\", "*.cs", SearchOption.AllDirectories);
if (files.Length == 0)
{
Console.WriteLine("No scripts were found.");
break;
}
Console.ForegroundColor = ConsoleColor.Green;
foreach (string s in files)
{
Console.WriteLine(s);
/* Old Lua way
* if (s.EndsWith(".lua"))
* {
* Console.WriteLine(s.Split('\\')[1].Split('.')[0]);
* }*/
}
Console.ResetColor();
break;
case "ping":
// ChatCom.Server.Ping();
Console.WriteLine("Ping is disabled till we can fix it");
break;
case "running":
if (zoneServer.Running)
{
Console.WriteLine("Zone Server is Running");
break;
}
Console.WriteLine("Zone Server not Running");
break;
case "online":
if (zoneServer.Running)
{
Console.ForegroundColor = ConsoleColor.White;
lock (zoneServer.Clients)
{
foreach (Client c in zoneServer.Clients)
{
Console.WriteLine("Character " + c.Character.Name + " online");
}
}
Console.ResetColor();
}
break;
default:
ct.TextRead("zone_consolecmdsdefault.txt");
break;
}
}
}
public static void Main (string[] args)
{
const int WIDTH = 80;
const int HEIGHT = 30;
var defaultSize = new Size (WIDTH, HEIGHT);
var win = new ConsoleArea (defaultSize);
//var driver = new ConsoleDriver ();
var driver = new AnsiDriver ();
var screen = new ConsoleUpdater (driver, defaultSize);
var scrolly = new ConsoleScrollWindow (new Size (WIDTH - 2, 10));
scrolly.Window.Background = ConsoleColor.DarkRed;
win.Foreground = ConsoleColor.White;
var input = new ConsoleInputField ();
const int diff = 40;
bool hide = false;
for (var anim = 0; anim < 1000; ++anim)
{
win.Background = ConsoleColor.Blue;
win.Clear ();
var x = (int)(Math.Sin (anim / 10.0f) * diff + diff);
win.Background = ConsoleColor.DarkBlue;
win.Foreground = ConsoleColor.Yellow;
var xStart = x / 3;
var yStart = x / 8;
var borderWidth = x / 3;
var borderHeight = x / 5 + 1;
ConsoleBorder.Draw (win, xStart, yStart, borderWidth, borderHeight);
win.Background = ConsoleColor.DarkGreen;
var p = new Position (xStart, yStart);
var s = new Size (borderWidth - 2, borderHeight - 2);
var rect = new Rectangle (p, s);
win.Fill (rect);
win.Background = ConsoleColor.Black;
win.Foreground = ConsoleColor.Yellow;
if (x > 40)
{
win.Background = ConsoleColor.Cyan;
}
else
{
win.Background = ConsoleColor.Red;
}
scrolly.AddString ("This is a test", true);
win.Move (new Position (x, 10));
win.AddString ("Hello world!");
win.Background = ConsoleColor.DarkMagenta;
win.Copy (scrolly.Window, new Position (40 - x / 6, 10 - x / 3));
// ConsoleText.Draw (win, "THis is a field", 25, ConsoleText.TextAlign.Center);
var info = driver.ReadKey ();
var result = input.DoChar (info);
if (result == InputResult.Enter)
{
hide = true;
}
else if (result == InputResult.Escape)
{
break;
}
win.Move (new Position (0, 15));
if (!hide)
{
var adjustedCursorX = ConsoleText.Draw (win, input.Value, input.CursorX, 25, ConsoleText.TextAlign.Left);
win.Move (new Position (adjustedCursorX, 15));
}
screen.Update (win);
Task.Delay (10).Wait ();
}
}
private static void Main(string[] args)
{
#region Console Texts...
Console.Title = "CellAO " + AssemblyInfoclass.Title + " Console. Version: " + AssemblyInfoclass.Description
+ " " + AssemblyInfoclass.AssemblyVersion + " " + AssemblyInfoclass.Trademark;
ConsoleText ct = new ConsoleText();
ct.TextRead("main.txt");
Console.WriteLine("Loading " + AssemblyInfoclass.Title + "...");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("[OK]");
Console.ResetColor();
#endregion
//Sying helped figure all this code out, about 5 yearts ago! :P
bool processedargs = false;
loginLoginServer = new LoginServer();
loginLoginServer.EnableTCP = true;
loginLoginServer.EnableUDP = false;
try
{
loginLoginServer.TcpIP = IPAddress.Parse(Config.Instance.CurrentConfig.ListenIP);
}
catch
{
ct.TextRead("ip_config_parse_error.txt");
Console.ReadKey();
return;
}
loginLoginServer.TcpPort = Convert.ToInt32(Config.Instance.CurrentConfig.LoginPort);
#region NLog
LoggingConfiguration config = new LoggingConfiguration();
ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget();
consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}";
FileTarget fileTarget = new FileTarget();
config.AddTarget("file", fileTarget);
fileTarget.FileName = "${basedir}/LoginEngineLog.txt";
fileTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}";
LoggingRule rule1 = new LoggingRule("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(rule1);
LoggingRule rule2 = new LoggingRule("*", LogLevel.Trace, fileTarget);
config.LoggingRules.Add(rule2);
LogManager.Configuration = config;
#endregion
#region NBug
SettingsOverride.LoadCustomSettings("NBug.LoginEngine.Config");
NBug.Settings.WriteLogToDisk = true;
AppDomain.CurrentDomain.UnhandledException += Handler.UnhandledException;
TaskScheduler.UnobservedTaskException += Handler.UnobservedTaskException;
//TODO: ADD More Handlers.
#endregion
loginLoginServer.MaximumPendingConnections = 100;
#region Console Commands
//Andyzweb: Added checks for start and stop
//also added a running command to return status of the server
//and added Console.Write("\nServer Command >>"); to login server
string consoleCommand;
ct.TextRead("login_consolecommands.txt");
while (true)
{
if (!processedargs)
{
if (args.Length == 1)
{
if (args[0].ToLower() == "/autostart")
{
ct.TextRead("autostart.txt");
ThreadMgr.Start();
loginLoginServer.Start();
}
}
processedargs = true;
}
Console.Write("\nServer Command >>");
consoleCommand = Console.ReadLine();
string temp = "";
while (temp != consoleCommand)
{
temp = consoleCommand;
consoleCommand = consoleCommand.Replace(" ", " ");
}
consoleCommand = consoleCommand.Trim();
switch (consoleCommand.ToLower())
{
case "start":
if (loginLoginServer.Running)
{
Console.ForegroundColor = ConsoleColor.Red;
ct.TextRead("loginisrunning.txt");
Console.ResetColor();
break;
}
ThreadMgr.Start();
loginLoginServer.Start();
break;
case "stop":
if (!loginLoginServer.Running)
{
Console.ForegroundColor = ConsoleColor.Red;
ct.TextRead("loginisnotrunning.txt");
Console.ResetColor();
break;
}
ThreadMgr.Stop();
loginLoginServer.Stop();
break;
case "exit":
Process.GetCurrentProcess().Kill();
break;
case "running":
if (loginLoginServer.Running)
{
//Console.WriteLine("Login Server is running");
ct.TextRead("loginisrunning.txt");
break;
}
//Console.WriteLine("Login Server not running");
ct.TextRead("loginisnotrunning.txt");
break;
#region Help Commands....
case "help":
ct.TextRead("logincmdhelp.txt");
break;
case "help start":
ct.TextRead("helpstart.txt");
break;
case "help exit":
ct.TextRead("helpstop.txt");
break;
case "help running":
ct.TextRead("loginhelpcmdrunning.txt");
break;
case "help Adduser":
ct.TextRead("logincmdadduserhelp.txt");
break;
case "help setpass":
ct.TextRead("logincmdhelpsetpass.txt");
break;
#endregion
default:
#region Adduser
//This section handles the command for adding a user to the database
if (consoleCommand.ToLower().StartsWith("adduser"))
{
string[] parts = consoleCommand.Split(' ');
if (parts.Length < 9)
{
Console.WriteLine(
"Invalid command syntax.\nPlease use:\nAdduser <username> <password> <number of characters> <expansion> <gm level> <email> <FirstName> <LastName>");
break;
}
string username = parts[1];
string password = parts[2];
int numChars = 0;
try
{
numChars = int.Parse(parts[3]);
}
catch
{
Console.WriteLine("Error: <number of characters> must be a number (duh!)");
break;
}
int expansions = 0;
try
{
expansions = int.Parse(parts[4]);
}
catch
{
Console.WriteLine("Error: <expansions> must be a number between 0 and 2047!");
break;
}
if (expansions < 0 || expansions > 2047)
{
Console.WriteLine("Error: <expansions> must be a number between 0 and 2047!");
break;
}
int gm = 0;
try
{
gm = int.Parse(parts[5]);
}
catch
{
Console.WriteLine("Error: <GM Level> must be number (duh!)");
break;
}
string email = parts[6];
if (email == null)
{
email = String.Empty;
}
if (!TestEmailRegex(email))
{
Console.WriteLine("Error: <Email> You must supply an email address for this account");
break;
}
string firstname = parts[7];
try
{
if (firstname == null)
{
throw new ArgumentNullException();
}
}
catch
{
Console.WriteLine("Error: <FirstName> You must supply a first name for this accout");
break;
}
string lastname = parts[8];
try
{
if (lastname == null)
{
throw new ArgumentNullException();
}
}
catch
{
Console.WriteLine("Error: <LastName> You must supply a last name for this account");
break;
}
const string FormatString =
"INSERT INTO `login` (`CreationDate`, `Flags`,`AccountFlags`,`Username`,`Password`,`Allowed_Characters`,`Expansions`, `GM`, `Email`, `FirstName`, `LastName`) VALUES "
+ "(NOW(), '0', '0', '{0}', '{1}', {2}, {3}, {4}, '{5}', '{6}', '{7}');";
LoginEncryption le = new LoginEncryption();
string hashedPassword = le.GeneratePasswordHash(password);
string sql = String.Format(
FormatString,
username,
hashedPassword,
numChars,
expansions,
gm,
email,
firstname,
lastname);
SqlWrapper sqlWrapper = new SqlWrapper();
try
{
sqlWrapper.SqlInsert(sql);
}
catch (MySqlException ex)
{
switch (ex.Number)
{
case 1062: //duplicate entry for key
Console.WriteLine("A user account with this username already exists.");
break;
default:
Console.WriteLine(
"An error occured while trying to add a new user account:\n{0}", ex.Message);
break;
}
break;
}
Console.WriteLine("User added successfully.");
break;
}
#endregion
#region Hashpass
//This function just hashes the string you enter using the loginencryption method
if (consoleCommand.ToLower().StartsWith("hash"))
{
string Syntax =
"The Syntax for this command is \"hash <String to hash>\" alphanumeric no spaces";
string[] parts = consoleCommand.Split(' ');
if (parts.Length != 2)
{
Console.WriteLine(Syntax);
break;
}
string pass = parts[1];
LoginEncryption le = new LoginEncryption();
string hashed = le.GeneratePasswordHash(pass);
Console.WriteLine(hashed);
break;
}
#endregion
#region setpass
//sets the password for the given username
//Added by Andyzweb
//Still TODO add exception and error handling
if (consoleCommand.ToLower().StartsWith("setpass"))
{
string Syntax =
"The syntax for this command is \"setpass <account username> <newpass>\" where newpass is alpha numeric no spaces";
string[] parts = consoleCommand.Split(' ');
if (parts.Length != 3)
{
Console.WriteLine(Syntax);
break;
}
string username = parts[1];
string newpass = parts[2];
LoginEncryption le = new LoginEncryption();
string hashed = le.GeneratePasswordHash(newpass);
string formatString;
formatString = "UPDATE `login` SET Password = '******' WHERE login.Username = '******'";
string sql = String.Format(formatString, hashed, username);
SqlWrapper updt = new SqlWrapper();
try
{
updt.SqlUpdate(sql);
}
//yeah this part here, some kind of exception handling for mysql errors
catch
{
}
}
#endregion
ct.TextRead("login_consolecmdsdefault.txt");
break;
}
}
#endregion
}
/// <summary>
/// Parse command line arguments, to allow override of some silo runtime config settings.
/// </summary>
/// <param name="args">Command line arguments, as received by the Main program.</param>
/// <returns></returns>
public bool ParseArguments(string[] args)
{
string siloName = Dns.GetHostName(); // Default to machine name
SiloHost = new SiloHost(siloName);
int argPos = 1;
for (int i = 0; i < args.Length; i++)
{
string a = args[i];
if (a.StartsWith("-") || a.StartsWith("/"))
{
switch (a.ToLowerInvariant())
{
case "/?":
case "/help":
case "-?":
case "-help":
// Query usage help
return(false);
case "/debug":
SiloHost.Debug = true;
break;
default:
ConsoleText.WriteError("Bad command line arguments supplied: " + a);
return(false);
}
}
else if (a.Contains("="))
{
string[] split = a.Split('=');
if (String.IsNullOrEmpty(split[1]))
{
ConsoleText.WriteError("Bad command line arguments supplied: " + a);
return(false);
}
switch (split[0].ToLowerInvariant())
{
case "deploymentid":
SiloHost.DeploymentId = split[1];
break;
case "deploymentgroup":
ConsoleText.WriteError("Ignoring deprecated command line argument: " + a);
break;
default:
ConsoleText.WriteError("Bad command line arguments supplied: " + a);
return(false);
}
}
// unqualified arguments below
else if (argPos == 1)
{
SiloHost.Name = a;
argPos++;
}
else if (argPos == 2)
{
SiloHost.ConfigFileName = a;
argPos++;
}
else
{
// Too many command line arguments
ConsoleText.WriteError("Too many command line arguments supplied: " + a);
return(false);
}
}
return(true);
}
public void ACText(string s)
{
ConsoleText.AppendText(s);
}
private void OutputLine(string line)
{
ConsoleText.Text += line + "\n";
ConsoleText.ScrollToEnd();
}
/// <summary>
/// Makes errors visible in VS and MSBuild by prefixing error message with "Error"
/// </summary>
/// <param name="errorMsg">Error message</param>
/// <param name="exc">Exception associated with the error</param>
internal static void ReportError(string errorMsg, Exception exc)
{
ConsoleText.WriteError("Error: Orleans code generator found error: " + errorMsg, exc);
}
/// <summary>
/// The main.
/// </summary>
/// <param name="args">
/// Program arguments
/// </param>
private static void Main(string[] args)
{
Console.Title = "CellAO " + AssemblyInfoclass.Title + " Console. Version: " + AssemblyInfoclass.Description
+ " " + AssemblyInfoclass.AssemblyVersion + " " + AssemblyInfoclass.Trademark;
ConsoleText ct = new ConsoleText();
ct.TextRead("main.txt");
Console.WriteLine("Loading " + AssemblyInfoclass.Title + "...");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Using ISComm v1.0");
Console.WriteLine("[OK]");
Console.ResetColor();
bool processedArgs = false;
ChatServer chatServer = new ChatServer();
Console.WriteLine("[ISComm] Waiting for link...");
#region NLog
LoggingConfiguration config = new LoggingConfiguration();
ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget();
consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}";
FileTarget fileTarget = new FileTarget();
config.AddTarget("file", fileTarget);
fileTarget.FileName = "${basedir}/ChatEngineLog.txt";
fileTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}";
LoggingRule rule1 = new LoggingRule("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(rule1);
LoggingRule rule2 = new LoggingRule("*", LogLevel.Trace, fileTarget);
config.LoggingRules.Add(rule2);
LogManager.Configuration = config;
#endregion
#region NBug
SettingsOverride.LoadCustomSettings("NBug.ChatEngine.Config");
Settings.WriteLogToDisk = true;
AppDomain.CurrentDomain.UnhandledException += Handler.UnhandledException;
TaskScheduler.UnobservedTaskException += Handler.UnobservedTaskException;
// TODO: ADD More Handlers.
#endregion
IPAddress localISComm;
try
{
// Local ISComm IP valid?
localISComm = IPAddress.Parse(Config.Instance.CurrentConfig.ISCommLocalIP);
}
catch
{
// Fallback to ZoneIP
localISComm = IPAddress.Parse(Config.Instance.CurrentConfig.ZoneIP);
}
if (!ZoneCom.Link(localISComm.ToString(), Config.Instance.CurrentConfig.CommPort, chatServer))
{
Console.WriteLine("[ISComm] Unable to link to ZoneEngine. :(");
return;
}
Console.WriteLine("[ISComm] Linked with ZoneEngine! :D");
chatServer.EnableTCP = true;
chatServer.EnableUDP = false;
try
{
chatServer.TcpIP = IPAddress.Parse(Config.Instance.CurrentConfig.ListenIP);
}
catch
{
ct.TextRead("ip_config_parse_error.txt");
Console.ReadKey();
return;
}
try
{
chatServer.UdpIP = IPAddress.Parse(Config.Instance.CurrentConfig.ListenIP);
}
catch
{
ct.TextRead("ip_config_parse_error.txt");
Console.ReadKey();
return;
}
chatServer.TcpPort = Convert.ToInt32(Config.Instance.CurrentConfig.ChatPort);
chatServer.MaximumPendingConnections = 100;
AppDomain.CurrentDomain.UnhandledException += Handler.UnhandledException;
TaskScheduler.UnobservedTaskException += Handler.UnobservedTaskException;
// TODO: ADD More Handlers.
// Andyzweb: I added checks for if the server is running or not
// also a command called running that returns the status of the server
// and added the Console.Write("\nServer Command >>"); to chatserver
string consoleCommand;
ct.TextRead("chat_consolecommands.txt");
while (true)
{
if (!processedArgs)
{
if (args.Length == 1)
{
if (args[0].ToLower() == "/autostart")
{
ct.TextRead("autostart.txt");
ThreadMgr.Start();
chatServer.Start();
}
}
processedArgs = true;
}
Console.Write("\nServer Command >>");
consoleCommand = Console.ReadLine();
switch (consoleCommand.ToLower())
{
case "start":
if (chatServer.Running)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Chat Server is already running");
Console.ResetColor();
break;
}
ThreadMgr.Start();
chatServer.Start();
break;
case "stop":
if (!chatServer.Running)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Chat Server is not running");
Console.ResetColor();
break;
}
ThreadMgr.Stop();
chatServer.Stop();
break;
case "exit":
Process.GetCurrentProcess().Kill();
break;
case "running":
if (chatServer.Running)
{
Console.WriteLine("Chat Server is Running");
break;
}
Console.WriteLine("Chat Server not Running");
break;
default:
ct.TextRead("chat_consolecmdsdefault.txt");
break;
}
}
}
public int RunMain(string[] args)
{
ConsoleText.WriteStatus("Orleans-CodeGen - command-line = {0}", Environment.CommandLine);
if (args.Length < 1)
{
PrintUsage();
return(1);
}
try
{
var options = new CodeGenOptions();
// STEP 1 : Parse parameters
if (args.Length == 1 && args[0].StartsWith("@"))
{
// Read command line args from file
string arg = args[0];
string argsFile = arg.Trim('"').Substring(1).Trim('"');
Console.WriteLine("Orleans-CodeGen - Reading code-gen params from file={0}", argsFile);
AssertWellFormed(argsFile, true);
args = File.ReadAllLines(argsFile);
}
int i = 1;
foreach (string a in args)
{
string arg = a.Trim('"').Trim().Trim('"');
if (GrainClientGeneratorFlags.Verbose)
{
Console.WriteLine("Orleans-CodeGen - arg #{0}={1}", i++, arg);
}
if (string.IsNullOrEmpty(arg) || string.IsNullOrWhiteSpace(arg))
{
continue;
}
if (arg.StartsWith("/"))
{
if (arg.StartsWith("/reference:") || arg.StartsWith("/r:"))
{
// list of references passed from from project file. separator =';'
string refstr = arg.Substring(arg.IndexOf(':') + 1);
string[] references = refstr.Split(';');
foreach (string rp in references)
{
AssertWellFormed(rp, true);
options.ReferencedAssemblies.Add(rp);
}
}
else if (arg.StartsWith("/in:"))
{
var infile = arg.Substring(arg.IndexOf(':') + 1);
AssertWellFormed(infile);
options.InputAssembly = new FileInfo(infile);
}
else if (arg.StartsWith("/out:"))
{
var outfile = arg.Substring(arg.IndexOf(':') + 1);
AssertWellFormed(outfile, false);
options.OutputFileName = outfile;
}
}
else
{
Console.WriteLine($"Invalid argument: {arg}.");
PrintUsage();
return(1);
}
}
// STEP 2 : Validate and calculate unspecified parameters
if (options.InputAssembly == null)
{
Console.WriteLine("ERROR: Orleans-CodeGen - no input file specified.");
return(2);
}
if (String.IsNullOrEmpty(options.OutputFileName))
{
Console.WriteLine("ERROR: Orleans-Codegen - no output filename specified");
return(2);
}
// STEP 3 : Dump useful info for debugging
Console.WriteLine($"Orleans-CodeGen - Options {Environment.NewLine}\tInputLib={options.InputAssembly.FullName}{Environment.NewLine}\tOutputFileName={options.OutputFileName}");
if (options.ReferencedAssemblies != null)
{
Console.WriteLine("Orleans-CodeGen - Using referenced libraries:");
foreach (string assembly in options.ReferencedAssemblies)
{
Console.WriteLine("\t{0} => {1}", Path.GetFileName(assembly), assembly);
}
}
// STEP 5 : Finally call code generation
if (!CreateGrainClientAssembly(options))
{
return(-1);
}
// DONE!
return(0);
}
catch (Exception ex)
{
Console.WriteLine("-- Code-gen FAILED -- \n{0}", LogFormatter.PrintException(ex));
return(3);
}
}
internal static void Init()
{
ConsoleText.WriteStatus("Initializing serializer generation manager");
typesToProcess = new HashSet <Type>();
processedTypes = new HashSet <Type>();
}
private static void ReportErrorAndThrow(string errorMsg)
{
ConsoleText.WriteError("Orleans code generator found error: " + errorMsg);
throw new OrleansException(errorMsg);
}
internal static void RecordTypeToGenerate(Type t)
{
if (t.IsGenericParameter || processedTypes.Contains(t) || typesToProcess.Contains(t) ||
typeof(Exception).IsAssignableFrom(t))
{
return;
}
if (t.IsArray)
{
RecordTypeToGenerate(t.GetElementType());
return;
}
if (t.IsNestedPublic || t.IsNestedFamily || t.IsNestedPrivate)
{
Console.WriteLine("Skipping serializer generation for nested type {0}. If this type is used frequently, you may wish to consider making it non-nested.", t.Name);
}
if (t.IsGenericType)
{
var args = t.GetGenericArguments();
foreach (var arg in args)
{
if (!arg.IsGenericParameter)
{
RecordTypeToGenerate(arg);
}
}
}
if (t.IsInterface || t.IsAbstract || t.IsEnum || t == typeof(object) || t == typeof(void) ||
GrainInterfaceData.IsTaskType(t))
{
return;
}
if (t.IsGenericType)
{
var def = t.GetGenericTypeDefinition();
if (def == typeof(Task <>) || (SerializationManager.GetSerializer(def) != null) ||
processedTypes.Contains(def) || typeof(IAddressable).IsAssignableFrom(def))
{
return;
}
if (def.Namespace.Equals("System") || def.Namespace.StartsWith("System."))
{
ConsoleText.WriteWarning("System type " + def.Name + " requires a serializer.");
}
else
{
typesToProcess.Add(def);
}
return;
}
if (t.IsOrleansPrimitive() || (SerializationManager.GetSerializer(t) != null) ||
typeof(IAddressable).IsAssignableFrom(t))
{
return;
}
bool isSystemType = t.Namespace != null && (t.Namespace.Equals("System") || t.Namespace.StartsWith("System."));
if (isSystemType)
{
ConsoleText.WriteWarning("System type " + t.Name + " may require a custom serializer for optimal performance. " +
"If you use arguments of this type a lot, consider asking the Orleans team to build a custom serializer for it.");
return;
}
if (t.IsArray)
{
RecordTypeToGenerate(t.GetElementType());
return;
}
bool hasCopier = false;
bool hasSerializer = false;
bool hasDeserializer = false;
foreach (var method in t.GetMethods(BindingFlags.Static | BindingFlags.Public))
{
if (method.GetCustomAttributes(typeof(SerializerMethodAttribute), false).Length > 0)
{
hasSerializer = true;
}
else if (method.GetCustomAttributes(typeof(DeserializerMethodAttribute), false).Length > 0)
{
hasDeserializer = true;
}
if (method.GetCustomAttributes(typeof(CopierMethodAttribute), false).Length > 0)
{
hasCopier = true;
}
}
if (hasCopier && hasSerializer && hasDeserializer)
{
return;
}
typesToProcess.Add(t);
}
public int RunMain(string[] args)
{
ConsoleText.WriteStatus("Orleans-CodeGen - command-line = {0}", Environment.CommandLine);
if (args.Length < 1)
{
Console.WriteLine(
"Usage: ClientGenerator.exe <grain interface dll path> [<client dll path>] [<key file>] [<referenced assemblies>]");
Console.WriteLine(
" ClientGenerator.exe /server <grain dll path> [<factory dll path>] [<key file>] [<referenced assemblies>]");
return(1);
}
try
{
var options = new CodeGenOptions();
// STEP 1 : Parse parameters
if (args.Length == 1 && args[0].StartsWith("@"))
{
// Read command line args from file
string arg = args[0];
string argsFile = arg.Trim('"').Substring(1).Trim('"');
Console.WriteLine("Orleans-CodeGen - Reading code-gen params from file={0}", argsFile);
AssertWellFormed(argsFile, true);
args = File.ReadAllLines(argsFile);
}
int i = 1;
foreach (string a in args)
{
string arg = a.Trim('"').Trim().Trim('"');
if (GrainClientGeneratorFlags.Verbose)
{
Console.WriteLine("Orleans-CodeGen - arg #{0}={1}", i++, arg);
}
if (string.IsNullOrEmpty(arg) || string.IsNullOrWhiteSpace(arg))
{
continue;
}
if (arg.StartsWith("/"))
{
if (arg.StartsWith("/reference:") || arg.StartsWith("/r:"))
{
// list of references passed from from project file. separator =';'
string refstr = arg.Substring(arg.IndexOf(':') + 1);
string[] references = refstr.Split(';');
foreach (string rp in references)
{
AssertWellFormed(rp, true);
options.ReferencedAssemblies.Add(rp);
}
}
else if (arg.StartsWith("/in:"))
{
var infile = arg.Substring(arg.IndexOf(':') + 1);
AssertWellFormed(infile);
options.InputLib = new FileInfo(infile);
}
else if (arg.StartsWith("/bootstrap") || arg.StartsWith("/boot"))
{
// special case for building circular dependecy in preprocessing:
// Do not build the input assembly, assume that some other build step
options.CodeGenFile = Path.GetFullPath(CodeGenFileRelativePathCSharp);
if (GrainClientGeneratorFlags.Verbose)
{
Console.WriteLine(
"Orleans-CodeGen - Set CodeGenFile={0} from bootstrap",
options.CodeGenFile);
}
}
else if (arg.StartsWith("/sources:") || arg.StartsWith("/src:"))
{
var sourcesStr = arg.Substring(arg.IndexOf(':') + 1);
string[] sources = sourcesStr.Split(';');
foreach (var source in sources)
{
HandleSourceFile(source, options);
}
}
}
else
{
HandleSourceFile(arg, options);
}
}
if (options.TargetLanguage != Language.CSharp)
{
ConsoleText.WriteLine(
"ERROR: Compile-time code generation is supported for C# only. "
+ "Remove code generation from your project in order to use run-time code generation.");
return(2);
}
// STEP 2 : Validate and calculate unspecified parameters
if (options.InputLib == null)
{
Console.WriteLine("ERROR: Orleans-CodeGen - no input file specified.");
return(2);
}
if (string.IsNullOrEmpty(options.CodeGenFile))
{
Console.WriteLine(
"ERROR: No codegen file. Add a file '{0}' to your project",
Path.Combine("Properties", "orleans.codegen.cs"));
return(2);
}
options.SourcesDir = Path.Combine(options.InputLib.DirectoryName, "Generated");
// STEP 3 : Dump useful info for debugging
Console.WriteLine(
"Orleans-CodeGen - Options " + Environment.NewLine + "\tInputLib={0} " + Environment.NewLine
+ "\tCodeGenFile={1}",
options.InputLib.FullName,
options.CodeGenFile);
if (options.ReferencedAssemblies != null)
{
Console.WriteLine("Orleans-CodeGen - Using referenced libraries:");
foreach (string assembly in options.ReferencedAssemblies)
{
Console.WriteLine("\t{0} => {1}", Path.GetFileName(assembly), assembly);
}
}
// STEP 5 : Finally call code generation
if (!CreateGrainClientAssembly(options))
{
return(-1);
}
// DONE!
return(0);
}
catch (Exception ex)
{
File.WriteAllText("error.txt", ex.Message + Environment.NewLine + ex.StackTrace);
Console.WriteLine("-- Code-gen FAILED -- \n{0}", LogFormatter.PrintException(ex));
return(3);
}
}
public int RunMain(string[] args)
{
ConsoleText.WriteStatus("Orleans-CodeGen - command-line = {0}", Environment.CommandLine);
if (args.Length < 1)
{
Console.WriteLine(
"Usage: ClientGenerator.exe <grain interface dll path> [<client dll path>] [<key file>] [<referenced assemblies>]");
Console.WriteLine(
" ClientGenerator.exe /server <grain dll path> [<factory dll path>] [<key file>] [<referenced assemblies>]");
return(1);
}
try
{
var options = new CodeGenOptions();
// STEP 1 : Parse parameters
if (args.Length == 1 && args[0].StartsWith("@"))
{
// Read command line args from file
string arg = args[0];
string argsFile = arg.Trim('"').Substring(1).Trim('"');
Console.WriteLine("Orleans-CodeGen - Reading code-gen params from file={0}", argsFile);
AssertWellFormed(argsFile, true);
args = File.ReadAllLines(argsFile);
}
int i = 1;
foreach (string a in args)
{
string arg = a.Trim('"').Trim().Trim('"');
if (GrainClientGeneratorFlags.Verbose)
{
Console.WriteLine("Orleans-CodeGen - arg #{0}={1}", i++, arg);
}
if (string.IsNullOrEmpty(arg) || string.IsNullOrWhiteSpace(arg))
{
continue;
}
if (arg.StartsWith("/"))
{
if (arg.StartsWith("/reference:") || arg.StartsWith("/r:"))
{
// list of references passed from from project file. separator =';'
string refstr = arg.Substring(arg.IndexOf(':') + 1);
string[] references = refstr.Split(';');
foreach (string rp in references)
{
AssertWellFormed(rp, true);
options.ReferencedAssemblies.Add(rp);
}
}
else if (arg.StartsWith("/cwd:"))
{
options.WorkingDirectory = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/in:"))
{
var infile = arg.Substring(arg.IndexOf(':') + 1);
AssertWellFormed(infile);
options.InputLib = new FileInfo(infile);
}
else if (arg.StartsWith("/keyfile:") || arg.StartsWith("/key:"))
{
string keyFile = arg.Substring(arg.IndexOf(':') + 1);
if (!string.IsNullOrWhiteSpace(keyFile))
{
AssertWellFormed(keyFile, true);
options.SigningKey = new FileInfo(keyFile);
}
}
else if (arg.StartsWith("/config:"))
{
options.Config = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/fsharp:"))
{
var path = arg.Substring(arg.IndexOf(':') + 1);
if (!string.IsNullOrEmpty(path))
{
Console.WriteLine("F# compiler path = '{0}' ", path);
options.FSharpCompilerPath = path;
}
else
{
Console.WriteLine("F# compiler path not set.");
}
}
else if (arg.StartsWith("/rootns:") || arg.StartsWith("/rns:"))
{
options.RootNamespace = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/bootstrap") || arg.StartsWith("/boot"))
{
// special case for building circular dependecy in preprocessing:
// Do not build the input assembly, assume that some other build step
options.CodeGenFile = Path.GetFullPath(CodeGenFileRelativePathCSharp);
if (GrainClientGeneratorFlags.Verbose)
{
Console.WriteLine(
"Orleans-CodeGen - Set CodeGenFile={0} from bootstrap",
options.CodeGenFile);
}
}
else if (arg.StartsWith("/define:") || arg.StartsWith("/d:"))
{
// #define constants passed from project file. separator =';'
var definsStr = arg.Substring(arg.IndexOf(':') + 1);
if (!string.IsNullOrWhiteSpace(definsStr))
{
string[] defines = definsStr.Split(';');
foreach (var define in defines)
{
options.Defines.Add(define);
}
}
}
else if (arg.StartsWith("/imports:") || arg.StartsWith("/i:"))
{
// Standard VB imports passed from project file. separator =';'
string importsStr = arg.Substring(arg.IndexOf(':') + 1);
if (!string.IsNullOrWhiteSpace(importsStr))
{
string[] imports = importsStr.Split(';');
foreach (var import in imports)
{
options.Imports.Add(import);
}
}
}
else if (arg.StartsWith("/Option")) // VB-specific options
{
if (arg.StartsWith("/OptionExplicit:"))
{
options.OptionExplicit = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/OptionStrict:"))
{
options.OptionStrict = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/OptionInfer:"))
{
options.OptionInfer = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/OptionCompare:"))
{
options.OptionCompare = arg.Substring(arg.IndexOf(':') + 1);
}
}
else if (arg.StartsWith("/MyType:")) // VB-specific option
{
options.MyType = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/sources:") || arg.StartsWith("/src:"))
{
// C# sources passed from from project file. separator = ';'
//if (GrainClientGeneratorFlags.Verbose)
// Console.WriteLine("Orleans-CodeGen - Unpacking source file list arg={0}", arg);
var sourcesStr = arg.Substring(arg.IndexOf(':') + 1);
//if (GrainClientGeneratorFlags.Verbose)
// Console.WriteLine("Orleans-CodeGen - Splitting source file list={0}", sourcesStr);
string[] sources = sourcesStr.Split(';');
foreach (var source in sources)
{
AddSourceFile(
options.SourceFiles,
ref options.LanguageConflict,
ref options.TargetLanguage,
ref options.CodeGenFile,
source);
}
}
}
else
{
// files passed in without associated flags , we'll make the best guess.
if (arg.ToLowerInvariant().EndsWith(".snk", StringComparison.InvariantCultureIgnoreCase))
{
options.SigningKey = new FileInfo(arg);
}
else
{
AddSourceFile(
options.SourceFiles,
ref options.LanguageConflict,
ref options.TargetLanguage,
ref options.CodeGenFile,
arg);
}
}
}
if (!options.TargetLanguage.HasValue)
{
Console.WriteLine("ERROR: Unable to determine source code language to use for code generation.");
return(2);
}
// STEP 2 : Validate and calculate unspecified parameters
if (options.InputLib == null)
{
Console.WriteLine("ERROR: Orleans-CodeGen - no input file specified.");
return(2);
}
if (string.IsNullOrEmpty(options.CodeGenFile))
{
Console.WriteLine(
"ERROR: No codegen file. Add a file '{0}' to your project",
Path.Combine("Properties", "orleans.codegen.cs"));
return(2);
}
// STEP 3 : Check timestamps and skip if output is up-to-date wrt to all inputs
/* if (!bootstrap && IsProjectUpToDate(options.InputLib, options.SourceFiles, options.ReferencedAssemblies)
* && !Debugger.IsAttached)
* {
* Console.WriteLine(
* "Orleans-CodeGen - Skipping because all output files are up-to-date with respect to the input files.");
* return 0;
* }*/
options.SourcesDir = Path.Combine(options.InputLib.DirectoryName, "Generated");
// STEP 4 : Dump useful info for debugging
Console.WriteLine(
"Orleans-CodeGen - Options " + Environment.NewLine + "\tInputLib={0} " + Environment.NewLine
+ "\tSigningKey={1} " + Environment.NewLine
+ "\tCodeGenFile={2}",
options.InputLib.FullName,
options.SigningKey != null ? options.SigningKey.FullName : "",
options.CodeGenFile);
if (options.ReferencedAssemblies != null)
{
Console.WriteLine("Orleans-CodeGen - Using referenced libraries:");
foreach (string assembly in options.ReferencedAssemblies)
{
Console.WriteLine("\t{0} => {1}", Path.GetFileName(assembly), assembly);
}
}
// STEP 5 :
// if (!bootstrap) BuildInputAssembly(options);
// STEP 6 : Finally call code generation
if (!CreateGrainClientAssembly(options))
{
return(-1);
}
// DONE!
return(0);
}
catch (Exception ex)
{
Console.WriteLine("-- Code-gen FAILED -- \n{0}", TraceLogger.PrintException(ex));
return(3);
}
}
private bool CollectCompletionList(ConsoleText line, int cursorIndex)
{
var text = line.ToString();
var lexer = new Lexer(text, options: _lexerOptions);
var tokens = lexer.ToList();
// Find that we are in a correct place
var index = FindTokenIndexFromColumnIndex(cursorIndex, text.Length, tokens);
if (index >= 0)
{
// If we are in the middle of a comment/integer/float/string
// we don't expect to make any completion
var token = tokens[index];
switch (token.Type)
{
case TokenType.Comment:
case TokenType.CommentMulti:
case TokenType.Identifier:
case TokenType.IdentifierSpecial:
case TokenType.Integer:
case TokenType.HexaInteger:
case TokenType.BinaryInteger:
case TokenType.Float:
case TokenType.String:
case TokenType.ImplicitString:
case TokenType.VerbatimString:
return(false);
}
}
// Look for the start of the work to complete
_startIndexForCompletion = cursorIndex - 1;
while (_startIndexForCompletion >= 0)
{
var c = text[_startIndexForCompletion];
if (!IsIdentifierLetter(c))
{
break;
}
_startIndexForCompletion--;
}
_startIndexForCompletion++;
if (!IsFirstIdentifierLetter(text[_startIndexForCompletion]))
{
return(false);
}
var startTextToFind = text.Substring(_startIndexForCompletion, cursorIndex - _startIndexForCompletion);
Collect(startTextToFind, ScriptKeywords, _completionMatchingList);
Collect(startTextToFind, ValueKeywords, _completionMatchingList);
Collect(startTextToFind, Variables.Keys, _completionMatchingList);
Collect(startTextToFind, Builtins.Keys, _completionMatchingList);
// If we are not able to match anything from builtin and user variables/functions
// continue on units
if (_completionMatchingList.Count == 0)
{
Collect(startTextToFind, Units.Keys, _completionMatchingList);
}
return(true);
}
/// <summary>
/// Generates a syntax tree for the provided assemblies.
/// </summary>
/// <param name="assemblies">The assemblies to generate code for.</param>
/// <param name="runtime">Whether or not runtime code generation is being performed.</param>
/// <returns>The generated syntax tree.</returns>
private static GeneratedSyntax GenerateForAssemblies(List <Assembly> assemblies, bool runtime)
{
if (Logger.IsVerbose)
{
Logger.Verbose(
"Generating code for assemblies: {0}",
string.Join(", ", assemblies.Select(_ => _.FullName)));
}
Assembly targetAssembly;
HashSet <Type> ignoredTypes;
if (runtime)
{
// Ignore types which have already been accounted for.
ignoredTypes = GetTypesWithGeneratedSupportClasses();
targetAssembly = null;
}
else
{
ignoredTypes = new HashSet <Type>();
targetAssembly = assemblies.FirstOrDefault();
}
var members = new List <MemberDeclarationSyntax>();
// If any KnownAssemblies have been specified, include them during code generation.
var knownAssemblies =
assemblies.SelectMany(_ => _.GetCustomAttributes <KnownAssemblyAttribute>())
.Select(_ => _.Assembly)
.Distinct()
.ToSet();
if (knownAssemblies.Count > 0)
{
knownAssemblies.UnionWith(assemblies);
assemblies = knownAssemblies.ToList();
}
// Get types from assemblies which reference Orleans and are not generated assemblies.
var includedTypes = new HashSet <Type>();
for (var i = 0; i < assemblies.Count; i++)
{
var assembly = assemblies[i];
foreach (var attribute in assembly.GetCustomAttributes <KnownTypeAttribute>())
{
ConsiderType(attribute.Type, runtime, targetAssembly, includedTypes);
}
foreach (var type in assembly.DefinedTypes)
{
ConsiderType(type, runtime, targetAssembly, includedTypes);
}
}
includedTypes.RemoveWhere(_ => ignoredTypes.Contains(_));
// Group the types by namespace and generate the required code in each namespace.
foreach (var group in includedTypes.GroupBy(_ => CodeGeneratorCommon.GetGeneratedNamespace(_)))
{
var namespaceMembers = new List <MemberDeclarationSyntax>();
foreach (var type in group)
{
// The module containing the serializer.
var module = runtime ? null : type.Module;
// Every type which is encountered must be considered for serialization.
Action <Type> onEncounteredType = encounteredType =>
{
// If a type was encountered which can be accessed, process it for serialization.
SerializerGenerationManager.RecordTypeToGenerate(encounteredType, module, targetAssembly);
};
if (Logger.IsVerbose2)
{
Logger.Verbose2("Generating code for: {0}", type.GetParseableName());
}
if (GrainInterfaceData.IsGrainInterface(type))
{
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating GrainReference and MethodInvoker for {0}",
type.GetParseableName());
}
GrainInterfaceData.ValidateInterfaceRules(type);
namespaceMembers.Add(GrainReferenceGenerator.GenerateClass(type, onEncounteredType));
namespaceMembers.Add(GrainMethodInvokerGenerator.GenerateClass(type));
}
// Generate serializers.
var first = true;
Type toGen;
while (SerializerGenerationManager.GetNextTypeToProcess(out toGen))
{
if (!runtime)
{
if (first)
{
ConsoleText.WriteStatus("ClientGenerator - Generating serializer classes for types:");
first = false;
}
ConsoleText.WriteStatus(
"\ttype " + toGen.FullName + " in namespace " + toGen.Namespace
+ " defined in Assembly " + toGen.Assembly.GetName());
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating & Registering Serializer for Type {0}",
toGen.GetParseableName());
}
namespaceMembers.AddRange(SerializerGenerator.GenerateClass(toGen, onEncounteredType));
}
}
if (namespaceMembers.Count == 0)
{
if (Logger.IsVerbose)
{
Logger.Verbose2("Skipping namespace: {0}", group.Key);
}
continue;
}
members.Add(
SF.NamespaceDeclaration(SF.ParseName(group.Key))
.AddUsings(
TypeUtils.GetNamespaces(typeof(TaskUtility), typeof(GrainExtensions))
.Select(_ => SF.UsingDirective(SF.ParseName(_)))
.ToArray())
.AddMembers(namespaceMembers.ToArray()));
}
return(new GeneratedSyntax
{
SourceAssemblies = assemblies,
Syntax = members.Count > 0 ? SF.CompilationUnit().AddMembers(members.ToArray()) : null
});
}
public void addKey()
{
keys++;
keyText.text = "x" + keys;
ConsoleText.getInstance().ShowMessage("Single use keycard acquired");
}
private void MenuItem_ClearConsole_Click(object sender, RoutedEventArgs e)
{
ConsoleText.Clear();
}
