public void Stop() { if (!m_started) { return; } try { Log.WriteLine(LogLevel.Debug, "Stopping communication instance."); // TODO notify the modules if (HasHttpEndpoints()) { StopHttpServer(); } // Unregister cloud storage memory_cloud = null; // Shutdown message passing networking NativeNetwork.StopTrinityServer(); // Unregister communication instance Global.CommunicationInstance = null; var _config = TrinityConfig.CurrentClusterConfig; m_started = false; Log.WriteLine("{0} {1} is successfully stopped.", RunningMode, _config.MyInstanceId); } catch (Exception ex) { Log.WriteLine(LogLevel.Error, "CommunicationInstance: " + ex.ToString()); } }
/// <summary> /// Stops a Trinity instance. /// </summary> public void Stop() { lock (m_lock) { if (!m_started) { return; } try { int id = memory_cloud.MyInstanceId; Log.WriteLine(LogLevel.Debug, "Stopping communication instance."); // TODO notify the modules StopCommunicationListeners(); m_module_init_signal.Reset(); // Unregister cloud storage memory_cloud = null; // Unregister communication instance Global.CommunicationInstance = null; m_started = false; Log.WriteLine("{0} {1} is successfully stopped.", RunningMode, id); } catch (Exception ex) { Log.WriteLine(LogLevel.Error, "CommunicationInstance: " + ex.ToString()); } } }
public ClientIStorage(MemoryCloud mc) { m_messages = new ConcurrentQueue <TrinityMessage>(); m_req_tokens = new ConcurrentDictionary <long, TaskCompletionSource <bool> >(); m_rsp_tokens = new ConcurrentDictionary <long, TaskCompletionSource <TrinityResponse> >(); m_mc = mc; }
/// <summary> /// It is guaranteed that CloudStorage can be accessed (server started) /// before a client calls module ClientInitialize() method. /// </summary> public unsafe void ClientInitialize(RunningMode remoteRunningMode, MemoryCloud mc) { m_memorycloud = mc; string moduleName = GetModuleName(); IMessagePassingEndpoint rs = remoteRunningMode == RunningMode.Server ? mc.StorageTable.FirstOrDefault(_ => !(_ is LocalMemoryStorage)) as IMessagePassingEndpoint : mc.ProxyList.FirstOrDefault(); if (null == rs) { string msg = "ClientInitialize: " + moduleName + ": No remote communication instance found."; Log.WriteLine(LogLevel.Error, msg); throw new InvalidOperationException(msg); } ushort synReqOffset; ushort synReqRspOffset; ushort asynReqOffset; ushort asynReqRspOffset; if (!rs.GetCommunicationModuleOffset(moduleName, out synReqOffset, out synReqRspOffset, out asynReqOffset, out asynReqRspOffset)) { string msg = "CommunicationModule " + moduleName + " not found on the remote side."; Log.WriteLine(LogLevel.Error, msg); throw new InvalidOperationException(msg); } else { this.SynReqIdOffset = synReqOffset; this.SynReqRspIdOffset = synReqRspOffset; this.AsynReqIdOffset = asynReqOffset; this.AsynReqRspIdOffset = asynReqRspOffset; } }
/// <summary> /// Creates a cloud storage instance with the specified name. /// </summary> /// <param name="config">A ClusterConfig instance.</param> /// <returns>The newly created cloud storage instance.</returns> public static MemoryCloud CreateCloudStorage(ClusterConfig config) { lock (s_storage_init_lock) { MemoryCloud mc = new MemoryCloud(config); mc.RegisterGenericOperationsProvider(generic_cell_ops); s_registered_memoryclouds.Add(mc); return(mc); } }
/// <summary> /// Starts a Trinity instance. /// </summary> public void Start() { lock (m_lock) { if (m_started) { return; } try { Log.WriteLine(LogLevel.Debug, "Starting communication instance."); var _config = TrinityConfig.CurrentClusterConfig; _config.RunningMode = this.RunningMode; Global.CommunicationInstance = this; if (_InstanceList.Count == 0) { Log.WriteLine(LogLevel.Warning, "No distributed instances configured. Turning on local test mode."); TrinityConfig.LocalTest = true; } // Initialize message handlers MessageHandlers.Initialize(); RegisterMessageHandler(); // Initialize message passing networking NativeNetwork.StartTrinityServer((UInt16)_config.ListeningPort); Log.WriteLine("My IPEndPoint: " + _config.MyBoundIP + ":" + _config.ListeningPort); // Initialize cloud storage memory_cloud = Global.CloudStorage; // Initialize the modules _InitializeModules(); if (HasHttpEndpoints()) { StartHttpServer(); } Console.WriteLine("Working Directory: {0}", Global.MyAssemblyPath); Console.WriteLine(_config.OutputCurrentConfig()); Console.WriteLine(TrinityConfig.OutputCurrentConfig()); m_started = true; Log.WriteLine("{0} {1} is successfully started.", RunningMode, _config.MyInstanceId); _RaiseStartedEvents(); } catch (Exception ex) { Log.WriteLine(LogLevel.Error, "CommunicationInstance: " + ex.ToString()); } } }
/// <summary> /// Constructs a MessageSorter instance /// </summary> public MessageSorter(MemoryCloud mc = null) { memory_cloud = mc; if (memory_cloud == null) { memory_cloud = Global.CloudStorage; } dest_cell_ids = new List <long> [memory_cloud.ServerCount]; for (int i = 0; i < memory_cloud.ServerCount; i++) { dest_cell_ids[i] = new List <long>(); } }
public CloudIndex(CancellationToken token, INameService namesvc, IChunkTable ctable, MemoryCloud mc, string nickname, Func <int, Partition> ptable) { m_mc = mc; m_myname = nickname; m_partitions = ptable; m_nameservice = namesvc; m_chunktable = ctable; m_cancel = token; m_storagetab = new Dictionary <Guid, IStorage>(); m_ctcache = new Dictionary <Guid, IEnumerable <Chunk> >(); m_masters = new IStorage[m_nameservice.PartitionCount]; m_replicaList = Utils.Integers(m_nameservice.PartitionCount).Select(_ => Enumerable.Empty <ReplicaInformation>()).ToArray(); m_ctupdateproc = Utils.Daemon(m_cancel, "ChunkTableUpdateProc", 10000, ChunkTableUpdateProc); m_masterproc = Utils.Daemon(m_cancel, "MasterNotifyProc", 10000, MasterNotifyProc); m_scanproc = Utils.Daemon(m_cancel, "ScanNodesProc", 10000, ScanNodesProc); }
/// <summary> /// Starts a Trinity instance. /// </summary> public unsafe void Start() { lock (m_lock) { if (m_started) { return; } try { Log.WriteLine(LogLevel.Debug, "Starting communication instance."); Global.CommunicationInstance = this; TrinityConfig.CurrentRunningMode = this.RunningMode; // Initialize message handlers MessageHandlers.Initialize(); RegisterMessageHandler(); MessageDispatcher = _MessageInitializationTrap; // Bring up networking subsystems StartCommunicationListeners(); // Initialize cloud storage memory_cloud = Global.CloudStorage; // Initialize the modules _ScanForAutoRegisteredModules(); _InitializeModules(); // Modules initialized, release pending messages from the trap m_module_init_signal.Set(); MessageDispatcher = MessageHandlers.DefaultParser.DispatchMessage; Log.WriteLine("Working Directory: {0}", Global.MyAssemblyPath); Log.WriteLines(TrinityConfig.OutputCurrentConfig()); m_started = true; Log.WriteLine("{0} {1} is successfully started.", RunningMode, memory_cloud.MyInstanceId); _RaiseStartedEvents(); } catch (Exception ex) { Log.WriteLine(LogLevel.Error, "CommunicationInstance: " + ex.ToString()); } } }
/// <summary> /// It is guaranteed that CloudStorage can be accessed (server started) /// before a client calls module ClientInitialize() method. /// </summary> internal protected unsafe void ClientInitialize(RunningMode remoteRunningMode, MemoryCloud mc = null) { //Debug.Assert(TrinityConfig.CurrentRunningMode == RunningMode.Client); //Debug.Assert(remoteRunningMode == RunningMode.Server || remoteRunningMode == RunningMode.Proxy); if (mc == null) { mc = Global.CloudStorage; } m_memoryCloud = mc; string moduleName = GetModuleName(); RemoteStorage rs = remoteRunningMode == RunningMode.Server ? mc.StorageTable.FirstOrDefault(_ => _ is RemoteStorage) as RemoteStorage : mc.ProxyList.FirstOrDefault(); if (null == rs) { string msg = "ClientInitialize: " + moduleName + ": No remote communication instance found."; Log.WriteLine(LogLevel.Error, msg); throw new InvalidOperationException(msg); } ushort synReqOffset; ushort synReqRspOffset; ushort asynReqOffset; if (!rs.GetCommunicationModuleOffset(moduleName, out synReqOffset, out synReqRspOffset, out asynReqOffset)) { string msg = "CommunicationModule " + moduleName + " not found on the remote side."; Log.WriteLine(LogLevel.Error, msg); throw new InvalidOperationException(msg); } else { this.SynReqIdOffset = synReqOffset; this.SynReqRspIdOffset = synReqRspOffset; this.AsynReqIdOffset = asynReqOffset; } SetupMessagePassingInterfaces(remoteRunningMode); }
private unsafe void ServerInitialize(CommunicationInstance instance) { m_memorycloud = Global.CloudStorage; ICommunicationSchema schema = this.GetCommunicationSchema(); this.SynReqIdOffset = instance.SynReqIdOffset; this.SynReqRspIdOffset = instance.SynReqRspIdOffset; this.AsynReqIdOffset = instance.AsynReqIdOffset; this.AsynReqRspIdOffset = instance.AsynReqRspIdOffset; checked { instance.SynReqIdOffset += (ushort)schema.SynReqProtocolDescriptors.Count(); instance.SynReqRspIdOffset += (ushort)schema.SynReqRspProtocolDescriptors.Count(); instance.AsynReqIdOffset += (ushort)schema.AsynReqProtocolDescriptors.Count(); instance.AsynReqRspIdOffset += (ushort)schema.AsynReqRspProtocolDescriptors.Count(); // each ASYNC_WITH_RSP message comes with a response handler. instance.AsynReqIdOffset += (ushort)schema.AsynReqRspProtocolDescriptors.Count(); } }
/// <summary> /// It is guaranteed that CloudStorage can be accessed (native server started) /// before an instance calls module Initialize() method. /// </summary> internal unsafe void Initialize(CommunicationInstance instance) { //Debug.Assert(TrinityConfig.CurrentRunningMode != RunningMode.Client); //Debug.Assert(TrinityConfig.CurrentRunningMode != RunningMode.Embedded); //Debug.Assert(TrinityConfig.CurrentRunningMode != RunningMode.Undefined); ICommunicationSchema schema = this.GetCommunicationSchema(); m_memoryCloud = instance.CloudStorage; this.SynReqIdOffset = instance.SynReqIdOffset; this.SynReqRspIdOffset = instance.SynReqRspIdOffset; this.AsynReqIdOffset = instance.AsynReqIdOffset; checked { instance.SynReqIdOffset += (ushort)schema.SynReqProtocolDescriptors.Count(); instance.SynReqRspIdOffset += (ushort)schema.SynReqRspProtocolDescriptors.Count(); instance.AsynReqIdOffset += (ushort)schema.AsynReqProtocolDescriptors.Count(); } this.RegisterMessageHandler(); SetupMessagePassingInterfaces(instance.RunningMode); }
public DynamicRemoteStorage(ReplicaInformation server_info, int connPerServer, MemoryCloud mc) : base(new[] { new ServerInfo(server_info.Address, server_info.Port, null, LogLevel.Info) }, connPerServer, mc, server_info.PartitionId, nonblocking: true) { ReplicaInformation = server_info; NickName = Utils.GenerateNickName(ReplicaInformation.Id); }