### Starting and Listing SMPP Connectors

Source: https://docs.jasminsms.com/en/latest/installation/index

Instructions for starting a previously added SMPP connector and listing all active connectors.

```APIDOC
## Starting and Listing SMPP Connectors

### Description
Start a specific SMPP connector and list all configured connectors with their status.

### Method
Interactive CLI commands

### Endpoint
`jcli console`

### Parameters

#### CLI Commands
- `smppccm -1 <connector_id>`: Start the specified connector.
- `smppccm --list`: List all connectors and their status.

### Request Example
#### Starting Connector
```
jcli : smppccm -1 DEMO_CONNECTOR
Successfully started connector id:DEMO_CONNECTOR
```

#### Listing Connectors
```
jcli : smppccm --list
#Connector id                        Service Session          Starts Stops
#DEMO_CONNECTOR                      started BOUND_TRX        1      0
Total connectors: 1
```

### Response
#### Success Response (Start Connector)
- `Successfully started connector id:<connector_id>`

#### Success Response (List Connectors)
- A table listing connector ID, service status, session status, starts, and stops.
```

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

### Start and List SMPP Connectors using jCli

Source: https://docs.jasminsms.com/en/latest/installation/index

This snippet shows how to start a previously configured SMPP connector and list all active connectors in the Jasmin SMS gateway via the jCli console. Starting a connector makes it available for message routing. Listing connectors helps in verifying their status.

```shell
smppccm -1 DEMO_CONNECTOR
smppccm --list
```

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

### Install and Start Jasmin RESTful API Service

Source: https://docs.jasminsms.com/en/latest/apis/rest/index

This command installs and starts the Jasmin RESTful API as a system service. Ensure you have the necessary sudo privileges. This is the recommended method for managing the API.

```bash
sudo systemctl start jasmin-restapi

```

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

### Install Jasmin SMS Gateway using PyPI

Source: https://docs.jasminsms.com/en/latest/installation/index

Installs Jasmin SMS Gateway using pip. This method is for systems not covered by DEB or RPM packages. It includes steps for creating a system user, necessary directories, and then installing the package. Finally, it enables and starts the jasmind service.

```bash
sudo useradd jasmin

sudo mkdir -p /etc/jasmin/resource
sudo mkdir -p /etc/jasmin/store
sudo mkdir -p /var/log/jasmin

sudo pip install jasmin

sudo systemctl enable jasmind
sudo systemctl start jasmind
```

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

### Install Jasmin SMS Gateway on Ubuntu

Source: https://docs.jasminsms.com/en/latest/installation/index

Installs Jasmin SMS Gateway on Ubuntu using DEB packages from Packagecloud. Ensures RabbitMQ and Redis are installed and running. Enables and starts the jasmind service.

```bash
curl -s https://setup.jasminsms.com/deb | sudo bash
sudo apt-get install jasmin-sms-gateway

sudo systemctl enable jasmind
sudo systemctl start jasmind
```

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

### Install pip

Source: https://docs.jasminsms.com/en/latest/installation/index

Installs the latest version of the pip module for Python using curl. This is a prerequisite for installing Jasmin via PyPI on some systems.

```bash
curl https://bootstrap.pypa.io/get-pip.py | python
```

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

### List Docker Images

Source: https://docs.jasminsms.com/en/latest/installation/index

This command lists all Docker images currently available on the system. It is useful for verifying that the 'jasmin', 'redis', and 'rabbitmq' images have been successfully pulled and are ready for use.

```bash
# docker images

```

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

### Start Jasmin SMS Services with Docker Compose

Source: https://docs.jasminsms.com/en/latest/installation/index

This command initiates and runs the services defined in the 'docker-compose.yml' file in detached mode. It ensures that the Jasmin SMS, Redis, and RabbitMQ containers are started and continue to run in the background.

```bash
docker-compose up -d

```

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

### Install Jasmin SMS Gateway on RHEL/CentOS

Source: https://docs.jasminsms.com/en/latest/installation/index

Installs Jasmin SMS Gateway on RHEL and CentOS using RPM packages from Packagecloud. Requires EPEL repository. Ensures RabbitMQ and Redis are installed and running. Enables and starts the jasmind service.

```bash
curl -s https://setup.jasminsms.com/rpm | sudo bash
sudo yum install epel-release
sudo yum install jasmin-sms-gateway

sudo systemctl enable jasmind
sudo systemctl start jasmind
```

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

### User Management

Source: https://docs.jasminsms.com/en/latest/installation/index

Create user groups and user accounts for accessing the Jasmin HTTP API.

```APIDOC
## User Management

### Description
Create user groups and individual user accounts required for authenticating with the Jasmin HTTP API.

### Method
Interactive CLI commands

### Endpoint
`jcli console`

### Parameters

#### CLI Commands (Group Creation)
- `group -a`: Add a new group.
- `gid <group_id>`: Set the group ID (e.g., `foogroup`).
- `ok`: Save the group configuration.

#### CLI Commands (User Creation)
- `user -a`: Add a new user.
- `username <username>`: Set the username (e.g., `foo`).
- `password <password>`: Set the user's password (e.g., `bar`).
- `gid <group_id>`: Assign the user to a group (e.g., `foogroup`).
- `uid <user_id>`: Set the user ID (e.g., `foo`).
- `ok`: Save the user configuration.

### Request Example
#### Group Creation
```
jcli : group -a
    Adding a new Group: (ok: save, ko: exit)
    > gid foogroup
    > ok
    Successfully added Group [foogroup]
```

#### User Creation
```
jcli : user -a
Adding a new User: (ok: save, ko: exit)
> username foo
> password bar
> gid foogroup
> uid foo
> ok
Successfully added User [foo] to Group [foogroup]
```

### Response
#### Success Response (Group Creation)
- `Successfully added Group [<group_id>]`

#### Success Response (User Creation)
- `Successfully added User [<username>] to Group [<group_id>]`
```

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

### Start SMPP Client Connector

Source: https://docs.jasminsms.com/en/latest/management/jcli/modules

Starts an SMPP Client connector and attempts to establish a connection. This command requires the connector's CID as an argument.

```bash
smppccm -1 <cid>
```

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

### Install Jasmin SMS Gateway

Source: https://docs.jasminsms.com/en/latest/faq/users

Installs the Jasmin SMS Gateway package using pip. The `--pre` flag is necessary to install beta versions.

```bash
$ sudo pip install python-jasmin
[sudo] password for richard:
Downloading/unpacking jasmin
    Could not find a version that satisfies the requirement jasmin (from versions: 0.6b1, 0.6b10, 0.6b11, 0.6b12, 0.6b13, 0.6b14, 0.6b2, 0.6b3, 0.6b4, 0.6b5, 0.6b6, 0.6b7, 0.6b8, 0.6b9)
Cleaning up...
No distributions matching the version for jasmin
Storing debug log for failure in /home/richard/.pip/pip.log

```

```bash
$ sudo pip install --pre python-jasmin
...
```

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

### Configuring Simple Route

Source: https://docs.jasminsms.com/en/latest/installation/index

Configure a default route to direct all outgoing SMS messages through a specific SMPP connector.

```APIDOC
## Configuring Simple Route

### Description
Set up a default route to send all SMS messages via the configured SMPP connector.

### Method
Interactive CLI commands

### Endpoint
`jcli console`

### Parameters

#### CLI Commands
- `mtrouter -a`: Add a new MT (Mobile Terminated) route.
- `type defaultroute`: Specify the route type as default.
- `connector <connector_smpp_identifier>`: Assign the SMPP connector to this route (e.g., `smppc(DEMO_CONNECTOR)`).
- `rate <rate_value>`: Set the routing rate (e.g., `0.00` for no rate limiting).
- `ok`: Save the route configuration.

### Request Example
```
jcli : mtrouter -a
Adding a new MT Route: (ok: save, ko: exit)
> type defaultroute
jasmin.routing.Routes.DefaultRoute arguments:
connector
> connector smppc(DEMO_CONNECTOR)
> rate 0.00
> ok
Successfully added MTRoute [DefaultRoute] with order:0
```

### Response
#### Success Response
- `Successfully added MTRoute [DefaultRoute] with order:<order_number>`
```

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

### Command to Spin Up Docker Services

Source: https://docs.jasminsms.com/en/latest/installation/index

This command initiates the Docker containers defined in the 'docker-compose.grafana.yml' file. It brings up all services, including Jasmin, Prometheus, and Grafana, in detached mode.

```bash
docker-compose -f docker-compose.grafana.yml up -d
```

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

### List Running Docker Containers

Source: https://docs.jasminsms.com/en/latest/installation/index

This command displays all currently running Docker containers. It helps confirm that the 'jasmin', 'redis', and 'rabbitmq' services are active and accessible, showing their status, ports, and names.

```bash
# docker ps

```

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

### Manually Launch Jasmin RESTful API

Source: https://docs.jasminsms.com/en/latest/apis/rest/index

These commands manually launch the Jasmin RESTful API without using systemd services. This method is useful if systemd services are not installed or for development purposes. It involves starting a Celery worker and a Twistd web server.

```bash
celery -A jasmin.protocols.rest.tasks worker -l INFO -c 4 --autoscale=10,3
twistd -n --pidfile=/tmp/twistd-web-restapi.pid web --wsgi=jasmin.protocols.rest.api

```

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

### Send SMS with Jasmin HTTP API (Python, PHP, Ruby)

Source: https://docs.jasminsms.com/en/latest/programming-examples/index

Demonstrates how to send SMS messages using the Jasmin HTTP API. It covers basic sending with minimal parameters and sending with a defined originating address. Assumes Jasmin is installed and accessible via HTTP on localhost:1401. Requires valid username and password.

```python
# Python example
# http://jasminsms.com
import urllib.request, urllib.error, urllib.parse
import urllib.request, urllib.parse, urllib.error

baseParams = {'username':'foo', 'password':'bar', 'to':'+336222172', 'content':'Hello'}

# Send an SMS-MT with minimal parameters
urllib.request.urlopen("http://127.0.0.1:1401/send?%s" % urllib.parse.urlencode(baseParams)).read()

# Send an SMS-MT with defined originating address
baseParams['from'] = 'Jasmin GW'
urllib.request.urlopen("http://127.0.0.1:1401/send?%s" % urllib.parse.urlencode(baseParams)).read()

```

```php
<?php
// Sending simple message using PHP
// http://jasminsms.com

$baseurl = 'http://127.0.0.1:1401/send'

$params = '?username=foo'
$params.= '&password=bar'
$params.= '&to='.urlencode('+336222172')
$params.= '&content='.urlencode('Hello world !')

$response = file_get_contents($baseurl.$params);
?>

```

```ruby
# Sending simple message using Ruby
# http://jasminsms.com

require 'net/http'

uri = URI('http://127.0.0.1:1401/send')
params = { :username => 'foo', :password => 'bar',
           :to => '+336222172', :content => 'Hello world' }
uri.query = URI.encode_www_form(params)

response = Net::HTTP.get_response(uri)


```

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

### POST /send (Send SMS)

Source: https://docs.jasminsms.com/en/latest/programming-examples/index

This endpoint allows you to send SMS messages. The request includes parameters for the recipient's phone number and the message content.  Examples in Python, PHP, and Ruby are provided.

```APIDOC
## POST /send

### Description
Sends an SMS message to a specified recipient.  Requires authentication and the message content.

### Method
POST

### Endpoint
http://127.0.0.1:1401/send

### Parameters
#### Query Parameters
- **username** (string) - Required - Your Jasmin username.
- **password** (string) - Required - Your Jasmin password.
- **to** (string) - Required - The recipient's phone number.
- **content** (string) - Required - The message content.
- **from** (string) - Optional - The sender's address.

### Request Example
```
# Python Example
import urllib.request, urllib.parse

params = {'username':'foo', 'password':'bar', 'to':'+336222172', 'content':'Hello'}

url = "http://127.0.0.1:1401/send?" + urllib.parse.urlencode(params)

response = urllib.request.urlopen(url).read()
```

### Response
#### Success Response (200)
- (string) - Response from the server.  The response format is not specified in the provided documentation.

#### Response Example
```
# Python Example
response = urllib.request.urlopen("http://127.0.0.1:1401/send?%s" % urllib.parse.urlencode(baseParams)).read()
```
```

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

### Send Simple SMS (PHP)

Source: https://docs.jasminsms.com/en/latest/apis/http/index

Example demonstrating how to send a simple SMS message using PHP. It constructs the URL with parameters and uses `file_get_contents` to send the request.

```php
<?php
// Sending simple message using PHP
// http://jasminsms.com

$baseurl = 'http://127.0.0.1:1401/send'

$params = '?username=foo'
$params.= '&password=bar'
$params.= '&to='.urlencode('+336222172')
$params.= '&content='.urlencode('Hello world !')

$response = file_get_contents($baseurl.$params);
?>

```

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

### Send Simple SMS (Ruby)

Source: https://docs.jasminsms.com/en/latest/apis/http/index

Illustrates sending a basic SMS message using Ruby's Net::HTTP library. It shows how to construct the URI with query parameters and make a GET request.

```ruby
# Sending simple message using Ruby
# http://jasminsms.com

require 'net/http'
 uri = URI('http://127.0.0.1:1401/send')
params = { :username => 'foo', :password => 'bar',
           :to => '+336222172', :content => 'Hello world' }
uri.query = URI.encode_www_form(params)

response = Net::HTTP.get_response(uri)


```

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

### Send SMS via HTTP API

Source: https://docs.jasminsms.com/en/latest/installation/index

Send outbound SMS messages using Jasmin's HTTP API by making a GET request to the specified endpoint.

```APIDOC
## Send SMS via HTTP API

### Description
Send outbound (MT) SMS messages programmatically using the Jasmin HTTP API. Requires valid user credentials.

### Method
GET

### Endpoint
`http://<jasmin_host>:<api_port>/send`

### Parameters

#### Query Parameters
- **username** (string) - Required - The username for API authentication.
- **password** (string) - Required - The password for API authentication.
- **to** (string) - Required - The recipient's phone number.
- **content** (string) - Required - The message content.

### Request Example
```
http://127.0.0.1:1401/send?username=foo&password=bar&to=06222172&content=hello
```

### Response
#### Success Response (200)
- The response will be a JSON string containing a message ID upon successful acceptance for delivery.

#### Response Example
```json
"9ab2867c-96ce-4405-b890-8d35d52c8e01"
```

### Error Handling
- Refer to Jasmin's HTTP API documentation for detailed information on error responses and troubleshooting message delivery.
```

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

### JCli Help Command Listing

Source: https://docs.jasminsms.com/en/latest/management/jcli/index

Displays a list of all available commands and their brief descriptions within the Jasmin JCli. Typing 'help' provides an overview of functionalities.

```Shell
jcli : help
```

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

### Docker Compose for Jasmin, Prometheus, and Grafana

Source: https://docs.jasminsms.com/en/latest/installation/index

This docker-compose file orchestrates the deployment of Jasmin, RabbitMQ, Redis, Prometheus, and Grafana. It defines services, their images, ports, volumes, health checks, and resource limits, facilitating a complete monitoring setup.

```yaml
version: "3.10"

services:
  redis:
    image: redis:alpine
    restart: unless-stopped
    healthcheck:
      test: redis-cli ping | grep PONG
    deploy:
      resources:
        limits:
          cpus: '0.2'
          memory: 128M
    security_opt:
      - no-new-privileges:true

  rabbit-mq:
    image: rabbitmq:3.10-management-alpine
    restart: unless-stopped
    healthcheck:
      test: rabbitmq-diagnostics -q ping
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 525M
    security_opt:
      - no-new-privileges:true

  prometheus:
    image: prom/prometheus:latest
    restart: unless-stopped
    ports:
      - '9090:9090'
    volumes:
      - prometheus.yml:/etc/prometheus/prometheus.yml
      - monitoring_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
      - '--web.enable-lifecycle'
    depends_on:
      - jasmin
    deploy:
      resources:
        limits:
          cpus: '0.2'
          memory: 128M
    security_opt:
      - no-new-privileges:true

  grafana:
    image: grafana/grafana
    restart: unless-stopped
    ports:
      - 3000:3000
    environment:
      GF_INSTALL_PLUGINS: "grafana-clock-panel,grafana-simple-json-datasource"
    volumes:
      # These mount points should be copied from https://github.com/jookies/jasmin/tree/master/docker/grafana
      - ./provisioning/datasources:/etc/grafana/provisioning/datasources:ro
      - ./provisioning/dashboards:/etc/grafana/provisioning/dashboards:ro
      - ./dashboards:/opt/grafana-dashboards:ro

      - monitoring_data:/var/lib/grafana
    depends_on:
      - prometheus
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 256M
    security_opt:
      - no-new-privileges:true

  jasmin:
    image: jookies/jasmin:latest
    restart: unless-stopped
    ports:
      - 2775:2775
      - 8990:8990
      - 1401:1401
    depends_on:
      redis:
        condition: service_healthy
      rabbit-mq:
        condition: service_healthy
    environment:
      REDIS_CLIENT_HOST: redis
      AMQP_BROKER_HOST: rabbit-mq
    deploy:
      resources:
        limits:
          cpus: '1'
          memory: 256M
    security_opt:
      - no-new-privileges:true

volumes:
  monitoring_data: { }

```

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

### Configure SMPP Server User Credentials with jcli

Source: https://docs.jasminsms.com/en/latest/management/jcli/modules

This code example shows how to add a new user with specific SMPP server credentials using the Jasmin CLI (jcli). It includes authorizing binding to the SMPP server and setting the maximum number of concurrent bindings (max_bindings).

```bash
jcli : user -a
Adding a new User: (ok: save, ko: exit)
> username foo
> password bar
> gid marketing
> uid foo
> smpps_cred authorization bind yes
> smpps_cred quota max_bindings 2
> ok
Successfully added User [foo] to Group [marketing]
```

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

### Send SMS via Jasmin HTTP API

Source: https://docs.jasminsms.com/en/latest/installation/index

This snippet shows how to send an outbound SMS message using Jasmin's HTTP API. It involves making an HTTP GET request to the '/send' endpoint with parameters for username, password, recipient phone number ('to'), and message content. A successful response indicates the message has been accepted for delivery.

```http
http://127.0.0.1:1401/send?username=foo&password=bar&to=06222172&content=hello
```

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

### JCli Interactive Command Listing

Source: https://docs.jasminsms.com/en/latest/management/jcli/index

Demonstrates how to discover available commands in the Jasmin JCli by using the TABULATION key. This provides a quick way to see the commands you can execute.

```Shell
jcli : [TABULATION]
```

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

### Start Jasmin Interceptor Service

Source: https://docs.jasminsms.com/en/latest/interception/index

Command to start the Jasmin interceptord system service. This service runs separately from the main Jasmin daemon and handles message interception logic.

```bash
sudo systemctl start jasmin-interceptord
```

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

### Send Simple SMS (Python)

Source: https://docs.jasminsms.com/en/latest/apis/http/index

Example of sending a simple SMS message using Python's urllib library. It demonstrates setting up basic parameters like username, password, recipient, and content.

```python
# Python example
# http://jasminsms.com
import urllib.request, urllib.error, urllib.parse
import urllib.request, urllib.parse, urllib.error

baseParams = {'username':'foo', 'password':'bar', 'to':'+336222172', 'content':'Hello'}

# Send an SMS-MT with minimal parameters
urllib.request.urlopen("http://127.0.0.1:1401/send?%s" % urllib.parse.urlencode(baseParams)).read()

# Send an SMS-MT with defined originating address
baseParams['from'] = 'Jasmin GW'
urllib.request.urlopen("http://127.0.0.1:1401/send?%s" % urllib.parse.urlencode(baseParams)).read()

```

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

### Load Configuration Profile from Disk (jcli)

Source: https://docs.jasminsms.com/en/latest/management/jcli/index

The 'load' command restores a Jasmin SMS configuration profile from disk. It can load the default profile or a specified profile, replacing the current runtime configuration. Dependencies include the Jasmin CLI tool ('jcli').

```bash
jcli : load
mtrouter configuration loaded (profile:jcli-prod)
smppcc configuration loaded (profile:jcli-prod)
group configuration loaded (profile:jcli-prod)
user configuration loaded (profile:jcli-prod)
httpcc configuration loaded (profile:jcli-prod)
mointerceptor configuration loaded (profile:jcli-prod)
filter configuration loaded (profile:jcli-prod)
mtinterceptor configuration loaded (profile:jcli-prod)
morouter configuration loaded (profile:jcli-prod)
```

```bash
jcli : load -p testing
```

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

### Adding SMPP Connection

Source: https://docs.jasminsms.com/en/latest/installation/index

This section details how to add a new SMPP connection to the Jasmin SMS Gateway using the jCli console.

```APIDOC
## Adding SMPP Connection

### Description
Connect to the jCli console and add a new SMPP connector with specified parameters.

### Method
Interactive CLI commands

### Endpoint
`telnet 127.0.0.1 8990`

### Parameters

#### CLI Commands
- `smppccm -a`: Add a new SMPP connector.
- `cid <connector_id>`: Set the connector ID.
- `host <ip_address>`: Set the SMPP server host.
- `port <port_number>`: Set the SMPP server port.
- `username <username>`: Set the SMPP username.
- `password <password>`: Set the SMPP password.
- `submit_throughput <rate>`: Set the submission throughput rate.
- `ok`: Save the configuration.

### Request Example
```
Authentication required.

Username: jcliadmin
Password: 
Welcome to Jasmin console
Type help or ? to list commands.

Session ref: 2
jcli : smppccm -a
> cid DEMO_CONNECTOR
> host 172.16.10.67
> port 2775
> username smppclient1
> password password
> submit_throughput 110
> ok
Successfully added connector [DEMO_CONNECTOR]
```

### Response
#### Success Response
- `Successfully added connector [DEMO_CONNECTOR]`
```

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

### Accessing Grafana UI

Source: https://docs.jasminsms.com/en/latest/installation/index

This URL is used to access the Grafana web interface after the services have been deployed. The default username and password for Grafana are 'admin' and 'admin', respectively.

```bash
http://127.0.0.1:3000
```

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

### Jasmin Configuration for DLR Thrower

Source: https://docs.jasminsms.com/en/latest/apis/http/index

Details the configuration parameters for the DLRThrower service found in the `jasmin.cfg` file.

```APIDOC
## jasmin.cfg / dlr-thrower Configuration

### Description
The `jasmin.cfg` file, located in `/etc/jasmin`, contains a section `[dlr-thrower]` which holds configuration elements for the DLRThrower service.

### Configuration Section
```ini
[dlr-thrower]
http_timeout       = 30
retry_delay        = 30
max_retries        = 3
log_level          = INFO
log_file           = /var/log/jasmin/dlr-thrower.log
log_format         = %(asctime)s %(levelname)-8s %(process)d %(message)s
log_date_format    = %Y-%m-%d %H:%M:%S
```

### Configuration Elements
#### General
- **http_timeout** (Integer) - Default: `30` - Sets the socket timeout in seconds for outgoing client HTTP connections.
- **retry_delay** (Integer) - Default: `30` - Defines the delay in seconds for retrying a failed DLR throw within the queuing system.
- **max_retries** (Integer) - Default: `3` - Defines the maximum number of retries to perform for failing DLR throws.

#### Logging
- **log_level** (String) - Default: `INFO` - Sets the logging level (e.g., `INFO`, `DEBUG`, `ERROR`).
- **log_file** (String) - Default: `/var/log/jasmin/dlr-thrower.log` - Specifies the path to the log file.
- **log_format** (String) - Default: `%%(asctime)s %%(levelname)-8s %%(process)d %%(message)s` - Configures the format of log messages.
- **log_date_format** (String) - Default: `%Y-%m-%d %H:%M:%S` - Configures the date format for log entries.

### Notes
- The `log_*` parameters follow Python's logging module configuration conventions.
```

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

### Prometheus Configuration for Jasmin Monitoring

Source: https://docs.jasminsms.com/en/latest/installation/index

This Prometheus configuration defines scrape jobs for Jasmin and RabbitMQ. It sets global scrape intervals and timeouts, and specifies targets for the Jasmin '/metrics' API and RabbitMQ metrics.

```yaml
global:
  scrape_interval: 30s
  scrape_timeout: 10s

scrape_configs:
  - job_name: jasmin
    static_configs:
      - targets:
          - 'jasmin:1401'
  - job_name: rabbitmq
    static_configs:
      - targets:
          - 'rabbit-mq:15692'

```

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

### HTTP API Configuration (jasmin.cfg)

Source: https://docs.jasminsms.com/en/latest/apis/http/index

Configuration options for the HTTP API within the jasmin.cfg file.

```APIDOC
## HTTP API Configuration (jasmin.cfg)

### Description
This section details the configuration parameters for the HTTP API found in the `jasmin.cfg` file under the `[http-api]` section.

### Method
N/A (Configuration File)

### Endpoint
N/A (Configuration File)

### Parameters
#### Configuration Options
- **bind** (string) - Default: `0.0.0.0` - The IP address the HTTP API listener will bind to. `0.0.0.0` binds to all interfaces.
- **port** (integer) - Default: `1401` - The TCP port for the HTTP API listener.
- **long_content_max_parts** (integer) - Default: `5` - The maximum number of individual SMS-MT messages to split long content into.
- **long_content_split** (string) - Default: `udh` - The method for splitting long content. Possible values are `sar` (using SAR options) or `udh` (using User Data Header).
- **access_log** (string) - Default: `/var/log/jasmin/http-access.log` - Path to the file for logging HTTP requests and errors.
- **log_level** (string) - Default: `INFO` - The logging level (e.g., `INFO`, `DEBUG`, `ERROR`).
- **log_file** (string) - Default: `/var/log/jasmin/http-api.log` - Path to the file for HTTP API specific logs.
- **log_format** (string) - Default: `%(asctime)s %(levelname)-8s %(process)d %(message)s` - The format for log messages.
- **log_date_format** (string) - Default: `%Y-%m-%d %H:%M:%S` - The date format for log messages.

### Request Example
```ini
[http-api]
bind = 0.0.0.0
port = 1401
long_content_max_parts = 5
long_content_split = udh
access_log = /var/log/jasmin/http-access.log
log_level = INFO
log_file = /var/log/jasmin/http-api.log
log_format = %(asctime)s %(levelname)-8s %(process)d %(message)s
log_date_format = %Y-%m-%d %H:%M:%S
```

### Response
N/A (Configuration File)
```

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

### Display SMPP Client Connector Details

Source: https://docs.jasminsms.com/en/latest/management/jcli/modules

Displays all parameters for a specified SMPP Client connector, including those set to their default values. This is useful for verifying configuration after creation or updates.

```bash
jcli : smppccm -s Demo
ripf 0
con_fail_delay 10
dlr_expiry 86400
coding 0
submit_throughput 1
elink_interval 10
bind_to 30
port 2775
con_fail_retry yes
password password
src_addr None
bind_npi 1
addr_range None
dst_ton 1
res_to 60
def_msg_id 0
priority 0
con_loss_retry yes
username smppclient
dst_npi 1
validity None
requeue_delay 120
host 127.0.0.1
src_npi 1
trx_to 300
logfile /var/log/jasmin/default-Demo.log
systype
cid Demo
loglevel 20
bind transmitter
proto_id None
con_loss_delay 10
bind_ton 0
pdu_red_to 10
src_ton 2
```

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

### Add SMPP Connection using jCli

Source: https://docs.jasminsms.com/en/latest/installation/index

This snippet demonstrates how to add a new SMPP connection to the Jasmin SMS gateway using the jCli console. It requires specifying connection details such as host, port, username, password, and throughput. The 'cid' parameter is used as a unique identifier for the connector.

```shell
telnet 127.0.0.1 8990
jcliadmin
jclipwd
smppccm -a
cid DEMO_CONNECTOR
host 172.16.10.67
port 2775
username smppclient1
password password
submit_throughput 110
ok
```

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

### JCli Add User Interactive Session

Source: https://docs.jasminsms.com/en/latest/management/jcli/index

Illustrates the interactive process of adding a new user in Jasmin JCli using the 'user -a' command. Parameters like username, password, uid, and gid are entered sequentially.

```Shell
jcli : user -a
Adding a new User: (ok: save, ko: exit)
> username foo
> password bar
> uid u1
> gid g1
> ok
Successfully added User [u1] to Group [g1]
```

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

### Configure Default MT Router using jCli

Source: https://docs.jasminsms.com/en/latest/installation/index

This snippet illustrates how to configure a default route for outbound SMS (MT) messages using the jCli console. It specifies the connector to be used for sending messages and sets a rate limit. This ensures that all outgoing SMS are directed through the defined SMPP connector.

```shell
mtrouter -a
type defaultroute
connector smppc(DEMO_CONNECTOR)
rate 0.00
ok
```