public override IEnumerable <XNode> Process(XNode node)
{
XElement element = _AssumeElement(node);
Validation.RequireAttributes(element, AttrName.Type);
string type_ref = element.GetAttributeValue(AttrName.Type);
string assembly_loc = element.GetAttributeValue(AttrName.AssemblyLocation);
Assembly assembly = null;
if (!String.IsNullOrEmpty(assembly_loc))
{
assembly = Assembly.LoadFrom(assembly_loc);
}
Type type;
type = assembly != null?assembly.GetType(type_ref) : Type.GetType(type_ref);
var processor = Activator.CreateInstance(type, _Env) as IElementProcessor;
if (processor == null)
{
throw ImportException.CreateException(
"Imported type '{0}' does not implement '{1}'",
type_ref, typeof(IElementProcessor).Name);
}
_Env._DefaultNodeProcessor._RegisterElementProcessor(processor);
return(new XNode[] {});
}
void importer_OnError(ImportException e)
{
if (this.InvokeRequired && !importer.IsDisposed)
{
this.Invoke(new Action(() => { OnErrorMessaging(e); }));
}
else
{
OnErrorMessaging(e);
}
}
void importer_OnError(ImportException e)
{
string msg = e.Message;
if (e.StackTrace != null)
{
msg += "\n " + e.StackTrace;
}
MessageBox.Show(msg,
Program.LanguageManager.GetString(StringResources.Message_ErrorHeader), MessageBoxButtons.OK, MessageBoxIcon.Error);
ResetControls();
}
private compat.collections.Pair<ExprAggregateNode, IList<StmtClassForgeableFactory>> ValidateAggregationExpr(
ExprNode columnExpressionType,
EventType optionalProvidedType,
StatementCompileTimeServices services)
{
var classpathImportService = services.ImportServiceCompileTime;
// determine validation context types and istream/irstream
EventType[] types;
string[] streamNames;
bool[] istreamOnly;
if (optionalProvidedType != null) {
types = new[] {optionalProvidedType};
streamNames = new[] {types[0].Name};
istreamOnly = new[] {
false
}; // always false (expected to be bound by data window), use "ever"-aggregation functions otherwise
}
else {
types = new EventType[0];
streamNames = new string[0];
istreamOnly = new bool[0];
}
var streamTypeService = new StreamTypeServiceImpl(types, streamNames, istreamOnly, false, false);
var validationContext =
new ExprValidationContextBuilder(streamTypeService, @base.StatementRawInfo, services).Build();
// substitute parameter nodes
foreach (var childNode in columnExpressionType.ChildNodes) {
if (childNode is ExprIdentNode) {
var identNode = (ExprIdentNode) childNode;
var propname = identNode.FullUnresolvedName.Trim();
var clazz = TypeHelper.GetTypeForSimpleName(
propname,
classpathImportService.ClassForNameProvider);
if (propname.ToLowerInvariant().Trim().Equals("@object")) {
clazz = typeof(object);
}
ImportException ex = null;
if (clazz == null) {
try {
clazz = classpathImportService.ResolveClass(propname, false, services.ClassProvidedExtension);
}
catch (ImportException e) {
ex = e;
}
}
if (clazz != null) {
var typeNode = new ExprTypedNoEvalNode(propname, clazz);
ExprNodeUtilityModify.ReplaceChildNode(columnExpressionType, identNode, typeNode);
}
else {
if (optionalProvidedType == null) {
if (ex != null) {
throw new ExprValidationException(
"Failed to resolve type '" + propname + "': " + ex.Message,
ex);
}
throw new ExprValidationException("Failed to resolve type '" + propname + "'");
}
}
}
}
// validate
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.CREATETABLECOLUMN,
columnExpressionType,
validationContext);
if (!(validated is ExprAggregateNode)) {
throw new ExprValidationException(
"Expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(validated) +
"' is not an aggregation");
}
return new compat.collections.Pair<ExprAggregateNode, IList<StmtClassForgeableFactory>>(
(ExprAggregateNode) validated,
validationContext.AdditionalForgeables);
}
private static void Import(Opts opts)
{
bool createdTempFile = false;
if (opts.FilePath.StartsWith("http:") || opts.FilePath.StartsWith("https:"))
{
DreamMessage packageMessage = Plug.New(opts.FilePath).InvokeEx("GET", DreamMessage.Ok(), new Result <DreamMessage>()).Wait();
if (!packageMessage.IsSuccessful)
{
throw new Exception(string.Format("Unable to download package from '{0}'", opts.FilePath));
}
opts.FilePath = Path.GetTempFileName();
opts.Archive = true;
createdTempFile = true;
using (Stream tempStream = File.Create(opts.FilePath)) {
packageMessage.ToStream().CopyTo(tempStream, packageMessage.ContentLength, new Result <long>()).Wait();
}
}
IPackageReader packageReader;
if (opts.Archive)
{
if (!File.Exists(opts.FilePath))
{
throw new ConfigurationException("No such file: {0}", opts.FilePath);
}
if (opts.Test)
{
return;
}
packageReader = new ArchivePackageReader(opts.FilePath);
}
else
{
if (!Directory.Exists(opts.FilePath))
{
throw new ConfigurationException("No such directory: {0}", opts.FilePath);
}
if (opts.Test)
{
return;
}
packageReader = new FilePackageReader(opts.FilePath);
}
ImportManager manager;
try {
var manifest = packageReader.ReadManifest(new Result <XDoc>()).Wait();
FixupManifest(manifest, opts);
var forceOverwrite = !(opts.PreserveLocalChanges ?? true);
var importer = opts.ImportRelto.HasValue
? Importer.CreateAsync(opts.DekiApi, manifest, opts.ImportRelto.Value, forceOverwrite, new Result <Importer>()).Wait()
: Importer.CreateAsync(opts.DekiApi, manifest, opts.ImportReltoPath, forceOverwrite, new Result <Importer>()).Wait();
manager = new ImportManager(importer, packageReader);
} catch (Exception e) {
if (createdTempFile)
{
File.Delete(opts.FilePath);
}
throw new Exception(string.Format("Import failed: {0}", e.Message), e);
}
manager.MaxRetries = opts.Retries;
Result result = manager.ImportAsync(new Result());
int completed = 0;
Console.WriteLine("Importing:");
while (!result.HasFinished)
{
Thread.Sleep(200);
if (manager.CompletedItems <= completed)
{
continue;
}
if (SysUtil.IsUnix)
{
Console.WriteLine(" {0} of {1} files ({2:0}%)", manager.CompletedItems, manager.TotalItems, 100.0 * manager.CompletedItems / manager.TotalItems);
}
else
{
Console.Write(" {0} of {1} files ({2:0}%) \r", manager.CompletedItems, manager.TotalItems, 100.0 * manager.CompletedItems / manager.TotalItems);
}
completed = manager.CompletedItems;
}
if (!SysUtil.IsUnix)
{
Console.WriteLine();
}
if (createdTempFile)
{
File.Delete(opts.FilePath);
}
if (result.HasException)
{
ImportException importException = result.Exception as ImportException;
if (importException != null)
{
Console.WriteLine("Import failed on Item:\r\n{0}", importException.ManifestItem.ToPrettyString());
}
throw new Exception(string.Format("Import failed: {0}", result.Exception.Message), result.Exception);
}
}
private static VariableMetaData GetTypeInfo(
string variableName,
string variableModuleName,
NameAccessModifier variableVisibility,
string optionalContextName,
NameAccessModifier? optionalContextVisibility,
string optionalContextModule,
ClassIdentifierWArray variableTypeWArray,
bool preconfigured,
bool constant,
bool compileTimeConstant,
object valueAsProvided,
ImportService importService,
ExtensionClass extensionClass,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
EventTypeRepositoryImpl eventTypeRepositoryPreconfigured,
BeanEventTypeFactory beanEventTypeFactory)
{
// Determine the variable type
var primitiveType = TypeHelper.GetPrimitiveTypeForName(variableTypeWArray.ClassIdentifier);
var type = TypeHelper.GetTypeForSimpleName(variableTypeWArray.ClassIdentifier).GetBoxedType();
Type arrayType = null;
EventType eventType = null;
if (type == null) {
if (variableTypeWArray.ClassIdentifier.Equals("object", StringComparison.InvariantCultureIgnoreCase)) {
type = TypeHelper.GetArrayType(typeof(object), variableTypeWArray.ArrayDimensions);
}
if (type == null) {
eventType = eventTypeRepositoryPreconfigured.GetTypeByName(variableTypeWArray.ClassIdentifier);
if (eventType != null) {
type = eventType.UnderlyingType;
}
}
ImportException lastException = null;
if (type == null) {
try {
type = importService.ResolveClass(variableTypeWArray.ClassIdentifier, false, extensionClass);
type = TypeHelper.GetArrayType(type, variableTypeWArray.ArrayDimensions);
}
catch (ImportException e) {
Log.Debug("Not found '" + type + "': " + e.Message, e);
lastException = e;
// expected
}
}
if (type == null) {
throw new VariableTypeException(
"Cannot create variable '" +
variableName +
"', type '" +
variableTypeWArray.ClassIdentifier +
"' is not a recognized type",
lastException);
}
if (variableTypeWArray.ArrayDimensions > 0 && eventType != null) {
throw new VariableTypeException(
"Cannot create variable '" +
variableName +
"', type '" +
variableTypeWArray.ClassIdentifier +
"' cannot be declared as an array type as it is an event type",
lastException);
}
}
else {
if (variableTypeWArray.ArrayDimensions > 0) {
if (variableTypeWArray.IsArrayOfPrimitive) {
if (primitiveType == null) {
throw new VariableTypeException(
"Cannot create variable '" +
variableName +
"', type '" +
variableTypeWArray.ClassIdentifier +
"' is not a primitive type");
}
arrayType = TypeHelper.GetArrayType(primitiveType, variableTypeWArray.ArrayDimensions);
}
else {
arrayType = TypeHelper.GetArrayType(type, variableTypeWArray.ArrayDimensions);
}
}
}
if (eventType == null &&
!type.IsBuiltinDataType() &&
type != typeof(object) &&
!type.IsArray &&
!type.IsEnum) {
if (variableTypeWArray.ArrayDimensions > 0) {
throw new VariableTypeException(
"Cannot create variable '" +
variableName +
"', type '" +
variableTypeWArray.ClassIdentifier +
"' cannot be declared as an array, only scalar types can be array");
}
eventType = beanEventTypeFactory.GetCreateBeanType(type, false);
}
if (arrayType != null) {
type = arrayType;
}
var coerced = GetCoercedValue(valueAsProvided, eventType, variableName, type, eventBeanTypedEventFactory);
return new VariableMetaData(
variableName,
variableModuleName,
variableVisibility,
optionalContextName,
optionalContextVisibility,
optionalContextModule,
type,
eventType,
preconfigured,
constant,
compileTimeConstant,
coerced,
true);
}
