public void Handle(IGluonSession session, HealthPing ping)
{
session.Write(new HealthPingResponse {
CallId = ping.CallId,
PoolHash = HostPool.PoolHash
});
}
public void Handle(IGluonSession session, TransferClaim request)
{
if (request.Type != Protocol.Gluon.Model.ClaimType.LOT)
{
//what?
session.Write(new TransferClaimResponse
{
Status = TransferClaimResponseStatus.REJECTED,
Type = request.Type,
ClaimId = request.ClaimId,
EntityId = request.EntityId
});
return;
}
Lots.TryClose(request.EntityId, request.ClaimId);
try
{
using (var db = DAFactory.Get())
{
db.LotClaims.Delete(request.ClaimId, request.FromOwner);
}
}
catch (Exception e)
{
//probably already unclaimed. do nothing.
}
}
public void Handle(IGluonSession session, TransferClaimResponse claimResponse)
{
if (claimResponse.Type == Protocol.Gluon.Model.ClaimType.LOT)
{
Lots.OnTransferClaimResponse(claimResponse);
}
}
public void Handle(IGluonSession session, ShardShutdownRequest request)
{
//todo: how to handle partial shard shutdown?
//if there are two separate cities, sure they can both shut down separately and the lot server will not need a "full" shutdown.
//...assuming they dont want to upgrade the software! in this case, reconnecting to the upgraded city server without upgrading ourselves
//could prove to be an issue!
//just assume for now that lot servers are for a single shard each.
var server = Kernel.Get <LotServer>();
Lots.Shutdown().ContinueWith(x =>
{
if (x.Result)
{
//shutdown complete. Send a response!
session.Write(new ShardShutdownCompleteResponse
{
ShardId = request.ShardId
});
server.Shutdown(); //actually shut down the server
server.SignalInternalShutdown(request.Type);
}
else
{
//shutdown already started likely.
}
});
}
public void UpdateServerAdvertisement(IGluonSession session, AdvertiseCapacity request)
{
lock (Servers)
{
var state = GetState(session);
if (state == null)
{
state = new LotServerState {
Session = session
};
Servers.Add(state);
if (ServersByCallsign.ContainsKey(session.CallSign))
{
ServersByCallsign[session.CallSign] = state;
}
else
{
ServersByCallsign.Add(session.CallSign, state);
}
}
state.Session = session; //can be hot-swapped if we re-establish connection. TODO: verify and look for race conditions
state.MaxLots = request.MaxLots;
state.CurrentLots = request.CurrentLots;
state.CpuPercentAvg = request.CpuPercentAvg;
state.RamAvaliable = request.RamAvaliable;
state.RamUsed = request.RamUsed;
}
}
public async void Handle(IGluonSession session, NotifyLotRoommateChange packet)
{
//recieved from a lot server to notify of another lot's roommate change.
using (var da = DAFactory.Get())
{
var lot = da.Lots.Get(packet.LotId);
if (lot == null)
{
return; //lot missing
}
DataService.Invalidate <FSO.Common.DataService.Model.Lot>(lot.location);
//if online, notify the lot
var lotOwned = da.LotClaims.GetByLotID(lot.lot_id);
if (lotOwned != null)
{
var lotServer = LotServers.GetLotServerSession(lotOwned.owner);
if (lotServer != null)
{
//immediately notify lot of new roommate
lotServer.Write(packet);
}
}
else
{
//try force the lot open
//we don't need to send any packets in this case - the lot fully restores object ownership from db.
var result = await Lots.TryFindOrOpen(lot.location, 0, NullSecurityContext.INSTANCE);
}
}
}
public LotHostEntry TryHost(int id, IGluonSession cityConnection)
{
lock (Lots)
{
if (AwaitingShutdown)
{
return(null);
}
if (Lots.Values.Count >= Config.Max_Lots)
{
//No room
return(null);
}
if (Lots.ContainsKey(id))
{
return(null);
}
var ctnr = Kernel.Get <LotHostEntry>();
var bind = Kernel.GetBindings(typeof(LotHostEntry));
ctnr.CityConnection = cityConnection;
Lots.Add(id, ctnr);
CityConnections.LotCount = (short)Lots.Count;
return(ctnr);
}
}
public void Handle(IGluonSession session, RequestClientSession request)
{
//Respond asking for a gluon challenge
session.Write(new RequestChallenge()
{
CallSign = session.CallSign, PublicHost = session.PublicHost, InternalHost = session.InternalHost
});
}
public void Handle(IGluonSession session, RequestChallengeResponse challenge)
{
var rawSession = ((CityConnection)session);
var answer = ChallengeResponse.AnswerChallenge(challenge.Challenge, Secret);
session.Write(new AnswerChallenge {
Answer = answer
});
}
public async void Handle(IGluonSession session, MatchmakerNotify packet)
{
switch (packet.Mode)
{
case MatchmakerNotifyType.RemoveAvatar:
Matchmaker.RemoveAvatar(packet.LotID, packet.AvatarID);
break;
}
}
public async void Handle(IGluonSession session, CityNotify packet)
{
try
{
await Nhoods.TickNeighborhoods();
} catch (Exception e)
{
LOG.Error("Neighborhood Task Failed: " + e.ToString());
}
}
public void RegisterShutdown(IGluonSession session)
{
lock (ServersShutdown)
{
ServersShutdown.Remove(session);
if (ServersShutdown.Count == 0)
{
AllServersShutdown.SetResult(true);
}
}
}
public IGluonSession GetLotServerSession(string callSign)
{
lock (Servers)
{
IGluonSession result = null;
LotServerState state = null;
if (ServersByCallsign.TryGetValue(callSign, out state))
{
result = state.Session;
}
return(result);
}
}
public void Handle(IGluonSession session, TransferClaim request)
{
LOG.Info("Recieved lot host request... ");
if (request.Type != Protocol.Gluon.Model.ClaimType.LOT)
{
session.Write(new TransferClaimResponse {
Status = TransferClaimResponseStatus.REJECTED,
Type = request.Type,
ClaimId = request.ClaimId,
EntityId = request.EntityId
});
return;
}
var lot = Lots.TryHost(request.EntityId, session);
if (lot == null)
{
session.Write(new TransferClaimResponse
{
Status = TransferClaimResponseStatus.REJECTED,
Type = request.Type,
ClaimId = request.ClaimId,
EntityId = request.EntityId
});
return;
}
if (Lots.TryAcceptClaim((int)request.EntityId, request.ClaimId, request.SpecialId, request.FromOwner, request.Action))
{
session.Write(new TransferClaimResponse
{
Status = TransferClaimResponseStatus.ACCEPTED,
Type = request.Type,
ClaimId = request.ClaimId,
EntityId = request.EntityId
});
}
else
{
session.Write(new TransferClaimResponse
{
Status = TransferClaimResponseStatus.CLAIM_NOT_FOUND,
Type = request.Type,
ClaimId = request.ClaimId,
EntityId = request.EntityId
});
}
}
public void Handle(IGluonSession session, SendCityMail packet)
{
try
{
foreach (var mail in packet.Items)
{
SendEmail(mail, true);
}
}
catch (Exception e)
{
LOG.Error("Failed to send an ingame email from another service: " + e.ToString());
}
}
public async void Handle(IGluonSession session, DataServiceWrapperPDU packet)
{
try //data service throws exceptions (SecurityException, etc) when invalid requests are made. These should not crash the server...
{
if (packet.Body is cTSOTopicUpdateMessage)
{
//Client wants to update a value in the data service
var update = packet.Body as cTSOTopicUpdateMessage;
DataService.ApplyUpdate(update, session);
List <uint> resultDotPath = new List <uint>();
foreach (var item in update.DotPath)
{
resultDotPath.Add(item);
if (item == packet.RequestTypeID)
{
break;
}
}
try
{
var result = await DataService.SerializePath(resultDotPath.ToArray());
if (result != null)
{
session.Write(new DataServiceWrapperPDU()
{
SendingAvatarID = packet.SendingAvatarID,
RequestTypeID = packet.RequestTypeID,
Body = result
});
}
} catch (Exception e)
{
//TODO
//keep this silent for now - bookmarks tend to spam errors.
}
}
}
catch (Exception e)
{
LOG.Error(e, "Gluon DataService request failed!");
}
}
public void Handle(IGluonSession session, RequestTask task)
{
var shardId = new Nullable <int>();
if (task.ShardId > 0)
{
shardId = task.ShardId;
}
var id = TaskEngine.Run(new TaskRunOptions()
{
Task = task.TaskType,
Shard_Id = shardId,
Parameter = JsonConvert.DeserializeObject(task.ParameterJson)
});
session.Write(new RequestTaskResponse()
{
CallId = task.CallId,
TaskId = id
});
}
public void Handle(IGluonSession session, TuningChanged request)
{
Lots.UpdateTuning(request.UpdateInstantly);
}
public void Handle(IGluonSession session, AdvertiseCapacity capacity)
{
PickingEngine.UpdateServerAdvertisement(session, capacity);
}
private LotServerState GetState(IGluonSession session)
{
var server = Servers.FirstOrDefault(x => x.Session == session);
return(server);
}
public void Handle(IGluonSession session, ShardShutdownCompleteResponse request)
{
Picker.RegisterShutdown(session);
}
public void Handle(IGluonSession session, AnswerAccepted accepted)
{
var rawSession = ((CityConnection)session);
rawSession.AuthenticationEstablished();
}
public void Handle(IGluonSession session, RequestLotClientTermination request)
{
Lots.TryDisconnectClient(request.LotId, request.AvatarId);
}
public void Handle(IGluonSession session, NotifyLotRoommateChange request)
{
Lots.NotifyRoommateChange(request.LotId, request.AvatarId, request.ReplaceId, request.Change);
}
