See https://github.com/openedx/edx-platform/issues/34702
This necessarily involves switching from calling
`StaticContent.is_versioned_asset_path` to determine whether to handle the
request to having a hardcoded urlpattern. I've made the choice to hardcode
the other two patterns similarly rather than using imported constants. The
mapping of URL patterns to database records should be explicit (even though
we don't expect those constants to change out from under us.)
I've renamed the middleware rather than choosing a new name for the
implementation because there are other references in tests and other code.
This was the smaller change.
A note on HTTP methods: The middleware currently completely ignores the
request's HTTP method, so I wanted to confirm that only GETs were being
used in practice. This query reveals that 99.8% of requests that this
middleware handles are GET, with just a smattering of PROPFIND and OPTIONS
and a tiny number of HEAD and POST:
```
from Transaction select count(*) facet request.method
where name = 'WebTransaction/Function/openedx.core.djangoapps.contentserver.middleware:StaticContentServer'
since 4 weeks ago
```
The git-ignored target directory for LMS Sass compilation is:
lms/static/css
Unfortunately, that directory contains git-controlled directory of
vendored-in static assets:
lms/static/css/vendor
This is a problem for a couple reasons:
1. In Tutor, we would like to make lms/static/css a symlink to an
external location for the sake of build efficiency. This is
impossible to do without clobbering lms/static/css/vendor and
dirtying the git state.
2. More generally, when optimizing (or just understanding) a build
system, it adds complexity when git-controlled source directories are
mixed up inside git-ignored target directories.
The solution is to simply merge these vendored-in assets to another
existing git-controlled vendor directory:
common/static/css/vendor
LMS already reads assets from this folder, so no further changes need to
be made. common/static/css is fully git-controlled, so we avoid the
complexity described above.
This commit modifies the approve_id_verifications management command to send an IDV approval email to learners. This ensures that learners are informed of approvals to their IDV attempts when performed using the management command. This more closely mirrors the way IDV approvals work when using an IDV vendor.
As of Python 3.3, the 3rd-party `mock` package has been subsumed into the
standard `unittest.mock` package. Refactoring tests to use the latter will
allow us to drop `mock` as a dependency, which is currently coming in
transitively through requirements/edx/paver.in.
We don't actually drop the `mock` dependency in this PR. That will happen
naturally in:
* https://github.com/openedx/edx-platform/pull/34830
[APER-3241]
This PR updates the retirement pipeline to purge learners' names from certificate records when their account is being retired.
It also introduces a new management command that can be used by Open edX operators to purge the leftover name data (PII data) from the `certificates_generatedcertificate` table. This is designed as a one-time use data fixup, as the retirement functionality should clean this moving forward.
Blockstore and all of its (experimental) functionality has been replaced with
openedx-learning, aka "Learning Core". This commit uninstalls the now-unused
openedx-blockstore package and removes all dangling references to it.
Note: This also removes the `copy_library_from_v1_to_v2` management command,
which has been broken ever since we switched from Blockstore to Learning Core.
Part of this DEPR: https://github.com/openedx/public-engineering/issues/238
Introduce emission of the COURSE_PASSING_STATUS_UPDATED as well as CCX_COURSE_PASSING_STATUS_UPDATED events, that are groundwork for the new Credly integration and the future badging initiative.
Product GH ticket for tracking - openedx/platform-roadmap#280
The LMS and Studio need to set values for CORS_ALLOW_HEADERS so that the
MFEs can work properly, since preflight requests will need to send over
extra headers. Prior to this commit, CORS_ALLOW_HEADERS was being
redefined in multiple places in edx-platform and again in Tutor's config
because it was only being conditionally set if ENABLE_CORS_HEADERS was
True (which was a policy setting). But CORS_ALLOW_HEADERS is application
logic in that the value is determined by what the view needs, and won't
vary by deployment.
By consolidating this to always be defined in the common.py files, we
make sure that deployment environments don't have to define it. An
example of where this bit us was when course import in the course
authoring MFE did not work because Tutor was using an outdated value for
this setting.
A followup to this would be to just rip out the ENABLE_CORS_HEADERS
setting entirely, and just always have it on. But that would benefit
from a little more discovery to make sure there's no weird use case that
still requires it to be False (maybe something in the test suite?).
Prior to this commit, the LMS would log the following error in tutor
production:
pymongo/topology.py:175: UserWarning: MongoClient opened before fork.
Create MongoClient only after forking. See PyMongo's documentation for
details:
https://pymongo.readthedocs.io/en/stable/faq.html#is-pymongo-fork-safe
Quoting from that page:
> PyMongo is not fork-safe. Care must be taken when using instances of
> MongoClient with fork(). Specifically, instances of MongoClient must
> not be copied from a parent process to a child process. Instead, the
> parent process and each child process must create their own instances
> of MongoClient. Instances of MongoClient copied from the parent
> process have a high probability of deadlock in the child process due
> to the inherent incompatibilities between fork(), threads, and locks
> described below. PyMongo will attempt to issue a warning if there is a
> chance of this deadlock occurring.
For edx-platform, the MongoClient connection is initalized with the
modulestore() invocation. That call creates and caches a global variable
that Studio or the LMS will reuse across the life of the worker process.
That initialization was put into lms/wsgi.py in 7c758ec9, but originated
in lms/startup.py with 51d0dd1. The original reason for it is because at
that time (2013), we still supported the XML Modulestore, which stored
courses on disk as directories of OLX files and static assets. The XML
Modulestore would then read the entirety of those courses into memory at
startup. This meant that the startup process was *extremely* expensive,
so we needed to have it happen before the workers started serving
requests to users, instead of having the system lazily read them in when
the first user request arrived.
Loading course content in this form hasn't been supported since 2016,
meaning that modulestore initialization is no longer the performance
time bomb that it once was. The fact that this code remained here is
likely an oversight, which was considered harmless until @ztraboo
reported these pymongo log messages during the course of investigating
performance issues:
https://discuss.openedx.org/t/atlas-mongodb-performance-issues-un-indexed-queries/12803/16
Two potential followups that should be explored after this:
1. Tutor should probably be forking earlier than this, before we load
Django settings and initialize database and cache connections.
2. It's possible that the caching mechanism for modulestore should be
revisited to operate at the request cache level. The performance
benefit of keeping it around may not be worth the potential memory
leaks. Anything we do here would have to be very carefully monitored
though, since connection costs may add up.
Reverts #34554, which causes compilation of edX.org's
legacy comprehensive theme to be skipped in their deployment pipeline.
We have not determined the precise cause yet, but it seems like the
compile_sass management command is not correctly getting the
list of comprehensive theme directories from Django settings.
Together, these changes make it so that all features of the Paver-based
asset compilation system are supported with drop-in Paver-free
replacements. The remaining Paver asset functions are trivial wrappers,
which can be comfortably deleted before Sumac.
* Turn `./manage.py ... compile_sass` into a simple wrapper around `npm
run compile-sass`
* Turn `paver webpack` into a simple wrapper around `npm run webpack`
* Turn `pavelib.assets:collect_assets` into a simple wrapper around
`./manage.py ... collectstatic`
* Add/improve deprecation warnings for all Paver asset commands.
* Load defaults for asset-related Django settings from environment
variables. This allows the build to work without Python. For the
settings which will be removed in Sumac, I've added deprecation
warnings.
* Change EDX_PLATFORM_THEME_DIRS env var to COMPREHENSIVE_THEME_DIRS.
This simplifies the migration instructions, because all the new env
vars now match their corresponding Django settings. This amends an
ADR, but it should not be a breaking change because the env var was
recently added (since Quince) and nobody should be using it yet.
* Future-proof the static assets ADR with links. The linked pages will
be kept up-to-date even if the ADR isn't.
Part of: https://github.com/openedx/edx-platform/issues/34467
We've long rolled out the
`COURSEWARE_COURSE_NOT_STARTED_ENTERPRISE_LEARNER_ERROR` setting toggle so
it should be safe to remove.
I'm completely at a loss as to why course access checks are not
returning the `course_not_started_enterprise_learner` error code when it
should, but it does in stage/local, so this PR is grasping at straws.
ENT-8766
Skill tagging [1] is not a core feature, and it is not installed into core
requirements, evidenced by the fact that a try-except clause must be used to
import it into common settings. Setting overrides like this should be made in
each operator's private settings file rather than the upstream common settings
file.
BREAKING CHANGE: Operators who install the xblock-skilltagging package will
need to add SkillTaggingMixin to XBLOCK_MIXINS_EXTRA (or XBLOCK_MIXINS) in a
private settings/YAML file, as it will no longer be done automatically in
common settings. The README for xblock-skilltagging has an example [2]
[1] https://github.com/openedx/xblock-skill-tagging
[2] https://github.com/openedx/xblock-skill-tagging?tab=readme-ov-file#configuration
The course team management section under Instructor > Membership tab
allows users to be added a role even if are not enrolled in the course.
This is behaviour does not match the help text displayed in the section.
This PR updates modify_access api to enrolls user if they are not enrolled
after adding them to a role as well as changes the help text to reflect
actual changes.
This commit addresses to the need to add an API for Sidebar Navigation
that returns the course structure with sections, subsections, and
**units**, according to user access rules. (Previous outline requests
only went down to subsections.)
To improve the performance of the API, we cache the course structure
for a user, which makes it much easier to calculate the block structure
for the user at each request. However, there may be cases when this
caching can lead to an overflow of the cache storage in high-loaded LMS
with large courses, so the corresponding flag
"courseware.disable_navigation_sidebar_blocks_caching" was added so
that this caching can be disabled.
Implements the connection from the teams feature to the content groups feature. This implementation uses the dynamic partition generator extension point to associate content groups with the users that belong to a Team.
This implementation was heavily inspired by the enrollment tracks dynamic partitions.
* feat: include access serializer into mobile info api view
* test: add tests for serializer and view methods
* test: move tests to common directory and update test case
* fix: cr fixes and use snake case for functions
* test: fix additional get call assertion
* feat: add required course access messages to mobile endpoint
* test: [AXM-229] Improve test coverage
* style: [AXM-229] Try to fix linters
* fix: remove redundant comment
* refactor: change names for the test files
---------
Co-authored-by: KyryloKireiev <kirillkireev888@gmail.com>
