Module: K8s::Util

Defined in:
lib/k8s/util.rb

Overview

Miscellaneous helpers

Defined Under Namespace

Modules: HashDeepMerge

Constant Summary collapse

PATH_TR_MAP = 
{ '~' => '~0', '/' => '~1' }.freeze
PATH_REGEX = 
%r{(/|~(?!1))}.freeze

Class Method Summary collapse

Class Method Details

.compact_map(args) {|args| ... } ⇒ Array<nil, Object>

Yield with all non-nil args, returning matching array with corresponding return values or nils.

Args must be usable as hash keys. Duplicate args will all map to the same return value.

Parameters:

  • args (Array<nil, Object>)

Yields:

  • args

Yield Parameters:

  • args (Array<Object>) —

    omitting any nil values

Returns:

  • (Array<nil, Object>) —

    matching args array 1:1, containing yielded values for non-nil args



69
70
71
72
73
74
75
76
77
78
 
# File 'lib/k8s/util.rb', line 69

def self.compact_map(args)
  func_args = args.compact

  values = yield func_args

  # Hash{arg => value}
  value_map = Hash[func_args.zip(values)]

  args.map{ |arg| value_map[arg] }
end

.json_patch(patch_to, patch_from) ⇒ Object

Produces a set of json-patch operations so that applying the operations on a, gives you the results of b Used in correctly patching the Kube resources on stack updates

Parameters:

  • patch_to (Hash) —

    Hash to compute patches against

  • patch_from (Hash) —

    New Hash to compute patches “from”



100
101
102
103
104
105
106
107
108
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
 
# File 'lib/k8s/util.rb', line 100

def self.json_patch(patch_to, patch_from)
  diffs = Hashdiff.diff(patch_to, patch_from, array_path: true)
  ops = []
  # Each diff is like:
  # ["+", ["spec", "selector", "food"], "kebab"]
  # ["-", ["spec", "selector", "drink"], "pepsi"]
  # or
  # ["~", ["spec", "selector", "drink"], "old value", "new value"]
  # the path elements can be symbols too, depending on the input hashes
  diffs.each do |diff|
    operator = diff[0]
    # substitute '/' with '~1' and '~' with '~0'
    # according to RFC 6901
    path = diff[1].map { |p| p.to_s.gsub(PATH_REGEX, PATH_TR_MAP) }
    if operator == '-'
      ops << {
        op: "remove",
        path: "/" + path.join('/')
      }
    elsif operator == '+'
      ops << {
        op: "add",
        path: "/" + path.join('/'),
        value: diff[2]
      }
    elsif operator == '~'
      ops << {
        op: "replace",
        path: "/" + path.join('/'),
        value: diff[3]
      }
    else
      raise "Unknown diff operator: #{operator}!"
    end
  end

  ops
end

.recursive_compact(hash_or_array) ⇒ Hash, Array

Recursive compact for Hash/Array

Parameters:

  • hash_or_array (Hash, Array)

Returns:

  • (Hash, Array) 


84
85
86
87
88
89
90
91
92
 
# File 'lib/k8s/util.rb', line 84

def self.recursive_compact(hash_or_array)
  p = proc do |*args|
    v = args.last
    v.delete_if(&p) if v.respond_to?(:delete_if) && !v.is_a?(Array)
    v.nil? || v.respond_to?(:empty?) && (v.empty? && (v.is_a?(Hash) || v.is_a?(Array)))
  end

  hash_or_array.delete_if(&p)
end