private void ConnectAndUpdateServerList()
{
DispatchHandler.Instance.AddHandler <ServersMsg>(ProcessServersMsg);
DispatchHandler.Instance.AddHandler <InterChatCommandMsg>(ProcessInterChatCommandMsg);
try
{
#if DEBUG
_session.Connect("127.0.0.1", Configuration.PylonPort);
#else
_session.Connect(Configuration.PylonHost, Configuration.PylonPort);
#endif
_session.StartReceive();
_session.Send(new RequestServerMsg());
UpdateUi(() => timerRefresh.Enabled = true);
}
catch (Exception exception)
{
UpdateUi(() =>
{
ShowError("Cannot connect to xelina: {0}", exception.Message);
textAccountName.Enabled = false;
listViewServers.Enabled = false;
buttonInterChat.Enabled = false;
buttonStartGame.Enabled = false;
});
}
}
internal void OnEnterWorld(MessageSession session, EnterWorldMsg msg)
{
// get or create entity
Entity entity;
lock (_accountLock)
{
if (NameCache.Instance.Contains(msg.Name))
{
entity = EntityManager.Instance[NameCache.Instance[msg.Name]];
}
else
{
entity = EntityManager.Instance.Create(EntityTemplate.Ids.User);
entity.Get <Nameplate>().Name = msg.Name;
if (!EntityBinder.Instance.Add(entity))
{
Logger.Write("Cannot insert entity[{0}]", msg.Name);
return;
}
NameCache.Instance.Add(msg.Name, entity.Id);
}
// ignore duplicately send enter-world msg
if (entity.Id == session.SessionId)
{
return;
}
// prevent repeatly login
if (entity.Get <Player>().Logged)
{
Logger.Write("{0} is already logged.", msg.Name);
session.Shutdown(SocketShutdown.Both);
return;
}
entity.Get <Player>().Logged = true;
}
entity.Ensure <Tickable>();
entity.Get <Tickable>().Interval = DataCenter.Instance.GetAttributeValue <int>(typeof(Tickable), "interval");
session.SessionId = entity.Id;
session.Send(new WorldInfoMsg {
Id = entity.Id, WorldId = 1
});
session.Send(entity.ToMessage <SpawnMsg>());
PositionSystem.Global.Appear(entity);
Logger.Write("{0} is logged.", msg.Name);
}
public async Task GenerateMetricsFromLatestJob(int count)
{
var dataContext = Container.Resolve <JobsDataContext>();
var jobs = await dataContext.Jobs
.Where(job =>
job.JobType == JobType.EarningsJob &&
(job.Status == JobStatus.Completed || job.Status == JobStatus.CompletedWithErrors)
).OrderByDescending(job => job.LearnerCount)
.Take(count)
.ToListAsync();
var messages = jobs.Select(job => new GenerateSubmissionSummary
{
Ukprn = job.Ukprn.Value,
CollectionPeriod = job.CollectionPeriod,
AcademicYear = job.AcademicYear,
JobId = job.DcJobId.Value,
})
.ToList();
foreach (var generateSubmissionSummary in messages)
{
await MessageSession.Send(generateSubmissionSummary).ConfigureAwait(false);
}
}
public async Task WhenTheEventIsDuplicatedButWithADifferentCommandIdOnTheProcessLearnerCommand()
{
var command = Context.Get <ProcessLearnerCommand>(ProcessLearnerCommand);
command.CommandId = Guid.NewGuid();
await MessageSession.Send(command);
}
internal void DispatchCommand(MessageSession session, InterChatCommandMsg msg)
{
var user = FindUserFromSessionWithLock(session);
if (user == null)
return;
switch ((InterChatCommandType)msg.TypeCode)
{
case InterChatCommandType.CheckUserName:
// 중복된 유저 이름이 있는지 검사해서 알려준다.
session.Send(new InterChatCommandMsg
{
TypeCode = (int)InterChatCommandType.CheckUserName,
Content = user.ToString()
});
break;
case InterChatCommandType.ChangeColor:
// 자신의 텍스트 색상을 변경한다.
user.TextColor = Color.FromArgb(int.Parse(msg.Content));
BroadcastCommandMsgWithLock(InterChatCommandType.ChangeColor, user.ToString());
break;
case InterChatCommandType.Speech:
// Speech를 수행한다.
Task.Factory.StartNew(() => DoSpeech(user.Name, msg.Content));
break;
}
}
public async Task GenerateMetricsFromLatestJob(int count)
{
//set these to the period you have data for
var academicYear = 2122;
var collectionPeriod = 11;
var dataContext = Container.Resolve <JobsDataContext>();
var jobs = await dataContext.Jobs
.Where(job =>
job.JobType == JobType.EarningsJob &&
(job.Status == JobStatus.Completed || job.Status == JobStatus.CompletedWithErrors) &&
job.AcademicYear == academicYear &&
job.CollectionPeriod > collectionPeriod
).OrderByDescending(job => job.LearnerCount)
.Take(count)
.ToListAsync();
var messages = jobs.Select(job => new RecordPeriodEndRequestReportsJob
{
JobId = job.DcJobId.Value,
CollectionPeriod = job.CollectionPeriod,
CollectionYear = job.AcademicYear,
})
.ToList();
foreach (var periodEndRequestReportsEvent in messages)
{
await MessageSession.Send(periodEndRequestReportsEvent).ConfigureAwait(false);
}
}
internal void ProcessPing(MessageSession session, AlivePingMsg msg)
{
if (session != _session)
{
return;
}
// ping을 받았으니 pong을 보낸다.
session.Send(new AlivePongMsg());
}
private async Task ResetDataLockActors(List <Learner> learners)
{
await MessageSession.Send(new ResetActorsCommand
{
Ulns = learners.Select(learner => learner.Uln).ToList()
})
.ConfigureAwait(false);
await Task.Delay(2000).ConfigureAwait(false);
}
internal void RequestServer(MessageSession session, RequestServerMsg msg)
{
_serverMapLock.DoRead(() =>
{
var response = new ServersMsg();
response.ServerList.AddRange(_serverMap.Values);
session.Send(response);
Logger.Write("Response To: {0} -> {1}", session.ClientSocket.RemoteEndPoint, _serverMap.Count);
});
}
public async Task WhenAnEarningEventIsReceived()
{
var startTime = DateTimeOffset.UtcNow;
var earnings = Earnings.GroupBy(p => p.LearnerId).Select(CreateEarningEvent).ToList();
await CreateTestEarningsJob(startTime, earnings.Cast <IPaymentsEvent>().ToList());
foreach (var earningEvent in earnings)
{
await MessageSession.Send(earningEvent).ConfigureAwait(false);
}
}
public async Task WhenRequiredPaymentsEventIsReceived()
{
var startTime = DateTimeOffset.UtcNow;
var payments = RequiredPayments.Select(CreateRequiredPaymentEvent).ToList();
await CreateTestEarningsJob(startTime, payments.Cast <IPaymentsEvent>().ToList());
foreach (var paymentDue in payments)
{
await MessageSession.Send(paymentDue).ConfigureAwait(false);
}
}
public async Task WhenSubmissionFailedEventForILRSubmittedAtArrives(string p0)
{
var submissionFailedEvent = new SubmissionFailedEvent
{
AcademicYear = 1,
CollectionPeriod = 1,
Ukprn = TestSession.Ukprn,
IlrSubmissionDateTime = DateTime.Parse(p0)
};
await MessageSession.Send(submissionFailedEvent).ConfigureAwait(false);
}
public async Task WhenTheFundingSourcePaymentsEventAreReceivedAsync()
{
var startTime = DateTimeOffset.UtcNow;
var submissionTime = TestSession.IlrSubmissionTime;
var payments = FundingSourcePayments.Select(p => CreateFundingSourcePaymentEvent(p, submissionTime)).ToList();
await CreateTestEarningsJob(startTime, payments.Cast <IPaymentsEvent>().ToList());
foreach (var payment in payments)
{
await MessageSession.Send(payment).ConfigureAwait(false);
}
}
internal void LoginInterChat(MessageSession session, InterChatLoginMsg msg)
{
_interChatLock.DoWrite(() =>
{
// 중복 로그인 방지
if (_interChatUserMap.ContainsValue(msg.Name))
{
Logger.Write("Connected: Duplicate Login [{0}]", msg.Name);
session.Send(new InterChatCommandMsg {TypeCode = (int) InterChatCommandType.CheckUserName, Content = "false"});
return;
}
session.Send(new InterChatCommandMsg { TypeCode = (int)InterChatCommandType.CheckUserName, Content = "true" });
Logger.Write("Connected: InterChat [{0}]", msg.Name);
// 먼저 목록을 보내주고,
session.Send(new InterChatCommandMsg
{
TypeCode = (int)InterChatCommandType.InformLoggedUsers,
Content = SerializeUserListWithNoLock()
});
// 예전 채팅 내역이 있으면 보내준 뒤,
// ReSharper disable ImplicitlyCapturedClosure
_interChatMessageLock.DoRead(() =>
{
var skipCount = Math.Max(0, _lastMessages.Count - LastClientMessageCount);
foreach (var lastMessage in _lastMessages.Skip(skipCount).Take(LastClientMessageCount))
session.Send(lastMessage);
});
// ReSharper restore ImplicitlyCapturedClosure
// 맵에 자기 자신을 추가한 뒤, 자신에 대한 정보도 같이 처리한다.
_interChatUserMap.Add(session, msg.Name);
BroadcastChatMsgWithNoLock("system", msg.Name + "께서 접속하였습니다.");
BroadcastCommandMsgWithNoLock(InterChatCommandType.InformLoggedUser, FindOrCreateUserWithLock(msg.Name).ToString());
});
}
public async Task TheSameLearnerIsSubmittedButWithADifferentUkprn()
{
var command = Context.Get <ProcessLearnerCommand>(ProcessLearnerCommand);
command.Ukprn = TestSession.GenerateId();
command.JobId = TestSession.GenerateId(100000);
var currentJobIds = Context.Get <List <long> >(JobIds);
currentJobIds.Add(command.JobId);
Context.Set <List <long> >(currentJobIds, JobIds);
await MessageSession.Send(command);
}
private void ConnectionLoop()
{
while (true)
{
try
{
_event.Reset();
Logger.Write("Try to connect Pylon({0}:{1})", Configuration.PylonHost, Configuration.PylonPort);
_session = MessageSessionManager.Instance.CreateSession();
_session.Connect(Configuration.PylonHost, Configuration.PylonPort);
Task.Factory.StartNew(_session.StartReceive);
_session.Send(new ServerMsg
{
Host = Configuration.HostAddress,
Port = Configuration.Port,
Name = Configuration.ServerName
});
Logger.Write("Pylon Connected.");
_event.WaitOne();
}
#if DEBUG
catch (Exception e)
{
Logger.Write("Cannot connect to Pylon");
Logger.Write(e);
Thread.Sleep(RetryInterval);
}
#else
catch
{
Logger.Write("Cannot connect to Pylon");
Thread.Sleep(RetryInterval);
}
#endif
}
// ReSharper disable FunctionNeverReturns
}
public async Task WhenAProcessLearnerCommandIsHandledByTheProcessLearnerService()
{
var command = new ProcessLearnerCommand
{
JobId = TestSession.GenerateId(100000),
CollectionPeriod = 1,
CollectionYear = 1920,
CommandId = Guid.NewGuid(),
IlrFileName = "SomeFile",
IlrSubmissionDateTime = DateTime.Now,
Ukprn = TestSession.GenerateId(),
Learner = GetFm36Learner()
};
Context.Add(ProcessLearnerCommand, command);
Context.Add(JobIds, new List <long> {
command.JobId
});
await MessageSession.Send(command);
}
private void Reconnect()
{
try
{
_session = MessageSessionManager.Instance.CreateSession();
#if DEBUG
_session.Connect("127.0.0.1", Configuration.PylonPort);
#else
_session.Connect(Configuration.PylonHost, Configuration.PylonPort);
#endif
_session.StartReceive();
_session.Send(new InterChatLoginMsg {
Name = _userName
});
return;
}
catch
{
Task.Delay(5000).ContinueWith(_ => Reconnect());
}
}
public async Task WhenTheILRIsSubmittedAndTheLearnerEarningsAreSentToTheEarningEventsService()
{
var command = new ProcessLearnerCommand
{
Ukprn = TestSession.Ukprn,
CollectionYear = CollectionYear,
CollectionPeriod = CollectionPeriod,
JobId = TestSession.JobId,
RequestTime = DateTime.UtcNow,
Learner = new FM36Learner
{
LearnRefNumber = TestSession.Learner.LearnRefNumber,
PriceEpisodes = new List <PriceEpisode>(),
LearningDeliveries = new List <LearningDelivery>()
}
};
IlrLearnerEarnings.ForEach(earnings =>
{
AddLearnerEarnings(command.Learner, earnings);
});
await MessageSession.Send(command, new SendOptions());
}
private async Task SendMonthEndEvent()
{
MonthEndJobId = TestSession.GenerateId();
Console.WriteLine($"Month end job id: {MonthEndJobId}");
var monthEndCommand = new ProcessProviderMonthEndCommand
{
Ukprn = TestSession.Ukprn,
JobId = MonthEndJobId,
CollectionPeriod = CollectionPeriodFactory.CreateFromAcademicYearAndPeriod(AcademicYear, CollectionPeriod),
};
await CreateJob(DateTimeOffset.UtcNow, new List <GeneratedMessage>
{
new GeneratedMessage
{
StartTime = monthEndCommand.RequestTime,
MessageName = monthEndCommand.GetType().FullName,
MessageId = monthEndCommand.CommandId
}
},
JobType.ComponentAcceptanceTestMonthEndJob);
await MessageSession.Send(monthEndCommand).ConfigureAwait(false);
}
private void OnPing(AlivePingMsg msg)
{
_session.Send(new AlivePongMsg());
}
public async Task WhenIfTheEventIsDuplicated()
{
var command = Context.Get <ProcessLearnerCommand>(ProcessLearnerCommand);
await MessageSession.Send(command);
}
private void ErrorsOnMessageSentToErrorQueue(object sender, FailedMessage message)
{
logger.Info($"mapping failed message to a custom message to be sent. Original exception: {message.Exception.Message}");
// Just to show it's working
MessageSession.Send("temp", new ConvertedMessage());
}
