docs: def on_ok(self):
          """
          Take the tool selections and perform the provided action on them
          """
          def diff(first, second):
              """
              Get the elements that exist in the first list and not in the second
              """
              second = set(second)
              return [item for item in first if item not in second]
  
          def popup(original, orig_type, thr, title):
              """
              Start the thread and display a popup of info
              until the thread is finished
              """
              thr.start()
              info_str = ''
              while thr.is_alive():
                  if orig_type == 'containers':
                      info = diff(Containers(), original)
                  elif orig_type == 'images':
                      info = diff(Images(), original)
                  if info:
                      info_str = ''
                  for entry in info:
                      info_str = entry[0] + ': ' + entry[1] + '\n' + info_str
                  if self.action['action_name'] != 'configure':
                      npyscreen.notify_wait(info_str, title=title)
                      time.sleep(1)
  
              thr.join()
              try:
                  result = self.api_action.queue.get(False)
                  if isinstance(result, tuple) and isinstance(result[1], tuple):
                      running, failed = result[1]
                      r_str = ''
                      for container in running:
                          r_str += container + ': successful\n'
                      for container in failed:
                          r_str += container + ': failed\n'
                      npyscreen.notify_confirm(r_str)
              except Exception as e:  # pragma: no cover
                  pass
              return
  
          if self.action['type'] == 'images':
              originals = Images()
          else:
              originals = Containers()
  
          tool_d = {}
          if self.action['action_name'] in ['remove', 'stop', 'update']:
              reconfirmation_str = ''
              if self.action['cores']:
                  reconfirmation_str = 'Are you sure you want to '
                  reconfirmation_str += self.action['action_name']
                  reconfirmation_str += ' core containers?'
              else:
                  reconfirmation_str = 'Are you sure you want to '
                  reconfirmation_str += self.action['action_name']
                  reconfirmation_str += ' plugin containers?'
  
              perform = npyscreen.notify_ok_cancel(reconfirmation_str,
                                                   title='Confirm command')
              if not perform:
                  return
  
          tools_to_configure = []
          for repo in self.tools_tc:
              for tool in self.tools_tc[repo]:
                  if self.tools_tc[repo][tool].value:
                      t = tool.split(':', 2)[2].split('/')[-1]
                      if t.startswith('/:'):
                          t = ' '+t[1:]
                      t = t.split(':')
                      if self.action['action_name'] in ['start', 'stop']:
                          status = self.action['action_object1'](repo, t[0])
                      elif self.action['action_name'] == 'configure':
                          constraints = {'name': t[0],
                                         'branch': t[1],
                                         'version': t[2],
                                         'repo': repo}
                          options = ['type']
                          action = self.action['api_action']
                          tool = self.manifest.constrain_opts(constraints,
                                                              options)[0]
                          # only one tool should be returned
                          name = list(tool.keys())[0]
                          if tool[name]['type'] == 'registry':
                              registry_image = True
                          else:
                              registry_image = False
                          kargs = {'name': 'Configure ' + t[0],
                                   'tool_name': t[0],
                                   'branch': t[1],
                                   'version': t[2],
                                   'repo': repo,
                                   'next_tool': None,
                                   'get_configure': self.api_action.get_configure,
                                   'save_configure': self.api_action.save_configure,
                                   'restart_tools': self.api_action.restart_tools,
                                   'start_tools': action.start,
                                   'from_registry': registry_image}
                          if tools_to_configure:
                              kargs['next_tool'] = tools_to_configure[-1]
                          self.parentApp.addForm('EDITOR' + t[0], EditorForm,
                                                 **kargs)
                          tools_to_configure.append('EDITOR' + t[0])
                      elif self.action['action_name'] == 'remove':
                          status = self.action['action_object1'](repo, t[0])
                      else:
                          kargs = {'name': t[0],
                                   'branch': t[1],
                                   'version': t[2]}
                          # add core recognition
                          if self.action['cores']:
                              kargs.update({'groups': 'core'})
                          # use latest version for update, not necessarily
                          # version in manifest
                          if self.action['action_name'] == 'update':
                              if t[2] != 'HEAD':
                                  repo_commits = self.tools_inst.repo_commits(repo)[
                                      1]
                                  for branch in repo_commits:
                                      if branch[0] == t[1]:
                                          kargs.update(
                                              {'new_version': branch[1][0]})
                              else:
                                  kargs.update({'new_version': 'HEAD'})
                          thr = Thread(target=self.action['action_object1'],
                                       args=(),
                                       kwargs=kargs)
                          popup(originals, self.action['type'], thr,
                                'Please wait, ' + self.action['present_t'] +
                                '...')
  
          if self.action['action_name'] != 'configure':
              npyscreen.notify_confirm('Done ' + self.action['present_t'] + '.',
                                       title=self.action['past_t'])
              self.quit()
          else:
              if len(tools_to_configure) > 0:
                  self.parentApp.change_form(tools_to_configure[-1])
              else:
                  npyscreen.notify_confirm('No tools selected, returning to'
                                           ' main menu',
                                           title='No action taken')
                  self.quit()