ECommandResult::Type FSubversionSourceControlProvider::IssueCommand(FSubversionSourceControlCommand& InCommand, const bool bSynchronous)
{
if ( !bSynchronous && GThreadPool != NULL )
{
// Queue this to our worker thread(s) for resolving
GThreadPool->AddQueuedWork(&InCommand);
CommandQueue.Add(&InCommand);
return ECommandResult::Succeeded;
}
else
{
InCommand.bCommandSuccessful = InCommand.DoWork();
UpdateConnectionState(InCommand);
InCommand.Worker->UpdateStates();
OutputCommandMessages(InCommand);
// Callback now if present. When asynchronous, this callback gets called from Tick().
ECommandResult::Type Result = InCommand.bCommandSuccessful ? ECommandResult::Succeeded : ECommandResult::Failed;
InCommand.OperationCompleteDelegate.ExecuteIfBound(InCommand.Operation, Result);
return Result;
}
}
void FSubversionSourceControlProvider::Tick()
{
bool bStatesUpdated = false;
for (int32 CommandIndex = 0; CommandIndex < CommandQueue.Num(); ++CommandIndex)
{
FSubversionSourceControlCommand& Command = *CommandQueue[CommandIndex];
if (Command.bExecuteProcessed)
{
// Remove command from the queue
CommandQueue.RemoveAt(CommandIndex);
// let command update the states of any files
bStatesUpdated |= Command.Worker->UpdateStates();
// update connection state
UpdateConnectionState(Command);
// dump any messages to output log
OutputCommandMessages(Command);
// run the completion delegate if we have one bound
Command.OperationCompleteDelegate.ExecuteIfBound(Command.Operation, Command.bCommandSuccessful ? ECommandResult::Succeeded : ECommandResult::Failed);
//commands that are left in the array during a tick need to be deleted
if(Command.bAutoDelete)
{
// Only delete commands that are not running 'synchronously'
delete &Command;
}
// only do one command per tick loop, as we dont want concurrent modification
// of the command queue (which can happen in the completion delegate)
break;
}
}
if(bStatesUpdated)
{
OnSourceControlStateChanged.Broadcast();
}
}
void FOneSkyLocalizationServiceProvider::Tick()
{
bool bStatesUpdated = false;
while (!ShowImportTaskQueue.IsEmpty())
{
FShowImportTaskQueueItem ImportTaskItem;
ShowImportTaskQueue.Dequeue(ImportTaskItem);
TSharedRef<FOneSkyShowImportTaskOperation, ESPMode::ThreadSafe> ShowImportTaskOperation = ILocalizationServiceOperation::Create<FOneSkyShowImportTaskOperation>();
ShowImportTaskOperation->SetInProjectId(ImportTaskItem.ProjectId);
ShowImportTaskOperation->SetInImportId(ImportTaskItem.ImportId);
ShowImportTaskOperation->SetInExecutionDelayInSeconds(ImportTaskItem.ExecutionDelayInSeconds);
ShowImportTaskOperation->SetInCreationTimestamp(ImportTaskItem.CreatedTimestamp);
FOneSkyLocalizationServiceModule::Get().GetProvider().Execute(ShowImportTaskOperation, TArray<FLocalizationServiceTranslationIdentifier>(), ELocalizationServiceOperationConcurrency::Asynchronous);
}
for (int32 CommandIndex = 0; CommandIndex < CommandQueue.Num(); ++CommandIndex)
{
FOneSkyLocalizationServiceCommand& Command = *CommandQueue[CommandIndex];
if (Command.bExecuteProcessed)
{
// Remove command from the queue
CommandQueue.RemoveAt(CommandIndex);
// update connection state
bServerAvailable = !Command.bConnectionDropped || Command.bCancelled;
// let command update the states of any files
bStatesUpdated |= Command.Worker->UpdateStates();
// dump any messages to output log
OutputCommandMessages(Command);
// run the completion delegate if we have one bound
ELocalizationServiceOperationCommandResult::Type Result = ELocalizationServiceOperationCommandResult::Failed;
if(Command.bCommandSuccessful)
{
Result = ELocalizationServiceOperationCommandResult::Succeeded;
}
else if(Command.bCancelled)
{
Result = ELocalizationServiceOperationCommandResult::Cancelled;
}
Command.OperationCompleteDelegate.ExecuteIfBound(Command.Operation, Result);
//commands that are left in the array during a tick need to be deleted
if(Command.bAutoDelete)
{
// Only delete commands that are not running 'synchronously'
delete &Command;
}
// only do one command per tick loop, as we dont want concurrent modification
// of the command queue (which can happen in the completion delegate)
break;
}
}
//if(bStatesUpdated)
//{
// OnLocalizationServiceStateChanged.Broadcast();
//}
}
void FPerforceSourceControlProvider::Tick()
{
bool bStatesUpdated = false;
for (int32 CommandIndex = 0; CommandIndex < CommandQueue.Num(); ++CommandIndex)
{
FPerforceSourceControlCommand& Command = *CommandQueue[CommandIndex];
if (Command.bExecuteProcessed)
{
// Remove command from the queue
CommandQueue.RemoveAt(CommandIndex);
// update connection state
bServerAvailable = !Command.bConnectionDropped || Command.bCancelled;
// let command update the states of any files
bStatesUpdated |= Command.Worker->UpdateStates();
// dump any messages to output log
OutputCommandMessages(Command);
// If the command was cancelled while trying to connect, the operation complete delegate will already
// have been called. Otherwise, now we have to call it.
if (!Command.bCancelledWhileTryingToConnect)
{
// run the completion delegate if we have one bound
ECommandResult::Type Result = ECommandResult::Failed;
if (Command.bCancelled)
{
Result = ECommandResult::Cancelled;
}
else if (Command.bCommandSuccessful)
{
Result = ECommandResult::Succeeded;
}
Command.OperationCompleteDelegate.ExecuteIfBound(Command.Operation, Result);
}
//commands that are left in the array during a tick need to be deleted
if(Command.bAutoDelete)
{
// Only delete commands that are not running 'synchronously'
delete &Command;
}
// only do one command per tick loop, as we dont want concurrent modification
// of the command queue (which can happen in the completion delegate)
break;
}
// If a cancel is detected before the server has connected, abort immediately.
else if (Command.bCancelled && !Command.bConnectionWasSuccessful)
{
// Mark command as having been cancelled while trying to connect
Command.CancelWhileTryingToConnect();
// If this was a synchronous command, set it free so that it will be deleted automatically
// when its (still running) thread finally finishes
Command.bAutoDelete = true;
// run the completion delegate if we have one bound
Command.OperationCompleteDelegate.ExecuteIfBound(Command.Operation, ECommandResult::Cancelled);
break;
}
}
if(bStatesUpdated)
{
OnSourceControlStateChanged.Broadcast();
}
}
