Data Grid Command Line Interface

1. Open a terminal in $ISPN_HOME.

2. Run the CLI.

   $ bin/cli.sh
   [disconnected]>

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a distributed, synchronous cache from a template and name it "mycache".

   [//containers/default]> create cache --template=org.infinispan.DIST_SYNC mycache

   Copy to Clipboard Toggle word wrap
   Tip

   Press the tab key after the --template= argument to list available cache templates.

2. Retrieve the cache configuration.

   [//containers/default]> describe caches/mycache
   {
     "distributed-cache" : {
       "mode" : "SYNC",
       "remote-timeout" : 17500,
       "state-transfer" : {
         "timeout" : 60000
       },
       "transaction" : {
         "mode" : "NONE"
       },
       "locking" : {
         "concurrency-level" : 1000,
         "acquire-timeout" : 15000,
         "striping" : false
       },
       "statistics" : true
     }
   }

   Copy to Clipboard Toggle word wrap

Procedure

1. Put an entry into "mycache".

   [//containers/default/caches/mycache]> put hello world

   Copy to Clipboard Toggle word wrap
   Tip

   If not in the context of a cache, use the --cache= parameter. For example:

   [//containers/default]> put --cache=mycache hello world

   Copy to Clipboard Toggle word wrap

2. Get the entry to verify it.

   [//containers/default/caches/mycache]> get hello
   world

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a file that contains a set of operations.

   For example, create a file named batch that creates a cache named mybatch, adds two entries to the cache, and disconnects from the CLI.

   $ cat > batch<<EOF
   create cache --template=org.infinispan.DIST_SYNC mybatch
   put --cache=mybatch hello world
   put --cache=mybatch hola mundo
   disconnect
   EOF

   Copy to Clipboard Toggle word wrap

2. Run the CLI and specify the file as input.

   $ bin/cli.sh -c localhost:11222 -f batch

   Copy to Clipboard Toggle word wrap

3. Open a new CLI connection to Data Grid and verify mybatch.

   [//containers/default]> ls caches
   ___protobuf_metadata
   mybatch
   [//containers/default]> ls caches/mybatch
   hola
   hello
   [//containers/default]> disconnect
   [disconnected]>

   Copy to Clipboard Toggle word wrap

Procedure

1. Start the Data Grid CLI in interactive mode.

   $ bin/cli.sh -c localhost:11222 -f -

   Copy to Clipboard Toggle word wrap
   Note

   If you do not use the -c flag, you must run the connect command.

   $ bin/cli.sh -f -
   connect

   Copy to Clipboard Toggle word wrap

2. Run batch operations, for example:

   create cache --template=org.infinispan.DIST_SYNC mybatch
   put --cache=mybatch hello world
   put --cache=mybatch hola mundo
   disconnect
   quit

   Copy to Clipboard Toggle word wrap

Procedure

1. Run create counter with the appropriate arguments.

   1. Create my-weak-counter.

      [//containers/default]> create counter --concurrency-level=1 --initial-value=5 --storage=PERSISTENT --type=weak my-weak-counter

      Copy to Clipboard Toggle word wrap

   2. Create my-strong-counter.

      [//containers/default]> create counter --initial-value=3 --storage=PERSISTENT --type=strong my-strong-counter

      Copy to Clipboard Toggle word wrap

2. List available counters.

   [//containers/default]> ls counters
   my-strong-counter
   my-weak-counter

   Copy to Clipboard Toggle word wrap

3. Verify counter configurations.

   1. Describe my-weak-counter.

      [//containers/default]> describe counters/my-weak-counter
      
      {
          "weak-counter":{
              "initial-value":5,
              "storage":"PERSISTENT",
              "concurrency-level":1
          }
      }

      Copy to Clipboard Toggle word wrap

   2. Describe my-strong-counter.

      [//containers/default]> describe counters/my-strong-counter
      
      {
          "strong-counter":{
              "initial-value":3,
              "storage":"PERSISTENT",
              "upper-bound":5
          }
      }

      Copy to Clipboard Toggle word wrap

Procedure

1. Select a counter.

   [//containers/default]> counter my-weak-counter

   Copy to Clipboard Toggle word wrap

2. List the current count.

   [//containers/default/counters/my-weak-counter]> ls
   5

   Copy to Clipboard Toggle word wrap

3. Increment the counter value by 2.

   [//containers/default/counters/my-weak-counter]> add --delta=2

   Copy to Clipboard Toggle word wrap

4. Decrement the counter value by -4.

   [//containers/default/counters/my-weak-counter]> add --delta=-4

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a Data Grid configuration file that adds a distributed cache named qcache and configures the media type, for example:

   <infinispan>
      <cache-container>
         <distributed-cache name="qcache">
            <encoding>
               <key media-type="application/x-protostream"/>
               <value media-type="application/x-protostream"/>
            </encoding>
         </distributed-cache>
      </cache-container>
   </infinispan>

   Copy to Clipboard Toggle word wrap

2. Create qcache from pcache.xml with the --file= option.

   [//containers/default]> create cache --file=pcache.xml pcache

   Copy to Clipboard Toggle word wrap

3. Verify pcache.

   [//containers/default]> ls caches
   pcache
   ___protobuf_metadata
   [//containers/default]> describe caches/pcache
   {
     "distributed-cache" : {
       "mode" : "SYNC",
       "encoding" : {
         "key" : {
           "media-type" : "application/x-protostream"
         },
         "value" : {
           "media-type" : "application/x-protostream"
         }
       },
       "transaction" : {
         "mode" : "NONE"
       }
     }
   }

   Copy to Clipboard Toggle word wrap

4. Add an entry to pcache and check the encoding.

   [//containers/default]> put --cache=pcache good morning
   [//containers/default]> cd caches/pcache
   [//containers/default/caches/pcache]> get good
   {
     "_type" : "string",
     "_value" : "morning"
   }

   Copy to Clipboard Toggle word wrap

Procedure

1. Create a schema file named person.proto with the following messages:

   package org.infinispan.rest.search.entity;
   
   message Address {
       required string street = 1;
       required string postCode = 2;
   }
   
   message PhoneNumber {
       required string number = 1;
   }
   
   message Person {
       optional int32 id = 1;
       required string name = 2;
       required string surname = 3;
       optional Address address = 4;
       repeated PhoneNumber phoneNumbers = 5;
       optional uint32 age = 6;
       enum Gender {
           MALE = 0;
           FEMALE = 1;
       }
   
       optional Gender gender = 7;
   }

   Copy to Clipboard Toggle word wrap

2. Register person.proto.

   [//containers/default]> schema --upload=person.proto person.proto

   Copy to Clipboard Toggle word wrap

3. Verify person.proto.

   [//containers/default]> cd caches/___protobuf_metadata
   [//containers/default/caches/___protobuf_metadata]> ls
   person.proto
   [//containers/default/caches/___protobuf_metadata]> get person.proto

   Copy to Clipboard Toggle word wrap

Procedure

1. Navigate to the pcache cache.

   [//containers/default/caches]> cd pcache

   Copy to Clipboard Toggle word wrap

2. Add each JSON document as an entry to the cache, for example:

   [//containers/default/caches/pcache]> put --encoding=application/json --file=jessicajones.json jessicajones
   [//containers/default/caches/pcache]> put --encoding=application/json --file=matthewmurdock.json matthewmurdock
   [//containers/default/caches/pcache]> put --encoding=application/json --file=lukecage.json lukecage

   Copy to Clipboard Toggle word wrap

3. Verify that the entries exist.

   [//containers/default/caches/pcache]> ls
   lukecage
   matthewmurdock
   jessicajones

   Copy to Clipboard Toggle word wrap

4. Query the cache to return entries from the Protobuf Person entity where the gender datatype is MALE.

   [//containers/default/caches/pcache]> query "from org.infinispan.rest.search.entity.Person p where p.gender = 'MALE'"
   {
     "total_results" : 2,
     "hits" : [ {
       "hit" : {
         "_type" : "org.infinispan.rest.search.entity.Person",
         "id" : 2,
         "name" : "Luke",
         "surname" : "Cage",
         "gender" : "MALE",
         "address" : {
           "street" : "38th St",
           "postCode" : "NY 11221"
         },
         "phoneNumbers" : [ {
           "number" : "4444"
         }, {
           "number" : "5555"
         } ]
       }
     }, {
       "hit" : {
         "_type" : "org.infinispan.rest.search.entity.Person",
         "id" : 3,
         "name" : "Matthew",
         "surname" : "Murdock",
         "gender" : "MALE",
         "address" : {
           "street" : "57th St",
           "postCode" : "NY 10019"
         }
       }
     } ]
   }

   Copy to Clipboard Toggle word wrap

Procedure

1. Access the Red Hat customer portal.
2. Download the appropriate Data Grid server patch from the software downloads section.
3. Open a terminal window and navigate to $RHDG_HOME.

4. Start the CLI.

   $ bin/cli.sh
   [disconnected]>

   Copy to Clipboard Toggle word wrap

5. Describe the patch file you downloaded.

   [disconnected]> patch describe /path/to/redhat-datagrid-$version-server-patch.zip
   Red Hat Data Grid patch target=$target_version source=$source_version created=$timestamp

   Copy to Clipboard Toggle word wrap
   • $target_version is the Data Grid version that applies when you install the patch on a server.
   • $source_version is one or more Data Grid server versions where you can install the patch.

1. Run the md5sum or sha256sum command with the downloaded patch as the argument, for example:

   $ sha256sum redhat-datagrid-$version-server-patch.zip

   Copy to Clipboard Toggle word wrap
2. Compare with the MD5 or SHA-256 checksum value on the Data Grid Software Details page.

Procedure

1. Navigate to $RHDG_HOME for a Data Grid server installation that has the target version for the patch you want to create.

2. Start the CLI.

   $ bin/cli.sh
   [disconnected]>

   Copy to Clipboard Toggle word wrap

3. Use the patch create command to generate a patch archive and include the -q option with a meaningful qualifier to describe the patch.

   [disconnected]> patch create -q "this is my test patch" path/to/mypatch.zip \
   path/to/target/server/home path/to/source/server/home

   Copy to Clipboard Toggle word wrap

   The preceding command generates a .zip archive in the specified directory. Paths are relative to $RHDG_HOME for the target server.

   Tip

   Create single patches for multiple different Data Grid versions, for example:

   [disconnected]> patch create -q "this is my test patch" path/to/mypatch.zip \
   path/to/target/server/home \
   path/to/source/server1/home path/to/source/server2/home

   Copy to Clipboard Toggle word wrap

   Where server1 and server2 are different Data Grid versions where you can install "mypatch.zip".

4. Describe the generated patch archive.

   [disconnected]> patch describe path/to/mypatch.zip
   
   Red Hat Data Grid patch target=$target_version(my test patch)  source=$source_version created=$timestamp

   Copy to Clipboard Toggle word wrap
   • $target_version is the Data Grid server version from which the patch was created.

   • $source_version is one or more Data Grid server versions to which you can apply the patch.

     You can apply patches to Data Grid servers that match the $source_version only. Attempting to apply patches to other versions results in the following exception:

     java.lang.IllegalStateException: The supplied patch cannot be applied to `$source_version`

     Copy to Clipboard Toggle word wrap

Procedure

1. Navigate to $RHDG_HOME for the Data Grid server you want to patch.

2. Stop the server if it is running.

   Note

   If you patch a server while it is running, the version changes take effect after restart. If you do not want to stop the server, create a new cluster with the target version and perform a rolling upgrade to that version instead of patching.

3. Start the CLI.

   $ bin/cli.sh
   [disconnected]>

   Copy to Clipboard Toggle word wrap

4. Install the patch.

   [disconnected]> patch install path/to/patch.zip
   
   Red Hat Data Grid patch target=$target_version source=$source_version \
   created=$timestamp installed=$timestamp

   Copy to Clipboard Toggle word wrap
   • $target_version displays the Data Grid version that the patch installed.
   • $source_version displays the Data Grid version before you installed the patch.

5. Start the server to verify the patch is installed.

   $ bin/server.sh
   ...
   ISPN080001: Red Hat Data Grid Server $version

   Copy to Clipboard Toggle word wrap

   If the patch is installed successfully $version matches $target_version.

Procedure

1. Navigate to $RHDG_HOME for the Data Grid server installation you want to roll back.
2. Stop the server if it is running.

3. Start the CLI.

   $ bin/cli.sh
   [disconnected]>

   Copy to Clipboard Toggle word wrap

4. List the installed patches.

   [disconnected]> patch ls
   
   Red Hat Data Grid patch target=$target_version source=$source_version
   created=$timestamp installed=$timestamp

   Copy to Clipboard Toggle word wrap
   • $target_version is the Data Grid server version after the patch was applied.
   • $source_version is the version for Data Grid server before the patch was applied. Rolling back the patch restores the server to this version.

5. Roll back the last installed patch.

   [disconnected]> patch rollback

   Copy to Clipboard Toggle word wrap

6. Quit the CLI.

   [disconnected]> quit

   Copy to Clipboard Toggle word wrap

7. Start the server to verify the patch is rolled back to the previous version.

   $ bin/server.sh
   ...
   ISPN080001: Data Grid Server $version

   Copy to Clipboard Toggle word wrap

   If the patch is rolled back successfully $version matches $source_version.