Python functions as REST objects, with clustering, load balancing and state replication; no containers or orchestration.

0 downloads

Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic-object-primitive.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic-object-primitive.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic-object-primitive.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

Dan Q Consolidate duplicate QUICKSTARTs on the top-level file 503f830 7 months ago History
environment.py · 9.9 KB · 392 lines
1"""
2Environment Config Object - Multi-source configuration for Object Primitives
3
4This object provides configuration management with multiple sources:
51. Runtime overrides (highest priority - for testing)
62. Environment variables
73. Persistent config values (via API)
84. Default values (lowest priority)
9
10Example usage:
11 # Get config value
12 GET /objects/environment?key=DATABASE_URL
13
14 # Set config value (persistent)
15 POST /objects/environment
16 {
17 "key": "DATABASE_URL",
18 "value": "postgresql://localhost/mydb"
19 }
20
21 # Set runtime override (temporary, for testing)
22 PUT /objects/environment
23 {
24 "key": "DATABASE_URL",
25 "value": "postgresql://localhost/testdb",
26 "ttl": 3600
27 }
28
29 # Delete config value
30 DELETE /objects/environment?key=DATABASE_URL
31
32 # List all config values
33 GET /objects/environment?list=true
34"""
35
36import os
37import time
38import json
39from typing import Any, Dict, Optional
40
41# These will be injected by ObjectRuntime
42_logger = None
43_state_manager = None
44
45
46def GET(request: Dict[str, Any]) -> Dict[str, Any]:
47 """Get config value or list all config"""
48
49 # List all config
50 if request.get('list'):
51 return _list_all_config()
52
53 # Get specific config value
54 key = request.get('key', '').strip()
55
56 if not key:
57 return {'status': 'error', 'message': 'key is required'}
58
59 default = request.get('default')
60
61 # Get value from all sources (priority order)
62 value, source = _get_config_value(key, default)
63
64 if value is None and default is None:
65 return {
66 'status': 'error',
67 'message': f'Config not found: {key}',
68 }
69
70 if _logger:
71 _logger.info('Config retrieved',
72 key=key,
73 source=source,
74 has_value=value is not None)
75
76 return {
77 'status': 'ok',
78 'key': key,
79 'value': value,
80 'source': source,
81 }
82
83
84def POST(request: Dict[str, Any]) -> Dict[str, Any]:
85 """Set config value (persistent)"""
86 key = request.get('key', '').strip()
87 value = request.get('value')
88
89 if not key:
90 return {'status': 'error', 'message': 'key is required'}
91
92 if value is None:
93 return {'status': 'error', 'message': 'value is required'}
94
95 # Validate value type
96 value_type = request.get('type', 'string')
97 validated_value, error = _validate_value(value, value_type)
98
99 if error:
100 return {'status': 'error', 'message': error}
101
102 # Save to persistent config
103 config_entry = {
104 'key': key,
105 'value': validated_value,
106 'type': value_type,
107 'created_at': int(time.time()),
108 'updated_at': int(time.time()),
109 }
110
111 _save_config(config_entry)
112
113 if _logger:
114 _logger.info('Config set',
115 key=key,
116 type=value_type)
117
118 return {
119 'status': 'ok',
120 'key': key,
121 'value': validated_value,
122 'message': f'Config set: {key}',
123 }
124
125
126def PUT(request: Dict[str, Any]) -> Dict[str, Any]:
127 """Set runtime override (temporary, for testing)"""
128 key = request.get('key', '').strip()
129 value = request.get('value')
130 ttl = request.get('ttl', 3600) # Default 1 hour
131
132 if not key:
133 return {'status': 'error', 'message': 'key is required'}
134
135 if value is None:
136 return {'status': 'error', 'message': 'value is required'}
137
138 try:
139 ttl = int(ttl)
140 except (ValueError, TypeError):
141 ttl = 3600
142
143 # Save as runtime override
144 override = {
145 'key': key,
146 'value': value,
147 'created_at': int(time.time()),
148 'expires_at': int(time.time()) + ttl,
149 }
150
151 _save_override(override)
152
153 if _logger:
154 _logger.info('Runtime override set',
155 key=key,
156 ttl=ttl)
157
158 return {
159 'status': 'ok',
160 'key': key,
161 'value': value,
162 'ttl': ttl,
163 'message': f'Runtime override set: {key} (expires in {ttl}s)',
164 }
165
166
167def DELETE(request: Dict[str, Any]) -> Dict[str, Any]:
168 """Delete config value or override"""
169 key = request.get('key', '').strip()
170 override_only = request.get('override_only', False)
171
172 if not key:
173 return {'status': 'error', 'message': 'key is required'}
174
175 # Delete override
176 override_deleted = _delete_override(key)
177
178 # Delete persistent config (unless override_only)
179 config_deleted = False
180 if not override_only:
181 config_deleted = _delete_config(key)
182
183 if not override_deleted and not config_deleted:
184 return {
185 'status': 'error',
186 'message': f'Config not found: {key}',
187 }
188
189 if _logger:
190 _logger.info('Config deleted',
191 key=key,
192 override_deleted=override_deleted,
193 config_deleted=config_deleted)
194
195 return {
196 'status': 'ok',
197 'message': f'Config deleted: {key}',
198 'override_deleted': override_deleted,
199 'config_deleted': config_deleted,
200 }
201
202
203# Helper functions
204
205def _get_config_value(key: str, default: Any = None) -> tuple[Any, str]:
206 """
207 Get config value from all sources (priority order):
208 1. Runtime overrides (highest priority)
209 2. Environment variables
210 3. Persistent config
211 4. Default value (lowest priority)
212 """
213
214 # 1. Check runtime overrides first
215 override = _get_override(key)
216 if override:
217 # Check if expired
218 if override['expires_at'] <= int(time.time()):
219 _delete_override(key)
220 else:
221 return override['value'], 'override'
222
223 # 2. Check environment variables
224 env_value = os.environ.get(key)
225 if env_value is not None:
226 return env_value, 'environment'
227
228 # 3. Check persistent config
229 config = _get_config(key)
230 if config:
231 return config['value'], 'config'
232
233 # 4. Return default
234 return default, 'default'
235
236
237def _validate_value(value: Any, value_type: str) -> tuple[Any, Optional[str]]:
238 """Validate value matches expected type"""
239
240 if value_type == 'string':
241 return str(value), None
242
243 elif value_type == 'int':
244 try:
245 return int(value), None
246 except (ValueError, TypeError):
247 return None, f'Invalid int: {value}'
248
249 elif value_type == 'float':
250 try:
251 return float(value), None
252 except (ValueError, TypeError):
253 return None, f'Invalid float: {value}'
254
255 elif value_type == 'bool':
256 if isinstance(value, bool):
257 return value, None
258 if isinstance(value, str):
259 if value.lower() in ('true', '1', 'yes'):
260 return True, None
261 if value.lower() in ('false', '0', 'no'):
262 return False, None
263 return None, f'Invalid bool: {value}'
264
265 elif value_type == 'json':
266 if isinstance(value, (dict, list)):
267 return value, None
268 try:
269 return json.loads(value), None
270 except (ValueError, TypeError):
271 return None, f'Invalid JSON: {value}'
272
273 else:
274 return None, f'Unknown type: {value_type}'
275
276
277def _save_config(config: Dict[str, Any]) -> None:
278 """Save config to persistent storage"""
279 if not _state_manager:
280 return
281
282 key = config['key']
283 _state_manager.set(f'config_{key}', json.dumps(config))
284
285
286def _get_config(key: str) -> Optional[Dict[str, Any]]:
287 """Get config from persistent storage"""
288 if not _state_manager:
289 return None
290
291 config_json = _state_manager.get(f'config_{key}')
292 if not config_json:
293 return None
294
295 return json.loads(config_json)
296
297
298def _delete_config(key: str) -> bool:
299 """Delete config from persistent storage"""
300 if not _state_manager:
301 return False
302
303 config = _get_config(key)
304 if not config:
305 return False
306
307 _state_manager.delete(f'config_{key}')
308 return True
309
310
311def _save_override(override: Dict[str, Any]) -> None:
312 """Save runtime override"""
313 if not _state_manager:
314 return
315
316 key = override['key']
317 _state_manager.set(f'override_{key}', json.dumps(override))
318
319
320def _get_override(key: str) -> Optional[Dict[str, Any]]:
321 """Get runtime override"""
322 if not _state_manager:
323 return None
324
325 override_json = _state_manager.get(f'override_{key}')
326 if not override_json:
327 return None
328
329 return json.loads(override_json)
330
331
332def _delete_override(key: str) -> bool:
333 """Delete runtime override"""
334 if not _state_manager:
335 return False
336
337 override = _get_override(key)
338 if not override:
339 return False
340
341 _state_manager.delete(f'override_{key}')
342 return True
343
344
345def _list_all_config() -> Dict[str, Any]:
346 """List all config values from all sources"""
347 if not _state_manager:
348 return {
349 'status': 'ok',
350 'config': {},
351 'overrides': {},
352 'environment': {},
353 }
354
355 all_state = _state_manager.get_all()
356
357 # Get persistent config
358 config_values = {}
359 for key, value in all_state.items():
360 if key.startswith('config_'):
361 config = json.loads(value)
362 config_key = config['key']
363 config_values[config_key] = config['value']
364
365 # Get runtime overrides
366 override_values = {}
367 now = int(time.time())
368 for key, value in all_state.items():
369 if key.startswith('override_'):
370 override = json.loads(value)
371
372 # Skip expired
373 if override['expires_at'] < now:
374 continue
375
376 override_key = override['key']
377 override_values[override_key] = override['value']
378
379 # Get environment variables (only those that match config keys)
380 env_values = {}
381 all_keys = set(config_values.keys()) | set(override_values.keys())
382 for key in all_keys:
383 env_value = os.environ.get(key)
384 if env_value is not None:
385 env_values[key] = env_value
386
387 return {
388 'status': 'ok',
389 'config': config_values,
390 'overrides': override_values,
391 'environment': env_values,
392 }