┌─────────────────────────────────────────────────────────────┐
│                         Client Layer                        │
│  ┌──────────────┐  ┌──────────────┐  ┌─────────────────┐   │
│  │   Web UI     │  │   REST API   │  │   AWX CLI       │   │
│  │  (React)     │  │   Clients    │  │   (awxkit)      │   │
│  └──────────────┘  └──────────────┘  └─────────────────┘   │
└────────────────────────┬────────────────────────────────────┘
                         │ HTTPS / WebSocket
┌────────────────────────▼────────────────────────────────────┐
│                    AWX Web Nodes                            │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  Django Web Application                             │    │
│  │  - REST API (Django REST Framework)                 │    │
│  │  - Authentication & RBAC                            │    │
│  │  - WebSocket handlers (Channels/Daphne)            │    │
│  └─────────────────────────────────────────────────────┘    │
└────────────────────────┬────────────────────────────────────┘
                         │
        ┌────────────────┴────────────────┐
        │                                 │
┌───────▼─────────┐            ┌──────────▼────────┐
│   PostgreSQL    │            │   Redis           │
│   Database      │            │   - Cache         │
│                 │            │   - Broker        │
└───────┬─────────┘            └──────────┬────────┘
        │                                 │
┌───────▼─────────────────────────────────▼───────────────────┐
│                    AWX Task Nodes                           │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  Dispatcher (Task Engine)                           │    │
│  │  - Task Manager                                     │    │
│  │  - Job Scheduler                                    │    │
│  │  - Callback Receiver                                │    │
│  └─────────────────────────────────────────────────────┘    │
└────────────────────────┬────────────────────────────────────┘
                         │
                         │ Receptor Mesh Network
                         │
┌────────────────────────▼────────────────────────────────────┐
│                 Execution Nodes                             │
│  ┌──────────────────────────────────────────────────────┐   │
│  │  ansible-runner                                      │   │
│  │  - Playbook execution in containers/virtual envs    │   │
│  │  - Event callbacks to AWX                           │   │
│  └──────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

# From awx/conf/settings.py
class EncryptedCacheProxy(object):
    """Proxy wrapping Redis cache with encryption for sensitive values."""
    
    def get(self, key, **kwargs):
        value = self.cache.get(key, **kwargs)
        value = self._handle_encryption(self.decrypter, key, value)
        return value
    
    def set(self, key, value, **kwargs):
        self.cache.set(
            key,
            self._handle_encryption(self.encrypter, key, value),
            **kwargs
        )

# From awx/main/dispatch/worker/task.py
def resolve_callable(task):
    """Transform dotted notation task into callable function.
    
    Examples:
        awx.main.tasks.system.delete_inventory
        awx.main.tasks.jobs.RunJob
    """
    if not task.startswith('awx.'):
        raise ValueError(f'{task} is not a valid awx task')
    module, target = task.rsplit('.', 1)
    module = importlib.import_module(module)
    _call = getattr(module, target, None)
    return _call

def run_callable(body):
    """Execute task with args/kwargs from AMQP message."""
    task = body['task']
    args = body.get('args', [])
    kwargs = body.get('kwargs', {})
    _call = resolve_callable(task)
    return _call(*args, **kwargs)

# From awx/main/models/unified_jobs.py
class TaskManagerUnifiedJobMixin:
    """Mixin providing task manager integration for jobs."""
    
    def start_job(self, **kwargs):
        """Called by task manager to start job execution."""
        # Transitions job from 'pending' -> 'waiting' -> 'running'
        # Dispatches to execution node via Receptor

                    ┌─────────────────┐
                    │  AWX Control    │
                    │     Plane       │
                    └────────┬────────┘
                             │
              ┌──────────────┴──────────────┐
              │                             │
      ┌───────▼────────┐            ┌──────▼───────┐
      │  Receptor Hop  │            │  Execution   │
      │     Node       │            │    Node 1    │
      └───────┬────────┘            └──────────────┘
              │
      ┌───────┴────────┐
      │   Execution    │
      │     Node 2     │
      └────────────────┘

# Conceptual example (simplified from actual implementation)
import ansible_runner

def run_job(job_id, playbook, inventory, credentials):
    """Execute Ansible playbook via ansible-runner."""
    
    runner_config = {
        'private_data_dir': f'/tmp/awx_{job_id}',
        'playbook': playbook,
        'inventory': inventory,
        'extravars': job.extra_vars,
        'envvars': build_safe_env(credentials),
    }
    
    # Run in execution environment (container)
    if job.execution_environment:
        runner_config['container_image'] = job.execution_environment.image
        runner_config['process_isolation'] = True
    
    # Execute with streaming events
    runner = ansible_runner.run(
        **runner_config,
        event_handler=send_event_to_awx,
        status_handler=send_status_to_awx,
    )
    
    return runner.status, runner.rc

# From awx/asgi.py
import os
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application

application = ProtocolTypeRouter({
    "http": get_asgi_application(),
    "websocket": URLRouter([
        # WebSocket routes for job events, etc.
    ]),
})

# From awx/main/consumers.py
def emit_channel_notification(group_name, data):
    """Publish notification to WebSocket channel group."""
    channel_layer = channels.layers.get_channel_layer()
    async_to_sync(channel_layer.group_send)(
        group_name,
        {'type': 'job.status', 'data': data}
    )

class CredentialType(models.Model):
    """Defines schema for credential input fields."""
    
    kind = models.CharField(
        choices=[
            ('cloud', 'Cloud'),
            ('net', 'Network'),
            ('ssh', 'Machine'),
            ('vault', 'Vault'),
            ('external', 'External'),
        ]
    )
    
    # JSON schema for input fields
    inputs = models.JSONField(default=dict)
    
    # JSON schema for injecting credentials into jobs
    injectors = models.JSONField(default=dict)

# From awx/main/utils/encryption.py concepts
def encrypt_field(obj, field_name):
    """Encrypt a model field using Fernet symmetric encryption."""
    value = getattr(obj, field_name)
    if value:
        encrypted = fernet.encrypt(value.encode())
        return encrypted
    return value

def decrypt_field(obj, field_name):
    """Decrypt a model field."""
    value = getattr(obj, field_name)
    if value:
        decrypted = fernet.decrypt(value)
        return decrypted.decode()
    return value

# From awx/main/models/credential.py
def build_safe_env(credential):
    """Build environment dict with credential values."""
    env = {}
    
    # Example: AWS credentials
    if credential.credential_type.kind == 'aws':
        env['AWS_ACCESS_KEY_ID'] = credential.inputs['username']
        env['AWS_SECRET_ACCESS_KEY'] = credential.inputs['password']
    
    # Machine credentials → SSH agent
    if credential.credential_type.kind == 'ssh':
        # Write SSH key to temporary file
        # Set up SSH agent
        # Set ansible_ssh_private_key_file
    
    return env

# From awx/main/models/notifications.py
class NotificationTemplate(models.Model):
    """Configuration for sending notifications."""
    notification_type = models.CharField(
        choices=[
            ('email', 'Email'),
            ('slack', 'Slack'),
            ('webhook', 'Webhook'),
            # ...
        ]
    )
    notification_configuration = models.JSONField()

# Build development image
make docker-compose-build

# Start AWX with hot-reload
make docker-compose

# Access shell in container
docker exec -it tools_awx_1 bash

# Run migrations
awx-manage migrate

# Create superuser
awx-manage createsuperuser

awx/
├── awx/                    # Main Django application
│   ├── main/              # Core models, tasks, business logic
│   │   ├── models/        # Django models
│   │   ├── tasks/         # Background tasks
│   │   ├── dispatch/      # Task queue system
│   │   └── tests/         # Unit tests
│   ├── api/               # REST API (DRF)
│   ├── conf/              # Dynamic configuration system
│   ├── ui/                # React frontend (built separately)
│   └── settings/          # Django settings files
├── awxkit/                # Python CLI client library
├── awx_collection/        # Ansible collection for AWX
├── tools/                 # Development tools
│   ├── docker-compose/    # Docker Compose setup
│   └── grafana/          # Grafana dashboards
├── requirements/          # Python dependencies
└── docs/                  # Documentation

# Run unit tests
make test

# Run specific test
py.test awx/main/tests/unit/test_models.py::TestJobModel

# Run with coverage
make test COVERAGE=true