public async Task <ApiResult> GetCodeGen([FromBody] JObject config)
{
try
{
RolesCheck.EnsureWriter(Request, _isLocal);
Ensure.NotNull(config, "config");
string queries = string.Join("\n", config.GetValue("query").ToString());
var ruleDefinitionRaw = config.Value <JArray>("rules");
var ruleDefinitionList = ruleDefinitionRaw.ToObject <List <FlowGuiRule> >();
var ruleDefinitions = RuleDefinitionGenerator.GenerateRuleDefinitions(ruleDefinitionList, config.GetValue("name").ToString());
RulesCode codeGen = CodeGen.GenerateCode(queries, ruleDefinitions, config.GetValue("name").ToString());
await Task.Yield();
return(ApiResult.CreateSuccess(codeGen.Code));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
public async Task <ApiResult> SaveFlow([FromBody] JObject config)
{
try
{
RolesCheck.EnsureWriter(Request, _isLocal);
Ensure.NotNull(config, "config");
var inputJson = JsonConfig.From(config.ToString());
var result = await _flowOperation.SaveFlowConfig(FlowGuiConfig.From(inputJson));
Ensure.IsSuccessResult(result);
if (result.Properties != null && result.Properties.TryGetValue(FlowOperation.FlowConfigPropertyName, out object flowConfig))
{
return(ApiResult.CreateSuccess(JToken.FromObject(flowConfig)));
}
else
{
return(ApiResult.CreateSuccess(JToken.FromObject(string.Empty)));
}
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
[Route("inputdata/refreshsample")] // schema inf
public async Task <ApiResult> RefreshSample([FromBody] JObject jObject)
{
try
{
RolesCheck.EnsureWriter(Request);
SchemaInferenceManager sim = new SchemaInferenceManager(_logger);
return(await sim.RefreshSample(jObject));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
[Route("inputdata/refreshsampleandkernel")] // diag
public async Task <ApiResult> RefreshInputDataAndKernel([FromBody] JObject jObject)
{
try
{
RolesCheck.EnsureWriter(Request);
LiveDataManager ldm = new LiveDataManager(_logger, _configuration);
return(await ldm.RefreshInputDataAndKernel(jObject));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
[Route("kernel/executequery")] // diag
public async Task <ApiResult> ExecuteCode([FromBody] JObject jObject)
{
try
{
RolesCheck.EnsureWriter(Request);
InteractiveQueryManager iqm = new InteractiveQueryManager(_logger);
return(await iqm.ExecuteQuery(jObject));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
[Route("flow/schedulebatch")] // schedule batch jobs
public async Task <ApiResult> ScheduleBatch()
{
try
{
RolesCheck.EnsureWriter(Request, _isLocal);
var result = await _flowOperation.ScheduleBatch(this._runtimeConfigGenerator).ConfigureAwait(false);
return(ApiResult.CreateSuccess(JToken.FromObject(result)));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
[Route("kernel/refresh")] // diag
public async Task <ApiResult> RefreshKernel([FromBody] JObject jObject)
{
try
{
RolesCheck.EnsureWriter(Request);
InteractiveQueryManager iqm = new InteractiveQueryManager(_logger, _configuration);
return(await iqm.RecycleKernel(jObject));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
[Route("inputdata/inferschema")] // schemainf
public async Task<ApiResult> GetInputSchema([FromBody]JObject jObject)
{
try
{
RolesCheck.EnsureWriter(Request);
SchemaInferenceManager sim = new SchemaInferenceManager(_logger, _configuration);
return await sim.GetInputSchema(jObject);
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return ApiResult.CreateError(e.Message);
}
}
public async Task <ApiResult> DeleteAllKernels()
{
try
{
RolesCheck.EnsureWriter(Request);
InteractiveQueryManager iqm = new InteractiveQueryManager(_logger);
return(await iqm.DeleteAllKernels().ConfigureAwait(false));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
[Route("flow/delete")] // Flow delete
public async Task <ApiResult> DeleteFlow([FromBody] JObject queryObject)
{
try
{
RolesCheck.EnsureWriter(Request);
Ensure.NotNull(queryObject, "queryObject");
ConfigDeleter c = new ConfigDeleter(_logger, _configuration);
return(await c.DeleteFlow(queryObject));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
[Route("kernel/delete")] // diag
public async Task <ApiResult> DeleteKernel([FromBody] string kernelId)
{
try
{
RolesCheck.EnsureWriter(Request);
InteractiveQueryManager iqm = new InteractiveQueryManager(_logger, _configuration);
return(await iqm.DeleteKernel(kernelId).ConfigureAwait(false));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
[Route("kernel/delete")] // diag
public async Task <ApiResult> DeleteKernel([FromBody] JObject jObject)
{
try
{
RolesCheck.EnsureWriter(Request);
var diag = jObject.ToObject <InteractiveQueryObject>();
InteractiveQueryManager iqm = new InteractiveQueryManager(_logger, _configuration);
return(await iqm.DeleteKernel(diag.KernelId, diag.Name).ConfigureAwait(false));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
public async Task <ApiResult> DeleteKernelList([FromBody] System.Collections.Generic.List <string> kernels)
{
try
{
RolesCheck.EnsureWriter(Request);
InteractiveQueryManager iqm = new InteractiveQueryManager(_logger);
return(await iqm.DeleteKernelList(kernels).ConfigureAwait(false));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
public async Task <ApiResult> GenerateConfigs([FromBody] string flowName)
{
try
{
RolesCheck.EnsureWriter(Request, _isLocal);
Ensure.NotNull(flowName, "flowName");
var result = await this._runtimeConfigGenerator.GenerateRuntimeConfigs(flowName);
return(ApiResult.CreateSuccess(JToken.FromObject(result)));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
public async Task <ApiResult> SyncAllJobs()
{
try
{
RolesCheck.EnsureWriter(Request, _isLocal);
// Sync all jobs
var jobOpResult = await _jobOperation.SyncAllJobState();
return(ApiResult.CreateSuccess(JToken.FromObject(jobOpResult)));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
public async Task <ApiResult> RestartJob([FromBody] string jobName)
{
try
{
RolesCheck.EnsureWriter(Request, _isLocal);
Ensure.NotNull(jobName, "jobName");
// Restart job
var jobOpResult = await _jobOperation.RestartJob(jobName);
return(ApiResult.CreateSuccess(JToken.FromObject(jobOpResult)));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
public async Task <ApiResult> StopJobsForFlow([FromBody] string flowName)
{
try
{
RolesCheck.EnsureWriter(Request, _isLocal);
Ensure.NotNull(flowName, "flowName");
// stop all jobs for flow
var result = await _flowOperation.StopJobsForFlow(flowName);
return(ApiResult.CreateSuccess(JToken.FromObject(result)));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
[Route("kernel")] // diag
public async Task <ApiResult> CreateAndInitializeKernel([FromBody] JObject jObject)
{
try
{
RolesCheck.EnsureWriter(Request);
InteractiveQueryManager iqm = new InteractiveQueryManager(_logger);
ApiResult response = await iqm.CreateAndInitializeKernel(jObject);
//Logging information / success
_logger.LogInformation("Successful Kernel Initialization!");
return(response);
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
public async Task <ApiResult> RestatAllWithRetries([FromBody] JObject request)
{
try
{
RolesCheck.EnsureWriter(Request, _isLocal);
Ensure.NotNull(request, "request");
var jobNames = request.Value <JArray>("JobNames")?.Value <string[]>() ?? Array.Empty <string>();
var maxRetryTimes = request.GetValue("MaxRetryTimes", StringComparison.OrdinalIgnoreCase)?.Value <int>() ?? 2;
var waitIntervalInSeconds = request.GetValue("WaitIntervalInSeconds", StringComparison.OrdinalIgnoreCase)?.Value <int>() ?? 2;
var maxWaitTimeInSeconds = request.GetValue("MaxWaitTimeInSeconds", StringComparison.OrdinalIgnoreCase)?.Value <int>() ?? 60;
int retryTimes = 0;
IEnumerable <SparkJobFrontEnd> notReadyJobs = Enumerable.Empty <SparkJobFrontEnd>();
do
{
await _jobOperation.RestartAllJobs(jobNames);
var startTime = DateTime.Now;
do
{
SparkJobFrontEnd[] jobOpResult = jobNames != null && jobNames.Any() ?
await _jobOperation.SyncJobStateByNames(jobNames)
: await _jobOperation.SyncAllJobState();
notReadyJobs = jobOpResult.Where(r => r.JobState == JobState.Starting || r.JobState == JobState.Idle || r.JobState == JobState.Error);
jobNames = notReadyJobs.Select(j => j.Name).ToArray();
if (!notReadyJobs.Any())
{
break;
}
System.Threading.Thread.Sleep(waitIntervalInSeconds * 1000);
} while ((DateTime.Now - startTime).TotalSeconds < maxWaitTimeInSeconds);
} while (retryTimes++ < maxRetryTimes && notReadyJobs.Any());
return(ApiResult.CreateSuccess(JToken.FromObject(notReadyJobs)));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}
[Route("flow/delete")] // delete flow configs
public async Task <ApiResult> DeleteConfigs([FromBody] JObject queryObject)
{
try
{
RolesCheck.EnsureWriter(Request, _isLocal);
Ensure.NotNull(queryObject, "queryObject");
var flowName = queryObject.GetValue("name").ToString();
var result = await this._runtimeConfigGenerator.DeleteConfigs(flowName);
return(ApiResult.CreateSuccess(JToken.FromObject(result)));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(ApiResult.CreateError(e.Message));
}
}