Without Persistence

If you start a node without persistence, then the data is stored in memory and is lost when the node stops. To start the node without persistence, use the following batch file, which I named start_node.bat:

cd c:users
odapache-ignite-2.14.0-binin
ignite.bat
pause

This file uses the cd command to set the current directory to the location of the ignite.bat file. It then runs ignite.bat to start the node. When the node starts, you should see a command window similar to the one shown in Figure 24.1.

That window will remain running as long as the node is running.

The batch file's final pause command is only there in case there's a problem starting ignite.bat. For example, if ignite.bat isn't in the directory passed to the cd command, the pause command makes the output pause so that you can read the error message. Without that command, the window would vanish too quickly for you to see the error message.

You can start as many nodes as you like, and they should find each other automatically.

With Persistence

If you start a node with persistence enabled, then as much data as possible is stored in memory and it is all shadowed to hard disk. If you stop the node and restart it, the node reloads the saved data.

To start the node with persistence, use the following batch file, which I named start_node_persistent.bat:

cd c:users
odapache-ignite-2.14.0-binin
ignite.bat ..examplesconfigpersistentstoreexample-persistent-store.xml
pause

This file uses the same cd command and runs ignite.bat as before. This time it passes the location of a configuration file to ignite.bat. You can look at that configuration file to see what it does. The most important part for our purposes is that it sets the value persistenceEnabled to true.

If you look closely at the avalanche of information in the command window, you'll see a couple of differences with the window shown in Figure 24.1. First, you'll find the following information:

Ignite node started OK (id=36174a6d)
[15:24:56]>>> Ignite cluster is in INACTIVE state (limited functionality
available). Use control.(sh|bat) script or IgniteCluster.state(ClusterState.ACTIVE) to change the state.
[15:24:56] Topology snapshot [ver=1, locNode=36174a6d, servers=1, clients=0,
state=INACTIVE, CPUs=8, offheap=3.1GB, heap=1.0GB]

This says the node is in an inactive state. For some reason, that's the default if you start the node with persistence enabled. If you try to access the node while it is inactive, you get the following message:

CacheCreationError: Cannot perform the operation because the cluster is
inactive. Note, that the cluster is considered inactive by default if Ignite
Persistent Store is used to let all the nodes join the cluster. To activate the
cluster call Ignite.active(true).

You can use the Ignite control script control.bat (or control.sh if you have a Linux accent to change the state, but I found it easy enough to make the program do it.

To make it easier to test the database with and without persistence, I've broken the example program into sections that define a class, write some data, and read some data. The following sections describe those pieces. Later in the chapter, I'll summarize how to use the pieces to demonstrate persistence. In a real application, you might want to combine the pieces or call them from a main program.

Install the pyignite Database Adapter

To install the pyignite driver, simply use the following pip command:

$ pip install pyignite

If you're not familiar with pip, you can execute the following command in a Jupyter Notebook cell instead:

!pip install pyignite

That's all there is to it!

Define the Building Class

The example program saves a few pieces of information into the database. One of those pieces is a Building class. To allow Ignite to understand the data saved in the object's fields, you need to define it properly.

The following code shows how the program defines the Building class:

# Cell 1.
# Define the Building class with a schema
# so the database can understand its fields.
from pyignite import *
from pyignite.datatypes import String, IntObject
 
class Building(metaclass=GenericObjectMeta, schema={
    'name': String,
    'city': String,
    'height': IntObject,
    }):
 
    def __init__(self, name, city, height):
        self.name = name
        self.city = city
        self.height = height

This code uses the GenericObjectMeta class to define the Building class. The interesting part here is the schema, which is a dictionary that defines the class's fields and their data types. Ignite uses the data types to understand how it should save and retrieve data for Building objects. In addition to defining the class's fields, this cell creates a constructor to make initializing objects easier.

Save Data

The following cell saves data into the database.

# Create some data.
from pyignite import *
from pyignite.datatypes import String, IntObject
from pyignite.cluster import *
 
client = Client()
with client.connect('localhost', 10800):
    my_cluster = cluster.Cluster(client)
    my_cluster.set_state(ClusterState.ACTIVE)
 
    misc_data_cache = client.get_or_create_cache('misc_data')
 
    building = Building('Burj Khalifa', 'Dubai', 2717)
    misc_data_cache.put(100, building)
    
    misc_data_cache.put('fish', 'humuhumunukunukuapua'a')
    misc_data_cache.put(3.14, 'pi')
 
print("Created data")

After the imports statements, the code creates a client. This example assumes that the node is running on the local computer, so it connects to localhost. You can change that value to an IP address if the node is running on another computer. You can also replace the parameters with a list of IP addresses and port numbers, as in the following code:

nodes = [
    ('127.0.0.1', 10800),
    ('127.0.0.1', 10801),
    ('127.0.0.1', 10802),
]
 
with client.connect(nodes):
    …

After it has connected to the node, the code gets a Cluster object representing the cluster that it is using and calls its set_state method to activate the cluster.

If you started the node without persistence, then it is already active and this does nothing. If you started the node with persistence, then it is initially inactive and this activates it.

Next, the code calls the client's get_or_create_cache method to retrieve a cache named misc_data. As the method's name implies, this gets the cache if it already exists, and it creates an empty cache if it does not exist.

The next statements add data to the cache using an assortment of data types for both keys and values.

The program creates a new Building object representing Burj Khalifa, the tallest building in the world. It then saves that object in the database, giving it the integer key 100.

Next, the cell saves the string value “humuhumunukunukuapua'a” in the cache with the string key “fish.” (It's the official state fish of Hawaii. It's also called the reef triggerfish, but humuhumunukunukuapua'a is more fun to say.)

Finally, the code saves the string value “pi” in the cache with the floating point key 3.14.

This cell finishes by displaying a message to show that it finished.

Read Data

The following cell reads data back from the node:

# Cell 3.
# Read and display the  data.
from pyignite import *
from pyignite.datatypes import String, IntObject
from pyignite.cluster import *
 
client = Client()
with client.connect('localhost', 10800):
    my_cluster = cluster.Cluster(client)
    my_cluster.set_state(ClusterState.ACTIVE)
 
    misc_data_cache = client.get_or_create_cache('misc_data')
 
    building = misc_data_cache.get(100)
    print(building)
 
    text = misc_data_cache.get('fish')
    print(text)
 
    number = misc_data_cache.get(3.14)
    print(number)

The code first creates a client, connects to the database, and activates the cluster in case it is not already active. It then uses the client's get_or_create_cache method to get the cache.

The program then calls the cache's get method, passing it the keys that the previous cell used to save the data. It uses the key 100 to retrieve the Building object and prints that object. Next, it uses the string key "fish" to fetch the fish's name and displays that value. Finally, it uses the floating point key 3.14 to fetch the associated string and prints that string. Here's the result:

Building(name='Burj Khalifa', city='Dubai', height=2717, version=1)
humuhumunukunukuapua'a
pi

If you would rather not create a Building class with a schema, you can store and retrieve building data in another format such as a JSON document or delimited string.

Demonstrate Volatile Data

To demonstrate the program using volatile data, use the following steps:

1. Run start_node.bat to start the node without persistence.
2. Run Cell 1 to define the Building class.
3. Run Cell 2 to create some data.
4. Run Cell 3 to read and display the data. It should look as expected.
5. Close the node's command window and rerun start_node.bat to restart the node, again without persistence.
6. Run Cell 3 to read and display the data. Notice that all of the values are displayed as “none.”

Demonstrate Persistent Data

To demonstrate the program using volatile data, use the following steps:

1. Run start_node_persistent.bat to start the node without persistence.
2. Run Cell 1 to define the Building class.
3. Run Cell 2 to create some data.
4. Run Cell 3 to read and display the data. It should look as expected.
5. Close the node's command window and rerun start_node_persistent.bat to restart the node, again with persistence.
6. Run Cell 3 to read and display the data. This time all the values should be displayed normally.