docs: def call_high(self, high, orchestration_jid=None):
          '''
          Process a high data call and ensure the defined states.
          '''
          self.inject_default_call(high)
          errors = []
          # If there is extension data reconcile it
          high, ext_errors = self.reconcile_extend(high)
          errors.extend(ext_errors)
          errors.extend(self.verify_high(high))
          if errors:
              return errors
          high, req_in_errors = self.requisite_in(high)
          errors.extend(req_in_errors)
          high = self.apply_exclude(high)
          # Verify that the high data is structurally sound
          if errors:
              return errors
          # Compile and verify the raw chunks
          chunks = self.compile_high_data(high, orchestration_jid)
  
          # If there are extensions in the highstate, process them and update
          # the low data chunks
          if errors:
              return errors
          ret = self.call_chunks(chunks)
          ret = self.call_listen(chunks, ret)
  
          def _cleanup_accumulator_data():
              accum_data_path = os.path.join(
                  get_accumulator_dir(self.opts['cachedir']),
                  self.instance_id
              )
              try:
                  os.remove(accum_data_path)
                  log.debug('Deleted accumulator data file %s', accum_data_path)
              except OSError:
                  log.debug('File %s does not exist, no need to cleanup', accum_data_path)
          _cleanup_accumulator_data()
          if self.jid is not None:
              pause_path = os.path.join(self.opts['cachedir'], 'state_pause', self.jid)
              if os.path.isfile(pause_path):
                  try:
                      os.remove(pause_path)
                  except OSError:
                      # File is not present, all is well
                      pass
  
          return ret