code: def manage_job(self, job_record):
          
          assert isinstance(job_record, Job)
          try:
              if self._is_noop_timeperiod(job_record.process_name, job_record.timeperiod):
                  self._process_noop_timeperiod(job_record)
                  return
  
              if job_record.is_embryo:
                  self._process_state_embryo(job_record)
  
              elif job_record.is_in_progress:
                  self._process_state_in_progress(job_record)
  
              elif job_record.is_final_run:
                  self._process_state_final_run(job_record)
  
              elif job_record.is_skipped:
                  self._process_terminal_state(job_record)
  
              elif job_record.is_processed:
                  self._process_terminal_state(job_record)
  
              elif job_record.is_noop:
                  self._process_terminal_state(job_record)
  
              else:
                  msg = 'Unknown state {0} of the job {1}'.format(job_record.state, job_record.db_id)
                  self._log_message(ERROR, job_record.process_name, job_record.timeperiod, msg)
  
          except LookupError as e:
              job_record.number_of_failures += 1
              self.job_dao.update(job_record)
              self.timetable.skip_if_needed(job_record)
              msg = 'Increasing fail counter for Job {0}@{1}, because of: {2}' \
                    .format(job_record.process_name, job_record.timeperiod, e)
              self._log_message(WARNING, job_record.process_name, job_record.timeperiod, msg)
  
          finally:
              self.mq_transmitter.publish_job_status(job_record)
docs: method main duty - is to _avoid_ publishing another unit_of_work, if previous was not yet processed
              In case the State Machine sees that the unit_of_work already exist it could either:
              - update boundaries of the processing; republish
              - wait another tick; idle