Add documentation and files related to initial host setup
[csit.git] / resources / tools / testbed-setup / cimc / cimclib.py
1 #!/usr/bin/python
2 #
3 # Copyright (c) 2016 Cisco and/or its affiliates.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at:
7 #
8 #     http://www.apache.org/licenses/LICENSE-2.0
9 #
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
15
16 import requests
17 import xml.etree.ElementTree as et
18 import re
19
20 from requests.packages.urllib3.exceptions import InsecureRequestWarning
21 requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
22
23 BASEDN = "sys/rack-unit-1"
24
25 ###
26 ### Helper function - iterate through a list in pairs
27 ###
28 def chunks(lst, chunksize):
29     """Yield successive n-sized chunks from l."""
30     for i in range(0, len(lst), chunksize):
31         yield lst[i:i+chunksize]
32
33 ###
34 ### Helper function: Perform an XML request to CIMC
35 ###
36 def xml_req(ip, xml, debug=False):
37     if debug:
38         print "DEBUG: XML-REQUEST:"
39         et.dump(xml)
40     headers = {'Content-Type': 'text/xml'}
41     req = requests.post('https://' + ip + '/nuova', headers=headers,
42                         verify=False, data=et.tostring(xml))
43     resp = et.fromstring(req.content)
44     if debug:
45         print "DEBUG: XML-RESPONSE:"
46         et.dump(resp)
47
48     if resp.tag == 'error':
49         if debug:
50             print "XML response contains error:"
51             et.dump(error)
52         raise RuntimeError('XML response contains error')
53     return resp
54
55 ###
56 ### Authenticate (Log-In) to CIMC and obtain a cookie
57 ###
58 def login(ip, username, password):
59     reqxml = et.Element('aaaLogin',
60                         attrib={'inName':username, 'inPassword':password})
61     respxml = xml_req(ip, reqxml)
62     try:
63         cookie = respxml.attrib['outCookie']
64     except:
65         print "Cannot find cookie in CIMC server response."
66         print "CIMC server output:"
67         et.dump(respxml)
68         raise
69
70     return cookie
71
72 ###
73 ### Log out from CIMC.
74 ###
75 ### Note: There is a maximum session limit in CIMC and sessions to take a long
76 ### time (10 minutes) to time out. Therefore, calling this function during
77 ### testing is essential, otherwise one will quickly exhaust all available
78 ### sessions.
79 ###
80 def logout(ip, cookie):
81     reqxml = et.Element('aaaLogout', attrib={'cookie': cookie,
82                                              'inCookie': cookie})
83     xml_req(ip, reqxml)
84
85 ###
86 ### Power off the host
87 ###
88 def powerOff(ip, cookie, debug=False):
89     reqxml = et.Element('configConfMo',
90                         attrib={'cookie': cookie, 'inHierarchical': 'false',
91                                 'dn': BASEDN})
92     inconfig = et.SubElement(reqxml, 'inConfig')
93     et.SubElement(inconfig, 'computeRackUnit',
94                   attrib={'adminPower': 'down', 'dn': BASEDN})
95     respxml = xml_req(ip, reqxml, debug)
96     return respxml
97
98 ###
99 ### Power on the host
100 ###
101 def powerOn(ip, cookie, debug=False):
102     reqxml = et.Element('configConfMo',
103                         attrib={'cookie': cookie, 'inHierarchical': 'false',
104                                 'dn': BASEDN})
105     inconfig = et.SubElement(reqxml, 'inConfig')
106     et.SubElement(inconfig, 'computeRackUnit',
107                   attrib={'adminPower': 'up', 'dn': BASEDN})
108     respxml = xml_req(ip, reqxml, debug)
109     return respxml
110
111 ###
112 ### Restore BIOS to default settings
113 ###
114 def restoreBiosDefaultSettings(ip, cookie, debug=False):
115     reqxml = et.Element('configResolveClass',
116                         attrib={'cookie': cookie, 'inHierarchical': 'true',
117                                 'classId': 'biosPlatformDefaults'})
118     respxml = xml_req(ip, reqxml, debug)
119
120     configs = respxml.find('outConfigs')
121     defaults = configs.find('biosPlatformDefaults')
122
123     reqxml = et.Element('configConfMo',
124                         attrib={'cookie': cookie, 'inHierarchical': 'true',
125                                 'dn': "{}/bios/bios-settings".format(BASEDN)})
126     inconfig = et.SubElement(reqxml, 'inConfig')
127     biosset = et.SubElement(inconfig, 'biosSettings')
128     biosset.extend(defaults)
129
130     respxml = xml_req(ip, reqxml, debug)
131     return respxml
132
133 ###
134 ### Apply specified BIOS settings.
135 ###
136 ### These must be a list of strings in XML format. Not currently very
137 ### user friendly. Format can either be obtained from CIMC
138 ### documention, or by setting them manually and then fetching
139 ### BIOS settings via CIMC XML API.
140 ###
141 def setBiosSettings(ip, cookie, settings, debug=False):
142     reqxml = et.Element('configConfMo',
143                         attrib={'cookie': cookie, 'inHierarchical': 'true',
144                                 'dn': "{}/bios/bios-settings".format(BASEDN)})
145     inconfig = et.SubElement(reqxml, 'inConfig')
146     biosset = et.SubElement(inconfig, 'biosSettings')
147     print "Applying settings:"
148     print settings
149     for s in settings:
150         x = et.fromstring(s)
151         et.dump(x)
152         biosset.append(et.fromstring(s))
153
154     respxml = xml_req(ip, reqxml, debug)
155     return respxml
156 ###
157 ### Delete any existing virtual drives
158 ###
159 ### WARNING: THIS WILL ERASE ALL DATA ON ALL DISKS, WITHOUT ANY CONFIRMATION
160 ### QUESTION.
161 ###
162 ### The server must be POWERED ON for this to succeed.
163 ###
164 def deleteAllVirtualDrives(ip, cookie, debug=False):
165     reqxml = et.Element('configResolveClass',
166                         attrib={'cookie': cookie, 'inHierarchical': 'true',
167                                 'classId': 'storageController'})
168     respxml = xml_req(ip, reqxml, debug)
169
170     configs = respxml.find('outConfigs')
171     for sc in configs.iter('storageController'):
172         if debug:
173             print "DEBUG: SC DN {} ID {}".format(sc.attrib['dn'],
174                                                  sc.attrib['id'])
175         reqxml = et.Element('configConfMo',
176                             attrib={'cookie': cookie, 'inHierarchical': 'true',
177                                     'dn': sc.attrib['dn']})
178         inconfig = et.SubElement(reqxml, 'inConfig')
179         et.SubElement(inconfig, 'storageController',
180                       attrib={'adminAction': 'delete-all-vds-reset-pds',
181                               'dn': sc.attrib['dn']})
182         xml_req(ip, reqxml, debug)
183
184 ###
185 ### Create a single RAID-10 across all drives.
186 ###
187 ### The server must be POWERED ON for this to succeed.
188 ###
189 def createRaid10_all(ip, cookie, debug=False):
190     reqxml = et.Element('configResolveClass',
191                         attrib={'cookie': cookie, 'inHierarchical': 'true',
192                                 'classId': 'storageController'})
193     respxml = xml_req(ip, reqxml, debug)
194
195     configs = respxml.find('outConfigs')
196     for sc in configs.iter('storageController'):
197         if debug:
198             print "DEBUG: SC DN {} ID {}".format(sc.attrib['dn'],
199                                                  sc.attrib['id'])
200         #
201         # Find disk size and number of disks
202         #
203         disks = []
204         total_size = 0
205         for pd in sc.iter('storageLocalDisk'):
206             if debug:
207                 print "DEBUG: PD {} size {}".format(pd.attrib['id'],
208                                                     pd.attrib['coercedSize'])
209             disks.append(pd.attrib['id'])
210             total_size += int(pd.attrib['coercedSize'].split(' ')[0])
211
212         #
213         # Create a RAID10 array of all available disks, as in:
214         # [1,2][3,4][5,6][7,8][9,10][11,12][13,14][15,16][17,18]
215         #
216         raid_size = total_size/2
217         raid_span = ''
218         for p in list(chunks(disks, 2)):
219             raid_span += "[{},{}]".format(p[0], p[1])
220
221         reqxml = et.Element('configConfMo',
222                             attrib={'cookie': cookie, 'inHierarchical': 'true',
223                                     'dn': sc.attrib['dn']})
224         inconfig = et.SubElement(reqxml, 'inConfig')
225         et.SubElement(inconfig,
226                       'storageVirtualDriveCreatorUsingUnusedPhysicalDrive',
227                       attrib={'virtualDriveName': 'raid10-all',
228                               'size': str(raid_size)+' MB',
229                               'raidLevel': '10', 'driveGroup': raid_span,
230                               'adminState': 'trigger'})
231
232         xml_req(ip, reqxml, debug)
233
234 ###
235 ### Create a single RAID across from empty drives as provided.
236 ###
237 ### The server must be POWERED ON for this to succeed.
238 ###
239 def createRaid(ip, cookie, name, raidlevel, size, drives, debug=False):
240     reqxml = et.Element('configResolveClass',
241                         attrib={'cookie': cookie, 'inHierarchical': 'true',
242                                 'classId': 'storageController'})
243     respxml = xml_req(ip, reqxml, debug)
244
245     configs = respxml.find('outConfigs')
246     for sc in configs.iter('storageController'):
247         if debug:
248             print "DEBUG: SC DN {} ID {}".format(sc.attrib['dn'],
249                                                  sc.attrib['id'])
250
251         reqxml = et.Element('configConfMo',
252                             attrib={'cookie': cookie, 'inHierarchical': 'true',
253                                     'dn': sc.attrib['dn']})
254         inconfig = et.SubElement(reqxml, 'inConfig')
255         et.SubElement(inconfig,
256                       'storageVirtualDriveCreatorUsingUnusedPhysicalDrive',
257                       attrib={'virtualDriveName': name,
258                               'size': str(size)+' MB',
259                               'raidLevel': raidlevel,
260                               'driveGroup': drives,
261                               'adminState': 'trigger'})
262
263         xml_req(ip, reqxml, debug)
264
265 ###
266 ### Enable Serial-Over-LAN (SOL) console and redirect BIOS output to
267 ### serial console
268 ###
269 def enableConsoleRedir(ip, cookie, debug=False):
270     reqxml = et.Element('configConfMo',
271                         attrib={'cookie': cookie, 'inHierarchical': 'false',
272                                 'dn': "{}/bios/bios-settings".format(BASEDN)})
273     inconfig = et.SubElement(reqxml, 'inConfig')
274     bs = et.SubElement(inconfig, 'biosSettings',
275                        attrib={'dn': "{}/bios/bios-settings".format(BASEDN)})
276     et.SubElement(bs,
277                   'biosVfConsoleRedirection',
278                   attrib={'vpConsoleRedirection': 'com-0',
279                           'vpBaudRate': '115200'})
280     respxml = xml_req(ip, reqxml, debug)
281     reqxml = et.Element('configConfMo',
282                         attrib={'cookie': cookie, 'inHierarchical': 'false',
283                                 'dn': BASEDN+'/sol-if'})
284     inconfig = et.SubElement(reqxml, 'inConfig')
285     et.SubElement(inconfig, 'solIf',
286                   attrib={'dn': BASEDN+'/sol-if', 'adminState': 'enable',
287                           'speed': '115200', 'comport': 'com0'})
288     respxml = xml_req(ip, reqxml, debug)
289     return respxml
290
291 ###
292 ### Boot into UEFI bootloader (we may use this to "park" the host in
293 ### powered-on state)
294 ###
295 def bootIntoUefi(ip, cookie, debug=False):
296     reqxml = et.Element('configConfMo',
297                         attrib={'cookie': cookie, 'inHierarchical': 'false',
298                                 'dn': BASEDN+'/boot-policy'})
299     inconfig = et.SubElement(reqxml, 'inConfig')
300     bootDef = et.SubElement(inconfig, 'lsbootDef',
301                             attrib={'dn': BASEDN+'/boot-policy',
302                                     'rebootOnUpdate': 'yes'})
303     et.SubElement(bootDef, 'lsbootEfi',
304                   attrib={'rn': 'efi-read-only', 'order': '1',
305                           'type': 'efi'})
306
307     respxml = xml_req(ip, reqxml, debug)
308     return respxml
309
310 ###
311 ### Boot via PXE. Reboot immediately.
312 ###
313 def bootPXE(ip, cookie, debug=False):
314     reqxml = et.Element('configConfMo',
315                         attrib={'cookie': cookie, 'inHierarchical': 'false',
316                                 'dn': BASEDN+'/boot-policy'})
317     inconfig = et.SubElement(reqxml, 'inConfig')
318     bootDef = et.SubElement(inconfig, 'lsbootDef',
319                             attrib={'dn': BASEDN+'/boot-policy',
320                                     'rebootOnUpdate': 'yes'})
321     et.SubElement(bootDef, 'lsbootLan',
322                   attrib={'rn': 'lan-read-only', 'order': '1',
323                           'type': 'lan', 'prot': 'pxe'})
324
325     respxml = xml_req(ip, reqxml, debug)
326     return respxml
327
328
329 ###
330 ### Boot via Local HDD first, then via PXE. Do not reboot immediately.
331 ###
332 def bootHDDPXE(ip, cookie, debug=False):
333     reqxml = et.Element('configConfMo',
334                         attrib={'cookie': cookie, 'inHierarchical': 'false',
335                                 'dn': BASEDN+'/boot-policy'})
336     inconfig = et.SubElement(reqxml, 'inConfig')
337     bootDef = et.SubElement(inconfig, 'lsbootDef',
338                             attrib={'dn': BASEDN+'/boot-policy',
339                                     'rebootOnUpdate': 'no'})
340     storage = et.SubElement(bootDef, 'lsbootStorage',
341                             attrib={'rn': 'storage-read-write',
342                                     'access': 'read-write',
343                                     'order': '1', 'type': 'storage'})
344     et.SubElement(storage, 'lsbootLocalStorage',
345                   attrib={'rn': 'local-storage'})
346     et.SubElement(bootDef, 'lsbootLan',
347                   attrib={'rn': 'lan-read-only', 'order': '2',
348                           'type': 'lan', 'prot': 'pxe'})
349
350     respxml = xml_req(ip, reqxml, debug)
351     return respxml
352
353 ###
354 ### Return LOM port 1 MAC address
355 ###
356 def getLOMMacAddress(ip, cookie, debug=False):
357     reqxml = et.Element('configResolveClass',
358                         attrib={'cookie': cookie, 'inHierarchical': 'true',
359                                 'classId': 'networkAdapterUnit'})
360     respxml = xml_req(ip, reqxml, debug)
361     reqxml = et.Element('configResolveDn',
362                         attrib={'cookie': cookie, 'inHierarchical': 'true',
363                                 'dn': BASEDN+'/network-adapter-L/eth-1'})
364     respxml = xml_req(ip, reqxml, debug)
365
366     oc = respxml.find('outConfig')
367     netw = oc.find('networkAdapterEthIf')
368     if debug:
369         print "DEBUG: MAC address is {}".format(netw.get('mac'))
370     return netw.get('mac')
371
372 ###
373 ### Return all port MAC addresses
374 ###
375 def getMacAddresses(ip, cookie, debug=False):
376     maclist = {}
377     reqxml = et.Element('configResolveClass',
378                         attrib={'cookie': cookie, 'inHierarchical': 'true',
379                                 'classId': 'networkAdapterUnit'})
380     respxml = xml_req(ip, reqxml, debug)
381     oc = respxml.find('outConfigs')
382     for adapter in oc.iter('networkAdapterUnit'):
383         if debug:
384             print "DEBUG: ADAPTER SLOT {} MODEL {}".format(adapter.attrib['slot'],
385                                                            adapter.attrib['model'])
386         slot = adapter.attrib['slot']
387         maclist[slot] = {}
388         for port in adapter.iter('networkAdapterEthIf'):
389             if debug:
390                 print "DEBUG:    SLOT {} PORT {} MAC {}".format(slot,
391                                                                 port.attrib['id'],
392                                                                 port.attrib['mac'])
393             maclist[slot][port.attrib['id']] = port.attrib['mac'].lower()
394
395     reqxml = et.Element('configResolveClass',
396                         attrib={'cookie': cookie, 'inHierarchical': 'true',
397                                 'classId': 'adaptorUnit'})
398     respxml = xml_req(ip, reqxml, debug)
399     oc = respxml.find('outConfigs')
400     for adapter in oc.iter('adaptorUnit'):
401         if debug:
402             print "DEBUG: VIC ADAPTER SLOT {} MODEL {}".format(adapter.attrib['pciSlot'],
403                                                                adapter.attrib['model'])
404         slot = adapter.attrib['pciSlot']
405         maclist[slot] = {}
406         for port in adapter.iter('adaptorHostEthIf'):
407             portnum = int(re.sub('eth([0-9]+)', '\\1', port.attrib['name']))+1
408             if debug:
409                 print "DEBUG:    VIC SLOT {} PORT {} MAC {}".format(slot,
410                                                                     portnum,
411                                                                     port.attrib['mac'])
412             maclist[slot][portnum] = port.attrib['mac'].lower()
413
414     return maclist

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.