public virtual void handleIsClusterInStateTransfer(Address sender) { Message msg = new Message(sender, null, new byte[0]); GMS.HDR hdr = new GMS.HDR(GMS.HDR.IS_NODE_IN_STATE_TRANSFER_RSP); gms.Stack.NCacheLog.Debug("gmsImpl.handleIsClusterInStateTransfer", "(state transfer request) sender: " + sender + " ->" + isInStateTransfer); hdr.arg = isInStateTransfer; msg.putHeader(HeaderType.GMS,hdr); gms.passDown(new Event(Event.MSG,msg,Alachisoft.NCache.Common.Enum.Priority.Critical)); }
public bool SendInitializationPhaseRsp(bool initializationPhase) { self_close = true; ConnectionHeader header = new ConnectionHeader(ConnectionHeader.INITIALIZATION_PHASE_RSP); header.InitializationPhase = initializationPhase; Message closeMsg = new Message(peer_addr, null, new byte[0]); closeMsg.putHeader("ConnectionHeader", header); if (NCacheLog.IsInfoEnabled) NCacheLog.Info("Connection.SendSilentCloseNotification", "sending silent close request"); try { lock (initializationPhase_mutex) { byte[] binaryMsg = Util.Util.serializeMessage(closeMsg); SendInternal(binaryMsg); Monitor.Wait(initializationPhase_mutex); return inInitializationPhase; } } catch (Exception e) { NCacheLog.Error("Connection.SendSilentCloseNotification", e.ToString()); } return false; }
internal virtual void sendJoinMessage(Address coord, Address mbr, string subGroup_name, bool isStartedAsMirror) { Message msg; GMS.HDR hdr; msg = new Message(coord, null, null); hdr = new GMS.HDR(GMS.HDR.JOIN_REQ, mbr, subGroup_name, isStartedAsMirror); hdr.GMSId = gms.unique_id; msg.putHeader(HeaderType.GMS, hdr); gms.passDown(new Event(Event.MSG_URGENT, msg, Priority.Critical)); }
public override void handleNodeRejoining(Address node) { if (node != null) { if (gms.Stack.NCacheLog.IsInfoEnabled) gms.Stack.NCacheLog.Info("ParticipantGmsImpl.handleNodeRejoining", "I should inform coordinator about node rejoining with " + node); if (gms.members.contains(node)) { //inform coordinator about the node rejoining in the cluster. GMS.HDR header = new GMS.HDR(GMS.HDR.INFORM_NODE_REJOINING, node); Message rejoiningMsg = new Message(gms.determineCoordinator(), null, new byte[0]); rejoiningMsg.putHeader(HeaderType.GMS, header); gms.passDown(new Event(Event.MSG, rejoiningMsg, Priority.Critical)); } } }
public override void handleConnectedNodesRequest(Address src,int reqId) { if (gms.determineCoordinator().Equals(src)) { ArrayList mbrs = gms.members.Members; ArrayList suspected = suspected_mbrs.Clone() as ArrayList; foreach (Address suspect in suspected_mbrs) { mbrs.Remove(suspect); } if (gms.Stack.NCacheLog.IsInfoEnabled) gms.Stack.NCacheLog.Info("ParticipantGmsImp.handleConnectedNodesRequest " + gms.local_addr + " --> " + Global.ArrayListToString(mbrs)); Message rspMsg = new Message(src,null,new byte[0]); GMS.HDR hdr = new GMS.HDR(GMS.HDR.CONNECTED_NODES_RESPONSE,(Object)reqId); hdr.nodeList = mbrs; rspMsg.putHeader(HeaderType.GMS,hdr); gms.passDown(new Event(Event.MSG,rspMsg,Priority.Critical)); } }
public virtual Message makeReply( ) { Message m = new Message(src_addr, null, null); m.IsUserMsg = IsUserMsg; m.dest_addr = src_addr; m.profileid = profileid; m.isProfilable = isProfilable; if(IsProfilable) m.TraceMsg = traceMsg + "-->complete"; return m; }
/// <summary> Create a copy of the message. If offset and length are used (to refer to another buffer), the copy will /// contain only the subset offset and length point to, copying the subset into the new copy. /// </summary> /// <param name="">copy_buffer /// </param> /// <returns> /// </returns> public virtual Message copy(bool copy_buffer,MemoryManager memManaager) { Message retval = null; if (memManaager != null) { ObjectProvider provider = memManaager.GetProvider(typeof(Message)); if(provider != null) retval = (Message)provider.RentAnObject(); } else retval = new Message(); retval.dest_addr = dest_addr; retval.dest_addrs = dest_addrs; retval.src_addr = src_addr; retval.prio = prio; retval.isUserMsg = isUserMsg; retval.isProfilable = IsProfilable; retval.ProfileId = profileid; retval.psTime = psTime; retval.tnspTime = tnspTime; retval.traceMsg = traceMsg; retval.RequestId = reqId; retval.handledAsynchronously = handledAsynchronously; retval.responseExpected = responseExpected; if (copy_buffer && buf != null) { retval.setBuffer(buf, offset, length); } if (headers != null) { retval.headers = (Hashtable)headers.Clone(); } retval.Payload = this.Payload; return retval; }
/// <summary> /// Send a broadcast no reply message to a specific node /// </summary> /// <param name="dest"></param> /// <param name="msg"></param> /// <param name="part"></param> protected internal void SendNoReplyMessage(Address dest, Object msg, Priority priority, bool isSeqRequired) { if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("ClustService.SendNoRepMsg", "dest_addr :" + dest); byte[] serializedMsg = SerializeMessage(msg); Message m = new Message(dest, null, serializedMsg); m.IsSeqRequired = isSeqRequired; m.Priority = priority; _channel.send(m); }
/// <summary> /// Send a multicast no reply message /// </summary> /// <param name="dest"></param> /// <param name="msg"></param> /// <param name="part"></param> protected internal void SendNoReplyMulticastMessage(ArrayList dest, Object msg, Priority priority, bool isSeqRequired) { byte[] serializedMsg = SerializeMessage(msg); Message m = new Message(null, null, serializedMsg); m.IsSeqRequired = isSeqRequired; m.Priority = priority; m.Dests = dest; _channel.send(m); }
public override void down(Event evt) { Message msg; long time_to_wait, start_time; switch (evt.Type) { case Event.FIND_INITIAL_MBRS: // sent by GMS layer, pass up a GET_MBRS_OK event //We pass this event down to tcp so that it can take some measures. passDown(evt); initial_members.Clear(); msg = new Message(null, null, null); msg.putHeader(HeaderType.TCPPING, new PingHeader(PingHeader.GET_MBRS_REQ, (System.Object)local_addr,group_addr)); // if intitial nodes have been specified and static is true, then only those // members will form the cluster, otherwise, nodes having the same IP Multicast and port // will form the cluster dyanamically. mbrDiscoveryInProcess = true; lock (members.SyncRoot) { if( initial_hosts != null) { for (System.Collections.IEnumerator it = initial_hosts.GetEnumerator(); it.MoveNext(); ) { Address addr = (Address) it.Current; msg.Dest = addr; if(Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("[FIND_INITIAL_MBRS] sending PING request to " + msg.Dest); passDown(new Event(Event.MSG_URGENT, msg.copy(), Priority.Critical)); } } } // 2. Wait 'timeout' ms or until 'num_initial_members' have been retrieved if(Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TcpPing.down()", "[FIND_INITIAL_MBRS] waiting for results..............."); lock (initial_members.SyncRoot) { start_time = (System.DateTime.Now.Ticks - 621355968000000000) / 10000; time_to_wait = timeout; while (initial_members.Count < num_initial_members && time_to_wait > 0) { try { if (Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TcpPing.down()", "initial_members Count: " + initial_members.Count + "initialHosts Count: " + num_initial_members); if (Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TcpPing.down()", "Time to wait for next response: " + time_to_wait); ///Big_clusterd: initial members will be pulsed in case connection is not available. ///so here we dont have to wait till each member is timed out. ///this significantly improves time for initial member discovery. bool timeExpire = System.Threading.Monitor.Wait(initial_members.SyncRoot, TimeSpan.FromMilliseconds(time_to_wait)); } catch (System.Exception e) { Stack.NCacheLog.Error("TCPPing.down(FIND_INITIAL_MBRS)", e.ToString()); } time_to_wait = timeout - ((System.DateTime.Now.Ticks - 621355968000000000) / 10000 - start_time); } mbrDiscoveryInProcess = false; } if(Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TcpPing.down()", "[FIND_INITIAL_MBRS] initial members are " + Global.CollectionToString(initial_members)); if(Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TcpPing.down()", "[FIND_INITIAL_MBRS] initial members count " + initial_members.Count); //remove those which are not functional due to twoPhaseConnect for (int i = initial_members.Count - 1; i >= 0; i--) { PingRsp rsp = initial_members[i] as PingRsp; if (!rsp.IsStarted) initial_members.RemoveAt(i); } // 3. Send response passUp(new Event(Event.FIND_INITIAL_MBRS_OK, initial_members)); break; case Event.TMP_VIEW: case Event.VIEW_CHANGE: System.Collections.ArrayList tmp; if ((tmp = ((View) evt.Arg).Members) != null) { lock (members.SyncRoot) { members.Clear(); members.AddRange(tmp); } } passDown(evt); break; /****************************After removal of NackAck *********************************/ //TCPPING emulates a GET_DIGEST call, which is required by GMS. This is needed //since we have now removed NAKACK from the stack! case Event.GET_DIGEST: pbcast.Digest digest = new pbcast.Digest(members.Count); for (int i = 0; i < members.Count; i++) { Address sender = (Address)members[i]; digest.add(sender, 0, 0); } passUp(new Event(Event.GET_DIGEST_OK, digest)); return; case Event.SET_DIGEST: // Not needed! Just here to let you know that it is needed by GMS! return; /********************************************************************************/ case Event.BECOME_SERVER: // called after client has joined and is fully working group member if(Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TcpPing.down()", "received BECOME_SERVER event"); passDown(evt); is_server = true; break; case Event.CONNECT: object[] addrs = ((object[])evt.Arg); group_addr = (string)addrs[0]; subGroup_addr = (string)addrs[1]; twoPhaseConnect = (bool)addrs[3]; if (twoPhaseConnect) timeout = 1000; passDown(evt); break; case Event.DISCONNECT: passDown(evt); break; case Event.HAS_STARTED: hasStarted = true; passDown(evt); break; default: passDown(evt); // Pass on to the layer below us break; } }
public override void up(Event evt) { Message msg, rsp_msg; System.Object obj; PingHeader hdr, rsp_hdr; PingRsp rsp; Address coord; switch (evt.Type) { case Event.MSG: msg = (Message) evt.Arg; obj = msg.getHeader(HeaderType.TCPPING); if (obj == null || !(obj is PingHeader)) { passUp(evt); return ; } hdr = (PingHeader)msg.removeHeader(HeaderType.TCPPING); switch (hdr.type) { case PingHeader.GET_MBRS_REQ: if( !hdr.group_addr.Equals(group_addr)) { if (Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TcpPing.up()", "GET_MBRS_REQ from different group , so discarded"); return; } Address src = (Address) hdr.arg; msg.Src = src; if(Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TCPPING.up()", "GET_MBRS_REQ from " + msg.Src.ToString()); lock (members.SyncRoot) { coord = members.Count > 0 ? (Address)members[0] : local_addr; } if(Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TCPPING.up()", "my coordinator is " + coord.ToString()); rsp_msg = new Message(msg.Src, null, null); rsp_hdr = new PingHeader(PingHeader.GET_MBRS_RSP, new PingRsp(local_addr, coord, Stack.IsOperational,Stack.IsOperational)); rsp_msg.putHeader(HeaderType.TCPPING, rsp_hdr); if(Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TCPPING.up()", "responding to GET_MBRS_REQ back to " + msg.Src.ToString()); if (Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info(local_addr + " - [FIND_INITIAL_MBRS] replying PING request to " + rsp_msg.Dest); passDown(new Event(Event.MSG, rsp_msg, Priority.Critical)); return ; case PingHeader.GET_MBRS_RSP: // add response to vector and notify waiting thread if(Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TCPPING.up()", "GET_MBRS_RSP from " + msg.Src.ToString()); rsp = (PingRsp) hdr.arg; //muds: //check if the received response is valid i.e. successful security authorization //at other end. if (rsp.OwnAddress == null && rsp.CoordAddress == null && rsp.HasJoined == false) { lock (initial_members.SyncRoot) { if (Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TCPPING.up()", "I am not authorized to join to " + msg.Src.ToString()); System.Threading.Monitor.PulseAll(initial_members.SyncRoot); } } else { if (Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TCPPING.up()", "Before Adding initial members response"); lock (initial_members.SyncRoot) { if (Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TCPPING.up()", "Adding initial members response"); if (!initial_members.Contains(rsp)) { initial_members.Add(rsp); if (Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TCPPING.up()", "Adding initial members response for " + rsp.OwnAddress); } else if (Stack.NCacheLog.IsInfoEnabled) Stack.NCacheLog.Info("TcpPing.up()", "response already received"); System.Threading.Monitor.PulseAll(initial_members.SyncRoot); } } return ; default: Stack.NCacheLog.Warn("got TCPPING header with unknown type (" + hdr.type + ')'); return ; } //goto case Event.SET_LOCAL_ADDRESS; case Event.SET_LOCAL_ADDRESS: passUp(evt); local_addr = (Address) evt.Arg; // Add own address to initial_hosts if not present: we must always be able to ping ourself ! if (initial_hosts != null && local_addr != null) { if (!initial_hosts.Contains(local_addr)) { Stack.NCacheLog.Debug("[SET_LOCAL_ADDRESS]: adding my own address (" + local_addr + ") to initial_hosts; initial_hosts=" + Global.CollectionToString(initial_hosts)); initial_hosts.Add(local_addr); } } break; case Event.CONNECT_OK: obj = evt.Arg; if(obj != null && obj is Address) { tcpServerPort = ((Address)obj).Port; } passUp(evt); break; case Event.CONNECTION_NOT_OPENED: if (mbrDiscoveryInProcess) { Address node = evt.Arg as Address; PingRsp response = new PingRsp(node, node, true, false); lock (initial_members.SyncRoot) { initial_members.Add(response); System.Threading.Monitor.PulseAll(initial_members.SyncRoot); } Stack.NCacheLog.CriticalInfo(Name + ".up", "connection failure with " + node); } break; // end services default: passUp(evt); // Pass up to the layer above us break; } }
public void SendSecondaryAddressofPeer() { Address secondaryAddress = null; Connection.ConnectionHeader header = new ConnectionHeader(ConnectionHeader.GET_SECOND_ADDRESS_RSP); header.MySecondaryAddress = enclosingInstance.local_addr_s; Message msg = new Message(peer_addr, null, new byte[0]); msg.putHeader("ConnectionHeader", header); NCacheLog.Error("Connection.SendSecondaryAddress", "secondaryAddr: " + header.MySecondaryAddress); SendInternal(Util.Util.serializeMessage(msg)); }
public Address GetSecondaryAddressofPeer() { Connection.ConnectionHeader header = new ConnectionHeader(ConnectionHeader.GET_SECOND_ADDRESS_REQ); Message msg = new Message(peer_addr, null, new byte[0]); msg.putHeader("ConnectionHeader", header); lock (get_addr_sync) { SendInternal(Util.Util.serializeMessage(msg)); Monitor.Wait(get_addr_sync); } return secondaryAddress; }
public virtual void Run() { Message msg= null; byte[] buf = null; int len = 0; while (handler != null) { Stream stmIn = null; BinaryReader msgReader = null; try { if (sock == null) { NCacheLog.Error("input stream is null !"); break; } byte[] lenBuff = new byte[4]; buf = null; Util.Util.ReadInput(sock, lenBuff, 0, lenBuff.Length); len = Util.Util.convertToInt32(lenBuff); buf = receiveBuffer; if (len > receiveBuffer.Length) buf = new byte[len]; HPTimeStats socketReceiveTimeStats = null; if (enclosingInstance.enableMonitoring) { socketReceiveTimeStats = new HPTimeStats(); socketReceiveTimeStats.BeginSample(); } DateTime dt = DateTime.Now; int recLength = Util.Util.ReadInput(sock, buf, 0, len); DateTime now = DateTime.Now; TimeSpan ts = now - dt; if (ts.TotalMilliseconds > _worsRecvTime.TotalMilliseconds) _worsRecvTime = ts; if (socketReceiveTimeStats != null) { socketReceiveTimeStats.EndSample(); enclosingInstance.enclosingInstance.Stack.perfStatsColl.IncrementSocketReceiveTimeStats((long)socketReceiveTimeStats.Current); enclosingInstance.enclosingInstance.Stack.perfStatsColl.IncrementSocketReceiveSizeStats((long)len); } enclosingInstance.publishBytesReceivedStats(len + 4); if (recLength == len) { int noOfMessages = Util.Util.convertToInt32(buf, 0); int messageBaseIndex = 4; for (int msgCount = 0; msgCount < noOfMessages; msgCount++) { int totalMessagelength = Util.Util.convertToInt32(buf, messageBaseIndex); int messageLength = Util.Util.convertToInt32(buf, messageBaseIndex + 4); stmIn = new MemoryStream(); stmIn.Position = 0; stmIn.Write(buf, messageBaseIndex + 8, messageLength); stmIn.Position = 0; msgReader = new BinaryReader(stmIn, new UTF8Encoding(true)); FlagsByte flags = new FlagsByte(); flags.DataByte = msgReader.ReadByte(); if (flags.AnyOn(FlagsByte.Flag.TRANS)) { Message tmpMsg = new Message(); tmpMsg.DeserializeLocal(msgReader); msg = tmpMsg; } else { msg = (Message)CompactBinaryFormatter.Deserialize(stmIn, null, false, null); } if (msg != null) { int payLoadLength = totalMessagelength - messageLength - 4; if (payLoadLength > 0) { int noOfChunks = payLoadLength / LARGE_OBJECT_SIZE; noOfChunks += (payLoadLength - (noOfChunks * LARGE_OBJECT_SIZE)) != 0 ? 1 : 0; Array payload = new Array[noOfChunks]; int nextChunk = 0; int nextChunkSize = 0; int startIndex = messageBaseIndex + 8 + messageLength; for (int i = 0; i < noOfChunks; i++) { nextChunkSize = payLoadLength - nextChunk; if (nextChunkSize > LARGE_OBJECT_SIZE) nextChunkSize = LARGE_OBJECT_SIZE; byte[] binaryChunk = new byte[nextChunkSize]; Buffer.BlockCopy(buf, startIndex, binaryChunk, 0, nextChunkSize); nextChunk += nextChunkSize; startIndex += nextChunkSize; payload.SetValue(binaryChunk, i); } msg.Payload = payload; } messageBaseIndex += (totalMessagelength + 4); ConnectionHeader hdr = msg.getHeader("ConnectionHeader") as ConnectionHeader; if (hdr != null) { switch (hdr.Type) { case ConnectionHeader.CLOSE_SILENT: if (NCacheLog.IsInfoEnabled) NCacheLog.Info("Connection.Run", "connection being closed silently"); this.self_close = true; handler = null; continue; case ConnectionHeader.LEAVE: //The node is leaving the cluster gracefully. leavingGracefully = true; if (NCacheLog.IsInfoEnabled) NCacheLog.Info("Connection.Run", peer_addr.ToString() + " is leaving gracefully"); handler = null; continue; case ConnectionHeader.GET_SECOND_ADDRESS_REQ: SendSecondaryAddressofPeer(); continue; case ConnectionHeader.GET_SECOND_ADDRESS_RSP: lock (get_addr_sync) { secondaryAddress = hdr.MySecondaryAddress; Monitor.PulseAll(get_addr_sync); } continue; case ConnectionHeader.ARE_U_IN_INITIALIZATION_PHASE: try { bool iMinInitializationPhase = !enclosingInstance.enclosingInstance.Stack.IsOperational; SendInitializationPhaseRsp(iMinInitializationPhase); } catch (Exception e) { } break; case ConnectionHeader.INITIALIZATION_PHASE_RSP: lock (initializationPhase_mutex) { inInitializationPhase = hdr.InitializationPhase; Monitor.PulseAll(inInitializationPhase); } break; } } } msg.Src = peer_addr; msg.MarkArrived(); Enclosing_Instance.receive(msg); // calls receiver.receiver(msg) } } } catch (ObjectDisposedException) { lock (send_mutex) { socket_error = true; isConnected = false; } break; } catch (ThreadAbortException) { lock (send_mutex) { socket_error = true; isConnected = false; } break; } catch (ThreadInterruptedException) { lock (send_mutex) { socket_error = true; isConnected = false; } break; } catch (System.OutOfMemoryException memExc) { lock (send_mutex) { isConnected = false; } NCacheLog.CriticalInfo("Connection.Run()", Enclosing_Instance.local_addr + "-->" + peer_addr.ToString() + " memory exception " + memExc.ToString()); break; // continue; } catch (ExtSocketException sock_exp) { lock (send_mutex) { socket_error = true; isConnected = false; } // peer closed connection NCacheLog.Error("Connection.Run()", Enclosing_Instance.local_addr + "-->" + peer_addr.ToString() + " exception is " + sock_exp.Message); break; } catch (System.IO.EndOfStreamException eof_ex) { lock (send_mutex) { isConnected = false; } // peer closed connection NCacheLog.Error("Connection.Run()", "data :" + len + Enclosing_Instance.local_addr + "-->" + peer_addr.ToString() + " exception is " + eof_ex); break; } catch (System.Net.Sockets.SocketException io_ex) { lock (send_mutex) { socket_error = true; isConnected = false; } NCacheLog.Error("Connection.Run()", Enclosing_Instance.local_addr + "-->" + peer_addr.ToString() + " exception is " + io_ex.Message); break; } catch (System.ArgumentException ex) { lock (send_mutex) { isConnected = false; } break; } catch (System.Exception e) { lock (send_mutex) { isConnected = false; } NCacheLog.Error("Connection.Run()", Enclosing_Instance.local_addr + "-->" + peer_addr.ToString() + " exception is " + e); break; } finally { if (stmIn != null) stmIn.Close(); if (msgReader != null) msgReader.Close(); } } handler = null; if (LeavingGracefully) { enclosingInstance.notifyConnectionClosed(peer_addr); enclosingInstance.remove(peer_addr, IsPrimary); } }
/// <summary> /// Sends notification to other node about leaving. /// </summary> public void SendLeaveNotification() { leavingGracefully = true; ConnectionHeader header = new ConnectionHeader(ConnectionHeader.LEAVE); Message leaveMsg = new Message(peer_addr, null, new byte[0]); leaveMsg.putHeader("ConnectionHeader", header); if (NCacheLog.IsInfoEnabled) NCacheLog.Info("Connection.SendSilentCloseNotification", "sending leave request"); try { byte[] binaryMsg = Util.Util.serializeMessage(leaveMsg); SendInternal(binaryMsg); } catch (Exception e) { NCacheLog.Error("Connection.SendLeaveNotification", e.ToString()); } }
protected internal object SendMessage(Address dest, object msg, byte mode, bool isSeqRequired, long timeout) { try { if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("ClustService.SendMsg", "dest_addr :" + dest); byte[] serializedMsg = SerializeMessage(msg); Message m = new Message(dest, null, serializedMsg); if (msg is Function) m.Payload = ((Function)msg).UserPayload; m.IsSeqRequired = isSeqRequired; object result = _msgDisp.sendMessage(m, mode, timeout); if (result is OperationResponse) { ((OperationResponse)result).SerializablePayload = CompactBinaryFormatter.FromByteBuffer((byte[])((OperationResponse)result).SerializablePayload, _context.SerializationContext); } else if (result is byte[]) { result = CompactBinaryFormatter.FromByteBuffer((byte[])result, _context.SerializationContext); } if (result != null && result is Exception) throw (Exception)result; return result; } catch (Alachisoft.NGroups.SuspectedException e) { throw new Runtime.Exceptions.SuspectedException("operation failed because the group member was suspected " + e.suspect); } catch (Runtime.Exceptions.TimeoutException e) { throw; } finally { if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("ClustService.SendMsg", "completed"); } }
protected internal object SendMessage(Address dest, object msg, byte mode, long timeout, bool handleAsync) { try { if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("ClustService.SendMsg", "dest_addr :" + dest); byte[] serializedMsg = SerializeMessage(msg); Message m = new Message(dest, null, serializedMsg); m.HandledAysnc = handleAsync; m.IsUserMsg = true; object result = _msgDisp.sendMessage(m, mode, timeout); if (result is byte[]) result = CompactBinaryFormatter.FromByteBuffer((byte[])result, _context.SerializationContext); return result; } catch (Alachisoft.NGroups.SuspectedException e) { throw new Runtime.Exceptions.SuspectedException("operation failed because the group member was suspected " + e.suspect); } catch (Runtime.Exceptions.TimeoutException e) { throw; } finally { if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("ClustService.SendMsg", "completed"); } }
/// <summary> /// Notify the target object of a received Message. /// </summary> /// <param name="msg">Received Message</param> void MessageListener.receive(Message msg) { ((RequestHandler)this).handle(msg); }
public virtual object HandleClusterMessage(Address src, Function func, out Address destination, out Message replicationMsg) { destination = null; replicationMsg = null; return null; }
public object handleFunction(Address src, Function func, out Address destination, out Message replicationMsg) { return _participant.HandleClusterMessage(src, func, out destination, out replicationMsg); }
public virtual Message makeReply(ObjectProvider MsgProvider) { Message m = null; if (MsgProvider != null) { m = (Message) MsgProvider.RentAnObject(); } else m = new Message(src_addr, null, null); m.dest_addr = src_addr; m.profileid = profileid; m.isProfilable = isProfilable; return m; }
object RequestHandler.handleNHopRequest(Message req, out Address destination, out Message replicationMsg) { destination = null; replicationMsg = null; if (req == null || req.Length == 0) return null; try { bool isLocalReq = LocalAddress.CompareTo(req.Src) == 0; object body = req.getFlatObject(); try { if (body is Byte[]) body = CompactBinaryFormatter.FromByteBuffer((byte[])body, _context.SerializationContext); } catch (Exception e) { return e; } object result = null; if (body is Function) { Function func = (Function)body; func.UserPayload = req.Payload; if (isLocalReq && func.ExcludeSelf) { if (req.HandledAysnc && req.RequestId > 0) SendResponse(req.Src, null, req.RequestId); return null; } if (req.HandledAysnc) { AsyncRequst asyncReq = new AsyncRequst(func, func.SyncKey); asyncReq.Src = req.Src; asyncReq.RequsetId = req.RequestId; _asynHandler.HandleRequest(asyncReq); return null; } else { result = handleFunction(req.Src, func, out destination, out replicationMsg); } } else if (body is AggregateFunction) { AggregateFunction funcs = (AggregateFunction)body; object[] results = new object[funcs.Functions.Length]; for (int i = 0; i < results.Length; i++) { Function func = (Function)funcs.Functions.GetValue(i); if (isLocalReq && func.ExcludeSelf) { if (req.HandledAysnc && req.RequestId > 0) { SendResponse(req.Src, null, req.RequestId); continue; } results[i] = null; } else { if (req.HandledAysnc) { AsyncRequst asyncReq = new AsyncRequst(func, func.SyncKey); asyncReq.Src = req.Src; asyncReq.RequsetId = req.RequestId; _asynHandler.HandleRequest(asyncReq); continue; } results[i] = handleFunction(req.Src, func); } } result = results; } if (result is OperationResponse) { ((OperationResponse)result).SerializablePayload = CompactBinaryFormatter.ToByteBuffer(((OperationResponse)result).SerializablePayload, _context.SerializationContext); } else { result = CompactBinaryFormatter.ToByteBuffer(result, _context.SerializationContext); } return result; } catch (Exception e) { return e; } return null; }
private void sendMemberLeftNotificationToCoordinator(Address suspected,Address coordinator) { if (gms.Stack.NCacheLog.IsInfoEnabled) gms.Stack.NCacheLog.Info("ParticipantGmsImp.sendMemberLeftNotification", "informing coordinator about abnormal connection breakage with " + suspected); GMS.HDR hdr = new GMS.HDR(GMS.HDR.CONNECTION_BROKEN, suspected); Message nodeLeftMsg = new Message(coordinator, null, new byte[0]); nodeLeftMsg.putHeader(HeaderType.GMS, hdr); gms.passDown(new Event(Event.MSG, nodeLeftMsg, Priority.Critical)); }
private RspList BroadcastToMultiple(ArrayList dests, object msg, byte mode, long timeout, bool isSeqRequired, string traceMsg,Priority priority) { ///TODO: remove this conditional compilation byte[] serializedMsg = SerializeMessage(msg); Message m = new Message(null, null, serializedMsg); if (msg is Function) { m.Payload = ((Function)msg).UserPayload; m.responseExpected = ((Function)msg).ResponseExpected; } m.setBuffer(serializedMsg); m.IsSeqRequired = isSeqRequired; m.Priority = priority; RspList rspList = null; try { rspList = _msgDisp.castMessage(dests, m, mode, timeout); } finally { if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("ClustService.BcastToMultiple", "completed"); } if (rspList.size() == 0) { return null; } Rsp rsp; for (int i = 0; i < rspList.size(); i++) { rsp = (Rsp)rspList.elementAt(i); rsp.Deflate(_context.SerializationContext); } return rspList; }
/// <summary> /// Informs the coodinator about the nodes to which this node can not establish connection /// on receiving the first view.Only the node who has most recently joined the cluster /// should inform the coodinator other nodes will neglect this event. /// </summary> /// <param name="nodes"></param> public override void handleConnectionFailure(System.Collections.ArrayList nodes) { if (nodes != null && nodes.Count > 0) { if (gms.Stack.NCacheLog.IsInfoEnabled) gms.Stack.NCacheLog.Info("ParticipantGmsImp.handleConnectionFailure", "informing coordinator about connection failure with [" + Global.CollectionToString(nodes) + "]"); GMS.HDR header = new GMS.HDR(GMS.HDR.CAN_NOT_CONNECT_TO); header.nodeList = nodes; Message msg = new Message(gms.determineCoordinator(),null,new byte[0]); msg.putHeader(HeaderType.GMS,header); gms.passDown(new Event(Event.MSG,msg,Priority.Critical)); } }
public RspList BroadcastToMultiple(ArrayList dests, object msg, byte mode, long timeout, string traceMsg, bool handleAsync) { if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("ClustService.BcastToMultiple", ""); byte[] serializedMsg = SerializeMessage(msg); Message m = new Message(null, null, serializedMsg); m.HandledAysnc = handleAsync; m.setBuffer(serializedMsg); m.IsUserMsg = true; RspList rspList = null; try { rspList = _msgDisp.castMessage(dests, m, mode, timeout); } finally { if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("ClustService.BcastToMultiple", "completed"); } if (rspList.size() == 0) { return null; } Rsp rsp; for (int i = 0; i < rspList.size(); i++) { rsp = (Rsp)rspList.elementAt(i); rsp.Deflate(_context.SerializationContext); } return rspList; }
internal virtual void sendLeaveMessage(Address coord, Address mbr) { Message msg = new Message(coord, null, null); GMS.HDR hdr = new GMS.HDR(GMS.HDR.LEAVE_REQ, mbr); msg.putHeader(HeaderType.GMS, hdr); gms.passDown(new Event(Event.MSG, msg)); }
public RspList Multicast(ArrayList dests, object msg, byte mode, bool isSeqRequired, long timeout) { if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("ClustService.Mcast", ""); byte[] serializedMsg = SerializeMessage(msg); Message m = new Message(null, null, serializedMsg); if (msg is Function) m.Payload = ((Function)msg).UserPayload; m.setBuffer(serializedMsg); m.Dests = dests; m.IsSeqRequired = isSeqRequired; RspList rspList = null; try { rspList = _msgDisp.castMessage(dests, m, mode, timeout); } finally { if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("ClustService.Mcast", "completed"); } if (rspList.size() == 0) { return null; } Rsp rsp; for (int i = 0; i < rspList.size(); i++) { rsp = (Rsp)rspList.elementAt(i); rsp.Deflate(_context.SerializationContext); } return rspList; }
public void SendResponse(Address dest, object result, long reqId) { byte[] serializedMsg = SerializeMessage(result); Message response = new Message(dest, null, serializedMsg); try { _msgDisp.SendResponse(reqId, response); } catch (Exception e) { //Trace.error("ClusterService", e.ToString()); throw; } finally { } }
/// <summary> /// Sends the notification to the peer that connection is being closed silently. /// </summary> private void SendSilentCloseNotification() { self_close = true; ConnectionHeader header = new ConnectionHeader(ConnectionHeader.CLOSE_SILENT); Message closeMsg = new Message(peer_addr, null, new byte[0]); closeMsg.putHeader("ConnectionHeader", header); if (NCacheLog.IsInfoEnabled) NCacheLog.Info("Connection.SendSilentCloseNotification", "sending silent close request"); try { byte[] binaryMsg = Util.Util.serializeMessage(closeMsg); SendInternal(binaryMsg); } catch (Exception e) { NCacheLog.Error("Connection.SendSilentCloseNotification", e.ToString()); } }