import os, json, textwrap, hashlib, shutil, time, py_compile
from pathlib import Path
BASE = Path(“/mnt/data/solveforce-code”)
PKG = BASE / “solveforce_gateway”
ADAPTERS = PKG / “adapters”
DATA = PKG / “data”
BANDPLANS = DATA / “bandplans”
OPERATORS = DATA / “operators”
Clean up any previous build
if BASE.exists():
shutil.rmtree(BASE)
Create directories
(BANDPLANS).mkdir(parents=True, exist_ok=True)
(OPERATORS).mkdir(parents=True, exist_ok=True)
(ADAPTERS).mkdir(parents=True, exist_ok=True)
—————————-
Write top-level files
—————————-
readme = “””# SolveForce UCLS Infra Gateway (Read‑Only Scaffold)
A safe‑by‑default, language‑first gateway scaffold. Pure Python standard library.
It exposes a minimal HTTP surface and a pluggable adapter loop. All built‑ins are
read‑only. Writes require explicit code changes so safety is visible by design.
Endpoints
/health— heartbeat with uptime/adapters— which adapters are enabled and their state/results/latest— last poll payloads per adapter (JSON)/translate?q=...— currency + operator normalizer (symbol → canonical)/metrics— Prometheus text exposition (basic counters)
Run
“`bash
python ucls_infra_gateway.py –config config.example.json
open http://127.0.0.1:8080/health
Configure
See config.example.json. Enable/disable adapters and exports.
JSONL exports are ClickHouse‑friendly (format: JSONEachRow).
Project Layout
Always show detailssolveforce-code/
ucls_infra_gateway.py
config.example.json
solveforce_gateway/
core.py http manager, poller, exporters
httpd.py HTTP server + endpoints
util.py helpers (time, translate)
adapters/ adapter modules (heartbeat, bandplan, currency_operator, ...)
data/
bandplans/ sample RF bands
operators/ math & currency symbol maps
License
MIT © 2025 Ronald Joseph Legarski, Jr. — Published by SolveForce
“””
(Path(BASE/”README.md”)).write_text(readme, encoding=”utf-8″)
license_text = “””MIT License
Copyright (c) 2025 Ronald Joseph Legarski, Jr.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
“””
(Path(BASE/”LICENSE”)).write_text(license_text, encoding=”utf-8″)
pyproject = “””[project]
name = “solveforce-gateway”
version = “0.1.0”
description = “SolveForce UCLS Infra Gateway (read-only scaffold)”
authors = [{name = “Ronald Joseph Legarski, Jr.”}]
requires-python = “>=3.8”
“””
(Path(BASE/”pyproject.toml”)).write_text(pyproject, encoding=”utf-8″)
config_json = {
“http”: {“host”: “127.0.0.1”, “port”: 8080},
“poll_interval_sec”: 5,
“adapters”: [
{“name”: “heartbeat”, “enabled”: True},
{“name”: “currency_operator”, “enabled”: True, “config”: {“load_currency_sample”: True}},
{“name”: “bandplan”, “enabled”: True, “config”: {
“bandplan_files”: [“solveforce_gateway/data/bandplans/US_FCC_2.4_5.json”]
}},
{“name”: “iec61850_helper”, “enabled”: True},
{“name”: “snmp”, “enabled”: False},
{“name”: “netconf”, “enabled”: False},
{“name”: “gnmi”, “enabled”: False},
{“name”: “openadr”, “enabled”: False},
{“name”: “iec61850”, “enabled”: False},
{“name”: “dnp3”, “enabled”: False},
{“name”: “tmforum”, “enabled”: False}
],
“exports”: {
“enable_prometheus”: True,
“enable_clickhouse_csv”: False,
“export_jsonl”: True,
“export_dir”: “exports”
}
}
(Path(BASE/”config.example.json”)).write_text(json.dumps(config_json, indent=2), encoding=”utf-8″)
—————————-
Package files
—————————-
(Path(PKG/”init.py”)).write_text(‘VERSION = “0.1.0”\n’, encoding=”utf-8″)
core_py = r”’
import json, os, threading, time, traceback
from datetime import datetime, timezone
from . import util
class AdapterInterface:
NAME = “adapter”
def init(self, config=None):
self.config = config or {}
self.seq = 0
self.last = None
self.err = None
def poll(self):
“””Return a JSON-serializable dict. Override in subclass.”””
self.seq += 1
return {“seq”: self.seq}
def info(self):
return {“name”: self.NAME, “seq”: self.seq, “last_ok”: self.last is not None, “error”: self.err}
class Manager:
def init(self, cfg, adapter_classes):
self.cfg = cfg
self.adapter_classes = adapter_classes
self.adapters = []
self.results = {}
self.errors = {}
self.lock = threading.Lock()
self.poll_interval = int(cfg.get(“poll_interval_sec”, 5))
self._stop = threading.Event()
self.started_at = time.time()
Always show details # Exports
self.export_jsonl = cfg.get("exports", {}).get("export_jsonl", True)
self.export_dir = cfg.get("exports", {}).get("export_dir", "exports")
if self.export_jsonl:
os.makedirs(self.export_dir, exist_ok=True)
# Instantiate enabled adapters
for entry in cfg.get("adapters", []):
name = entry.get("name")
if not entry.get("enabled", False):
continue
cls = adapter_classes.get(name)
if not cls:
continue
try:
inst = cls(config=entry.get("config", {}))
self.adapters.append(inst)
except Exception as e:
self.errors[name] = f"init failed: {e}"
def poll_once(self):
for a in self.adapters:
try:
data = a.poll()
if not isinstance(data, dict):
data = {"value": data}
data["_ts"] = util.now_utc_iso()
with self.lock:
self.results[a.NAME] = data
a.last = data
if self.export_jsonl:
path = os.path.join(self.export_dir, f"{a.NAME}.jsonl")
with open(path, "a", encoding="utf-8") as f:
f.write(json.dumps(data, ensure_ascii=False) + "\n")
except Exception as e:
a.err = f"{e}"
self.errors[a.NAME] = traceback.format_exc()
def loop_forever(self):
while not self._stop.is_set():
self.poll_once()
self._stop.wait(self.poll_interval)
def stop(self):
self._stop.set()
def adapter_infos(self):
return [a.info() for a in self.adapters]
def latest_results(self):
with self.lock:
return dict(self.results)
def metrics_text(self):
# Minimal Prometheus exposition
lines = []
up = int(time.time() - self.started_at)
lines.append(f'solveforce_up {up}')
for a in self.adapters:
lines.append(f'solveforce_adapter_seq{{adapter="{a.NAME}"}} {a.seq}')
ok = 1 if a.last is not None else 0
lines.append(f'solveforce_adapter_last_ok{{adapter="{a.NAME}"}} {ok}')
return "\n".join(lines) + "\n"
def load_builtin_adapters():
# Import locally to avoid heavy imports on startup
from .adapters.heartbeat import HeartbeatAdapter
from .adapters.currency_operator_adapter import CurrencyOperatorAdapter
from .adapters.bandplan_adapter import BandplanAdapter
from .adapters.iec61850_helper import IEC61850HelperAdapter
# Stubs
from .adapters.snmp_adapter import SNMPAdapter
from .adapters.netconf_adapter import NETCONFAdapter
from .adapters.gnmi_adapter import GNMIAdapter
from .adapters.openadr_adapter import OpenADRAdapter
from .adapters.iec61850_adapter import IEC61850Adapter
from .adapters.dnp3_adapter import DNP3Adapter
from .adapters.tmforum_adapter import TMForumAdapter
Always show detailsreturn {
"heartbeat": HeartbeatAdapter,
"currency_operator": CurrencyOperatorAdapter,
"bandplan": BandplanAdapter,
"iec61850_helper": IEC61850HelperAdapter,
# stubs
"snmp": SNMPAdapter,
"netconf": NETCONFAdapter,
"gnmi": GNMIAdapter,
"openadr": OpenADRAdapter,
"iec61850": IEC61850Adapter,
"dnp3": DNP3Adapter,
"tmforum": TMForumAdapter,
}
”’
(Path(PKG/”core.py”)).write_text(core_py, encoding=”utf-8″)
httpd_py = r”’
import json, time
from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import urlparse, parse_qs
from . import util
The server needs a manager injected at start
MANAGER = None
class Handler(BaseHTTPRequestHandler):
server_version = “SolveForceGateway/0.1”
Always show detailsdef _send(self, code, payload, content_type="application/json; charset=utf-8"):
data = payload
if isinstance(payload, (dict, list)):
data = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
elif isinstance(payload, str):
data = payload
else:
data = str(payload)
body = data.encode("utf-8")
self.send_response(code)
self.send_header("Content-Type", content_type)
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def log_message(self, fmt, *args):
# Quieter logs
return
def do_GET(self):
global MANAGER
parsed = urlparse(self.path)
if parsed.path == "/health":
self._send(200, {"status": "ok", "time": util.now_utc_iso(), "uptime_sec": int(time.time() - MANAGER.started_at)})
return
if parsed.path == "/adapters":
self._send(200, {"adapters": MANAGER.adapter_infos()})
return
if parsed.path == "/results/latest":
self._send(200, MANAGER.latest_results())
return
if parsed.path == "/translate":
q = parse_qs(parsed.query).get("q", [""])[0]
result = util.translate_query(q)
self._send(200, result)
return
if parsed.path == "/metrics":
text = MANAGER.metrics_text()
self._send(200, text, content_type="text/plain; version=0.0.4; charset=utf-8")
return
self._send(404, {"error": "not found", "path": parsed.path})
def run_http(host, port, manager):
global MANAGER
MANAGER = manager
httpd = HTTPServer((host, port), Handler)
return httpd
”’
(Path(PKG/”httpd.py”)).write_text(httpd_py, encoding=”utf-8″)
util_py = r”’
import json, os, re
from datetime import datetime, timezone
from pathlib import Path
Base dir resolves relative to working directory
BASE_DIR = Path(“.”)
def now_utc_iso():
return datetime.now(timezone.utc).isoformat()
def load_json(path):
with open(path, “r”, encoding=”utf-8″) as f:
return json.load(f)
def _operators_path():
return BASE_DIR / “solveforce_gateway” / “data” / “operators”
def load_operator_maps():
op_dir = _operators_path()
math_ops = load_json(op_dir / “math_operators.json”)
curr_map = load_json(op_dir / “currency_sample.json”)
# Normalize keys for multi-character currency tokens
# e.g., “NZ$” must be matched before “$”
# Build a sorted list for greedy matching
keys = sorted(curr_map.keys(), key=lambda k: len(k), reverse=True)
return math_ops, curr_map, keys
def translate_query(q: str):
“””Return a normalized string and token list for an input expression.”””
math_ops, curr_map, curr_keys = load_operator_maps()
i = 0
tokens = []
out = []
while i < len(q):
# Try currency multi-char match first
matched = False
for key in curr_keys:
if q.startswith(key, i):
iso = curr_map[key]
tokens.append({“type”: “currency”, “raw”: key, “iso”: iso})
out.append(f”<{iso}>”)
i += len(key)
matched = True
break
if matched:
continue
ch = q[i]
# Operators map
if ch in math_ops:
canon = math_ops[ch]
tokens.append({“type”: “operator”, “raw”: ch, “op”: canon})
out.append(canon)
i += 1
continue
# Numbers
if ch.isdigit() or (ch == “.” and i + 1 < len(q) and q[i+1].isdigit()):
j = i + 1
while j < len(q) and (q[j].isdigit() or q[j] in “.,“):
j += 1
num = q[i:j]
tokens.append({“type”: “number”, “raw”: num})
out.append(num.replace(“,”, “”))
i = j
continue
# Letters / other
if ch.isalpha():
j = i + 1
while j < len(q) and (q[j].isalpha() or q[j] in “-/”):
j += 1
word = q[i:j]
tokens.append({“type”: “text”, “raw”: word})
out.append(word)
i = j
continue
# Fallback: pass-through
out.append(ch)
i += 1
return {“input”: q, “normalized”: “”.join(out), “tokens”: tokens}
”’
(Path(PKG/”util.py”)).write_text(util_py, encoding=”utf-8″)
—————————-
Data files
—————————-
bandplan_json = {
“authority”: “US_FCC”,
“bands”: [
{“name”: “2.4 GHz ISM”, “start_mhz”: 2400.0, “end_mhz”: 2483.5, “channels”: [{“ch”: ch, “center_mhz”: 2407 + 5*(ch-1)} for ch in range(1, 12)]},
{“name”: “5 GHz U-NII-1”, “start_mhz”: 5150.0, “end_mhz”: 5250.0, “channels”: [{“ch”: x, “center_mhz”: x5} for x in [36,40,44,48]]},
{“name”: “5 GHz U-NII-2A (DFS)”, “start_mhz”: 5250.0, “end_mhz”: 5350.0, “dfs”: True, “channels”: [{“ch”: x, “center_mhz”: x5} for x in [52,56,60,64]]},
{“name”: “5 GHz U-NII-2C/Extended (DFS)”, “start_mhz”: 5470.0, “end_mhz”: 5725.0, “dfs”: True, “channels”: [{“ch”: x, “center_mhz”: x5} for x in [100,104,108,112,116,120,124,128,132,136,140,144]]},
{“name”: “5 GHz U-NII-3”, “start_mhz”: 5725.0, “end_mhz”: 5850.0, “channels”: [{“ch”: x, “center_mhz”: x5} for x in [149,153,157,161,165]]}
]
}
(Path(BANDPLANS/”US_FCC_2.4_5.json”)).write_text(json.dumps(bandplan_json, indent=2), encoding=”utf-8″)
math_ops_json = {
“+”: “+”, “＋”: “+”,
“-“: “-“, “−”: “-“, “–”: “-“, “—”: “-“,
“×”: ““, “∙”: ““, “·”: ““, “⋅”: ““, ““: ““,
“÷”: “/”, “∕”: “/”, “/”: “/”,
“=”: “=”, “≈”: ““, “≃”: ““, “≅”: “~”,
“<“: “<“, “≤”: “<=”, “⩽”: “<=”,
“>”: “>”, “≥”: “>=”, “⩾”: “>=”,
“^”: “^”, “%”: “%”
}
(Path(OPERATORS/”math_operators.json”)).write_text(json.dumps(math_ops_json, indent=2), encoding=”utf-8″)
currency_map = {
“A$”: “AUD”, “C$”: “CAD”, “NZ$”: “NZD”, “HK$”: “HKD”, “S$”: “SGD”, “R$”: “BRL”, “MX$”: “MXN”,
“$”: “USD”,
“€”: “EUR”, “£”: “GBP”, “¥”: “JPY”, “₩”: “KRW”, “₹”: “INR”, “₽”: “RUB”, “₺”: “TRY”,
“₫”: “VND”, “₦”: “NGN”, “₱”: “PHP”, “฿”: “THB”, “₵”: “GHS”, “₡”: “CRC”, “₭”: “LAK”,
“₴”: “UAH”, “₲”: “PYG”, “₮”: “MNT”, “₼”: “AZN”, “₸”: “KZT”, “₺”: “TRY”, “₾”: “GEL”,
“₿”: “BTC”
}
(Path(OPERATORS/”currency_sample.json”)).write_text(json.dumps(currency_map, indent=2), encoding=”utf-8″)
—————————-
Adapters
—————————-
heartbeat_py = r”’
import time
from ..core import AdapterInterface
from .. import util
class HeartbeatAdapter(AdapterInterface):
NAME = “heartbeat”
def poll(self):
self.seq += 1
return {
“seq”: self.seq,
“ts”: util.now_utc_iso(),
“unix”: time.time()
}
”’
(Path(ADAPTERS/”heartbeat.py”)).write_text(heartbeat_py, encoding=”utf-8″)
currency_adapter_py = r”’
from ..core import AdapterInterface
from .. import util
class CurrencyOperatorAdapter(AdapterInterface):
NAME = “currency_operator”
def init(self, config=None):
super().init(config=config)
self.math_ops, self.curr_map, self.curr_keys = util.load_operator_maps()
def poll(self):
self.seq += 1
return {
“seq”: self.seq,
“operators_loaded”: len(self.math_ops),
“currencies_loaded”: len(self.curr_map),
“example”: util.translate_query(“$199.99+VAT=€210≈”)
}
”’
(Path(ADAPTERS/”currency_operator_adapter.py”)).write_text(currency_adapter_py, encoding=”utf-8″)
bandplan_adapter_py = r”’
import json
from pathlib import Path
from ..core import AdapterInterface
class BandplanAdapter(AdapterInterface):
NAME = “bandplan”
def poll(self):
self.seq += 1
files = self.config.get(“bandplan_files”, []) if isinstance(self.config, dict) else []
plans = []
for p in files:
try:
data = json.loads(Path(p).read_text(encoding=”utf-8″))
plans.append({“file”: p, “authority”: data.get(“authority”), “bands”: len(data.get(“bands”, []))})
except Exception as e:
plans.append({“file”: p, “error”: str(e)})
return {“seq”: self.seq, “plans”: plans}
”’
(Path(ADAPTERS/”bandplan_adapter.py”)).write_text(bandplan_adapter_py, encoding=”utf-8″)
iec61850_helper_py = r”’
from ..core import AdapterInterface
def parse_iec61850_path(path: str):
“””
Parse IEC 61850 logical path like: MMXU1.A.phsA.cVal.mag.f
Returns a list of path components.
“””
parts = [p for p in path.replace(“/”, “.”).split(“.”) if p]
return parts
class IEC61850HelperAdapter(AdapterInterface):
NAME = “iec61850_helper”
def poll(self):
self.seq += 1
example = “MMXU1.A.phsA.cVal.mag.f”
return {“seq”: self.seq, “example_path”: example, “parsed”: parse_iec61850_path(example)}
”’
(Path(ADAPTERS/”iec61850_helper.py”)).write_text(iec61850_helper_py, encoding=”utf-8″)
Stubs
stubs = {
“snmp_adapter.py”: “SNMPAdapter”,
“netconf_adapter.py”: “NETCONFAdapter”,
“gnmi_adapter.py”: “GNMIAdapter”,
“openadr_adapter.py”: “OpenADRAdapter”,
“iec61850_adapter.py”: “IEC61850Adapter”,
“dnp3_adapter.py”: “DNP3Adapter”,
“tmforum_adapter.py”: “TMForumAdapter”,
}
for filename, clsname in stubs.items():
code = f”’
from ..core import AdapterInterface
class {clsname}(AdapterInterface):
NAME = “{clsname.replace(‘Adapter’,”).lower()}”
def poll(self):
self.seq += 1
return {{“seq”: self.seq, “status”: “stub”, “note”: “read-only placeholder”}}
”’
(Path(ADAPTERS/filename)).write_text(code, encoding=”utf-8″)
—————————-
Entrypoint script
—————————-
ucls_py = r”’
#!/usr/bin/env python3
–– coding: utf-8 ––
“””
SolveForce UCLS Infra Gateway — Read-only scaffold
“””
import argparse, json, threading, time
from pathlib import Path
from solveforce_gateway.core import Manager, load_builtin_adapters
from solveforce_gateway.httpd import run_http
from solveforce_gateway import util
def main():
ap = argparse.ArgumentParser()
ap.add_argument(“–config”, default=”config.example.json”, help=”Path to config JSON”)
args = ap.parse_args()
Always show detailscfg = json.loads(Path(args.config).read_text(encoding="utf-8"))
adapter_classes = load_builtin_adapters()
mgr = Manager(cfg, adapter_classes)
# Poller thread
t = threading.Thread(target=mgr.loop_forever, daemon=True)
t.start()
host = cfg.get("http", {}).get("host", "127.0.0.1")
port = int(cfg.get("http", {}).get("port", 8080))
httpd = run_http(host, port, mgr)
print(f"[SolveForce] HTTP listening on http://{host}:{port}")
print(f"[SolveForce] Enabled adapters: {[a['name'] for a in cfg.get('adapters', []) if a.get('enabled')]}")
try:
httpd.serve_forever()
except KeyboardInterrupt:
print("\n[SolveForce] Shutting down...")
finally:
mgr.stop()
httpd.server_close()
if name == “main“:
main()
”’
(Path(BASE/”ucls_infra_gateway.py”)).write_text(ucls_py, encoding=”utf-8″)
—————————-
Sanity check (compile)
—————————-
py_files = []
for root, _, files in os.walk(BASE):
for f in files:
if f.endswith(“.py”):
py_files.append(Path(root)/f)
errors = []
for p in py_files:
try:
py_compile.compile(str(p), doraise=True)
except Exception as e:
errors.append((str(p), str(e)))
—————————-
Make zip archive
—————————-
zip_path = “/mnt/data/solveforce-code.zip”
if os.path.exists(zip_path):
os.remove(zip_path)
shutil.make_archive(“/mnt/data/solveforce-code”, “zip”, str(BASE))
Compute SHA256
sha256 = hashlib.sha256()
with open(zip_path, “rb”) as f:
for chunk in iter(lambda: f.read(8192), b””):
sha256.update(chunk)
digest = sha256.hexdigest()
{
“zip_path”: zip_path,
“sha256”: digest,
“compile_errors”: errors,
“tree_sample”: [str(p.relative_to(BASE)) for p in py_files]
}
Always show details
Result
{'zip_path': '/mnt/data/solveforce-code.zip',
'sha256': 'c5e8497f99001d1991f3d90542d903d902a40fe44d61ae8d42ebdc6591886c71',
'compile_errors': [],
'tree_sample': ['ucls_infra_gateway.py',
'solveforce_gateway/__init__.py',
'solveforce_gateway/core.py',
'solveforce_gateway/httpd.py',
'solveforce_gateway/util.py',
'solveforce_gateway/adapters/heartbeat.py',
'solveforce_gateway/adapters/currency_operator_adapter.py',
'solveforce_gateway/adapters/bandplan_adapter.py',
'solveforce_gateway/adapters/iec61850_helper.py',
'solveforce_gateway/adapters/snmp_adapter.py',
'solveforce_gateway/adapters/netconf_adapter.py',
'solveforce_gateway/adapters/gnmi_adapter.py',
'solveforce_gateway/adapters/openadr_adapter.py',
'solveforce_gateway/adapters/iec61850_adapter.py',
'solveforce_gateway/adapters/dnp3_adapter.py',
'solveforce_gateway/adapters/tmforum_adapter.py']}
You’re right—that link was premature. I hadn’t actually built the archive. I’ve packaged the code now and verified it compiles cleanly.
Download: solveforce-code.zip
SHA‑256: c5e8497f99001d1991f3d90542d903d902a40fe44d61ae8d42ebdc6591886c71
Quick start
unzip solveforce-code.zip
cd solveforce-code
python ucls_infra_gateway.py --config config.example.json
# open http://127.0.0.1:8080/health
What you’ll see
- /health→ heartbeat + uptime
- /adapters→ enabled modules (heartbeat, currency/operator, bandplan, 61850 helper; stubs for SNMP/NETCONF/gNMI/OpenADR/IEC‑61850/DNP3/TM Forum)
- /results/latest→ last payload from each adapter
- /translate?q=$199.99+VAT=€210≈→ currency+operator normalization
- /metrics→ Prometheus text (basic counters)
If anything else hiccups—path, permissions, or port conflicts—tell me exactly what you see and I’ll fix it on the spot.
Key terms in plain language
Open a term for a concise explanation of language used on this page.
Cloud Computing
Computing resources—such as applications, servers, storage, or databases—delivered from remote infrastructure and scaled as requirements change.
Infrastructure as a Service (IaaS)
Cloud-based servers, storage, and networking that customers configure and manage without owning the underlying data-center hardware.
Software as a Service (SaaS)
Software accessed as an online service instead of being installed and maintained entirely on the customer’s own computers or servers.
Disaster Recovery (DRaaS)
A plan and service for restoring applications, data, and operations after an outage or disruption. DRaaS provides recovery infrastructure through a managed cloud service.
Identity and Access Management (IAM)
The systems and policies that determine who a user is, what resources they may access, and how that access is authenticated and reviewed.
API
An application programming interface is a defined way for software systems to exchange data or request functions from one another.