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);
}
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 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;
}
public static string GetHashCodeFromFile(string fileName, FileCodeHashType hashtype)
{
string rst = string.Empty;
byte[] retVal = null;
try
{
switch (hashtype)
{
case FileCodeHashType.MD5:
case FileCodeHashType.SHA1:
using (FileStream file = new FileStream(fileName, System.IO.FileMode.Open))
{
switch (hashtype)
{
case FileCodeHashType.MD5:
MD5 md5 = new MD5CryptoServiceProvider();
retVal = md5.ComputeHash(file);
rst = GetCodeByByteArray(retVal);
break;
case FileCodeHashType.SHA1:
SHA1 sha1 = new SHA1CryptoServiceProvider();
retVal = sha1.ComputeHash(file);
rst = GetCodeByByteArray(retVal);
break;
}
file.Close();
}
break;
case FileCodeHashType.CRC16:
rst = CRC16Util.GetFileCRC16(fileName);
break;
case FileCodeHashType.CRC32:
rst = CRC32Util.GetFileCRC32(fileName);
break;
}
return(rst);
}
catch (Exception ex)
{
throw new Exception("GetMD5HashFromFile() fail,error:" + ex.Message);
}
}
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);
}
