public Runspace(IRunspaceData runspaceData)
{
if (runspaceData == null)
{
throw new ArgumentNullException(nameof(runspaceData));
}
Id = runspaceData.Id;
CreationTime = runspaceData.CreationTime;
Name = runspaceData.Name;
RunVcConnectionScript = runspaceData.RunVcConnectionScript;
State = runspaceData.State;
VcConnectionScriptId = runspaceData.VcConnectionScriptId;
ErrorDetails = runspaceData.ErrorDetails;
}
public IRunspaceData Get(string userId, string runspaceId)
{
_logger.LogInformation($"Get runspace with id: {runspaceId}");
IRunspaceData result = null;
try {
Sessions.Instance.EnsureValidUser(userId);
if (!_userRunspaces.Contains(userId))
{
throw new RunspaceProviderException(
string.Format(APIGatewayResources.MultiTenantRunspaceProvider_UserHasNoRunspaces, userId));
}
if (!_userRunspaces.Contains(userId, runspaceId))
{
throw new RunspaceProviderException(
string.Format(APIGatewayResources.MultiTenantRunspaceProvider_UserHasNoRunspaceWithId, userId, runspaceId));
}
var runspaceInfo = _runspaceProvider.Get(runspaceId);
var runspaceData = _userRunspaces.GetData(userId, runspaceId);
if (runspaceInfo == null && runspaceData != null)
{
_userRunspaces.RemoveData(userId, runspaceId);
}
else
{
result = runspaceData;
}
} catch (Exception ex) {
throw new RunspaceProviderException(
string.Format(
APIGatewayResources.MultiTenantRunspaceProvider_GetFailed,
userId,
ex.Message),
ex);
}
return(result);
}
public IRunspaceData StartCreate(
string userId,
ISessionToken sessionToken,
string name,
bool runVcConnectionScript,
ISolutionStsClient stsClient,
string vcEndpoint)
{
IRunspaceData result = null;
_logger.LogInformation("StartCreate");
try {
Sessions.Instance.EnsureValidUser(userId);
_logger.LogDebug("RunspaceProvider -> StartCreate call");
var runspaceInfo = _runspaceProvider.StartCreate();
_logger.LogDebug($"Runspace provider result: {runspaceInfo.Id}, {runspaceInfo.CreationState}, {runspaceInfo.CreationError}");
result = new RunspaceData(runspaceInfo);
result.CreationTime = DateTime.Now;
result.Name = name;
result.RunVcConnectionScript = runVcConnectionScript;
result.State = DataTypes.RunspaceState.Creating;
_userRunspaces.Add(userId, result.Id, result);
_runspacesStatsMonitor.Register(result, sessionToken.SessionId);
Task.Run(() => {
_logger.LogDebug("RunspaceProvider -> WaitCreateCompletion call");
var waitResult = _runspaceProvider.WaitCreateCompletion(result);
_logger.LogDebug($"Runspace provider WaitCreateCompletion result: {waitResult.Id}, {waitResult.CreationState}, {waitResult.CreationError}");
if (waitResult.CreationState == RunspaceCreationState.Error)
{
((RunspaceData)result).ErrorDetails = new DataTypes.ErrorDetails(waitResult.CreationError);
((RunspaceData)result).State = DataTypes.RunspaceState.Error;
}
else
{
// Update endpoint info
((RunspaceData)result).Endpoint = waitResult.Endpoint;
}
if (waitResult.CreationState == RunspaceCreationState.Ready &&
!runVcConnectionScript)
{
((RunspaceData)result).State = DataTypes.RunspaceState.Ready;
}
_logger.LogDebug($"Connect VC requested: {runVcConnectionScript}");
if (runVcConnectionScript && waitResult.CreationState == RunspaceCreationState.Ready)
{
string bearerSamlToken = null;
try {
_logger.LogDebug($"HoK Saml Token availble: {sessionToken.HoKSamlToken != null}");
if (sessionToken.HoKSamlToken == null)
{
throw new Exception(APIGatewayResources.PowerCLIVCloginController_NoRefreshTokenAvailable_For_Session);
}
_logger.LogDebug($"STSClient -> IssueBearerTokenBySolutionToken call");
bearerSamlToken = stsClient
.IssueBearerTokenBySolutionToken(sessionToken.HoKSamlToken.RawXmlElement)
.OuterXml;
} catch (Exception exc) {
_logger.LogError(exc, "Issue Bearer Token failed");
result.State = DataTypes.RunspaceState.Error;
result.ErrorDetails = new DataTypes.ErrorDetails(exc);
}
if (bearerSamlToken != null)
{
// Connect PowerCLI
try {
var scriptExecutionRequest = new DataTypes.ScriptExecution {
OutputObjectsFormat = OutputObjectsFormat.Json,
Name = "powerclivclogin",
Script = PCLIScriptsReader.ConnectByStringSamlToken,
ScriptParameters = new DataTypes.ScriptParameter[] {
new DataTypes.ScriptParameter {
Name = "server",
Value = vcEndpoint
},
new DataTypes.ScriptParameter {
Name = "samlToken",
Value = bearerSamlToken
},
new DataTypes.ScriptParameter {
Name = "allLinked",
Value = true
}
}
};
_logger.LogDebug($"Start Connect VC script");
var scriptResult = ScriptExecutionMediatorSingleton.
Instance.
ScriptExecutionMediator.
StartScriptExecution(sessionToken.UserName, result, scriptExecutionRequest).Result;
result.VcConnectionScriptId = scriptResult.Id;
_logger.LogDebug($"Wait Connect VC script to complete");
while (scriptResult.State == ScriptState.Running)
{
var intermediateResult = ScriptExecutionMediatorSingleton.Instance.ScriptExecutionMediator.GetScriptExecution(
sessionToken.UserName,
scriptResult.Id);
if (intermediateResult != null)
{
scriptResult = intermediateResult;
}
Thread.Sleep(200);
}
} catch (RunspaceEndpointException runspaceEndointException) {
_logger.LogError(runspaceEndointException, "Runspace endpoint exception while waiting connect VC script");
result.ErrorDetails = new DataTypes.ErrorDetails(runspaceEndointException);
result.State = DataTypes.RunspaceState.Error;
} catch (Exception exc) {
_logger.LogError(exc, "Wait Connect VC script failed");
result.ErrorDetails = new DataTypes.ErrorDetails(exc);
result.State = DataTypes.RunspaceState.Error;
}
}
if (result.State != DataTypes.RunspaceState.Error)
{
result.State = DataTypes.RunspaceState.Ready;
}
}
});
} catch (RunspaceProviderException runspaceProviderException) {
_logger.LogError(runspaceProviderException, "Runspace provider exception was thrown");
throw;
}
catch (Exception ex) {
throw new RunspaceProviderException(
string.Format(
APIGatewayResources.MultiTenantRunspaceProvider_CreateFailed,
userId,
ex.Message),
ex);
}
return(result);
}
public async Task <ActionResult <DataTypes.ScriptExecution> > Post([FromBody] DataTypes.ScriptExecution script_execution)
{
ActionResult <DataTypes.ScriptExecution> result = null;
// Get Runspace Endpoint or throw Runspace Not Found
IRunspaceData runspaceInfo = null;
try {
var authzToken = SessionToken.FromHeaders(Request.Headers);
runspaceInfo =
RunspaceProviderSingleton.
Instance.
RunspaceProvider.
Get(authzToken.UserName, script_execution.RunspaceId);
} catch (Exception) {
}
if (runspaceInfo == null)
{
result = NotFound(
new ErrorDetails(
ApiErrorCodes.GetErrorCode(
nameof(APIGatewayResources.RunspaceNotFound)),
string.Format(
APIGatewayResources.RunspaceNotFound, script_execution.RunspaceId)));
}
else if (runspaceInfo.State != RunspaceState.Ready)
{
result = StatusCode(
500,
new ErrorDetails(
ApiErrorCodes.GetErrorCode(
nameof(APIGatewayResources.RunspaceNotReady)),
string.Format(
APIGatewayResources.RunspaceNotReady,
script_execution.RunspaceId,
runspaceInfo.State)));
}
else
{
// Add Script Execution in the ScriptExecutionMediator
try {
var authzToken = SessionToken.FromHeaders(Request.Headers);
var scriptResult =
await ScriptExecutionMediatorSingleton.Instance.ScriptExecutionMediator.StartScriptExecution(
authzToken.UserName,
runspaceInfo,
script_execution);
result = StatusCode(
202,
new DataTypes.ScriptExecution(scriptResult));
} catch (RunspaceEndpointException runspaceEndointException) {
result = StatusCode(
runspaceEndointException.HttpErrorCode,
new ErrorDetails(
ApiErrorCodes.CalculateScriptsErrorCode(runspaceEndointException.ErrorCode),
runspaceEndointException.Message,
runspaceEndointException.ToString()));
} catch (Exception exc) {
result = StatusCode(
500,
new ErrorDetails(
ApiErrorCodes.GetErrorCode(
nameof(APIGatewayResources.ScriptsController_RunspaceFailedToProcessScriptRequest)),
APIGatewayResources.ScriptsController_RunspaceFailedToProcessScriptRequest,
exc.ToString()));
}
}
return(result);
}
