Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
@inlineCallbacks
def child(self, name):
# FIXME: Move this logic to locate()
# if not name:
# return succeed(self)
# if name == ".":
# return succeed(self)
# if name == "..":
# path = self.path[:-1]
# if not path:
# path = "/"
# return RootFolder(self.service).locate(path)
if name in self._children:
returnValue(self._children[name])
if name in self._childClasses:
child = (yield self._childClasses[name](self.service, self.path + (name,)))
self._children[name] = child
returnValue(child)
raise NotFoundError("Folder %r has no child %r" % (str(self), name))
@inlineCallbacks
def declineShare(self, request, inviteUID):
# Remove it if it is in the DB
try:
result = yield self._newStoreHome.declineShare(inviteUID)
except DirectoryRecordNotFoundError:
# Missing sharer record => just treat decline as success
result = True
if not result:
raise HTTPError(ErrorResponse(
responsecode.FORBIDDEN,
(calendarserver_namespace, "invalid-share"),
"Invite UID not valid",
))
returnValue(Response(code=responsecode.NO_CONTENT))
def oess_get_circuits(conn, workgroup_id):
query = 'services/data.cgi?'
query += 'action=get_existing_circuits&workgroup_id=%s' % workgroup_id
retval = yield http_query(conn, query)
defer.returnValue(retval)
@inlineCallbacks
def _connect_to_peer(self, host, port):
try:
channel = yield grpc.insecure_channel('{}:{}'.format(host, port))
log.info('grpc-channel-created-with-peer', peer=host)
returnValue(channel)
except Exception, e:
log.exception('exception', e=e)
else:
if mem:
self._logger.debug("Found memory values from %s: %r",
mib.mib['moduleName'], mem)
memory.update(mem)
timestamp = time.time()
result = []
for name, (used, free) in memory.items():
for netbox in netboxes:
prefix = metric_prefix_for_memory(netbox, name)
result.extend([
(prefix + '.used', (timestamp, used)),
(prefix + '.free', (timestamp, free)),
])
defer.returnValue(result)
indices, names = [], []
# send the actual lookup request
recs = [(C.LOOKUP, (server, names), ['w*s', 's*s'])]
resp = yield self._sendRequestNoLookup(C.MANAGER_ID, recs)
serverID, IDs = resp[0][1]
# cache the results
if isinstance(server, str):
self._serverCache[server] = serverID
server = serverID
settings = self._settingCache.setdefault(server, {})
settings.update(zip(names, IDs))
# update the records for the packet
for index, ID in zip(indices, IDs):
records[index] = (ID,) + tuple(records[index][1:])
returnValue((server, records))
found = bool((
yield self._insertFindPreviouslyNamedQuery.on(
self._txn, resourceID=self._resourceID, name=name)))
if found:
self._syncTokenRevision = (
yield self._updatePreviouslyNamedQuery.on(
self._txn, resourceID=self._resourceID, name=name)
)[0][0]
else:
self._syncTokenRevision = (
yield self._completelyNewRevisionQuery.on(
self._txn, homeID=self.ownerHome()._resourceID,
resourceID=self._resourceID, name=name)
)[0][0]
yield self._maybeNotify()
returnValue(self._syncTokenRevision)
def _need_to_collect(self):
yield self.stampcheck.load()
yield self.stampcheck.collect([self.entitymib.get_last_change_time()])
result = yield self.stampcheck.is_changed()
defer.returnValue(result)
def _send(self, access_id, msg):
"""
Send to backend engine.
"""
url = os.path.join(self.base_url, 'engine', str(access_id))
result = yield getPage(url,
contextFactory=None,
method='POST',
postdata=str(msg))
defer.returnValue(result)
def get_invite_for_user_in_room(self, user_id, room_id):
"""Gets the invite for the given user and room
Args:
user_id (str)
room_id (str)
Returns:
Deferred: Resolves to either a RoomsForUser or None if no invite was
found.
"""
invites = yield self.get_invited_rooms_for_user(user_id)
for invite in invites:
if invite.room_id == room_id:
defer.returnValue(invite)
defer.returnValue(None)