PLC/Methods/GetBootMedium.py

   1 # pylint: disable=c0111, c0103
   2
   3 import random
   4 import base64
   5 import os
   6 import os.path
   7 import time
   8
   9 from PLC.Faults import *
  10 from PLC.Method import Method
  11 from PLC.Parameter import Parameter, Mixed
  12 from PLC.Auth import Auth
  13
  14 from PLC.Nodes import Node, Nodes
  15 from PLC.Interfaces import Interface, Interfaces
  16 from PLC.InterfaceTags import InterfaceTag, InterfaceTags
  17 from PLC.NodeTags import NodeTag, NodeTags
  18
  19 from PLC.Logger import logger
  20
  21 from PLC.Accessors.Accessors_standard import *              # node accessors
  22
  23 # could not define this in the class..
  24 # create a dict with the allowed actions for each type of node
  25 # reservable nodes being more recent, we do not support the floppy stuff anymore
  26 allowed_actions = {
  27     'regular' :
  28     [ 'node-preview',
  29       'node-floppy',
  30       'node-iso',
  31       'node-usb',
  32       'generic-iso',
  33       'generic-usb',
  34       ],
  35     'reservable':
  36     [ 'node-preview',
  37       'node-iso',
  38       'node-usb',
  39       ],
  40     }
  41
  42 # compute a new key
  43 def compute_key():
  44     # Generate 32 random bytes
  45     int8s = random.sample(range(0, 256), 32)
  46     # Base64 encode their string representation
  47     key = base64.b64encode(bytes(int8s))
  48     # Boot Manager cannot handle = in the key
  49     key = key.replace(b"=", b"")
  50     return key
  51
  52 class GetBootMedium(Method):
  53     """
  54     This method is a redesign based on former, supposedly dedicated,
  55     AdmGenerateNodeConfFile
  56
  57     As compared with its ancestor, this method provides a much more
  58     detailed interface, that allows to
  59     (*) either just preview the node config file -- in which case
  60         the node key is NOT recomputed, and NOT provided in the output
  61     (*) or regenerate the node config file for storage on a floppy
  62         that is, exactly what the ancestor method used todo,
  63         including renewing the node's key
  64     (*) or regenerate the config file and bundle it inside an ISO or USB image
  65     (*) or just provide the generic ISO or USB boot images
  66         in which case of course the node_id_or_hostname parameter is not used
  67
  68     action is expected among the following string constants according the
  69     node type value:
  70
  71     for a 'regular' node:
  72     (*) node-preview
  73     (*) node-floppy
  74     (*) node-iso
  75     (*) node-usb
  76     (*) generic-iso
  77     (*) generic-usb
  78
  79     Apart for the preview mode, this method generates a new node key for the
  80     specified node, effectively invalidating any old boot medium.
  81     Note that 'reservable' nodes do not support 'node-floppy',
  82     'generic-iso' nor 'generic-usb'.
  83
  84     In addition, two return mechanisms are supported.
  85     (*) The default behaviour is that the file's content is returned as a
  86         base64-encoded string. This is how the ancestor method used to work.
  87         To use this method, pass an empty string as the file parameter.
  88
  89     (*) Or, for efficiency -- this makes sense only when the API is used
  90         by the web pages that run on the same host -- the caller may provide
  91         a filename, in which case the resulting file is stored in that location instead.
  92         The filename argument can use the following markers, that are expanded
  93         within the method
  94         - %d : default root dir (some builtin dedicated area under /var/tmp/)
  95                Using this is recommended, and enforced for non-admin users
  96         - %n : the node's name when this makes sense, or a mktemp-like name when
  97                generic media is requested
  98         - %s : a file suffix appropriate in the context (.txt, .iso or the like)
  99         - %v : the bootcd version string (e.g. 4.0)
 100         - %p : the PLC name
 101         - %f : the nodefamily
 102         - %a : arch
 103         With the file-based return mechanism, the method returns the full pathname
 104         of the result file;
 105         ** WARNING **
 106         It is the caller's responsability to remove this file after use.
 107
 108     Options: an optional array of keywords.
 109         options are not supported for generic images
 110       Currently supported are
 111         - 'partition' - for USB actions only
 112         - 'cramfs'
 113         - 'serial' or 'serial:<console_spec>'
 114         console_spec (or 'default') is passed as-is to bootcd/build.sh
 115         it is expected to be a colon separated string denoting
 116         tty - baudrate - parity - bits
 117         e.g. ttyS0:115200:n:8
 118         - 'variant:<variantname>'
 119         passed to build.sh as -V <variant>
 120         variants are used to run a different kernel on the bootCD
 121         see kvariant.sh for how to create a variant
 122         - 'no-hangcheck' - disable hangcheck
 123         - 'systemd-debug' - turn on systemd debug in bootcd
 124
 125     Tags: the following tags are taken into account when attached to the node:
 126         'serial', 'cramfs', 'kvariant', 'kargs', 'no-hangcheck', 'systemd-debug'
 127
 128     Security:
 129         - Non-admins can only generate files for nodes at their sites.
 130         - Non-admins, when they provide a filename, *must* specify it in the %d area
 131
 132    Housekeeping:
 133         Whenever needed, the method stores intermediate files in a
 134         private area, typically not located under the web server's
 135         accessible area, and are cleaned up by the method.
 136
 137     """
 138
 139     roles = ['admin', 'pi', 'tech']
 140
 141     accepts = [
 142         Auth(),
 143         Mixed(Node.fields['node_id'],
 144               Node.fields['hostname']),
 145         Parameter (str, "Action mode, expected value depends of the type of node"),
 146         Parameter (str, "Empty string for verbatim result, resulting file full path otherwise"),
 147         Parameter ([str], "Options"),
 148         ]
 149
 150     returns = Parameter(str, "Node boot medium, either inlined, or filename, depending on the filename parameter")
 151
 152     # define globals for regular nodes, override later for other types
 153     BOOTCDDIR = "/usr/share/bootcd-@NODEFAMILY@/"
 154     BOOTCDBUILD = "/usr/share/bootcd-@NODEFAMILY@/build.sh"
 155     GENERICDIR = "/var/www/html/download-@NODEFAMILY@/"
 156     WORKDIR = "/var/tmp/bootmedium"
 157     LOGDIR = "/var/tmp/bootmedium/logs/"
 158     DEBUG = False
 159     # uncomment this to preserve temporary area and bootcustom logs
 160     #DEBUG = True
 161
 162     ### returns (host, domain) :
 163     # 'host' : host part of the hostname
 164     # 'domain' : domain part of the hostname
 165     def split_hostname (self, node):
 166         # Split hostname into host and domain parts
 167         parts = node['hostname'].split(".", 1)
 168         if len(parts) < 2:
 169             raise PLCInvalidArgument("Node hostname {} is invalid".format(node['hostname']))
 170         return parts
 171
 172     # Generate the node (plnode.txt) configuration content.
 173     #
 174     # This function will create the configuration file a node
 175     # composed by:
 176     #  - a common part, regardless of the 'node_type' tag
 177     #  - XXX a special part, depending on the 'node_type' tag value.
 178     def floppy_contents (self, node, renew_key):
 179
 180         # Do basic checks
 181         if node['peer_id'] is not None:
 182             raise PLCInvalidArgument("Not a local node {}".format(node['hostname']))
 183
 184         # If we are not an admin, make sure that the caller is a
 185         # member of the site at which the node is located.
 186         if 'admin' not in self.caller['roles']:
 187             if node['site_id'] not in self.caller['site_ids']:
 188                 raise PLCPermissionDenied(
 189                     "Not allowed to generate a configuration file for {}"\
 190                     .format(node['hostname']))
 191
 192         # Get interface for this node
 193         primary = None
 194         interfaces = Interfaces(self.api, node['interface_ids'])
 195         for interface in interfaces:
 196             if interface['is_primary']:
 197                 primary = interface
 198                 break
 199         if primary is None:
 200             raise PLCInvalidArgument(
 201                 "No primary network configured on {}".format(node['hostname']))
 202
 203         host, domain = self.split_hostname (node)
 204
 205         # renew the key and save it on the database
 206         if renew_key:
 207             node['key'] = compute_key()
 208             node.update_last_download(commit=False)
 209             node.sync()
 210
 211         # Generate node configuration file suitable for BootCD
 212         file = ""
 213
 214         if renew_key:
 215             file += 'NODE_ID="{}"\n'.format(node['node_id'])
 216             file += 'NODE_KEY="{}"\n'.format(node['key'])
 217             # not used anywhere, just a note for operations people
 218             file += 'KEY_RENEWAL_DATE="{}"\n'\
 219                 .format(time.strftime('%Y/%m/%d at %H:%M +0000',time.gmtime()))
 220
 221         if primary['mac']:
 222             file += 'NET_DEVICE="{}"\n'.format(primary['mac'].lower())
 223
 224         file += 'IP_METHOD="{}"\n'.format(primary['method'])
 225
 226         if primary['method'] == 'static':
 227             file += 'IP_ADDRESS="{}"\n'.format(primary['ip'])
 228             file += 'IP_GATEWAY="{}"\n'.format(primary['gateway'])
 229             file += 'IP_NETMASK="{}"\n'.format(primary['netmask'])
 230             file += 'IP_NETADDR="{}"\n'.format(primary['network'])
 231             file += 'IP_BROADCASTADDR="{}"\n'.format(primary['broadcast'])
 232             file += 'IP_DNS1="{}"\n'.format(primary['dns1'])
 233             file += 'IP_DNS2="{}"\n'.format(primary['dns2'] or "")
 234
 235         file += 'HOST_NAME="{}"\n'.format(host)
 236         file += 'DOMAIN_NAME="{}"\n'.format(domain)
 237
 238         # define various interface settings attached to the primary interface
 239         settings = InterfaceTags (self.api, {'interface_id':interface['interface_id']})
 240
 241         categories = set()
 242         for setting in settings:
 243             if setting['category'] is not None:
 244                 categories.add(setting['category'])
 245
 246         for category in categories:
 247             category_settings = InterfaceTags(self.api,{'interface_id' : interface['interface_id'],
 248                                                         'category' : category})
 249             if category_settings:
 250                 file += '### Category : {}\n'.format(category)
 251                 for setting in category_settings:
 252                     file += '{}_{}="{}"\n'\
 253                         .format(category.upper(), setting['tagname'].upper(), setting['value'])
 254
 255         for interface in interfaces:
 256             if interface['method'] == 'ipmi':
 257                 file += 'IPMI_ADDRESS="{}"\n'.format(interface['ip'])
 258                 if interface['mac']:
 259                     file += 'IPMI_MAC="{}"\n'.format(interface['mac'].lower())
 260                 break
 261
 262         return file
 263
 264     # see also GetNodeFlavour that does similar things
 265     def get_nodefamily (self, node, auth):
 266         pldistro = self.api.config.PLC_FLAVOUR_NODE_PLDISTRO
 267         fcdistro = self.api.config.PLC_FLAVOUR_NODE_FCDISTRO
 268         arch = self.api.config.PLC_FLAVOUR_NODE_ARCH
 269         if not node:
 270             return (pldistro,fcdistro,arch)
 271
 272         node_id = node['node_id']
 273
 274         # no support for deployment-based BootCD's, use kvariants instead
 275         node_pldistro = GetNodePldistro (self.api,self.caller).call(auth, node_id)
 276         if node_pldistro:
 277             pldistro = node_pldistro
 278
 279         node_fcdistro = GetNodeFcdistro (self.api,self.caller).call(auth, node_id)
 280         if node_fcdistro:
 281             fcdistro = node_fcdistro
 282
 283         node_arch = GetNodeArch (self.api,self.caller).call(auth,node_id)
 284         if node_arch:
 285             arch = node_arch
 286
 287         return (pldistro,fcdistro,arch)
 288
 289     def bootcd_version (self):
 290         try:
 291             with open(self.BOOTCDDIR + "/build/version.txt") as feed:
 292                 return feed.readline().strip()
 293         except:
 294             raise Exception("Unknown boot cd version - probably wrong bootcd dir : {}"\
 295                             .format(self.BOOTCDDIR))
 296
 297     def cleantrash (self):
 298         for file in self.trash:
 299             if self.DEBUG:
 300                 logger.debug('DEBUG -- preserving trash file {}'.format(file))
 301             else:
 302                 os.unlink(file)
 303
 304     ### handle filename
 305     # build the filename string
 306     # check for permissions and concurrency
 307     # returns the filename
 308     def handle_filename (self, filename, nodename, suffix, arch):
 309         # allow to set filename to None or any other empty value
 310         if not filename: filename=''
 311         filename = filename.replace ("%d",self.WORKDIR)
 312         filename = filename.replace ("%n",nodename)
 313         filename = filename.replace ("%s",suffix)
 314         filename = filename.replace ("%p",self.api.config.PLC_NAME)
 315         # let's be cautious
 316         try: filename = filename.replace ("%f", self.nodefamily)
 317         except: pass
 318         try: filename = filename.replace ("%a", arch)
 319         except: pass
 320         try: filename = filename.replace ("%v",self.bootcd_version())
 321         except: pass
 322
 323         ### Check filename location
 324         if filename != '':
 325             if 'admin' not in self.caller['roles']:
 326                 if ( filename.index(self.WORKDIR) != 0):
 327                     raise PLCInvalidArgument("File {} not under {}".format(filename, self.WORKDIR))
 328
 329             ### output should not exist (concurrent runs ..)
 330             # numerous reports of issues with this policy
 331             # looks like people sometime suspend/cancel their download
 332             # and this leads to the old file sitting in there forever
 333             # so, if the file is older than 5 minutes, we just trash
 334             grace=5
 335             if os.path.exists(filename) and (time.time()-os.path.getmtime(filename)) >= (grace*60):
 336                 os.unlink(filename)
 337             if os.path.exists(filename):
 338                 raise PLCInvalidArgument(
 339                     "Resulting file {} already exists - please try again in {} minutes"\
 340                     .format(filename, grace))
 341
 342             ### we can now safely create the file,
 343             ### either we are admin or under a controlled location
 344             filedir=os.path.dirname(filename)
 345             # dirname does not return "." for a local filename like its shell counterpart
 346             if filedir:
 347                 if not os.path.exists(filedir):
 348                     try:
 349                         os.makedirs (filedir,0o777)
 350                     except:
 351                         raise PLCPermissionDenied("Could not create dir {}".format(filedir))
 352
 353         return filename
 354
 355     def build_command(self, nodename, node_type, build_sh_spec, node_image, type, floppy_file):
 356         """
 357         returns a tuple
 358         (*) build command to be run
 359         (*) location of the log_file
 360         """
 361
 362         command = ""
 363
 364         # regular node, make build's arguments
 365         # and build the full command line to be called
 366         if node_type not in [ 'regular', 'reservable' ]:
 367             logger.error("GetBootMedium.build_command: unexpected node_type {}".format(node_type))
 368             return command, None
 369
 370         build_sh_options=""
 371         if "cramfs" in build_sh_spec:
 372             type += "_cramfs"
 373         if "serial" in build_sh_spec:
 374             build_sh_options += " -s {}".format(build_sh_spec['serial'])
 375         if "variant" in build_sh_spec:
 376             build_sh_options += " -V {}".format(build_sh_spec['variant'])
 377
 378         for karg in build_sh_spec['kargs']:
 379             build_sh_options += ' -k "{}"'.format(karg)
 380
 381         import time
 382         date = time.strftime('%Y-%m-%d-%H-%M', time.gmtime())
 383         if not os.path.isdir(self.LOGDIR):
 384             os.makedirs(self.LOGDIR)
 385         log_file = "{}/{}-{}.log".format(self.LOGDIR, date, nodename)
 386
 387         command = '{} -f "{}" -o "{}" -t "{}" {} > {} 2>&1'\
 388                   .format(self.BOOTCDBUILD,
 389                           floppy_file,
 390                           node_image,
 391                           type,
 392                           build_sh_options,
 393                           log_file)
 394
 395         logger.info("The build command line is {}".format(command))
 396
 397         return command, log_file
 398
 399     def call(self, auth, node_id_or_hostname, action, filename, options = []):
 400
 401         self.trash=[]
 402
 403         ### compute file suffix and type
 404         if action.find("-iso") >= 0 :
 405             suffix = ".iso"
 406             type   = "iso"
 407         elif action.find("-usb") >= 0:
 408             suffix = ".usb"
 409             type   = "usb"
 410         else:
 411             suffix = ".txt"
 412             type   = "txt"
 413
 414         # check for node existence and get node_type
 415         nodes = Nodes(self.api, [node_id_or_hostname])
 416         if not nodes:
 417             raise PLCInvalidArgument("No such node {}".format(node_id_or_hostname))
 418         node = nodes[0]
 419
 420         logger.info("GetBootMedium: {} requested on node {}. Node type is: {}"\
 421             .format(action, node['node_id'], node['node_type']))
 422
 423         # check the required action against the node type
 424         node_type = node['node_type']
 425         if action not in allowed_actions[node_type]:
 426             raise PLCInvalidArgument("Action {} not valid for {} nodes, valid actions are {}"\
 427                                    .format(action, node_type, "|".join(allowed_actions[node_type])))
 428
 429         # handle / canonicalize options
 430         if type == "txt":
 431             if options:
 432                 raise PLCInvalidArgument("Options are not supported for node configs")
 433         else:
 434             # create a dict for build.sh
 435             build_sh_spec={'kargs':[]}
 436             # use node tags as defaults
 437             # check for node tag equivalents
 438             tags = NodeTags(self.api,
 439                             {'node_id': node['node_id'],
 440                              'tagname': ['serial', 'cramfs', 'kvariant', 'kargs',
 441                                          'no-hangcheck', 'systemd-debug' ]},
 442                             ['tagname', 'value'])
 443             if tags:
 444                 for tag in tags:
 445                     if tag['tagname'] == 'serial':
 446                         build_sh_spec['serial'] = tag['value']
 447                     elif tag['tagname'] == 'cramfs':
 448                         build_sh_spec['cramfs'] = True
 449                     elif tag['tagname'] == 'kvariant':
 450                         build_sh_spec['variant'] = tag['value']
 451                     elif tag['tagname'] == 'kargs':
 452                         build_sh_spec['kargs'] += tag['value'].split()
 453                     elif tag['tagname'] == 'no-hangcheck':
 454                         build_sh_spec['kargs'].append('hcheck_reboot0')
 455                     elif tag['tagname'] == 'systemd-debug':
 456                         build_sh_spec['kargs'].append('systemd.log_level=debug')
 457                         build_sh_spec['kargs'].append('systemd.log_target=console')
 458             # then options can override tags
 459             for option in options:
 460                 if option == "cramfs":
 461                     build_sh_spec['cramfs']=True
 462                 elif option == 'partition':
 463                     if type != "usb":
 464                         raise PLCInvalidArgument("option 'partition' is for USB images only")
 465                     else:
 466                         type="usb_partition"
 467                 elif option == "serial":
 468                     build_sh_spec['serial']='default'
 469                 elif option.find("serial:") == 0:
 470                     build_sh_spec['serial']=option.replace("serial:","")
 471                 elif option.find("variant:") == 0:
 472                     build_sh_spec['variant']=option.replace("variant:","")
 473                 elif option == "no-hangcheck":
 474                     build_sh_spec['kargs'].append('hcheck_reboot0')
 475                 elif option == "systemd-debug":
 476                     build_sh_spec['kargs'].append('systemd.log_level=debug')
 477                 else:
 478                     raise PLCInvalidArgument("unknown option {}".format(option))
 479
 480         # compute nodename according the action
 481         if action.find("node-") == 0:
 482             nodename = node['hostname']
 483         else:
 484             node = None
 485             # compute a 8 bytes random number
 486             tempbytes = random.sample (range(0,256), 8);
 487             def hexa2 (c): return chr((c>>4)+65) + chr ((c&16)+65)
 488             nodename = "".join(map(hexa2,tempbytes))
 489
 490         # get nodefamily
 491         (pldistro,fcdistro,arch) = self.get_nodefamily(node, auth)
 492         self.nodefamily="{}-{}-{}".format(pldistro, fcdistro, arch)
 493
 494         # apply on globals
 495         for attr in [ "BOOTCDDIR", "BOOTCDBUILD", "GENERICDIR" ]:
 496             setattr(self,attr,getattr(self,attr).replace("@NODEFAMILY@",self.nodefamily))
 497
 498         filename = self.handle_filename(filename, nodename, suffix, arch)
 499
 500         # log call
 501         if node:
 502             self.message='GetBootMedium on node {} - action={}'.format(nodename, action)
 503             self.event_objects={'Node': [ node ['node_id'] ]}
 504         else:
 505             self.message='GetBootMedium - generic - action={}'.format(action)
 506
 507         ### generic media
 508         if action == 'generic-iso' or action == 'generic-usb':
 509             if options:
 510                 raise PLCInvalidArgument("Options are not supported for generic images")
 511             # this raises an exception if bootcd is missing
 512             version = self.bootcd_version()
 513             generic_name = "{}-BootCD-{}{}".format(self.api.config.PLC_NAME, version, suffix)
 514             generic_path = "{}/{}".format(self.GENERICDIR, generic_name)
 515
 516             if filename:
 517                 ret=os.system ('cp "{}" "{}"'.format(generic_path, filename))
 518                 if ret==0:
 519                     return filename
 520                 else:
 521                     raise PLCPermissionDenied("Could not copy {} into {}"\
 522                                               .format(generic_path, filename))
 523             else:
 524                 ### return the generic medium content as-is, just base64 encoded
 525                 with open(generic_path) as feed:
 526                     return base64.b64encode(feed.read())
 527
 528         ### config file preview or regenerated
 529         if action == 'node-preview' or action == 'node-floppy':
 530             renew_key = (action == 'node-floppy')
 531             floppy = self.floppy_contents (node,renew_key)
 532             if filename:
 533                 try:
 534                     with open(filename, 'w') as writer:
 535                         writer.write(floppy)
 536                 except:
 537                     raise PLCPermissionDenied("Could not write into {}".format(filename))
 538                 return filename
 539             else:
 540                 return floppy
 541
 542         ### we're left with node-iso and node-usb
 543         # the steps involved in the image creation are:
 544         # - create and test the working environment
 545         # - generate the configuration file
 546         # - build and invoke the build command
 547         # - delivery the resulting image file
 548
 549         if action == 'node-iso' or action == 'node-usb':
 550
 551             ### check we've got required material
 552             version = self.bootcd_version()
 553
 554             if not os.path.isfile(self.BOOTCDBUILD):
 555                 raise PLCAPIError("Cannot locate bootcd/build.sh script {}".format(self.BOOTCDBUILD))
 556
 557             # create the workdir if needed
 558             if not os.path.isdir(self.WORKDIR):
 559                 try:
 560                     os.makedirs(self.WORKDIR,0o777)
 561                     os.chmod(self.WORKDIR,0o777)
 562                 except:
 563                     raise PLCPermissionDenied("Could not create dir {}".format(self.WORKDIR))
 564
 565             try:
 566                 # generate floppy config
 567                 floppy_text = self.floppy_contents(node, True)
 568                 # store it
 569                 floppy_file = "{}/{}.txt".format(self.WORKDIR, nodename)
 570                 try:
 571                     with open(floppy_file, "w") as writer:
 572                         writer.write(floppy_text)
 573                 except:
 574                     raise PLCPermissionDenied("Could not write into {}".format(floppy_file))
 575
 576                 self.trash.append(floppy_file)
 577
 578                 node_image = "{}/{}{}".format(self.WORKDIR, nodename, suffix)
 579
 580                 command, log_file = self.build_command(nodename, node_type, build_sh_spec,
 581                                                        node_image, type, floppy_file)
 582
 583                 # invoke the image build script
 584                 if command != "":
 585                     ret = os.system(command)
 586
 587                 if ret != 0:
 588                     raise PLCAPIError("{} failed Command line was: {} See logs in {}"\
 589                                       .format(self.BOOTCDBUILD, command, log_file))
 590
 591                 if not os.path.isfile(node_image):
 592                     raise PLCAPIError("Unexpected location of build.sh output - {}".format(node_image))
 593
 594                 # handle result
 595                 if filename:
 596                     ret = os.system('mv "{}" "{}"'.format(node_image, filename))
 597                     if ret != 0:
 598                         self.trash.append(node_image)
 599                         self.cleantrash()
 600                         raise PLCAPIError("Could not move node image {} into {}"\
 601                                           .format(node_image, filename))
 602                     self.cleantrash()
 603                     return filename
 604                 else:
 605                     with open(node_image) as feed:
 606                         result = feed.read()
 607                     self.trash.append(node_image)
 608                     self.cleantrash()
 609                     logger.info("GetBootMedium - done with build.sh")
 610                     encoded_result = base64.b64encode(result)
 611                     logger.info("GetBootMedium - done with base64 encoding - lengths: raw={} - b64={}"
 612                                 .format(len(result), len(encoded_result)))
 613                     return encoded_result
 614             except:
 615                 self.cleantrash()
 616                 raise
 617
 618         # we're done here, or we missed something
 619         raise PLCAPIError('Unhandled action {}'.format(action))