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
|
#!/usr/bin/python
""" PN CLI vlag-create/vlag-delete/vlag-modify """
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
#
import shlex
ANSIBLE_METADATA = {'status': ['preview'],
'supported_by': 'community',
'version': '1.0'}
DOCUMENTATION = """
---
module: pn_vlag
author: "Pluribus Networks (@amitsi)"
version_added: "2.2"
version: 1.0
short_description: CLI command to create/delete/modify vlag.
description:
- Execute vlag-create/vlag-delete/vlag-modify command.
- A virtual link aggregation group (VLAG) allows links that are physically
connected to two different Pluribus Networks devices to appear as a single
trunk to a third device. The third device can be a switch, server, or any
Ethernet device. A VLAG can provide Layer 2 multipathing, which allows you
to create redundancy by increasing bandwidth, enabling multiple parallel
paths between nodes and loadbalancing traffic where alternative paths exist.
options:
pn_cliusername:
description:
- Provide login username if user is not root.
required: False
pn_clipassword:
description:
- Provide login password if user is not root.
required: False
pn_cliswitch:
description:
- Target switch(es) to run this command on.
state:
description:
- State the action to perform. Use 'present' to create vlag,
'absent' to delete vlag and 'update' to modify vlag.
required: True
choices: ['present', 'absent', 'update']
pn_name:
description:
- The C(pn_name) takes a valid name for vlag configuration.
required: true
pn_port:
description:
- Specify the local VLAG port.
- Required for vlag-create.
pn_peer_port:
description:
- Specify the peer VLAG port.
- Required for vlag-create.
pn_mode:
description:
- Specify the mode for the VLAG. Active-standby indicates one side is
active and the other side is in standby mode. Active-active indicates
that both sides of the vlag are up by default.
choices: ['active-active', 'active-standby']
pn_peer_switch:
description:
- Specify the fabric-name of the peer switch.
pn_failover_action:
description:
- Specify the failover action as move or ignore.
choices: ['move', 'ignore']
pn_lacp_mode:
description:
- Specify the LACP mode.
choices: ['off', 'passive', 'active']
pn_lacp_timeout:
description:
- Specify the LACP timeout as slow(30 seconds) or fast(4 seconds).
choices: ['slow', 'fast']
pn_lacp_fallback:
description:
- Specify the LACP fallback mode as bundles or individual.
choices: ['bundle', 'individual']
pn_lacp_fallback_timeout:
description:
- Specify the LACP fallback timeout in seconds. The range is between 30
and 60 seconds with a default value of 50 seconds.
"""
EXAMPLES = """
- name: create a VLAG
pn_vlag:
state: 'present'
pn_name: spine-to-leaf
pn_port: 'spine01-to-leaf'
pn_peer_port: 'spine02-to-leaf'
pn_peer_switch: spine02
pn_mode: 'active-active'
- name: delete VLAGs
pn_vlag:
state: 'absent'
pn_name: spine-to-leaf
"""
RETURN = """
command:
description: The CLI command run on the target node(s).
stdout:
description: The set of responses from the vlag command.
returned: always
type: list
stderr:
description: The set of error responses from the vlag command.
returned: on error
type: list
changed:
description: Indicates whether the CLI caused changes on the target.
returned: always
type: bool
"""
VLAG_EXISTS = None
def pn_cli(module):
"""
This method is to generate the cli portion to launch the Netvisor cli.
It parses the username, password, switch parameters from module.
:param module: The Ansible module to fetch username, password and switch
:return: returns the cli string for further processing
"""
username = module.params['pn_cliusername']
password = module.params['pn_clipassword']
cliswitch = module.params['pn_cliswitch']
if username and password:
cli = '/usr/bin/cli --quiet --user %s:%s ' % (username, password)
else:
cli = '/usr/bin/cli --quiet '
if cliswitch == 'local':
cli += ' switch-local '
else:
cli += ' switch ' + cliswitch
return cli
def check_cli(module, cli):
"""
This method checks for idempotency using the vlag-show command.
If a vlag with given vlag exists, return VLAG_EXISTS as True else False.
:param module: The Ansible module to fetch input parameters
:param cli: The CLI string
:return Global Booleans: VLAG_EXISTS
"""
name = module.params['pn_name']
show = cli + ' vlag-show format name no-show-headers'
show = shlex.split(show)
out = module.run_command(show)[1]
out = out.split()
# Global flags
global VLAG_EXISTS
if name in out:
VLAG_EXISTS = True
else:
VLAG_EXISTS = False
def run_cli(module, cli):
"""
This method executes the cli command on the target node(s) and returns the
output. The module then exits based on the output.
:param cli: the complete cli string to be executed on the target node(s).
:param module: The Ansible module to fetch command
"""
cliswitch = module.params['pn_cliswitch']
state = module.params['state']
command = get_command_from_state(state)
cmd = shlex.split(cli)
# 'out' contains the output
# 'err' contains the error messages
result, out, err = module.run_command(cmd)
print_cli = cli.split(cliswitch)[1]
# Response in JSON format
if result != 0:
module.exit_json(
command=print_cli,
stderr=err.strip(),
msg="%s operation failed" % command,
changed=False
)
if out:
module.exit_json(
command=print_cli,
stdout=out.strip(),
msg="%s operation completed" % command,
changed=True
)
else:
module.exit_json(
command=print_cli,
msg="%s operation completed" % command,
changed=True
)
def get_command_from_state(state):
"""
This method gets appropriate command name for the state specified. It
returns the command name for the specified state.
:param state: The state for which the respective command name is required.
"""
command = None
if state == 'present':
command = 'vlag-create'
if state == 'absent':
command = 'vlag-delete'
if state == 'update':
command = 'vlag-modify'
return command
def main():
""" This section is for argument parsing """
module = AnsibleModule(
argument_spec=dict(
pn_cliusername=dict(required=False, type='str'),
pn_clipassword=dict(required=False, type='str', no_log=True),
pn_cliswitch=dict(required=False, type='str', default='local'),
state =dict(required=True, type='str',
choices=['present', 'absent', 'update']),
pn_name=dict(required=True, type='str'),
pn_port=dict(type='str'),
pn_peer_port=dict(type='str'),
pn_mode=dict(type='str', choices=[
'active-standby', 'active-active']),
pn_peer_switch=dict(type='str'),
pn_failover_action=dict(type='str', choices=['move', 'ignore']),
pn_lacp_mode=dict(type='str', choices=[
'off', 'passive', 'active']),
pn_lacp_timeout=dict(type='str', choices=['slow', 'fast']),
pn_lacp_fallback=dict(type='str', choices=[
'individual', 'bundled']),
pn_lacp_fallback_timeout=dict(type='str')
),
required_if=(
["state", "present", ["pn_name", "pn_port", "pn_peer_port",
"pn_peer_switch"]],
["state", "absent", ["pn_name"]],
["state", "update", ["pn_name"]]
)
)
# Argument accessing
state = module.params['state']
name = module.params['pn_name']
port = module.params['pn_port']
peer_port = module.params['pn_peer_port']
mode = module.params['pn_mode']
peer_switch = module.params['pn_peer_switch']
failover_action = module.params['pn_failover_action']
lacp_mode = module.params['pn_lacp_mode']
lacp_timeout = module.params['pn_lacp_timeout']
lacp_fallback = module.params['pn_lacp_fallback']
lacp_fallback_timeout = module.params['pn_lacp_fallback_timeout']
command = get_command_from_state(state)
# Building the CLI command string
cli = pn_cli(module)
if command == 'vlag-delete':
check_cli(module, cli)
if VLAG_EXISTS is False:
module.exit_json(
skipped=True,
msg='VLAG with name %s does not exist' % name
)
cli += ' %s name %s ' % (command, name)
else:
if command == 'vlag-create':
check_cli(module, cli)
if VLAG_EXISTS is True:
module.exit_json(
skipped=True,
msg='VLAG with name %s already exists' % name
)
cli += ' %s name %s ' % (command, name)
if port:
cli += ' port %s peer-port %s ' % (port, peer_port)
if mode:
cli += ' mode ' + mode
if peer_switch:
cli += ' peer-switch ' + peer_switch
if failover_action:
cli += ' failover-' + failover_action + '-L2 '
if lacp_mode:
cli += ' lacp-mode ' + lacp_mode
if lacp_timeout:
cli += ' lacp-timeout ' + lacp_timeout
if lacp_fallback:
cli += ' lacp-fallback ' + lacp_fallback
if lacp_fallback_timeout:
cli += ' lacp-fallback-timeout ' + lacp_fallback_timeout
run_cli(module, cli)
# AnsibleModule boilerplate
from ansible.module_utils.basic import AnsibleModule
if __name__ == '__main__':
main()
|