File: rabbitmq_policy.rb

package info (click to toggle)
puppet-module-puppetlabs-rabbitmq 8.5.0-7
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 1,140 kB
  • sloc: ruby: 5,223; sh: 10; makefile: 4
file content (163 lines) | stat: -rw-r--r-- 4,884 bytes parent folder | download | duplicates (5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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
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
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
163
Puppet::Type.newtype(:rabbitmq_policy) do
  desc <<-DESC
Type for managing rabbitmq policies

@example Create a rabbitmq_policy
 rabbitmq_policy { 'ha-all@myvhost':
   pattern    => '.*',
   priority   => 0,
   applyto    => 'all',
   definition => {
     'ha-mode'      => 'all',
     'ha-sync-mode' => 'automatic',
   },
 }
DESC

  ensurable do
    defaultto(:present)
    newvalue(:present) do
      provider.create
    end
    newvalue(:absent) do
      provider.destroy
    end
  end

  autorequire(:service) { 'rabbitmq-server' }

  validate do
    raise('pattern parameter is required.') if self[:ensure] == :present && self[:pattern].nil?
    raise('definition parameter is required.') if self[:ensure] == :present && self[:definition].nil?
  end

  newparam(:name, namevar: true) do
    desc 'combination of policy@vhost to create policy for'
    newvalues(%r{^\S+@\S+$})
  end

  newproperty(:pattern) do
    desc 'policy pattern'
    validate do |value|
      resource.validate_pattern(value)
    end
  end

  newproperty(:applyto) do
    desc 'policy apply to'
    newvalue(:all)
    newvalue(:exchanges)
    newvalue(:queues)
    defaultto :all
  end

  newproperty(:definition) do
    desc 'policy definition'
    validate do |value|
      resource.validate_definition(value)
    end
    munge do |value|
      resource.munge_definition(value)
    end
  end

  newproperty(:priority) do
    desc 'policy priority'
    newvalues(%r{^\d+$})
    defaultto 0
  end

  autorequire(:rabbitmq_vhost) do
    [self[:name].split('@')[1]]
  end

  def validate_pattern(value)
    Regexp.new(value)
  rescue RegexpError
    raise ArgumentError, "Invalid regexp #{value}"
  end

  def validate_definition(definition)
    unless [Hash].include?(definition.class)
      raise ArgumentError, 'Invalid definition'
    end
    definition.each do |k, v|
      if k == 'ha-params' && definition['ha-mode'] == 'nodes'
        unless [Array].include?(v.class)
          raise ArgumentError, "Invalid definition, value #{v} for key #{k} is not an array"
        end
      else
        unless [String].include?(v.class)
          raise ArgumentError, "Invalid definition, value #{v} is not a string"
        end
      end
    end
    if definition['ha-mode'] == 'exactly'
      ha_params = definition['ha-params']
      unless ha_params.to_i.to_s == ha_params
        raise ArgumentError, "Invalid ha-params '#{ha_params}' for ha-mode 'exactly'"
      end
    end
    if definition.key? 'expires'
      expires_val = definition['expires']
      unless expires_val.to_i.to_s == expires_val
        raise ArgumentError, "Invalid expires value '#{expires_val}'"
      end
    end
    if definition.key? 'message-ttl'
      message_ttl_val = definition['message-ttl']
      unless message_ttl_val.to_i.to_s == message_ttl_val
        raise ArgumentError, "Invalid message-ttl value '#{message_ttl_val}'"
      end
    end
    if definition.key? 'max-length'
      max_length_val = definition['max-length']
      unless max_length_val.to_i.to_s == max_length_val
        raise ArgumentError, "Invalid max-length value '#{max_length_val}'"
      end
    end
    if definition.key? 'max-length-bytes'
      max_length_bytes_val = definition['max-length-bytes']
      unless max_length_bytes_val.to_i.to_s == max_length_bytes_val
        raise ArgumentError, "Invalid max-length-bytes value '#{max_length_bytes_val}'"
      end
    end
    if definition.key? 'shards-per-node'
      shards_per_node_val = definition['shards-per-node']
      unless shards_per_node_val.to_i.to_s == shards_per_node_val
        raise ArgumentError, "Invalid shards-per-node value '#{shards_per_node_val}'"
      end
    end
    if definition.key? 'ha-sync-batch-size' # rubocop:disable Style/GuardClause
      ha_sync_batch_size_val = definition['ha-sync-batch-size']
      unless ha_sync_batch_size_val.to_i.to_s == ha_sync_batch_size_val
        raise ArgumentError, "Invalid ha-sync-batch-size value '#{ha_sync_batch_size_val}'"
      end
    end
  end

  def munge_definition(definition)
    if definition['ha-mode'] == 'exactly'
      definition['ha-params'] = definition['ha-params'].to_i
    end
    if definition.key? 'expires'
      definition['expires'] = definition['expires'].to_i
    end
    if definition.key? 'message-ttl'
      definition['message-ttl'] = definition['message-ttl'].to_i
    end
    if definition.key? 'max-length'
      definition['max-length'] = definition['max-length'].to_i
    end
    if definition.key? 'max-length-bytes'
      definition['max-length-bytes'] = definition['max-length-bytes'].to_i
    end
    if definition.key? 'shards-per-node'
      definition['shards-per-node'] = definition['shards-per-node'].to_i
    end
    if definition.key? 'ha-sync-batch-size'
      definition['ha-sync-batch-size'] = definition['ha-sync-batch-size'].to_i
    end
    definition
  end
end