docs: def _post_master_init(self, master):
          '''
          Function to finish init after connecting to a master
  
          This is primarily loading modules, pillars, etc. (since they need
          to know which master they connected to)
  
          If this function is changed, please check ProxyMinion._post_master_init
          to see if those changes need to be propagated.
  
          Minions and ProxyMinions need significantly different post master setups,
          which is why the differences are not factored out into separate helper
          functions.
          '''
          if self.connected:
              self.opts['master'] = master
  
              # Initialize pillar before loader to make pillar accessible in modules
              async_pillar = salt.pillar.get_async_pillar(
                  self.opts,
                  self.opts['grains'],
                  self.opts['id'],
                  self.opts['saltenv'],
                  pillarenv=self.opts.get('pillarenv')
              )
              self.opts['pillar'] = yield async_pillar.compile_pillar()
              async_pillar.destroy()
  
          if not self.ready:
              self._setup_core()
          elif self.connected and self.opts['pillar']:
              # The pillar has changed due to the connection to the master.
              # Reload the functions so that they can use the new pillar data.
              self.functions, self.returners, self.function_errors, self.executors = self._load_modules()
              if hasattr(self, 'schedule'):
                  self.schedule.functions = self.functions
                  self.schedule.returners = self.returners
  
          if not hasattr(self, 'schedule'):
              self.schedule = salt.utils.schedule.Schedule(
                  self.opts,
                  self.functions,
                  self.returners,
                  cleanup=[master_event(type='alive')])
  
          # add default scheduling jobs to the minions scheduler
          if self.opts['mine_enabled'] and 'mine.update' in self.functions:
              self.schedule.add_job({
                  '__mine_interval':
                  {
                      'function': 'mine.update',
                      'minutes': self.opts['mine_interval'],
                      'jid_include': True,
                      'maxrunning': 2,
                      'run_on_start': True,
                      'return_job': self.opts.get('mine_return_job', False)
                  }
              }, persist=True)
              log.info('Added mine.update to scheduler')
          else:
              self.schedule.delete_job('__mine_interval', persist=True)
  
          # add master_alive job if enabled
          if (self.opts['transport'] != 'tcp' and
                  self.opts['master_alive_interval'] > 0 and
                  self.connected):
              self.schedule.add_job({
                  master_event(type='alive', master=self.opts['master']):
                  {
                      'function': 'status.master',
                      'seconds': self.opts['master_alive_interval'],
                      'jid_include': True,
                      'maxrunning': 1,
                      'return_job': False,
                      'kwargs': {'master': self.opts['master'],
                                  'connected': True}
                  }
              }, persist=True)
              if self.opts['master_failback'] and \
                      'master_list' in self.opts and \
                      self.opts['master'] != self.opts['master_list'][0]:
                  self.schedule.add_job({
                      master_event(type='failback'):
                      {
                          'function': 'status.ping_master',
                          'seconds': self.opts['master_failback_interval'],
                          'jid_include': True,
                          'maxrunning': 1,
                          'return_job': False,
                          'kwargs': {'master': self.opts['master_list'][0]}
                      }
                  }, persist=True)
              else:
                  self.schedule.delete_job(master_event(type='failback'), persist=True)
          else:
              self.schedule.delete_job(master_event(type='alive', master=self.opts['master']), persist=True)
              self.schedule.delete_job(master_event(type='failback'), persist=True)