Rihanna

https://hexdocs.pm/rihanna/2.3.1/
Admin
Rihanna is a concurrent job queueing and scheduling system designed for Elixir applications,...
Tokens:3,305
Snippets:36
Trust Score:9
Update:4 months ago
Show doc for...
Tokens:
Raw
### Schedule Job (Module, Args) in X Minutes

Source: https://hexdocs.pm/rihanna

Schedules a job implemented with the Rihanna.Job behavior to run in a specified duration, such as 5 minutes. The job module must implement perform/1.

```elixir
Rihanna.schedule(MyApp.MyJob, [arg1, arg2], in: :timer.minutes(5))
```

--------------------------------

### Schedule Job (Module, Args) at DateTime

Source: https://hexdocs.pm/rihanna

Schedules a job implemented with the Rihanna.Job behavior to run at a specific DateTime. The job module must implement perform/1.

```elixir
due_at = DateTime.from_naive!(~N[2018-07-01 12:00:00], "Etc/UTC")
Rihanna.schedule(MyApp.MyJob, [arg1, arg2], at: due_at)
```

--------------------------------

### enqueue(job, opts)

Source: https://hexdocs.pm/rihanna

Enqueues a job for execution. The job can be specified as a module and arguments, or just a module.

```APIDOC
## enqueue(job, opts)

### Description
Enqueues a job specified as a module and one argument. It is expected that the module implements the `Rihanna.Job` behaviour and defines a function `Rihanna.Job.perform/1`. The argument may be anything. See `Rihanna.Job` for more on how to implement your own jobs.

### Function Signatures
`enqueue({module(), atom(), list()}, keyword()) :: {:ok, Rihanna.Job.t()}`
`enqueue({module(), any()}, keyword()) :: {:ok, Rihanna.Job.t()}`
`enqueue(module(), any()) :: {:ok, Rihanna.Job.t()}`

### Example

Enqueue job for later execution and return immediately:
```
Rihanna.enqueue(MyApp.MyJob, [arg1, arg2])
```
```

--------------------------------

### schedule(mod, arg, schedule_options)

Source: https://hexdocs.pm/rihanna

Schedules a job defined by a module and a single argument to run later. The specified module must implement the `Rihanna.Job` behavior and define a `perform/1` function. The argument can be of any type.

```APIDOC
## schedule(mod, arg, schedule_options)

### Description
Schedule a job specified as a module and one argument to run later. It is expected that the module implements the `Rihanna.Job` behaviour and defines a function `Rihanna.Job.perform/1`. The argument may be anything.

### Parameters
#### Path Parameters
- **mod** (module()) - Required - The module containing the job implementation.
- **arg** (any()) - Required - The argument to be passed to the job's perform function.
- **schedule_options** (schedule_options()) - Required - Options for scheduling, such as `at:` or `in:`.

### Request Example
```elixir
due_at = DateTime.from_naive!(~N[2018-07-01 12:00:00], "Etc/UTC")
Rihanna.schedule(MyApp.MyJob, [arg1, arg2], at: due_at)

Rihanna.schedule(MyApp.MyJob, [arg1, arg2], in: :timer.minutes(5))
```

### Response
#### Success Response (200)
- **:ok** (Rihanna.Job.t()) - A tuple containing :ok and the job identifier.
```

--------------------------------

### schedule(mod, arg, schedule_options)

Source: https://hexdocs.pm/rihanna

Schedules a job, specified as a module and a single argument, for deferred execution at a later time.

```APIDOC
## schedule(mod, arg, schedule_options)

### Description
Schedule a job specified as a module and one argument to run later.

### Parameters
#### Path Parameters
- **mod** (module) - Required - The module containing the job function.
- **arg** (any) - Required - The argument for the job function.
- **schedule_options** (schedule_options) - Required - Options specifying when the job should run.
```

--------------------------------

### Schedule Job (Mod-Fun-Args Tuple) in X Minutes

Source: https://hexdocs.pm/rihanna

Schedules a job defined by a module, function, and arguments tuple to run in a specified duration, such as 5 minutes.

```elixir
Rihanna.schedule({IO, :puts, ["Umbrella-ella-ella"]}, in: :timer.minutes(5))
```

--------------------------------

### enqueue(term, opts)

Source: https://hexdocs.pm/rihanna

Enqueues a job specified as a module and a single argument for processing.

```APIDOC
## enqueue(term, opts)

### Description
Enqueues a job specified as a module and one argument.

### Parameters
#### Path Parameters
- **term** (any) - Required - The job to enqueue, typically a module and its argument.
- **opts** (list) - Optional - Additional options for enqueuing.
```

--------------------------------

### Enqueue Job with Arguments

Source: https://hexdocs.pm/rihanna

Enqueues a job for later execution. The job is specified by its module and arguments, and the function returns immediately.

```elixir
enqueue({module(), atom(), list()}, keyword()) :: {:ok, Rihanna.Job.t()}
```

```elixir
enqueue({module(), any()}, keyword()) :: {:ok, Rihanna.Job.t()}
```

```elixir
enqueue(module(), any()) :: {:ok, Rihanna.Job.t()}
```

```elixir
# Enqueue job for later execution and return immediately
Rihanna.enqueue(MyApp.MyJob, [arg1, arg2])
```

--------------------------------

### Schedule Job (Mod-Fun-Args Tuple) at DateTime

Source: https://hexdocs.pm/rihanna

Schedules a job defined by a module, function, and arguments tuple to run at a specific DateTime. Ensure the DateTime is correctly formatted.

```elixir
due_at = ~N[2018-07-01 12:00:00] |> DateTime.from_naive!("Etc/UTC")
Rihanna.schedule({IO, :puts, ["Umbrella-ella-ella"]}, at: due_at)
```

--------------------------------

### schedule(term, schedule_options)

Source: https://hexdocs.pm/rihanna

Schedules a job, specified as a mod-fun-args tuple, for deferred execution at a later time.

```APIDOC
## schedule(term, schedule_options)

### Description
Schedule a job specified as a simple mod-fun-args tuple to run later.

### Parameters
#### Path Parameters
- **term** (tuple) - Required - The job to schedule, in mod-fun-args format.
- **schedule_options** (schedule_options) - Required - Options specifying when the job should run.
```

--------------------------------

### Rihanna Job Schedule Options List Type

Source: https://hexdocs.pm/rihanna

Represents a list of schedule options for a job.

```elixir
schedule_options() :: [schedule_option()]
```

--------------------------------

### schedule(term, schedule_options)

Source: https://hexdocs.pm/rihanna

Schedules a job specified as a simple module-function-arguments tuple to run at a later time. The job can be scheduled using a specific `DateTime` or relative to the current time using `in:` option.

```APIDOC
## schedule({module(), atom(), list()}, schedule_options())

### Description
Schedule a job specified as a simple mod-fun-args tuple to run later.

### Parameters
#### Path Parameters
- **term** ({module(), atom(), list()}) - Required - A tuple representing the job to schedule in the format {Module, atom, list_of_arguments}.
- **schedule_options** (keyword()) - Required - Options for scheduling, such as `at:` or `in:`.

### Request Example
```elixir
due_at = ~N[2018-07-01 12:00:00] |> DateTime.from_naive!("Etc/UTC")
Rihanna.schedule({IO, :puts, ["Umbrella-ella-ella"]}, at: due_at)

Rihanna.schedule({IO, :puts, ["Umbrella-ella-ella"]}, in: :timer.minutes(5))
```

### Response
#### Success Response (200)
- **:ok** (Rihanna.Job.t()) - A tuple containing :ok and the job identifier.
```

--------------------------------

### retry(job_id, opts \\ [])

Source: https://hexdocs.pm/rihanna

Retries a job by its ID. The ID can be provided as either an integer or a string. This function is effective only for jobs that have failed; it will have no effect on jobs that have not yet run or are currently in progress.

```APIDOC
## retry(job_id, opts \\ [])

### Description
Retries a job by ID. ID can be passed as either integer or string. This only works if the job has failed.

### Parameters
#### Path Parameters
- **job_id** (String.t() | integer()) - Required - The ID of the job to retry.
- **opts** (keyword()) - Optional - Additional options for retrying.

### Response
#### Success Response (200)
- **:ok** (:retried) - Indicates the job was successfully retried.
#### Error Response
- **:error** (:job_not_found) - Indicates the job with the specified ID was not found.
```

--------------------------------

### delete_by(args, opts)

Source: https://hexdocs.pm/rihanna

Deletes all jobs that match the provided arguments, which can include module or function specifications.

```APIDOC
## delete_by(args, opts)

### Description
Deletes all jobs that match either or both module and function criteria.

### Function Signature
`delete_by(list(), keyword()) :: {:ok, :deleted} | {:error, :job_not_found}`

### Example

Deletes all jobs for `Module.function`:
```
Rihanna.delete_by(mod: Module, fun: :function)
```

Deletes all jobs for the module `Module`:
```
Rihanna.delete_by(mod: Module)
```

Deletes all jobs for the function `function`:
```
Rihanna.delete_by(fun: :function)
```
```

--------------------------------

### Rihanna Job Schedule Options Type

Source: https://hexdocs.pm/rihanna

Defines the possible options for scheduling a job, including specific times, delays, priorities, and database connections.

```elixir
schedule_option() ::
  {:at, DateTime.t()} 
  | {:in, pos_integer()} 
  | {:due_at, DateTime.t()} 
  | {:priority, pos_integer()} 
  | {:producer_postgres_connection, {module(), any()}}
```

--------------------------------

### retry(job_id, opts)

Source: https://hexdocs.pm/rihanna

Retries a previously failed or deleted job using its unique identifier. The job ID can be provided as either an integer or a string.

```APIDOC
## retry(job_id, opts)

### Description
Retries a job by ID. ID can be passed as either integer or string.

### Parameters
#### Path Parameters
- **job_id** (integer | string) - Required - The ID of the job to retry.
- **opts** (list) - Optional - Additional options for retrying.
```

--------------------------------

### delete_by(args, opts)

Source: https://hexdocs.pm/rihanna

Deletes all jobs that match either the module or function specified in the arguments.

```APIDOC
## delete_by(args, opts)

### Description
Deletes all jobs that match either/or module or function.

### Parameters
#### Path Parameters
- **args** (any) - Required - Criteria for deletion (e.g., module or function).
- **opts** (list) - Optional - Additional options for deletion.
```

--------------------------------

### delete(job_id, opts)

Source: https://hexdocs.pm/rihanna

Deletes a job by its ID. The ID can be provided as either an integer or a string.

```APIDOC
## delete(job_id, opts)

### Description
Deletes a job by ID. ID can be passed as either integer or string.

### Function Signature
`delete(String.t() | integer(), keyword()) :: {:ok, Rihanna.Job.t()} | {:error, :job_not_found}`
```

--------------------------------

### Retry Job by ID (String)

Source: https://hexdocs.pm/rihanna

Retries a job using its ID provided as a string. This function only affects jobs that have failed.

```elixir
retry(String.t(), keyword()) :: {:ok, :retried} | {:error, :job_not_found}
```

--------------------------------

### Retry Job by ID (Integer)

Source: https://hexdocs.pm/rihanna

Retries a job using its ID provided as an integer. This function only affects jobs that have failed.

```elixir
retry(integer(), keyword()) :: {:ok, :retried} | {:error, :job_not_found}
```

--------------------------------

### delete(job_id, opts)

Source: https://hexdocs.pm/rihanna

Deletes a job from the queue by its unique identifier. The job ID can be provided as either an integer or a string.

```APIDOC
## delete(job_id, opts)

### Description
Deletes a job by ID. ID can be passed as either integer or string.

### Parameters
#### Path Parameters
- **job_id** (integer | string) - Required - The ID of the job to delete.
- **opts** (list) - Optional - Additional options for deletion.
```

--------------------------------

### Delete Jobs by Module or Function

Source: https://hexdocs.pm/rihanna

Deletes jobs based on their associated module or function. This is useful for clearing related tasks.

```elixir
delete_by(list(), keyword()) :: {:ok, :deleted} | {:error, :job_not_found}
```

```elixir
Rihanna.delete_by(mod: Module, fun: :function)
```

```elixir
Rihanna.delete_by(mod: Module)
```

```elixir
Rihanna.delete_by(fun: :function)
```

--------------------------------

### Delete Job by ID Function

Source: https://hexdocs.pm/rihanna

Deletes a job using its unique identifier. The ID can be provided as either an integer or a string.

```elixir
delete(String.t() | integer(), keyword()) ::
  {:ok, Rihanna.Job.t()} | {:error, :job_not_found}
```
Tokens:
Raw