import remoulade
from remoulade.scheduler import Scheduler, ScheduledJob
from remoulade.brokers.rabbitmq import RabbitmqBroker
broker = RabbitmqBroker(max_priority=10)
remoulade.set_broker(broker)
remoulade.set_scheduler(
Scheduler(broker, [
ScheduledJob(actor_name="write_loaded_at",
kwargs={
"filename": "/tmp/scheduler-2",
"text": "simple schedule\n"
},
interval=3600)
],
period=0.1))
@remoulade.actor()
def write_loaded_at(filename, text):
with open(filename, "a+") as f:
f.write(text)
broker.declare_actor(write_loaded_at)
import random
import sys
import remoulade
from remoulade.brokers.rabbitmq import RabbitmqBroker
broker = RabbitmqBroker()
remoulade.set_broker(broker)
@remoulade.actor
def add(x, y):
add.logger.info("The sum of %d and %d is %d.", x, y, x + y)
broker.declare_actor(add)
def main(count):
count = int(count)
for _ in range(count):
add.send(random.randint(0, 1000), random.randint(0, 1000))
if __name__ == "__main__":
sys.exit(main(sys.argv[1]))
import remoulade
from remoulade.brokers.rabbitmq import RabbitmqBroker
from remoulade.scheduler import ScheduledJob, Scheduler
broker = RabbitmqBroker()
remoulade.set_broker(broker)
@remoulade.actor()
def count_words(url):
response = requests.get(url).text
print("There are {} words in {}".format(len(response), url))
broker.declare_actor(count_words)
if __name__ == "__main__":
scheduler = Scheduler(
broker,
[
ScheduledJob(actor_name="count_words",
kwargs={"url": "https://github.com"},
interval=1),
ScheduledJob(actor_name="count_words",
kwargs={"url": "https://gitlab.com"},
interval=10),
],
period=0.1, # scheduler run each 0.1 (second)
)
remoulade.set_scheduler(scheduler)
for i in range(i, n + 1):
state = {
"i": i,
"x2": x2,
"x1": x1,
}
x2, x1 = x1, x2 + x1
fib.logger.info("fib(%d): %d", i, x1)
time.sleep(0.1)
remove_state(n)
fib.logger.info("Done!")
except Shutdown:
dump_state(n, state)
broker.declare_actor(fib)
def main():
parser = argparse.ArgumentParser(description="Calculates fib(n)")
parser.add_argument("n", type=int, help="must be a positive number")
args = parser.parse_args()
fib.send(args.n)
return 0
if __name__ == "__main__":
sys.exit(main())
matches = 0
session = get_session()
with closing(session.get(url, timeout=(3.05, 5), stream=True)) as response:
if not response.headers.get("content-type",
"").startswith("text/html"):
logger.warning("Skipping URL %r since it's not HTML.", url)
return
for match in anchor_re.finditer(response.content):
anchor = match.group(1).decode("utf-8")
if anchor.startswith("http://") or anchor.startswith("https://"):
crawl.send(anchor)
matches += 1
logger.info("Done crawling %r. Found %d anchors.", url, matches)
broker.declare_actor(crawl)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("url", type=str, help="a URL to crawl")
args = parser.parse_args()
crawl.send(args.url)
return 0
if __name__ == "__main__":
sys.exit(main())
@remoulade.actor(time_limit=86400000)
def long_running(duration):
deadline = time.monotonic() + duration
while time.monotonic() < deadline:
long_running.logger.info("%d seconds remaining.",
deadline - time.monotonic())
n = random.randint(1000, 1000000)
long_running.logger.info("Computing fib(%d).", n)
fib(n)
long_running.logger.info("Computed fib(%d).", n)
sleep = random.randint(1, 30)
long_running.logger.info("Sleeping for %d seconds...", sleep)
time.sleep(sleep)
broker.declare_actor(long_running)
def main():
for _ in range(1000):
long_running.send(random.randint(3600, 14400))
time.sleep(random.randint(60, 3600))
if __name__ == "__main__":
sys.exit(main())
from remoulade.results import Results
from remoulade.results.backends import RedisBackend
result_backend = RedisBackend(encoder=PickleEncoder())
broker = RabbitmqBroker()
broker.add_middleware(Results(backend=result_backend))
remoulade.set_broker(broker)
@remoulade.actor(store_results=True)
def sleep_then_add(t, x, y):
time.sleep(t)
return x + y
broker.declare_actor(sleep_then_add)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("count", type=int, help="the number of messages to enqueue")
args = parser.parse_args()
messages = []
for _ in range(args.count):
messages.append(sleep_then_add.send(random.randint(1, 5), random.randint(0, 1000), random.randint(0, 1000)))
for message in messages:
print(message.result.get(block=True))
