public EventPropertyGetter GetGetter(String propertyName) { EventPropertyGetter cachedGetter = _propertyGetterCache.Get(propertyName); if (cachedGetter != null) { return(cachedGetter); } SimplePropertyInfo simpleProp = GetSimplePropertyInfo(propertyName); if ((simpleProp != null) && (simpleProp.Getter != null)) { EventPropertyGetter propertyGetter = simpleProp.Getter; _propertyGetterCache.Put(propertyName, propertyGetter); return(propertyGetter); } Property prop = PropertyParser.ParseAndWalk(propertyName, false); if (prop is SimpleProperty) { // there is no such property since it wasn't in simplePropertyGetters return(null); } EventPropertyGetter getter = prop.GetGetter(this, _eventAdapterService); _propertyGetterCache.Put(propertyName, getter); return(getter); }
public FragmentEventType GetFragmentType(String propertyExpression) { SimplePropertyInfo simpleProp = GetSimplePropertyInfo(propertyExpression); if ((simpleProp != null) && (simpleProp.PropertyType != null)) { GenericPropertyDesc genericProp = simpleProp.Descriptor.GetReturnTypeGeneric(); return(EventBeanUtility.CreateNativeFragmentType(genericProp.PropertyType, genericProp.GenericType, _eventAdapterService)); } Property prop = PropertyParser.ParseAndWalk(propertyExpression, false); if (prop is SimpleProperty) { // there is no such property since it wasn't in simplePropertyTypes return(null); } GenericPropertyDesc genericPropertyDesc = prop.GetPropertyTypeGeneric(this, _eventAdapterService); if (genericPropertyDesc == null) { return(null); } return(EventBeanUtility.CreateNativeFragmentType(genericPropertyDesc.PropertyType, genericPropertyDesc.GenericType, _eventAdapterService)); }
/// <summary> /// Looks up and returns a cached simple property's descriptor. /// </summary> /// <param name="propertyName">to look up</param> /// <returns>property descriptor</returns> public InternalEventPropDescriptor GetSimpleProperty(string propertyName) { SimplePropertyInfo simpleProp = GetSimplePropertyInfo(propertyName); if (simpleProp != null) { return simpleProp.Descriptor; } return null; }
internal void Initialize(PluginDiscoverer.Merger merger, Runner.ServiceInfo r) { _assemblyQualifiedName = r.AssemblyQualifiedName; _serviceFullName = r.ServiceFullName; _isDynamicService = r.IsDynamicService; Debug.Assert(!_isDynamicService || (r.HasError || r.AssemblyInfo != null), "If we are a DynamicService, we must have an assembly or be in error."); if (r.AssemblyInfo != null) { _assembly = merger.FindOrCreate(r.AssemblyInfo); } base.Initialize(r); _implCollection = new List <PluginInfo>(); foreach (Runner.PluginInfo plugin in r.Implementations) { _implCollection.Add(merger.FindOrCreate(plugin)); } _impl = new ReadOnlyListOnIList <PluginInfo>(_implCollection); _propertiesInfoCollection = new List <SimplePropertyInfo>(); foreach (Runner.SimplePropertyInfo rP in r.PropertiesInfoCollection) { SimplePropertyInfo p = new SimplePropertyInfo(); p.Initialize(rP); _propertiesInfoCollection.Add(p); } _propertiesInfoCollectionEx = new ReadOnlyListOnIList <SimplePropertyInfo>(_propertiesInfoCollection); _methodsInfoCollection = new List <SimpleMethodInfo>(); foreach (Runner.SimpleMethodInfo rM in r.MethodsInfoCollection) { SimpleMethodInfo m = new SimpleMethodInfo(); m.Initialize(rM); _methodsInfoCollection.Add(m); } _methodsInfoCollectionEx = new ReadOnlyListOnIList <SimpleMethodInfo>(_methodsInfoCollection); _eventsInfoCollection = new List <SimpleEventInfo>(); foreach (Runner.SimpleEventInfo rE in r.EventsInfoCollection) { SimpleEventInfo e = new SimpleEventInfo(); e.Initialize(rE); _eventsInfoCollection.Add(e); } _eventsInfoCollectionEx = new ReadOnlyListOnIList <SimpleEventInfo>(_eventsInfoCollection); }
public Type GetPropertyType(string propertyName) { SimplePropertyInfo simpleProp = GetSimplePropertyInfo(propertyName); if ((simpleProp != null) && (simpleProp.Clazz != null)) { return simpleProp.Clazz; } Property prop = PropertyParser.ParseAndWalkLaxToSimple(propertyName); if (prop is SimpleProperty) { // there is no such property since it wasn't in simplePropertyTypes return null; } return prop.GetPropertyType(this, _eventAdapterService); }
/// <summary> /// Called by the GenericMergeList method /// </summary> /// <param name="rP"></param> /// <returns></returns> SimplePropertyInfo FindOrCreate(Runner.SimplePropertyInfo rP) { SimplePropertyInfo foundProp = null; foreach (SimplePropertyInfo p in this._propertiesInfoCollection) { if (p.Name == rP.Name) { foundProp = p; } } if (foundProp != null) { foundProp.Merge(rP); } else { foundProp = new SimplePropertyInfo(); foundProp.Initialize(rP); } return(foundProp); }
public void WriteParams(IndentedTextWriter writer, OperationAnalyzer analyzer, SimplePropertyInfo spi, Param paramCustomization) { // replace the enum type with a string param instead and convert to enum member on execution writer.WriteLine("/// <summary>"); writer.WriteLine("/// Specifies the HTTP verb to be used. The allowable verbs are GET, PUT, HEAD and DELETE."); writer.WriteLine("/// Not all verbs may be accepted by the service operation; check service documentation for details."); writer.WriteLine("/// If not specified, the default verb is GET."); writer.WriteLine("/// </summary>"); if (spi.IsRecursivelyRequired && spi.DefaultValue == null) { writer.WriteLine("#if !MODULAR"); writer.WriteLine("[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]"); writer.WriteLine("#else"); writer.WriteLine("[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)]"); if (spi.PropertyType == typeof(string)) { writer.WriteLine("[System.Management.Automation.AllowEmptyString]"); } writer.WriteLine("#endif"); writer.WriteLine("[Amazon.PowerShell.Common.AWSRequiredParameter]"); } else { writer.WriteLine("[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]"); } writer.WriteLine("public String {0} {{ get; set; }}", spi.CmdletParameterName); }
private void Initialize(bool isConfigured) { var propertyListBuilder = PropertyListBuilderFactory.CreateBuilder(OptionalLegacyDef); var properties = propertyListBuilder.AssessProperties(UnderlyingType); _propertyDescriptors = new EventPropertyDescriptor[properties.Count]; _propertyDescriptorMap = new Dictionary <String, EventPropertyDescriptor>(); PropertyNames = new String[properties.Count]; _simpleProperties = new Dictionary <String, SimplePropertyInfo>(); _mappedPropertyDescriptors = new Dictionary <String, InternalEventPropDescriptor>(); _indexedPropertyDescriptors = new Dictionary <String, InternalEventPropDescriptor>(); if (UsesSmartResolutionStyle) { _simpleSmartPropertyTable = new Dictionary <String, IList <SimplePropertyInfo> >(); _mappedSmartPropertyTable = new Dictionary <String, IList <SimplePropertyInfo> >(); _indexedSmartPropertyTable = new Dictionary <String, IList <SimplePropertyInfo> >(); } if ((OptionalLegacyDef == null) || (OptionalLegacyDef.CodeGeneration != CodeGenerationEnum.DISABLED)) { // get CGLib fast class FastClass = null; try { FastClass = FastClass.Create(UnderlyingType); } catch (Exception ex) { Log.Warn(".initialize Unable to obtain CGLib fast class and/or method implementation for class " + UnderlyingType.Name + ", error msg is " + ex.Message, ex); FastClass = null; } } int count = 0; foreach (InternalEventPropDescriptor desc in properties) { String propertyName = desc.PropertyName; Type underlyingType; Type componentType; bool isRequiresIndex; bool isRequiresMapkey; bool isIndexed; bool isMapped; bool isFragment; if (desc.PropertyType.GetValueOrDefault() == EventPropertyType.SIMPLE) { EventPropertyGetter getter; Type type; if (desc.ReadMethod != null) { getter = PropertyHelper.GetGetter(desc.PropertyName, desc.ReadMethod, FastClass, _eventAdapterService); type = desc.ReadMethod.ReturnType; } else { if (desc.AccessorField == null) { // Ignore property continue; } getter = new ReflectionPropFieldGetter(desc.AccessorField, _eventAdapterService); type = desc.AccessorField.FieldType; } underlyingType = type; componentType = null; isRequiresIndex = false; isRequiresMapkey = false; isIndexed = false; isMapped = false; if (type.IsGenericDictionary()) { isMapped = true; // We do not yet allow to fragment maps entries. // Class genericType = TypeHelper.GetGenericReturnTypeMap(desc.ReadMethod, desc.AccessorField); isFragment = false; if (desc.ReadMethod != null) { componentType = TypeHelper.GetGenericReturnTypeMap(desc.ReadMethod, false); } else if (desc.AccessorField != null) { componentType = TypeHelper.GetGenericFieldTypeMap(desc.AccessorField, false); } else { componentType = typeof(object); } } else if (type.IsArray) { isIndexed = true; isFragment = type.GetElementType().IsFragmentableType(); componentType = type.GetElementType(); } else if (type.IsImplementsInterface(typeof(IEnumerable))) { isIndexed = true; Type genericType = TypeHelper.GetGenericReturnType(desc.ReadMethod, desc.AccessorField, true); isFragment = genericType.IsFragmentableType(); if (genericType != null) { componentType = genericType; } else { componentType = typeof(Object); } } else { isMapped = false; isFragment = type.IsFragmentableType(); } _simpleProperties.Put(propertyName, new SimplePropertyInfo(type, getter, desc)); // Recognize that there may be properties with overlapping case-insentitive names if (UsesSmartResolutionStyle) { // Find the property in the smart property table var smartPropertyName = propertyName.ToLower(); var propertyInfoList = _simpleSmartPropertyTable.Get(smartPropertyName); if (propertyInfoList == null) { propertyInfoList = new List <SimplePropertyInfo>(); _simpleSmartPropertyTable.Put(smartPropertyName, propertyInfoList); } // Enter the property into the smart property list var propertyInfo = new SimplePropertyInfo(type, getter, desc); propertyInfoList.Add(propertyInfo); } } else if (desc.PropertyType.GetValueOrDefault() == EventPropertyType.MAPPED) { _mappedPropertyDescriptors.Put(propertyName, desc); underlyingType = desc.ReturnType; componentType = typeof(object); isRequiresIndex = false; isRequiresMapkey = desc.ReadMethod.GetParameterTypes().Length > 0; isIndexed = false; isMapped = true; isFragment = false; // Recognize that there may be properties with overlapping case-insentitive names if (UsesSmartResolutionStyle) { // Find the property in the smart property table var smartPropertyName = propertyName.ToLower(); var propertyInfoList = _mappedSmartPropertyTable.Get(smartPropertyName); if (propertyInfoList == null) { propertyInfoList = new List <SimplePropertyInfo>(); _mappedSmartPropertyTable.Put(smartPropertyName, propertyInfoList); } // Enter the property into the smart property list var propertyInfo = new SimplePropertyInfo(desc.ReturnType, null, desc); propertyInfoList.Add(propertyInfo); } } else if (desc.PropertyType.GetValueOrDefault() == EventPropertyType.INDEXED) { _indexedPropertyDescriptors.Put(propertyName, desc); underlyingType = desc.ReturnType; componentType = null; isRequiresIndex = desc.ReadMethod.GetParameterTypes().Length > 0; isRequiresMapkey = false; isIndexed = true; isMapped = false; isFragment = desc.ReturnType.IsFragmentableType(); if (UsesSmartResolutionStyle) { // Find the property in the smart property table String smartPropertyName = propertyName.ToLower(); IList <SimplePropertyInfo> propertyInfoList = _indexedSmartPropertyTable.Get(smartPropertyName); if (propertyInfoList == null) { propertyInfoList = new List <SimplePropertyInfo>(); _indexedSmartPropertyTable.Put(smartPropertyName, propertyInfoList); } // Enter the property into the smart property list var propertyInfo = new SimplePropertyInfo(desc.ReturnType, null, desc); propertyInfoList.Add(propertyInfo); } } else { continue; } PropertyNames[count] = desc.PropertyName; var descriptor = new EventPropertyDescriptor(desc.PropertyName, underlyingType, componentType, isRequiresIndex, isRequiresMapkey, isIndexed, isMapped, isFragment); _propertyDescriptors[count++] = descriptor; _propertyDescriptorMap.Put(descriptor.PropertyName, descriptor); } // Determine event type super types SuperTypes = GetBaseTypes(UnderlyingType, _eventAdapterService.BeanEventTypeFactory); if (SuperTypes != null && SuperTypes.Length == 0) { SuperTypes = null; } if (Metadata != null && Metadata.TypeClass == TypeClass.NAMED_WINDOW) { SuperTypes = null; } // Determine deep supertypes // Get base types (superclasses and interfaces), deep get of all in the tree ICollection <Type> supers = new HashSet <Type>(); GetSuper(UnderlyingType, supers); RemoveLibraryInterfaces(supers); // Remove CLR library base types // Cache the supertypes of this event type for later use _deepSuperTypes = new HashSet <EventType>(); foreach (Type superClass in supers) { EventType superType = _eventAdapterService.BeanEventTypeFactory.CreateBeanType(superClass.FullName, superClass, false, false, isConfigured); _deepSuperTypes.Add(superType); } DeepSuperTypes = _deepSuperTypes.ToArray(); }
public void WriteContextMembers(IndentedTextWriter writer, string contextVar, SimplePropertyInfo spi, Param paramCustomization) { string contextMember = string.Format("{0}.{1}", contextVar, spi.CmdletParameterName); writer.WriteLine("if (this.StandardStorage.IsPresent)"); writer.OpenRegion(); { writer.WriteLine("{0} = S3StorageClass.Standard;", contextMember); } writer.CloseRegion(); writer.WriteLine("else if (this.ReducedRedundancyStorage.IsPresent)"); writer.OpenRegion(); { writer.WriteLine("{0} = S3StorageClass.ReducedRedundancy;", contextMember); } writer.CloseRegion(); writer.WriteLine(); }
public void WriteContextMembers(IndentedTextWriter writer, string contextVar, SimplePropertyInfo spi, Param paramCustomization) { var contextMember = string.Format("{0}.{1}", contextVar, spi.CmdletParameterName); writer.WriteLine("if (this.{0} != null)", spi.CmdletParameterName); writer.OpenRegion(); writer.WriteLine("{0} = AmazonEC2Helper.InstanceParamToIDs(this.{1});", contextMember, spi.CmdletParameterName); writer.CloseRegion(); writer.WriteLine(); }
public void WriteParams(IndentedTextWriter writer, OperationAnalyzer analyzer, SimplePropertyInfo spi, Param param) { writer.WriteLine(DocumentationUtils.CommentDocumentation(spi.MemberDocumentation /*FlattenedDocumentation*/)); CmdletSourceWriter.WriteParamAttribute(writer, analyzer, spi, param); CmdletSourceWriter.WriteParamAliases(writer, analyzer, spi); writer.WriteLine("public object[] {0} {{ get; set; }}", spi.CmdletParameterName); }
public void WriteParams(IndentedTextWriter writer, OperationAnalyzer analyzer, SimplePropertyInfo spi, ServiceConfig.Param param) { // for S3StorageClass, we replace the enum type with two string switches instead writer.WriteLine("/// <summary>"); writer.WriteLine("/// Specifies the STANDARD storage class, which is the default storage class for S3 objects."); writer.WriteLine("/// Provides a 99.999999999% durability guarantee."); writer.WriteLine("/// </summary>"); writer.WriteLine("[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]"); writer.WriteLine("public SwitchParameter StandardStorage { get; set; }"); writer.WriteLine(); writer.WriteLine("/// <summary>"); writer.WriteLine("/// Specifies S3 should use REDUCED_REDUNDANCY storage class for the object. This"); writer.WriteLine("/// provides a reduced (99.99%) durability guarantee at a lower"); writer.WriteLine("/// cost as compared to the STANDARD storage class. Use this"); writer.WriteLine("/// storage class for non-mission critical data or for data"); writer.WriteLine("/// that doesn’t require the higher level of durability that S3"); writer.WriteLine("/// provides with the STANDARD storage class."); writer.WriteLine("/// </summary>"); writer.WriteLine("[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]"); writer.WriteLine("public SwitchParameter ReducedRedundancyStorage { get; set; }"); }
public AnalyzedResult(Type returnType, SimplePropertyInfo singleResultProperty) { ReturnType = returnType; SingleResultProperty = singleResultProperty; }
public void WriteContextMembers(IndentedTextWriter writer, string contextVar, SimplePropertyInfo spi, Param paramCustomization) { string contextMember = string.Format("{0}.{1}", contextVar, spi.CmdletParameterName); writer.WriteLine("if (!string.IsNullOrEmpty(this.{0}))", spi.CmdletParameterName); writer.OpenRegion(); { writer.WriteLine("try"); writer.OpenRegion(); { writer.WriteLine("{0} = (HttpVerb)Enum.Parse(typeof(HttpVerb), this.{1}, true);", contextMember, spi.CmdletParameterName); } writer.CloseRegion(); writer.WriteLine("catch (ArgumentException e)"); writer.OpenRegion(); { writer.WriteLine("string errMsg = \"Invalid parameter value; allowable values: \" + string.Join(\", \", Enum.GetNames(typeof(HttpVerb)));"); writer.WriteLine("this.ThrowArgumentError(errMsg, this.{0}, e);", spi.CmdletParameterName); } writer.CloseRegion(); } writer.CloseRegion(); writer.WriteLine(); }
/// <summary> /// Perform the scan on the source file. If we locate attributes marking use /// of ConstantClass-derived types, update the service model so that argument /// completers are generated and/or the cmdlet is added to the completer /// registration. /// </summary> public void Scan(string sourceFile, Dictionary <string, AdvancedCmdletInfo> advancedCmdlets, ArgumentCompleterDetails argumentCompleters = null) { var originalSource = File.ReadAllText(sourceFile); try { SyntaxTree tree = CSharpSyntaxTree.ParseText(originalSource); CompilationUnitSyntax root = tree.GetCompilationUnitRoot(); foreach (var ns in root.Members.OfType <NamespaceDeclarationSyntax>()) { foreach (var cls in ns.Members.OfType <ClassDeclarationSyntax>()) { var attributes = cls.AttributeLists.SelectMany(al => al.Attributes).ToArray(); var cmdletAttribute = attributes.FirstOrDefault(attr => GetAttributeName(attr) == "Cmdlet"); if (cmdletAttribute != null) { var cmdletVerb = (cmdletAttribute.ArgumentList.Arguments[0].Expression as LiteralExpressionSyntax).Token.ValueText; var cmdletNoun = (cmdletAttribute.ArgumentList.Arguments[1].Expression as LiteralExpressionSyntax).Token.ValueText; var cmdletName = $"{cmdletVerb}-{cmdletNoun}"; var cmdletInfo = new AdvancedCmdletInfo(); advancedCmdlets.Add(cmdletName, cmdletInfo); var awsCmdletAttribute = attributes.FirstOrDefault(attr => GetAttributeName(attr) == "AWSCmdlet"); var operationNameAttribute = awsCmdletAttribute?.ArgumentList.Arguments.Where(arg => arg.NameEquals?.Name.Identifier.ValueText == "Operation").FirstOrDefault() as AttributeArgumentSyntax; var operationNames = (operationNameAttribute?.Expression as ImplicitArrayCreationExpressionSyntax)?.Initializer.Expressions.OfType <LiteralExpressionSyntax>().Select(expr => expr.Token.ValueText); if (operationNames != null) { cmdletInfo.OperationNames.AddRange(operationNames); } if (argumentCompleters != null) { foreach (var prop in cls.Members.OfType <PropertyDeclarationSyntax>()) { var propertyAttributes = prop.AttributeLists.SelectMany(al => al.Attributes).ToArray(); if (propertyAttributes.Any(attr => GetAttributeName(attr) == "Parameter")) { var awsConstantClassSourceAttribute = propertyAttributes.FirstOrDefault(attr => GetAttributeName(attr) == "AWSConstantClassSource"); if (awsConstantClassSourceAttribute != null) { var constantType = (awsConstantClassSourceAttribute.ArgumentList.Arguments[0].Expression as LiteralExpressionSyntax).Token.ValueText; var propertyName = prop.Identifier.ValueText; if (!argumentCompleters.IsConstantClassRegistered(constantType)) { var propertyType = ServiceAssembly.GetType(constantType); var members = SimplePropertyInfo.GetConstantClassMembers(propertyType); argumentCompleters.AddConstantClass(constantType, members); } argumentCompleters.AddConstantClassReference(constantType, propertyName, cmdletName); } } } } } } } } catch (Exception e) { throw new InvalidDataException($"Error parsing advanced cmdlet file {sourceFile}", e); } }
public T Build() { var baseType = typeof(T).GetTypeInfo(); var typeBuilder = baseType.IsInterface ? ModuleBuilder.DefineType(typeof(T).Name + "DynamicImpl", TypeAttributes.Class, null, new Type[] { baseType }) : ModuleBuilder.DefineType(typeof(T).Name + "DynamicImpl", TypeAttributes.Class, baseType); foreach (var propertyInfo in baseType.DeclaredProperties) { var propertyGetMethod = propertyInfo.GetMethod; if (!propertyGetMethod.IsVirtual) { continue; } var internalMethod = typeBuilder.DefineMethod(propertyGetMethod.Name + "Internal", MethodAttributes.Private | MethodAttributes.Static, propertyGetMethod.ReturnType, null); var prop = typeBuilder.DefineProperty(propertyInfo.Name, PropertyAttributes.None, propertyInfo.PropertyType, null); var getter = typeBuilder.DefineMethod(propertyGetMethod.Name, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual, propertyGetMethod.ReturnType, null); if (!_propertyImpl.TryGetValue(propertyInfo, out var impl)) { Delegate deleg; if (!_delegates.TryGetValue(prop.PropertyType, out deleg)) { throw new Exception($"Implementation for type '{prop.PropertyType}' has not found"); } var simplePropInfo = new SimplePropertyInfo { Name = propertyInfo.Name, Type = propertyInfo.PropertyType }; impl = (LambdaExpression)deleg.DynamicInvoke(simplePropInfo); var visitor = new InlinePropertyVisitor(simplePropInfo); impl = (LambdaExpression)visitor.Visit(impl); } impl.CompileToMethod(internalMethod); var ilGenerator = getter.GetILGenerator(); ilGenerator.Emit(OpCodes.Call, internalMethod); ilGenerator.Emit(OpCodes.Ret); prop.SetGetMethod(getter); typeBuilder.DefineMethodOverride(getter, propertyGetMethod); } var resultType = typeBuilder.CreateTypeInfo(); var instance = Activator.CreateInstance(resultType.AsType()); return((T)instance); }
public void WriteParams(IndentedTextWriter writer, OperationAnalyzer analyzer, SimplePropertyInfo spi, Param paramCustomization) { // replace the enum type with a string param instead and convert to enum member on execution writer.WriteLine("/// <summary>"); writer.WriteLine("/// Specifies the protocol that will be used. Allowable values are 'HTTP' and 'HTTPS'."); writer.WriteLine("/// </summary>"); if (spi.IsRecursivelyRequired && spi.DefaultValue == null) { writer.WriteLine("#if !MODULAR"); writer.WriteLine("[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]"); writer.WriteLine("#else"); writer.WriteLine("[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)]"); if (spi.PropertyType == typeof(string)) { writer.WriteLine("[System.Management.Automation.AllowEmptyString]"); } writer.WriteLine("#endif"); writer.WriteLine("[Amazon.PowerShell.Common.AWSRequiredParameter]"); } else { writer.WriteLine("[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]"); } writer.WriteLine("public String {0} {{ get; set; }}", spi.CmdletParameterName); }