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