Capsule is a framework for network function development. Written in Rust, inspired by NetBricks and built on Intel's Data Plane Development Kit.
The goal of Capsule is to offer an ergonomic framework for network function development that traditionally has high barriers of entry for developers. We've created a tool to efficiently manipulate network packets while being type-safe, memory-safe, and thread-safe.
Building on DPDK and Rust, Capsule offers: a fast packet processor that uses minimum number of CPU cycles; a rich packet type system that guarantees memory-safety and thread-safety; a declarative programming model that emphasizes simplicity; and, an extensible and testable framework that is easy to develop and maintain.
The jrugged library allows your code to adapt to network issues in a responsible way.
The jrugged library provides straightforward add-ons to existing code to make it more robust and easier to manage. Examples include CircuitBreaker, Initializer, PerformanceMonitor and Monitorable.
Most of these classes implement a ServiceWrapper interface to allow them to be applied around existing services using the Decorator design pattern. Those classes providing operational information, such as PerformanceMonitor and Monitorable can be wrapped in classes that expose their data to JMX controls or on web-accessible health status pages as desired.
Sheens is an automation engine that hosts message-processing state machines. These machines process and emit messages efficiently and atomically. The initial motivation was implementing IoT-oriented home automations; however, Sheens has been useful in other settings.
Sheens is easy to integrate via HTTP, WebSockets, MQTT, plain TCP, Go or C applications, or via other glue. For example, we have integrated Sheens with several internal services, AWS IoT, Home Assistant, and other frameworks.
The structure and behavior of sheens are amenable to standardization, and multiple implementations are feasible and practical. The Sheens engine is highly programmable, so tools (e.g., debuggers, visualizations, monitors, analyzers) are often easy to implement.
Sirius is a library for distributing and coordinating data updates amongst a cluster of nodes.
Sirius enables a cluster of nodes to keep developer-controlled in-memory data structures eventually consistent, allowing I/O-free access to shared information.
A compact framework for building Android apps with an MVP architecture. Blueprint helps Android devs build scrollable lists of discrete components using the Android RecyclerView library.
Additional Articles About Blueprint
Intro to Blueprint
Building Blueprint Components
A framework designed around helping you and your team build thoughtful, pattern-driven user interfaces using the atomic design principles.
The webpack wrapper around patternlab-node core, providing tasks to interact with the core library and move supporting frontend assets.
A micro-library for gathering frontend web page performance data.
Surf-N-Perf provides a simple to use API to gather User Timing and other important performance data in any browser.
SpeedtestJS is a JavaScript based speed test providing users with an enriched view of their Internet speed. We developed and open sourced SpeedTestJS to create a benchmark solution that would be transparent, independent and used and contributed by many.
Using speed tier data to add a qualifying metric to standard speed test results, users will now know whether their experience is poor, good or great.
ns-3 bindings to support simulation evaluations of Distributed Monotonic Clocks (DMC).
Distributed monotonic clocks (DMC) whose timestamps can reflect causality but which have a component that stays close to wall clock time. This scheme builds on previous hybrid logical clock proposals by adding important operational hooks and by building in mechanisms to prevent a single runaway system clock from dragging a whole cluster's logical clocks forward into the future. More at YouTube.
Documentation for running RDK profiles ( Video, broadband, Camera ) on Raspberrypi boards.
Traffic Control is a caching server control plane application used to aggregate caching servers into a Content Delivery Network (CDN).
The CDN caching software chosen for Traffic Control is Apache Traffic Server (ATS). Although the current release only supports ATS as a cache, this may change with future releases.
Running YARN on Kubernetes with PetSet controller.
Apache Hadoop YARN (Yet Another Resource Negotiator) is a cluster management technology. This allows you to build an Image for deploying the kube-yarn artifacts without any local dependencies.
Server remediation as a service
Bynar is an open source system for automating server maintenance across the datacenter. Bynar builds upon many years of experience automating the drudgery of server repair. The goal is to have the datacenter maintain itself.
A tool for testing and validation of firewall rules
In a firewall heavy environment, being able to test and validate your firewall rules is essential. This utility aims to automate that by having "rules files" which this script then procesess and will SSH into each machine and try connecting to the target host on the specified port.
A dashboard accelerator for Prometheus
Trickster is a reverse proxy cache for the Prometheus HTTP APIv1 that dramatically accelerates dashboard rendering times for any series queried from Prometheus.
Making DNS self-service safe, secure, and convenient.
VinylDNS is a vendor-agnostic frontend for enabling self-service and enhancing administration across all of your DNS servers.
Custom Views for drawing Dotted and Dashed Lines without jumping through hoops.
MVP String ResourceProvider API Generator for Android
A LoadingDots view based on AnimatedVectorDrawable. Backwards compatible to API 11
Curtail is a utility program that reads stdin and writes to a fixed size file.
Easy synthetic testing for Kubernetes clusters. Supplements other solutions like Prometheus nicely.
Kuberhealthy performs synthetic tests from within Kubernetes clusters in order to catch issues that would otherwise go unnoticed.
Run your cucumber-jvm tests in parallel across all your devices.
Zucchini sits on top of cucumber-jvm and maven to provide higher testing throughput by enabling concurrent test execution. A test author specifies a description of each of the devices (or browsers) under test as well as the cucumber feature files to execute and zucchini runs the tests in parallel with a separate backing cucumber runtime for each device under test. Upon completion, all of these tests are compiled into a single report made available in an html format.
gots (Go Transport Streams) is a library for working with MPEG transport streams.
It provides abstractions for reading packet information and program specific information (psi).
Package currently provides AAC parsing capabilities. This package performs a full parse of AAC-LC and HE-AACv1 bitstreams. Bitstreams with Parametric Stereo (HE-AACv2) are not yet supported, but AAC bitstream data and SBR data will be extracted. The AAC decode from the parsed data to LPCM (.wav) is not yet implemented. Please help us expand and test this library!
WebPA is a combination of a server and client that provide a simple interface to access the TR-181 objects on an RDK device. WebPA leverages XMiDT for the connection to the RDK device.
Webpa is a very simple micro service and client that provides a REST interface to access the TR-181 data model on an RDK device.
XMiDT (pronounced "transmit") is a combination of a server cluster and client that provide a highly available data path to devices deployed all over the world.
A device connects to the XMiDT cloud via the xmidt client. Cloud based services can use the XMiDT cloud api to send and receive messages from the devices without needing to worry about where the device is in the world or in the network. Push and pull data from the device with ease.
Codex provides a historical context about devices connected to XMiDT.
Codex accepts incoming events, stores them in a postgres database, and provides event information by device id.
C implementation of the Web Routing Protocol
The goal of this layer is to enable devices to interact with a centralized web router (cluster) that routes the messages to/from various services on the other side. From the service perspective, this layer provides a centralized mechanism to directly interact with millions of authorized devices in the field in a scalable manor.