public Socket(Line Line, PeerListener Listener) : this(Line)
{
m_Status = PeerStatus.Connecting;
Listener.DoneEvent += ToTransmission;
Listener.ErrorEvent += ToClose;
m_Machine.Push(Listener);
}
public void ClientDisconnect()
{
try
{
if (Status != PeerStatus.CONNECTED || !HostId.IsValid)
{
throw new Exception("Attempted to disconnect while not connected or HostId is invalid");
}
if (!SteamNetworking.CloseP2PSessionWithUser(HostId))
{
throw new Exception($"Unable to disconnect from {HostId}");
}
}
catch (Exception e)
{
Output.LogError($"{Name}: Exception in ClientDisconnect ({e.Message})");
}
finally
{
// Reset status and host id
_status = PeerStatus.OFFLINE;
_host = new SteamId();
// Raise OnDisconnected event
OnDisconnected?.Invoke();
}
}
public NetPeer(PeerAddress nodeAddress, PeerAddress peerAddress, Socket socket = null)
{
_nodeAddress = nodeAddress;
_peerAddress = peerAddress;
_socket = socket;
_status = PeerStatus.Idle;
if (_socket == null)
{
ConnectPeer();
_status = PeerStatus.SendingId;
}
if (peerAddress == null)
{
_status = PeerStatus.WaitingId;
}
_socket.Blocking = false;
_socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);
_running = true;
_thread = new Thread(Run);
_thread.Start();
}
public Socket(Line line, PeerListener listener) : this(line)
{
_Status = PeerStatus.Connecting;
listener.DoneEvent += ToTransmission;
listener.ErrorEvent += ToClose;
_Machine.Push(listener);
}
public StartPeerViewModel()
{
#region Init
_totalEnergy = 0f;
_totalPrice = 0f;
OnPropertyChanged("GetTotalEnergy");
OnPropertyChanged("GetTotalPrice");
_priceHeaderWidth = 0;
OnPropertyChanged("GetPriceWidth");
_refreshListTimer = new DispatcherTimer();
_refreshListTimer.Interval = new TimeSpan(0, 0, 4);
_refreshListTimer.Tick += new EventHandler(_refreshListTimer_Tick);
_infoColour = "Gray";
OnPropertyChanged("GetInfoColour");
_infoViewEnabled = false;
OnPropertyChanged("InfoViewEnabled");
_sellerBuyer = "";
OnPropertyChanged("GetSellerBuyer");
_checkIconFieldsVisibility = "Visible";
OnPropertyChanged("CheckIconFieldsVisibility");
_checkIconInfoVisibility = "Hidden";
OnPropertyChanged("CheckIconInfoVisibility");
_setFieldsVisibility = "Visible";
OnPropertyChanged("SetFieldsVisibility");
_setInfoVisibility = "Hidden";
OnPropertyChanged("SetFieldsVisibility");
SetErrorMessages();
_imgPath = @"/WPF_StartPeer;component/img/offline.png";
_startButtonIconPath = @"/WPF_StartPeer;component/img/disconnected.png";
_peerStatus = "Offline...";
_formEnabled = true;
OnPropertyChanged("FormEnabled");
_startButton = "Connect";
_status = PeerStatus.Consumer;
#endregion
this.StartPeer = new DelegateCommand(o => this.Start(), o => this.canDo);
this.SetProducer = new DelegateCommand(o => this.Producer(), o => this.canDo);
this.Exit = new DelegateCommand(o => this.AppExit(), o => this.canDo);
this.ViewLog = new DelegateCommand(o => this.Log(), o => this.canDo);
this.ViewSplash = new DelegateCommand(o => this.Splashing(), o => this.canDo);
this.ShowFields = new DelegateCommand(o => this.FieldsView(), o => this.canDo);
this.ShowInfo = new DelegateCommand(o => this.InfoView(), o => this.canDo);
}
public SignalNowPeer(string userId, PeerStatus status, TimeSpan statusExpirationTimeout)
{
SetUserId(userId);
Status = status;
StatusExpirationTimeout = statusExpirationTimeout;
LastStatusTime = DateTime.UtcNow;
LastDataMessageTime = DateTime.MinValue;
}
private void ToTransmission()
{
m_Status = PeerStatus.Transmission;
var stage = new PeerTransmission(_SendTasks, m_Line, _ReadTask);
stage.DisconnectEvent += _Disconnect;
m_Machine.Push(stage);
}
private void ToTransmission()
{
_Status = PeerStatus.Transmission;
PeerTransmission stage = new PeerTransmission(_Line, _Stream);
stage.DisconnectEvent += _Disconnect;
_Machine.Push(stage);
}
internal void SetPeerInfoStatus(Peer peer, PeerStatus status)
{
var addr = peer.EndPoint.Address.ToString();
var port = peer.EndPoint.Port;
var info = PeerInfoList.Where(x => x.Address == addr && x.Port == port).First();
if (info != null)
{
info.Status = status;
}
}
private void _Disconnect()
{
if (_Status != PeerStatus.Close)
{
_Status = PeerStatus.Disconnect;
PeerDisconnecter stage = new PeerDisconnecter(_Line);
stage.DoneEvent += ToClose;
_Machine.Push(stage);
}
}
internal void SetPeerInfoStatus(Peer peer, PeerStatus status)
{
var addr = peer.EndPoint.Address.ToString();
var port = peer.EndPoint.Port;
var info = PeerInfoList.Where(x => x.Address == addr && x.Port == port).First();
if (info != null)
{
info.Status = status;
}
}
public Peer(String ID, PeerStatus status = PeerStatus.None)
{
this.isConnected = false;
this.ID = ID;
this.status = status;
if (!(status == PeerStatus.Resolver)) //Il Resolver lancerà il servizio manualmente
{
this.StartService();
}
}
public Building(String Name, PeerStatus status, EnergyType enType, float enProduced, float energyPeak, float price, string address, string adminName)
: base(Name)
{
_name = Name;
_enType = enType;
_enProduced = enProduced;
_enPeak = energyPeak;
_price = price;
_address = address;
_adminName = adminName;
_status = status;
_pwManager = new PowerManager(Name, status, new EnergyGenerator(enType, enProduced), energyPeak, price);
}
public void Producer()
{
if (_status == PeerStatus.Consumer)
{
_status = PeerStatus.Producer;
}
else
{
_status = PeerStatus.Consumer;
_enType = EnergyType.None;
_price = 0;
OnPropertyChanged("EnType");
OnPropertyChanged("Price");
}
}
private System.Timers.Timer _mainTimer; //The main cycle
#endregion
#endregion
#region Methods
public PowerManager(String bName, PeerStatus status, EnergyGenerator generator, float energyPeak, float price)
{
this.MsgHandler = Connector.messageHandler;
#region EventListeners
MsgHandler.OnHelloResponse += new HelloResponse(ReceiveResolverName);
MsgHandler.OnStatusChanged += new statusNotify(CreateProposal);//Energy Request arrives
MsgHandler.OnProposalArrived += new energyProposal(ReceiveProposal);
MsgHandler.OnProposalAccepted += new acceptProposal(ProposalAccepted);
MsgHandler.OnEndProposalArrived += new endProposal(EndProposal);
MsgHandler.OnPeerDown += new alertPeerDown(SomePeerIsDown);
#endregion
#region Init Session
_generator = generator;
_enPeak = energyPeak;
_name = bName;
_peerStatus = status;
producers = new ObservableCollectionEx <EnergyLink>();
consumers = new ObservableCollectionEx <EnergyLink>();
_price = price;
_enBought = 0f;
_enSold = 0f;
#region Timing Zone
_proposalCountdown = new System.Timers.Timer();
_proposalCountdown.Interval = 5000;
_proposalCountdown.Elapsed += new ElapsedEventHandler(_proposalCountdown_Elapsed);
_proposalCountdown.Enabled = false;
_heartBeatTimer = new System.Timers.Timer();
_heartBeatTimer.Enabled = false;
_heartBeatTimer.Interval = 5000;
_heartBeatTimer.Elapsed += new ElapsedEventHandler(_heartBeatTimer_Elapsed);
_mainTimer = new System.Timers.Timer();
_mainTimer.Interval = 500;
_mainTimer.Elapsed += new ElapsedEventHandler(_mainTimer_Elapsed);
_mainTimer.Enabled = false;
#endregion
#endregion
}
public static HelloMessage CreateHelloMessage(string dest, string source, PeerStatus status, EnergyType enType,
float enProduced, float enPeak, float enPrice, string address, string admin)
{
HelloMessage message = new HelloMessage()
{
header = Tools.getHeader(dest, source),
Status = status,
EnType = enType,
EnProduced = enProduced,
EnPeak = enPeak,
EnPrice = enPrice,
Address = address,
Admin = admin
};
return(message);
}
internal void Resurrect(PeerStatus status = PeerStatus.Online)
{
LastStatusTime = DateTime.UtcNow;
Status = status;
}
public static StatusNotifyMessage createEnergyRequestMessage(string dest, string source, PeerStatus peerStatus, float enReq)
{
StatusNotifyMessage message = new StatusNotifyMessage()
{
header = Tools.getHeader(dest, source),
status = peerStatus,
energyReq = enReq
};
return(message);
}
private void OnMessageIn(string senderId, string messageType, string messagePayload)
{
if (disconnecting)
{
return;
}
DateTime messageTime = DateTime.UtcNow;
if (messageType.Equals("I_AM_HERE", StringComparison.InvariantCultureIgnoreCase))
{
TimeSpan statusExpirationTimeout = TimeSpan.FromSeconds(int.Parse(messagePayload));
bool newPeer = true;
if (peers.ContainsKey(senderId))
{
newPeer = false;
peers[senderId].Resurrect();
PeerStatusChanged?.Invoke(this, peers[senderId]);
}
string response = $"[\"{(int)Me.StatusExpirationTimeout.TotalSeconds}\", \"{Me.Status.ToString()}\"]";
SendImportantMessage(senderId, false, "HELLO", response, true)
.ContinueWith((res) =>
{
if (newPeer)
{
peers[senderId] = new SignalNowPeer(senderId, PeerStatus.Online, statusExpirationTimeout);
NewPeer?.Invoke(this, peers[senderId]);
}
});
}
else if (messageType.Equals("HELLO", StringComparison.InvariantCultureIgnoreCase))
{
JArray paramArray = JArray.Parse(messagePayload);
var timeoutStr = paramArray[0].ToString();
var statusStr = paramArray[1].ToString();
TimeSpan statusExpirationTimeout = TimeSpan.FromSeconds(int.Parse(timeoutStr));
PeerStatus status = (PeerStatus)Enum.Parse(typeof(PeerStatus), statusStr, true);
if (!peers.ContainsKey(senderId))
{
peers[senderId] = new SignalNowPeer(senderId, status, statusExpirationTimeout);
NewPeer?.Invoke(this, peers[senderId]);
}
else
{
peers[senderId].LastStatusTime = messageTime;
peers[senderId].Status = status;
peers[senderId].StatusExpirationTimeout = statusExpirationTimeout;
PeerStatusChanged?.Invoke(this, peers[senderId]);
}
}
else if (messageType.Equals("I_AM_OUTTA_HERE", StringComparison.InvariantCultureIgnoreCase))
{
if (peers.ContainsKey(senderId))
{
peers[senderId].Status = PeerStatus.Offline;
PeerStatusChanged?.Invoke(this, peers[senderId]);
#if UNITY_2018_2_OR_NEWER
UnityEngine.Debug.Log($"{senderId} quit.");
#else
System.Diagnostics.Debug.WriteLine($"{senderId} quit.");
#endif
}
}
else
{
// only respect messages from peers we had a handshake with
if (peers.ContainsKey(senderId))
{
peers[senderId].LastDataMessageTime = messageTime;
peers[senderId].LastStatusTime = messageTime;
if (messageType.Equals("STILL_HERE", StringComparison.InvariantCultureIgnoreCase))
{
PeerStatus status = (PeerStatus)Enum.Parse(typeof(PeerStatus), messagePayload, true);
peers[senderId].Status = status;
}
else
{
Task.Run(() =>
{
NewMessage?.Invoke(this, senderId, messageType, messagePayload);
});
}
}
}
}
private void ToClose()
{
CloseEvent();
_Status = PeerStatus.Close;
_Machine.Empty();
}
public Socket(Line Line, PeerConnecter Connecter) : this(Line)
{
m_Status = PeerStatus.Connecting;
Connecter.DoneEvent += ToTransmission;
m_Machine.Push(Connecter);
}
public Socket(Line line, PeerConnecter connecter) : this(line)
{
_Status = PeerStatus.Connecting;
connecter.DoneEvent += ToTransmission;
_Machine.Push(connecter);
}
protected override void ResetStatus()
{
_active = false;
_status = PeerStatus.OFFLINE;
}
public async void ConnectToId(SteamId hostId)
{
// Refuse to attempt another connection if one is active or in progress
if (Active || Status == PeerStatus.CONNECTING)
{
Output.LogWarning($"{Name}: Attempted to connect while a previous connection is active or in progress");
return;
}
// Set timeout start time, set client active, and set client status to Connecting
DateTime timeoutStart = DateTime.Now;
// Set status appropriately
_active = true;
_status = PeerStatus.CONNECTING;
try
{
// Send a request to connect
byte[] sendData = new byte[] { (byte)PacketType.CONNECT };
SendPacket(hostId, sendData, sendData.Length);
while (Status == PeerStatus.CONNECTING)
{
// Wait for a packet to arrive
while (!IsPacketAvailable())
{
TimeSpan timeoutChk = DateTime.Now - timeoutStart;
if (timeoutChk.TotalMilliseconds >= MP_TIMEOUT)
{
throw new Exception("Timed out attempting to connect");
}
await Task.Delay(TimeSpan.FromMilliseconds(TickRate));
}
GetNextPacket(out P2Packet? packet);
if (packet == null)
{
throw new Exception("Null packet received");
}
// If the packet is not null, get data and sender SteamId
byte[] data = packet.Value.Data;
SteamId sender = packet.Value.SteamId;
if (data.Length < 1 || data == null)
{
throw new Exception("Null or zero-length data array received");
}
// Ignore packets sent by someone who isn't expected
if (sender != hostId)
{
continue;
}
if (data[0] != (byte)PacketType.CONNECTION_ACCEPTED)
{
throw new Exception($"Unexpected response ({data[0]})");
}
// Now connected to a new server, set status and refresh receive queue
_status = PeerStatus.CONNECTED;
_receiveQueue.Clear();
// Raise OnConnected event
OnConnected?.Invoke();
}
_host = hostId;
}
catch (Exception e)
{
Output.LogError($"{Name}: Error connecting to host ({e.Message})");
// If we catch an exception, reset active and status
ResetStatus();
}
}
public Task <bool> SetMyStatus(PeerStatus status)
{
Me.Status = status;
Me.LastStatusTime = DateTime.UtcNow;
return(SendMessageToAll("STILL_HERE", Me.Status.ToString(), true));
}
