taskflow 5.8.0__py3-none-any.whl → 5.9.1__py3-none-any.whl

taskflow/engines/action_engine/runtime.py

@@ -291,6 +291,18 @@ class Runtime(object):
         """Resets all the provided atoms to the given state and intention."""
         tweaked = []
         for atom in atoms:
+            cur_intention = self.storage.get_atom_intention(atom.name)
+            # Don't trigger a RETRY if the atom needs to be REVERTED.
+            # This is a workaround for a bug when REVERT_ALL is applied to
+            # unordered flows
+            # (https://bugs.launchpad.net/taskflow/+bug/2043808)
+            # A subflow may trigger a REVERT_ALL, all the atoms of all the
+            # related subflows are marked as REVERT but a task of a related
+            # flow may still be running in another thread. If this task
+            # triggers a RETRY, it overrides the previously set REVERT status,
+            # breaking the revert path of the flow.
+            if cur_intention == st.REVERT and intention == st.RETRY:
+                continue
             if state or intention:
                 tweaked.append((atom, state, intention))
             if state:

taskflow/jobs/backends/impl_etcd.py

@@ -0,0 +1,610 @@
+#    Copyright (C) Red Hat
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import threading
+import typing
+
+import etcd3gw
+import fasteners
+from oslo_serialization import jsonutils
+from oslo_utils import timeutils
+from oslo_utils import uuidutils
+
+from taskflow import exceptions as exc
+from taskflow.jobs import base
+from taskflow import logging
+from taskflow import states
+from taskflow.utils import misc
+if typing.TYPE_CHECKING:
+    from taskflow.types import entity
+
+LOG = logging.getLogger(__name__)
+
+
+class EtcdJob(base.Job):
+    """An Etcd job."""
+
+    board: 'EtcdJobBoard'
+
+    def __init__(self, board: 'EtcdJobBoard', name, client, key,
+                 uuid=None, details=None, backend=None,
+                 book=None, book_data=None,
+                 priority=base.JobPriority.NORMAL,
+                 sequence=None, created_on=None):
+        super().__init__(board, name, uuid=uuid, details=details,
+                         backend=backend, book=book, book_data=book_data)
+
+        self._client = client
+        self._key = key
+        self._priority = priority
+        self._sequence = sequence
+        self._created_on = created_on
+        self._root = board._root_path
+
+        self._lease = None
+
+    @property
+    def key(self):
+        return self._key
+
+    @property
+    def last_modified(self):
+        try:
+            raw_data = self.board.get_last_modified(self)
+            data = jsonutils.loads(raw_data)
+            ret = timeutils.parse_strtime(data["last_modified"])
+            return ret
+        except Exception:
+            LOG.exception("Cannot read load_modified key.")
+        return 0
+
+    @property
+    def created_on(self):
+        return self._created_on
+
+    @property
+    def state(self):
+        """Access the current state of this job."""
+        owner, data = self.board.get_owner_and_data(self)
+        if not data:
+            if owner is not None:
+                LOG.info(f"Owner key was found for job {self.uuid}, "
+                         f"but the key {self.key} is missing")
+            return states.COMPLETE
+        if not owner:
+            return states.UNCLAIMED
+        return states.CLAIMED
+
+    @property
+    def sequence(self):
+        return self._sequence
+
+    @property
+    def priority(self):
+        return self._priority
+
+    @property
+    def lease(self):
+        if not self._lease:
+            owner_data = self.board.get_owner_data(self)
+            if 'lease_id' not in owner_data:
+                return None
+            lease_id = owner_data['lease_id']
+            self._lease = etcd3gw.Lease(id=lease_id,
+                                        client=self._client)
+        return self._lease
+
+    def expires_in(self):
+        """How many seconds until the claim expires."""
+        if self.lease is None:
+            return -1
+        return self.lease.ttl()
+
+    def extend_expiry(self, expiry):
+        """Extends the owner key (aka the claim) expiry for this job.
+
+        Returns ``True`` if the expiry request was performed
+        otherwise ``False``.
+        """
+        if self.lease is None:
+            return False
+        ret = self.lease.refresh()
+        return (ret > 0)
+
+    @property
+    def root(self):
+        return self._root
+
+    def __lt__(self, other):
+        if not isinstance(other, EtcdJob):
+            return NotImplemented
+        if self.root == other.root:
+            if self.priority == other.priority:
+                return self.sequence < other.sequence
+            else:
+                ordered = base.JobPriority.reorder(
+                    (self.priority, self), (other.priority, other))
+                if ordered[0] is self:
+                    return False
+                return True
+        else:
+            # Different jobboards with different roots...
+            return self.root < other.root
+
+    def __eq__(self, other):
+        if not isinstance(other, EtcdJob):
+            return NotImplemented
+        return ((self.root, self.sequence, self.priority) ==
+                (other.root, other.sequence, other.priority))
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash(self.key)
+
+
+class EtcdJobBoard(base.JobBoard):
+    """A jobboard backed by `etcd`_.
+
+    This jobboard creates sequenced key/value pairs in etcd. Each key
+    represents a job and its associated value contains the parameter of the
+    job encoded in
+    json.
+    The users of the jobboard can iterate over the available job and decide if
+    they want to attempt to claim one job by calling the :meth:`.claim` method.
+    Claiming a job consists in atomically create a key based on the key of job
+    and the ".lock" postfix. If the atomic creation of the key is successful
+    the job belongs to the user. Any attempt to lock an already locked job
+    will fail.
+    When a job is complete, the user consumes the job by calling the
+    :meth:`.consume` method, it deletes the job and the lock from etcd.
+    Alternatively, a user can trash (:meth:`.trash`) or abandon
+    (:meth:`.abandon`) if they want to delete the job or leave it for another
+    user.
+    Etcd doesn't provide a method for unlocking the jobs when a consumer dies.
+    The Etcd jobboard provides timed expirations, based on a global ``ttl``
+    configuration setting or the ``expiry`` parameter of the :meth:`.claim`
+    method. When this time-to-live/expiry is reached, the job is automatically
+    unlocked and another consumer can claim it. If it is expected that a task
+    of a job takes more time than the defined time-to-live, the
+    consumer can refresh the timer by calling the :meth:`EtcdJob.extend_expiry`
+    function.
+
+    .. _etcd: https://etcd.io/
+    """
+    ROOT_PATH = "/taskflow/jobs"
+
+    TRASH_PATH = "/taskflow/.trash"
+
+    DEFAULT_PATH = "jobboard"
+
+    JOB_PREFIX = "job"
+
+    SEQUENCE_KEY = "sequence"
+
+    DATA_POSTFIX = ".data"
+
+    LOCK_POSTFIX = ".lock"
+
+    LAST_MODIFIED_POSTFIX = ".last_modified"
+
+    ETCD_CONFIG_OPTIONS = (
+        ("host", str),
+        ("port", int),
+        ("protocol", str),
+        ("ca_cert", str),
+        ("cert_key", str),
+        ("cert_cert", str),
+        ("timeout", float),
+        ("api_path", str),
+    )
+
+    INIT_STATE = 'init'
+    CONNECTED_STATE = 'connected'
+    FETCH_STATE = 'fetched'
+
+    _client: etcd3gw.Etcd3Client
+
+    def __init__(self, name, conf, client=None, persistence=None):
+        super().__init__(name, conf)
+
+        self._client = client
+        self._persistence = persistence
+        self._state = self.INIT_STATE
+
+        path_elems = [self.ROOT_PATH,
+                      self._conf.get("path", self.DEFAULT_PATH)]
+        self._root_path = self._create_path(*path_elems)
+
+        self._job_cache = {}
+        self._job_cond = threading.Condition()
+
+        self._open_close_lock = threading.RLock()
+
+        self._watcher_thd = None
+        self._thread_cancel = None
+        self._watcher = None
+        self._watcher_cancel = None
+
+    def _create_path(self, root, *args):
+        return "/".join([root] + [a.strip("/") for a in args])
+
+    def incr(self, key):
+        """Atomically increment an integer, create it if it doesn't exist"""
+        while True:
+            value = self._client.get(key)
+            if not value:
+                res = self._client.create(key, 1)
+                if res:
+                    return 1
+                # Another thread has just created the key after we failed to
+                # read it, retry to get the new current value
+                continue
+
+            value = int(value[0])
+            next_value = value + 1
+
+            res = self._client.replace(key, value, next_value)
+            if res:
+                return next_value
+
+    def get_one(self, key):
+        if self._client is None:
+            raise exc.JobFailure(f"Cannot read key {key}, client is closed")
+        value = self._client.get(key)
+        if not value:
+            return None
+        return value[0]
+
+    def _fetch_jobs(self, only_unclaimed=False, ensure_fresh=False):
+        # TODO(gthiemonge) only_unclaimed is ignored
+        if ensure_fresh or self._state != self.FETCH_STATE:
+            self._ensure_fresh()
+        return sorted(self._job_cache.values())
+
+    def _ensure_fresh(self):
+        prefix = self._create_path(self._root_path, self.JOB_PREFIX)
+        jobs = self._client.get_prefix(prefix)
+        listed_jobs = {}
+        for job in jobs:
+            data, metadata = job
+            key = misc.binary_decode(metadata['key'])
+            if key.endswith(self.DATA_POSTFIX):
+                key = key.rstrip(self.DATA_POSTFIX)
+                listed_jobs[key] = data
+
+        removed_jobs = []
+        with self._job_cond:
+            for key in self._job_cache.keys():
+                if key not in listed_jobs:
+                    removed_jobs.append(key)
+        for key in removed_jobs:
+            self._remove_job_from_cache(key)
+
+        for key, data in listed_jobs.items():
+            self._process_incoming_job(key, data)
+        self._state = self.FETCH_STATE
+
+    def _process_incoming_job(self, key, data):
+        try:
+            job_data = jsonutils.loads(data)
+        except jsonutils.json.JSONDecodeError:
+            msg = ("Incorrectly formatted job data found at "
+                   f"key: {key}")
+            LOG.warning(msg, exc_info=True)
+            LOG.info("Deleting invalid job data at key: %s", key)
+            self._client.delete(key)
+            raise exc.JobFailure(msg)
+
+        with self._job_cond:
+            if key not in self._job_cache:
+                job_priority = base.JobPriority.convert(job_data["priority"])
+                new_job = EtcdJob(self,
+                                  job_data["name"],
+                                  self._client,
+                                  key,
+                                  uuid=job_data["uuid"],
+                                  details=job_data.get("details", {}),
+                                  backend=self._persistence,
+                                  book_data=job_data.get("book"),
+                                  priority=job_priority,
+                                  sequence=job_data["sequence"])
+                self._job_cache[key] = new_job
+                self._job_cond.notify_all()
+
+    def _remove_job_from_cache(self, key):
+        """Remove job from cache."""
+        with self._job_cond:
+            if key in self._job_cache:
+                self._job_cache.pop(key, None)
+
+    def _board_removal_func(self, job):
+        try:
+            self._remove_job_from_cache(job.key)
+            self._client.delete_prefix(job.key)
+        except Exception:
+            LOG.exception(f"Failed to delete prefix {job.key}")
+
+    def iterjobs(self, only_unclaimed=False, ensure_fresh=False):
+        """Returns an iterator of jobs that are currently on this board."""
+        return base.JobBoardIterator(
+            self, LOG, only_unclaimed=only_unclaimed,
+            ensure_fresh=ensure_fresh,
+            board_fetch_func=self._fetch_jobs,
+            board_removal_func=self._board_removal_func)
+
+    def wait(self, timeout=None):
+        """Waits a given amount of time for **any** jobs to be posted."""
+        # Wait until timeout expires (or forever) for jobs to appear.
+        watch = timeutils.StopWatch(duration=timeout)
+        watch.start()
+        with self._job_cond:
+            while True:
+                if not self._job_cache:
+                    if watch.expired():
+                        raise exc.NotFound("Expired waiting for jobs to"
+                                           " arrive; waited %s seconds"
+                                           % watch.elapsed())
+                    # This is done since the given timeout can not be provided
+                    # to the condition variable, since we can not ensure that
+                    # when we acquire the condition that there will actually
+                    # be jobs (especially if we are spuriously awaken), so we
+                    # must recalculate the amount of time we really have left.
+                    self._job_cond.wait(watch.leftover(return_none=True))
+                else:
+                    curr_jobs = self._fetch_jobs()
+                    fetch_func = lambda ensure_fresh: curr_jobs
+                    removal_func = lambda a_job: self._remove_job_from_cache(
+                        a_job.key)
+                    return base.JobBoardIterator(
+                        self, LOG, board_fetch_func=fetch_func,
+                        board_removal_func=removal_func)
+
+    @property
+    def job_count(self):
+        """Returns how many jobs are on this jobboard."""
+        return len(self._job_cache)
+
+    def get_owner_data(self, job: EtcdJob) -> typing.Optional[dict]:
+        owner_key = job.key + self.LOCK_POSTFIX
+        owner_data = self.get_one(owner_key)
+        if not owner_data:
+            return None
+        return jsonutils.loads(owner_data)
+
+    def find_owner(self, job: EtcdJob) -> typing.Optional[dict]:
+        """Gets the owner of the job if one exists."""
+        data = self.get_owner_data(job)
+        if data:
+            return data['owner']
+        return None
+
+    def get_data(self, job: EtcdJob) -> bytes:
+        key = job.key + self.DATA_POSTFIX
+        return self.get_one(key)
+
+    def get_owner_and_data(self, job: EtcdJob) -> tuple[
+            typing.Optional[str], typing.Optional[bytes]]:
+        if self._client is None:
+            raise exc.JobFailure("Cannot retrieve information, "
+                                 "not connected")
+
+        job_data = None
+        job_owner = None
+
+        for data, metadata in self._client.get_prefix(job.key + "."):
+            key = misc.binary_decode(metadata["key"])
+            if key.endswith(self.DATA_POSTFIX):
+                # bytes?
+                job_data = data
+            elif key.endswith(self.LOCK_POSTFIX):
+                data = jsonutils.loads(data)
+                job_owner = data["owner"]
+
+        return job_owner, job_data
+
+    def set_last_modified(self, job: EtcdJob):
+        key = job.key + self.LAST_MODIFIED_POSTFIX
+
+        now = timeutils.utcnow()
+        self._client.put(key, jsonutils.dumps({"last_modified": now}))
+
+    def get_last_modified(self, job: EtcdJob):
+        key = job.key + self.LAST_MODIFIED_POSTFIX
+
+        return self.get_one(key)
+
+    def post(self, name, book=None, details=None,
+             priority=base.JobPriority.NORMAL) -> EtcdJob:
+        """Atomically creates and posts a job to the jobboard."""
+        job_priority = base.JobPriority.convert(priority)
+        job_uuid = uuidutils.generate_uuid()
+        job_posting = base.format_posting(job_uuid, name,
+                                          created_on=timeutils.utcnow(),
+                                          book=book, details=details,
+                                          priority=job_priority)
+        seq = self.incr(self._create_path(self._root_path, self.SEQUENCE_KEY))
+        key = self._create_path(self._root_path, f"{self.JOB_PREFIX}{seq}")
+
+        job_posting["sequence"] = seq
+        raw_job_posting = jsonutils.dumps(job_posting)
+
+        data_key = key + self.DATA_POSTFIX
+
+        self._client.create(data_key, raw_job_posting)
+        job = EtcdJob(self, name, self._client, key,
+                      uuid=job_uuid,
+                      details=details,
+                      backend=self._persistence,
+                      book=book,
+                      book_data=job_posting.get('book'),
+                      priority=job_priority,
+                      sequence=seq)
+        with self._job_cond:
+            self._job_cache[key] = job
+            self._job_cond.notify_all()
+        return job
+
+    @base.check_who
+    def claim(self, job, who, expiry=None):
+        """Atomically attempts to claim the provided job."""
+        owner_key = job.key + self.LOCK_POSTFIX
+
+        ttl = expiry or self._conf.get('ttl', None)
+
+        if ttl:
+            lease = self._client.lease(ttl=ttl)
+        else:
+            lease = None
+
+        owner_dict = {
+            "owner": who,
+        }
+        if lease:
+            owner_dict["lease_id"] = lease.id
+
+        owner_value = jsonutils.dumps(owner_dict)
+
+        # Create a lock for the job, if the lock already exists, the job
+        # is owned by another worker
+        created = self._client.create(owner_key, owner_value, lease=lease)
+        if not created:
+            # Creation is denied, revoke the lease, we cannot claim the job.
+            if lease:
+                lease.revoke()
+
+            owner = self.find_owner(job)
+            if owner:
+                message = f"Job {job.uuid} already claimed by '{owner}'"
+            else:
+                message = f"Job {job.uuid} already claimed"
+            raise exc.UnclaimableJob(message)
+
+        # Ensure that the job still exists, it may have been claimed and
+        # consumed by another thread before we enter this function
+        if not self.get_data(job):
+            # Revoke the lease
+            if lease:
+                lease.revoke()
+            else:
+                self._client.delete(owner_key)
+            raise exc.UnclaimableJob(f"Job {job.uuid} already deleted.")
+
+        self.set_last_modified(job)
+
+    @base.check_who
+    def consume(self, job, who):
+        """Permanently (and atomically) removes a job from the jobboard."""
+        owner, data = self.get_owner_and_data(job)
+        if data is None or owner is None:
+            raise exc.NotFound(f"Cannot find job {job.uuid}")
+        if owner != who:
+            raise exc.JobFailure(f"Cannot consume a job {job.uuid}"
+                                 f" which is not owned by {who}")
+
+        self._client.delete_prefix(job.key + ".")
+        self._remove_job_from_cache(job.key)
+
+    @base.check_who
+    def abandon(self, job, who):
+        """Atomically attempts to abandon the provided job."""
+        owner, data = self.get_owner_and_data(job)
+        if data is None or owner is None:
+            raise exc.NotFound(f"Cannot find job {job.uuid}")
+        if owner != who:
+            raise exc.JobFailure(f"Cannot abandon a job {job.uuid}"
+                                 f" which is not owned by {who}")
+
+        owner_key = job.key + self.LOCK_POSTFIX
+        self._client.delete(owner_key)
+
+    @base.check_who
+    def trash(self, job, who):
+        """Trash the provided job."""
+        owner, data = self.get_owner_and_data(job)
+        if data is None or owner is None:
+            raise exc.NotFound(f"Cannot find job {job.uuid}")
+        if owner != who:
+            raise exc.JobFailure(f"Cannot trash a job {job.uuid} "
+                                 f"which is not owned by {who}")
+
+        trash_key = job.key.replace(self.ROOT_PATH, self.TRASH_PATH)
+        self._client.create(trash_key, data)
+        self._client.delete_prefix(job.key + ".")
+        self._remove_job_from_cache(job.key)
+
+    def register_entity(self, entity: 'entity.Entity'):
+        """Register an entity to the jobboard('s backend), e.g: a conductor"""
+        # TODO(gthiemonge) Doesn't seem to be useful with Etcd
+
+    @property
+    def connected(self):
+        """Returns if this jobboard is connected."""
+        return self._client is not None
+
+    @fasteners.locked(lock='_open_close_lock')
+    def connect(self):
+        """Opens the connection to any backend system."""
+        if self._client is None:
+            etcd_conf = {}
+            for config_opts in self.ETCD_CONFIG_OPTIONS:
+                key, value_type = config_opts
+                if key in self._conf:
+                    etcd_conf[key] = value_type(self._conf[key])
+
+            self._client = etcd3gw.Etcd3Client(**etcd_conf)
+            self._state = self.CONNECTED_STATE
+
+            watch_url = self._create_path(self._root_path, self.JOB_PREFIX)
+            self._thread_cancel = threading.Event()
+            try:
+                (self._watcher,
+                 self._watcher_cancel) = self._client.watch_prefix(watch_url)
+            except etcd3gw.exceptions.ConnectionFailedError:
+                exc.raise_with_cause(exc.JobFailure,
+                                     "Failed to connect to Etcd")
+            self._watcher_thd = threading.Thread(target=self._watcher_thread)
+            self._watcher_thd.start()
+
+    def _watcher_thread(self):
+        while not self._thread_cancel.is_set():
+            for event in self._watcher:
+                if "kv" not in event:
+                    continue
+
+                key_value = event["kv"]
+                key = misc.binary_decode(key_value["key"])
+
+                if key.endswith(self.DATA_POSTFIX):
+                    key = key.rstrip(self.DATA_POSTFIX)
+                    if event.get("type") == "DELETE":
+                        self._remove_job_from_cache(key)
+                    else:
+                        data = key_value["value"]
+                        self._process_incoming_job(key, data)
+
+    @fasteners.locked(lock='_open_close_lock')
+    def close(self):
+        """Close the connection to any backend system."""
+        if self._client is not None:
+            if self._watcher_cancel is not None:
+                self._watcher_cancel()
+            if self._thread_cancel is not None:
+                self._thread_cancel.set()
+            if self._watcher_thd is not None:
+                self._watcher_thd.join()
+            del self._client
+            self._client = None
+            self._state = self.INIT_STATE

taskflow/tests/unit/jobs/test_etcd_job.py

@@ -0,0 +1,421 @@
+#    Copyright (C) Red Hat
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from unittest import mock
+
+from oslo_serialization import jsonutils
+from oslo_utils import uuidutils
+import testtools
+
+from taskflow import exceptions as exc
+from taskflow.jobs.backends import impl_etcd
+from taskflow.jobs import base as jobs_base
+from taskflow import test
+from taskflow.tests.unit.jobs import base
+from taskflow.tests import utils as test_utils
+
+ETCD_AVAILABLE = test_utils.etcd_available()
+
+
+class EtcdJobBoardMixin:
+    def create_board(self, conf=None, persistence=None):
+        self.path = f"test-{uuidutils.generate_uuid()}"
+        board_conf = {
+            "path": self.path,
+        }
+        if conf:
+            board_conf.update(conf)
+        board = impl_etcd.EtcdJobBoard("etcd", board_conf,
+                                       persistence=persistence)
+        return board._client, board
+
+
+class MockedEtcdJobBoard(test.TestCase, EtcdJobBoardMixin):
+
+    def test_create_board(self):
+        _, jobboard = self.create_board()
+        self.assertEqual(f"/taskflow/jobs/{self.path}", jobboard._root_path)
+
+        _, jobboard = self.create_board({"path": "/testpath"})
+        self.assertEqual("/taskflow/jobs/testpath", jobboard._root_path)
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard.incr")
+    @mock.patch("threading.Condition")
+    @mock.patch("oslo_utils.uuidutils.generate_uuid")
+    @mock.patch("oslo_utils.timeutils.utcnow")
+    def test_post(self,
+                  mock_utcnow: mock.Mock,
+                  mock_generated_uuid: mock.Mock,
+                  mock_cond: mock.Mock,
+                  mock_incr: mock.Mock):
+        mock_incr.return_value = 12
+        mock_generated_uuid.return_value = "uuid1"
+        mock_utcnow.return_value = "utcnow1"
+
+        mock_book = mock.Mock()
+        mock_book.name = "book1_name"
+        mock_book.uuid = "book1_uuid"
+        mock_details = mock.Mock()
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+        job = jobboard.post("post1", book=mock_book,
+                            details=mock_details,
+                            priority=jobs_base.JobPriority.NORMAL)
+
+        expected_key = (
+            f"/taskflow/jobs/{self.path}/job12")
+        expected_data_key = expected_key + jobboard.DATA_POSTFIX
+        expected_book_data = {
+            "name": "book1_name",
+            "uuid": "book1_uuid"
+        }
+        expected_job_posting = {
+            "uuid": "uuid1",
+            "name": "post1",
+            "priority": "NORMAL",
+            "created_on": "utcnow1",
+            "details": mock_details,
+            "book": expected_book_data,
+            "sequence": 12,
+        }
+
+        mock_incr.assert_called_with(f"/taskflow/jobs/{self.path}/sequence")
+
+        jobboard._client.create.assert_called_with(
+            expected_data_key, jsonutils.dumps(expected_job_posting))
+
+        self.assertEqual("post1", job.name)
+        self.assertEqual(expected_key, job.key)
+        self.assertEqual(mock_details, job.details)
+        self.assertEqual(mock_book, job.book)
+        self.assertEqual(expected_book_data, job._book_data)
+        self.assertEqual(jobs_base.JobPriority.NORMAL, job.priority)
+        self.assertEqual(12, job.sequence)
+
+        self.assertEqual(1, len(jobboard._job_cache))
+        self.assertEqual(job, jobboard._job_cache[expected_key])
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "set_last_modified")
+    def test_claim(self, mock_set_last_modified):
+        who = "owner1"
+        lease_id = uuidutils.generate_uuid()
+
+        _, jobboard = self.create_board(conf={"ttl": 37})
+        jobboard._client = mock.Mock()
+
+        mock_lease = mock.Mock(id=lease_id)
+        jobboard._client.lease.return_value = mock_lease
+        jobboard._client.create.return_value = True
+        jobboard._client.get.return_value = [mock.Mock()]
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7",
+                                uuid=uuidutils.generate_uuid(),
+                                details=mock.Mock(),
+                                backend="etcd",
+                                book=mock.Mock(),
+                                book_data=mock.Mock(),
+                                priority=jobs_base.JobPriority.NORMAL,
+                                sequence=7,
+                                created_on="date")
+
+        jobboard.claim(job, who)
+
+        jobboard._client.lease.assert_called_once_with(ttl=37)
+
+        jobboard._client.create.assert_called_once_with(
+            f"{job.key}{jobboard.LOCK_POSTFIX}",
+            jsonutils.dumps({"owner": who,
+                             "lease_id": lease_id}),
+            lease=mock_lease)
+
+        jobboard._client.get.assert_called_once_with(
+            job.key + jobboard.DATA_POSTFIX)
+        mock_lease.revoke.assert_not_called()
+
+        mock_set_last_modified.assert_called_once_with(job)
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "set_last_modified")
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "find_owner")
+    def test_claim_already_claimed(self, mock_find_owner,
+                                   mock_set_last_modified):
+        who = "owner1"
+        lease_id = uuidutils.generate_uuid()
+
+        mock_find_owner.return_value = who
+
+        _, jobboard = self.create_board({"ttl": 37})
+        jobboard._client = mock.Mock()
+
+        mock_lease = mock.Mock(id=lease_id)
+        jobboard._client.lease.return_value = mock_lease
+        jobboard._client.create.return_value = False
+        jobboard._client.get.return_value = []
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7",
+                                uuid=uuidutils.generate_uuid(),
+                                details=mock.Mock(),
+                                backend="etcd",
+                                book=mock.Mock(),
+                                book_data=mock.Mock(),
+                                priority=jobs_base.JobPriority.NORMAL,
+                                sequence=7,
+                                created_on="date")
+
+        self.assertRaisesRegex(exc.UnclaimableJob, "already claimed by",
+                               jobboard.claim, job, who)
+
+        jobboard._client.lease.assert_called_once_with(ttl=37)
+
+        jobboard._client.create.assert_called_once_with(
+            f"{job.key}{jobboard.LOCK_POSTFIX}",
+            jsonutils.dumps({"owner": who,
+                             "lease_id": lease_id}),
+            lease=mock_lease)
+
+        mock_lease.revoke.assert_called_once()
+
+        mock_set_last_modified.assert_not_called()
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "set_last_modified")
+    def test_claim_deleted(self, mock_set_last_modified):
+        who = "owner1"
+        lease_id = uuidutils.generate_uuid()
+
+        _, jobboard = self.create_board({"ttl": 37})
+        jobboard._client = mock.Mock()
+
+        mock_lease = mock.Mock(id=lease_id)
+        jobboard._client.lease.return_value = mock_lease
+        jobboard._client.create.return_value = True
+        jobboard._client.get.return_value = []
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7",
+                                uuid=uuidutils.generate_uuid(),
+                                details=mock.Mock(),
+                                backend="etcd",
+                                book=mock.Mock(),
+                                book_data=mock.Mock(),
+                                priority=jobs_base.JobPriority.NORMAL,
+                                sequence=7,
+                                created_on="date")
+
+        self.assertRaisesRegex(exc.UnclaimableJob, "already deleted",
+                               jobboard.claim, job, who)
+
+        jobboard._client.lease.assert_called_once_with(ttl=37)
+
+        jobboard._client.create.assert_called_once_with(
+            f"{job.key}{jobboard.LOCK_POSTFIX}",
+            jsonutils.dumps({"owner": who,
+                             "lease_id": lease_id}),
+            lease=mock_lease)
+
+        jobboard._client.get.assert_called_once_with(
+            job.key + jobboard.DATA_POSTFIX)
+        mock_lease.revoke.assert_called_once()
+
+        mock_set_last_modified.assert_not_called()
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "_remove_job_from_cache")
+    def test_consume(self, mock__remove_job_from_cache,
+                     mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner1", mock.Mock()]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        jobboard.consume(job, "owner1")
+
+        jobboard._client.delete_prefix.assert_called_once_with(job.key + ".")
+        mock__remove_job_from_cache.assert_called_once_with(job.key)
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    def test_consume_bad_owner(self, mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner2", mock.Mock()]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        self.assertRaisesRegex(exc.JobFailure, "which is not owned",
+                               jobboard.consume, job, "owner1")
+
+        jobboard._client.delete_prefix.assert_not_called()
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    def test_abandon(self, mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner1", mock.Mock()]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        jobboard.abandon(job, "owner1")
+
+        jobboard._client.delete.assert_called_once_with(
+            f"{job.key}{jobboard.LOCK_POSTFIX}")
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    def test_abandon_bad_owner(self, mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner2", mock.Mock()]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        self.assertRaisesRegex(exc.JobFailure, "which is not owned",
+                               jobboard.abandon, job, "owner1")
+
+        jobboard._client.delete.assert_not_called()
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "_remove_job_from_cache")
+    def test_trash(self, mock__remove_job_from_cache,
+                   mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner1", mock.Mock()]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        jobboard.trash(job, "owner1")
+
+        jobboard._client.create.assert_called_once_with(
+            f"/taskflow/.trash/{self.path}/job7", mock.ANY)
+        jobboard._client.delete_prefix.assert_called_once_with(job.key + ".")
+        mock__remove_job_from_cache.assert_called_once_with(job.key)
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "_remove_job_from_cache")
+    def test_trash_bad_owner(self, mock__remove_job_from_cache,
+                             mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner2", mock.Mock()]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        self.assertRaisesRegex(exc.JobFailure, "which is not owned",
+                               jobboard.trash, job, "owner1")
+
+        jobboard._client.create.assert_not_called()
+        jobboard._client.delete_prefix.assert_not_called()
+        mock__remove_job_from_cache.assert_not_called()
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "_remove_job_from_cache")
+    def test_trash_deleted_job(self, mock__remove_job_from_cache,
+                               mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner1", None]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        self.assertRaisesRegex(exc.NotFound, "Cannot find job",
+                               jobboard.trash, job, "owner1")
+
+        jobboard._client.create.assert_not_called()
+        jobboard._client.delete_prefix.assert_not_called()
+        mock__remove_job_from_cache.assert_not_called()
+
+
+@testtools.skipIf(not ETCD_AVAILABLE, 'Etcd is not available')
+class EtcdJobBoardTest(test.TestCase, base.BoardTestMixin, EtcdJobBoardMixin):
+    def setUp(self):
+        super().setUp()
+        self.client, self.board = self.create_board()
+
+    def test__incr(self):
+        key = uuidutils.generate_uuid()
+
+        self.board.connect()
+        self.addCleanup(self.board.close)
+        self.addCleanup(self.board._client.delete, key)
+
+        self.assertEqual(1, self.board.incr(key))
+        self.assertEqual(2, self.board.incr(key))
+        self.assertEqual(3, self.board.incr(key))
+
+        self.assertEqual(b'3', self.board.get_one(key))
+        self.board.close()
+
+    def test_get_one(self):
+        key1 = uuidutils.generate_uuid()
+
+        self.board.connect()
+        self.addCleanup(self.board._client.delete, key1)
+
+        # put data and get it
+        self.board._client.put(key1, "testset1")
+        self.assertEqual(b"testset1", self.board.get_one(key1))
+
+        # delete data and check that it's not found
+        self.board._client.delete(key1)
+        self.assertIsNone(self.board.get_one(key1))
+
+        # get a non-existant data
+        key2 = uuidutils.generate_uuid()
+        # (ensure it doesn't exist)
+        self.board._client.delete(key2)
+        self.assertIsNone(self.board.get_one(key2))
+        self.board.close()

taskflow/tests/unit/test_retries.py

@@ -15,8 +15,10 @@
 #    under the License.
 
 import testtools
+import time
 
 import taskflow.engines
+from taskflow.engines.action_engine import executor
 from taskflow import exceptions as exc
 from taskflow.patterns import graph_flow as gf
 from taskflow.patterns import linear_flow as lf
@@ -502,6 +504,56 @@ class RetryTest(utils.EngineTestBase):
         self.assertRaisesRegex(RuntimeError, '^Woot', engine.run)
         self.assertRaisesRegex(RuntimeError, '^Woot', engine.run)
 
+    def test_restart_reverted_unordered_flows_with_retries(self):
+        now = time.time()
+
+        # First flow of an unordered flow:
+        subflow1 = lf.Flow('subflow1')
+
+        # * a task that completes in 3 sec with a few retries
+        subsubflow1 = lf.Flow('subflow1.subsubflow1',
+                              retry=utils.RetryFiveTimes())
+        subsubflow1.add(utils.SuccessAfter3Sec('subflow1.fail1',
+                                               inject={'start_time': now}))
+        subflow1.add(subsubflow1)
+
+        # * a task that fails and triggers a revert after 5 retries
+        subsubflow2 = lf.Flow('subflow1.subsubflow2',
+                              retry=utils.RetryFiveTimes())
+        subsubflow2.add(utils.FailingTask('subflow1.fail2'))
+        subflow1.add(subsubflow2)
+
+        # Second flow of the unordered flow:
+        subflow2 = lf.Flow('subflow2')
+
+        # * a task that always fails and retries
+        subsubflow1 = lf.Flow('subflow2.subsubflow1',
+                              retry=utils.AlwaysRetry())
+        subsubflow1.add(utils.FailingTask('subflow2.fail1'))
+        subflow2.add(subsubflow1)
+
+        unordered_flow = uf.Flow('unordered_flow')
+        unordered_flow.add(subflow1, subflow2)
+
+        # Main flow, contains a simple task and an unordered flow
+        flow = lf.Flow('test')
+        flow.add(utils.NoopTask('task1'))
+        flow.add(unordered_flow)
+
+        engine = self._make_engine(flow)
+
+        # This test fails when using Green threads, skipping it for now
+        if isinstance(engine._task_executor,
+                      executor.ParallelGreenThreadTaskExecutor):
+            self.skipTest("Skipping this test when using green threads.")
+
+        with utils.CaptureListener(engine) as capturer:
+            self.assertRaisesRegex(exc.WrappedFailure,
+                                   '.*RuntimeError: Woot!',
+                                   engine.run)
+            # task1 should have been reverted
+            self.assertIn('task1.t REVERTED(None)', capturer.values)
+
     def test_run_just_retry(self):
         flow = utils.OneReturnRetry(provides='x')
         engine = self._make_engine(flow)

taskflow/tests/utils.py

@@ -19,6 +19,7 @@ import string
 import threading
 import time
 
+import etcd3gw
 from oslo_utils import timeutils
 import redis
 
@@ -88,6 +89,15 @@ def redis_available(min_version):
         return ok
 
 
+def etcd_available():
+    client = etcd3gw.Etcd3Client()
+    try:
+        client.get("/")
+    except Exception:
+        return False
+    return True
+
+
 class NoopRetry(retry.AlwaysRevert):
     pass
 
@@ -217,6 +227,32 @@ class FailingTask(ProgressingTask):
         raise RuntimeError('Woot!')
 
 
+class SimpleTask(task.Task):
+    def execute(self, time_sleep=0, **kwargs):
+        time.sleep(time_sleep)
+
+
+class SuccessAfter3Sec(task.Task):
+    def execute(self, start_time, **kwargs):
+        now = time.time()
+        if now - start_time >= 3:
+            return None
+        raise RuntimeError('Woot!')
+
+
+class RetryFiveTimes(retry.Times):
+    def on_failure(self, history, *args, **kwargs):
+        if len(history) < 5:
+            time.sleep(1)
+            return retry.RETRY
+        return retry.REVERT_ALL
+
+
+class AlwaysRetry(retry.Times):
+    def on_failure(self, history, *args, **kwargs):
+        return retry.RETRY
+
+
 class OptionalTask(task.Task):
     def execute(self, a, b=5):
         result = a * b

{taskflow-5.8.0.dist-info → taskflow-5.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: taskflow
-Version: 5.8.0
+Version: 5.9.1
 Summary: Taskflow structured state management library.
 Home-page: https://docs.openstack.org/taskflow/latest/
 Author: OpenStack
@@ -43,6 +43,8 @@ Requires-Dist: SQLAlchemy-Utils (>=0.30.11) ; extra == 'database'
 Requires-Dist: SQLAlchemy (>=1.0.10) ; extra == 'database'
 Requires-Dist: alembic (>=0.8.10) ; extra == 'database'
 Requires-Dist: psycopg2 (>=2.8.0) ; extra == 'database'
+Provides-Extra: etcd
+Requires-Dist: etcd3gw (>=2.0.0) ; extra == 'etcd'
 Provides-Extra: eventlet
 Requires-Dist: eventlet (>=0.18.2) ; extra == 'eventlet'
 Provides-Extra: redis

{taskflow-5.8.0.dist-info → taskflow-5.9.1.dist-info}/RECORD

@@ -29,7 +29,7 @@ taskflow/engines/action_engine/deciders.py,sha256=WEKo189CL9Zdg506Sz3Mlxpfp6dqGv
 taskflow/engines/action_engine/engine.py,sha256=kz_9BVD22IO2mEHBc735zUDPCF0Y_hzcAuQqZpUUVCk,29817
 taskflow/engines/action_engine/executor.py,sha256=sBmKwgDQN9fEZz42T7RB-RYUZvWqfHqC-Y2EsWRGkYI,7749
 taskflow/engines/action_engine/process_executor.py,sha256=if8kc7Dg3lvT7NwKVe2eqHhksv1pxEPNoI5E80naGr4,27975
-taskflow/engines/action_engine/runtime.py,sha256=exGFpk7iPPrl7vywAHqdeDW-cyFlYxphPLi8W1umP3o,13845
+taskflow/engines/action_engine/runtime.py,sha256=FAUJZsZaADo4t1kRzs0Pf5z2qRjrlNG5GCycUoe4N8U,14604
 taskflow/engines/action_engine/scheduler.py,sha256=yZEn2z23N-0XNpHtjOs3kxJh4CTpZl-2ASrPsyLP2t0,4048
 taskflow/engines/action_engine/scopes.py,sha256=u0cmoMycrNZqMebgKqLW2YXBVLukNi9dVqKOFr79lKw,5432
 taskflow/engines/action_engine/selector.py,sha256=9FKRKOi6mqIn4kfEY2R6Uq6aVzPPsT0DgI1VDVRaZdU,11558
@@ -105,6 +105,7 @@ taskflow/examples/resume_many_flows/run_flow.py,sha256=MOD78Zg7IaSAVRoLPap36njTZ
 taskflow/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 taskflow/jobs/base.py,sha256=nowX7pKESnTz-_iPmg1vUQJ0bgO3HLOOtytOKOy12kA,22463
 taskflow/jobs/backends/__init__.py,sha256=ILlqq_U0FPM77nPQgx_OexjHxUvC5Tl4RXkX-IznSfw,2902
+taskflow/jobs/backends/impl_etcd.py,sha256=3o5xBe0UkqPo9b8LYcbHD2L7e5lDlJHjo8VQsyd4iIE,22067
 taskflow/jobs/backends/impl_redis.py,sha256=ZgxVSlAOncTE089a6c1qjafSIzv8_ekLQKvq1G_n7IE,43925
 taskflow/jobs/backends/impl_zookeeper.py,sha256=1Noi75aTH0NCx-qlsRExsx-QKBtY5j2PJb6RIi_Cm5o,37644
 taskflow/listeners/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -148,7 +149,7 @@ taskflow/persistence/backends/sqlalchemy/alembic/versions/README,sha256=AwegmiWc
 taskflow/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 taskflow/tests/fixtures.py,sha256=VfGlusX2q79_ktPME4cm1qt_gN9VNRAwyYy5sDBAX0Y,2004
 taskflow/tests/test_examples.py,sha256=g2zhguLKE4Tex2e_vSmKMhsNXItnKWj89_VbnmgGejU,4925
-taskflow/tests/utils.py,sha256=P6RPD2w5h00KAse7r31LC9tJils0jaeiUx5QiVqLOA0,11157
+taskflow/tests/utils.py,sha256=go8D7cUHQJ31F0n0Ts5ijeHdC7JsCFpsgdHb09QL5A4,11954
 taskflow/tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 taskflow/tests/unit/test_arguments_passing.py,sha256=jK9-Z7xBfPI4nHB7_Bh_rllBH-X55v6wplxdrjwRS3E,9381
 taskflow/tests/unit/test_check_transition.py,sha256=DuxJAErCwheWPAdN_43LOOvZg00vmUoC-IzGgh642IM,6173
@@ -166,7 +167,7 @@ taskflow/tests/unit/test_mapfunctor_task.py,sha256=1FI8AJxRUPxT7Lu6h9Mhd62srAnKf
 taskflow/tests/unit/test_notifier.py,sha256=Q4xGl9e_LZRiJVpGR2FbG2qSp9CqlP65aDsaIKxPqHI,7894
 taskflow/tests/unit/test_progress.py,sha256=oeYFeWuHde1D2cAahhE1yN1NznNcXk7ajw0Z2yCyZkM,5259
 taskflow/tests/unit/test_reducefunctor_task.py,sha256=vM4P5h80-Ex4uq2N_dNmTFL49Ks3iFmP5dMbZEk0YQ0,2106
-taskflow/tests/unit/test_retries.py,sha256=yRQF_TUtZ-d13sIzFNLjKZXg5DhuSj2xkhvgi8zGgCE,56542
+taskflow/tests/unit/test_retries.py,sha256=xxHEBNoiaDR5WMztzm5CidqGrOkKJ2yqs2J69P1KwkE,58658
 taskflow/tests/unit/test_states.py,sha256=iYyHo9YzHBMjlYaqlzZJTcKjB53WCqf5Fw3OGoVKVME,3660
 taskflow/tests/unit/test_storage.py,sha256=SlShgJ4hirdnggDkpB3GoosY--4B0PqMOVvMBG5D6g4,23520
 taskflow/tests/unit/test_suspend.py,sha256=2d5y15Fw6NESJ4oEUAA7dosECGb2-CLkkgXULqwNtWw,10077
@@ -187,6 +188,7 @@ taskflow/tests/unit/action_engine/test_scoping.py,sha256=wIB9C3LMgfsqO6cdz_ZdhQc
 taskflow/tests/unit/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 taskflow/tests/unit/jobs/base.py,sha256=wYv5ziDeVdYn2nhuMSfYTWU39Xxpv8lRKvJbGsB79lM,8447
 taskflow/tests/unit/jobs/test_entrypoint.py,sha256=t2m5zeYhjb2pmPxBgGO_0AMWR0dabWxglDBODzLE0fY,2220
+taskflow/tests/unit/jobs/test_etcd_job.py,sha256=oKnZ0nnmpmr9K04x3a4d6STvrE811uPRYdrJAbgdyv0,16512
 taskflow/tests/unit/jobs/test_redis_job.py,sha256=wHwptqgrafZMk0aDZNvn2h3sJw8ckKY1g5J9I_dzWAM,7394
 taskflow/tests/unit/jobs/test_zk_job.py,sha256=e5CdkqmiQY_jzNtcHsxKcsS9uY7k-D8CMGkqt1J_bqE,13789
 taskflow/tests/unit/patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -232,11 +234,11 @@ taskflow/utils/persistence_utils.py,sha256=GWceOcxdfsf-MtrdR74xmC2khClF8im6DpZmR
 taskflow/utils/redis_utils.py,sha256=zJBvXmlNZUQ_gwGZAaNLySVtCtou3YayHAkGSCNKDUw,4345
 taskflow/utils/schema_utils.py,sha256=Zf6eL0NK0_TVFD_Sc1yEZYswFz9K0tet1Dmj48F8uMA,1434
 taskflow/utils/threading_utils.py,sha256=eiaNUK127DOBr_zfj3-j4Oi5a2dsD7VunVeTYN6NjPo,5849
-taskflow-5.8.0.dist-info/AUTHORS,sha256=uKVGnRq9UrIKLl5MhXJ9QuqzKXynjWcZcuaW_j9Eh5g,4564
-taskflow-5.8.0.dist-info/LICENSE,sha256=0t4vVm0tDgtQn7DqH6Nmn0kGSrHeIcV0U8qzdQojTo8,10143
-taskflow-5.8.0.dist-info/METADATA,sha256=kuefeelA76iqoYN42iONSN0BIGMC1kuBl3gbAFUxFZU,5074
-taskflow-5.8.0.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
-taskflow-5.8.0.dist-info/entry_points.txt,sha256=MGjjnng_YpSJs9BMAJBC2hJnljMV0pNllXl_5VoHJV0,1183
-taskflow-5.8.0.dist-info/pbr.json,sha256=-MpKNBkoFQci3B2CFjUNnVUnce_VqQpi9W83oKFErq4,47
-taskflow-5.8.0.dist-info/top_level.txt,sha256=PsdN41vwysesDlqHCSVVXH4mkTMdMiZFW_yHEAXiZE4,9
-taskflow-5.8.0.dist-info/RECORD,,
+taskflow-5.9.1.dist-info/AUTHORS,sha256=uKVGnRq9UrIKLl5MhXJ9QuqzKXynjWcZcuaW_j9Eh5g,4564
+taskflow-5.9.1.dist-info/LICENSE,sha256=0t4vVm0tDgtQn7DqH6Nmn0kGSrHeIcV0U8qzdQojTo8,10143
+taskflow-5.9.1.dist-info/METADATA,sha256=cZHxTrZuq1RW6ZopG9g3Yf5nM1d-dIpnW0BIZy2zyoo,5146
+taskflow-5.9.1.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
+taskflow-5.9.1.dist-info/entry_points.txt,sha256=bIwgsxgCx_nrcv_gMhFDVffkg_r4NHX2O43iEXUKohU,1236
+taskflow-5.9.1.dist-info/pbr.json,sha256=r6eUVJh_ZGPwgjtiFsQha4d7x0jrO255TgbBcTs1G8M,47
+taskflow-5.9.1.dist-info/top_level.txt,sha256=PsdN41vwysesDlqHCSVVXH4mkTMdMiZFW_yHEAXiZE4,9
+taskflow-5.9.1.dist-info/RECORD,,

{taskflow-5.8.0.dist-info → taskflow-5.9.1.dist-info}/entry_points.txt

@@ -10,6 +10,7 @@ worker-based = taskflow.engines.worker_based.engine:WorkerBasedActionEngine
 workers = taskflow.engines.worker_based.engine:WorkerBasedActionEngine
 
 [taskflow.jobboards]
+etcd = taskflow.jobs.backends.impl_etcd:EtcdJobBoard
 redis = taskflow.jobs.backends.impl_redis:RedisJobBoard
 zookeeper = taskflow.jobs.backends.impl_zookeeper:ZookeeperJobBoard
 

taskflow-5.9.1.dist-info/pbr.json

@@ -0,0 +1 @@
+{"git_version": "a8b48d6e", "is_release": true}

taskflow-5.8.0.dist-info/pbr.json

@@ -1 +0,0 @@
-{"git_version": "828e9240", "is_release": true}