2. 2
Hyperty
Microservice (Independently deployable Business Capability) similar to user
agents or bots, perform tasks on user's behalf
An instance is associated to a “User” through an identity
The Identity is decoupled from the Service Provider
2
Hyperty – User
Association
Hyperty – User
Association
3. 3
No need to standardise Service Network Protocols or Service APIs
{
"id": "HelloObject",
"type": "object",
"required": ["hello"],
"additionalProperties": false,
"properties": {
"scheme": {
"constant": "hello"
},
"hello": {
"type": "string"
}
}
}
Service Interoperability with agreements on the data formats, only.
Inherently Inter-operable
5. 5
Write
O
JSON Data
Object
Communication via Data Synchronisation
Streams
Read Changes
Read Changes
Reporter
Observer
Observer
Observer
A
hello://example.com/201601290617
hyperty://example.com/sdfg-fdjhgj
B
C
D
hyperty://example.io/hfgdjhfg-jkhkjjdf
hyperty://foo.net/hfgdjhfg-jkhkjjdf
hyperty://example.org/hfgdjhfg-jkhkjjdf
6. 6
Connector Hyperty
Hyperties supporting Connection schema are able to handle WebRTC Peer Connections
independently of the signalling protocol used. The Connection schema is defined from the
W3C WebRTC data model.
The URL Scheme for Connection Data Objects is "connection" (example:
"connection://example.com/201601290617")
A
Connection
B
Connection
7. 7
A Context B
Context Hyperty
C
D
Hyperties supporting Context Data Schema are able to produce or consume
Context Data, usually collected from sensors. Compliant with Jenning’s IETF Draft
Sensor Markup Language (SenML).
The URL Scheme for Context Data Objects is "context“. Example:
context://example.com/room/temperature201601290617").
10. 10
Decentralized
A Decentralized Resource Oriented Messaging Framework is used for
communication.
Publish/subscribe and request/response messaging patterns are
supported.
10
11. 11
Message Delivery Layers
11
Hyperty Runtime Hyperty Runtime
Msg Node
Msg BUS
Sandbox
Msg BUS
Mini
BUS
HH
Sandbox
Mini
BUS
HH
Domain level
Message Delivery
Runtime level
Message Delivery
Sandbox level
Message Delivery
Sandbox
Mini
BUS
HH
Sandbox
Mini
BUS
HH
Native Standard
Hyperty
JSON Messaging
Any Messaging
Protocol
(Protofly)
P2P
12. 12
Protocol on-the-fly – Protofly
Protocol on-the-fly leverages the code on-demand support by Web runtimes (e.g.
Javascript)
The most appropriate protocol stack is dynamically selected loaded and instantiate
during run-time
Protostub
Protostub
13. 13
Data Synch Stream Routing Path
Data Synchronisation
Routing Path
Add Listeners to setup
Data Sync Routing Path
Data Sync Routing
Path Management
between Msg Node
and Runtimes
14. 14
Trust Model
1-Intercept
Outgoing Message
3-Msg with
Assertion
4-Intercept
Incoming
Message
6-Message
with Assertion
Validated
5-Validate
Assertion
2-Generate
Assertion
• Identity tokens are generated, inserted in intercepted Messages sent by Hyperties, and
validated by recipient Hyperty Runtimes before delivered to the target Identity.
• Identity management procedures are performed according to applicable policies
managed by the end-user.
15. 15
H1
P1
Load
Hyperty
H3
Register Hyperty Instance
H1
Service Provider
Message Node
Registry
Catalog
H1 P1
Edge Server Runtime
H2
Messaging Communication
between Hyperties
User
Device Runtime
IDP
Proxy
Identity Provider
Generate
Assertions
Validate
Assertions
reTHINK Service Delivery Framework
Global registry
trusted circleDiscover
Hyperties provides a few unique advantages:
- Hyperty reinforces modular structure, which is particularly important for larger and complex Applications.
- Hyperties from different Service Providers can easily cooperate with no federation required or the standardisation of Protocols.
- Hyperties uses a simple but powerful Trust model where the User Identity is decoupled from the Hyperty Service Provider enabling the end-user to decide which is the Identity to be used with a certain Hyperty instance.
- Hyperties follow edge computing principles, promoting a more effective usage of computing and network resources, as well as decreasing communication latency.
- the development of Hyperties and Applications is very easy and flexible, giving the freedom to the developer to select its favorite web framework.
Hyperties can be used on any Application Domain, but they are specially suitable for Real Time Communication Apps (eg Video Conference and Chat) as well as IoT Apps.
Enables the end-user to decide which Identity shall be used with a certain Hyperty instance
The Messaging Framework works at three layers:
At the Runtime Sandbox level where Hyperties are executing, message delivery is provided by the MiniBUS component.
At the Runtime level where Sandboxes are hosted (e.g. in a Browser or in a NodeJS instance), message delivery is provided by the [Message BUS component], which is an extension of the MiniBUS.
At Domain Level, message delivery is provided by the Message Node functionality by using the [Protofly mechanism], i.e. communication between Message BUS and Message Nodes and among Message Nodes are protocol agnostic. This also means that the Message Node can be provided by any Messaging solution as soon as there is a [Protostub available]. Currently, a [Vertx Message Node], a [Matrix Message Node and a [NodeJS Message Node] are provided. These are just reference implementations of Message Nodes and anyone is free to develop its own Message Node.
At runtime level (MessageBUS and MiniBUS), it is used a standard CRUD based [JSON Message Model] which is easily mapped into Restfull APIs.
Protofly enables protocols to be selected at run-time and not at design time, enabling protocol interoperability among distributed services, promoting loosely coupled service architectures, optimising resources spent by avoiding the need to have Protocol Gateways in service's middleware as well as minimising standardisation efforts. The implementation of the protocol stack, e.g. in a javascript file, that is dynamically loaded and instantiated in run-time is called **Protostub:**. For security reasons, Protostubs are executed in isolated sandboxes and are only reachable through the Runtime MessageBUS and the Protostub Sandbox MiniBUS.