text:
[![GitHub license](https://img.shields.io/badge/license-apache2-blue.svg)](https://github.com/bbonnin/pulsar-express/blob/master/LICENSE)
[![GitHub version](https://img.shields.io/badge/dynamic/json.svg?color=green&label=version&query=version&url=https://raw.githubusercontent.com/bbonnin/pulsar-express/master/package.json)](https://github.com/bbonnin/pulsar-express/releases)

# pulsar-express

> Simple Web Interface for Apache Pulsar

![Pulsar logo](docs/pulsar.png)

## Install

There are several ways to use `pulsar-express`:
* By cloning the projet and running it locally (see `Development` section)
* By running a docker image: `docker run -it -p 3000:3000 bbonnin/pulsar-express`
  * You can set a connection url in the command: `docker run -it -p 3000:3000 -e PE_CONNECTION_URL=http://host.docker.internal:8080 bbonnin/pulsar-express`
  * Important: the calls to the Pulsar API are done on server side (i.e. from the container), so your Pulsar must be reachable from the container (do not use localhost :)). A solution: you can add `--network=host` to the command line (but, it's only working on Linux...)
* By installing it using `npm`
```bash
# Install it globally
$ npm install pulsar-express -g

# Start it
$ pulsar-express

        ╭────────────────╮
        │ PULSAR EXPRESS │
        ╰────────────────╯

        => Open http://localhost:3000

# Start it on a specific port
$ PORT=8000 pulsar-express

        ╭────────────────╮
        │ PULSAR EXPRESS │
        ╰────────────────╯

        => Open http://localhost:8000

```

If you want to configure connections (to be available to all users), you can:
* Create a json file with the connections:
```json
[
  { "name": "test cluster",
     "url": "http://test-cluster-host:8080" },

  { "name": "integration cluster",
     "url": "http://int-cluster-host:8080",
     "token": "<YOUR_TOKEN>" },

  { "name": "prod cluster",
     "url": "http://prod-cluster-host:8080",
     "fctWorkerUrl": "http://prod-fct-worker-cluster-host:6750",
     "token": "<YOUR_TOKEN>" },
]
```
* and set the env variable `PE_CONFIG_FILE`
```bash
export PE_CONFIG_FILE=/path/to/my/config.json
```
* Or you can also set a connection URL
```bash
export PE_CONNECTION_URL=http://pulsar-host:8080

# Without a name, the url will be used (hostname:port),
# Or you can set a name:
export PE_CONNECTION_NAME=my-pulsar

# A token if needed:
export PE_CONNECTION_TOKEN=<YOUR_TOKEN>
```

From there, you can connect with your browser to the url above !

![Pulsar express home](docs/home.png)

## Quick start

> If you haven't defined a connection, the first step is to go the `Connections` page and add a new connection. These connections are stored on client side (localstorage of your browser)

![Pulsar express connections](docs/connections.png)

### Overview

In this page, you can see some basic informations about your clusters.

![Pulsar express overview](docs/overview.png)

### Clusters

![Pulsar express clusters](docs/clusters.png)

### Tenants

![Pulsar express clusters](docs/tenants.png)

### Namespaces

![Pulsar express clusters](docs/namespaces.png)

### Topics

![Pulsar express topics](docs/topics.png)

![Pulsar express topics](docs/topic.png)

### Functions

![Pulsar express functions](docs/functions.png)

![Pulsar express function](docs/function.png)

## Security

To enable security in Pulsar, please read [https://pulsar.apache.org/docs/en/security-overview/](the docs).

For example, with token authentication with a secret key (more details, [https://pulsar.apache.org/docs/en/security-token-admin/](here)),

* Create a secret key:
```bash
pulsar tokens create-secret-key --output my-secret.key --base64
```

* Create a token for pulsar-express
```bash
pulsar tokens create --secret-key file:///path/to/my-secret.key \
            --subject pulsar-express
```

* Configure your broker (`conf/broker.conf` or `conf/standalone.conf`)
```bash
authenticationEnabled=true
authorizationEnabled=true
authenticationProviders=org.apache.pulsar.broker.authentication.AuthenticationProviderToken
superUserRoles=pulsar-express
tokenSecretKey=file:///path/to/my-secret.key
```

* Configure your workers (`conf/functions_worker.yml`)
```bash
clientAuthenticationPlugin: "org.apache.pulsar.client.impl.auth.AuthenticationToken"
clientAuthenticationParameters: "token:<YOUR_TOKEN>"

authenticationEnabled: true
authorizationEnabled: true
authenticationProviders:
  - org.apache.pulsar.broker.authentication.AuthenticationProviderToken
properties:
  tokenSecretKey: "file:///path/to/my-secret.key"
superUserRoles:
  - pulsar-express
```

* Test a call to the API (you should get a 401 response without the token):
```bash
curl localhost:8080/admin/v2/clusters  -H "Authorization: Bearer <YOUR_TOKEN>"

["standalone"]
```

## Development

This app has been developed with [Nuxt.js](https://nuxtjs.org).

``` bash
# install dependencies
$ npm install

# serve with hot reload at localhost:3000
$ npm run dev

# build for production and launch server
$ npm run build
$ npm start
```

For detailed explanation on how things work, checkout [Nuxt.js docs](https://nuxtjs.org).

For Docker:
* Build: `npm run docker-build`
* Test locally: `npm run docker-run`
* Tag: `docker tag pulsar-express USER/pulsar-express:VERSION`
* Publish: `docker push USER/pulsar-express:VERSION`

## How-to

* Change the base URL (work in progress, it's a quick fix):
  * Set the base URL you want to use: `export PE_BASE_URL=pulsar-express`
  * Rebuild the docker image: `npm run docker-build` (or `docker build --build-arg BASE_URL=${PE_BASE_URL} -t pulsar-express .`)
  * Run the image, for example: `docker run -it -p 3000:3000 -e PE_CONNECTION_URL=http://host.docker.internal:8080 -e PE_BASE_URL=${PE_BASE_URL} pulsar-express`

  > When running the image, do not forget to set PE_BASE_URL !

## To do

> A lot of things of course :), but the main step is to change the architecture and add a backend instead of making the queries from the browser. This backend could provide api, cache, better management of configuration, ...

* General:
  * [ ] test with the latest version (2020/06/08 => v2.5.2)
* Clusters
  * [x] connections to clusters (configured on server and client side)
  * [x] list clusters
  * [ ] get config of a cluster
  * [ ] manage clusters
* Tenants
  * [x] list the tenants
  * [x] create a tenant (simple way)
  * [x] delete a tenant
  * [ ] get config of a tenant
  * [ ] update config of a tenant
* Namespaces
  * [x] list the namespace
  * [ ] create a namespace
  * [ ] delete a namespace
  * [x] get config of a namespace
  * [ ] update config of a namespace
  * [ ] any other features (persistence policies, messages ttl, backlog quotas...)
* Topics
  * [x] list the topics
  * [x] create a topic
  * [ ] create a partitioned topic
  * [x] delete a topic
  * [x] get stats about a topic
  * [x] get subscriptions of a topic
  * [ ] manage subscriptions
  * [ ] manage partitioned topics
  * [ ] any other features (reset cursor, expire messages, ...)
    * [x] peek messages
* Functions
  * [x] list the functions
  * [ ] get config of a function
  * [x] start/stop instances
  * [ ] manage functions (deploy ? delete ? create ? simple python function for test purpose ?)
* Connections
  * [x] update a connection
* [ ] Manage base URL (with env var)
  * Images (assets vs static)
  * Pages (Config router) -> dynamic ? seems to be NO !
  * API (config Axios)

## Misc

Icons: https://icones8.fr/

## Credit

Pulsar Express is a single only tool which is using daily to manage and maintain a Pulsar cluster of over ten nodes in production environment at https://doopage.com.

repository: bbonnin/pulsar-express

repo_name: bbonnin/pulsar-express


text:
---
layout: page
title: Contact
permalink: /contact/
---

Recruiters please note:  If you are here to request a mailing list posting about a job:

The best way to present jobs is to come to our meeting and participate in our "Have-a-Job/Need-a-Job" segment.  This segment allows any person with an opening or any person seeking a job to stand up in front of the entire group and talk for a few minutes.  See the trilug.org for info about the next meeting.

If you can not attend a meeting, the next-best way is to join the main discussion mailing list and post your job to the list.  Please put the word "JOB" in the subject.  Note: we monitor posts to the list.  Recruiters who post irrelevant job postings or who "spam" the list with a lot of posts will be "moderated" or removed from the mailing list.

If you have something that you would like to bring to the attention of the Steering Committee, fill in the form below.  This is not the place to post job openings.  This form sends an email directly to the five steering committee members.

----

Email: contact email

Mailing Address

TriLUG

P.O. Box 37874

Raleigh, NC 27627

license: MIT

repository: scottlinux/trilug

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: scottlinux/trilug


text:
Worqr

Atomic Redis Queue

A distributed, reliable, atomic, work queueing system that only requires redis as the backend.

Is **Worqr** for me?

- You need to distribute a task workload
- You are already using Redis in your application
- You don't want to run a queue service or pay per-transaction fees

If the answer to all three of those questions is yes, then **Worqr** is for you.

repository: droplit/worqr

gha_language: TypeScript

gha_license_id: MIT

repo_name: droplit/worqr


text:
# AngularJS Cordova generator

[![Build Status] (https://travis-ci.org/keshavos/generator-angularjs-cordova.svg?branch=master)] (https://travis-ci.org/keshavos/generator-angularjs-cordova)

##Overview

Combining the best features from the already available yeoman generators such as [yeoman-angular framework](https://github.com/yeoman/generator-angular) and the [angularjs-cordova](http://angularjs-cordova.org/) generators.

The purpose of this generator is to allow the user to create and extend an AngularJS-phonegap application

* Uses a [Vertical Module](http://angularjs-cordova.org/docs.html#angularjs-modules) approach to extending AngularJs apps The pros and cons of the [angular-seed](https://github.com/angular/angular-seed) project and hence a modular approach to extending AngularJs apps is mentioned [here](http://angularjs-cordova.org/docs.html#angularjs-modules).

## Getting Started
Before you begin make sure you have the [yo scaffolding tool](http://yeoman.io/generators.html) installed(As it is part of the Yeoman tool set you might have installed it before). To globally install *yo* you will need to use npm:

```
$ npm install -g yo
```

**Note:** Your user might not have the permissions to install package globally, so use a super user or **sudo**.

Once ready, you should be able to use this with

```
npm install -g generator-angularjs-cordova
```

### Yeoman Generators for AngularJS

* [angularjs-cordova](#application-generator)
* [angularjs-cordova:angular-config](#angularjs-config-sub-generator)
* [angularjs-cordova:angular-controller](#angularjs-controller-sub-generator)
* [angularjs-cordova:angular-directive](#angularjs-directive-sub-generator)
* [angularjs-cordova:angular-filter](#angularjs-filter-sub-generator)
* [angularjs-cordova:angular-module](#angularjs-module-sub-generator)
* [angularjs-cordova:angular-route](#angularjs-route-sub-generator)
* [angularjs-cordova:angular-service](#angularjs-service-sub-generator)
* [angularjs-cordova:angular-test](#angularjs-test-sub-generator)
* [angularjs-cordova:angular-view](#angularjs-view-sub-generator)

### Proposed Yeoman Generators for Cordova
~~* [angularjs-cordova:cordova-name](#cordova-app-name)~~

~~* [angularjs-cordova:cordova-id](#cordova-app-id)~~

~~* [angularjs-cordova:cordova-platform-add](#cordova-platform-installer)~~

~~* [angularjs-cordova:cordova-platform-remove](#cordova-platform-uninstaller)~~

~~* [angularjs-cordova:cordova-platform-build](#cordova-platform-build)~~

~~* [angularjs-cordova:cordova-platform-](#cordova-platform-build)~~

~~* [angularjs-cordova:cordova-plugin-list](#cordova-plugin-list)~~

~~* [angularjs-cordova:cordova-plugin-add](#cordova-plugin-installer)~~

~~* [angularjs-cordova:cordova-plugin-remove](#cordova-platform-uninstaller)~~

It might be a good idea to use the native cordova commands directly within the project root as this encourages correct usage of cordova commands in other projects that do not use this framework

All the available cordova commands can be listed by typing the following in the command line:

`cordova help`

As per **cordova v3.4.0**, these are the available options

Synopsis

    cordova command [options]

Global Commands

    create <PATH> [ID [NAME [CONFIG]]] ....... creates a Cordova project in the specified PATH, with
                                               ID reverse-domain-style package name - used in <widget id>
                                               NAME is a human readable field
                                               CONFIG is a json string whose key/values will be included
                                               in [PATH]/.cordova/config.json
                  [--copy-from|src=<PATH>] ... use custom www assets instead of the stock Cordova hello-world.
                  [--link-to=<PATH>] ......... symlink to custom www assets without creating a copy.

    help ..................................... shows this syntax summary

    info ..................................... print out useful information helpful for submitting bug
                                               reports and getting help.  Creates an info.txt file at the
                                               base of your project

Project-Level Commands

    platform(s) [{add|remove|rm} <PLATFORM>] .. add or remove a specified PLATFORM, OR
                [{list|ls}] ................... list all installed and available platforms
                [{update|up} <PLATFORM>] ...... update the version of Cordova used for a specific
                                                PLATFORM; use after updating the CLI.
                [check] ....................... list platforms which can be updated by `platform update`

    plugin add <SPEC1> [<SPEC2> ...] .......... SPEC can be a plugin ID, a local path, or a git URL.
               [--searchpath <directory>] ..... When looking up plugins by ID, look in this directory and
                                                each of its subdirectories for the plugin before hitting the registry.
                                                Multiple search paths can be used by either specifying the flag multiple
                                                times, or by separating paths with a delimiter (: on 'nix, ; on Windows).

    plugin(s) rm <plugin_id1> [<plugin_id2>] .. remove a plugin with the given IDs.

              [{ls|list}] ..................... list all currently installed plugins
              [search <keyword1 keyword2...>] . search the plugin registry for plugins matching the keywords

    prepare [PLATFORM..] ...................... copies files for specified platforms, or all platforms,
                                                so that the project is ready to build in each SDK

    compile [PLATFORM..] ...................... builds the app for specified platforms, or all platforms

    build [PLATFORM...] ....................... shortcut for prepare, then compile

    run [--debug|--release]
        [--device|--emulator|--target=FOO]
        [PLATFORM] ............................ deploys app on specified platform devices / emulators

    emulate [PLATFORM...] ..................... alias for "run --emulator"

    serve [PORT] .............................. runs a local web server for www/ assets. Port defaults to 8000.
                                                Access projects at: http://HOST_IP:PORT/PLATFORM/www

Command-line Flags/Options

    -v, --version ............................. prints out this utility's version
    -d, --verbose ............................. debug mode produces verbose log output for all activity,
                                                including output of sub-commands cordova invokes

## Application Generator

The application generator will help you create a fresh copy of a AngularJs application in your working Cordova folder.

```
$ yo angularjs-cordova
```

The generator will ask you a few questions about your new application and will generate it for you.

Now, the application generator does a great job scaffolding a whole application, but daily work requires us to repeat a lot of structured code. For this purpose we provided you with some sub-generators to help you speed up your development.

## AngularJS Module Sub-Generator

Another redundant task is creating a new AngularJS module structure. For this purpose you can use the Angular module sub-generator. It will create the proper folder structure for you and the module initialization file. Creating a new AngularJS module is simple:

```
$ yo angularjs-cordova:angular-module <module-name>
```

The sub-generator will ask for more information about your folder structure, and will create the empty new AngularJS module. Now, to fill that new module with your business logic, we provided you with several AngularJS entities sub-generators.

## AngularJS Route Sub-Generator

To construct your module you will often need to create a new route. The AngularJS route sub-generator will help you create a view, controller and a proper route in your module **routes.js** file. If it can't find the module routes file the sub-generator will create one for you. Creating a new AngularJS route will involve executing this command:

```
$ yo angularjs-cordova:angular-route <route-name>
```

The sub-generator will ask for more information about your controller, view and routing URL, and will generate the appropriate files for you.

## AngularJS Controller Sub-Generator

The AngularJS Controller sub-generator will create a new AngularJS controller in the specified module's **controllers** folder. To create a new AngularJS controller run *yo* again by using this command:

```
$ yo angularjs-cordova:angular-controller <controller-name>
```

The sub-generator will ask you for the module name under which you would like to create your new controller, and will create a new AngularJS controller file in that module **controllers** folder and a test file in the **tests** folder.

**Don't forget!** This time you pass the controller name as an argument.

## AngularJS View Sub-Generator

Once you have your controller file ready, you may want to add a view that makes use of this controller. The AngularJS view sub-generator will create a new AngularJS view in thr specified module's **views** folder, and will allow you to add a route definition for it. To create a new AngularJS view you will need to execute this command:

```
$ yo angularjs-cordova:angular-view <view-name>
```

The sub-generator will ask you for the module name under which you would like to create your new view, and some additional routing information. It will then create a new view file in that module's **views** folder and add a routing state to the module **routes.js** file. If it can't find the module routes file it will create one for you.

## AngularJS Service Sub-Generator

The AngularJS service sub-generator will create a new AngularJS service in the specified module's **services** folder. To create a new AngularJS service you will need to execute this command:

```
$ yo angularjs-cordova:angular-service <service-name>
```

The sub-generator will ask you for the module name under which you would like to create your new service, and will create a new AngularJS service file in that module's **services** folder.

## AngularJS Directive Sub-Generator

The AngularJS directive sub-generator will create a new AngularJS directive in the specified module's **directives** folder. Creating a new AngularJS directive should already look familiar:

```
$ yo angularjs-cordova:angular-directive <directive-name>
```

The sub-generator will ask you for the module name under which you would like to create your new directive, and will create a new AngularJS directive file in that module's **directives** folder.

## AngularJS Filter Sub-Generator

The AngularJS filter sub-generator will create a new AngularJS filter in a specified module's **filters** folder. To create a new AngularJS filter you need to call yo again:

```
$ yo angularjs-cordova:angular-filter <filter-name>
```

The sub-generator will ask you for the module name under which you would like to create your new filter, and will create a new AngularJS filter file in that module **filters** folder.

## AngularJS Config Sub-Generator

The AngularJS config sub-generator will create a new AngularJS config section in a specified module's **config** folder. To create a new AngularJS config file just call yo:

```
$ yo angularjs-cordova:angular-config <config-name>
```

The sub-generator will ask you for the module name under which you would like to create your new config, and will create a new AngularJS config file in that module's **config** folder.

## AngularJS Test Sub-Generator

Your MEAN application comes pre-bundled with the Karma test runner and Jasmine testing framework. To test your AngularJS controllers you'll need to create a test file, which Karma will later use to run the tests. For this purpose we provided you with the AngularJS test sub-generator. Creating a new AngularJS test is effortless, just execute this command:

```
$ yo angularjs-cordova:angular-test <controller-name>
```

This will create a test file for your controller, and if the sub-generator doesn't find the specified controller file, it will create one for you.

**Don't forget!** You're suppose to pass the controller name as an argument.

###
## License

MIT

repository: manviny/generator-angularjs-cordova

repo_name: manviny/generator-angularjs-cordova