class LRGParser(HTMLParser.HTMLParser): def __init__(self, downloadFileControl, toAddPassword, linkType): HTMLParser.HTMLParser.__init__(self) self.valList = [] self.done = False self.toAddPassword = toAddPassword self.linkType = linkType self.downloadFileControl = downloadFileControl self.linksDict = {} self.log = Log() def feed(self, htmlBody): try: HTMLParser.HTMLParser.feed(self, htmlBody) except HTMLParser.HTMLParseError, e: self.log.debug('LRGParser HTMLParser.HTMLParseError', e) if self.linkType == URLCASH: tmpHTMLBody = htmlBody pos = tmpHTMLBody.find(URLCASH_IFRAME) if pos != -1: tmpBody = tmpHTMLBody[pos + len(URLCASH_IFRAME):] rapidUrl = tmpBody[:tmpBody.find(SINGLE_QUOTE)] self.log.debug(rapidUrl) self.linksDict[rapidUrl] = rapidUrl self.downloadFileControl.processTag(self.valList, self.linksDict) else: self.downloadFileControl.reportError('Cannot find rapidshare links')
def probe(self, conn): """Ask everybody this account is subscribed to for a status update. This is used when a client first connects. Also fake responses from TERM users""" Log.debug("probing friends from %s" % conn.authJID.full) roster = self._get(conn) elem = conn.E.presence({'from': unicode(conn.authJID), 'type': 'probe'}) sender = UserManager.UserManager.LoadUser(conn._userid) for jid in roster.watching(): if (jid in self._rosters): try: conn.send(jid, elem) except Exception as e: Log.error("Exception caught when probing XMPP user %r: %r" % (jid, e)) Log.error(traceback.format_exc()) # if (jid != conn.authJID.bare): # bug somewhere, if they are equal.. for session_info in self.get_bbs_online(jid): if (not sender.CanSee(session_info._userinfo)): continue show = session_info.get_show(self.get_user(conn.authJID.bare)) elem = conn.E.presence( {'from' : '%s/%s' % (jid, session_info.get_res()), 'to' : conn.authJID.bare}, conn.E.status(session_info.get_status()), conn.E.priority(session_info.get_priority())) if (show != None): elem.append(conn.E.show(show)) try: conn.send(conn.authJID, elem) except Exception as e: Log.error("Exception caught when faking response from %s/%s to %r" % (jid, session_info.get_res(), conn.authJID.bare)) Log.error(traceback.format_exc()) Log.debug("probed friends from %s" % conn.authJID.full)
def getOsdMapInfos(self, pgid): Log.info("___getOsdMapInfos(pgid=" + str(pgid) + ")") cephRestApiUrl = self.cephRestApiUrl + 'tell/' + pgid + '/query.json'; Log.debug("____cephRestApiUrl Request=" + cephRestApiUrl) osdmap = [] data = requests.get(cephRestApiUrl) r = data.content if data.status_code != 200: print 'Error ' + str(data.status_code) + ' on the request getting pools' return osdmap # print(r) if len(r) > 0: osdmap = json.loads(r) else: Log.err('The getOsdMapInfos() method returns empty data') osdmap = json.loads(r) # osdmap=r.read() # Log.debug(osdmap) acting = osdmap["output"]["acting"] up = osdmap["output"]["up"] state = osdmap["output"]["state"] acting_primary = osdmap["output"] ["info"]["stats"]["acting_primary"] up_primary = osdmap["output"]["info"]["stats"]["up_primary"] osdmap_infos = {"acting":acting, "acting_primary":acting_primary, "state":state, "up":up, "up_primary":up_primary} return osdmap_infos
def getChunkSize2(self, poolName, objectid): Log.debug("___getChunkSize(poolName=" + str(poolName) + ", objectId=" + str(objectid) + ")") outdata = self.executeCmd('rados --pool=', [poolName, ' stat ', objectid], []) #'.rgw.buckets/default.4651.2__shadow__0cIEZvHYuHkJ6xyyh9lwX4pj5ZsHrFD_125 mtime 1391001418, size 4194304\n' objectsize = outdata[outdata.index('size') + 5: outdata.index('\n')] return objectsize.rstrip()
def parse(self, requestString): """ Populate the header based on an input string. """ self.parseError = False lines = requestString.splitlines() Log.log('Parsing request-line...') requestLine = lines[0].split(' ') if len(requestLine) != 3: Log.log('Malformed request-line.') self.parseError = True return self.method = requestLine[0].upper() # The URI can have 3 forms; absoluteURI, abs_path, authority # We transform absoluteURI to abs_path for convenience uri = requestLine[1] uri = re.sub(r'^http://.*?(?=/)', '', uri) self.uri = Uri(uri) self.parseError = self.parseError or self.uri.parseError self.version = requestLine[2].upper() Log.debug('(method, uri, version) =', (self.method, str(self.uri), self.version)) for line in lines[1:]: field, _, value = line.partition(':') self.setField(field, value) Log.debug('Fields:', self.fields)
def forget(self, jid): """A client has disconnected.""" Log.debug('forgetting %r in roster' % jid) self._requests.discard(jid) self._last.pop(jid, None) return self
def notify_session(self, jid, session, type = None): # notify session changed (online/state change) for hisjid in self._rosters: roster = self._rosters[hisjid] if (jid in roster.watching()): him = self.get_user(hisjid) # he can't see you! if (not him.CanSee(session._userinfo)): continue # you are watching me, so I'll notify you Log.debug("notify %s about %s" % (hisjid, session.get_fulljid())) elem = None if (type == None): show = session.get_show(self.get_user(hisjid)) elem = self.E.presence( {'from' : session.get_fulljid(), 'to' : hisjid}, self.E.status(session.get_status()), self.E.priority(session.get_priority())) if (show != None): elem.append(self.E.show(show)) else: elem = self.E.presence( {'from' : session.get_fulljid(), 'to' : hisjid, 'type' : type}) try: self.transmit(hisjid, elem) except Exception as e: Log.error("notify error: %r" % e) Log.error(traceback.format_exc())
def getChunkBaseName1(self, poolName, objId): Log.debug("____Get the chunks list for the object [" + str(objId) + "] and the pool[ " + str(poolName) + "]") outdata = self.executeCmd( "rados --pool ", [poolName, " getxattr ", '"' + objId + '"' + " ", "user.rgw.manifest"], [] ) shadow = ( outdata.replace("\x00", "") .replace("\x07", "") .replace("\x01", "") .replace("\x02", "") .replace("\x08", "") .replace("\x03", "") .replace("\x11", "") .replace("\x12", "") ) # '.index\x08\x08!.a8IqjFd0B9KyTAxmOh77aJEAB8lhGUV_\x01\x02\x01 \x08@\x07\x03_\x07cephfun\x0c' # Log.debug("___Shadow: "+shadow) if shadow.count("shadow") > 0: shadow_motif = re.search("(?<=_shadow__)(\w(\-)*)+", shadow) print "_____ shadow motif= ", shadow_motif # chunkname=shadow_motif[shadow_motif.index('_shadow__')+9:,] chunkname = shadow_motif.group(0) chunkname = chunkname[0 : chunkname.index("_")] elif shadow.count("!."): # shadow_motif = re.search('(?<=\!\.)\w+', shadow) # chunkname=shadow_motif.group(0) chunkname = shadow[shadow.index("!.") + 3 : shadow.index("_ @")] else: # The case the object has no chunk because it's not too large chunkname = "" Log.debug("____Chunkbasename= " + chunkname) return chunkname
def __exit__(self, *args): self.end = time.time() self.secs = self.end - self.start self.msecs = self.secs * 1000 # millisecs if self.verbose: Log.debug('elapsed time for action \"%s\": %f ms' % (self.action, self.msecs))
def getChunkBaseName(self, poolName, objectid): Log.info("____Get the chunks list for the object [" + objectid + "] and the pool[ " + str(poolName) + "]") ioctx = self.cluster.open_ioctx(str(poolName)) xattr = ioctx.get_xattr(str(objectid), 'user.rgw.manifest') shadow = xattr.replace('\x00', '').replace('\x01', '').replace('\x02', '').replace('\x03', '').\ replace('\x04', '').replace('\x05', '').replace('\x06', '').replace('\x07', '').replace('\x08', '').replace('\x09', '')\ .replace('\x10', '').replace('\x11', '').replace('\x12', '').replace('\x0e', '').replace('\x0b', '').replace('\x0c', '') # '.index\x08\x08!.a8IqjFd0B9KyTAxmOh77aJEAB8lhGUV_\x01\x02\x01 \x08@\x07\x03_\x07cephfun\x0c' Log.debug("___Shadow: " + shadow) if shadow.count('shadow') > 0: shadow_motif = re.search('(?<=_shadow__)(\w(\-)*)+', shadow) print "_____ shadow motif= ", shadow_motif # chunkname=shadow_motif[shadow_motif.index('_shadow__')+9:,] chunkname = shadow_motif.group(0) chunkname = chunkname[0:chunkname.index('_')] elif shadow.count('!.'): # shadow_motif = re.search('(?<=\!\.)\w+', shadow) # chunkname=shadow_motif.group(0) pos = shadow.index('!.') + 2 chunkname = shadow[pos:pos + 30] # The lenght of the shadow base name is 30! else: # The case the object has no chunk because it's not too large chunkname = '' Log.debug("____Chunkbasename= " + chunkname) return chunkname
def getChunkBaseName1(self, poolName, objId): Log.debug("____Get the chunks list for the object [" + str(objId) + "] and the pool[ " + str(poolName) + "]") outdata = self.executeCmd('rados --pool ', [ poolName, ' getxattr ', '"' + objId + '"' + ' ', 'user.rgw.manifest' ], []) shadow = outdata.replace('\x00', '').replace('\x07', '').replace('\x01', '').replace('\x02', '').\ replace('\x08','').replace('\x03', '').replace('\x11', '').replace('\x12','') # '.index\x08\x08!.a8IqjFd0B9KyTAxmOh77aJEAB8lhGUV_\x01\x02\x01 \x08@\x07\x03_\x07cephfun\x0c' #Log.debug("___Shadow: "+shadow) if shadow.count('shadow') > 0: shadow_motif = re.search('(?<=_shadow__)(\w(\-)*)+', shadow) print "_____ shadow motif= ", shadow_motif #chunkname=shadow_motif[shadow_motif.index('_shadow__')+9:,] chunkname = shadow_motif.group(0) chunkname = chunkname[0:chunkname.index('_')] elif shadow.count('!.'): #shadow_motif = re.search('(?<=\!\.)\w+', shadow) #chunkname=shadow_motif.group(0) chunkname = shadow[shadow.index('!.') + 3:shadow.index('_ @')] else: # The case the object has no chunk because it's not too large chunkname = '' Log.debug("____Chunkbasename= " + chunkname) return chunkname
def deleteCapability(uid): Log.debug("deleteCapability") try: return Response(S3Ctrl(conf).deleteCapability(uid),mimetype='application/json') except S3Error , e: Log.err(e.__str__()) return Response(e.reason, status=e.code)
def getObjectStructure() : Log.debug("Calling getObjectStructure() method") try : return Response(S3ObjectCtrl(conf).getObjectStructure(),mimetype='application/json') except S3Error , e : Log.err(e.__str__()) return Response(e.reason, status=e.code)
def getOsdInfos(self, osds, osdid): Log.info("___getOsdInfos(osdid=" + str(osdid) + ")") i = 0 osdnodename = '' capacity = 0 used = 0 total = 1 hostid = '' while i < len(osds): if osds[i]["node"]["_id"] == osdid: osdnodename = osds[i]["node"]["name"] break i = i + 1 Log.debug("_____OSD Node Name= " + str(osdnodename)) stat = [] try: while i < len(osds): if osds[i]["stat"]["osd"]["node"]["$id"] == osdid: state = osds[i]["stat"] if state["in"]: stat.append("in") if state["up"]: stat.append("up") hostid = osds[i]["stat"]["osd"]["host"]["$id"] capacity = osds[i]["host"]["network_interfaces"][0]["capacity"] if osds[i]["partition"]["stat"] != 'null': used = osds[i]["partition"]["stat"]["used"] if osds[i]["partition"]["stat"] != 'null': total = osds[i]["partition"]["stat"]["total"] break i = i + 1 except TypeError, e: Log.err(e.__str__())
def deleteCapability(self, uid): capType = request.form['type'] capPerm = request.form['perm'] Log.debug("deleteCapability " + capType + "=" + capPerm + " for user with uid " + uid) return S3User.deleteCapability(uid, capType, capPerm, self.getAdminConnection())
def deleteSubuserKey(uid, subuser, key): Log.debug("deleteSubuserKey") try: return Response(S3Ctrl(conf).deleteSubuserKey(uid, subuser,key),mimetype='application/json') except S3Error , e: Log.err(e.__str__()) return Response(e.reason, status=e.code)
def createSubuserKey(self, uid, subuser): Log.debug("create key for subuser " + subuser + " for user with uid " + uid) generate_key = request.form['generate_key'] secret_key = request.form['secret_key'] return S3User.createSubuserKey(uid, subuser, generate_key, secret_key, self.getAdminConnection())
def modify(uid, jsonUserData, conn): # Content of jsonUserData : # -------------------- # display-name / The display name of the user to be created. / String / Required # email / The email address associated with the user./ String / not required # key-type / Key type to be generated, options are: swift, s3 (default). / String / not required # access-key / Specify access key./ String / not required # secret-key / Specify secret key./ String / not required # user-caps / User capabilities / String : Example: usage=read, write; users=read / not required # generate-key / Generate a new key pair and add to the existing keyring./Boolean Example: True [True]/ not required # max-buckets / Specify the maximum number of buckets the user can own. / Integer / not required # suspended / Specify whether the user should be suspended / Boolean Example: False [False] / not required self = S3User() Log.debug("User modification input parameters : json=" + jsonUserData) userData = json.loads(jsonUserData) self.uid = uid self.displayName = userData.get('display_name', None) self.email = userData.get('email', None) self.maxBuckets = userData.get('max_buckets', None) self.suspended = userData.get('suspended', None) # self.keyType = userData.get('key_type', None) self.access = userData.get('access_key', None) self.secret = userData.get('secret_key', None) # self.caps = userData.get('user_caps', None) self.generate = userData.get('generate_key', None) myargs = [] myargs.append(("uid", self.uid)) if self.displayName is not None: myargs.append(("display-name", self.displayName)) if self.email is not None: myargs.append(("email", self.email)) # if self.keyType is not None : # myargs.append(("key-type",self.keyType)) # if self.access is not None : # myargs.append(("access-key",self.access)) # if self.secret is not None : # myargs.append(("secret-key",self.secret)) # if self.caps is not None : # myargs.append(("user-caps",self.caps)) if self.generate is not None: myargs.append(("generate-key", self.generate)) else: if self.access is not None and self.secret is not None: myargs.append(("access-key", self.access)) myargs.append(("secret-key", self.secret)) if self.maxBuckets is not None: myargs.append(("max-buckets", self.maxBuckets.__str__())) if self.suspended is not None: myargs.append(("suspended", self.suspended)) Log.debug("Modify user : "******"POST", key="user", args=myargs) res = conn.send(request) user = res.read() return user
def modify(uid, jsonUserData , conn): # Content of jsonUserData : # -------------------- # display-name / The display name of the user to be created. / String / Required # email / The email address associated with the user./ String / not required # key-type / Key type to be generated, options are: swift, s3 (default). / String / not required # access-key / Specify access key./ String / not required # secret-key / Specify secret key./ String / not required # user-caps / User capabilities / String : Example: usage=read, write; users=read / not required # generate-key / Generate a new key pair and add to the existing keyring./Boolean Example: True [True]/ not required # max-buckets / Specify the maximum number of buckets the user can own. / Integer / not required # suspended / Specify whether the user should be suspended / Boolean Example: False [False] / not required self = S3User() Log.debug("User modification input parameters : json="+jsonUserData) userData = json.loads(jsonUserData) self.uid = uid self.displayName = userData.get('display_name', None) self.email = userData.get('email',None) self.maxBuckets = userData.get('max_buckets', None) self.suspended = userData.get('suspended', None) # self.keyType = userData.get('key_type', None) self.access = userData.get('access_key', None) self.secret = userData.get('secret_key', None) # self.caps = userData.get('user_caps', None) self.generate = userData.get('generate_key', None) myargs = [] myargs.append(("uid",self.uid)) if self.displayName is not None : myargs.append(("display-name",self.displayName)) if self.email is not None : myargs.append(("email",self.email)) # if self.keyType is not None : # myargs.append(("key-type",self.keyType)) # if self.access is not None : # myargs.append(("access-key",self.access)) # if self.secret is not None : # myargs.append(("secret-key",self.secret)) # if self.caps is not None : # myargs.append(("user-caps",self.caps)) if self.generate is not None : myargs.append(("generate-key",self.generate)) else: if self.access is not None and self.secret is not None : myargs.append(("access-key",self.access)) myargs.append(("secret-key",self.secret)) if self.maxBuckets is not None : myargs.append(("max-buckets",self.maxBuckets.__str__())) if self.suspended is not None : myargs.append(("suspended",self.suspended)) Log.debug("Modify user : "******"POST", key="user", args= myargs) res = conn.send(request) user = res.read() return user
def deleteCapability(uid): Log.debug("deleteCapability") try: return Response(S3Ctrl(conf).deleteCapability(uid), mimetype='application/json') except S3Error, e: Log.err(e.__str__()) return Response(e.reason, status=e.code)
def getObjectStructure(): Log.debug("Calling getObjectStructure() method") try: return Response(S3ObjectCtrl(conf).getObjectStructure(), mimetype='application/json') except S3Error, e: Log.err(e.__str__()) return Response(e.reason, status=e.code)
def test_Log(self): # Log log = Log() log.debug("Test", "Debug") log.info("Test", "Info") log.warning("Test", "Warning") log.error("Test", "Error") log.SQLQuery("INSERT INTO ha_data (DataId, DataName, DataText, DataStatus, DataLastUpdated) VALUES (9999, 'Test', 'Test', 200, NOW()) ON DUPLICATE KEY UPDATE DataText = VALUES(DataText), DataStatus = VALUES(DataStatus), DataLastUpdated = VALUES(DataLastUpdated)")
def ping_client(self): try: pingelem = self.E.ping(xmlns='urn:xmpp:ping') return self.iq('get', self.ping_result, pingelem) except Exception as e: Log.debug("ping client %r failed: %r" % (self.authJID, e)) Log.debug(traceback.format_exc()) return False
def deleteSubuserKey(uid, subuser, key): Log.debug("deleteSubuserKey") try: return Response(S3Ctrl(conf).deleteSubuserKey(uid, subuser, key), mimetype='application/json') except S3Error, e: Log.err(e.__str__()) return Response(e.reason, status=e.code)
def deleteSubuser(uid, subuser , conn): myargs = [] myargs.append(("subuser",subuser)) myargs.append(("uid", uid)) Log.debug(myargs.__str__()) request= conn.request(method="DELETE", key="user", args= myargs) res = conn.send(request) return "";
def update_friends(self): Log.debug("updating friend lists") for login_id in self._conns: conn = self._conns[login_id] roster = self._rosters.get(conn.authJID.bare) # user may have disconnected if roster is not None: roster.check_update(conn)
def transmit(self, to, elem): for (fulljid, route) in self.routes(to): Log.debug("sending to %s" % fulljid) try: route.handle(elem) except Exception as e: Log.error("send error: %r" % e) Log.error(traceback.format_exc())
def deleteSubuser(uid, subuser, conn): myargs = [] myargs.append(("subuser", subuser)) myargs.append(("uid", uid)) Log.debug(myargs.__str__()) request = conn.request(method="DELETE", key="user", args=myargs) res = conn.send(request) return ""
def handle_signal_abort(self, signum, frame): Log.warn("Someone want to kill me! But I'll not die now! Hahahaha!") s = summary.summarize(muppy.get_objects()) Log.debug("Current memory usage:") summary.print_(s) diff = summary.get_diff(self.mem_sum, s) self.mem_sum = s Log.debug("New memory usage:") summary.print_(diff)
def getAttribute(self, key): try: attr = self._attributes[key] if(attr == "" or attr == None): attr = Person,ATTR_NOT_AVAILABLE return attr except: Log.debug(self.__class__, "key does not exist =" + key) return Person.ATTR_NOT_AVAILABLE
def createBucket(self): bucket = request.form['bucket'] owner = request.form['owner'] Log.debug( "createBucket "+bucket+" for user "+owner) # creation under admin account mybucket = S3Bucket( bucket, access_key=self.key, secret_key=self.secret , base_url= self.radosgw_url+bucket) mybucket.put_bucket() # change new bucket's owner return self.linkBucket(owner,bucket)
def getChunkSize2(self, poolName, objectid): Log.debug("___getChunkSize(poolName=" + str(poolName) + ", objectId=" + str(objectid) + ")") outdata = self.executeCmd('rados --pool=', [poolName, ' stat ', objectid], []) #'.rgw.buckets/default.4651.2__shadow__0cIEZvHYuHkJ6xyyh9lwX4pj5ZsHrFD_125 mtime 1391001418, size 4194304\n' objectsize = outdata[outdata.index('size') + 5:outdata.index('\n')] return objectsize.rstrip()
def getPoolnBucketId(self,bucketname): Log.debug("___getPoolPoolnBucketId(" + bucketname+")" ) args=[] args.append(bucketname) greplist=[] outdata=self.executeCmd('radosgw-admin metadata get bucket:', args, greplist) jsondata=json.loads(outdata) poolname_bucketid={"poolname":jsondata["data"]["bucket"]["pool"],"bucketid": jsondata["data"]["bucket"]["bucket_id"]} return poolname_bucketid
def getUserRgwManifest(self,poolname,objid) : Log.debug("___getUserRgwManifest for the object="+str(objid) + " and the pool=" + str(poolname)) outdata=self.executeCmd('rados --pool=',[poolname,' listxattr ',objid],[]) #Check that the listxattr that is returned contains the 'user.rgw.manifest' manifest=outdata.strip().split('\n') #['user.rgw.acl', 'user.rgw.cache_control', 'user.rgw.content_disposition', 'user.rgw.content_type', 'user.rgw.etag', 'user.rgw.idtag', 'user.rgw.manifest', ''] if manifest.index('user.rgw.manifest') : return manifest[manifest.index('user.rgw.manifest')] else: return -1 #means the lisxattr does not contain the 'user.rgw.manifest'
def getPgId(self,poolName,objectId): Log.debug("____getPgId(poolname=" + poolName + ", object= " + objectId + ")") outdata = self.executeCmd('ceph osd map ', [poolName, ' '+objectId], []) pgids = [outdata.split(' -> ')[1].split('(')[0].split(' ')[1], outdata.split(' -> ')[1].split('(')[1].split(')')[0]] # pgids={'26.2c717bcf','26.7'} print "_____pgids=" ,pgids return pgids
def close(self): if (self._closed): Log.debug("already closed. ignore") return self._closed = True Log.info("%s: session end" % unicode(self.authJID)) if (self._session): self._session.Unregister() self.unbind_res() self.rosters.unregister_conn(self)
def deliver_msg(self, start): Log.debug("deliver msg to %s" % unicode(self.authJID)) msgbox = MsgBox.MsgBox(self._userid) msg_count = msgbox.GetMsgCount(all=False) my_pid = os.getpid() for i in range(start, msg_count): msghead = msgbox.LoadMsgHead(i, all=False) if msghead.topid == my_pid: msgtext = msgbox.LoadMsgText(msghead) self.recv_msg(self.make_jid(msghead.id), msgtext)
def deleteSubuserKey(uid, subuser, key, conn): myargs = [] myargs.append(("subuser", subuser)) myargs.append(("uid", uid)) myargs.append(("key-type", "swift")) myargs.append(("secret-key", key)) Log.debug(myargs.__str__()) request = conn.request(method="DELETE", key="user", args=myargs) res = conn.send(request) return ""
def deliver_msg(self, start): Log.debug("deliver msg to %s" % unicode(self.authJID)) msgbox = MsgBox.MsgBox(self._userid) msg_count = msgbox.GetMsgCount(all = False) my_pid = os.getpid() for i in range(start, msg_count): msghead = msgbox.LoadMsgHead(i, all = False) if msghead.topid == my_pid: msgtext = msgbox.LoadMsgText(msghead) self.recv_msg(self.make_jid(msghead.id), msgtext)
def deleteSubuserKey(uid, subuser , key, conn): myargs = [] myargs.append(("subuser",subuser)) myargs.append(("uid", uid)) myargs.append(("key-type", "swift")) myargs.append(("secret-key", key)) Log.debug(myargs.__str__()) request= conn.request(method="DELETE", key="user", args= myargs) res = conn.send(request) return "";
def __init__(self, rosters, host): self.probed = False self._closed = False self.rosters = rosters self._session = None self.rosters.set_resources(self.get_resources()) self._fixedjid = UCache.UCache.formalize_jid(unicode(self.authJID)) self._userid = self._fixedjid.partition('@')[0].encode("gbk") if (not self.rosters.allow_login(self.authJID.bare)): Log.warn("user %s login denied" % self._userid) # self.unbind_res() self.stream_error('policy-violation', 'Login denied. Too many logins?') return Log.info("%s: session start" % unicode(self.authJID)) if self.authJID.resource[:-8] != "Resource" and len(self.authJID.resource) > 8: try: routes = self.routes(self.authJID.bare) for route in routes: jid = route[0] if jid.resource[:-8] == self.authJID.resource[:-8]: if jid.resource != self.authJID.resource: # old resource! Log.info("old jid: %s %r" % (jid.full, route[1])) route[1].stream_error('conflict', 'A new client with the same resource connected') else: Log.info("another me: %s %r" % (jid.full, route[1])) except NoRoute: pass Log.debug("%s: checked for old sessions" % self.authJID.full) # Login the user self._user = UserManager.UserManager.LoadUser(self._userid) if (self._user == None): raise Exception("How can that be!") self._peer_addr = self.getpeername() self._session = Session(self._user, self._peer_addr[0]) self._session.RecordLogin() # insert into global session list! self._userinfo = self._session.Register() self._loginid = self._session.utmpent self._hostname = host self.bind(xmpp.ReceivedCloseStream, self.recv_close) self.bind(xmpp.StreamClosed, self.stream_closed) self.bind(xmpp.SentCloseStream, self.sent_close) self.rosters.register_conn(self) msgbox = MsgBox.MsgBox(self._userid) if self.rosters.get_xmpp_read(self._user.GetUID()) is None: self.rosters.set_xmpp_read(self._user.GetUID(), msgbox.GetMsgCount(all = False) - msgbox.GetUnreadCount()) self.check_msg()
def getOsdDump(self): Log.debug("___getOsdDump()") #print str(datetime.datetime.now()), "-- Process OSDDump" cephRestUrl=request.url_root+'ceph/osd?depth=2' print(cephRestUrl) data = requests.get(cephRestUrl) r = data.content # print(r) osds = json.loads(r) return osds
def deleteCapability(uid, type, perm, conn): myargs = [] myargs.append(("caps", "")) myargs.append(("uid", uid)) myargs.append(("user-caps", type + "=" + perm)) Log.debug(myargs.__str__()) request = conn.request(method="DELETE", key="user", args=myargs) res = conn.send(request) caps = res.read() Log.debug(caps.__str__()) return caps.__str__()
def deleteCapability(uid, type, perm , conn): myargs = [] myargs.append(("caps","")) myargs.append(("uid",uid)) myargs.append(("user-caps",type+"="+perm)) Log.debug(myargs.__str__()) request= conn.request(method="DELETE", key="user", args= myargs) res = conn.send(request) caps = res.read() Log.debug(caps.__str__()) return caps.__str__()
def request(self, conn): """Remember that a client requested roster information. The remembered set is used to push roster updates.""" self.check_update(conn) if conn.authJID not in self._requests: jid = conn.authJID self._requests.add(jid) Log.debug("scheduled for forgetting for %r" % jid) conn.one(xmpp.StreamClosed, lambda: self.forget(jid)) return self
def Register(self): # register this session (so TERM users can see me) userinfo = self.InitNewUserInfo() self.utmpent = Utmp.Utmp.GetNewUtmpEntry(userinfo) if (self.utmpent == -1): return None Log.debug("assigned utmp %d to new user" % self.utmpent) self.user.GetFriends(userinfo) userinfo.save() self._userinfo = userinfo return userinfo
def GetNewUserId(username): try: sock = socket.create_connection(('127.0.0.1', 60001)) sock.sendall("NEW %s" % username) ret = sock.recv(4) if len(ret) == 4: newid = struct.unpack('=i', ret)[0] Log.debug("new user id: %d" % newid) return newid Log.error("invalid response from miscd for newuser") return -1 except Exception as exc: Log.error("fail to get new user id: %r" % exc) return -1
def check_msg(self): Log.debug("checking msg for %s" % self._userid) msgbox = MsgBox.MsgBox(self._userid) msg_count = msgbox.GetMsgCount(all=False) my_pid = os.getpid() xmpp_read = self.rosters.get_xmpp_read(self._user.GetUID()) if xmpp_read > msg_count: xmpp_read = 0 Log.debug("total: %d xmpp read: %d" % (msg_count, xmpp_read)) self.rosters.set_xmpp_read(self._user.GetUID(), msg_count) if xmpp_read < msg_count: return xmpp_read else: return -1
def index_board(self, board): """ Index one board (name: board)""" boardobj = BoardManager.BoardManager.GetBoard(board) if not boardobj: Log.error("Error loading board %s" % board) return if board in self.board_info: idx_obj = self.board_info[board] else: idx_obj = IndexBoardInfo(board, 0) self.board_info[board] = idx_obj bdir_path = boardobj.GetDirPath() with open(bdir_path, 'rb') as bdir: Util.FLock(bdir, shared=True) try: if not board in self.state.locks: self.state.locks[board] = threading.Lock() status = os.stat(bdir_path) if status.st_mtime <= idx_obj.last_idx: # why <? anyway... return Log.debug("Board %s updated. Indexing..." % board) # index into buffer table self.init_buf(board) for idx in xrange(status.st_size / PostEntry.PostEntry.size): post_entry = PostEntry.PostEntry( bdir.read(PostEntry.PostEntry.size)) self.insert_entry(board, post_entry, idx) self.conn.commit() # commit buffer table self.state.locks[board].acquire() try: self.remove_idx_status(idx_obj) self.commit_buf(board) self.create_db_index(board) idx_obj.last_idx = status.st_mtime self.insert_idx_status(idx_obj) finally: self.state.locks[board].release() Log.debug("Board %s indexed." % board) finally: Util.FUnlock(bdir)
def createSubuserKey(uid, subuser, generate_key, secret_key, conn): myargs = [] myargs.append(("key", "")) myargs.append(("uid", uid)) myargs.append(("subuser", subuser)) myargs.append(("key-type", "swift")) if (generate_key == 'True'): myargs.append(("generate-key", 'True')) else: myargs.append(("secret-key", secret_key)) Log.debug(myargs.__str__()) request = conn.request(method="PUT", key="user", args=myargs) Log.debug(request.__str__()) res = conn.send(request) return ""
def stop(self): if self.battery != None and self.state & DroneState.RUNNING: if self.state & DroneState.IN_AIR: l.debug(Drone.TAG, "Stopping drone in air. Bad idea. CRASHING !") self.state = DroneState.OUT_OF_ORDER | DroneState.ON_LAND | DroneState.OFF else: l.debug(Drone.TAG, "Shut off the drone") self.state = DroneState.OFF | DroneState.ON_LAND return 0 elif self.battery != None: l.info(Drone.TAG, "Can't stop drone not started") return -1 else: l.info(Drone.TAG, "Irrelevant to stop drone. No battery found plugged into the drones") return -1
def Clear2(uent): userinfo = UserInfo(uent) Log.debug("clearing user %s uid %d loginid %d" % (userinfo.userid, userinfo.uid, uent)) user = UCache.UCache.GetUserByUid(userinfo.uid) UCache.UCache.DoAfterLogout(user, userinfo, uent, 0) login = Login.Login(uent) login.hash_remove() login.list_remove() if (userinfo.active): UtmpHead.DecNumber() Log.debug("zeroing utmp %d" % uent) zeroinfo = UserInfo() zeroinfo.SetIndex(uent) zeroinfo.save()