def __new__(cls, name, bases, attrs): super_new = super(TaskType, cls).__new__ task_module = attrs["__module__"] # Abstract class, remove the abstract attribute so # any class inheriting from this won't be abstract by default. if attrs.pop("abstract", None) or not attrs.get("autoregister", True): return super_new(cls, name, bases, attrs) # Automatically generate missing name. if not attrs.get("name"): task_module = sys.modules[task_module] task_name = ".".join([task_module.__name__, name]) attrs["name"] = task_name # Because of the way import happens (recursively) # we may or may not be the first time the task tries to register # with the framework. There should only be one class for each task # name, so we always return the registered version. task_name = attrs["name"] if task_name not in tasks: task_cls = super_new(cls, name, bases, attrs) tasks.register(task_cls) return tasks[task_name].__class__
def __new__(cls, name, bases, attrs): new = super(TaskType, cls).__new__ task_module = attrs.get("__module__") or "__main__" # Abstract class: abstract attribute should not be inherited. if attrs.pop("abstract", None) or not attrs.get("autoregister", True): return new(cls, name, bases, attrs) # Automatically generate missing/empty name. autoname = False if not attrs.get("name"): try: module_name = sys.modules[task_module].__name__ except KeyError: # Fix for manage.py shell_plus (Issue #366). module_name = task_module attrs["name"] = '.'.join([module_name, name]) autoname = True # Because of the way import happens (recursively) # we may or may not be the first time the task tries to register # with the framework. There should only be one class for each task # name, so we always return the registered version. task_name = attrs["name"] if task_name not in tasks: task_cls = new(cls, name, bases, attrs) if autoname and task_module == "__main__" and task_cls.app.main: task_name = task_cls.name = '.'.join([task_cls.app.main, name]) tasks.register(task_cls) task = tasks[task_name].__class__ return task
def setup_tasks(self, consumer_dict): for calendar_id, transformers in consumer_dict.iteritems(): for Transformer in transformers: _tasks.append(self.create_task(calendar_id, Transformer())) for Task in _tasks: tasks.register(Task)
def test_periodic_taskmeta(self): tasks.register(TestPeriodicTask) p = self.createPeriodicTaskMeta(TestPeriodicTask.name) # check that repr works. self.assertTrue(unicode(p).startswith("<PeriodicTask:")) self.assertFalse(p in PeriodicTaskMeta.objects.get_waiting_tasks()) # Have to avoid save() because it applies the auto_now=True. PeriodicTaskMeta.objects.filter(name=p.name).update( last_run_at=datetime.now() - TestPeriodicTask.run_every) self.assertTrue(p in PeriodicTaskMeta.objects.get_waiting_tasks()) self.assertTrue(isinstance(p.task, TestPeriodicTask)) p.delay()
def test_periodic_taskmeta(self): tasks.register(TestPeriodicTask) p = self.createPeriodicTaskMeta(TestPeriodicTask.name) # check that repr works. self.assertTrue(unicode(p).startswith("<PeriodicTask:")) self.assertFalse(p in PeriodicTaskMeta.objects.get_waiting_tasks()) p.last_run_at = datetime.now() - (TestPeriodicTask.run_every + timedelta(seconds=10)) p.save() self.assertTrue(p in PeriodicTaskMeta.objects.get_waiting_tasks()) self.assertTrue(isinstance(p.task, TestPeriodicTask)) p.delay()
>>> class TwitterUpdateTask(WebhookSignal): ... name = "myapp.tasks.TwitterWebhookSignal" ... ... def run(self, username, password, message, \*\*kwargs): ... import twitter ... api = twitter.Api(username=username, password=password) ... api.PostUpdate(message) >>> tasks.register(TwitterUpdateTask)
items = soup.findAll('item') for item in items: post_type = item.find('wp:post_type').string post_status = item.find('wp:status').string if post_type == 'attachment': get_media(item, uri_parser, user) # Note! This script assumes all the attachments come before # posts and pages in the xml. If this ends up changing, # do two loops, one with attachments and the second with posts and pages. elif post_type == 'post' and post_status == 'publish': get_posts(item, uri_parser, user) elif post_type == 'page' and post_status == 'publish': get_pages(item, uri_parser, user) if user.email: context_instance = { 'SITE_GLOBAL_SITEDISPLAYNAME': get_setting('site', 'global', 'sitedisplayname'), 'SITE_GLOBAL_SITEURL': get_setting('site', 'global', 'siteurl'), } subject = ''.join(render_to_string(('notification/wp_import/short.txt'), context_instance).splitlines()) body = render_to_string(('notification/wp_import/full.html'), context_instance) #send_mail(subject, body, settings.DEFAULT_FROM_EMAIL, [user.email], fail_silently=False) email = EmailMessage(subject, body, settings.DEFAULT_FROM_EMAIL, [user.email]) email.content_subtype = 'html' email.send(fail_silently=True) tasks.register(WPImportTask)
def transfer(self, name, local, remote, **kwargs): """ `name` is the filename, `local` the local backend instance, `remote` the remote backend instance. Returns `True` when the transfer succeeded, `False` if not. Retries the task when returning `False`. """ try: remote.save(name, local.open(name)) return True except Exception, e: logger = self.get_logger(**kwargs) logger.exception("Unable to save '%s' to remote storage. About " "to retry." % name) logger.exception(e) return False class TransferAndDelete(Transfer): def transfer(self, name, local, remote, **kwargs): result = super(TransferAndDelete, self).transfer(name, local, remote, **kwargs) if result: local.delete(name) return result tasks.register(Transfer) tasks.register(TransferAndDelete)
from celery.task import PeriodicTask from celery.registry import tasks from datetime import timedelta from datetime import datetime from django.core import management #Test only #Deprecated,please see settings.py CELERYBEAT_SCHEDULE class MyTask(PeriodicTask): run_every = timedelta(minutes=1) def run(self, **kwargs): self.get_logger().info("Time now: " + datetime.now()) print("Time now: " + datetime.now()) tasks.register(MyTask) #Test only @task() def add(x, y): print 'add****' return x + y @task() def update_index(): management.call_command('update_index')
from celery.registry import tasks from friends.contrib.suggestions.backends import importers from friends.contrib.suggestions.backends.runners import AsyncRunner from friends.contrib.suggestions.settings import RUNNER if issubclass(RUNNER, AsyncRunner): tasks.register(importers.GoogleImporter) tasks.register(importers.FacebookImporter) tasks.register(importers.TwitterImporter) tasks.register(importers.YahooImporter) tasks.register(importers.LinkedInImporter)
url_boleto = gera_boleto_bradesco(user.id, inv) email = user.email if email is not None and len(email) > 0: bcc_list = ['*****@*****.**', user.email] else: bcc_list = ['*****@*****.**'] msg = EmailMessage() msg.subject = 'Teste: Cobrança de mensalidade' #temp = request.META # if request is None: msg.body = render_to_string( 'async_tasks/email_cobranca_mensalidade.html', locals()) # else: # from celery.schedules import discard_all # discard_all() # return render_to_response('async_tasks/email_cobranca_mensalidade.html', locals()) # msg.from = 'GestoPSI <*****@*****.**>' msg.to = ['*****@*****.**', ] msg.bcc = bcc_list msg.content_subtype = "html" # Main content is now text/html msg.send() logger.info("CheckAndCharge Finished.\n\n") tasks.register(CheckAndCharge) def check_and_charge(): CheckAndCharge().run()
def job(_context, class_, name=None): if name is not None: class_.name = name tasks.register(class_)
raise ImproperlyConfigured("when used celery<3.1, djcelery is required!") if 'djcelery' not in settings.INSTALLED_APPS: from django.core.exceptions import ImproperlyConfigured raise ImproperlyConfigured("djcelery not in INSTALLED_APPS!") from beproud.django.notify import notify_now class Notify(Task): def run(self, targets, notify_type, extra_data={}, include_media=None, exclude_media=[], max_retries=3, retry_countdown=10, **kwargs): try: return notify_now( targets, notify_type, extra_data=extra_data, include_media=include_media, exclude_media=exclude_media, ) except Exception, e: return self.retry( exc=e, countdown=retry_countdown, max_retries=max_retries, ) tasks.register(Notify)
from django.conf import settings from django.core.cache import cache from django.core.files.storage import get_storage_class from celery.registry import tasks from celery.task import Task MAX_RETRIES = getattr(settings, 'QUEUED_REMOTE_STORAGE_RETRIES', 5) RETRY_DELAY = getattr(settings, 'QUEUED_REMOTE_STORAGE_RETRY_DELAY', 60) class SaveToRemoteTask(Task): max_retries = MAX_RETRIES default_retry_delay = RETRY_DELAY def run(self, name, local, remote, cache_key, **kwargs): local_storage = get_storage_class(local)() remote_storage = get_storage_class(remote)() try: remote_storage.save(name, local_storage.open(name)) except: # something went wrong while uploading the file, retry self.retry([name, local, remote, cache_key], **kwargs) return False cache.set(cache_key, True) return True tasks.register(SaveToRemoteTask)
from celery.task import Task from celery.registry import tasks from subprocess import * from django_wikinetwork import settings class AnalyseTask(Task): def run(self, lang, options): import os from glob import glob logger = self.get_logger() logger.info("Running: %s" % (lang,)) files = '%s/%swiki-*_rich.pickle' % (settings.DATASET_PATH, lang,) # find the most recent file fn = sorted(glob(files))[-1] logger.info("Running: %s, filename: %s" % (lang, fn)) cmd = "/sra0/sra/setti/Source/wiki-network/analysis.py --as-table --group %s %s" % (' '.join(options), fn) logger.info(cmd) p = Popen(cmd, shell=True, stderr=PIPE) return fn tasks.register(AnalyseTask)
from celery import task from celery.task import PeriodicTask from celery.registry import tasks from datetime import timedelta from datetime import datetime from django.core import management #Test only #Deprecated,please see settings.py CELERYBEAT_SCHEDULE class MyTask(PeriodicTask): run_every = timedelta(minutes=1) def run(self, **kwargs): self.get_logger().info("Time now: " + datetime.now()) print("Time now: " + datetime.now()) tasks.register(MyTask) #Test only @task() def add(x, y): print 'add****' return x + y @task() def update_index(): management.call_command('update_index')
from celery.task import Task from celery.registry import tasks from django.core.files.base import ContentFile class AsyncSaveInBackup(Task): def run(self, primary_storage, backup_storage, filename): primary_file = primary_storage.open(filename) real_filename = primary_file.real_filename primary_file = ContentFile(primary_file.read()) primary_file.name = real_filename backup_storage.save(filename, primary_file) class AsyncDeleteFromBackup(Task): def run(self, backup_storage, filename): backup_storage.delete(filename) tasks.register(AsyncSaveInBackup) tasks.register(AsyncDeleteFromBackup)
self.partners_gates = {} for p in Partner.objects.select_related().filter(gate__isnull=False): self.partners_gates[p.id] = self.gate_interfaces[ p.gate.gate_module] def run(self, queue_item): status_message = str(datetime.now()) queue_item.status = STATUS_SENDING queue_item.status_message = status_message queue_item.save() gate = self.partners_gates[queue_item.partner_id] try: gate.send(queue_item) queue_item.status = STATUS_OK queue_item.status_message = '' except ProviderFailure as ex: queue_item.status = STATUS_PROVIDER_FAILURE queue_item.status_message = str(ex.encode('utf8')) except Exception as ex: queue_item.status = STATUS_INNER_FAILURE queue_item.status_message = str(ex.encode('utf8')) finally: queue_item.save() tasks.register(SendSms)
from celery.task import Task from celery.registry import tasks from threadless_router.router import Router from aremind.apps.adherence.models import Feed class ReminderSchedulerTask(Task): def run(self): router = Router() app = router.get_app("aremind.apps.adherence") app.cronjob() tasks.register(ReminderSchedulerTask) class FeedUpdatesTask(Task): def run(self): return Feed.objects.fetch_feeds() tasks.register(FeedUpdatesTask)
from celery.registry import tasks from celery.task import Task from celery import task from django.core import management # This is having some problems with celery 3.0.13 and mod_wsgi class CreateInstancesTask(Task): def run(self, pk): management.call_command('create_instances', verbosity=0, pk=pk) tasks.register(CreateInstancesTask) @task() def create_instances_task(pk): management.call_command('create_instances', verbosity=0, pk=pk)
from theme.models import Theme class ThemeDelegate(Task): """ This task will be responsible for getting the ball rolling for finding information for this task """ name = "theme_delegate" def run(self): print "This run got called" def run(self, theme_id): if theme_id: try: theme = Theme.objects.get(pk=theme_id) event_type = theme.event_type event_types = [event_type] if event_type else [] print "Calling basic agent to search for theme: %s" % theme gsa = GazetteerSearchAlgorithm() ba = BasicAgent() reports = ba.search(event_types=event_types, algorithm=gsa) if reports: print "We found %s reports based on our theme %s" % (len(reports), theme) else: print "No reports found for our theme %s" % theme except Theme.DoesNotExist: print "No theme exists with id %s" % theme_id tasks.register(ThemeDelegate)
from celery.registry import tasks from datetime import datetime from brigitte.repositories.models import RepositoryUpdate class UpdateGitoliteTask(Task): default_retry_delay = 10 max_retries = 3 def run(self, **kwargs): logger = self.get_logger(**kwargs) try: logger.info('updating gitolite..') if RepositoryUpdate.objects.filter(is_exported=False).count() > 0: from brigitte.repositories.utils import update_gitolite update_gitolite() RepositoryUpdate.objects.filter(is_exported=False).update( is_exported=True, exported=datetime.now() ) logger.info('updated!') else: logger.info('no update needed!') return True except Exception, exc: logger.error('failed: %s' % exc) self.retry([], kwargs, exc=exc) return False tasks.register(UpdateGitoliteTask)
from celery.task import Task from celery.registry import tasks from emp.apps.videos.utils import convert_uploaded_video """ Task to be started from videos.views.video_upload to process uploaded video Process contained in videos.utils """ class ProcessVideoTask(Task): def run(self, video_id, **kwargs): convert_uploaded_video(video_id) # convert video, pass in Video id for further processing tasks.register(ProcessVideoTask)
profile.mobile_phone, profile.email2, profile.url, profile.url2, profile.dob, profile.ssn, profile.spouse, profile.department, profile.education, profile.student, profile.remember_login, profile.exported, profile.direct_mail, profile.notes, profile.admin_notes, profile.referral_source, profile.hide_in_search, profile.hide_address, profile.hide_email, profile.hide_phone, profile.first_responder, profile.agreed_to_tos, profile.original_username, '\n', ] data_rows.append(data_row) return render_excel(filename, field_list, data_rows, '.csv') tasks.register(ExportProfilesTask)
class AddProject_Run(Task): def run(self,svn_path='',git_path='',svn_user='',svn_password=''): try: resultsFile=os.path.join(ANSIBLE_TEMP,str(self.request.id)+'.out').replace('\\','/') result=open(resultsFile,'w') if not os.path.exists(git_path): os.mkdir(git_path) cmd='svn checkout {svn_path} --username {svn_user} --password {svn_password} {git_path}'.format(svn_path=svn_path,svn_user=svn_user,svn_password=svn_password,git_path=git_path) print cmd p=subprocess.Popen(cmd, shell=True, universal_newlines=True, stdin=subprocess.PIPE,stdout=result, stderr=result) p.wait() result.close() #t=AnsibleTask.objects.get(task_id=self.request.id) # t.status='完成' # t.save() except Exception, e: #t=AnsibleTask.objects.get(task_id=self.request.id) #t.status='错误' #t.save() print e return "OK" tasks.register(AddProject_Run)
# processing.trigger_update(logger=logger) # else: # logger.info('start internal poller') # processing.poll_internal(logger=logger) #tasks.register(PollingTask) class PollingTaskExternal(PeriodicTask): run_every = timedelta(seconds=5) def run(self, **kwargs): logger = self.get_logger(**kwargs) logger.info('PollingTaskExternal') logger.info('start external poller') processing.poll_external(logger=logger) tasks.register(PollingTaskExternal) class ProcessResponses(PeriodicTask): run_every = timedelta(seconds=5) def run(self, **kwargs): logger = self.get_logger(**kwargs) logger.info('ProcessResponses') processing.process_responses(logger) tasks.register(ProcessResponses)
from tendenci.apps.site_settings.utils import get_setting from tendenci.apps.wp_exporter.models import XMLExport from tendenci.apps.wp_exporter.utils import gen_xml class WPExportTask(Task): def run(self, form, user, **kwargs): xml = gen_xml(form.cleaned_data) file_content = ContentFile(xml.content.encode(encoding='UTF-8',errors='strict')) export = XMLExport() export.author = user export.xml.save('export.xml', file_content, save=True) if user.email: context_instance = { 'SITE_GLOBAL_SITEDISPLAYNAME': get_setting('site', 'global', 'sitedisplayname'), 'SITE_GLOBAL_SITEURL': get_setting('site', 'global', 'siteurl'), 'export': export, } subject = ''.join(render_to_string(('notification/wp_export/short.txt'), context_instance).splitlines()) body = render_to_string(('notification/wp_export/full.html'), context_instance) #send_mail(subject, body, settings.DEFAULT_FROM_EMAIL, [user.email], fail_silently=False) email = EmailMessage(subject, body, settings.DEFAULT_FROM_EMAIL, [user.email]) email.content_subtype = 'html' email.send(fail_silently=True) tasks.register(WPExportTask)
try: from celery.task import PeriodicTask from celery.registry import tasks except ImportError: PeriodicTask = object tasks = None from datetime import timedelta import logging from .models import Answer from . import settings as local_settings logger = logging.getLogger('crowdsourcing.tasks') class SyncFlickr(PeriodicTask): run_every = timedelta(minutes=5) def run(self, *args, **kwargs): logger.debug("Syncing flickr") Answer.sync_to_flickr() if tasks and not local_settings.SYNCHRONOUS_FLICKR_UPLOAD: tasks.register(SyncFlickr)
from datetime import datetime from celery.task import Task from celery.registry import tasks from tendenci.apps.locations.importer.tasks import ImportLocationsTask tasks.register(ImportLocationsTask)
text, user.phone_number, user.name)).save() class ContentProducerTask(Task): def run(self, content_producer_pk): content = ContentProducer.objects.get(pk=content_producer_pk) self.text = content.text_body conditions = content.conditions.all() end_execution = datetime.now() + timedelta(seconds=15) users = SimpleUser.objects.all() # Build the query with the given conditions for condition in conditions: filters = Q(**{condition.field: condition.value}) users = users.filter(filters) jobs = TaskSet(tasks=[ send_sms.subtask(( content.text_body, user, ), expires=end_execution) for user in users ]) jobs.apply_async() # Check for time limit exceeded # Then, revoke evey task waiting for execution tasks.register(ContentProducerTask)
class ScaleScheduler(PeriodicTask): run_every = timedelta(seconds=5) # Used for tick frequency def is_due(self, last_run_at): for app in Application.objects.exclude( to_be_run_at__gt=datetime.now()): app.to_be_run_at = datetime.now() + timedelta( seconds=app.scale_interarrival) app.save() Scale.delay(app) return (False, self.timedelta_seconds(ScaleScheduler.run_every.run_every)) tasks.register(ScaleScheduler) class Scale(Task): def run(self, app): # Create an instance of the logger log = get_logger('vdi') # Create the cluster object to help us manage the cluster cluster = AppCluster(app.pk) # Clean up all idle users on all nodes for this application cluster log.debug('APP NAME %s' % app.name) cluster.logout_idle_users() log.debug("Checking for active clusters")
from django_wikinetwork import settings class AnalyseTask(Task): def run(self, lang, options): import os from glob import glob logger = self.get_logger() logger.info("Running: %s" % (lang, )) files = '%s/%swiki-*_rich.pickle' % ( settings.DATASET_PATH, lang, ) # find the most recent file fn = sorted(glob(files))[-1] logger.info("Running: %s, filename: %s" % (lang, fn)) cmd = "/sra0/sra/setti/Source/wiki-network/analysis.py --as-table --group %s %s" % ( ' '.join(options), fn) logger.info(cmd) p = Popen(cmd, shell=True, stderr=PIPE) return fn tasks.register(AnalyseTask)
xml_content = xml_response.read() # docket_xml_filepath = "%s%s" % (XML_DOWNLOAD_FOLDER_PATH, docket_filename) with open(docket_xml_filepath, 'w') as docket_file: docket_file.write(xml_content) with open(result_csv_filename, 'a') as result_csv_file: result_writer = csv.writer(result_csv_file, delimiter=',', quotechar='"') result_writer.writerow([counter, docket_filename]) # Renaming the file for status COMPLETE os.rename(result_csv_filename, completed_csv_filename) return tasks.register(downloader) def main(): args = get_args() downloader.delay(recap_download_csv_file_name=args.docket_csv) if __name__ == '__main__': main()
if response.status != 200 or response.reason != 'OK': raise EventTracker.FailedEventRequest( "The tracking request failed. " "Non-200 response code was: " "[%s] reason: [%s]" % (response.status, response.reason) ) # Successful requests will generate a log response_data = response.read() if response_data != '1': return False return True tasks.register(EventTracker) class PeopleTracker(EventTracker): endpoint = mp_settings.MIXPANEL_PEOPLE_ENDPOINT event_map = { 'set': '$set', 'add': '$increment', 'track_charge': '$append', } def run( self, event_name, properties=None, token=None, test=None, **kwargs ): """ Track an People event occurrence to mixpanel through the API.
execute the check. Return tuple of (RESULT, MSG). MSG is empty for UP states. """ plugin = get_cls_by_name(plugin_cls_name)() plugin.set_logger(logger or get_task_logger('django')) msg = None try: msg = plugin.run_check(settings) except PluginImplementationError as e: return (Service.STATE_UNKNOWN, e.message) except PluginConfigurationError as e: return (Service.STATE_UNKNOWN, "Plugin {} is misconfigured: {}".format( plugin_cls_name, e.message)) except ServiceCheckFailed as e: return (Service.STATE_UNKNOWN, "Service check failed: " + e.reason) except ServiceIsDown as e: return (Service.STATE_DOWN, e.message) except ServiceHasWarning as e: return (Service.STATE_WARNING, e.message) except Exception as e: return (Service.STATE_UNKNOWN, 'Unknown exception: {}: {}'.format( e.__class__, e)) return (Service.STATE_OK, msg or '') tasks.register(ArgusChecker)
@task() def fetch_rate(symbol_from, symbol_to): logger.info('Requesting currency rate from %s to %s ', symbol_from, symbol_to) try: ratehandler = urlopen(RATE_URL % (symbol_from, symbol_to)) new_rate = Decimal(ratehandler.read().rstrip()) ratehandler.close() cache.set('%s%s' % (symbol_from, symbol_to), new_rate, CURRENCY_RATE_VALIDITY) try: rate = CurrencyRate.objects.get(source=symbol_from, destination=symbol_to) except ObjectDoesNotExist: rate = CurrencyRate(source=symbol_from, destination=symbol_to) rate.rate = new_rate rate.last_update = datetime.utcnow() rate.save() return new_rate except URLError: logger.error('Failed to get currency rate from %s to %s', symbol_from, symbol_to) raise MoneypitException('Failed to get currency') tasks.register(fetch_rate)
from celery.contrib.abortable import Task from celery.registry import tasks from sample.scripts.stream import StreamManage from pprint import pprint class StreamTask(Task): sm = None th = None def __init__(self): pass def run(self, coords, **kwargs): try: print "StreamTask ::: Stream already instantiated, %s" % coords['stop'] try: self.th = self.sm.stream(coords, obj = self.th) except AttributeError, e: print "StreamTask ::: the asshole is not an instance %s" % e self.retry(args = [coords], exc=e, countdown=30, kwargs=kwargs) except KeyError, e: print "StreamTask ::: Stream instantiated, for exception %s" % e self.sm = StreamManage() self.th = self.sm.stream(coords) print "From sample.task Task is %s" % self.request.id + " the returned result from script called is %s" % self.th + " instance of Straming is %s" % self.sm return 'task executed' tasks.register(StreamTask)
url = Response.generateMediaURL(photo) try: # valid = image_validator.validate(tag, url) # if valid == 1: # logger.info(database.write_item("Pictures", "url", tag=tag, id=id, url=url)) # else: # logger.debug("HERE " + str(valid)) # raise database.write_item("Pictures", "url", tag=tag, id=id, url=url) except: continue id += 1 logger.info("All images for %s is stored to database" % tag) tasks.register(StoreAllPhotos) # Entire file needs to be refactored # task object: stores all variables and methods which are purpose-specific # Template - to be further implemented with template functions class Task(object): def __init__(self): logger.info("Task created") def Run(): logger.info("Start task run") # Refactor to remove all static methods
class SendTestRabbitMQ2(Task): def run(self, N, args): return class SendResponse(Task): def run(self): with Connection('amqp://*****:*****@localhost:5672//') as conn: try: worker = Worker(conn) worker.run() except KeyboardInterrupt: print('bye bye') @task def Deliver(self, args): print(args) tasks.register(Deliver) tasks.register(CreateDeviceTask) tasks.register(UpdatePersonalAccount) tasks.register(SendChangePersonalAccountReport) tasks.register(SendGetPayBillReport) tasks.register(SendAuthReport) tasks.register(SendAuthReportChecker) tasks.register(SendTestRabbitMQ) tasks.register(SendResponse)
", ".join(errors)), state="ERROR") errors = [] if not repo_utils.rebalance_sync_schedule(errors): for error in errors: self.update(error, state="ERROR") if self.errors: raise TaskExecutionError("Created %s (%s), but encountered errors: " "%s" % (name, repo_id, self.errors)) else: return "Successfully created repo %s" % repo['name'] tasks.register(CreateRepo) class CloneRepo(TrackedTask): def run(self, clone_id, name=None, parent=None, groups=None, filters=None): if groups is None: groups = [] if filters is None: filters = [] repoapi = RepositoryAPI() try: repoapi.clone(parent['id'], clone_id, name, relative_path=clone_id) self.update("Cloned %s to %s" % (parent['id'], clone_id))
def run(self, dry_run=False, reset=False): logger = self.get_logger() logger.info("Starting aggregates task") update_all_aggregates(dry_run, reset) logger.info("Stopping aggregates task") class DailyAlertsTask(PeriodicTask): alert_frequency = 'daily' name = 'openrural.dailyalerts' run_every = crontab(hour=0, minute=1) def run(self): logger = self.get_logger() logger.info('Starting %s alerts task' % self.alert_frequency) send_alerts(['-f', self.alert_frequency]) logger.info('Stopping %s alerts task' % self.alert_frequency) class WeeklyAlertsTask(DailyAlertsTask): alert_frequency = 'weekly' name = 'openrural.weeklyalerts' run_every = crontab(hour=1, minute=1, day_of_week='wednesday') tasks.register(AggregatesTask) tasks.register(DailyAlertsTask) tasks.register(WeeklyAlertsTask)
name = 'openrural.incidents' run_every = timedelta(days=1) def run(self, clear=False): logger = self.get_logger() logger.info("Starting incidents task") WhitevilleIncidentsScraper(clear=clear).run() logger.info("Stopping incidents task") class WhitevilleArrestsTask(PeriodicTask): name = 'openrural.arrests' run_every = timedelta(days=1) def run(self, clear=False): logger = self.get_logger() logger.info("Starting arrests task") WhitevilleArrestsScraper(clear=clear).run() logger.info("Stopping arrests task") tasks.register(CorporationsTask) tasks.register(AddressesTask) tasks.register(PropertyTransactionsTask) tasks.register(RestaurantInspectionsTask) tasks.register(WhitevilleNewsTask) tasks.register(WhitevilleSchoolsTask) tasks.register(WhitevilleIncidentsTask) tasks.register(WhitevilleArrestsTask)
try: resultsFile=os.path.join(ANSIBLE_TEMP,str(self.request.id)+'.out').replace('\\','/') hostFile=os.path.join(ANSIBLE_TEMP,str(self.request.id)+'.hosts').replace('\\','/') f=open(hostFile,'w') for ip in hosts: f.write(ip+'\n') f.close() result=open(resultsFile,'w') #cmd='ansible -i "{host}" all -m shell -f 100 -a "{cmd}"'.format(host=hostFile,cmd=cmd) cmd='{cmd} -i "{host}"'.format(host=hostFile,cmd=cmd) print cmd p=subprocess.Popen(cmd, shell=True, universal_newlines=True, stdin=subprocess.PIPE,stdout=result, stderr=result) p.wait() result.close() t=AnsibleTask.objects.get(task_id=self.request.id) t.status='完成' t.save() except Exception, e: t=AnsibleTask.objects.get(task_id=self.request.id) t.status='错误' t.save() return "OK" tasks.register(Ansible_Run)
import requests import logging from celery.decorators import task from celery.registry import tasks from celery.task import Task class IssueTask(Task): def __init__(self): logging.info("My log") def run(self, url, method, urlData): try: if (method == "POST"): logging.info(url) logging.info("Here to POST!") r = requests.post("http://localhost:8000/creative/", data=urlData) logging.info(r.status_code) else: requests.get(url, data=urlData) except: logging.info("Something gone wrong") tasks.register(IssueTask)
def on_failure(self, exc, task_id, args, kwargs, einfo): """ If the processing failed we should mark that in the database. Assuming that the exception raised is a subclass of BaseProcessingFail, we can use that to get more information about the failure and store that for conveying information to users about the failure, etc. """ entry_id = args[0] mark_entry_failed(entry_id, exc) entry = mgg.database.MediaEntry.query.filter_by(id=entry_id).first() json_processing_callback(entry) mgg.database.reset_after_request() def after_return(self, *args, **kwargs): """ This is called after the task has returned, we should clean up. We need to rollback the database to prevent ProgrammingError exceptions from being raised. """ # In eager mode we get DetachedInstanceError, we do rollback on_failure # to deal with that case though when in eager mode. if not celery.app.default_app.conf['CELERY_ALWAYS_EAGER']: mgg.database.reset_after_request() tasks.register(ProcessMedia)
ni, created = NewsItem.objects.get_or_create(user=post.user_to, post=post) elif isinstance(post, SharePost): ni, created = NewsItem.objects.get_or_create(user=post.user_to, post=post) elif isinstance(post, PagePost): users = post.page.get_lovers_active() for user in users: ni, created = NewsItem.objects.get_or_create(user=user, post=post) else: ni, created = NewsItem.objects.get_or_create(user=post.user_to, post=post) tasks.register(UpdateNewsFeeds) class DeleteNewsFeeds(Task): def run(self, post, user=None, **kwargs): from models import NewsItem, FriendPost #rdb.set_trace() post_wrapper = post if user: users = [user] else: users = post_wrapper.get_involved() for user in users: post_news = NewsItem.objects.filter(user=user, post=post_wrapper.post) if post_news:
from celery.task import Task from celery.registry import tasks from django.core import management class DeleteInactiveUsers(Task): def run(self, **kwargs): management.call_command('cleanupregistration', verbosity=0, interactive=False) tasks.register(DeleteInactiveUsers) class SendReminderToInactiveUsers(Task): def run(self, **kwargs): management.call_command('send_reminder', verbosity=0, interactive=False) tasks.register(SendReminderToInactiveUsers)
from celery.task import Task from celery.registry import tasks from stats.models import DataPoint class DataPointUpdate(Task): def run(self, key, value, date, **kwargs): point, created = DataPoint.objects.get_or_create(key=key, date_added=date) if value > 0: point.value += value elif value < 0: point.value -= abs(value) point.save() tasks.register(DataPointUpdate)
from celery.registry import tasks from celery.task import Task from django.template.loader import render_to_string from django.utils.html import strip_tags from django.core.mail import EmailMultiAlternatives class SignUpTask(Task): def product(x, y): return x * y tasks.register(SignUpTask)
call_command('compilemessages') os.chdir(curr) logger.info("handling template") # handling the template excepation os.chdir("templates") # TODO: fix a way for unix platfroms os.system ("xcopy /S /Y ..\locale\*.* .\locale") call_command('makemessages',all=True) os.system ("xcopy /S /Y .\locale\*.* ..\locale") logger.info("coming back to curr folder") os.chdir(curr) call_command('compilemessages') ''' except Exception, e: logger.info ( "Exception: %s" % str( e) ) raise e finally: os.chdir(curr) return True tasks.register( findMovieByTitleTask ) tasks.register( findPersonByNameTask ) tasks.register( findShowByIDTask ) tasks.register( fillActorDataTask) tasks.register( fillShowEpisodesTask ) tasks.register(maintenanceTranslateTask) tasks.register(maintenanceReIndexTask)
html_url += "&news=%s" % form.cleaned_data.get('news') html_url += "&news_days=%s" % form.cleaned_data.get('news_days') html_url += "&jobs=%s" % form.cleaned_data.get('jobs') html_url += "&jobs_days=%s" % form.cleaned_data.get('jobs_days') html_url += "&pages=%s" % form.cleaned_data.get('pages') html_url += "&pages_days=%s" % form.cleaned_data.get('pages_days') if template.zip_file: if hasattr(settings, 'USE_S3_STORAGE') and settings.USE_S3_STORAGE: zip_url = unicode(template.get_zip_url()) else: zip_url = unicode("%s%s" % (site_url, template.get_zip_url())) else: zip_url = unicode() #sync with campaign monitor try: t = CST(template_id=template.template_id) t.update(unicode(template.name), html_url, zip_url) except BadRequest, e: messages.add_message( request, messages.ERROR, 'Bad Request %s: %s' % (e.data.Code, e.data.Message)) return redirect('campaign_monitor.campaign_generate') except Exception, e: messages.add_message(request, messages.ERROR, 'Error: %s' % e) return redirect('campaign_monitor.campaign_generate') tasks.register(CampaignGenerateTask)
from celery.registry import tasks from celery.task import Task class SignupTask(Task): def run(self,user): return "manikandan" tasks.register(SignupTask)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to]) msg.attach_alternative(html_content, "text/html") msg.send() class SignUpTask(Task): def run(self, user): """This method is responsible for asynchronously sending welcome email to users when they sign up. Keyword agruments: user- user object who just signed up """ email = user.email user = user subject, from_email, to = 'Welcome', '*****@*****.**', email html_content = render_to_string('email_signup.html', {'user':user.first_name}) text_content = strip_tags(html_content) # create the email, and attach the HTML version as well. msg = EmailMultiAlternatives(subject, text_content, from_email, [to]) msg.attach_alternative(html_content, "text/html") msg.send() # register the task with celery tasks.register(SignUpTask)
) ravenclient.captureException() except Profile.DoesNotExist: # user must have profile. logger.critical( "Caught DoesNotExist exception for {}, user_id{}, \ in {}".format( Profile.__name__, user_id, __file__ ), exc_info=True ) ravenclient.captureException() except Exception: logger.critical( "Caught exception in {}".format(__file__), exc_info=True ) ravenclient.captureException() return False else: logger.error( "Email type not given, {}, user_id {}". format( __file__, user["id"] ) ) # Registered the task tasks.register(BaseSendMail)