public void AddType(EventType eventType) { var name = eventType.Metadata.Name; if (NameToTypeMap.ContainsKey(name)) { throw new ArgumentException("Event type by name '" + name + "' already registered"); } NameToTypeMap.Put(name, eventType); var publicId = eventType.Metadata.EventTypeIdPair.PublicId; if (compileTime) { publicId = CRC32Util.ComputeCRC32(name); } else { if (publicId == -1) { throw new ArgumentException("Event type by name '" + name + "' has a public id of -1 at runtime"); } } var sameIdType = idToTypeMap.Get(publicId); if (sameIdType != null) { throw new ArgumentException( "Event type by name '" + name + "' has a public crc32 id overlap with event type by name '" + sameIdType.Name + "', please consider renaming either of these types"); } idToTypeMap.Put(publicId, eventType); }
private static void BuildAvroType( EventTypeRepositoryImpl eventTypeRepositoryPreconfigured, string eventTypeName, ConfigurationCommonEventTypeAvro config, EventTypeAvroHandler eventTypeAvroHandler, EventBeanTypedEventFactory eventBeanTypedEventFactory) { var metadata = new EventTypeMetadata( eventTypeName, null, EventTypeTypeClass.APPLICATION, EventTypeApplicationType.AVRO, NameAccessModifier.PRECONFIGURED, EventTypeBusModifier.NONBUS, false, new EventTypeIdPair(CRC32Util.ComputeCRC32(eventTypeName), -1)); var avroSuperTypes = EventTypeUtility.GetSuperTypesDepthFirst( config.SuperTypes, EventUnderlyingType.AVRO, eventTypeRepositoryPreconfigured); var newEventType = eventTypeAvroHandler.NewEventTypeFromSchema( metadata, eventBeanTypedEventFactory, config, avroSuperTypes.First, avroSuperTypes.Second); eventTypeRepositoryPreconfigured.AddType(newEventType); }
private static void AddNestableObjectArrayType( string eventTypeName, IDictionary<string, object> propertyTypesMayHavePrimitive, ConfigurationCommonEventTypeObjectArray optionalConfig, BeanEventTypeFactory beanEventTypeFactory, EventTypeRepositoryImpl repo) { if (optionalConfig != null && optionalConfig.SuperTypes.Count > 1) { throw new EventAdapterException(ConfigurationCommonEventTypeObjectArray.SINGLE_SUPERTYPE_MSG); } var propertyTypes = EventTypeUtility.GetPropertyTypesNonPrimitive(propertyTypesMayHavePrimitive); var metadata = new EventTypeMetadata( eventTypeName, null, EventTypeTypeClass.APPLICATION, EventTypeApplicationType.OBJECTARR, NameAccessModifier.PRECONFIGURED, EventTypeBusModifier.NONBUS, false, new EventTypeIdPair(CRC32Util.ComputeCRC32(eventTypeName), -1)); string[] superTypes = null; if (optionalConfig != null && optionalConfig.SuperTypes != null && !optionalConfig.SuperTypes.IsEmpty()) { superTypes = optionalConfig.SuperTypes.ToArray(); } var newEventType = beanEventTypeFactory.EventTypeFactory.CreateObjectArray( metadata, propertyTypes, superTypes, optionalConfig != null ? optionalConfig.StartTimestampPropertyName : null, optionalConfig != null ? optionalConfig.EndTimestampPropertyName : null, beanEventTypeFactory, repo); var existingType = repo.GetTypeByName(eventTypeName); if (existingType != null) { // The existing type must be the same as the type createdStatement if (newEventType.EqualsCompareType(existingType) != null) { var message = newEventType.CompareEquals(existingType); throw new EPException( "Event type named '" + eventTypeName + "' has already been declared with differing column name or type information: " + message.Message, message); } // Since it's the same, return the existing type return; } repo.AddType(newEventType); }
public EventTypeIdPair ComputeIdFromWrapped( NameAccessModifier visibility, string innerName, EventTypeMetadata metadataWrapper) { if (visibility == TRANSIENT || visibility == PRIVATE) { return new EventTypeIdPair(metadataWrapper.EventTypeIdPair.PublicId, CRC32Util.ComputeCRC32(innerName)); } return new EventTypeIdPair(CRC32Util.ComputeCRC32(innerName), -1); }
public DeploymentInternal RemoveDeployment(string deploymentId) { var deployment = DeploymentMap.Delete(deploymentId); if (deployment != null) { var crc = CRC32Util.ComputeCRC32(deploymentId); deploymentsByCRC.Remove(crc); } return deployment; }
private static void AddXMLDOMType( EventTypeRepositoryImpl repo, string eventTypeName, ConfigurationCommonEventTypeXMLDOM detail, SchemaModel schemaModel, BeanEventTypeFactory beanEventTypeFactory, XMLFragmentEventTypeFactory xmlFragmentEventTypeFactory) { if (detail.RootElementName == null) { throw new EventAdapterException("Required root element name has not been supplied"); } var existingType = repo.GetTypeByName(eventTypeName); if (existingType != null) { var message = "Event type named '" + eventTypeName + "' has already been declared with differing column name or type information"; throw new ConfigurationException(message); } var propertyAgnostic = detail.SchemaResource == null && detail.SchemaText == null; var metadata = new EventTypeMetadata( eventTypeName, null, EventTypeTypeClass.STREAM, EventTypeApplicationType.XML, NameAccessModifier.PRECONFIGURED, EventTypeBusModifier.BUS, propertyAgnostic, new EventTypeIdPair(CRC32Util.ComputeCRC32(eventTypeName), -1)); var type = beanEventTypeFactory.EventTypeFactory.CreateXMLType( metadata, detail, schemaModel, null, metadata.Name, beanEventTypeFactory, xmlFragmentEventTypeFactory, repo); repo.AddType(type); if (type is SchemaXMLEventType) { xmlFragmentEventTypeFactory.AddRootType((SchemaXMLEventType) type); } }
private static void AddVariantStream( string name, ConfigurationCommonVariantStream config, EventTypeRepositoryImpl repo, EventTypeFactory eventTypeFactory) { var variantSpec = ValidateVariantStream(name, config, repo); var metadata = new EventTypeMetadata( name, null, EventTypeTypeClass.VARIANT, EventTypeApplicationType.VARIANT, NameAccessModifier.PRECONFIGURED, EventTypeBusModifier.BUS, false, new EventTypeIdPair(CRC32Util.ComputeCRC32(name), -1)); var variantEventType = eventTypeFactory.CreateVariant(metadata, variantSpec); repo.AddType(variantEventType); }
public void AddDeployment( string deploymentId, DeploymentInternal deployment) { var existing = DeploymentMap.Get(deploymentId); if (existing != null) { throw new IllegalStateException("Deployment already exists by name '" + deploymentId + "'"); } var crc = CRC32Util.ComputeCRC32(deploymentId); existing = deploymentsByCRC.Get(crc); if (existing != null) { throw new IllegalStateException("Deployment already exists by same-value crc"); } DeploymentMap.Put(deploymentId, deployment); deploymentsByCRC.Put(crc, deployment); }
public EventType GetCreateXMLDOMType( string rootTypeName, string derivedEventTypeName, string moduleName, SchemaElementComplex complex, string representsFragmentOfProperty) { if (rootTypes == null) { rootTypes = new Dictionary<string, SchemaXMLEventType>(); } if (derivedTypes == null) { derivedTypes = new Dictionary<string, SchemaXMLEventType>(); } var type = rootTypes.Get(rootTypeName); if (type == null) { throw new IllegalStateException("Failed to find XML root event type '" + rootTypeName + "'"); } var config = type.ConfigurationEventTypeXMLDOM; // add a new type var xmlDom = new ConfigurationCommonEventTypeXMLDOM(); xmlDom.RootElementName = "//" + complex.Name; // such the reload of the type can resolve it xmlDom.RootElementNamespace = complex.Namespace; xmlDom.IsAutoFragment = config.IsAutoFragment; xmlDom.IsEventSenderValidatesRoot = config.IsEventSenderValidatesRoot; xmlDom.IsXPathPropertyExpr = config.IsXPathPropertyExpr; xmlDom.IsXPathResolvePropertiesAbsolute = config.IsXPathResolvePropertiesAbsolute; xmlDom.SchemaResource = config.SchemaResource; xmlDom.SchemaText = config.SchemaText; xmlDom.XPathFunctionResolver = config.XPathFunctionResolver; xmlDom.XPathVariableResolver = config.XPathVariableResolver; xmlDom.DefaultNamespace = config.DefaultNamespace; xmlDom.AddNamespacePrefixes(config.NamespacePrefixes); var metadata = new EventTypeMetadata( derivedEventTypeName, moduleName, EventTypeTypeClass.STREAM, EventTypeApplicationType.XML, NameAccessModifier.PRECONFIGURED, EventTypeBusModifier.BUS, false, new EventTypeIdPair(CRC32Util.ComputeCRC32(derivedEventTypeName), -1)); var eventType = (SchemaXMLEventType) eventTypeFactory.EventTypeFactory.CreateXMLType( metadata, xmlDom, type.SchemaModel, representsFragmentOfProperty, rootTypeName, eventTypeFactory, this, eventTypeNameResolver); derivedTypes.Put(derivedEventTypeName, eventType); optionalCompileTimeRegistry?.NewType(eventType); return eventType; }
public static DeployerModulePaths UpdatePath( int rolloutItemNumber, DeployerModuleEPLObjects eplObjects, string moduleName, string deploymentId, EPServicesContext services) { // save path-visibility event types and named windows to the path var deploymentIdCrc32 = CRC32Util.ComputeCRC32(deploymentId); IDictionary <long, EventType> deploymentTypes = EmptyDictionary <long, EventType> .Instance; IList <string> pathEventTypes = new List <string>(eplObjects.ModuleEventTypes.Count); IList <string> pathNamedWindows = new List <string>(eplObjects.ModuleNamedWindows.Count); IList <string> pathTables = new List <string>(eplObjects.ModuleTables.Count); IList <string> pathContexts = new List <string>(eplObjects.ModuleContexts.Count); IList <string> pathVariables = new List <string>(eplObjects.ModuleVariables.Count); IList <string> pathExprDecl = new List <string>(eplObjects.ModuleExpressions.Count); IList <NameAndParamNum> pathScripts = new List <NameAndParamNum>(eplObjects.ModuleScripts.Count); IList <string> pathClasses = new List <string>(eplObjects.ModuleClasses.Count); try { foreach (var entry in eplObjects.ModuleNamedWindows) { if (entry.Value.EventType.Metadata.AccessModifier.IsNonPrivateNonTransient()) { try { services.NamedWindowPathRegistry.Add(entry.Key, moduleName, entry.Value, deploymentId); } catch (PathExceptionAlreadyRegistered ex) { throw new EPDeployPreconditionException(ex.Message, ex, rolloutItemNumber); } pathNamedWindows.Add(entry.Key); } } foreach (var entry in eplObjects.ModuleTables) { if (entry.Value.TableVisibility.IsNonPrivateNonTransient()) { try { services.TablePathRegistry.Add(entry.Key, moduleName, entry.Value, deploymentId); } catch (PathExceptionAlreadyRegistered ex) { throw new EPDeployPreconditionException(ex.Message, ex, rolloutItemNumber); } pathTables.Add(entry.Key); } } foreach (var entry in eplObjects.ModuleEventTypes) { var eventTypeSPI = (EventTypeSPI)entry.Value; var nameTypeId = CRC32Util.ComputeCRC32(eventTypeSPI.Name); var eventTypeMetadata = entry.Value.Metadata; if (eventTypeMetadata.AccessModifier == NameAccessModifier.PRECONFIGURED) { // For XML all fragment event types are public if (eventTypeMetadata.ApplicationType != EventTypeApplicationType.XML) { throw new IllegalStateException("Unrecognized public visibility type in deployment"); } } else if (eventTypeMetadata.AccessModifier.IsNonPrivateNonTransient()) { if (eventTypeMetadata.BusModifier == EventTypeBusModifier.BUS) { eventTypeSPI.SetMetadataId(nameTypeId, -1); services.EventTypeRepositoryBus.AddType(eventTypeSPI); } else { eventTypeSPI.SetMetadataId(deploymentIdCrc32, nameTypeId); } try { services.EventTypePathRegistry.Add(entry.Key, moduleName, entry.Value, deploymentId); } catch (PathExceptionAlreadyRegistered ex) { throw new EPDeployPreconditionException(ex.Message, ex, rolloutItemNumber); } } else { eventTypeSPI.SetMetadataId(deploymentIdCrc32, nameTypeId); } if (eventTypeMetadata.AccessModifier.IsNonPrivateNonTransient()) { pathEventTypes.Add(entry.Key); } // we retain all types to enable variant-streams if (deploymentTypes.IsEmpty()) { deploymentTypes = new Dictionary <long, EventType>(); } deploymentTypes.Put(nameTypeId, eventTypeSPI); } // add serde information to event types services.EventTypeSerdeRepository.AddSerdes( deploymentId, eplObjects.EventTypeSerdes, eplObjects.ModuleEventTypes, eplObjects.BeanEventTypeFactory); foreach (var entry in eplObjects.ModuleContexts) { if (entry.Value.ContextVisibility.IsNonPrivateNonTransient()) { try { services.ContextPathRegistry.Add(entry.Key, moduleName, entry.Value, deploymentId); } catch (PathExceptionAlreadyRegistered ex) { throw new EPDeployPreconditionException(ex.Message, ex, rolloutItemNumber); } pathContexts.Add(entry.Key); } } foreach (var entry in eplObjects.ModuleVariables) { if (entry.Value.VariableVisibility.IsNonPrivateNonTransient()) { try { services.VariablePathRegistry.Add(entry.Key, moduleName, entry.Value, deploymentId); } catch (PathExceptionAlreadyRegistered ex) { throw new EPDeployPreconditionException(ex.Message, ex, rolloutItemNumber); } pathVariables.Add(entry.Key); } } foreach (var entry in eplObjects.ModuleExpressions) { if (entry.Value.Visibility.IsNonPrivateNonTransient()) { try { services.ExprDeclaredPathRegistry.Add(entry.Key, moduleName, entry.Value, deploymentId); } catch (PathExceptionAlreadyRegistered ex) { throw new EPDeployPreconditionException(ex.Message, ex, rolloutItemNumber); } pathExprDecl.Add(entry.Key); } } foreach (var entry in eplObjects.ModuleScripts) { if (entry.Value.Visibility.IsNonPrivateNonTransient()) { try { services.ScriptPathRegistry.Add(entry.Key, moduleName, entry.Value, deploymentId); } catch (PathExceptionAlreadyRegistered ex) { throw new EPDeployPreconditionException(ex.Message, ex, rolloutItemNumber); } pathScripts.Add(entry.Key); } } foreach (var index in eplObjects.ModuleIndexes) { if (index.IsNamedWindow) { var namedWindow = services.NamedWindowPathRegistry.GetWithModule(index.InfraName, index.InfraModuleName); if (namedWindow == null) { throw new IllegalStateException("Failed to find named window '" + index.InfraName + "'"); } ValidateIndexPrecondition(rolloutItemNumber, namedWindow.IndexMetadata, index); } else { var table = services.TablePathRegistry.GetWithModule(index.InfraName, index.InfraModuleName); if (table == null) { throw new IllegalStateException("Failed to find table '" + index.InfraName + "'"); } ValidateIndexPrecondition(rolloutItemNumber, table.IndexMetadata, index); } } foreach (var entry in eplObjects.ModuleClasses) { if (entry.Value.Visibility.IsNonPrivateNonTransient()) { try { services.ClassProvidedPathRegistry.Add(entry.Key, moduleName, entry.Value, deploymentId); } catch (PathExceptionAlreadyRegistered ex) { throw new EPDeployPreconditionException(ex.Message, ex, rolloutItemNumber); } pathClasses.Add(entry.Key); } } } catch (Exception) { Undeployer.DeleteFromEventTypeBus(services, deploymentTypes); Undeployer.DeleteFromPathRegistries(services, deploymentId); throw; } return(new DeployerModulePaths( deploymentTypes, pathEventTypes, pathNamedWindows, pathTables, pathContexts, pathVariables, pathExprDecl, pathScripts, pathClasses)); }
private static void BuildPublicBeanType( BeanEventTypeStemService beanEventTypeStemService, EventTypeRepository repo, string eventTypeName, Type clazz, BeanEventTypeFactoryPrivate privateFactory, IDictionary<string, ConfigurationCommonEventTypeBean> configs) { // check existing type var existingType = repo.GetTypeByName(eventTypeName); if (existingType != null) { if (existingType.Metadata.ApplicationType != EventTypeApplicationType.CLASS) { throw new ConfigurationException( "Event type named '" + eventTypeName + "' has already been declared with differing underlying type information: Class " + existingType.UnderlyingType.FullName + " versus " + clazz.Name); } var beanEventType = (BeanEventType) existingType; if (beanEventType.UnderlyingType != clazz) { throw new ConfigurationException( "Event type named '" + eventTypeName + "' has already been declared with differing underlying type information: Class " + existingType.UnderlyingType.FullName + " versus " + beanEventType.UnderlyingType); } return; } var optionalConfig = configs.Get(eventTypeName); // check-allocate bean-stem var stem = beanEventTypeStemService.GetCreateStem(clazz, optionalConfig); // metadata var publicId = CRC32Util.ComputeCRC32(eventTypeName); var metadata = new EventTypeMetadata( eventTypeName, null, EventTypeTypeClass.STREAM, EventTypeApplicationType.CLASS, NameAccessModifier.PRECONFIGURED, EventTypeBusModifier.NONBUS, false, new EventTypeIdPair(publicId, -1)); // supertypes var superTypes = GetSuperTypes(stem.SuperTypes, beanEventTypeStemService, repo, privateFactory, configs); var deepSuperTypes = GetDeepSupertypes( stem.DeepSuperTypes, beanEventTypeStemService, repo, privateFactory, configs); // bean type var startTS = optionalConfig == null ? null : optionalConfig.StartTimestampPropertyName; var endTS = optionalConfig == null ? null : optionalConfig.EndTimestampPropertyName; var eventType = privateFactory.EventTypeFactory.CreateBeanType( stem, metadata, privateFactory, superTypes, deepSuperTypes, startTS, endTS); repo.AddType(eventType); }
public void RemoveType(EventType eventType) { NameToTypeMap.Remove(eventType.Name); idToTypeMap.Remove(CRC32Util.ComputeCRC32(eventType.Name)); }
public EventTypeIdPair ComputeTypeId(string eventTypeName) { var id = CRC32Util.ComputeCRC32(eventTypeName); return new EventTypeIdPair(0, id); }