product_os_command_control/

registry.rs

use core::str::FromStr;
use std::prelude::v1::*;

use std::collections::BTreeMap;
use std::sync::Arc;
use serde::{ Deserialize, Serialize };

use product_os_capabilities::{ Features, Services };
use product_os_security::{AsByteVector, DHKeyStore, RandomGenerator, certificates::Certificates, RandomGeneratorTemplate, RNG, StdRng, SeedableRng};
use product_os_store::ProductOSKeyValueStore;

use chrono::{DateTime, Utc };
use parking_lot::Mutex;
use product_os_request::Uri;

#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
enum Protocol {
    HTTP,
    HTTPS,
    UNIX
}


#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Node {
    id: uuid::Uuid,
    machine_id: String,

    uri: String,
    process_id: u32,

    certificate: Vec<u8>,

    capabilities: Vec<String>,
    services: Services,
    features: Features,

    failures: u8,
    created_at: DateTime<Utc>,
    updated_at: DateTime<Utc>
}

impl AsByteVector for &Node {
    fn as_byte_vector(&self) -> Vec<u8> {
        let mut bytes = vec!();

        bytes.extend_from_slice(self.id.clone().as_bytes());
        bytes.extend_from_slice(self.machine_id.clone().as_bytes());
        bytes.extend_from_slice(self.uri.to_string().as_bytes());
        bytes.extend_from_slice(self.certificate.clone().as_slice());
        bytes.extend_from_slice(&[self.failures.clone().clone()]);
        bytes.extend_from_slice(self.created_at.to_string().as_bytes());
        bytes.extend_from_slice(self.updated_at.to_string().as_bytes());
        // bytes.extend_from_slice();

        bytes
    }
}


impl Node {
    pub fn default(config: &product_os_configuration::Configuration, certificates: Certificates) -> Self {
        let machine_uid = match machine_uid::get() {
            Ok(uid) => uid,
            Err(e) => panic!("Unable to generate machine id: {}", e)
        };

        Self {
            id: uuid::Uuid::new_v4(),
            uri: Uri::from_str(config.url_address().as_str()).unwrap().to_string(),
            process_id: std::process::id(),
            machine_id: product_os_security::create_string_hash(machine_uid.as_str()),
            certificate: certificates.certificates.first().unwrap().to_owned(),
            capabilities: Vec::new(),
            services: Services::new(),
            features: Features::new(),
            failures: 0,
            created_at: Utc::now(),
            updated_at: Utc::now()
        }
    }

    pub fn get_identifier(&self) -> String {
        self.id.to_string()
    }

    pub fn get_protocol(&self) -> String {
        let uri = Uri::from_str(self.uri.as_str()).unwrap();
        match uri.scheme() {
            None => String::new(),
            Some(s) => s.to_string()
        }
    }

    pub fn get_address(&self) -> Uri {
        Uri::from_str(self.uri.as_str()).unwrap()
    }

    pub fn get_process_id(&self) -> u32 {
        self.process_id
    }

    pub fn get_certificate(&self) -> Vec<u8> {
        self.certificate.to_owned()
    }

    pub fn get_failures(&self) -> u8 {
        self.failures
    }

    pub fn get_features(&self) -> &Features {
        &self.features
    }

    pub fn get_services(&self) -> &Services {
        &self.services
    }

    pub fn match_node(&self, selector: &str, search_value: &str) -> bool {
        let mut matched = true;

        let search = selector;
        let value = search_value;

        match search {
            "feature" => {
                match self.features.get(value) {
                    Some(_) => (),
                    None => matched = false
                }
            },
            "capability" => {
                for capability in &self.capabilities {
                    if capability != value { matched = false; }
                }
            },
            "service.kind" => {
                match self.services.find(value.to_string()) {
                    Some(_) => (),
                    None => matched = false
                }
            },
            "service.enabled" => {
                for (_, service) in self.services.list() {
                    if service.enabled.to_string() != value { matched = false; }
                }
            },
            "service.active" => {
                for (_, service) in self.services.list() {
                    if service.active.to_string() != value { matched = false; }
                }
            },
            _ => ()
        }

        matched
    }

    pub fn match_node_query(&self, query: &BTreeMap<&str, &str>) -> bool {
        let mut matched = true;

        for (s, v) in query {
            let search = s;
            let value = v;

            if !self.match_node(search, value) { matched = false }
        }

        matched
    }

    pub fn get_created_at(&self) -> DateTime<Utc> {
        self.created_at
    }

    pub fn get_last_updated_at(&self) -> DateTime<Utc> {
        self.updated_at
    }
}




pub struct Registry {
    me: Node,
    nodes: BTreeMap<String, Node>,
    key_store: DHKeyStore,

    store: Arc<ProductOSKeyValueStore>,

    max_failures: u8
}

impl Registry {
    pub fn new(config: &product_os_configuration::Configuration, key_value_store: Arc<ProductOSKeyValueStore>, certificates: Certificates) -> Self {
        let me = Node::default(config, certificates);

        let registry = Registry {
            me,
            nodes: BTreeMap::new(),
            key_store: DHKeyStore::new(),
            store: key_value_store,
            max_failures: config.get_cc_max_failures(),
        };

        registry
    }

    pub fn get_max_failures(&self) -> u8 {
        self.max_failures.to_owned()
    }

    async fn upsert_me_remote(&mut self) {
        self.store.group_set(self.me.id.to_string().as_str(), serde_json::to_string(&self.me).unwrap().as_str()).unwrap_or_default()
    }

    async fn upsert_node_remote(&mut self, node: &Node) {
        tracing::info!("Upserting node: {:?}", node);
        self.store.group_set(node.id.to_string().as_str(), serde_json::to_string(node).unwrap().as_str()).unwrap_or_default();
    }

    async fn remove_node_remote(&mut self, identifier: &str) {
        self.store.group_remove(identifier).unwrap_or_default()
    }

    async fn get_node_remote(&mut self, id: &str) -> Option<Node> {
        match self.store.group_get(id) {
            Ok(v) => {
                let mut node: Node = serde_json::from_str(v.as_str()).unwrap();
                node.features.setup_router();
                Some(node)
            },
            Err(_) => None
        }
    }

    pub async fn check_me_remote(&mut self) -> Option<&Node> {
        let id = self.me.id.to_string();

        match self.get_node_remote(id.as_str()).await {
            Some(node) => {
                if node.id != self.me.id {
                    // Kill or try to do a revival of node - lost for some reason
                    None
                }
                else {
                    Some(&self.me)
                }
            },
            None => { None }
        }
    }

    /****** All other features query the local registry first ********/

    pub fn get_me(&self) -> &Node {
        &self.me
    }

    pub async fn update_me(&mut self) {
        self.upsert_me_remote().await;
    }

    pub fn update_me_status(&mut self, success: bool) -> bool {
        let failures = if success { 0 } else { self.me.failures.to_owned() + 1 };

        if failures < self.max_failures {
            self.me.failures = failures;
            self.me.updated_at = Utc::now();

            true
        }
        else {
            false
        }
    }

    pub async fn update_pulse_status(&mut self, id: &str, success: bool) -> bool {
        match self.get_node_remote(id).await {
            Some(mut node) => {
                let failures = if success { 0 } else { node.failures + 1 };

                if failures < self.max_failures {
                    node.failures = failures;
                    node.updated_at = Utc::now();

                    self.upsert_node_remote(&node).await;
                    self.nodes.insert(node.id.to_string(), node);

                    true
                }
                else {
                    tracing::info!("Removing node due to failures count {}: {:?}", failures, node);
                    self.remove_node(node.id.to_string().as_str()).await;

                    false
                }
            },
            None => false
        }
    }

    pub fn upsert_node_local(&mut self, identifier: String, mut node: Node) {
        node.features.setup_router();
        self.nodes.insert(identifier, node);
    }

    pub fn find_nodes(&self, query: BTreeMap<&str, &str>, exclude_me: bool) -> BTreeMap<String, &Node> {
        let mut result = BTreeMap::new();
        let me = self.me.id.to_string();

        for (id, node) in &self.nodes {
            if (!exclude_me || (exclude_me && !me.eq(id))) && node.match_node_query(&query) { result.insert(id.to_string(), node); }
        }

        result
    }

    pub fn get_node(&self, id: &str) -> Option<&Node> {
        self.nodes.get(id)
    }

    pub fn get_nodes(&self, skip: u8, exclude_me: bool) -> BTreeMap<String, &Node> {
        let mut nodes = BTreeMap::new();
        let mut count = 0;
        let me = self.me.id.to_string();

        for (id, node) in self.nodes.iter() {
            if (!exclude_me || (exclude_me && !me.eq(id))) && count >= skip { nodes.insert(id.to_string(), node); }
            count = count + 1;
        }

        nodes
    }

    pub fn get_nodes_certificates(&self, skip: u8, exclude_me: bool) -> Vec<Vec<u8>> {
        let mut certificates = Vec::new();
        let mut count = 0;
        let me = self.me.id.to_string();

        for (id, node) in self.nodes.iter() {
            if (!exclude_me || (exclude_me && !me.eq(id))) && count >= skip { certificates.push(node.get_certificate()) }
            count = count + 1;
        }

        certificates
    }

    pub fn get_nodes_raw_certificates(&self, skip: u8, exclude_me: bool) -> Vec<Vec<u8>> {
        let mut certificates = Vec::new();
        let mut count = 0;
        let me = self.me.id.to_string();

        for (id, node) in self.nodes.iter() {
            if (!exclude_me || (exclude_me && !me.eq(id))) && count >= skip { certificates.push(node.get_certificate()) }
            count = count + 1;
        }

        certificates
    }

    pub fn get_nodes_endpoints(&self, skip: u8, exclude_me: bool) -> BTreeMap<String, (Uri, Option<Vec<u8>>)> {
        let mut node_map = BTreeMap::new();
        let mut count = 0;
        let me = self.me.id.to_string();

        for (id, node) in self.nodes.iter() {
            if (!exclude_me || (exclude_me && !me.eq(id))) && count >= skip {
                let address = node.get_address();
                let key = self.get_key(id);

                node_map.insert(id.to_string(), (address, key));
            }

            count = count + 1;
        }

        node_map
    }

    pub async fn remove_node(&mut self, identifier: &str) -> Option<Node> {
        match self.nodes.remove(identifier) {
            Some(node) => {
                self.remove_node_remote(node.id.to_string().as_str()).await;
                Some(node)
            },
            None => None
        }
    }

    pub fn pick_node(&self, query: BTreeMap<&str, &str>) -> Option<&Node> {
        let eligible_nodes = Vec::from_iter(self.find_nodes(query, false).into_iter());
        let select = RandomGenerator::new(Some(RNG::Std(StdRng::from_entropy()))).get_random_usize(0, eligible_nodes.len());

        match eligible_nodes.get(select) {
            Some(value) => Some(value.1),
            None => None
        }
    }

    pub fn pick_node_for_capability(&self, capability: &str) -> Option<&Node> {
        let mut query = BTreeMap::new();
        query.insert("capability", capability);
        self.pick_node(query)
    }

    pub async fn add_feature(&mut self, feature: Arc<dyn product_os_capabilities::Feature>, base_path: String, router: &mut product_os_router::ProductOSRouter) {
        self.me.features.add(feature, base_path, router).await;
        self.update_me().await;
    }

    pub async fn add_feature_mut(&mut self, feature: Arc<Mutex<dyn product_os_capabilities::Feature>>, base_path: String, router: &mut product_os_router::ProductOSRouter) {
        self.me.features.add_mut(feature, base_path, router).await;
        self.update_me().await;
    }

    pub fn pick_node_for_feature(&self, feature: &str) -> Option<&Node> {
        let mut query = BTreeMap::new();
        query.insert("feature", feature);
        self.pick_node(query)
    }

    pub async fn remove_feature(&mut self, identifier: &str) {
        self.me.features.remove(identifier);
        self.update_me().await;
    }

    pub async fn add_service(&mut self, service: Arc<dyn product_os_capabilities::Service>) {
        self.me.services.add(service).await;
        self.update_me().await;
    }

    pub async fn add_service_mut(&mut self, service: Arc<Mutex<dyn product_os_capabilities::Service>>) {
        self.me.services.add_mut(service).await;
        self.update_me().await;
    }

    pub async fn set_service_active(&mut self, identifier: String, status: bool) {
        let id = identifier.as_str();
        match self.me.services.get_mut(id) {
            None => (),
            Some(s) => {
                s.active = status;
                self.update_me().await;
            }
        }
    }

    pub async fn remove_service(&mut self, identifier: &str) {
        self.me.services.remove(identifier);
        self.update_me().await;
    }

    pub async fn remove_inactive_services(&mut self, query: BTreeMap<&str, &str>) {
        let mut matches = Vec::new();

        for (identifier, _) in self.find_nodes(query, true) {
            matches.push(identifier.to_owned());
        }

        for identifier in &matches {
            self.remove_service(identifier).await;
        }

        if matches.len() > 0 { self.update_me().await };
    }

    pub async fn start_services(&mut self) {
        for (_, service) in self.me.services.list_mut() {
            match service.start().await {
                Ok(_) => {}
                Err(_) => {}
            }
        }
    }

    pub async fn discover_nodes(&mut self) {
        let mut nodes = BTreeMap::new();

        match self.store.group_find(None) {
            Ok(ns) => {
                nodes = ns;
            },
            Err(_) => {
                tracing::error!("Error getting nodes from store store");
            }
        }

        for (id, node) in nodes {
            match serde_json::from_str(node.as_str()) {
                Ok(n) => {
                    let mut node: Node = n;
                    node.features.setup_router();
                    tracing::trace!("Importing remote node: {:?}", node.id);
                    self.upsert_node_local(node.id.to_string(), node);
                },
                Err(e) => {
                    tracing::error!("Error importing remote node {} - purging: {:?}", id, e);
                    self.remove_node_remote(id.as_str()).await;
                }
            }
        }
    }

    pub fn get_key(&self, identifier: &str) -> Option<Vec<u8>> {
        match self.key_store.get_key(identifier) {
            Some(k) => Some(k.to_vec()),
            None => None
        }
    }

    pub fn create_key_session(&mut self) -> (String, [u8; 32]) {
        self.key_store.create_session()
    }

    pub fn generate_key(&mut self, session_identifier: &str, remote_public_key: &[u8], association: String, remote_session_identifier: Option<String>) {
        self.key_store.generate_key(session_identifier, remote_public_key, association, remote_session_identifier);
    }
}


/*
{
  "_id": {
    "$oid": "6160ed1181d34b02de2054d1"
  },
  "capabilities": [
    "updateUsersStatus",
    "cleanUpManagers",
    "queue"
  ],
  "machineID": "bd674848a60c3e19cf25764bb5d6b1a124a46c344f9a30573b60e4fbb6615e2d",
  "key": "Z_m=2Wg(0HD4c-%%Jkqu>,H0<a&3TJ>s",
  "services": {
    "authentication": {
      "identifier": "authentication",
      "path": "/authentication",
      "remotes": {
        "https://172.18.0.9:8421": ",J>mM]z>wnQQ4-nT?a/J4`XpU]Pjy1/d",
        "https://172.18.0.3:8989": "Yf/bE`*O>3;^HsWj(&_<!v(Kq;HT9?[{",
        "https://172.18.0.5:8888": "fcVk[[O65<FwRrsJwDnnxD!y`^m]B~S`",
        "https://172.18.0.4:9102": "@P~3?^}6_}yph{@/L|a+tW7I#2^(O]cJ",
        "https://172.18.0.2:9410": "}ub%oUYN)9e/<<qL%*|m1`f]c(*t!Rc7",
        "https://172.18.0.8:8443": ".#z@4(_Q_o(yO#R!aDIR3(z-t[PeRgTN",
        "https://172.18.0.7:9337": "(1|)v|D?24?pR4,tc*a{bI]ue-UHPw`_"
      }
    },
    "servers": {
      "identifier": "servers",
      "path": "/servers",
      "remotes": {
        "https://172.18.0.9:8421": ",J>mM]z>wnQQ4-nT?a/J4`XpU]Pjy1/d",
        "https://172.18.0.3:8989": "Yf/bE`*O>3;^HsWj(&_<!v(Kq;HT9?[{",
        "https://172.18.0.5:8888": "fcVk[[O65<FwRrsJwDnnxD!y`^m]B~S`",
        "https://172.18.0.4:9102": "@P~3?^}6_}yph{@/L|a+tW7I#2^(O]cJ",
        "https://172.18.0.2:9410": "}ub%oUYN)9e/<<qL%*|m1`f]c(*t!Rc7",
        "https://172.18.0.8:8443": ".#z@4(_Q_o(yO#R!aDIR3(z-t[PeRgTN",
        "https://172.18.0.7:9337": "(1|)v|D?24?pR4,tc*a{bI]ue-UHPw`_"
      }
    }
  },
  "features": {
    "service-cache": {
      "identifier": "service-cache",
      "paths": [
        "/cache*",
        "/cache/\*"
      ],
      "remotes": {
        "https://172.18.0.9:8421": ",J>mM]z>wnQQ4-nT?a/J4`XpU]Pjy1/d",
        "https://172.18.0.3:8989": "Yf/bE`*O>3;^HsWj(&_<!v(Kq;HT9?[{",
        "https://172.18.0.5:8888": "fcVk[[O65<FwRrsJwDnnxD!y`^m]B~S`",
        "https://172.18.0.4:9102": "@P~3?^}6_}yph{@/L|a+tW7I#2^(O]cJ",
        "https://172.18.0.2:9410": "}ub%oUYN)9e/<<qL%*|m1`f]c(*t!Rc7",
        "https://172.18.0.8:8443": ".#z@4(_Q_o(yO#R!aDIR3(z-t[PeRgTN",
        "https://172.18.0.7:9337": "(1|)v|D?24?pR4,tc*a{bI]ue-UHPw`_"
      }
    },
    "command/endpoint": {
      "identifier": "command/endpoint",
      "paths": [
        "/command/:service/:instruction"
      ],
      "remotes": {
        "https://172.18.0.9:8421": ",J>mM]z>wnQQ4-nT?a/J4`XpU]Pjy1/d",
        "https://172.18.0.3:8989": "Yf/bE`*O>3;^HsWj(&_<!v(Kq;HT9?[{",
        "https://172.18.0.5:8888": "fcVk[[O65<FwRrsJwDnnxD!y`^m]B~S`",
        "https://172.18.0.4:9102": "@P~3?^}6_}yph{@/L|a+tW7I#2^(O]cJ",
        "https://172.18.0.2:9410": "}ub%oUYN)9e/<<qL%*|m1`f]c(*t!Rc7",
        "https://172.18.0.8:8443": ".#z@4(_Q_o(yO#R!aDIR3(z-t[PeRgTN",
        "https://172.18.0.7:9337": "(1|)v|D?24?pR4,tc*a{bI]ue-UHPw`_"
      }
    }
  },
  "services": [
    {
      "_id": {
        "$oid": "6160ed1481d34b02de205502"
      },
      "identifier": "queue0",
      "key": "r@a{mjm{Q#ccwQhnQC7NB8/i,j^QUUCp",
      "type": "queue",
      "active": true,
      "enabled": true,
      "updatedAt": {
        "$date": "2021-10-09T01:15:00.336Z"
      },
      "createdAt": {
        "$date": "2021-10-09T01:15:00.274Z"
      }
    }
  ],
  "failures": 0,
  "addressV4": "172.18.0.6",
  "port": 9751,
  "processID": "734",
  "createdAt": {
    "$date": "2021-10-09T01:14:57.245Z"
  },
  "updatedAt": {
    "$date": "2021-10-09T08:58:00.373Z"
  },
  "__v": 0,
  "remoteFeatures": {
    "events/execute": {
      "identifier": "events/execute",
      "paths": [
        "/api/events/trigger",
        "/api/events/notification",
        "/api/events/process"
      ]
    },
    "flows/execute": {
      "identifier": "flows/execute",
      "paths": [
        "/api/flows/execute"
      ]
    },
    "conditions/execute": {
      "identifier": "conditions/execute",
      "paths": [
        "/api/conditions/execute"
      ]
    },
    "effects/execute": {
      "identifier": "effects/execute",
      "paths": [
        "/api/effect/trigger",
        "/api/effects/trigger",
        "/api/effects/process"
      ]
    },
    "authentication": {
      "identifier": "authentication",
      "paths": [
        "/do-login/credentials",
        "/do-login/token",
        "/do-logout"
      ]
    },
    "oidc2": {
      "identifier": "oidc2",
      "paths": [
        "/oidc2/authorize",
        "/oidc2/authorize/decision",
        "/oidc2/verify",
        "/oidc2/whoami",
        "/oidc2/invalidate",
        "/oidc2/token",
        "/oidc2/refresh"
      ]
    },
    "intelligent/type": {
      "identifier": "intelligent/type",
      "paths": [
        "/api/intelligent/agent/categories/:name",
        "/api/intelligent/agent/list/predefined",
        "/api/intelligent/agent/list/userdefined"
      ]
    },
    "ipreveal": {
      "identifier": "ipreveal",
      "paths": [
        "/api/ipreveal/:experience/:ipaddress",
        "/api/ipreveal/dataset/update/all"
      ]
    },
    "analyzer": {
      "identifier": "analyzer",
      "paths": [
        "/api/analytics/process"
      ]
    },
    "processor": {
      "identifier": "processor",
      "paths": [
        "/api/process/reaction",
        "/api/process/signal"
      ]
    },
    "tiny": {
      "identifier": "tiny",
      "paths": [
        "/go/:tinyID"
      ]
    },
    "talk": {
      "identifier": "talk",
      "paths": [
        "/talk/load",
        "/talk/style",
        "/talk/:appID",
        "/talk/:appID/resume"
      ]
    },
    "responses/execute": {
      "identifier": "responses/execute",
      "paths": [
        "/api/response/send/:key/:identifier/:uuid/:channel",
        "/api/response/receive/:key/:identifier/:uuid"
      ]
    },
    "media/get": {
      "identifier": "media/get",
      "paths": [
        "/media/avatar/bot/:appID/:identifier",
        "/media/image/:identifier",
        "/media/file/:identifier",
        "/media/video/:identifier",
        "/media/audio/:identifier",
        "/media/:identifier"
      ]
    },
    "shared": {
      "identifier": "shared",
      "paths": [
        "/shared/product-os/blog/rss",
        "/shared/tracking/google",
        "/shared/location/display/map",
        "/shared/experience/loading",
        "/shared/product-os/preview",
        "/shared/product-os/chat",
        "/shared/live/chat",
        "/shared/courier/chat",
        "/shared/product-os/settings",
        "/shared/product-os/load",
        "/shared/product-os/launch",
        "/shared/product-os/journey/load",
        "/shared/product-os/journey/launch",
        "/shared/product-os/motion/load",
        "/shared/product-os/motion/launch",
        "/shared/avatar/:type",
        "/shared/try/journey/designer"
      ]
    },
    "assets/special": {
      "identifier": "assets/special",
      "paths": [
        "/js/product.client.bundle.js",
        "/js/product.designer.bundle.js",
        "/ui/\*",
        "/motion/\*",
        "/.well-known/\*"
      ]
    },
    "assets": {
      "identifier": "assets",
      "paths": [
        "/js/\*",
        "/css/\*",
        "/images/\*",
        "/webfonts/\*",
        "/assets/\*",
        "/favicon.ico",
        "/robots.txt"
      ]
    },
    "pipes/rest": {
      "identifier": "pipes/rest",
      "paths": [
        "/api/plugins/rest/:pipe*"
      ]
    },
    "pipes/stream": {
      "identifier": "pipes/stream",
      "paths": [
        "/api/plugins/stream/:pipe"
      ]
    },
    "pipes/graphql": {
      "identifier": "pipes/graphql",
      "paths": [
        "/api/plugins/graphql/:pipe*"
      ]
    },
    "pipes/ws": {
      "identifier": "pipes/ws",
      "paths": [
        "/api/plugins/ws/:pipe"
      ]
    },
    "pipes/mqtt": {
      "identifier": "pipes/mqtt",
      "paths": [
        "/api/plugins/mqtt/:pipe"
      ]
    },
    "channels/primus": {
      "identifier": "channels/primus",
      "paths": [
        "/channels/product-os/primus*",
        "/channels/product-os/primus/omega/supreme*",
        "/channels/live/send",
        "/channels/live/notify"
      ]
    },
    "content": {
      "identifier": "content",
      "paths": [
        "/error/:code",
        "/",
        "/\*"
      ]
    },
    "swagger/api": {
      "identifier": "swagger/api",
      "paths": [
        "/help/api/reference/openapi.json"
      ]
    },
    "swagger/docs": {
      "identifier": "swagger/docs",
      "paths": [
        "/help/api/reference/"
      ]
    },
    "qrcode": {
      "identifier": "qrcode",
      "paths": [
        "/api/qrcode/generate"
      ]
    },
    "connect": {
      "identifier": "connect",
      "paths": [
        "/api/connect/verify/:app",
        "/api/connect/verify-complete/:app",
        "/api/connect/authorize",
        "/api/connect/request/:appID/:key/:action"
      ]
    },
    "embedded": {
      "identifier": "embedded",
      "paths": [
        "/api/embedded/:type/:action"
      ]
    },
    "webhooks": {
      "identifier": "webhooks",
      "paths": [
        "/api/hooks/store/:uuid",
        "/api/hooks/subscribe",
        "/api/hooks/unsubscribe/:key",
        "/api/hooks/external/:key"
      ]
    },
    "zapier": {
      "identifier": "zapier",
      "paths": [
        "/api/hooks/zapier/send/:method/:type/:key",
        "/api/hooks/zapier/send/:type"
      ]
    },
    "ifttt": {
      "identifier": "ifttt",
      "paths": [
        "/api/ifttt/status",
        "/api/ifttt/test/setup",
        "/api/ifttt/user/info",
        "/api/ifttt/triggers/effect",
        "/api/ifttt/actions/event",
        "/api/hooks/ifttt/send/:type/:key"
      ]
    },
    "msflow": {
      "identifier": "msflow",
      "paths": [
        "/api/hooks/msflow/send/:type/:key"
      ]
    },
    "integromat": {
      "identifier": "integromat",
      "paths": [
        "/api/hooks/integromat/send/:type/:key"
      ]
    },
    "notify": {
      "identifier": "notify",
      "paths": [
        "/api/notify/:service/:type",
        "/api/notifications/process",
        "/api/notifications/email/process"
      ]
    },
    "channels/telegram": {
      "identifier": "channels/telegram",
      "paths": [
        "/channels/telegram/:uuid",
        "/channels/telegram"
      ]
    },
    "channels/facebook/messenger": {
      "identifier": "channels/facebook/messenger",
      "paths": [
        "/channels/facebook/messenger"
      ]
    },
    "channels/whatsapp": {
      "identifier": "channels/whatsapp",
      "paths": [
        "/channels/whatsapp/whatsapp",
        "/channels/whatsapp/connect",
        "/channels/whatsapp/reconnect",
        "/channels/whatsapp/disconnect",
        "/channels/whatsapp/qr-refresh",
        "/channels/whatsapp/connect-complete"
      ]
    },
    "channels/line": {
      "identifier": "channels/line",
      "paths": [
        "/channels/line/:uuid",
        "/channels/line"
      ]
    },
    "channels/viber": {
      "identifier": "channels/viber",
      "paths": [
        "/channels/viber/:uuid",
        "/channels/viber"
      ]
    },
    "channels/twilio": {
      "identifier": "channels/twilio",
      "paths": [
        "/channels/twilio/sms/:uuid",
        "/channels/twilio/whatsapp/:uuid",
        "/channels/twilio"
      ]
    },
    "channels/wechat": {
      "identifier": "channels/wechat",
      "paths": [
        "/channels/wechat/:uuid"
      ]
    },
    "channels/slack": {
      "identifier": "channels/slack",
      "paths": [
        "/channels/slack",
        "/channels/slack/disconnect-all"
      ]
    },
    "channels/microsoft/azurebot": {
      "identifier": "channels/microsoft/azurebot",
      "paths": [
        "/channels/microsoft/azurebot/:uuid"
      ]
    },
    "channels/dialogflow": {
      "identifier": "channels/dialogflow",
      "paths": [
        "/channels/google/dialogflow/:uuid",
        "/channels/google/dialogflow"
      ]
    },
    "channels/amazon/alexa": {
      "identifier": "channels/amazon/alexa",
      "paths": [
        "/channels/amazon/alexa/:uuid",
        "/channels/amazon/alexa"
      ]
    },
    "channels/intercom": {
      "identifier": "channels/intercom",
      "paths": [
        "/channels/intercom"
      ]
    },
    "channels/signal": {
      "identifier": "channels/signal",
      "paths": [
        "/channels/signal/signal",
        "/channels/signal/connect",
        "/channels/signal/disconnect"
      ]
    },
    "channels/facebook/instagram": {
      "identifier": "channels/facebook/instagram",
      "paths": [
        "/channels/instagram/instagram",
        "/channels/instagram/connect",
        "/channels/instagram/disconnect"
      ]
    },
    "channels/product-os/rest": {
      "identifier": "channels/product-os/rest",
      "paths": [
        "/channels/product-os/rest/:mode"
      ]
    },
    "channels/product-os/ws": {
      "identifier": "channels/product-os/ws",
      "paths": [
        "/channels/product-os/ws"
      ]
    }
  },
  "remoteServices": {
    "stories": {
      "identifier": "stories",
      "path": "/stories"
    },
    "logging": {
      "identifier": "logging",
      "path": "/logging"
    },
    "users": {
      "identifier": "users",
      "path": "/users"
    },
    "oidc": {
      "identifier": "oidc",
      "path": "/oidc"
    },
    "manage-users": {
      "identifier": "manage-users",
      "path": "/manage-users"
    },
    "teams": {
      "identifier": "teams",
      "path": "/teams"
    },
    "motions": {
      "identifier": "motions",
      "path": "/motions"
    },
    "subscriptions": {
      "identifier": "subscriptions",
      "path": "/subscriptions"
    },
    "watchers": {
      "identifier": "watchers",
      "path": "/watchers"
    },
    "hooks": {
      "identifier": "hooks",
      "path": "/hooks"
    },
    "licences": {
      "identifier": "licences",
      "path": "/licences"
    },
    "notifications": {
      "identifier": "notifications",
      "path": "/notifications"
    },
    "invites": {
      "identifier": "invites",
      "path": "/invites"
    },
    "statistics": {
      "identifier": "statistics",
      "path": "/statistics"
    },
    "iplocations": {
      "identifier": "iplocations",
      "path": "/iplocations"
    },
    "templates": {
      "identifier": "templates",
      "path": "/templates"
    },
    "signals": {
      "identifier": "signals",
      "path": "/signals"
    },
    "plans": {
      "identifier": "plans",
      "path": "/plans"
    },
    "errors": {
      "identifier": "errors",
      "path": "/errors"
    },
    "queues": {
      "identifier": "queues",
      "path": "/queues"
    },
    "trainer": {
      "identifier": "trainer",
      "path": "/trainer"
    },
    "find-experiences": {
      "identifier": "find-experiences",
      "path": "/find-experiences"
    },
    "find-motions": {
      "identifier": "find-motions",
      "path": "/find-motions"
    },
    "experiences": {
      "identifier": "experiences",
      "path": "/experiences"
    },
    "journeys": {
      "identifier": "journeys",
      "path": "/journeys"
    },
    "liveexperiences": {
      "identifier": "liveexperiences",
      "path": "/liveexperiences"
    },
    "pages": {
      "identifier": "pages",
      "path": "/pages"
    },
    "reactions": {
      "identifier": "reactions",
      "path": "/reactions"
    },
    "tinyurls": {
      "identifier": "tinyurls",
      "path": "/tinyurls"
    },
    "media": {
      "identifier": "media",
      "path": "/media"
    },
    "connections": {
      "identifier": "connections",
      "path": "/connections"
    },
    "mappings": {
      "identifier": "mappings",
      "path": "/mappings"
    },
    "pipes": {
      "identifier": "pipes",
      "path": "/pipes"
    },
    "anatomies": {
      "identifier": "anatomies",
      "path": "/anatomies"
    }
  }
}
 */