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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
# vim: expandtab:tabstop=4:shiftwidth=4
#
# disable pylint checks
# permanently disabled unless someone wants to refactor the object model:
# too-few-public-methods
# no-self-use
# too-many-arguments
# too-many-locals
# too-many-branches
# pylint:disable=too-many-arguments, no-self-use
# pylint:disable=too-many-locals, too-many-branches, too-few-public-methods
"""Ansible module to register a kubernetes node to the cluster"""
import os
DOCUMENTATION = '''
---
module: kubernetes_register_node
short_description: Registers a kubernetes node with a master
description:
- Registers a kubernetes node with a master
options:
name:
default: null
description:
- Identifier for this node (usually the node fqdn).
required: true
api_verison:
choices: ['v1beta1', 'v1beta3']
default: 'v1beta1'
description:
- Kubernetes API version to use
required: true
host_ip:
default: null
description:
- IP Address to associate with the node when registering.
Available in the following API versions: v1beta1.
required: false
cpu:
default: null
description:
- Number of CPUs to allocate for this node. When using the v1beta1
API, you must specify the CPU count as a floating point number
with no more than 3 decimal places. API version v1beta3 and newer
accepts arbitrary float values.
required: false
memory:
default: null
description:
- Memory available for this node. When using the v1beta1 API, you
must specify the memory size in bytes. API version v1beta3 and
newer accepts binary SI and decimal SI values.
required: false
'''
EXAMPLES = '''
# Minimal node registration
- openshift_register_node: name=ose3.node.example.com
# Node registration using the v1beta1 API and assigning 1 CPU core and 10 GB of
# Memory
- openshift_register_node:
name: ose3.node.example.com
api_version: v1beta1
hostIP: 192.168.1.1
cpu: 1
memory: 500000000
'''
class ClientConfigException(Exception):
"""Client Configuration Exception"""
pass
class ClientConfig(object):
""" Representation of a client config
Attributes:
config (dict): dictionary representing the client configuration
Args:
client_opts (list of str): client options to use
module (AnsibleModule):
Raises:
ClientConfigException:
"""
def __init__(self, client_opts, module):
kubectl = module.params['kubectl_cmd']
_, output, _ = module.run_command((kubectl +
["config", "view", "-o", "json"] +
client_opts), check_rc=True)
self.config = json.loads(output)
if not (bool(self.config['clusters']) or
bool(self.config['contexts']) or
bool(self.config['current-context']) or
bool(self.config['users'])):
raise ClientConfigException(
"Client config missing required values: %s" % output
)
def current_context(self):
""" Gets the current context for the client config
Returns:
str: The current context as set in the config
"""
return self.config['current-context']
def section_has_value(self, section_name, value):
""" Test if specified section contains a value
Args:
section_name (str): config section to test
value (str): value to test if present
Returns:
bool: True if successful, false otherwise
"""
section = self.config[section_name]
if isinstance(section, dict):
return value in section
else:
val = next((item for item in section
if item['name'] == value), None)
return val is not None
def has_context(self, context):
""" Test if specified context exists in config
Args:
context (str): value to test if present
Returns:
bool: True if successful, false otherwise
"""
return self.section_has_value('contexts', context)
def has_user(self, user):
""" Test if specified user exists in config
Args:
context (str): value to test if present
Returns:
bool: True if successful, false otherwise
"""
return self.section_has_value('users', user)
def has_cluster(self, cluster):
""" Test if specified cluster exists in config
Args:
context (str): value to test if present
Returns:
bool: True if successful, false otherwise
"""
return self.section_has_value('clusters', cluster)
def get_value_for_context(self, context, attribute):
""" Get the value of attribute in context
Args:
context (str): context to search
attribute (str): attribute wanted
Returns:
str: The value for attribute in context
"""
contexts = self.config['contexts']
if isinstance(contexts, dict):
return contexts[context][attribute]
else:
return next((c['context'][attribute] for c in contexts
if c['name'] == context), None)
def get_user_for_context(self, context):
""" Get the user attribute in context
Args:
context (str): context to search
Returns:
str: The value for the attribute in context
"""
return self.get_value_for_context(context, 'user')
def get_cluster_for_context(self, context):
""" Get the cluster attribute in context
Args:
context (str): context to search
Returns:
str: The value for the attribute in context
"""
return self.get_value_for_context(context, 'cluster')
def get_namespace_for_context(self, context):
""" Get the namespace attribute in context
Args:
context (str): context to search
Returns:
str: The value for the attribute in context
"""
return self.get_value_for_context(context, 'namespace')
class Util(object):
"""Utility methods"""
@staticmethod
def remove_empty_elements(mapping):
""" Recursively removes empty elements from a dict
Args:
mapping (dict): dict to remove empty attributes from
Returns:
dict: A copy of the dict with empty elements removed
"""
if isinstance(mapping, dict):
copy = mapping.copy()
for key, val in mapping.iteritems():
if not val:
del copy[key]
return copy
else:
return mapping
class NodeResources(object):
""" Kubernetes Node Resources
Attributes:
resources (dict): A dictionary representing the node resources
Args:
version (str): kubernetes api version
cpu (str): string representation of the cpu resources for the node
memory (str): string representation of the memory resources for the
node
"""
def __init__(self, version, cpu=None, memory=None):
if version == 'v1beta1':
self.resources = dict(capacity=dict())
self.resources['capacity']['cpu'] = cpu
self.resources['capacity']['memory'] = memory
def get_resources(self):
""" Get the dict representing the node resources
Returns:
dict: representation of the node resources with any empty
elements removed
"""
return Util.remove_empty_elements(self.resources)
class NodeSpec(object):
""" Kubernetes Node Spec
Attributes:
spec (dict): A dictionary representing the node resources
Args:
version (str): kubernetes api version
cpu (str): string representation of the cpu resources for the node
memory (str): string representation of the memory resources for the
node
cidr (str): string representation of the cidr block available for
the node
externalID (str): The external id of the node
"""
def __init__(self, version, cpu=None, memory=None, cidr=None,
externalID=None):
if version == 'v1beta3':
self.spec = dict(podCIDR=cidr, externalID=externalID,
capacity=dict())
self.spec['capacity']['cpu'] = cpu
self.spec['capacity']['memory'] = memory
def get_spec(self):
""" Get the dict representing the node spec
Returns:
dict: representation of the node spec with any empty elements
removed
"""
return Util.remove_empty_elements(self.spec)
class Node(object):
""" Kubernetes Node
Attributes:
node (dict): A dictionary representing the node
Args:
module (AnsibleModule):
client_opts (list): client connection options
version (str, optional): kubernetes api version
node_name (str, optional): name for node
hostIP (str, optional): node host ip
cpu (str, optional): cpu resources for the node
memory (str, optional): memory resources for the node
labels (list, optional): labels for the node
annotations (list, optional): annotations for the node
podCIDR (list, optional): cidr block to use for pods
externalID (str, optional): external id of the node
"""
def __init__(self, module, client_opts, version='v1beta1', node_name=None,
hostIP=None, cpu=None, memory=None, labels=None,
annotations=None, podCIDR=None, externalID=None):
self.module = module
self.client_opts = client_opts
if version == 'v1beta1':
self.node = dict(id=node_name,
kind='Node',
apiVersion=version,
hostIP=hostIP,
resources=NodeResources(version, cpu, memory),
cidr=podCIDR,
labels=labels,
annotations=annotations,
externalID=externalID)
elif version == 'v1beta3':
metadata = dict(name=node_name,
labels=labels,
annotations=annotations)
self.node = dict(kind='Node',
apiVersion=version,
metadata=metadata,
spec=NodeSpec(version, cpu, memory, podCIDR,
externalID))
def get_name(self):
""" Get the name for the node
Returns:
str: node name
"""
if self.node['apiVersion'] == 'v1beta1':
return self.node['id']
elif self.node['apiVersion'] == 'v1beta3':
return self.node['metadata']['name']
def get_node(self):
""" Get the dict representing the node
Returns:
dict: representation of the node with any empty elements
removed
"""
node = self.node.copy()
if self.node['apiVersion'] == 'v1beta1':
node['resources'] = self.node['resources'].get_resources()
elif self.node['apiVersion'] == 'v1beta3':
node['spec'] = self.node['spec'].get_spec()
return Util.remove_empty_elements(node)
def exists(self):
""" Tests if the node already exists
Returns:
bool: True if node exists, otherwise False
"""
kubectl = self.module.params['kubectl_cmd']
_, output, _ = self.module.run_command((kubectl + ["get", "nodes"] +
self.client_opts),
check_rc=True)
if re.search(self.module.params['name'], output, re.MULTILINE):
return True
return False
def create(self):
""" Creates the node
Returns:
bool: True if node creation successful
"""
kubectl = self.module.params['kubectl_cmd']
cmd = kubectl + self.client_opts + ['create', '-f', '-']
exit_code, output, error = self.module.run_command(
cmd, data=self.module.jsonify(self.get_node())
)
if exit_code != 0:
if re.search("minion \"%s\" already exists" % self.get_name(),
error):
self.module.exit_json(msg="node definition already exists",
changed=False, node=self.get_node())
else:
self.module.fail_json(msg="Node creation failed.",
exit_code=exit_code,
output=output, error=error,
node=self.get_node())
else:
return True
def generate_client_opts(module):
""" Generates the client options
Args:
module(AnsibleModule)
Returns:
str: client options
"""
client_config = '~/.kube/.kubeconfig'
if 'default_client_config' in module.params:
client_config = module.params['default_client_config']
user_has_client_config = os.path.exists(os.path.expanduser(client_config))
if not (user_has_client_config or module.params['client_config']):
module.fail_json(msg="Could not locate client configuration, "
"client_config must be specified if "
"~/.kube/.kubeconfig is not present")
client_opts = []
if module.params['client_config']:
kubeconfig_flag = '--kubeconfig'
if 'kubeconfig_flag' in module.params:
kubeconfig_flag = module.params['kubeconfig_flag']
client_opts.append(kubeconfig_flag + '=' + os.path.expanduser(module.params['client_config']))
try:
config = ClientConfig(client_opts, module)
except ClientConfigException as ex:
module.fail_json(msg="Failed to get client configuration",
exception=str(ex))
client_context = module.params['client_context']
if config.has_context(client_context):
if client_context != config.current_context():
client_opts.append("--context=%s" % client_context)
else:
module.fail_json(msg="Context %s not found in client config" % client_context)
client_user = module.params['client_user']
if config.has_user(client_user):
if client_user != config.get_user_for_context(client_context):
client_opts.append("--user=%s" % client_user)
else:
module.fail_json(msg="User %s not found in client config" % client_user)
client_cluster = module.params['client_cluster']
if config.has_cluster(client_cluster):
if client_cluster != config.get_cluster_for_context(client_context):
client_opts.append("--cluster=%s" % client_cluster)
else:
module.fail_json(msg="Cluster %s not found in client config" % client_cluster)
client_namespace = module.params['client_namespace']
if client_namespace != config.get_namespace_for_context(client_context):
client_opts.append("--namespace=%s" % client_namespace)
return client_opts
def main():
""" main """
module = AnsibleModule(
argument_spec=dict(
name=dict(required=True, type='str'),
host_ip=dict(type='str'),
api_version=dict(type='str', default='v1beta1',
choices=['v1beta1', 'v1beta3']),
cpu=dict(type='str'),
memory=dict(type='str'),
# TODO: needs documented
labels=dict(type='dict', default={}),
# TODO: needs documented
annotations=dict(type='dict', default={}),
# TODO: needs documented
pod_cidr=dict(type='str'),
# TODO: needs documented
client_config=dict(type='str'),
# TODO: needs documented
client_cluster=dict(type='str', default='master'),
# TODO: needs documented
client_context=dict(type='str', default='default'),
# TODO: needs documented
client_namespace=dict(type='str', default='default'),
# TODO: needs documented
client_user=dict(type='str', default='system:admin'),
# TODO: needs documented
kubectl_cmd=dict(type='list', default=['kubectl']),
# TODO: needs documented
kubeconfig_flag=dict(type='str'),
# TODO: needs documented
default_client_config=dict(type='str')
),
supports_check_mode=True
)
labels = module.params['labels']
kube_hostname_label = 'kubernetes.io/hostname'
if kube_hostname_label not in labels:
labels[kube_hostname_label] = module.params['name']
node = Node(module, generate_client_opts(module),
module.params['api_version'], module.params['name'],
module.params['host_ip'], module.params['cpu'],
module.params['memory'], labels, module.params['annotations'],
module.params['pod_cidr'])
if node.exists():
module.exit_json(changed=False, node=node.get_node())
elif module.check_mode:
module.exit_json(changed=True, node=node.get_node())
elif node.create():
module.exit_json(changed=True, msg="Node created successfully",
node=node.get_node())
else:
module.fail_json(msg="Unknown error creating node", node=node.get_node())
# ignore pylint errors related to the module_utils import
# pylint: disable=redefined-builtin, unused-wildcard-import, wildcard-import
# import module snippets
from ansible.module_utils.basic import *
if __name__ == '__main__':
main()
|