class ProfilePictureHandler(BaseHandler): @tornado.web.asynchronous @tornado.gen.coroutine def post(self): posted_file = self.request.files['profile'][0] original_filename = posted_file['filename'] ti = ThumbImage() result = {} try: img_cover = ti.process(posted_file['body'], format="binary>json", tags=["delete"], attrs={"filename": original_filename, "random": random.uniform(0,1)}, template="profile") except Exception, e: result = {"error": unicode(e)} if "error" not in result: image_id = yield motor.Op(self.db.images.insert, img_cover) self.set_cookie("profile_picture", unicode(image_id)) result = {"image_id": unicode(image_id), "data": img_cover["data-160x160"]} # once a time remove images marked to delete if random.randint(0, 9) == 9: created_at = datetime.utcnow()-timedelta(minutes=60) yield motor.Op(self.db.images.remove, {"tags": {"$in": ["delete"]}, "created_at": {"$lte": created_at}}) self.set_header("Content-Type", "text/plain") self.write(json.dumps(result)) self.finish()
def test_partial_update(self, done): """Motor: partial atomic update with save""" class Doc(BaseDocument, dot_notation=True): foo = Field(str) bar = Field(int, required=False) moo = Field(list) Doc.register(client=MOTOR_CLIENT, db='nanotestdb') d = Doc(foo='foo value', bar=42) d.moo = [] yield motor.Op(d.insert) del d.bar # unset yield motor.Op(d.save) yield AssertEqual(d, Doc.find_one, {'_id': d._id}) d.foo = 'new foo' d['bar'] = 1337 d.moo = ['moo 0'] yield motor.Op(d.save, atomic=True) yield AssertEqual(d, Doc.find_one, {'foo': 'new foo', 'bar': 1337}) d.moo = [] del d['bar'] yield motor.Op(d.save) yield AssertEqual(d, Doc.find_one, {'_id': d._id}) done()
def get_posts(self, slug, callback): slug = slug.rstrip('/') posts = self.settings['db'].posts postdoc = yield motor.Op(posts.find_one, {'slug': slug, 'status': 'publish'}, {'summary': False, 'original': False}) if not postdoc: raise tornado.web.HTTPError(404) # Only posts have prev / next navigation, not pages if postdoc['type'] == 'post': fields = {'summary': False, 'body': False, 'original': False} prevdoc = yield motor.Op(posts.find({ 'status': 'publish', 'type': 'post', '_id': {'$lt': postdoc['_id']} }, fields).sort([('_id', -1)]).limit(-1).next) nextdoc = yield motor.Op(posts.find({ 'status': 'publish', 'type': 'post', '_id': {'$gt': postdoc['_id']} }, fields).sort([('_id', 1)]).limit(-1).next) else: prevdoc, nextdoc = None, None # Done callback([prevdoc, postdoc, nextdoc], None)
def _get(self, *args, **kwargs): categorydocs = yield motor.Op(self.get_categories) self.categories = categories = [Category(**doc) for doc in categorydocs] postdocs = yield motor.Op(self.get_posts, *args, **kwargs) self.posts = posts = [ Post(**doc) if doc else None for doc in postdocs] mod = max( thing.last_modified for things in (posts, categories) for thing in things if thing) if mod: # If-Modified-Since header is only good to the second. Truncate # our own mod-date to match its precision. mod = mod.replace(microsecond=0) self.set_header('Last-Modified', mod) # Adapted from StaticFileHandler ims_value = self.request.headers.get("If-Modified-Since") if ims_value is not None: date_tuple = email.utils.parsedate(ims_value) if_since = models.utc_tz.localize( datetime.datetime.fromtimestamp(time.mktime(date_tuple))) if if_since >= mod: # No change since client's last request. Tornado will take # care of the rest. self.set_status(304) self.finish() return gen.engine(get)(self, *args, **kwargs)
def run(*fileids): _redis = redis.client.Redis(settings.REDIS_HOST, settings.REDIS_PORT) connection = motor.MotorConnection().open_sync() db = connection.tiler try: cursor = db.images.find({'fileid': {'$in': fileids}}) for document in (yield motor.Op(cursor.to_list)): pprint(document) yield motor.Op(db.images.update, {'_id': document['_id']}, {'$unset': { 'cdn_domain': 1 }}) metadata_key = 'metadata:%s' % document['fileid'] if _redis.get(metadata_key): print "Invalidated metadata cache" _redis.delete(metadata_key) lock_key = 'uploading:%s' % document['fileid'] # locking it from aws upload for 1 hour _redis.setex(lock_key, time.time(), 60 * 60) upload_log = os.path.join(ROOT, 'static', 'upload.%s.txt' % document['fileid']) if os.path.isfile(upload_log): os.remove(upload_log) print "\n" finally: IOLoop.instance().stop()
def find_deepsky(self, query): if query.startswith('Abell'): res = yield motor.Op( self.datadb.deepsky.find_one, { '$or': [{ 'alias': query }, { 'object': query }, { 'cn_name': query }, { 'cn_alias': query }] }) else: res = yield motor.Op( self.datadb.deepsky.find_one, { '$or': [{ 'object': query }, { 'alias': query }, { 'cn_name': query }, { 'cn_alias': query }] }) raise tornado.gen.Return(res)
def post(self, fileid): image = yield motor.Op(self.db.images.find_one, {'fileid': fileid}) if not image: raise tornado.web.HTTPError(404, "File not found") yield motor.Op(self.db.images.update, {'_id': image['_id']}, {'$unset': { 'cdn_domain': 1 }}) lock_key = 'uploading:%s' % fileid # locking it from aws upload for 1 hour self.redis.setex(lock_key, time.time(), 60 * 60) metadata_key = 'metadata:%s' % fileid self.redis.delete(metadata_key) upload_log = os.path.join(self.application.settings['static_path'], 'upload.%s.txt' % fileid) if os.path.isfile(upload_log): os.remove(upload_log) else: print "couldn't remove", upload_log url = self.reverse_url('admin_image', fileid) self.redirect(url)
def get(self, fileid): image = yield motor.Op(self.db.images.find_one, {'fileid': fileid}) if not image: raise tornado.web.HTTPError(404, "File not found") image_split = (fileid[:1] + '/' + fileid[1:3] + '/' + fileid[3:]) if image['contenttype'] == 'image/jpeg': extension = 'jpg' elif image['contenttype'] == 'image/png': extension = 'png' else: raise NotImplementedError image['found_tiles'] = self._count_tiles(image) _ranges = image.get('ranges') if _ranges: _ranges = [int(x) for x in _ranges] image['ranges'] = _ranges or self._calculate_ranges(image) image['expected_tiles'] = self._expected_tiles(image) _tiles_before = self.get_argument('before', None) if _tiles_before is not None and _tiles_before != image['found_tiles']: if image.get('cdn_domain'): yield motor.Op(self.db.images.update, {'_id': image['_id']}, {'$unset': { 'cdn_domain': 1 }}) image['cdn_domain'] = None lock_key = 'uploading:%s' % fileid # locking it from aws upload for 1 hour self.redis.setex(lock_key, time.time(), 60 * 60) data = { 'image_split': image_split, 'ranges': image['ranges'], 'found_tiles_before': _tiles_before, } data['image'] = image _cols = {} _rows = {} tiles = {} root = self.application.settings['static_path'] for zoom in image['ranges']: extra = self.get_extra_rows_cols(zoom) tiles[zoom] = {} width = 256 * (2**zoom) cols = rows = extra + width / 256 _cols[zoom] = cols _rows[zoom] = rows for row in range(rows): for col in range(cols): key = '%s,%s' % (row, col) filename = os.path.join(root, 'tiles', image_split, '256', str(zoom), key + '.' + extension) tiles[zoom][key] = os.path.isfile(filename) data['rows'] = _rows data['cols'] = _cols data['tiles'] = tiles self.render('admin/tiles.html', **data)
def get(self): stream_id = self.get_argument("stream_id") stream = yield motor.Op(self.db.streams.find_one, {"_id": ObjectId(stream_id)}, { "reencoding": 1, "name": 1, "default_program_id": 1, "fav_group_id": 1, "picture": 1, "_id": 1 }) program = yield motor.Op( self.db.programs.find_one, {"_id": ObjectId(stream["default_program_id"])}, { "groups": 1, "selection": 1, "_id": 0 }) group_id = program["groups"][0] stream["_id"] = unicode(stream["_id"]) self.write({ "program": program, "group_id": group_id, "stream": stream }) self.finish()
def check_external_portal(self, portid): """Check to make sure a portal is okay for external linking. (This lives here because a couple of different handlers use it.) Returns the portal DB object, or raises an exception. """ portal = yield motor.Op(self.application.mongodb.portals.find_one, {'_id': portid}) if not portal: raise tornado.web.HTTPError(403, 'No such portal') if portal['iid'] is not None: raise tornado.web.HTTPError(403, 'Portal is not world-level') if portal['scid'] == 'same': raise tornado.web.HTTPError(403, 'Portal is current-scope') plist = yield motor.Op(self.application.mongodb.portlists.find_one, {'_id': portal['plistid']}) if not plist: raise tornado.web.HTTPError(403, 'No such portlist') if plist['type'] != 'world': raise tornado.web.HTTPError(403, 'Portlist is not world-level') if not plist.get('external', False): raise tornado.web.HTTPError( 403, 'Portlist is not available for external linking') world = yield motor.Op(self.application.mongodb.worlds.find_one, {'_id': portal['wid']}, {'copyable': 1}) if not world: raise tornado.web.HTTPError(403, 'No such world') if not world.get('copyable', False): raise tornado.web.HTTPError(403, 'World is not copyable') return portal
def global_eventloc(loc, all): """Send an event message to all players in the given location. (Location or key, or the entire realm.) """ ctx = EvalPropContext.get_current_context() iid = ctx.loctx.iid if ctx.level != LEVEL_EXECUTE: raise Exception('Events may only occur in action code') if isinstance(loc, two.execute.RealmProxy): locid = None elif isinstance(loc, two.execute.LocationProxy): res = yield motor.Op(ctx.app.mongodb.locations.find_one, {'_id':loc.locid, 'wid':ctx.loctx.wid}, {'_id':1}) if not res: raise KeyError('No such location') locid = loc.locid else: res = yield motor.Op(ctx.app.mongodb.locations.find_one, {'key':loc, 'wid':ctx.loctx.wid}, {'_id':1}) if not res: raise KeyError('No such location: %s' % (loc,)) locid = res['_id'] if is_typed_dict(all, 'text'): all = all.get('text', None) subctx = EvalPropContext(ctx.task, parent=ctx, level=LEVEL_MESSAGE) val = yield subctx.eval(all, evaltype=EVALTYPE_TEXT) else: val = str(all) others = yield ctx.task.find_location_players(iid, locid) ctx.task.write_event(others, val)
def post(self): update = { "max_size": int(self.get_argument('max-size')) * 1048576, "max_streams": int(self.get_argument('max-streams')) } confirmed = self.get_argument("confirmed", False) if confirmed == "on": confirmed = True else: confirmed = False update["confirmed"] = confirmed yield motor.Op(self.db.users.update, {"_id": ObjectId(self.get_current_user())}, {"$set": update}, upsert=False, multi=False) if self.get_argument("remove") == "1": yield motor.Op(self.db.users.remove, {"_id": ObjectId(self.get_current_user())}) stream = yield motor.Op(self.db.streams.find_one, {"user_id": self.get_current_user()}, {"_id": 1}) if stream is not None: stream_id = unicode(stream["_id"]) yield motor.Op(self.db.streams.remove, {"user_id": self.get_current_user()}) yield motor.Op(self.db.media.remove, {"stream_id": stream_id}) self.redirect("/admin/user/me/log-as.html") self.write({"msg": "User settings updated successfully."}) self.finish()
def get(self, stream_id): stream = yield motor.Op(self.db.streams.find_one, {"_id": ObjectId(stream_id)}, { "reencoding": 1, "name": 1, "cover_image": 1, "_id": 1 }) print stream["cover_image"] cover_picture = yield motor.Op( self.db.images.find_one, {"_id": ObjectId(stream["cover_image"])}, { "tags": 1, "_id": 0 }, upsert=False, multi=False) self.clear_cookie("cover_picture") self.clear_cookie("cover_stream_id") self.template_vars["menu"] = "appearance" self.template_vars["submenu"] = "appearance" self.template_vars["stream"] = stream self.template_vars["stream_id"] = stream_id if cover_picture is not None and "uploaded" in cover_picture["tags"]: uploaded = True else: uploaded = False self.template_vars["cover_uploaded"] = uploaded self.render("admin/appearance.html", **self.template_vars)
def get(self, stream_id): stream = yield motor.Op(self.db.streams.find_one, {"_id": ObjectId(stream_id)}, { "reencoding": 1, "name": 1, "default_program_id": 1, "_id": 1 }) program = yield motor.Op( self.db.programs.find_one, {"_id": ObjectId(stream["default_program_id"])}, { "groups": 1, "selection": 1, "_id": 0 }) group_id = program["groups"][0] stream["_id"] = unicode(stream["_id"]) stream["id"] = unicode(stream["_id"]) self.template_vars["program"] = program self.template_vars["group_id"] = group_id self.template_vars["stream"] = stream self.template_vars["live"] = True self.template_vars["menu"] = "streams" self.template_vars["submenu"] = "live" self.template_vars["stream_id"] = stream_id self.render("admin/live.html", **self.template_vars)
def test_op(self): # motor.Op is deprecated in Motor 0.2, superseded by Tornado 3 Futures. # Just make sure it still works. collection = self.collection doc = {'_id': 'jesse'} with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") # Op works. _id = yield motor.Op(collection.insert, doc) self.assertEqual('jesse', _id) # Raised a DeprecationWarning. self.assertEqual(1, len(w)) warning = w[-1] self.assertTrue(issubclass(warning.category, DeprecationWarning)) message = str(warning.message) self.assertTrue("deprecated" in message) self.assertTrue("insert" in message) result = yield motor.Op(collection.find_one, doc) self.assertEqual(doc, result) # Make sure it works with no args. result = yield motor.Op(collection.find_one) self.assertTrue(isinstance(result, dict)) with assert_raises(pymongo.errors.DuplicateKeyError): yield motor.Op(collection.insert, doc)
def global_location(obj=None): """Create a LocationProxy. - No argument: the current player's location - String argument: the location with the given key - Player argument: the location of the given player (if in the current world!) """ if obj is None: ctx = EvalPropContext.get_current_context() if not ctx.uid: raise Exception('No current player') if not ctx.loctx.locid: return None return two.execute.LocationProxy(ctx.loctx.locid) if isinstance(obj, two.execute.PlayerProxy): ctx = EvalPropContext.get_current_context() res = yield motor.Op(ctx.app.mongodb.playstate.find_one, {'_id':obj.uid}, {'iid':1, 'locid':1}) if not res: raise KeyError('No such player') if res['iid'] != ctx.loctx.iid: return None return two.execute.LocationProxy(res['locid']) ctx = EvalPropContext.get_current_context() if not ctx.loctx.wid: raise Exception('No current world') res = yield motor.Op(ctx.app.mongodb.locations.find_one, {'wid':ctx.loctx.wid, 'key':obj}, {'_id':1}) if not res: raise KeyError('No such location: %s' % (obj,)) return two.execute.LocationProxy(res['_id'])
def resolve_dirty(self, ent): """Write back (or delete) a single dirty entry. Then mark it clean. """ dbname = ent.tup[0] if dbname not in writable_collections: # Maybe we should update the equivalent writable entry here, # but we'll just skip it. self.log.warning('Unable to update %s entry: %s', dbname, ent.key) if ent.mutable: ent.origval = deepcopy(ent.val) return if ent.found: # Resolve update. try: checkwritable(ent.val) except TypeError as ex: self.log.warning('Unable to update %s entry: %s', ent.key, ex) ### drop entry entirely? return newval = dict(ent.query) newval['val'] = ent.val yield motor.Op(self.app.mongodb[dbname].update, ent.query, newval, upsert=True) if ent.mutable: ent.origval = deepcopy(ent.val) else: # Resolve delete. yield motor.Op(self.app.mongodb[dbname].remove, ent.query) ent.dirty = False
def get(self): item = self.get_argument('item', None) ruleid = self.get_argument('ruleid', None) origin = self.get_argument('origin', None) host = self.get_argument('host', None) doc = True if self.get_argument('doc', False) else False coll = 'documentation' if doc else 'log_logentry' body = None fmt = None reqheaders = {} respheaders = {} entry = None if item: collection = self.settings['db'].proxyservice[coll] entry = yield motor.Op(collection.find_one, {'_id': self.get_id(item)}) if entry: reqheaders = entry['request'][ 'headers'] if 'request' in entry and 'headers' in entry[ 'request'] and entry['request'][ 'headers'] else reqheaders respheaders = entry['response'][ 'headers'] if 'response' in entry and 'headers' in entry[ 'response'] else respheaders status = entry['response']['status'] if 'fileid' in entry['response']: body, ctype = yield self.get_gridfs_body( entry['response']['fileid'], respheaders) fmt = util.get_format(ctype) elif 'body' in entry['response']: body = entry['response']['body'] entry = entry['request'] entry['status'] = status elif ruleid: collection = self.settings['db'].proxyservice['log_rules'] entry = yield motor.Op(collection.find_one, {'_id': self.get_id(ruleid)}) body = entry['body'] reqheaders = entry['reqheaders'] if 'reqheaders' in entry and entry[ 'reqheaders'] else reqheaders respheaders = entry[ 'respheaders'] if 'respheaders' in entry else respheaders fmt = util.get_format( util.get_content_type( self.nice_headers(respheaders))) if respheaders else None self.render("ruleadd.html", tryagain=False, item=item, origin=origin, host=host, entry=entry, body=body, fmt=fmt, reqheaders=reqheaders, respheaders=respheaders)
def get(self, stream_id): stream = yield motor.Op(self.db.streams.find_one, {"_id": ObjectId(stream_id)}, { "reencoding": 1, "name": 1, "default_program_id": 1, "_id": 1 }) program = yield motor.Op( self.db.programs.find_one, {"_id": ObjectId(stream["default_program_id"])}, { "groups": 1, "selection": 1, "_id": 0 }) # basic mode pick first, in extended mode there is different situation where user selecting the group group_id = program["groups"][0] cursor = self.db.media.find( { "stream_id": stream_id, "groups.id": group_id }, { "_id": 1, "artist": 1, "title": 1, "tags.duration": 1, "groups.weight": 1, "file_id": 1 }, sort=[('groups.weight', 1)]) results = yield motor.Op(cursor.to_list, self.batch_size) self.template_vars["group_id"] = group_id self.template_vars["group"] = yield motor.Op( self.db.groups.find_one, {"_id": ObjectId(group_id)}, { "fade_in": 1, "fade_out": 1, "_id": 0 }) self.template_vars["program"] = program stream["id"] = unicode(stream["_id"]) self.template_vars["stream"] = stream self.template_vars["media"] = results self.template_vars["menu"] = "streams" self.template_vars["submenu"] = "database" self.template_vars["stream_id"] = stream_id self.render("admin/database.html", **self.template_vars)
def get(self): stream_id = self.get_argument("stream_id") stream = yield motor.Op(self.db.streams.find_one, {"_id": ObjectId(stream_id)}, { "reencoding": 1, "name": 1, "default_program_id": 1, "fav_group_id": 1, "_id": 1 }) stream["_id"] = unicode(stream["_id"]) program = yield motor.Op( self.db.programs.find_one, {"_id": ObjectId(stream["default_program_id"])}, { "groups": 1, "selection": 1, "_id": 0 }) # basic mode pick first, in extended mode there is different situation where user selecting the group group_id = program["groups"][0] cursor = self.db.media.find( { "stream_id": stream_id, "groups.id": group_id }, { "_id": 1, "artist": 1, "title": 1, "tags.duration": 1, "groups.weight": 1, "file_id": 1 }, sort=[('groups.weight', 1)]) results = yield motor.Op(cursor.to_list, self.batch_size) media = self.list_normalize(results) group = yield motor.Op(self.db.groups.find_one, {"_id": ObjectId(group_id)}, { "fade_in": 1, "fade_out": 1, "_id": 0 }) self.write({ "stream": stream, "media": media, "group_id": group_id, "group": group, "program": program }) self.finish()
def post(self): stream = yield motor.Op(self.db.streams.find_one, {"_id":ObjectId(self.get_argument("stream_id"))}, {"current":1, "name": 1, "user_id": 1, "_id": 0}) user = yield motor.Op(self.db.users.find_one, {"_id":ObjectId(stream['user_id'])}, {"name": 1, "email": 1, "_id": 0}) self.write({"stream": stream, "user": user}) self.finish()
def post(self, key): res = yield motor.Op(self.application.mongodb.pwrecover.find_one, {'key': key}) if not res: raise tornado.web.HTTPError(404) uid = res['_id'] # Apply canonicalizations to the passwords. password = self.get_argument('password', '') password = unicodedata.normalize('NFKC', password) password = password.encode() # to UTF8 bytes password2 = self.get_argument('password2', '') password2 = unicodedata.normalize('NFKC', password2) password2 = password2.encode() # to UTF8 bytes formerror = None formfocus = 'name' if self.twsessionstatus == 'auth': formerror = 'You are already signed in!' elif (not password): formerror = 'You must enter your new password.' formfocus = 'password' elif (not password2): formerror = 'You must enter your new password twice.' formfocus = 'password2' elif (len(password) < 6): formerror = 'Please use at least six characters in your password.' formfocus = 'password' elif (len(password) > 128): formerror = 'Please use no more than 128 characters in your password.' formfocus = 'password' elif (password != password2): formerror = 'The passwords you entered were not the same.' password2 = '' formfocus = 'password2' if formerror: self.render('recover2.html', key=key, formerror=formerror) return try: yield self.application.twsessionmgr.change_password(uid, password) # Success. yield motor.Op(self.application.mongodb.pwrecover.remove, {'key': key}) formerror = None except MessageException as ex: formerror = str(ex) if formerror: self.render('recover2.html', key=key, formerror=formerror) return self.render('recover2.html', key=key, pwchanged=True)
def post(self): ''' Cebus applications post Register a app record ''' result = yield gen.Task(check_json, self.request.body) struct, error = result.args if error: self.set_status(400) self.finish(error) return records = yield gen.Task(self.new_app_record, struct) app_id, error = records.args # WARNING: The complete error module it's going to be re-written if error: error = str(error) system_error = errors.Error(error) # Error handling 409? self.set_status(400) if error and 'Model' in error: error = system_error.model('Applications') self.finish(error) return elif error and 'duplicate' in error: error = system_error.duplicate('App', 'uniqueid', struct['uniqueid']) self.finish(error) return elif error: self.finish(error) return if 'accountcode' in struct: account = struct['accountcode'] resource = { 'account': account, 'resource': 'applications', 'id': app_id } exist = yield motor.Op(self.check_exist, account) if exist: # update the account data set the app_id on applications resources update = yield motor.Op(self.new_resource, resource) # Set status self.set_status(201) # Return the new application id self.finish({'id': app_id})
def global_setfocus(symbol, player=None): """Set the given player's focus to this symbol. (If player is None, the current player; if a location, then every player in it; if the realm, then every player in the instance.) """ ctx = EvalPropContext.get_current_context() if ctx.level != LEVEL_EXECUTE: raise Exception('setfocus: may only occur in action code') if type(symbol) is not str: raise TypeError('setfocus: symbol must be string') uid = None query = None if player is None: if not ctx.uid: raise Exception('No current player') uid = ctx.uid elif isinstance(player, two.execute.PlayerProxy): uid = player.uid elif isinstance(player, two.execute.RealmProxy): query = { 'iid':ctx.loctx.iid } elif isinstance(player, two.execute.LocationProxy): query = { 'iid':ctx.loctx.iid, 'locid':player.locid } else: raise TypeError('setfocus: must be player, location, realm, or None') if uid is not None: # Focus exactly one player. res = yield motor.Op(ctx.app.mongodb.playstate.find_one, {'_id':uid}, {'iid':1, 'focus':1}) if not res: raise KeyError('No such player') if res['iid'] != ctx.loctx.iid: raise Exception('Player is not in this instance') yield motor.Op(ctx.app.mongodb.playstate.update, {'_id':uid}, {'$set':{'focus':symbol}}) ctx.task.set_dirty(uid, DIRTY_FOCUS) elif query is not None: # Focus all matching players uids = [] cursor = ctx.app.mongodb.playstate.find(query, {'_id':1}) while (yield cursor.fetch_next): player = cursor.next_object() uids.append(player['_id']) # cursor autoclose if uids: yield motor.Op(ctx.app.mongodb.playstate.update, query, {'$set':{'focus':symbol}}, multi=True) ctx.task.set_dirty(uids, DIRTY_FOCUS)
def post(self): """ Delete everything in the collection """ db = self.settings['motor_db'] yield motor.Op(db.chirps.drop) chirps.clear() yield motor.Op(db.create_collection, 'chirps', size=10000, capped=True) logging.info('Created capped collection "chirps" in database "test"') self.settings['cursor_manager'].emit('cleared', {}) self.finish()
def get(self): session = self.get_argument("session", default=False) confirm_key = self.get_argument('confirm-key', None) user_id = self.get_argument('user-id', None) confirmed = None try: if not confirm_key is None and not user_id is None: user = yield motor.Op(self.db.users.find_one, { "_id": ObjectId(user_id), "confirm_key": confirm_key }, { "confirmed": 1, "_id": 0, "waiting_email": 1 }) if user is not None: if user["confirmed"]: yield motor.Op(self.db.users.update, {"_id": ObjectId(user_id)}, { "$set": { "confirmed": True, "email": user["waiting_email"] } }, upsert=False, multi=False) else: yield motor.Op(self.db.users.update, {"_id": ObjectId(user_id)}, {"$set": { "confirmed": True }}, upsert=False, multi=False) yield self.new_session(unicode(user_id)) confirmed = True else: confirmed = False except: confirmed = False self.write({ "session_file_no": 0, "user": self.current_user if self.current_user else False, "genres": genres, "session": session, "confirmed": confirmed }) self.finish()
def post(self, fileid): image = yield motor.Op(self.db.images.find_one, {'fileid': fileid}) if not image: raise tornado.web.HTTPError(404, "File not found") featured = image.get('featured', True) yield motor.Op(self.db.images.update, {'_id': image['_id']}, {'$set': { 'featured': not featured }}) url = self.reverse_url('admin_image', fileid) self.redirect(url)
def setUp(self): super(TestTrackingClientWithMockPusher, self).setUp() logging.basicConfig( level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') self.pusher = MockPusher() self.server.application.pusher = self.pusher # Cleaning test database after tests motor.Op(self.server.application.mongo.trackings.remove) motor.Op(self.server.application.mongo.tdespatch_cabdriver.remove)
def run(*args): _redis = redis.client.Redis(settings.REDIS_HOST, settings.REDIS_PORT) connection = motor.MotorConnection().open_sync() db = connection.tiler try: cursor = (db.images.find()) image = yield motor.Op(cursor.next_object) while image: _redis.incr('bytes_downloaded', image['size']) image = yield motor.Op(cursor.next_object) finally: IOLoop.instance().stop()
def monitor_mongo_status(self): """Check the status of the MongoDB connection. If the server has died, close the socket. If the socket is closed (or has never been opened), try to open it. This is called once when the app launches, to open the initial connection, and every few seconds thereafter. The mongotimerbusy flag protects us from really slow connection attempts. Not sure why that would happen, but if it does, we'll avoid piling up multiple attempts. On the down side, if the function throws an uncaught exception, the flag will be stuck forever. (So don't do that.) """ if (self.mongotimerbusy): self.log.warning('monitor_mongo_status: already in flight; did a previous call jam?') return if (self.app.caughtinterrupt): self.log.warning('monitor_mongo_status: shutting down, never mind') return self.mongotimerbusy = True if (self.mongoavailable): try: res = yield motor.Op(self.mongo.admin.command, 'ping') if (not res): self.log.error('Mongo client not alive') self.mongoavailable = False except Exception as ex: self.log.error('Mongo client not alive: %s', ex) self.mongoavailable = False if (not self.mongoavailable): self.mongo_disconnect() if (not self.mongoavailable): try: self.mongo = motor.MotorClient(tz_aware=True) res = yield motor.Op(self.mongo.open) ### maybe authenticate to a database? self.mongoavailable = True self.app.mongodb = self.mongo[self.app.twopts.mongo_database] self.log.info('Mongo client open') # Schedule a callback to load up the localization data. tornado.ioloop.IOLoop.instance().add_callback(self.load_localization) except Exception as ex: self.mongoavailable = False self.app.mongodb = None self.log.error('Mongo client not open: %s', ex) self.mongotimerbusy = False