private bool StartRemoteService()
{
bool bRet = false;
_remoteMessageHandler = new PeerServices();
_remoteHost = new ServiceHost(_remoteMessageHandler);
//To handle the remote traffic
_remoteMessageHandler.OnRemoteEnergyRequest += new manageEnergyRequest(ManageRemoteEnergyRequest);
_remoteMessageHandler.OnRemoteEnergyReply += new replyEnergyRequest(ManageRemoteEnergyReply);
_remoteMessageHandler.OnRemotePeerIsDown += new remotePeerIsDown(RemotePeerIsDown);
try
{
_remoteHost.Open();
bRet = true;
XMLLogger.WriteRemoteActivity("Remote service started.");
}
catch (Exception e)
{
XMLLogger.WriteErrorMessage(this.GetType().FullName.ToString(), "Unable to start Remote Service.");
//XMLLogger.WriteErrorMessage(this.GetType().FullName.ToString(), e.ToString()); //For debug purpose
_remoteHost.Abort();
}
return(bRet);
}
private void ForwardEnergyRequest(StatusNotifyMessage message)
{
XMLLogger.WriteRemoteActivity("Forwarding " + message.energyReq + "kW Energy Request from: " + message.header.Sender);
XMLLogger.WriteRemoteActivity("MessageID: " + message.header.MessageID);
_requestThread = new Thread(new ParameterizedThreadStart(ConnectToRemoteHost));
_requestThread.Start(message);
}
private void ManageRemoteEnergyRequest(RemoteEnergyRequest message)
{
RemoteConnection remConn;
Guid MessageID = message.enReqMessage.header.MessageID;
string remotePeer = message.enReqMessage.header.Sender;
XMLLogger.WriteRemoteActivity("Received Remote Energy Request from: " + message.enReqMessage.header.Sender + " by Remote Resolver: " + message.header.Sender);
XMLLogger.WriteRemoteActivity("Message ID: " + message.enReqMessage.header.MessageID);
remConn = GetConnection(message.IP, message.port, ConnectionType.Incoming);
if (remConn == null)//If entry doesn't exist
{
remConn = new RemoteConnection()
{
type = ConnectionType.Incoming,
remoteResolver = new RemoteHost()
{
name = message.header.Sender,
IP = message.IP,
port = message.port,
netAddress = @"net.tcp://" + message.IP + ":" + message.port + @"/Remote"
}
};
remConn.requests.Add(MessageID, new RemoteRequest()
{
localePeerName = "",
remotePeerName = remotePeer,
energy = 0
});
_remoteConnections.Add(remConn);
}
else
{
remConn.requests.Add(MessageID, new RemoteRequest()
{
localePeerName = "",
remotePeerName = remotePeer,
energy = 0
});
}
_broker.EnergyLookUp(message.enReqMessage);
}
//public void EnergyLookUp(object m)
public void EnergyLookUp(StatusNotifyMessage message)
{
//StatusNotifyMessage message = (StatusNotifyMessage)m;
_sem.Wait();
_originPeerName = message.header.Sender;
_enLookUp = message.energyReq;
_originGuid = message.header.MessageID;
message.header.Sender = this._name;
XMLLogger.WriteRemoteActivity("Broker is serving: " + message.header.MessageID + " session.");
Connector.channel.statusAdv(message);
_proposalCountdown.Enabled = true;
}
void ForwardEnergyReply(EndProposalMessage message)
{
RemoteConnection conn = GetConnectionByMessageID(message.header.MessageID, ConnectionType.Incoming);
XMLLogger.WriteRemoteActivity("Forwarding Remote Response about message: " + message.header.MessageID + " Status = " + message.endStatus);
XMLLogger.WriteRemoteActivity("Message ID: " + message.header.MessageID);
if (conn != null)
{
//Header re-handling
conn.requests[message.header.MessageID].localePeerName = message.header.Sender;
conn.requests[message.header.MessageID].energy = message.energy;
message.header.Receiver = conn.requests[message.header.MessageID].remotePeerName;
#region Creating Channel
NetTcpBinding tcpBinding = new NetTcpBinding();
EndpointAddress remoteEndpoint = new EndpointAddress(conn.remoteResolver.netAddress);
tcpBinding.Security.Mode = SecurityMode.None;
ChannelFactory <IRemote> cf = new ChannelFactory <IRemote>(tcpBinding, remoteEndpoint);
IRemote tChannel = cf.CreateChannel();
#endregion
RemoteEndProposalMessage remoteEndMessage = (MessageFactory.createRemoteEndProposalMessage(message, conn.remoteResolver.name, this.name, Tools.getLocalIP(), Tools.getResolverServicePort()));
try
{
tChannel.ReplyEnergyRequest(remoteEndMessage);
}
catch (Exception e)
{
XMLLogger.WriteErrorMessage(this.GetType().FullName.ToString(), "Error in Forwarding Energy Reply Message: " + e.ToString());
}
}
else
{
XMLLogger.WriteErrorMessage(this.GetType().FullName.ToString(), "Could not find the following message: " + message.header.MessageID);
}
}
private void _proposalCountdown_Elapsed(object sender, ElapsedEventArgs e)
{
_proposalCountdown.Enabled = false; //Stop the timer
if (_proposalList.Count > 0)
{
_proposalTimeout = 0;
EvaluateProposal();
}
else
{
_proposalTimeout++;
if (_proposalTimeout > 2) //Go Outbound
{
float enReq = _enPeak - (getEnergyLevel() + _enBought);
XMLLogger.WriteRemoteActivity("Going Outside to find " + enReq + " KW/h");
Connector.channel.forwardEnergyRequest(MessageFactory.createEnergyRequestMessage(_resolverName, _name, _peerStatus, enReq));
messageSent = true;
_proposalTimeout = 0;
//start the timer to waiting for proposals
if (_proposalCountdown.Enabled == false)
{
_proposalCountdown.Enabled = true;
}
}
else
{
XMLLogger.WriteLocalActivity("No Energy proposal receveid");
messageSent = false; //send the request message again
}
}
}
public virtual void peerDown(PeerIsDownMessage message)
{
XMLLogger.WriteRemoteActivity("Peer " + message.peerName + " is down");
}
void ManageRemoteEnergyReply(RemoteEndProposalMessage message)
{
string localBuilding = message.endProposalMessage.header.Receiver;
string remoteBuilding = message.endProposalMessage.header.Sender;
float energyBought = message.endProposalMessage.energy;
if (message.endProposalMessage.endStatus == true)
{
RemoteConnection oC;
oC = GetConnection(message.IP, message.port, ConnectionType.Outgoing);
if (oC == null)
{
oC = new RemoteConnection()
{
type = ConnectionType.Outgoing,
remoteResolver = new RemoteHost()
{
name = message.header.Sender,
IP = message.IP,
port = message.port,
netAddress = @"net.tcp://" + message.IP + ":" + message.port + @"/Remote"
}
};
oC.requests.Add(message.endProposalMessage.header.MessageID, new RemoteRequest()
{
localePeerName = localBuilding,
remotePeerName = remoteBuilding,
energy = energyBought
});
_remoteConnections.Add(oC);
}
else
{
oC.requests.Add(message.endProposalMessage.header.MessageID, new RemoteRequest()
{
localePeerName = localBuilding,
remotePeerName = remoteBuilding,
energy = energyBought
});
}
XMLLogger.WriteRemoteActivity("Received Remote Energy Reply from: " + remoteBuilding + "@" + message.header.Sender);
XMLLogger.WriteRemoteActivity("Message ID: " + message.endProposalMessage.header.MessageID);
Connector.channel.endProposal(message.endProposalMessage);
}
else //No Energy From this remote resolver..Go with the next
{
Connector.channel.endProposal(message.endProposalMessage);
lock (_counterLock)
{
_nHostIndex++;
}
}
}
private void ConnectToRemoteHost(object m)
{
bool connected = false;
StatusNotifyMessage message = (StatusNotifyMessage)m;
_remoteResolvers = Tools.getRemoteHosts();
while (connected == false && _nHostIndex < _remoteResolvers.Count)
{
lock (_counterLock)
{
//localhost connections filter
if (_remoteResolvers[_nHostIndex].IP == "127.0.0.1" || _remoteResolvers[_nHostIndex].IP.ToLower() == "localhost")
{
if (_nHostIndex < (_remoteResolvers.Count - 1))
{
_nHostIndex++;
}
else
{
_nHostIndex = 0;
}
continue;
}
XMLLogger.WriteRemoteActivity("Connecting to " + _remoteResolvers[_nHostIndex].IP);
NetTcpBinding tcpBinding = new NetTcpBinding();
EndpointAddress remoteEndpoint = new EndpointAddress(_remoteResolvers[_nHostIndex].netAddress);
tcpBinding.Security.Mode = SecurityMode.None;
ChannelFactory <IRemote> cf = new ChannelFactory <IRemote>(tcpBinding, remoteEndpoint);
_remoteChannel = cf.CreateChannel();
try
{
_remoteChannel.Open();
//Retrieve Remote IP Addresses
foreach (var newRemote in _remoteChannel.RetrieveContactList())
{
if (!_remoteResolvers.Exists(delegate(RemoteHost x) { return(x.netAddress == newRemote.netAddress); }))
{
_remoteResolvers.Add(newRemote);
Tools.updateRemoteHosts(newRemote);
}
}
XMLLogger.WriteRemoteActivity("Connected to: " + _remoteResolvers[_nHostIndex].IP);
XMLLogger.WriteRemoteActivity("Forwarding Energy Request from: " + message.header.Sender + "To: " + _remoteResolvers[_nHostIndex]);
XMLLogger.WriteRemoteActivity("Message ID: " + message.header.MessageID);
_remoteChannel.ManageRemoteEnergyRequest(MessageFactory.createRemoteEnergyRequestMessage(message,
_remoteResolvers[_nHostIndex].name,
this.name,
Tools.getLocalIP(),
Tools.getResolverServicePort()
));
this.isRemoteConnected = true;
connected = true;
}
catch (Exception e)
{
XMLLogger.WriteErrorMessage(this.GetType().FullName.ToString(), "Unable to connect to remote host.");
//XMLLogger.WriteErrorMessage(this.GetType().FullName.ToString(), e.ToString()); //For debug purpose
_nHostIndex++;
if (_nHostIndex >= _remoteResolvers.Count)
{
_nHostIndex = 0;
_remoteChannel.Abort();
}
connected = false;
}
}
}
if (_nHostIndex >= _remoteResolvers.Count)
{
lock (_counterLock)
{
_nHostIndex = 0;
}
}
}
