Examples

Switch

 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
from mdssdk.switch import Switch

user = "yourswitchusername"
pw = "yourswitchpassword"
ip_address = "yourswitchip"  # 10.197.155.110
p = 8443

# Set connection_type='https' for NXAPI
# Set connection_type='ssh' for SSH
switch_obj = Switch(
    ip_address=ip_address,
    username=user,
    password=pw,
    connection_type="https",
    port=p,
    timeout=30,
    verify_ssl=False,
)

# Displaying switch name, version, image
print("Name: " + switch_obj.name)
print("Version: " + switch_obj.version)
print("Kickstart Image: " + switch_obj.kickstart_image)
print("System Image: " + switch_obj.system_image)

# Changing name of switch
switch_obj.name = "switch_test"
print("Changed Name: " + switch_obj.name)

# Enabling feature analytics
switch_obj.feature("analytics", True)
print("Analytics feature : " + str(switch_obj.feature("analytics")))

Download: ExampleScript

Module

 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
from mdssdk.switch import Switch

user = "yourswitchusername"
pw = "yourswitchpassword"
ip_address = "yourswitchip"  # 10.197.155.110
p = 8443

# Set connection_type='https' for NXAPI
# Set connection_type='ssh' for SSH
switch_obj = Switch(
    ip_address=ip_address,
    username=user,
    password=pw,
    connection_type="https",
    port=p,
    timeout=30,
    verify_ssl=False,
)

# Print the information of all switch modules
mod_handler = switch_obj.modules  # dict of module objects
print(mod_handler)
for m in mod_handler.values():
    print("Model : " + m.model)
    print("Module Number : " + str(m.module_number))
    print("Ports : " + str(m.ports))
    print("Status : " + m.status)
    print("Type : " + m.type)

Download: ExampleScript

Vsan

 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
from mdssdk.switch import Switch
from mdssdk.vsan import Vsan

user = "yourswitchusername"
pw = "yourswitchpassword"
ip_address = "yourswitchip"  # 10.197.155.110
p = 8443

# Set connection_type='https' for NXAPI
# Set connection_type='ssh' for SSH
sw = Switch(
    ip_address=ip_address,
    username=user,
    password=pw,
    connection_type="https",
    port=p,
    timeout=30,
    verify_ssl=False,
)

# Example for creating and deleting 10 vsan objects from id 10 to 19
vsan = []
for i in range(10, 20):
    vsan.append(Vsan(switch=sw, id=i))
print("Vsan ID\tName\tState")
for v in vsan:
    v.create()  # creates vsan on switch
    print(str(v.id) + "\t\t" + v.name + "\t" + v.state)  # print id,name,state
    v.delete()  # deletes vsan

Download: ExampleScript

DeviceAlias

 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
from mdssdk.devicealias import DeviceAlias
from mdssdk.switch import Switch

user = "yourswitchusername"
pw = "yourswitchpassword"
ip_address = "yourswitchip"  # 10.197.155.110
p = 8443

# Set connection_type='https' for NXAPI
# Set connection_type='ssh' for SSH
sw = Switch(
    ip_address=ip_address,
    username=user,
    password=pw,
    connection_type="https",
    port=p,
    timeout=30,
    verify_ssl=False,
)

# Instantiating DeviceAlias object
d = DeviceAlias(sw)

# Display the database, mode, distribute, locked
print("Device Alias Database")
print(d.database)
print("Mode : " + d.mode)
print("Distribute : " + str(d.distribute))
print("Locked : " + str(d.locked))

old = d.database
d.clear_database()

# Adding new device alias
new = {"device1": "21:00:00:0e:1e:30:34:a5", "device2": "21:00:00:0e:1e:30:3c:c5"}
d.create(new)

prnt("Clearing database\nDatabase after adding new entry")
print(d.database)

# Renaming the device alias
d.rename("device1", "device_new_name")

print("Database after renaming device alias device1 as device_new_name")
print(d.database)

# Deleting device alias
d.delete("device_new_name")
d.delete("device2")

# Recreating original database
d.create(old)

Download: ExampleScript

Zone

 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
from mdssdk.switch import Switch
from mdssdk.vsan import Vsan
from mdssdk.zone import Zone

user = "yourswitchusername"
pw = "yourswitchpassword"
ip_address = "yourswitchip"  # 10.197.155.110
p = 8443

# Set connection_type='https' for NXAPI
# Set connection_type='ssh' for SSH
sw = Switch(
    ip_address=ip_address,
    username=user,
    password=pw,
    connection_type="https",
    port=p,
    timeout=30,
    verify_ssl=False,
)

# Instantiating Vsan object with id 2
v = Vsan(sw, 2)

# Creating vsan
v.create()

# Instantiate zone object
z = Zone(sw, "zone1", v.id)

# Create new zone
z.create()

memlist = [
    {"pwwn": "50:08:01:60:08:9f:4d:00"},
    {"ip-address": "1.1.1.1"},
    {"symbolic-nodename": "symbnodename"},
    {"fwwn": "11:12:13:14:15:16:17:18"},
    {"fcid": "0x123456"},
]

# Adding members to zone
z.add_members(memlist)

# Display zone name, vsan id, members
print("Zone name: " + z.name)
print("Vsan id: " + str(z.vsan.id))
print("Zone members: " + str(z.members))

# Removing members from zone
z.remove_members(memlist)

# Deleting zone
z.delete()

# Deleting vsan
v.delete()

Download: ExampleScript

Zoneset

  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
from mdssdk.devicealias import DeviceAlias
from mdssdk.fc import Fc
from mdssdk.portchannel import PortChannel
from mdssdk.switch import Switch
from mdssdk.vsan import Vsan
from mdssdk.zone import Zone
from mdssdk.zoneset import ZoneSet

# Switch credentials
user = "yourswitchusername"
pw = "yourswitchpassword"
ip_address = "yourswitchip"  # 10.197.155.110
p = 8443

# Creating switch object
sw = Switch(
    ip_address=ip_address,
    username=user,
    password=pw,
    connection_type="https",
    port=p,
    timeout=30,
    verify_ssl=False,
)

# Instantiating Vsan object with id 2
v = Vsan(sw, 2)

# Creating vsan
v.create()

# Creating Fc object for interface fc1/3
int13 = Fc(sw, "fc1/3")

# Instantiating PortChannel object 1
pc1 = PortChannel(sw, 1)

# Creating port channel
pc1.create()

# Adding interfaces to vsan 2
v.add_interfaces([int13, pc1])

# Instantiating DeviceAlias object
d = DeviceAlias(sw)
new = {"da1": "60:66:61:01:0e:00:01:ff"}

# Adding new device alias
d.create(new)

# Instantiate zone object
z = Zone(sw, "zone1", v.id)

# Create new zone
z.create()

# Configuring fcalias
sw.config("fcalias name somefcalias vsan " + str(v.id))

memlist = [
    {"pwwn": "50:08:01:60:08:9f:4d:00"},
    {"pwwn": "50:08:01:60:08:9f:4d:01"},
    {"interface": int13.name},
    {"device-alias": "da1"},
    {"ip-address": "1.1.1.1"},
    {"symbolic-nodename": "symbnodename"},
    {"fwwn": "11:12:13:14:15:16:17:18"},
    {"fcid": "0x123456"},
    {"interface": pc1.name},
    {"symbolic-nodename": "testsymnode"},
    {"fcalias": "somefcalias"},
]

# Adding members to zone
z.add_members(memlist)

# Instantiating ZoneSet object
zoneset = ZoneSet(sw, "zoneset1", v.id)

# Creating zoneset
zoneset.create()

# Add members to zoneset
zoneset.add_members([z])

# Activating zoneset
zoneset.activate(True)

# Display zoneset information
print("Zoneset name: " + zoneset.name)
print("Vsan id: " + str(zoneset.vsan.id))
print("Zoneset members: " + str(zoneset.members))
print("Activation: " + zonese.is_active())

# Removing members from zoneset
zoneset.remove_members([z])

# Deleting zoneset
zoneset.delete()

# Removing members from zone
z.remove_members(memlist)

# Deleting zone
z.delete()

# Deleting vsan
v.delete()

# Deleting device alias
d.delete("da1")

# Deleting port channel
pc1.delete()

Download: ExampleScript

Multiprocessing

 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
# An example to show how we can do multiprocessing to execute some logic on multiple switches parallelly

from mdssdk.switch import Switch
from concurrent.futures import wait
from concurrent.futures.thread import ThreadPoolExecutor
import multiprocessing

user = "your_switch_username"
pw = "your_switch_password"
iplist = ["ip1", "ip2"]
p = 8443

myData = {}


def runAnySwitchLogic(ip, user, pw, port):
    my_switch = Switch(ip, user, pw, "https", port=port, verify_ssl=False)
    status = isCFSoIpEnabled(my_switch)
    myData[my_switch.name] = status


def isCFSoIpEnabled(sw):
    cmd = "show cfs status"
    # ensures that the output is in cli output format
    out = sw.show(cmd, raw_text=True)
    if "Distribution over IP : Disabled" in out:
        return "Disabled"
    return "Enabled"


m = multiprocessing.Manager()
allfutures = []
executor = ThreadPoolExecutor(len(iplist))
IP_list = []
CFS_list = []

for i in range(0, len(iplist)):
    ip = iplist[i]
    fut = executor.submit(runAnySwitchLogic, ip, user, pw, p)
    allfutures.append(fut)
wait(allfutures)

for swname, cfsstatus in myData.items():
    print('CFS Distribution over IP on switch', swname, 'is', cfsstatus)

Download: ExampleScript