confluent/confluent_client/bin/nodefirmware

#!/usr/bin/python
# vim: tabstop=4 shiftwidth=4 softtabstop=4

# Copyright 2016-2017 Lenovo
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import optparse
import os
import signal
import sys
import time

try:
    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
except AttributeError:
    pass
path = os.path.dirname(os.path.realpath(__file__))
path = os.path.realpath(os.path.join(path, '..', 'lib', 'python'))
if path.startswith('/opt'):
    sys.path.append(path)

import confluent.client as client
import confluent.screensqueeze as sq

exitcode = 0


def printfirm(node, prefix, data):
    if 'model' in data:
        prefix += ' ' + data['model']
    builddesc = []
    if 'build' in data:
        builddesc.append(data['build'])
    if 'date' in data:
        builddesc.append(data['date'])
    if 'version' in data:
        version = data['version']
        if builddesc:
            version += ' ({0})'.format(' '.join(builddesc))
    else:
        version = ' '.join(builddesc)
    print('{0}: {1}: {2}'.format(node, prefix, version))

components = ['all']

argparser = optparse.OptionParser(
    usage="Usage: %prog <noderange> [update [--backup <file>]]|[<components>]")
argparser.add_option('-b', '--backup', action='store_true',
                     help='Target a backup bank rather than primary')
(options, args) = argparser.parse_args()
upfile = None
try:
    noderange = args[0]
    if len(args) > 1:
        if args[1] == 'update':
            upfile = args[2]
        else:
            components = []
            for arg in args[1:]:
                components += arg.split(',')

except IndexError:
    argparser.print_help()
    sys.exit(1)
client.check_globbing(noderange)

def get_update_progress(session, url):
    for res in session.read(url):
        status = res['phase']
        percent = res['progress']
        detail = res['detail']
        if status == 'error':
            text = 'error!'
        else:
            text = '{0}: {1:3.0f}%'.format(status, percent)
    return text, status, detail

def update_firmware(session, filename):
    global exitcode
    output = sq.ScreenPrinter(noderange, session)
    nodeurls = {}
    filename = os.path.abspath(filename)
    resource = '/noderange/{0}/inventory/firmware/updates/active'.format(
        noderange)
    upargs = {'filename': filename}
    if options.backup:
        upargs['bank'] = 'backup'
    noderrs = {}
    for res in session.create(resource, upargs):
        if 'created' not in res:
            for nodename in res.get('databynode', ()):
                output.set_output(nodename, 'error!')
                noderrs[nodename] = res['databynode'][nodename].get(
                    'error', 'Unknown Error')
            continue
        watchurl = res['created']
        currnode = watchurl.split('/')[1]
        nodeurls[currnode] = '/' + watchurl
    while nodeurls:
        for node in list(nodeurls):
            progress, status, err = get_update_progress(
                session, nodeurls[node])
            if status == 'error':
                exitcode = 1
                noderrs[node] = err
            if status in ('error', 'complete', 'pending'):
                list(session.delete(nodeurls[node]))
                del nodeurls[node]
            output.set_output(node, progress)
        time.sleep(2)
    allerrnodes = ','.join(noderrs)
    if noderrs:
        sys.stderr.write(
            'Nodes had errors updating ({0})!\n'.format(allerrnodes))
    for node in noderrs:
        sys.stderr.write('{0}: {1}\n'.format(node, noderrs[node]))

def show_firmware(session):
    firmware_shown = False
    for component in components:
        for res in session.read(
                '/noderange/{0}/inventory/firmware/all/{1}'.format(
                    noderange, component)):
            exitcode |= client.printerror(res)
            if 'databynode' not in res:
                continue
            for node in res['databynode']:
                exitcode |= client.printerror(res['databynode'][node], node)
                if 'firmware' not in res['databynode'][node]:
                    continue
                for inv in res['databynode'][node]['firmware']:
                    for prefix in inv:
                        firmware_shown = True
                        printfirm(node, prefix, inv[prefix])
    if not firmware_shown:
        argparser.print_help()


try:
    session = client.Command()
    if upfile is None:
        show_firmware(session)
    else:
        update_firmware(session, upfile)
except KeyboardInterrupt:
    print('')
sys.exit(exitcode)