wmglobalqueue 2.4.5.1__py3-none-any.whl

WMCore/REST/Services.py

@@ -0,0 +1,24 @@
+from __future__ import print_function, division
+
+import time
+from Utils.ProcessStats import processStatusDict
+from WMCore.REST.Format import JSONFormat, PrettyJSONFormat
+from WMCore.REST.Server import RESTEntity, restcall, rows
+
+class ProcessMatrix(RESTEntity):
+    """
+    Process and thread matrix in reqmgr2
+    """
+    def __init__(self, app, api, config, mount):
+        # CouchDB auxiliary database name
+        RESTEntity.__init__(self, app, api, config, mount)
+        self.time0 = time.time()
+
+    def validate(self, apiobj, method, api, param, safe):
+        pass
+
+    @restcall(formats=[('text/plain', PrettyJSONFormat()), ('application/json', JSONFormat())])
+    def get(self):
+        sdict = {'server': processStatusDict()}
+        sdict['server'].update({'uptime': time.time() - self.time0})
+        return rows([sdict])

WMCore/REST/Test.py

@@ -0,0 +1,120 @@
+
+from Utils.Utilities import encodeUnicodeToBytes
+from future.utils import viewitems, viewvalues, listitems
+
+import os, hmac, hashlib, cherrypy
+from tempfile import NamedTemporaryFile
+
+from Utils.PythonVersion import PY3
+
+from WMCore.REST.Main import RESTMain
+from WMCore.REST.Auth import authz_canonical
+from WMCore.Configuration import Configuration
+
+def fake_authz_headers(hmac_key, method = 'HNLogin',
+                       login='testuser', name='Test User',
+                       dn="/test/dn", roles={}, format="list"):
+    """Create fake authentication and authorisation headers compatible
+    with the CMSWEB front-ends. Assumes you have the HMAC signing key
+    the back-end will use to validate the headers.
+
+    :arg str hmac_key: binary key data for signing headers.
+    :arg str method: authentication method, one of X509Cert, X509Proxy,
+      HNLogin, HostIP, AUCookie or None.
+    :arg str login: account login name.
+    :arg str name: account user name.
+    :arg str dn: account X509 subject.
+    :arg dict roles: role dictionary, each role with 'site' and 'group' lists.
+    :returns: list of header name, value tuples to add to a HTTP request."""
+    headers = { 'cms-auth-status': 'OK', 'cms-authn-method': method }
+
+    if login:
+        headers['cms-authn-login'] = login
+
+    if name:
+        headers['cms-authn-name'] = name
+
+    if dn:
+        headers['cms-authn-dn'] = dn
+
+    for name, role in viewitems(roles):
+        name = 'cms-authz-' + authz_canonical(name)
+        headers[name] = []
+        for r in 'site', 'group':
+            if r in role:
+                headers[name].extend(["%s:%s" % (r, authz_canonical(v)) for v in role[r]])
+        headers[name] = " ".join(headers[name])
+
+    prefix = suffix = ""
+    hkeys = list(headers)
+    for hk in sorted(hkeys):
+        if hk != 'cms-auth-status':
+            prefix += "h%xv%x" % (len(hk), len(headers[hk]))
+            suffix += "%s%s" % (hk, headers[hk])
+
+    msg = prefix + "#" + suffix
+    if PY3:
+        hmac_key = encodeUnicodeToBytes(hmac_key)
+        msg = encodeUnicodeToBytes(msg)
+    cksum = hmac.new(hmac_key, msg, hashlib.sha1).hexdigest()
+    headers['cms-authn-hmac'] = cksum
+    if format == "list":
+        return listitems(headers)
+    else:
+        return headers
+
+def fake_authz_key_file(delete=True):
+    """Create temporary file for fake authorisation hmac signing key.
+
+    :returns: Instance of :class:`~.NamedTemporaryFile`, whose *data*
+      attribute contains the HMAC signing binary key."""
+    t = NamedTemporaryFile(delete=delete)
+    with open("/dev/urandom", "rb") as fd:
+        t.data = fd.read(20)
+    t.write(t.data)
+    t.seek(0)
+    return t
+
+def setup_dummy_server(module_name, class_name, app_name = None, authz_key_file=None, port=8888):
+    """Helper function to set up a :class:`~.RESTMain` server from given
+    module and class. Creates a fake server configuration and instantiates
+    the server application from it.
+
+    :arg str module_name: module from which to import test class.
+    :arg str class_type: name of the server test class.
+    :arg str app_name: optional test application name, 'test' by default.
+    :returns: tuple with the server object and authz hmac signing key."""
+    if authz_key_file:
+        test_authz_key = authz_key_file
+    else:
+        test_authz_key = fake_authz_key_file()
+
+    cfg = Configuration()
+    main = cfg.section_('main')
+    main.application = app_name or 'test'
+    main.silent = True
+    main.index = 'top'
+    main.authz_defaults = { 'role': None, 'group': None, 'site': None }
+    main.section_('tools').section_('cms_auth').key_file = test_authz_key.name
+
+    app = cfg.section_(app_name or 'test')
+    app.admin = 'dada@example.org'
+    app.description = app.title = 'Test'
+
+    views = cfg.section_('views')
+    top = views.section_('top')
+    top.object = module_name + "." + class_name
+
+    server = RESTMain(cfg, os.getcwd())
+    server.validate_config()
+    server.setup_server()
+    server.install_application()
+    cherrypy.config.update({'server.socket_port': port})
+    cherrypy.config.update({'server.socket_host': '127.0.0.1'})
+    cherrypy.config.update({'request.show_tracebacks': True})
+    cherrypy.config.update({'environment': 'test_suite'})
+    for app in viewvalues(cherrypy.tree.apps): 
+        if '/' in app.config:
+            app.config["/"]["request.show_tracebacks"] = True
+
+    return server, test_authz_key

WMCore/REST/Tools.py

@@ -0,0 +1,38 @@
+import time
+
+import cherrypy
+from cherrypy import Tool, request, tools
+
+from WMCore.REST.Auth import RESTAuth
+
+
+def set_request_time():
+    """Utility to time stamp the start of HTTP request handling."""
+    request.start_time = time.time()
+
+
+def set_proxy_base(base=None):
+    """Utility to correctly handle requests behind a proxy."""
+    scheme = request.headers.get('X-Forwarded-Proto', request.base[:request.base.find("://")])
+    base = request.headers.get('X-Forwarded-Host', base)
+    if not base:
+        port = cherrypy.request.local.port
+        if port == 80:
+            base = 'localhost'
+        else:
+            base = 'localhost:%s' % port
+
+    base = base.split(',')[0].strip()
+    if base.find("://") == -1:
+        base = scheme + "://" + base
+    request.base = base
+
+    xff = request.headers.get('X-Forwarded-For')
+    if xff:
+        xff = xff.split(',')[0].strip()
+        request.remote.ip = xff
+
+
+tools.cms_auth = RESTAuth()
+tools.time = Tool('on_start_resource', set_request_time)
+tools.proxy = Tool('before_request_body', set_proxy_base, priority=30)

WMCore/REST/Validation.py

@@ -0,0 +1,250 @@
+from builtins import str as newstr, bytes as newbytes
+
+from WMCore.REST.Error import *
+import math
+import re
+import numbers
+
+from Utils.Utilities import decodeBytesToUnicodeConditional, encodeUnicodeToBytesConditional
+from Utils.PythonVersion import PY3, PY2
+
+def return_message(main_err, custom_err):
+    if custom_err:
+        return custom_err
+    return main_err
+
+def _arglist(argname, kwargs):
+    val = kwargs.get(argname, None)
+    if val == None:
+        return []
+    elif not isinstance(val, list):
+        return [ val ]
+    else:
+        return val
+
+def _check_rx(argname, val, custom_err = None):
+    if not isinstance(val, (newstr, newbytes)):
+        raise InvalidParameter(return_message("Incorrect '%s' parameter" % argname, custom_err))
+    try:
+        return re.compile(val)
+    except:
+        raise InvalidParameter(return_message("Incorrect '%s' parameter" % argname, custom_err))
+
+def _check_str(argname, val, rx, custom_err = None):
+    """
+    This is not really check val is ASCII.
+    2021 09: we are now using version 17.4.0 -> we do not need to convert to 
+    bytes here anymore, we are using a recent verison of cherrypy.
+    We merged the funcionality of _check_str and _check_ustr into a single function
+
+    :type val: str or bytes (only utf8 encoded string) in py3, unicode or str in py2
+    :type rx: regex, compiled from native str (unicode in py3, bytes in py2)
+    """
+    val = decodeBytesToUnicodeConditional(val, condition=PY3)
+    val = encodeUnicodeToBytesConditional(val, condition=PY2)
+    # `val` should now be a "native str" (unicode in py3, bytes in py2)
+    # here str has not been redefined. it is default `str` in both py2 and py3.
+    if not isinstance(val, str) or not rx.match(val):
+        raise InvalidParameter(return_message("Incorrect '%s' parameter %s %s" % (argname, type(val), val), custom_err))
+    return val
+
+def _check_num(argname, val, bare, minval, maxval, custom_err = None):
+    if not isinstance(val, numbers.Integral) and (not isinstance(val, (newstr, newbytes)) or (bare and not val.isdigit())):
+        raise InvalidParameter(return_message("Incorrect '%s' parameter" % argname, custom_err))
+    try:
+        n = int(val)
+        if (minval != None and n < minval) or (maxval != None and n > maxval):
+            raise InvalidParameter(return_message("Parameter '%s' value out of bounds" % argname, custom_err))
+        return n
+    except InvalidParameter:
+        raise
+    except:
+        raise InvalidParameter(return_message("Invalid '%s' parameter" % argname, custom_err))
+
+def _check_real(argname, val, special, minval, maxval, custom_err = None):
+    if not isinstance(val, numbers.Number) and not isinstance(val, (newstr, newbytes)):
+        raise InvalidParameter(return_message("Incorrect '%s' parameter" % argname, custom_err))
+    try:
+        n = float(val)
+        if not special and (math.isnan(n) or math.isinf(n)):
+            raise InvalidParameter(return_message("Parameter '%s' improper value" % argname, custom_err))
+        if (minval != None and n < minval) or (maxval != None and n > maxval):
+            raise InvalidParameter(return_message("Parameter '%s' value out of bounds" % argname, custom_err))
+        return n
+    except InvalidParameter:
+        raise
+    except:
+        raise InvalidParameter(return_message("Invalid '%s' parameter" % argname, custom_err))
+
+def _validate_one(argname, param, safe, checker, optional, *args):
+    val = param.kwargs.get(argname, None)
+    if optional and val == None:
+        safe.kwargs[argname] = None
+    else:
+        safe.kwargs[argname] = checker(argname, val, *args)
+        del param.kwargs[argname]
+
+def _validate_all(argname, param, safe, checker, *args):
+    safe.kwargs[argname] = [checker(argname, v, *args) for v in _arglist(argname, param.kwargs)]
+    if argname in param.kwargs:
+        del param.kwargs[argname]
+
+def validate_rx(argname, param, safe, optional = False, custom_err = None):
+    """Validates that an argument is a valid regexp.
+
+    Checks that an argument named `argname` exists in `param.kwargs`,
+    and it a string which compiles into a python regular expression.
+    If successful, the regexp object (not the string) is copied into
+    `safe.kwargs` and the string value is removed from `param.kwargs`.
+
+    If `optional` is True, the argument is not required to exist in
+    `param.kwargs`; None is then inserted into `safe.kwargs`. Otherwise
+    a missing value raises an exception."""
+    _validate_one(argname, param, safe, _check_rx, optional, custom_err)
+
+def validate_str(argname, param, safe, rx, optional = False, custom_err = None):
+    """Validates that an argument is a string and matches a regexp.
+
+    Checks that an argument named `argname` exists in `param.kwargs`
+    and it is a string which matches regular expression `rx`. If
+    successful the string is copied into `safe.kwargs` and the value
+    is removed from `param.kwargs`.
+
+    Accepts both unicode strings and utf8-encoded bytes strings as argument 
+    string.
+    Accepts regex compiled only with "native strings", which means  str in both 
+    py2 and py3 (unicode in py3, bytes of utf8-encoded strings in py2)
+
+    If `optional` is True, the argument is not required to exist in
+    `param.kwargs`; None is then inserted into `safe.kwargs`. Otherwise
+    a missing value raises an exception."""
+    _validate_one(argname, param, safe, _check_str, optional, rx, custom_err)
+
+def validate_num(argname, param, safe, optional = False,
+                 bare = False, minval = None, maxval = None, custom_err = None):
+    """Validates that an argument is a valid integer number.
+
+    Checks that an argument named `argname` exists in `param.kwargs`,
+    and it is an int or a string convertible to a valid number. If successful
+    the integer value (not the string) is copied into `safe.kwargs`
+    and the original int/string value is removed from `param.kwargs`.
+
+    If `optional` is True, the argument is not required to exist in
+    `param.kwargs`; None is then inserted into `safe.kwargs`. Otherwise
+    a missing value raises an exception.
+
+    If `bare` is True, the number is required to be a pure digit sequence if it is a string.
+    Otherwise anything accepted by `int(val)` is acceted, including for
+    example leading white space or sign. Note that either way arbitrarily
+    large values are accepted; if you want to prevent abuse against big
+    integers, use the `minval` and `maxval` thresholds described below,
+    or check the length the of the string against some limit first.
+
+    If `minval` or `maxval` are given, values less than or greater than,
+    respectively, the threshold are rejected."""
+    _validate_one(argname, param, safe, _check_num, optional, bare, minval, maxval, custom_err)
+
+def validate_real(argname, param, safe, optional = False,
+                  special = False, minval = None, maxval = None, custom_err = None):
+    """Validates that an argument is a valid real number.
+
+    Checks that an argument named `argname` exists in `param.kwargs`,
+    and it is float number or a string convertible to a valid number. If successful
+    the float value (not the string) is copied into `safe.kwargs`
+    and the original float/string value is removed from `param.kwargs`.
+
+    If `optional` is True, the argument is not required to exist in
+    `param.kwargs`; None is then inserted into `safe.kwargs`. Otherwise
+    a missing value raises an exception.
+
+    Anything accepted by `float(val)` is accepted, including for example
+    leading white space, sign and exponent. However NaN and +/- Inf are
+    rejected unless `special` is True.
+
+    If `minval` or `maxval` are given, values less than or greater than,
+    respectively, the threshold are rejected."""
+    _validate_one(argname, param, safe, _check_real, optional, special, minval, maxval, custom_err)
+
+def validate_rxlist(argname, param, safe, custom_err = None):
+    """Validates that an argument is an array of strings, each of which
+    can be compiled into a python regexp object.
+
+    Checks that an argument named `argname` is either a single string or
+    an array of strings, each of which compiles into a regular expression.
+    If successful the array is copied into `safe.kwargs` and the value is
+    removed from `param.kwargs`. The value always becomes an array in
+    `safe.kwargs`, even if no or only one argument was provided.
+
+    Note that an array of zero length is accepted, meaning there were no
+    `argname` parameters at all in `param.kwargs`."""
+    _validate_all(argname, param, safe, _check_rx, custom_err)
+
+def validate_strlist(argname, param, safe, rx, custom_err = None):
+    """Validates that an argument is an array of strings, each of which
+    matches a regexp.
+
+    Checks that an argument named `argname` is either a single string or
+    an array of strings, each of which matches the regular expression
+    `rx`. If successful the array is copied into `safe.kwargs` and the
+    value is removed from `param.kwargs`. The value always becomes an
+    array in `safe.kwargs`, even if no or only one argument was provided.
+
+    Use this method only for inputs which are meant to be bare strings.
+
+    Note that an array of zero length is accepted, meaning there were no
+    `argname` parameters at all in `param.kwargs`."""
+    _validate_all(argname, param, safe, _check_str, rx, custom_err)
+
+def validate_numlist(argname, param, safe, bare=False, minval=None, maxval=None, custom_err = None):
+    """Validates that an argument is an array of integers, as checked by
+    `validate_num()`.
+
+    Checks that an argument named `argname` is either a single string/int or
+    an array of strings/int, each of which validates with `validate_num` and
+    `bare`, `minval` and `maxval` arguments.  If successful the array is
+    copied into `safe.kwargs` and the value is removed from `param.kwargs`.
+    The value always becomes an array in `kwsafe`, even if no or only one
+    argument was provided.
+
+    Note that an array of zero length is accepted, meaning there were no
+    `argname` parameters at all in `param.kwargs`."""
+    _validate_all(argname, param, safe, _check_num, bare, minval, maxval, custom_err)
+
+def validate_reallist(argname, param, safe, special=False, minval=None, maxval=None, custom_err = None):
+    """Validates that an argument is an array of integers, as checked by
+    `validate_real()`.
+
+    Checks that an argument named `argname` is either a single string/float or
+    an array of strings/floats, each of which validates with `validate_real` and
+    `special`, `minval` and `maxval` arguments.  If successful the array is
+    copied into `safe.kwargs` and the value is removed from `param.kwargs`.
+    The value always becomes an array in `safe.kwargs`, even if no or only
+    one argument was provided.
+
+    Note that an array of zero length is accepted, meaning there were no
+    `argname` parameters at all in `param.kwargs`."""
+    _validate_all(argname, param, safe, _check_real, special, minval, maxval, custom_err)
+
+def validate_no_more_input(param):
+    """Verifies no more input is left in `param.args` or `param.kwargs`."""
+    if param.args:
+        raise InvalidParameter("Excess path arguments, not validated args='%s'" % param.args)
+    if param.kwargs:
+        raise InvalidParameter("Excess keyword arguments, not validated kwargs='%s'" % param.kwargs)
+
+def validate_lengths(safe, *names):
+    """Verifies that all `names` exist in `safe.kwargs`, are lists, and
+    all the lists have the same length. This is convenience function for
+    checking that an API accepting multiple values receives equal number
+    of values for all of its parameters."""
+    refname = names[0]
+    if refname not in safe.kwargs or not isinstance(safe.kwargs[refname], list):
+        raise InvalidParameter("Incorrect '%s' parameter" % refname)
+
+    reflen = len(safe.kwargs[refname])
+    for other in names[1:]:
+        if other not in safe.kwargs or not isinstance(safe.kwargs[other], list):
+            raise InvalidParameter("Incorrect '%s' parameter" % other)
+        elif len(safe.kwargs[other]) != reflen:
+            raise InvalidParameter("Mismatched number of arguments: %d %s vs. %d %s"
+                                   % (reflen, refname, len(safe.kwargs[other]), other))

WMCore/REST/__init__.py

@@ -0,0 +1 @@
+"""WMCore.REST module"""

WMCore/ReqMgr/DataStructs/RequestStatus.py

@@ -0,0 +1,209 @@
+"""
+Definition of valid status values for a request and valid status transitions.
+
+"""
+
+from future.utils import viewitems
+
+# make this list to ensure insertion order here
+REQUEST_START_STATE = "new"
+REQUEST_STATE_TRANSITION = {
+    REQUEST_START_STATE: [REQUEST_START_STATE,
+                          "assignment-approved",
+                          "rejected"],
+
+    "assignment-approved": ["assigned",  # manual transition
+                            "rejected"],  # manual transition
+
+    "assigned": ["staging",
+                 "aborted"],  # manual transition
+    "staging": ["staged",
+                "aborted"],  # manual transition
+    "staged": ["acquired",
+               "aborted",  # manual transition
+               "failed"],
+    "acquired": ["running-open",
+                 "aborted",  # manual transition
+                 "failed"],
+    "running-open": ["running-closed",
+                     "force-complete",  # manual transition
+                     "aborted"],  # manual transition
+
+    "running-closed": ["force-complete",  # manual transition
+                       "completed",
+                       "aborted"],  # manual transition
+
+    "force-complete": ["completed"],
+
+    "failed": ["rejected",  # manual transition
+               "assigned"],  # manual transition
+
+    "completed": ["closed-out",
+                  "rejected"],  # manual transition
+
+    "closed-out": ["announced", "rejected"],  # manual transition
+
+    "announced": ["rejected", "normal-archived"],
+
+    "aborted": ["aborted-completed"],
+
+    "aborted-completed": ["aborted-archived"],
+
+    "rejected": ["rejected-archived"],
+
+    # final status
+    "normal-archived": ["rejected-archived"],
+
+    "aborted-archived": [],
+
+    "rejected-archived": []
+}
+
+# List of requests that a human user can change a request to
+REQUEST_HUMAN_STATES = ["assignment-approved",
+                        "assigned",
+                        "force-complete",
+                        "closed-out",
+                        "announced",
+                        "rejected",
+                        "aborted"]
+
+ACTIVE_STATUS = ["new",
+                 "assignment-approved",
+                 "assigned",
+                 "staging",
+                 "staged",
+                 "acquired",
+                 "running-open",
+                 "running-closed",
+                 "failed",
+                 "force-complete",
+                 "completed",
+                 "closed-out",
+                 "announced",
+                 "aborted",
+                 "aborted-completed",
+                 "rejected"]
+
+### WMSTATS_JOB_INFO + WMSTATS_NO_JOB_INFO is meant to be equal to ACTIVE_STATUS
+WMSTATS_JOB_INFO = ["running-open",
+                    "running-closed",
+                    "force-complete",
+                    "completed",
+                    "closed-out"]
+
+WMSTATS_NO_JOB_INFO = ["new",
+                       "assignment-approved",
+                       "assigned",
+                       "staging",
+                       "staged",
+                       "acquired",
+                       "failed",
+                       "announced",
+                       "aborted",
+                       "aborted-completed",
+                       "rejected"]
+
+### Used for monitoring in T0-WMStats. See: Services/WMStats/WMStatsReader
+T0_ACTIVE_STATUS = ["new",
+                    "Closed",
+                    "Merge",
+                    "Harvesting",
+                    "Processing Done",
+                    "AlcaSkim",
+                    "completed"]
+
+# if the state is not defined here (new) allows all the property to get
+# states in the key is the source states (need to define source states instead of destination states for GUI update)
+ALLOWED_ACTIONS_FOR_STATUS = {
+    "new": ["RequestPriority"],
+    "assignment-approved": ["RequestPriority", "Team", "SiteWhitelist", "SiteBlacklist",
+                            "AcquisitionEra", "ProcessingString", "ProcessingVersion",
+                            "Dashboard", "MergedLFNBase", "TrustSitelists",
+                            "UnmergedLFNBase", "MinMergeSize", "MaxMergeSize",
+                            "MaxMergeEvents", "BlockCloseMaxWaitTime",
+                            "BlockCloseMaxFiles", "BlockCloseMaxEvents", "BlockCloseMaxSize",
+                            "SoftTimeout", "GracePeriod",
+                            "TrustPUSitelists", "CustodialSites",
+                            "NonCustodialSites", "Override",
+                            "SubscriptionPriority"],
+    "assigned": ["RequestPriority"],
+    "staging": ["RequestPriority", "SiteWhitelist", "SiteBlacklist"],
+    "staged": ["RequestPriority"],
+    "acquired": ["RequestPriority", "SiteWhitelist", "SiteBlacklist"],
+    "running-open": ["RequestPriority", "SiteWhitelist", "SiteBlacklist"],
+    "running-closed": ["RequestPriority"],
+    "failed": [],
+    "force-complete": [],
+    "completed": [],
+    "closed-out": [],
+    "announced": [],
+    "aborted": [],
+    "aborted-completed": [],
+    "rejected": [],
+    "normal-archived": [],
+    "aborted-archived": [],
+    "rejected-archived": [],
+}
+
+# NOTE: We need to Explicitly add RequestStatus to reqArgsDiff, since it is
+#       missing from the ALLOWED_ACTIONS_FOR_STATUS mapping. The alternative
+#       would be to add it as allowed action to every state.
+#       The same applies to few more, such as all the keys needed for the
+#       workqueue_stat_validation() calls, but we do this only during
+#       request parameters validation.
+ALLOWED_ACTIONS_ALL_STATUS = ["RequestStatus"]
+
+# NOTE: We need to explicitly add all stat keys during validation
+#       They are needed for the workqueue_stat_validation() calls
+ALLOWED_STAT_KEYS = ['total_jobs', 'input_lumis', 'input_events', 'input_num_files']
+
+# Workflow state transition automatically controlled by ReqMgr2
+### NOTE: order of this list matters and it's used for status transition
+AUTO_TRANSITION = {"staged": ["acquired", "running-open", "running-closed", "completed"],
+                   "acquired": ["running-open", "running-closed", "completed"],
+                   "running-open": ["running-closed", "completed"],
+                   "running-closed": ["completed"]}
+
+# Workflow state transition automatically controlled by ReqMgr2
+# Specific to workflows either aborted or force-completed
+CANCEL_AUTO_TRANSITION = {"aborted": "aborted-completed",
+                          "force-complete": "completed"}
+
+# list of destination states which doesn't allow any additional argument update
+STATES_ALLOW_ONLY_STATE_TRANSITION = [key for key, val in viewitems(ALLOWED_ACTIONS_FOR_STATUS) if len(val) == 0]
+# each item from STATUS_TRANSITION is a dictionary with 1 item, the key
+# is name of the status
+REQUEST_STATE_LIST = list(REQUEST_STATE_TRANSITION)
+
+ACTIVE_STATUS_FILTER = {"RequestStatus": ['assignment-approved', 'assigned', 'staging', 'staged',
+                                          'failed', 'acquired', 'running-open', 'running-closed',
+                                          'force-complete', 'completed', 'closed-out']}
+
+
+def check_allowed_transition(preState, postState):
+    stateList = REQUEST_STATE_TRANSITION.get(preState, [])
+    if postState in stateList:
+        return True
+    else:
+        return False
+
+
+def get_modifiable_properties(status=None):
+    """
+    returns mondifiable property list by status.
+    if status is not defined return dictionarly of all the status and property list
+    TODO: Currently gets the result from hardcoded list. change to get from configuration or db
+    """
+    if status:
+        allowedKeys = ALLOWED_ACTIONS_FOR_STATUS.get(status, 'all_attributes')
+        return allowedKeys
+    else:
+        return ALLOWED_ACTIONS_FOR_STATUS
+
+
+def get_protected_properties():
+    """
+    returns properties never be modified once request is created
+    """
+    return ["RequestName", "_id"]

WMCore/ReqMgr/DataStructs/RequestType.py

@@ -0,0 +1,13 @@
+"""
+List of valid request types.
+
+"""
+
+REQUEST_TYPES = [
+    "ReReco",
+    "StoreResults",
+    "Resubmission",
+    "TaskChain",
+    "DQMHarvest",
+    "StepChain"
+]

WMCore/ReqMgr/__init__.py

@@ -0,0 +1 @@
+