adap Alternatives - Elixir Queue

Popularity

3.0

Declining

Activity

0.0

Stable

Stars 14

Watchers 2

Forks 2

Last Commit

Monthly Downloads: 2

Programming language: Elixir

License: MIT License

Tags: Queue

adap alternatives and similar packages

Based on the "Queue" category

exq

9.7 6.9 adap VS exq

Job processing library for Elixir
oban

9.6 9.0 adap VS oban

Robust asynchronous job processor powered by Elixir and modern PostgreSQL.
verk

9.3 1.8 adap VS verk

Verk is a job processing system backed by Redis. It uses the same job definition of Sidekiq/Resque.
amqp

9.3 7.4 adap VS amqp

Simple Elixir wrapper for the Erlang RabbitMQ client, based on Langohr.
kafka_ex

9.2 7.8 adap VS kafka_ex

Kafka client library for Elixir.
honeydew

9.2 5.0 adap VS honeydew

Honeydew is a worker pool library for Elixir.
que

9.1 6.5 adap VS que

Simple Background Job Processing with Mnesia.
Rihanna

8.7 6.4 adap VS Rihanna

High performance postgres-backed job queue for Elixir.
enm

8.7 0.0 adap VS enm

enm is an Erlang port driver that wraps the nanomsg C library.
toniq

8.6 0.0 adap VS toniq

Simple and reliable background job library for Elixir.
ecto_job

8.2 5.2 adap VS ecto_job

A transactional job queue built with Ecto, PostgreSQL and GenStage.
task_bunny

8.0 0.0 adap VS task_bunny

background processing application written in Elixir and uses RabbitMQ as a messaging backend.
elixir_nsq

7.6 2.7 adap VS elixir_nsq

NSQ client library for Elixir.
pqueue

7.5 1.3 adap VS pqueue

Erlang Priority Queue Implementation.
hulaaki

7.5 0.0 adap VS hulaaki

An MQTT 3.1.1 client library written in Elixir.
opq

7.4 0.0 adap VS opq

A simple, in-memory queue with worker pooling and rate limiting in Elixir.
gen_rmq

7.2 6.9 adap VS gen_rmq

Set of behaviours meant to be used to create RabbitMQ consumers and publishers.
Ravenx

6.8 0.0 adap VS Ravenx

Notification dispatch library for Elixir applications
conduit

6.8 0.6 adap VS conduit

A framework for working with message queues, with adapters for SQS and AMQP, and plugs for reusable messaging patterns.
Cafex

6.3 0.0 adap VS Cafex

Cafex is a pure Elixir implementation of Kafka client
exrabbit

6.1 0.0 adap VS exrabbit

RabbitMQ bindings and DSL for Elixir.
mqs

5.3 0.0 adap VS mqs

RabbitMQ client library, routing keys, RPC over MQ and other stuff.
RBMQ

5.2 2.6 adap VS RBMQ

Simple API for spawning RabbitMQ Producers and Consumers.
work_queue

4.9 2.4 adap VS work_queue

Simple implementation of the hungry-consumer model in Elixir.
elixir_talk

4.3 0.0 adap VS elixir_talk

An Elixir client for beanstalkd.
kafka_consumer

4.1 0.0 adap VS kafka_consumer

Consumer for Kafka using kafka_ex.
cspex

3.6 0.0 adap VS cspex

Simple, OTP compliant, Elixir implementation of CSP channels.
exdisque

3.0 0.6 adap VS exdisque

Elixir client for Disque, an in-memory, distributed job queue.
queuex

2.4 0.0 adap VS queuex

Priority Queue with multiple backends.
heapq

1.7 0.0 adap VS heapq

A Heap-based Priority Queue Implementation in Elixir.
dbus

1.3 0.0 adap VS dbus

A dumb message bus for sharing data between microservices decoupled using Redis.
ActiveJorb

0.6 0.0 adap VS ActiveJorb

An Elixir-based ActiveJob Compatible Queueing Library
stream_weaver

- - adap VS stream_weaver

Library for working with streams.

Do you think we are missing an alternative of adap or a related project?

Add another 'Queue' Package

Popular Comparisons

README

ADAP

Awesome (big) Data Augmentation Pipeline

Create a data stream across your information systems to query, augment and transform data according to Elixir matching rules.

See the generated documentation for more detailed explanations.

The principle is:

to make each element hop from node to node in order to be processed using the locally present data.
that any node at any time can emit new elements in the pipeline stream
to construct processing units on each node on demand. They can die at any time to free memory or because of an exception: they will be restarted on demand.
to pull elements by chunk in order to allow long processing time without the need of any back-pressure mechanism.

Let's see a processing pipe example:

the input is a product stream : stream of {:product,%{field1: value1, field2: value2}}
user@jsonserver1 contains a json file "/color.json" containing a COLOR mapping
user@jsonserver2 contains a json file "/size.json" containing a SIZE mapping
you want to map product color and size according to these mappings
you want to add a field "deleted" when the mapped color is red

Adap.Piper.defpipe ColorPipe, [{ColorPipe.Rules,[]}]
defmodule JSONMap do
  use Adap.Unit.Simple, ttl: 1_000
  def init(mapping), do: 
    {:ok,File.read!("/#{mapping}.json") |> JSON.decode!}
  def node("color"), do: :"user@jsonserver1"
  def node("size"), do: :"user@jsonserver2"
end
defmodule ColorPipe.Rules do
  use Adap.Piper, for: :product
  defrule map_color(%{color: color}=prod,_) do
    {JSONMap,"color"},color_map->
      %{prod| color: color_map[color]}
  end
  defrule map_size(%{size: size}=prod,_) do
    {JSONMap,"size"},size_map->
      %{prod| size: size_map[size]}
  end
  defrule red_is_deleted(%{color: "red"}=prod,_) do
    Dict.put(prod,:deleted,true)
  end
end
result = [
  {:product,%{gender: "male", category: "ipad"}},
  {:product,%{color: "carmine", category: "shirt"}},
  {:product,%{color: "periwinkle", size: "xxl"}}
] |> Adap.Stream.new(ColorPipe) |> Enum.to_list
assert result == [
  {:product,%{gender: "male", category: "ipad"}},
  {:product,%{color: "red", category: "shirt", deleted: true}},
  {:product,%{color: "blue", size: "large"}}
]