0
# Queue Operations
1

2
Queue creation, configuration, and management functionality including multiple queue support, Redis connection handling, and queue statistics.
3

4
## Capabilities
5

6
### Queue Access
7

8
Get queue instances configured through Django settings.
9

10
```python { .api }
11
def get_queue(name='default', default_timeout=None, is_async=None, autocommit=None, 
12
              connection=None, queue_class=None, job_class=None, serializer=None, **kwargs):
13
    """
14
    Get an RQ Queue instance using RQ_QUEUES configuration.
15
    
16
    Args:
17
        name: Queue name from RQ_QUEUES (default: 'default')
18
        default_timeout: Override default job timeout
19
        is_async: Whether queue runs asynchronously
20
        autocommit: Whether jobs are committed immediately
21
        connection: Redis connection instance
22
        queue_class: Custom queue class
23
        job_class: Custom job class
24
        serializer: Custom serializer
25
        **kwargs: Additional queue options
26
        
27
    Returns:
28
        DjangoRQ: Queue instance
29
    """
30

31
def get_queues(*queue_names, **kwargs):
32
    """
33
    Get multiple queue instances that share the same Redis connection.
34
    
35
    Args:
36
        *queue_names: Queue names to retrieve
37
        **kwargs: Options passed to get_queue()
38
        
39
    Returns:
40
        list: List of queue instances
41
        
42
    Raises:
43
        ValueError: If queues have different classes or connections
44
    """
45
```
46

47
Usage examples:
48

49
```python
50
import django_rq
51

52
# Get default queue
53
queue = django_rq.get_queue()
54

55
# Get named queue
56
high_queue = django_rq.get_queue('high')
57

58
# Get queue with custom options
59
queue = django_rq.get_queue('default', 
60
                           default_timeout=600,
61
                           is_async=True)
62

63
# Get multiple queues
64
queues = django_rq.get_queues('high', 'default', 'low')
65
```
66

67
### Redis Connection Management
68

69
Manage Redis connections for queues.
70

71
```python { .api }
72
def get_connection(name='default', use_strict_redis=False):
73
    """
74
    Get Redis connection for a named queue.
75
    
76
    Args:
77
        name: Queue name from RQ_QUEUES
78
        use_strict_redis: Use StrictRedis class
79
        
80
    Returns:
81
        redis.Redis: Redis connection instance
82
    """
83

84
def get_redis_connection(config, use_strict_redis=False):
85
    """
86
    Create Redis connection from configuration.
87
    
88
    Args:
89
        config: Queue configuration dict
90
        use_strict_redis: Use StrictRedis class
91
        
92
    Returns:
93
        redis.Redis: Redis connection instance
94
    """
95

96
def get_unique_connection_configs(config=None):
97
    """
98
    Get unique Redis connection configurations.
99
    
100
    Args:
101
        config: Queue configurations (uses RQ_QUEUES if None)
102
        
103
    Returns:
104
        list: Unique connection configurations
105
    """
106
```
107

108
Usage examples:
109

110
```python
111
import django_rq
112

113
# Get connection for queue
114
conn = django_rq.get_connection('high')
115

116
# Share connection across queues
117
conn = django_rq.get_connection('default')
118
queue1 = django_rq.get_queue('queue1', connection=conn)
119
queue2 = django_rq.get_queue('queue2', connection=conn)
120
```
121

122
### Django-Specific Queue Class
123

124
Enhanced queue class with Django integration features.
125

126
```python { .api }
127
class DjangoRQ:
128
    """
129
    Django-specific Queue class extending RQ's Queue.
130
    
131
    Features:
132
    - Autocommit support for Django transactions
133
    - Settings integration for result TTL
134
    - Request/response cycle job enqueueing
135
    """
136
    
137
    def __init__(self, *args, autocommit=None, **kwargs):
138
        """
139
        Initialize Django RQ queue.
140
        
141
        Args:
142
            *args: Positional arguments for Queue
143
            autocommit: Override autocommit setting
144
            **kwargs: Keyword arguments for Queue
145
        """
146
    
147
    def enqueue_call(self, *args, **kwargs):
148
        """
149
        Enqueue job with Django transaction support.
150
        
151
        Respects autocommit setting - jobs may be delayed
152
        until end of Django request if autocommit=False.
153
        """
154
    
155
    def original_enqueue_call(self, *args, **kwargs):
156
        """
157
        Direct enqueue bypassing autocommit behavior.
158
        
159
        Always enqueues immediately regardless of autocommit setting.
160
        """
161
```
162

163
### Queue Configuration
164

165
Configure queue classes and behavior.
166

167
```python { .api }
168
def get_queue_class(config=None, queue_class=None):
169
    """
170
    Get queue class from configuration or settings.
171
    
172
    Args:
173
        config: Queue configuration dict
174
        queue_class: Override queue class
175
        
176
    Returns:
177
        type: Queue class to use
178
    """
179

180
def get_commit_mode():
181
    """
182
    Get autocommit mode from RQ settings.
183
    
184
    Returns:
185
        bool: Whether jobs are committed immediately
186
    """
187
```
188

189
## Queue Statistics and Monitoring
190

191
```python { .api }
192
from django_rq.utils import get_statistics
193

194
def get_statistics(run_maintenance_tasks=False):
195
    """
196
    Get comprehensive queue statistics.
197
    
198
    Note: This function is in the utils module and must be imported directly.
199
    
200
    Args:
201
        run_maintenance_tasks: Whether to run cleanup tasks
202
        
203
    Returns:
204
        dict: Statistics including job counts, worker info, etc.
205
    """
206
```
207

208
Statistics include:
209
- Queue job counts by status (queued, started, finished, failed, deferred, scheduled)
210
- Worker counts and details
211
- Oldest job timestamps
212
- Connection information
213
- Scheduler status
214

215
## Supported Redis Configurations
216

217
Django-RQ supports various Redis configurations:
218

219
### Basic Connection
220
```python
221
RQ_QUEUES = {
222
    'default': {
223
        'HOST': 'localhost',
224
        'PORT': 6379,
225
        'DB': 0,
226
    }
227
}
228
```
229

230
### URL-based Connection
231
```python
232
RQ_QUEUES = {
233
    'default': {
234
        'URL': 'redis://localhost:6379/0',
235
    }
236
}
237
```
238

239
### Sentinel Configuration
240
```python
241
RQ_QUEUES = {
242
    'default': {
243
        'SENTINELS': [('localhost', 26379)],
244
        'MASTER_NAME': 'mymaster',
245
        'DB': 0,
246
    }
247
}
248
```
249

250
### Django Cache Integration
251
```python
252
RQ_QUEUES = {
253
    'default': {
254
        'USE_REDIS_CACHE': 'redis-cache',
255
    }
256
}
257
```
258

259
### SSL Connection
260
```python
261
RQ_QUEUES = {
262
    'default': {
263
        'HOST': 'localhost',
264
        'PORT': 6380,
265
        'DB': 0,
266
        'SSL': True,
267
        'SSL_CERT_REQS': 'required',
268
    }
269
}
270
```
271

272
## Queue Management Features
273

274
- **Multiple Queues**: Support for prioritized queue processing
275
- **Connection Sharing**: Efficient Redis connection reuse
276
- **Custom Classes**: Support for custom queue, job, and worker classes
277
- **Async/Sync Modes**: Toggle between asynchronous and synchronous execution
278
- **Transaction Integration**: Respect Django's database transaction boundaries
279
- **Result Storage**: Configurable result TTL and storage options