Merge branch 'master' into issue-35276-unpin-django-webpack-loader

Author: wgu-ram-chandra

README.rst

@@ -103,7 +103,7 @@ Language Packages:
 * Backend application:
 
   - ``pip install -r requirements/edx/base.txt`` (production)
-  - ``pip install -r requirements/edx/dev.txt`` (development)
+  - ``pip install -r requirements/edx/development.txt`` (development)
 
   Some Python packages have system dependencies. For example, installing these packages on Debian or Ubuntu will require first running ``sudo apt install python3-dev default-libmysqlclient-dev build-essential pkg-config`` to satisfy the requirements of the ``mysqlclient`` Python package.
 

cms/envs/common.py

@@ -378,7 +378,6 @@
     # Prevent auto auth from creating superusers or modifying existing users
     'RESTRICT_AUTOMATIC_AUTH': True,
 
-    'PREVIEW_LMS_BASE': "preview.localhost:18000",
     'ENABLE_GRADE_DOWNLOADS': True,
     'ENABLE_MKTG_SITE': False,
     'ENABLE_DISCUSSION_HOME_PANEL': True,

cms/envs/devstack-experimental.yml

@@ -324,7 +324,6 @@ FEATURES:
     ENABLE_SYSADMIN_DASHBOARD: false
     ENABLE_THIRD_PARTY_AUTH: true
     ENABLE_VIDEO_UPLOAD_PIPELINE: false
-    PREVIEW_LMS_BASE: preview.localhost:18000
     SHOW_FOOTER_LANGUAGE_SELECTOR: false
     SHOW_HEADER_LANGUAGE_SELECTOR: false
 FEEDBACK_SUBMISSION_EMAIL: ''

cms/envs/devstack.py

@@ -45,7 +45,6 @@
 
 LMS_BASE = 'localhost:18000'
 LMS_ROOT_URL = f'http://{LMS_BASE}'
-FEATURES['PREVIEW_LMS_BASE'] = "preview." + LMS_BASE
 
 FRONTEND_REGISTER_URL = LMS_ROOT_URL + '/register'
 

cms/envs/mock.yml

@@ -454,7 +454,6 @@ FEATURES:
   LTI_1P3_ENABLED: true
   MILESTONES_APP: true
   PREVENT_CONCURRENT_LOGINS: true
-  PREVIEW_LMS_BASE: preview.courses.localhost
   SEGMENT_IO_LMS: true
   SEPARATE_VERIFICATION_FROM_PAYMENT: true
   SHOW_FOOTER_LANGUAGE_SELECTOR: true

cms/envs/test.py

@@ -137,7 +137,6 @@
 
 LMS_BASE = "localhost:8000"
 LMS_ROOT_URL = f"http://{LMS_BASE}"
-FEATURES["PREVIEW_LMS_BASE"] = "preview.localhost"
 
 CMS_BASE = "localhost:8001"
 CMS_ROOT_URL = f"http://{CMS_BASE}"

common/djangoapps/student/management/commands/backfill_is_disabled.py

@@ -8,11 +8,13 @@
 """
 
 import logging
+import time
 from django.core.management.base import BaseCommand
 from django.contrib.auth import get_user_model
 from django.contrib.auth.hashers import UNUSABLE_PASSWORD_PREFIX
 from django.db import DatabaseError
 from common.djangoapps.track import segment
+import requests
 
 LOGGER = logging.getLogger(__name__)
 User = get_user_model()
@@ -28,47 +30,123 @@ def add_arguments(self, parser):
         parser.add_argument(
             '--batch-size',
             type=int,
-            default=100,
+            default=9000,
             help='Number of users to process per batch'
         )
         parser.add_argument(
             '--dry-run',
             action='store_true',
             help='Simulate the back fill without calling Segment'
         )
+        parser.add_argument(
+            '--retry-limit',
+            type=int, default=3,
+            help='Retry attempts for failed API calls'
+        )
+
+    def _process_user(self, user_id, batch_number, dry_run):
+        """Process a single user, logging success or failure."""
+        if dry_run:
+            LOGGER.info(
+                f"[Dry Run] Would update user {user_id} with is_disabled=true "
+                f"in batch {batch_number}"
+            )
+            return True
+        try:
+            segment.analytics.identify(user_id=user_id, traits={'is_disabled': True})
+            LOGGER.info(
+                f"Successfully updated user {user_id} with is_disabled=true "
+                f"in batch {batch_number}"
+            )
+            return True
+        except (ConnectionError, ValueError) as e:
+            LOGGER.error(
+                f"Failed to update user {user_id} in batch {batch_number}: "
+                f"{str(e)}"
+            )
+            return False
+
+    def _process_batch(self, users_batch, batch_number, dry_run, retry_limit):
+        """Process a batch of users with retries."""
+        current_batch_size = len(users_batch)
+        if dry_run:
+            for user_id in users_batch:
+                self._process_user(user_id, batch_number, dry_run)
+            return current_batch_size
+
+        retry_count = 0
+        success = False
+        while not success and retry_count <= retry_limit:
+            try:
+                for user_id in users_batch:
+                    self._process_user(user_id, batch_number, dry_run)
+                segment.analytics.flush()
+                LOGGER.info(f"Successfully processed batch {batch_number}")
+                success = True
+                return current_batch_size
+            except (requests.exceptions.RequestException, segment.analytics.errors.APIError) as e:
+                retry_count += 1
+                if retry_count <= retry_limit:
+                    LOGGER.warning(
+                        f"Batch {batch_number} failed (attempt {retry_count}/"
+                        f"{retry_limit}): {str(e)}"
+                    )
+                    time.sleep(2 * retry_count)
+                else:
+                    LOGGER.error(
+                        f"Batch {batch_number} failed after {retry_limit} attempts, "
+                        f"processed {{processed}} users: {str(e)}"
+                    )
+                    return None
 
     def handle(self, *args, **options):
         batch_size = options['batch_size']
         dry_run = options['dry_run']
+        retry_limit = options['retry_limit']
 
         try:
-            LOGGER.info(f"Starting back fill with batch_size={batch_size}, dry_run={dry_run}")
+            LOGGER.info(
+                f"Starting backfill (batch_size={batch_size}, dry_run={dry_run}, "
+                f"retry_limit={retry_limit})"
+            )
 
-            queryset = User.objects.filter(
+            total_users = User.objects.filter(
                 password__startswith=UNUSABLE_PASSWORD_PREFIX
-            ).values('id', 'password')
-
-            total_users = queryset.count()
+            ).count()
 
             if total_users == 0:
                 LOGGER.info("No users to process, exiting")
                 return
 
             LOGGER.info(f"Found {total_users} users that are disabled")
 
+            offset = 0
             processed = 0
-            for user in queryset.iterator(chunk_size=batch_size):
-                try:
-                    if dry_run:
-                        LOGGER.info(f"[Dry Run] Would update user {user['id']} with is_disabled=true")
-                    else:
-                        segment.identify(user['id'], {'is_disabled': 'true'})
-                        LOGGER.info(f"Successfully updated user {user['id']} with is_disabled=true")
-                    processed += 1
-                except (ConnectionError, ValueError) as e:
-                    LOGGER.error(f"Failed to update user {user['id']}: {str(e)}")
-
-            LOGGER.info(f"Back fill completed: processed {processed}/{total_users} users")
+            batch_number = 0
+
+            while offset < total_users:
+                batch_number += 1
+                users_batch = User.objects.filter(
+                    password__startswith=UNUSABLE_PASSWORD_PREFIX
+                ).values_list('id', flat=True)[offset:offset + batch_size]
+                LOGGER.info(f"Processing batch {batch_number} ({len(users_batch)} users)")
+
+                batch_result = self._process_batch(
+                    users_batch, batch_number, dry_run, retry_limit
+                )
+                if batch_result is None:
+                    LOGGER.error(
+                        f"Backfill stopped, processed {processed} users"
+                    )
+                    return
+                processed += batch_result
+                offset += batch_size
+                LOGGER.info(f"Processed {processed} / {total_users} users")
+
+            LOGGER.info(
+                f"Completed: processed {processed} / {total_users} users in "
+                f"{batch_number} batches"
+            )
 
         except DatabaseError as e:
             LOGGER.error(f"Back fill failed: {str(e)}")

docs/decisions/0002-inter-app-apis.rst

@@ -34,7 +34,7 @@ Decisions
    part of the app's domain API), then test-relevant Python APIs should be
    defined/exported in an intentional Python module called "api_for_tests.py".
 
-Exmaples
+Examples
 ~~~~~~~~
 
 As a reference example, see the Python APIs exposed by the grades app in the

lms/djangoapps/courseware/access.py

@@ -34,7 +34,6 @@
     check_course_open_for_learner,
     check_start_date,
     debug,
-    in_preview_mode
 )
 from lms.djangoapps.courseware.masquerade import get_masquerade_role, is_masquerading_as_student
 from lms.djangoapps.ccx.custom_exception import CCXLocatorValidationException
@@ -158,11 +157,6 @@ def has_access(user, action, obj, course_key=None):
     if not user:
         user = AnonymousUser()
 
-    # Preview mode is only accessible by staff.
-    if in_preview_mode() and course_key:
-        if not has_staff_access_to_preview_mode(user, course_key):
-            return ACCESS_DENIED
-
     # delegate the work to type-specific functions.
     # (start with more specific types, then get more general)
     if isinstance(obj, CourseBlock):

lms/djangoapps/courseware/access_utils.py

@@ -25,7 +25,6 @@
 from lms.djangoapps.courseware.masquerade import get_course_masquerade, is_masquerading_as_student
 from openedx.features.course_experience import COURSE_ENABLE_UNENROLLED_ACCESS_FLAG, COURSE_PRE_START_ACCESS_FLAG
 from xmodule.course_block import COURSE_VISIBILITY_PUBLIC  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.util.xmodule_django import get_current_request_hostname  # lint-amnesty, pylint: disable=wrong-import-order
 
 DEBUG_ACCESS = False
 log = getLogger(__name__)
@@ -138,7 +137,7 @@ def check_start_date(user, days_early_for_beta, start, course_key, display_error
     if start_dates_disabled and not masquerading_as_student:
         return ACCESS_GRANTED
     else:
-        if start is None or in_preview_mode() or get_course_masquerade(user, course_key):
+        if start is None or get_course_masquerade(user, course_key):
             return ACCESS_GRANTED
 
         if now is None:
@@ -158,15 +157,6 @@ def check_start_date(user, days_early_for_beta, start, course_key, display_error
         return StartDateError(start, display_error_to_user=display_error_to_user)
 
 
-def in_preview_mode():
-    """
-    Returns whether the user is in preview mode or not.
-    """
-    hostname = get_current_request_hostname()
-    preview_lms_base = settings.FEATURES.get("PREVIEW_LMS_BASE", None)
-    return bool(preview_lms_base and hostname and hostname.split(":")[0] == preview_lms_base.split(":")[0])
-
-
 def check_course_open_for_learner(user, course):
     """
     Check if the course is open for learners based on the start date.

lms/djangoapps/courseware/tests/helpers.py

@@ -8,9 +8,8 @@
 import json
 from collections import OrderedDict
 from datetime import timedelta
-from unittest.mock import Mock, patch
+from unittest.mock import Mock
 
-from django.conf import settings
 from django.contrib import messages
 from django.contrib.auth.models import User  # lint-amnesty, pylint: disable=imported-auth-user
 from django.test import TestCase
@@ -20,7 +19,6 @@
 from xblock.field_data import DictFieldData
 
 from common.djangoapps.edxmako.shortcuts import render_to_string
-from lms.djangoapps.courseware import access_utils
 from lms.djangoapps.courseware.access import has_access
 from lms.djangoapps.courseware.utils import verified_upgrade_deadline_link
 from lms.djangoapps.courseware.masquerade import MasqueradeView
@@ -460,11 +458,3 @@ def get_context_dict_from_string(data):
         sorted(json.loads(validated_data['metadata']).items(), key=lambda t: t[0])
     )
     return validated_data
-
-
-def set_preview_mode(preview_mode: bool):
-    """
-    A decorator to force the preview mode on or off.
-    """
-    hostname = settings.FEATURES.get('PREVIEW_LMS_BASE') if preview_mode else None
-    return patch.object(access_utils, 'get_current_request_hostname', new=lambda: hostname)