from pecan import expose, request
from pecan.rest import RestController
-from restful import common, module
+from restful import common, context
from restful.decorators import auth
"""
Show OSD configuration options
"""
- flags = module.instance.get("osd_map")['flags']
+ flags = context.instance.get("osd_map")['flags']
# pause is a valid osd config command that sets pauserd,pausewr
flags = flags.replace('pauserd,pausewr', 'pause')
valid_flags = set(args.keys()) & set(common.OSD_FLAGS)
invalid_flags = list(set(args.keys()) - valid_flags)
if invalid_flags:
- module.instance.log.warn("%s not valid to set/unset" % invalid_flags)
+ context.instance.log.warn("%s not valid to set/unset" % invalid_flags)
for flag in list(valid_flags):
if args[flag]:
'key': flag,
})
- return module.instance.submit_request([commands], **kwargs)
+ return context.instance.submit_request([commands], **kwargs)
"""
Show specific configuration option
"""
- return module.instance.get("config").get(self.key, None)
+ return context.instance.get("config").get(self.key, None)
"""
Show all cluster configuration options
"""
- return module.instance.get("config")
+ return context.instance.get("config")
@expose()
from pecan import expose
from pecan.rest import RestController
-from restful import common, module
+from restful import common, context
from collections import defaultdict
from restful.decorators import auth
"""
Show crush rules
"""
- rules = module.instance.get('osd_map_crush')['rules']
- nodes = module.instance.get('osd_map_tree')['nodes']
+ rules = context.instance.get('osd_map_crush')['rules']
+ nodes = context.instance.get('osd_map_tree')['nodes']
for rule in rules:
rule['osd_count'] = len(common.crush_rule_osds(nodes, rule))
from pecan import expose
from pecan.rest import RestController
-from restful import module
+from restful import context
import restful
"""
Show documentation information
"""
- return module.instance.get_doc_api(restful.api.Root)
+ return context.instance.get_doc_api(restful.api.Root)
from pecan import expose, response
from pecan.rest import RestController
-from restful import module
+from restful import context
from restful.decorators import auth
"""
mon = filter(
lambda x: x['name'] == self.name,
- module.instance.get_mons()
+ context.instance.get_mons()
)
if len(mon) != 1:
"""
Show the information for all the monitors
"""
- return module.instance.get_mons()
+ return context.instance.get_mons()
@expose()
from pecan import expose, request, response
from pecan.rest import RestController
-from restful import common, module
+from restful import common, context
from restful.decorators import auth
"""
Show implemented commands for the OSD id
"""
- osd = module.instance.get_osd_by_id(self.osd_id)
+ osd = context.instance.get_osd_by_id(self.osd_id)
if not osd:
response.status = 500
"""
command = request.json.get('command', None)
- osd = module.instance.get_osd_by_id(self.osd_id)
+ osd = context.instance.get_osd_by_id(self.osd_id)
if not osd:
response.status = 500
response.status = 500
return {'message': 'Command "%s" not available' % command}
- return module.instance.submit_request([[{
+ return context.instance.submit_request([[{
'prefix': 'osd ' + command,
'who': str(self.osd_id)
}]], **kwargs)
"""
Show the information for the OSD id
"""
- osd = module.instance.get_osds(ids=[str(self.osd_id)])
+ osd = context.instance.get_osds(ids=[str(self.osd_id)])
if len(osd) != 1:
response.status = 500
return {'message': 'Failed to identify the OSD id "%d"' % self.osd_id}
'weight': args['reweight']
})
- return module.instance.submit_request([commands], **kwargs)
+ return context.instance.submit_request([commands], **kwargs)
# TODO Filter by ids
pool_id = kwargs.get('pool', None)
- return module.instance.get_osds(pool_id)
+ return context.instance.get_osds(pool_id)
@expose()
from pecan import expose, request, response
from pecan.rest import RestController
-from restful import common, module
+from restful import common, context
from restful.decorators import auth
"""
Show the information for the pool id
"""
- pool = module.instance.get_pool_by_id(self.pool_id)
+ pool = context.instance.get_pool_by_id(self.pool_id)
if not pool:
response.status = 500
return {'message': 'Bad request: malformed JSON or wrong Content-Type'}
# Get the pool info for its name
- pool = module.instance.get_pool_by_id(self.pool_id)
+ pool = context.instance.get_pool_by_id(self.pool_id)
if not pool:
response.status = 500
return {'message': 'Failed to identify the pool id "%d"' % self.pool_id}
return {'message': 'Invalid arguments found: "%s"' % str(invalid)}
# Schedule the update request
- return module.instance.submit_request(common.pool_update_commands(pool['pool_name'], args), **kwargs)
+ return context.instance.submit_request(common.pool_update_commands(pool['pool_name'], args), **kwargs)
@expose(template='json')
"""
Remove the pool data for the pool id
"""
- pool = module.instance.get_pool_by_id(self.pool_id)
+ pool = context.instance.get_pool_by_id(self.pool_id)
if not pool:
response.status = 500
return {'message': 'Failed to identify the pool id "%d"' % self.pool_id}
- return module.instance.submit_request([[{
+ return context.instance.submit_request([[{
'prefix': 'osd pool delete',
'pool': pool['pool_name'],
'pool2': pool['pool_name'],
"""
Show the information for all the pools
"""
- pools = module.instance.get('osd_map')['pools']
+ pools = context.instance.get('osd_map')['pools']
# pgp_num is called pg_placement_num, deal with that
for pool in pools:
return {'message': 'Invalid arguments found: "%s"' % str(invalid)}
# Schedule the creation and update requests
- return module.instance.submit_request(
+ return context.instance.submit_request(
[[create_command]] +
common.pool_update_commands(pool_name, args),
**kwargs
from pecan import expose, request, response
from pecan.rest import RestController
-from restful import module
+from restful import context
from restful.decorators import auth, lock, paginate
"""
request = filter(
lambda x: x.id == self.request_id,
- module.instance.requests
+ context.instance.requests
)
if len(request) != 1:
"""
Remove the request id from the database
"""
- for index in range(len(module.instance.requests)):
- if module.instance.requests[index].id == self.request_id:
- return module.instance.requests.pop(index)
+ for index in range(len(context.instance.requests)):
+ if context.instance.requests[index].id == self.request_id:
+ return context.instance.requests.pop(index)
# Failed to find the job to cancel
response.status = 500
"""
List all the available requests
"""
- return module.instance.requests
+ return context.instance.requests
@expose(template='json')
"""
Remove all the finished requests
"""
- num_requests = len(module.instance.requests)
+ num_requests = len(context.instance.requests)
- module.instance.requests = filter(
+ context.instance.requests = filter(
lambda x: not x.is_finished(),
- module.instance.requests
+ context.instance.requests
)
# Return the job statistics
return {
- 'cleaned': num_requests - len(module.instance.requests),
- 'remaining': len(module.instance.requests),
+ 'cleaned': num_requests - len(context.instance.requests),
+ 'remaining': len(context.instance.requests),
}
"""
Pass through method to create any request
"""
- return module.instance.submit_request([[request.json]], **kwargs)
+ return context.instance.submit_request([[request.json]], **kwargs)
@expose()
from pecan import expose
from pecan.rest import RestController
-from restful import module
+from restful import context
from restful.decorators import auth
"""
Show the information for the server fqdn
"""
- return module.instance.get_server(self.fqdn)
+ return context.instance.get_server(self.fqdn)
"""
Show the information for all the servers
"""
- return module.instance.list_servers()
+ return context.instance.list_servers()
@expose()
--- /dev/null
+# Global instance to share
+instance = None
import traceback
-import module
+from . import context
# Handle authorization
username, password = b64decode(request.authorization[1]).split(':')
# Check that the username exists
- if username not in module.instance.keys:
+ if username not in context.instance.keys:
response.status = 401
response.headers['WWW-Authenticate'] = 'Basic realm="Login Required"'
return {'message': 'auth: No such user'}
# Check the password
- if module.instance.keys[username] != password:
+ if context.instance.keys[username] != password:
response.status = 401
response.headers['WWW-Authenticate'] = 'Basic realm="Login Required"'
return {'message': 'auth: Incorrect password'}
def lock(f):
@wraps(f)
def decorated(*args, **kwargs):
- with module.instance.requests_lock:
+ with context.instance.requests_lock:
return f(*args, **kwargs)
return decorated
import traceback
-from . import module
+from . import context
class ErrorHook(PecanHook):
def on_error(self, stat, exc):
- module.instance.log.error(str(traceback.format_exc()))
+ context.instance.log.error(str(traceback.format_exc()))
import socket
from . import common
+from . import context
from uuid import uuid4
from pecan import jsonify, make_app
except:
iteritems = dict.items
-# Global instance to share
-instance = None
-
class CannotServe(Exception):
pass
results.append(result)
# Run the command
- instance.send_command(result, 'mon', '', json.dumps(commands[index]), tag)
+ context.instance.send_command(result, 'mon', '', json.dumps(commands[index]), tag)
return results
def __init__(self, *args, **kwargs):
super(Module, self).__init__(*args, **kwargs)
- global instance
- instance = self
+ context.instance = self
self.requests = []
self.requests_lock = threading.RLock()