internal async Task <long> StartSessionAsync(ApplicationUser user, SessionStartRequest startRequest)
{
using (var context = _services.GetService <EcclesiaContext>())
{
var executor = _services.GetService <IExecutor>();
var poller = _services.GetService <Poller>();
var executionId = await executor.StartSessionAsync(startRequest);
var session = new Session
{
StartTime = DateTime.Now,
LastPolling = null,
MnemonicsTable = startRequest.ComputationGraph.MnemonicsTable,
OriginalGraph = startRequest.ComputationGraph,
OperationsStatus =
startRequest.ComputationGraph.Operations
.Select(op => new OperationStatus {
Id = op.Id, State = OperationState.Awaits
})
.ToList(),
UserId = user.Id,
ExecutionId = executionId,
State = SessionState.Running
};
await context.Sessions.AddAsync(session);
await context.SaveChangesAsync();
poller.StartTracking(session.Id);
return(session.Id);
}
}
public async Task <RepositorySession> Start(SessionStartRequest request, CancellationToken cancellationToken = default)
{
var repositorySession = GetSession(request.BranchName);
if (request.RepositoryGroupName != null && !TryImportRepositoryGroup(request.RepositoryGroupName, repositorySession))
{
return(repositorySession);
}
if (request.Slugs != null && !TryAddSlugsIfNotExist(request.Slugs.ToList(), repositorySession))
{
return(repositorySession);
}
repositorySession.Active = true;
_fileRepository.WriteSession(repositorySession);
if (request.Checkout)
{
CheckoutRepositories(repositorySession.RepositorySlugs, repositorySession.BranchName);
}
if (request.DockerComposeMetaData.Run)
{
await _dockerComposeManager.Up(new DockerComposeUpRequest
{
Build = true,
FileName = request.DockerComposeMetaData.ComposeFile,
Name = request.BranchName
}, cancellationToken);
}
return(repositorySession);
}
public async Task <IActionResult> CreateSessionAsync([FromBody] SessionStartRequest startRequest)
{
var user = await AppUser();
var sessionId = await _sessionManager.StartSessionAsync(user, startRequest);
return(Ok(new { SessionId = sessionId }));
}
public IActionResult Post([FromBody] SessionStartRequest request)
{
if (request == null)
{
_logger.LogError("Could not parse user request");
return(BadRequest(new { Error = "Incorrect input" }));
}
var sessionId = _manager.StartSession(request.ComputationGraph);
return(Ok(new { SessionId = sessionId }));
}
private async Task _validate(SessionStartRequest model)
{
if ((await Exists(model.Id)).Equals(false))
{
throw new ResourceNotFound();
}
var player = await _store.Retrieve(model.Id);
if (player.SessionBegin.Year > 1)
{
throw new SessionAlreadyStarted();
}
await Task.CompletedTask;
}
public async Task <Player> Start([FromBody] SessionStartRequest model)
{
AuthorizeAny(
() => Actor.IsRegistrar,
() => PlayerService.MapId(model.Id).Result == Actor.Id
);
await Validate(model);
var result = await PlayerService.Start(model, Actor.IsRegistrar);
await Hub.Clients.Group(result.TeamId).TeamEvent(
new HubEvent <TeamState>(Mapper.Map <TeamState>(result), EventAction.Started)
);
return(result);
}
public async Task <string> StartSessionAsync(SessionStartRequest startRequest)
{
using (var client = new HttpClient())
{
var content = new StringContent(
JsonConvert.SerializeObject(startRequest),
Encoding.UTF8,
"application/json");
var response = await client.PostAsync($"{_hostname}/api/session", content);
var responseString = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.OK)
{
return(JsonConvert.DeserializeAnonymousType(responseString, new { SessionId = "" }).SessionId);
}
else
{
throw new InvalidOperationException(responseString);
}
}
}
public SessionStartReply SessionStart(SessionStartRequest request)
{
SessionStartReply reply = new SessionStartReply();
try
{
//Get user their session
reply.session = Guid.NewGuid().ToString("N");
//Write session
//(In real life you replace this with a sql database)
string filepath;
if (request.isvideo)
{
filepath = System.Web.HttpRuntime.AppDomainAppPath + "Sessions\\Video\\" + reply.session;
}
else
{
filepath = System.Web.HttpRuntime.AppDomainAppPath + "Sessions\\Text\\" + reply.session;
}
using (StreamWriter sw = File.AppendText(filepath))
{
sw.WriteLine(request.name);
}
}
catch (Exception ex)
{
reply.error += "\n" + ex.Message;
reply.successful = false;
}
return reply;
}
public async Task <Player> Start(SessionStartRequest model, bool sudo)
{
var team = await Store.ListTeamByPlayer(model.Id);
var player = team.First();
var game = await Store.DbContext.Games.FindAsync(player.GameId);
if (!sudo && game.SessionLimit > 0)
{
var ts = DateTimeOffset.UtcNow;
int sessionCount = await Store.DbSet
.CountAsync(p =>
p.GameId == game.Id &&
ts < p.SessionEnd
)
;
if (sessionCount >= game.SessionLimit)
{
throw new SessionLimitReached();
}
}
if (!sudo && game.IsLive.Equals(false))
{
throw new GameNotActive();
}
if (
!sudo &&
game.RequireTeam &&
team.Length < game.MinTeamSize
)
{
throw new InvalidTeamSize();
}
var st = DateTimeOffset.UtcNow;
var et = st.AddMinutes(game.SessionMinutes);
foreach (var p in team)
{
p.SessionMinutes = game.SessionMinutes;
p.SessionBegin = st;
p.SessionEnd = et;
}
await Store.Update(team);
if (player.Score > 0)
{
// insert _initialscore_ "challenge"
var challenge = new Data.Challenge
{
Id = Guid.NewGuid().ToString("n"),
PlayerId = player.Id,
TeamId = player.TeamId,
GameId = player.GameId,
SpecId = "_initialscore_",
Name = "_initialscore_",
Points = player.Score,
Score = player.Score,
};
Store.DbContext.Add(challenge);
await Store.DbContext.SaveChangesAsync();
}
return(Mapper.Map <Player>(
team.First(p => p.Id == model.Id)
));
}
