private void SendHeartBeat()
{
HeartBeat sendMsg = new HeartBeat();
NetUdpFixedSizePackage mPackage = GetUdpSystemPackage(UdpNetCommand.COMMAND_HEARTBEAT, sendMsg);
SendNetPackage(mPackage);
}
private void OnConnectGameServer(ClientType clientType)
{
DebugUtils.Log(DebugUtils.Type.AsyncSocket, "Success! Connected to GameServer " + clientType);
UnityEngine.SceneManagement.SceneManager.LoadScene("MainMenu");
if (OpenMainMenuUI)
{
UIManager.locateState = UIManagerLocateState.MainMenu;
}
else
{
UIManager.locateState = UIManagerLocateState.BattleModeView;
}
DataManager clientData = DataManager.GetInstance();
clientData.ResetBattleData();
clientData.SetPlayerIsInBattle(false);
HeartBeat.RegisterGameHeartMessageHandler();
//DataManager.GetInstance().RegisterDataServerMessageHandler();
MultiDeviceListenerManager.RegisterHandler();
DebugToScreen.RegisterHandler();
}
/// <summary>
/// 接受来自leader节点的心跳请求
/// </summary>
/// <param name="heartBeat"></param>
/// <returns></returns>
public async Task <HeartBeatResponse> Handle(HeartBeat heartBeat)
{
_logger.LogInformation($"leader 接收{heartBeat.LeaderId}的心跳");
//如果当前任期大于心跳任期
var rs = new HeartBeatResponse();
var currentLog = _blockDataManager.GetLastBlockEntity(_node.GetChannelId());
rs.Term = CurrentState.CurrentTerm;
rs.Height = currentLog.Header.Number;
rs.BlockCurrentHash = currentLog.Header.DataHash;
rs.BlockPreviousHash = currentLog.Header.PreviousHash;
rs.LeaderId = CurrentState.LeaderId;
rs.Success = false;
//当前任期大于leader任期 返回当前任期，leaderID和最新日志信息
if (CurrentState.CurrentTerm > heartBeat.Term)
{
return(rs);
}
else
//任期小于等于leader任期，则返回最新日志,改变自身状态(觉得自身状态和自己最新的日志的任期一致)
{
CurrentState.LeaderId = heartBeat.LeaderId;
rs.LeaderId = heartBeat.LeaderId;
rs.Success = true;
return(rs);
}
}
public async Task Execute(HeartBeat o)
{
await Task.Run(() =>
{
Logger.Info($"HEARTBEAT | {o.Hostname} | {o.Program} | {o.Process}");
});
}
static async Task PostAsync(HeartBeat heartBeat)
{
using (var client = new HttpClient())
{
try
{
client.BaseAddress = new Uri(connectionString);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
//Http post
HttpResponseMessage response = await client.PostAsJsonAsync("api/HeartBeat/AddNewHeartBeat", heartBeat);
if (response.IsSuccessStatusCode)
{
Console.WriteLine("HeartBeat Posted succesfully!");
PrintPost(heartBeat);
}
else
{
Console.WriteLine("Attempt unsuccesfull!\n");
}
}
catch (Exception ex)
{
Console.WriteLine("Attempt unsuccesfull!\n" + ex.Message);
}
}
}
public void PauseResumeClientTest()
{
ClientManager cmn = new ClientManager();
// Pasando configuracion.
cmn.SetClientConfig(new SendClientConfig(CreateClientConfig()));
cmn.SetSystemConfig(new SendSystemConfig(CreateSystemConfig()));
cmn.Start();
// Generando HB para el cliente.
HeartBeat hb = HeartBeat.CreateHeartBeat(Client1_ID);
cmn.ReceiveHB(new SendHeartbeat(hb));
// Comprobar cliente en lista de trabajo
Assert.AreEqual(1, cmn.ClientList.Count);
Assert.AreEqual(1, cmn.WorkList.Count);
// Pausar cliente
cmn.PauseClient(new RequestPauseClient(Client1_Guid));
// Comprobar cliente en lista de pausa
Assert.AreEqual(0, cmn.WorkList.Count);
Assert.AreEqual(1, cmn.PausedList.Count);
// Continuar cliente
cmn.ResumeClient(new RequestResumeClient(Client1_Guid));
// Comprobar cliente en lista de trabajo
Assert.AreEqual(1, cmn.WorkList.Count);
Assert.AreEqual(0, cmn.PausedList.Count);
// Fin
cmn.Stop();
}
private void timer1_Tick(object sender, EventArgs e)
{
HeartBeat heart = new HeartBeat();
heart.Projectid = Convert.ToInt32(navBarControl1.ActiveGroup.Tag);
heart.CheckHeartBeat();
}
public List <HeartBeat> GetAllHeartBeats()
{
List <HeartBeat> heartBeatList = null;
HeartBeat heartBeat = new HeartBeat();
using (StreamReader readtext = new StreamReader(@"Data.config"))
{
string info = " ";
while (info != null)
{
try
{
info = readtext.ReadLine();
heartBeat.HearBeatRate = int.Parse(info);
info = readtext.ReadLine();
heartBeat.SampleDate = info;
info = readtext.ReadLine();
heartBeatList.Add(heartBeat);
}
catch
{
}
}
readtext.Dispose();
}
return(heartBeatList);
}
internal Connection(IBufferManager bufferManager, AmqpSettings amqpSettings, Address address,
IAsyncTransport transport, Open open, OnOpened onOpened, IHandler handler)
: this(address, (ushort)(amqpSettings.MaxSessionsPerConnection - 1), (uint)amqpSettings.MaxFrameSize)
{
transport.SetConnection(this);
this.handler = handler;
this.BufferManager = bufferManager;
this.MaxLinksPerSession = amqpSettings.MaxLinksPerSession;
this.onOpened = onOpened;
this.writer = new TransportWriter(transport, this.OnIoException);
// after getting the transport, move state to open pipe before starting the pump
if (open == null)
{
open = new Open()
{
ContainerId = amqpSettings.ContainerId,
HostName = amqpSettings.HostName ?? this.address.Host,
ChannelMax = this.channelMax,
MaxFrameSize = this.maxFrameSize,
IdleTimeOut = (uint)amqpSettings.IdleTimeout
};
}
if (open.IdleTimeOut > 0)
{
this.heartBeat = new HeartBeat(this, open.IdleTimeOut);
}
this.SendHeader();
this.SendOpen(open);
this.state = ConnectionState.OpenPipe;
}
public virtual Task Send(PersistentResponse response)
{
HeartBeat.MarkConnection(this);
AddTransportData(response);
return(Send((object)response));
}
static void Main(string[] args)
{
Console.WriteLine("{0}\t程序已启动，连接服务器... ", DateTime.Now);
var s2 = ProxyFactory.GetContext<IDuplexChannelService>();
s2.OnConnectionChanged += (x, y) => { Console.WriteLine("s2 online"); };
s2.OnBroadcast += (x, y) => { Console.WriteLine("接收广播：{0}", y.Content); };
s2.OnGetOnlineClients += (x, y) =>
{
Console.WriteLine("在线客户端:");
foreach (var item in y.Macs)
{
Console.WriteLine("\t" + item);
}
};
var s1 = ProxyFactory.GetContext<IMainService>();
s1.OnConnectionChanged += (x, y) => { Console.WriteLine("s1 online"); };
HeartBeat hb = new HeartBeat();
hb.Regist<IDuplexChannelService>(s2, 5000);
hb.Regist<IMainService>(s1);
hb.Start();
System.Threading.Thread.Sleep(3000);
//s1.Invoke(s => s.Test("发送广播"));
//s2.Invoke(s => s.GetClients());
//s1.Invoke(s => s.Test("发送广播2"));
//context.inverk(context => context.Test());
//HeartBeat s = new HeartBeat();
//s.register(context);
//s.stop();
////ms.Online("", false);
//////
////var dd = ms.Test("wef");
//HeartBeat.OnSending += HeartBeat_OnSending;
//HeartBeat.OnSent += HeartBeat_OnSent;
//HeartBeat.Go(callback);
//ServiceProxy.Call<IDuplexChannelService, IDuplexChannelCallback>(callback, net =>
//{
// for (int i = 0; i < 10; i++)
// {
// net.Online("MMM" + i.ToString(), false);
// }
//});
Console.Read();
}
static private void IniciaServidor()
{
Console.WriteLine("Simulador iniciado. Servidor Pipe atiende: " + name);
Console.WriteLine(messg);
Console.CancelKeyPress += Console_CancelKeyPress;
Encd = new ASCIIEncoding();
_pipeServer = new NamedPipeServerStream(name, PipeDirection.In, maxconn, PipeTransmissionMode.Message, PipeOptions.Asynchronous, bufferSize, bufferSize);
int numBytes = 0;
keepLoop = true;
while (keepLoop)
{
string message = String.Empty;
buffer = new byte[bufferSize];
_pipeServer.WaitForConnection();
do
{
numBytes = _pipeServer.Read(buffer, 0, bufferSize);
//Console.WriteLine("LEidos: " + numBytes.ToString());
} while (numBytes != 0);
HeartBeat hb = HeartBeat.CreateHeartBeat(buffer);
message = string.Format("Cliente: {0} Pipe: {1} TS: {2} Serial: {3}", hb.ClientID, name, hb.Timestamp, hb.Serial);
Console.WriteLine(message);
_pipeServer.Disconnect();
}
}
protected virtual async Task Execute(HeartBeat heartbeat)
{
await Task.Run(() =>
{
// implement default heartbeat properties and tags
});
}
/// <summary>
/// Initializes a connection with SASL profile, open and open callback.
/// </summary>
/// <param name="address">The address.</param>
/// <param name="saslProfile">The SASL profile to do authentication (optional). If it is
/// null and address has user info, SASL PLAIN profile is used.</param>
/// <param name="open">The open frame to send (optional). If not null, all mandatory
/// fields must be set. Ensure that other fields are set to desired values.</param>
/// <param name="onOpened">The callback to handle remote open frame (optional).</param>
/// <remarks>
/// The connection initialization includes establishing the underlying transport,
/// which typically has blocking network I/O. Depending on the current synchronization
/// context, it may cause deadlock or UI freeze. Please use the ConnectionFactory.CreateAsync
/// method instead.
/// </remarks>
public Connection(Address address, SaslProfile saslProfile, Open open, OnOpened onOpened)
: this(DefaultMaxSessions, DefaultMaxFrameSize)
{
this.address = address;
this.onOpened = onOpened;
if (open != null)
{
this.maxFrameSize = open.MaxFrameSize;
this.channelMax = open.ChannelMax;
}
else
{
open = new Open()
{
ContainerId = Guid.NewGuid().ToString(),
HostName = this.address.Host,
MaxFrameSize = this.maxFrameSize,
ChannelMax = this.channelMax
};
}
if (open.IdleTimeOut > 0)
{
this.heartBeat = new HeartBeat(this, open.IdleTimeOut);
}
this.Connect(saslProfile, open);
}
//清数据
public void Dispose()
{
disposed = true;
EventSystem.RemoveEvent(EventID.SOKECT_CONNECT_RESULT, OnEventSocketConnectOK);
//MsgCallManager.RemoveCallback(ProtoID.SC_LOGIN_RECONNECTION_REPLY, ReconnectSuccess);
if (heartBeatCheck != null)
{
heartBeatCheck.Dispose();
}
heartBeatCheck = null;
if (clientSocket != null)
{
clientSocket.Dispose();
}
clientSocket = null;
if (clientProtoMsg != null)
{
clientProtoMsg.Dispose();
}
clientProtoMsg = null;
// if (msgCacheMgr != null)
// msgCacheMgr.Dispose ();
// msgCacheMgr = null;
if (msgVerifyMgr != null)
{
msgVerifyMgr.Dispose();
}
msgVerifyMgr = null;
}
private Task ProcessReceiveRequest(ITransportConnection connection, Action postReceive = null)
{
HeartBeat.UpdateConnection(this);
HeartBeat.MarkConnection(this);
if (TransportConnected != null)
{
TransportConnected().Catch();
}
// ReceiveAsync() will async wait until a message arrives then return
var receiveTask = IsConnectRequest ?
connection.ReceiveAsync(TimeoutToken) :
connection.ReceiveAsync(MessageId, TimeoutToken);
if (postReceive != null)
{
postReceive();
}
return(receiveTask.Then(response =>
{
if (response.Aborted)
{
// If this was a clean disconnect then raise the event
OnDisconnect();
}
return Send(response);
}));
}
public Connection(string n, bool needSyncTime = true)
{
name = n;
socketClient = new SocketClient(this);
heartBeat = new HeartBeat(this);
NeedSyncTime = needSyncTime;
}
internal void Init(IBufferManager bufferManager, AmqpSettings amqpSettings, IAsyncTransport transport, Open open)
{
transport.SetConnection(this);
this.BufferManager = bufferManager;
this.channelMax = GetChannelMax(amqpSettings, open);
this.maxFrameSize = GetMaxFrameSize(amqpSettings, open);
this.MaxLinksPerSession = amqpSettings.MaxLinksPerSession;
this.writer = new TransportWriter(transport, this.OnIoException);
// after getting the transport, move state to open pipe before starting the pump
if (open == null)
{
open = new Open()
{
ContainerId = amqpSettings.ContainerId,
HostName = amqpSettings.HostName ?? this.address.Host,
ChannelMax = this.channelMax,
MaxFrameSize = this.maxFrameSize,
IdleTimeOut = (uint)amqpSettings.IdleTimeout / 2
};
}
if (open.IdleTimeOut > 0)
{
this.heartBeat = new HeartBeat(this, open.IdleTimeOut * 2);
}
this.SendHeader();
this.SendOpen(open);
this.state = ConnectionState.OpenPipe;
}
/// <summary>
/// The internal heartbeat timer has elapsed, raise the Heartbeat event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.Timers.ElapsedEventArgs"/> instance containing the event data.</param>
private void InternalHeartbeatTimerElapsed(object sender, ElapsedEventArgs e)
{
this._userMemoryProvider.Set("HeartBeat", DateTime.Now, PersistHint.AcrossSessions);
//RaiseHeartBeat Event
HeartBeat?.Invoke(this, EventArgs.Empty);
}
public void AddHeartBeat(HeartBeat heartBeat)
{
string command = "INSERT INTO Heartbeats(HearBeatRate , SampleDate ) VALUES ('" + heartBeat.HearBeatRate.ToString() + "','" + heartBeat.SampleDate.ToString() + "'); ";
SqlCommand sqlCommand = new SqlCommand(command, sqlConnection);
sqlCommand.ExecuteNonQuery();
}
protected override async Task Execute(HeartBeat heartbeat)
{
foreach (var i in await Application.GetApplications())
{
heartbeat.Tags.Add(i.Id.ToString());
heartbeat.Properties.Add(i.Id.ToString(), JsonConvert.SerializeObject(i));
}
}
public void AddHeartBeat(HeartBeat heartBeat)
{
using (StreamWriter writetext = new StreamWriter(@"Data.config"))
{
writetext.WriteLine(heartBeat.HearBeatRate + "\n" + heartBeat.SampleDate);
writetext.Dispose();
}
}
private void SendHeartBeat()
{
HeartBeat sendMsg = new HeartBeat();
NetUdpFixedSizePackage mPackage = GetUdpSystemPackage(UdpNetCommand.COMMAND_HEARTBEAT, sendMsg);
SendNetPackage(mPackage);
//ObjectPoolManager.Instance.mUdpFixedSizePackagePool.recycle (mPackage);
}
public override void Start()
{
requestCode = RequestCode.Game;
actionCode = ActionCode.HeartBeat;
heartBeatRequest = GetComponent <HeartBeat>();
base.Start();
}
protected virtual void OnSending(string payload)
{
HeartBeat.MarkConnection(this);
if (Sending != null)
{
Sending(payload);
}
}
public override void OnInspectorGUI()
{
GUILayout.Label("Object dynamic size!");
HeartBeat heartBeat = (HeartBeat)target;
heartBeat.baseSize = EditorGUILayout.Slider("Size", heartBeat.baseSize, .1f, 2f);
heartBeat.transform.localScale = Vector3.one * heartBeat.baseSize;
}
private Task ProcessReceiveRequest(IReceivingConnection connection)
{
HeartBeat.AddConnection(this);
return(InitializeResponse(connection)
.Then((c, id) => ProcessMessages(c, id), connection, LastMessageId)
.FastUnwrap());
}
public override void _Ready()
{
_animationPlayer = this.GetNode <AnimationPlayer>();
_heartBeat = GetNode <HeartBeat>("/root/HeartBeat");
_heartBeat.SafeConnect(nameof(HeartBeat.OnHeartBeat), this, nameof(OnHeartBeat));
_explodeSfx = this.GetNode <SfxPlayer>();
}
public virtual Task Send(PersistentResponse response)
{
HeartBeat.MarkConnection(this);
var data = _jsonSerializer.Stringify(response);
OnSending(data);
return(Context.Response.WriteAsync(data));
}
private void ReadData(object sender, EventArgs e)
{
Serial.BaudRate = int.Parse(Baud.Text);
Serial.PortName = Comm.Text;
Serial.Open();
Start.Enabled = false;
HeartBeat.RunWorkerAsync();
}
void Connect(SaslProfile saslProfile, Open open)
{
if (open != null)
{
this.maxFrameSize = open.MaxFrameSize;
this.channelMax = open.ChannelMax;
}
else
{
open = new Open()
{
ContainerId = MakeAmqpContainerId(),
HostName = this.address.Host,
MaxFrameSize = this.maxFrameSize,
ChannelMax = this.channelMax
};
}
if (open.IdleTimeOut > 0)
{
this.heartBeat = new HeartBeat(this, open.IdleTimeOut * 2);
}
ITransport transport;
{
TcpTransport tcpTransport = new TcpTransport();
tcpTransport.Connect(this, this.address, DisableServerCertValidation);
transport = tcpTransport;
}
try
{
if (saslProfile != null)
{
transport = saslProfile.Open(this.address.Host, transport);
}
else if (this.address.User != null)
{
transport = new SaslPlainProfile(this.address.User, this.address.Password).Open(this.address.Host, transport);
}
}
catch
{
transport.Close();
throw;
}
this.writer = new Writer(transport);
// after getting the transport, move state to open pipe before starting the pump
this.SendHeader();
this.SendOpen(open);
this.state = ConnectionState.OpenPipe;
this.reader = new Pump(this, transport);
this.reader.Start();
}
private void Awake()
{
instance = this;
usedAudioSources = new List<AudioSource>();
unusedAudioSources = new List<AudioSource>();
heartBeat = gameObject.AddComponent<HeartBeat>();
heartBeat.Initialize(this, heartBeat1, heartBeat2);
}
// Use this for initialization
void Start()
{
motor = gameObject.GetComponent<CharacterMotor>();
pic = gameObject.GetComponent<PlatformInputController>();
heart = GameObject.Find ("Player").GetComponent<HeartBeat>();
GameObject.Find("Spawn Particles").GetComponent<ParticleSystem>().Play(true);
boost = 3.0f;
}
public void Start()
{
m_hb=this;
m_AS=(AudioSource)gameObject.GetComponent<AudioSource>();
m_PS=(ParticleSystem)gameObject.GetComponent<ParticleSystem>();
m_mass=(Mass)gameObject.GetComponent<Mass>();
m_curMax=m_baseMax;
m_curRate=m_baseEmissionRate;
sm_planetBonus=0;
sm_score=0;
}
public AmqpConnection(TransportBase transport, ProtocolHeader protocolHeader, bool isInitiator, AmqpSettings amqpSettings, AmqpConnectionSettings connectionSettings) :
base((isInitiator ? "out" : "in") + "-connection", transport, connectionSettings, isInitiator)
{
if (amqpSettings == null)
{
throw new ArgumentNullException("amqpSettings");
}
this.initialHeader = protocolHeader;
this.isInitiator = isInitiator;
this.amqpSettings = amqpSettings;
this.sessionsByLocalHandle = new HandleTable<AmqpSession>(this.Settings.ChannelMax ?? AmqpConstants.DefaultMaxConcurrentChannels - 1);
this.sessionsByRemoteHandle = new HandleTable<AmqpSession>(this.Settings.ChannelMax ?? AmqpConstants.DefaultMaxConcurrentChannels - 1);
this.SessionFactory = this;
this.heartBeat = HeartBeat.None;
}
void OnReceiveOpen(Open open)
{
StateTransition stateTransition = this.TransitState("R:OPEN", StateTransition.ReceiveOpen);
uint peerIdleTimeout = open.IdleTimeOut();
if (peerIdleTimeout < this.Settings.MinIdleTimeout)
{
this.CompleteOpen(false,
new AmqpException(AmqpErrorCode.NotAllowed, AmqpResources.GetString(AmqpResources.AmqpIdleTimeoutNotSupported, peerIdleTimeout, this.Settings.MinIdleTimeout)));
return;
}
this.Negotiate(open);
this.NotifyOpening(open);
if (stateTransition.To == AmqpObjectState.OpenReceived)
{
this.SendOpen();
}
if(this.isInitiator)
{
// check if open returned an error right away
Error openError = null;
if (open.Properties != null && open.Properties.TryGetValue<Error>(AmqpConstants.OpenErrorName, out openError))
{
this.CompleteOpen(stateTransition.From == AmqpObjectState.Start, new AmqpException(openError));
return;
}
}
uint myIdleTimeout = this.Settings.IdleTimeOut();
peerIdleTimeout = open.IdleTimeOut();
if (peerIdleTimeout != uint.MaxValue || myIdleTimeout != uint.MaxValue)
{
this.heartBeat = HeartBeat.Initialize(this, myIdleTimeout, peerIdleTimeout);
}
this.CompleteOpen(stateTransition.From == AmqpObjectState.Start, null);
}
private void InitModule()
{
mHeartBeat = new HeartBeat();
mCltSyncMgr = ClientSyncMgr.Inst;
}
void Start()
{
defaultBeat = (HeartBeat) GameObject.Find("Player").GetComponent("HeartBeat");
initialPosition = transform.position;
target += transform.position;
}
