Aperi Device Server Design R2
Document Author: Christoph Reichert
- 1 Introduction
- 2 Design Overview and Goals
- 3 Design Rationale
- 4 Open Items
- 5 Requirements Addressed and Features Provided
- 6 Main Components of the Architecture
- 6.1 Device Servers Platform Components
- 6.1.1 Discovery
- 6.1.2 Control
- 6.1.3 Monitoring/Alerting
- 6.1.4 Database
- 6.1.5 Other base components
- 6.2 Standard Technology Support
- 6.3 Device Support
- 6.3.1 Disk
- 184.108.40.206 Main Extensions
- 220.127.116.11 Extension Points and Interfaces/generic classes for Discovery and Probe
- 18.104.22.168 Extension Points and Interfaces/generic classes for Control
- 22.214.171.124 Extension Points and Interfaces/generic classes for Monitoring
- 126.96.36.199 ICIMIndicationHandler/DiskIndicationHandlerFactory
- 188.8.131.52 for Reporting
- 184.108.40.206 Other components
- 6.3.2 Tape
- 6.3.3 Fabric
- 6.3.4 IBM SVC (SAN Volume Controller)
- 6.3.1 Disk
- 6.1 Device Servers Platform Components
The primary goal of the 2nd phase of the Aperi Eclipse project is to add extensibility that is based on Eclipse technology.
This document describes the enhancements for extensibility for the Aperi device server. Because the device server is a combination of three functional blocks for disk, tape and fabric support, this document focuses on the separation and the dynamic extensibility of the functional blocks.
This document does not cover the design of the Aperi device sever itself. Changes to this design that are done because of the Aperi work will be discussed in this document.
Design Overview and Goals
A main goal for the Aperi project is to create a extensible platform where different parties can contribute by refining the existing base, adding new functions or extend specific functions. This can only be archieved by providing an extensible and modularised code base. Therefore the existing device server is split into separated plugins and features that provide base functionality like logging or generic discovery and device specific extensions like disk discovery.
The former device server consists of a service manager that starts up all components defined as "services" in a services.properties file and deployed them as webservices. The service manager itself was started as a servlet during initialization within a servlet container. Using the Eclipse/OSGi infrastructure the "services" will be redefined as OSGi services. A connector component will look for these services and publish their APIs as webservices. The code belonging to the service is defined as a OSGi bundle, so the OSGi container cares about the bundle lifecycle and service starting and stopping. Defining dependencies between the OSGi bundles and assigning them to different runlevels ensures the correct startup order of the bundles.
The implementations of the existing serivce and component registrations on execution of java code (e.g add object and constants to registry hashtable). With Eclipse plugin registration this should migrated to a XML-property based registration wherever possible, to support lazy service initialization.
This document does not cover the extensibility of the Aperi common services (like logging or job handling) but refers to needed extension points that have to be available. It is assumed that similar common services from the dataserver needs to be merged into single Aperi infrastructure components. Additional, existing plugins from other eclipse projects that provide such "common services" should be reviewed and included into the base Aperi infrastructure.
The design follows the existing building blocks the device server consists of and provide these as extensible components with less changes to the code as possible. Some components would require a large rework to provide detailed extensibility, these will be left as larger blocks which can be reworked as needed later in the Aperi project.
- Agent: The common components between agent and device server needs to be identified for server/agent communication
- Component shutdown/removal: There is no common strategie to deregister device server components. How can a component or the OSGi service container know if parts are used by running jobs or required by managed devices?
- Detectability: Detectability service is highly dependent on the underlying database schema, so we should consider to treat it as a database component. Detectability is not designed for dynamic extensibility, there are a lot of numeric constants and if-then-else constructs that need more in-depth analysis and design.
Requirements Addressed and Features Provided
Aperi Extensibility can be grouped in different categories:
- Special Device Extensibility
- Support for a kind of Storage Devices (like Disk Arrays) can be extended to support special features of a device or to provide a fix/workaround for a special device.
- Additional Device Extensibility
- Support for new kind of devices like NAS devices can be added to Aperi.
- API Extensibility
- The API provided by WebServices and internal Services can be extended.
Main Components of the Architecture
Device Servers Platform Components
The Infrastructure components have to be moved from the Device-Server to the Aperi platform. Some main building blocks need to be defined as Eclipse Plugins that the device-server apps can use and extend. Others are just used as-is and will not be separated in different plugins in this phase.
(org.eclipse.aperi.discovery) Aperi Discovery is a framework to detect storage devices and query their configuration data. The detection and identification of new devices or their providers is called "discovery", collection of the configuration data of a specific storage device is called "probe".
The abstract class DiscoverProcess is the main extension point for different process steps that has to performed for a discovery or device probe. If more than one DiscoverProcess step needs to be performed for a discovery, the IStep Interface provides a container for combining and executing different DiscoverProcess' in the required order.
Depending on the Device type discovered, number and sequence of the DiscoverProcess steps may vary. Therefore the different DiscoverProcesses are registered in the Router component, which selects the DiscoverProcess based on the DiscoverProcess name and different device attributes like Vendor name, device type etc, which is provided by the DiscoverProcess RegistrationData. Plugins that want to extend the Aperi Discovery has to implement the required DiscoverProcess and register them within the Router.
AbstractDiscoverProcess Router.addProcess() Router.registerProcess()
|Discovery and Probe functions for SLP, SNMP and G3|
The abstract Discover Process class provides common functionality for the Discovery framework. Derived classes implements the technology or device specific part of the discovery.
A DiscoverProcess needs to be registered within the Router by Name (Router.addProcess()) or Registration data (Router.registerProcess()) which is provided by a static getRegistrationData() method. In the first case a DiscoverProcess java-object is registered, in the second case the class itself is passed. The registration can be done by a startup method of a Discovery Service-Plugin or within a registerSteps() method of a main DiscoverProcess that registers all subsequent steps.
In Aperi two interfaces INamedDiscoverProcess and a IDiscoverProcess will cover both cases. INamedDiscoverProvess is implemented by the existing abstract DiscoverProcess class the IDiscoverProcess interface adds the getRegistrationData() and registerSteps() methods.
DiscoverProcess Extension Point Definition:
Identifier: org.eclipse.aperi.discovery.DiscoverProcess Configuration Markup: <!ELEMENT extension (DiscoverProcess+)> <!ATTLIST extension point CDATA #REQUIRED id CDATA #IMPLIED name CDATA #IMPLIED> <!ELEMENT DiscoverProcess EMPTY> <!ATTLIST DiscoverProcess DiscoverProcess CDATA #REQUIRED, implements org.eclipse.aperi.discovery.IDiscoverProcess Name CDATA #REQUIRED, SMISVersion CDATA SMISProfile CDATA Vendor CDATA Model CDATA InstrumentationVersion CDATA>
In future, both registration mechanism should be based on Eclipse plugin registration technology to allow lazy initialization and XML-based registration data. In this phase only the registerProcess()-based DiscoverProcess will be defined as DiscoverProcess extensions, while the Router will query and register the plugin registry for these DiscoverProcess. The addProcess-based DiscoverProcess are subsequent registered by calling the registerSteps() method or during startup of the device specific Discovery Service.
Interface and basic implementations for combining the DiscoverProcess needed for a full device Discovery or probe run.
Picks up and registers the DiscoverProcess from the eclipse extension registry and provide API for manual registration.
TODO: naming of registerSteps not correct, rename to registerDiscoverProcessByName() How to deregister DiscoverProcesses when plugin is stopped? Add deregisterSteps()?
Within Aperi, control functions like Volume creation on a storage subsystem are implemented using a Controller class. Plugins that want to provide control functions have to extend this abstract class, which cares for asynchronous execution of control tasks and job handling.
Control functions API are often published as WebServices.
Monitoring is used to detect configuration and state changes of devices in the SAN. Aperi will register and listen for messages and indications sent by devices. These are internally distributed by JMS queues. Alerting is also part of the data server and extensability is discussed in the Aperi Phase 2 Data server design.
Monitoring is handled by the IEventMonitorService, where the different events can be registered.
AlertPopulatorPlugin Extension Point Definition:
Identifier: org.eclipse.aperi.monitor.eventcorrelator.interfaces.IAlertPopulator Configuration Markup: <!ELEMENT extension (AlertPopultor+)> <!ATTLIST extension point CDATA #REQUIRED id CDATA #IMPLIED name CDATA #IMPLIED> <!ELEMENT DBAttributeMapper EMPTY> <!ATTLIST DBAttributeMapper DeviceType CDATA #REQUIRED DBAttributeMapper CDATA #REQUIRED, implements org.eclipse.aperi.monitor.eventcorrelator.interfaces.IAlertPopulator >
TableToEntitiyTypeMapping Extension Point Definition:
Identifier: org.eclipse.aperi.monitor.eventcorrelator.TableToEntitiyTypeMapping Configuration Markup: <!ELEMENT extension (AlertPopultor+)> <!ATTLIST extension point CDATA #REQUIRED id CDATA #IMPLIED name CDATA #IMPLIED> <!ELEMENT TableToEntitiyTypeMapping EMPTY> <!ATTLIST TableToEntitiyTypeMapping TableName CDATA #REQUIRED DeviceType CDATA #REQUIRED >
The Database definition, helper classes and utilities like "Detectability service" are described in the Aperi Database design document.
The Aperi database infrastructure defines some extension points that are mainly used by the discover and probe processes to translate device specific data into database entries and group tables to logical entities like a disk storage system. The data translation is done by database mappers that convert device and technologie specific properties like a CIM-SMIS class to generic values and store them to one or more database table entries.
The Aperi DB provides basic Mapper functions like a MapperPackage that registers all Mappers and a MapperRouter that select a specific Mapper for a given object and describing attributes. Also common mapper functions are provided with the DBAttributeMapper that can be extended for each table and device specific class.
AperiDBAttributeMapper Extension Point Definition:
Identifier: org.eclipse.aperi.infrastructure.mapping.DBAttributeMapper Configuration Markup: <!ELEMENT extension (DBAttributeMapper+)> <!ATTLIST extension point CDATA #REQUIRED id CDATA #IMPLIED name CDATA #IMPLIED> <!ELEMENT DBAttributeMapperEMPTY> <!ATTLIST DBAttributeMapper CIMClassName CDATA #REQUIRED DBAttributeMapper CDATA #REQUIRED, implements org.eclipse.aperi.infrastructure.mapping.DBAttributeMapper SMISVersion CDATA #REQUIRED DeviceType CDATA #REQUIRED InstrumentationVersion CDATA #REQUIRED Dedicated CDATA #for top level systems only, value 0-20 accoding to SMIS >
Other base components
|Other base components:
SANEventService ConfigService Alert
|Because these base functions are unlikely extended in the first Aperi release and because they might be merged with similar services existing on the data server, a separation into different plugins may not be useful in this phase.|
Standard Technology Support
Administration and configuration of different device types is based on the basic technologies like CIM/SMI-S or SNMP. Because Aperi platform should be extensible with additional "base technologies" and storage devices might rely on more than one of them, they are be separated in plugin-bundles.
The SMI-S CIM bundle provides all basic technologies from the SMI-S/CIM standard from version 1.0.x and 1,1. This includes constants for classes, names and properties defined in the SMIS standards, the sblimCIMClient and CIMOM Management. The following plugins and components will be defined:
Communication with the SMIS CIM Provider is done by use of the SBLIM CIM Client. It is not part of the Aperi project but bundled with the Aperi distribution, The Client API is wrapped by a CIMClientWrapper that adds more control to the communication like specific timeout values.
The list of known CIM Providers, their access info and additional attributes are managed by the CIMOMManager. Additional the CIMOMManager can be queried for a specific CIMOM to access a given storage device. As well a connection test is performed and faulty CIMOMs skipped.
ICIMOMManagementService extends IService CIMNames class. The SMIS standard defines Constant string variables for CIM classes, objects, methods etc. These constants are defined in the CIMNames constants class.
The Aperi framework for Discovery and Probe is based on querying device data, convert it to the database schema and persist it. The following components implements this for CIM/SMIS based data.
- CIM specific IStep implementations like caching of CIM elements.
The DB Mapper associate and convert the properties from the CIM objects to Aperi DB tables and fields. Mappers are registered within the MapperRouter of the DB component.
Registers and listen to SMIS/CIM Indications. It extends the Aperi Platform Monitoring and provides ICIMIndicationHandler/CIMIndicationHandler
The discovery extends the Aperi platform discovery by querying a given CIMOM for storage devices like fabric, disk or tape devices. Device properties are retrived to identify the device and store it into the Aperi database, afterwards a device type specific probe can be run to collect the device configuration.
- TopLevelDiscoveryProcess extends DiscoverProcess
Other standard technologies
Several other technologies are used by Aperi. Right now they are included within the Aperi platform or part of single devices but might be packaged in separate plugins later.
SLP discovery is part of the CIM/SMIS discovery. Therfore Aperi installation includes the sblim SLP implementation.
Aperi includes a module for the SNMP protocol.
Based on the Aperi platform, the device type specific components of the device-server for disk, fabric or tape devices are provided as Eclipse feature bundles. These extends the platform components for specific Discover/Probe, Configuration and Monitoring functionality and depends on the technology the device is based on. The bundles provide there own APIs for there function blocks and register them as WebService.
Aperi supports Storage Subsystems that implements the Array- and InbandVirtualizer Profile with SMIS versions of SMI-S 1.0.x and 1.1. Some vendor specific funcions and fixes for non-compliant devices are already included. In future the device specific cimponents might be separated in additional plugins.
|org.eclipse.aperi.disk.ManagerService||IDiskManagerService||Service registration/Bundle Lifecycle||-|
|Disk.Reporting||org.eclipse.aperi.disk.reporting||IDiskReportingService||no common plattform module|
IDiskManagerService extends IService
Extension Points and Interfaces/generic classes for Discovery and Probe
- ProbeGenericSubsystemProcess extends DiscoverProcess
- ProbeGenericMappingMaskingProcess extends DiscoverProcess
Extension Points and Interfaces/generic classes for Control
The IStorageConfigurationPlugin is the extension point for specific implementations of control functions. The StorageConfigurationPluginFactory needs to use the extension registry to fetch the StorageConfigurationPlugins and return them based on the extensions XML-properties.
StorageConfigurationPlugin Extension Point Definition:
Identifier: org.eclipse.aperi.disk.control.StorageConfigurationPlugin Configuration Markup: <!ELEMENT extension (StorageConfigurationPlugin+)> <!ATTLIST extension point CDATA #REQUIRED id CDATA #IMPLIED name CDATA #IMPLIED> <!ELEMENT StorageConfigurationPlugin EMPTY> <!ATTLIST StorageConfigurationPlugin StorageConfigurationPlugin CDATA #REQUIRED, implements org.eclipse.aperi.disk.control.IStorageConfigurationPlugin SMISVersion CDATA #REQUIRED DeviceType CDATA #REQUIRED >
Extension Points and Interfaces/generic classes for Monitoring
The ICIMIndicationHandler is the extension point for different SMIS or device specific CIM-indications. DiskIndicationHandlerFactory has to dynamically register the IndicationHandlers from the plugin registry.
CIMIndicationHandler Extension Point Definition:
Identifier: org.eclipse.aperi.disk.monitor.CIMIndicationHandler Configuration Markup: <!ELEMENT extension (CIMIndicationHandler+)> <!ATTLIST extension point CDATA #REQUIRED id CDATA #IMPLIED name CDATA #IMPLIED> <!ELEMENT CIMIndicationHandler EMPTY> <!ATTLIST CIMIndicationHandler IndicationHandler CDATA #REQUIRED, implements org.eclipse.aperi.disk.monitor.ICIMIndicationHandler CIMClassName CDATA #REQUIRED IndicationClassname CDATA #REQUIRED >
The disk component defines a common LogTraceHelper class for all disk related logging, encapsulating the underlying logging service.
Aperi supports discovery/probe and reporting for Tape devices following the SMI-S 1.1 standard. Because the structure and implementation of the Tape component is similar to Disk, there is only a list of the Extensions and interfaces provided.
|org.eclipse.aperi.tape.ManagerService||ITapeManagerService||Service registration/Bundle Lifecycle||-|
Extension Points and Interfaces/generic classes
- for Discovery and Probe
ProbeGenericTapeLibraryProcess extends DiscoverProcess
- for Monitoring
- for Reporting
Aperi supports Switch and Fabric discovery and configuration using SNMP and G3 protocol.
The Fabric support includes SNMP and G3 protocol support. Only the basic plugin APIs are defined for this release and a more modular fabric application structure is introduced with the integration of the fabric SMI-S support.
IFabricManagerService extends IService
Extension Points and Interfaces/generic classes
- for Discovery and Probe
Scanner implements IScanner SNMPScanner IFabricCollectionService
- for Control
- for Monitoring
- for Reporting
IBM SVC (SAN Volume Controller)
IBM SAN Volume Controller (SVC) provides some additional support that goes beyond the standard SMIS InbandStorageVirtualizer Profile. To demonstrate the Aperi Extension capabilities the SVC support resides in a separate Plugin Bundle. The SVC support will add additional API methods specific to the IBM SVC device and has to register revice specific discovery/probe and configuration modules. Main Extensions Component plugin Extension points Comments org.eclipse.aperi.disk.SVCManagerService IDiskSVCManagerService Service registration/Bundle Lifecycle Disk.Control org.eclipse.aperi.disk.control IDiskSVCConfigurationService
SVCManagerService extends DiskManagerService Extension Points and Interfaces/generic classes - for Discovery and Probe
ProbeSVCSubsystemProcess extends ProbeGenericInbandVirtualizer ProbeSVCMappingMaskingProcess extends ProbeMappingMaskingProcess - for Control
IDiskSVCConfigurationService - for Monitoring
no special Monitoring for SVC device, the base Disk Monitoring component will be used. - for Reporting
no special Reporting for SVC device, the base Disk Monitoring component will be used.
External Interfaces and Semantics
Programmatic Interfaces (APIs)
Document the new or modified APIs delivered with this component. Include information about their signatures, behavior, outputs, and error handling.
Security and Authentication
The different device server components include no security or authentication mechanism. A user and roles concept might be added at the external (webservice) API level, but is not part of this design document
Installation and Configuration
All Device Server components are packaged as OSGi bundles/Eclipse features and installed into an OSGi Container on top of the Aperi platform. Also a Aperi database must be installed and running. The technology support bundle requires the Aperi platform, the device support bundles require the Aperi platform and may require one or more technology support bundles. The resolving of bundle and plugin dependencies is done by the OSGi Container.
Identify the configuration required to utilize the components. Does this configuration occur during installation or after installation?
Please elaborate on any globalization issues.
Identify all open source code that is used that is not owned by Aperi. If non-Aperi open source code is used, identify the origin or the owner of the source code and any binding legal agreement.