This glossary defines terms used in Pivotal GemFire documentation.
A time-to-wait for message acknowledgment between system members.
Application Programming Interface. GemFire provides APIs to cached data for Java applications.
A program designed to perform a specific function directly for the user or, in some cases, for another application program. GemFire applications use the GemFire application programming interfaces (APIs) to modify cached data.
Querying: A named member of a data object. The public fields and methods of an object may be accessed as attributes in the context of a query.
Region: See region attributes.
A sequence of attributes separated by a dot (.), applied to objects where the value of each attribute is used to apply the next attribute.
A behavior associated with synchronization functions. Blocking behavior is exhibited as waiting for a signal to proceed, regardless of how long it takes. See also timeout.
In-memory GemFire data storage created by an application or cache server for data storage, distribution, and management. This is the point of access for Java applications for all caching features, and the only view of the cache that is available to the application. Cache creation creates a connection to the cluster. See also local and remote.
Residing or occurring in the local cache.
Common name for the XML file that declares the initial configuration of a cache. This file is used to customize the behavior of the GemFire cache server process and can be used by any Java application. Applications can also configure the cache through the GemFire Java APIs. You can give this file any name.
User-implemented plug-in for receiving and handling region entry events. A region’s cache listener is called after an entry in the local cache is modified. See also cache writer.
User-implemented plug-in for loading data into a region. A region’s cache loader is used to load data that is requested of the region but is not available in the cluster. For a distributed region, the loader that is used can be in a different cache from the one where the data-request operation originated. See also netSearch and netLoad.cache misses, where a requested key is not present or has a null value in the local cache.
The situation where a key’s value is requested from a cache and the requested key is not present or has a null value. GemFire responds to cache misses in various ways, depending on the region and system configuration. For example, a client region goes to its servers to satisfy cache misses. A region with local scope uses its data loader to load the value from an outside data source, if a loader is installed on the region.
A long-lived, configurable GemFire cluster member process that can service client connections.
A native GemFire transaction, managed by GemFire and not by JTA. This type of transaction operates only on data available from the GemFire cache in the local member. See also JTA and global transaction.
User-implemented plug-in intended for synchronizing the cache with an outside data source. A region’s cache writer is a synchronous listener to cache data events. The cache writer has the ability to cancel a data modification. See also cache listener and netWrite.
A GemFire application that is configured as a standalone cluster member, with regions configured as client regions. Client configuration uses the <client-cache>
cache.xml element and the ClientCache API.
A GemFire cache region that is configured to go to one or more GemFire servers, in a separate GemFire cluster, for all data distribution activities. Among other things, client regions go to servers to satisfy cache misses, distribute data modifications, and to run single queries and continuous queries.
cluster configuration service
The cluster configuration service saves cluster configurations created by gfsh commands to the locators in a cluster and distributes the configurations to members of the cluster.
Used in the context of a query for a group of distinct objects of homogeneous type, referred to as elements. Valid collections include the
java.util.Collection as well as Set, Map, List, and arrays. The elements in a collection can be iterated over. Iteration over a Map traverses its entries as instances of Map.Entry. A region can also be treated as a collection of its values.
A transactional operation that merges a transaction’s result into the cache. Changes are made in an “all or none” fashion. Other changes from outside the current transaction are kept separate from those being committed.
Region attribute that specifies an estimate of the number of threads ever expected to concurrently modify values in the region. The actual concurrency may vary; this value is used to optimize the allocation of system resources.
Combining entries in a message queue for better performance. When an event is added to queue, if a similar event exists in the queue, there are two ways to conflate the events. One way is to remove the existing entry from wherever it resides in the queue, and add the new entry to the end of the queue. The other way is to replace the existing entry with the new entry, where it resides in the queue, and add nothing to the end of the queue. In GemFire, region entry update events, server events going to clients, and gateway sender events going to remote clusters can all be conflated.
The connection used by an application to access a GemFire system. A Java application connects to its GemFire cluster when it creates its cache. The application must connect to a cluster to gain access to the GemFire functionalities. A client connects to a running GemFire server to distribute data and events between itself and the server tier. These client connections are managed by server connection pools within the client applications. Gateway senders connect to a remote gateway receiver to distribute data events between sites.
GemFire member process that receives data and/or events from other members. Peer consumers are often configured with replicated regions, so all changes in the cluster arrive into the local cache. Client consumers can register subscriptions with their servers so that updates are automatically forwarded from the server tier. See producer.
The member of the cluster that sends out membership views. This is typically the locator in GemFire.
In the context of a region, a member configured to use a region, but not store any data for it in the member’s local cache. Common use cases for data accessors are thin clients, and thin producer and consumer applications. Accessors can put data into the region and receive events for the region from remote members or servers, but they store no data in the application. See also data store.
Also referred to as an in-memory data grid or an enterprise data fabric. GemFire is an implementation of a data fabric. A data fabric is a distributed, memory-based data management platform that uses cluster-wide resources – memory, CPU, network bandwidth, and optionally local disk – to manage application data and application logic (behavior). The data fabric uses dynamic replication and data partitioning techniques to offer continuous availability, very high performance, and linear scalability for data intensive applications, all without compromising on data consistency even when exposed to failure conditions.
Region attribute used to determine what events the region receives from remote caches, whether data is stored in the local cache, and whether the data is persisted to disk. For disk persistence, writes are performed according to the cache disk-store configuration.
A logical grouping of data within a cache. Regions usually contain data entries (see entry). Each region has a set of region attributes governing activities such as expiration, distribution, data loading, events, and capacity control. In addition, a region can have an application-defined user attribute.
In the context of a region, a member configured to store data for the region. This is used mostly for partitioned regions, where data is spread across the cluster among the data stores. See also data accessor.
A situation in which two or more processes are waiting indefinitely for events that will never occur.
Distributed: To remove a cached object across the distributed cache.
Local: To remove a cached object from the local cache only.
A persistent region.
Cache element specifying location and write behavior for disk storage. Used for persistence and overflow of data. The cache can have multiple disk stores, which are specified by name for region attributes, client subscription queues (for servers), and WAN gateway sender queues.
A collection of caches spread across multiple machines and multiple locations that functions as a single cache for the individual applications.
One or more GemFire system members or clusters that have been configured to communicate cache events with each other, forming a single, logical system.
Data distribution setting that causes synchronous distribution operations, which wait for acknowledgment from other caches before continuing. Operations from multiple caches can arrive out of order. This scope is slower but more reliable than distributed-no-ack.
Data distribution setting that causes asynchronous distribution operations, which return without waiting for a response from other caches. This scope produces the best performance, but is prone to race conditions.
A data object in a region consisting of a key and a value. The value is either null (invalid) or a Java object. A region entry knows what region it is in. An entry can have an application-defined user attribute. See also region data, entry key, and entry value.
The unique identifier for an entry in a region.
The data contained in an entry.
An action recognized by the GemFire system members, which can respond by executing callback methods. The GemFire API produces two types of events: cache events for detail-level management of applications with data caches and administrative events for higher-level management of the cluster and its components. An operation can produce administrative events, cache events, or both.
Region attribute that causes the cache to limit the size of the region by removing old entries to make space for new ones.
A cached object expires when its time-to-live or idle timeout counters are exhausted. A region has one set of expiration attributes for itself and one set for all of its entries.
The action to be taken when a cached object expires. The expiration action specifies whether the object is to be invalidated or destroyed and whether the action is to be performed only in the local cache or throughout the cluster. A destroyed object is completely removed from the cache. A region is invalidated by invalidating all entries contained in the region. An entry is invalidated by having its value marked as invalid. Region.getEntry.getValue returns null for an invalid entry.
In GemFire, expiration attributes are set at the region level for the region and at the entry level for entries. See also idle timeout and time-to-live.
An interface for creating an object which at creation time can let its subclasses decide which class to instantiate. The factory method helps instantiate the appropriate subclass by creating the correct object from a group of related classes.
Forcible removal of a member from membership without the member’s consent.
A gateway receiver defines connection information for receiving region events that were distributed from a gateway sender in a multi-site deployment.
A gateway sender defines a single remote cluster site and an associated queue for distributing region events in a multi-site deployment.
Common name for the file used for cluster configuration, including system member connection and communication behavior, logging and statistics files and settings, and security settings. Applications can also configure the cluster through the GemFire Java APIs. You can give this file any name.
Data distribution setting that provides locking across the cluster for load, create, put, invalidate, and destroy operations on the region and its entries. This scope is the slowest, but it guarantees consistency across the cluster.
A JTA-controlled transaction in which multiple resources, such as the GemFire cache and a JDBC database connection, participate. JTA coordinates the completion of the transaction with each of the transaction’s resources. See also JTA and cache transaction.
World Wide Web’s Hypertext Transfer Protocol. A standard protocol used to request and transmit information over the Internet or other computer network.
The amount of time a region or region entry may remain in the cache without being accessed before being expired. Access to an entry includes any get operation and any operation that resets the entry’s time-to-live counter. Region access includes any operation that resets an entry idle timeout and any operation that resets the region’s time-to-live.
Region attribute. The initial capacity of the map used for storing region entries.
The state of an object when the cache holding it does not have the current value of the object.
Distributed: To mark an object as being invalid across the distributed cache.
Local: To mark an object as being invalid in the local cache only.
Java DataBase Connectivity. A programming interface that lets Java applications access a database via the SQL language.
Java Management eXtensions. A set of specifications for dynamic application and network management in the J2EE development and application environment.
Java Naming and Directory Interface. An interface to naming and directory services for Java applications. Applications can use JNDI to locate data sources, such as databases to use in global transactions. GemFire allows its JNDI to be configured in a
cache.xml configuration file.
Java Transaction API. The local Java interfaces between a transaction manager (JTS) and the parties involved in a global transaction. GemFire can be a member of a JTA global transaction. See also global transaction.
Java Virtual Machine. A virtual machine capable of handling Java bytecode.
Enforcing a specific entry key type. The key-constraint region attribute, when set, constrains the entries in the region to keys of the specified object type.
An event handler. The listener registers its interest in one or more events, such as region entry updates, and is notified when the events occur.
Region attribute. The load factor of the map used for storing entries.
Local cache: The part of the distributed cache that is resident in the current member’s memory. This term is used to differentiate the cache where a specific operation is being performed from other caches in the same cluster or in another cluster. See also remote.
Region with local scope: A region whose scope is set to local. This type of region does not distribute anything with other members in the cluster.
Region shortcuts: In the RegionShortcut and settings, LOCAL means the scope is set to local. All client regions have local scope. In the ClientRegionShortcut settings, LOCAL means the region does not connect to the client’s servers.
Data distribution setting that keeps data private and visible only to threads running within the local member. A region with local scope is completely contained in the local cache. Client regions are automatically given local scope.
GemFire process that tracks system members and provides current membership information to joining members so they can establish communication. For server systems, the locator also tracks servers and server load and, when a client requests a server connection, the locator sends the client to one of the least loaded servers. .
Least recently used. Used to refer to region entry or entries most eligible for eviction due to lack of interest by client applications. GemFire offers eviction controllers that use the LRU status of a region’s entries to determine which to evict to free up space. Possible eviction actions are local destroy and overflow. See also resource manager.
Any GemFire-supported physical machine or Virtual Machine.
A process that has defined a connection to a GemFire cluster and created a GemFire cache. This can be a Java or Native Client application. This can also be a GemFire process such as a locator or cacheserver. The minimal GemFire process configuration is a single member that is connected to a cluster.
A first-in, first-out data structure in a GemFire system member that stores messages for distribution in the same order that the original operations happened in the local member. Each thread has its own queue. Depending on the kind of queue, the messages could be going between two members of a cluster, a client and server, or two members in different clusters. See also conflation.
A form of UDP communications where a datagram is sent to multiple processes in one network operation.
Region attributes that are stored in the member memory and can be retrieved through their region attributes refid setting. GemFire provides standard predefined named region attributes, that are stored using region shortcut refids. You can use any stored attributes that you wish, setting an id when you create them and using the id setting in the refid you want to use to retrieve them.
The method used by GemFire to load an entry value into a distributed region. The netLoad operation invokes all remote cache loaders defined for the region until either the entry value is successfully loaded or all loaders have been tried.
The method used by GemFire to search remote caches for a data entry that is not found in the member’s local cache region. This method operates only on distributed regions with a data-policy of empty, normal and preloaded.
The method used by GemFire to invoke a cache writer for region and region entry events. This method operates only on distributed regions. For each event, if any cache writer is defined for the region, the netWrite operation invokes exactly one of them.
A situation that arises from a communications partition that causes processes to become unaware of one another.
Object Query Language, SQL-92 extended for querying object data. GemFire supports a subset of OQL.
Memory that is not on the standard Java heap and that is not managed by the JVM and its garbage collector.
Eviction option for eviction controllers. This causes the values of LRU entries to be moved to disk when the region reaches capacity. Writes are performed according to the cache disk-store configuration.
The files in a disk-store used for the cache operations.
The memory in each member that is reserved for a specific partitioned region’s use.
A region that manages large volumes of data by partitioning it into manageable chunks and distributing it across multiple machines. Defining partition attributes or setting the region attribute data-policy to partition makes the region a partitioned region.
A GemFire member application that is not configured as a client. Peer configuration uses the <cache>
cache.xml element and the Cache API. Peers can also be configured as servers to client applications and as gateway-receivers or gateway-senders to remote clusters.
A region with the attribute data-policy set to persistent-replicate.
A region attribute setting identifying a region as a partitioned region whose data is persisted to disk. With persistence, all region entry keys and values are stored in an operation log on disk as well as being stored in memory. Also referred to as disk region. Writes are performed according to the cache disk-store configuration.
A region attribute setting identifying a region as a replicate whose data is persisted to disk. With persistence, all region entry keys and values are stored in an operation log on disk as well as being stored in memory. Also referred to as disk region. Writes are performed according to the cache disk-store configuration.
A GemFire member process that puts data into the cache for consumption by other members. Producers may be configured with empty regions, where the data they put into the cache is not stored locally, but causes cache update events to be sent to other members. This is a common configuration in peer members and for client processes. See consumer.
Data distribution model where each process receives updates only for the data in which the process has explicitly expressed interest. In a GemFire peer member, this is accomplished using a distributed, non-replicated region and creating the data entries that are of interest in the local region. When updates happen for the region in remote caches, the only updates that are forwarded to the local cache are those for entries that are already defined in the local cache. In a GemFire client, you get pull behavior by specifically subscribing to the entries of interest. See push model.
Data distribution model where each process receives updates for everything in the data set. In a GemFire peer member, this is accomplished using a replicated region. All data modifications, creations, and deletes in remote caches are pushed to the replicated region. In a GemFire client, you get push behavior by registering interest in all keys in the region. See pull model.
A fully-formed SQL statement that can be passed to a query engine and executed against a data set. A query string may or may not contain a SELECT statement.
Anomalous behavior caused by the unexpected dependence on the relative timing of events. Race conditions often result from incorrect assumptions about possible ordering of events.
An XPath index optimized for range-queries with the added index maintenance expense of sorting the set of values. A range index allows faster retrieval of the set of nodes with values in a certain range. See also structure-index and value-index.
A logical grouping of data within a cache. Regions usually contain data entries (see entry). Each region has a set of region attributes governing activities such as expiration, distribution, data loading, events, and capacity control. In addition, a region can have an application-defined user attribute.
The class of attributes governing the creation, distribution, and management of a region and its entries.
All of the entries directly contained in the region.
Enums RegionShortcut and ClientRegionShortcut defining the main region types in GemFire for peers/servers and clients, respectively. Region shortcuts are predefined named region attributes.
Resident or running in a cache other than the current member’s cache, but connected to the current member’s cache through GemFire. For example, if a member does not have a data entry in the region in its local cache, it can do a netSearch in an attempt to retrieve the entry from the region in a remote cache within the same cluster. Or, if the member is a client, it can send a request to a server in an attempt to retrieve the entry from the region in a remote server cache in the server’s cluster. In multi-site installations, a gateway sends events from the local cache to remote caches in other clusters. See also local.
A region with data-policy set to replicate or persistent-replicate.
Region data-policy specification indicating to copy all distributed region data into the local cache at region creation time and to keep the local cache consistent with the distributed region data.
GemFire process that works with your JVM’s tenured garbage collection (GC) to control heap use and protect your JVM from hangs and crashes due to memory overload. The manager prevents the cache from consuming too much memory by evicting old data and, if the collector is unable to keep up, by refusing additions to the cache until the collector has freed an adequate amount of memory. Eviction is done for regions configured for LRU eviction based on heap percentage. See also LRU and eviction-attributes.
A transactional operation that excludes a transaction’s changes from the cache, leaving the cache undisturbed.
Region attribute: In non-partitioned regions, a distribution property for data identifying whether it is distributed and, if so, whether distribution acknowledgements are required and whether distributed synchronization is required. A distributed region’s cache loader and cache writer (defined in the local cache) can be invoked for operations originating in remote caches. A region that is not distributed has a local scope. See also replicate.
Querying: The data context for the part of the query currently under evaluation. The expressions in a SELECT statement’s FROM clause can add to the data that is in scope in the query.
A statement of the form SELECT projection_list FROM expressions WHERE expressions that can be passed to the query engine, parsed, and executed against data in the local cache.
The process of converting an object or object graph to a stream of bytes.
A GemFire member application that is configured as a peer in its own system and as a server to connecting GemFire client applications.
An optional logical grouping of servers in a server clusters. There is always the default server group made up of all available server in the server clusters. Clients can specify the server group in their server pool configuration. Then the pool only connects to those servers. If no group is specified, the default is used.
The cache entity that manages client connections to servers.
The application interface for TCP/IP communications. UDP provides unicast and multicast datagram sockets, while TCP provides server and connection sockets. TCP server sockets are used by server processes to create connection sockets between the server and a client.
Structured Query Language.
Secure Socket Layer. A protocol for secure communication between Java VMs.
A cluster configured for no communication with peers. Client applications are generally defined with standalone clusters, so there is no peer communication and all event and data communication is done between the client member and the server tier.
Region attribute. Specifies whether to collect statistics for the region.
A data type that has a fixed number of elements, each of which has a field name and can contain an object value.
An XPath index that is basically a pre-computed query. Any legal XPath expression can be used. The index maintains lists of all nodes that match the expression used to create it. If a query is performed that has the same expression as the index then the result is available without XPath evaluation. See also range-index and value-index.
The Transmission Control Protocol is a part of the internet protocol (IP) suite that provides unicast communications with guaranteed delivery. The TCP protocol is connection-based, meaning that a TCP socket can only be used to send messages between one pair of processes at a time. Compare to UDP.
A behavior associated with synchronization functions. Timeout behavior is exhibited as refusal to wait longer than a specified time for a signal to proceed. See also blocking.
The amount of time a region or region entry may remain in the cache without being modified before being expired. Entry modification includes creation, update, and removal. Region modification includes creation, update, or removal of the region or of any of its entries.
User-implemented plug-in for receiving and handling transaction events. A transaction listener is called after a transaction commits. See also transaction writer.
User-implemented plug-in intended for synchronizing the cache with an outside data source. A transaction writer is a synchronous listener to cache transactions. The transaction writer has the ability to veto a transaction. See also transaction listener.
The result of a history of transactional operations for a given open transaction.
The network used to connect the GemFire system members in a GemFire system.
The User Datagram Protocol is a part of the internet protocol (IP) suite that provides simple, unreliable transmission of datagram messages from one process to another. Reliability must be implemented by applications using UDP. The UDP protocol is connectionless, meaning that the same UDP socket can be used to send or receive messages to or from more than one process. Compare to TCP.
A message sent from one process to another process (point-to-point communications). Both UDP and TCP provide unicast messaging.
Uniform Resource Identifier. A unique identifier for abstract or physical resources on the World Wide Web.
An optional object associated with a region or a data entry where an application can store data about the region or entry. The data is accessed by the application only. GemFire does not use these attributes. Compare to region attributes, which are used by GemFire.
Enforcing a specific entry value type. The value-constraint region attribute, when set, constrains the entries in the region to values of the specified object type. Value constraints can be used to provide object typing for region querying and indexing. The value-constraint is only checked in the cache that does the entry put or create operation. When the entry is distributed to other caches, the value constraint is not checked.
An XPath index that operates much as a structure-index does, but that separates the nodes that match the XPath expression into sets mapped by each node’s value. This allows further filtering of the nodes to be evaluated in a query by going directly to those with a specific value. See also structure-index and range-index.
A collection of member identifiers that defines the membership group.
A completely isolated operating system installation within your normal operating system. This is generally implemented by software emulation or hardware virtualization.
Also referred to as a VMware VM. A VMware VM is a tightly isolated software container that can run its own operating systems and applications as if it were a physical computer. A VMware VM behaves exactly like a physical computer and contains it own virtual (ie, software-based) CPU, RAM hard disk and network interface card (NIC). An operating system can’t tell the difference between a VMware VM and a physical machine, nor can applications or other computers on a network. Even the VMware VM thinks it is a “real” computer. Nevertheless, a VMware VM is composed entirely of software and contains no hardware components whatsoever.
EXtensible Markup Language. An open standard for describing data, XML is a markup language similar to HTML. Both are designed to describe and transform data, but where HTML uses predefined tags, XML allows tags to be defined inside the XML document itself. Thus, virtually any data item can be identified. The XML programmer creates and implements data-appropriate tags whose syntax is defined in a DTD file or an XSD (XML schema definition.)
The definition of the structure, content, and semantics used in an XML document. The definition can be used to verify that each item of content in a document adheres to the specification of the element in which the content is placed. The XML schema is a superset of DTD. Unlike DTD, XML schemas are written in XML syntax, which, although more verbose than DTD, are more descriptive and can have stronger typing. Files containing XML schema definitions generally have the XSD extension.
A language that describes a way to locate and process items in Extensible Markup Language (XML) documents by using an addressing syntax based on a path through the document’s logical structure or hierarchy.
See XML schema definition.