All Classes and Interfaces
Class
Description
Base class for OSGi bundle validator.
Superclass for all config producers.
The parent class of classes having the role as the root of a config producer tree.
Superclass for all Processes.
Helper class for http access control.
Validates that 'access-control' does not include any exclusions unless explicitly allowed.
Validates that 'access-control' is not enabled when no access control filter implementation is available.
Adds the attribute summary transform (
SummaryTransform.ATTRIBUTE to all SummaryField having an imported
field as source.This processor creates a
SDDocumentType for each Schema
object which holds all the data that search
associates with a document described in a search definition file.This is the admin pseudo-plugin of the Vespa model, responsible for
creating all admin services.
Config model adaptor of the Admin class.
Represents a set of affinities that can be expressed by a service.
A collection of objects representing the content of an application package.
Application builder.
This is the parent of all ConfigProducers in the system resulting from configuring an application.
A container that is typically used by container clusters set up from the user application.
A container cluster that is typically set up from the user application.
A search-time document attribute (per-document in-memory value).
The attribute collection type enumeration
The attribute type enumeration
Validates the changes between the current and next set of attribute fields in a document database.
The set of all attribute fields defined by a search definition
Checks that attribute properties only are set for attributes that have data (are created by an indexing statement).
Fields that derive to attribute(s) and no indices should use the WORD indexing form,
in a feeble attempt to match the most peoples expectations as closely as possible.
Metrics used for autoscaling
URI binding pattern used by filter and handler bindings.
Checks that bolding or dynamic summary is turned on only for text fields.
Validates attribute fields using bool type, ensuring the collection type is supported.
Transforms
a && b into if(a, b, false)
and
a || b into if(a, true, b)
to avoid computing b if a is false and true respectively.
Encapsulates values required for predicate fields.
Represents configuration for bucket splitting.
Adds field sets for 1) fields defined inside document type 2) fields inside search but outside document
This object builds a bundle instantiation spec from an XML element.
A validator for bundles.
Describes if items should preserve lower/upper case, or shall be uncased
which normally mean they are all normalized to lowercase.
Check that data plane certificates are not removed from a cluster.
Represents a component chain in the vespa model.
ChainedComponent<T extends com.yahoo.component.chain.model.ChainedComponentModel>
Builds a regular ChainedComponentModel from an element.
Root config producer the whole chains model(contains chains and components).
Creates a partial ChainSpecification without inner components
Builder of a message describing the changes in a given field.
Interface for validating changes between a current active and next config model.
This interface describes a character stream that maintains line and
column number positions of the characters.
This is a placeholder config producer that makes global configuration available through a single identifier.
Represents a client.
Validates that only allowed-listed cloud applications can set up user-specified filter chains
Helper object for CloudWatch configuration.
Used if clustercontroller is run standalone (not as part of the config server ZooKeeper cluster)
to provide common configs to container components.
Sets up a simple component to keep the state of the cluster controller, even when configuration changes.
Config generation for common parameters for all fleet controllers.
Model serving class.
Container implementation for cluster-controllers
Container cluster for cluster-controller containers.
Class tracking the feed block resource limits for a content cluster.
This interface describes the configs that are produced by the model producer root.
Utils used to check whether a complex field supports being represented as struct field attributes.
Validates that complex fields (of type struct or map) that have struct field attributes are supported.
Validates that complex fields (of type struct or map) do not have any struct fields with 'indexing: index'.
Component<CHILD extends AbstractConfigProducer<?>,MODEL extends com.yahoo.osgi.provider.model.ComponentModel>
Creates component models and component references from xml for a given scope.
A config model is an abstract representation of a subsystem, which is used
by the builder of that subsystem to derive a config producer tree for the subsystem, and by other
builders to access information about the subsystem for config production at a suitable abstraction level.
Builds a config model using DOM parsers
This class contains a context that is passed to a model builder, and can be used to retrieve the application package,
logger etc.
A
ConfigModelId describes an element handled by a ConfigModelBuilder.Interface for factories of config models.
A resolver of implementations of named config models.
A collection of config model instances owned by a system model
An interface which provides addition of new config models.
Interface that should be implemented by all config producing modules
in the vespa model.
A group of config producers that have a component id.
Intended to be used as an external interface to the vespa model root.
There is one config proxy running on each Vespa host, and one instance of
this class is therefore created by each instance of class
Host.There is one config-sentinel running on each Vespa host, and one
instance of this class is therefore created by each instance of
class
Host.Represents a Configserver.
Represents a config server cluster.
Builds the config model for the standalone config server.
Configure SSL with PEM encoded certificate/key strings
Configure SSL using file references
Compares the config instances in the current and next Vespa model to determine if some services will require restart.
ConstantTensorJsonValidator strictly validates a constant tensor in JSON format read from a Reader object
Transforms named references to constant tensors with the rank feature 'constant'.
RankingConstantsValidator validates all constant tensors (ranking constants) bundled with an application package
Note about components: In general, all components should belong to the cluster and not the container.
Parent class for all container cluster types.
A model of a container cluster.
Configuration of components for stateless model evaluation
Returns a restart action for each container that has turned on
QrConfig.restartOnDeploy().Holder for components and options related to either processing/search/docproc
for a container cluster.
Component definition for a
Executor using ContainerThreadPool.The config model from a content tag in services.
A content cluster.
Checks that this does not remove a content cluster (or changes its id)
as that means losing all data of that cluster.
Common class for config producers for storage and distributor nodes.
Encapsulates the various options for search in a content model.
Checks that this does not remove a data type in a cluster, as that causes deletion
of all data of that type.
A machine learned model imported from the models/ directory in the application package, for a single rank profile.
Helper for converting ParsedField etc to SDField with settings
Helper for converting ParsedRankProfile etc to RankProfile with settings
Class converting a collection of schemas from the intermediate format.
Helper class for converting ParsedType instances to DataType
Class converting a collection of schemas from the intermediate format.
Adds a "fieldName_zcurve" long attribute and "fieldName.distance" and "FieldName.position" summary fields to all position type fields.
Class to produce unique names for DataType instances that have
different contents even when their getName() and getId() may be
equal.
Represents a set of query profile variants (more or less) as they were declared -
a helper to produce config, which is also using the "declared" representation
Metrics for the 'default' consumer, which is used by default for the generic metrics api and
other user facing apis, e.g.
Monitoring service properties
The rank profile containing default settings.
Encapsulates a minimal set of Vespa metrics to be used as default for all metrics consumers.
Builds Dependencies (provides, before, after) from an element.
Validate deployment spec (deployment.xml).
Contains various state during deploy that should be available in all builders of a
ConfigModelSuperclass of all derived configurations
A set of all derived configuration of a schema.
Facade for deriving configs from schemas
Represents settings for dictionary control
Propagates dictionary settings from field level to attribute level.
Non-primitive key types for map and weighted set forbidden (though OK in document model)
Represents a dispatcher component - an instance of a dispatcher in a search container cluster
knows how to communicate with one indexed search cluster and owns the connections to it.
Class representing a group of @link{SearchInterface} nodes and a set of @link{Dispatch} nodes.
Class used to build the mid-level dispatch groups in an indexed content cluster.
Represents the dispatch setup for a content cluster.
A dispatch group with a list of nodes contained in that group.
Reference to a node which is contained in a dispatch group.
Tuning of dispatching to content nodes, see the
dispatch tuning documentation.
Represents specific configuration for a given distributor node.
Generates distributor-specific configuration.
Creates all docproc chains from xml.
Represents a document database and the backend configuration needed for this database.
Validates the changes between a current and next document database that is part of an indexed search cluster.
Handles the document bindings (concrete document types).
Validates that there are no cycles between document types (exception: self-reference is allowed).
DocumentModel represents everything derived from a set of schemas.
A search that was derived from an sd file containing no search element(s), only
document specifications, so the name of this is decided by parsing and adding the document instance.
This class is responsible for generating all hops and routes for the Document protocol running on message bus.
Represents a document reference.
Resolves all document references in the search definitions
Iterates through all document fields having a
NewDocumentReferenceDataType and uses NewDocumentReferenceDataType.getTargetTypeName()
to determine the referenced document.Contains all document references for a document mapped by field name
A rank profile which ignores all calls made to it which may fail in a document only setting.
A document summary definition - a list of summary fields.
Validates the changes between a current and next document type used in a document database.
A base class for admin model builders, to support common functionality across versions.
Builds the admin model from a V2 admin XML tag.
Builds the admin model from a version 4 XML tag, or as a default when an admin 3 tag or no admin tag is used.
Utility class for instantiating a builder using reflection.
Base functionality for all chain builders (docprocChain, searchChain, provider, source)
DomChainsBuilder<COMPONENT extends ChainedComponent<?>,CHAIN extends Chain<COMPONENT>,CHAINS extends Chains<CHAIN>>
NOTE: This class _must_ be abstract, due to calling subclass method in ctor.
Builder that transforms xml config to a slime tree representation of the config.
Builder for the dispatch setup for a content cluster.
Builds a docproc chain from xml
Builds the docproc chains model from xml.
Builds a DocumentProcessor from XML.
Builds a federation searcher config producer from an element.
Root builder of the processing model
Builds a processor from XML.
Builds a provider from xml.
Builder for feed block resource limits.
Builds the Routing plugin
Builds a Search chain from xml.
Builds the search chains model from xml.
Builds a Searcher from XML.
Builder for the tuning config for a search cluster.
Builds a source from xml.
Parses a string on the form:
[numbers]\s*[unit]?
Where numbers is a double, and unit is one of:
d - days
m - minutes
s - seconds
ms - milliseconds
Default is seconds.
This class contains utils used when handling summary fields with dynamic transforms during processing and deriving.
Creates the correct engine factory from XML.
The implementation of exact matching
Classes exportable to configurations
The transformations done on ranking expressions done at config time before passing them on to the Vespa
engine for execution.
Validates the use of the fast-access property.
Encapsulates the arguments of a specific model output
Utility methods for query, document and constant rank feature names
Builds federation options from a federations options element
Config producer for the FederationSearcher.
An operation on a field.
The rank settings of a field used for native rank features.
The result transformation of a named field
Searchable collection of fields.
The field sets owned by a
Schema
Both built in and user defined.Computes the right "index commands" for each fieldset in a search definition.
Constant values for ranking/model execution tied to a rank profile,
to be distributed as files.
ONNX models distributed as files.
File distribution config producer, delegates getting config to
FileDistributionConfigProvider (one per host)Utility methods for sending files to a collection of nodes.
Sets up VipStatusHandler that answers OK when a certain file is present.
Serves stor-filestor for storage clusters.
Takes the fields and indexes that are of type rank filter, and stores those names on all rank profiles
Delegates to a map that can be frozen.
Inlines functions in ranking expressions
Transforms function nodes to reference nodes if a rank profile function shadows a built-in function.
reads the common attributes and elements of all chained component elements.
A generic provider, used when no type is given.
A search chain that is intended to be used for federation (i.e.
Common utilities for recognizing fields with the built-in "position" datatype,
possibly in array form.
Determines the set of document types that are configured to be globally distributed.
Performs the following validations:
- Verify that all global documents have required redundancy
- Verify that all referred documents are present in services.xml
- Verify that all referred documents are global
Class that fails via exception if global attribute changes for a document
type in a content cluster unless corresponding override is present.
Models a jdisc RequestHandler (including ClientProvider).
The default threadpool for all handlers, except those that declare their own, e.g.
Configuration parameters for a hnsw index used together with a 1-dimensional indexed tensor for approximate nearest neighbor search.
A hostname with zero or more aliases.
A physical host, running a set of services.
Creates a
ConfigModelRegistry instance that simulates the hosted environment.Component specification for
ConnectorFactory with hosted specific configuration.Allocator for network ports on a host
A host representation.
A collection of hosts
A host provisioner based on a hosts.xml file.
The parent node for all Host instances, and thus accessible
to enable services to get their Host.
Represents the http servers and filters of a container cluster.
Wraps
ImportedComplexField as ImmutableSDField.Wraps
ImportedField as ImmutableSDField.An interface containing the non-mutating methods of
Schema.An interface containing the non-mutating methods of
SDField.Makes implicitly defined summaries into explicit summaries
This processor adds all implicit summary fields to all registered document summaries.
A complex field that is imported from a concrete field in a referenced document type and given an alias name.
A field that is imported from a concrete field in a referenced document type and given an alias name.
This class derives imported fields from search definition and produces imported-fields.cfg as needed by the search backend.
A set of fields that are imported from concrete fields in referenced document types.
Enumerates and emplaces a set of all imported fields into a SDDocumentType from
its corresponding Search instance.
Iterates all imported fields from schema parsing and validates and resolves them into concrete fields from referenced document types.
A simple field that is imported from a concrete field in a referenced document type and given an alias name.
A type of an index structure
An index definition in a search definition.
The index type enumeration
Resolver-class for harmonizing index-commands in multifield indexes
Class used to validate that hierarchic distribution is correctly setup when having an indexed content cluster.
Class used to retrieve combined configuration from multiple document databases.
Validates the changes between all current and next indexed search clusters in a vespa model.
Because of the way the parser works (allowing any token as identifier),
it is not practical to limit the syntax of field names there, do it here.
Per-index commands which should be applied to queries prior to searching
An index command.
This processor modifies all indexing scripts so that they input the value of the owning field by default.
Returns any change to the indexing mode of a cluster.
This processor modifies all indexing scripts so that they output to the owning field by default.
An indexing language script derived from a search definition.
Class used to build a message describing the usual field changes causing changes in the indexing script.
Validates the indexing script changes in all fields in the current and next search model.
Deriver of indexschema config containing information of all text index fields with name and data type.
Representation of an index field with name and data type.
Build an Inheritance object from an inheritance section.
Class resolving some inheritance relationships.
In memory host provisioner for testing only.
Replaces the 'index' statement of all numerical fields to 'attribute' because we no longer support numerical indexes.
Serves stor-integritychecker config for storage clusters.
Class wrapping parsing of schema files and holding a collection of
schemas in the intermediate format.
Generated juniperrc-config for controlling juniper.
A model builder that can be used to deal with toplevel config overrides and create another
producer in between.
Replaces instances of the lightgbm(model-path) pseudofeature with the
native Vespa ranking expression implementing the same computation.
Expresses literal boosts in terms of extra indices with rank boost.
Adds default search chains for all local clusters not mentioned explicitly
Config producer for search chain responsible for sending queries to a local cluster.
There is one logd running on each Vespa host, and one instance of
this class is therefore created by each instance of class
Host.Represents the Logserver.
Container that should be running on same host as the logserver.
Takes the aliases set on field by parser and sets them on correct Index or Attribute
All summary fields which are not attributes
must currently be present in the default summary class,
since the default summary class also defines the docsum.dat format.
A context which only contains type information.
Which match algorithm is used by this matching setup
Warn on inconsistent match settings for any index
Iterates all summary fields with 'matched-elements-only' and adjusts transform (if all struct-fields are attributes)
and validates that the field type is supported.
Defines how a field should be matched.
Validates the match phase settings for all registered rank profiles.
Helper class to model a metric.
A mutable helper class representing the user defined metrics and consumers.
A metric consumer is a set of metrics given an id that can be requested at runtime.
Models a metric set containing a set of metrics and child metric sets.
Container running a metrics proxy.
Container cluster for metrics proxy containers.
For testing purposes only
Use for testing.
A
ConfigModelBuilder that configures a dummy filter component to the AccessControl.ACCESS_CONTROL_CHAIN_ID filter chain.A config provider for the model config.
A w3c Element wrapper with a better API.
A model graph contains the dependency graph of config models.
Used to add builders and elements in addBuilder, and then build a dependency graph based on the
constructor arguments.
Replaces model id references in configs by their url.
Models used in a rank profile has the rank profile name as name space while global model names have no namespace
Represents a node in the dependency graph, and contains information about a builders dependencies.
A ModelsEvaluator object is usually injected automatically in a component if
requested.
Interface for monitoring services
Ensures that there are no conflicting types or field settings
in multifield indices, either by changing settings or by splitting
conflicting fields in multiple ones with different settings.
Abstract superclass of all multifield conflict resolvers
Class used to validate that multilevel dispatch is correctly setup in an indexed content cluster.
The definition of a rank type used for native rank features.
A set of rank type definitions used for native rank features.
A named rank table of a certain type.
A table type enumeration
Interface implemented by services using network ports, identifying its requirements.
Model for ReferenceDataType which is more suitable when
we want to end up with NewDocumentType as target type.
The implementation of "gram" matching - splitting the incoming text and the queries into
n-grams for matching.
Emits restart change actions for clusters where the node resources are changed in a way
which requires a "restart" (container recreation) to take effect.
Tuning of proton config for a search node based on the resources on the node.
Represents the group and partition id of a search interface node.
A common utility class to represent a requirement for nodes during model building.
match:prefix for indexed fields not supported
class representing the character normalization
we want to do on query and indexed text.
The current levels are as follows:
NONE: no changes to input text
CODEPOINT: convert text into Unicode
Normalization Form Compatibility Composition
LOWERCASE: also convert text into lowercase letters
ACCENT: do both above and remove accents on characters
A config model class registry that only forwards to the chained registry.
Attributes
A named attribute containing either singular float, integer, string, graph,
and tensor values, or repeated float, integer, string, graph, and tensor values.
Note: this enum is structurally identical to the OpSchema::AttrType
enum defined in schema.h.
Attributes
A named attribute containing either singular float, integer, string, graph,
and tensor values, or repeated float, integer, string, graph, and tensor values.
A set of pre-defined constants to be used as values for
the standard denotation field in TensorShapeProto.Dimension
for semantic description of the tensor dimension.
A set of pre-defined constants to be used as values for
the standard denotation field in TensorShapeProto.Dimension
for semantic description of the tensor dimension.
Graphs
A graph defines the computational logic of a model and is comprised of a parameterized
list of nodes that form a directed acyclic graph based on their inputs and outputs.
Graphs
A graph defines the computational logic of a model and is comprised of a parameterized
list of nodes that form a directed acyclic graph based on their inputs and outputs.
Models
ModelProto is a top-level file/container format for bundling a ML model and
associating its computation graph with metadata.
Models
ModelProto is a top-level file/container format for bundling a ML model and
associating its computation graph with metadata.
Nodes
Computation graphs are made up of a DAG of nodes, which represent what is
commonly called a "layer" or "pipeline stage" in machine learning frameworks.
Nodes
Computation graphs are made up of a DAG of nodes, which represent what is
commonly called a "layer" or "pipeline stage" in machine learning frameworks.
Operator Sets
OperatorSets are uniquely identified by a (domain, opset_version) pair.
Operator Sets
OperatorSets are uniquely identified by a (domain, opset_version) pair.
StringStringEntryProto follows the pattern for cross-proto-version maps.
StringStringEntryProto follows the pattern for cross-proto-version maps.
Tensors
A serialized tensor value.
Tensors
A serialized tensor value.
Protobuf enum
onnx.TensorProto.DataType
For very large tensors, we may want to store them in chunks, in which
case the following fields will specify the segment that is stored in
the current TensorProto.
For very large tensors, we may want to store them in chunks, in which
case the following fields will specify the segment that is stored in
the current TensorProto.
Defines a tensor shape.
Defines a tensor shape.
Protobuf type
onnx.TensorShapeProto.DimensionProtobuf type
onnx.TensorShapeProto.Dimension
Types
The standard ONNX data types.
Types
The standard ONNX data types.
Protobuf type
onnx.TypeProto.TensorProtobuf type
onnx.TypeProto.Tensor
Defines information on value, including the name, the type, and
the shape of the value.
Defines information on value, including the name, the type, and
the shape of the value.
Versioning
ONNX versioning is specified in docs/IR.md and elaborated on in docs/Versioning.md
To be compatible with both proto2 and proto3, we will use a version number
that is not defined by the default value but an explicit enum number.
Replaces instances of the onnx(model-path, output)
pseudofeature with the native Vespa ranking expression implementing
the same computation.
A global ONNX model distributed using file distribution, similar to ranking constants.
Processes ONNX ranking features of the form:
onnx("files/model.onnx", "path/to/output:1")
And generates an "onnx-model" configuration as if it was defined in the profile:
onnx-model files_model_onnx {
file: "files/model.onnx"
}
Inputs and outputs are resolved in OnnxModelTypeResolver, which must be
processed after this.
Model information (input and output types) for an ONNX model.
Defers to 'vespa-analyze-onnx-model' to determine the output type given
a set of inputs.
Transforms ONNX model features of the forms:
onnx(config_name)
onnx(config_name).output
onnx("path/to/model")
onnx("path/to/model").output
onnx("path/to/model", "path/to/output")
onnx("path/to/model", "unused", "path/to/output") // signature is unused
To the format expected by the backend:
onnx(config_name).output
Processes every "onnx-model" element in the schema.
Run ExpressionOptimizer on all scripts, to get rid of expressions that have no effect.
Model for StructDataType declared in a specific document
Proxy for a struct type declared in a specific document
API for a type declared in a specific document
Validates the 'paged' attribute setting and throws if specified on unsupported types.
Owns the page templates to be handed to the qrs nodes.
Common methods for various Parsed* classes.
This class holds the extracted information after parsing a
"document" block in a schema (.sd) file, using simple data
structures as far as possible.
This class holds the extracted information after parsing a "match"
block, using simple data structures as far as possible.
This class holds the extracted information after parsing
one schema (.sd) file, using simple data structures
as far as possible.
This class holds the extracted information after parsing a "struct"
block, using simple data structures as far as possible.
This exception is thrown when parse errors are encountered.
Creates a config producer for the engines provider at a given node.
Serves engines config for storage clusters.
NOTE: Stable ordering of bundles in config is handled by
ContainerCluster.addPlatformBundle(Path)API for allocating network ports
This class acts as a bridge between NetworkPortRequestor and HostPorts
for a single call to allocatePorts(), gathering the resulting port
allocations in a list of integers.
Track meta information about the ports of a service.
A data object for predefined metric sets.
Validates the predicate fields.
Executor of processors.
Represents a processing chain in the config model
Root config producer for processing
Creates all processing chains from xml.
Represents a handler for processing chains.
Abstract superclass of all search definition processors.
Representation of a Processor in the configuration model
This interface defines the necessary api for
Routing to prepare and combine routing tables for all available
protocols.Initializes the engines engine on each storage node.
Base config producer for search chains that communicate with backends.
A helper class to wrap a set of QRS cache settings.
Owns the query profiles and query profile types to be handed to the qrs nodes.
Reads the query profile and query profile types from an application package.
Checks that the generated model does not have resources that exceeds the given quota.
The rank settings given in a rank clause in the search definition.
Resolves and assigns types to all functions in a ranking expression, and
validates the types of all ranking expressions under a schema instance:
Some operators constrain the types of inputs, and first-and second-phase expressions
must return scalar values.
Represents a rank profile - a named set of ranking settings
A function in a rank profile
A rank property.
A rank setting.
The derived rank profiles of a schema
Extends the transform context with rank profile information
This processes a schema and adds input type settings on all rank profiles.
Validates rank setup for all content clusters (rank-profiles, index-schema, attributes configs), validation is done
by running the binary 'vespa-verify-ranksetup-bin'
The rank type of a field.
Checks if fields have defined different rank types for the same
index (typically in an index-to statement), and if they have
output a warning and use the first ranktype.
A rank profile derived from a search definition, containing exactly the features available natively in the server
RawRankProfile has a long lifetime so do not refer objects not necessary.
A filter for log messages that prevents the most recently published messages
to be published again.
Configuration of the redundancy of a content cluster.
Builds redundancy config for a content cluster.
Checks that redundancy is not increased (without a validation override),
as that may easily cause the cluster to run out of resources.
Validates that applications in prod zones do not have redundancy 1 (without a validation override).
Class that processes reference fields and removes attribute aspect of such fields from summary.
Utility class containing static methods for retrieving information about the config producer tree.
Context required to configure automatic reindexing for a given cluster controller cluster (for a given content cluster).
Issues a warning if some function has a reserved name.
Class tracking feed block resource limits used by a component in a content cluster (e.g.
Checks that no cluster sizes are reduced too much in one go.
Services should use this annotation to list all consumed configurations which contain definitions flagged with restart.
This is the routing plugin of the Vespa model.
Validates routing selector for search and content clusters
Validates routing
A schema contains a document type, additional fields, rank profiles and document summaries.
Represents a single schema file.
Information about a schema.
A store of a *small* (in memory) amount of rank profile info.
The schema parser
NOTE: When this grammar is changed, also change integration/intellij/src/main/bnf/ai/vespa/intellij/schema/parser/sd.bnf
Token literal values and constants.
Token Manager.
Validates that correct directory is used for schemas
A document definition is a list of fields.
The field class represents a document field.
Represents a search chain in the vespa model.
Root config producer of the whole search chains model (contains searchchains and searchers).
Creates top level search chains(searchchain, provider) from xml.
Represents a search cluster.
This Validator iterates through all search cluster in the given VespaModel to make sure that there are no custom
structs defined in any of its search definitions.
This is a representation of features to generate for this field.
This represents an interface for searching.
A search must have a document definition of the same name inside of it, otherwise crashes may occur as late as
during feeding
Represents a search node (proton).
A class which can reorder a list of search definitions such that any supertype
always preceed any subtype.
Validates the requirements for setting up a secret store.
Reads the semantic rules from the application package by delegating to SemanticRules.
Returns the semantic rules config form a set of rule bases.
A config view of a rule base
Representation of a process which runs a service
A provider of services (an entity which has its own top-level tag in the services.xml file).
All rank: filter fields should have rank type empty.
A component that uses the class name as id, and resides in the container-disc bundle.
Some configuration level with no special handling of its own.
A host provisioner used when there is no hosts.xml file (using localhost as the only host)
No state in this provisioner, i.e it does not know anything about the active
application if one exists.
Represents a Slobrok service.
A search-time document attribute sort specification(per-document in-memory value).
Validate conflicting settings for sorting
Config producer for source, which is contained in a provider.
Compares the startup command for the services in the next model with the ones in the current model.
The stemming setting of a field.
Class resolving conflicts when fields with different stemming-settings are
combined into the same index
Represents configuration that is common to all storage nodes.
A group of storage nodes/distributors.
Class to provide config related to a specific storage node.
Serves config for stor-server for storage clusters (clusters of storage nodes).
Serves stor-visitor config for storage clusters.
A search cluster of type streaming.
Validates the changes between all current and next streaming search clusters in a Vespa model.
Validates streaming mode
Validates the changes between the current and next set of struct field attributes in a document database.
A list of derived summaries
A summary derived from a search definition.
A summary field derived from a search definition
The summary field type enumeration
Ensure that summary field transforms for fields having the same name
are consistent across summary classes
Emits a warning for summaries which accesses disk.
Fail if:
An SD field explicitly says summary:dynamic , but the field is non-string array, wset, or struct.
A summary field
A source (field name).
The command used when using data from this SummaryField to generate StreamingSummary config (vsmsummary).
Verifies that the source fields actually refers to a valid field.
Verifies that equally named summary fields in different summary classes don't use different fields for source.
A value class representing a search time
transformation on a summary field.
Adds the corresponding summary transform for all "documentid" summary fields.
A
BindingPattern which is implicitly constructed by the model, e.g for built-in handlers and filter chains.The implementation of the tag datatype
A field that is imported from a field in a referenced document type and given an alias name.
A set of fields that are imported from referenced document types.
Proxy for an unknown type (must resolve to struct or document)
Class that processes and validates tensor fields.
Replaces instances of the tensorflow(model-path, signature, output)
pseudofeature with the native Vespa ranking expression implementing
the same computation.
Test driver for testing config models.
A test-only Properties class
Test utility class that provides many methods for inspecting the state of a completely built model
Utility class for parsing timeout fields.
Describes the input token stream.
Will tokenize based on the delimiters while dequoting any qouted text.
Token Manager Error.
Convenience feature transforms for inputs to Transformer type models.
Class that sorts a list of document types in topological order
according to the document references between the types.
Class representing the tuning config used for a search cluster.
Common interface for various typed key (or field definitions).
A low-cost ranking profile to use for watcher queries etc.
A
BindingPattern which is constructed directly from a user provided 'binding' element from services.xml.A UserConfigRepo is a repository for user configs, typically for a particular config producer.
This Processor makes sure all fields with the same name have the same
DataType.Check that fields with index settings actually creates an index or attribute
Executor of validators.
Validate validation overrides (validation-overrides.xml).
Abstract superclass of all application package validators.
Class containing the action to be performed on the given services to handle a config change
between the current active vespa model and the next vespa model to prepare.
Resolves the Vespa config model types
This class represents the builtin 'document' document type that all other documenttypes inherits.
Builds Vespa model components using the w3c dom api
Base class for builders of producers using DOM.
Encapsulates vespa service metrics.
The root ConfigProducer node for all Vespa systems (there is currently only one).
Base class for classes capable of building vespa model.
Factory for creating
VespaModel instances.Represents an action to re-feed a document type in order to handle a config change.
Represents an action to re-index a document type in order to handle a config change.
Represents an action to restart services in order to handle a config change.
Creates the search chains vespaPhases, vespa and native.
Vertical streaming matcher field specification
Vertical streaming matcher summary specification
The implementation of word matching - with word matching the field is assumed to contain a single "word" - some
contiguous sequence of word and number characters - but without changing the data at the indexing side (as with text
matching) to enforce this.
Replaces instances of the xgboost(model-path)
pseudofeature with the native Vespa ranking expression implementing
the same computation.
Static methods for helping dom building