Module: ObjectsResources

Extended by:
Util::Logging
Defined in:
lib/objects_resources.rb

Defined Under Namespace

Classes: Cluster

Constant Summary

Constants included from Util::Logging

Util::Logging::SEV_LABEL, Util::Logging::TRACE

Class Method Summary collapse

Methods included from Util::Logging

logger, logger=

Class Method Details

.get_objects_resources(object_type) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/objects_resources.rb', line 109

def get_objects_resources(object_type)
  object_payload = object_type.downcase.to_s

  case object_payload
  when Enum::KubernetesObjectsEnum::CRON_JOBS.to_s
    @cron_jobs = Discover::Object.get_cron_jobs
    log_individual_payload_items(object_type.to_s, @cron_jobs[:processed])
  when Enum::KubernetesObjectsEnum::DAEMON_SETS.to_s
    @daemon_sets = Discover::Object.get_daemon_sets
    log_individual_payload_items(object_type.to_s, @daemon_sets[:processed])
  when Enum::KubernetesObjectsEnum::DEPLOYMENTS.to_s
    @deployments = Discover::Object.get_deployments
    log_individual_payload_items(object_type.to_s, @deployments[:processed])
  when Enum::KubernetesObjectsEnum::ENDPOINT_SLICES.to_s
    @endpoint_slices = Discover::Object.get_endpoint_slices
    log_individual_payload_items(object_type.to_s, @endpoint_slices[:processed])
  when Enum::KubernetesObjectsEnum::JOBS.to_s
    @jobs = Discover::Object.get_jobs
    log_individual_payload_items(object_type.to_s, @jobs[:processed])
  when Enum::KubernetesObjectsEnum::NODES.to_s
    @nodes = Discover::Object.get_nodes
    log_individual_payload_items(object_type.to_s, @nodes[:processed])
  when Enum::KubernetesObjectsEnum::PODS.to_s
    @pods = Discover::Object.get_pods
    log_individual_payload_items(object_type.to_s, @pods[:processed])
  when Enum::KubernetesObjectsEnum::REPLICA_SETS.to_s
    @replica_sets = Discover::Object.get_replica_sets
    log_individual_payload_items(object_type.to_s, @replica_sets[:processed])
  when Enum::KubernetesObjectsEnum::SERVICES.to_s
    @services = Discover::Object.get_services
    log_individual_payload_items(object_type.to_s, @services[:processed])
  when Enum::KubernetesObjectsEnum::STATEFUL_SETS.to_s
    @stateful_sets = Discover::Object.get_stateful_sets
    log_individual_payload_items(object_type.to_s, @stateful_sets[:processed])
  when Enum::KubernetesObjectsEnum::EVENTS.to_s
    @events = Discover::Object.get_events
    log_individual_payload_items(object_type.to_s, @events[:processed])
  when Enum::KubernetesObjectsEnum::NAMESPACES.to_s
    @namespaces = Discover::Object.get_namespaces
    log_individual_payload_items(object_type.to_s, @namespaces[:processed])
  when Enum::KubernetesObjectsEnum::PERSISTENT_VOLUMES.to_s
    @persistent_volumes = Discover::Object.get_persistent_volumes
    unless @persistent_volumes[:processed].nil?
      log_individual_payload_items(object_type.to_s, @persistent_volumes[:processed])
    end
  when Enum::KubernetesObjectsEnum::PERSISTENT_VOLUME_CLAIMS.to_s
    @persistent_volume_claims = Discover::Object.get_persistent_volume_claims
    unless @persistent_volume_claims[:processed].nil?
      log_individual_payload_items(object_type.to_s, @persistent_volume_claims[:processed])
    end
  else
    logger.error("Object type '#{object_payload}' not supported")
  end
end

.get_objects_resources_helper(cluster_id, cluster_name, app_config) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/objects_resources.rb', line 30

def get_objects_resources_helper(cluster_id, cluster_name, app_config)
  cluster = Cluster.new(cluster_id, cluster_name)

  enable_threading = app_config[:enable_threading]
  if enable_threading
    thread_count = app_config[:thread_count]
    work_queue_size = app_config[:work_queue_size]

    begin
      thread_pool = Concurrent::FixedThreadPool.new(
        Concurrent.processor_count,
        min_threads: thread_count,
        max_threads: thread_count,
        max_queue: work_queue_size,
        fallback_policy: :abort
      )

      logger.debug("Thread count set to '#{thread_count}' for fixed thread pool.")
      logger.debug("Work queue size set to '#{work_queue_size}'.")
    rescue StandardError => e
      logger.warn("Error occurred while creating thread pool. Falling back to sequential execution. Error: #{error}")
      enable_threading = false
    end
  end

  start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)

  begin
    payload_executors = Enum::KubernetesObjectsEnum.constants(false).map do |object_type|
      if Enum::ObjectClientMapingEnum.const_defined? object_type
        if enable_threading == true
          Concurrent::Future.execute({ executor: thread_pool }) do
            get_objects_resources(object_type)
          end
        else
          get_objects_resources(object_type)
        end
      end
    end

    if enable_threading
      payload_executors.map do |executor|
        executor.value! unless executor.nil?
      end
    end
  rescue StandardError => e
    logger.error("Error while fetching object details - #{e}")
    raise
  end

  end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
  logger.debug("Time elapsed in collecting objects: #{(end_time - start_time).round(2)} seconds.")

  kubernetes_objects_processed = Dto::KubernetesObjectsPayLoad.new(
    cluster, @nodes[:processed], @pods[:processed], @services[:processed], @endpoint_slices[:processed],
    @deployments[:processed], @replica_sets[:processed], @daemon_sets[:processed], @cron_jobs[:processed],
    @jobs[:processed], @stateful_sets[:processed], @events[:processed], @namespaces[:processed]
  )

  kubernetes_objects_raw_responses = {
    nodes: @nodes[:raw],
    pods: @pods[:raw],
    services: @services[:raw],
    endpoint_slices: @endpoint_slices[:raw],
    deployments: @deployments[:raw],
    replica_sets: @replica_sets[:raw],
    daemon_sets: @daemon_sets[:raw],
    cron_jobs: @cron_jobs[:raw],
    jobs: @jobs[:raw],
    stateful_sets: @stateful_sets[:raw],
    events: @events[:raw],
    namespaces: @namespaces[:raw],
    persistent_volumes: @persistent_volumes[:raw],
    persistent_volume_claims: @persistent_volume_claims[:raw]
  }

  { processed_objects: kubernetes_objects_processed, raw_response: kubernetes_objects_raw_responses }
end

.log_individual_payload_items(object_name, arr) ⇒ Object 



164
165
166
167
168
169
170
171
172
173
 
# File 'lib/objects_resources.rb', line 164

def log_individual_payload_items(object_name, arr)
  logger.info("Total count of '#{object_name}': #{arr.length}")

  return if arr.empty?

  logger.trace("Iterating over each '#{object_name}'.")
  arr.each do |item|
    logger.trace("#{object_name}: #{item.to_h.to_json}")
  end
end