* fixed problem with creating some CourseItem with some parent:
we must get the updated parent item before using that parent item
* replaced parent_location with parent argument in ItemFactory due to
error children/parent relation for split modulestore. In all tests with
split modulestore parent argument used
We run atomic-requests in almost all environments (for the lms and cms
anyway) EXCEPT devstack_with_worker. Using a different setting means
that even if you think you are testing with a worker like real deploys
use, you are not actually testing with the data a worker would
actually see.
The removed code also claims that if you run with atomic transactions
and a worker you will deadlock the system. If so edx.org would be
deadlocked at all times and yet is not. The old code was vintage 2015
and its assumptions probably haven't been examined since then.
Current behavior for both old and new exams paths on exam creation is
that the signal fires, the update code kicks off a celery task which
looks for a new exam, and that exam is not found so no actual update
is done. Or the old version is visible but the updated version is not.
By waiting until the change is actually committed, we should find the
new exam when we search for it.
This is currently an invisible bug just because of the large numbers
of updates that working on a course provides, the exam will be correct
unless it was the absolute last thing that was touched, in which case
it will be out of date.
https://github.com/openedx/edx-platform/pull/31261 fixed celery
cache behavior when not running a worker and made sure production
would keep the old cache behavior, but missed these secret alternate
settings files, bring them up to date.
Also fixes the cms file to have the actual broker URL.
CMS youtube transcript tests call GET twice & need different responses on each of the two calls
Current solution (setup_caption_responses) decides what to return on basis of call number.
Former solution (mock_request_get()) decided what to return on the basis of kwargs, which would differ on first vs. second call
When running in a sharded MongoDB setup it's possible that querying the
modulestore right after the course publish signal will not return the
latest data.
This commit adds a delay similar to the one used in other places in the
codebase for a similar reason.
This function is no longer needed as all XModules have been converted to XBlocks.
XBLOCK_SELECT_FUNCTION Django setting is removed too, as it could take only `prefer_xmodules` or `default_select` values.
Clearing the RequestCache was intended to address memory leaks in the
celery workers. Celery worker processes will process many tasks before
they are terminated. RequestCache cleanup typically happens in the
RequestCacheMiddleware class, and middleware never executes for celery.
To get around that issue, the CLEAR_REQUEST_CACHE_ON_TASK_COMPLETION
setting was created to clear the RequestCache after every task was
successfully completed.
This works fine when celery is running as a separate process, as it's
set up to do in production. But during development, the
CELERY_ALWAYS_EAGER setting variable is set to True, meaning that
celery tasks are run in the same thread as the Django Request. This is
meant to make debugging easier, as task failures run as part of the
request cycle and will raise exceptions that are visible to the
browser.
However, celery tasks are triggered from many different actions. That
means that the RequestCache was being cleared many times during the
course of processing a request. This led to behavior that was
potentially slower, but also incorrect–the RequestCache was getting
flushed in a way that wouldn't happen in any deployed environment
because celery would be running in separate processes there. This came
up when trying to fix an issue around extra history records being
created during problem submissions:
https://discuss.openedx.org/t/extra-history-record-stored-on-each-problem-submission/8081
Furthermore, it's not necessary to prevent RequestCache memory leaks
when running in CELERY_AWLAYS_EAGER mode in development because the
middleware cleanup happens automatically–as everything is running as
part of the request/response cycle.
There are times in which we may want to run celery eagerly and still
clear the cache, such as testing. I have set
CLEAR_REQUEST_CACHE_ON_TASK_COMPLETION = False in all dev and test
environments that already have CELERY_ALWAYS_EAGER = True. The unit
test that specifically tests whether the request cache is getting
cleared upon completion of a celery task then overrides
CLEAR_REQUEST_CACHE_ON_TASK_COMPLETION = True even though
CELERY_ALWAYS_EAGER = True for the sake of that specific testing
purpose.
