Data Grid REST API

您可以以不同格式写入和读取数据，Data Grid 可以根据需要在这些格式之间进行转换。

以下"标准"格式是可交换的：

您还可以将前面的数据格式转换为以下格式：

通过数据网格，您可以在 application/x-protostream 和 application/json 之间转换。

对 REST API 的所有调用都可以提供标头，描述在读取时写入的内容或所需格式。Data Grid 支持为值应用的标准 HTTP/1.1 标头 "Content-Type" 和 "Accept"，以及 "Key-Content-Type"，对键类似。

Data Grid REST 端点与 RFC-2616 Accept 标头兼容，并根据支持的转换协商正确的 MediaType。

例如，在读取数据时发送以下标头：

Accept: text/plain;q=0.7, application/json;q=0.8, */*;q=0.6

前面的标头会导致 Data Grid 首先返回 JSON 格式的内容（高优先级 0.8）。如果无法将存储格式转换为 JSON，Data Grid 将尝试下一个 text/plain 格式（具有最高优先级 0.7）。最后，Data Grid 会返回 * attention，它根据缓存配置选择合适的格式。

创建任何 REST 资源需要一个属于 URL 的名称，如果此名称包含 RFC 3986 spec 第 2.2 节 中定义的任何特殊字符，则需要使用 Percent 编码机制对其进行编码。

大多数 REST API 调用在 URL 中包含密钥。Data Grid 假设 Key 在处理这些调用时是 java.lang.String，但您可以对采用不同格式的密钥使用特定的标头 Key-Content-Type。

API 调用：

`PUT /my-cache/AQIDBDM=`

headers:

key-Content-Type: application/octet-stream

API 调用：

GET /my-cache/0x01CA03042F

headers:

Key-Content-Type: application/octet-stream; encoding=hex

API 调用：

POST /my-cache/3.141456

headers:

Key-Content-Type: application/x-java-object;type=java.lang.Double

application/x-java-object 的 type 参数仅限于：

当缓存被索引或专门配置为存储 application/x-protostream 时，您可以发送和接收自动转换为 Protostream 的 JSON 文档。

您必须注册 protobuf 模式才能使转换正常工作。

要通过 REST 注册 protobuf 模式，请在 ___protobuf_metadata 缓存中调用 POST 或 PUT，如下例所示：

curl -u user:password -X POST --data-binary @./schema.proto http://127.0.0.1:11222/rest/v2/caches/___protobuf_metadata/schema.proto

编写 JSON 文档时，文档中必须存在一个特殊字段 _type，以对与文档对应的 protobuf 消息 进行身份。

例如，请考虑以下模式：

message Person  {
  required string name = 1;
  required int32 age = 2;
}

对应的 JSON 文档如下：

{
   "_type": "Person",
   "name": "user1",
   "age": 32
}

在启动服务器时，可以使用 VM 属性 infinispan.server.rest.cors-allow，以允许所有权限对一个或多个源进行。Example:

./bin/server.sh -Dinfinispan.server.rest.cors-allow=http://192.168.1.78:11222,http://host.mydomain.com

使用此方法指定的所有源都优先于配置的规则。

使用 payload 中包含 XML 或 JSON 配置的 POST 请求，在 Data Grid 集群中创建命名的缓存。

POST /rest/v2/caches/{cacheName}

<infinispan>
    <cache-container>
        <distributed-cache name="myCache" mode="SYNC">
          <encoding media-type="application/x-protostream"/>
          <memory max-count="1000000" when-full="REMOVE"/>
        </distributed-cache>
    </cache-container>
</infinispan>

{
  "distributed-cache": {
    "name": "myCache",
    "mode": "SYNC",
    "encoding": {
      "media-type": "application/x-protostream"
      },
    "memory": {
      "max-count": 1000000,
      "when-full": "REMOVE"
    }
  }
}

检查带有 HEAD 请求的 Data Grid 集群中是否有缓存。

HEAD /rest/v2/caches/{cacheName}

通过 POST 请求和 ?template= 参数，从 Data Grid 模板创建缓存。

POST /rest/v2/caches/{cacheName}?template={templateName}

使用 GET 请求检索数据网格缓存配置。

GET /rest/v2/caches/{name}?action=config

使用有效的 XML 配置和 ?action=toJSON 参数调用 POST 请求。Data Grid 使用配置等效的 JSON 表示来响应。

POST /rest/v2/caches?action=toJSON

调用 GET 请求，以重新检查数据网格缓存的所有详细信息。

GET /rest/v2/caches/{name}

Data Grid 提供 JSON 响应，如下所示：

{
  "stats": {
    "time_since_start": -1,
    "time_since_reset": -1,
    "hits": -1,
    "current_number_of_entries": -1,
    "current_number_of_entries_in_memory": -1,
    "total_number_of_entries": -1,
    "stores": -1,
    "off_heap_memory_used": -1,
    "data_memory_used": -1,
    "retrievals": -1,
    "misses": -1,
    "remove_hits": -1,
    "remove_misses": -1,
    "evictions": -1,
    "average_read_time": -1,
    "average_read_time_nanos": -1,
    "average_write_time": -1,
    "average_write_time_nanos": -1,
    "average_remove_time": -1,
    "average_remove_time_nanos": -1,
    "required_minimum_number_of_nodes": -1
  },
  "size": 0,
  "configuration": {
    "distributed-cache": {
      "mode": "SYNC",
      "transaction": {
        "stop-timeout": 0,
        "mode": "NONE"
      }
    }
  },
  "rehash_in_progress": false,
  "bounded": false,
  "indexed": false,
  "persistent": false,
  "transactional": false,
  "secured": false,
  "has_remote_backup": false,
  "indexing_in_progress": false,
  "statistics": false
}

使用 POST 请求向缓存添加条目。

POST /rest/v2/caches/{cacheName}/{cacheKey}

前面的请求使用 cacheKey 键将有效负载或请求正文放在 cacheName 缓存中。请求会替换已经存在的任何数据，并在应用 Time-To-Live 和 Last-Modified 值时更新它们。

如果指定键已存在值，则 POST 请求会返回 HTTP CONFLICT 状态，且不会修改值。要更新值，您应该使用 PUT 请求。请参阅 替换条目。

将缓存中的条目替换为 PUT 请求。

PUT /rest/v2/caches/{cacheName}/{cacheKey}

如果指定键已存在值，PUT 请求会更新该值。如果您不想修改现有值，请使用返回 HTTP CONFLICT 状态的 POST 请求，而不是修改值。请参阅 添加值。

使用 GET 请求检索特定密钥的数据。

GET /rest/v2/caches/{cacheName}/{cacheKey}

服务器在给定密钥 cacheKey 下返回来自给定缓存 cacheName 的数据，在响应正文中返回数据。响应包含与 MediaType 协商对应的 Content-Type 标头。

GET /rest/v2/caches/{cacheName}/{cacheKey}?extended

验证 HEAD 请求是否存在特定的条目。

HEAD /rest/v2/caches/{cacheName}/{cacheKey}

前面的请求只返回标头字段，以及您与该条目存储相同的内容。例如，如果您存储了 String，请求会返回一个 String。如果您存储了二进制、base64 编码的、blob 或序列化 Java 对象，则 Data Grid 不会序列化请求中的内容。

使用 DELETE 请求从缓存中删除条目。

DELETE /rest/v2/caches/{cacheName}/{cacheKey}

使用 DELETE 请求从 Data Grid 集群中删除缓存。

DELETE /rest/v2/caches/{cacheName}

调用 GET 请求，以检索 JSON 格式的缓存中的所有密钥。

GET /rest/v2/caches/{cacheName}?action=keys

要从缓存中删除所有数据，请使用 ?action=clear 参数调用 POST 请求。

POST /rest/v2/caches/{cacheName}?action=clear

使用 GET 请求和 ?action=size 参数在整个集群中检索缓存的大小。

GET /rest/v2/caches/{cacheName}?action=size

获取使用 GET 请求缓存的运行时统计信息。

GET /rest/v2/caches/{cacheName}?action=stats

对带有 GET 请求和 ?action=search&query 参数的缓存执行 Ickle 查询。

GET /rest/v2/caches/{cacheName}?action=search&query={ickle query}

Data Grid 使用查询点击进行响应，如下所示：

{
  "total_results" : 150,
  "hits" : [ {
    "hit" : {
      "name" : "user1",
      "age" : 35
    }
  }, {
    "hit" : {
       "name" : "user2",
       "age" : 42
    }
  }, {
    "hit" : {
       "name" : "user3",
       "age" : 12
    }
  } ]
}

要使用请求的正文而不是指定查询参数，请按如下所示调用 POST 请求：

POST /rest/v2/caches/{cacheName}?action=search

以下示例显示了请求正文中的查询：

{
 "query":"from Entity where name:\"user1\"",
 "max_results":20,
 "offset":10
}

使用 POST 请求和 ?action=mass-index&mode={mode} 参数重新索引缓存中的所有数据。

POST  /v2/caches/{cacheName}/search/indexes?action=mass-index&mode={mode}

mode 参数的值如下：

使用 POST 请求和 ?action=clear 参数从缓存中删除所有索引。

POST  /v2/caches/{cacheName}/search/indexes?action=clear

使用 GET 请求，获取缓存中的索引信息。

GET /v2/caches/{cacheName}/search/indexes/stats

Data Grid 提供 JSON 响应，如下所示：

{
    "indexed_class_names": ["org.infinispan.sample.User"],
    "indexed_entities_count": {
        "org.infinispan.sample.User": 4
    },
    "index_sizes": {
        "cacheName_protobuf": 14551
    },
    "reindexing": false
}

使用 GET 请求，获取有关在缓存中运行的查询的信息。

GET /v2/caches/{cacheName}/search/query/stats

Data Grid 提供 JSON 响应，如下所示：

{
    "search_query_execution_count":20,
    "search_query_total_time":5,
    "search_query_execution_max_time":154,
    "search_query_execution_avg_time":2,
    "object_loading_total_time":1,
    "object_loading_execution_max_time":1,
    "object_loading_execution_avg_time":1,
    "objects_loaded_count":20,
    "search_query_execution_max_time_query_string": "FROM entity"
}

通过 POST 请求和 ?action=clear 参数重置运行时统计信息。

POST /v2/caches/{cacheName}/search/query/stats?action=clear

列出具有 GET 请求的 Data Grid 集群中的所有可用缓存。

GET /rest/v2/caches/

使用 Data Grid REST API 执行跨站点复制操作。

GET /v2/caches/{cacheName}/x-site/backups/

{
  "NYC": "online",
  "LON": "offline"
}

GET /v2/caches/{cacheName}/x-site/backups/{siteName}

{
  "NodeA":"offline",
  "NodeB":"online"
}

POST /v2/caches/{cacheName}/x-site/backups/{siteName}?action=take-offline

POST /v2/caches/{cacheName}/x-site/backups/{siteName}?action=bring-online

POST /v2/caches/{cacheName}/x-site/backups/{siteName}?action=start-push-state

POST /v2/caches/{cacheName}/x-site/backups/{siteName}?action=cancel-push-state

GET /v2/caches/{cacheName}/x-site/backups?action=push-state-status

{
   "NYC":"CANCELED",
   "LON":"OK"
}

POST /v2/caches/{cacheName}/x-site/local?action=clear-push-state-status

POST /v2/caches/{cacheName}/x-site/backups/{siteName}?action=cancel-receive-state

在 Data Grid 集群间执行缓存数据的滚动升级

POST /v2/caches/{cacheName}?action=sync-data

POST /v2/caches/{cacheName}?action=disconnect-source

使用在有效负载中包含配置的 POST 请求创建计数器。

POST /rest/v2/counters/{counterName}

{
    "weak-counter":{
        "initial-value":5,
        "storage":"PERSISTENT",
        "concurrency-level":1
    }
}

{
    "strong-counter":{
        "initial-value":3,
        "storage":"PERSISTENT",
        "upper-bound":5
    }
}

使用 DELETE 请求删除特定计数器。

DELETE /rest/v2/counters/{counterName}

检索具有 GET 请求的特定计数器的配置。

GET /rest/v2/counters/{counterName}/config

Data Grid 以 JSON 格式使用计数器配置响应。

使用 POST 请求为特定计数器添加值。

POST /rest/v2/counters/{counterName}

如果请求有效负载为空，则计数器会递增，否则有效负载将解释为已签名并添加到计数器中。

使用 GET 请求检索计数器值。

GET /rest/v2/counters/{counterName}

在没有 POST 请求和 ?action=reset 参数的情况下恢复计数器的 intial 值。

POST /rest/v2/counters/{counterName}?action=reset

使用 POST 请求' 和 ?action=increment 参数递增计数器值。

POST /rest/v2/counters/{counterName}?action=increment

使用包含 ?action=add 和 delta 参数的 POST 请求向计数器添加任意值。

POST /rest/v2/counters/{counterName}?action=add&delta={delta}

使用 POST 请求和 ?action=decrement 参数减少计数器值。

POST /rest/v2/counters/{counterName}?action=decrement

原子为具有 GET 请求和 compareAndSet 参数的强计数器设置值。

POST /rest/v2/counters/{counterName}?action=compareAndSet&expect={expect}&update={update}

如果当前值为 {expect}，则以原子方式将值设为 {update}。如果操作成功，Data Grid 返回 true。

atomic 为强计数器设置值与 GET 请求，以及 compareAndSwap 参数。

POST /rest/v2/counters/{counterName}?action=compareAndSwap&expect={expect}&update={update}

如果当前值为 {expect}，则以原子方式将值设为 {update}。如果操作成功，Data Grid 会返回有效负载中前面的值。

检索具有 GET 请求的 Data Grid 集群中的计数器列表。

GET /rest/v2/counters/

使用 POST 请求在 Data Grid 集群间创建 Protobuf 模式，该请求在有效负载中包含 protobuf 文件的内容。

POST /rest/v2/schemas/{schemaName}

如果架构已存在，Data Grid 返回 CONFLICT。如果架构无效，无论是由于语法错误，或由于其某些依赖项丢失，则数据网格会存储架构并在响应正文中返回错误。

Data Grid 使用架构名称和任何错误进行响应。

{
  "name" : "users.proto",
  "error" : {
    "message": "Schema users.proto has errors",
    "cause": "java.lang.IllegalStateException:Syntax error in error.proto at 3:8: unexpected label: messoge"
  }
}

使用 GET 请求从 Data Grid 检索 Protobuf 模式。

GET /rest/v2/schemas/{schemaName}

修改包含有效负载中 protobuf 文件的内容的 PUT 请求的 Protobuf 模式。

PUT /rest/v2/schemas/{schemaName}

如果架构无效，无论是由于语法错误，或由于其某些依赖项丢失，则数据网格会更新架构并在响应正文中返回错误。

{
  "name" : "users.proto",
  "error" : {
    "message": "Schema users.proto has errors",
    "cause": "java.lang.IllegalStateException:Syntax error in error.proto at 3:8: unexpected label: messoge"
  }
}

使用 DELETE 请求从 Data Grid 集群中删除 Protobuf 模式。

DELETE /rest/v2/schemas/{schemaName}

使用 GET 请求列出所有可用的 Protobuf 模式。

GET /rest/v2/schemas/

Data Grid 使用集群中所有可用的模式列表进行响应。

[ {
  "name" : "users.proto",
  "error" : {
    "message": "Schema users.proto has errors",
    "cause": "java.lang.IllegalStateException:Syntax error in error.proto at 3:8: unexpected label: messoge"
  }
}, {
  "name" : "people.proto",
  "error" : null
}]

使用 GET 请求检索有关缓存管理器的信息。

GET /rest/v2/cache-managers/{cacheManagerName}

Data Grid 使用 JSON 格式的信息响应，如下例所示：

{
    "version":"xx.x.x-FINAL",
    "name":"default",
    "coordinator":true,
    "cache_configuration_names":[
        "___protobuf_metadata",
        "cache2",
        "CacheManagerResourceTest",
        "cache1"
    ],
    "cluster_name":"ISPN",
    "physical_addresses":"[127.0.0.1:35770]",
    "coordinator_address":"CacheManagerResourceTest-NodeA-49696",
    "cache_manager_status":"RUNNING",
    "created_cache_count":"3",
    "running_cache_count":"3",
    "node_address":"CacheManagerResourceTest-NodeA-49696",
    "cluster_members":[
        "CacheManagerResourceTest-NodeA-49696",
        "CacheManagerResourceTest-NodeB-28120"
    ],
    "cluster_members_physical_addresses":[
        "127.0.0.1:35770",
        "127.0.0.1:60031"
    ],
    "cluster_size":2,
    "defined_caches":[
        {
            "name":"CacheManagerResourceTest",
            "started":true
        },
        {
            "name":"cache1",
            "started":true
        },
        {
            "name":"___protobuf_metadata",
            "started":true
        },
        {
            "name":"cache2",
            "started":true
        }
    ]

}

使用 GET 请求检索 Data Grid 集群的健康信息。

GET /rest/v2/cache-managers/{cacheManagerName}/health

Data Grid 使用 JSON 格式的集群健康信息响应，如下例所示：

{
    "cluster_health":{
        "cluster_name":"ISPN",
        "health_status":"HEALTHY",
        "number_of_nodes":2,
        "node_names":[
            "NodeA-36229",
            "NodeB-28703"
        ]
    },
    "cache_health":[
        {
            "status":"HEALTHY",
            "cache_name":"___protobuf_metadata"
        },
        {
            "status":"HEALTHY",
            "cache_name":"cache2"
        },
        {
            "status":"HEALTHY",
            "cache_name":"mycache"
        },
        {
            "status":"HEALTHY",
            "cache_name":"cache1"
        }
    ]

}

使用不需要身份验证的 GET 请求检索 Cache Managers 的健康状况。

GET /rest/v2/cache-managers/{cacheManagerName}/health/status

Data Grid 以 text/plain 格式之一响应：

验证 Data Grid server REST 端点可用性与 HEAD 请求。

HEAD /rest/v2/cache-managers/{cacheManagerName}/health

如果您收到成功的响应代码，则 Data Grid REST 服务器正在运行并服务请求。

使用 GET 请求检索缓存管理器的全局配置。

GET /rest/v2/cache-managers/{cacheManagerName}/config

检索具有 GET 请求的所有缓存的配置。

GET /rest/v2/cache-managers/{cacheManagerName}/cache-configs

Data Grid 使用包含每个缓存和缓存配置的 JSON 阵列响应，如下例所示：

[
  {
      "name":"cache1",
      "configuration":{
          "distributed-cache":{
              "mode":"SYNC",
              "partition-handling":{
                  "when-split":"DENY_READ_WRITES"
              },
              "statistics":true
          }
      }
  },
  {
      "name":"cache2",
      "configuration":{
          "distributed-cache":{
              "mode":"SYNC",
              "transaction":{
                  "mode":"NONE"
              }
          }
      }
  }
]

使用 GET 请求检索所有可用的 Data Grid 缓存模板。

GET /rest/v2/cache-managers/{cacheManagerName}/cache-configs/templates

检索缓存管理器的所有可用缓存列表，以及缓存状态和详情，以及 GET 请求。

GET /rest/v2/cache-managers/{cacheManagerName}/caches

Data Grid 使用列出和描述每个可用缓存的 JSON 阵列响应，如下例所示：

[ {
  "status" : "RUNNING",
  "name" : "cache1",
  "type" : "local-cache",
  "simple_cache" : false,
  "transactional" : false,
  "persistent" : false,
  "bounded": false,
  "secured": false,
  "indexed": true,
  "has_remote_backup": true,
  "health":"HEALTHY"
}, {
  "status" : "RUNNING",
  "name" : "cache2",
  "type" : "distributed-cache",
  "simple_cache" : false,
  "transactional" : true,
  "persistent" : false,
  "bounded": false,
  "secured": false,
  "indexed": true,
  "has_remote_backup": true,
  "health":"HEALTHY"
}]

使用 GET 请求检索缓存管理器的统计信息。

GET /rest/v2/cache-managers/{cacheManagerName}/stats

Data Grid 以 JSON 格式使用缓存管理器统计信息响应，如下例所示：

{
    "statistics_enabled":true,
    "read_write_ratio":0.0,
    "time_since_start":1,
    "time_since_reset":1,
    "number_of_entries":0,
    "total_number_of_entries":0,
    "off_heap_memory_used":0,
    "data_memory_used":0,
    "misses":0,
    "remove_hits":0,
    "remove_misses":0,
    "evictions":0,
    "average_read_time":0,
    "average_read_time_nanos":0,
    "average_write_time":0,
    "average_write_time_nanos":0,
    "average_remove_time":0,
    "average_remove_time_nanos":0,
    "required_minimum_number_of_nodes":1,
    "hits":0,
    "stores":0,
    "current_number_of_entries_in_memory":0,
    "hit_ratio":0.0,
    "retrievals":0
}

使用缓存管理器执行跨站点操作，以将操作应用到所有缓存。

GET /rest/v2/cache-managers/{cacheManagerName}/x-site/backups/

{
   "SFO-3":{
      "status":"online"
   },
   "NYC-2":{
      "status":"mixed",
      "online":[
         "CACHE_1"
      ],
      "offline":[
         "CACHE_2"
      ]
   }
}

POST /rest/v2/cache-managers/{cacheManagerName}/x-site/backups/{siteName}?action=take-offline

POST /rest/v2/cache-managers/{cacheManagerName}/x-site/backups/{siteName}?action=bring-online

POST /rest/v2/cache-managers/{cacheManagerName}/x-site/backups/{siteName}?action=start-push-state

POST /rest/v2/cache-managers/{cacheManagerName}/x-site/backups/{siteName}?action=cancel-push-state

使用 GET 请求查看有关 Data Grid 服务器的基本信息。

GET /rest/v2/server

Data Grid 以 JSON 格式使用服务器名称、代码名称和版本响应，如下例所示：

{
  "version":"Infinispan 'Codename' xx.x.x.Final"
}

使用 GET 请求，检索用于 Data Grid 服务器的缓存管理器列表。

GET /rest/v2/server/cache-managers

Data Grid 使用为服务器配置缓存管理器名称的数组响应。

配置 Data Grid 以临时排除客户端请求的特定缓存。发送包含缓存管理器名称和缓存的空 POST 请求。

POST /v2/server/ignored-caches/{cache-manager}/{cache}

Data Grid 返回用于 REST 客户端请求的服务不可用状态(503)，为 Hot Rod 客户端请求返回一个 Server Error (code 0x85)。

使用 DELETE 请求从 ignore 列表中删除缓存。

DELETE /v2/server/ignored-caches/{cache-manager}/{cache}

确认通过 GET 请求会忽略缓存。

GET /v2/server/ignored-caches/{cache-manager}

使用 GET 请求检索数据网格服务器配置。

GET /rest/v2/server/config

Data Grid 使用 JSON 格式的配置响应，如下所示：

{
    "server":{
        "interfaces":{
            "interface":{
                "name":"public",
                "inet-address":{
                    "value":"127.0.0.1"
                }
            }
        },
        "socket-bindings":{
            "port-offset":0,
            "default-interface":"public",
            "socket-binding":[
                {
                    "name":"memcached",
                    "port":11221,
                    "interface":"memcached"
                }
            ]
        },
        "security":{
            "security-realms":{
                "security-realm":{
                    "name":"default"
                }
            }
        },
        "endpoints":{
            "socket-binding":"default",
            "security-realm":"default",
            "hotrod-connector":{
                "name":"hotrod"
            },
            "rest-connector":{
                "name":"rest"
            }
        }
    }
}

使用 GET 请求检索 Data Grid 服务器的所有环境变量。

GET /rest/v2/server/env

检索具有 GET 请求的 Data Grid 服务器的 JVM 内存用量信息。

GET /rest/v2/server/memory

Data Grid 使用堆和非堆内存统计信息响应，直接内存用量，以及 JSON 格式的内存池和垃圾回收的信息。

使用 GET 请求检索 JVM 的当前线程转储。

GET /rest/v2/server/threads

Data Grid 以 text/plain 格式使用当前的线程转储响应。

使用 GET 请求检索 Data Grid 服务器的聚合报告。

GET /rest/v2/server/report

Data Grid 使用 tar.gz 存档进行响应，其中包含一个聚合的报告，其中包含有关 Data Grid 服务器和主机的诊断信息。除了配置和日志文件外，该报告还提供有关 CPU、内存、打开文件、网络套接字和路由线程的详细信息。

使用 POST 请求停止 Data Grid 服务器。

POST /rest/v2/server?action=stop

网格以 200 (OK) 响应，然后停止运行。

使用 POST 请求关闭整个 Data Grid 集群。

POST /rest/v2/cluster?action=stop

网格以 200 (OK) 响应，然后执行整个集群的顺序关闭。

使用 GET 请求和 ?action=stop&server 参数关闭 Data Grid 集群中的一个或多个特定服务器。

POST /rest/v2/cluster?action=stop&server={server1_host}&server={server2_host}

数据网格以 200 (OK) 响应。

查看所有配置的带有 GET 请求的附加程序列表。

GET /rest/v2/logging/appenders

Data Grid 使用 JSON 格式的附加器列表响应，如下例所示：

{
  "STDOUT" : {
    "name" : "STDOUT"
  },
  "JSON-FILE" : {
    "name" : "JSON-FILE"
  },
  "HR-ACCESS-FILE" : {
    "name" : "HR-ACCESS-FILE"
  },
  "FILE" : {
    "name" : "FILE"
  },
  "REST-ACCESS-FILE" : {
    "name" : "REST-ACCESS-FILE"
  }
}

查看所有配置的带有 GET 请求的日志记录器的列表。

GET /rest/v2/logging/loggers

Data Grid 使用 JSON 格式的日志记录器列表响应，如下例所示：

[ {
  "name" : "",
  "level" : "INFO",
  "appenders" : [ "STDOUT", "FILE" ]
}, {
  "name" : "org.infinispan.HOTROD_ACCESS_LOG",
  "level" : "INFO",
  "appenders" : [ "HR-ACCESS-FILE" ]
}, {
  "name" : "com.arjuna",
  "level" : "WARN",
  "appenders" : [ ]
}, {
  "name" : "org.infinispan.REST_ACCESS_LOG",
  "level" : "INFO",
  "appenders" : [ "REST-ACCESS-FILE" ]
} ]

创建新日志记录器或修改带有 PUT 请求的现有日志记录器。

PUT /rest/v2/logging/loggers/{loggerName}?level={level}&appender={appender}&appender={appender}...

Data Grid 将 {loggerName} 标识的日志记录器级别设置为 {level}。（可选）可以为日志记录器设置一个或多个附加程序。如果没有指定附加程序，则将使用 root 日志记录器中指定的程序。

删除具有 DELETE 请求的现有日志记录器。

DELETE /rest/v2/logging/loggers/{loggerName}

Data Grid 删除 {loggerName} 标识的日志记录器，并有效地恢复到使用根日志记录器配置。

使用 GET 请求查看有关可用服务器任务的信息。

GET /rest/v2/tasks

Data Grid 使用可用任务列表进行响应。列表中包括任务的名称、处理任务的引擎、任务的指定参数、任务的执行模式，可以是 ONE_NODE 或 ALL_NODES，以及 JSON 格式的允许的安全角色，如下例所示：

[
  {
    "name": "SimpleTask",
    "type": "TaskEngine",
    "parameters": [
      "p1",
      "p2"
    ],
    "execution_mode": "ONE_NODE",
    "allowed_role": null
  },
  {
    "name": "RunOnAllNodesTask",
    "type": "TaskEngine",
    "parameters": [
      "p1"
    ],
    "execution_mode": "ALL_NODES",
    "allowed_role": null
  },
  {
    "name": "SecurityAwareTask",
    "type": "TaskEngine",
    "parameters": [],
    "execution_mode": "ONE_NODE",
    "allowed_role": "MyRole"
  }
]

使用 GET 请求执行任务，其中包含以 param 前缀的任务名称和必需参数。

GET /rest/v2/tasks/myTask?action=exec&param.p1=v1&param.p2=v2

Data Grid 使用任务结果做出响应。

使用 PUT 或 POST 请求上传脚本任务。

提供 脚本作为请求的内容有效负载。在数据网格上传脚本后，您可以使用 GET 请求执行该脚本。

POST /rest/v2/tasks/taskName