cloudmunch_sdk_v3 3.0.0

data/lib/cloudmunch_Ruby_sdk_v3/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_v3/CloudmunchService.rb

@@ -0,0 +1,300 @@
+#!/usr/bin/ruby
+
+require 'net/http'
+require 'cgi'
+require 'json'
+
+require_relative "Util"
+
+module CloudmunchService
+  include Util  
+
+  ##################################################################################
+  ###
+  ### downloadKeys(filekey, context, contextid)
+  ### getResource(type)
+  ### deleteKeys()
+  ### getCloudmunchData(paramHash)
+  ### updateCloudmunchData(paramHash, method = "POST") 
+  ### deleteCloudmunchData(paramHash)
+  ### parseResponse(responseJson)
+  ### generateServerURL(paramHash, appendQueryParams = nil)
+  ###
+  ###
+  ################################################################################## 
+
+  ###################################################################################
+  #### getResource(type)
+  #### Return resources available for a given type
+  ###################################################################################
+  def getResource(type)
+    if !type.nil?
+      paramHash = Hash.new
+      paramHash["context"] = "resources"
+      paramHash["filter"] = {"type" => type}
+      paramHash["fields"] = "id,integration_id,key_fields"
+
+      resource = getCloudmunchData(paramHash)
+
+      if resource.nil?
+        log("DEBUG", "Unable to retrieve resource for this type")
+        return nil
+      else
+        return resource
+      end
+    else
+      log("DEBUG", "Type needs to be provided to retrieve resource!")
+      return nil
+    end
+  end
+
+    def getIntegrationWithID(integrationID)
+      if !integrationID.nil?
+        paramHash = Hash.new
+        paramHash["context"] = "integrations"
+        paramHash["contextID"] = integrationID
+
+        integration = getCloudmunchData(paramHash)
+
+        log("DEBUG",integration)
+        if integration.nil?
+          return nil
+        else
+          if integration["configuration"]
+              return integration["configuration"]
+          else
+              return nil
+          end
+        end
+      else
+        return nil
+      end        
+  end
+
+
+  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
+        paramData["method"] = "patch"
+        responseJson = Net::HTTP.post_form(uri,"data" => paramData.to_json)
+      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

data/lib/cloudmunch_Ruby_sdk_v3/ElasticBeanStalkServer.rb

@@ -0,0 +1,52 @@
+#!/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 ElasticBeanStalkServer < Server
+	attr_accessor :servername
+	attr_accessor :envname
+	attr_accessor :bucketname
+	attr_accessor :applicationName
+	attr_accessor :templateName
+	attr_accessor :description
+	attr_accessor :dns
+	attr_accessor :appName
+	attr_accessor :deployTempLoc
+	attr_accessor :assettype
+	attr_accessor :status
+	attr_accessor :starttime
+	attr_accessor :provider
+	attr_accessor :provider
+	attr_accessor :region
+	attr_accessor :cmserver
+	attr_accessor :assetname
+
+    def initialize(appContext)
+        @servername = ""
+        @envname = ""
+        @bucketname = ""
+        @applicationName = ""
+        @templateName = ""
+        @description = ""
+        @dns = ""
+        @appName = ""
+        @deployTempLoc = ""
+        @assettype = ""
+        @status = ""
+        @starttime = ""
+        @provider = ""
+        @region = ""
+        @cmserver = ""
+        @assetname = ""
+    end
+
+
+end

data/lib/cloudmunch_Ruby_sdk_v3/EnvironmentHelper.rb

@@ -0,0 +1,292 @@
+#!/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
+    @defaultRole   = "Area_51"
+    
+    def initialize(appContext)
+        @appContext = appContext
+        @cloudmunchDataService = CloudmunchService.new 
+        @roleHelper = RoleHelper.new
+    end
+
+   # ##
+   # ## 
+   # ## @param  Json Object filterData In the format {"filterfield":"=value"}
+   # ## @return json object environmentdetails
+   # ##
+   # ##   
+   def getExistingEnvironments(filterData)
+        paramHash = {}
+        if !filterData.nil?
+            paramHash["filter"] = filterData.to_json
+        end
+
+        serverUrl = @appContext.getMasterURL() + "/applications/"  + @appContext.getProject() + "/environments"
+        envResult = @cloudmunchDataService.getDataForContext(serverUrl, @appContext.getAPIJey(), paramHash)
+
+        if envResult == nil then 
+            log("ERROR", "Unable to get data from cloudmunch") 
+            return nil
+        else
+            envResult = JSON.parse(envResult)
+            envData = envResult["data"]
+            if envData.nil? then
+                log("ERROR", "environments do not exist") 
+                return nil
+            else
+                return envData
+            end
+        end
+   end
+
+   # ###
+   # ### 
+   # ### @param  String  environmentID
+   # ### @param  Json Object filterData In the format {"filterfield":"=value"}
+   # ### @return json object environmentdetails
+   # ### 
+   # ###    
+    def getEnvironment(environmentID, filterData)
+        paramHash = {}
+        if !filterData.nil?
+            paramHash["filter"] = filterData.to_json
+        end
+        serverUrl = @appContext.getMasterURL() + "/applications/" + @appContext.getProject() + "/environments/" + environmentID
+        envResult = @cloudmunchDataService.getDataForContext(serverUrl, @appContext.getAPIJey(), paramHash)
+
+        if envResult == nil then 
+            log("ERROR", "Unable to get data from cloudmunch") 
+            return nil
+        else
+            envResult = JSON.parse(envResult)
+            envData = envResult["data"]
+            if envData.nil? then
+                log("DEBUG", "Environment does not exist") 
+                return nil
+            else
+                return envData
+            end
+        end
+    end
+
+    # ###
+    # ###
+    # ### @param string environmentName Name of the environment
+    # ### @param string environmentStatus Environment status ,valid values are success,failed,in-progress
+    # ### @param array  environmentData Array of environment properties
+    # ###
+    def addEnvironment(environmentName, environmentStatus, environmentData)
+        if environmentName.empty? || environmentStatus.empty? then
+            log("ERROR", "Environment name ,status and type need to be provided") 
+            return false
+        end
+
+        statusArray = [STATUS_CREATION_IN_PROGRESS, STATUS_RUNNING, STATUS_STOPPED, STATUS_STOPPED_WITH_ERRORS, STATUS_RUNNING_WITH_WARNINGS, STATUS_ACTION_IN_PROGRESS]
+        if !statusArray.include?(assetStatus) then
+            log("ERROR", "Invalid status sent. Allowed values " + STATUS_CREATION_IN_PROGRESS + "," + STATUS_RUNNING + "," + STATUS_STOPPED + "," + STATUS_STOPPED_WITH_ERRORS + "," STATUS_RUNNING_WITH_WARNINGS + "," + STATUS_ACTION_IN_PROGRESS) 
+            return false
+        end
+
+        environmentData["name"] = environmentName
+        environmentData["status"] = environmentStatus
+
+        serverUrl = @appContext.getMasterURL() + "/applications/" + @appContext.getProject() + "/environments/"
+        retResult = @cloudmunchDataService.updateDataForContext(serverUrl, @appContext.getAPIKey(), environmentData)
+
+        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
+
+    # ###
+    # ###
+    # ### @param String Environment ID
+    # ### @param JsonObject Environment Data
+    # ###
+    def updateEnvironment(environmentID, environmentData, comment)
+        serverUrl = @appContext.getMasterURL() + "/applications/" + @appContext.getProject() + "/environments/" + environmentID
+        retResult = @cloudmunchDataService.updateDataForContext(serverUrl, @appContext.getAPIKey(), environmentData)
+    end
+
+    # ###
+    # ###
+    # ### @param String Environment ID
+    # ### @param URL    Environment Data
+    # ###
+    def updateEnvironmentURL(environmentID, environmentURL)
+        if environmentURL.nil? || environmentURL.empty then
+            log("ERROR", "Environment URL is not provided to update environment details") 
+            return false
+        else
+            comment = "Setting application URL";
+            paramHash = {}
+            paramHash["application_url"] = environmentURL
+            updateEnvironment(environmentID, paramHash, comment);
+        end
+    end
+
+    # ###
+    # ### 
+    # ### @param String Environment ID
+    # ### @param URL    Environment Data
+    # ###
+    def updateEnvironmentBuildVersion(environmentID, buildNumber)
+        if buildNumber.nil? || buildNumber.empty then
+            log("ERROR", "Build Number is not provided to update environment details") 
+            return false
+        else
+            comment = "Setting application build version";
+            paramHash = {}
+            paramInnerHash = {}
+            paramInnerHash["version"] = ""
+            paramInnerHash["build"] = buildNumber
+            paramHash["application"] = paramInnerHash
+            updateEnvironment(environmentID, paramHash, comment);
+        end
+    end
+
+    # ###
+    # ### 
+    # ### @param String Environment ID
+    # ### @param Array  AssetArray
+    # ### @param String Role Id
+    # ###
+    def updateAsset(environmentID, assetHash, roleID)
+        if assetHash.nil? || assetHash.empty? then
+            log("DEBUG","An array of asset ids are excpected for updating asset details to an environment")
+            return false
+        end
+
+        if !assetHash.is_h? then
+            log("INFO", "Role is not provided, creating a default role with name " + @defaultRole )
+            return false
+        end
+
+        if roleID.nil? || roleID.empty? then
+            filter = '{"name":"' + @defaultRole + '"}'
+            defaultRoleDetails = @roleHelper.getExistingRoles(filter)
+
+            if defaultRoleDetails.empty? then
+                log("INFO", "Role is not provided, creating a default role with name " + @defaultRole )
+                newRoleDetails = @roleHelper.addRole(@defaultRole)
+                roleID = newRoleDetails.id
+                paramHash = {}
+                paramInnerHash = {}
+                paramDataHash = {}
+                paramDataHash["id"] = roleID
+                paramDataHash["name"] = @defaultRole
+                paramDataHash["assets"] = assetHash
+                paramInnerHash[roleID] = paramDataHash
+                paramHash["tiers"] = paramInnerHash
+            else
+                log("INFO", "Role is not provided, linking with default role : " + @defaultRole)
+                roleID = defaultRoleDetails[0]["id"]
+                paramHash = {}
+                paramInnerHash = {}
+                paramDataHash = {}
+                paramDataHash["id"] = roleID
+                paramDataHash["name"] = '{$tiers/'  + roleID + '.name}'
+                paramDataHash["assets"] = assetHash
+                paramInnerHash[roleID] = paramDataHash
+                paramHash["tiers"] = paramInnerHash
+            end
+        else
+            paramHash = {}
+            paramInnerHash = {}
+            paramDataHash = {}
+            paramDataHash["id"] = roleID
+            paramDataHash["name"] = @defaultRole
+            paramDataHash["assets"] = assetHash
+            paramInnerHash[roleID] = paramDataHash
+            paramHash["tiers"] = paramInnerHash
+        end
+
+        comment = "Updating role asset mapping"
+        updateEnvironment(environmentID, paramHash, comment)
+    end
+
+    # ###
+    # ### 
+    # ### @param String environmentID
+    # ### @param array  key value pairs to be updated to environment details
+    # ###
+    def updateVariables(environmentID, envVariables)
+        if environmentID.nil? then
+            log("DEBUG", "Environment id value is needed for variables update on an environment")
+        else
+            variablesHash = {}
+            variablesHash["variables"] = envVariables
+            comment = "Updating variables"
+            updateEnvironment(environmentID, variablesHash, comment)
+        end
+    end
+
+    # ###
+    # ###
+    # ### @param String Environment ID
+    # ### @param String Environment status
+    # ###
+    def updateStatus(environmentID, status)
+        statusArray = [::STATUS_CREATION_IN_PROGRESS, ::STATUS_RUNNING, ::STATUS_STOPPED, ::STATUS_STOPPED_WITH_ERRORS, ::STATUS_RUNNING_WITH_WARNINGS, ::STATUS_ACTION_IN_PROGRESS]
+        if !statusArray.include?(status) then
+            log("ERROR", "Invalid status, valid values are " + ::STATUS_CREATION_IN_PROGRESS + "," + ::STATUS_RUNNING + "," + ::STATUS_STOPPED + "," + ::STATUS_STOPPED_WITH_ERRORS + "," + ::STATUS_RUNNING_WITH_WARNINGS + "," + ::STATUS_ACTION_IN_PROGRESS) 
+            return false
+        end
+
+        statusHash = {}
+        statusHash["status"] = status
+        updateEnvironment(environmentID, statusHash)
+    end
+
+    # ###
+    # ### Checks if Environment exists in cloudmunch.
+    # ### @param string $environmentID
+    # ### @return boolean
+    # ###
+    def checkIfEnvironmentExists(environmentID)
+        serverUrl = @appContext.getMasterURL() + "/applications/" + @appContext.getProject() + "/environments/" + environmentID
+
+        envResult = @cloudmunchDataService.getDataForContext(serverUrl, @appContext.getAPIKey(), "")
+        if envResult == nil then  
+            log("DEBUG", "Could not retreive data from cloudmunch")
+            return nil
+        else
+            envResult = JSON.parse(envResult)
+            envData = envResult["data"]
+            if envData.nil? then
+                log("ERROR", "Environment does not exist") 
+                return false
+            else
+                return true
+            end
+        end
+    end
+
+
+end