Belle II Software  release-06-00-14
RunningTagUpdater Class Reference

Public Member Functions

def __init__ (self, db, running, staging, valid_from, mode, dry_run=False)
 
def calculate_update (self)
 
def apply_update (self)
 

Private Member Functions

def _check_state (self, tagname, taginfo, required)
 
def _check_all (self)
 
def _check_running_tag (self, tagname, payloads)
 
def _check_staging_tag_simple (self, tagname, payloads)
 
def _check_staging_tag (self, tagname, payloads)
 

Private Attributes

 _db
 Reference to the database object to use for queries.
 
 _dry_run
 If we're in dry run mode be less critical about globaltag states (just show warnings) but refuse to do any actual update.
 
 _valid_from
 First valid run for the update.
 
 _mode
 True if we want to allow payloads in the staging tag to be closed, for example when retireing a payload.
 
 _allow_closed
 Do we allow closed iovs in staging?
 
 _fix_closed
 Do we want to automatically open closed iovs?
 
 _staging_coverage
 Dictionary mapping payload names in the staging tag to the coverage they have in the staging tag, filled by check_staging_tag.
 
 _operations
 Operations for the update, filled by calculate_update()
 
 _running_info
 Globaltag information for the running tag.
 
 _staging_info
 Globaltag information for the staging tag.
 
 _running_payloads
 Payloads currently in the running tag.
 
 _staging_payloads
 Payloads currently in the staging tag.
 
 _staging_first_iovs
 First iov per payload name in staging to not close and open the same revision.
 

Detailed Description

Calculate and apply the necessary changes to update a running globaltag

For this we take two globaltags: the running one and a staging one
containing all the payloads and iovs to be added to the running tag. We then

1. Make sure they are in the correct states (RUNNING and VALIDATED)
2. Make sure all payloads in the running tag start and end (except for open
   iovs) before the given ``valid_from`` run
3. Make sure the staging tag is overlap and gap free
4. Make all payloads in staging start at either 0,0 or on/after the given
   ``valid_from`` run
5. Make sure all payloads in staging are unbound unless the mode is
   ``ALLOW_CLOSED`` or ``FIX_CLOSED``. In case of ``FIX_CLOSED`` extend the
   last iov to infinity
6. Close all payloads to be updated in the running tag that are open just
   before the validity in the staging tag.

Definition at line 55 of file runningupdate.py.

Constructor & Destructor Documentation

◆ __init__()

def __init__ (   self,
  db,
  running,
  staging,
  valid_from,
  mode,
  dry_run = False 
)
Initialize the class

Arguments:
    db (ConditionsDB): reference to the database object
    running (str): name of the running tag
    stagin (str): name of the staging tag
    valid_from (tuple(int,int)): first valid exp,run
    mode (RunningTagUpdateMode): the mode of the update
    dry_run (bool): If true only check, don't do anything.
        But be more lenient with globaltag state of staging.

Definition at line 74 of file runningupdate.py.

74  def __init__(self, db, running, staging, valid_from, mode, dry_run=False):
75  """Initialize the class
76 
77  Arguments:
78  db (ConditionsDB): reference to the database object
79  running (str): name of the running tag
80  stagin (str): name of the staging tag
81  valid_from (tuple(int,int)): first valid exp,run
82  mode (RunningTagUpdateMode): the mode of the update
83  dry_run (bool): If true only check, don't do anything.
84  But be more lenient with globaltag state of staging.
85  """
86 
87  self._db = db
88 
89  # make sure the valid_from is a tuple of two ints
90  try:
91  valid_from = tuple(map(int, valid_from))
92  if len(valid_from) != 2:
93  raise ValueError("exp,run number needs to have two elements")
94  except Exception as e:
95  raise RunningTagUpdaterError("No first valid run for the update specified", error=str(e)) from e
96 
97 
99  self._dry_run = dry_run
100 
101  self._valid_from = valid_from
102 
103 
105  self._mode = mode
106 
107  self._allow_closed = mode in (RunningTagUpdateMode.ALLOW_CLOSED, RunningTagUpdateMode.FIX_CLOSED,
108  RunningTagUpdateMode.FULL_REPLACEMENT)
109 
110  self._fix_closed = (mode == RunningTagUpdateMode.FIX_CLOSED)
111 
113  self._staging_coverage = None
114 
115  self._operations = None
116 
117 
118  self._running_info = db.get_globalTagInfo(running)
119 
120  self._staging_info = db.get_globalTagInfo(staging)
121  # make sure the tags can be found and have the correct state
122  self._check_state(running, self._running_info, "RUNNING")
123  self._check_state(staging, self._staging_info, "VALIDATED")
124 
125  # Get the actual payloads
126 
127  self._running_payloads = db.get_all_iovs(self._running_info['name'])
128 
129  self._staging_payloads = db.get_all_iovs(self._staging_info['name'])
130 
131  self._staging_first_iovs = {}
132 

Member Function Documentation

◆ _check_all()

def _check_all (   self)
private
Run all necessary checks on all globaltags

Definition at line 156 of file runningupdate.py.

◆ _check_running_tag()

def _check_running_tag (   self,
  tagname,
  payloads 
)
private
Check that all payloads in the running tag start and end (or are open)
before the first valid run for the update

Definition at line 168 of file runningupdate.py.

◆ _check_staging_tag()

def _check_staging_tag (   self,
  tagname,
  payloads 
)
private
Check if the staging tag is
    1. overlap free
    2. gap free
    3. all payloads are open (unless the mode allows closed payloads)
    4. all payloads start at 0,0 or after the first valid run for the update

Arguments:
    tagname (str): Name of the globaltag for error messages
    payloads (list(conditions_db.PayloadInformation)): List of payloads in the tag

Definition at line 233 of file runningupdate.py.

◆ _check_staging_tag_simple()

def _check_staging_tag_simple (   self,
  tagname,
  payloads 
)
private
Extra simple case where we want to have a very simple staging tag just
consisting of (0,0,-1,-1) iovs, one per payload

Definition at line 204 of file runningupdate.py.

◆ _check_state()

def _check_state (   self,
  tagname,
  taginfo,
  required 
)
private
Check the state of a globaltag given the tag information object returned by the database

1) that it's found and
2) that it has the same state as in ``required``

Parameters:
    tagname: name of the tag for error messages
    taginfo: tag information returned from the database, None if the tag could not be found
    required: required state for the tag.

Raises:
    an `RunningTagUpdaterError` if any condition is not fulfilled

Definition at line 133 of file runningupdate.py.

◆ apply_update()

def apply_update (   self)
Apply a previously calculated update to the globaltag

Warning:
    This action cannot be undone, only call it after checking the
    operations returned by the calculation of the update

Definition at line 379 of file runningupdate.py.

◆ calculate_update()

def calculate_update (   self)
Calculate the operations needed to merge staging into the running base tag

Definition at line 330 of file runningupdate.py.


The documentation for this class was generated from the following file: