def files(metaId=None):
if metaId:
account = get_account()
storage = get_storage(account=account, namespace=namespace)
logger.debug("Get file '%s'" % metaId)
rfile = get_cfile(metaId, storage)
file_name = rfile.data['file_name']
content_type = rfile.data['content_type']
logger.debug(" + File name: %s" % file_name)
logger.debug(" + Content type: %s" % content_type)
logger.debug(" + Bin Id: %s" % rfile.get_binary_id())
data = rfile.get()
if data:
response.headers['Content-Disposition'] = 'attachment; filename="%s"' % file_name
response.headers['Content-Type'] = content_type
try:
return data
except Exception, err:
logger.error(err)
else:
logger.error('No report found in gridfs')
return HTTPError(404, " Not Found")
def delete_file(metaId=None):
account = get_account()
storage = get_storage(account=account, namespace=namespace)
rfiles = []
data = request.body.readline()
items = []
try:
items = json.loads(data)
except:
logger.warning('Invalid data in request payload')
## Only accept list for multiremove
if not isinstance(items, list):
items = []
if metaId and not items:
rfile = get_cfile(metaId, storage)
rfiles.append(rfile)
else:
logger.debug('Multi-remove: %s' % data)
for item in items:
rfile = get_cfile(item['id'], storage)
rfiles.append(rfile)
logger.debug('Remove %s files' % len(rfiles))
try:
for rfile in rfiles:
rfile.remove()
return {'total': len(rfiles),"data": [] ,"success":True}
except:
logger.error('Failed to remove file')
return HTTPError(500, "Failed to remove file")
def get_account(_id=None):
logger.debug("Get Account:")
if not _id:
s = bottle.request.environ.get('beaker.session')
_id = s.get('account_id',0)
logger.debug(" + Get _id from Beaker Session (%s)" % _id)
user = s.get('account_user',0)
logger.debug(" + Try to load account %s ('%s') ..." % (user, _id))
storage = get_storage(namespace='object')
try:
account = session_accounts[_id]
logger.debug(" + Load account from memory.")
except:
if _id:
record = storage.get(_id, account=caccount(user=user) )
logger.debug(" + Load account from DB.")
account = caccount(record)
session_accounts[_id] = account
else:
logger.debug(" + Impossible to load account, return Anonymous account.")
try:
return session_accounts['anonymous']
except:
session_accounts['anonymous'] = caccount()
return session_accounts['anonymous']
return account
def account_delete(_id=None):
account = get_account()
storage = get_storage(namespace='object')
logger.debug("DELETE:")
data = request.body.readline()
if data:
try:
data = json.loads(data)
except:
logger.warning('Invalid data in request payload')
data = None
if data:
logger.debug(" + Data: %s" % data)
if isinstance(data, list):
logger.debug(" + Attempt to remove %i item from db" % len(data))
_id = []
for item in data:
if isinstance(item,str):
_id.append(item)
if isinstance(item,dict):
item_id = item.get('_id', item.get('id', None))
if item_id:
_id.append(item_id)
if isinstance(data, str):
_id = data
if isinstance(data, dict):
_id = data.get('_id', data.get('id', None))
if not _id:
return HTTPError(404, "No '_id' field in header ...")
logger.debug(" + _id: %s " % _id)
try:
storage.remove(_id, account=account)
delete_session(_id)
except:
return HTTPError(404, _id+" Not Found")
#delete all object
if not isinstance(_id, list):
_id = [_id]
mfilter = {'aaa_owner':{'$in':_id}}
record_list = storage.find(mfilter=mfilter,account=account)
record_id_list = [record._id for record in record_list]
try:
storage.remove(record_id_list,account=account)
except Exception as err:
log.error('Error While suppressing account items: %s' % err)
logger.debug('account removed')
def reload_account(_id=None,record=None):
try:
logger.debug('Reload Account %s' % _id)
account = get_account()
storage = get_storage(namespace='object')
account_to_update = None
if not record:
if _id:
record = storage.get(_id, account=account)
account_to_update = caccount(record)
else:
record = storage.get(account._id, account=account )
account_to_update = caccount(record)
if not account_to_update:
account_to_update = caccount(record)
session_accounts[account_to_update._id] = account_to_update
s = bottle.request.environ.get('beaker.session')
logger.debug(s)
logger.debug(s['account_group'])
logger.debug(s['account_groups'])
s['account_group'] = account_to_update.group
s['account_groups'] = account_to_update.groups
logger.debug('Account %s is in following groups : %s' % (_id,str(account_to_update.groups)))
s.save()
return True
except Exception,err:
logger.error('Account reloading failed : %s' % err)
return False
def account_newAuthKey(dest_account):
if not dest_account:
return HTTPError(404, 'No account specified')
#------------------------get accounts----------------------
account = get_account()
storage = get_storage(namespace='object',account=account)
_id = 'account.%s' % dest_account
try:
aim_account = caccount(storage.get(_id,account=account))
except:
logger.debug('aimed account not found')
return HTTPError(404, 'Wrong account name or no enough rights')
#---------------------generate new key-------------------
logger.debug('Change AuthKey for : %s' % aim_account.user)
try:
aim_account.generate_new_authkey()
storage.put(aim_account,account=account)
logger.debug('New auth key is : %s' % aim_account.get_authkey())
return {'total': 0, 'success': True, 'data': {'authkey': aim_account.get_authkey(),'account':aim_account.user}}
except Exception,err:
logger.error('Error while updating auth key : %s' % err)
return {'total': 0, 'success': False, 'data': {}}
def pre_run(self): self.storage = get_storage(namespace='object', account=caccount(user="******", group="root")) # TODO: Not compatible with HA ! self.topo_unloadAll() self.beat()
def update_file(metaId=None):
data = json.loads(request.body.readline())
if not metaId:
metaId = data.get('id', None)
file_name = data.get('file_name', None)
logger.debug("Update file")
if not metaId:
logger.error('No file Id specified')
return HTTPError(405, " No file Id specified")
if not file_name:
logger.error('No file_name specified')
return HTTPError(405, " No file_name specified")
logger.debug(" + metaId: %s" % metaId)
logger.debug(" + file name: %s" % file_name)
account = get_account()
storage = get_storage(account=account, namespace=namespace)
try:
record = storage.get(metaId)
if record:
record.data['file_name'] = file_name
record.name = file_name
storage.put(record)
except Exception, err:
logger.error("Error when updating report %s: %s" % (metaId,err))
return HTTPError(500, "Failed to update report")
def account_get_me():
namespace = 'object'
ctype= 'account'
#get the session (security)
account = get_account()
storage = get_storage(namespace=namespace)
#try:
logger.debug(" + Try to get '%s' ... " % account._id)
record = storage.get(account._id, account=account)
#logger.debug(" + Result: '%s'" % record)
#except Exception, err:
# self.logger.error("Exception !\nReason: %s" % err)
# return HTTPError(404, _id+" Not Found")
if record:
data = record.dump(json=True)
data['id'] = data['_id']
output = [data]
reload_account(account._id,record)
output={'total': 1, 'success': True, 'data': output}
logger.debug(" + Output: "+str(output))
logger.debug('Response status: %s' % response.status)
return output
def remove_account_from_group(group_id=None,account_id=None):
session_account = get_account()
storage = get_storage(namespace='object',account=session_account)
if not group_id or not account_id:
return HTTPError(400, 'Bad request, must specified group and account')
#get group && account
if group_id.find('group.') == -1:
group_id = 'group.%s' % group_id
if account_id.find('account.') == -1:
account_id = 'account.%s' % account_id
logger.debug('Try to get %s and %s' % (account_id,group_id))
try:
account_record = storage.get(account_id,account=session_account)
account = caccount(account_record)
group_record = storage.get(group_id,account=session_account)
group = cgroup(group_record)
except Exception,err:
logger.error('error while fetching %s and %s : %s' % (account_id,group_id,err))
return HTTPError(403, 'Record not found or insufficient rights')
def export_object(_id=None):
logger.debug('Prepare to return object json file')
account = get_account()
storage = get_storage(namespace='object', account=account)
if not _id:
_id = request.params.get('_id', default=None)
try:
logger.debug(' + Try to get object from database')
record = storage.get(_id, account=account)
logger.debug(' + %s found' % record.name)
response.headers['Content-Disposition'] = 'attachment; filename="%s.json"' % record.name
response.headers['Content-Type'] = 'application/json'
dump = record.dump()
del dump['_id']
return json.dumps(dump, sort_keys=True, indent=4)
except Exception,err:
logger.error(' + Error while fetching object : %s' % err)
return json.dumps({'error': str(err)}, sort_keys=True, indent=4)
def auth(login=None, password=None):
if not login:
login = request.params.get('login', default=None)
if not password:
password = request.params.get('password', default=None)
if not login or not password:
return HTTPError(400, "Invalid arguments")
mode = 'plain'
if request.params.get('shadow', default=False):
mode = 'shadow'
if request.params.get('cryptedKey', default=False) or request.params.get('crypted', default=False):
mode = 'crypted'
_id = "account.%s" % login
logger.debug(" + _id: %s" % _id)
logger.debug(" + Login: %s" % login)
logger.debug(" + Mode: %s" % mode)
storage = get_storage(namespace='object')
account = None
## Local
try:
account = caccount(storage.get(_id, account=caccount(user=login)))
except Exception, err:
logger.error(err)
def get_account(_id=None):
logger.debug("Get Account:")
if not _id:
s = bottle.request.environ.get('beaker.session')
_id = s.get('account_id', None)
logger.debug(" + _id: %s" % _id)
if not _id:
logger.debug(" + Failed")
return session_accounts['anonymous']
logger.debug("Load account from cache")
account = session_accounts.get(_id, None)
if account:
return account
logger.debug(" + Failed")
logger.debug("Load account from DB")
try:
user = s.get('account_user', None)
storage = get_storage(namespace='object')
account = caccount(storage.get(_id, account=caccount(user=user)))
except Exception as err:
logger.debug(" + Failed: %s" % err)
return session_accounts['anonymous']
session_accounts[_id] = account
return account
def exportView(_id=None):
logger.debug('Prepare to return view json file')
account = get_account()
storage = get_storage(namespace='object', account=account)
if not _id:
_id = request.params.get('_id', default=None)
try:
logger.debug(' + Try to get view from database')
record = storage.get(_id, account=account)
logger.debug(' + %s found' % record.name)
response.headers['Content-Disposition'] = 'attachment; filename="%s.json"' % record.name
response.headers['Content-Type'] = 'application/json'
record.parent = []
record._id = None
dump = record.dump()
output = {}
for item in dump:
if item in export_fields:
output[item] = dump[item]
return json.dumps(output, sort_keys=True, indent=4)
except Exception,err:
logger.error(' + Error while fetching view : %s' % err)
return {"total": 0, "success": False, "data": {}}
def rest_put(namespace, ctype, _id=None):
#get the session (security)
account = get_account()
storage = get_storage(namespace=namespace)
#check rights on specific ctype (check ctype_to_group_access variable below)
if ctype in ctype_to_group_access:
if not check_group_rights(account,ctype_to_group_access[ctype]):
return HTTPError(403, 'Insufficient rights')
logger.debug("PUT:")
data = request.body.readline()
if not data:
return HTTPError(400, "No data received")
logger.debug(" + data: %s" % data)
logger.debug(" + data-type: %s" % type(data))
if isinstance(data, str):
try:
data = json.loads(data)
except Exception, err:
logger.error("PUT: Impossible to parse data (%s)" % err)
return HTTPError(404, "Impossible to parse data")
def rest_delete(namespace, ctype, _id=None):
account = get_account()
storage = get_storage(namespace=namespace)
logger.debug("DELETE:")
if not _id:
data = request.body.readline()
if not data:
return HTTPError(400, "No data received")
logger.debug(" + data: %s" % data)
logger.debug(" + data-type: %s" % type(data))
if isinstance(data, str):
try:
data = json.loads(data)
except Exception, err:
logger.error("DELETE: Impossible to parse data (%s)" % err)
return HTTPError(404, "Impossible to parse data")
_id = None
try:
_id = str(data['_id'])
except:
pass
try:
_id = str(data['id'])
except:
pass
def tree_delete(name=None):
namespace = "object"
account = get_account()
storage = get_storage(namespace=namespace, account=account, logging_level=logging.DEBUG)
record = storage.get(name, account=account)
if isinstance(record, crecord):
if len(record.children) == 0:
if record.check_write(account=account):
# remove record from its parent child list
for parent in record.parent:
parent_rec = storage.get(parent, account=account)
parent_rec.remove_children(record)
if parent_rec.check_write(account=account):
storage.put(parent_rec, account=account)
else:
logger.debug("Access Denied")
return HTTPError(403, "Access Denied")
try:
storage.remove(record, account=account)
except Exception, err:
logger.error(err)
return HTTPError(404, "Error while removing: %s" % err)
else:
logger.debug("Access Denied")
return HTTPError(403, "Access Denied")
else:
logger.warning("This record have children, remove those child before")
def export_objects():
logger.debug('Prepare to return objects json file')
account = get_account()
storage = get_storage(namespace='object', account=account)
ids = request.params.getall('ids')
try:
records = []
for _id in ids:
logger.debug(' + Try to get object: %s' % _id)
record = storage.get(_id, account=account)
logger.debug(' + %s found' % record.name)
dump = record.dump()
del dump['_id']
records.append(dump)
response.headers['Content-Disposition'] = 'attachment; filename="objects.json"'
response.headers['Content-Type'] = 'application/json'
return json.dumps(records, sort_keys=True, indent=4)
except Exception, err:
logger.error(' + Error while fetching objects : %s' % err)
return json.dumps({'error': str(err)}, sort_keys=True, indent=4)
def autoLogin(key=None):
if not key:
return HTTPError(400, "No key provided")
#---------------------Get storage/account-------------------
storage = get_storage(namespace='object')
mfilter = {
'crecord_type':'account',
'authkey':key,
}
logger.debug('Try to find %s key' % key)
foundByKey = storage.find(mfilter=mfilter, account=caccount(user='******'))
#-------------------------if found, create session and redirect------------------------
if len(foundByKey) == 1:
account = caccount(foundByKey[0])
if not account.is_enable():
return HTTPError(403, "This account is not enabled")
s = bottle.request.environ.get('beaker.session')
s['account_id'] = account._id
s['account_user'] = account.user
s['account_group'] = account.group
s['account_groups'] = account.groups
s['auth_on'] = True
s.save()
#logger.debug('Autologin success, redirecting browser')
#redirect('/static/canopsis/index.html')
account = caccount(foundByKey[0])
return {'total':1,'data':[account.dump()],'success':True}
else:
logger.debug('Autologin failed, no key match the provided one')
return {'total':0,'data':{},'success':False}
def add_file():
# Must be set as text/html cause of extjs upload file method
# http://docs.sencha.com/extjs/4.0.7/#!/api/Ext.form.Basic-method-hasUpload
# A json in a string will be return to avoid Bottle to automatically set header to json
response.headers['Content-Type'] = 'text/html'
data = request.files['file-path']
if data.filename and data.file:
if allowed_mimetypes.get(data.filename.split('.')[-1], False):
content_type = allowed_mimetypes[data.filename.split('.')[-1]]
account = get_account()
storage = get_storage(account=account, namespace=namespace)
cfile_record = cfile(storage=storage)
cfile_record.put_data(data.file.read(), file_name=data.filename, content_type=content_type)
try:
file_id = storage.put(cfile_record)
data = {'success': True, 'data': {'code': 200, 'message': 'File uploaded', 'filename': data.filename, 'file_id': str(file_id)}}
except Exception as err:
data = {'success': False, 'data': {'code': 500, 'message': err}}
else:
data = {'success': False, 'data': {'code': 415, 'message': 'Unsupported Media Type'}}
else:
data = {'success': False, 'data': {'code': 400, 'message': 'Bad request'}}
return json.dumps(data)
def auth(login=None, password=None):
if not login:
login = request.params.get('login', default=None)
shadow = request.params.get('shadow', default=False)
if shadow:
shadow = True
cryptedKey = request.params.get('cryptedKey', default=False)
if not password:
password = request.params.get('password', default=None)
if not login or not password:
return HTTPError(400, "Invalid arguments")
_id = "account." + login
logger.debug(" + _id: "+_id)
logger.debug(" + Login: "******" + Password: "******" + is Shadow: "+str(shadow))
logger.debug(" + is cryptedKey: "+str(cryptedKey))
storage = get_storage(namespace='object')
try:
account = caccount(storage.get(_id, account=caccount(user=login)))
logger.debug(" + Check password ...")
if not account.is_enable():
return HTTPError(403, "This account is not enabled")
if shadow:
access = account.check_shadowpasswd(password)
elif cryptedKey:
logger.debug(" + Valid auth key: %s" % (account.make_tmp_cryptedKey()))
access = account.check_tmp_cryptedKey(password)
else:
access = account.check_passwd(password)
if access:
s = bottle.request.environ.get('beaker.session')
s['account_id'] = account._id
s['account_user'] = account.user
s['account_group'] = account.group
s['account_groups'] = account.groups
s['auth_on'] = True
s.save()
output = [ account.dump() ]
output = {'total': len(output), 'success': True, 'data': output}
return output
else:
logger.debug(" + Invalid password ...")
except Exception, err:
logger.error(err)
def init_callback():
log("Init plugin")
from cstorage import get_storage
from caccount import caccount
global storage
root = caccount(user="******", group="root")
storage = get_storage(account=root, namespace="object")
def check_and_create_authkey():
storage = get_storage(account=root, namespace='object')
records = storage.find({'crecord_type': 'account'}, namespace='object', account=root)
accounts = []
for record in records:
if not 'authkey' in record.data:
#caccount auto create authkey if not provided
accounts.append(caccount(record))
storage.put(accounts)
def update_view_relatives(_id=None):
logger.debug('PUT:')
account = get_account()
storage = get_storage(namespace='object', account=account)
data = json.loads(request.body.readline())
output = update_view(data, storage, account)
return {"total": len(data), "success": True, "data": output}
def check_user_canopsis_groups() :
try:
storage = get_storage(account=root, namespace='object')
record = storage.get('account.canopsis')
account = caccount(record)
if not 'group.CPS_view' in account.groups and not 'authkey' in record.data:
account.groups.append('group.CPS_view')
storage.put(account)
except:
pass
def resolve_selectors_name(self):
if int(time.time()) > (self.last_resolv + 60):
storage = get_storage(namespace='object', account=caccount(user="******", group="root"))
records = storage.find(mfilter={'crecord_type': 'selector'}, mfields=['crecord_name'])
self.selectors_name = [record['crecord_name'] for record in records]
self.last_resolv = int(time.time())
del storage
def get_rights(namespace,crecord_id=None):
account = get_account()
storage = get_storage(namespace=namespace, account=account, logging_level=logging.DEBUG)
if(crecord_id != None):
record = storage.get(crecord_id, account=account)
if isinstance(record, crecord):
return {"success": True, "data": record.dump(json=True)}
else:
logger.warning('The record doesn\'t exist')
def get_all_menu():
_id = request.params.get('node', default=[])
#if _id == 'root' means we want all menu
if _id == 'root':
_id = []
account = get_account()
storage = get_storage(namespace='object')
#if _id == 'menu.view' catch all view, parsed them and give them in json
if _id == 'menu.view':
logger.debug('menu.view catched ------------------------------------------------->')
mfilter = {'crecord_type': 'view'}
records = storage.find(mfilter,account=account)
#logger.debug(str(records))
output = []
for record in records:
## Check if view is not pointed by menu
mfilter = { 'crecord_type': 'menu', 'view': record._id }
item = storage.find_one(mfilter,account=account)
if not item:
logger.debug(str(record.dump()))
data = record.data
#data['id'] = str(record._id)
data['text'] = record.name
data['view'] = record._id
data['leaf'] = True
if 'template' in data:
if not data['template'] == True:
output.append(data)
else:
output.append(data)
output = json.dumps(output)
#logger.debug(" + Output: "+str(output))
return output
###############
logger.debug("Get menu:")
logger.debug(" + Node: "+str(_id))
records = storage.get_childs_of_parent(_id, rtype='menu', account=account)
output = []
for record in records:
data = record.data
data['id'] = str(record._id)
data['text'] = record.name
output.append(data)
output = json.dumps(output)
return output
def add_description_to_group():
storage = get_storage(account=root, namespace='object')
for name in groups:
try:
record = storage.get('group.%s' % name)
group_record = cgroup(record)
if not group_record.description:
group_record.description = groups[name]
storage.put(group_record)
except:
pass
def get_timeline(start=None,stop=None):
#get user and access to mongo
account = get_account()
storage = get_storage(namespace='events_log')
#get data in payload
start = request.params.get('start', default=None)
stop = request.params.get('stop', default=None)
#set returned variable
output = { }
total = None
#build filter for mongo request (put advanced option in it)
mfilter = {'$and':[{'crecord_type':'event'}]}
if start :
mfilter['and'].append({'timestamp': {'$gt': start}})
if stop :
mfilter['and'].append({'timestamp': {'$lt': stop}})
#clean mfilter
mfilter = clean_mfilter(mfilter)
records = storage.find(mfilter, account=account)
tmp_output = {}
for record in records:
dump = record.dump()
if not tmp_output.has_key(dump['event_id']) :
tmp_output[dump['event_id']] = []
tmp_output[dump['event_id']].append(dump)
events = {}
for tag in tmp_output.keys() :
prev_id = None
for record in tmp_output[tag] :
item = {}
if ( prev_id != None ) :
events[prev_id]['end'] = datetime.fromtimestamp(record['timestamp']).isoformat()#strftime('%Y-%m-%d %H:%M:%S')
item['title'] = str(dump['component'])
if 'long_output' in record :
item['description'] = record['long_output']
item['start'] = datetime.fromtimestamp(record['timestamp']).isoformat()#strftime('%Y-%m-%d %H:%M:%S')
item['durationEvent'] = True
events[record['_id']] = item
prev_id = record['_id']
output['events'] = events.values()
output['dateTimeFormat'] = 'iso8601'
output['wiki-url'] = "http://simile.mit.edu/shelf/"
output['wiki-section'] = "Simile JFK Timeline"
#return the total, the success of function and the requested data in output
return output
def pre_run(self): self.storage = get_storage(namespace='object', account=caccount(user="******", group="root")) self.manager = pyperfstore2.manager(logging_level=logging.INFO) self.beat()
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Canopsis. If not, see <http://www.gnu.org/licenses/>.
# ---------------------------------
from caccount import caccount
from cstorage import get_storage
logger = None
##set root account
root = caccount(user="******", group="root")
storage = get_storage(account=root, namespace='object')
def init():
logger.info(" + Create index of 'perfdata2'")
storage.get_backend('perfdata2').ensure_index([('co', 1), ('re', 1),
('me', 1)])
storage.get_backend('perfdata2').ensure_index([('re', 1), ('me', 1)])
storage.get_backend('perfdata2').ensure_index([('me', 1)])
storage.get_backend('perfdata2').ensure_index([('tg', 1)])
logger.info(" + Create index of 'events'")
storage.get_backend('events').ensure_index([('connector_name', 1),
('resource', 1),
('component', 1), ('state', 1),
('state_type', 1),
logger.debug(" + namespace: " + str(namespace))
logger.debug(" + Ctype: " + str(ctype))
logger.debug(" + _id: " + str(_id))
logger.debug(" + ids: " + str(ids))
logger.debug(" + Limit: " + str(limit))
logger.debug(" + Page: " + str(page))
logger.debug(" + Start: " + str(start))
logger.debug(" + Groups: " + str(groups))
logger.debug(" + onlyWritable: " + str(onlyWritable))
logger.debug(" + Sort: " + str(sort))
logger.debug(" + MSort: " + str(msort))
logger.debug(" + Search: " + str(search))
logger.debug(" + filter: " + str(filter))
logger.debug(" + query: " + str(query))
storage = get_storage(namespace=namespace, logging_level=logger.level)
total = 0
mfilter = {}
if isinstance(filter, list):
if len(filter) > 0:
mfilter = filter[0]
else:
logger.error(" + Invalid filter format")
elif isinstance(filter, dict):
mfilter = filter
records = []
if ctype:
def account_post():
#get the session (security)
account = get_account()
root_account = caccount(user="******", group="root")
storage = get_storage(namespace='object', account=account)
logger.debug("POST:")
data = request.body.readline()
if not data:
return HTTPError(400, "No data received")
data = json.loads(data)
## Clean data
try:
del data['_id']
del data['id']
del data['crecord_type']
except:
pass
if data['user']:
#check if already exist
already_exist = False
_id = "account." + str(data['user'])
try:
record = storage.get(_id, account=account)
logger.debug('Update account %s' % _id)
already_exist = True
except:
logger.debug('Create account %s' % _id)
if already_exist:
return HTTPError(
405, "Account already exist, use put method for update !")
#----------------------------CREATION--------------------------
logger.debug(' + New account')
new_account = caccount(user=data['user'],
group=data['aaa_group'],
lastname=data['lastname'],
firstname=data['firstname'],
mail=data['mail'])
#passwd
passwd = data['passwd']
new_account.passwd(passwd)
logger.debug(" + Passwd: '%s'" % passwd)
#secondary groups
if 'groups' in data:
groups = []
for group in data['groups']:
if group.find('group.') == -1:
groups.append('group.%s' % group)
else:
groups.append(group)
new_account.groups = groups
#put record
logger.debug(' + Save new account')
new_account.chown(new_account._id)
storage.put(new_account, account=account)
#get rootdir
logger.debug(' + Create view directory')
rootdir = storage.get('directory.root', account=root_account)
if rootdir:
userdir = crecord(
{
'_id': 'directory.root.%s' % new_account.user,
'id': 'directory.root.%s' % new_account.user,
'expanded': 'true'
},
type='view_directory',
name=new_account.user)
userdir.chown(new_account._id)
userdir.chgrp(new_account.group)
userdir.chmod('g-w')
userdir.chmod('g-r')
rootdir.add_children(userdir)
storage.put([rootdir, userdir], account=root_account)
else:
logger.error('Impossible to get rootdir')
else:
logger.warning('WARNING : no user specified ...')
def account_update(_id=None):
account = get_account()
root_account = caccount(user="******", group="root")
storage = get_storage(namespace='object', account=account)
logger.debug("PUT:")
data = request.body.readline()
if not data:
return HTTPError(400, "No data received")
data = json.loads(data)
if not isinstance(data, list):
data = [data]
for item in data:
logger.debug(item)
if '_id' in item:
_id = item['_id']
del item['_id']
if 'id' in item:
_id = item['id']
del item['id']
if not _id:
return HTTPError(400, "No id recieved")
try:
record = caccount(storage.get(_id, account=account))
logger.debug('Update account %s' % _id)
except:
logger.debug('Account %s not found' % _id)
return HTTPError(404, "Account to update not found")
#Get password
if 'passwd' in item:
logger.debug(' + Update password ...')
record.passwd(str(item['passwd']))
del item['passwd']
#Get group
if 'aaa_group' in item:
logger.debug(' + Update group ...')
record.chgrp(str(item['aaa_group']))
del item['aaa_group']
#get secondary groups
if 'groups' in item:
groups = []
for group in item['groups']:
if group.find('group.') == -1:
groups.append('group.%s' % group)
else:
groups.append(group)
logger.debug(' + Update groups ...')
logger.debug(' + Old groups : %s' % str(record.groups))
logger.debug(' + New groups : %s' % str(groups))
record.groups = groups
del item['groups']
for _key in item:
logger.debug('Update %s with %s' % (str(_key), item[_key]))
setattr(record, _key, item[_key])
storage.put(record, account=account)
#if user is itself, reload account
if account._id == record._id:
#user itself, reload
reload_account(record._id)
from libexec.auth import get_account
# Modules
from cstorage import get_storage
from ctools import parse_perfdata, clean_mfilter
from ctools import cleanTimestamp
from ctools import internal_metrics
import pyperfstore2
import pyperfstore2.utils
from cstorage import get_storage
from caccount import caccount
storage = get_storage(namespace='object',
account=caccount(user="******", group="root"))
manager = None
logger = logging.getLogger("perfstore")
def load():
global logger
global manager
manager = pyperfstore2.manager(logging_level='DEBUG')
def unload():
global manager
del manager
def pre_run(self):
self.storage = get_storage(namespace='object',
account=caccount(user="******", group="root"))
self.beat()
import ldap
import logging
from caccount import caccount
from cstorage import get_storage
from account import create_account
storage = get_storage(namespace='object')
logger = logging.getLogger("auth-ldap")
logger.setLevel(logging.DEBUG)
OPT_NETWORK_TIMEOUT = 1
CONFIG=None
root = account=caccount(user='******')
def get_config():
global CONFIG
if not CONFIG:
record = storage.get("ldap.config", account=root)
CONFIG = record.dump()
return CONFIG
def auth(user, password):
logger.debug("Check auth via ldap")
config = get_config()
if not config.get('enable', False):
from cselector import cselector
#from cselector import cselector_get, cselector_getall
import logging
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s %(name)s %(levelname)s %(message)s',
)
from crecord import crecord
from caccount import caccount
from cstorage import get_storage
root_account = caccount(user="******", group="root")
storage = get_storage(account=root_account,
namespace='unittest',
logging_level=logging.DEBUG)
selector = None
class KnownValues(unittest.TestCase):
def setUp(self):
pass
def test_01_InitPutGet(self):
global selector
selector = cselector(name="myselector",
namespace='unittest',
storage=storage)
selector.nocache = True
logger.debug(" + namespace: " + str(namespace))
logger.debug(" + Ctype: " + str(ctype))
logger.debug(" + _id: " + str(_id))
logger.debug(" + ids: " + str(ids))
logger.debug(" + Limit: " + str(limit))
logger.debug(" + Page: " + str(page))
logger.debug(" + Start: " + str(start))
logger.debug(" + Groups: " + str(groups))
logger.debug(" + onlyWritable: " + str(onlyWritable))
logger.debug(" + Sort: " + str(sort))
logger.debug(" + MSort: " + str(msort))
logger.debug(" + Search: " + str(search))
logger.debug(" + filter: " + str(filter))
logger.debug(" + query: " + str(query))
storage = get_storage(namespace=namespace)
total = 0
mfilter = {}
if isinstance(filter, list):
if len(filter) > 0:
mfilter = filter[0]
else:
logger.error(" + Invalid filter format")
elif isinstance(filter, dict):
mfilter = filter
records = []
if ctype:
#
# Configuration
#
########################################################
AMQP_HOST = "localhost"
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s %(name)s %(levelname)s %(message)s',
)
logger = logging.getLogger("bench")
amqp = camqp()
storage = get_storage(namespace='events',
account=caccount(user="******", group="root"))
base_component_event = cevent.forger(
connector='bench',
connector_name="engine",
event_type="check",
source_type="component",
component="component-",
state=0,
state_type=1,
output="Output",
long_output="",
#perf_data = None,
#perf_data_array = [
# {'metric': 'shortterm', 'value': 0.25, 'unit': None, 'min': None, 'max': None, 'warn': None, 'crit': None, 'type': 'GAUGE' },
# {'metric': 'midterm', 'value': 0.16, 'unit': None, 'min': None, 'max': None, 'warn': None, 'crit': None, 'type': 'GAUGE' },
def pre_run(self):
self.storage = get_storage(namespace='object',
account=caccount(user="******", group="root"))
self.manager = pyperfstore2.manager(logging_level=self.logging_level)
self.load_consolidation()
self.beat()
def __init__(self, *args, **kargs):
cengine.__init__(self, name=NAME, *args, **kargs)
self.beat_interval = 300
self.storage = get_storage(namespace='object',
account=caccount(user="******", group="root"))
