/// <summary>
        /// This is called for deleting the kernel by directly calling into the Rest Api's provided by the jupyter kernel
        /// </summary>
        /// <param name="kernelId">KernelId</param>
        /// <returns>Returns success or error as the case maybe as ApiResult</returns>
        public override async Task <ApiResult> DeleteKernelAsync(string kernelId)
        {
            string responseString = string.Empty;

            try
            {
                InitializeClusterId();
                // Set body
                string body    = "{\"contextId\":\"" + kernelId + "\", \"clusterId\":\"" + _clusterId + "\"}";
                var    content = new StringContent(body);

                // Application killed by user.
                HttpClient client   = DatabricksUtility.GetHttpClient(_token);
                var        response = await client.PostAsync($"{_baseUrl}/api/1.2/contexts/destroy", content);

                responseString = await response.Content.ReadAsStringAsync();

                string id = JsonConvert.DeserializeObject <DeleteDBKernelResponse>(responseString).Id;
                client.Dispose();
                return(ApiResult.CreateSuccess(id));
            }
            catch (Exception ex)
            {
                return(ApiResult.CreateError(responseString + "\n" + ex.ToString()));
            }
        }
        /// <summary>
        /// Initialized the cluster Id given the Spark cluster name
        /// </summary>
        private void InitializeClusterId()
        {
            if (!string.IsNullOrEmpty(_clusterId))
            {
                return;
            }

            HttpClient          client              = DatabricksUtility.GetHttpClient(_token);
            var                 response            = client.GetAsync($"{_baseUrl}/api/2.0/clusters/list").Result;
            var                 responseString      = response.Content.ReadAsStringAsync().Result;
            SparkClustersObject sparkClustersObject = JsonConvert.DeserializeObject <SparkClustersObject>(responseString);

            if (sparkClustersObject == null || sparkClustersObject.Clusters == null || sparkClustersObject.Clusters.Count <= 0)
            {
                throw new Exception("No Spark clusters found");
            }
            foreach (Cluster cluster in sparkClustersObject.Clusters)
            {
                if (cluster.Name == _clusterName)
                {
                    _clusterId = cluster.Id;
                    client.Dispose();
                    return;
                }
            }
            client.Dispose();
            throw new Exception($"No cluster with name {_clusterName} found");
        }
        /// <summary>
        /// CreateKernelAsync - calls into the Rest api for creating the kernel
        /// </summary>
        /// <returns>ApiResult which contains kernelid</returns>
        public override async Task <ApiResult> CreateKernelAsync()
        {
            try
            {
                // Iniitalize cluster id
                InitializeClusterId();

                // Call service
                HttpClient client  = DatabricksUtility.GetHttpClient(_token);
                var        nvc     = new List <KeyValuePair <string, string> >();
                var        url     = $"{_baseUrl}/api/1.2/contexts/create?language=scala&clusterId={_clusterId}";
                var        request = new HttpRequestMessage(HttpMethod.Post, url)
                {
                    Content = new FormUrlEncodedContent(nvc)
                };
                var response = await client.SendAsync(request);

                var responseString = await response.Content.ReadAsStringAsync();

                string id = JsonConvert.DeserializeObject <CreateDBKernelResponse>(responseString).Id;
                client.Dispose();
                return(ApiResult.CreateSuccess(id));
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, ex.Message);
                return(ApiResult.CreateError(ex.ToString()));
            }
        }
        /// <summary>
        /// Executes the code and returns the results
        /// </summary>
        /// <param name="code">Code to execute</param>
        /// <returns>Results of code execution</returns>
        public string ExecuteCode(string code)
        {
            // Call service
            HttpClient client = DatabricksUtility.GetHttpClient(_token);
            var        nvc    = new List <KeyValuePair <string, string> >
            {
                new KeyValuePair <string, string>("command", code)
            };
            var url     = $"{_baseUrl}/api/1.2/commands/execute?language=scala&clusterId={_clusterId}&contextId={Id}";
            var request = new HttpRequestMessage(HttpMethod.Post, url)
            {
                Content = new FormUrlEncodedContent(nvc)
            };
            var    response       = client.SendAsync(request).Result;
            var    responseString = response.Content.ReadAsStringAsync().Result;
            string commandId      = JsonConvert.DeserializeObject <ExecuteCodeDBKernelResponse>(responseString).Id;

            // Now get the result output
            CommandResponse result = null;
            string          status = "Running";

            do
            {
                var response2       = client.GetAsync($"{_baseUrl}/api/1.2/commands/status?clusterId={_clusterId}&contextId={Id}&commandId={commandId}").Result;
                var responsestring2 = response2.Content.ReadAsStringAsync().Result;
                result = JsonConvert.DeserializeObject <CommandResponse>(responsestring2);
                status = result.Status;
            } while (status != "Finished");
            client.Dispose();

            return((result.Results.Data != null) ? result.Results.Data.ToString() : "");
        }