private bool ActivateMutable() { Log.LogInformation("About to call ActivatePersistentGridServer.Instance().SetGridActive() for Mutable TRex grid"); bool result = ActivatePersistentGridServer.Instance().SetGridActive(TRexGrids.MutableGridName()); Log.LogInformation($"Activation process completed: Mutable = {result}"); return(result); }
/// <summary> /// Creates an appropriate new Ignite client node depending on the TRex Grid it is being attached to /// </summary> /// <param name="gridName"></param> /// <param name="role"></param> /// <returns></returns> public static IgniteServer NewClientNode(string gridName, string role) { if (gridName.Equals(TRexGrids.MutableGridName())) { return(new MutableClientServer(role)); } if (gridName.Equals(TRexGrids.ImmutableGridName())) { return(new ImmutableClientServer(role)); } throw new ArgumentException($"{gridName} is an unknown grid to create a client node within."); }
public void StartTRexGridCacheNode() { var cfg = new IgniteConfiguration(); ConfigureTRexGrid(cfg); _log.LogInformation($"Creating new Ignite node for {cfg.IgniteInstanceName}"); try { mutableTRexGrid = DIContext.Obtain <ITRexGridFactory>()?.Grid(TRexGrids.MutableGridName(), cfg); } finally { _log.LogInformation($"Completed creation of new Ignite node: Exists = {mutableTRexGrid != null}, Factory available = {DIContext.Obtain<ITRexGridFactory>() != null}"); } // Wait until the grid is active DIContext.Obtain <IActivatePersistentGridServer>().WaitUntilGridActive(TRexGrids.MutableGridName()); // Add the mutable Spatial & NonSpatial caches InstantiateNonSpatialCacheReference(); InstantiateSpatialSubGridDirectoryCacheReference(); InstantiateSpatialSubGridSegmentCacheReference(); InstantiateTAGFileBufferQueueCacheReference(); InstantiateSiteModelExistenceMapsCacheReference(); InstantiateSiteModelsCacheReference(); InstantiateRebuildSiteModelCacheReferences(); InstantiateDesignTopologyExistenceMapsCache(); // Create the SiteModel MetaData Manager so later DI context references wont need to create the cache etc for it at an inappropriate time var _ = DIContext.Obtain <ISiteModelMetadataManager>(); }
/// <summary> /// Constructor that creates a new server instance with a set of roles /// </summary> /// <param name="roles"></param> public MutableClientServer(string[] roles) { if (mutableTRexGrid == null) { // Attempt to attach to an already existing Ignite instance _log.LogInformation("Getting mutable grid"); mutableTRexGrid = DIContext.Obtain <ITRexGridFactory>()?.Grid(StorageMutability.Mutable); _log.LogInformation($"Got {mutableTRexGrid?.Name}"); // If there was no connection obtained, attempt to create a new instance if (mutableTRexGrid == null) { var roleNames = roles.Aggregate("|", (s1, s2) => s1 + s2 + "|"); TRexNodeID = Guid.NewGuid(); _log.LogInformation($"Creating new Ignite node with Roles = {roleNames} & TRexNodeId = {TRexNodeID}"); var cfg = new IgniteConfiguration() { IgniteInstanceName = TRexGrids.MutableGridName(), ClientMode = true, JvmOptions = new List <string>() { "-DIGNITE_QUIET=false", "-Djava.net.preferIPv4Stack=true", "-XX:+UseG1GC", "--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED", "--add-exports=java.base/sun.nio.ch=ALL-UNNAMED", "--add-exports=java.management/com.sun.jmx.mbeanserver=ALL-UNNAMED", "--add-exports=jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED", "--add-exports=java.base/sun.reflect.generics.reflectiveObjects=ALL-UNNAMED", "--illegal-access=permit" }, JvmMaxMemoryMb = DIContext.Obtain <IConfigurationStore>().GetValueInt(IGNITE_JVM_MAX_HEAP_SIZE_MB, DEFAULT_IGNITE_JVM_MAX_HEAP_SIZE_MB), JvmInitialMemoryMb = DIContext.Obtain <IConfigurationStore>().GetValueInt(IGNITE_JVM_INITIAL_HEAP_SIZE_MB, DEFAULT_IGNITE_JVM_INITIAL_HEAP_SIZE_MB), UserAttributes = new Dictionary <string, object>() { { "TRexNodeId", TRexNodeID.ToString() } }, Logger = new TRexIgniteLogger(DIContext.Obtain <IConfigurationStore>(), Logger.CreateLogger("MutableClientServer")), // Set an Ignite metrics heartbeat of 10 seconds MetricsLogFrequency = new TimeSpan(0, 0, 0, 10), PublicThreadPoolSize = DIContext.Obtain <IConfigurationStore>().GetValueInt(IGNITE_PUBLIC_THREAD_POOL_SIZE, DEFAULT_IGNITE_PUBLIC_THREAD_POOL_SIZE), SystemThreadPoolSize = DIContext.Obtain <IConfigurationStore>().GetValueInt(IGNITE_SYSTEM_THREAD_POOL_SIZE, DEFAULT_IGNITE_SYSTEM_THREAD_POOL_SIZE), PeerAssemblyLoadingMode = PeerAssemblyLoadingMode.CurrentAppDomain, BinaryConfiguration = new BinaryConfiguration { Serializer = new BinarizableSerializer() } }; foreach (var roleName in roles) { cfg.UserAttributes.Add($"{ServerRoles.ROLE_ATTRIBUTE_NAME}-{roleName}", "True"); } bool.TryParse(Environment.GetEnvironmentVariable("IS_KUBERNETES"), out var isKubernetes); cfg = isKubernetes ? setKubernetesIgniteConfiguration(cfg) : setLocalIgniteConfiguration(cfg); try { base.ConfigureTRexGrid(cfg); mutableTRexGrid = DIContext.Obtain <ITRexGridFactory>()?.Grid(TRexGrids.MutableGridName(), cfg); } catch (Exception e) { _log.LogError(e, $"Creation of new Ignite node with Role = {roleNames} & TRexNodeId = {TRexNodeID} failed with Exception:"); } finally { _log.LogInformation($"Completed creation of new Ignite node with Role = {roleNames} & TRexNodeId = {TRexNodeID}"); } } } }
/// <summary> /// No-arg constructor. Instantiates the continuous query and performs initial scan of elements that the remote filter /// will populate into the node-local groupers within the mutable grid. /// </summary> public SegmentRetirementQueueManager(bool runLocally) { _log.LogInformation("Establishing segment retirement queue cache context"); // Get the ignite grid and cache references _ignite = DIContext.Obtain <ITRexGridFactory>()?.Grid(StorageMutability.Mutable) ?? Ignition.GetIgnite(TRexGrids.MutableGridName()); var queueCache = _ignite.GetCache <ISegmentRetirementQueueKey, SegmentRetirementQueueItem>(TRexCaches.SegmentRetirementQueueCacheName()); // Todo: Create a thread to periodically (needed if we don't go down the service route // .... _log.LogInformation("Completed segment retirement queue manager initialization"); }
/// <summary> /// Executes the life cycle of the service until it is aborted /// </summary> public void Execute(IServiceContext context) { try { if (_log == null) { Console.WriteLine($"Error: Null logger present in {nameof(TAGFileBufferQueueService)}.{nameof(Execute)}"); } _log.LogInformation($"{nameof(TAGFileBufferQueueService)} {context.Name} starting executing"); _aborted = false; _waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset); // Get the ignite grid and cache references var ignite = DIContext.Obtain <ITRexGridFactory>()?.Grid(StorageMutability.Mutable) ?? Ignition.GetIgnite(TRexGrids.MutableGridName()); if (ignite == null) { _log.LogError("Ignite reference in service is null - aborting service execution"); return; } // Don't start operations until the local (mutable) grid is confirmed as active DIContext.ObtainRequired <IActivatePersistentGridServer>().WaitUntilGridActive(TRexGrids.MutableGridName()); // Once active, delay start of operations for a time to ensure everything is up and running var delay = DIContext.ObtainRequired <IConfigurationStore>().GetValueInt("TREX_TAG_FILE_BUFFER_QUEUE_SERVICE_OPERATION_START_DELAY_SECONDS", 120); _log.LogInformation($"Delaying start of operations for {delay} seconds"); Thread.Sleep(delay * 1000); _log.LogInformation("Obtaining queue cache reference"); var queueCache = ignite.GetCache <ITAGFileBufferQueueKey, TAGFileBufferQueueItem>(TRexCaches.TAGFileBufferQueueCacheName()); _handler = new TAGFileBufferQueueItemHandler(); while (_queryHandle == null && !_aborted) { try { // Construct the continuous query machinery // Set the initial query to return all elements in the cache // Instantiate the queryHandle and start the continuous query on the remote nodes // Note: Only cache items held on this local node will be handled here _log.LogInformation("Obtaining continuous query handle"); _queryHandle = queueCache.QueryContinuous (qry: new ContinuousQuery <ITAGFileBufferQueueKey, TAGFileBufferQueueItem>(new LocalTAGFileListener(_handler)) { Local = true }, initialQry: new ScanQuery <ITAGFileBufferQueueKey, TAGFileBufferQueueItem> { Local = true }); } catch (Exception e) { _log.LogError(e, "Exception while constructing continuous query, will sleep and retry"); Thread.Sleep(5000); } } if (_queryHandle == null || _aborted) { _log.LogInformation("No query handle available, or aborting"); return; } using (_queryHandle) { // Perform the initial query to grab all existing elements and add them to the grouper _log.LogInformation("Performing initial continuous query cursor scan of items"); _queryHandle.GetInitialQueryCursor().ForEach(item => _handler.Add(item.Key)); // Transition into steady state looking for new elements in the cache via the continuous query while (!_aborted) { try { // Cycle looking for new work to do as TAG files arrive until aborted... _log.LogInformation("Entering steady state continuous query scan of items to process in TAGFileBufferQueue"); do { _waitHandle.WaitOne(_serviceCheckIntervalMs); //Log.LogInformation("Continuous query scan of items to process in TAGFileBufferQueue still active"); } while (!_aborted); } catch (Exception e) { _log.LogError(e, "Tag file buffer service unhandled exception, waiting and trying again"); // Sleep for 5 seconds to see if things come right and then try again Thread.Sleep(5000); } } } _handler.Cancel(); } catch (Exception e) { _log.LogError(e, "Exception occurred performing initial set up of continuous query and scan of existing items"); } finally { _log.LogInformation($"{nameof(TAGFileBufferQueueService)} {context.Name} completed executing"); } }
static void Main(string[] args) { EnsureAssemblyDependenciesAreLoaded(); DependencyInjection(); try { Log = Logger.CreateLogger <Program>(); Log.LogInformation("Activating Grids"); Log.LogInformation( "About to call ActivatePersistentGridServer.Instance().SetGridActive() for Mutable TRex grid"); bool result2 = DIContext.Obtain <IActivatePersistentGridServer>().SetGridActive(TRexGrids.MutableGridName()); Log.LogInformation( "About to call ActivatePersistentGridServer.Instance().SetGridActive() for Immutable TRex grid"); bool result1 = DIContext.Obtain <IActivatePersistentGridServer>().SetGridActive(TRexGrids.ImmutableGridName()); Log.LogInformation($"Immutable Grid Active: {result1}"); if (!result1) { Log.LogCritical("Immutable Grid failed to activate"); } Log.LogInformation($"Mutable Grid Active: {result2}"); if (!result2) { Log.LogCritical("Mutable Grid failed to activate"); } } finally { DIContext.Obtain <ITRexGridFactory>()?.StopGrids(); } }
public AddAlignmentRequest() : base(TRexGrids.MutableGridName(), ServerRoles.DATA_MUTATION_ROLE) { }
/// <summary> /// No-arg constructor. Instantiates the continuous query and performs initial scan of elements that the remote filter /// will populate into the node-local groupers within the mutable grid. /// </summary> public TAGFileBufferQueueManager(bool runLocally) { _log.LogInformation("Establishing Ignite and TAG file buffer queue cache contexts"); // Get the ignite grid and cache references _ignite = DIContext.Obtain <ITRexGridFactory>()?.Grid(StorageMutability.Mutable) ?? Ignition.GetIgnite(TRexGrids.MutableGridName()); var queueCache = _ignite.GetCache <ITAGFileBufferQueueKey, TAGFileBufferQueueItem>(TRexCaches.TAGFileBufferQueueCacheName()); var handler = new TAGFileBufferQueueItemHandler(); var tagFileFilter = new RemoteTAGFileFilter(handler); _log.LogInformation("Creating continuous query"); // Construct the continuous query machinery // Set the initial query to return all elements in the cache // Instantiate the queryHandle and start the continuous query on the remote nodes // Note: Only cache items held on this local node will be handled here _queryHandle = queueCache.QueryContinuous (qry: new ContinuousQuery <ITAGFileBufferQueueKey, TAGFileBufferQueueItem>(new LocalTAGFileListener(handler)) { Local = runLocally, Filter = tagFileFilter }, initialQry: new ScanQuery <ITAGFileBufferQueueKey, TAGFileBufferQueueItem> { Local = runLocally, Filter = tagFileFilter }); // Perform the initial query to grab all existing elements and add them to the grouper // All processing should happen on the remote node in the implementation of the TAGFileFilter remote filter foreach (var item in _queryHandle.GetInitialQueryCursor()) { _log.LogError( $"A cache entry ({item.Key}) from the TAG file buffer queue was passed back to the local scan query rather than intercepted by the remote filter"); } _log.LogInformation("Completed TAG file buffer queue manager initialization"); }
/// <summary> /// Default no-arg constructor that sets up cluster and compute projections available for use /// </summary> public CoordinateSystemRequest() : base(TRexGrids.MutableGridName(), ServerRoles.TAG_PROCESSING_NODE) { }
public override void ConfigureTRexGrid(IgniteConfiguration cfg) { base.ConfigureTRexGrid(cfg); cfg.IgniteInstanceName = TRexGrids.MutableGridName(); cfg.JvmMaxMemoryMb = DIContext.Obtain <IConfigurationStore>().GetValueInt(IGNITE_JVM_MAX_HEAP_SIZE_MB, DEFAULT_IGNITE_JVM_MAX_HEAP_SIZE_MB); cfg.JvmInitialMemoryMb = DIContext.Obtain <IConfigurationStore>().GetValueInt(IGNITE_JVM_INITIAL_HEAP_SIZE_MB, DEFAULT_IGNITE_JVM_INITIAL_HEAP_SIZE_MB); cfg.UserAttributes = new Dictionary <string, object> { { "Owner", TRexGrids.MutableGridName() } }; // Configure the Ignite persistence layer to store our data cfg.DataStorageConfiguration = new DataStorageConfiguration { WalMode = WalMode.Fsync, PageSize = DataRegions.DEFAULT_MUTABLE_DATA_REGION_PAGE_SIZE, StoragePath = Path.Combine(TRexServerConfig.PersistentCacheStoreLocation, "Mutable", "Persistence"), WalPath = Path.Combine(TRexServerConfig.PersistentCacheStoreLocation, "Mutable", "WalStore"), WalArchivePath = Path.Combine(TRexServerConfig.PersistentCacheStoreLocation, "Mutable", "WalArchive"), WalSegmentSize = 512 * 1024 * 1024, // Set the WalSegmentSize to 512Mb to better support high write loads (can be set to max 2Gb) MaxWalArchiveSize = (long)10 * 512 * 1024 * 1024, // Ensure there are 10 segments in the WAL archive at the defined segment size DefaultDataRegionConfiguration = new DataRegionConfiguration { Name = DataRegions.DEFAULT_MUTABLE_DATA_REGION_NAME, InitialSize = DIContext.Obtain <IConfigurationStore>().GetValueLong( MUTABLE_DATA_REGION_INITIAL_SIZE_MB, DEFAULT_MUTABLE_DATA_REGION_INITIAL_SIZE_MB) * 1024 * 1024, MaxSize = DIContext.Obtain <IConfigurationStore>().GetValueLong( MUTABLE_DATA_REGION_MAX_SIZE_MB, DEFAULT_MUTABLE_DATA_REGION_MAX_SIZE_MB) * 1024 * 1024, PersistenceEnabled = true }, // Establish a separate data region for the TAG file buffer queue DataRegionConfigurations = new List <DataRegionConfiguration> { new DataRegionConfiguration { Name = DataRegions.TAG_FILE_BUFFER_QUEUE_DATA_REGION, InitialSize = DIContext.Obtain <IConfigurationStore>().GetValueLong( TAG_FILE_BUFFER_QUEUE_DATA_REGION_INITIAL_SIZE_MB, DEFAULT_TAG_FILE_BUFFER_QUEUE_DATA_REGION_INITIAL_SIZE_MB) * 1024 * 1024, MaxSize = DIContext.Obtain <IConfigurationStore>().GetValueLong( TAG_FILE_BUFFER_QUEUE_DATA_REGION_MAX_SIZE_MB, DEFAULT_TAG_FILE_BUFFER_QUEUE_DATA_REGION_MAX_SIZE_MB) * 1024 * 1024, PersistenceEnabled = true } } }; cfg.CacheConfiguration = new List <CacheConfiguration>(); _log.LogInformation($"cfg.DataStorageConfiguration.StoragePath={cfg.DataStorageConfiguration.StoragePath}"); _log.LogInformation($"cfg.DataStorageConfiguration.WalArchivePath={cfg.DataStorageConfiguration.WalArchivePath}"); _log.LogInformation($"cfg.DataStorageConfiguration.WalPath={cfg.DataStorageConfiguration.WalPath}"); cfg.JvmOptions = new List <string>() { "-DIGNITE_QUIET=false", "-Djava.net.preferIPv4Stack=true", "-XX:+UseG1GC", "--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED", "--add-exports=java.base/sun.nio.ch=ALL-UNNAMED", "--add-exports=java.management/com.sun.jmx.mbeanserver=ALL-UNNAMED", "--add-exports=jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED", "--add-exports=java.base/sun.reflect.generics.reflectiveObjects=ALL-UNNAMED", "--illegal-access=permit" }; cfg.Logger = new TRexIgniteLogger(DIContext.Obtain <IConfigurationStore>(), Logger.CreateLogger("MutableCacheComputeServer")); // Set an Ignite metrics heartbeat of 10 seconds cfg.MetricsLogFrequency = new TimeSpan(0, 0, 0, 10); // TODO: This needs to be added to configuration cfg.PublicThreadPoolSize = DIContext.Obtain <IConfigurationStore>().GetValueInt(IGNITE_PUBLIC_THREAD_POOL_SIZE, DEFAULT_IGNITE_PUBLIC_THREAD_POOL_SIZE); cfg.SystemThreadPoolSize = DIContext.Obtain <IConfigurationStore>().GetValueInt(IGNITE_SYSTEM_THREAD_POOL_SIZE, DEFAULT_IGNITE_SYSTEM_THREAD_POOL_SIZE); cfg.PeerAssemblyLoadingMode = PeerAssemblyLoadingMode.CurrentAppDomain; cfg.BinaryConfiguration = new BinaryConfiguration { Serializer = new BinarizableSerializer() }; bool.TryParse(Environment.GetEnvironmentVariable("IS_KUBERNETES"), out var isKubernetes); cfg = isKubernetes ? setKubernetesIgniteConfiguration(cfg) : setLocalIgniteConfiguration(cfg); cfg.WorkDirectory = Path.Combine(TRexServerConfig.PersistentCacheStoreLocation, "Mutable"); }
public TestQueueHolder() { // MutableClientServer Server = new MutableClientServer(new [] { "TestQueue2" }); IIgnite Ignite = DIContext.Obtain <ITRexGridFactory>()?.Grid(StorageMutability.Mutable) ?? Ignition.GetIgnite(TRexGrids.MutableGridName()); QueueCache = Ignite.GetOrCreateCache <long, TestQueueItem>( new CacheConfiguration { Name = "TestQueueCache2", QueryEntities = new[] { new QueryEntity(typeof(long), typeof(TestQueueItem)) }, KeepBinaryInStore = true }); Add(DateTime.UtcNow, "First"); Add(DateTime.UtcNow, "Second"); Add(DateTime.UtcNow, "Third"); Add(DateTime.UtcNow, "Fourth"); Add(DateTime.UtcNow, "Fifth"); }
/// <summary> /// Executes the life cycle of the service until it is aborted /// </summary> public void Execute(IServiceContext context) { try { _log.LogInformation($"{nameof(SegmentRetirementQueueService)} {context.Name} starting executing"); _aborted = false; _waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset); // Get the ignite grid and cache references var mutableIgnite = DIContext.Obtain <ITRexGridFactory>()?.Grid(StorageMutability.Mutable) ?? Ignition.GetIgnite(TRexGrids.MutableGridName()); if (mutableIgnite == null) { _log.LogError("Mutable Ignite reference in service is null - aborting service execution"); return; } // Don't start operations until the local (mutable) grid is confirmed as active DIContext.ObtainRequired <IActivatePersistentGridServer>().WaitUntilGridActive(TRexGrids.MutableGridName()); // Once active, delay start of operations for a time to ensure everything is up and running var delay = DIContext.ObtainRequired <IConfigurationStore>().GetValueInt("TREX_SEGMENT_RETIREMENT_QUEUE_SERVICE_OPERATION_START_DELAY_SECONDS", 120); _log.LogInformation($"Delaying start of operations for {delay} seconds"); Thread.Sleep(delay * 1000); _log.LogInformation("Obtaining queue cache reference"); var queueCache = mutableIgnite.GetCache <ISegmentRetirementQueueKey, SegmentRetirementQueueItem>(TRexCaches.TAGFileBufferQueueCacheName()); var queue = new SegmentRetirementQueue(); var handler = new SegmentRetirementQueueItemHandler(); // Cycle looking for new work to do until aborted... do { try { // Obtain a specific local mutable storage proxy so as to have a local transactional proxy // for this activity var storageProxy = DIContext.Obtain <IStorageProxyFactory>().MutableGridStorage(); if (storageProxy.Mutability != StorageMutability.Mutable) { throw new TRexException("Non mutable storage proxy available to segment retirement queue"); } _log.LogInformation("About to query retiree spatial streams from cache"); var earlierThan = DateTime.UtcNow - retirementAge; // Retrieve the list of segments to be retired var retirees = queue.Query(earlierThan); // Pass the list to the handler for action var retireesCount = retirees?.Count ?? 0; if (retireesCount > 0) { _log.LogInformation($"About to retire {retireesCount} groups of spatial streams from mutable and immutable contexts"); if (handler.Process(storageProxy, queueCache, retirees)) { if (_reportDetailedSegmentRetirementActivityToLog) { _log.LogInformation($"Successfully retired {retireesCount} spatial streams from mutable and immutable contexts"); } // Remove the elements from the segment retirement queue queue.Remove(earlierThan); } else { _log.LogError($"Failed to retire {retireesCount} spatial streams from mutable and immutable contexts"); } } } catch (Exception e) { _log.LogError(e, "Exception reported while obtaining new group of retirees to process:"); } _waitHandle.WaitOne(SEGMENT_RETIREMENT_QUEUE_SERVICE_CHECK_INTERVAL_MS); } while (!_aborted); } catch (Exception e) { _log.LogError(e, $"Unhandled exception occurred in {nameof(SegmentRetirementQueueService)}"); } finally { _log.LogInformation($"{nameof(SegmentRetirementQueueService)} {context.Name} completed executing"); } }
/// <summary> /// Default no-arg constructor that sets up cluster and compute projections available for use by the TAG file processing pipeline /// </summary> public TAGFileProcessingPoolRequest() : base(TRexGrids.MutableGridName(), ServerRoles.TAG_PROCESSING_NODE) { }
public void ImmutableGridName() { TRexGrids.GridName(StorageMutability.Immutable).Should().NotBeNullOrWhiteSpace(); TRexGrids.MutableGridName().Should().Be(TRexGrids.GridName(StorageMutability.Mutable)); }
/// <summary> /// Creates or obtains a reference to an already created TAG file buffer queue /// </summary> private void InstantiateCache() { var ignite = DIContext.Obtain <ITRexGridFactory>()?.Grid(StorageMutability.Mutable) ?? Ignition.GetIgnite(TRexGrids.MutableGridName()); _queueCache = ignite.GetCache <ITAGFileBufferQueueKey, TAGFileBufferQueueItem>(TRexCaches.TAGFileBufferQueueCacheName()); if (_queueCache == null) { _log.LogInformation($"Failed to get Ignite cache {TRexCaches.TAGFileBufferQueueCacheName()}"); throw new ArgumentException("Ignite cache not available"); } }
/// <summary> /// Site model deletion requests are coordinated from the mutable grid. All project information in the mutable grid, and all projections /// of that data present in the immutable grid are removed. /// </summary> public DeleteSiteModelRequest() : base(TRexGrids.MutableGridName(), ServerRoles.TAG_PROCESSING_NODE) { }
public RemoveSurveyedSurfaceRequest() : base(TRexGrids.MutableGridName(), ServerRoles.DATA_MUTATION_ROLE) { }
public RemoveTTMDesignRequest() : base(TRexGrids.MutableGridName(), ServerRoles.DATA_MUTATION_ROLE) { }
/// <summary> /// Site model rebuild requests are coordinated from the mutable grid. /// </summary> public RebuildSiteModelRequest() : base(TRexGrids.MutableGridName(), ServerRoles.PROJECT_REBUILDER_ROLE) { }