/// <summary>
/// This deletes the kernelId as specified
/// </summary>
/// <param name="subscriptionId">subscriptionId that is passed in from the frontend</param>
/// <param name="kernelId">kernelId that needs to be deleted</param>
/// <param name="flowName">flowName</param>
/// <returns>Returns success or failure after the delete kernel api is called</returns>
private async Task <ApiResult> DeleteKernelHelper(string subscriptionId, string kernelId, string flowName)
{
// validate KernelId can't be null
if (string.IsNullOrEmpty(kernelId))
{
_logger.LogError("No Kernel found to delete");
return(ApiResult.CreateError("No Kernel found to delete"));
}
try
{
KernelService kernelService = CreateKernelService(flowName);
var result = await kernelService.DeleteKernelAsync(kernelId);
if (!(result.Error.HasValue && result.Error.Value))
{
//Passing in false as the last parameter since this is a delete call and the entry needs to be deleted from the blob
await kernelService.UpdateGarbageCollectKernelBlob(kernelId, "", "", _engineEnvironment.OpsBlobConnectionString, Path.Combine(_engineEnvironment.OpsDiagnosticPath, _GarbageCollectBlobName), false);
}
return(result);
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(ApiResult.CreateError(ex.Message));
}
}
/// <summary>
/// CreateAndInitializeKernelHelper is the helper that does the heavy listing for creating and initializing the kernel
/// </summary>
/// <param name="rawSchema">rawSchema as passed in from the frontend</param>
/// <param name="userId">userId as passed in from the frontend</param>
/// <param name="flowId">flowId as passed in from the frontend</param>
/// <param name="sampleDataPath">sampleDataPath where the sample data is stored</param>
/// <param name="normalizationSnippet">normalizationSnippet as passed in from the frontend</param>
/// <param name="referenceDatas">referenceDatas as passed in from the frontend</param>
/// <param name="functions">functions as passed in from the frontend</param>
/// <returns></returns>
private async Task <ApiResult> CreateAndInitializeKernelHelper(string rawSchema, string userId, string flowId, string sampleDataPath, string normalizationSnippet, List <ReferenceDataObject> referenceDatas, List <FunctionObject> functions)
{
try
{
//Create the xml with the scala steps to execute to initialize the kernel
DiagnosticInputhelper(rawSchema, sampleDataPath, normalizationSnippet, flowId);
KernelService kernelService = CreateKernelService(flowId);
var response = await kernelService.GarbageCollectListOfKernels(_engineEnvironment.OpsBlobConnectionString, Path.Combine(_engineEnvironment.OpsDiagnosticPath, _GarbageCollectBlobName));
response = await kernelService.CreateKernelAsync();
if (response.Error.HasValue && response.Error.Value)
{
return(ApiResult.CreateError(response.Message));
}
string kernelId = response.Result.ToString();
response = await kernelService.UpdateGarbageCollectKernelBlob(kernelId, userId, flowId, _engineEnvironment.OpsBlobConnectionString, Path.Combine(_engineEnvironment.OpsDiagnosticPath, _GarbageCollectBlobName), true);
if (response.Error.HasValue && response.Error.Value)
{
await kernelService.DeleteKernelAsync(kernelId);
return(ApiResult.CreateError(response.Message));
}
if (_engineEnvironment.EngineFlowConfig.SparkType == Config.ConfigDataModel.Constants.SparkTypeDataBricks)
{
kernelService.MountStorage(_engineEnvironment.EngineFlowConfig.OpsStorageAccountName, _engineEnvironment.EngineFlowConfig.SparkKeyVaultName, sampleDataPath, kernelId);
}
response = await kernelService.CreateandInitializeKernelAsync(kernelId, SetupSteps, false, referenceDatas, functions);
if (response.Error.HasValue && response.Error.Value)
{
_logger.LogError(response.Message);
return(ApiResult.CreateError(response.Message));
}
else
{
return(ApiResult.CreateSuccess(response.Result));
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(ApiResult.CreateError(ex.Message));
}
}