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"))