Proposals

The Eclipse SDV Blueprints project hosts different blueprints of how to apply technologies developed in the scope of the projects of the Eclipse SDV working group (sdv.eclipse.org). This makes it possible to highlight the capabilities and features of the software provided by the Eclipse SDV working group and explore potential for collaboration and integration of these technologies.

A blueprint is an examplatory use case implementation based on artifacts created in the scope of participating SDV projects and adjacent OSS technologies together with some blueprint specific code that ties it all together.

Adopters of a blueprint can then see all the moving parts and can participate in the future development of the software to ensure it meets their future needs as well. With these blueprints, the goal is not to define how everyone will tackle these problems, but to get something usable out, see how people make use of it, and to get feedback on it. This feedback can either be channeled backed into the blueprint or forwarded to the utilized projects.

The Eclipse Documentation for Jakarta EE project hosts documentation intended for programmers interested in developing and deploying Jakarta EE applications. It covers the technologies comprising the Jakarta EE platform and describes how to develop applications using Jakarta EE components and deploy them on the Eclipse GlassFish and other popular runtimes.

Eclipse Ankaios manages multiple nodes and virtual machines with a single unique API in order to start, stop, configure, and update containers and workloads. It provides a central place to manage automotive applications with a setup consisting of one server and multiple agents. Usually one agent per node connects to one or more runtimes that are running the workloads.

Eclipse Ankaios follows the UNIX philosophy to have one tool for one job and do that job well. It does not depend on a specific init system like systemd but can be started with any init system. It also does not handle persistency but can use an existing automotive persistency handling, e.g. provided by AUTOSAR Adaptive.

The workloads are provided access to the Eclipse Ankaios API using access control and thus are able to dynamically reconfigure the system. One possible use case is the dynamic startup of an application that is only required in a particular situation such as a parking assistant. When the driver wants to park the car, a control workload can start the parking assistant application. When the parking is finished, the parking assistant workload is stopped again.

Eclipse Ankaios also provides a CLI that allows developers to develop and test configurations. In order to gain compatibility with Kubernetes, Eclipse Ankaios accepts pod specifications.

A cloud connector can use the Eclipse Ankaios API to connect to a cloud-based software update system, which allows an OEM to manage a fleet of vehicles and provide new states to Eclipse Ankaios in order to update single or all applications. The cloud connection is optional, Eclipse Ankaios also works as standalone component.

In order to support the Automotive SPICE process, Eclipse Ankaios comes with requirements tracing supported by OpenFastTrace.

The Eclipse Dataspace TCK will consist of a modular test harness that can be extended to verify multiple Dataspace protocols and standards. The core framework is written in Java but can verify runtimes and services implemented in other programming languages. The framework is designed to be run in various contexts, such as a development command line, a continuous integration pipeline, or an online service.

The Eclipse Dataspace TCK's first compliance extension will be for the IDS Datasapce Protocol (https://github.com/International-Data-Spaces-Association/ids-specification). This compliance extension will test all normative statements in the protocol specifications. Specification implementors will be able to run the tests against their software to assist in development and to provide an independent mechanism to validate conformance.   

Eclipse XFSC (Cross Federation Services Components) develops the software components necessary to set up a federated system that interconnects several participants in a data and service infrastructure with each other, aiming to develop new data-driven services and innovative products. Such ecosystems consist of joined interconnected data and infrastructure ecosystems, aggregated in so-called Federations that are individually orchestrated and operated with the help of Federation Services, part of Gaia-X.

It consists of several components (mainly microservices) enabling federations in data ecosystems and providing interoperability across federations.

The Eclipse XFSC Toolbox provides a set of services for the functional implementation of Self Sovereign Identities, W3C credential management, Trust Services, database functions for knowledge graphs, usage policy negotiation and a core Low Code Engine. The main purpose is the operational uptake of federations as decentralized ecosystems.

Eclipse XFSC is to be seen as the implementation of a suite of solutions – providing for the minimum technical requirements to empower Federations to become operational and to allow organizations to participate in a world of Self Sovereign Identity and data ecosystems. The Eclipse XFSC toolbox defines a range of components necessary to fulfil the Gaia-X’s objective of building trust and interoperability, and ensuring participants retain sovereignty over their data. Concretely, the first set of services delivered are:

Identity & Trust

These services empower federations to authenticate and authorize participants in a federation, for example via credential validation, and cover technology functionalities to ensure a consistent level of trust between all Participants of a federation.

• Authentication & Authorization Service (AAS)
• Personal Credential Manager (PCM)
• Organization Credential Manager (OCM)
• Trust Services (TRU)
• Notarization Service (NOT)

Self-Description/Catalogue

The Federated Catalogue is the repository of one Federation, enabling participants to find other participants’ information and service offerings in the shape of the Self-Descriptions. The toolbox provides the basic code for each Federation to build their own Federated Catalogue. Once a service offerings has been found, the toolbox also provides services that can facilitate contract negotiations and keep track of data transactions within Federations. These will empower Participants to determine and keep track of how their data is used through different transactions.

• Federated Catalogue (CAT)
• Self-Description Wizard (SD-Wizard)
• Data Contract Transaction (DCT)
• Data Exchange Logging Service (DELS)

Tooling

The Toolbox also contains services supporting federations with handy functionalities to organize itself. E.g., the Portal serves as a sample integration layer showcasing the Federation Services and providing user-friendly access to these services. A Workflow Engine is delivered aiming at improving complex application networking, e.g., the implementation and configuration of Onboarding & Accreditation workflows for federations. Furthermore, it contains functionalities for sample service orchestration and provisioning as well as compliance monitoring based on EUCS metrics.

• Portal (POR)
• Workflow Engine (WFE)
• Continuous Automated Monitoring (CAM)
• Orchestration (ORC)

Eclipse Keypop open source interfaces will initially be available in Java and C++, designed on the same mutual Object-Oriented Model.

The 'Reader API' is a high-level interface used by terminal applications to operate smart card readers, it:

• provides the means to identify card readers and verify the presence of smart cards,
• offers the possibility to configure the observation of readers in order to be notified on card insertion or withdrawal,
• is the entry point to manage the selection of a smart card in a specific reader.

The 'Card API' defines the internal elements shared by the reader layer to implement specific ticketing card extension.

The 'Calypso API' is an extension of the Reader API which provides a high-level API standardizing the way to interact with Calypso cards.

• The Calypso Card API provides the means to select a target card and then perform a secure transaction with the selected target.
• The Calypso Crypto Legacy SAM API is the interface to manage security modules.

Purpose

Connecting Automotive Apps and Services, Everywhere

The purpose of this project shall be to provide a transport agnostic, layered communication protocol that builds on top of existing automotive and Internet standards, from the mechatronic layer (between ECUs, VMs, etc…) up to the Cloud, enabling a connected software defined vehicles.

Overview

The protocol is divided up into three layers:

• Application Layer (uP-L3):
  • Responsible for business/application logic through definition of methods, topics, messages
  • Core Platform uEs (uSubscription, uDiscovery, etc...)
• Communication Layer (uP-L2):
  • Describing data & metadate in a common way using CloudEvents: publication/notificaitons, request/response, file transfer, etc...
  • Routing & Dispatching of events through Dispatchers (uBus, uStreamer, Device Proxy Router, Cloud Proxy)
• Transport Layer (uP-L1):
  • Sending & receiving of events point-2-point between Software Entities (uEs)
  • Session an connection over automotive & Internet standards

For more information about uProtocol please visit: Overview of uProtocol

Project Contents

The uProtocol project shall contain that contain a number of children repos that are:

1. eclipse-uprotocol/uprotocol: Protocol specification & various layers interface definitions  and interface definitions
2. eclipse-uprotocol/uprotocol-sdk-java: Java Software development Kit (implements uP-L2 and includes other helper code for the protocol)
3. eclipse-uprotocol/uprotocol-sdk-cpp: Same as Java SDK but for C++
4. eclipse-uprotocol/uprotocol-android: Android implementation of uProtocol, both the transport protocol (Binder) and core dispatchers and application logic 

Eclipse Tocandira is a collection of tools aiming to help industries to remove their barriers on observability. To achieve this goal it uses the cutting edge technologies in the field. You will find the deploy easily configured with Docker, the connectivity with PLCs powered by 4diac, the gathering and storage done by Prometheus and the visualization shown with Grafana.Ec

Eclipse Tocandira was build focusing on:

• Reusability: Every technology chosen for this stack is the cutting edge of its field and the majority of them are well known in the IT world.
• Microservice Based: All services composing this application are truly independent and linked only by configurations, APIs and protocols.
• Cloud Native Architecture: These packages are usually applied for observability in IT world, and are therefore fully compatible with cloud environments, from instances to databases
• Small servers: Its components can run though several machines and consume little resources. It even runs on single board computers.
• Unlimited storage: Enough of charging for every variable read, the limit is only your hardware or the cloud capacity.

Eclipse SDV Developer Console (DCO) integrates necessary sources for software lifecycle management and there by optimizes the complete process from development to release of software. The core of DCO includes services for development, testing, simulations, release and lifecycle management of software. Hereby, DCOs mission is to automize as much as possible by using different concepts of re-usability and standardization by connecting different business roles along the software lifecycle on one source. As our open-source contribution, we focus on simulation of services with DCO.

With DCO you benefit from the concepts of standardization and re-usability. You can directly experience the scenario simulation in your productive environment. For instance simulate vehicle or fleet behaviours or use your own virtual vehicles or simulators to simulate backend services.

DCO comes with an user interface and related endpoints for backend interactions for defining your scenario, creating your simulation setup and to simulate your set of scenarios. In addition, your tool chain can be easily integreated to trigger a simulation with third-party applications, to analyze the simulation result and track the defects with your devops toolchain as well as the integration of applications for reporting and monitoring.

Eclipse Store provides a Java micro persistence layer built for cloud-native microservices and serverless functions written in Java. Eclipse Store is based on the system prevalence architectural pattern. It enables seamlessly storing any Java objects of any size and complexity transaction-save into cloud blob stores such as AWS S3 or any other binary data storage. Therefore, Eclipse Store provides connectors to various relational and NoSQL database systems. ACID transactions are journaled and changes in the system state are regularly saved to disk (deltas only). All transactions are stored in a highly optimized serialization byte format appended to the storage. To reduce startup time and run also with a small RAM capacity, Eclipse Store provides lazy loading. At the system start, only object IDs must be loaded into memory. Related object references (subgraphs) are only loaded and restored in memory on demand by calling common get methods. The Java Streams API is used for searching and filtering data in memory. Eclipse Store provides object versioning, dynamic class loading, and serialization control for handling class changes, ensuring that applications can continue to function even if classes are modified. Eclipse Store runs also on Android mobile, edge, and embedded devices.