Terminate this cache and release all local resources. After this cache is closed, any further method call on this cache, or on any object associated with this cache, will throw CacheClosedException.

Node.js apps should always call close() on a cache instance when it is no longer used in order to prevent leaks of resources (such as memory and N-API handles) that can occur in the Node.js environment.

const gemfire = require('gemfire')
cache = gemfire.createCacheFactory('./gfcpp.properties', 'xml/ExampleClient.xml')
   .create()
// Do things with the cache here

await cache.close()

Instantiates a region in the app.

See [Region Attributes]https://gemfire-native.docs.pivotal.io/latest/geode-native-client/regions/region-attributes.html for descriptions of the region types.

const gemfire = require('gemfire')
cache = await gemfire.createCacheFactory('./gfcpp.properties', 'xml/ExampleClient.xml')
   .create()
cache.getPoolManager()
   .createPoolFactory()
   .addLocator('localhost', 10334)
   .create('examplePool')
region = cache.createRegion('exampleRegion', { type: 'PROXY', poolName: 'examplePool' })
// Do things with the region here, e.g. put/get some values

await cache.close()

Invokes a data-independent function which has already been deployed on the server. See Region.executeFunction for data-dependent functions

• No arguments are passed in.
• options is not an object.
• functionName is undefined.
• args is given a function.
• functionName is not found on the server.
• functionName throws an error on the server.
• functionName sends an exception with its results.

var sum = cache.executeFunction('io.pivotal.node_gemfire.Sum', { args: [1, 2, 3] })
// Should print '6'
console.log('Sum of [1, 2, 3] is ' + sum[0])

Retrieves all values that match the query.

await region.put('a string', 'a string')

const queryResults = await cache.executeQueryOnDefaultPool('SELECT DISTINCT * FROM /exampleRegion')
console.log(queryResults.length)
console.log('key: "a string", value: ' + queryResults[0])

// output:
//   key: "a string", value: this is a string

Acquires the pool manager from the cache. The PoolManager is required in order to create PoolFactory objects, and ultimately new Pools.

// code example here for getPoolManager()
const gemfire = require('gemfire')
cache = await gemfire.createCacheFactory('./gfcpp.properties', 'xml/ExampleClient.xml')
   .create()
poolManager = cache.getPoolManager()

// Do things with the pool manager here, usually just create a PoolFactory

await cache.close()

Returns a region object for the specified client region.

const gemfire = require('gemfire')
cache = await gemfire.createCacheFactory('./gfcpp.properties', 'xml/ExampleClient.xml')
   .create()
region = cache.getRegion('exampleRegion')
// Do things with the region here, e.g. put/get some values

await cache.close()

Returns an array containing all of the regions in the cache.

const rootRegions = cache.rootRegions()

_.each(rootRegions, (rootRegion) => {
         console.log("Found region named" + rootRegion.name)
       })

Create a cache to interact with servers.

const gemfire = require('gemfire')
factory = gemfire.createCacheFactory('./gfcpp.properties', 'xml/ExampleClient.xml')
cache = await factory.create()

Set a GemFire property that will be honored when creating a cache.

const gemfire = require('gemfire')
factory = gemfire.createCacheFactory('./gfcpp.properties', 'xml/ExampleClient.xml')
// Send logs to a file, customize file/location here
factory.set('log-file', 'cacheFactorySetExample.log')

Set authentication properties for use when setting up communication with servers.

cacheFactory.setAuthentication((properties, server) => {
         properties['security-username'] = 'root'
         properties['security-password'] = 'root-password'
       }, () => {
       })

Controls when PDX serialization ignores fields that were unread during deserialization.

const gemfire = require('gemfire')
factory = gemfire.createCacheFactory('./gfcpp.properties', 'xml/ExampleClient.xml')
factory.setPdxIgnoreUnreadFields(true)

Instantiates a default CacheFactory. There are two variants to this api - the first just assumes all of the GemFire defaults for any properties. The second allows the developer to externalize some of the properties and cache configuration in separate files.

const gemfire = require('gemfire')
cacheFactory = await gemfire.createCacheFactory()

Instantiates a CacheFactory configured through a properties file and a cache.xml file.

const gemfire = require('gemfire')
cacheFactory = await gemfire.createCacheFactory('./system.properties', 'ExampleClient.xml')

Closes any connections and removes the pool object.

expect(pool.isDestroyed()).toBeFalse()

pool.destroy(true)

expect(pool.isDestroyed()).toBeTrue()

Invokes a data-independent function which has already been deployed on the servers of a specific pool. This method permits an app to execute data-independent functions on more than one pool.

• No arguments are passed in.
• options is not an object.
• functionName is undefined.
• args is given a function.
• functionName is not found on a server within the pool.
• functionName throws an error on a server within the pool.
• functionName sends an exception with its results.

const data = await pool.executeFunction('io.pivotal.node_gemfire.Sum', { args: [1, 2, 3] })

expect(data).toEqual([6])

Gets the free connection timeout for this pool. The free connection timeout specifies how long operations will block waiting for a free connection.

Gets the idle timeout for this pool. If the pool size is greater than the minimum specified by PoolFactory.setMinConnections(int), connections which have been idle for longer than the idleTimeout will be closed.

Gets the load conditioning interval for this pool. This interval controls how frequently the pool will check to see if a connection to a given server should be moved to a different server to improve the load balance.

Gets an array of locators that this pool has connections to.

Gets the maximum number of connections allowed for this pool. A value of -1 indicates that there is no maximum number of connections.

Gets the minimum number of connections for this pool. If the value is 0, then connections will not be made until an operation is invoked that requires client-to-server communication.

Gets current value of Multi User Authentication.

Gets the name of this pool.

Gets the ping interval, the frequency at which a client must ping each server to verify that the client is still alive. These pings are used by the server to monitor the health of the client. Make sure that the pingInterval is less than the maximum time between pings allowed by the server.

Gets current value of PR Single Hop Enabled. When set to true, restrict server to server hops when performing put, get, and destroy operations on partitioned regions, to maximize performance. The client will make requests to the server containing the primary copy of the data entries it needs.

Gets the duration to wait for a response from a server before timing out the operation and trying another server (if any are available).

Gets the number of retry attempts for a pool after a timeout or exception. A value of -1 indicates that a request should be tried against every available server before failing.

Gets the server group for this pool. If the server group is the empty string, then the pool connects to all servers.

Gets an array of server IP addresses that this pool has connections to.

Gets the size of the socket buffer for this pool.

Gets the frequency at which the client sends statistics to the server.

Gets the interval in milliseconds the client will wait before sending acknowledgements to the cache server for events received from the server subscriptions.

Gets the status of subscriptions.

Gets the subscription message tracking timeout for this pool. This is the time to live for subscription events recieved from the server. Increase the timeout to minimize duplicate events.

Gets the reduncancy level for this pool. If zero, there are no redundant copies kept on the server.

Gets the thread local connections status from this pool.

Gets the time interval between client updates of the locator list.

Returns the status of the pool.

expect(pool.isDestroyed()).toBeFalse()

pool.destroy(true)

expect(pool.isDestroyed()).toBeTrue()

If this pool was configured to use thread local connections, then this method will release the connection cached for the calling thread. The connection will then be available for use by other threads. If this pool is not using thread local connections, this method will have no effect.

Adds a locator to the list of locators used when creating a pool.

cacheFactory.create()
.then((cache) => {
     const poolFactory = cache.getPoolManager().createFactory()
     poolFactory.addLocator(locatorServer, locatorPort)
}

Adds a server to the list of servers used when creating a pool.

cacheFactory.create()
.then((cache) => {
     const poolFactory = cache.getPoolManager().createFactory()
     poolFactory.addServer('localhost', 40404)
}

Creates a pool with the given name.

cacheFactory.create()
.then((cache) => {
     const poolFactory = cache.getPoolManager().createFactory()
     poolFactory.addLocator(locatorServer, locatorPort)
     poolFactory.create('myPool')
}

Sets the free connection timeout for a pool. The free connection timeout specifies how long those operations will block when waiting for a free connection.

Set the idle timeout for a pool. If the pool size is greater than the minimum specified by PoolFactory.setMinConnections(connections), connections which have been idle for longer than the milliseconds will be closed.

Sets the load conditioning interval for a pool. This interval controls how frequently the pool will check to see if a connection to a given server should be moved to a different server to improve the load balance.

Sets the maxium number of connections for a pool. A value of -1 indicates that there is no maximum number of connections.

Sets the minimum number of connections for a pool. A value of 0 causes connections to be delayed until an operation is invoked that requires client-to-server communication.

Configure if a pool can use multiuser authentication secure mode.

Sets the ping interval for a pool, which is the time interval between pings of servers to verify that they are still alive. These pings are used by the server to monitor the health of the client. Make sure that the ping interval is less than the maximum time between pings allowed by the bridge server.

Restrict server to server hops for partitioned region operations of put, get, and destroy when set to true, such that the operations go directly to the server containing the primary copy of the data entry.

Sets the duration to wait for a response from a server before timing out the operation and trying another server (if any are available).

Sets the number of retry attempts for a pool after a timeout or exception. A value of -1 indicates that a request should be tried against every available server before failing.

Sets a server group for a pool. If the server group is the empty string, then the pool connects to all servers.

Sets the size of the socket buffer for a pool.

Sets the time interval between sends of client statistics to the server. A value of zero disables the sending of client statistics to the server.

Sets the subscription acknowledgement interval for a pool.

Configure if a pool can have server to client subscriptions.

Sets the subscription message tracking timeout for a pool. This timeout is the time to live for subscription events recieved from the server. Increase the timeout to minimize duplicate events.

Sets the redundancy level for a pool. If zero, there are no redundant copies kept on the server.

Configure the thread local connections policy for a pool.

Sets the time interval between updates of the locator list for a pool.

Instantiates a factory with which to create pools.

cache = await cacheFactory.create()
poolFactory = await cache.getPoolManager().createFactory()
console.log('Configuring the pool factory to find a locator at localhost:10337')
poolFactory.addLocator('localhost', 10337)
poolFactory.create('pool')

Retrieves the Pool object given the pool’s name.

Returns the current attributes object.

• cachingEnabled (boolean)

• clientNotificationEnabled (boolean)

• concurrencyChecksEnabled (boolean)

• concurrencyLevel (number)

• diskPolicy (number)

• entryIdleTimeout (number)

• entryTimeToLive (number)

• initialCapacity (number)

• loadFactor (number)

• lruEntriesLimit (number)

• lruEvictionAction (number)

• poolName (string)

• regionIdleTimeout (number)

• regionTimeToLive (number)

  Detailed documentation of region attributes may be found at Region Attributes.

const attributes = await region.attributes()

console.log('cachingEnabled=' + attributes.cachingEnabled)

Removes all entries from a replicated region. clear() is not supported for partitioned regions.

await region.put('key', 'value')
await region.clear()
value = await region.get('key')
if (typeof value === 'undefined') {
  console.log('Value no longer exists in region, as expected')
}

Removes the region from existence.

Caution: This also removes the corresponding region from the cluster's servers. To remove only the client region, call region.localDestroyRegion().

let region = cache.getRegion('exampleRegion')
await region.destroyRegion()
region = cache.getRegion('exampleRegion')
if (typeof region === 'undefined') {
  console.log('Successfully destroyed region')
}

Returns an array containing all the region's entries.

region = await cache.getRegion('exampleRegion')
await region.clear()
await region.putAll({ foo: 10, bar: 'quux', baz: 12 })

const results = await region.entries()

console.log('Region entry count: ' + results.length)
console.log('foo = ' + results['foo'])
console.log('bar = ' + results['bar'])
console.log('baz = ' + results['baz'])

Invokes a function that is already deployed on the server.

• The filter is not an array
• No arguments are passed in
• options is not an object
• functionName is undefined
• args is given a function
• functionName is not found on the server
• functionName throws an error on the server
• functionName sends an exception with its results

await region.put('one', 1)
await region.put('two', 2)

let data = await region.executeFunction('io.pivotal.node_gemfire.SumRegion')

expect(data).toEqual([3])

Executes a query to determine if that query returns a value.

await region.put('key1', { foo: 1 })

let does_it_exist = await region.existsValue('foo = 1')

expect(does_it_exist).toEqual(true)

does_it_exist = await region.existsValue('bar = 2')

expect(does_it_exist).toEqual(false)

Does a lookup to retrieve the value associated with key.

• No key is passed.
• key is invalid. Invalid keys are null, undefined, or {} (the empty object).
• The key parameter is a function.

await region.put('high', 'five')
const data = await region.get('high')

expect(data).toEqual('five')

Retrieves all entries for all keys passed in.

• keyArray is empty.
• keyArray is null.
• keyArray is undefined.
• keyArray is not an array.
• keyArray is a function.
• No argument is passed.

let result = await region.getAll(['a', 'dd'])
Object.keys(result).length).toBe(2)
console.log('Item "a" is ' + result.a);
console.log('Item "dd" is ' + result.dd);

Retrieves all keys from the client cache for a CACHING_PROXY type of region. Retrieves all keys from the server for a PROXY type of region.

await region.putAll({ foo: 1, bar: 2, baz: 3 })

let results = await region.keys()

expect(results.length).toEqual(3)
expect(results).toContain('foo')
expect(results).toContain('bar')
expect(results).toContain('baz')

Removes the client region from existence.

Note: Only the local region is destroyed. A corresponding region on the servers is not destroyed. To destroy the corresponding region on the servers, use region.destroyRegion().

const region = cache.createRegion('exampleRegion', { type: 'CACHING_PROXY' })
await region.localDestroyRegion()

expect(cache.getRegion('exampleRegion')).not.toBeDefined()

Returns the name of the region.

const name = region.name()
console.log('Operating on region ' + name)

For an event type defined by eventType, invokes the given function on that event.

region.on('afterCreate', (event) => {
  console.log('afterCreate called, event.key=' + event.key + ', oldValue=' + event.oldValue +
     ', newValue=' + event.newValue)
 }))
})

// Should see output from afterCreate callback when this put completes
await region.put('foo', 'bar')

Inserts a new region entry consisting of a key/value pair into the region. If the key already exists in the region, the existing entry is updated with the specified value. The value may not be a function or null.

• No key is passed.
• No value is passed.
• value is null.
• value is a function.

await region.put('high', 'five')

const data = await region.get('high')

// data should be 'five'
console.log('get: data is ' = data)

Insert all key/value pairs in the region.

• No keyObject is passed.
• One of the values is null.
• One of the values is a function.
• keyObject is null.
• keyObject is undefined.
• keyObject is not an object.

region.putAll({ key1: 'foo', key2: 'bar', 1: 'one' })
// is equivalent to these three put() calls:
region.put( 'key1', 'foo' )
region.put( 'key2', 'bar' )
region.put( 1, 'one' )

Retrieves all values from the region that match the query.

await region.put('key1', 1)
await region.put('key2', 2)
await region.put('key3', 3)
let array = await region.query('this > 1')

console.log('got ' + array.length + ' results')
for (i = 0; i < array.length; i++) {
   console.log('   ' + i + '. ' + array[i])
}

Causes an invocation of a callback on each region operation. The callback is specified by a call to Region.on().

await region.registerAllKeys()

region.on('afterCreate', do_stuff)

// Should trigger a call to do_stuff()
await region.put('foo', 'bar')

Removes the region entry for the given key.

• No key is specified.
• key is null.
• key is undefined.
• key is an empty array.
• key is a function.

await region.put('foo', 'bar')
await region.remove('foo')

let value = await region.get('foo')

expect(value).toBeNull()

Runs a query, expecting to match exactly one region entry, returning the value of that entry. If you want to query for multiple results, use Region.query().

await region.putAll({ key1: { foo: 1 }, key2: { foo: 2 }, key3: { foo: 3 } })

let value = await region.selectValue('foo = 2')
console.log('Value is ' + value)

Retrieves all the keys in the region from the server.

Note: Exercise caution using this function. Composing the resulting array of keys for a large region can exhaust available server memory space.

await region.putAll({ foo: 7, bar: 'qux', baz: 9 })

const result = await region.serverKeys()

expect(result.length).toEqual(3)
expect(result).toContain('foo')
expect(result).toContain('bar')
expect(result).toContain('baz')

Tells the server not to trigger entry events for this app instance.

region.on('afterCreate', () => { console.log('callback invoked') }) 
await region.unregisterAllKeys()

region.put('key1', 'hello')  // callback will not be invoked

Retrieves all the values on the region.

Note: Exercise caution using this function. Composing the resulting array of values for a large region can exhaust available server memory space.

await region.putAll({ foo: 7, bar: 'qux', baz: 9 })

const result = await region.values()

console.log('Received ' + result.length + ' values.')
for (i = 0; i < result.length; i++) {
   console.log(' value: ', result[i])
}