Hazelcast Node.js Client

'use strict';

const { Client } = require('hazelcast-client');

(async () => {
    try {
        // Start the Hazelcast Client and connect to an already running
        // Hazelcast Cluster on 127.0.0.1
        const hz = await Client.newHazelcastClient();
        // Get a Replicated Map called 'my-replicated-map'
        const map = await hz.getReplicatedMap('my-replicated-map');
        // Put and Get a value from the Replicated Map
        // (key/value is replicated to all members)
        const replacedValue = await map.put('key', 'value');
        // Will print 'Replaced value: null' as it's the first update
        console.log('Replaced value:', replacedValue);
        const value = await map.get('key');
        // The value is retrieved from a random member in the cluster
        console.log('Value for key:', value);
        // Shutdown this Hazelcast client
        await hz.shutdown();
    } catch (err) {
        console.error('Error occurred:', err);
    }
})();

'use strict';

const { Client } = require('hazelcast-client');

(async () => {
    try {
        // Start the Hazelcast Client and connect to an already running
        // Hazelcast Cluster on 127.0.0.1
        const hz = await Client.newHazelcastClient();
        // Get the Distributed MultiMap from Cluster
        const multiMap = await hz.getMultiMap('my-distributed-multimap');
        // Put values in the map against the same key
        await multiMap.put('my-key', 'value1');
        await multiMap.put('my-key', 'value2');
        await multiMap.put('my-key', 'value3');
        // Print out all the values for associated with key called 'my-key'
        const values = await multiMap.get('my-key');
        for (const value of values) {
            console.log(value);
        }
        // remove specific key/value pair
        await multiMap.remove('my-key', 'value2');
        // Shutdown this Hazelcast client
        await hz.shutdown();
    } catch (err) {
        console.error('Error occurred:', err);
    }
})();

'use strict';

const { Client } = require('hazelcast-client');

(async () => {
    try {
        // Start the Hazelcast Client and connect to an already running
        // Hazelcast Cluster on 127.0.0.1
        const hz = await Client.newHazelcastClient();
        // Get the Distributed Set from Cluster
        const set = await hz.getSet('my-distributed-set');
        // Add items to the set with duplicates
        await set.add('item1');
        await set.add('item1');
        await set.add('item2');
        await set.add('item2');
        await set.add('item2');
        await set.add('item3');
        // Get the items. Note that there are no duplicates
        const items = await set.toArray();
        console.log(items);
        // Shutdown this Hazelcast client
        await hz.shutdown();
    } catch (err) {
        console.error('Error occurred:', err);
    }
})();

'use strict';

const { Client } = require('hazelcast-client');

(async () => {
    try {
        // Start the Hazelcast Client and connect to an already running
        // Hazelcast Cluster on 127.0.0.1
        const hz = await Client.newHazelcastClient();
        // Get the Distributed List from Cluster
        const list = await hz.getList('my-distributed-list');
        // Add elements to the list
        await list.add('item1');
        await list.add('item2');
        //Remove the first element
        const value = await list.removeAt(0);
        console.log('Removed:', value);
        // There is only one element left
        const len = await list.size();
        console.log('Current size is', len);
        // Clear the list
        await list.clear();
        // Shutdown this Hazelcast client
        await hz.shutdown();
    } catch (err) {
        console.error('Error occurred:', err);
    }
})();

'use strict';

const { Client } = require('hazelcast-client');

(async () => {
    try {
        // Start the Hazelcast Client and connect to an already running
        // Hazelcast Cluster on 127.0.0.1
        const hz = await Client.newHazelcastClient();
        // Get a Queue called 'my-distributed-queue'
        const queue  = await hz.getQueue('my-distributed-queue');
        // Offer a string into the Distributed Queue
        await queue.offer('item');
        // Poll the Distributed Queue and return the string
        await queue.poll();
        // Timed-restricted operations
        await queue.offer('anotheritem', 500);
        await queue.poll(5000);
        // Indefinitely-waiting operations
        await queue.put('yetanotheritem');
        const item = await await queue.take();
        console.log(item);
        // Shutdown this Hazelcast Client
        await hz.shutdown();
    } catch (err) {
        console.error('Error occurred:', err);
    }
})();

'use strict';

const { Client } = require('hazelcast-client');

(async () => {
    try {
        // Start the Hazelcast Client and connect to an already running
        // Hazelcast Cluster on 127.0.0.1
        const hz = await Client.newHazelcastClient();
        // Get a Topic called 'my-distributed-topic'
        const topic = await hz.getReliableTopic('my-distributed-topic');
        // Add a Listener to the Topic
        topic.addMessageListener((message) => {
            console.log(message);
        });
        // Publish a message to the Topic
        await topic.publish('Hello to distributed world');
        // Shutdown this Hazelcast Client
        await hz.shutdown();
    } catch (err) {
        console.error('Error occurred:', err);
    }
})();

'use strict';

const {
    Client,
    Predicates
} = require('hazelcast-client');

class User {
    constructor(username, age, active) {
        this.username = username;
        this.age = age;
        this.active = active;
        this.factoryId = 1;
        this.classId = 1;
    }

    readPortable(reader) {
        this.username = reader.readUTF('username');
        this.age = reader.readInt('age');
        this.active = reader.readBoolean('active');
    }

    writePortable(writer) {
        writer.writeUTF('username', this.username);
        writer.writeInt('age', this.age);
        writer.writeBoolean('active', this.active);
    }
}

function portableFactory(classId) {
    if (classId === 1) {
        return new User();
    }
    return null;
}

async function generateUsers(usersMap) {
    await usersMap.put('Rod', new User('Rod', 19, true));
    await usersMap.put('Jane', new User('Jane', 20, true));
    await usersMap.put('Freddy', new User('Freddy', 23, true));
}

(async () => {
    try {
        // Start the Hazelcast Client and connect to an already running
        // Hazelcast Cluster on 127.0.0.1
        const hz = await Client.newHazelcastClient({
            serialization: {
                portableFactories: {
                    1: portableFactory
                }
            }
        });
        const usersMap = await hz.getMap('users');
        // Add some users to the Distributed Map
        await generateUsers(usersMap);
        // Create a Predicate from a String (a SQL like Where clause)
        const sqlQuery = Predicates.sql('active AND age BETWEEN (18 AND 21)');
        // Creating the same Predicate as above but with a builder
        const criteriaQuery = Predicates.and(
            Predicates.equal('active', true),
            Predicates.between('age', 18, 21)
        );
        // Get result collections using the two different Predicates
        const result1 = await usersMap.values(sqlQuery);
        const result2 = await usersMap.values(criteriaQuery);
        // Print out the results
        console.log(result1.toArray());
        console.log(result2.toArray());
        // Shutdown this Hazelcast client
        await hz.shutdown();
    } catch (err) {
        console.error('Error occurred:', err);
    }
})();

'use strict';

const { Client } = require('hazelcast-client');

(async () => {
    try {
        // Start the Hazelcast Client and connect to an already running
        // Hazelcast Cluster on 127.0.0.1
        const hz = await Client.newHazelcastClient();
        // Get the Distributed Lock from CP Subsystem
        const lock = await hz.getCPSubsystem().getLock('my-distributed-lock');
        // Now acquire the lock and execute some guarded code
        const fence = await lock.lock();
        console.log('Fence token:', fence);
        try {
            // Guarded code goes here
        } finally {
            await lock.unlock(fence);
        }
        // Shutdown this Hazelcast client
        await hz.shutdown();
    } catch (err) {
        console.error('Error occurred:', err);
    }
})();