def delete(self, request): self.check_authenciation() resource = ndb.Key(urlsafe=request.id).get() if resource: try: resource.key.delete() if not settings.DEBUG: taskqueue.add(url='/tasks/delete_resources', params={ 'object_name': resource.object_name, 'bucket_name': resource.bucket }, queue_name='resource-delete') else: logging.info( '/_ah/spi is not a dispatchable path, task queue:delete_resources won\'t be executed at development env. ' ) except taskqueue.Error, error: logging.error('An error occurred in endpoints APIs: %s' % error)
def GET(self): result = {} service_parameter = web.input(service = None)['service'] question_id_parameter = web.input(question_id = None)['question_id'] sort_parameter = web.input(sort = 'week')['sort'] pagesize_parameter = web.input(pagesize = 30)['pagesize'] try: if service_parameter: se_downloader = StackExchangeDownloader(service_parameter) if question_id_parameter: se_downloader.get_post(question_id_parameter, False) else: questions = se_downloader.get_questions_by_hotness(pagesize = pagesize_parameter, sort = sort_parameter) for question in questions: question_id = int(question['question_id']) score = int(question['score']) if score > VOTES_ENTRY_LEVEL: taskqueue.add(url='/admin/topquestionsretriever?service=%s&question_id=%s&sort=%s' % \ (service_parameter, question_id, sort_parameter) , method = 'GET', queue_name = 'retriever') else: supported_services = StackAuthDownloader.get_supported_services() for service in supported_services.keys: if not service.startswith('meta.'): taskqueue.add(url='/admin/topquestionsretriever?service=%s&sort=%s' % \ (service, sort_parameter), method = 'GET', queue_name = 'retriever') except Exception: logging.exception("Exception handling TopQuestionRetriever") result['result'] = True return render.admin(result)
def GET(self): #Cache ajax request taskqueue.add(url='/admin?action=cacherefresh', method = 'GET', queue_name = 'populate', countdown = 5) pass
def request(self, request): user = users.get_current_user() email = user.email() fromDate = parseMsgTime(request.fromDate) toDate = parseMsgTime(request.toDate) taskqueue.add(url='/reportWorker', method='GET', params={'email': email, 'fromDate':fromDate, 'toDate':toDate, 'type': 'dateSpan'}) return RequestReportResponseMessage(message = 'a Report from UTC:%s to UTC:%s. Report Email is %s' % (fromDate, toDate, email))
def get(self, request): """ タイトルから --- parameters: - name: title type: string paramType: query - name: isbn type: string paramType: query - name: author type: string paramType: query """ title = request.GET.get("title", None) isbn = request.GET.get("isbn", None) creator = request.GET.get("author", None) request = SRU() request.cnt = 20 books = request.search(title, creator, isbn) books = self.remove(books) results = {"books": [self.serialize(book) for book in books]} for book in books: taskqueue.add(url="/tasks/save/amazon", params={ u"title": book.title, u"original_title": book.original_title, u"isbn": book.isbn }) return Response(results)
def add_taste_movie(self, movie, taste=1.0): """ Add user's taste of a movie. :param movie: movie to be voted :type movie: Movie :param taste: taste to associate to the movie :type taste: float :return: None """ # TODO: improve, I don't know if it is the best way to see if there is yet TasteArtist taste_movie = TasteMovie(id=(movie.key.id() + self.key.id()), # Create the user's taste with unique id taste=taste) if taste == 1.0: taste_movie.added = True taste_movie.add_movie(movie) taste_movie_key = taste_movie.put() if taste_movie_key not in self.tastes_movies: self.tastes_movies.append(taste_movie_key) # Append the taste to user's tastes self.put() taskqueue.add(url='/_ah/start/task/movie_tastes/' + self.key.id() + '/' + movie.key.id() + '/' + str(taste), method='GET')
def get(self, token_string): logging.info("Received a self vote") num_votes = self.request.get("votes") params = {'token':token_string, 'votes':num_votes} taskqueue.add(url='/worker/self_vote', params=params, queue_name='email', countdown=0) self.response.out.write("Success!")
def run_trigger(trigger): params = { "trigger_key": trigger.key.urlsafe() } url = '/queue/trigger/run' taskqueue.add(url=url, params=params, queue_name="trigger-run")
def close(order): company = CompanyNew.get_by_iiko_id(order.venue_id) if company.auto_token and order.source == AUTO_APP_SOURCE: close_order(order, company.auto_token) if order.payment_type == PaymentType.CARD: delivery_terminal = DeliveryTerminal.get_by_id(order.delivery_terminal_id) \ if order.delivery_terminal_id else None pay_result = pay_by_card(company, delivery_terminal, order.alfa_order_id, 0) logging.info("pay result: %s" % str(pay_result)) success = 'errorCode' not in pay_result.keys() or str( pay_result['errorCode']) == '0' if not success: logging.warning("pay failed") return if company.is_iiko_system: bonus = SharedBonus.query( SharedBonus.recipient == order.customer, SharedBonus.status == SharedBonus.READY).get() if bonus: taskqueue.add(url='/single_task/bonus/activate', params={'order_id': order.order_id}) order_user_agent = order.customer.get().user_agent if company.review_enable and supports_review(company.iiko_org_id, order_user_agent): taskqueue.add(url='/single_task/push/review', params={'order_id': order.order_id}, countdown=60 * 30) send_order_status_push(order)
def generateDallyReport(self): #todo remove dailly report as functionality , spanDate should be used days = int( self.request.get('days') ) user = users.get_current_user() email = user.email() # Add the task to the default queue. taskqueue.add(url='/reportWorker', method='GET', params={'email': email, 'days':days, 'type:': 'days'}) self.response.write('email is going to be sent at %s' % email)
def addReportJob(self, settings, days): logging.info('make plan for settings %s' % settings) utcDate = datetime.datetime.utcnow() #fixme might be incorrect utcDateTrimmed = datetime.datetime.combine(utcDate, datetime.time(0,0)) eta = utcDateTrimmed + datetime.timedelta(days = 1) - datetime.timedelta(hours = settings.timeZoneOffset) taskqueue.add(url='/reportWorker', method='GET', params={'email': settings.email, 'days':days - 1}, eta = eta) pass
def queue_task(self): name = self.request.get('name') url = None if name == 'load_churches': url = '/_tasks/load_churches' elif name == 'index_churches': url = '/_tasks/index_churches' taskqueue.add(queue_name='default-tasks', url=url) logging.info('Added %s task to queue' % name) self.success_response()
def send_review_push(order): namespace_manager.set_namespace(order.key.namespace()) module = config.REVIEW_MODULE if module and module.status: review = ReviewPush(order=order.key) review.put() start = datetime.utcnow() + timedelta(seconds=module.wait_seconds) taskqueue.add(url='/task/pushes/review', method='POST', eta=start, params={'review_id': review.key.id()})
def incr(name, delta=1, update_interval=10): """Increments a counter. The increment is generally a memcache-only operation, though a task will also be enqueued about once per update_interval. May under-count if memcache contents is lost. Args: name: The name of the counter. delta: Amount to increment counter by, defaulting to 1. update_interval: Approximate interval, in seconds, between updates. Must be greater than zero. """ lock_key = "ctr_lck:" + name delta_key = "ctr_val:" + name # update memcache if delta >= 0: v = memcache.incr(delta_key, delta, initial_value=BASE_VALUE) elif delta < 0: v = memcache.decr(delta_key, -delta, initial_value=BASE_VALUE) if memcache.add(lock_key, None, time=update_interval): # time to enqueue a new task to persist the counter # note: cast to int on next line is due to GAE issue 2012 # (http://code.google.com/p/googleappengine/issues/detail?id=2012) v = int(v) delta_to_persist = v - BASE_VALUE if delta_to_persist == 0: return # nothing to save try: qn = random.randint(0, 4) qname = 'PersistCounter%d' % qn taskqueue.add(url='/task/counter_persist_incr', queue_name=qname, params=dict(name=name, delta=delta_to_persist)) except: # task queue failed but we already put the delta in memcache; # just try to enqueue the task again next interval return # we added the task --> need to decr memcache so we don't double-count failed = False if delta_to_persist > 0: if memcache.decr(delta_key, delta=delta_to_persist) is None: failed = True elif delta_to_persist < 0: if memcache.incr(delta_key, delta=-delta_to_persist) is None: failed = True if failed: logging.warn("counter %s reset failed (will double-count): %d", name, delta_to_persist)
def get(self): if self.request.get('admin') == credentials.ADMIN_KEY: params = {'admin': credentials.ADMIN_KEY} if self.request.get('id'): params['id'] = self.request.get('id') if self.request.get('rank_id'): params['rank_id'] = self.request.get('rank_id') taskqueue.add(url='/populate', params=params) self.response.write('Added task!') else: self.response.write('Wrong key!')
def announce_new_gig(the_gig, the_gig_url, is_edit=False, is_reminder=False, change_string="", the_members=[]): the_params = pickle.dumps({'the_gig_key': the_gig.key, 'the_gig_url': the_gig_url, 'is_edit': is_edit, 'is_reminder': is_reminder, 'change_string': change_string, 'the_members': the_members}) taskqueue.add( url='/announce_new_gig_handler', params={'the_params': the_params })
def post(self,*args,**kargs): logging.info("it is here "+self.request.__str__()) projmemid = self.request.get("id") user_info = self.auth.get_user_by_session() key= ndb.Key('ProjectMembers',int(projmemid)) projmem = key.get() projmem.modified_by = user_info['email_address'] projmem.modified_date = datetime.now() projmem.status = False projmem.put() sprints = sprint.Sprint().get_by_project(projmem.projectid) logging.info if not sprints: logging.info("No sprints") else: task = taskqueue.add( queue_name = "my-push-queue", url='/deleteusereffortspersist', params={'projectid': projmem.projectid.id(),'userid':projmem.userid.id()}) # projmem.status = 'False' # projmem.set() #projmem.delete_entity(projmemid) self.response.write("success")
def make_rss_feed_for_band(the_band): the_params = pickle.dumps({'the_band_key': the_band.key}) task = taskqueue.add( url='/make_rss_feed_handler', params={'the_params': the_params })
def request(self, request): user = users.get_current_user() email = user.email() fromDate = parseMsgTime(request.fromDate) toDate = parseMsgTime(request.toDate) taskqueue.add(url='/reportWorker', method='GET', params={ 'email': email, 'fromDate': fromDate, 'toDate': toDate, 'type': 'dateSpan' }) return RequestReportResponseMessage( message='a Report from UTC:%s to UTC:%s. Report Email is %s' % (fromDate, toDate, email))
def rename_section(section, section_product_cls, section_name): section_products = section_product_cls.query(section_product_cls.section_key == section.key) for section_product in section_products: product_mem_key = uuid() if not section_product.product_key: continue memcache.add( product_mem_key, {'%s' % section_name: section.name}, 7200 ) taskqueue.add( url=url_for( 'product.task.update_product', key_id=section_product.product_key.id(), mem_key=product_mem_key ))
def post(self): email = self.request.POST.get('email') if not email or "@" not in email or "." not in email: self.request.add_message( 'Please enter a valid email address', 'error') return self.get() existing_account = UserProfile.get_key('password', email).get() if not existing_account: self.request.add_message( 'The email address you provided was not found. ' 'Please try again.', 'error') return self.get() user = User.get_by_auth_id(existing_account.key.id()) taskqueue.add(url='/account/tasks/password-recovery-email', params={ 'recipient_id': user.key.id(), }) return self.sent(email)
def announce_new_gig(the_gig, the_gig_url, is_edit=False, is_reminder=False, change_string="", the_members=[]): the_params = pickle.dumps({ 'the_gig_key': the_gig.key, 'the_gig_url': the_gig_url, 'is_edit': is_edit, 'is_reminder': is_reminder, 'change_string': change_string, 'the_members': the_members }) taskqueue.add(url='/announce_new_gig_handler', params={'the_params': the_params})
def rename_category(self): #change the name of a cat old_cat = self.request.params["old_cat"] new_cat = self.request.params["new_cat"] if Category.get_by_id(new_cat) == None: new_cat_instance = Category(id=new_cat) new_cat_instance.title = new_cat new_cat_instance.put() taskqueue.add(url='/task/batch_update_items', params={ 'migration':'rename_category', 'p1': old_cat, 'p2': new_cat}) taskqueue.add(url='/task/batch_update_votes', params={ 'migration':'rename_category', 'p1': old_cat, 'p2': new_cat}) self.response.out.write("Batch job started")
def new_game(request): user = User.query(User.name == request.user_name).get() total_words = Word.query().count() rand_num = random.randint(1, total_words) word = Word.query(Word.word_id == rand_num).get() if not user: raise endpoints.NotFoundException( 'A User with that name does not exist!') try: game = Game.new_game(user.key, word.key) except AttributeError: raise endpoints.BadRequestException('Random word not found') # Use a task queue to update the average attempts remaining. # This operation is not needed to complete the creation of a new game # so it is performed out of sequence. taskqueue.add(url='/tasks/cache_average_attempts') return game
def make_move(request): game = get_by_urlsafe(request.urlsafe_game_key, Game) game.number_of_guess += 1 word = Word.query(Word.key == game.word).get() split_word = list(word.word) guess = request.guess game_history = History.query(History.game == game.key) letters_guessed_so_far = [] for history in game_history.iter(): letters_guessed_so_far.append(history.guess) if game.game_over is True: msg = 'Game already over!' elif guess == '' or guess.isdigit() or len(guess) > 1: msg = "Please enter a single alpha character only" elif guess in letters_guessed_so_far: msg = "You have already used that letter" elif guess not in split_word: msg = "letter isn't in word" game.guesses_remaining -= 1 save_history(game.key, game.number_of_guess, guess, False) else: msg = "Letter is in word!" save_history(game.key, game.number_of_guess, guess, True) # Added in a sleep because of latency writing to the datastore. # http://stackoverflow.com/questions/9137214/writing-then-reading-entity-does-not-fetch-entity-from-datastore time.sleep(0.1) count_of_success = History.query(History.status == True).filter(History.game == game.key).count() if len(word.word) == count_of_success: msg = "You've won! The word was {}".format(word.word) game.end_game(True) elif game.guesses_remaining == 0: msg = 'You have run out of guesses! The word was {}'.format(word.word) game.end_game() taskqueue.add(url='/tasks/cache_average_attempts') game.put() return game, msg
def post(self,*args,**kargs): #role=model.user.Groups() tenant_domain = self.request.get('company_domain') tenant_name = self.request.get('company_name') tenant = model.user.Tenant() tenant.name = tenant_name tenant.domain = tenant_domain tenant.created_by = self.request.get('email') duplicate_tenant = tenant.query(model.user.Tenant.domain==tenant_domain).fetch() if duplicate_tenant: self.response.write('Domain already exists with the same name.') return else: tenant_key_added = tenant.put() role=ndb.Key(urlsafe=self.request.get('role')) user_name = self.request.get('email') email = self.request.get('email') name = self.request.get('company_name') last_name = self.request.get('company_name') designation = "" empid="" contact="" tenant_key = tenant_key_added password = name+empid #unique_properties = ['email_address'] user_data = self.user_model.create_user(user_name, email_address=email, name=name, password_raw=password,designation=designation,empid=empid,contact=contact, last_name=last_name,role=role,tenant_domain=tenant_domain,status = True,tenant_key=tenant_key,project_permission=True,verified=False) if not user_data[0]: #user_data is a tuple self.response.write('User already exists with the same email.') return user = user_data[1] user_id = user.get_id() token = self.user_model.create_signup_token(user_id) verification_url = self.uri_for('verification', type='v', user_id=user_id,signup_token=token, _full=True) logging.info("before email"); message= """Hi """+name+""", Thank you for registering on APM. Please follow the below url to activate your account. Remember to change your password. You will be able to do so by visiting {url}""" task = taskqueue.add( queue_name = "my-push-queue", url='/email', params={'To_email':email,'verification_url':verification_url,'message':message}) logging.info("after email") logging.info(verification_url) self.response.write('true')
def GET(self): result = {} submitted = True action = web.input(action = None)['action'] if action == 'renametags_init': tags_to_rename = web.input(tags_to_rename = None)['tags_to_rename'] tag_destination = web.input(tag_destination = None)['tag_destination'] taskqueue.add(url='/admin/tags', method = 'POST', queue_name = 'populate', countdown = 5, params = { 'action' : 'renametags', 'tags_to_rename': tags_to_rename, 'tag_destination' : tag_destination, }) result[action] = "Done" if action == 'renametags': tags_to_rename = web.input(tags_to_rename = None)['tags_to_rename'] tag_destination = web.input(tag_destination = None)['tag_destination'] for tag_to_rename in tags_to_rename.split(): if tag_to_rename: entities = models.Post.all().filter('tags',tag_to_rename).fetch(1000) for entity in entities: entity_tags_old = entity.tags entity_tags_new = [tag.strip() for tag in entity_tags_old if tag and tag != tag_to_rename ] entity_tags_new.append(tag_destination.strip()) entity.tags = list(set(entity_tags_new)) entity.put() models.Tag.update_tags(list(set(entity_tags_new)), list(set(entity_tags_old))) result[action] = "Done" if action == 'deletetags': keys = models.Tag.all(keys_only = True).filter('counter =', 0).fetch(1000) db.delete(keys) result[action] = "Done" return render_template(render.admin.admin_tags( submitted, result, action) )
def post(self): the_params = pickle.loads(self.request.get('the_params')) the_gig_key = the_params['the_gig_key'] the_gig_url = the_params['the_gig_url'] is_edit = the_params['is_edit'] is_reminder = the_params['is_reminder'] change_string = the_params['change_string'] the_members = the_params['the_members'] the_gig = the_gig_key.get() the_band_key = the_gig_key.parent() the_assocs = assoc.get_confirmed_assocs_of_band_key( the_band_key, include_occasional=the_gig.invite_occasionals) if is_reminder and the_members: recipient_assocs = [] for a in the_assocs: if a.member in the_members: recipient_assocs.append(a) else: recipient_assocs = the_assocs logging.info('announcing gig {0} to {1} people'.format( the_gig_key, len(recipient_assocs))) the_shared_params = pickle.dumps({ 'the_gig_key': the_gig_key, 'the_band_key': the_band_key, 'the_gig_url': the_gig_url, 'is_edit': is_edit, 'is_reminder': is_reminder, 'change_string': change_string }) for an_assoc in recipient_assocs: if an_assoc.email_me: the_member_key = an_assoc.member the_member_params = pickle.dumps( {'the_member_key': the_member_key}) task = taskqueue.add(queue_name='emailqueue', url='/send_new_gig_handler', params={ 'the_shared_params': the_shared_params, 'the_member_params': the_member_params }) logging.info('announced gig {0}'.format(the_gig_key)) self.response.write(200)
def post(self): the_params = pickle.loads(self.request.get('the_params')) the_gig_key = the_params['the_gig_key'] the_gig_url = the_params['the_gig_url'] is_edit = the_params['is_edit'] is_reminder = the_params['is_reminder'] change_string = the_params['change_string'] the_members = the_params['the_members'] the_gig = the_gig_key.get() the_band_key = the_gig_key.parent() the_assocs = assoc.get_confirmed_assocs_of_band_key(the_band_key, include_occasional=the_gig.invite_occasionals) if is_reminder and the_members: recipient_assocs=[] for a in the_assocs: if a.member in the_members: recipient_assocs.append(a) else: recipient_assocs = the_assocs logging.info('announcing gig {0} to {1} people'.format(the_gig_key,len(recipient_assocs))) the_shared_params = pickle.dumps({ 'the_gig_key': the_gig_key, 'the_band_key': the_band_key, 'the_gig_url': the_gig_url, 'is_edit': is_edit, 'is_reminder': is_reminder, 'change_string': change_string }) for an_assoc in recipient_assocs: if an_assoc.email_me: the_member_key = an_assoc.member the_member_params = pickle.dumps({ 'the_member_key': the_member_key }) task = taskqueue.add( queue_name='emailqueue', url='/send_new_gig_handler', params={'the_shared_params': the_shared_params, 'the_member_params': the_member_params }) logging.info('announced gig {0}'.format(the_gig_key)) stats.update_band_email_stats(the_band_key, len(recipient_assocs)) self.response.write( 200 )
def main(request): reLink = re.compile("((https?|ftp|file):\/\/[\-A-Z0-9+&@#\/%?=~_|!:,.;]*[\-A-Z0-9+&@#\/%=~_|])",re.IGNORECASE) parseUrlList = Dao.DataSource_GetListAll() errorOutput = '' # logging.info('Starting to fetch items from Twitter: %s items' % parseUrlList.count()) hrefList = [] for parseUrl in parseUrlList: logging.info('fetching twitter feed: %s' % parseUrl.SourceUrl) try: page = urlfetch.fetch(parseUrl.SourceUrl, headers = {'Cache-Control' : 'max-age=0'}) logging.info(page) if page.status_code == 200: statusList = [] try: xmlDoc = minidom.parseString(page.content) statusList = xmlDoc.getElementsByTagName('text') except ExpatError, e: errorOutput += 'invalid Xml document.<BR>' + page.content for statusText in statusList: reResult = reLink.search(statusText.childNodes[0].nodeValue) r = reLink.findall(statusText.childNodes[0].nodeValue) for linkText in r: linkUrl = urlparse.urlparse(linkText[0]) logging.info('queueing url: %s' % linkUrl.geturl()) try: # taskqueue.add( url='/fetchdata', params={'dataUrl':linkUrl.geturl(), 'dataSource': parseUrl.SourceName }) params={'dataUrl':linkUrl.geturl(), 'dataSource': parseUrl.SourceName } #url = '/fetchdata/?dataUrl='+linkUrl.geturl()+'&dataSource='+parseUrl.SourceName url = '/fetchdata/' taskqueue.add( name=generateTaskName(linkUrl, parseUrl.SourceName), url=url, params=params, method='GET') logging.info('get url: %s' % url) logging.info('post data: %s' % params) hrefList.append( linkUrl.geturl()) except taskqueue.TaskAlreadyExistsError, e: errorOutput += '<li>%(sourcename)s - Duplicate task: %(taskname)s</li>' % {'sourcename': parseUrl.SourceName, 'taskname': generateTaskName(linkUrl, parseUrl.SourceName) } except taskqueue.TombstonedTaskError, e: errorOutput += '<li>%(sourcename)s - Tombstoned task: %(taskname)s</li>' % {'sourcename': parseUrl.SourceName, 'taskname': generateTaskName(linkUrl, parseUrl.SourceName) }
def post(self,*args,**kargs): currentUser=self.auth.get_user_by_session() logging.info("it is here "+self.request.__str__()) userid = self.request.get("userid") projid = self.request.get("projid") roleid = self.request.get("role") logging.info("it is here and the userId is"+userid) logging.info("it is here and the projid is"+projid) logging.info("it is here and the role is"+roleid) companyId= self.user_model.get_by_id(currentUser['user_id']).tenant_key projemem = project.ProjectMembers() userkey = ndb.Key('OurUser',int(userid)) model = userkey.get() projemem.userName = model.name projemem.projectid = ndb.Key('Project',int(projid)) projemem.companyid = companyId projemem.userid = userkey projemem.roleid = ndb.Key('Groups',int(roleid)) projemem.userRole = ndb.Key('Groups',int(roleid)).get().role user_info = self.auth.get_user_by_session() projemem.created_by = user_info['email_address'] projemem.status = True projekey = projemem.set() projmodel = projekey.get() sprints = sprint.Sprint().get_by_project(projmodel.projectid) logging.info if not sprints: logging.info("No sprints") else: task = taskqueue.add( queue_name = "my-push-queue", url='/newusereffortspersist', params={'projectid': projmodel.projectid.id(),'userid':projmodel.userid.id()}) data = {} data['id'] = projmodel.key.id() data['projectid'] = projmodel.projectid.id() data['companyid'] = projmodel.companyid.id() data['userName'] = (projmodel.userid).get().name data['userid'] = projmodel.userid.id() data['userRole'] = projmodel.userRole self.response.write(json.dumps(data, ensure_ascii=False))
def incr(name, delta=1): """Increments a counter. The increment is generally a memcache-only operation, though a task will also be enqueued about once per update_interval. May under-count if memcache contents is lost. Args: name: The name of the counter. delta: Amount to increment counter by, defaulting to 1. update_interval: Approximate interval, in seconds, between updates. Must be greater than zero. """ lock_key = "ctr_lck:" + name delta_key = "ctr_val:" + name # update memcache if delta >= 0: v = memcache.incr(delta_key, delta, initial_value = 0) elif delta < 0: v = memcache.decr(delta_key, -delta, initial_value = 0) if memcache.add(lock_key, None, time=UPDATE_INTERVAL): # time to enqueue a new task to persist the counter # note: cast to int on next line is due to GAE issue 2012 # (http://code.google.com/p/googleappengine/issues/detail?id=2012) v = int(v) try: qn = random.randint(0, 4) qname = 'PersistCounter%d' % qn taskqueue.add(url='/task/counter_persist_incr', queue_name=qname, params=dict(name=name, value=v)) except: # task queue failed but we already put the delta in memcache; # just try to enqueue the task again next interval return
def remove_taste_movie(self, movie): """ :param movie: :return: """ taste_movie_id = movie.key.id() + self.key.id() taste_movie = TasteMovie.get_by_id(taste_movie_id) if taste_movie is not None: taste_movie_key = taste_movie.key taste_movie.key.delete() if taste_movie_key in self.tastes_movies: self.tastes_movies.remove(taste_movie_key) self.put() taskqueue.add(url='/_ah/start/task/movie_untaste/' + self.key.id() + '/' + movie.key.id(), method='GET') # Recalculate proposal self.remove_proposal()
def put_dataset(self, datasetskey, resource, **kwargs): model = ndb.Key(urlsafe=datasetskey).get() if not model: errors.create(404) args = helper.parse_args_for_model(model, [{'name': 'secret', 'required': True}], validator=False) if model.secret != args.get('secret'): errors.create(401, payload={'message': 'Invalid secret key. You do not have access to modify this dataset.'}) model.populate(**args) model.status = {'code': 'parsing'} model.put() task = taskqueue.add( # first process headers queue_name='processor-queue', url='/tasks/process_data', payload=json.dumps(dict( key=model.get_key_urlsafe()) )) return model.to_dict()
def add_dataset(self, resource, **kwargs): _Model = resource.get_model() args = helper.parse_args_for_model(_Model, [{'name': 'files', 'required': True, 'action': 'append'}]) args['secret'] = util.uuid() args['headers'] = [] files = args.pop('files') model = _Model(**args) model.status = dict(code='started') model.put() # start the processing response = model.to_dict() response['secret'] = model.secret # force show the secret on creation task = taskqueue.add( # first process headers queue_name='processor-queue', url='/tasks/process_headers', payload= json.dumps(dict( key=model.get_key_urlsafe(), files=files) )) return response
def wipe_votes_json(self): #reset all votes json taskqueue.add(url='/task/batch_update_votes', params={'migration':'reset-votes-json'}) self.response.out.write("Batch job started<br/>")
def _common(self): (req,rsp,rheaders,rcookies) = common_init(self) pre_str = u'restoreTimer: ' rsp.set_status(200) loginfo(pre_str+u'start') max_num = MAX_RESTORE_NUM_PER_CYCLE last_id = req.get('last_id') flg_first = False if not last_id: set_maintenance_mode(True) flg_first = True timer_initialize() db_gc_list = dbGaeCronUser.all().order('date').fetch(max_num) cnt = 0 tcnt = 0 else: last_time = isofmt_to_datetime(req.get('last_time')) log(' last_id=%s' % (last_id)) log(' last_time=%s' % (req.get('last_time'))) db_gc_list = dbGaeCronUser.all().filter('date >=', last_time).order('date').fetch(max_num) cnt = int(req.get('cnt'),0) tcnt = int(req.get('tcnt'),0) gae_timer = GAE_Timer() set_timer = gae_timer.set_timer rel_timer = gae_timer.rel_timer for db_gc in db_gc_list: db_gc_id = str(db_gc.key().id()) if db_gc_id == last_id: continue cnt += 1 email = db_gc.email loginfo(u'%d: %s %s' % (cnt,email,db_gc.date)) cron_info_dict = json.loads(db_gc.croninfo) for (no,cron_info) in cron_info_dict.items(): tid = None if cron_info['valid']: timerid=u'%s-%s-%s' % (NAMESPACE,db_gc_id,str(no)) if cron_info['kind'] == 'cycle': tid = set_timer(minutes=cron_info['cycle_info']['cycle'],url=cron_info['url'],user_id=email,user_info=no,timerid=timerid,sem=False,save_after=True) else: _c = cron_info['cron_info'] _crontime = ' '.join([_c['min'],_c['hour'],_c['day'],_c['month'],_c['wday']]) tid = set_timer(crontime=_crontime,url=cron_info['url'],user_id=email,user_info=no,tz_hours=_c['tz_hours'],timerid=timerid,sem=False,save_after=True) if tid: tcnt += 1 loginfo(u' timer(No.%d) update (timerid=%s)' % (1+int(no),tid)) else: cron_info['valid'] = 0 logerr(u' timer(No.%d) set error' % (1+int(no))) cron_info['tid'] = tid db_gc.croninfo = db.Text(json.dumps(cron_info_dict)) dbPut(db_gc) last_id = db_gc_id last_time = db_gc.date if max_num<=len(db_gc_list): str_rsp = pre_str+u'continue' url=PATH_RESTORE_TIMER+'?last_id=%s&last_time=%s&cnt=%d&tcnt=%d' % (urllib.quote(last_id),urllib.quote(datetime_to_isofmt(last_time)),cnt,tcnt) log(u'call:"%s"' % (url)) for ci in range(3): try: taskqueue.add(url=url,method='GET',headers={'X-AppEngine-TaskRetryCount':0}) break except Exception, s: str_rsp = pre_str+u'taskqueue error: %s' % (str(s)) pass time.sleep(1)
def txn(): taskqueue.add(url=url_for( 'api/internal_delete_gifts_json_1c', task_id=task_id), transactional=True)
def _safe_taskqueue_add(url, params): params['the_key'] = cryptoutil.encrypt_string("Trust Me") taskqueue.add(queue_name='emailqueue', url=url, params=params)
def create(site_uri): taskqueue.add(url=service_uri, params={'site_uri': site_uri})
def get(self): if self.request.get('admin') == credentials.ADMIN_KEY: taskqueue.add(url='/deleteData', params={'admin': credentials.ADMIN_KEY}) self.response.write('Added task!') else: self.response.write('Wrong key!')