Class DiagDriverAdapter

java.lang.Object
io.nosqlbench.nb.api.components.core.NBBaseComponentMetrics
io.nosqlbench.nb.api.components.core.NBBaseComponent
io.nosqlbench.adapters.api.activityimpl.uniform.BaseDriverAdapter<DiagOp,DiagSpace>
io.nosqlbench.adapter.diag.DiagDriverAdapter
All Implemented Interfaces:
SyntheticOpTemplateProvider, DriverAdapter<DiagOp,DiagSpace>, DriverAdapterDecorators, NBComponent, NBComponentAdvisors, NBComponentEvents, NBComponentMetrics, NBComponentProps, NBComponentServices, NBComponentTimeline, NBProviderSearch, NBTokenWords, NBCanConfigure, NBCanReconfigure, NBConfigModelProvider, NBConfigurable, NBReconfigModelProvider, NBReconfigurable, NBLabeledElement, AutoCloseable
public class DiagDriverAdapter extends BaseDriverAdapter<DiagOp,DiagSpace> implements SyntheticOpTemplateProvider

  • Constructor Details

  • Method Details

    • getOpMapper

      public OpMapper<DiagOp,DiagSpace> getOpMapper()
      Description copied from interface: DriverAdapter
      Op Mapping

      An Op Mapper is a function which can look at a ParsedOp and create a matching OpDispenser. An OpDispenser is a function that will produce a special type DriverAdapter that this DriverAdapter implements. There may be many different ops supported by an adapter, thus there may be similarly many dispensers.

      Both OpMapper and OpDispenser are functions. The role of OpMapper is to map the op template provided by the user to an op implementation provided by the driver adapter, and then to create a suitable function for creating that type of operations, known as the OpDispenser.

      These roles are split for a very good reason: Mapping what the user wants to do with an op template is resource intensive, and should be as pre-baked as possible. This phase is the op mapping phase. It is essential that the mapping logic be very clear and maintainable. Performance is not as important at this phase, because all of the mapping logic is run during initialization of an activity.

      Conversely, op dispensing (the next phase) while an activity is running should be as efficient as possible.

      Specified by:
      getOpMapper in interface DriverAdapter<DiagOp,DiagSpace>
      Returns:
      a dispensing function for an DriverAdapter op generation

    • getSpaceInitializer

      public LongFunction<DiagSpace> getSpaceInitializer(NBConfiguration cfg)
      Description copied from interface: DriverAdapter

      This method allows each driver adapter to create named state which is automatically cached and re-used by name. For each (driver,space) combination in an activity, a distinct space instance will be created. In general, adapter developers will use the space type associated with an adapter to wrap native driver instances one-to-one. As such, if the space implementation is an AutoCloseable, it will be explicitly shutdown as part of the activity shutdown.

      It is not necessary to implement a space for a stateless driver adapter, or one which injects all necessary state into each op instance.

      Specified by:
      getSpaceInitializer in interface DriverAdapter<DiagOp,DiagSpace>
      Returns:
      A function which can initialize a new Space, which is a place to hold object state related to retained objects for the lifetime of a native driver.

    • getConfigModel

      public NBConfigModel getConfigModel()
      Description copied from class: BaseDriverAdapter
      In order to be provided with config information, it is required that the driver adapter specify the valid configuration options, their types, and so on.
      Specified by:
      getConfigModel in interface NBConfigModelProvider
      Specified by:
      getConfigModel in interface NBConfigurable
      Overrides:
      getConfigModel in class BaseDriverAdapter<DiagOp,DiagSpace>
      Returns:
      A valid configuration model for the implementing class

    • getReconfigModel

      public NBConfigModel getReconfigModel()
      Description copied from interface: NBReconfigurable
      Implement this method by returning an instance of ConfigModel. Any configuration which is provided to the NBReconfigurable.applyReconfig(NBConfiguration) method will be validated through this model. A configuration model is required in order to build a validated configuration from source data provided by a user.
      Specified by:
      getReconfigModel in interface NBReconfigModelProvider
      Specified by:
      getReconfigModel in interface NBReconfigurable
      Overrides:
      getReconfigModel in class BaseDriverAdapter<DiagOp,DiagSpace>
      Returns:
      A valid configuration model for the implementing class

    • getOpStmtRemappers

      public List<Function<String,Optional<Map<String,Object>>>> getOpStmtRemappers()
      Description copied from class: BaseDriverAdapter

      Provide a list of field remappers which operate exclusively on the 'stmt' field in the op template. These are useful, for example, for taking the 'stmt' field and parsing it into component fields which might otherwise be specified by the user. This allows users to specify String-form op templates which are automatically parsed and destructured into the canonical field-wise form for a given type of operation.


      Each function in this list is applied in order. If the function returns a value, then the 'stmt' field is removed and the resulting map is added to the other fields in the op template.


      If a driver adapter is meant to support the stmt field, then this must be provided. The use of the stmt field should be documented in the driver adapter user docs with examples for any supported formats. A default implementation does nothing, as it must be decided per-driver whether or not the stmt field will be used directly or whether it is short-hand for a more canonical form.


      If you want to automatically destructure stmt values into a map and inject its entries into the op template fields, simply provide an implementation like this:

       
     return List.of(stmt -> Optional.of(NBParams.one(stmt).getMap()));

      Overrides:
      getOpStmtRemappers in class BaseDriverAdapter<DiagOp,DiagSpace>
      Returns:
      A list of optionally applied remapping functions.

    • applyConfig

      public void applyConfig(NBConfiguration cfg)
      Description copied from interface: NBConfigurable
      Implementors should take care to ensure that this can be called after initial construction without unexpected interactions between construction parameters and configuration parameters.
      Specified by:
      applyConfig in interface NBCanConfigure
      Specified by:
      applyConfig in interface NBConfigurable
      Overrides:
      applyConfig in class BaseDriverAdapter<DiagOp,DiagSpace>
      Parameters:
      cfg - The configuration data to be applied to a new instance

    • applyReconfig

      public void applyReconfig(NBConfiguration cfg)
      Description copied from interface: NBReconfigurable
      This applies a configuration to an element AFTER the initial configuration from NBConfigurable.
      Specified by:
      applyReconfig in interface NBCanReconfigure
      Specified by:
      applyReconfig in interface NBReconfigurable
      Overrides:
      applyReconfig in class BaseDriverAdapter<DiagOp,DiagSpace>
      Parameters:
      cfg - The configuration data to be applied to a new instance

    • getSyntheticOpTemplates

      public List<OpTemplate> getSyntheticOpTemplates(OpsDocList opsDocList, Map<String,Object> params)
      Description copied from interface: SyntheticOpTemplateProvider
      If a driver adapter supports creating example op templates from bindings, it must implement this method to do so.
      Specified by:
      getSyntheticOpTemplates in interface SyntheticOpTemplateProvider
      Parameters:
      opsDocList - The existing doc structure, which should contain no fully defined op templates, but may contain other elements like bindings
      Returns:
      A list of op templates, size zero or more