| /*========================================================================= |
| * Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved. |
| * This product is protected by U.S. and international copyright |
| * and intellectual property laws. Pivotal products are covered by |
| * more patents listed at http://www.pivotal.io/patents. |
| *========================================================================= |
| */ |
| |
| //#include "gf_includesN.hpp" |
| #include "version.h" |
| #include "SerializableMN.hpp" |
| #include "DistributedSystemMN.hpp" |
| #include "SystemPropertiesMN.hpp" |
| #include "CacheFactoryMN.hpp" |
| #include "CacheableDateMN.hpp" |
| #include "CacheableFileNameMN.hpp" |
| #include "CacheableHashMapMN.hpp" |
| #include "CacheableHashSetMN.hpp" |
| #include "CacheableHashTableMN.hpp" |
| #include "CacheableIdentityHashMapMN.hpp" |
| #include "CacheableObjectArrayMN.hpp" |
| #include "CacheableStringMN.hpp" |
| #include "CacheableStringArrayMN.hpp" |
| #include "CacheableUndefinedMN.hpp" |
| #include "CacheableVectorMN.hpp" |
| #include "CacheableArrayListMN.hpp" |
| #include "CacheableStackMN.hpp" |
| #include "CacheableObjectN.hpp" |
| #include "CacheableObjectXmlN.hpp" |
| #include "CacheableBuiltinsMN.hpp" |
| #include "LogMN.hpp" |
| #include "StructMN.hpp" |
| #include "impl/MemoryPressureHandlerN.hpp" |
| #include <cppcache/CacheLoader.hpp> |
| #include <cppcache/CacheListener.hpp> |
| #include <cppcache/FixedPartitionResolver.hpp> |
| #include <cppcache/CacheWriter.hpp> |
| #include <cppcache/GemfireTypeIds.hpp> |
| #include <cppcache/impl/CacheImpl.hpp> |
| #include <cppcache/impl/PooledBasePool.hpp> |
| #include <cppcache/impl/CacheXmlParser.hpp> |
| #include "impl/SafeConvertN.hpp" |
| #include <cppcache/impl/DistributedSystemImpl.hpp> |
| #include "../../impl/MemoryPressureHandler.hpp" |
| #include "impl/PdxType.hpp" |
| #include "impl/EnumInfo.hpp" |
| #include "impl/ManagedPersistenceManagerN.hpp" |
| |
| // disable spurious warning |
| #pragma warning(disable:4091) |
| #include <msclr/lock.h> |
| #pragma warning(default:4091) |
| #include <ace/Process.h> // Added to get rid of unresolved token warning |
| |
| |
| using namespace System; |
| |
| using namespace GemStone::GemFire::Cache; |
| |
| namespace gemfire |
| { |
| class ManagedCacheLoaderGeneric |
| : public CacheLoader |
| { |
| public: |
| |
| static CacheLoader* create(const char* assemblyPath, |
| const char* factoryFunctionName); |
| }; |
| |
| class ManagedCacheListenerGeneric |
| : public CacheListener |
| { |
| public: |
| |
| static CacheListener* create(const char* assemblyPath, |
| const char* factoryFunctionName); |
| }; |
| |
| class ManagedFixedPartitionResolverGeneric |
| : public FixedPartitionResolver |
| { |
| public: |
| |
| static PartitionResolver* create(const char* assemblyPath, |
| const char* factoryFunctionName); |
| }; |
| |
| class ManagedCacheWriterGeneric |
| : public CacheWriter |
| { |
| public: |
| |
| static CacheWriter* create(const char* assemblyPath, |
| const char* factoryFunctionName); |
| }; |
| |
| class ManagedAuthInitializeGeneric |
| : public AuthInitialize |
| { |
| public: |
| |
| static AuthInitialize* create(const char* assemblyPath, |
| const char* factoryFunctionName); |
| }; |
| } |
| |
| |
| namespace GemStone |
| { |
| namespace GemFire |
| { |
| namespace Cache |
| { |
| namespace Generic |
| { |
| DistributedSystem^ DistributedSystem::Connect(String^ name) |
| { |
| return DistributedSystem::Connect(name, nullptr); |
| } |
| |
| DistributedSystem^ DistributedSystem::Connect(String^ name, Properties<String^, String^>^ config) |
| { |
| gemfire::DistributedSystemImpl::acquireDisconnectLock(); |
| |
| _GF_MG_EXCEPTION_TRY2 |
| |
| ManagedString mg_name(name); |
| |
| gemfire::PropertiesPtr nativepropsptr( |
| GetNativePtr<gemfire::Properties>(config)); |
| |
| // gemfire::PropertiesPtr nativepropsptr; |
| DistributedSystem::AppDomainInstanceInitialization(nativepropsptr); |
| |
| // this we are calling after all .NET initialization required in |
| // each AppDomain |
| gemfire::DistributedSystemPtr& nativeptr( |
| gemfire::DistributedSystem::connect(mg_name.CharPtr, |
| nativepropsptr)); |
| |
| ManagedPostConnect(); |
| |
| // DistributedSystem::AppDomainInstancePostInitialization(); |
| |
| return Create(nativeptr.ptr()); |
| |
| _GF_MG_EXCEPTION_CATCH_ALL2 |
| |
| finally { |
| gemfire::DistributedSystemImpl::releaseDisconnectLock(); |
| } |
| } |
| |
| void DistributedSystem::Disconnect() |
| { |
| gemfire::DistributedSystemImpl::acquireDisconnectLock(); |
| |
| _GF_MG_EXCEPTION_TRY2 |
| |
| if (gemfire::DistributedSystem::isConnected()) { |
| // gemfire::CacheImpl::expiryTaskManager->cancelTask( |
| // s_memoryPressureTaskID); |
| Serializable::UnregisterNativesGeneric(); |
| DistributedSystem::UnregisterBuiltinManagedTypes(); |
| } |
| gemfire::DistributedSystem::disconnect(); |
| |
| _GF_MG_EXCEPTION_CATCH_ALL2 |
| |
| finally { |
| gemfire::DistributedSystemImpl::releaseDisconnectLock(); |
| } |
| } |
| |
| |
| /* DistributedSystem^ DistributedSystem::ConnectOrGetInstance(String^ name) |
| { |
| return DistributedSystem::ConnectOrGetInstance(name, nullptr); |
| } |
| |
| DistributedSystem^ DistributedSystem::ConnectOrGetInstance(String^ name, |
| Properties^ config) |
| { |
| gemfire::DistributedSystemImpl::acquireDisconnectLock(); |
| |
| _GF_MG_EXCEPTION_TRY |
| |
| ManagedString mg_name(name); |
| gemfire::PropertiesPtr nativepropsptr( |
| GetNativePtr<gemfire::Properties>(config)); |
| DistributedSystem::AppDomainInstanceInitialization(nativepropsptr); |
| |
| // this we are calling after all .NET initialization required in |
| // each AppDomain |
| gemfire::DistributedSystemPtr& nativeptr( |
| gemfire::DistributedSystem::connectOrGetInstance(mg_name.CharPtr, |
| nativepropsptr)); |
| |
| if (gemfire::DistributedSystem::currentInstances() == 1) { |
| // stuff to be done only for the first connect |
| ManagedPostConnect(); |
| } |
| |
| DistributedSystem::AppDomainInstancePostInitialization(); |
| |
| return Create(nativeptr.ptr()); |
| |
| _GF_MG_EXCEPTION_CATCH_ALL |
| |
| finally { |
| gemfire::DistributedSystemImpl::releaseDisconnectLock(); |
| } |
| } |
| */ |
| /* int DistributedSystem::DisconnectInstance() |
| { |
| gemfire::DistributedSystemImpl::acquireDisconnectLock(); |
| |
| _GF_MG_EXCEPTION_TRY |
| |
| int remainingInstances = |
| gemfire::DistributedSystem::currentInstances(); |
| if (remainingInstances <= 0) { |
| throw gcnew NotConnectedException("DistributedSystem." |
| "DisconnectInstance: no remaining instance connections"); |
| } |
| |
| //gemfire::CacheImpl::expiryTaskManager->cancelTask( |
| //s_memoryPressureTaskID); |
| Serializable::UnregisterNatives(); |
| |
| if (remainingInstances == 1) { // last instance |
| DistributedSystem::UnregisterBuiltinManagedTypes(); |
| } |
| return gemfire::DistributedSystem::disconnectInstance(); |
| |
| _GF_MG_EXCEPTION_CATCH_ALL |
| |
| finally { |
| gemfire::DistributedSystemImpl::releaseDisconnectLock(); |
| } |
| } |
| */ |
| |
| void DistributedSystem::AppDomainInstanceInitialization( |
| const gemfire::PropertiesPtr& nativepropsptr) |
| { |
| _GF_MG_EXCEPTION_TRY2 |
| |
| // Register wrapper types for built-in types, this are still cpp wrapper |
| |
| /* |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(GemStone::GemFire::Cache::CacheableHashSet::Create), |
| gemfire::GemfireTypeIds::CacheableHashSet); |
| |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(GemStone::GemFire::Cache::CacheableLinkedHashSet::Create), |
| gemfire::GemfireTypeIds::CacheableLinkedHashSet); |
| |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(GemStone::GemFire::Cache::Struct::Create), |
| gemfire::GemfireTypeIds::Struct); |
| |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(GemStone::GemFire::Cache::Properties::CreateDeserializable), |
| gemfire::GemfireTypeIds::Properties); |
| |
| // End register wrapper types for built-in types |
| |
| // Register with cpp using unmanaged Cacheablekey wrapper |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableByte, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableByte::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableBoolean, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableBoolean::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableBytes, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableBytes::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::BooleanArray, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::BooleanArray::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableWideChar, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableCharacter::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CharArray, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CharArray::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableDouble, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableDouble::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableDoubleArray, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableDoubleArray::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableFloat, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableFloat::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableFloatArray, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableFloatArray::CreateDeserializable)); |
| |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableHashSet, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableHashSet::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableLinkedHashSet, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableLinkedHashSet::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableInt16, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableInt16::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableInt16Array, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableInt16Array::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableInt32, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableInt32::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableInt32Array, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableInt32Array::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableInt64, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableInt64::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableInt64Array, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableInt64Array::CreateDeserializable)); |
| */ |
| |
| /*Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableASCIIString, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableString::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableASCIIStringHuge, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableString::createDeserializableHuge)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableString, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableString::createUTFDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableStringHuge, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableString::createUTFDeserializableHuge));*/ |
| |
| /* |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableNullString, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableString::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableStringArray, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableStringArray::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::Struct, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::Struct::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::Properties, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::Properties::CreateDeserializable)); |
| */ |
| |
| // End register other built-in types |
| |
| //primitive types are still C++, as these are used as keys mostly |
| // Register generic wrapper types for built-in types |
| //byte |
| |
| /* Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(CacheableByte::Create), |
| gemfire::GemfireTypeIds::CacheableByte, Byte::typeid);*/ |
| |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(CacheableByte::Create), |
| gemfire::GemfireTypeIds::CacheableByte, SByte::typeid); |
| |
| //boolean |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(CacheableBoolean::Create), |
| gemfire::GemfireTypeIds::CacheableBoolean, Boolean::typeid); |
| //wide char |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(CacheableCharacter::Create), |
| gemfire::GemfireTypeIds::CacheableWideChar, Char::typeid); |
| //double |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(CacheableDouble::Create), |
| gemfire::GemfireTypeIds::CacheableDouble, Double::typeid); |
| //ascii string |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(CacheableString::Create), |
| gemfire::GemfireTypeIds::CacheableASCIIString, String::typeid); |
| |
| //TODO:hitesh |
| ////ascii string huge |
| //Serializable::RegisterWrapperGeneric( |
| // gcnew WrapperDelegateGeneric(CacheableString::Create), |
| // gemfire::GemfireTypeIds::CacheableASCIIStringHuge, String::typeid); |
| ////string |
| //Serializable::RegisterWrapperGeneric( |
| // gcnew WrapperDelegateGeneric(CacheableString::Create), |
| // gemfire::GemfireTypeIds::CacheableString, String::typeid); |
| ////string huge |
| //Serializable::RegisterWrapperGeneric( |
| // gcnew WrapperDelegateGeneric(CacheableString::Create), |
| // gemfire::GemfireTypeIds::CacheableStringHuge, String::typeid); |
| //float |
| |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(CacheableFloat::Create), |
| gemfire::GemfireTypeIds::CacheableFloat, float::typeid); |
| //int 16 |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(CacheableInt16::Create), |
| gemfire::GemfireTypeIds::CacheableInt16, Int16::typeid); |
| //int32 |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(CacheableInt32::Create), |
| gemfire::GemfireTypeIds::CacheableInt32, Int32::typeid); |
| //int64 |
| Serializable::RegisterWrapperGeneric( |
| gcnew WrapperDelegateGeneric(CacheableInt64::Create), |
| gemfire::GemfireTypeIds::CacheableInt64, Int64::typeid); |
| |
| ////uint16 |
| //Serializable::RegisterWrapperGeneric( |
| // gcnew WrapperDelegateGeneric(CacheableInt16::Create), |
| // gemfire::GemfireTypeIds::CacheableInt16, UInt16::typeid); |
| ////uint32 |
| //Serializable::RegisterWrapperGeneric( |
| // gcnew WrapperDelegateGeneric(CacheableInt32::Create), |
| // gemfire::GemfireTypeIds::CacheableInt32, UInt32::typeid); |
| ////uint64 |
| //Serializable::RegisterWrapperGeneric( |
| // gcnew WrapperDelegateGeneric(CacheableInt64::Create), |
| // gemfire::GemfireTypeIds::CacheableInt64, UInt64::typeid); |
| //======================================================================= |
| |
| //Now onwards all will be wrap in managed cacheable key.. |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableBytes, |
| gcnew TypeFactoryMethodGeneric(CacheableBytes::CreateDeserializable), |
| Type::GetType("System.Byte[]")); |
| |
| /* Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableBytes, |
| gcnew TypeFactoryMethodGeneric(CacheableBytes::CreateDeserializable), |
| Type::GetType("System.SByte[]"));*/ |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableDoubleArray, |
| gcnew TypeFactoryMethodGeneric(CacheableDoubleArray::CreateDeserializable), |
| Type::GetType("System.Double[]")); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableFloatArray, |
| gcnew TypeFactoryMethodGeneric(CacheableFloatArray::CreateDeserializable), |
| Type::GetType("System.Single[]")); |
| |
| //TODO:hitesh |
| //as it is |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableHashSet, |
| gcnew TypeFactoryMethodGeneric(CacheableHashSet::CreateDeserializable), |
| nullptr); |
| |
| //as it is |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableLinkedHashSet, |
| gcnew TypeFactoryMethodGeneric(CacheableLinkedHashSet::CreateDeserializable), |
| nullptr); |
| |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableInt16Array, |
| gcnew TypeFactoryMethodGeneric(CacheableInt16Array::CreateDeserializable), |
| Type::GetType("System.Int16[]")); |
| |
| /* Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableInt16Array, |
| gcnew TypeFactoryMethodGeneric(CacheableInt16Array::CreateDeserializable), |
| Type::GetType("System.UInt16[]"));*/ |
| |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableInt32Array, |
| gcnew TypeFactoryMethodGeneric(CacheableInt32Array::CreateDeserializable), |
| Type::GetType("System.Int32[]")); |
| |
| /* Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableInt32Array, |
| gcnew TypeFactoryMethodGeneric(CacheableInt32Array::CreateDeserializable), |
| Type::GetType("System.UInt32[]"));*/ |
| |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableInt64Array, |
| gcnew TypeFactoryMethodGeneric(CacheableInt64Array::CreateDeserializable), |
| Type::GetType("System.Int64[]")); |
| |
| /* Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableInt64Array, |
| gcnew TypeFactoryMethodGeneric(CacheableInt64Array::CreateDeserializable), |
| Type::GetType("System.UInt64[]"));*/ |
| //TODO:;split |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::BooleanArray, |
| gcnew TypeFactoryMethodGeneric(BooleanArray::CreateDeserializable), |
| Type::GetType("System.Boolean[]")); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CharArray, |
| gcnew TypeFactoryMethodGeneric(CharArray::CreateDeserializable), |
| Type::GetType("System.Char[]")); |
| |
| //TODO::hitesh |
| |
| //Serializable::RegisterTypeGeneric( |
| // gemfire::GemfireTypeIds::CacheableNullString, |
| // gcnew TypeFactoryMethodNew(GemStone::GemFire::Cache::CacheableString::CreateDeserializable)); |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableStringArray, |
| gcnew TypeFactoryMethodGeneric(CacheableStringArray::CreateDeserializable), |
| Type::GetType("System.String[]")); |
| |
| //as it is |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::Struct, |
| gcnew TypeFactoryMethodGeneric(Struct::CreateDeserializable), |
| nullptr); |
| |
| //as it is |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::Properties, |
| gcnew TypeFactoryMethodGeneric(Properties<String^, String^>::CreateDeserializable), |
| nullptr); |
| |
| /* Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::PdxType, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::Generic::Internal::PdxType::CreateDeserializable), |
| nullptr);*/ |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::EnumInfo, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::Generic::Internal::EnumInfo::CreateDeserializable), |
| nullptr); |
| |
| // End register generic wrapper types for built-in types |
| |
| if (!gemfire::DistributedSystem::isConnected()) |
| { |
| // Set the Generic ManagedAuthInitialize factory function |
| gemfire::SystemProperties::managedAuthInitializeFn = |
| gemfire::ManagedAuthInitializeGeneric::create; |
| |
| // Set the Generic ManagedCacheLoader/Listener/Writer factory functions. |
| gemfire::CacheXmlParser::managedCacheLoaderFn = |
| gemfire::ManagedCacheLoaderGeneric::create; |
| gemfire::CacheXmlParser::managedCacheListenerFn = |
| gemfire::ManagedCacheListenerGeneric::create; |
| gemfire::CacheXmlParser::managedCacheWriterFn = |
| gemfire::ManagedCacheWriterGeneric::create; |
| |
| // Set the Generic ManagedPartitionResolver factory function |
| gemfire::CacheXmlParser::managedPartitionResolverFn = |
| gemfire::ManagedFixedPartitionResolverGeneric::create; |
| |
| // Set the Generic ManagedPersistanceManager factory function |
| gemfire::CacheXmlParser::managedPersistenceManagerFn = |
| gemfire::ManagedPersistenceManagerGeneric::create; |
| } |
| |
| _GF_MG_EXCEPTION_CATCH_ALL2 |
| } |
| |
| void DistributedSystem::ManagedPostConnect() |
| { |
| // [sumedh] The registration into the native map should be after |
| // native connect since it can be invoked only once |
| |
| // Register other built-in types |
| /* |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableDate, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableDate::CreateDeserializable)); |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableFileName, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableFileName::CreateDeserializable)); |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableHashMap, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableHashMap::CreateDeserializable)); |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableHashTable, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableHashTable::CreateDeserializable)); |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableIdentityHashMap, |
| gcnew TypeFactoryMethodGeneric( |
| GemStone::GemFire::Cache::CacheableIdentityHashMap::CreateDeserializable)); |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableUndefined, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableUndefined::CreateDeserializable)); |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableVector, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableVector::CreateDeserializable)); |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableObjectArray, |
| gcnew TypeFactoryMethodGeneric( |
| GemStone::GemFire::Cache::CacheableObjectArray::CreateDeserializable)); |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableArrayList, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableArrayList::CreateDeserializable)); |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableStack, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableStack::CreateDeserializable)); |
| Serializable::RegisterTypeGeneric( |
| GemFireClassIds::CacheableManagedObject - 0x80000000, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableObject::CreateDeserializable)); |
| Serializable::RegisterTypeGeneric( |
| GemFireClassIds::CacheableManagedObjectXml - 0x80000000, |
| gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::CacheableObjectXml::CreateDeserializable)); |
| */ |
| // End register other built-in types |
| |
| // Register other built-in types for generics |
| //c# datatime |
| |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableDate, |
| gcnew TypeFactoryMethodGeneric(CacheableDate::CreateDeserializable), |
| Type::GetType("System.DateTime")); |
| |
| //as it is |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableFileName, |
| gcnew TypeFactoryMethodGeneric(CacheableFileName::CreateDeserializable), |
| nullptr); |
| |
| //for generic dictionary define its type in static constructor of SerializableMN.hpp |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableHashMap, |
| gcnew TypeFactoryMethodGeneric(CacheableHashMap::CreateDeserializable), |
| nullptr); |
| |
| //c# hashtable |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableHashTable, |
| gcnew TypeFactoryMethodGeneric(CacheableHashTable::CreateDeserializable), |
| Type::GetType("System.Collections.Hashtable")); |
| |
| //Need to keep public as no counterpart in c# |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableIdentityHashMap, |
| gcnew TypeFactoryMethodGeneric( |
| CacheableIdentityHashMap::CreateDeserializable), |
| nullptr); |
| |
| //keep as it is |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableUndefined, |
| gcnew TypeFactoryMethodGeneric(CacheableUndefined::CreateDeserializable), |
| nullptr); |
| |
| //c# arraylist |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableVector, |
| gcnew TypeFactoryMethodGeneric(CacheableVector::CreateDeserializable), |
| nullptr); |
| |
| //as it is |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableObjectArray, |
| gcnew TypeFactoryMethodGeneric( |
| CacheableObjectArray::CreateDeserializable), |
| nullptr); |
| |
| //Generic::List |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableArrayList, |
| gcnew TypeFactoryMethodGeneric(CacheableArrayList::CreateDeserializable), |
| nullptr); |
| |
| //c# generic stack |
| Serializable::RegisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableStack, |
| gcnew TypeFactoryMethodGeneric(CacheableStack::CreateDeserializable), |
| nullptr); |
| |
| //as it is |
| Serializable::RegisterTypeGeneric( |
| GemFireClassIds::CacheableManagedObject - 0x80000000, |
| gcnew TypeFactoryMethodGeneric(CacheableObject::CreateDeserializable), |
| nullptr); |
| |
| //as it is |
| Serializable::RegisterTypeGeneric( |
| GemFireClassIds::CacheableManagedObjectXml - 0x80000000, |
| gcnew TypeFactoryMethodGeneric(CacheableObjectXml::CreateDeserializable), |
| nullptr); |
| |
| // End register other built-in types |
| |
| // TODO: what will happen for following if first appDomain unload ?? |
| // Testing shows that there are problems; need to discuss -- maybe |
| // maintain per AppDomainID functions in C++ layer. |
| |
| // Log the version of the C# layer being used |
| Log::Config(".NET layer assembly version: {0}({1})", System::Reflection:: |
| Assembly::GetExecutingAssembly()->GetName()->Version->ToString(), |
| System::Reflection::Assembly::GetExecutingAssembly()->ImageRuntimeVersion); |
| |
| Log::Config(".NET runtime version: {0} ",System::Environment::Version); |
| Log::Config(".NET layer source repository (revision): {0} ({1})", |
| GEMFIRE_SOURCE_REPOSITORY, GEMFIRE_SOURCE_REVISION); |
| } |
| |
| void DistributedSystem::AppDomainInstancePostInitialization() |
| { |
| //to create .net memory pressure handler |
| Create(gemfire::DistributedSystem::getInstance().ptr()); |
| } |
| |
| void DistributedSystem::UnregisterBuiltinManagedTypes() |
| { |
| _GF_MG_EXCEPTION_TRY2 |
| |
| gemfire::DistributedSystemImpl::acquireDisconnectLock(); |
| |
| Serializable::UnregisterNativesGeneric(); |
| |
| int remainingInstances = |
| gemfire::DistributedSystemImpl::currentInstances(); |
| |
| if (remainingInstances == 0) { // last instance |
| |
| |
| Serializable::UnregisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableDate); |
| Serializable::UnregisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableFileName); |
| Serializable::UnregisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableHashMap); |
| Serializable::UnregisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableHashTable); |
| Serializable::UnregisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableIdentityHashMap); |
| Serializable::UnregisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableVector); |
| Serializable::UnregisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableObjectArray); |
| Serializable::UnregisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableArrayList); |
| Serializable::UnregisterTypeGeneric( |
| gemfire::GemfireTypeIds::CacheableStack); |
| Serializable::UnregisterTypeGeneric( |
| GemFireClassIds::CacheableManagedObject - 0x80000000); |
| Serializable::UnregisterTypeGeneric( |
| GemFireClassIds::CacheableManagedObjectXml - 0x80000000); |
| |
| } |
| |
| _GF_MG_EXCEPTION_CATCH_ALL2 |
| |
| finally { |
| gemfire::DistributedSystemImpl::releaseDisconnectLock(); |
| } |
| } |
| |
| GemStone::GemFire::Cache::Generic::SystemProperties^ DistributedSystem::SystemProperties::get() |
| { |
| _GF_MG_EXCEPTION_TRY2 |
| |
| // VJR: TODO |
| return GemStone::GemFire::Cache::Generic::SystemProperties::Create( |
| gemfire::DistributedSystem::getSystemProperties()); |
| |
| //return nullptr; |
| |
| _GF_MG_EXCEPTION_CATCH_ALL2 |
| } |
| |
| String^ DistributedSystem::Name::get() |
| { |
| return ManagedString::Get(NativePtr->getName()); |
| } |
| |
| bool DistributedSystem::IsConnected::get() |
| { |
| return gemfire::DistributedSystem::isConnected(); |
| } |
| |
| DistributedSystem^ DistributedSystem::GetInstance() |
| { |
| gemfire::DistributedSystemPtr& nativeptr( |
| gemfire::DistributedSystem::getInstance()); |
| return Create(nativeptr.ptr()); |
| } |
| |
| void DistributedSystem::HandleMemoryPressure(System::Object^ state) |
| { |
| ACE_Time_Value dummy(1); |
| MemoryPressureHandler handler; |
| handler.handle_timeout(dummy, nullptr); |
| } |
| |
| DistributedSystem^ DistributedSystem::Create( |
| gemfire::DistributedSystem* nativeptr) |
| { |
| if (m_instance == nullptr) { |
| msclr::lock lockInstance(m_singletonSync); |
| if (m_instance == nullptr) { |
| m_instance = (nativeptr != nullptr |
| ? gcnew DistributedSystem(nativeptr) : nullptr); |
| } |
| } |
| DistributedSystem^ instance = (DistributedSystem^)m_instance; |
| return instance; |
| } |
| |
| DistributedSystem::DistributedSystem(gemfire::DistributedSystem* nativeptr) |
| : SBWrap(nativeptr) |
| { |
| System::Threading::TimerCallback^ timerCallback = gcnew System:: |
| Threading::TimerCallback(&DistributedSystem::HandleMemoryPressure); |
| m_memoryPressureHandler = gcnew System::Threading::Timer( |
| timerCallback, "MemoryPressureHandler", 3*60000, 3*60000); |
| } |
| |
| DistributedSystem::~DistributedSystem() |
| { |
| m_memoryPressureHandler->Dispose(nullptr); |
| } |
| |
| void DistributedSystem::acquireDisconnectLock() |
| { |
| gemfire::DistributedSystemImpl::acquireDisconnectLock(); |
| } |
| |
| void DistributedSystem::disconnectInstance() |
| { |
| gemfire::DistributedSystemImpl::disconnectInstance(); |
| } |
| |
| void DistributedSystem::releaseDisconnectLock() |
| { |
| gemfire::DistributedSystemImpl::releaseDisconnectLock(); |
| } |
| |
| void DistributedSystem::connectInstance() |
| { |
| gemfire::DistributedSystemImpl::connectInstance(); |
| } |
| |
| void DistributedSystem::registerCliCallback() |
| { |
| m_cliCallBackObj = gcnew CliCallbackDelegate(); |
| cliCallback^ nativeCallback = |
| gcnew cliCallback(m_cliCallBackObj, |
| &CliCallbackDelegate::Callback); |
| |
| gemfire::DistributedSystemImpl::registerCliCallback( System::Threading::Thread::GetDomainID(), |
| (gemfire::CliCallbackMethod)System::Runtime::InteropServices:: |
| Marshal::GetFunctionPointerForDelegate( |
| nativeCallback).ToPointer()); |
| } |
| |
| void DistributedSystem::unregisterCliCallback() |
| { |
| gemfire::DistributedSystemImpl::unregisterCliCallback( System::Threading::Thread::GetDomainID()); |
| } |
| } // end namespace generic |
| } |
| } |
| } |
