public async Task <IResponse> Process(IRequest request)
{
try
{
LoginUserRequest lr = request as LoginUserRequest;
LoginUserResponse response = new LoginUserResponse();
if (!string.IsNullOrEmpty(lr.UserName) && !string.IsNullOrEmpty(lr.Password))
{
//Compute actor id for user name
ActorId userid = lr.UserName.ToLowerInvariant().ToMD5GuidActorId();
var userproxy = userid.Proxy <IUser>();
bool exists = await userproxy.isCreatedAsync(); //Note: change to NOT create actors later, possible vector
if (exists)
{
var loginproxy = userid.Proxy <ILogin>();
if (await loginproxy.ValidatePassword(lr.Password))
{
response.UserId = userid.GetGuidId();
response.Status = System.Net.HttpStatusCode.OK;
}
else
{
response.UserId = Guid.Empty;
response.Status = System.Net.HttpStatusCode.Forbidden;
}
}
else
{
//Already exists
response.UserId = Guid.Empty;
response.Status = System.Net.HttpStatusCode.NotFound;
}
return(response);
}
else
{
response.UserId = Guid.Empty;
response.Status = System.Net.HttpStatusCode.BadRequest;
}
return(response);
}
catch (Exception E)
{
E.Log();
ErrorResponse errorresponse = new ErrorResponse(E.Message);
return(errorresponse);
}
}
public async Task <IResponse> Process(IRequest request)
{
try
{
CreateSessionRequest rq = request as CreateSessionRequest;
CreateSessionResponse response = new CreateSessionResponse();
if (rq.SessionKey == string.Empty) //noSession
{
ActorId userActorId = new ActorId(rq.UserId);
var userProxy = userActorId.Proxy <IUser>();
if (await userProxy.isCreatedAsync())
{
var SessionProxy = userActorId.Proxy <ISession>();
if (await SessionProxy.CreateSessionAsync(userActorId, ""))
{
await SessionProxy.SetUsedAsync();
response.SessionKey = await SessionProxy.GetSessionHashAsync();
response.Status = System.Net.HttpStatusCode.OK;
}
else
{
await SessionProxy.SetUsedAsync();
response.SessionKey = await SessionProxy.GetSessionHashAsync();
response.Status = System.Net.HttpStatusCode.OK;
}
}
else
{
response.Status = System.Net.HttpStatusCode.Forbidden;
response.SessionKey = string.Empty;
}
}
else //Validate session
{
}
return(await Task.FromResult(response));
}
catch (Exception E)
{
E.Log();
ErrorResponse errorresponse = new ErrorResponse(E.Message);
return(errorresponse);
}
}
public async Task <IResponse> Process(IRequest request)
{
try
{
UserExistsRequest uer = request as UserExistsRequest;
UserExistsResponse response = new UserExistsResponse();
if (!string.IsNullOrEmpty(uer.UserName))
{
//Compute actor id for user name
ActorId userid = uer.UserName.ToLowerInvariant().ToMD5GuidActorId();
var userproxy = userid.Proxy <IUser>();
bool exists = await userproxy.isCreatedAsync(); //Note: change to NOT create actors later, possible vector
response.Exists = exists;
response.Status = System.Net.HttpStatusCode.OK;
}
else
{
response.Exists = false;
response.Status = System.Net.HttpStatusCode.NotAcceptable;
}
return(response);
}
catch (Exception E)
{
E.Log();
ErrorResponse errorresponse = new ErrorResponse(E.Message);
return(errorresponse);
}
}
async Task <bool> IUser.CreateUserAsync(string UserName, string Password, bool isDeveloper)
{
try
{
UserState state = await this.GetStateAsync <UserState>();
if (state.isCreated)
{
return(false);
}
//Try to create login state
ActorId loginId = UserName.ToLowerInvariant().ToMD5GuidActorId();
var loginproxy = loginId.Proxy <ILogin>();
if (!await loginproxy.Create(this.Id, Password))
{
return(false);
}
//Set rest of user state
state.LoginActorId = loginId;
state.UserName = UserName;
state.isDeveloper = isDeveloper;
state.isCreated = true;
await this.SetStateAsync(state);
return(true);
}
catch (Exception E)
{
this.Log(E);
return(false);
}
}
public async Task <bool> CheckUser(string name)
{
try
{
ActorId id = new ActorId(1);
var gateproxy = id.Proxy <IGate>();
GateRequest request = new GateRequest();
UserExistsRequest uer = new Shared.Requests.UserExistsRequest();
uer.UserName = name;
request.Kind = 1;
request.JsonPayload = uer.Serialize();
GateResponse response = await gateproxy.Process(request);
if (response.ResultCode == 200)
{
UserExistsResponse r = response.JsonPayload.Deserialize <UserExistsResponse>();
return(r.Exists);
}
return(false);
}
catch (Exception e)
{
await Logger.LogMessage(e);
throw (e);
}
}
public async Task <IResponse> Process(IRequest request)
{
try
{
CanStartRoundRequest csr = request as CanStartRoundRequest;
CanStartRoundResponse response = new CanStartRoundResponse();
if (csr.GameSessionId != Guid.Empty)
{
//Compute actor id for user name
ActorId gamesessionid = new ActorId(csr.GameSessionId);
var sessionproxy = gamesessionid.Proxy <ITankGameSession>();
bool canstart = await sessionproxy.CanStartRound(csr.RoundNo);
response = new CanStartRoundResponse(csr.GameSessionId, canstart, csr.RoundNo);
return(response);
}
return(response);
}
catch (Exception E)
{
E.Log();
ErrorResponse errorresponse = new ErrorResponse(E.Message);
return(errorresponse);
}
}
public async Task <List <RequestStats> > GetStats()
{
GameFabric.Logging.Logger.Instance.Message($"Called stats at{DateTime.UtcNow.ToUniversalTime()} ms: {DateTime.UtcNow.Millisecond}. ");
ActorId StatId = new ActorId(1);
List <RequestStats> _Stats = await StatId.Proxy <IStatistics>().GetStatistics("Gate");
_Stats = _Stats.OrderBy(p => p.CallKind).ToList();
return(_Stats);
}
public static async Task <bool> SaveGeneric <T>(this T toSave, ActorId targetId, bool compress = true)
{
try
{
if (compress)
{
return(await targetId.Proxy <IGenericStorage>().SetDataAsync(toSave.Serialize <T>().Compress()));
}
else
{
return(await targetId.Proxy <IGenericStorage>().SetDataAsync(toSave.Serialize <T>()));
}
}
catch (Exception E)
{
E.Log();
throw (E);
}
}
public static async Task <bool> ClearGeneric <T>(this ActorId toClear)
{
try
{
return(await toClear.Proxy <IGenericStorage>().DeleteDataAsync());
}
catch (Exception E)
{
E.Log();
return(false);
}
}
protected override async Task OnDeactivateAsync()
{
if (_Timer != null)
{
UnregisterTimer(_Timer);
_Timer = null;
}
ActorId StatId = new ActorId(1);
await StatId.Proxy <IStatistics>().UpdateStats("Gate", _StatDict);
await base.OnDeactivateAsync();
}
public static async Task <T> LoadGeneric <T>(this ActorId toLoadFrom, bool compressed = true)
{
try
{
if (compressed)
{
string data = await toLoadFrom.Proxy <IGenericStorage>().GetDataAsync();
return(data.Decompress().Deserialize <T>());
}
else
{
string data = await toLoadFrom.Proxy <IGenericStorage>().GetDataAsync();
return(data.Deserialize <T>());
}
}
catch (Exception E)
{
E.Log();
throw (E);
}
}
public static async Task <bool> DeleteActor <T>(this ActorId id, Uri serviceUri = null) where T : IActor
{
CancellationToken token = new CancellationToken();
if (serviceUri == null)
{
serviceUri = ServiceUriHelper.Resolve <T>();
}
var proxy = id.Proxy <T>(serviceUri);
ActorReference actorReference = ActorReference.Get(proxy);
var actorServiceProxy = ActorServiceProxy.Create(actorReference.ServiceUri, id);
await actorServiceProxy.DeleteActorAsync(id, token);
return(await Task.FromResult(true));
}
public async Task ExecuteAsync(string s)
{
Interlocked.Increment(ref InterfaceHub._NumQues);
ActorId gatewayId = new ActorId(Context.ConnectionId);
try
{
GateRequest request = s.Deserialize <GateRequest>();
GateResponse response = await gatewayId.Proxy <IGate>().Process(request);
}
catch (Exception e)
{
e.Log();
}
}
public async Task <string> pinggw()
{
try
{
GameFabric.Logging.Logger.Instance.Message($"Called pinggw at{DateTime.UtcNow.ToUniversalTime()} ms: {DateTime.UtcNow.Millisecond}. ");
ActorId gwid = new ActorId(1);
GateResponse r = await gwid.Proxy <IGate>().Process(new GateRequest());
return(r.JsonPayload);
}
catch (Exception e)
{
e.Log();
return(e.FormatException());
}
}
public async Task <IResponse> Process(IRequest request)
{
try
{
CreateUserRequest uer = request as CreateUserRequest;
CreateUserResponse response = new CreateUserResponse();
if (!string.IsNullOrEmpty(uer.UserName) && !string.IsNullOrEmpty(uer.Password))
{
//Compute actor id for user name
ActorId userid = uer.UserName.ToLowerInvariant().ToMD5GuidActorId();
var userproxy = userid.Proxy <IUser>();
bool exists = await userproxy.isCreatedAsync(); //Note: change to NOT create actors later, possible vector
if (!exists)
{
bool result = await userproxy.CreateUserAsync(uer.UserName, uer.Password, false);
response.Sucessful = true;
response.UserId = userid.GetGuidId();
response.Status = System.Net.HttpStatusCode.OK;
}
else
{
//Already exists
response.Sucessful = false;
response.UserId = Guid.Empty;
response.Status = System.Net.HttpStatusCode.Forbidden;
}
return(response);
}
else
{
response.Sucessful = false;
response.UserId = Guid.Empty;
response.Status = System.Net.HttpStatusCode.BadRequest;
}
return(response);
}
catch (Exception E)
{
E.Log();
ErrorResponse errorresponse = new ErrorResponse(E.Message);
return(errorresponse);
}
}
public async Task <IResponse> Process(IRequest request)
{
try
{
TankPositionQueRequest rq = request as TankPositionQueRequest;
ActorId SessionId = new ActorId(rq.TankGameSessionId);
await SessionId.Proxy <ITankGameSession>().NotifyPosition(new ActorId(rq.TankId), rq.x, rq.y, rq.z, rq.r);
//Do que resolution
TankPosistionResponse response = new TankPosistionResponse(rq.x, rq.y, rq.z, rq.r);
response.TankId = rq.TankId;
return(await Task.FromResult(response));
}
catch (Exception E)
{
E.Log();
ErrorResponse errorresponse = new ErrorResponse(E.Message);
return(errorresponse);
}
}
public async Task <IResponse> Process(IRequest request)
{
try
{
FireShellRequest rq = request as FireShellRequest;
FireShellResponse response = new FireShellResponse(rq.TankId, rq.pos, rq.rot, rq.vel);
//And notify
ActorId SessionId = new ActorId(rq.TankGameSessionId);
await SessionId.Proxy <ITankGameSession>().NotifyFireShell(new ActorId(rq.TankId), response.Serialize());
response.Status = HttpStatusCode.OK;
return(await Task.FromResult(response));
}
catch (Exception E)
{
E.Log();
ErrorResponse errorresponse = new ErrorResponse(E.Message);
return(errorresponse);
}
}
public async Task <IResponse> Process(IRequest request)
{
try
{
StartRoundRequest rq = request as StartRoundRequest;
StartRoundResponse response = new StartRoundResponse();
//And notify
ActorId SessionId = new ActorId(rq.TankGameSessionId);
await SessionId.Proxy <ITankGameSession>().StartRound(new ActorId(rq.UserId));
response.Status = HttpStatusCode.OK;
return(await Task.FromResult(response));
}
catch (Exception E)
{
E.Log();
ErrorResponse errorresponse = new ErrorResponse(E.Message);
return(errorresponse);
}
}
public async Task <IResponse> Process(IRequest request)
{
try
{
SendMessageRequest sendRequest = request as SendMessageRequest;
SendMessageResponse response = new SendMessageResponse();
EmptyResponse empty = new EmptyResponse();
if (sendRequest.FromUserId != Guid.Empty && sendRequest.ToUserId != Guid.Empty)
{
//Test reciever exists
ActorId userId = new ActorId(sendRequest.ToUserId);
var userproxy = userId.Proxy <IUser>();
bool exists = await userproxy.isCreatedAsync();
if (exists)
{
response.FromUserId = sendRequest.FromUserId;
response.Message = sendRequest.Message;
await userproxy.SendGateResponseAsync(new Models.GateResponse(this.ProcessorId, (int)System.Net.HttpStatusCode.OK, sendRequest.ToUserId, response.Serialize()));
}
else
{
empty.Status = System.Net.HttpStatusCode.BadRequest;
}
return(empty);
}
else
{
empty.Status = System.Net.HttpStatusCode.BadRequest;
}
return(empty);
}
catch (Exception E)
{
E.Log();
ErrorResponse errorresponse = new ErrorResponse(E.Message);
return(errorresponse);
}
}
public async Task Execute(string s)
{
//Use the current connection id (Guid) as the identity of the stateless gateway actor
ActorId gatewayId = new ActorId(Context.ConnectionId);
try
{
//Increment counter
Interlocked.Increment(ref InterfaceHub._NumCalls);
//Deserialize envelope request
GateRequest request = s.Deserialize <GateRequest>();
//call ServiceFabric gateway actor and process the request
GateResponse response = await gatewayId.Proxy <IGate>().Process(request);
//Return the response to the caller
await Clients.Caller.Invoke("Exec", response.Serialize());
}
catch (Exception e)
{
e.Log();
}
}
public async Task <IResponse> Process(IRequest request)
{
try
{
TakeDamageRequest rq = request as TakeDamageRequest;
TakeDamageResponse response = new TakeDamageResponse();
response.Status = HttpStatusCode.OK;
response.TankGameSessionId = rq.TankGameSessionId;
response.TankId = rq.TankId;
//Do processing and notify clients
ActorId SessionActorId = new ActorId(rq.TankGameSessionId);
await SessionActorId.Proxy <ITankGameSession>().TakeDamage(new ActorId(rq.TankId), rq.Amount);
//Send back response (dummy response here since we only support que in this call)
return(await Task.FromResult(response));
}
catch (Exception E)
{
E.Log();
ErrorResponse errorresponse = new ErrorResponse(E.Message);
return(errorresponse);
}
}
public async Task <IResponse> Process(IRequest request)
{
try
{
JoinOrCreateGameSessionRequest rq = request as JoinOrCreateGameSessionRequest;
JoinOrCreateGameSessionResponse response = new JoinOrCreateGameSessionResponse();
List <ActorId> NotifyList = new List <ActorId>();
//test if there is a session
var listproxy = new ActorId(1).Proxy <ITankGameSessionList>();
if (await listproxy.HasSessionsAsync())
{
GameSessionListItem itm = await listproxy.GetNextSessionAsync();
if (itm != null)
{
response.GameSessionId = itm.GameSessionId.GetGuidId();
response.Status = HttpStatusCode.OK;
response.waitForPlayers = false;
response.start = true;
await listproxy.RemoveGameSessionAsync(itm.GameSessionId);
var sessionproxy = itm.GameSessionId.Proxy <ITankGameSession>();
int sequenceno = await sessionproxy.JoinAsync(new ActorId(rq.UserId));
//Get players
List <TankSessionMemberItem> members = await sessionproxy.GetPlayersAsync();
foreach (TankSessionMemberItem i in members)
{
response.SessionPlayers.Add(new GameSessionPlayerItem(i.UserId.GetGuidId(), i.TankId.GetGuidId(), i.Sequence)); NotifyList.Add(i.UserId);
}
}
else
{
response.Status = HttpStatusCode.InternalServerError;
ErrorResponse errorresponse = new ErrorResponse("Failed to create gamesession");
return(errorresponse);
}
}
else
{
Guid newSessionid = Guid.NewGuid();
ActorId sessionActorId = new ActorId(newSessionid);
if (await listproxy.AddGameSessionAsync(sessionActorId))
{
//Set Session Params
var sessionproxy = sessionActorId.Proxy <ITankGameSession>();
int sequenceno = await sessionActorId.Proxy <ITankGameSession>().JoinAsync(new ActorId(rq.UserId));
response.GameSessionId = newSessionid;
response.Status = HttpStatusCode.OK;
response.waitForPlayers = true;
response.start = false;
//Get players
List <TankSessionMemberItem> members = await sessionproxy.GetPlayersAsync();
foreach (TankSessionMemberItem i in members)
{
response.SessionPlayers.Add(new GameSessionPlayerItem(i.UserId.GetGuidId(), i.TankId.GetGuidId(), i.Sequence)); NotifyList.Add(i.UserId);
}
}
else
{
response.Status = HttpStatusCode.InternalServerError;
ErrorResponse errorresponse = new ErrorResponse("Failed to create gamesession");
return(errorresponse);
}
}
response.Status = HttpStatusCode.OK;
//Notidy participants
if (NotifyList.Count == 0)
{
NotifyList.Add(new ActorId(rq.UserId));
}
foreach (ActorId uid in NotifyList)
{
GateResponse gr = new GateResponse(this.ProcessorId, (int)System.Net.HttpStatusCode.OK, uid.GetGuidId(), response.Serialize());
await uid.Proxy <IUser>().SendGateResponseAsync(gr);
}
return(await Task.FromResult(response));
}
catch (Exception E)
{
E.Log();
ErrorResponse errorresponse = new ErrorResponse(E.Message);
return(errorresponse);
}
}
