| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.ignite.util; |
| |
| import java.lang.reflect.Field; |
| import java.sql.Connection; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.Properties; |
| import java.util.Set; |
| import java.util.UUID; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.atomic.AtomicInteger; |
| import java.util.function.Consumer; |
| import java.util.stream.Collectors; |
| import org.apache.ignite.Ignite; |
| import org.apache.ignite.IgniteCache; |
| import org.apache.ignite.IgniteJdbcThinDriver; |
| import org.apache.ignite.Ignition; |
| import org.apache.ignite.cache.CacheMode; |
| import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction; |
| import org.apache.ignite.cache.query.ContinuousQuery; |
| import org.apache.ignite.cache.query.QueryCursor; |
| import org.apache.ignite.cache.query.ScanQuery; |
| import org.apache.ignite.cache.query.SqlFieldsQuery; |
| import org.apache.ignite.client.IgniteClient; |
| import org.apache.ignite.configuration.CacheConfiguration; |
| import org.apache.ignite.configuration.ClientConfiguration; |
| import org.apache.ignite.configuration.DataRegionConfiguration; |
| import org.apache.ignite.configuration.DataStorageConfiguration; |
| import org.apache.ignite.configuration.IgniteConfiguration; |
| import org.apache.ignite.configuration.SqlConfiguration; |
| import org.apache.ignite.internal.IgniteEx; |
| import org.apache.ignite.internal.binary.mutabletest.GridBinaryTestClasses.TestObjectAllTypes; |
| import org.apache.ignite.internal.binary.mutabletest.GridBinaryTestClasses.TestObjectEnum; |
| import org.apache.ignite.internal.commandline.CommandList; |
| import org.apache.ignite.internal.commandline.systemview.SystemViewCommandArg; |
| import org.apache.ignite.internal.metric.SystemViewSelfTest.TestPredicate; |
| import org.apache.ignite.internal.metric.SystemViewSelfTest.TestRunnable; |
| import org.apache.ignite.internal.metric.SystemViewSelfTest.TestTransformer; |
| import org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion; |
| import org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState; |
| import org.apache.ignite.internal.processors.cache.metric.SqlViewExporterSpiTest.TestAffinityFunction; |
| import org.apache.ignite.internal.processors.cache.persistence.GridCacheDatabaseSharedManager; |
| import org.apache.ignite.internal.processors.cache.persistence.IgniteCacheDatabaseSharedManager; |
| import org.apache.ignite.internal.processors.metastorage.DistributedMetaStorage; |
| import org.apache.ignite.internal.processors.service.DummyService; |
| import org.apache.ignite.internal.util.StripedExecutor; |
| import org.apache.ignite.internal.util.typedef.internal.U; |
| import org.apache.ignite.internal.visor.systemview.VisorSystemViewTask; |
| import org.apache.ignite.services.ServiceConfiguration; |
| import org.apache.ignite.spi.systemview.view.SystemView; |
| import org.apache.ignite.spi.systemview.view.SystemViewRowAttributeWalker.AttributeVisitor; |
| import org.apache.ignite.testframework.GridTestUtils; |
| import org.apache.ignite.transactions.Transaction; |
| import org.junit.Test; |
| |
| import static java.lang.Integer.MAX_VALUE; |
| import static java.util.Arrays.asList; |
| import static java.util.concurrent.TimeUnit.MILLISECONDS; |
| import static java.util.regex.Pattern.quote; |
| import static org.apache.ignite.cache.CacheAtomicityMode.TRANSACTIONAL; |
| import static org.apache.ignite.cluster.ClusterState.ACTIVE; |
| import static org.apache.ignite.cluster.ClusterState.INACTIVE; |
| import static org.apache.ignite.internal.commandline.CommandHandler.EXIT_CODE_INVALID_ARGUMENTS; |
| import static org.apache.ignite.internal.commandline.CommandHandler.EXIT_CODE_OK; |
| import static org.apache.ignite.internal.commandline.CommandList.SYSTEM_VIEW; |
| import static org.apache.ignite.internal.commandline.systemview.SystemViewCommand.COLUMN_SEPARATOR; |
| import static org.apache.ignite.internal.commandline.systemview.SystemViewCommandArg.NODE_ID; |
| import static org.apache.ignite.internal.managers.systemview.GridSystemViewManager.STREAM_POOL_QUEUE_VIEW; |
| import static org.apache.ignite.internal.managers.systemview.GridSystemViewManager.SYS_POOL_QUEUE_VIEW; |
| import static org.apache.ignite.internal.managers.systemview.ScanQuerySystemView.SCAN_QRY_SYS_VIEW; |
| import static org.apache.ignite.internal.metric.SystemViewSelfTest.TEST_PREDICATE; |
| import static org.apache.ignite.internal.metric.SystemViewSelfTest.TEST_TRANSFORMER; |
| import static org.apache.ignite.internal.processors.cache.ClusterCachesInfo.CACHES_VIEW; |
| import static org.apache.ignite.internal.processors.cache.ClusterCachesInfo.CACHE_GRPS_VIEW; |
| import static org.apache.ignite.internal.processors.cache.GridCacheProcessor.CACHE_GRP_PAGE_LIST_VIEW; |
| import static org.apache.ignite.internal.processors.cache.GridCacheProcessor.PART_STATES_VIEW; |
| import static org.apache.ignite.internal.processors.cache.GridCacheUtils.cacheGroupId; |
| import static org.apache.ignite.internal.processors.cache.GridCacheUtils.cacheId; |
| import static org.apache.ignite.internal.processors.cache.binary.CacheObjectBinaryProcessorImpl.BINARY_METADATA_VIEW; |
| import static org.apache.ignite.internal.processors.cache.index.AbstractSchemaSelfTest.queryProcessor; |
| import static org.apache.ignite.internal.processors.cache.persistence.GridCacheDatabaseSharedManager.METASTORE_VIEW; |
| import static org.apache.ignite.internal.processors.cache.persistence.IgniteCacheDatabaseSharedManager.DATA_REGION_PAGE_LIST_VIEW; |
| import static org.apache.ignite.internal.processors.cache.transactions.IgniteTxManager.TXS_MON_LIST; |
| import static org.apache.ignite.internal.processors.continuous.GridContinuousProcessor.CQ_SYS_VIEW; |
| import static org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageImpl.DISTRIBUTED_METASTORE_VIEW; |
| import static org.apache.ignite.internal.processors.metric.impl.MetricUtils.toSqlName; |
| import static org.apache.ignite.internal.processors.odbc.ClientListenerProcessor.CLI_CONN_VIEW; |
| import static org.apache.ignite.internal.processors.query.QueryUtils.DFLT_SCHEMA; |
| import static org.apache.ignite.internal.processors.query.QueryUtils.SCHEMA_SYS; |
| import static org.apache.ignite.internal.processors.query.h2.SchemaManager.SQL_SCHEMA_VIEW; |
| import static org.apache.ignite.internal.processors.query.h2.SchemaManager.SQL_TBLS_VIEW; |
| import static org.apache.ignite.internal.processors.query.h2.SchemaManager.SQL_TBL_COLS_VIEW; |
| import static org.apache.ignite.internal.processors.query.h2.SchemaManager.SQL_VIEWS_VIEW; |
| import static org.apache.ignite.internal.processors.query.h2.SchemaManager.SQL_VIEW_COLS_VIEW; |
| import static org.apache.ignite.internal.processors.service.IgniteServiceProcessor.SVCS_VIEW; |
| import static org.apache.ignite.internal.processors.task.GridTaskProcessor.TASKS_VIEW; |
| import static org.apache.ignite.internal.util.IgniteUtils.toStringSafe; |
| import static org.apache.ignite.testframework.GridTestUtils.assertContains; |
| import static org.apache.ignite.testframework.GridTestUtils.waitForCondition; |
| import static org.apache.ignite.transactions.TransactionConcurrency.OPTIMISTIC; |
| import static org.apache.ignite.transactions.TransactionConcurrency.PESSIMISTIC; |
| import static org.apache.ignite.transactions.TransactionIsolation.REPEATABLE_READ; |
| import static org.apache.ignite.transactions.TransactionIsolation.SERIALIZABLE; |
| |
| /** Tests output of {@link CommandList#SYSTEM_VIEW} command. */ |
| public class SystemViewCommandTest extends GridCommandHandlerClusterByClassAbstractTest { |
| /** Command line argument for printing content of a system view. */ |
| private static final String CMD_SYS_VIEW = SYSTEM_VIEW.text(); |
| |
| /** Latch that is used to unblock all compute jobs. */ |
| private static final CountDownLatch COMPUTE_JOB_UNBLOCK_LATCH = new CountDownLatch(1); |
| |
| /** Latch that indicates number of compute jobs to be blocked.*/ |
| private static final CountDownLatch COMPUTE_JOB_BLOCK_LATCH = new CountDownLatch(5); |
| |
| /** Name of the test data region. */ |
| private static final String DATA_REGION_NAME = "in-memory"; |
| |
| /** Test node with 0 index. */ |
| private IgniteEx ignite0; |
| |
| /** Test node with 1 index. */ |
| private IgniteEx ignite1; |
| |
| /** {@inheritDoc} */ |
| @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception { |
| IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName); |
| |
| cfg.setDataStorageConfiguration(new DataStorageConfiguration() |
| .setDataRegionConfigurations(new DataRegionConfiguration() |
| .setName(DATA_REGION_NAME) |
| .setMaxSize(100L * 1024 * 1024)) |
| .setDefaultDataRegionConfiguration(new DataRegionConfiguration() |
| .setPersistenceEnabled(true))); |
| |
| return cfg; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override protected void beforeTest() throws Exception { |
| super.beforeTest(); |
| |
| injectTestSystemOut(); |
| |
| autoConfirmation = false; |
| |
| ignite0 = ignite(0); |
| ignite1 = ignite(1); |
| } |
| |
| /** Tests command error output in case of mandatory system view name is omitted. */ |
| @Test |
| public void testSystemViewNameMissedFailure() { |
| assertContains(log, executeCommand(EXIT_CODE_INVALID_ARGUMENTS, CMD_SYS_VIEW), |
| "The name of the system view for which its content should be printed is expected."); |
| } |
| |
| /** Tests command error output in case value of {@link SystemViewCommandArg#NODE_ID} argument is omitted. */ |
| @Test |
| public void testNodeIdMissedFailure() { |
| assertContains(log, executeCommand(EXIT_CODE_INVALID_ARGUMENTS, CMD_SYS_VIEW, SVCS_VIEW, NODE_ID.argName()), |
| "ID of the node from which system view content should be obtained is expected."); |
| } |
| |
| /** Tests command error output in case value of {@link SystemViewCommandArg#NODE_ID} argument is invalid.*/ |
| @Test |
| public void testInvalidNodeIdFailure() { |
| assertContains(log, |
| executeCommand(EXIT_CODE_INVALID_ARGUMENTS, CMD_SYS_VIEW, SVCS_VIEW, NODE_ID.argName(), "invalid_node_id"), |
| "Failed to parse " + NODE_ID.argName() + |
| " command argument. String representation of \"java.util.UUID\" is exepected." + |
| " For example: 123e4567-e89b-42d3-a456-556642440000" |
| ); |
| } |
| |
| /** Tests command error output in case multiple system view names are specified. */ |
| @Test |
| public void testMultipleSystemViewNamesFailure() { |
| assertContains(log, |
| executeCommand(EXIT_CODE_INVALID_ARGUMENTS, CMD_SYS_VIEW, SVCS_VIEW, CACHE_GRP_PAGE_LIST_VIEW), |
| "Multiple system view names are not supported."); |
| } |
| |
| /** |
| * Tests command error output in case {@link SystemViewCommandArg#NODE_ID} argument value refers to nonexistent |
| * node. |
| */ |
| @Test |
| public void testNonExistentNodeIdFailure() { |
| String incorrectNodeId = UUID.randomUUID().toString(); |
| |
| assertContains(log, |
| executeCommand(EXIT_CODE_INVALID_ARGUMENTS, CMD_SYS_VIEW, "--node-id", incorrectNodeId, CACHES_VIEW), |
| "Failed to perform operation.\nNode with id=" + incorrectNodeId + " not found"); |
| } |
| |
| /** Tests command output in case nonexistent system view names is specified. */ |
| @Test |
| public void testNonExistentSystemView() { |
| assertContains(log, executeCommand(EXIT_CODE_OK, CMD_SYS_VIEW, "non_existent_system_view"), |
| "No system view with specified name was found [name=non_existent_system_view]"); |
| } |
| |
| /** */ |
| @Test |
| public void testCachesView() { |
| Set<String> cacheNames = new HashSet<>(asList("cache-1", "cache-2")); |
| |
| cacheNames.forEach(cacheName -> ignite0.createCache(cacheName)); |
| |
| List<List<String>> cachesView = systemView(ignite0, CACHES_VIEW); |
| |
| assertEquals(ignite0.context().cache().cacheDescriptors().size(), cachesView.size()); |
| |
| cachesView.forEach(row -> cacheNames.remove(row.get(0))); |
| |
| assertTrue(cacheNames.isEmpty()); |
| } |
| |
| /** */ |
| @Test |
| public void testCacheGroupsView() { |
| Set<String> grpNames = new HashSet<>(asList("grp-1", "grp-2")); |
| |
| for (String grpName : grpNames) |
| ignite0.createCache(new CacheConfiguration<>("cache-" + grpName).setGroupName(grpName)); |
| |
| List<List<String>> cacheGrpsView = systemView(ignite0, CACHE_GRPS_VIEW); |
| |
| assertEquals(ignite0.context().cache().cacheGroupDescriptors().size(), cacheGrpsView.size()); |
| |
| cacheGrpsView.forEach(row -> grpNames.remove(row.get(0))); |
| |
| assertTrue(grpNames.toString(), grpNames.isEmpty()); |
| } |
| |
| /** */ |
| @Test |
| public void testComputeBroadcast() throws Exception { |
| long tasksCnt = COMPUTE_JOB_BLOCK_LATCH.getCount(); |
| |
| try { |
| for (int i = 0; i < tasksCnt; i++) { |
| ignite0.compute().broadcastAsync(() -> { |
| try { |
| COMPUTE_JOB_BLOCK_LATCH.countDown(); |
| COMPUTE_JOB_UNBLOCK_LATCH.await(); |
| } |
| catch (InterruptedException e) { |
| throw new RuntimeException(e); |
| } |
| }); |
| } |
| |
| COMPUTE_JOB_BLOCK_LATCH.await(); |
| |
| List<List<String>> tasksView = systemView(ignite0, TASKS_VIEW).stream() |
| .filter(row -> !VisorSystemViewTask.class.getName().equals(row.get(3))) |
| .collect(Collectors.toList()); |
| |
| assertEquals(tasksCnt, tasksView.size()); |
| |
| tasksView.forEach(row -> { |
| assertEquals("false", row.get(10)); //internal |
| assertEquals("null", row.get(6)); // affinityCacheName |
| assertEquals("-1", row.get(5)); // affinityPartitionId |
| assertTrue(row.get(4).startsWith(getClass().getName())); // taskClassName |
| assertTrue(row.get(3).startsWith(getClass().getName())); // taskName |
| assertEquals(ignite0.localNode().id().toString(), row.get(2)); // taskNodeId |
| assertEquals("0", row.get(12)); // userVersion |
| }); |
| } |
| finally { |
| COMPUTE_JOB_UNBLOCK_LATCH.countDown(); |
| } |
| } |
| |
| /** */ |
| @Test |
| public void testServices() { |
| ServiceConfiguration srvcCfg = new ServiceConfiguration(); |
| |
| srvcCfg.setName("service"); |
| srvcCfg.setMaxPerNodeCount(1); |
| srvcCfg.setService(new DummyService()); |
| |
| ignite0.services().deploy(srvcCfg); |
| |
| List<List<String>> srvsView = systemView(ignite0, SVCS_VIEW); |
| |
| assertEquals(1, srvsView.size()); |
| |
| List<String> sysView = srvsView.get(0); |
| |
| assertEquals(srvcCfg.getName(), sysView.get(1)); // name |
| assertEquals(DummyService.class.getName(), sysView.get(2)); // serviceClass |
| assertEquals(Integer.toString(srvcCfg.getMaxPerNodeCount()), sysView.get(6)); // maxPerNodeCount |
| } |
| |
| /** */ |
| @Test |
| public void testClientsConnections() throws Exception { |
| String host = ignite0.configuration().getClientConnectorConfiguration().getHost(); |
| |
| if (host == null) |
| host = ignite0.configuration().getLocalHost(); |
| |
| int port = ignite0.configuration().getClientConnectorConfiguration().getPort(); |
| |
| try ( |
| IgniteClient ignored1 = Ignition.startClient(new ClientConfiguration().setAddresses(host + ":" + port)); |
| Connection ignored2 = new IgniteJdbcThinDriver().connect("jdbc:ignite:thin://" + host, new Properties()) |
| ) { |
| assertEquals(2, systemView(ignite0, CLI_CONN_VIEW).size()); |
| } |
| } |
| |
| /** */ |
| @Test |
| public void testTransactions() throws Exception { |
| IgniteCache<Integer, Integer> cache = ignite0.createCache( |
| new CacheConfiguration<Integer, Integer>("test-cache").setAtomicityMode(TRANSACTIONAL)); |
| |
| assertTrue(systemView(ignite0, TXS_MON_LIST).isEmpty()); |
| |
| CountDownLatch txBlockLatch = new CountDownLatch(10); |
| CountDownLatch txUnblockLatch = new CountDownLatch(1); |
| |
| try { |
| AtomicInteger cntr = new AtomicInteger(); |
| |
| GridTestUtils.runMultiThreadedAsync(() -> { |
| try ( |
| Transaction ignored = ignite0.transactions().withLabel("test") |
| .txStart(PESSIMISTIC, REPEATABLE_READ) |
| ) { |
| cache.put(cntr.incrementAndGet(), cntr.incrementAndGet()); |
| cache.put(cntr.incrementAndGet(), cntr.incrementAndGet()); |
| |
| txBlockLatch.countDown(); |
| txUnblockLatch.await(); |
| } |
| catch (InterruptedException e) { |
| throw new RuntimeException(e); |
| } |
| }, 5, "sys-view-cmd-tx-test-1"); |
| |
| GridTestUtils.runMultiThreadedAsync(() -> { |
| try (Transaction ignored = ignite0.transactions().txStart(OPTIMISTIC, SERIALIZABLE)) { |
| cache.put(cntr.incrementAndGet(), cntr.incrementAndGet()); |
| cache.put(cntr.incrementAndGet(), cntr.incrementAndGet()); |
| |
| txBlockLatch.countDown(); |
| txUnblockLatch.await(); |
| } |
| catch (InterruptedException e) { |
| throw new RuntimeException(e); |
| } |
| }, 5, "sys-view-cmd-tx-test-2"); |
| |
| txBlockLatch.await(getTestTimeout(), MILLISECONDS); |
| |
| List<List<String>> txsView = systemView(ignite0, TXS_MON_LIST); |
| |
| assertEquals(10, txsView.size()); |
| } |
| finally { |
| txUnblockLatch.countDown(); |
| } |
| |
| assertTrue(waitForCondition(() -> systemView(ignite0, TXS_MON_LIST).isEmpty(), getTestTimeout())); |
| } |
| |
| /** */ |
| @Test |
| public void testSchemas() throws Exception { |
| try ( |
| IgniteEx g = startGrid(getConfiguration(getTestIgniteInstanceName(3)) |
| .setSqlConfiguration(new SqlConfiguration().setSqlSchemas("MY_SCHEMA", "ANOTHER_SCHEMA"))) |
| ) { |
| Set<String> schemaNames = new HashSet<>(); |
| |
| HashSet<String> expSchemas = new HashSet<>(asList("MY_SCHEMA", "ANOTHER_SCHEMA", "SYS", "PUBLIC")); |
| |
| List<List<String>> sqlSchemaView = systemView(g, SQL_SCHEMA_VIEW); |
| |
| sqlSchemaView.forEach(row -> schemaNames.add(row.get(0))); // name |
| |
| assertEquals(schemaNames, expSchemas); |
| } |
| } |
| |
| /** */ |
| @Test |
| public void testViews() { |
| Set<String> expViewNames = new HashSet<>(asList( |
| "METRICS", |
| "VIEWS", |
| "SERVICES", |
| "CACHE_GROUPS", |
| "CACHES", |
| "TASKS", |
| "JOBS", |
| "SQL_QUERIES_HISTORY", |
| "NODES", |
| "SCHEMAS", |
| "NODE_METRICS", |
| "BASELINE_NODES", |
| "BASELINE_NODE_ATTRIBUTES", |
| "INDEXES", |
| "LOCAL_CACHE_GROUPS_IO", |
| "SQL_QUERIES", |
| "SCAN_QUERIES", |
| "NODE_ATTRIBUTES", |
| "TABLES", |
| "CLIENT_CONNECTIONS", |
| "TABLE_COLUMNS", |
| "VIEW_COLUMNS", |
| "TRANSACTIONS", |
| "CONTINUOUS_QUERIES", |
| "STRIPED_THREADPOOL_QUEUE", |
| "DATASTREAM_THREADPOOL_QUEUE", |
| "DATA_REGION_PAGE_LISTS", |
| "CACHE_GROUP_PAGE_LISTS", |
| "PARTITION_STATES", |
| "BINARY_METADATA", |
| "METASTORAGE", |
| "DISTRIBUTED_METASTORAGE", |
| "STATISTICS_CONFIGURATION", |
| "STATISTICS_PARTITION_DATA", |
| "STATISTICS_LOCAL_DATA" |
| )); |
| |
| Set<String> viewNames = new HashSet<>(); |
| |
| List<List<String>> sqlViewsView = systemView(ignite0, SQL_VIEWS_VIEW); |
| |
| sqlViewsView.forEach(row -> viewNames.add(row.get(0))); // name |
| |
| assertEquals(expViewNames, viewNames); |
| } |
| |
| /** */ |
| @Test |
| public void testTable() { |
| assertTrue(systemView(ignite0, SQL_TBLS_VIEW).isEmpty()); |
| |
| executeSql(ignite0, "CREATE TABLE T1(ID LONG PRIMARY KEY, NAME VARCHAR)"); |
| |
| List<List<String>> sqlTablesView = systemView(ignite0, SQL_TBLS_VIEW); |
| |
| assertEquals(1, sqlTablesView.size()); |
| |
| List<String> row = sqlTablesView.get(0); |
| |
| assertEquals(Integer.toString(cacheId("SQL_PUBLIC_T1")), row.get(0)); // CACHE_GROUP_ID |
| assertEquals("SQL_PUBLIC_T1", row.get(1)); // CACHE_GROUP_NAME |
| assertEquals(Integer.toString(cacheId("SQL_PUBLIC_T1")), row.get(2)); // CACHE_ID |
| assertEquals("SQL_PUBLIC_T1", row.get(3)); // CACHE_NAME |
| assertEquals(DFLT_SCHEMA, row.get(4)); // SCHEMA_NAME |
| assertEquals("T1", row.get(5)); // TABLE_NAME |
| assertEquals("null", row.get(6)); // AFFINITY_KEY_COLUMN |
| assertEquals("ID", row.get(7)); // KEY_ALIAS |
| assertEquals("null", row.get(8)); // VALUE_ALIAS |
| assertEquals("java.lang.Long", row.get(9)); // KEY_TYPE_NAME |
| assertFalse("null".equals(row.get(10))); // VALUE_TYPE_NAME |
| |
| executeSql(ignite0, "CREATE TABLE T2(ID LONG PRIMARY KEY, NAME VARCHAR)"); |
| |
| assertEquals(2, systemView(ignite0, SQL_TBLS_VIEW).size()); |
| |
| executeSql(ignite0, "DROP TABLE T1"); |
| executeSql(ignite0, "DROP TABLE T2"); |
| |
| assertTrue(systemView(ignite0, SQL_TBLS_VIEW).isEmpty()); |
| } |
| |
| /** */ |
| @Test |
| public void testTableColumns() { |
| assertTrue(systemView(ignite0, SQL_TBL_COLS_VIEW).isEmpty()); |
| |
| executeSql(ignite0, "CREATE TABLE T1(ID LONG PRIMARY KEY, NAME VARCHAR(40))"); |
| |
| Set<?> actCols = systemView(ignite0, SQL_TBL_COLS_VIEW).stream() |
| .map(row -> row.get(0)) // columnName |
| .collect(Collectors.toSet()); |
| |
| assertEquals(new HashSet<>(asList("ID", "NAME", "_KEY", "_VAL")), actCols); |
| |
| executeSql(ignite0, "CREATE TABLE T2(ID LONG PRIMARY KEY, NAME VARCHAR(50))"); |
| |
| Set<List<String>> expSqlTableColumnsView = new HashSet<>(asList( |
| asList("ID", "T1", "PUBLIC", "false", "false", "null", "true", "true", "-1", "-1", Long.class.getName()), |
| asList("NAME", "T1", "PUBLIC", "false", "false", "null", "true", "false", "40", "-1", String.class.getName()), |
| asList("_KEY", "T1", "PUBLIC", "true", "false", "null", "false", "true", "-1", "-1", "null"), |
| asList("_VAL", "T1", "PUBLIC", "false", "false", "null", "true", "false", "-1", "-1", "null"), |
| asList("ID", "T2", "PUBLIC", "false", "false", "null", "true", "true", "-1", "-1", Long.class.getName()), |
| asList("NAME", "T2", "PUBLIC", "false", "false", "null", "true", "false", "50", "-1", String.class.getName()), |
| asList("_KEY", "T2", "PUBLIC", "true", "false", "null", "false", "true", "-1", "-1", "null"), |
| asList("_VAL", "T2", "PUBLIC", "false", "false", "null", "true", "false", "-1", "-1", "null") |
| )); |
| |
| Set<List<String>> sqlTableColumnsView = new HashSet<>(systemView(ignite0, SQL_TBL_COLS_VIEW)); |
| |
| assertEquals(expSqlTableColumnsView, sqlTableColumnsView); |
| |
| executeSql(ignite0, "DROP TABLE T1"); |
| executeSql(ignite0, "DROP TABLE T2"); |
| |
| assertTrue(systemView(ignite0, SQL_TBL_COLS_VIEW).isEmpty()); |
| } |
| |
| /** */ |
| @Test |
| public void testViewColumns() { |
| Set<List<String>> expsqlViewColumnsView = new HashSet<>(asList( |
| asList("CONNECTION_ID", "CLIENT_CONNECTIONS", SCHEMA_SYS, "null", "true", "19", "0", Long.class.getName()), |
| asList("LOCAL_ADDRESS", "CLIENT_CONNECTIONS", SCHEMA_SYS, "null", "true", Integer.toString(MAX_VALUE), "0", |
| String.class.getName()), |
| asList("REMOTE_ADDRESS", "CLIENT_CONNECTIONS", SCHEMA_SYS, "null", "true", Integer.toString(MAX_VALUE), "0", |
| String.class.getName()), |
| asList("TYPE", "CLIENT_CONNECTIONS", SCHEMA_SYS, "null", "true", Integer.toString(MAX_VALUE), "0", |
| String.class.getName()), |
| asList("USER", "CLIENT_CONNECTIONS", SCHEMA_SYS, "null", "true", Integer.toString(MAX_VALUE), "0", |
| String.class.getName()), |
| asList("VERSION", "CLIENT_CONNECTIONS", SCHEMA_SYS, "null", "true", Integer.toString(MAX_VALUE), "0", |
| String.class.getName()) |
| )); |
| |
| Set<List<String>> sqlViewColumnsView = systemView(ignite0, SQL_VIEW_COLS_VIEW).stream() |
| .filter(row -> "CLIENT_CONNECTIONS".equals(row.get(1))) // viewName |
| .collect(Collectors.toSet()); |
| |
| assertEquals(expsqlViewColumnsView, sqlViewColumnsView); |
| } |
| |
| /** */ |
| @Test |
| public void testContinuousQuery() throws Exception { |
| IgniteCache<Integer, Integer> cache = ignite0.createCache("test-cache"); |
| |
| assertTrue(systemView(ignite0, CQ_SYS_VIEW).isEmpty()); |
| assertTrue(systemView(ignite1, CQ_SYS_VIEW).isEmpty()); |
| |
| try (QueryCursor<?> ignored = cache.query(new ContinuousQuery<>() |
| .setInitialQuery(new ScanQuery<>()) |
| .setPageSize(100) |
| .setTimeInterval(1000) |
| .setLocalListener(evts -> { |
| // No-op. |
| }) |
| .setRemoteFilterFactory(() -> evt -> true) |
| )) { |
| for (int i = 0; i < 100; i++) |
| cache.put(i, i); |
| |
| checkContinuouQueryView(ignite0, true); |
| checkContinuouQueryView(ignite1, false); |
| } |
| |
| assertTrue(systemView(ignite0, CQ_SYS_VIEW).isEmpty()); |
| assertTrue(waitForCondition(() -> systemView(ignite1, CQ_SYS_VIEW).isEmpty(), getTestTimeout())); |
| } |
| |
| /** */ |
| private void checkContinuouQueryView(IgniteEx node, boolean loc) { |
| List<List<String>> cqSysView = systemView(node, CQ_SYS_VIEW); |
| |
| assertEquals(1, cqSysView.size()); |
| |
| List<String> row = cqSysView.get(0); |
| |
| assertEquals("test-cache", row.get(0)); //cacheName |
| assertEquals("100", row.get(7)); // bufferSize |
| assertEquals("1000", row.get(9)); // interval |
| assertEquals(ignite0.localNode().id().toString(), row.get(14)); // nodeId |
| |
| if (loc) |
| assertTrue(row.get(1).startsWith(getClass().getName())); // localListener |
| else |
| assertEquals("null", row.get(1)); // localListener |
| |
| assertTrue(row.get(2).startsWith(getClass().getName())); // remoteFilter |
| assertEquals("null", row.get(4)); // localTransformedListener |
| assertEquals("null", row.get(3)); // remoteTransformer |
| } |
| |
| /** */ |
| @Test |
| public void testLocalScanQuery() throws Exception { |
| IgniteCache<Integer, Integer> cache1 = ignite0.createCache( |
| new CacheConfiguration<Integer, Integer>("cache1").setGroupName("group1")); |
| |
| int part = ignite0.affinity("cache1").primaryPartitions(ignite0.localNode())[0]; |
| |
| List<Integer> partKeys = partitionKeys(cache1, part, 11, 0); |
| |
| partKeys.forEach(key -> cache1.put(key, key)); |
| |
| assertTrue(systemView(ignite0, SCAN_QRY_SYS_VIEW).isEmpty()); |
| |
| try ( |
| QueryCursor<Integer> qryRes1 = cache1.query( |
| new ScanQuery<Integer, Integer>() |
| .setFilter(new TestPredicate()) |
| .setLocal(true) |
| .setPartition(part) |
| .setPageSize(10), |
| new TestTransformer()) |
| ) { |
| assertTrue(qryRes1.iterator().hasNext()); |
| |
| assertTrue(waitForCondition(() -> !systemView(ignite0, SCAN_QRY_SYS_VIEW).isEmpty(), getTestTimeout())); |
| |
| List<String> view = systemView(ignite0, SCAN_QRY_SYS_VIEW).get(0); |
| |
| assertEquals(ignite0.localNode().id().toString(), view.get(0)); // originNodeId |
| assertEquals("0", view.get(1)); // queryId |
| assertEquals("cache1", view.get(2)); // cacheName |
| assertEquals(Integer.toString(cacheId("cache1")), view.get(3)); // cacheId |
| assertEquals(Integer.toString(cacheGroupId("cache1", "group1")), view.get(4)); // cacheGroupId |
| assertEquals("group1", view.get(5)); // cacheGroupName |
| assertTrue(Long.parseLong(view.get(6)) <= System.currentTimeMillis()); // startTime |
| assertTrue(Long.parseLong(view.get(7)) >= 0); // duration |
| assertFalse(Boolean.parseBoolean(view.get(8))); // canceled |
| assertEquals(TEST_PREDICATE, view.get(9)); // filter |
| assertTrue(Boolean.parseBoolean(view.get(11))); // local |
| assertEquals(part, Integer.parseInt(view.get(13))); // partition |
| assertEquals(toStringSafe(ignite0.context().discovery().topologyVersionEx()), view.get(16)); // topology |
| assertEquals(TEST_TRANSFORMER, view.get(17)); // transformer |
| assertFalse(Boolean.parseBoolean(view.get(10))); // keepBinary |
| assertEquals("null", view.get(14)); // subjectId |
| assertEquals("null", view.get(15)); // taskName |
| } |
| |
| assertTrue(waitForCondition(() -> systemView(ignite0, SCAN_QRY_SYS_VIEW).isEmpty(), getTestTimeout())); |
| } |
| |
| /** */ |
| @Test |
| public void testScanQuery() throws Exception { |
| try ( |
| IgniteEx client1 = startClientGrid("client-1"); |
| IgniteEx client2 = startClientGrid("client-2") |
| ) { |
| IgniteCache<Integer, Integer> cache1 = client1.createCache( |
| new CacheConfiguration<Integer, Integer>("cache1").setGroupName("group1")); |
| |
| IgniteCache<Integer, Integer> cache2 = client2.createCache("cache2"); |
| |
| for (int i = 0; i < 100; i++) { |
| cache1.put(i, i); |
| cache2.put(i, i); |
| } |
| |
| assertTrue(systemView(ignite0, SCAN_QRY_SYS_VIEW).isEmpty()); |
| assertTrue(systemView(ignite1, SCAN_QRY_SYS_VIEW).isEmpty()); |
| |
| try ( |
| QueryCursor<Integer> qryRes1 = cache1.query( |
| new ScanQuery<Integer, Integer>() |
| .setFilter(new TestPredicate()) |
| .setPageSize(10), |
| new TestTransformer()); |
| |
| QueryCursor<?> qryRes2 = cache2.withKeepBinary().query(new ScanQuery<>().setPageSize(20)) |
| ) { |
| assertTrue(qryRes1.iterator().hasNext()); |
| assertTrue(qryRes2.iterator().hasNext()); |
| |
| checkScanQueryView(client1, client2, ignite0); |
| checkScanQueryView(client1, client2, ignite1); |
| } |
| |
| assertTrue(waitForCondition(() -> |
| systemView(ignite0, SCAN_QRY_SYS_VIEW).isEmpty() && systemView(ignite1, SCAN_QRY_SYS_VIEW).isEmpty(), |
| getTestTimeout())); |
| } |
| } |
| |
| /** */ |
| private void checkScanQueryView(IgniteEx client1, IgniteEx client2, IgniteEx node) throws Exception { |
| assertTrue(waitForCondition(() -> systemView(ignite0, SCAN_QRY_SYS_VIEW).size() > 1, getTestTimeout())); |
| |
| Consumer<List<String>> cache1checker = view -> { |
| assertEquals(client1.localNode().id().toString(), view.get(0)); |
| assertTrue(Long.parseLong(view.get(1)) != 0); |
| assertEquals("cache1", view.get(2)); |
| assertEquals(Integer.toString(cacheId("cache1")), view.get(3)); |
| assertEquals(Integer.toString(cacheGroupId("cache1", "group1")), view.get(4)); |
| assertEquals("group1", view.get(5)); |
| assertTrue(Long.parseLong(view.get(6)) <= System.currentTimeMillis()); |
| assertTrue(Long.parseLong(view.get(7)) >= 0); |
| assertFalse(Boolean.parseBoolean(view.get(8))); |
| assertEquals(TEST_PREDICATE, view.get(9)); |
| assertFalse(Boolean.parseBoolean(view.get(11))); |
| assertEquals("-1", view.get(13)); |
| assertEquals(toStringSafe(client1.context().discovery().topologyVersionEx()), view.get(16)); |
| assertEquals(TEST_TRANSFORMER, view.get(17)); |
| assertFalse(Boolean.parseBoolean(view.get(10))); |
| assertEquals("null", view.get(14)); |
| assertEquals("null", view.get(15)); |
| assertEquals("10", view.get(12)); |
| }; |
| |
| Consumer<List<String>> cache2checker = view -> { |
| assertEquals(client2.localNode().id().toString(), view.get(0)); |
| assertTrue(Long.parseLong(view.get(1)) != 0); |
| assertEquals("cache2", view.get(2)); |
| assertEquals(Integer.toString(cacheId("cache2")), view.get(3)); |
| assertEquals(Integer.toString(cacheGroupId("cache2", null)), view.get(4)); |
| assertEquals("cache2", view.get(5)); |
| assertTrue(Long.parseLong(view.get(6)) <= System.currentTimeMillis()); |
| assertTrue(Long.parseLong(view.get(7)) >= 0); |
| assertFalse(Boolean.parseBoolean(view.get(8))); |
| assertEquals("null", view.get(9)); |
| assertFalse(Boolean.parseBoolean(view.get(11))); |
| assertEquals("-1", view.get(13)); |
| assertEquals(toStringSafe(client2.context().discovery().topologyVersionEx()), view.get(16)); |
| assertEquals("null", view.get(17)); |
| assertTrue(Boolean.parseBoolean(view.get(10))); |
| assertEquals("null", view.get(14)); |
| assertEquals("null", view.get(15)); |
| assertEquals("20", view.get(12)); |
| }; |
| |
| boolean found1 = false; |
| boolean found2 = false; |
| |
| for (List<String> row : systemView(node, SCAN_QRY_SYS_VIEW)) { |
| if ("cache2".equals(row.get(2))) { |
| cache2checker.accept(row); |
| found1 = true; |
| } |
| else { |
| cache1checker.accept(row); |
| found2 = true; |
| } |
| } |
| |
| assertTrue(found1 && found2); |
| } |
| |
| /** */ |
| @Test |
| public void testStripedExecutor() throws Exception { |
| checkStripeExecutorView(ignite0.context().pools().getStripedExecutorService(), |
| SYS_POOL_QUEUE_VIEW, |
| "sys"); |
| } |
| |
| /** */ |
| @Test |
| public void testStreamerExecutor() throws Exception { |
| checkStripeExecutorView(ignite0.context().pools().getDataStreamerExecutorService(), |
| STREAM_POOL_QUEUE_VIEW, |
| "data-streamer"); |
| } |
| |
| /** |
| * Checks striped executor system view. |
| * |
| * @param execSvc Striped executor. |
| * @param view System view name. |
| * @param poolName Executor name. |
| */ |
| private void checkStripeExecutorView(StripedExecutor execSvc, String view, String poolName) throws Exception { |
| CountDownLatch latch = new CountDownLatch(1); |
| |
| execSvc.execute(0, new TestRunnable(latch, 0)); |
| execSvc.execute(0, new TestRunnable(latch, 1)); |
| execSvc.execute(1, new TestRunnable(latch, 2)); |
| execSvc.execute(1, new TestRunnable(latch, 3)); |
| |
| try { |
| assertTrue(waitForCondition(() -> systemView(ignite0, view).size() == 2, getTestTimeout())); |
| |
| List<List<String>> stripedQueue = systemView(ignite0, view); |
| |
| List<String> row0 = stripedQueue.get(0); |
| |
| assertEquals("0", row0.get(0)); |
| assertEquals(TestRunnable.class.getSimpleName() + '1', row0.get(1)); |
| assertEquals(poolName + "-stripe-0", row0.get(2)); |
| assertEquals(TestRunnable.class.getName(), row0.get(3)); |
| |
| List<String> row1 = stripedQueue.get(1); |
| |
| assertEquals("1", row1.get(0)); |
| assertEquals(TestRunnable.class.getSimpleName() + '3', row1.get(1)); |
| assertEquals(poolName + "-stripe-1", row1.get(2)); |
| assertEquals(TestRunnable.class.getName(), row1.get(3)); |
| } |
| finally { |
| latch.countDown(); |
| } |
| } |
| |
| /** */ |
| @Test |
| public void testPagesList() throws Exception { |
| String cacheName = "cacheFL"; |
| |
| IgniteCache<Integer, byte[]> cache = ignite0.getOrCreateCache(new CacheConfiguration<Integer, byte[]>() |
| .setName(cacheName) |
| .setAffinity(new RendezvousAffinityFunction() |
| .setPartitions(1))); |
| |
| GridCacheDatabaseSharedManager dbMgr = (GridCacheDatabaseSharedManager)ignite0.context().cache().context() |
| .database(); |
| |
| int pageSize = dbMgr.pageSize(); |
| |
| try { |
| dbMgr.enableCheckpoints(false).get(); |
| |
| int key = 0; |
| |
| // Fill up different free-list buckets. |
| for (int j = 0; j < pageSize / 2; j++) |
| cache.put(key++, new byte[j + 1]); |
| |
| // Put some pages to one bucket to overflow pages cache. |
| for (int j = 0; j < 1000; j++) |
| cache.put(key++, new byte[pageSize / 2]); |
| |
| List<List<String>> cacheGrpView = systemView(ignite0, CACHE_GRP_PAGE_LIST_VIEW); |
| |
| List<List<String>> dataRegionView = systemView(ignite0, DATA_REGION_PAGE_LIST_VIEW); |
| |
| String cacheId = Integer.toString(cacheId(cacheName)); |
| |
| // Test filtering by 3 columns. |
| assertFalse(cacheGrpView.stream().noneMatch(row -> |
| cacheId.equals(row.get(0)) && |
| "0".equals(row.get(1)) && |
| "0".equals(row.get(3)))); |
| |
| // Test filtering with invalid cache group id. |
| assertTrue(cacheGrpView.stream().noneMatch(row -> "-1".equals(row.get(0)))); |
| |
| // Test filtering with invalid partition id. |
| assertTrue(cacheGrpView.stream().noneMatch(row -> "-1".equals(row.get(1)))); |
| |
| // Test filtering with invalid bucket number. |
| assertTrue(cacheGrpView.stream().noneMatch(row -> "-1".equals(row.get(3)))); |
| |
| assertFalse(cacheGrpView.stream().noneMatch(row -> |
| Integer.parseInt(row.get(4)) > 0 && cacheId.equals(row.get(0)))); |
| |
| assertFalse(cacheGrpView.stream().noneMatch(row -> |
| Integer.parseInt(row.get(5)) > 0 && cacheId.equals(row.get(0)))); |
| |
| assertFalse(cacheGrpView.stream().noneMatch(row -> |
| Integer.parseInt(row.get(6)) > 0 && cacheId.equals(row.get(0)))); |
| |
| assertFalse(dataRegionView.stream().noneMatch(row -> row.get(0).startsWith(DATA_REGION_NAME))); |
| |
| assertTrue(dataRegionView.stream().noneMatch(row -> |
| row.get(0).startsWith(DATA_REGION_NAME) && Integer.parseInt(row.get(4)) > 0)); |
| } |
| finally { |
| dbMgr.enableCheckpoints(true).get(); |
| } |
| |
| ignite0.cluster().state(INACTIVE); |
| |
| ignite0.cluster().state(ACTIVE); |
| |
| IgniteCache<Integer, Integer> cacheInMemory = ignite0.getOrCreateCache( |
| new CacheConfiguration<Integer, Integer>() |
| .setName("cacheFLInMemory") |
| .setDataRegionName(DATA_REGION_NAME)); |
| |
| cacheInMemory.put(0, 0); |
| |
| // After activation/deactivation new view for data region pages lists should be created, check that new view |
| // correctly reflects changes in free-lists. |
| assertTrue(systemView(ignite0, DATA_REGION_PAGE_LIST_VIEW).stream().noneMatch(row -> |
| row.get(0).startsWith(DATA_REGION_NAME) && Integer.parseInt(row.get(4)) > 0)); |
| } |
| |
| /** */ |
| @Test |
| public void testPartitionStates() throws Exception { |
| String nodeName0 = getTestIgniteInstanceName(0); |
| String nodeName1 = getTestIgniteInstanceName(1); |
| String nodeName2 = getTestIgniteInstanceName(2); |
| |
| IgniteCache<Integer, Integer> cache1 = ignite0.createCache(new CacheConfiguration<Integer, Integer>() |
| .setName("cache1") |
| .setCacheMode(CacheMode.PARTITIONED) |
| .setAffinity(new TestAffinityFunction(new String[][] {{nodeName0, nodeName1}, {nodeName1, nodeName2}, |
| {nodeName2, nodeName0}}))); |
| |
| IgniteCache<Integer, Integer> cache2 = ignite0.createCache(new CacheConfiguration<Integer, Integer>() |
| .setName("cache2") |
| .setCacheMode(CacheMode.PARTITIONED) |
| .setAffinity(new TestAffinityFunction(new String[][] {{nodeName0, nodeName1, nodeName2}, {nodeName1}}))); |
| |
| for (int i = 0; i < 100; i++) { |
| cache1.put(i, i); |
| cache2.put(i, i); |
| } |
| |
| try (IgniteEx ignite2 = startGrid(nodeName2)) { |
| ignite2.rebalanceEnabled(false); |
| |
| ignite0.cluster().setBaselineTopology(ignite0.cluster().topologyVersion()); |
| |
| String nodeId0 = ignite0.cluster().localNode().id().toString(); |
| String nodeId1 = ignite(1).cluster().localNode().id().toString(); |
| String nodeId2 = ignite2.cluster().localNode().id().toString(); |
| |
| String cacheGrpId1 = Integer.toString(ignite0.cachex("cache1").context().groupId()); |
| String cacheGrpId2 = Integer.toString(ignite0.cachex("cache2").context().groupId()); |
| |
| String owningState = GridDhtPartitionState.OWNING.name(); |
| String movingState = GridDhtPartitionState.MOVING.name(); |
| |
| for (int i = 0; i < 3; i++) { |
| List<List<String>> partStatesView = systemView(ignite(i), PART_STATES_VIEW); |
| |
| // Check partitions for cache1. |
| checkPartitionStatesView(partStatesView, owningState, true, cacheGrpId1, nodeId0, 0); |
| checkPartitionStatesView(partStatesView, owningState, false, cacheGrpId1, nodeId1, 0); |
| checkPartitionStatesView(partStatesView, owningState, true, cacheGrpId1, nodeId1, 1); |
| checkPartitionStatesView(partStatesView, movingState, false, cacheGrpId1, nodeId2, 1); |
| checkPartitionStatesView(partStatesView, owningState, true, cacheGrpId1, nodeId0, 2); |
| checkPartitionStatesView(partStatesView, movingState, false, cacheGrpId1, nodeId2, 2); |
| |
| checkPartitionStatesView(partStatesView, owningState, true, cacheGrpId2, nodeId0, 0); |
| checkPartitionStatesView(partStatesView, owningState, false, cacheGrpId2, nodeId1, 0); |
| checkPartitionStatesView(partStatesView, movingState, false, cacheGrpId2, nodeId2, 0); |
| checkPartitionStatesView(partStatesView, owningState, true, cacheGrpId2, nodeId1, 1); |
| } |
| |
| AffinityTopologyVersion topVer = ignite0.context().discovery().topologyVersionEx(); |
| |
| ignite2.rebalanceEnabled(true); |
| |
| // Wait until rebalance complete. |
| assertTrue(waitForCondition(() -> |
| ignite0.context().discovery().topologyVersionEx().compareTo(topVer) > 0, getTestTimeout())); |
| |
| for (int i = 0; i < 3; i++) { |
| List<List<String>> rows = systemView(ignite(i), PART_STATES_VIEW); |
| |
| assertEquals(10, rows.stream().filter(row -> |
| (cacheGrpId1.equals(row.get(0)) || cacheGrpId2.equals(row.get(0))) && owningState.equals(row.get(3))).count()); |
| |
| assertTrue(rows.stream().noneMatch(row -> |
| (cacheGrpId1.equals(row.get(0)) || cacheGrpId2.equals(row.get(0))) && movingState.equals(row.get(3)))); |
| } |
| |
| // Check that assignment is now changed to ideal. |
| for (int i = 0; i < 3; i++) { |
| List<List<String>> rows = systemView(ignite(i), PART_STATES_VIEW); |
| |
| checkPartitionStatesView(rows, owningState, false, cacheGrpId1, nodeId0, 2); |
| checkPartitionStatesView(rows, owningState, true, cacheGrpId1, nodeId2, 2); |
| } |
| } |
| finally { |
| ignite0.cluster().setBaselineTopology(ignite0.cluster().topologyVersion()); |
| } |
| } |
| |
| /** |
| * Checks that partitions stated view contains row with specified parameters. |
| * |
| * @param partStatesView Partition states view rows. |
| * @param state Partition state. |
| * @param isPrimary Primary falg. |
| * @param cacheGrpId Cache group id. |
| * @param nodeId Node id. |
| * @param partitionId partition id. |
| */ |
| private void checkPartitionStatesView( |
| List<List<String>> partStatesView, |
| String state, |
| boolean isPrimary, |
| String cacheGrpId, |
| String nodeId, |
| int partitionId |
| ) { |
| assertEquals(1, partStatesView.stream().filter(row -> |
| cacheGrpId.equals(row.get(0)) && |
| nodeId.equals(row.get(1)) && |
| Integer.toString(partitionId).equals(row.get(2)) && |
| state.equals(row.get(3)) && |
| Boolean.toString(isPrimary).equals(row.get(4)) |
| ).count()); |
| } |
| |
| /** */ |
| @Test |
| public void testBinaryMeta() { |
| IgniteCache<Integer, TestObjectAllTypes> c1 = ignite0.createCache("test-cache"); |
| IgniteCache<Integer, TestObjectEnum> c2 = ignite0.createCache("test-enum-cache"); |
| |
| executeSql(ignite0, "CREATE TABLE T1(ID LONG PRIMARY KEY, NAME VARCHAR(40), ACCOUNT BIGINT)"); |
| executeSql(ignite0, "INSERT INTO T1(ID, NAME, ACCOUNT) VALUES(1, 'test', 1)"); |
| |
| c1.put(1, new TestObjectAllTypes()); |
| c2.put(1, TestObjectEnum.A); |
| |
| List<List<String>> binaryMetaView = systemView(ignite0, BINARY_METADATA_VIEW); |
| |
| assertEquals(3, binaryMetaView.size()); |
| |
| for (List<String> row : binaryMetaView) { |
| if (Objects.equals(TestObjectEnum.class.getName(), row.get(1))) { |
| assertTrue(Boolean.parseBoolean(row.get(6))); |
| |
| assertEquals("0", row.get(3)); |
| } |
| else if (Objects.equals(TestObjectAllTypes.class.getName(), row.get(1))) { |
| assertFalse(Boolean.parseBoolean(row.get(6))); |
| |
| Field[] fields = TestObjectAllTypes.class.getDeclaredFields(); |
| |
| assertEquals(Integer.toString(fields.length), row.get(3)); |
| |
| for (Field field : fields) |
| assertTrue(row.get(4).contains(field.getName())); |
| } |
| else { |
| assertFalse(Boolean.parseBoolean(row.get(6))); |
| |
| assertEquals("2", row.get(3)); |
| |
| assertTrue(row.get(4).contains("NAME")); |
| assertTrue(row.get(4).contains("ACCOUNT")); |
| } |
| } |
| } |
| |
| /** */ |
| @Test |
| public void testMetastorage() throws Exception { |
| IgniteCacheDatabaseSharedManager db = ignite0.context().cache().context().database(); |
| |
| String name = "test-key"; |
| String val = "test-value"; |
| |
| db.checkpointReadLock(); |
| |
| try { |
| db.metaStorage().write(name, val); |
| } |
| finally { |
| db.checkpointReadUnlock(); |
| } |
| |
| assertEquals(1, systemView(ignite0, METASTORE_VIEW).stream() |
| .filter(row -> name.equals(row.get(0)) && val.equals(row.get(1))) |
| .count()); |
| } |
| |
| /** */ |
| @Test |
| public void testDistributedMetastorage() throws Exception { |
| DistributedMetaStorage dms = ignite0.context().distributedMetastorage(); |
| |
| String name = "test-distributed-key"; |
| String val = "test-distributed-value"; |
| |
| dms.write(name, val); |
| |
| assertEquals(1, systemView(ignite0, DISTRIBUTED_METASTORE_VIEW).stream() |
| .filter(row -> name.equals(row.get(0)) && val.equals(row.get(1))) |
| .count()); |
| |
| assertTrue(waitForCondition(() -> systemView(ignite1, DISTRIBUTED_METASTORE_VIEW).stream() |
| .filter(row -> name.equals(row.get(0)) && val.equals(row.get(1))) |
| .count() == 1, |
| getTestTimeout())); |
| } |
| |
| /** |
| * Execute query on given node. |
| * |
| * @param node Node. |
| * @param sql Statement. |
| */ |
| private List<List<?>> executeSql(Ignite node, String sql, Object... args) { |
| SqlFieldsQuery qry = new SqlFieldsQuery(sql) |
| .setArgs(args) |
| .setSchema("PUBLIC"); |
| |
| return queryProcessor(node).querySqlFields(qry, true).getAll(); |
| } |
| |
| /** |
| * Gets system view content via control utility from specified node. Here we also check if attributes names |
| * returned by the command match the real ones. And that both "SQL" and "Java" command names styles are supported. |
| * |
| * @param node The node to obtain system view from. |
| * @param sysViewName Name of the system view which content is required. |
| * @return Content of the requested system view. |
| */ |
| private List<List<String>> systemView(IgniteEx node, String sysViewName) { |
| List<String> attrNames = new ArrayList<>(); |
| |
| SystemView<?> sysView = node.context().systemView().view(sysViewName); |
| |
| sysView.walker().visitAll(new AttributeVisitor() { |
| @Override public <T> void accept(int idx, String name, Class<T> clazz) { |
| attrNames.add(name); |
| } |
| }); |
| |
| String nodeId = node.context().discovery().localNode().id().toString(); |
| |
| List<List<String>> rows = parseSystemViewCommandOutput( |
| executeCommand(EXIT_CODE_OK, CMD_SYS_VIEW, toSqlName(sysViewName), NODE_ID.argName(), nodeId)); |
| |
| assertEquals(attrNames, rows.get(0)); |
| |
| rows = parseSystemViewCommandOutput( |
| executeCommand(EXIT_CODE_OK, CMD_SYS_VIEW, toSqlName(sysViewName).toLowerCase(), NODE_ID.argName(), nodeId)); |
| |
| assertEquals(attrNames, rows.get(0)); |
| |
| rows = parseSystemViewCommandOutput( |
| executeCommand(EXIT_CODE_OK, CMD_SYS_VIEW, sysViewName, NODE_ID.argName(), nodeId)); |
| |
| assertEquals(attrNames, rows.remove(0)); |
| |
| int attrsCnt = sysView.walker().count(); |
| |
| rows.forEach(row -> assertEquals(attrsCnt, row.size())); |
| |
| return rows; |
| } |
| |
| /** |
| * Obtains system view values for each row from command output. |
| * |
| * @param out Command output to parse. |
| * @return System view values. |
| */ |
| private List<List<String>> parseSystemViewCommandOutput(String out) { |
| String outStart = "--------------------------------------------------------------------------------"; |
| |
| String outEnd = "Command [" + SYSTEM_VIEW.toCommandName() + "] finished with code: " + EXIT_CODE_OK; |
| |
| List<String> rows = Arrays.asList(out.substring( |
| out.indexOf(outStart) + outStart.length() + 1, |
| out.indexOf(outEnd) - 1 |
| ).split(U.nl())); |
| |
| return rows.stream().map(row -> |
| Arrays.stream(row.split(quote(COLUMN_SEPARATOR))) |
| .map(String::trim) |
| .filter(str -> !str.isEmpty()) |
| .collect(Collectors.toList())) |
| .collect(Collectors.toList()); |
| } |
| |
| /** |
| * Executes command and checks its exit code. |
| * |
| * @param expExitCode Expected exit code. |
| * @param args Command lines arguments. |
| * @return Result of command execution. |
| */ |
| private String executeCommand(int expExitCode, String... args) { |
| int res = execute(args); |
| |
| assertEquals(expExitCode, res); |
| |
| return testOut.toString(); |
| } |
| } |
