cloudmunch_sdk 0.7.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 62f77e9360bb900fb478f2f53f126f0ec8415370
-  data.tar.gz: 64405240eb61c16234e7f5aa043c79f7cd6e235a
+  metadata.gz: 235f0fb0275fa62d48de2cd67b378331beb99e02
+  data.tar.gz: 3acb35f525fe837908a1dfb8671118d7da5ac605
 SHA512:
-  metadata.gz: cda6786a698876f0742d58857c4b9e0c6a4d5ae4ffbced16dd74ac0cc740f7bf0cac41c3a642822e56bcc89b6d968e1d7872b19d5407367721a32535ffaa73c7
-  data.tar.gz: a7817398062304b3a6f246107eb34c7dbd1da81a926c2a0a6b115acc7c3add3dad4d4ebe257c721de46c3354532fbdc8a2f1f399ecdb4de410e15e89a03f491a
+  metadata.gz: 4926e7a3b77dd1ba611f9d199bab152312ab70bb233383f8fa2217ba16f1dc7f1f373f2caefd32628f586e23d052b9ecd03ba5ccd5fdf4f7c82e360b526e0964
+  data.tar.gz: bcdd1c1925b55321135008b1f6e35f5a251f9ff8f72582d4aab28300e21f0f1c37aa158439d658120ec578ff403eaa9f93cee6bba621b1e03cc15e1b18662382

data/lib/cloudmunch_Ruby_sdk_v2/AppAbstract.rb

@@ -2,22 +2,21 @@
 $LOAD_PATH << '.'
 
 require_relative "CloudmunchService"
+require_relative "InsightHelper"
 require_relative "Util"
 require_relative "ServiceProvider"
 require_relative "AppContext"
 
 class AppAbstract
     include CloudmunchService
+    include InsightHelper
     include Util
 
-    #@@config_path = ENV["SDK_CONFIG_PATH"]+"/sdk_config.json"
     @@config = nil
 
     def initialize(param = nil)
-        @domain, @project, @logfile = "", "", ""
     end
 
-
     def logInit(log_level)
         @logger = @logger ? @logger : Util.logInit()
         @log_level = log_level
@@ -52,106 +51,96 @@ class AppAbstract
         @integration_input=JSON.load(integrations)
         createAppContext();
         return @json_input
-    end
+    end   
 
     def createAppContext()
+        @appContext = AppContext.new(@var_input)        
+    end
 
-        @appContext = AppContext.new(@var_input)
-        
+    def getAppContext()
+        return @appContext
     end
 
+    # def getCloudmunchContext(context)
+    #     begin
+    #         return @@config[context+"_context"]
+    #     rescue
+    #         return false
+    #     end
+    # end
+
     def getCloudmunchService()
-        # @cloudmunchservice = @cloudmunchservice ? @cloudmunchservice : CloudmunchService.new(@var_input)
-#        @cloudmunchservice = @cloudmunchservice ? @cloudmunchservice : CloudmunchService.initialize(@appContext)
         @cloudmunchservice = self.extend(CloudmunchService)
         return @cloudmunchservice
-    end 
-    def openJSONFile(fileNameWithPath)
-        Util.openJSONFile(fileNameWithPath)
     end
 
-    def generateReport(reportFilename, reportString)
-        Util.generateReport(reportFilename, reportString)
-    end
+    def getInsightHelper()
+        @insightHelper = self.extend(InsightHelper)
+        return @insightHelper
+    end 
     
     def getIntegrationDetails(param = nil)
-        #@json_input = @json_input ? @json_input : getJSONArgs()
         serviceProvider = ServiceProvider.new(@json_input["providername"])
         serviceProvider.load_data(@integration_input)
         return serviceProvider
     end
-    
-    def getAppContext()
-        return @appContext
-    end
-
-    def getDataContextFromCMDB(param)
-        appContext = getAppContext()
-        params = {
-            "username" => @@config['username'],
-            "customcontext" => param["job"] + "_" + param["context"],
-            "action" => "listcustomcontext"
-        }
-        param.delete("context")
-        params = param.merge(params)
-
-        return CloudmunchService.getDataContext(appContext.get_data('masterurl'), @@config["endpoint"], params)
-    end
-
-    def updateDataContextToCMDB(param)
-        appContext = getAppContext()
-        params = {
-            "username" => @@config['username'],
-            "customcontext" => param["job"] + "_" + param["context"],
-            "action" => "updatecustomcontext"
-        }
-        param.delete("context")
-        params = param.merge(params)
-        return CloudmunchService.updateDataContext(appContext.get_data('masterurl'), @@config['endpoint'], params)
-    end
-
-
-    def getCMContext(context)
-        begin
-            return @@config[context+"_context"]
-        rescue
-            return false
-        end
-    end
-
-    def getTemplate(template_name)
-        begin
-            Util.getTemplate(template_name)
-        rescue
-            return false
-        end
-    end   
-
-    def load_config()
-        @@config = openJSONFile(@@config_path)
-    end
 
     def initializeApp()
-        #puts "initializeApp from AppAbstract"
     end
 
     def process()
-        #puts "process func from AppAbstract"
     end
 
     def cleanupApp()
        log("INFO", "\nExiting app")
-       #puts "cleanupApp from AppAbstract"
     end
 
     def start()
-        # load_config is commented out as this config file is not required now
-        #load_config()
         initializeApp()
         process()
         cleanupApp()
     end
 
-    private :load_config
+    # def openJSONFile(fileNameWithPath)
+    #     Util.openJSONFile(fileNameWithPath)
+    # end  
+
+    # def generateReport(reportFilename, reportString)
+    #     Util.generateReport(reportFilename, reportString)
+    # end
+
+    # def getDataContextFromCMDB(param)
+    #     appContext = getAppContext()
+    #     params = {
+    #         "username" => @@config['username'],
+    #         "customcontext" => param["job"] + "_" + param["context"],
+    #         "action" => "listcustomcontext"
+    #     }
+    #     param.delete("context")
+    #     params = param.merge(params)
+
+    #     return CloudmunchService.getDataContext(appContext.get_data('masterurl'), @@config["endpoint"], params)
+    # end
+
+    # def updateDataContextToCMDB(param)
+    #     appContext = getAppContext()
+    #     params = {
+    #         "username" => @@config['username'],
+    #         "customcontext" => param["job"] + "_" + param["context"],
+    #         "action" => "updatecustomcontext"
+    #     }
+    #     param.delete("context")
+    #     params = param.merge(params)
+    #     return CloudmunchService.updateDataContext(appContext.get_data('masterurl'), @@config['endpoint'], params)
+    # end
+   
+    # def getTemplate(template_name)
+    #     begin
+    #         Util.getTemplate(template_name)
+    #     rescue
+    #         return false
+    #     end
+    # end   
+    
 
 end

data/lib/cloudmunch_Ruby_sdk_v2/AppContext.rb

@@ -1,8 +1,49 @@
+#!/usr/bin/ruby
+###
+###  (c) CloudMunch Inc.
+### All Rights Reserved
+### Un-authorized copying of this file, via any medium is strictly prohibited
+###  Proprietary and confidential
+###
+###  ganesan@cloudmunch.com
+###
 
-
+$LOAD_PATH << '.'
+ 
 class AppContext
+    attr_accessor :masterurl
+    attr_accessor :cloudproviders 
+    attr_accessor :domainName 
+    attr_accessor :project
+    attr_accessor :job
+    attr_accessor :workspaceLocation
+    attr_accessor :archiveLocation 
+    attr_accessor :stepid
+    attr_accessor :targetServer
+    attr_accessor :integrations
+    attr_accessor :reportsLocation
+    attr_accessor :runnumber
+    attr_accessor :apikey 
+    attr_accessor :stepname 
+    attr_accessor :environmentId
+
 
     def initialize(param)
+        @masterurl = ""
+        @cloudproviders = ""
+        @domainName = ""
+        @project = ""
+        @job = ""
+        @workspaceLocation = ""
+        @archiveLocation = ""
+        @stepid = ""
+        @targetServer=""
+        @integrations=""
+        @reportsLocation=""
+        @runnumber=""
+        @apikey=""
+        @stepname=""
+        @environmentId=""
        load_data(param) 
     end
 
@@ -14,4 +55,5 @@ class AppContext
         @AppContextParams[keyname] 
     end     
 
-end
+
+end

data/lib/cloudmunch_Ruby_sdk_v2/AssetHelper.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/ruby
+###
+###  (c) CloudMunch Inc.
+### All Rights Reserved
+### Un-authorized copying of this file, via any medium is strictly prohibited
+###  Proprietary and confidential
+###
+###  ganesan@cloudmunch.com
+###
+
+$LOAD_PATH << '.'
+require 'json'
+require_relative "CloudmunchConstants"
+ 
+class AssetHelper
+    include CloudmunchService
+    include Util
+
+    @appContext = nil;
+    @cmDataManager = nil;
+    @logHelper = nil;
+    
+    def initialize(appContext)
+        @appContext = appContext
+        @cloudmunchDataService = CloudmunchService.new 
+    end
+
+    def getAsset(assetID, filterData)
+        paramHash = {}
+        if !filterData.nil?
+            paramHash["filter"] = filterData.to_json
+        end
+        serverUrl = @appContext.getMasterURL() + "/applications/" + @appContext.getProject() + "/assets/" + assetID
+        assetResult = @cloudmunchDataService.getDataForContext(serverUrl, @appContext.getAPIJey(), paramHash)
+
+        if assetResult == nil then 
+            log("ERROR", "Unable to get data from cloudmunch") 
+            return nil
+        else
+            assetResult = JSON.parse(assetResult)
+            assetData = assetResult["data"]
+            if assetData.nil? then
+                log("ERROR", "Asset does not exist") 
+                return nil
+            else
+                return assetData
+            end
+        end
+    end
+    
+    def addAsset(assetName, assetType, assetStatus, assetExternalRef, assetData)
+        if assetName.empty? || assetType.empty? || assetStatus.empty? then
+            log("ERROR", "Asset name ,status and type need to be provided") 
+            return false
+        end
+
+        statusArray = [::STATUS_RUNNING, ::STATUS_STOPPED, ::STATUS_NIL]
+        if !statusArray.include?(assetStatus) then
+            log("ERROR", "Invalid status sent. Allowed values " + ::STATUS_RUNNING, ::STATUS_STOPPED, ::STATUS_NIL) 
+            return false
+        end
+
+        assetData["name"] = assetName
+        assetData["type"] = assetType
+        assetData["status"] = assetStatus
+        assetData["external_reference"] = assetExternalRef
+
+        serverUrl = @appContext.getMasterURL() + "/applications/" + @appContext.getProject() + "/assets/"
+        retResult = @cloudmunchDataService.updateDataForContext(serverUrl, @appContext.getAPIKey(), assetData)
+
+        if retResult == nil then 
+            return nil
+        else
+            retResult = JSON.parse(retResult)
+            retData = retResult["data"]
+            if retData.nil? then 
+                return nil
+            else
+                return retData
+            end
+        end
+
+    end
+
+    
+    def updateAsset(assetID, assetData)
+        serverUrl = @appContext.getMasterURL() + "/applications/" + @appContext.getProject() + "/assets/" + assetID
+        @cloudmunchDataService.updateDataForContext(serverUrl, @appContext.getAPIKey(), assetData)
+    end
+    
+    def deleteAsset(assetID)
+        serverUrl = @appContext.getMasterURL() + "/applications/" + @appContext.getProject() + "/assets/" + assetID
+        @cloudmunchDataService.deleteDataForContext(serverUrl, @appContext.getAPIKey())
+    end
+    
+    def updateStatus(assetID, status)
+        statusArray = [::STATUS_RUNNING, ::STATUS_STOPPED, ::STATUS_NIL]
+        if !statusArray.include?(status) then
+            log("ERROR", "Invalid status") 
+            return false
+        end
+
+        assetData = {}
+        assetData["status"] = status
+        updateAsset(assetID, assetData)
+    end
+
+    def checkIfAssetExists(assetID)
+        serverUrl = @appContext.getMasterURL() + "/applications/" + @appContext.getProject() + "/assets/" + assetID
+
+        assetResult = @cloudmunchDataService.getDataForContext(serverUrl, @appContext.getAPIKey(), "")
+        if assetResult == nil then  
+            return nil
+        else
+            assetResult = JSON.parse(assetResult)
+            assetData = assetResult["data"]
+            if assetData.nil? then
+                log("ERROR", "Asset does not exist") 
+                return false
+            else
+                return true
+            end
+        end
+    end
+
+
+end

data/lib/cloudmunch_Ruby_sdk_v2/CloudmunchConstants.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/ruby
+###
+###  (c) CloudMunch Inc.
+### All Rights Reserved
+### Un-authorized copying of this file, via any medium is strictly prohibited
+###  Proprietary and confidential
+###
+###  ganesan@cloudmunch.com
+###
+
+$LOAD_PATH << '.'
+ 
+class CloudmunchConstants
+    #Assets
+    STATUS_RUNNING = 'running'
+    STATUS_STOPPED = 'stopped'
+    STATUS_NIL = 'NIL'
+
+    #Environments
+    STATUS_RUNNING_WITH_WARNING = 'running_with_warning'
+    STATUS_STOPPED_WITH_ERRORS = 'stopped_with_errors'
+    STATUS_ACTION_IN_PROGRESS = 'action_in_progress'
+    STATUS_CREATION_IN_PROGRESS = 'creation_in_progress'
+end

data/lib/cloudmunch_Ruby_sdk_v2/CloudmunchService.rb

@@ -7,411 +7,72 @@ require 'json'
 require_relative "Util"
 
 module CloudmunchService
-  include Util
-
-  # def self.initialize(appcontext)
-  #   @appContext=appcontext
-  # end
-
-  def getDataStoreID(insightID, dataStoreName)
-      if insightID.nil? || dataStoreName.nil?
-        log("DEBUG", "insight id and datastore name is needed to get datastore id")
-        return nil
-      end
-
-      paramHash = Hash.new
-      paramHash["insightID"] = insightID
-      paramHash["filter"] = {"name" => dataStoreName} 
-      paramHash["count"]  = 1
-      paramHash["fields"] = "id" 
-
-      dataStore = getInsightDataStores(paramHash)
-      if dataStore.nil? || !dataStore.any?
-        log("DEBUG", "Data store with name "+dataStoreName+" does not exist")
-        return nil
-      else
-        return dataStore[0]["id"]
-      end
-  end
-
-  def getReportID(insightID, reportName)
-      if insightID.nil? || reportName.nil?
-        log("DEBUG", "insight id and report name is needed to get report id")
-        return nil
-      end
-
-      paramHash = Hash.new
-      paramHash["insightID"] = insightID
-      paramHash["filter"] = {"name" => reportName} 
-      paramHash["count"]  = 1
-      paramHash["fields"] = "id" 
-
-      report = getInsightReports(paramHash)
-      if report.nil? || !report.any?
-        log("DEBUG", "Report with name "+reportName+" does not exist")
-        return nil
-      else
-        return report[0]["id"]
-      end
-  end
-
-  def getExtractID(insightID, dataStoreID, extractName)
-      if insightID.nil? || dataStoreID.nil? || extractName.nil?
-        log("DEBUG", "insight id, datastore id and extract name is needed to get extract id")
-        return nil
-      end
-
-      extract = nil
-      paramHash = Hash.new
-      paramHash["insightID"]   = insightID
-      paramHash["dataStoreID"] = dataStoreID
-      paramHash["filter"] = {"name" => extractName}
-      paramHash["count"]  = 1
-      paramHash["fields"] = "id" 
-
-      extract = getInsightDataStoreExtracts(paramHash)
-      if extract.nil? || !extract.any?
-        log("DEBUG", "Data store with name "+extractName+" does not exist")
-        return nil
-      else
-        return extract[0]["id"]
-      end
-  end
-
-  def getReportCardID(insightID, reportID, cardName)
-      if insightID.nil? || reportID.nil? || cardName.nil?
-        log("DEBUG", "insight id, report id and card name is needed to get report card id")
-        return nil
-      end
-
-      card = nil
-      paramHash = Hash.new
-      paramHash["insightID"] = insightID
-      paramHash["reportID"] = reportID
-      paramHash["filter"] = {"name" => cardName}
-      paramHash["count"]  = 1
-      paramHash["fields"] = "id" 
-
-      card = getInsightReportCards(paramHash)
-      if card.nil? || !card.any?
-        log("DEBUG", "Report with name "+cardName+" does not exist")
-        return nil
-      else
-        return card[0]["id"]
-      end
-  end
-
-  def getKeyMetricID(insightID, reportID, keyMetricName)
-      extract = nil
-      paramHash = Hash.new
-      paramHash["insightID"] = insightID
-      paramHash["reportID"] = reportID
-      paramHash["filter"] = {"name" => keyMetricName}
-      paramHash["count"]  = 1
-      paramHash["fields"] = "id" 
-
-      keyMetric = getInsightReportCards(paramHash)
-      if keyMetric.nil? || !keyMetric.any?
-        log("DEBUG", "Report key metric with name "+keyMetricName+" does not exist")
-        return nil
-      else
-        return keyMetric[0]["id"]
-      end
-  end
-
-  def createInsight(insightName)
-    if !insightName.nil?
-      insightID = nil
-      insightID = getInsightID(insightName)
-      
-      if !insightID.nil?
-        log("DEBUG", "Insight with name "+insightName+" already exists!")
-        return insightID
-      else
-        paramHash = {}
-        paramHash["context"]    = "insights"
-        paramHash["data"]       = {"name" => insightName}
-        insight = updateCloudmunchData(paramHash)
-        
-        if insight["id"].nil?
-          log("DEBUG", "Unable to create insight : "+insightName+"! refer log for more details")
-          return nil
-        else
-          return insight["id"]
-        end
-      end
-    else
-        log("DEBUG", "Insights name is needed for creating an insight")
-        return nil
-    end
-  end
-
-  def createInsightDataStore(insightID, dataStoreName)
-    if !dataStoreName.nil? && !dataStoreName.empty? && !insightID.nil?
-      dataStoreID = nil
-      dataStoreID = getDataStoreID(insightID, dataStoreName)
-      
-      if !dataStoreID.nil?
-        log("DEBUG", "Data store with name "+dataStoreName+" already exists!")
-        return dataStoreID
-      else
-        paramHash = {}
-        paramHash["context"]    = "insights"
-        paramHash["contextID"]  = insightID
-        paramHash["subContext"] = "datastores"
-        paramHash["data"]       = {"name" => dataStoreName}
-        dataStore = updateCloudmunchData(paramHash)
-        
-        if dataStore["id"].nil?
-          return nil
-        else
-          return dataStore["id"]
-        end
-      end
-    else
-        log("DEBUG", "Datastore name and insights id is needed for creating a data store")
-        return nil
-    end
-  end
-
-  def createInsightDataStoreExtract(insightID, dataStoreID, extractName)
-    if !extractName.nil? && !extractName.empty? && !insightID.nil?  && !dataStoreID.nil?
-
-      extractID = nil
-      extractID = getExtractID(insightID, dataStoreID, extractName)
-      
-      if !extractID.nil?
-        return extractID
-      else
-        paramHash = Hash.new
-        paramHash["context"]      = "insights"
-        paramHash["contextID"]    = insightID
-        paramHash["subContext"]   = "datastores"
-        paramHash["subContextID"] = dataStoreID
-        paramHash["leafContext"]  = "extracts"
-        paramHash["data"]         = {"name" => extractName}
-
-        log("DEBUG", "Attempting creation of extract with name " + extractName + "...")
-        extract = updateCloudmunchData(paramHash)
-
-        if extract["id"].nil? then return nil else extract["id"] end
-      end
-    else
-        log("DEBUG", "Extract name, insights id and datastore id is needed for creating an extract")
-        return nil
-    end
-  end
+  include Util  
+
+  ##################################################################################
+  ###
+  ### downloadKeys(filekey, context, contextid)
+  ### deleteKeys()
+  ### getCloudmunchData(paramHash)
+  ### updateCloudmunchData(paramHash, method = "POST") 
+  ### deleteCloudmunchData(paramHash)
+  ### parseResponse(responseJson)
+  ### generateServerURL(paramHash, appendQueryParams = nil)
+  ###
+  ###
+  ################################################################################## 
+
+  def downloadKeys(filekey, context, contextid)
+
+    paramHash = Hash.new
+    paramHash["context"]     = context
+    paramHash["contextID"]   = contextid
+    paramHash["file"]        = filekey
+
+    keyString = getCloudmunchData(paramHash)
     
-  def createInsightReportCard(insightID, reportID, cardName)
-    if !cardName.nil? && !cardName.empty? && !insightID.nil?  && !reportID.nil?
-
-      cardID = nil
-      cardID = getReportCardID(insightID, reportID, cardName)
-      
-      if !cardID.nil?
-        return cardID
-      else
-        paramHash = Hash.new
-        paramHash["context"]      = "insights"
-        paramHash["contextID"]    = insightID
-        paramHash["subContext"]   = "insight_reports"
-        paramHash["subContextID"] = reportID
-        paramHash["leafContext"]  = "insight_cards"
-        paramHash["data"]         = {"name" => cardName}
-
-        log("DEBUG", "Attempting creation of report card with name " + cardName + "...")
-        card = updateCloudmunchData(paramHash)
-
-        if card["id"].nil? then return nil else card["id"] end
-      end
-    else
-        log("DEBUG", "Extract name, insight id and report id is needed for creating a report card")
-        return nil
-    end
-  end
-
-  def createInsightReportKeyMetric(insightID, reportID, keyMetricName)
-    if !keyMetricName.nil? && !keyMetricName.empty? && !insightID.nil?  && !reportID.nil?
-
-      keyMetricID = nil
-      keyMetricID = getReportKeyMetricID(insightID, reportID, keyMetricName)
-      
-      if !keyMetricID.nil?
-        return keyMetricID
-      else
-        paramHash = Hash.new
-        paramHash["context"]      = "insights"
-        paramHash["contextID"]    = insightID
-        paramHash["subContext"]   = "insight_reports"
-        paramHash["subContextID"] = reportID
-        paramHash["leafContext"]  = "insight_cards"
-        paramHash["data"]         = {"name" => keyMetricName}
-
-        log("DEBUG", "Attempting creation of report key metric with name " + keyMetricName + "...")
-        keyMetric = updateCloudmunchData(paramHash)
-
-        if keyMetric["id"].nil? then return nil else keyMetric["id"] end
-      end
-    else
-        log("DEBUG", "Key metric name, insight id and report id is needed for creating a report key metric")
-        return nil
-    end
-  end
-
-  def createInsightReport(insightID, reportName)
-    if !reportName.nil? && !reportName.empty? && !insightID.nil?
-
-      reportID = nil
-      reportID = getExtractID(insightID, reportName)
-      
-      if !reportID.nil?
-        return reportID
-      else
-        paramHash = Hash.new
-        paramHash["context"]     = "insights"
-        paramHash["contextID"]   = insightID
-        paramHash["subContext"]  = "insight_reports"
-        paramHash["data"]        = {"name" => reportName}
-
-        log("DEBUG", "Attempting creation of report with name " + reportName + "...")
-        report = updateCloudmunchData(paramHash)
-
-        if report["id"].nil? then return nil else report["id"] end
-      end
-    else
-        log("DEBUG", "Report name and insight id is needed for creating a report")
-        return nil
-    end
-  end
-
-  def updateInsightDataStoreExtract(insightID, dataStoreID, data)
-    # /applications/{application_id}/insights/{insight_id}/datastores/{datastore_id}
-
-    if (insightID.nil? || insightID.empty?) && (dataStoreID.nil? || dataStoreID.empty?) && data.nil?
-      log("DEBUG", "Insight id, datastore id and data is needed to be update an existing data store")
-      return nil
-    end
-        paramHash = {}
-        paramHash["context"]      = "insights"
-        paramHash["contextID"]    = insightID
-        paramHash["subContext"]   = "datastores"
-        paramHash["subContextID"] = dataStoreID
-        paramHash["data"]         = data
-        return updateCloudmunchData(paramHash)
-  end
-
-  def updateInsightReport(insightID, reportID, data)
-    # /applications/{application_id}/insights/{insight_id}/insight_reports/{insight_report_id}
-
-    if (insightID.nil? || insightID.empty?) && (reportID.nil? || reportID.empty?) && data.nil?
-      log("DEBUG", "Insight id, report id and data is needed to be update an existing report")
-      return nil
-    end
-        paramHash = {}
-        paramHash["context"]      = "insights"
-        paramHash["contextID"]    = insightID
-        paramHash["subContext"]   = "insight_reports"
-        paramHash["subContextID"] = reportID
-        paramHash["data"]         = data
-        return updateCloudmunchData(paramHash)
-  end
-
-  def updateInsightDataStoreExtract(insightID, dataStoreID, extractID, data)
-    # /insights/{insight_id}/datastores/{datastore_id}/extracts/{extract_id}
-
-    if (insightID.nil? || insightID.empty?) && (dataStoreID.nil? || dataStoreID.empty?) && (extractID.nil? || extractID.empty?) && data.nil?
-      log("DEBUG", "Insight id, datastore id, extract id and data is needed to be update an existing extract")
+    if !keyString.to_s == ""
+      log("ERROR", "downloaded key content is empty, please re-upload key and try")
       return nil
     end
-        paramHash = {}
-        paramHash["context"]       = "insights"
-        paramHash["contextID"]     = insightID
-        paramHash["subContext"]    = "datastores"
-        paramHash["subContextID"]  = dataStoreID
-        paramHash["leafContext"]   = "extracts"
-        paramHash["leafContextID"] = extractID
-        paramHash["data"]          = data
-        return updateCloudmunchData(paramHash)
-  end
-
-
-  def updateInsightReportCard(insightID, reportID, cardID, data)
-    # /applications/{application_id}/insights/{insight_id}/insight_reports/{insight_report_id}/insight_cards/{insight_card_id}
-
-    if (insightID.nil? || insightID.empty?) && (reportID.nil? || reportID.empty?) && (cardID.nil? || cardID.empty?) && data.nil?
-      log("DEBUG", "Insight id, report id, cardID and data is needed to be update an existing report card")
-      return nil
+    
+    filename = "keyfile_" + Time.now.strftime('%Y%m%d%H%M%S%L')
+    file     = @appContext.get_data("{workspace}")+"/"+filename
+    
+    File.open(file, 'w') { |file| file.write(keyString) }
+    system('chmod 400 '+file)
+    
+    if @keyArray.nil?
+      @keyArray = []
     end
 
-    paramHash = {}
-    paramHash["context"]       = "insights"
-    paramHash["contextID"]     = insightID
-    paramHash["subContext"]    = "insight_reports"
-    paramHash["subContextID"]  = reportID
-    paramHash["leafContext"]   = "insight_cards"
-    paramHash["leafContextID"] = cardID
-    paramHash["data"]          = data
-    return updateCloudmunchData(paramHash)
+    @keyArray.push(file)
+    return file;
   end
 
-
-  def updateInsightReportKeyMetric(insightID, reportID, keyMetricID, data)
-    # /applications/{application_id}/insights/{insight_id}/insight_reports/{insight_report_id}/key_metrics/{key_metric_id}
-
-    if (insightID.nil? || insightID.empty?) && (reportID.nil? || reportID.empty?) && (keyMetricID.nil? || keyMetricID.empty?) && data.nil?
-      log("DEBUG", "Insight id, report id, keyMetricID and data is needed to be update an existing report key metric")
-      return nil
-    end
-
-    paramHash = {}
-    paramHash["context"]       = "insights"
-    paramHash["contextID"]     = insightID
-    paramHash["subContext"]    = "insight_reports"
-    paramHash["subContextID"]  = reportID
-    paramHash["leafContext"]   = "key_metrics"
-    paramHash["leafContextID"] = keyMetricID
-    paramHash["data"]          = data
-    return updateCloudmunchData(paramHash)
+  def deleteKeys()
+    fileName = @appContext.get_data("{workspace}")+"/keyfile_*"
+    File.delete(fileName)
   end
 
-  def getInsightReportKeyMetrics(paramHash)
-    # /applications/{application_id}/insights/{insight_id}/insight_reports/{insight_report_id}/key_metrics/{key_metric_id}
-    paramReportId  = paramHash["reportID"].nil? ? nil : paramHash["reportID"]
-    paramInsightID = paramHash["insightID"].nil? ? nil : paramHash["insightID"]
+  def getCloudmunchData(paramHash)
+    serverurl = nil
+    serverurl = generateServerURL(paramHash,true)
 
-    if paramInsightID.nil? || paramInsightID.empty? || paramReportId.nil? || paramReportId.empty?
-      log("DEBUG", "Insight id and report id is needed to gets its report key metric details")
-      return nil
+    if serverurl.nil?
+        log("DEBUG", "Unable to generate server url")
+        log("ERROR", "Unable to get data from cloudmunch")    
+        return nil
     end
 
-    paramFormatted = Hash.new
-    paramFormatted = paramHash
-    paramFormatted["context"]      = "insights"
-    paramFormatted["subContext"]   = "insight_reports"
-    paramFormatted["leafContext"]  = "key_metrics"
-    paramFormatted["contextID"]    = paramInsightID
-    paramFormatted["subContextID"] = paramReportId
+    uri = URI.parse(serverurl)              
     
-    if !paramHash["keyMetricID"].nil?
-      paramFormatted["leafContextID"] = paramHash["keyMetricID"]
-    end
-
-    return getCloudmunchData(paramFormatted)
-  end
-
-  def updateInsight(insightID, data)
-    # /applications/{application_id}/insights/{insight_id}
-
-    if (insightID.nil? || insightID.empty?) && data.nil?
-      log("DEBUG", "Insight id and data is needed to be update an existing data store")
-      return nil
-    end
-
-    paramHash = {}
-    paramHash["context"]   = "insights"
-    paramHash["contextID"] = insightID
-    paramHash["data"]      = data
-    return updateCloudmunchData(paramHash)
+    log("DEBUG", "URI for get : ")
+    log("DEBUG", uri)          
+    
+    responseJson = Net::HTTP.get(uri)
+    
+    parseResponse(responseJson)
   end
 
   def updateCloudmunchData(paramHash, method = "POST") 
@@ -442,7 +103,28 @@ module CloudmunchService
       return parseResponse(responseJson.body)      
   end
 
+  def deleteCloudmunchData(paramHash)
+    paramContext = paramHash["context"]
+    paramContextID = paramHash["contextID"]
+
+    if !paramContext.nil? && !paramContext.empty? && !paramContextID.nil? && !paramContextID.empty?
+        serverurl=@appContext.get_data("{master_url}")+"/applications/"+@appContext.get_data("{application}")+"/"+context+"/"+contextID;
+        serverurl=serverurl+"?apikey="+@appContext.get_data("{api_key}")
+        uri = URI.parse(serverurl)
+        Net::HTTP::Delete(uri)
+        return 1
+    else
+        return nil
+    end
+  end 
+
   def parseResponse(responseJson)
+    begin
+        JSON.parse(responseJson)
+    rescue
+        return responseJson
+    end
+
     requestDetails = (JSON.load(responseJson))['request']
     responseData   = (JSON.load(responseJson))['data']
 
@@ -459,134 +141,7 @@ module CloudmunchService
     end
   end
 
-  def getCloudmunchData(paramHash)
-    serverurl = nil
-    serverurl = generateServerURL(paramHash,true)
-
-    if serverurl.nil?
-        log("DEBUG", "Unable to generate server url")
-        log("ERROR", "Unable to get data from cloudmunch")    
-        return nil
-    end
-
-    uri = URI.parse(serverurl)              
-    
-    log("DEBUG", "URI for get : ")
-    log("DEBUG", uri)          
-    
-    responseJson = Net::HTTP.get(uri)
-    return parseResponse(responseJson)
-  end
-
-  def getInsights(paramHash)
-    # /insights/{insight_id}
-    paraminsightID = paramHash["insightID"].nil? ? nil : paramHash["insightID"]
-
-    paramFormatted = Hash.new
-    paramFormatted = paramHash
-    paramFormatted["context"] = "insights"
-    
-    if !paraminsightID.nil? && !paraminsightID.empty?
-        paramFormatted["contextID"]  = paramInsightID
-    end    
-
-    return getCloudmunchData(paramFormatted)          
-  end
-
-  def getInsightDataStoreExtracts(paramHash)
-    # /insights/{insight_id}/datastores/{datastore_id}/extracts/{extract_id}
-    paramDataStoreId = paramHash["dataStoreID"].nil? ? nil : paramHash["dataStoreID"]
-    paramInsightID   = paramHash["insightID"].nil? ? nil : paramHash["insightID"]
-
-    serverurl   = nil
-
-    if paramInsightID.nil? || paramInsightID.empty? || paramDataStoreId.nil? || paramDataStoreId.empty?
-      log("DEBUG", "Insight id and datastore id is needed to gets its extract details")
-      return nil
-    end
-
-    paramFormatted = Hash.new
-    paramFormatted = paramHash
-    paramFormatted["context"]      = "insights"
-    paramFormatted["subContext"]   = "datastores"
-    paramFormatted["leafContext"]  = "extracts"
-    paramFormatted["contextID"]    = paramInsightID
-    paramFormatted["subContextID"] = paramDataStoreId
-    
-    if !paramHash["extractID"].nil?
-      paramFormatted["leafContextID"] = paramHash["extractID"]
-    end
-
-    return getCloudmunchData(paramFormatted)
-  end
-
-  def getInsightDataStores(paramHash)
-    # /insights/{insight_id}/datastores/{datastore_id}
-    paramInsightID  = paramHash["insightID"].nil? ? nil : paramHash["insightID"]
-
-    if paramInsightID.nil? || paramInsightID.empty?
-      log("DEBUG", "Insight id is not provided")
-      return nil
-    end
-
-    paramFormatted = Hash.new
-    paramFormatted = paramHash
-    paramFormatted["context"]    = "insights"
-    paramFormatted["subContext"] = "datastores"
-    paramFormatted["contextID"]  = paramInsightID
-    
-    if !paramHash["dataStoreID"].nil?
-      paramFormatted["subContextID"] = paramHash["dataStoreID"]
-    end
-    return getCloudmunchData(paramFormatted)          
-  end
-
-  def getInsightReports(paramHash)
-    # /applications/{application_id}/insights/{insight_id}/insight_reports/{insight_report_id}
-    paramInsightID = paramHash["insightID"].nil? ? nil : paramHash["insightID"]
-
-    if paramInsightID.nil? || paramInsightID.empty?
-      log("DEBUG", "Insight id is needed to gets its report details")
-      return nil
-    end
-
-    paramFormatted = Hash.new
-    paramFormatted = paramHash
-    paramFormatted["context"]    = "insights"
-    paramFormatted["subContext"] = "insight_reports"
-    paramFormatted["contextID"]  = paramInsightID
-    
-    if !paramHash["reportID"].nil?
-      paramFormatted["subContextID"] = paramHash["reportID"]
-    end
-
-    return getCloudmunchData(paramFormatted)
-  end
-
-  def getInsightReportCards(paramHash)
-    # /applications/{application_id}/insights/{insight_id}/insight_reports/{insight_report_id}/insight_cards/{insight_card_id}
-    paramReportId  = paramHash["reportID"].nil? ? nil : paramHash["reportID"]
-    paramInsightID = paramHash["insightID"].nil? ? nil : paramHash["insightID"]
-
-    if paramInsightID.nil? || paramInsightID.empty? || paramReportId.nil? || paramReportId.empty?
-      log("DEBUG", "Insight id and report id is needed to gets its report card details")
-      return nil
-    end
-
-    paramFormatted = Hash.new
-    paramFormatted = paramHash
-    paramFormatted["context"]      = "insights"
-    paramFormatted["subContext"]   = "insight_reports"
-    paramFormatted["leafContext"]  = "insight_cards"
-    paramFormatted["contextID"]    = paramInsightID
-    paramFormatted["subContextID"] = paramReportId
-    
-    if !paramHash["cardID"].nil?
-      paramFormatted["leafContextID"] = paramHash["cardID"]
-    end
-
-    return getCloudmunchData(paramFormatted)
-  end
+  
 
   def generateServerURL(paramHash, appendQueryParams = nil)
 
@@ -628,6 +183,7 @@ module CloudmunchService
     
     if !appendQueryParams.nil?
       queryString = queryString + "filter=" + paramHash["filter"].to_json + "&" if !paramHash["filter"].nil?
+      queryString = queryString + "file="   + paramHash["file"].to_s      + "&" if !paramHash["file"].nil?
       queryString = queryString + "fields=" + paramHash["fields"].to_s    + "&" if !paramHash["fields"].nil?
       queryString = queryString + "count="  + paramHash["count"].to_s     + "&" if !paramHash["count"].nil?
       queryString = queryString + "offset=" + paramHash["offset"].to_s    + "&" if !paramHash["offset"].nil?
@@ -639,31 +195,9 @@ module CloudmunchService
     return serverurl
   end
 
-  def deleteCloudmunchData(paramHash)
-    paramContext = paramHash["context"]
-    paramContextID = paramHash["contextID"]
-
-    if !paramContext.nil? && !paramContext.empty? && !paramContextID.nil? && !paramContextID.empty?
-        serverurl=@appContext.get_data("{master_url}")+"/applications/"+@appContext.get_data("{application}")+"/"+context+"/"+contextID;
-        serverurl=serverurl+"?apikey="+@appContext.get_data("{api_key}")
-        uri = URI.parse(serverurl)
-        Net::HTTP::Delete(uri)
-        return 1
-    else
-        return nil
-    end
-  end 
-   
-  def deleteCloudmunchDataBKUP(context,contextID)
-    serverurl=@appContext.get_data("{master_url}")+"/applications/"+@appContext.get_data("{application}")+"/"+context+"/"+contextID;
-    serverurl=serverurl+"?apikey="+@appContext.get_data("{api_key}")
-    uri = URI.parse(serverurl)
-    Net::HTTP::Delete(uri)
-  end 
-
   def self.putCustomDataContext(server, endpoint, param)
     result = self.http_post(server, endpoint, param)
-    #p result.code.to_s 
+    
     if result.code.to_s == "200"
       return true 
     else
@@ -697,11 +231,19 @@ module CloudmunchService
     end
   end
 
-  def self.getDataContext(server, endpoint, param)
-      getCustomDataContext(server, endpoint, param)     
+  # def self.getDataContext(server, endpoint, param)
+  #     getCustomDataContext(server, endpoint, param)     
+  # end
+
+  # def self.updateDataContext(server, endpoint, param)
+  #     putCustomDataContext(server, endpoint, param)  
+  # end
+
+  def getDataForContext(server, endpoint, param)
+      getCustomDataContext(server, endpoint, param)    
   end
 
-  def self.updateDataContext(server, endpoint, param)
+  def updateDataForContext(server, endpoint, param)
       putCustomDataContext(server, endpoint, param)  
   end
 end