discover

in source/code/plugins/in_wlm_discovery.rb [43:151]

• 102 lines of code
• 13 McCabe index (conditional complexity)

    def discover
      is_azure_vm = get_vm_metadata()
      if is_azure_vm
        omi_lib = WLM::WLMOMIDiscoveryCollector.new(@omi_mapping_path)
        discovery_data = omi_lib.get_discovery_data()
        wlm_formatter = WLM::WLMDataFormatter.new(@wlm_class_file)
        discovery_data.each do |wclass|
          if wclass["class_name"].to_s == "Universal Linux Computer"
            wclass["discovery_data"][0]["CSName"] = OMS::Common.get_fully_qualified_domain_name
          end
          discovery_xml = wlm_formatter.get_discovery_xml(wclass)
          instance = {}
          instance["Host"] = OMS::Common.get_fully_qualified_domain_name
          instance["OSType"] = "Linux"
          instance["ObjectName"] = wclass["class_name"]
          instance["EncodedDataItem"] = Base64.strict_encode64(discovery_xml)
          wrapper = {
            "DataType"=>"WLM_LINUX_INSTANCE_DATA_BLOB",
            "IPName"=>"InfrastructureInsights",
            "DataItems"=>[instance]
          }
          router.emit("oms.wlm.discovery", Time.now.to_f, wrapper)
        end 
        update_discovery_time(Time.now.to_i)
        $log.debug "Discovery data for #{@omi_mapping_path} generated successfully"
      end
    end 

    def run_periodic
      begin
        timeout_value = @default_timeout
        last_discovery_time = Time.at(get_last_discovery_time.to_i)
        if(last_discovery_time.to_i > 0)
          next_discovery_time = last_discovery_time + @default_timeout
          current_time = Time.now
          if(current_time >= next_discovery_time)
            discover
          else
            timeout_value = next_discovery_time - current_time
          end 
        else
          discover
        end 
        @mutex.lock
        done = @finished
        until done
          $log.debug "#{timeout_value} seconds befor next discovery"
          @condition.wait(@mutex, timeout_value)
          timeout_value = @default_timeout
          done = @finished
          @mutex.unlock
          if !done
            discover
          end
          @mutex.lock
        end 
        @mutex.unlock
        rescue => e
          $log.error "Error generating discovery data #{e}"
        end 
    end 

    def update_discovery_time(time)
      begin
        time_file = File.open(@discovery_time_file, "w")
        time_file.write(time.to_s)
      rescue => e
        $log.debug "Error updating last discovery time #{e}"
      ensure
        time_file.close unless time_file.nil?
      end 
    end 

    def get_last_discovery_time()
      begin
        last_discovery_time = File.open(@discovery_time_file, &:readline)
        return last_discovery_time.strip()
      rescue => e
        $log.debug "Error reading last discovery time #{e}"
        return ""
      end 
    end 

    def get_vm_metadata()
      begin
        url_metadata="http://169.254.169.254/metadata/instance?api-version=#{@metadata_api_version}"
        metadata_json = open(url_metadata,"Metadata"=>"true").read
        metadata_instance = { 
          "EncodedVMMetadata" => Base64.strict_encode64(metadata_json),
          "Hostname" => OMS::Common.get_fully_qualified_domain_name,
          "ApiVersion" => @metadata_api_version
        }
        wrapper = {
          "DataType"=>"WLM_LINUX_VM_METADATA_BLOB",
          "IPName"=>"InfrastructureInsights",
          "DataItems"=>[metadata_instance]
        }
        router.emit("oms.wlm.vm.metadata", Time.now.to_f, wrapper)
      rescue => e
        $log.error "Error sending VM metadata #{e}"
        return false
      end 
      return true
    end 

  end 

end