cloudmunch_sdk_v3 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a307ebe2d38a7538a9b8aafd1e93b1de349aac54
+  data.tar.gz: 8407081379ce3deb467a57b3e1f7a8f23d75a5f2
+SHA512:
+  metadata.gz: cb485f0f0af99d19a361813d03b7727a3bc15c1da48ad8c23a518c365243d78ff3303102c83891b34d2fea280a8184389a45bc6d1f3450671870d672e13fbd9f
+  data.tar.gz: b083500d731499aa79ce7e09352fa79b48983d949102aa6b0765a53906ab85159ed023db233e6f4c9e29d4189890c90bd2b96f8ba3adca31c834e4c4f8da7299

data/lib/cloudmunch_Ruby_sdk_v2/AppAbstract.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/ruby
+$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 = nil
+
+    def initialize(param = nil)
+    end
+
+    def logInit(log_level)
+        @logger = @logger ? @logger : Util.logInit()
+        @log_level = log_level
+    end
+
+    def log(level,logString)
+        if @logger.nil?
+            logInit("DEBUG")
+        end     
+        Util.logIt(@logger, @log_level, level.to_s.downcase, logString)
+    end
+
+
+    def logClose()
+        Util.logClose(@logger)
+    end
+
+    def getJSONArgs()
+      jsonin = nil
+      varin=nil
+      integrations=nil
+      loop { case ARGV[0]
+          when '-jsoninput' then  ARGV.shift; jsonin = ARGV.shift
+          when '-variables' then  ARGV.shift; varin = ARGV.shift
+          when '-integrations' then  ARGV.shift; integrations = ARGV.shift
+
+          when /^-/ then  usage("Unknown option: #{ARGV[0].inspect}")
+          else break
+      end; }
+        @json_input = JSON.load(jsonin)
+        @var_input =JSON.load(varin)
+        @integration_input=JSON.load(integrations)
+        createAppContext();
+        return @json_input
+    end   
+
+    def createAppContext()
+        @appContext = AppContext.new(@var_input)        
+    end
+
+    def getAppContext()
+        return @appContext
+    end
+
+    # def getCloudmunchContext(context)
+    #     begin
+    #         return @@config[context+"_context"]
+    #     rescue
+    #         return false
+    #     end
+    # end
+
+    def getCloudmunchService()
+        @cloudmunchservice = self.extend(CloudmunchService)
+        return @cloudmunchservice
+    end
+
+    def getInsightHelper()
+        @insightHelper = self.extend(InsightHelper)
+        return @insightHelper
+    end 
+    
+    def getIntegrationDetails(param = nil)
+        serviceProvider = ServiceProvider.new(@json_input["providername"])
+        serviceProvider.load_data(@integration_input)
+        return serviceProvider
+    end
+
+    def initializeApp()
+    end
+
+    def process()
+    end
+
+    def cleanupApp()
+       log("INFO", "\nExiting app")
+    end
+
+    def start()
+        initializeApp()
+        process()
+        cleanupApp()
+    end
+
+    # 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

@@ -0,0 +1,59 @@
+#!/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
+
+    def load_data(param)
+        @AppContextParams = param
+    end     
+
+    def get_data(keyname)
+        @AppContextParams[keyname] 
+    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

@@ -0,0 +1,249 @@
+#!/usr/bin/ruby
+
+require 'net/http'
+require 'cgi'
+require 'json'
+
+require_relative "Util"
+
+module CloudmunchService
+  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)
+    
+    if !keyString.to_s == ""
+      log("ERROR", "downloaded key content is empty, please re-upload key and try")
+      return nil
+    end
+    
+    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
+
+    @keyArray.push(file)
+    return file;
+  end
+
+  def deleteKeys()
+    fileName = @appContext.get_data("{workspace}")+"/keyfile_*"
+    File.delete(fileName)
+  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)
+    
+    parseResponse(responseJson)
+  end
+
+  def updateCloudmunchData(paramHash, method = "POST") 
+      paramData = Hash.new
+      paramData["data"] = paramHash["data"]
+      
+      serverurl = nil
+      serverurl = generateServerURL(paramHash)
+
+      if serverurl.nil?
+          log("DEBUG", "Unable to generate server url")
+          log("ERROR", "Unable to "+method+" data on cloudmunch")    
+          return nil
+      end
+
+      uri = URI.parse(serverurl)              
+      
+      log("DEBUG", "URI for "+method+" : ")
+      log("DEBUG", uri)          
+      
+      if method.casecmp("post") == 0
+        responseJson = Net::HTTP.post_form(uri,"data" => paramData.to_json)
+      elsif method.casecmp("patch") == 0
+        #code for patch
+      elsif method.casecmp("put") == 0
+        #code for put
+      end
+      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']
+
+    log("DEBUG", "Response : ")
+    log("DEBUG", responseJson)
+    
+    if !requestDetails['status'].nil? && requestDetails['status'].casecmp('success') == 0    
+        return responseData
+    else
+        if !requestDetails['message'].nil?
+          log("ERROR", requestDetails['message'])
+        end
+        return nil
+    end
+  end
+
+  
+
+  def generateServerURL(paramHash, appendQueryParams = nil)
+
+    serverurl = ""
+    
+    if !paramHash["url"].nil?
+        serverurl = @appContext.get_data("{master_url}")+"/"+paramHash["url"]
+    elsif !paramHash["context"].nil?
+        paramContext       = paramHash["context"].nil? ? nil : paramHash["context"]
+        paramContextID     = paramHash["contextID"].nil? ? nil : paramHash["contextID"]
+        paramSubContext    = paramHash["subContext"].nil? ? nil : paramHash["subContext"]
+        paramSubContextID  = paramHash["subContextID"].nil? ? nil : paramHash["subContextID"]
+        paramLeafContext   = paramHash["leafContext"].nil? ? nil : paramHash["leafContext"]
+        paramLeafContextID = paramHash["leafContextID"].nil? ? nil : paramHash["leafContextID"]
+
+        serverurl=@appContext.get_data("{master_url}")+"/applications/"+@appContext.get_data("{application}")+"/"+paramContext
+
+        if !paramContextID.nil? && !paramContextID.empty?
+            serverurl=serverurl+"/"+paramContextID;
+            if !paramSubContext.nil? && !paramSubContext.empty?
+                serverurl=serverurl+"/"+paramSubContext;              
+                if !paramSubContextID.nil? && !paramSubContextID.empty?
+                    serverurl=serverurl+"/"+paramSubContextID;
+                    if !paramLeafContext.nil? && !paramLeafContext.empty?
+                        serverurl=serverurl+"/"+paramLeafContext;
+                        if !paramLeafContextID.nil? && !paramLeafContextID.empty?
+                            serverurl=serverurl+"/"+paramLeafContextID;
+                        end
+                    end
+                end
+            end
+        end
+    else
+        log("DEBUG", "No context provided for get api call");
+        return nil
+    end
+
+    queryString = ""
+    
+    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?
+      queryString = queryString + "request_category=" + paramHash["requestCategory"].to_s + "&" if !paramHash["requestCategory"].nil?
+      queryString = queryString + "order_by=" + paramHash["orderBy"].to_s + "&" if !paramHash["orderBy"].nil?
+      queryString = queryString + "group_by=" + paramHash["groupBy"].to_s + "&" if !paramHash["groupBy"].nil?
+    end
+    serverurl = serverurl+"?"+queryString+"apikey="+@appContext.get_data("{api_key}")
+    return serverurl
+  end
+
+  def self.putCustomDataContext(server, endpoint, param)
+    result = self.http_post(server, endpoint, param)
+    
+    if result.code.to_s == "200"
+      return true 
+    else
+      return false 
+    end     
+  end
+
+  def self.getCustomDataContext(server, endpoint, param)
+      return self.http_get(server, endpoint, param)
+  end
+
+  def self.http_get(server,path,params)
+    if params.nil?
+     return Net::HTTP.get(server, path)
+    else
+       queryStr =  "#{path}?".concat(params.collect { |k,v| "#{k}=#{CGI::escape(v.to_s)}" }.join('&'))
+       puts ("SDKDEBUG: Calling URL " + server+queryStr)
+       uri = URI(server + "/" + queryStr)
+       return Net::HTTP.get(uri) 
+    end
+  end
+ 
+  def self.http_post(server,path,params)
+    queryStr =  "#{path}?".concat(params.collect { |k,v| "#{k}=#{CGI::escape(v.to_s)}" }.join('&'))
+    puts ("SDKDEBUG: Calling URL " + server+queryStr)
+    if params.nil?
+        return Net::HTTP.post(server, path)
+    else
+        uri = URI(server +  path)
+        return Net::HTTP.post_form(uri, params)
+    end
+  end
+
+  # 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 updateDataForContext(server, endpoint, param)
+      putCustomDataContext(server, endpoint, param)  
+  end
+end