From c5a915ea987624d738ae25f0b8abe4a5c3597792 Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Thu, 17 Aug 2023 21:31:20 +0800 Subject: [PATCH 01/26] chore: move hugegraph-hstore --- hugegraph-server/hugegraph-hstore/pom.xml | 50 ++ .../backend/store/hstore/HstoreFeatures.java | 130 +++ .../hstore/HstoreNodePartitionerImpl.java | 279 ++++++ .../backend/store/hstore/HstoreOptions.java | 70 ++ .../backend/store/hstore/HstoreProvider.java | 66 ++ .../backend/store/hstore/HstoreSessions.java | 206 +++++ .../store/hstore/HstoreSessionsImpl.java | 784 +++++++++++++++++ .../backend/store/hstore/HstoreStore.java | 796 ++++++++++++++++++ .../backend/store/hstore/HstoreTable.java | 745 ++++++++++++++++ .../backend/store/hstore/HstoreTables.java | 201 +++++ .../backend/store/hstore/fake/IdClient.java | 58 ++ .../backend/store/hstore/fake/PDIdClient.java | 52 ++ 12 files changed, 3437 insertions(+) create mode 100644 hugegraph-server/hugegraph-hstore/pom.xml create mode 100644 hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreFeatures.java create mode 100644 hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreNodePartitionerImpl.java create mode 100644 hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreOptions.java create mode 100644 hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java create mode 100755 hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreSessions.java create mode 100755 hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreSessionsImpl.java create mode 100644 hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java create mode 100755 hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTable.java create mode 100644 hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTables.java create mode 100644 hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/IdClient.java create mode 100644 hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/PDIdClient.java diff --git a/hugegraph-server/hugegraph-hstore/pom.xml b/hugegraph-server/hugegraph-hstore/pom.xml new file mode 100644 index 0000000000..f777eb05ef --- /dev/null +++ b/hugegraph-server/hugegraph-hstore/pom.xml @@ -0,0 +1,50 @@ + + + + + hugegraph-server + org.apache.hugegraph + ${revision} + ../pom.xml + + + 4.0.0 + + hugegraph-hstore + + + + org.apache.hugegraph + hugegraph-core + ${revision} + + + org.apache.hugegraph + hg-store-client + ${revision} + + + org.apache.hugegraph + hg-pd-client + ${revision} + + + + diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreFeatures.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreFeatures.java new file mode 100644 index 0000000000..4490690706 --- /dev/null +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreFeatures.java @@ -0,0 +1,130 @@ +/* + * 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.hugegraph.backend.store.hstore; + +import org.apache.hugegraph.backend.store.BackendFeatures; + +public class HstoreFeatures implements BackendFeatures { + + @Override + public boolean supportsScanToken() { + return false; + } + + @Override + public boolean supportsScanKeyPrefix() { + return true; + } + + @Override + public boolean supportsScanKeyRange() { + return true; + } + + @Override + public boolean supportsQuerySchemaByName() { + return false; + } + + @Override + public boolean supportsQueryByLabel() { + return false; + } + + @Override + public boolean supportsQueryWithRangeCondition() { + return true; + } + + @Override + public boolean supportsQuerySortByInputIds() { + return true; + } + + @Override + public boolean supportsQueryWithOrderBy() { + return true; + } + + @Override + public boolean supportsQueryWithContains() { + return false; + } + + @Override + public boolean supportsQueryWithContainsKey() { + return false; + } + + @Override + public boolean supportsQueryByPage() { + return true; + } + + @Override + public boolean supportsDeleteEdgeByLabel() { + return false; + } + + @Override + public boolean supportsUpdateVertexProperty() { + // Vertex properties are stored in a cell(column value) + return false; + } + + @Override + public boolean supportsMergeVertexProperty() { + return false; + } + + @Override + public boolean supportsUpdateEdgeProperty() { + // Edge properties are stored in a cell(column value) + return false; + } + + @Override + public boolean supportsTransaction() { + return false; + } + + @Override + public boolean supportsNumberType() { + return false; + } + + @Override + public boolean supportsAggregateProperty() { + return false; + } + + @Override + public boolean supportsTtl() { + return false; + } + + @Override + public boolean supportsOlapProperties() { + return true; + } + + @Override + public boolean supportsFilterInStore() { + return true; + } +} diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreNodePartitionerImpl.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreNodePartitionerImpl.java new file mode 100644 index 0000000000..2a69fe1c03 --- /dev/null +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreNodePartitionerImpl.java @@ -0,0 +1,279 @@ +/* + * 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.hugegraph.backend.store.hstore; + +import static org.apache.hugegraph.store.client.util.HgStoreClientConst.ALL_PARTITION_OWNER; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import org.apache.hugegraph.config.HugeConfig; +import org.apache.hugegraph.pd.client.PDClient; +import org.apache.hugegraph.pd.common.KVPair; +import org.apache.hugegraph.pd.common.PDException; +import org.apache.hugegraph.pd.common.PartitionUtils; +import org.apache.hugegraph.pd.grpc.Metapb; +import org.apache.hugegraph.store.client.HgNodePartition; +import org.apache.hugegraph.store.client.HgNodePartitionerBuilder; +import org.apache.hugegraph.store.client.HgStoreNode; +import org.apache.hugegraph.store.client.HgStoreNodeManager; +import org.apache.hugegraph.store.client.HgStoreNodeNotifier; +import org.apache.hugegraph.store.client.HgStoreNodePartitioner; +import org.apache.hugegraph.store.client.HgStoreNodeProvider; +import org.apache.hugegraph.store.client.HgStoreNotice; +import org.apache.hugegraph.store.client.type.HgNodeStatus; +import org.apache.hugegraph.store.client.util.HgStoreClientConst; +import org.apache.hugegraph.util.Log; +import org.slf4j.Logger; + +public class HstoreNodePartitionerImpl implements HgStoreNodePartitioner, + HgStoreNodeProvider, + HgStoreNodeNotifier { + + private static final Logger LOG = Log.logger(HstoreNodePartitionerImpl.class); + private PDClient pdClient; + private HgStoreNodeManager nodeManager; + + protected HstoreNodePartitionerImpl() { + + } + + public HstoreNodePartitionerImpl(String pdPeers) { + pdClient = HstoreSessionsImpl.getDefaultPdClient(); + } + + public HstoreNodePartitionerImpl(HgStoreNodeManager nodeManager, + String pdPeers) { + this(pdPeers); + this.nodeManager = nodeManager; + } + + public void setPDClient(PDClient pdClient) { + this.pdClient = pdClient; + } + + /** + * 查询分区信息，结果通过HgNodePartitionerBuilder返回 + */ + @Override + public int partition(HgNodePartitionerBuilder builder, String graphName, + byte[] startKey, byte[] endKey) { + try { + HashSet partitions = null; + if (HgStoreClientConst.ALL_PARTITION_OWNER == startKey) { + List stores = pdClient.getActiveStores(graphName); + partitions = new HashSet<>(stores.size()); + for (Metapb.Store store : stores) { + partitions.add(HgNodePartition.of(store.getId(), -1)); + } + + } else if (endKey == HgStoreClientConst.EMPTY_BYTES + || startKey == endKey || Arrays.equals(startKey, endKey)) { + KVPair partShard = + pdClient.getPartition(graphName, startKey); + Metapb.Shard leader = partShard.getValue(); + partitions = new HashSet<>(1); + partitions.add(HgNodePartition.of(leader.getStoreId(), + pdClient.keyToCode(graphName, startKey))); + } else { + LOG.warn( + "StartOwnerkey is not equal to endOwnerkey, which is meaningless!!, It is" + + " a error!!"); + List stores = pdClient.getActiveStores(graphName); + for (Metapb.Store store : stores) { + partitions.add(HgNodePartition.of(store.getId(), -1)); + } + } + builder.setPartitions(partitions); + } catch (PDException e) { + LOG.error("An error occurred while getting partition information :{}", e.getMessage()); + throw new RuntimeException(e.getMessage(), e); + } + return 0; + } + + @Override + public int partition(HgNodePartitionerBuilder builder, String graphName, + int startKey, int endKey) { + try { + HashSet partitions = new HashSet<>(); + Metapb.Partition partition = null; + while ((partition == null || partition.getEndKey() < endKey) + && startKey < PartitionUtils.MAX_VALUE) { + KVPair partShard = + pdClient.getPartitionByCode(graphName, startKey); + if (partShard != null) { + partition = partShard.getKey(); + Metapb.Shard leader = partShard.getValue(); + partitions.add(HgNodePartition.of(leader.getStoreId(), startKey, + (int) partition.getStartKey(), + (int) partition.getEndKey())); + startKey = (int) partition.getEndKey(); + } else { + break; + } + } + builder.setPartitions(partitions); + } catch (PDException e) { + LOG.error("An error occurred while getting partition information :{}", e.getMessage()); + throw new RuntimeException(e.getMessage(), e); + } + return 0; + + } + + /** + * 查询hgstore信息 + * + * @return hgstore + */ + @Override + public HgStoreNode apply(String graphName, Long nodeId) { + try { + Metapb.Store store = pdClient.getStore(nodeId); + return nodeManager.getNodeBuilder().setNodeId(store.getId()) + .setAddress(store.getAddress()).build(); + } catch (PDException e) { + throw new RuntimeException(e.getMessage(), e); + } + } + + /** + * 通知更新缓存 + */ + @Override + public int notice(String graphName, HgStoreNotice storeNotice) { + LOG.warn(storeNotice.toString()); + if (storeNotice.getPartitionLeaders() != null) { + storeNotice.getPartitionLeaders().forEach((partId, leader) -> { + pdClient.updatePartitionLeader(graphName, partId, leader); + LOG.warn("updatePartitionLeader:{}-{}-{}", + graphName, partId, leader); + }); + } + if (storeNotice.getPartitionIds() != null) { + storeNotice.getPartitionIds().forEach(partId -> { + pdClient.invalidPartitionCache(graphName, partId); + }); + } + if (!storeNotice.getNodeStatus().equals( + HgNodeStatus.PARTITION_COMMON_FAULT) + && !storeNotice.getNodeStatus().equals( + HgNodeStatus.NOT_PARTITION_LEADER)) { + pdClient.invalidPartitionCache(); + LOG.warn("invalidPartitionCache:{} ", storeNotice.getNodeStatus()); + } + return 0; + } + + public Metapb.Graph delGraph(String graphName) { + try { + return pdClient.delGraph(graphName); + } catch (PDException e) { + LOG.error("delGraph {} exception, {}", graphName, e.getMessage()); + } + return null; + } + + public void setNodeManager(HgStoreNodeManager nodeManager) { + this.nodeManager = nodeManager; + } +} + +class FakeHstoreNodePartitionerImpl extends HstoreNodePartitionerImpl { + private static final Logger LOG = Log.logger(HstoreNodePartitionerImpl.class); + private static final int partitionCount = 3; + private static final Map leaderMap = new ConcurrentHashMap<>(); + private static final Map storeMap = new ConcurrentHashMap<>(); + HgStoreNodeManager nodeManager; + private final String hstorePeers; + + public FakeHstoreNodePartitionerImpl(String pdPeers) { + this.hstorePeers = pdPeers; + // store列表 + for (String address : hstorePeers.split(",")) { + storeMap.put((long) address.hashCode(), address); + } + // 分区列表 + for (int i = 0; i < partitionCount; i++) { + leaderMap.put(i, storeMap.keySet().iterator().next()); + } + } + + public FakeHstoreNodePartitionerImpl(HgStoreNodeManager nodeManager, + String peers) { + this(peers); + this.nodeManager = nodeManager; + } + + @Override + public int partition(HgNodePartitionerBuilder builder, String graphName, + byte[] startKey, byte[] endKey) { + int startCode = PartitionUtils.calcHashcode(startKey); + HashSet partitions = new HashSet<>(storeMap.size()); + if (ALL_PARTITION_OWNER == startKey) { + storeMap.forEach((k, v) -> { + partitions.add(HgNodePartition.of(k, -1)); + }); + } else if (endKey == HgStoreClientConst.EMPTY_BYTES || startKey == endKey || + Arrays.equals(startKey, endKey)) { + partitions.add( + HgNodePartition.of(leaderMap.get(startCode % partitionCount), startCode)); + } else { + LOG.error("OwnerKey转成HashCode后已经无序了， 按照OwnerKey范围查询没意义"); + storeMap.forEach((k, v) -> { + partitions.add(HgNodePartition.of(k, -1)); + }); + } + builder.setPartitions(partitions); + return 0; + } + + @Override + public HgStoreNode apply(String graphName, Long nodeId) { + return nodeManager.getNodeBuilder().setNodeId(nodeId) + .setAddress(storeMap.get(nodeId)).build(); + } + + @Override + public int notice(String graphName, HgStoreNotice storeNotice) { + if (storeNotice.getPartitionLeaders() != null + && storeNotice.getPartitionLeaders().size() > 0) { + leaderMap.putAll(storeNotice.getPartitionLeaders()); + } + return 0; + } + + public static class NodePartitionerFactory { + public static HstoreNodePartitionerImpl getNodePartitioner( + HugeConfig config, HgStoreNodeManager nodeManager) { + if (config.get(HstoreOptions.PD_FAKE)) { + return new FakeHstoreNodePartitionerImpl(nodeManager, + config.get(HstoreOptions.HSTORE_PEERS)); + } else { + return new HstoreNodePartitionerImpl(nodeManager, + config.get(HstoreOptions.PD_PEERS) + ); + } + + } + } +} diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreOptions.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreOptions.java new file mode 100644 index 0000000000..bafde45f82 --- /dev/null +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreOptions.java @@ -0,0 +1,70 @@ +/* + * 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.hugegraph.backend.store.hstore; + +import static org.apache.hugegraph.config.OptionChecker.disallowEmpty; + +import org.apache.hugegraph.config.ConfigOption; +import org.apache.hugegraph.config.OptionHolder; + +public class HstoreOptions extends OptionHolder { + + public static final ConfigOption PD_PEERS = new ConfigOption<>( + "pd.peers", + "The addresses of pd nodes, separated with commas.", + disallowEmpty(), + "localhost:8686" + ); + public static final ConfigOption PD_FAKE = new ConfigOption<>( + "pd.fake", + "Enable the fake PD service.", + disallowEmpty(), + false + ); + public static final ConfigOption HSTORE_PEERS = new ConfigOption<>( + "hstore.peers", + "The addresses of store nodes, separated with commas.", + disallowEmpty(), + "localhost:9080" + ); + public static final ConfigOption PARTITION_COUNT = new ConfigOption<>( + "hstore.partition_count", + "Number of partitions, which PD controls partitions based on.", + disallowEmpty(), + 0 + ); + public static final ConfigOption SHARD_COUNT = new ConfigOption<>( + "hstore.shard_count", + "Number of copies, which PD controls partition copies based on.", + disallowEmpty(), + 0 + ); + private static volatile HstoreOptions instance; + + private HstoreOptions() { + super(); + } + + public static synchronized HstoreOptions instance() { + if (instance == null) { + instance = new HstoreOptions(); + instance.registerOptions(); + } + return instance; + } +} diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java new file mode 100644 index 0000000000..e5f2c1e408 --- /dev/null +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java @@ -0,0 +1,66 @@ +/* + * 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.hugegraph.backend.store.hstore; + +import org.apache.hugegraph.HugeGraph; +import org.apache.hugegraph.backend.store.AbstractBackendStoreProvider; +import org.apache.hugegraph.backend.store.BackendStore; +import org.apache.hugegraph.backend.store.hstore.HstoreStore.HstoreGraphStore; +import org.apache.hugegraph.config.CoreOptions; +import org.apache.hugegraph.util.Events; + +public class HstoreProvider extends AbstractBackendStoreProvider { + + protected String namespace() { + return this.graph(); + } + + @Override + protected synchronized BackendStore newSchemaStore(String store) { + return null; + } + + @Override + protected BackendStore newGraphStore(String store) { + return new HstoreGraphStore(this, this.namespace(), store); + } + + @Override + public void truncateGraph(HugeGraph graph) { + this.checkOpened(); + String g = graph.option(CoreOptions.STORE_GRAPH); + BackendStore store = this.stores.get(g); + store.truncate(); + this.notifyAndWaitEvent(Events.STORE_TRUNCATE); + LOG.debug("Graph '{}' store has been truncated", graph.name()); + } + + @Override + public String type() { + return "hstore"; + } + + @Override + public String version() { + /* + * Versions history: + * [1.0] HugeGraph-1328: supports hstore + */ + return "1.11"; + } +} diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreSessions.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreSessions.java new file mode 100755 index 0000000000..883ae7bec8 --- /dev/null +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreSessions.java @@ -0,0 +1,206 @@ +/* + * 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.hugegraph.backend.store.hstore; + +import java.util.Iterator; +import java.util.List; +import java.util.Set; + +import org.apache.commons.lang3.tuple.Pair; +import org.apache.hugegraph.backend.query.Query; +import org.apache.hugegraph.backend.store.BackendEntry; +import org.apache.hugegraph.backend.store.BackendEntry.BackendColumnIterator; +import org.apache.hugegraph.backend.store.BackendSession.AbstractBackendSession; +import org.apache.hugegraph.backend.store.BackendSessionPool; +import org.apache.hugegraph.config.HugeConfig; +import org.apache.hugegraph.store.HgOwnerKey; +import org.apache.hugegraph.type.define.GraphMode; + +public abstract class HstoreSessions extends BackendSessionPool { + + public HstoreSessions(HugeConfig config, String database, String store) { + super(config, database + "/" + store); + } + + public abstract Set openedTables(); + + public abstract void createTable(String... tables); + + public abstract void dropTable(String... tables); + + public abstract boolean existsTable(String table); + + public abstract void truncateTable(String table); + + public abstract void clear(); + + @Override + public abstract Session session(); + + public interface Countable { + + public long count(); + } + + /** + * Session for Hstore + */ + public static abstract class Session extends AbstractBackendSession { + + public static final int SCAN_ANY = 0x80; + public static final int SCAN_PREFIX_BEGIN = 0x01; + public static final int SCAN_PREFIX_END = 0x02; + public static final int SCAN_GT_BEGIN = 0x04; + public static final int SCAN_GTE_BEGIN = 0x0c; + public static final int SCAN_LT_END = 0x10; + public static final int SCAN_LTE_END = 0x30; + public static final int SCAN_KEY_ONLY = 0x40; + public static final int SCAN_HASHCODE = 0x100; + + private HugeConfig conf; + private String graphName; + + public static boolean matchScanType(int expected, int actual) { + return (expected & actual) == expected; + } + + public abstract void createTable(String tableName); + + public abstract void dropTable(String tableName); + + public abstract boolean existsTable(String tableName); + + public abstract void truncateTable(String tableName); + + public abstract void deleteGraph(); + + public abstract Pair keyRange(String table); + + public abstract void put(String table, byte[] ownerKey, + byte[] key, byte[] value); + + public abstract void increase(String table, byte[] ownerKey, + byte[] key, byte[] value); + + public abstract void delete(String table, byte[] ownerKey, byte[] key); + + public abstract void deletePrefix(String table, byte[] ownerKey, + byte[] key); + + public abstract void deleteRange(String table, byte[] ownerKeyFrom, + byte[] ownerKeyTo, byte[] keyFrom, + byte[] keyTo); + + public abstract byte[] get(String table, byte[] key); + + public abstract byte[] get(String table, byte[] ownerKey, byte[] key); + + public abstract BackendColumnIterator scan(String table); + + public abstract BackendColumnIterator scan(String table, + byte[] ownerKey, + byte[] prefix); + + public BackendColumnIterator scan(String table, byte[] ownerKeyFrom, + byte[] ownerKeyTo, byte[] keyFrom, + byte[] keyTo) { + return this.scan(table, ownerKeyFrom, ownerKeyTo, keyFrom, keyTo, + SCAN_LT_END); + } + + public abstract List scan(String table, + List keys, + int scanType, + long limit, + byte[] query); + + public abstract BackendEntry.BackendIterator scan(String table, + Iterator keys, + int scanType, + Query queryParam, + byte[] query); + + public abstract BackendColumnIterator scan(String table, + byte[] ownerKeyFrom, + byte[] ownerKeyTo, + byte[] keyFrom, + byte[] keyTo, + int scanType); + + public abstract BackendColumnIterator scan(String table, + byte[] ownerKeyFrom, + byte[] ownerKeyTo, + byte[] keyFrom, + byte[] keyTo, + int scanType, + byte[] query); + + public abstract BackendColumnIterator scan(String table, + byte[] ownerKeyFrom, + byte[] ownerKeyTo, + byte[] keyFrom, + byte[] keyTo, + int scanType, + byte[] query, + byte[] position); + + public abstract BackendColumnIterator scan(String table, + int codeFrom, + int codeTo, + int scanType, + byte[] query); + + public abstract BackendColumnIterator scan(String table, + int codeFrom, + int codeTo, + int scanType, + byte[] query, + byte[] position); + + public abstract BackendColumnIterator getWithBatch(String table, + List keys); + + public abstract void merge(String table, byte[] ownerKey, + byte[] key, byte[] value); + + public abstract void setMode(GraphMode mode); + + public abstract void truncate() throws Exception; + + public abstract BackendColumnIterator scan(String table, + byte[] conditionQueryToByte); + + public HugeConfig getConf() { + return conf; + } + + public void setConf(HugeConfig conf) { + this.conf = conf; + } + + public String getGraphName() { + return graphName; + } + + public void setGraphName(String graphName) { + this.graphName = graphName; + } + + public abstract void beginTx(); + } +} diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreSessionsImpl.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreSessionsImpl.java new file mode 100755 index 0000000000..123c98acfe --- /dev/null +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreSessionsImpl.java @@ -0,0 +1,784 @@ +/* + * 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.hugegraph.backend.store.hstore; + +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicInteger; + +import org.apache.commons.lang.NotImplementedException; +import org.apache.commons.lang3.ArrayUtils; +import org.apache.commons.lang3.tuple.Pair; +import org.apache.hugegraph.backend.query.Query; +import org.apache.hugegraph.backend.store.BackendEntry; +import org.apache.hugegraph.backend.store.BackendEntry.BackendColumn; +import org.apache.hugegraph.backend.store.BackendEntry.BackendColumnIterator; +import org.apache.hugegraph.backend.store.BackendEntryIterator; +import org.apache.hugegraph.config.HugeConfig; +import org.apache.hugegraph.pd.client.PDClient; +import org.apache.hugegraph.pd.client.PDConfig; +import org.apache.hugegraph.pd.common.PDException; +import org.apache.hugegraph.pd.grpc.Metapb; +import org.apache.hugegraph.store.HgKvEntry; +import org.apache.hugegraph.store.HgKvIterator; +import org.apache.hugegraph.store.HgOwnerKey; +import org.apache.hugegraph.store.HgScanQuery; +import org.apache.hugegraph.store.HgStoreClient; +import org.apache.hugegraph.store.HgStoreSession; +import org.apache.hugegraph.store.client.grpc.KvCloseableIterator; +import org.apache.hugegraph.store.client.util.HgStoreClientConst; +import org.apache.hugegraph.store.grpc.common.ScanOrderType; +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.type.define.GraphMode; +import org.apache.hugegraph.util.Bytes; +import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.StringEncoding; + +public class HstoreSessionsImpl extends HstoreSessions { + + private static final Set infoInitializedGraph = + Collections.synchronizedSet(new HashSet<>()); + private static int tableCode = 0; + private static volatile Boolean initializedNode = Boolean.FALSE; + private static volatile PDClient defaultPdClient; + private static volatile HgStoreClient hgStoreClient; + private final HugeConfig config; + private final HstoreSession session; + private final Map tables; + private final AtomicInteger refCount; + private final String graphName; + + public HstoreSessionsImpl(HugeConfig config, String database, + String store) { + super(config, database, store); + this.config = config; + this.graphName = database + "/" + store; + this.initStoreNode(config); + this.session = new HstoreSession(this.config, graphName); + this.tables = new ConcurrentHashMap<>(); + this.refCount = new AtomicInteger(1); + } + + public static HgStoreClient getHgStoreClient() { + return hgStoreClient; + } + + public static PDClient getDefaultPdClient() { + return defaultPdClient; + } + + public static byte[] encode(String string) { + return StringEncoding.encode(string); + } + + public static String decode(byte[] bytes) { + return StringEncoding.decode(bytes); + } + + private void initStoreNode(HugeConfig config) { + if (!initializedNode) { + synchronized (this) { + if (!initializedNode) { + PDConfig pdConfig = + PDConfig.of(config.get(HstoreOptions.PD_PEERS)) + .setEnableCache(true); + defaultPdClient = PDClient.create(pdConfig); + hgStoreClient = + HgStoreClient.create(defaultPdClient); + initializedNode = Boolean.TRUE; + } + } + } + } + + @Override + public void open() throws Exception { + if (!infoInitializedGraph.contains(this.graphName)) { + synchronized (infoInitializedGraph) { + if (!infoInitializedGraph.contains(this.graphName)) { + Integer partitionCount = + this.config.get(HstoreOptions.PARTITION_COUNT); + Assert.assertTrue("The value of hstore.partition_count" + + " cannot be less than 0.", + partitionCount > -1); + defaultPdClient.setGraph(Metapb.Graph.newBuilder() + .setGraphName( + this.graphName) + .setPartitionCount( + partitionCount) + .build()); + infoInitializedGraph.add(this.graphName); + } + } + } + this.session.open(); + } + + @Override + protected boolean opened() { + return this.session != null; + } + + @Override + public Set openedTables() { + return this.tables.keySet(); + } + + @Override + public synchronized void createTable(String... tables) { + for (String table : tables) { + this.session.createTable(table); + this.tables.put(table, tableCode++); + } + } + + @Override + public synchronized void dropTable(String... tables) { + for (String table : tables) { + this.session.dropTable(table); + this.tables.remove(table); + } + } + + @Override + public boolean existsTable(String table) { + return this.session.existsTable(table); + } + + @Override + public void truncateTable(String table) { + this.session.truncateTable(table); + } + + @Override + public void clear() { + this.session.deleteGraph(); + try { + hgStoreClient.getPdClient().delGraph(this.graphName); + } catch (PDException e) { + + } + } + + @Override + public final Session session() { + return (Session) super.getOrNewSession(); + } + + @Override + protected final Session newSession() { + return new HstoreSession(this.config(), this.graphName); + } + + @Override + protected synchronized void doClose() { + this.checkValid(); + if (this.refCount != null) { + if (this.refCount.decrementAndGet() > 0) { + return; + } + if (this.refCount.get() != 0) { + return; + } + } + assert this.refCount.get() == 0; + this.tables.clear(); + this.session.close(); + } + + private void checkValid() { + } + + private static class ColumnIterator implements + BackendColumnIterator, + Countable { + + private final T iter; + private final byte[] keyBegin; + private final byte[] keyEnd; + private final int scanType; + private final String table; + private final byte[] value; + private boolean gotNext; + private byte[] position; + + public ColumnIterator(String table, T results) { + this(table, results, null, null, 0); + } + + public ColumnIterator(String table, T results, byte[] keyBegin, + byte[] keyEnd, int scanType) { + E.checkNotNull(results, "results"); + this.table = table; + this.iter = results; + this.keyBegin = keyBegin; + this.keyEnd = keyEnd; + this.scanType = scanType; + this.value = null; + if (this.iter.hasNext()) { + this.iter.next(); + this.gotNext = true; + this.position = iter.position(); + } else { + this.gotNext = false; + this.position = null; + } + if (!ArrayUtils.isEmpty(this.keyBegin) || + !ArrayUtils.isEmpty(this.keyEnd)) { + this.checkArguments(); + } + + } + + public T iter() { + return iter; + } + + private void checkArguments() { + E.checkArgument(!(this.match(Session.SCAN_PREFIX_BEGIN) && + this.match(Session.SCAN_PREFIX_END)), + "Can't set SCAN_PREFIX_WITH_BEGIN and " + + "SCAN_PREFIX_WITH_END at the same time"); + + E.checkArgument(!(this.match(Session.SCAN_PREFIX_BEGIN) && + this.match(Session.SCAN_GT_BEGIN)), + "Can't set SCAN_PREFIX_WITH_BEGIN and " + + "SCAN_GT_BEGIN/SCAN_GTE_BEGIN at the same time"); + + E.checkArgument(!(this.match(Session.SCAN_PREFIX_END) && + this.match(Session.SCAN_LT_END)), + "Can't set SCAN_PREFIX_WITH_END and " + + "SCAN_LT_END/SCAN_LTE_END at the same time"); + + if (this.match(Session.SCAN_PREFIX_BEGIN) && !matchHash()) { + E.checkArgument(this.keyBegin != null, + "Parameter `keyBegin` can't be null " + + "if set SCAN_PREFIX_WITH_BEGIN"); + E.checkArgument(this.keyEnd == null, + "Parameter `keyEnd` must be null " + + "if set SCAN_PREFIX_WITH_BEGIN"); + } + + if (this.match(Session.SCAN_PREFIX_END) && !matchHash()) { + E.checkArgument(this.keyEnd != null, + "Parameter `keyEnd` can't be null " + + "if set SCAN_PREFIX_WITH_END"); + } + + if (this.match(Session.SCAN_GT_BEGIN) && !matchHash()) { + E.checkArgument(this.keyBegin != null, + "Parameter `keyBegin` can't be null " + + "if set SCAN_GT_BEGIN or SCAN_GTE_BEGIN"); + } + + if (this.match(Session.SCAN_LT_END) && !matchHash()) { + E.checkArgument(this.keyEnd != null, + "Parameter `keyEnd` can't be null " + + "if set SCAN_LT_END or SCAN_LTE_END"); + } + } + + private boolean matchHash() { + return this.scanType == Session.SCAN_HASHCODE; + } + + private boolean match(int expected) { + return Session.matchScanType(expected, this.scanType); + } + + + @Override + public boolean hasNext() { + if (gotNext) { + this.position = this.iter.position(); + } else { + this.position = null; + } + return gotNext; + } + + private boolean filter(byte[] key) { + if (this.match(Session.SCAN_PREFIX_BEGIN)) { + /* + * Prefix with `keyBegin`? + * TODO: use custom prefix_extractor instead + * or use ReadOptions.prefix_same_as_start + */ + return Bytes.prefixWith(key, this.keyBegin); + } else if (this.match(Session.SCAN_PREFIX_END)) { + /* + * Prefix with `keyEnd`? + * like the following query for range index: + * key > 'age:20' and prefix with 'age' + */ + assert this.keyEnd != null; + return Bytes.prefixWith(key, this.keyEnd); + } else if (this.match(Session.SCAN_LT_END)) { + /* + * Less (equal) than `keyEnd`? + * NOTE: don't use BytewiseComparator due to signed byte + */ + if ((this.scanType | Session.SCAN_HASHCODE) != 0) { + return true; + } + assert this.keyEnd != null; + if (this.match(Session.SCAN_LTE_END)) { + // Just compare the prefix, can be there are excess tail + key = Arrays.copyOfRange(key, 0, this.keyEnd.length); + return Bytes.compare(key, this.keyEnd) <= 0; + } else { + return Bytes.compare(key, this.keyEnd) < 0; + } + } else { + assert this.match(Session.SCAN_ANY) || this.match(Session.SCAN_GT_BEGIN) || + this.match( + Session.SCAN_GTE_BEGIN) : "Unknown scan type"; + return true; + } + } + + @Override + public BackendColumn next() { + BackendEntryIterator.checkInterrupted(); + if (!this.hasNext()) { + throw new NoSuchElementException(); + } + BackendColumn col = + BackendColumn.of(this.iter.key(), + this.iter.value()); + if (this.iter.hasNext()) { + gotNext = true; + this.iter.next(); + } else { + gotNext = false; + } + return col; + } + + @Override + public long count() { + long count = 0L; + while (this.hasNext()) { + this.next(); + count++; + BackendEntryIterator.checkInterrupted(); + } + return count; + } + + @Override + public byte[] position() { + return this.position; + } + + @Override + public void close() { + if (this.iter != null) { + this.iter.close(); + } + } + } + + /** + * HstoreSession implement for hstore + */ + private final class HstoreSession extends Session { + + private static final boolean TRANSACTIONAL = true; + private final HgStoreSession graph; + int changedSize = 0; + + public HstoreSession(HugeConfig conf, String graphName) { + setGraphName(graphName); + setConf(conf); + this.graph = hgStoreClient.openSession(graphName); + } + + @Override + public void open() { + this.opened = true; + } + + @Override + public void close() { + this.opened = false; + } + + @Override + public boolean closed() { + return !this.opened; + } + + @Override + public void reset() { + if (this.changedSize != 0) { + this.rollback(); + this.changedSize = 0; + } + } + + /** + * Any change in the session + */ + @Override + public boolean hasChanges() { + return this.changedSize > 0; + } + + /** + * Commit all updates(put/delete) to DB + */ + @Override + public Integer commit() { + int commitSize = this.changedSize; + if (TRANSACTIONAL) { + this.graph.commit(); + } + this.changedSize = 0; + return commitSize; + } + + /** + * Rollback all updates(put/delete) not committed + */ + @Override + public void rollback() { + if (TRANSACTIONAL) { + this.graph.rollback(); + } + this.changedSize = 0; + } + + @Override + public void createTable(String tableName) { + this.graph.createTable(tableName); + } + + @Override + public void dropTable(String tableName) { + this.graph.dropTable(tableName); + } + + @Override + public boolean existsTable(String tableName) { + return this.graph.existsTable(tableName); + } + + @Override + public void truncateTable(String tableName) { + this.graph.deleteTable(tableName); + } + + @Override + public void deleteGraph() { + this.graph.deleteGraph(this.getGraphName()); + } + + @Override + public Pair keyRange(String table) { + return null; + } + + private void prepare() { + if (!this.hasChanges() && TRANSACTIONAL) { + this.graph.beginTx(); + } + this.changedSize++; + } + + /** + * Add a KV record to a table + */ + @Override + public void put(String table, byte[] ownerKey, byte[] key, + byte[] value) { + prepare(); + this.graph.put(table, HgOwnerKey.of(ownerKey, key), value); + } + + @Override + public synchronized void increase(String table, byte[] ownerKey, + byte[] key, byte[] value) { + prepare(); + this.graph.merge(table, HgOwnerKey.of(ownerKey, key), value); + } + + @Override + public void delete(String table, byte[] ownerKey, byte[] key) { + prepare(); + this.graph.delete(table, HgOwnerKey.of(ownerKey, key)); + } + + @Override + public void deletePrefix(String table, byte[] ownerKey, byte[] key) { + prepare(); + this.graph.deletePrefix(table, HgOwnerKey.of(ownerKey, key)); + } + + /** + * Delete a range of keys from a table + */ + @Override + public void deleteRange(String table, byte[] ownerKeyFrom, + byte[] ownerKeyTo, byte[] keyFrom, + byte[] keyTo) { + prepare(); + this.graph.deleteRange(table, HgOwnerKey.of(ownerKeyFrom, keyFrom), + HgOwnerKey.of(ownerKeyTo, keyTo)); + } + + @Override + public byte[] get(String table, byte[] key) { + return this.graph.get(table, HgOwnerKey.of( + HgStoreClientConst.ALL_PARTITION_OWNER, key)); + } + + @Override + public byte[] get(String table, byte[] ownerKey, byte[] key) { + byte[] values = this.graph.get(table, HgOwnerKey.of(ownerKey, key)); + return values != null ? values : new byte[0]; + } + + @Override + public void beginTx() { + this.graph.beginTx(); + } + + @Override + public BackendColumnIterator scan(String table) { + assert !this.hasChanges(); + return new ColumnIterator<>(table, this.graph.scanIterator(table)); + } + + @Override + public BackendColumnIterator scan(String table, + byte[] conditionQueryToByte) { + assert !this.hasChanges(); + HgKvIterator results = + this.graph.scanIterator(table, conditionQueryToByte); + return new ColumnIterator<>(table, results); + } + + @Override + public BackendColumnIterator scan(String table, byte[] ownerKey, + byte[] prefix) { + assert !this.hasChanges(); + HgKvIterator result = this.graph.scanIterator(table, + HgOwnerKey.of( + ownerKey, + prefix)); + return new ColumnIterator<>(table, result); + } + + @Override + public List scan(String table, + List keys, + int scanType, long limit, + byte[] query) { + HgScanQuery scanQuery = HgScanQuery.prefixOf(table, keys).builder() + .setScanType(scanType) + .setQuery(query) + .setPerKeyLimit(limit).build(); + List> scanIterators = + this.graph.scanBatch(scanQuery); + LinkedList columnIterators = + new LinkedList<>(); + scanIterators.forEach(item -> { + columnIterators.add( + new ColumnIterator<>(table, item)); + }); + return columnIterators; + } + + @Override + public BackendEntry.BackendIterator scan( + String table, + Iterator keys, + int scanType, Query queryParam, byte[] query) { + ScanOrderType orderType; + switch (queryParam.orderType()) { + case ORDER_NONE: + orderType = ScanOrderType.ORDER_NONE; + break; + case ORDER_WITHIN_VERTEX: + orderType = ScanOrderType.ORDER_WITHIN_VERTEX; + break; + case ORDER_STRICT: + orderType = ScanOrderType.ORDER_STRICT; + break; + default: + throw new RuntimeException("not implement"); + } + HgScanQuery scanQuery = HgScanQuery.prefixIteratorOf(table, keys) + .builder() + .setScanType(scanType) + .setQuery(query) + .setPerKeyMax(queryParam.limit()) + .setOrderType(orderType) + .setOnlyKey( + !queryParam.withProperties()) + .setSkipDegree( + queryParam.skipDegree()) + .build(); + KvCloseableIterator> scanIterators = + this.graph.scanBatch2(scanQuery); + return new BackendEntry.BackendIterator<>() { + @Override + public void close() { + scanIterators.close(); + } + + @Override + public byte[] position() { + throw new NotImplementedException(); + } + + @Override + public boolean hasNext() { + return scanIterators.hasNext(); + } + + @Override + public BackendColumnIterator next() { + return new ColumnIterator(table, + scanIterators.next()); + } + }; + } + + @Override + public BackendColumnIterator scan(String table, byte[] ownerKeyFrom, + byte[] ownerKeyTo, + byte[] keyFrom, byte[] keyTo, + int scanType) { + assert !this.hasChanges(); + HgKvIterator result = this.graph.scanIterator(table, HgOwnerKey.of( + ownerKeyFrom, keyFrom), + HgOwnerKey.of( + ownerKeyTo, + keyTo), 0, + scanType, + null); + return new ColumnIterator<>(table, result, keyFrom, + keyTo, scanType); + } + + @Override + public BackendColumnIterator scan(String table, byte[] ownerKeyFrom, + byte[] ownerKeyTo, + byte[] keyFrom, byte[] keyTo, + int scanType, byte[] query) { + assert !this.hasChanges(); + HgKvIterator result = this.graph.scanIterator(table, + HgOwnerKey.of( + ownerKeyFrom, + keyFrom), + HgOwnerKey.of( + ownerKeyTo, + keyTo), + 0, + scanType, + query); + return new ColumnIterator<>(table, result, keyFrom, keyTo, + scanType); + } + + @Override + public BackendColumnIterator scan(String table, byte[] ownerKeyFrom, + byte[] ownerKeyTo, + byte[] keyFrom, byte[] keyTo, + int scanType, byte[] query, + byte[] position) { + assert !this.hasChanges(); + HgKvIterator result = this.graph.scanIterator(table, + HgOwnerKey.of( + ownerKeyFrom, + keyFrom), + HgOwnerKey.of( + ownerKeyTo, + keyTo), + 0, + scanType, + query); + result.seek(position); + return new ColumnIterator<>(table, result, keyFrom, keyTo, + scanType); + } + + @Override + public BackendColumnIterator scan(String table, int codeFrom, + int codeTo, int scanType, + byte[] query) { + assert !this.hasChanges(); + HgKvIterator iterator = + this.graph.scanIterator(table, codeFrom, codeTo, 256, + new byte[0]); + return new ColumnIterator<>(table, iterator, new byte[0], + new byte[0], scanType); + } + + @Override + public BackendColumnIterator scan(String table, int codeFrom, + int codeTo, int scanType, + byte[] query, byte[] position) { + assert !this.hasChanges(); + HgKvIterator iterator = + this.graph.scanIterator(table, codeFrom, codeTo, 256, + new byte[0]); + iterator.seek(position); + return new ColumnIterator<>(table, iterator, new byte[0], + new byte[0], scanType); + } + + @Override + public BackendColumnIterator getWithBatch(String table, + List keys) { + assert !this.hasChanges(); + HgKvIterator kvIterator = + this.graph.batchPrefix(table, keys); + return new ColumnIterator<>(table, kvIterator); + } + + @Override + public void merge(String table, byte[] ownerKey, byte[] key, + byte[] value) { + prepare(); + this.graph.merge(table, HgOwnerKey.of(ownerKey, key), value); + } + + @Override + public void setMode(GraphMode mode) { + // no need to set pd mode + } + + @Override + public void truncate() throws Exception { + this.graph.truncate(); + HstoreSessionsImpl.getDefaultPdClient() + .resetIdByKey(this.getGraphName()); + } + } +} diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java new file mode 100644 index 0000000000..c3a72c868d --- /dev/null +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java @@ -0,0 +1,796 @@ +/* + * 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.hugegraph.backend.store.hstore; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReadWriteLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; +import java.util.function.Function; +import java.util.stream.Collectors; + +import org.apache.commons.collections.CollectionUtils; +import org.apache.commons.compress.utils.Lists; +import org.apache.hugegraph.HugeGraph; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.query.ConditionQuery; +import org.apache.hugegraph.backend.query.ConditionQueryFlatten; +import org.apache.hugegraph.backend.query.IdPrefixQuery; +import org.apache.hugegraph.backend.query.IdQuery; +import org.apache.hugegraph.backend.query.Query; +import org.apache.hugegraph.backend.serializer.BinaryBackendEntry; +import org.apache.hugegraph.backend.serializer.BytesBuffer; +import org.apache.hugegraph.backend.serializer.MergeIterator; +import org.apache.hugegraph.backend.store.AbstractBackendStore; +import org.apache.hugegraph.backend.store.BackendAction; +import org.apache.hugegraph.backend.store.BackendEntry; +import org.apache.hugegraph.backend.store.BackendFeatures; +import org.apache.hugegraph.backend.store.BackendMutation; +import org.apache.hugegraph.backend.store.BackendStoreProvider; +import org.apache.hugegraph.backend.store.BackendTable; +import org.apache.hugegraph.backend.store.hstore.HstoreSessions.Session; +import org.apache.hugegraph.config.CoreOptions; +import org.apache.hugegraph.config.HugeConfig; +import org.apache.hugegraph.iterator.CIter; +import org.apache.hugegraph.schema.EdgeLabel; +import org.apache.hugegraph.type.HugeTableType; +import org.apache.hugegraph.type.HugeType; +import org.apache.hugegraph.type.define.Action; +import org.apache.hugegraph.type.define.GraphMode; +import org.apache.hugegraph.type.define.HugeKeys; +import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.Log; +import org.slf4j.Logger; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; + +public abstract class HstoreStore extends AbstractBackendStore { + + private static final Logger LOG = Log.logger(HstoreStore.class); + + private static final Set INDEX_TYPES = ImmutableSet.of( + HugeType.SECONDARY_INDEX, HugeType.VERTEX_LABEL_INDEX, + HugeType.EDGE_LABEL_INDEX, HugeType.RANGE_INT_INDEX, + HugeType.RANGE_FLOAT_INDEX, HugeType.RANGE_LONG_INDEX, + HugeType.RANGE_DOUBLE_INDEX, HugeType.SEARCH_INDEX, + HugeType.SHARD_INDEX, HugeType.UNIQUE_INDEX + ); + + private static final BackendFeatures FEATURES = new HstoreFeatures(); + private final String store, namespace; + + private final BackendStoreProvider provider; + private final Map tables; + private final ReadWriteLock storeLock; + private boolean isGraphStore; + private HstoreSessions sessions; + + public HstoreStore(final BackendStoreProvider provider, + String namespace, String store) { + this.tables = new HashMap<>(); + this.provider = provider; + this.namespace = namespace; + this.store = store; + this.sessions = null; + this.storeLock = new ReentrantReadWriteLock(); + this.registerMetaHandlers(); + LOG.debug("Store loaded: {}", store); + } + + private void registerMetaHandlers() { + this.registerMetaHandler("metrics", (session, meta, args) -> { + return ImmutableMap.of(); + }); + this.registerMetaHandler("mode", (session, meta, args) -> { + E.checkArgument(args.length == 1, + "The args count of %s must be 1", meta); + session.setMode((GraphMode) args[0]); + return null; + }); + } + + protected void registerTableManager(HugeTableType type, HstoreTable table) { + this.tables.put((int) type.code(), table); + } + + @Override + protected final HstoreTable table(HugeType type) { + assert type != null; + HugeTableType table; + switch (type) { + case VERTEX: + table = HugeTableType.VERTEX; + break; + case EDGE_OUT: + table = HugeTableType.OUT_EDGE; + break; + case EDGE_IN: + table = HugeTableType.IN_EDGE; + break; + case OLAP: + table = HugeTableType.OLAP_TABLE; + break; + case TASK: + table = HugeTableType.TASK_INFO_TABLE; + break; + case SEARCH_INDEX: + case SHARD_INDEX: + case SECONDARY_INDEX: + case RANGE_INT_INDEX: + case RANGE_LONG_INDEX: + case RANGE_FLOAT_INDEX: + case RANGE_DOUBLE_INDEX: + case EDGE_LABEL_INDEX: + case VERTEX_LABEL_INDEX: + case UNIQUE_INDEX: + table = HugeTableType.ALL_INDEX_TABLE; + break; + default: + throw new AssertionError(String.format( + "Invalid type: %s", type)); + } + return this.tables.get((int) table.code()); + } + + protected List tableNames() { + return this.tables.values().stream() + .map(BackendTable::table) + .collect(Collectors.toList()); + } + + @Override + protected Session session(HugeType type) { + this.checkOpened(); + return this.sessions.session(); + } + + public String namespace() { + return this.namespace; + } + + @Override + public String store() { + return this.store; + } + + @Override + public String database() { + return this.namespace; + } + + @Override + public BackendStoreProvider provider() { + return this.provider; + } + + @Override + public BackendFeatures features() { + return FEATURES; + } + + @Override + public synchronized void open(HugeConfig config) { + E.checkNotNull(config, "config"); + + if (this.sessions == null) { + this.sessions = new HstoreSessionsImpl(config, this.namespace, + this.store); + } + + String graphStore = config.get(CoreOptions.STORE_GRAPH); + this.isGraphStore = this.store.equals(graphStore); + assert this.sessions != null; + if (!this.sessions.closed()) { + LOG.debug("Store {} has been opened before", this.store); + this.sessions.useSession(); + return; + } + + try { + // NOTE: won't throw error even if connection refused + this.sessions.open(); + } catch (Exception e) { + LOG.error("Failed to open Hstore '{}':{}", this.store, e); + } + this.sessions.session(); + LOG.debug("Store opened: {}", this.store); + } + + @Override + public void close() { + this.checkOpened(); + this.sessions.close(); + + LOG.debug("Store closed: {}", this.store); + } + + @Override + public boolean opened() { + this.checkConnectionOpened(); + return this.sessions.session().opened(); + } + + @Override + public void mutate(BackendMutation mutation) { + Session session = this.sessions.session(); + assert session.opened(); + Map>> mutations = mutation.mutations(); + Set>>> entries = mutations.entrySet(); + for (Map.Entry>> entry : entries) { + HugeType key = entry.getKey(); + // in order to obtain the owner efficiently, special for edge + boolean isEdge = key.isEdge(); + HstoreTable hTable = this.table(key); + Map> table = entry.getValue(); + Collection> values = table.values(); + for (List items : values) { + for (int i = 0; i < items.size(); i++) { + BackendAction item = items.get(i); + // set to ArrayList, use index to get item + this.mutate(session, item, hTable, isEdge); + } + } + } + } + + private void mutate(Session session, BackendAction item, + HstoreTable hTable, boolean isEdge) { + BackendEntry entry = item.entry(); + HstoreTable table; + if (!entry.olap()) { + // Oltp table + table = hTable; + } else { + if (entry.type().isIndex()) { + // Olap index + table = this.table(entry.type()); + } else { + // Olap vertex + table = this.table(HugeType.OLAP); + } + session = this.session(HugeType.OLAP); + } + + if (item.action().code() == Action.INSERT.code()) { + table.insert(session, entry, isEdge); + } else { + if (item.action().code() == Action.APPEND.code()) { + table.append(session, entry); + } else { + switch (item.action()) { + case DELETE: + table.delete(session, entry); + break; + case ELIMINATE: + table.eliminate(session, entry); + break; + case UPDATE_IF_PRESENT: + table.updateIfPresent(session, entry); + break; + case UPDATE_IF_ABSENT: + table.updateIfAbsent(session, entry); + break; + default: + throw new AssertionError(String.format( + "Unsupported mutate action: %s", + item.action())); + } + } + } + } + + private HstoreTable getTableByQuery(Query query) { + HugeType tableType = HstoreTable.tableType(query); + HstoreTable table; + if (query.olap()) { + if (query.resultType().isIndex()) { + // Any index type is ok here + table = this.table(HugeType.SECONDARY_INDEX); + } else { + table = this.table(HugeType.OLAP); + } + } else { + table = this.table(tableType); + } + return table; + } + + @Override + public Iterator query(Query query) { + Lock readLock = this.storeLock.readLock(); + readLock.lock(); + try { + this.checkOpened(); + Session session = this.sessions.session(); + HstoreTable table = getTableByQuery(query); + Iterator entries = table.query(session, query); + // Merge olap results as needed + entries = getBackendEntryIterator(entries, query); + return entries; + } finally { + readLock.unlock(); + } + } + + + @Override + public Iterator> query(Iterator queries, + Function queryWriter, + HugeGraph hugeGraph) { + if (queries == null || !queries.hasNext()) { + return new LinkedList>().iterator(); + } + + class QueryWrapper implements Iterator { + Query first; + Iterator queries; + Iterator subEls; + Query preQuery; + Iterator queryListIterator; + + QueryWrapper(Iterator queries, Query first) { + this.queries = queries; + this.first = first; + } + + @Override + public boolean hasNext() { + return first != null || (this.subEls != null && this.subEls.hasNext()) + || (queryListIterator != null && queryListIterator.hasNext()) || + queries.hasNext(); + } + + @Override + public IdPrefixQuery next() { + if (queryListIterator != null && queryListIterator.hasNext()) { + return queryListIterator.next(); + } + + Query q; + if (first != null) { + q = first; + preQuery = q.copy(); + first = null; + } else { + if (this.subEls == null || !this.subEls.hasNext()) { + q = queries.next(); + preQuery = q.copy(); + } else { + q = preQuery.copy(); + } + } + + assert q instanceof ConditionQuery; + ConditionQuery cq = (ConditionQuery) q; + ConditionQuery originQuery = (ConditionQuery) q.copy(); + + List queryList = Lists.newArrayList(); + if (hugeGraph != null) { + for (ConditionQuery conditionQuery : + ConditionQueryFlatten.flatten(cq)) { + Id label = conditionQuery.condition(HugeKeys.LABEL); + /* 父类型 + sortKeys： g.V("V.id").outE("parentLabel").has + ("sortKey","value")转成 所有子类型 + sortKeys*/ + if ((this.subEls == null || + !this.subEls.hasNext()) && label != null && + hugeGraph.edgeLabel(label).isFather() && + conditionQuery.condition(HugeKeys.SUB_LABEL) == + null && + conditionQuery.condition(HugeKeys.OWNER_VERTEX) != + null && + conditionQuery.condition(HugeKeys.DIRECTION) != + null && + matchEdgeSortKeys(conditionQuery, false, + hugeGraph)) { + this.subEls = + getSubLabelsOfParentEl( + hugeGraph.edgeLabels(), + label); + } + + if (this.subEls != null && + this.subEls.hasNext()) { + conditionQuery.eq(HugeKeys.SUB_LABEL, + subEls.next()); + } + + HugeType hugeType = conditionQuery.resultType(); + if (hugeType != null && hugeType.isEdge() && + !conditionQuery.conditions().isEmpty()) { + IdPrefixQuery idPrefixQuery = + (IdPrefixQuery) queryWriter.apply( + conditionQuery); + idPrefixQuery.setOriginQuery(originQuery); + queryList.add(idPrefixQuery); + } + } + + queryListIterator = queryList.iterator(); + if (queryListIterator.hasNext()) { + return queryListIterator.next(); + } + } + + Id ownerId = cq.condition(HugeKeys.OWNER_VERTEX); + assert ownerId != null; + BytesBuffer buffer = + BytesBuffer.allocate(BytesBuffer.BUF_EDGE_ID); + buffer.writeId(ownerId); + return new IdPrefixQuery(cq, new BinaryBackendEntry.BinaryId( + buffer.bytes(), ownerId)); + } + + private boolean matchEdgeSortKeys(ConditionQuery query, + boolean matchAll, + HugeGraph graph) { + assert query.resultType().isEdge(); + Id label = query.condition(HugeKeys.LABEL); + if (label == null) { + return false; + } + List sortKeys = graph.edgeLabel(label).sortKeys(); + if (sortKeys.isEmpty()) { + return false; + } + Set queryKeys = query.userpropKeys(); + for (int i = sortKeys.size(); i > 0; i--) { + List subFields = sortKeys.subList(0, i); + if (queryKeys.containsAll(subFields)) { + if (queryKeys.size() == subFields.size() || !matchAll) { + /* + * Return true if: + * matchAll=true and all queryKeys are in sortKeys + * or + * partial queryKeys are in sortKeys + */ + return true; + } + } + } + return false; + } + } + Query first = queries.next(); + List typeList = getHugeTypes(first); + QueryWrapper idPrefixQueries = new QueryWrapper(queries, first); + + return query(typeList, idPrefixQueries); + } + + private Iterator getSubLabelsOfParentEl(Collection allEls, + Id label) { + List list = new ArrayList<>(); + for (EdgeLabel el : allEls) { + if (el.edgeLabelType().sub() && el.fatherId().equals(label)) { + list.add(el.id()); + } + } + return list.iterator(); + } + + public List> query(List typeList, + List queries) { + Lock readLock = this.storeLock.readLock(); + readLock.lock(); + LinkedList> results = new LinkedList<>(); + try { + this.checkOpened(); + Session session = this.sessions.session(); + E.checkState(!CollectionUtils.isEmpty(queries) && + !CollectionUtils.isEmpty(typeList), + "Please check query list or type list."); + HstoreTable table = null; + StringBuilder builder = new StringBuilder(); + for (HugeType type : typeList) { + builder.append((table = this.table(type)).table()).append(","); + } + List> iteratorList = + table.query(session, queries, + builder.substring(0, builder.length() - 1)); + for (int i = 0; i < iteratorList.size(); i++) { + Iterator entries = iteratorList.get(i); + // Merge olap results as needed + Query query = queries.get(i); + entries = getBackendEntryIterator(entries, query); + if (entries instanceof CIter) { + results.add((CIter) entries); + } + } + return results; + } finally { + readLock.unlock(); + } + } + + public Iterator> query(List typeList, + Iterator queries) { + Lock readLock = this.storeLock.readLock(); + readLock.lock(); + try { + this.checkOpened(); + Session session = this.sessions.session(); + E.checkState(queries.hasNext() && + !CollectionUtils.isEmpty(typeList), + "Please check query list or type list."); + HstoreTable table = null; + StringBuilder builder = new StringBuilder(); + for (HugeType type : typeList) { + builder.append((table = this.table(type)).table()).append(","); + } + + Iterator> iterators = + table.query(session, queries, + builder.substring(0, builder.length() - 1)); + + return iterators; + } finally { + readLock.unlock(); + } + } + + private Iterator getBackendEntryIterator( + Iterator entries, + Query query) { + HstoreTable table; + Set olapPks = query.olapPks(); + if (this.isGraphStore && !olapPks.isEmpty()) { + List> iterators = new ArrayList<>(); + for (Id pk : olapPks) { + // 构造olap表查询query condition + Query q = this.constructOlapQueryCondition(pk, query); + table = this.table(HugeType.OLAP); + iterators.add(table.queryOlap(this.session(HugeType.OLAP), q)); + } + entries = new MergeIterator<>(entries, iterators, + BackendEntry::mergable); + } + return entries; + } + + + /** + * 重新构造 查询olap表 query + * 由于 olap合并成一张表, 在写入olap数据, key在后面增加了pk + * 所以在此进行查询的时候,需要重新构造pk前缀 + * 写入参考 BinarySerializer.writeOlapVertex + * + * @param pk + * @param query + * @return + */ + private Query constructOlapQueryCondition(Id pk, Query query) { + if (query instanceof IdQuery && !CollectionUtils.isEmpty((query).ids())) { + IdQuery q = (IdQuery) query.copy(); + Iterator iterator = q.ids().iterator(); + LinkedHashSet linkedHashSet = new LinkedHashSet<>(); + while (iterator.hasNext()) { + Id id = iterator.next(); + if (id instanceof BinaryBackendEntry.BinaryId) { + id = ((BinaryBackendEntry.BinaryId) id).origin(); + } + + // create binary id + BytesBuffer buffer = + BytesBuffer.allocate(1 + pk.length() + 1 + id.length()); + buffer.writeId(pk); + id = new BinaryBackendEntry.BinaryId( + buffer.writeId(id).bytes(), id); + linkedHashSet.add(id); + } + q.resetIds(); + q.query(linkedHashSet); + return q; + } else { + // create binary id + BytesBuffer buffer = BytesBuffer.allocate(1 + pk.length()); + pk = new BinaryBackendEntry.BinaryId( + buffer.writeId(pk).bytes(), pk); + + IdPrefixQuery idPrefixQuery = new IdPrefixQuery(HugeType.OLAP, pk); + return idPrefixQuery; + } + } + + @Override + public Number queryNumber(Query query) { + this.checkOpened(); + + Session session = this.sessions.session(); + HstoreTable table = this.table(HstoreTable.tableType(query)); + return table.queryNumber(session, query); + } + + @Override + public synchronized void init() { + Lock writeLock = this.storeLock.writeLock(); + writeLock.lock(); + try { + // Create tables with main disk + this.sessions.createTable(this.tableNames().toArray(new String[0])); + LOG.debug("Store initialized: {}", this.store); + } finally { + writeLock.unlock(); + } + } + + @Override + public void clear(boolean clearSpace) { + Lock writeLock = this.storeLock.writeLock(); + writeLock.lock(); + try { + // Drop tables with main disk + this.sessions.dropTable(this.tableNames().toArray(new String[0])); + if (clearSpace) { + this.sessions.clear(); + } + LOG.debug("Store cleared: {}", this.store); + } finally { + writeLock.unlock(); + } + } + + @Override + public boolean initialized() { + return true; + } + + @Override + public void truncate() { + try { + this.sessions.session().truncate(); + } catch (Exception e) { + LOG.error("Store truncated failed", e); + return; + } + LOG.debug("Store truncated: {}", this.store); + } + + @Override + public void beginTx() { + this.sessions.session().beginTx(); + } + + @Override + public void commitTx() { + this.checkOpened(); + Session session = this.sessions.session(); + session.commit(); + } + + @Override + public void rollbackTx() { + this.checkOpened(); + Session session = this.sessions.session(); + session.rollback(); + } + + private void checkConnectionOpened() { + } + + @Override + public Id nextId(HugeType type) { + long counter = 0L; + counter = this.getCounter(type); + E.checkState(counter != 0L, "Please check whether '%s' is OK", + this.provider().type()); + return IdGenerator.of(counter); + } + + @Override + public void setCounterLowest(HugeType type, long lowest) { + this.increaseCounter(type, lowest); + } + + /***************************** Store defines *****************************/ + + public static class HstoreGraphStore extends HstoreStore { + + public HstoreGraphStore(BackendStoreProvider provider, + String namespace, String store) { + super(provider, namespace, store); + + registerTableManager(HugeTableType.VERTEX, + new HstoreTables.Vertex(store)); + registerTableManager(HugeTableType.OUT_EDGE, + HstoreTables.Edge.out(store)); + registerTableManager(HugeTableType.IN_EDGE, + HstoreTables.Edge.in(store)); + registerTableManager(HugeTableType.ALL_INDEX_TABLE, + new HstoreTables.IndexTable(store)); + registerTableManager(HugeTableType.OLAP_TABLE, + new HstoreTables.OlapTable(store)); + registerTableManager(HugeTableType.TASK_INFO_TABLE, + new HstoreTables.TaskInfo(store)); + } + + @Override + public boolean isSchemaStore() { + return false; + } + + @Override + public void close(boolean force) { + } + + @Override + public Id nextId(HugeType type) { + throw new UnsupportedOperationException( + "HstoreGraphStore.nextId()"); + } + + @Override + public void increaseCounter(HugeType type, long num) { + throw new UnsupportedOperationException( + "HstoreGraphStore.increaseCounter()"); + } + + @Override + public long getCounter(HugeType type) { + throw new UnsupportedOperationException( + "HstoreGraphStore.getCounter()"); + } + + @Override + public void createOlapTable(Id pkId) { + HstoreTable table = new HstoreTables.OlapTable(this.store()); + LOG.info("Hstore create olap table {}", table.table()); + super.sessions.createTable(table.table()); + LOG.info("Hstore finish create olap table"); + registerTableManager(HugeTableType.OLAP_TABLE, table); + LOG.info("OLAP table {} has been created", table.table()); + } + + @Override + public void checkAndRegisterOlapTable(Id pkId) { + HstoreTable table = new HstoreTables.OlapTable(this.store()); + if (!super.sessions.existsTable(table.table())) { + LOG.error("Found exception: Table '{}' doesn't exist, we'll " + + "recreate it now. Please carefully check the recent" + + "operation in server and computer, then ensure the " + + "integrity of store file.", table.table()); + this.createOlapTable(pkId); + } else { + registerTableManager(HugeTableType.OLAP_TABLE, table); + } + } + + @Override + public void clearOlapTable(Id pkId) { + } + + @Override + public void removeOlapTable(Id pkId) { + } + + @Override + public boolean existOlapTable(Id pkId) { + String tableName = this.olapTableName(pkId); + return super.sessions.existsTable(tableName); + } + } +} diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTable.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTable.java new file mode 100755 index 0000000000..774b213fc6 --- /dev/null +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTable.java @@ -0,0 +1,745 @@ +/* + * 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.hugegraph.backend.store.hstore; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Set; +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Supplier; + +import org.apache.commons.collections.CollectionUtils; +import org.apache.commons.lang3.StringUtils; +import org.apache.hugegraph.backend.id.EdgeId; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.page.PageState; +import org.apache.hugegraph.backend.query.Aggregate; +import org.apache.hugegraph.backend.query.Aggregate.AggregateFunc; +import org.apache.hugegraph.backend.query.Condition; +import org.apache.hugegraph.backend.query.Condition.Relation; +import org.apache.hugegraph.backend.query.ConditionQuery; +import org.apache.hugegraph.backend.query.IdPrefixQuery; +import org.apache.hugegraph.backend.query.IdRangeQuery; +import org.apache.hugegraph.backend.query.Query; +import org.apache.hugegraph.backend.serializer.BinaryBackendEntry; +import org.apache.hugegraph.backend.serializer.BinaryEntryIterator; +import org.apache.hugegraph.backend.store.BackendEntry; +import org.apache.hugegraph.backend.store.BackendEntry.BackendColumn; +import org.apache.hugegraph.backend.store.BackendEntry.BackendColumnIterator; +import org.apache.hugegraph.backend.store.BackendEntry.BackendColumnIteratorWrapper; +import org.apache.hugegraph.backend.store.BackendEntryIterator; +import org.apache.hugegraph.backend.store.BackendTable; +import org.apache.hugegraph.backend.store.Shard; +import org.apache.hugegraph.backend.store.hstore.HstoreSessions.Countable; +import org.apache.hugegraph.backend.store.hstore.HstoreSessions.Session; +import org.apache.hugegraph.exception.NotSupportException; +import org.apache.hugegraph.pd.client.PDClient; +import org.apache.hugegraph.pd.common.PDException; +import org.apache.hugegraph.pd.grpc.Metapb; +import org.apache.hugegraph.store.HgOwnerKey; +import org.apache.hugegraph.store.client.util.HgStoreClientConst; +import org.apache.hugegraph.type.HugeType; +import org.apache.hugegraph.type.define.HugeKeys; +import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.Log; +import org.apache.hugegraph.util.StringEncoding; +import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils; +import org.slf4j.Logger; + +public class HstoreTable extends BackendTable { + + private static final Logger LOG = Log.logger(HstoreStore.class); + + private final HstoreShardSpliter shardSpliter; + Function ownerDelegate = (entry) -> getOwner(entry); + Function ownerByIdDelegate = (id) -> getOwnerId(id); + BiFunction ownerByQueryDelegate = + (type, id) -> getOwnerId(type, id); + Supplier ownerScanDelegate = + () -> HgStoreClientConst.ALL_PARTITION_OWNER; + + public HstoreTable(String database, String table) { + super(String.format("%s+%s", database, table)); + this.shardSpliter = new HstoreShardSpliter(this.table()); + } + + public static ConditionQuery removeDirectionCondition(ConditionQuery conditionQuery) { + Set conditions = conditionQuery.conditions(); + Set newConditions = new HashSet<>(); + for (Condition condition : conditions) { + if (!direction(condition)) { + newConditions.add(condition); + } + } + if (newConditions.size() > 0) { + conditionQuery.resetConditions(newConditions); + return conditionQuery; + } else { + return null; + } + } + + private static boolean direction(Condition condition) { + boolean direction = true; + List relations = condition.relations(); + for (Relation r : relations) { + if (!r.key().equals(HugeKeys.DIRECTION)) { + direction = false; + break; + } + } + return direction; + } + + protected static BackendEntryIterator newEntryIterator( + BackendColumnIterator cols, Query query) { + return new BinaryEntryIterator<>(cols, query, (entry, col) -> { + if (entry == null || !entry.belongToMe(col)) { + HugeType type = query.resultType(); + // NOTE: only support BinaryBackendEntry currently + entry = new BinaryBackendEntry(type, col.name); + } + entry.columns(col); + return entry; + }); + } + + protected static BackendEntryIterator newEntryIteratorOlap( + BackendColumnIterator cols, Query query, boolean isOlap) { + return new BinaryEntryIterator<>(cols, query, (entry, col) -> { + if (entry == null || !entry.belongToMe(col)) { + HugeType type = query.resultType(); + // NOTE: only support BinaryBackendEntry currently + entry = new BinaryBackendEntry(type, col.name, isOlap); + } + entry.columns(col); + return entry; + }); + } + + public static String bytes2String(byte[] bytes) { + StringBuilder result = new StringBuilder(); + for (byte b : bytes) { + String st = String.format("%02x", b); + result.append(st); + } + return result.toString(); + } + + @Override + protected void registerMetaHandlers() { + this.registerMetaHandler("splits", (session, meta, args) -> { + E.checkArgument(args.length == 1, + "The args count of %s must be 1", meta); + long splitSize = (long) args[0]; + return this.shardSpliter.getSplits(session, splitSize); + }); + } + + @Override + public void init(Session session) { + // pass + } + + @Override + public void clear(Session session) { + // pass + } + + public boolean isOlap() { + return false; + } + + private byte[] getOwner(BackendEntry entry) { + if (entry == null) { + return HgStoreClientConst.ALL_PARTITION_OWNER; + } + Id id = entry.type().isIndex() ? entry.id() : entry.originId(); + return getOwnerId(id); + } + // protected byte[] getInsertOwnerId(BackendEntry entry) { + // BinaryBackendEntry.BinaryId currentId = (BinaryBackendEntry.BinaryId) entry.id(); + // Id origin = currentId.origin(); + // if (origin.edge()) { + // origin = ((EdgeId) origin).ownerVertexId(); + // return origin.asBytes(); + // } else { + // return currentId.asBytes(); + // } + // } + + public Supplier getOwnerScanDelegate() { + return ownerScanDelegate; + } + + public byte[] getInsertEdgeOwner(BackendEntry entry) { + Id id = entry.originId(); + id = ((EdgeId) id).ownerVertexId(); + return id.asBytes(); + } + + public byte[] getInsertOwner(BackendEntry entry) { + // 为适应label索引散列，不聚焦在一个分区 + if (entry.type().isLabelIndex() && (entry.columns().size() == 1)) { + Iterator iterator = entry.columns().iterator(); + while (iterator.hasNext()) { + BackendColumn next = iterator.next(); + return next.name; + } + } + + Id id = entry.type().isIndex() ? entry.id() : entry.originId(); + return getOwnerId(id); + } + + /** + * 返回Id所属的点ID + * + * @param id + * @return + */ + protected byte[] getOwnerId(Id id) { + if (id instanceof BinaryBackendEntry.BinaryId) { + id = ((BinaryBackendEntry.BinaryId) id).origin(); + } + if (id != null && id.edge()) { + id = ((EdgeId) id).ownerVertexId(); + } + return id != null ? id.asBytes() : + HgStoreClientConst.ALL_PARTITION_OWNER; + } + + /** + * 返回Id所属的点ID + * + * @param id + * @return + */ + protected byte[] getOwnerId(HugeType type, Id id) { + if (type.equals(HugeType.VERTEX) || type.equals(HugeType.EDGE) || + type.equals(HugeType.EDGE_OUT) || type.equals(HugeType.EDGE_IN) || + type.equals(HugeType.COUNTER)) { + return getOwnerId(id); + } else { + return HgStoreClientConst.ALL_PARTITION_OWNER; + } + } + + @Override + public void insert(Session session, BackendEntry entry) { + byte[] owner = entry.type().isEdge() ? getInsertEdgeOwner(entry) : getInsertOwner(entry); + ArrayList columns = (ArrayList) entry.realColumns(); + for (int i = 0; i < columns.size(); i++) { + BackendColumn col = columns.get(i); + session.put(this.table(), owner, col.name, col.value); + } + } + + @Override + public void insert(Session session, BackendEntry entry, boolean isEdge) { + byte[] owner = isEdge ? getInsertEdgeOwner(entry) : getInsertOwner(entry); + ArrayList columns = (ArrayList) entry.realColumns(); + for (int i = 0; i < columns.size(); i++) { + BackendColumn col = columns.get(i); + session.put(this.table(), owner, col.name, col.value); + } + } + + @Override + public void delete(Session session, BackendEntry entry) { + byte[] ownerKey = ownerDelegate.apply(entry); + if (entry.columns().isEmpty()) { + byte[] idBytes = entry.id().asBytes(); + // LOG.debug("Delete from {} with owner {}, id: {}", + // this.table(), bytes2String(ownerKey), idBytes); + session.delete(this.table(), ownerKey, idBytes); + } else { + for (BackendColumn col : entry.columns()) { + // LOG.debug("Delete from {} with owner {}, id: {}", + // this.table(), bytes2String(ownerKey), + // bytes2String(col.name)); + assert entry.belongToMe(col) : entry; + session.delete(this.table(), ownerKey, col.name); + } + } + } + + @Override + public void append(Session session, BackendEntry entry) { + assert entry.columns().size() == 1; + this.insert(session, entry); + } + + @Override + public void eliminate(Session session, BackendEntry entry) { + assert entry.columns().size() == 1; + this.delete(session, entry); + } + + @Override + public boolean queryExist(Session session, BackendEntry entry) { + Id id = entry.id(); + try (BackendColumnIterator iter = this.queryById(session, id)) { + return iter.hasNext(); + } + } + + @Override + public Number queryNumber(Session session, Query query) { + Aggregate aggregate = query.aggregateNotNull(); + if (aggregate.func() != AggregateFunc.COUNT) { + throw new NotSupportException(aggregate.toString()); + } + + assert aggregate.func() == AggregateFunc.COUNT; + assert query.noLimit(); + Iterator results = this.queryBy(session, query); + if (results instanceof Countable) { + return ((Countable) results).count(); + } + return IteratorUtils.count(results); + } + + @Override + public Iterator query(Session session, Query query) { + if (query.limit() == 0L && !query.noLimit()) { + // LOG.debug("Return empty result(limit=0) for query {}", query); + return Collections.emptyIterator(); + } + return newEntryIterator(this.queryBy(session, query), query); + } + + @Override + public Iterator queryOlap(Session session, Query query) { + if (query.limit() == 0L && !query.noLimit()) { + // LOG.debug("Return empty result(limit=0) for query {}", query); + return Collections.emptyIterator(); + } + return newEntryIteratorOlap(this.queryBy(session, query), query, true); + } + + public List> query(Session session, + List queries, + String tableName) { + List queryByPrefixList = + this.queryByPrefixList(session, queries, tableName); + LinkedList> iterators = new LinkedList<>(); + for (int i = 0; i < queryByPrefixList.size(); i++) { + IdPrefixQuery q = queries.get(i).copy(); + q.capacity(Query.NO_CAPACITY); + q.limit(Query.NO_LIMIT); + BackendEntryIterator iterator = + newEntryIterator(queryByPrefixList.get(i), q); + iterators.add(iterator); + } + return iterators; + } + + public BackendEntry.BackendIterator> query(Session session, + Iterator queries, + String tableName) { + final IdPrefixQuery[] first = {queries.next()}; + int type = first[0].withProperties() ? 0 : Session.SCAN_KEY_ONLY; + + IdPrefixQuery queryTmpl = first[0].copy(); + queryTmpl.capacity(Query.NO_CAPACITY); + queryTmpl.limit(Query.NO_LIMIT); + + ConditionQuery originQuery = (ConditionQuery) first[0].originQuery(); + if (originQuery != null) { + originQuery = prepareConditionQueryList(originQuery); + } + byte[] queryBytes = originQuery == null ? null : originQuery.bytes(); + + BackendEntry.BackendIterator it + = session.scan(tableName, new Iterator() { + @Override + public boolean hasNext() { + if (first[0] != null) { + return true; + } + return queries.hasNext(); + } + + @Override + public HgOwnerKey next() { + IdPrefixQuery query = first[0] != null ? first[0] : queries.next(); + first[0] = null; + byte[] prefix = ownerByQueryDelegate.apply(query.resultType(), + query.prefix()); + return HgOwnerKey.of(prefix, query.prefix().asBytes()); + } + }, type, first[0], queryBytes); + return new BackendEntry.BackendIterator<>() { + @Override + public boolean hasNext() { + return it.hasNext(); + } + + @Override + public Iterator next() { + BackendEntryIterator iterator = newEntryIterator(it.next(), queryTmpl); + return iterator; + } + + @Override + public void close() { + it.close(); + } + + @Override + public byte[] position() { + return new byte[0]; + } + }; + } + + protected BackendColumnIterator queryBy(Session session, Query query) { + // Query all + if (query.empty()) { + return this.queryAll(session, query); + } + + // Query by prefix + if (query instanceof IdPrefixQuery) { + IdPrefixQuery pq = (IdPrefixQuery) query; + return this.queryByPrefix(session, pq); + } + + // Query by range + if (query instanceof IdRangeQuery) { + IdRangeQuery rq = (IdRangeQuery) query; + return this.queryByRange(session, rq); + } + + // Query by id + if (query.conditions().isEmpty()) { + assert !query.ids().isEmpty(); + // 单个id查询 走get接口查询 + if (query.ids().size() == 1) { + return this.getById(session, query.ids().iterator().next()); + } + // NOTE: this will lead to lazy create rocksdb iterator + LinkedList hgOwnerKeys = new LinkedList<>(); + for (Id id : query.ids()) { + hgOwnerKeys.add(HgOwnerKey.of(this.ownerByIdDelegate.apply(id), + id.asBytes())); + } + BackendColumnIterator withBatch = session.getWithBatch(this.table(), + hgOwnerKeys); + return new BackendColumnIteratorWrapper(withBatch); + } + + // Query by condition (or condition + id) + ConditionQuery cq = (ConditionQuery) query; + return this.queryByCond(session, cq); + } + + protected BackendColumnIterator queryAll(Session session, Query query) { + if (query.paging()) { + PageState page = PageState.fromString(query.page()); + byte[] ownerKey = this.getOwnerScanDelegate().get(); + int scanType = Session.SCAN_ANY | + (query.withProperties() ? 0 : Session.SCAN_KEY_ONLY); + byte[] queryBytes = query instanceof ConditionQuery ? + ((ConditionQuery) query).bytes() : null; + // LOG.debug("query {} with ownerKeyFrom: {}, ownerKeyTo: {}, " + + // "keyFrom: null, keyTo: null, scanType: {}, " + + // "conditionQuery: {}, position: {}", + // this.table(), bytes2String(ownerKey), + // bytes2String(ownerKey), scanType, + // queryBytes, page.position()); + return session.scan(this.table(), ownerKey, ownerKey, null, + null, scanType, queryBytes, + page.position()); + } + return session.scan(this.table(), + query instanceof ConditionQuery ? + ((ConditionQuery) query).bytes() : null); + } + + protected BackendColumnIterator queryById(Session session, Id id) { + // TODO: change to get() after vertex and schema don't use id prefix + return session.scan(this.table(), this.ownerByIdDelegate.apply(id), + id.asBytes()); + } + + protected BackendColumnIterator getById(Session session, Id id) { + byte[] value = session.get(this.table(), + this.ownerByIdDelegate.apply(id), + id.asBytes()); + if (value.length == 0) { + return BackendColumnIterator.empty(); + } + BackendColumn col = BackendColumn.of(id.asBytes(), value); + return new BackendEntry.BackendColumnIteratorWrapper(col); + } + + protected BackendColumnIterator queryByPrefix(Session session, + IdPrefixQuery query) { + int type = query.inclusiveStart() ? + Session.SCAN_GTE_BEGIN : Session.SCAN_GT_BEGIN; + type |= Session.SCAN_PREFIX_END; + byte[] position = null; + if (query.paging()) { + position = PageState.fromString(query.page()).position(); + } + ConditionQuery originQuery = (ConditionQuery) query.originQuery(); + if (originQuery != null) { + originQuery = prepareConditionQuery(originQuery); + } + byte[] ownerKeyFrom = this.ownerByQueryDelegate.apply(query.resultType(), + query.start()); + byte[] ownerKeyTo = this.ownerByQueryDelegate.apply(query.resultType(), + query.prefix()); + byte[] keyFrom = query.start().asBytes(); + // 前缀分页查询中, start为最初的位置。因为在不同的分区 都是从start位置开始查询 + if (query.paging()) { + keyFrom = query.prefix().asBytes(); + } + byte[] keyTo = query.prefix().asBytes(); + byte[] queryBytes = originQuery == null ? + null : + originQuery.bytes(); + + // LOG.debug("query {} with ownerKeyFrom: {}, ownerKeyTo: {}," + + // "keyFrom: {}, keyTo: {}, scanType: {}, conditionQuery: {}," + + // "position: {}", + // this.table(), bytes2String(ownerKeyFrom), + // bytes2String(ownerKeyTo), bytes2String(keyFrom), + // bytes2String(keyTo), type, originQuery, position); + + return session.scan(this.table(), ownerKeyFrom, ownerKeyTo, keyFrom, + keyTo, type, queryBytes, position); + } + + protected List queryByPrefixList( + Session session, + List queries, + String tableName) { + E.checkArgument(queries.size() > 0, + "The size of queries must be greater than zero"); + IdPrefixQuery query = queries.get(0); + int type = 0; + LinkedList ownerKey = new LinkedList<>(); + queries.forEach((item) -> { + byte[] prefix = this.ownerByQueryDelegate.apply(item.resultType(), + item.prefix()); + ownerKey.add(HgOwnerKey.of(prefix, item.prefix().asBytes())); + }); + ConditionQuery originQuery = (ConditionQuery) query.originQuery(); + if (originQuery != null) { + originQuery = prepareConditionQueryList(originQuery); + } + byte[] queryBytes = originQuery == null ? null : originQuery.bytes(); + + // LOG.debug("query {} with scanType: {}, limit: {}, conditionQuery: + // {}", this.table(), type, query.limit(), queryBytes); + return session.scan(tableName, ownerKey, type, + query.limit(), queryBytes); + } + + /*** + * Prepare ConditionQuery to do operator sinking, because some scenes do not need to be + * preserved + * @param conditionQuery + * @return + */ + private ConditionQuery prepareConditionQuery(ConditionQuery conditionQuery) { + if (CollectionUtils.isEmpty(conditionQuery.userpropConditions())) { + return null; + } + // only userpropConditions can send to store + Set conditions = conditionQuery.conditions(); + Set newConditions = new HashSet<>(); + for (Condition condition : conditions) { + if (!onlyOwnerVertex(condition)) { + newConditions.add(condition); + } + } + if (newConditions.size() > 0) { + conditionQuery.resetConditions(newConditions); + return conditionQuery; + } else { + return null; + } + } + + /*** + * Prepare ConditionQuery to do operator sinking, because some scenes do not need to be + * preserved + * @param conditionQuery + * @return + */ + private ConditionQuery prepareConditionQueryList(ConditionQuery conditionQuery) { + if (!conditionQuery.containsLabelOrUserpropRelation()) { + return null; + } + // only userpropConditions can send to store + Set conditions = conditionQuery.conditions(); + Set newConditions = new HashSet<>(); + for (Condition condition : conditions) { + if (!onlyOwnerVertex(condition)) { + newConditions.add(condition); + } + } + if (newConditions.size() > 0) { + conditionQuery.resetConditions(newConditions); + return conditionQuery; + } else { + return null; + } + } + + private boolean onlyOwnerVertex(Condition condition) { + boolean onlyOwnerVertex = true; + List relations = condition.relations(); + for (Relation r : relations) { + if (!r.key().equals(HugeKeys.OWNER_VERTEX)) { + onlyOwnerVertex = false; + break; + } + } + return onlyOwnerVertex; + } + + protected BackendColumnIterator queryByRange(Session session, + IdRangeQuery query) { + byte[] start = query.start().asBytes(); + byte[] end = query.end() == null ? null : query.end().asBytes(); + int type = query.inclusiveStart() ? + Session.SCAN_GTE_BEGIN : Session.SCAN_GT_BEGIN; + if (end != null) { + type |= query.inclusiveEnd() ? + Session.SCAN_LTE_END : Session.SCAN_LT_END; + } + ConditionQuery cq; + Query origin = query.originQuery(); + byte[] position = null; + if (query.paging() && !query.page().isEmpty()) { + position = PageState.fromString(query.page()).position(); + } + byte[] ownerStart = this.ownerByQueryDelegate.apply(query.resultType(), + query.start()); + byte[] ownerEnd = this.ownerByQueryDelegate.apply(query.resultType(), + query.end()); + if (origin instanceof ConditionQuery && + (query.resultType().isEdge() || query.resultType().isVertex())) { + cq = (ConditionQuery) query.originQuery(); + + // LOG.debug("query {} with ownerKeyFrom: {}, ownerKeyTo: {}, " + + // "keyFrom: {}, keyTo: {}, " + + // "scanType: {}, conditionQuery: {}", + // this.table(), bytes2String(ownerStart), + // bytes2String(ownerEnd), bytes2String(start), + // bytes2String(end), type, cq.bytes()); + return session.scan(this.table(), ownerStart, + ownerEnd, start, end, type, cq.bytes(), position); + } + return session.scan(this.table(), ownerStart, + ownerEnd, start, end, type, null, position); + } + + protected BackendColumnIterator queryByCond(Session session, + ConditionQuery query) { + if (query.containsScanCondition()) { + E.checkArgument(query.relations().size() == 1, + "Invalid scan with multi conditions: %s", query); + Relation scan = query.relations().iterator().next(); + Shard shard = (Shard) scan.value(); + return this.queryByRange(session, shard, query); + } + // throw new NotSupportException("query: %s", query); + return this.queryAll(session, query); + } + + protected BackendColumnIterator queryByRange(Session session, Shard shard, + ConditionQuery query) { + int type = Session.SCAN_GTE_BEGIN; + type |= Session.SCAN_LT_END; + type |= Session.SCAN_HASHCODE; + type |= query.withProperties() ? 0 : Session.SCAN_KEY_ONLY; + + int start = Integer.parseInt(StringUtils.isEmpty(shard.start()) ? + "0" : shard.start()); + int end = Integer.parseInt(StringUtils.isEmpty(shard.end()) ? + "0" : shard.end()); + byte[] queryBytes = query.bytes(); + String page = query.page(); + if (page != null && !page.isEmpty()) { + byte[] position = PageState.fromString(page).position(); + return session.scan(this.table(), start, end, type, queryBytes, + position); + } + return session.scan(this.table(), start, end, type, queryBytes); + } + + private static class HstoreShardSpliter extends ShardSpliter { + + public HstoreShardSpliter(String table) { + super(table); + } + + @Override + public List getSplits(Session session, long splitSize) { + E.checkArgument(splitSize >= MIN_SHARD_SIZE, + "The split-size must be >= %s bytes, but got %s", + MIN_SHARD_SIZE, splitSize); + + List splits = new ArrayList<>(); + try { + PDClient pdClient = HstoreSessionsImpl.getDefaultPdClient(); + List partitions = pdClient.getPartitions(0, + session.getGraphName()); + for (Metapb.Partition partition : partitions) { + String start = String.valueOf(partition.getStartKey()); + String end = String.valueOf(partition.getEndKey()); + splits.add(new Shard(start, end, 0)); + } + } catch (PDException e) { + e.printStackTrace(); + } + + return splits.size() != 0 ? + splits : super.getSplits(session, splitSize); + } + + @Override + public long estimateDataSize(Session session) { + return 1L; + } + + @Override + public long estimateNumKeys(Session session) { + return 1L; + } + + @Override + public byte[] position(String position) { + if (END.equals(position)) { + return null; + } + return StringEncoding.decodeBase64(position); + } + } +} diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTables.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTables.java new file mode 100644 index 0000000000..ab9482938d --- /dev/null +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTables.java @@ -0,0 +1,201 @@ +/* + * 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.hugegraph.backend.store.hstore; + +import java.util.List; + +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.query.Condition; +import org.apache.hugegraph.backend.query.Condition.Relation; +import org.apache.hugegraph.backend.query.ConditionQuery; +import org.apache.hugegraph.backend.serializer.BinarySerializer; +import org.apache.hugegraph.backend.store.BackendEntry; +import org.apache.hugegraph.backend.store.BackendEntry.BackendColumnIterator; +import org.apache.hugegraph.backend.store.hstore.HstoreSessions.Session; +import org.apache.hugegraph.type.HugeTableType; +import org.apache.hugegraph.type.HugeType; +import org.apache.hugegraph.type.define.HugeKeys; +import org.apache.hugegraph.util.E; + +public class HstoreTables { + + public static class Vertex extends HstoreTable { + + public static final String TABLE = HugeTableType.VERTEX.string(); + + public Vertex(String database) { + super(database, TABLE); + } + + @Override + protected BackendColumnIterator queryById(Session session, Id id) { + return this.getById(session, id); + } + } + + /** + * task信息存储表 + */ + public static class TaskInfo extends HstoreTable { + public static final String TABLE = HugeTableType.TASK_INFO_TABLE.string(); + + public TaskInfo(String database) { + super(database, TABLE); + } + + @Override + protected BackendColumnIterator queryById(Session session, Id id) { + return this.getById(session, id); + } + } + + public static class Edge extends HstoreTable { + + public static final String TABLE_SUFFIX = HugeType.EDGE.string(); + + public Edge(boolean out, String database) { + // Edge out/in table + super(database, (out ? HugeTableType.OUT_EDGE.string() : + HugeTableType.IN_EDGE.string())); + } + + public static Edge out(String database) { + return new Edge(true, database); + } + + public static Edge in(String database) { + return new Edge(false, database); + } + + @Override + protected BackendColumnIterator queryById(Session session, Id id) { + return this.getById(session, id); + } + } + + public static class IndexTable extends HstoreTable { + + public static final String TABLE = HugeTableType.ALL_INDEX_TABLE.string(); + + public IndexTable(String database) { + super(database, TABLE); + } + + @Override + public void eliminate(Session session, BackendEntry entry) { + assert entry.columns().size() == 1; + super.delete(session, entry); + } + + @Override + public void delete(Session session, BackendEntry entry) { + /* + * Only delete index by label will come here + * Regular index delete will call eliminate() + */ + byte[] ownerKey = super.ownerDelegate.apply(entry); + for (BackendEntry.BackendColumn column : entry.columns()) { + // Don't assert entry.belongToMe(column), length-prefix is 1* + session.deletePrefix(this.table(), ownerKey, column.name); + } + } + + /** + * 主要用于 range类型的index处理 + * + * @param session + * @param query + * @return + */ + @Override + protected BackendColumnIterator queryByCond(Session session, + ConditionQuery query) { + assert !query.conditions().isEmpty(); + + List conds = query.syspropConditions(HugeKeys.ID); + E.checkArgument(!conds.isEmpty(), + "Please specify the index conditions"); + + Id prefix = null; + Id min = null; + boolean minEq = false; + Id max = null; + boolean maxEq = false; + + for (Condition c : conds) { + Relation r = (Relation) c; + switch (r.relation()) { + case PREFIX: + prefix = (Id) r.value(); + break; + case GTE: + minEq = true; + case GT: + min = (Id) r.value(); + break; + case LTE: + maxEq = true; + case LT: + max = (Id) r.value(); + break; + default: + E.checkArgument(false, "Unsupported relation '%s'", + r.relation()); + } + } + + E.checkArgumentNotNull(min, "Range index begin key is missing"); + byte[] begin = min.asBytes(); + if (!minEq) { + begin = BinarySerializer.increaseOne(begin); + } + byte[] ownerStart = this.ownerScanDelegate.get(); + byte[] ownerEnd = this.ownerScanDelegate.get(); + if (max == null) { + E.checkArgumentNotNull(prefix, "Range index prefix is missing"); + return session.scan(this.table(), ownerStart, ownerEnd, begin, + prefix.asBytes(), Session.SCAN_PREFIX_END); + } else { + byte[] end = max.asBytes(); + int type = maxEq ? Session.SCAN_LTE_END : Session.SCAN_LT_END; + return session.scan(this.table(), ownerStart, + ownerEnd, begin, end, type); + } + } + } + + public static class OlapTable extends HstoreTable { + + public static final String TABLE = HugeTableType.OLAP_TABLE.string(); + + public OlapTable(String database) { + // 由原先多个ap_{pk_id} 合并成一个ap表 + super(database, TABLE); + } + + @Override + protected BackendColumnIterator queryById(Session session, Id id) { + return this.getById(session, id); + } + + @Override + public boolean isOlap() { + return true; + } + } +} diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/IdClient.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/IdClient.java new file mode 100644 index 0000000000..582e7da678 --- /dev/null +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/IdClient.java @@ -0,0 +1,58 @@ +/* + * 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.hugegraph.backend.store.hstore.fake; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +import org.apache.hugegraph.backend.store.hstore.HstoreSessions; +import org.apache.hugegraph.pd.grpc.Pdpb; + +/** + * @author zhangyingjie + * @date 2022/1/17 + **/ +public abstract class IdClient { + + protected HstoreSessions.Session session; + protected String table; + + public IdClient(HstoreSessions.Session session, String table) { + this.session = session; + this.table = table; + } + + protected static byte[] b(long value) { + return ByteBuffer.allocate(Long.BYTES).order( + ByteOrder.nativeOrder()).putLong(value).array(); + } + + protected static long l(byte[] bytes) { + assert bytes.length == Long.BYTES; + return ByteBuffer.wrap(bytes).order( + ByteOrder.nativeOrder()).getLong(); + } + + public abstract Pdpb.GetIdResponse getIdByKey(String key, int delta) + throws Exception; + + public abstract Pdpb.ResetIdResponse resetIdByKey(String key) throws Exception; + + public abstract void increaseId(String key, long increment) + throws Exception; +} diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/PDIdClient.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/PDIdClient.java new file mode 100644 index 0000000000..2a8806a770 --- /dev/null +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/PDIdClient.java @@ -0,0 +1,52 @@ +/* + * 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.hugegraph.backend.store.hstore.fake; + +import org.apache.hugegraph.backend.store.hstore.HstoreSessions; +import org.apache.hugegraph.backend.store.hstore.HstoreSessionsImpl; +import org.apache.hugegraph.pd.client.PDClient; +import org.apache.hugegraph.pd.grpc.Pdpb; + +/** + * @author zhangyingjie + * @date 2022/1/17 + **/ +public class PDIdClient extends IdClient { + + PDClient pdClient; + + public PDIdClient(HstoreSessions.Session session, String table) { + super(session, table); + pdClient = HstoreSessionsImpl.getDefaultPdClient(); + } + + @Override + public Pdpb.GetIdResponse getIdByKey(String key, int delta) throws Exception { + return pdClient.getIdByKey(key, delta); + } + + @Override + public Pdpb.ResetIdResponse resetIdByKey(String key) throws Exception { + return pdClient.resetIdByKey(key); + } + + @Override + public void increaseId(String key, long increment) throws Exception { + pdClient.getIdByKey(key, (int) increment); + } +} From 5ada15982dfc8da86f464d0413357c440f4ffc2f Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Fri, 18 Aug 2023 01:29:24 +0800 Subject: [PATCH 02/26] chore: simple adapt --- hugegraph-server/hugegraph-core/pom.xml | 5 + .../hugegraph/backend/id/IdGenerator.java | 2 +- .../hugegraph/backend/query/Condition.java | 4 + .../backend/query/ConditionQuery.java | 16 + .../serializer/AbstractSerializerAdapter.java | 65 +++ .../query/serializer/QueryAdapter.java | 150 +++++++ .../query/serializer/QueryIdAdapter.java | 48 +++ .../serializer/BinaryBackendEntry.java | 2 +- .../backend/store/BackendMutation.java | 4 + .../apache/hugegraph/type/HugeTableType.java | 63 +++ .../org/apache/hugegraph/type/HugeType.java | 4 + .../backend/store/hstore/HstoreFeatures.java | 9 +- .../backend/store/hstore/HstoreProvider.java | 33 +- .../store/hstore/HstoreSessionsImpl.java | 174 ++++---- .../backend/store/hstore/HstoreStore.java | 393 +++++++++--------- .../backend/store/hstore/HstoreTable.java | 314 +++++++------- .../backend/store/hstore/HstoreTables.java | 2 +- hugegraph-server/pom.xml | 1 + pom.xml | 2 +- 19 files changed, 811 insertions(+), 480 deletions(-) create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/AbstractSerializerAdapter.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryAdapter.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryIdAdapter.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeTableType.java diff --git a/hugegraph-server/hugegraph-core/pom.xml b/hugegraph-server/hugegraph-core/pom.xml index de312c9378..1c954e16f1 100644 --- a/hugegraph-server/hugegraph-core/pom.xml +++ b/hugegraph-server/hugegraph-core/pom.xml @@ -236,6 +236,11 @@ ${jjwt.version} runtime + + com.google.code.gson + gson + 2.8.9 + diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/id/IdGenerator.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/id/IdGenerator.java index c6f77a0f2b..977e26bb82 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/id/IdGenerator.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/id/IdGenerator.java @@ -379,7 +379,7 @@ public String toString() { /** * This class is just used by backend store for wrapper object as Id */ - private static final class ObjectId implements Id { + public static final class ObjectId implements Id { private final Object object; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java index 27fc822f30..b56cf1c702 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java @@ -565,6 +565,10 @@ public Object value() { return this.value; } + public void value(Object value) { + this.value = value; + } + public void serialKey(Object key) { this.serialKey = key; } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java index 8de686746d..7fe6b33442 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java @@ -18,6 +18,7 @@ package org.apache.hugegraph.backend.query; import java.math.BigDecimal; +import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; @@ -34,6 +35,8 @@ import org.apache.hugegraph.backend.id.SplicingIdGenerator; import org.apache.hugegraph.backend.query.Condition.Relation; import org.apache.hugegraph.backend.query.Condition.RelationType; +import org.apache.hugegraph.backend.query.serializer.QueryAdapter; +import org.apache.hugegraph.backend.query.serializer.QueryIdAdapter; import org.apache.hugegraph.perf.PerfUtil.Watched; import org.apache.hugegraph.structure.HugeElement; import org.apache.hugegraph.structure.HugeProperty; @@ -44,9 +47,12 @@ import org.apache.hugegraph.util.InsertionOrderUtil; import org.apache.hugegraph.util.LongEncoding; import org.apache.hugegraph.util.NumericUtil; + import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; public class ConditionQuery extends IdQuery { @@ -870,4 +876,14 @@ public interface ResultsFilter { boolean test(HugeElement element); } + + public byte[] bytes() { + Gson gson = new GsonBuilder() + .registerTypeAdapter(Condition.class, new QueryAdapter()) + .registerTypeAdapter(Id.class, new QueryIdAdapter()) + .setDateFormat("yyyy-MM-dd HH:mm:ss.SSS") + .create(); + String cqs = gson.toJson(this); + return cqs.getBytes(StandardCharsets.UTF_8); + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/AbstractSerializerAdapter.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/AbstractSerializerAdapter.java new file mode 100644 index 0000000000..1a1f8ecba3 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/AbstractSerializerAdapter.java @@ -0,0 +1,65 @@ +/* + * 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.hugegraph.backend.query.serializer; + +import java.lang.reflect.Type; +import java.util.Map; + +import org.apache.hugegraph.backend.BackendException; + +import com.google.gson.JsonDeserializationContext; +import com.google.gson.JsonDeserializer; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParseException; +import com.google.gson.JsonPrimitive; +import com.google.gson.JsonSerializationContext; +import com.google.gson.JsonSerializer; + +public abstract class AbstractSerializerAdapter implements JsonSerializer, + JsonDeserializer { + + //Note: By overriding the method to get the mapping + public abstract Map validType(); + + @Override + public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws + JsonParseException { + JsonObject object = json.getAsJsonObject(); + String type = object.get("cls").getAsString(); + JsonElement element = object.get("el"); + try { + return context.deserialize(element, validType().get(type)); + } catch (Exception e) { + throw new BackendException("Unknown element type: " + type, e); + } + } + + /* + * Note: Currently, only the first character of the class name is taken as the key + * to reduce serialization results + * */ + @Override + public JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context) { + JsonObject result = new JsonObject(); + Class clazz = src.getClass(); + result.add("cls", new JsonPrimitive(clazz.getSimpleName().substring(0, 1).toUpperCase())); + result.add("el", context.serialize(src, clazz)); + return result; + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryAdapter.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryAdapter.java new file mode 100644 index 0000000000..afe00e32d7 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryAdapter.java @@ -0,0 +1,150 @@ +/* + * 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.hugegraph.backend.query.serializer; + +import java.lang.reflect.Type; +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.hugegraph.backend.query.Condition; +import org.apache.hugegraph.type.define.Directions; + +import com.google.gson.JsonDeserializationContext; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParseException; +import com.google.gson.JsonPrimitive; +import com.google.gson.JsonSerializationContext; +import com.google.gson.reflect.TypeToken; + +public class QueryAdapter extends AbstractSerializerAdapter { + + static HashMap cls; + + static { + cls = new HashMap() {{ + //put("N", Condition.Not.class); + put("A", Condition.And.class); + put("O", Condition.Or.class); + put("S", Condition.SyspropRelation.class); + put("U", Condition.UserpropRelation.class); + }}; + } + + static boolean isPrimitive(Class clz) { + try { + return (clz == Date.class) || ((Class) clz.getField("TYPE").get(null)).isPrimitive(); + } catch (Exception e) { + return false; + } + } + + @Override + public Map validType() { + return cls; + } + + @Override + public Condition deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) + throws JsonParseException { + Condition condition = super.deserialize(json, typeOfT, context); + if (condition instanceof Condition.Relation) { + JsonObject object = json.getAsJsonObject(); + if (object.has("el")) { + JsonElement elElement = object.get("el"); + JsonElement valueElement = elElement.getAsJsonObject().get("value"); + if (valueElement.isJsonObject()) { + String cls = valueElement.getAsJsonObject().get("cls").getAsString(); + try { + Class actualClass = Class.forName(cls); + Object obj = context.deserialize(valueElement, actualClass); + ((Condition.Relation) condition).value(obj); + } catch (ClassNotFoundException e) { + throw new JsonParseException(e.getMessage()); + } + } else if (elElement.getAsJsonObject().has("valuecls")) { + if (valueElement.isJsonArray()) { + String cls = elElement.getAsJsonObject().get("valuecls").getAsString(); + try { + Class actualClass = Class.forName(cls); + Type type = TypeToken.getParameterized(ArrayList.class, actualClass) + .getType(); + Object value = context.deserialize(valueElement, type); + ((Condition.Relation) condition).value(value); + } catch (ClassNotFoundException e) { + throw new JsonParseException(e.getMessage()); + } + } else { + String cls = elElement.getAsJsonObject().get("valuecls").getAsString(); + try { + Class actualClass = Class.forName(cls); + Object obj = context.deserialize(valueElement, actualClass); + ((Condition.Relation) condition).value(obj); + } catch (ClassNotFoundException e) { + throw new JsonParseException(e.getMessage()); + } + } + + } else if (valueElement.isJsonPrimitive() && + valueElement.getAsJsonPrimitive().isString()) { + switch ((String) ((Condition.Relation) condition).value()) { + case "OUT": + ((Condition.Relation) condition).value(Directions.OUT); + break; + case "IN": + ((Condition.Relation) condition).value(Directions.IN); + break; + default: + break; + } + } + } + } + return condition; + } + + @Override + public JsonElement serialize(Condition src, Type typeOfSrc, JsonSerializationContext context) { + JsonElement result = super.serialize(src, typeOfSrc, context); + if (src instanceof Condition.Relation) { + JsonObject object = result.getAsJsonObject(); + JsonElement valueElement = object.get("el").getAsJsonObject().get("value"); + if (valueElement.isJsonObject()) { + valueElement.getAsJsonObject() + .add("cls", + new JsonPrimitive( + ((Condition.Relation) src).value().getClass().getName())); + } else if (isPrimitive(((Condition.Relation) src).value().getClass())) { + object.get("el").getAsJsonObject() + .add("valuecls", + new JsonPrimitive( + ((Condition.Relation) src).value().getClass().getName())); + } else if (valueElement.isJsonArray()) { + if (((Condition.Relation) src).value() instanceof List) { + String valueCls = + ((List) ((Condition.Relation) src).value()).get(0).getClass().getName(); + object.get("el").getAsJsonObject().add("valuecls", new JsonPrimitive(valueCls)); + } + } + } + return result; + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryIdAdapter.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryIdAdapter.java new file mode 100644 index 0000000000..64e7e1a09f --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryIdAdapter.java @@ -0,0 +1,48 @@ +/* + * 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.hugegraph.backend.query.serializer; + +import java.lang.reflect.Type; +import java.util.HashMap; +import java.util.Map; + +import org.apache.hugegraph.backend.id.EdgeId; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.serializer.BinaryBackendEntry; + +public class QueryIdAdapter extends AbstractSerializerAdapter { + + static HashMap cls; + + static { + cls = new HashMap() {{ + put("E", EdgeId.class); + put("S", IdGenerator.StringId.class); + put("L", IdGenerator.LongId.class); + put("U", IdGenerator.UuidId.class); + put("O", IdGenerator.ObjectId.class); + put("B", BinaryBackendEntry.BinaryId.class); + }}; + } + + @Override + public Map validType() { + return cls; + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BinaryBackendEntry.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BinaryBackendEntry.java index c801e16a3b..cd786a0162 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BinaryBackendEntry.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BinaryBackendEntry.java @@ -199,7 +199,7 @@ public int hashCode() { return this.id().hashCode() ^ this.columns.size(); } - protected static final class BinaryId implements Id { + public static final class BinaryId implements Id { private final byte[] bytes; private final Id id; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendMutation.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendMutation.java index 8004f987c4..7fb75f5918 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendMutation.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendMutation.java @@ -341,4 +341,8 @@ public void clear() { this.mutations.clear(); } } + + public Map>> mutations() { + return this.updates.mutations; + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeTableType.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeTableType.java new file mode 100644 index 0000000000..97722438a1 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeTableType.java @@ -0,0 +1,63 @@ +/* + * 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.hugegraph.type; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.hugegraph.type.define.SerialEnum; + +public enum HugeTableType implements SerialEnum { + + UNKNOWN(0, "UNKNOWN"), + + /* Schema types */ + VERTEX(1, "V"), // 顶点表 + OUT_EDGE(2, "OE"), // 出边表 + IN_EDGE(3, "IE"), // 入边表 + ALL_INDEX_TABLE(4, "INDEX"), // 索引表 + TASK_INFO_TABLE(5, "TASK"), // 任务信息表 + OLAP_TABLE(6, "OLAP"); // OLAP 表 + + private static final Map ALL_NAME = new HashMap<>(); + + static { + SerialEnum.register(HugeTableType.class); + for (HugeTableType type : values()) { + ALL_NAME.put(type.name, type); + } + } + + private byte type = 0; + private String name; + + HugeTableType(int type, String name) { + assert type < 256; + this.type = (byte) type; + this.name = name; + } + + @Override + public byte code() { + return this.type; + } + + public String string() { + return this.name; + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java index e23642b4ee..388dfccf07 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java @@ -192,4 +192,8 @@ public static HugeType fromString(String type) { public static HugeType fromCode(byte code) { return SerialEnum.fromCode(HugeType.class, code); } + + public boolean isLabelIndex() { + return this == VERTEX_LABEL_INDEX || this == EDGE_LABEL_INDEX; + } } diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreFeatures.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreFeatures.java index 4490690706..3e6c03e0c1 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreFeatures.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreFeatures.java @@ -46,6 +46,11 @@ public boolean supportsQueryByLabel() { return false; } + @Override + public boolean supportsQueryWithInCondition() { + return false; + } + @Override public boolean supportsQueryWithRangeCondition() { return true; @@ -123,8 +128,4 @@ public boolean supportsOlapProperties() { return true; } - @Override - public boolean supportsFilterInStore() { - return true; - } } diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java index e5f2c1e408..0e144c8593 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java @@ -17,12 +17,10 @@ package org.apache.hugegraph.backend.store.hstore; -import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.backend.store.AbstractBackendStoreProvider; import org.apache.hugegraph.backend.store.BackendStore; import org.apache.hugegraph.backend.store.hstore.HstoreStore.HstoreGraphStore; -import org.apache.hugegraph.config.CoreOptions; -import org.apache.hugegraph.util.Events; +import org.apache.hugegraph.config.HugeConfig; public class HstoreProvider extends AbstractBackendStoreProvider { @@ -31,36 +29,27 @@ protected String namespace() { } @Override - protected synchronized BackendStore newSchemaStore(String store) { - return null; + public String type() { + return "hstore"; } @Override - protected BackendStore newGraphStore(String store) { - return new HstoreGraphStore(this, this.namespace(), store); + public String driverVersion() { + return null; } @Override - public void truncateGraph(HugeGraph graph) { - this.checkOpened(); - String g = graph.option(CoreOptions.STORE_GRAPH); - BackendStore store = this.stores.get(g); - store.truncate(); - this.notifyAndWaitEvent(Events.STORE_TRUNCATE); - LOG.debug("Graph '{}' store has been truncated", graph.name()); + protected BackendStore newSchemaStore(HugeConfig config, String store) { + return new HstoreGraphStore(this, this.namespace(), store); } @Override - public String type() { - return "hstore"; + protected BackendStore newGraphStore(HugeConfig config, String store) { + return null; } @Override - public String version() { - /* - * Versions history: - * [1.0] HugeGraph-1328: supports hstore - */ - return "1.11"; + protected BackendStore newSystemStore(HugeConfig config, String store) { + return null; } } diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreSessionsImpl.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreSessionsImpl.java index 123c98acfe..dad89db79c 100755 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreSessionsImpl.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreSessionsImpl.java @@ -29,7 +29,6 @@ import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicInteger; -import org.apache.commons.lang.NotImplementedException; import org.apache.commons.lang3.ArrayUtils; import org.apache.commons.lang3.tuple.Pair; import org.apache.hugegraph.backend.query.Query; @@ -48,9 +47,7 @@ import org.apache.hugegraph.store.HgScanQuery; import org.apache.hugegraph.store.HgStoreClient; import org.apache.hugegraph.store.HgStoreSession; -import org.apache.hugegraph.store.client.grpc.KvCloseableIterator; import org.apache.hugegraph.store.client.util.HgStoreClientConst; -import org.apache.hugegraph.store.grpc.common.ScanOrderType; import org.apache.hugegraph.testutil.Assert; import org.apache.hugegraph.type.define.GraphMode; import org.apache.hugegraph.util.Bytes; @@ -60,7 +57,7 @@ public class HstoreSessionsImpl extends HstoreSessions { private static final Set infoInitializedGraph = - Collections.synchronizedSet(new HashSet<>()); + Collections.synchronizedSet(new HashSet<>()); private static int tableCode = 0; private static volatile Boolean initializedNode = Boolean.FALSE; private static volatile PDClient defaultPdClient; @@ -103,11 +100,11 @@ private void initStoreNode(HugeConfig config) { synchronized (this) { if (!initializedNode) { PDConfig pdConfig = - PDConfig.of(config.get(HstoreOptions.PD_PEERS)) - .setEnableCache(true); + PDConfig.of(config.get(HstoreOptions.PD_PEERS)) + .setEnableCache(true); defaultPdClient = PDClient.create(pdConfig); hgStoreClient = - HgStoreClient.create(defaultPdClient); + HgStoreClient.create(defaultPdClient); initializedNode = Boolean.TRUE; } } @@ -120,15 +117,15 @@ public void open() throws Exception { synchronized (infoInitializedGraph) { if (!infoInitializedGraph.contains(this.graphName)) { Integer partitionCount = - this.config.get(HstoreOptions.PARTITION_COUNT); + this.config.get(HstoreOptions.PARTITION_COUNT); Assert.assertTrue("The value of hstore.partition_count" + " cannot be less than 0.", partitionCount > -1); defaultPdClient.setGraph(Metapb.Graph.newBuilder() .setGraphName( - this.graphName) + this.graphName) .setPartitionCount( - partitionCount) + partitionCount) .build()); infoInitializedGraph.add(this.graphName); } @@ -355,7 +352,7 @@ private boolean filter(byte[] key) { } else { assert this.match(Session.SCAN_ANY) || this.match(Session.SCAN_GT_BEGIN) || this.match( - Session.SCAN_GTE_BEGIN) : "Unknown scan type"; + Session.SCAN_GTE_BEGIN) : "Unknown scan type"; return true; } } @@ -367,8 +364,8 @@ public BackendColumn next() { throw new NoSuchElementException(); } BackendColumn col = - BackendColumn.of(this.iter.key(), - this.iter.value()); + BackendColumn.of(this.iter.key(), + this.iter.value()); if (this.iter.hasNext()) { gotNext = true; this.iter.next(); @@ -553,7 +550,7 @@ public void deleteRange(String table, byte[] ownerKeyFrom, @Override public byte[] get(String table, byte[] key) { return this.graph.get(table, HgOwnerKey.of( - HgStoreClientConst.ALL_PARTITION_OWNER, key)); + HgStoreClientConst.ALL_PARTITION_OWNER, key)); } @Override @@ -578,7 +575,7 @@ public BackendColumnIterator scan(String table, byte[] conditionQueryToByte) { assert !this.hasChanges(); HgKvIterator results = - this.graph.scanIterator(table, conditionQueryToByte); + this.graph.scanIterator(table, conditionQueryToByte); return new ColumnIterator<>(table, results); } @@ -588,8 +585,8 @@ public BackendColumnIterator scan(String table, byte[] ownerKey, assert !this.hasChanges(); HgKvIterator result = this.graph.scanIterator(table, HgOwnerKey.of( - ownerKey, - prefix)); + ownerKey, + prefix)); return new ColumnIterator<>(table, result); } @@ -603,70 +600,71 @@ public List scan(String table, .setQuery(query) .setPerKeyLimit(limit).build(); List> scanIterators = - this.graph.scanBatch(scanQuery); + this.graph.scanBatch(scanQuery); LinkedList columnIterators = - new LinkedList<>(); + new LinkedList<>(); scanIterators.forEach(item -> { columnIterators.add( - new ColumnIterator<>(table, item)); + new ColumnIterator<>(table, item)); }); return columnIterators; } @Override public BackendEntry.BackendIterator scan( - String table, - Iterator keys, - int scanType, Query queryParam, byte[] query) { - ScanOrderType orderType; - switch (queryParam.orderType()) { - case ORDER_NONE: - orderType = ScanOrderType.ORDER_NONE; - break; - case ORDER_WITHIN_VERTEX: - orderType = ScanOrderType.ORDER_WITHIN_VERTEX; - break; - case ORDER_STRICT: - orderType = ScanOrderType.ORDER_STRICT; - break; - default: - throw new RuntimeException("not implement"); - } - HgScanQuery scanQuery = HgScanQuery.prefixIteratorOf(table, keys) - .builder() - .setScanType(scanType) - .setQuery(query) - .setPerKeyMax(queryParam.limit()) - .setOrderType(orderType) - .setOnlyKey( - !queryParam.withProperties()) - .setSkipDegree( - queryParam.skipDegree()) - .build(); - KvCloseableIterator> scanIterators = - this.graph.scanBatch2(scanQuery); - return new BackendEntry.BackendIterator<>() { - @Override - public void close() { - scanIterators.close(); - } - - @Override - public byte[] position() { - throw new NotImplementedException(); - } - - @Override - public boolean hasNext() { - return scanIterators.hasNext(); - } - - @Override - public BackendColumnIterator next() { - return new ColumnIterator(table, - scanIterators.next()); - } - }; + String table, + Iterator keys, + int scanType, Query queryParam, byte[] query) { + //ScanOrderType orderType; + //switch (queryParam.orderType()) { + // case ORDER_NONE: + // orderType = ScanOrderType.ORDER_NONE; + // break; + // case ORDER_WITHIN_VERTEX: + // orderType = ScanOrderType.ORDER_WITHIN_VERTEX; + // break; + // case ORDER_STRICT: + // orderType = ScanOrderType.ORDER_STRICT; + // break; + // default: + // throw new RuntimeException("not implement"); + //} + //HgScanQuery scanQuery = HgScanQuery.prefixIteratorOf(table, keys) + // .builder() + // .setScanType(scanType) + // .setQuery(query) + // .setPerKeyMax(queryParam.limit()) + // .setOrderType(orderType) + // .setOnlyKey( + // !queryParam.withProperties()) + // .setSkipDegree( + // queryParam.skipDegree()) + // .build(); + //KvCloseableIterator> scanIterators = + // this.graph.scanBatch2(scanQuery); + //return new BackendEntry.BackendIterator<>() { + // @Override + // public void close() { + // scanIterators.close(); + // } + // + // @Override + // public byte[] position() { + // throw new NotImplementedException(); + // } + // + // @Override + // public boolean hasNext() { + // return scanIterators.hasNext(); + // } + // + // @Override + // public BackendColumnIterator next() { + // return new ColumnIterator(table, + // scanIterators.next()); + // } + //}; + return null; } @Override @@ -676,10 +674,10 @@ public BackendColumnIterator scan(String table, byte[] ownerKeyFrom, int scanType) { assert !this.hasChanges(); HgKvIterator result = this.graph.scanIterator(table, HgOwnerKey.of( - ownerKeyFrom, keyFrom), + ownerKeyFrom, keyFrom), HgOwnerKey.of( - ownerKeyTo, - keyTo), 0, + ownerKeyTo, + keyTo), 0, scanType, null); return new ColumnIterator<>(table, result, keyFrom, @@ -694,11 +692,11 @@ public BackendColumnIterator scan(String table, byte[] ownerKeyFrom, assert !this.hasChanges(); HgKvIterator result = this.graph.scanIterator(table, HgOwnerKey.of( - ownerKeyFrom, - keyFrom), + ownerKeyFrom, + keyFrom), HgOwnerKey.of( - ownerKeyTo, - keyTo), + ownerKeyTo, + keyTo), 0, scanType, query); @@ -715,11 +713,11 @@ public BackendColumnIterator scan(String table, byte[] ownerKeyFrom, assert !this.hasChanges(); HgKvIterator result = this.graph.scanIterator(table, HgOwnerKey.of( - ownerKeyFrom, - keyFrom), + ownerKeyFrom, + keyFrom), HgOwnerKey.of( - ownerKeyTo, - keyTo), + ownerKeyTo, + keyTo), 0, scanType, query); @@ -734,8 +732,8 @@ public BackendColumnIterator scan(String table, int codeFrom, byte[] query) { assert !this.hasChanges(); HgKvIterator iterator = - this.graph.scanIterator(table, codeFrom, codeTo, 256, - new byte[0]); + this.graph.scanIterator(table, codeFrom, codeTo, 256, + new byte[0]); return new ColumnIterator<>(table, iterator, new byte[0], new byte[0], scanType); } @@ -746,8 +744,8 @@ public BackendColumnIterator scan(String table, int codeFrom, byte[] query, byte[] position) { assert !this.hasChanges(); HgKvIterator iterator = - this.graph.scanIterator(table, codeFrom, codeTo, 256, - new byte[0]); + this.graph.scanIterator(table, codeFrom, codeTo, 256, + new byte[0]); iterator.seek(position); return new ColumnIterator<>(table, iterator, new byte[0], new byte[0], scanType); @@ -758,7 +756,7 @@ public BackendColumnIterator getWithBatch(String table, List keys) { assert !this.hasChanges(); HgKvIterator kvIterator = - this.graph.batchPrefix(table, keys); + this.graph.batchPrefix(table, keys); return new ColumnIterator<>(table, kvIterator); } diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java index c3a72c868d..d9888f4c9f 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java @@ -17,7 +17,6 @@ package org.apache.hugegraph.backend.store.hstore; -import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; @@ -29,22 +28,16 @@ import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; -import java.util.function.Function; import java.util.stream.Collectors; import org.apache.commons.collections.CollectionUtils; -import org.apache.commons.compress.utils.Lists; -import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; -import org.apache.hugegraph.backend.query.ConditionQuery; -import org.apache.hugegraph.backend.query.ConditionQueryFlatten; import org.apache.hugegraph.backend.query.IdPrefixQuery; import org.apache.hugegraph.backend.query.IdQuery; import org.apache.hugegraph.backend.query.Query; import org.apache.hugegraph.backend.serializer.BinaryBackendEntry; import org.apache.hugegraph.backend.serializer.BytesBuffer; -import org.apache.hugegraph.backend.serializer.MergeIterator; import org.apache.hugegraph.backend.store.AbstractBackendStore; import org.apache.hugegraph.backend.store.BackendAction; import org.apache.hugegraph.backend.store.BackendEntry; @@ -56,12 +49,10 @@ import org.apache.hugegraph.config.CoreOptions; import org.apache.hugegraph.config.HugeConfig; import org.apache.hugegraph.iterator.CIter; -import org.apache.hugegraph.schema.EdgeLabel; import org.apache.hugegraph.type.HugeTableType; import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.type.define.Action; import org.apache.hugegraph.type.define.GraphMode; -import org.apache.hugegraph.type.define.HugeKeys; import org.apache.hugegraph.util.E; import org.apache.hugegraph.util.Log; import org.slf4j.Logger; @@ -74,11 +65,11 @@ public abstract class HstoreStore extends AbstractBackendStore { private static final Logger LOG = Log.logger(HstoreStore.class); private static final Set INDEX_TYPES = ImmutableSet.of( - HugeType.SECONDARY_INDEX, HugeType.VERTEX_LABEL_INDEX, - HugeType.EDGE_LABEL_INDEX, HugeType.RANGE_INT_INDEX, - HugeType.RANGE_FLOAT_INDEX, HugeType.RANGE_LONG_INDEX, - HugeType.RANGE_DOUBLE_INDEX, HugeType.SEARCH_INDEX, - HugeType.SHARD_INDEX, HugeType.UNIQUE_INDEX + HugeType.SECONDARY_INDEX, HugeType.VERTEX_LABEL_INDEX, + HugeType.EDGE_LABEL_INDEX, HugeType.RANGE_INT_INDEX, + HugeType.RANGE_FLOAT_INDEX, HugeType.RANGE_LONG_INDEX, + HugeType.RANGE_DOUBLE_INDEX, HugeType.SEARCH_INDEX, + HugeType.SHARD_INDEX, HugeType.UNIQUE_INDEX ); private static final BackendFeatures FEATURES = new HstoreFeatures(); @@ -152,7 +143,7 @@ protected final HstoreTable table(HugeType type) { break; default: throw new AssertionError(String.format( - "Invalid type: %s", type)); + "Invalid type: %s", type)); } return this.tables.get((int) table.code()); } @@ -297,8 +288,8 @@ private void mutate(Session session, BackendAction item, break; default: throw new AssertionError(String.format( - "Unsupported mutate action: %s", - item.action())); + "Unsupported mutate action: %s", + item.action())); } } } @@ -338,160 +329,160 @@ public Iterator query(Query query) { } - @Override - public Iterator> query(Iterator queries, - Function queryWriter, - HugeGraph hugeGraph) { - if (queries == null || !queries.hasNext()) { - return new LinkedList>().iterator(); - } - - class QueryWrapper implements Iterator { - Query first; - Iterator queries; - Iterator subEls; - Query preQuery; - Iterator queryListIterator; - - QueryWrapper(Iterator queries, Query first) { - this.queries = queries; - this.first = first; - } - - @Override - public boolean hasNext() { - return first != null || (this.subEls != null && this.subEls.hasNext()) - || (queryListIterator != null && queryListIterator.hasNext()) || - queries.hasNext(); - } - - @Override - public IdPrefixQuery next() { - if (queryListIterator != null && queryListIterator.hasNext()) { - return queryListIterator.next(); - } - - Query q; - if (first != null) { - q = first; - preQuery = q.copy(); - first = null; - } else { - if (this.subEls == null || !this.subEls.hasNext()) { - q = queries.next(); - preQuery = q.copy(); - } else { - q = preQuery.copy(); - } - } - - assert q instanceof ConditionQuery; - ConditionQuery cq = (ConditionQuery) q; - ConditionQuery originQuery = (ConditionQuery) q.copy(); - - List queryList = Lists.newArrayList(); - if (hugeGraph != null) { - for (ConditionQuery conditionQuery : - ConditionQueryFlatten.flatten(cq)) { - Id label = conditionQuery.condition(HugeKeys.LABEL); - /* 父类型 + sortKeys： g.V("V.id").outE("parentLabel").has - ("sortKey","value")转成 所有子类型 + sortKeys*/ - if ((this.subEls == null || - !this.subEls.hasNext()) && label != null && - hugeGraph.edgeLabel(label).isFather() && - conditionQuery.condition(HugeKeys.SUB_LABEL) == - null && - conditionQuery.condition(HugeKeys.OWNER_VERTEX) != - null && - conditionQuery.condition(HugeKeys.DIRECTION) != - null && - matchEdgeSortKeys(conditionQuery, false, - hugeGraph)) { - this.subEls = - getSubLabelsOfParentEl( - hugeGraph.edgeLabels(), - label); - } - - if (this.subEls != null && - this.subEls.hasNext()) { - conditionQuery.eq(HugeKeys.SUB_LABEL, - subEls.next()); - } - - HugeType hugeType = conditionQuery.resultType(); - if (hugeType != null && hugeType.isEdge() && - !conditionQuery.conditions().isEmpty()) { - IdPrefixQuery idPrefixQuery = - (IdPrefixQuery) queryWriter.apply( - conditionQuery); - idPrefixQuery.setOriginQuery(originQuery); - queryList.add(idPrefixQuery); - } - } - - queryListIterator = queryList.iterator(); - if (queryListIterator.hasNext()) { - return queryListIterator.next(); - } - } - - Id ownerId = cq.condition(HugeKeys.OWNER_VERTEX); - assert ownerId != null; - BytesBuffer buffer = - BytesBuffer.allocate(BytesBuffer.BUF_EDGE_ID); - buffer.writeId(ownerId); - return new IdPrefixQuery(cq, new BinaryBackendEntry.BinaryId( - buffer.bytes(), ownerId)); - } - - private boolean matchEdgeSortKeys(ConditionQuery query, - boolean matchAll, - HugeGraph graph) { - assert query.resultType().isEdge(); - Id label = query.condition(HugeKeys.LABEL); - if (label == null) { - return false; - } - List sortKeys = graph.edgeLabel(label).sortKeys(); - if (sortKeys.isEmpty()) { - return false; - } - Set queryKeys = query.userpropKeys(); - for (int i = sortKeys.size(); i > 0; i--) { - List subFields = sortKeys.subList(0, i); - if (queryKeys.containsAll(subFields)) { - if (queryKeys.size() == subFields.size() || !matchAll) { - /* - * Return true if: - * matchAll=true and all queryKeys are in sortKeys - * or - * partial queryKeys are in sortKeys - */ - return true; - } - } - } - return false; - } - } - Query first = queries.next(); - List typeList = getHugeTypes(first); - QueryWrapper idPrefixQueries = new QueryWrapper(queries, first); - - return query(typeList, idPrefixQueries); - } - - private Iterator getSubLabelsOfParentEl(Collection allEls, - Id label) { - List list = new ArrayList<>(); - for (EdgeLabel el : allEls) { - if (el.edgeLabelType().sub() && el.fatherId().equals(label)) { - list.add(el.id()); - } - } - return list.iterator(); - } + //@Override + //public Iterator> query(Iterator queries, + // Function queryWriter, + // HugeGraph hugeGraph) { + // if (queries == null || !queries.hasNext()) { + // return Collections.emptyIterator(); + // } + // + // class QueryWrapper implements Iterator { + // Query first; + // final Iterator queries; + // Iterator subEls; + // Query preQuery; + // Iterator queryListIterator; + // + // QueryWrapper(Iterator queries, Query first) { + // this.queries = queries; + // this.first = first; + // } + // + // @Override + // public boolean hasNext() { + // return first != null || (this.subEls != null && this.subEls.hasNext()) + // || (queryListIterator != null && queryListIterator.hasNext()) || + // queries.hasNext(); + // } + // + // @Override + // public IdPrefixQuery next() { + // if (queryListIterator != null && queryListIterator.hasNext()) { + // return queryListIterator.next(); + // } + // + // Query q; + // if (first != null) { + // q = first; + // preQuery = q.copy(); + // first = null; + // } else { + // if (this.subEls == null || !this.subEls.hasNext()) { + // q = queries.next(); + // preQuery = q.copy(); + // } else { + // q = preQuery.copy(); + // } + // } + // + // assert q instanceof ConditionQuery; + // ConditionQuery cq = (ConditionQuery) q; + // ConditionQuery originQuery = (ConditionQuery) q.copy(); + // + // List queryList = Lists.newArrayList(); + // if (hugeGraph != null) { + // for (ConditionQuery conditionQuery : + // ConditionQueryFlatten.flatten(cq)) { + // Id label = conditionQuery.condition(HugeKeys.LABEL); + // /* 父类型 + sortKeys： g.V("V.id").outE("parentLabel").has + // ("sortKey","value")转成 所有子类型 + sortKeys*/ + // if ((this.subEls == null || + // !this.subEls.hasNext()) && label != null && + // hugeGraph.edgeLabel(label).isFather() && + // conditionQuery.condition(HugeKeys.SUB_LABEL) == + // null && + // conditionQuery.condition(HugeKeys.OWNER_VERTEX) != + // null && + // conditionQuery.condition(HugeKeys.DIRECTION) != + // null && + // matchEdgeSortKeys(conditionQuery, false, + // hugeGraph)) { + // this.subEls = + // getSubLabelsOfParentEl( + // hugeGraph.edgeLabels(), + // label); + // } + // + // if (this.subEls != null && + // this.subEls.hasNext()) { + // conditionQuery.eq(HugeKeys.SUB_LABEL, + // subEls.next()); + // } + // + // HugeType hugeType = conditionQuery.resultType(); + // if (hugeType != null && hugeType.isEdge() && + // !conditionQuery.conditions().isEmpty()) { + // IdPrefixQuery idPrefixQuery = + // (IdPrefixQuery) queryWriter.apply( + // conditionQuery); + // idPrefixQuery.setOriginQuery(originQuery); + // queryList.add(idPrefixQuery); + // } + // } + // + // queryListIterator = queryList.iterator(); + // if (queryListIterator.hasNext()) { + // return queryListIterator.next(); + // } + // } + // + // Id ownerId = cq.condition(HugeKeys.OWNER_VERTEX); + // assert ownerId != null; + // BytesBuffer buffer = + // BytesBuffer.allocate(BytesBuffer.BUF_EDGE_ID); + // buffer.writeId(ownerId); + // return new IdPrefixQuery(cq, new BinaryBackendEntry.BinaryId( + // buffer.bytes(), ownerId)); + // } + // + // private boolean matchEdgeSortKeys(ConditionQuery query, + // boolean matchAll, + // HugeGraph graph) { + // assert query.resultType().isEdge(); + // Id label = query.condition(HugeKeys.LABEL); + // if (label == null) { + // return false; + // } + // List sortKeys = graph.edgeLabel(label).sortKeys(); + // if (sortKeys.isEmpty()) { + // return false; + // } + // Set queryKeys = query.userpropKeys(); + // for (int i = sortKeys.size(); i > 0; i--) { + // List subFields = sortKeys.subList(0, i); + // if (queryKeys.containsAll(subFields)) { + // if (queryKeys.size() == subFields.size() || !matchAll) { + // /* + // * Return true if: + // * matchAll=true and all queryKeys are in sortKeys + // * or + // * partial queryKeys are in sortKeys + // */ + // return true; + // } + // } + // } + // return false; + // } + // } + // Query first = queries.next(); + // List typeList = getHugeTypes(first); + // QueryWrapper idPrefixQueries = new QueryWrapper(queries, first); + // + // return query(typeList, idPrefixQueries); + //} + + //private Iterator getSubLabelsOfParentEl(Collection allEls, + // Id label) { + // List list = new ArrayList<>(); + // for (EdgeLabel el : allEls) { + // if (el.edgeLabelType().sub() && el.fatherId().equals(label)) { + // list.add(el.id()); + // } + // } + // return list.iterator(); + //} public List> query(List typeList, List queries) { @@ -510,8 +501,8 @@ public List> query(List typeList, builder.append((table = this.table(type)).table()).append(","); } List> iteratorList = - table.query(session, queries, - builder.substring(0, builder.length() - 1)); + table.query(session, queries, + builder.substring(0, builder.length() - 1)); for (int i = 0; i < iteratorList.size(); i++) { Iterator entries = iteratorList.get(i); // Merge olap results as needed @@ -544,8 +535,8 @@ public Iterator> query(List typeList, } Iterator> iterators = - table.query(session, queries, - builder.substring(0, builder.length() - 1)); + table.query(session, queries, + builder.substring(0, builder.length() - 1)); return iterators; } finally { @@ -554,21 +545,21 @@ public Iterator> query(List typeList, } private Iterator getBackendEntryIterator( - Iterator entries, - Query query) { - HstoreTable table; - Set olapPks = query.olapPks(); - if (this.isGraphStore && !olapPks.isEmpty()) { - List> iterators = new ArrayList<>(); - for (Id pk : olapPks) { - // 构造olap表查询query condition - Query q = this.constructOlapQueryCondition(pk, query); - table = this.table(HugeType.OLAP); - iterators.add(table.queryOlap(this.session(HugeType.OLAP), q)); - } - entries = new MergeIterator<>(entries, iterators, - BackendEntry::mergable); - } + Iterator entries, + Query query) { + //HstoreTable table; + //Set olapPks = query.olapPks(); + //if (this.isGraphStore && !olapPks.isEmpty()) { + // List> iterators = new ArrayList<>(); + // for (Id pk : olapPks) { + // // 构造olap表查询query condition + // Query q = this.constructOlapQueryCondition(pk, query); + // table = this.table(HugeType.OLAP); + // iterators.add(table.queryOlap(this.session(HugeType.OLAP), q)); + // } + // entries = new MergeIterator<>(entries, iterators, + // BackendEntry::mergable); + //} return entries; } @@ -596,10 +587,10 @@ private Query constructOlapQueryCondition(Id pk, Query query) { // create binary id BytesBuffer buffer = - BytesBuffer.allocate(1 + pk.length() + 1 + id.length()); + BytesBuffer.allocate(1 + pk.length() + 1 + id.length()); buffer.writeId(pk); id = new BinaryBackendEntry.BinaryId( - buffer.writeId(id).bytes(), id); + buffer.writeId(id).bytes(), id); linkedHashSet.add(id); } q.resetIds(); @@ -609,7 +600,7 @@ private Query constructOlapQueryCondition(Id pk, Query query) { // create binary id BytesBuffer buffer = BytesBuffer.allocate(1 + pk.length()); pk = new BinaryBackendEntry.BinaryId( - buffer.writeId(pk).bytes(), pk); + buffer.writeId(pk).bytes(), pk); IdPrefixQuery idPrefixQuery = new IdPrefixQuery(HugeType.OLAP, pk); return idPrefixQuery; @@ -733,26 +724,22 @@ public boolean isSchemaStore() { return false; } - @Override - public void close(boolean force) { - } - @Override public Id nextId(HugeType type) { throw new UnsupportedOperationException( - "HstoreGraphStore.nextId()"); + "HstoreGraphStore.nextId()"); } @Override public void increaseCounter(HugeType type, long num) { throw new UnsupportedOperationException( - "HstoreGraphStore.increaseCounter()"); + "HstoreGraphStore.increaseCounter()"); } @Override public long getCounter(HugeType type) { throw new UnsupportedOperationException( - "HstoreGraphStore.getCounter()"); + "HstoreGraphStore.getCounter()"); } @Override @@ -786,11 +773,5 @@ public void clearOlapTable(Id pkId) { @Override public void removeOlapTable(Id pkId) { } - - @Override - public boolean existOlapTable(Id pkId) { - String tableName = this.olapTableName(pkId); - return super.sessions.existsTable(tableName); - } } } diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTable.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTable.java index 774b213fc6..ef412d8ced 100755 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTable.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTable.java @@ -18,18 +18,16 @@ package org.apache.hugegraph.backend.store.hstore; import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; -import java.util.HashSet; import java.util.Iterator; import java.util.LinkedList; import java.util.List; -import java.util.Set; import java.util.function.BiFunction; import java.util.function.Function; import java.util.function.Supplier; import org.apache.commons.collections.CollectionUtils; -import org.apache.commons.lang3.StringUtils; import org.apache.hugegraph.backend.id.EdgeId; import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.page.PageState; @@ -46,7 +44,6 @@ import org.apache.hugegraph.backend.store.BackendEntry; import org.apache.hugegraph.backend.store.BackendEntry.BackendColumn; import org.apache.hugegraph.backend.store.BackendEntry.BackendColumnIterator; -import org.apache.hugegraph.backend.store.BackendEntry.BackendColumnIteratorWrapper; import org.apache.hugegraph.backend.store.BackendEntryIterator; import org.apache.hugegraph.backend.store.BackendTable; import org.apache.hugegraph.backend.store.Shard; @@ -70,22 +67,22 @@ public class HstoreTable extends BackendTable { private static final Logger LOG = Log.logger(HstoreStore.class); - private final HstoreShardSpliter shardSpliter; + private final HstoreShardSplitter shardSpliter; Function ownerDelegate = (entry) -> getOwner(entry); Function ownerByIdDelegate = (id) -> getOwnerId(id); BiFunction ownerByQueryDelegate = - (type, id) -> getOwnerId(type, id); + (type, id) -> getOwnerId(type, id); Supplier ownerScanDelegate = - () -> HgStoreClientConst.ALL_PARTITION_OWNER; + () -> HgStoreClientConst.ALL_PARTITION_OWNER; public HstoreTable(String database, String table) { super(String.format("%s+%s", database, table)); - this.shardSpliter = new HstoreShardSpliter(this.table()); + this.shardSpliter = new HstoreShardSplitter(this.table()); } public static ConditionQuery removeDirectionCondition(ConditionQuery conditionQuery) { - Set conditions = conditionQuery.conditions(); - Set newConditions = new HashSet<>(); + Collection conditions = conditionQuery.conditions(); + List newConditions = new ArrayList<>(); for (Condition condition : conditions) { if (!direction(condition)) { newConditions.add(condition); @@ -112,7 +109,7 @@ private static boolean direction(Condition condition) { } protected static BackendEntryIterator newEntryIterator( - BackendColumnIterator cols, Query query) { + BackendColumnIterator cols, Query query) { return new BinaryEntryIterator<>(cols, query, (entry, col) -> { if (entry == null || !entry.belongToMe(col)) { HugeType type = query.resultType(); @@ -125,7 +122,7 @@ protected static BackendEntryIterator newEntryIterator( } protected static BackendEntryIterator newEntryIteratorOlap( - BackendColumnIterator cols, Query query, boolean isOlap) { + BackendColumnIterator cols, Query query, boolean isOlap) { return new BinaryEntryIterator<>(cols, query, (entry, col) -> { if (entry == null || !entry.belongToMe(col)) { HugeType type = query.resultType(); @@ -248,17 +245,16 @@ protected byte[] getOwnerId(HugeType type, Id id) { @Override public void insert(Session session, BackendEntry entry) { byte[] owner = entry.type().isEdge() ? getInsertEdgeOwner(entry) : getInsertOwner(entry); - ArrayList columns = (ArrayList) entry.realColumns(); + ArrayList columns = (ArrayList) entry.columns(); for (int i = 0; i < columns.size(); i++) { BackendColumn col = columns.get(i); session.put(this.table(), owner, col.name, col.value); } } - @Override public void insert(Session session, BackendEntry entry, boolean isEdge) { byte[] owner = isEdge ? getInsertEdgeOwner(entry) : getInsertOwner(entry); - ArrayList columns = (ArrayList) entry.realColumns(); + ArrayList columns = (ArrayList) entry.columns(); for (int i = 0; i < columns.size(); i++) { BackendColumn col = columns.get(i); session.put(this.table(), owner, col.name, col.value); @@ -329,27 +325,27 @@ public Iterator query(Session session, Query query) { return newEntryIterator(this.queryBy(session, query), query); } - @Override - public Iterator queryOlap(Session session, Query query) { - if (query.limit() == 0L && !query.noLimit()) { - // LOG.debug("Return empty result(limit=0) for query {}", query); - return Collections.emptyIterator(); - } - return newEntryIteratorOlap(this.queryBy(session, query), query, true); - } + //@Override + //public Iterator queryOlap(Session session, Query query) { + // if (query.limit() == 0L && !query.noLimit()) { + // // LOG.debug("Return empty result(limit=0) for query {}", query); + // return Collections.emptyIterator(); + // } + // return newEntryIteratorOlap(this.queryBy(session, query), query, true); + //} public List> query(Session session, List queries, String tableName) { List queryByPrefixList = - this.queryByPrefixList(session, queries, tableName); + this.queryByPrefixList(session, queries, tableName); LinkedList> iterators = new LinkedList<>(); for (int i = 0; i < queryByPrefixList.size(); i++) { IdPrefixQuery q = queries.get(i).copy(); q.capacity(Query.NO_CAPACITY); q.limit(Query.NO_LIMIT); BackendEntryIterator iterator = - newEntryIterator(queryByPrefixList.get(i), q); + newEntryIterator(queryByPrefixList.get(i), q); iterators.add(iterator); } return iterators; @@ -358,60 +354,61 @@ public List> query(Session session, public BackendEntry.BackendIterator> query(Session session, Iterator queries, String tableName) { - final IdPrefixQuery[] first = {queries.next()}; - int type = first[0].withProperties() ? 0 : Session.SCAN_KEY_ONLY; - - IdPrefixQuery queryTmpl = first[0].copy(); - queryTmpl.capacity(Query.NO_CAPACITY); - queryTmpl.limit(Query.NO_LIMIT); - - ConditionQuery originQuery = (ConditionQuery) first[0].originQuery(); - if (originQuery != null) { - originQuery = prepareConditionQueryList(originQuery); - } - byte[] queryBytes = originQuery == null ? null : originQuery.bytes(); - - BackendEntry.BackendIterator it - = session.scan(tableName, new Iterator() { - @Override - public boolean hasNext() { - if (first[0] != null) { - return true; - } - return queries.hasNext(); - } - - @Override - public HgOwnerKey next() { - IdPrefixQuery query = first[0] != null ? first[0] : queries.next(); - first[0] = null; - byte[] prefix = ownerByQueryDelegate.apply(query.resultType(), - query.prefix()); - return HgOwnerKey.of(prefix, query.prefix().asBytes()); - } - }, type, first[0], queryBytes); - return new BackendEntry.BackendIterator<>() { - @Override - public boolean hasNext() { - return it.hasNext(); - } - - @Override - public Iterator next() { - BackendEntryIterator iterator = newEntryIterator(it.next(), queryTmpl); - return iterator; - } - - @Override - public void close() { - it.close(); - } - - @Override - public byte[] position() { - return new byte[0]; - } - }; + //final IdPrefixQuery[] first = {queries.next()}; + //int type = first[0].withProperties() ? 0 : Session.SCAN_KEY_ONLY; + // + //IdPrefixQuery queryTmpl = first[0].copy(); + //queryTmpl.capacity(Query.NO_CAPACITY); + //queryTmpl.limit(Query.NO_LIMIT); + // + //ConditionQuery originQuery = (ConditionQuery) first[0].originQuery(); + //if (originQuery != null) { + // originQuery = prepareConditionQueryList(originQuery); + //} + //byte[] queryBytes = originQuery == null ? null : originQuery.bytes(); + // + //BackendEntry.BackendIterator it + // = session.scan(tableName, new Iterator() { + // @Override + // public boolean hasNext() { + // if (first[0] != null) { + // return true; + // } + // return queries.hasNext(); + // } + // + // @Override + // public HgOwnerKey next() { + // IdPrefixQuery query = first[0] != null ? first[0] : queries.next(); + // first[0] = null; + // byte[] prefix = ownerByQueryDelegate.apply(query.resultType(), + // query.prefix()); + // return HgOwnerKey.of(prefix, query.prefix().asBytes()); + // } + //}, type, first[0], queryBytes); + //return new BackendEntry.BackendIterator<>() { + // @Override + // public boolean hasNext() { + // return it.hasNext(); + // } + // + // @Override + // public Iterator next() { + // BackendEntryIterator iterator = newEntryIterator(it.next(), queryTmpl); + // return iterator; + // } + // + // @Override + // public void close() { + // it.close(); + // } + // + // @Override + // public byte[] position() { + // return new byte[0]; + // } + //}; + return null; } protected BackendColumnIterator queryBy(Session session, Query query) { @@ -447,7 +444,7 @@ protected BackendColumnIterator queryBy(Session session, Query query) { } BackendColumnIterator withBatch = session.getWithBatch(this.table(), hgOwnerKeys); - return new BackendColumnIteratorWrapper(withBatch); + return BackendColumnIterator.wrap(withBatch); } // Query by condition (or condition + id) @@ -459,8 +456,9 @@ protected BackendColumnIterator queryAll(Session session, Query query) { if (query.paging()) { PageState page = PageState.fromString(query.page()); byte[] ownerKey = this.getOwnerScanDelegate().get(); - int scanType = Session.SCAN_ANY | - (query.withProperties() ? 0 : Session.SCAN_KEY_ONLY); + //int scanType = Session.SCAN_ANY | + // (query.withProperties() ? 0 : Session.SCAN_KEY_ONLY); + int scanType = 0; byte[] queryBytes = query instanceof ConditionQuery ? ((ConditionQuery) query).bytes() : null; // LOG.debug("query {} with ownerKeyFrom: {}, ownerKeyTo: {}, " + @@ -492,7 +490,7 @@ protected BackendColumnIterator getById(Session session, Id id) { return BackendColumnIterator.empty(); } BackendColumn col = BackendColumn.of(id.asBytes(), value); - return new BackendEntry.BackendColumnIteratorWrapper(col); + return BackendColumnIterator.iterator(col); } protected BackendColumnIterator queryByPrefix(Session session, @@ -534,29 +532,30 @@ protected BackendColumnIterator queryByPrefix(Session session, } protected List queryByPrefixList( - Session session, - List queries, - String tableName) { - E.checkArgument(queries.size() > 0, - "The size of queries must be greater than zero"); - IdPrefixQuery query = queries.get(0); - int type = 0; - LinkedList ownerKey = new LinkedList<>(); - queries.forEach((item) -> { - byte[] prefix = this.ownerByQueryDelegate.apply(item.resultType(), - item.prefix()); - ownerKey.add(HgOwnerKey.of(prefix, item.prefix().asBytes())); - }); - ConditionQuery originQuery = (ConditionQuery) query.originQuery(); - if (originQuery != null) { - originQuery = prepareConditionQueryList(originQuery); - } - byte[] queryBytes = originQuery == null ? null : originQuery.bytes(); - - // LOG.debug("query {} with scanType: {}, limit: {}, conditionQuery: - // {}", this.table(), type, query.limit(), queryBytes); - return session.scan(tableName, ownerKey, type, - query.limit(), queryBytes); + Session session, + List queries, + String tableName) { + //E.checkArgument(queries.size() > 0, + // "The size of queries must be greater than zero"); + //IdPrefixQuery query = queries.get(0); + //int type = 0; + //LinkedList ownerKey = new LinkedList<>(); + //queries.forEach((item) -> { + // byte[] prefix = this.ownerByQueryDelegate.apply(item.resultType(), + // item.prefix()); + // ownerKey.add(HgOwnerKey.of(prefix, item.prefix().asBytes())); + //}); + //ConditionQuery originQuery = (ConditionQuery) query.originQuery(); + //if (originQuery != null) { + // originQuery = prepareConditionQueryList(originQuery); + //} + //byte[] queryBytes = originQuery == null ? null : originQuery.bytes(); + // + //// LOG.debug("query {} with scanType: {}, limit: {}, conditionQuery: + //// {}", this.table(), type, query.limit(), queryBytes); + //return session.scan(tableName, ownerKey, type, + // query.limit(), queryBytes); + return null; } /*** @@ -570,8 +569,8 @@ private ConditionQuery prepareConditionQuery(ConditionQuery conditionQuery) { return null; } // only userpropConditions can send to store - Set conditions = conditionQuery.conditions(); - Set newConditions = new HashSet<>(); + Collection conditions = conditionQuery.conditions(); + List newConditions = new ArrayList<>(); for (Condition condition : conditions) { if (!onlyOwnerVertex(condition)) { newConditions.add(condition); @@ -592,23 +591,24 @@ private ConditionQuery prepareConditionQuery(ConditionQuery conditionQuery) { * @return */ private ConditionQuery prepareConditionQueryList(ConditionQuery conditionQuery) { - if (!conditionQuery.containsLabelOrUserpropRelation()) { - return null; - } - // only userpropConditions can send to store - Set conditions = conditionQuery.conditions(); - Set newConditions = new HashSet<>(); - for (Condition condition : conditions) { - if (!onlyOwnerVertex(condition)) { - newConditions.add(condition); - } - } - if (newConditions.size() > 0) { - conditionQuery.resetConditions(newConditions); - return conditionQuery; - } else { - return null; - } + //if (!conditionQuery.containsLabelOrUserpropRelation()) { + // return null; + //} + //// only userpropConditions can send to store + //Collection conditions = conditionQuery.conditions(); + //List newConditions = new ArrayList<>(); + //for (Condition condition : conditions) { + // if (!onlyOwnerVertex(condition)) { + // newConditions.add(condition); + // } + //} + //if (newConditions.size() > 0) { + // conditionQuery.resetConditions(newConditions); + // return conditionQuery; + //} else { + // return null; + //} + return null; } private boolean onlyOwnerVertex(Condition condition) { @@ -653,8 +653,9 @@ protected BackendColumnIterator queryByRange(Session session, // this.table(), bytes2String(ownerStart), // bytes2String(ownerEnd), bytes2String(start), // bytes2String(end), type, cq.bytes()); - return session.scan(this.table(), ownerStart, - ownerEnd, start, end, type, cq.bytes(), position); + //return session.scan(this.table(), ownerStart, + // ownerEnd, start, end, type, cq.bytes(), position); + return null; } return session.scan(this.table(), ownerStart, ownerEnd, start, end, type, null, position); @@ -662,41 +663,42 @@ protected BackendColumnIterator queryByRange(Session session, protected BackendColumnIterator queryByCond(Session session, ConditionQuery query) { - if (query.containsScanCondition()) { - E.checkArgument(query.relations().size() == 1, - "Invalid scan with multi conditions: %s", query); - Relation scan = query.relations().iterator().next(); - Shard shard = (Shard) scan.value(); - return this.queryByRange(session, shard, query); - } + //if (query.containsScanCondition()) { + // E.checkArgument(query.relations().size() == 1, + // "Invalid scan with multi conditions: %s", query); + // Relation scan = query.relations().iterator().next(); + // Shard shard = (Shard) scan.value(); + // return this.queryByRange(session, shard, query); + //} // throw new NotSupportException("query: %s", query); return this.queryAll(session, query); } protected BackendColumnIterator queryByRange(Session session, Shard shard, ConditionQuery query) { - int type = Session.SCAN_GTE_BEGIN; - type |= Session.SCAN_LT_END; - type |= Session.SCAN_HASHCODE; - type |= query.withProperties() ? 0 : Session.SCAN_KEY_ONLY; - - int start = Integer.parseInt(StringUtils.isEmpty(shard.start()) ? - "0" : shard.start()); - int end = Integer.parseInt(StringUtils.isEmpty(shard.end()) ? - "0" : shard.end()); - byte[] queryBytes = query.bytes(); - String page = query.page(); - if (page != null && !page.isEmpty()) { - byte[] position = PageState.fromString(page).position(); - return session.scan(this.table(), start, end, type, queryBytes, - position); - } - return session.scan(this.table(), start, end, type, queryBytes); - } - - private static class HstoreShardSpliter extends ShardSpliter { - - public HstoreShardSpliter(String table) { + //int type = Session.SCAN_GTE_BEGIN; + //type |= Session.SCAN_LT_END; + //type |= Session.SCAN_HASHCODE; + //type |= query.withProperties() ? 0 : Session.SCAN_KEY_ONLY; + // + //int start = Integer.parseInt(StringUtils.isEmpty(shard.start()) ? + // "0" : shard.start()); + //int end = Integer.parseInt(StringUtils.isEmpty(shard.end()) ? + // "0" : shard.end()); + //byte[] queryBytes = query.bytes(); + //String page = query.page(); + //if (page != null && !page.isEmpty()) { + // byte[] position = PageState.fromString(page).position(); + // return session.scan(this.table(), start, end, type, queryBytes, + // position); + //} + //return session.scan(this.table(), start, end, type, queryBytes); + return null; + } + + private static class HstoreShardSplitter extends ShardSplitter { + + public HstoreShardSplitter(String table) { super(table); } diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTables.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTables.java index ab9482938d..d1ca9e9057 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTables.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTables.java @@ -162,7 +162,7 @@ protected BackendColumnIterator queryByCond(Session session, E.checkArgumentNotNull(min, "Range index begin key is missing"); byte[] begin = min.asBytes(); if (!minEq) { - begin = BinarySerializer.increaseOne(begin); + BinarySerializer.increaseOne(begin); } byte[] ownerStart = this.ownerScanDelegate.get(); byte[] ownerEnd = this.ownerScanDelegate.get(); diff --git a/hugegraph-server/pom.xml b/hugegraph-server/pom.xml index 44a0e58edc..d1e4ef355b 100644 --- a/hugegraph-server/pom.xml +++ b/hugegraph-server/pom.xml @@ -129,6 +129,7 @@ hugegraph-palo hugegraph-hbase hugegraph-postgresql + hugegraph-hstore diff --git a/pom.xml b/pom.xml index b2fc6299aa..b5d06f5e79 100644 --- a/pom.xml +++ b/pom.xml @@ -93,8 +93,8 @@ - hugegraph-server hugegraph-pd hugegraph-store + hugegraph-server From d3e7ca9f5969807ac433ee12d31e55f30b714388 Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Fri, 18 Aug 2023 11:40:32 +0800 Subject: [PATCH 03/26] chore: register hstore --- hugegraph-server/hugegraph-dist/pom.xml | 5 +++++ .../assembly/static/conf/graphs/hugegraph.properties | 2 +- .../java/org/apache/hugegraph/dist/RegisterUtil.java | 12 ++++++++++++ .../src/main/resources/backend.properties | 2 +- 4 files changed, 19 insertions(+), 2 deletions(-) diff --git a/hugegraph-server/hugegraph-dist/pom.xml b/hugegraph-server/hugegraph-dist/pom.xml index e9f8e3c431..fe2287f590 100644 --- a/hugegraph-server/hugegraph-dist/pom.xml +++ b/hugegraph-server/hugegraph-dist/pom.xml @@ -98,6 +98,11 @@ hugegraph-postgresql ${revision} + + org.apache.hugegraph + hugegraph-hstore + ${revision} + org.apache.tinkerpop diff --git a/hugegraph-server/hugegraph-dist/src/assembly/static/conf/graphs/hugegraph.properties b/hugegraph-server/hugegraph-dist/src/assembly/static/conf/graphs/hugegraph.properties index 5f77efe939..74e1408c70 100644 --- a/hugegraph-server/hugegraph-dist/src/assembly/static/conf/graphs/hugegraph.properties +++ b/hugegraph-server/hugegraph-dist/src/assembly/static/conf/graphs/hugegraph.properties @@ -19,7 +19,7 @@ edge.cache_type=l2 #vertex.default_label=vertex -backend=rocksdb +backend=hstore serializer=binary store=hugegraph diff --git a/hugegraph-server/hugegraph-dist/src/main/java/org/apache/hugegraph/dist/RegisterUtil.java b/hugegraph-server/hugegraph-dist/src/main/java/org/apache/hugegraph/dist/RegisterUtil.java index 34e5ea3cf6..9a3b632d4d 100644 --- a/hugegraph-server/hugegraph-dist/src/main/java/org/apache/hugegraph/dist/RegisterUtil.java +++ b/hugegraph-server/hugegraph-dist/src/main/java/org/apache/hugegraph/dist/RegisterUtil.java @@ -91,6 +91,9 @@ private static void registerBackend(String backend) { case "postgresql": registerPostgresql(); break; + case "hstore": + registerHstore(); + break; default: throw new HugeException("Unsupported backend type '%s'", backend); } @@ -215,4 +218,13 @@ public static void registerPlugins() { } } } + + public static void registerHstore() { + // Register config + OptionSpace.register("hstore", + "org.apache.hugegraph.backend.store.hstore.HstoreOptions"); + // Register backend + BackendProviderFactory.register("hstore", + "org.apache.hugegraph.backend.store.hstore.HstoreProvider"); + } } diff --git a/hugegraph-server/hugegraph-dist/src/main/resources/backend.properties b/hugegraph-server/hugegraph-dist/src/main/resources/backend.properties index aa49ed14b2..c2dd5df2a8 100644 --- a/hugegraph-server/hugegraph-dist/src/main/resources/backend.properties +++ b/hugegraph-server/hugegraph-dist/src/main/resources/backend.properties @@ -15,4 +15,4 @@ # under the License. # -backends=[cassandra, scylladb, rocksdb, mysql, palo, hbase, postgresql] +backends=[cassandra, scylladb, rocksdb, mysql, palo, hbase, postgresql, hstore] From afd2c5cbe53b2f49b93fdcfdbb911bb4fc9a9c09 Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Fri, 18 Aug 2023 16:29:52 +0800 Subject: [PATCH 04/26] build: intro grpc dep --- hugegraph-server/pom.xml | 3 --- 1 file changed, 3 deletions(-) diff --git a/hugegraph-server/pom.xml b/hugegraph-server/pom.xml index d1e4ef355b..7a6ee74a8e 100644 --- a/hugegraph-server/pom.xml +++ b/hugegraph-server/pom.xml @@ -298,19 +298,16 @@ io.grpc grpc-netty ${grpc.version} - provided io.grpc grpc-protobuf ${grpc.version} - provided io.grpc grpc-stub ${grpc.version} - provided com.google.protobuf From e4c894cae3de9b22af5028ab8aced614c1ad17b8 Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Mon, 21 Aug 2023 23:07:36 +0800 Subject: [PATCH 05/26] chore: migrate org.apache.hugegraph.meta --- .../apache/hugegraph/meta/EtcdMetaDriver.java | 331 +++++ .../org/apache/hugegraph/meta/MetaDriver.java | 76 + .../apache/hugegraph/meta/MetaManager.java | 1312 +++++++++++++++++ .../apache/hugegraph/meta/PdMetaDriver.java | 250 ++++ .../meta/lock/AbstractDistributedLock.java | 51 + .../hugegraph/meta/lock/DistributedLock.java | 164 +++ .../hugegraph/meta/lock/LockResult.java | 61 + .../meta/lock/PdDistributedLock.java | 100 ++ .../meta/managers/AbstractMetaManager.java | 116 ++ .../meta/managers/AuthMetaManager.java | 1035 +++++++++++++ .../meta/managers/ConfigMetaManager.java | 149 ++ .../meta/managers/GraphMetaManager.java | 284 ++++ .../meta/managers/KafkaMetaManager.java | 46 + .../meta/managers/LockMetaManager.java | 27 + .../meta/managers/SchemaMetaManager.java | 517 +++++++ .../managers/SchemaTemplateMetaManager.java | 107 ++ .../meta/managers/ServiceMetaManager.java | 170 +++ .../meta/managers/SpaceMetaManager.java | 202 +++ .../meta/managers/TaskMetaManager.java | 76 + 19 files changed, 5074 insertions(+) create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/EtcdMetaDriver.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaDriver.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaManager.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/PdMetaDriver.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/AbstractDistributedLock.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/DistributedLock.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/LockResult.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/PdDistributedLock.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/AbstractMetaManager.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/AuthMetaManager.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/ConfigMetaManager.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/GraphMetaManager.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/KafkaMetaManager.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/LockMetaManager.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/SchemaMetaManager.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/SchemaTemplateMetaManager.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/ServiceMetaManager.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/SpaceMetaManager.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/TaskMetaManager.java diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/EtcdMetaDriver.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/EtcdMetaDriver.java new file mode 100644 index 0000000000..e07eecb9f5 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/EtcdMetaDriver.java @@ -0,0 +1,331 @@ +/* + * 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.hugegraph.meta; + +import java.io.File; +import java.net.URI; +import java.nio.charset.Charset; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ExecutionException; +import java.util.function.Consumer; + +import org.apache.commons.io.FileUtils; +import org.apache.hugegraph.HugeException; +import org.apache.hugegraph.meta.lock.DistributedLock; +import org.apache.hugegraph.meta.lock.LockResult; +import org.apache.hugegraph.type.define.CollectionType; +import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.collection.CollectionFactory; + +import com.google.common.base.Strings; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.ClientBuilder; +import io.etcd.jetcd.KV; +import io.etcd.jetcd.KeyValue; +import io.etcd.jetcd.kv.GetResponse; +import io.etcd.jetcd.lease.LeaseKeepAliveResponse; +import io.etcd.jetcd.options.DeleteOption; +import io.etcd.jetcd.options.GetOption; +import io.etcd.jetcd.options.WatchOption; +import io.etcd.jetcd.watch.WatchEvent; +import io.etcd.jetcd.watch.WatchResponse; +import io.netty.handler.ssl.ApplicationProtocolConfig; +import io.netty.handler.ssl.ApplicationProtocolNames; +import io.netty.handler.ssl.SslContext; +import io.netty.handler.ssl.SslContextBuilder; +import io.netty.handler.ssl.SslProvider; + +public class EtcdMetaDriver implements MetaDriver { + + private Client client; + private DistributedLock lock; + + public EtcdMetaDriver(String trustFile, String clientCertFile, + String clientKeyFile, Object... endpoints) { + ClientBuilder builder = this.etcdMetaDriverBuilder(endpoints); + + SslContext sslContext = openSslContext(trustFile, clientCertFile, + clientKeyFile); + this.client = builder.sslContext(sslContext).build(); + this.lock = DistributedLock.getInstance(this.client); + } + + public EtcdMetaDriver(Object... endpoints) { + ClientBuilder builder = this.etcdMetaDriverBuilder(endpoints); + this.client = builder.build(); + this.lock = DistributedLock.getInstance(this.client); + } + + private static ByteSequence toByteSequence(String content) { + return ByteSequence.from(content.getBytes()); + } + + private static boolean isEtcdPut(WatchEvent event) { + return event.getEventType() == WatchEvent.EventType.PUT; + } + + public static SslContext openSslContext(String trustFile, + String clientCertFile, + String clientKeyFile) { + SslContext ssl; + try { + File trustManagerFile = FileUtils.getFile(trustFile); + File keyCertChainFile = FileUtils.getFile(clientCertFile); + File KeyFile = FileUtils.getFile(clientKeyFile); + ApplicationProtocolConfig alpn = new ApplicationProtocolConfig( + ApplicationProtocolConfig.Protocol.ALPN, + ApplicationProtocolConfig.SelectorFailureBehavior.NO_ADVERTISE, + + ApplicationProtocolConfig.SelectedListenerFailureBehavior + .ACCEPT, + ApplicationProtocolNames.HTTP_2); + + ssl = SslContextBuilder.forClient() + .applicationProtocolConfig(alpn) + .sslProvider(SslProvider.OPENSSL) + .trustManager(trustManagerFile) + .keyManager(keyCertChainFile, KeyFile) + .build(); + } catch (Exception e) { + throw new HugeException("Failed to open ssl context", e); + } + return ssl; + } + + public ClientBuilder etcdMetaDriverBuilder(Object... endpoints) { + int length = endpoints.length; + ClientBuilder builder = null; + if (endpoints[0] instanceof List && endpoints.length == 1) { + builder = Client.builder() + .endpoints(((List) endpoints[0]) + .toArray(new String[0])); + } else if (endpoints[0] instanceof String) { + for (int i = 1; i < length; i++) { + E.checkArgument(endpoints[i] instanceof String, + "Inconsistent endpoint %s(%s) with %s(%s)", + endpoints[i], endpoints[i].getClass(), + endpoints[0], endpoints[0].getClass()); + } + builder = Client.builder().endpoints((String[]) endpoints); + } else if (endpoints[0] instanceof URI) { + for (int i = 1; i < length; i++) { + E.checkArgument(endpoints[i] instanceof String, + "Invalid endpoint %s(%s)", + endpoints[i], endpoints[i].getClass(), + endpoints[0], endpoints[0].getClass()); + } + builder = Client.builder().endpoints((URI[]) endpoints); + } else { + E.checkArgument(false, "Invalid endpoint %s(%s)", + endpoints[0], endpoints[0].getClass()); + } + return builder; + } + + @Override + public long keepAlive(String key, long leaseId) { + try { + LeaseKeepAliveResponse response = + this.client.getLeaseClient().keepAliveOnce(leaseId).get(); + return response.getID(); + } catch (InterruptedException | ExecutionException e) { + // keepAlive once Failed + return 0; + } + } + + @Override + public String get(String key) { + List keyValues; + KV kvClient = this.client.getKVClient(); + try { + keyValues = kvClient.get(toByteSequence(key)) + .get().getKvs(); + } catch (InterruptedException | ExecutionException e) { + throw new HugeException("Failed to get key '%s' from etcd", e, key); + } + + if (keyValues.size() > 0) { + return keyValues.get(0).getValue().toString(Charset.defaultCharset()); + } + + return null; + } + + @Override + public void put(String key, String value) { + KV kvClient = this.client.getKVClient(); + try { + kvClient.put(toByteSequence(key), toByteSequence(value)).get(); + } catch (InterruptedException | ExecutionException e) { + try { + kvClient.delete(toByteSequence(key)).get(); + } catch (Throwable t) { + throw new HugeException("Failed to put '%s:%s' to etcd", + e, key, value); + } + } + } + + @Override + public void delete(String key) { + KV kvClient = this.client.getKVClient(); + try { + kvClient.delete(toByteSequence(key)).get(); + } catch (InterruptedException | ExecutionException e) { + throw new HugeException( + "Failed to delete key '%s' from etcd", e, key); + } + } + + @Override + public void deleteWithPrefix(String prefix) { + KV kvClient = this.client.getKVClient(); + try { + DeleteOption option = DeleteOption.newBuilder() + .isPrefix(true) + .build(); + kvClient.delete(toByteSequence(prefix), option); + } catch (Throwable e) { + throw new HugeException( + "Failed to delete prefix '%s' from etcd", e, prefix); + } + } + + @Override + public Map scanWithPrefix(String prefix) { + GetOption getOption = GetOption.newBuilder() + .isPrefix(true) + .build(); + GetResponse response; + try { + response = this.client.getKVClient().get(toByteSequence(prefix), + getOption).get(); + } catch (InterruptedException | ExecutionException e) { + throw new HugeException("Failed to scan etcd with prefix '%s'", + e, prefix); + } + int size = (int) response.getCount(); + Map keyValues = CollectionFactory.newMap( + CollectionType.JCF, size); + for (KeyValue kv : response.getKvs()) { + String key = kv.getKey().toString(Charset.defaultCharset()); + String value = kv.getValue().size() == 0 ? "" : + kv.getValue().toString(Charset.defaultCharset()); + keyValues.put(key, value); + } + return keyValues; + } + + @Override + public List extractValuesFromResponse(T response) { + List values = new ArrayList<>(); + E.checkArgument(response instanceof WatchResponse, + "Invalid response type %s", response.getClass()); + for (WatchEvent event : ((WatchResponse) response).getEvents()) { + // Skip if not etcd PUT event + if (!isEtcdPut(event)) { + return null; + } + + String value = event.getKeyValue().getValue() + .toString(Charset.defaultCharset()); + values.add(value); + } + return values; + } + + @Override + public Map extractKVFromResponse(T response) { + E.checkArgument(response instanceof WatchResponse, + "Invalid response type %s", response.getClass()); + + Map resultMap = new HashMap<>(); + for (WatchEvent event : ((WatchResponse) response).getEvents()) { + // Skip if not etcd PUT event + if (!isEtcdPut(event)) { + continue; + } + + String key = event.getKeyValue().getKey().toString(Charset.defaultCharset()); + String value = event.getKeyValue().getValue() + .toString(Charset.defaultCharset()); + if (Strings.isNullOrEmpty(key)) { + continue; + } + resultMap.put(key, value); + } + return resultMap; + } + + @Override + public LockResult tryLock(String key, long ttl, long timeout) { + return this.lock.tryLock(key, ttl, timeout); + } + + @Override + public LockResult lock(String key, long ttl) { + return this.lock.lock(key, ttl); + } + + @Override + public boolean isLocked(String key) { + try { + long size = this.client.getKVClient().get(toByteSequence(key)) + .get().getCount(); + + if (size > 0) { + return true; + } else { + return false; + } + } catch (InterruptedException | ExecutionException e) { + throw new HugeException("Failed to check is locked '%s'", e, key); + } + } + + @Override + public void unlock(String key, LockResult lockResult) { + this.lock.unLock(key, lockResult); + } + + @SuppressWarnings("unchecked") + @Override + public void listen(String key, Consumer consumer) { + + this.client.getWatchClient().watch(toByteSequence(key), + (Consumer) consumer); + } + + /** + * Listen etcd key with prefix + */ + @SuppressWarnings("unchecked") + @Override + public void listenPrefix(String prefix, Consumer consumer) { + ByteSequence sequence = toByteSequence(prefix); + WatchOption option = WatchOption.newBuilder().isPrefix(true).build(); + this.client.getWatchClient().watch(sequence, option, (Consumer) consumer); + + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaDriver.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaDriver.java new file mode 100644 index 0000000000..9b949b01cd --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaDriver.java @@ -0,0 +1,76 @@ +/* + * 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.hugegraph.meta; + +import java.util.List; +import java.util.Map; +import java.util.function.Consumer; + +import org.apache.hugegraph.meta.lock.LockResult; + +public interface MetaDriver { + + public void put(String key, String value); + + public String get(String key); + + public void delete(String key); + + public void deleteWithPrefix(String prefix); + + public Map scanWithPrefix(String prefix); + + public void listen(String key, Consumer consumer); + + public void listenPrefix(String prefix, Consumer consumer); + + public List extractValuesFromResponse(T response); + + /** + * Extract K-V pairs of response + * + * @param + * @param response + * @return + */ + public Map extractKVFromResponse(T response); + + @Deprecated + public LockResult lock(String key, long ttl); + + public LockResult tryLock(String key, long ttl, long timeout); + + /** + * return if the key is Locked. + * + * @param key + * @return bool + */ + public boolean isLocked(String key); + + public void unlock(String key, LockResult lockResult); + + /** + * keepAlive of current lease + * + * @param key + * @param lease + * @return next leaseId + */ + public long keepAlive(String key, long lease); +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaManager.java new file mode 100644 index 0000000000..39314cf484 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaManager.java @@ -0,0 +1,1312 @@ +/* + * 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.hugegraph.meta; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.function.Consumer; + +import org.apache.commons.lang3.StringUtils; +import org.apache.hugegraph.auth.HugeAccess; +import org.apache.hugegraph.auth.HugeBelong; +import org.apache.hugegraph.auth.HugeGroup; +import org.apache.hugegraph.auth.HugePermission; +import org.apache.hugegraph.auth.HugeRole; +import org.apache.hugegraph.auth.HugeTarget; +import org.apache.hugegraph.auth.HugeUser; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.meta.lock.LockResult; +import org.apache.hugegraph.meta.managers.AuthMetaManager; +import org.apache.hugegraph.meta.managers.ConfigMetaManager; +import org.apache.hugegraph.meta.managers.GraphMetaManager; +import org.apache.hugegraph.meta.managers.KafkaMetaManager; +import org.apache.hugegraph.meta.managers.LockMetaManager; +import org.apache.hugegraph.meta.managers.SchemaMetaManager; +import org.apache.hugegraph.meta.managers.SchemaTemplateMetaManager; +import org.apache.hugegraph.meta.managers.ServiceMetaManager; +import org.apache.hugegraph.meta.managers.SpaceMetaManager; +import org.apache.hugegraph.meta.managers.TaskMetaManager; +import org.apache.hugegraph.schema.EdgeLabel; +import org.apache.hugegraph.schema.IndexLabel; +import org.apache.hugegraph.schema.PropertyKey; +import org.apache.hugegraph.schema.VertexLabel; +import org.apache.hugegraph.space.GraphSpace; +import org.apache.hugegraph.space.SchemaTemplate; +import org.apache.hugegraph.space.Service; +import org.apache.hugegraph.util.E; + +import com.google.common.collect.ImmutableMap; + +public class MetaManager { + + public static final String META_PATH_DELIMITER = "/"; + public static final String META_PATH_JOIN = "-"; + + public static final String META_PATH_HUGEGRAPH = "HUGEGRAPH"; + public static final String META_PATH_GRAPHSPACE = "GRAPHSPACE"; + public static final String META_PATH_GRAPHSPACE_LIST = "GRAPHSPACE_LIST"; + public static final String META_PATH_SERVICE = "SERVICE"; + public static final String META_PATH_SERVICE_CONF = "SERVICE_CONF"; + public static final String META_PATH_GRAPH_CONF = "GRAPH_CONF"; + public static final String META_PATH_CONF = "CONF"; + public static final String META_PATH_GRAPH = "GRAPH"; + public static final String META_PATH_SCHEMA = "SCHEMA"; + public static final String META_PATH_PROPERTY_KEY = "PROPERTY_KEY"; + public static final String META_PATH_VERTEX_LABEL = "VERTEX_LABEL"; + public static final String META_PATH_EDGE_LABEL = "EDGE_LABEL"; + public static final String META_PATH_INDEX_LABEL = "INDEX_LABEL"; + public static final String META_PATH_NAME = "NAME"; + public static final String META_PATH_ID = "ID"; + public static final String META_PATH_AUTH = "AUTH"; + public static final String META_PATH_USER = "USER"; + public static final String META_PATH_GROUP = "GROUP"; + public static final String META_PATH_ROLE = "ROLE"; + public static final String META_PATH_TARGET = "TARGET"; + public static final String META_PATH_BELONG = "BELONG"; + public static final String META_PATH_ACCESS = "ACCESS"; + public static final String META_PATH_K8S_BINDINGS = "BINDING"; + public static final String META_PATH_REST_PROPERTIES = "REST_PROPERTIES"; + public static final String META_PATH_GREMLIN_YAML = "GREMLIN_YAML"; + public static final String META_PATH_SCHEMA_TEMPLATE = "SCHEMA_TEMPLATE"; + public static final String META_PATH_TASK = "TASK"; + public static final String META_PATH_TASK_LOCK = "TASK_LOCK"; + public static final String META_PATH_AUTH_EVENT = "AUTH_EVENT"; + public static final String META_PATH_EVENT = "EVENT"; + public static final String META_PATH_ADD = "ADD"; + public static final String META_PATH_REMOVE = "REMOVE"; + public static final String META_PATH_UPDATE = "UPDATE"; + public static final String META_PATH_CLEAR = "CLEAR"; + public static final String META_PATH_DDS = "DDS_HOST"; + public static final String META_PATH_METRICS = "METRICS"; + public static final String META_PATH_KAFKA = "KAFKA"; + public static final String META_PATH_HOST = "BROKER_HOST"; + public static final String META_PATH_PORT = "BROKER_PORT"; + public static final String META_PATH_PARTITION_COUNT = "PARTITION_COUNT"; + public static final String META_PATH_DATA_SYNC_ROLE = "DATA_SYNC_ROLE"; + public static final String META_PATH_SLAVE_SERVER_HOST = "SLAVE_SERVER_HOST"; + public static final String META_PATH_SLAVE_SERVER_PORT = "SLAVE_SERVER_PORT"; + public static final String META_PATH_SYNC_BROKER = "SYNC_BROKER"; + public static final String META_PATH_SYNC_STORAGE = "SYNC_STORAGE"; + public static final String META_PATH_KAFKA_FILTER = "KAFKA-FILTER"; + public static final String META_PATH_WHITE_IP_LIST = "WHITE_IP_LIST"; + public static final String META_PATH_WHITE_IP_STATUS = "WHITE_IP_STATUS"; + public static final long LOCK_DEFAULT_LEASE = 30L; + public static final long LOCK_DEFAULT_TIMEOUT = 10L; + public static final int RANDOM_USER_ID = 100; + private static final String META_PATH_URLS = "URLS"; + private static final String META_PATH_PD_PEERS = "HSTORE_PD_PEERS"; + private static final MetaManager INSTANCE = new MetaManager(); + private MetaDriver metaDriver; + private String cluster; + private AuthMetaManager authMetaManager; + private GraphMetaManager graphMetaManager; + private SchemaMetaManager schemaMetaManager; + private ServiceMetaManager serviceMetaManager; + private SpaceMetaManager spaceMetaManager; + private TaskMetaManager taskMetaManager; + private ConfigMetaManager configMetaManager; + private KafkaMetaManager kafkaMetaManager; + private SchemaTemplateMetaManager schemaTemplateManager; + private LockMetaManager lockMetaManager; + + private MetaManager() { + } + + public static MetaManager instance() { + return INSTANCE; + } + + public synchronized boolean isReady() { + return null != this.metaDriver; + } + + public String cluster() { + return this.cluster; + } + + public synchronized void connect(String cluster, MetaDriverType type, + String trustFile, String clientCertFile, + String clientKeyFile, Object... args) { + E.checkArgument(cluster != null && !cluster.isEmpty(), + "The cluster can't be null or empty"); + if (this.metaDriver == null) { + this.cluster = cluster; + + switch (type) { + case ETCD: + this.metaDriver = trustFile == null || trustFile.isEmpty() ? + new EtcdMetaDriver(args) : + new EtcdMetaDriver(trustFile, + clientCertFile, + clientKeyFile, args); + break; + case PD: + assert args.length > 0; + String pdPeer = String.join(",", (List) args[0]); + this.metaDriver = new PdMetaDriver(pdPeer); + break; + default: + throw new AssertionError(String.format( + "Invalid meta driver type: %s", type)); + } + } + this.initManagers(this.cluster); + } + + private void initManagers(String cluster) { + this.authMetaManager = new AuthMetaManager(this.metaDriver, cluster); + this.graphMetaManager = new GraphMetaManager(this.metaDriver, cluster); + this.schemaMetaManager = new SchemaMetaManager(this.metaDriver, cluster, null); + this.serviceMetaManager = new ServiceMetaManager(this.metaDriver, cluster); + this.spaceMetaManager = new SpaceMetaManager(this.metaDriver, cluster); + this.taskMetaManager = new TaskMetaManager(this.metaDriver, cluster); + this.configMetaManager = new ConfigMetaManager(this.metaDriver, cluster); + this.kafkaMetaManager = new KafkaMetaManager(this.metaDriver, cluster); + this.schemaTemplateManager = new SchemaTemplateMetaManager(this.metaDriver, cluster); + this.lockMetaManager = new LockMetaManager(this.metaDriver, cluster); + } + + public void listenGraphSpaceAdd(Consumer consumer) { + this.spaceMetaManager.listenGraphSpaceAdd(consumer); + } + + public void listenGraphSpaceRemove(Consumer consumer) { + this.spaceMetaManager.listenGraphSpaceRemove(consumer); + } + + public void listenGraphSpaceUpdate(Consumer consumer) { + this.spaceMetaManager.listenGraphSpaceUpdate(consumer); + } + + public void notifyGraphSpaceAdd(String graphSpace) { + this.spaceMetaManager.notifyGraphSpaceAdd(graphSpace); + } + + public void notifyGraphSpaceRemove(String graphSpace) { + this.spaceMetaManager.notifyGraphSpaceRemove(graphSpace); + } + + public void notifyGraphSpaceUpdate(String graphSpace) { + this.spaceMetaManager.notifyGraphSpaceUpdate(graphSpace); + } + + public void listenServiceAdd(Consumer consumer) { + this.serviceMetaManager.listenServiceAdd(consumer); + } + + public void listenServiceRemove(Consumer consumer) { + this.serviceMetaManager.listenServiceRemove(consumer); + } + + public void listenServiceUpdate(Consumer consumer) { + this.serviceMetaManager.listenServiceUpdate(consumer); + } + + public void listenGraphAdd(Consumer consumer) { + this.graphMetaManager.listenGraphAdd(consumer); + } + + public void listenGraphUpdate(Consumer consumer) { + this.graphMetaManager.listenGraphUpdate(consumer); + } + + public void listenGraphRemove(Consumer consumer) { + this.graphMetaManager.listenGraphRemove(consumer); + } + + public void listenGraphClear(Consumer consumer) { + this.graphMetaManager.listenGraphClear(consumer); + } + + public void listenSchemaCacheClear(Consumer consumer) { + this.graphMetaManager.listenSchemaCacheClear(consumer); + } + + public void listenGraphCacheClear(Consumer consumer) { + this.graphMetaManager.listenGraphCacheClear(consumer); + } + + /** + * 监听vertex label变化, graph vertex cache clear + * + * @param consumer + * @param + */ + public void listenGraphVertexCacheClear(Consumer consumer) { + this.graphMetaManager.listenGraphVertexCacheClear(consumer); + } + + /** + * 监听edge label变化, graph edge cache clear + * + * @param consumer + * @param + */ + public void listenGraphEdgeCacheClear(Consumer consumer) { + this.graphMetaManager.listenGraphEdgeCacheClear(consumer); + } + + public void listenRestPropertiesUpdate(String graphSpace, + String serviceId, + Consumer consumer) { + this.configMetaManager.listenRestPropertiesUpdate(graphSpace, + serviceId, + consumer); + } + + public void listenGremlinYamlUpdate(String graphSpace, + String serviceId, + Consumer consumer) { + this.configMetaManager.listenGremlinYamlUpdate(graphSpace, + serviceId, + consumer); + } + + public void listenAuthEvent(Consumer consumer) { + this.authMetaManager.listenAuthEvent(consumer); + } + + private void putAuthEvent(AuthEvent event) { + this.authMetaManager.putAuthEvent(event); + } + + public void listenKafkaConfig(Consumer consumer) { + this.kafkaMetaManager.listenKafkaConfig(consumer); + } + + public String kafkaGetRaw(String key) { + return this.kafkaMetaManager.getRaw(key); + } + + public void kafkaPutOrDeleteRaw(String key, String val) { + this.kafkaMetaManager.putOrDeleteRaw(key, val); + } + + public Map graphSpaceConfigs() { + return this.spaceMetaManager.graphSpaceConfigs(); + } + + public Map serviceConfigs(String graphSpace) { + return this.serviceMetaManager.serviceConfigs(graphSpace); + } + + public Map> graphConfigs(String graphSpace) { + return this.graphMetaManager.graphConfigs(graphSpace); + } + + public Set schemaTemplates(String graphSpace) { + return this.schemaTemplateManager.schemaTemplates(graphSpace); + } + + @SuppressWarnings("unchecked") + public SchemaTemplate schemaTemplate(String graphSpace, + String schemaTemplate) { + return this.schemaTemplateManager.schemaTemplate(graphSpace, + schemaTemplate); + } + + public void addSchemaTemplate(String graphSpace, SchemaTemplate template) { + this.schemaTemplateManager.addSchemaTemplate(graphSpace, template); + } + + public void updateSchemaTemplate(String graphSpace, + SchemaTemplate template) { + this.schemaTemplateManager.updateSchemaTemplate(graphSpace, template); + } + + public void removeSchemaTemplate(String graphSpace, String name) { + this.schemaTemplateManager.removeSchemaTemplate(graphSpace, name); + } + + public void clearSchemaTemplate(String graphSpace) { + this.schemaTemplateManager.clearSchemaTemplate(graphSpace); + } + + public String extractGraphSpaceFromKey(String key) { + String[] parts = key.split(META_PATH_DELIMITER); + if (parts.length < 4) { + return null; + } + if (parts[3].equals(META_PATH_CONF)) { + return parts.length < 5 ? null : parts[4]; + } + return parts[3]; + } + + public List extractGraphFromKey(String key) { + String[] parts = key.split(META_PATH_DELIMITER); + if (parts.length < 6) { + return Collections.EMPTY_LIST; + } + return Arrays.asList(parts[3], parts[5]); + } + + public List extractGraphSpacesFromResponse(T response) { + return this.metaDriver.extractValuesFromResponse(response); + } + + public List extractServicesFromResponse(T response) { + return this.metaDriver.extractValuesFromResponse(response); + } + + public List extractGraphsFromResponse(T response) { + return this.metaDriver.extractValuesFromResponse(response); + } + + public Map extractKVFromResponse(T response) { + return this.metaDriver.extractKVFromResponse(response); + } + + public GraphSpace getGraphSpaceConfig(String graphSpace) { + return this.spaceMetaManager.getGraphSpaceConfig(graphSpace); + } + + public String getServiceRawConfig(String graphSpace, String service) { + return this.serviceMetaManager.getServiceRawConfig(graphSpace, service); + } + + public Service parseServiceRawConfig(String serviceRawConf) { + return this.serviceMetaManager.parseServiceRawConfig(serviceRawConf); + } + + public Service getServiceConfig(String graphSpace, String service) { + return this.serviceMetaManager.getServiceConfig(graphSpace, service); + } + + public Map getGraphConfig(String graphSpace, String graph) { + return this.graphMetaManager.getGraphConfig(graphSpace, graph); + } + + public void addGraphConfig(String graphSpace, String graph, + Map configs) { + this.graphMetaManager.addGraphConfig(graphSpace, graph, configs); + } + + public void updateGraphConfig(String graphSpace, String graph, + Map configs) { + this.graphMetaManager.updateGraphConfig(graphSpace, graph, configs); + } + + public GraphSpace graphSpace(String name) { + return this.spaceMetaManager.graphSpace(name); + } + + public void addGraphSpaceConfig(String name, GraphSpace space) { + this.spaceMetaManager.addGraphSpaceConfig(name, space); + } + + public void removeGraphSpaceConfig(String name) { + this.spaceMetaManager.removeGraphSpaceConfig(name); + } + + public void updateGraphSpaceConfig(String name, GraphSpace space) { + this.spaceMetaManager.updateGraphSpaceConfig(name, space); + } + + public void appendGraphSpaceList(String name) { + this.spaceMetaManager.appendGraphSpaceList(name); + } + + public void clearGraphSpaceList(String name) { + this.spaceMetaManager.clearGraphSpaceList(name); + } + + public void notifyServiceAdd(String graphSpace, String name) { + this.serviceMetaManager.notifyServiceAdd(graphSpace, name); + } + + public void notifyServiceRemove(String graphSpace, String name) { + this.serviceMetaManager.notifyServiceRemove(graphSpace, name); + } + + public void notifyServiceUpdate(String graphSpace, String name) { + this.serviceMetaManager.notifyServiceUpdate(graphSpace, name); + } + + public Service service(String graphSpace, String name) { + return this.serviceMetaManager.service(graphSpace, name); + } + + public void addServiceConfig(String graphSpace, Service service) { + this.serviceMetaManager.addServiceConfig(graphSpace, service); + } + + public void removeServiceConfig(String graphSpace, String service) { + this.serviceMetaManager.removeServiceConfig(graphSpace, service); + } + + public void updateServiceConfig(String graphSpace, Service service) { + this.addServiceConfig(graphSpace, service); + } + + public void removeGraphConfig(String graphSpace, String graph) { + this.graphMetaManager.removeGraphConfig(graphSpace, graph); + } + + public void notifyGraphAdd(String graphSpace, String graph) { + this.graphMetaManager.notifyGraphAdd(graphSpace, graph); + } + + public void notifyGraphRemove(String graphSpace, String graph) { + this.graphMetaManager.notifyGraphRemove(graphSpace, graph); + } + + public void notifyGraphUpdate(String graphSpace, String graph) { + this.graphMetaManager.notifyGraphUpdate(graphSpace, graph); + } + + public void notifyGraphClear(String graphSpace, String graph) { + this.graphMetaManager.notifyGraphClear(graphSpace, graph); + } + + public void notifySchemaCacheClear(String graphSpace, String graph) { + this.graphMetaManager.notifySchemaCacheClear(graphSpace, graph); + } + + public void notifyGraphCacheClear(String graphSpace, String graph) { + this.graphMetaManager.notifyGraphCacheClear(graphSpace, graph); + } + + /** + * 通知 需要进行 graph vertex cache clear + * + * @param graphSpace + * @param graph + */ + public void notifyGraphVertexCacheClear(String graphSpace, String graph) { + this.graphMetaManager.notifyGraphVertexCacheClear(graphSpace, graph); + } + + /** + * 通知 需要进行 graph edge cache clear + * + * @param graphSpace + * @param graph + */ + public void notifyGraphEdgeCacheClear(String graphSpace, String graph) { + this.graphMetaManager.notifyGraphEdgeCacheClear(graphSpace, graph); + } + + public LockResult lock(String... keys) { + return this.lockMetaManager.lock(keys); + } + + public LockResult lock(long ttl, String... keys) { + return this.lockMetaManager.lock(ttl, keys); + } + + public LockResult lock(String key, long ttl) { + return this.lockMetaManager.lock(key, ttl); + } + + public LockResult lock(String key) { + return this.lockMetaManager.lock(key); + } + + public LockResult tryLock(String key) { + return this.lockMetaManager.tryLock(key); + } + + public void unlock(LockResult lockResult, String... keys) { + this.lockMetaManager.unlock(lockResult, keys); + } + + public void unlock(String key, LockResult lockResult) { + this.lockMetaManager.unlock(key, lockResult); + } + + public String belongId(String userName, String roleName) { + return this.authMetaManager.belongId(userName, roleName, HugeBelong.UR); + } + + public String belongId(String source, String target, String link) { + return this.authMetaManager.belongId(source, target, link); + } + + public String accessId(String roleName, String targetName, + HugePermission permission) { + return this.authMetaManager.accessId(roleName, targetName, permission); + } + + private String graphSpaceBindingsServer(String name, BindingType type) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/CONF/{graphspace} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + name, + META_PATH_K8S_BINDINGS, + type.name(), + META_PATH_URLS); + } + + /** + * Get DDS (eureka) host, format should be "ip:port", with no / + * + * @return + */ + private String ddsHostKey() { + // HUGEGRAPH/{cluster}/DDS_HOST + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_DDS); + } + + private String hugeClusterRoleKey() { + // HUGEGRAPH/{clusterRole}/KAFKA/DATA_SYNC_ROLE + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_KAFKA, + META_PATH_DATA_SYNC_ROLE); + } + + private String kafkaHostKey() { + // HUGEGRAPH/{cluster}/KAFKA/BROKER_HOST + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_KAFKA, + META_PATH_HOST); + } + + private String kafkaPortKey() { + // HUGEGRAPH/{cluster}/KAFKA/BROKER_PORT + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_KAFKA, + META_PATH_PORT); + } + + private String kafkaPartitionCountKey() { + // HUGEGRAPH/{cluster}/KAFKA/PARTITION_COUNT + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_KAFKA, + META_PATH_PARTITION_COUNT); + } + + private String kafkaSlaveHostKey() { + // HUGEGRAPH/{cluster}/KAFKA/SLAVE_SERVER_HOST + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_KAFKA, + META_PATH_SLAVE_SERVER_HOST); + } + + private String kafkaSlavePortKey() { + // HUGEGRAPH/{cluster}/KAFKA/SLAVE_SERVER_PORT + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_KAFKA, + META_PATH_SLAVE_SERVER_PORT); + } + + public String kafkaSyncBrokerKey() { + // HUGEGRAPH/{cluster}/KAFKA/SYNC_BROKER + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_KAFKA, + META_PATH_SYNC_BROKER); + } + + public String kafkaSyncStorageKey() { + // HUGEGRAPH/{cluster}/KAFKA/SYNC_STORAGE + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_KAFKA, + META_PATH_SYNC_STORAGE); + } + + public String kafkaFilterGraphspaceKey() { + // HUGEGRAPH/{cluster}/KAFKA-FILTER/GRAPHSPACE + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_KAFKA_FILTER, + META_PATH_GRAPHSPACE); + } + + public String kafkaFilterGraphKey() { + // HUGEGRAPH/{cluster}/KAFKA-FILTER/FILTER/GRAPH + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_KAFKA_FILTER, + META_PATH_GRAPH); + } + + private String whiteIpListKey() { + // HUGEGRAPH/{cluster}/WHITE_IP_LIST + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_WHITE_IP_LIST); + } + + private String whiteIpStatusKey() { + // HUGEGRAPH/{cluster}/WHITE_IP_STATUS + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_WHITE_IP_STATUS); + } + + private String hstorePDPeersKey() { + // HUGEGRAPH/{cluster}/META_PATH_PD_PEERS + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_PD_PEERS); + } + + public Id addPropertyKey(String graphSpace, String graph, + PropertyKey propertyKey) { + this.schemaMetaManager.addPropertyKey(graphSpace, graph, propertyKey); + return IdGenerator.ZERO; + } + + public void updatePropertyKey(String graphSpace, String graph, + PropertyKey pkey) { + this.schemaMetaManager.updatePropertyKey(graphSpace, graph, pkey); + } + + public PropertyKey getPropertyKey(String graphSpace, String graph, + Id propertyKey) { + return this.schemaMetaManager.getPropertyKey(graphSpace, graph, + propertyKey); + } + + public PropertyKey getPropertyKey(String graphSpace, String graph, + String propertyKey) { + return this.schemaMetaManager.getPropertyKey(graphSpace, graph, + propertyKey); + } + + public List getPropertyKeys(String graphSpace, String graph) { + return this.schemaMetaManager.getPropertyKeys(graphSpace, graph); + } + + public Id removePropertyKey(String graphSpace, String graph, + Id propertyKey) { + return this.schemaMetaManager.removePropertyKey(graphSpace, graph, + propertyKey); + } + + public void addVertexLabel(String graphSpace, String graph, + VertexLabel vertexLabel) { + this.schemaMetaManager.addVertexLabel(graphSpace, graph, vertexLabel); + } + + public void updateVertexLabel(String graphSpace, String graph, + VertexLabel vertexLabel) { + this.schemaMetaManager.updateVertexLabel(graphSpace, graph, + vertexLabel); + } + + public VertexLabel getVertexLabel(String graphSpace, String graph, + Id vertexLabel) { + return this.schemaMetaManager.getVertexLabel(graphSpace, graph, + vertexLabel); + } + + public VertexLabel getVertexLabel(String graphSpace, String graph, + String vertexLabel) { + return this.schemaMetaManager.getVertexLabel(graphSpace, graph, + vertexLabel); + } + + public List getVertexLabels(String graphSpace, String graph) { + return this.schemaMetaManager.getVertexLabels(graphSpace, graph); + } + + public Id removeVertexLabel(String graphSpace, String graph, + Id vertexLabel) { + return this.schemaMetaManager.removeVertexLabel(graphSpace, graph, + vertexLabel); + } + + public void addEdgeLabel(String graphSpace, String graph, + EdgeLabel edgeLabel) { + this.schemaMetaManager.addEdgeLabel(graphSpace, graph, edgeLabel); + } + + public void updateEdgeLabel(String graphSpace, String graph, + EdgeLabel edgeLabel) { + this.schemaMetaManager.updateEdgeLabel(graphSpace, graph, edgeLabel); + } + + + public EdgeLabel getEdgeLabel(String graphSpace, String graph, + Id edgeLabel) { + return this.schemaMetaManager.getEdgeLabel(graphSpace, graph, + edgeLabel); + } + + public EdgeLabel getEdgeLabel(String graphSpace, String graph, + String edgeLabel) { + return this.schemaMetaManager.getEdgeLabel(graphSpace, graph, + edgeLabel); + } + + public List getEdgeLabels(String graphSpace, String graph) { + return this.schemaMetaManager.getEdgeLabels(graphSpace, graph); + } + + public Id removeEdgeLabel(String graphSpace, String graph, Id edgeLabel) { + return this.schemaMetaManager.removeEdgeLabel(graphSpace, graph, + edgeLabel); + } + + public void addIndexLabel(String graphSpace, String graph, + IndexLabel indexLabel) { + this.schemaMetaManager.addIndexLabel(graphSpace, graph, indexLabel); + } + + public void updateIndexLabel(String graphSpace, String graph, + IndexLabel indexLabel) { + this.schemaMetaManager.updateIndexLabel(graphSpace, graph, indexLabel); + } + + public IndexLabel getIndexLabel(String graphSpace, String graph, + Id indexLabel) { + return this.schemaMetaManager.getIndexLabel(graphSpace, graph, + indexLabel); + } + + public IndexLabel getIndexLabel(String graphSpace, String graph, + String indexLabel) { + return this.schemaMetaManager.getIndexLabel(graphSpace, graph, + indexLabel); + } + + public List getIndexLabels(String graphSpace, String graph) { + return this.schemaMetaManager.getIndexLabels(graphSpace, graph); + } + + public Id removeIndexLabel(String graphSpace, String graph, Id indexLabel) { + return this.schemaMetaManager.removeIndexLabel(graphSpace, graph, + indexLabel); + } + + public void createUser(HugeUser user) throws IOException { + this.authMetaManager.createUser(user); + } + + public HugeUser updateUser(HugeUser user) throws IOException { + return this.authMetaManager.updateUser(user); + } + + public HugeUser deleteUser(Id id) throws IOException, + ClassNotFoundException { + return this.authMetaManager.deleteUser(id); + } + + public HugeUser findUser(String name) + throws IOException, ClassNotFoundException { + return this.authMetaManager.findUser(name); + } + + public List listUsers(List ids) throws IOException, + ClassNotFoundException { + return this.authMetaManager.listUsers(ids); + } + + public List listAllUsers(long limit) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listAllUsers(limit); + } + + public Id createGroup(HugeGroup group) throws IOException { + return this.authMetaManager.createGroup(group); + } + + public HugeGroup updateGroup(HugeGroup group) throws IOException { + return this.authMetaManager.updateGroup(group); + } + + public HugeGroup deleteGroup(Id id) throws IOException, + ClassNotFoundException { + return this.authMetaManager.deleteGroup(id); + } + + public HugeGroup findGroup(String name) throws IOException, + ClassNotFoundException { + return this.authMetaManager.findGroup(name); + } + + public List listGroups(long limit) throws IOException, + ClassNotFoundException { + return this.authMetaManager.listGroups(limit); + } + + public Id createRole(String graphSpace, HugeRole role) + throws IOException { + return this.authMetaManager.createRole(graphSpace, role); + } + + public HugeRole updateRole(String graphSpace, HugeRole role) + throws IOException { + return this.authMetaManager.updateRole(graphSpace, role); + } + + public HugeRole deleteRole(String graphSpace, Id id) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.deleteRole(graphSpace, id); + } + + public HugeRole findRole(String graphSpace, Id id) { + return this.authMetaManager.findRole(graphSpace, id); + } + + public HugeRole getRole(String graphSpace, Id id) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.getRole(graphSpace, id); + } + + public List listRoles(String graphSpace, List ids) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listRoles(graphSpace, ids); + } + + public List listAllRoles(String graphSpace, long limit) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listAllRoles(graphSpace, limit); + } + + public Id createTarget(String graphSpace, HugeTarget target) + throws IOException { + return this.authMetaManager.createTarget(graphSpace, target); + } + + public HugeTarget updateTarget(String graphSpace, HugeTarget target) + throws IOException { + return this.authMetaManager.updateTarget(graphSpace, target); + } + + public HugeTarget deleteTarget(String graphSpace, Id id) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.deleteTarget(graphSpace, id); + } + + public HugeTarget findTarget(String graphSpace, Id id) { + return this.authMetaManager.findTarget(graphSpace, id); + } + + public HugeTarget getTarget(String graphSpace, Id id) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.getTarget(graphSpace, id); + } + + public List listTargets(String graphSpace, List ids) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listTargets(graphSpace, ids); + } + + public List listAllTargets(String graphSpace, long limit) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listAllTargets(graphSpace, limit); + } + + public Id createBelong(String graphSpace, HugeBelong belong) + throws IOException, ClassNotFoundException { + return this.authMetaManager.createBelong(graphSpace, belong); + } + + public HugeBelong updateBelong(String graphSpace, HugeBelong belong) + throws IOException, ClassNotFoundException { + return this.authMetaManager.updateBelong(graphSpace, belong); + } + + public HugeBelong deleteBelong(String graphSpace, Id id) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.deleteBelong(graphSpace, id); + } + + public HugeBelong getBelong(String graphSpace, Id id) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.getBelong(graphSpace, id); + } + + public boolean existBelong(String graphSpace, Id id) { + return this.authMetaManager.existBelong(graphSpace, id); + } + + public List listBelong(String graphSpace, List ids) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listBelong(graphSpace, ids); + } + + public List listAllBelong(String graphSpace, long limit) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listAllBelong(graphSpace, limit); + } + + public List listBelongBySource(String graphSpace, + Id user, String link, long limit) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listBelongBySource(graphSpace, user, + link, limit); + } + + public List listBelongByTarget(String graphSpace, + Id role, String link, long limit) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listBelongByTarget(graphSpace, role, + link, limit); + } + + public Id createAccess(String graphSpace, HugeAccess access) + throws IOException, ClassNotFoundException { + return this.authMetaManager.createAccess(graphSpace, access); + } + + public HugeAccess updateAccess(String graphSpace, HugeAccess access) + throws IOException, ClassNotFoundException { + return this.authMetaManager.updateAccess(graphSpace, access); + } + + public HugeAccess deleteAccess(String graphSpace, Id id) + throws IOException, ClassNotFoundException { + return this.authMetaManager.deleteAccess(graphSpace, id); + } + + public HugeAccess findAccess(String graphSpace, Id id) { + return this.authMetaManager.findAccess(graphSpace, id); + } + + public HugeAccess getAccess(String graphSpace, Id id) + throws IOException, ClassNotFoundException { + return this.authMetaManager.getAccess(graphSpace, id); + } + + public List listAccess(String graphSpace, List ids) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listAccess(graphSpace, ids); + } + + public List listAllAccess(String graphSpace, long limit) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listAllAccess(graphSpace, limit); + } + + public List listAccessByRole(String graphSpace, + Id role, long limit) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listAccessByRole(graphSpace, role, limit); + } + + public String targetFromAccess(String accessKey) { + return this.authMetaManager.targetFromAccess(accessKey); + } + + public void clearGraphAuth(String graphSpace) { + this.authMetaManager.clearGraphAuth(graphSpace); + } + + public List listAccessByTarget(String graphSpace, + Id target, long limit) + throws IOException, + ClassNotFoundException { + return this.authMetaManager.listAccessByTarget(graphSpace, target, + limit); + } + + public List listGraphSpace() { + return this.spaceMetaManager.listGraphSpace(); + } + + public void initDefaultGraphSpace() { + String defaultGraphSpace = "DEFAULT"; + this.appendGraphSpaceList(defaultGraphSpace); + } + + public Map restProperties(String graphSpace, + String serviceId) { + return this.configMetaManager.restProperties(graphSpace, serviceId); + } + + public Map restProperties(String graphSpace, + String serviceId, + Map properties) { + return this.configMetaManager.restProperties(graphSpace, serviceId, + properties); + } + + public Map deleteRestProperties(String graphSpace, + String serviceId, + String key) { + return this.configMetaManager.deleteRestProperties(graphSpace, + serviceId, key); + } + + public Map clearRestProperties(String graphSpace, + String serviceId) { + return this.configMetaManager.clearRestProperties(graphSpace, + serviceId); + } + + public LockResult tryLockTask(String graphSpace, String graphName, + String taskId) { + return this.taskMetaManager.tryLockTask(graphSpace, graphName, taskId); + } + + public boolean isLockedTask(String graphSpace, String graphName, + String taskId) { + return this.taskMetaManager.isLockedTask(graphSpace, graphName, taskId); + } + + public void unlockTask(String graphSpace, String graphName, + String taskId, LockResult lockResult) { + this.taskMetaManager.unlockTask(graphSpace, graphName, taskId, lockResult); + } + + public String gremlinYaml(String graphSpace, String serviceId) { + return this.configMetaManager.gremlinYaml(graphSpace, serviceId); + } + + public String gremlinYaml(String graphSpace, String serviceId, + String yaml) { + return this.configMetaManager.gremlinYaml(graphSpace, serviceId, yaml); + } + + public String hstorePDPeers() { + return this.metaDriver.get(hstorePDPeersKey()); + } + + public void listenAll(Consumer consumer) { + this.metaDriver.listenPrefix(MetaManager.META_PATH_HUGEGRAPH, consumer); + } + + public SchemaMetaManager schemaMetaManager() { + return this.schemaMetaManager; + } + + public MetaDriver metaDriver() { + return this.metaDriver; + } + + public String getDDSHost() { + String key = this.ddsHostKey(); + String host = this.metaDriver.get(key); + return host; + } + + public String getHugeGraphClusterRole() { + String key = this.hugeClusterRoleKey(); + String role = this.metaDriver.get(key); + return role; + } + + public String getKafkaBrokerHost() { + String key = this.kafkaHostKey(); + return this.metaDriver.get(key); + } + + public String getKafkaBrokerPort() { + String key = this.kafkaPortKey(); + return this.metaDriver.get(key); + } + + public Integer getPartitionCount() { + String key = this.kafkaPartitionCountKey(); + String result = this.metaDriver.get(key); + try { + Integer count = Integer.parseInt(Optional.ofNullable(result) + .orElse("0")); + return count < 1 ? 1 : count; + } catch (Exception e) { + return 1; + } + } + + public String getKafkaSlaveServerHost() { + String key = this.kafkaSlaveHostKey(); + return this.metaDriver.get(key); + } + + public Integer getKafkaSlaveServerPort() { + String key = this.kafkaSlavePortKey(); + String portStr = this.metaDriver.get(key); + int port = Integer.parseInt(portStr); + return port; + } + + public List getKafkaFilteredGraphspace() { + String key = this.kafkaFilterGraphspaceKey(); + + String raw = this.metaDriver.get(key); + if (StringUtils.isEmpty(raw)) { + return Collections.EMPTY_LIST; + } + String[] parts = raw.split(","); + return Arrays.asList(parts); + } + + public List getKafkaFilteredGraph() { + String key = this.kafkaFilterGraphKey(); + + String raw = this.metaDriver.get(key); + if (StringUtils.isEmpty(raw)) { + return Collections.EMPTY_LIST; + } + String[] parts = raw.split(","); + return Arrays.asList(parts); + } + + public void updateKafkaFilteredGraphspace(List graphSpaces) { + String key = this.kafkaFilterGraphspaceKey(); + String val = String.join(",", graphSpaces); + this.metaDriver.put(key, val); + + } + + public void updateKafkaFilteredGraph(List graphs) { + String key = this.kafkaFilterGraphKey(); + String val = String.join(",", graphs); + this.metaDriver.put(key, val); + } + + public List getWhiteIpList() { + String key = this.whiteIpListKey(); + + String raw = this.metaDriver.get(key); + if (StringUtils.isEmpty(raw)) { + return new ArrayList<>(); + } + String[] parts = raw.split(","); + return new ArrayList<>(Arrays.asList(parts)); + } + + public void setWhiteIpList(List whiteIpList) { + String key = this.whiteIpListKey(); + + String val = String.join(",", whiteIpList); + this.metaDriver.put(key, val); + } + + public String getCompStatus(String statuskey) { + String raw = this.metaDriver.get(statuskey); + if (StringUtils.isEmpty(raw)) { + return ""; + } + return raw; + } + + public boolean getWhiteIpStatus() { + String key = this.whiteIpStatusKey(); + String raw = this.metaDriver.get(key); + return ("true".equals(raw)); + } + + public void setWhiteIpStatus(boolean status) { + String key = this.whiteIpStatusKey(); + this.metaDriver.put(key, ((Boolean) status).toString()); + } + + public enum MetaDriverType { + ETCD, + PD + } + + public enum BindingType { + OLTP, + OLAP, + STORAGE + } + + public static class AuthEvent { + private String op; // ALLOW: CREATE | DELETE | UPDATE + private String type; // ALLOW: USER | GROUP | TARGET | ACCESS | BELONG + private String id; + + public AuthEvent(String op, String type, String id) { + this.op = op; + this.type = type; + this.id = id; + } + + public AuthEvent(Map properties) { + this.op = properties.get("op").toString(); + this.type = properties.get("type").toString(); + this.id = properties.get("id").toString(); + } + + public String op() { + return this.op; + } + + public void op(String op) { + this.op = op; + } + + public String type() { + return this.type; + } + + public void type(String type) { + this.type = type; + } + + public String id() { + return this.id; + } + + public void id(String id) { + this.id = id; + } + + public Map asMap() { + return ImmutableMap.of("op", this.op, + "type", this.type, + "id", this.id); + } + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/PdMetaDriver.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/PdMetaDriver.java new file mode 100644 index 0000000000..1e4813a195 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/PdMetaDriver.java @@ -0,0 +1,250 @@ +/* + * 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.hugegraph.meta; + +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.function.Consumer; + +import org.apache.hugegraph.HugeException; +import org.apache.hugegraph.meta.lock.LockResult; +import org.apache.hugegraph.meta.lock.PdDistributedLock; +import org.apache.hugegraph.pd.client.KvClient; +import org.apache.hugegraph.pd.client.PDClient; +import org.apache.hugegraph.pd.client.PDConfig; +import org.apache.hugegraph.pd.common.PDException; +import org.apache.hugegraph.pd.grpc.kv.KResponse; +import org.apache.hugegraph.pd.grpc.kv.LockResponse; +import org.apache.hugegraph.pd.grpc.kv.ScanPrefixResponse; +import org.apache.hugegraph.pd.grpc.kv.TTLResponse; +import org.apache.hugegraph.pd.grpc.kv.WatchEvent; +import org.apache.hugegraph.pd.grpc.kv.WatchResponse; +import org.apache.hugegraph.pd.grpc.kv.WatchType; + +import com.google.common.base.Strings; + +public class PdMetaDriver implements MetaDriver { + + KvClient client = null; + PDClient pdClient = null; + private PdDistributedLock lock; + + public PdMetaDriver(String pdPeer) { + PDConfig pdConfig = PDConfig.of(pdPeer); + this.client = new KvClient<>(pdConfig); + this.pdClient = PDClient.create(pdConfig); + lock = new PdDistributedLock(this.client); + } + + public static void main(String[] args) { + PDConfig pdConfig = PDConfig.of("127.0.0.1:8686"); + KvClient client = new KvClient<>(pdConfig); + ScanPrefixResponse contents; + try { + contents = client.scanPrefix("HUGEGRAPH/METRICS"); + Map map = contents.getKvsMap(); + for (Map.Entry entry : map.entrySet()) { + System.out.println(entry.getKey() + ":" + entry.getValue()); + } + System.out.println(map.size()); + } catch (PDException e) { + e.printStackTrace(); + } + Date dNow = new Date(); + System.out.println(dNow); + SimpleDateFormat ft = new SimpleDateFormat("HHmmss"); + System.out.println("当前时间为: " + ft.format(dNow)); + } + + public PDClient pdClient() { + return this.pdClient; + } + + @Override + public void put(String key, String value) { + try { + this.client.put(key, value); + } catch (PDException e) { + throw new HugeException("Failed to put '%s:%s' to pd", e, key, value); + } + } + + @Override + public String get(String key) { + try { + KResponse response = this.client.get(key); + return response.getValue(); + } catch (PDException e) { + throw new HugeException("Failed to get '%s' from pd", e, key); + } + } + + @Override + public void delete(String key) { + try { + this.client.delete(key); + } catch (PDException e) { + throw new HugeException("Failed to delete '%s' from pd", e, key); + } + } + + @Override + public void deleteWithPrefix(String prefix) { + try { + this.client.deletePrefix(prefix); + } catch (PDException e) { + throw new HugeException("Failed to deleteWithPrefix '%s' from pd", e, prefix); + } + } + + @Override + public Map scanWithPrefix(String prefix) { + try { + ScanPrefixResponse response = this.client.scanPrefix(prefix); + return response.getKvsMap(); + } catch (PDException e) { + throw new HugeException("Failed to scanWithPrefix '%s' from pd", e, prefix); + } + } + + @Override + public void listen(String key, Consumer consumer) { + try { + this.client.listen(key, (Consumer) consumer); + } catch (PDException e) { + throw new HugeException("Failed to listen '%s' to pd", e, key); + } + } + + @Override + public void listenPrefix(String prefix, Consumer consumer) { + try { + this.client.listenPrefix(prefix, (Consumer) consumer); + } catch (PDException e) { + throw new HugeException("Failed to listenPrefix '%s' to pd", e, prefix); + } + } + + @Override + public List extractValuesFromResponse(T response) { + List values = new ArrayList<>(); + WatchResponse res = (WatchResponse) response; + for (WatchEvent event : res.getEventsList()) { + // Skip if not PUT event + if (!event.getType().equals(WatchType.Put)) { + return null; + } + String value = event.getCurrent().getValue(); + values.add(value); + } + return values; + } + + @Override + public Map extractKVFromResponse(T response) { + Map resultMap = new HashMap<>(); + WatchResponse res = (WatchResponse) response; + for (WatchEvent event : res.getEventsList()) { + // Skip if not etcd PUT event + if (!event.getType().equals(WatchType.Put)) { + continue; + } + + String key = event.getCurrent().getKey(); + String value = event.getCurrent().getValue(); + if (Strings.isNullOrEmpty(key)) { + continue; + } + resultMap.put(key, value); + } + return resultMap; + } + + @Override + public LockResult lock(String key, long ttl) { + while (true) { + LockResult lock = this.lock.lock(key, ttl); + if (lock.lockSuccess()) { + return lock; + } else { + try { + Thread.sleep(1000L); + } catch (Exception e) { + + } + } + } + } + + @Override + public LockResult tryLock(String key, long ttl, long timeout) { + return this.lock.lock(key, ttl); + } + + @Override + public boolean isLocked(String key) { + LockResponse locked; + try { + locked = this.client.isLocked(key); + } catch (PDException e) { + throw new HugeException("Failed to get isLocked '%s' from pd", key); + } + return locked.getSucceed(); + } + + @Override + public void unlock(String key, LockResult lockResult) { + this.lock.unLock(key, lockResult); + } + + @Override + public long keepAlive(String key, long lease) { + try { + LockResponse lockResponse = this.client.keepAlive(key); + boolean succeed = lockResponse.getSucceed(); + if (!succeed) { + throw new HugeException("Failed to keepAlive '%s' to pd", key); + } + return lockResponse.getClientId(); + } catch (PDException e) { + throw new HugeException("Failed to keepAlive '%s' to pd", e, key); + } + } + + public boolean keepTTLAlive(String key) { + try { + TTLResponse response = this.client.keepTTLAlive(key); + return response.getSucceed(); + } catch (PDException e) { + throw new HugeException("Failed to keepTTLAlive '%s' to pd", e, key); + } + } + + public boolean putTTL(String key, String value, long ttl) { + try { + TTLResponse response = this.client.putTTL(key, value, ttl); + return response.getSucceed(); + } catch (PDException e) { + throw new HugeException("Failed to keepTTLAlive '%s' to pd", e, key); + } + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/AbstractDistributedLock.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/AbstractDistributedLock.java new file mode 100644 index 0000000000..4cc9aacf26 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/AbstractDistributedLock.java @@ -0,0 +1,51 @@ +/* + * 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.hugegraph.meta.lock; + +import org.apache.hugegraph.pd.client.KvClient; + +import io.etcd.jetcd.Client; + +/** + * @author zhangyingjie + * @date 2022/6/18 + **/ +public abstract class AbstractDistributedLock { + + private static volatile AbstractDistributedLock defaultLock; + + public static AbstractDistributedLock getInstance(AutoCloseable client) { + if (defaultLock == null) { + synchronized (AbstractDistributedLock.class) { + if (defaultLock == null) { + if (client instanceof Client) { + defaultLock = DistributedLock.getInstance((Client) client); + } else { + defaultLock = new PdDistributedLock((KvClient) client); + } + + } + } + } + return defaultLock; + } + + public abstract LockResult lock(String key, long ttl); + + public abstract void unLock(String key, LockResult lockResult); +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/DistributedLock.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/DistributedLock.java new file mode 100644 index 0000000000..5e45806fc5 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/DistributedLock.java @@ -0,0 +1,164 @@ +/* + * 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.hugegraph.meta.lock; + +import java.nio.charset.Charset; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +import org.apache.hugegraph.util.Log; +import org.slf4j.Logger; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.KV; +import io.etcd.jetcd.Lease; +import io.etcd.jetcd.Lock; + +public class DistributedLock extends AbstractDistributedLock { + + protected static final Logger LOG = Log.logger(DistributedLock.class); + private static final long UNLIMIT_TIMEOUT = -1L; + private final static Object mutex = new Object(); + private static DistributedLock lockProvider = null; + private final KV kvClient; + private final Lock lockClient; + private final Lease leaseClient; + + private DistributedLock(Client client) { + this.kvClient = client.getKVClient(); + this.lockClient = client.getLockClient(); + this.leaseClient = client.getLeaseClient(); + } + + public static DistributedLock getInstance(Client client) { + synchronized (mutex) { + if (null == lockProvider) { + lockProvider = new DistributedLock(client); + } + } + return lockProvider; + } + + private static ByteSequence toByteSequence(String content) { + return ByteSequence.from(content, Charset.defaultCharset()); + } + + public LockResult tryLock(String lockName, long ttl, long timeout) { + LockResult lockResult = new LockResult(); + ScheduledExecutorService service = + Executors.newSingleThreadScheduledExecutor(); + + lockResult.lockSuccess(false); + lockResult.setService(service); + + Long leaseId; + + try { + leaseId = this.leaseClient.grant(ttl).get().getID(); + } catch (InterruptedException | ExecutionException e) { + LOG.warn(String.format("Thread {} failed to create lease for {} " + + "with ttl {}", Thread.currentThread().getName(), + lockName, ttl), + e); + return lockResult; + } + + lockResult.setLeaseId(leaseId); + + long period = ttl - ttl / 5; + service.scheduleAtFixedRate(new KeepAliveTask(this.leaseClient, leaseId), + period, period, TimeUnit.SECONDS); + + try { + if (timeout == UNLIMIT_TIMEOUT) { + this.lockClient.lock(toByteSequence(lockName), leaseId).get(); + + } else { + this.lockClient.lock(toByteSequence(lockName), leaseId) + .get(1, TimeUnit.SECONDS); + } + } catch (InterruptedException | ExecutionException e) { + LOG.warn(String.format("Thread {} failed to lock {}", + Thread.currentThread().getName(), lockName), + e); + service.shutdown(); + this.revokeLease(leaseId); + return lockResult; + } catch (TimeoutException e) { + // 获取锁超时 + LOG.warn("Thread {} timeout to lock {}", + Thread.currentThread().getName(), lockName); + service.shutdown(); + this.revokeLease(leaseId); + return lockResult; + } + + lockResult.lockSuccess(true); + + return lockResult; + } + + @Override + public LockResult lock(String lockName, long ttl) { + return tryLock(lockName, ttl, UNLIMIT_TIMEOUT); + } + + @Override + public void unLock(String lockName, LockResult lockResult) { + LOG.debug("Thread {} start to unlock {}", + Thread.currentThread().getName(), lockName); + + lockResult.getService().shutdown(); + + if (lockResult.getLeaseId() != 0L) { + this.revokeLease(lockResult.getLeaseId()); + } + + LOG.debug("Thread {} unlock {} successfully", + Thread.currentThread().getName(), lockName); + } + + private void revokeLease(long leaseId) { + try { + this.leaseClient.revoke(leaseId).get(); + } catch (InterruptedException | ExecutionException e) { + LOG.warn(String.format("Thread %s failed to revoke release %s", + Thread.currentThread().getName(), leaseId), e); + } + } + + public static class KeepAliveTask implements Runnable { + + private final Lease leaseClient; + private final long leaseId; + + KeepAliveTask(Lease leaseClient, long leaseId) { + this.leaseClient = leaseClient; + this.leaseId = leaseId; + } + + @Override + public void run() { + this.leaseClient.keepAliveOnce(this.leaseId); + } + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/LockResult.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/LockResult.java new file mode 100644 index 0000000000..4357cc9a80 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/LockResult.java @@ -0,0 +1,61 @@ +/* + * 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.hugegraph.meta.lock; + +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledFuture; + +public class LockResult { + + private boolean lockSuccess; + private long leaseId; + private ScheduledExecutorService service; + private ScheduledFuture future; + + public void lockSuccess(boolean isLockSuccess) { + this.lockSuccess = isLockSuccess; + } + + public boolean lockSuccess() { + return this.lockSuccess; + } + + public long getLeaseId() { + return this.leaseId; + } + + public void setLeaseId(long leaseId) { + this.leaseId = leaseId; + } + + public ScheduledExecutorService getService() { + return this.service; + } + + public void setService(ScheduledExecutorService service) { + this.service = service; + } + + public ScheduledFuture getFuture() { + return future; + } + + public void setFuture(ScheduledFuture future) { + this.future = future; + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/PdDistributedLock.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/PdDistributedLock.java new file mode 100644 index 0000000000..59f7f93801 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/PdDistributedLock.java @@ -0,0 +1,100 @@ +/* + * 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.hugegraph.meta.lock; + +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledFuture; +import java.util.concurrent.ScheduledThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +import org.apache.hugegraph.HugeException; +import org.apache.hugegraph.pd.client.KvClient; +import org.apache.hugegraph.pd.common.PDException; +import org.apache.hugegraph.pd.grpc.kv.LockResponse; + +/** + * @author zhangyingjie + * @date 2022/6/18 + **/ +public class PdDistributedLock extends AbstractDistributedLock { + + private static int poolSize = 8; + private final KvClient client; + private ScheduledExecutorService service = new ScheduledThreadPoolExecutor(poolSize, r -> { + Thread t = new Thread(r); + t.setDaemon(true); + return t; + }); + + public PdDistributedLock(KvClient client) { + this.client = client; + } + + @Override + public LockResult lock(String key, long second) { + long ttl = second * 1000L; + try { + LockResponse response = this.client.lock(key, ttl); + boolean succeed = response.getSucceed(); + LockResult result = new LockResult(); + if (succeed) { + result.setLeaseId(response.getClientId()); + result.lockSuccess(true); + long period = ttl - ttl / 4; + ScheduledFuture future = service.scheduleAtFixedRate(() -> { + synchronized (result) { + keepAlive(key); + } + }, 10, period, TimeUnit.MILLISECONDS); + result.setFuture(future); + } + return result; + } catch (PDException e) { + throw new HugeException("Failed to lock '%s' to pd", e, key); + } + } + + @Override + public void unLock(String key, LockResult lockResult) { + try { + LockResponse response = this.client.unlock(key); + boolean succeed = response.getSucceed(); + if (succeed == false) { + throw new HugeException("Failed to unlock '%s' to pd", key); + } + if (lockResult.getFuture() != null) { + synchronized (lockResult) { + lockResult.getFuture().cancel(true); + } + } + } catch (PDException e) { + throw new HugeException("Failed to unlock '%s' to pd", e, key); + } + } + + public boolean keepAlive(String key) { + try { + LockResponse alive = this.client.keepAlive(key); + return alive.getSucceed(); + } catch (PDException e) { + throw new HugeException("Failed to keepAlive '%s' to pd", key); + } + } + + +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/AbstractMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/AbstractMetaManager.java new file mode 100644 index 0000000000..254068335a --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/AbstractMetaManager.java @@ -0,0 +1,116 @@ +/* + * 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.hugegraph.meta.managers; + +import static org.apache.hugegraph.meta.MetaManager.LOCK_DEFAULT_LEASE; +import static org.apache.hugegraph.meta.MetaManager.LOCK_DEFAULT_TIMEOUT; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_DELIMITER; + +import java.util.Map; +import java.util.Optional; +import java.util.function.Consumer; + +import org.apache.commons.lang3.StringUtils; +import org.apache.hugegraph.HugeException; +import org.apache.hugegraph.auth.SchemaDefine; +import org.apache.hugegraph.meta.MetaDriver; +import org.apache.hugegraph.meta.lock.LockResult; +import org.apache.hugegraph.schema.SchemaElement; +import org.apache.hugegraph.util.JsonUtil; + +public class AbstractMetaManager { + + protected final MetaDriver metaDriver; + protected final String cluster; + + public AbstractMetaManager(MetaDriver metaDriver, String cluster) { + this.metaDriver = metaDriver; + this.cluster = cluster; + } + + protected static String serialize(SchemaDefine.AuthElement element) { + Map objectMap = element.asMap(); + return JsonUtil.toJson(objectMap); + } + + protected static String serialize(SchemaElement element) { + Map objectMap = element.asMap(); + return JsonUtil.toJson(objectMap); + } + + @SuppressWarnings("unchecked") + protected static Map configMap(String config) { + return JsonUtil.fromJson(config, Map.class); + } + + protected void listen(String key, Consumer consumer) { + this.metaDriver.listen(key, consumer); + } + + protected void listenPrefix(String prefix, Consumer consumer) { + this.metaDriver.listenPrefix(prefix, consumer); + } + + public String getRaw(String key) { + String result = this.metaDriver.get(key); + return Optional.ofNullable(result).orElse(""); + } + + public void putOrDeleteRaw(String key, String val) { + if (StringUtils.isEmpty(val)) { + this.metaDriver.delete(key); + } else { + this.metaDriver.put(key, val); + } + } + + public LockResult lock(String... keys) { + return this.lock(LOCK_DEFAULT_LEASE, keys); + } + + public LockResult lock(long ttl, String... keys) { + String key = String.join(META_PATH_DELIMITER, keys); + return this.lock(key, ttl); + } + + public LockResult lock(String key, long ttl) { + LockResult lockResult = this.metaDriver.lock(key, ttl); + if (!lockResult.lockSuccess()) { + throw new HugeException("Failed to lock '%s'", key); + } + return lockResult; + } + + public LockResult lock(String key) { + return this.metaDriver.lock(key, LOCK_DEFAULT_LEASE); + } + + public LockResult tryLock(String key) { + return this.metaDriver.tryLock(key, LOCK_DEFAULT_LEASE, + LOCK_DEFAULT_TIMEOUT); + } + + public void unlock(LockResult lockResult, String... keys) { + String key = String.join(META_PATH_DELIMITER, keys); + this.unlock(key, lockResult); + } + + public void unlock(String key, LockResult lockResult) { + this.metaDriver.unlock(key, lockResult); + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/AuthMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/AuthMetaManager.java new file mode 100644 index 0000000000..2160226fbf --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/AuthMetaManager.java @@ -0,0 +1,1035 @@ +/* + * 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.hugegraph.meta.managers; + +import static org.apache.hugegraph.meta.MetaManager.META_PATH_ACCESS; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_AUTH; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_AUTH_EVENT; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_BELONG; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_DELIMITER; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GRAPHSPACE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GROUP; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_HUGEGRAPH; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_ROLE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_TARGET; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_USER; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Map; +import java.util.function.Consumer; + +import org.apache.commons.lang3.StringUtils; +import org.apache.hugegraph.auth.HugeAccess; +import org.apache.hugegraph.auth.HugeBelong; +import org.apache.hugegraph.auth.HugeGroup; +import org.apache.hugegraph.auth.HugePermission; +import org.apache.hugegraph.auth.HugeRole; +import org.apache.hugegraph.auth.HugeTarget; +import org.apache.hugegraph.auth.HugeUser; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.meta.MetaDriver; +import org.apache.hugegraph.meta.MetaManager; +import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.JsonUtil; + +public class AuthMetaManager extends AbstractMetaManager { + + public AuthMetaManager(MetaDriver metaDriver, String cluster) { + super(metaDriver, cluster); + } + + + public void createUser(HugeUser user) throws IOException { + String result = this.metaDriver.get(userKey(user.name())); + E.checkArgument(StringUtils.isEmpty(result), + "The user name '%s' has existed", user.name()); + this.metaDriver.put(userKey(user.name()), serialize(user)); + } + + public HugeUser updateUser(HugeUser user) throws IOException { + String result = this.metaDriver.get(userKey(user.name())); + E.checkArgument(StringUtils.isNotEmpty(result), + "The user name '%s' does not existed", user.name()); + + HugeUser ori = HugeUser.fromMap(JsonUtil.fromJson(result, Map.class)); + ori.update(new Date()); + ori.nickname(user.nickname()); + ori.password(user.password()); + ori.phone(user.phone()); + ori.email(user.email()); + ori.avatar(user.avatar()); + ori.description(user.description()); + this.metaDriver.put(userKey(user.name()), serialize(ori)); + return ori; + } + + public HugeUser deleteUser(Id id) throws IOException, + ClassNotFoundException { + String result = this.metaDriver.get(userKey(id.asString())); + E.checkArgument(StringUtils.isNotEmpty(result), + "The user name '%s' does not existed", id.asString()); + this.metaDriver.delete(userKey(id.asString())); + this.putAuthEvent(new MetaManager.AuthEvent("DELETE", "USER", id.asString())); + Map map = JsonUtil.fromJson(result, Map.class); + return HugeUser.fromMap(map); + } + + @SuppressWarnings("unchecked") + public HugeUser findUser(String name) + throws IOException, ClassNotFoundException { + String result = this.metaDriver.get(userKey(name)); + if (StringUtils.isEmpty(result)) { + return null; + } + + return HugeUser.fromMap(JsonUtil.fromJson(result, Map.class)); + } + + public List listUsers(List ids) throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map userMap = + this.metaDriver.scanWithPrefix(userListKey()); + for (Id id : ids) { + if (userMap.containsKey(userKey(id.asString()))) { + String value = userMap.get(userKey(id.asString())); + Map map = JsonUtil.fromJson(value, Map.class); + HugeUser user = HugeUser.fromMap(map); + result.add(user); + } + } + + return result; + } + + @SuppressWarnings("unchecked") + public List listUsersByGroup(String group, long limit) + throws IOException, ClassNotFoundException { + List result = new ArrayList<>(); + Map userMap = + this.metaDriver.scanWithPrefix(userListKey()); + for (Map.Entry item : userMap.entrySet()) { + if (limit >= 0 && result.size() >= limit) { + break; + } + Map map = JsonUtil.fromJson(item.getValue(), + Map.class); + HugeUser user = HugeUser.fromMap(map); + result.add(user); + } + + List belongs = new ArrayList<>(); + Map belongMap = this.metaDriver.scanWithPrefix( + belongListKey("*")); + for (Map.Entry item : belongMap.entrySet()) { + if (limit >= 0 && belongs.size() >= limit) { + break; + } + String groupName = arrayFromBelong(item.getKey())[2]; + if (groupName.equals(group)) { + Map map = JsonUtil.fromJson(item.getValue(), + Map.class); + HugeBelong belong = HugeBelong.fromMap(map); + belongs.add(belong); + } + } + + return result; + } + + @SuppressWarnings("unchecked") + public List listAllUsers(long limit) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map userMap = + this.metaDriver.scanWithPrefix(userListKey()); + for (Map.Entry item : userMap.entrySet()) { + if (limit >= 0 && result.size() >= limit) { + break; + } + Map map = JsonUtil.fromJson(item.getValue(), + Map.class); + HugeUser user = HugeUser.fromMap(map); + result.add(user); + } + + return result; + } + + public Id createGroup(HugeGroup group) throws IOException { + String key = groupKey(group.name()); + String result = this.metaDriver.get(key); + E.checkArgument(StringUtils.isEmpty(result), + "The group name '%s' has existed", group.name()); + this.metaDriver.put(key, serialize(group)); + return group.id(); + } + + public HugeGroup updateGroup(HugeGroup group) throws IOException { + String key = groupKey(group.name()); + String result = this.metaDriver.get(key); + E.checkArgument(StringUtils.isNotEmpty(result), + "The group name '%s' is not existed", group.name()); + Map map = JsonUtil.fromJson(result, Map.class); + HugeGroup ori = HugeGroup.fromMap(map); + ori.update(new Date()); + ori.nickname(group.nickname()); + ori.description(group.description()); + this.metaDriver.put(key, serialize(ori)); + return ori; + } + + public HugeGroup deleteGroup(Id id) throws IOException, + ClassNotFoundException { + String name = id.asString(); + String key = groupKey(name); + String result = this.metaDriver.get(key); + E.checkArgument(StringUtils.isNotEmpty(result), + "The group name '%s' is not existed", name); + this.metaDriver.delete(key); + this.putAuthEvent(new MetaManager.AuthEvent("DELETE", "GROUP", + name)); + Map map = JsonUtil.fromJson(result, Map.class); + return HugeGroup.fromMap(map); + } + + public HugeGroup findGroup(String name) throws IOException, + ClassNotFoundException { + String result = this.metaDriver.get(groupKey(name)); + if (StringUtils.isEmpty(result)) { + return null; + } + + return HugeGroup.fromMap(JsonUtil.fromJson(result, Map.class)); + } + + public List listGroups(long limit) throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map groupMap = + this.metaDriver.scanWithPrefix(groupListKey()); + for (Map.Entry item : groupMap.entrySet()) { + if (limit >= 0 && result.size() >= limit) { + break; + } + Map map = JsonUtil.fromJson(item.getValue(), + Map.class); + HugeGroup group = HugeGroup.fromMap(map); + result.add(group); + } + + return result; + } + + @SuppressWarnings("unchecked") + public Id createRole(String graphSpace, HugeRole role) + throws IOException { + Id roleId = IdGenerator.of(role.name()); + HugeRole existed = this.findRole(graphSpace, roleId); + // not support too many role to share same id + E.checkArgument(existed == null, "The role name '%s' has existed", + role.name()); + role.name(roleId.asString()); + + this.metaDriver.put(roleKey(graphSpace, role.name()), + serialize(role)); + return roleId; + } + + @SuppressWarnings("unchecked") + public HugeRole updateRole(String graphSpace, HugeRole role) + throws IOException { + String result = this.metaDriver.get(roleKey(graphSpace, role.name())); + E.checkArgument(StringUtils.isNotEmpty(result), + "The role name '%s' is not existed", role.name()); + + // only description and update-time could be updated + Map map = JsonUtil.fromJson(result, Map.class); + HugeRole ori = HugeRole.fromMap(map); + ori.update(new Date()); + ori.nickname(role.nickname()); + ori.description(role.description()); + this.metaDriver.put(roleKey(graphSpace, ori.name()), + serialize(ori)); + return ori; + } + + @SuppressWarnings("unchecked") + public HugeRole deleteRole(String graphSpace, Id id) + throws IOException, + ClassNotFoundException { + String result = this.metaDriver.get(roleKey(graphSpace, + id.asString())); + E.checkArgument(StringUtils.isNotEmpty(result), + "The role name '%s' is not existed", id.asString()); + this.metaDriver.delete(roleKey(graphSpace, id.asString())); + this.putAuthEvent(new MetaManager.AuthEvent("DELETE", "ROLE", id.asString())); + Map map = JsonUtil.fromJson(result, Map.class); + return HugeRole.fromMap(map); + } + + @SuppressWarnings("unchecked") + public HugeRole findRole(String graphSpace, Id id) { + String result = this.metaDriver.get(roleKey(graphSpace, + id.asString())); + if (StringUtils.isEmpty(result)) { + return null; + } + Map map = JsonUtil.fromJson(result, Map.class); + return HugeRole.fromMap(map); + } + + @SuppressWarnings("unchecked") + public HugeRole getRole(String graphSpace, Id id) + throws IOException, + ClassNotFoundException { + String result = this.metaDriver.get(roleKey(graphSpace, + id.asString())); + E.checkArgument(StringUtils.isNotEmpty(result), + "The role name '%s' is not existed", id.asString()); + Map map = JsonUtil.fromJson(result, Map.class); + return HugeRole.fromMap(map); + } + + @SuppressWarnings("unchecked") + public List listRoles(String graphSpace, List ids) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map roleMap = + this.metaDriver.scanWithPrefix(roleListKey(graphSpace)); + for (Id id : ids) { + if (roleMap.containsKey(roleKey(graphSpace, id.asString()))) { + String roleString = roleMap.get(roleKey(graphSpace, + id.asString())); + Map map = JsonUtil.fromJson(roleString, + Map.class); + HugeRole role = HugeRole.fromMap(map); + result.add(role); + } + } + + return result; + } + + @SuppressWarnings("unchecked") + public List listAllRoles(String graphSpace, long limit) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map roleMap = + this.metaDriver.scanWithPrefix(roleListKey(graphSpace)); + for (Map.Entry item : roleMap.entrySet()) { + if (limit >= 0 && result.size() >= limit) { + break; + } + Map map = JsonUtil.fromJson(item.getValue(), + Map.class); + HugeRole role = HugeRole.fromMap(map); + result.add(role); + } + + return result; + } + + public Id createTarget(String graphSpace, HugeTarget target) + throws IOException { + String result = this.metaDriver.get(targetKey(graphSpace, + target.name())); + E.checkArgument(StringUtils.isEmpty(result), + "The target name '%s' has existed", target.name()); + this.metaDriver.put(targetKey(graphSpace, target.name()), + serialize(target)); + return target.id(); + } + + @SuppressWarnings("unchecked") + public HugeTarget updateTarget(String graphSpace, HugeTarget target) + throws IOException { + String result = this.metaDriver.get(targetKey(graphSpace, + target.name())); + E.checkArgument(StringUtils.isNotEmpty(result), + "The target name '%s' is not existed", target.name()); + + // only resources and update-time could be updated + Map map = JsonUtil.fromJson(result, Map.class); + HugeTarget ori = HugeTarget.fromMap(map); + ori.update(new Date()); + ori.graph(target.graph()); + ori.description(target.description()); + ori.resources(target.resources()); + this.metaDriver.put(targetKey(graphSpace, target.name()), + serialize(ori)); + this.putAuthEvent(new MetaManager.AuthEvent("UPDATE", "TARGET", + ori.id().asString())); + return ori; + } + + @SuppressWarnings("unchecked") + public HugeTarget deleteTarget(String graphSpace, Id id) + throws IOException, + ClassNotFoundException { + String result = this.metaDriver.get(targetKey(graphSpace, + id.asString())); + E.checkArgument(StringUtils.isNotEmpty(result), + "The target name '%s' is not existed", id.asString()); + this.metaDriver.delete(targetKey(graphSpace, id.asString())); + this.putAuthEvent(new MetaManager.AuthEvent("DELETE", "TARGET", id.asString())); + Map map = JsonUtil.fromJson(result, Map.class); + return HugeTarget.fromMap(map); + } + + @SuppressWarnings("unchecked") + public HugeTarget findTarget(String graphSpace, Id id) { + String result = this.metaDriver.get(targetKey(graphSpace, + id.asString())); + if (StringUtils.isEmpty(result)) { + return null; + } + Map map = JsonUtil.fromJson(result, Map.class); + return HugeTarget.fromMap(map); + } + + @SuppressWarnings("unchecked") + public HugeTarget getTarget(String graphSpace, Id id) + throws IOException, + ClassNotFoundException { + String result = this.metaDriver.get(targetKey(graphSpace, + id.asString())); + E.checkArgument(StringUtils.isNotEmpty(result), + "The target name '%s' is not existed", id.asString()); + Map map = JsonUtil.fromJson(result, Map.class); + return HugeTarget.fromMap(map); + } + + @SuppressWarnings("unchecked") + public List listTargets(String graphSpace, List ids) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map targetMap = + this.metaDriver.scanWithPrefix(targetListKey(graphSpace)); + for (Id id : ids) { + if (targetMap.containsKey(targetKey(graphSpace, id.asString()))) { + String targetString = targetMap.get(targetKey(graphSpace, + id.asString())); + Map map = JsonUtil.fromJson(targetString, + Map.class); + HugeTarget target = HugeTarget.fromMap(map); + result.add(target); + } + } + + return result; + } + + @SuppressWarnings("unchecked") + public List listAllTargets(String graphSpace, long limit) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map targetMap = + this.metaDriver.scanWithPrefix(targetListKey(graphSpace)); + for (Map.Entry item : targetMap.entrySet()) { + if (limit >= 0 && result.size() >= limit) { + break; + } + Map map = JsonUtil.fromJson(item.getValue(), + Map.class); + HugeTarget target = HugeTarget.fromMap(map); + result.add(target); + } + + return result; + } + + public Id createBelong(String graphSpace, HugeBelong belong) + throws IOException, ClassNotFoundException { + String belongId = this.checkBelong(graphSpace, belong); + String result = this.metaDriver.get(belongKey(graphSpace, belongId)); + E.checkArgument(StringUtils.isEmpty(result), + "The belong name '%s' has existed", belongId); + this.metaDriver.put(belongKey(graphSpace, belongId), serialize(belong)); + this.putAuthEvent(new MetaManager.AuthEvent("CREATE", "BELONG", belongId)); + return IdGenerator.of(belongId); + } + + @SuppressWarnings("unchecked") + public HugeBelong updateBelong(String graphSpace, HugeBelong belong) + throws IOException, ClassNotFoundException { + String belongId = this.checkBelong(graphSpace, belong); + String result = this.metaDriver.get(belongKey(graphSpace, belongId)); + E.checkArgument(StringUtils.isNotEmpty(result), + "The belong name '%s' is not existed", belongId); + + // only description and update-time could be updated + Map map = JsonUtil.fromJson(result, Map.class); + HugeBelong ori = HugeBelong.fromMap(map); + ori.update(new Date()); + ori.description(belong.description()); + this.metaDriver.put(belongKey(graphSpace, belongId), serialize(ori)); + return ori; + } + + public String checkBelong(String graphSpace, HugeBelong belong) + throws IOException, ClassNotFoundException { + String source = belong.source().asString(); + String target = belong.target().asString(); + String link = belong.link(); + HugeUser user = this.findUser(source); + HugeGroup group = this.findGroup(source); + E.checkArgument(user != null || group != null, + "The source name '%s' is not existed", + source); + HugeGroup groupTarget = this.findGroup(target); + HugeRole role = this.findRole(graphSpace, belong.target()); + E.checkArgument(role != null || groupTarget != null, + "The target name '%s' is not existed", + target); + + return belongId(source, target, link); + } + + @SuppressWarnings("unchecked") + public HugeBelong deleteBelong(String graphSpace, Id id) + throws IOException, + ClassNotFoundException { + String result = this.metaDriver.get(belongKey(graphSpace, + id.asString())); + E.checkArgument(StringUtils.isNotEmpty(result), + "The belong name '%s' is not existed", id.asString()); + this.metaDriver.delete(belongKey(graphSpace, id.asString())); + this.putAuthEvent(new MetaManager.AuthEvent("DELETE", "BELONG", id.asString())); + Map map = JsonUtil.fromJson(result, Map.class); + return HugeBelong.fromMap(map); + } + + @SuppressWarnings("unchecked") + public HugeBelong getBelong(String graphSpace, Id id) + throws IOException, + ClassNotFoundException { + String result = this.metaDriver.get(belongKey(graphSpace, + id.asString())); + E.checkArgument(StringUtils.isNotEmpty(result), + "The belong name '%s' is not existed", id.asString()); + + Map map = JsonUtil.fromJson(result, Map.class); + return HugeBelong.fromMap(map); + } + + public boolean existBelong(String graphSpace, Id id) { + String result = this.metaDriver.get(belongKey(graphSpace, + id.asString())); + return StringUtils.isNotEmpty(result); + } + + @SuppressWarnings("unchecked") + public List listBelong(String graphSpace, List ids) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map belongMap = + this.metaDriver.scanWithPrefix(belongListKey(graphSpace)); + for (Id id : ids) { + if (belongMap.containsKey(belongKey(graphSpace, id.asString()))) { + String belongString = belongMap.get(belongKey(graphSpace, + id.asString())); + Map map = JsonUtil.fromJson(belongString, + Map.class); + HugeBelong belong = HugeBelong.fromMap(map); + result.add(belong); + } + } + + return result; + } + + @SuppressWarnings("unchecked") + public List listAllBelong(String graphSpace, long limit) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map belongMap = + this.metaDriver.scanWithPrefix(belongListKey(graphSpace)); + for (Map.Entry item : belongMap.entrySet()) { + if (limit >= 0 && result.size() >= limit) { + break; + } + Map map = JsonUtil.fromJson(item.getValue(), + Map.class); + HugeBelong belong = HugeBelong.fromMap(map); + result.add(belong); + } + + return result; + } + + @SuppressWarnings("unchecked") + public List listBelongBySource(String graphSpace, Id source, + String link, long limit) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + + String sourceLink = (HugeBelong.ALL.equals(link)) ? source.asString() : + source.asString() + "->" + link; + + String key = belongListKeyBySource(graphSpace, sourceLink); + + Map belongMap = this.metaDriver.scanWithPrefix(key); + for (Map.Entry item : belongMap.entrySet()) { + if (limit >= 0 && result.size() >= limit) { + break; + } + Map map = JsonUtil.fromJson(item.getValue(), + Map.class); + HugeBelong belong = HugeBelong.fromMap(map); + result.add(belong); + } + + return result; + } + + public String[] arrayFromBelong(String belongKey) { + E.checkArgument(StringUtils.isNotEmpty(belongKey), + "The belong name '%s' is empty", belongKey); + E.checkArgument(belongKey.contains("->"), + "The belong name '%s' is invalid", belongKey); + String[] items = belongKey.split("->"); + E.checkArgument(items.length == 3, + "The belong name '%s' is invalid", belongKey); + return items; + } + + @SuppressWarnings("unchecked") + public List listBelongByTarget(String graphSpace, + Id role, String link, long limit) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map belongMap = this.metaDriver.scanWithPrefix( + belongListKey(graphSpace)); + for (Map.Entry item : belongMap.entrySet()) { + if (limit >= 0 && result.size() >= limit) { + break; + } + String[] array = arrayFromBelong(item.getKey()); + String linkName = array[1]; + String roleName = array[2]; + if ((linkName.equals(link) || "*".equals(link)) && + roleName.equals(role.asString())) { + Map map = JsonUtil.fromJson(item.getValue(), + Map.class); + HugeBelong belong = HugeBelong.fromMap(map); + result.add(belong); + } + } + + return result; + } + + public Id createAccess(String graphSpace, HugeAccess access) + throws IOException, ClassNotFoundException { + String accessId = this.checkAccess(graphSpace, access); + String result = this.metaDriver.get(accessKey(graphSpace, accessId)); + E.checkArgument(StringUtils.isEmpty(result), + "The access name '%s' has existed", accessId); + this.metaDriver.put(accessKey(graphSpace, accessId), serialize(access)); + this.putAuthEvent(new MetaManager.AuthEvent("CREATE", "ACCESS", accessId)); + return IdGenerator.of(accessId); + } + + @SuppressWarnings("unchecked") + public HugeAccess updateAccess(String graphSpace, HugeAccess access) + throws IOException, ClassNotFoundException { + String accessId = this.checkAccess(graphSpace, access); + String result = this.metaDriver.get(accessKey(graphSpace, accessId)); + E.checkArgument(StringUtils.isNotEmpty(result), + "The access name '%s' is not existed", accessId); + Map map = JsonUtil.fromJson(result, Map.class); + HugeAccess existed = HugeAccess.fromMap(map); + E.checkArgument(existed.permission().code() == + access.permission().code(), + "The access name '%s' has existed", accessId); + + // only description and update-time could be updated + Map oriMap = JsonUtil.fromJson(result, Map.class); + HugeAccess ori = HugeAccess.fromMap(oriMap); + ori.update(new Date()); + ori.description(access.description()); + this.metaDriver.put(accessKey(graphSpace, accessId), serialize(ori)); + return ori; + } + + public String checkAccess(String graphSpace, HugeAccess access) + throws IOException, ClassNotFoundException { + HugeRole role = this.getRole(graphSpace, access.source()); + E.checkArgument(role != null, + "The role name '%s' is not existed", + access.source().asString()); + + HugeTarget target = this.getTarget(graphSpace, access.target()); + E.checkArgument(target != null, + "The target name '%s' is not existed", + access.target().asString()); + + return accessId(role.name(), target.name(), access.permission()); + } + + @SuppressWarnings("unchecked") + public HugeAccess deleteAccess(String graphSpace, Id id) + throws IOException, ClassNotFoundException { + String result = this.metaDriver.get(accessKey(graphSpace, + id.asString())); + E.checkArgument(StringUtils.isNotEmpty(result), + "The access name '%s' is not existed", id.asString()); + this.metaDriver.delete(accessKey(graphSpace, id.asString())); + this.putAuthEvent(new MetaManager.AuthEvent("DELETE", "ACCESS", id.asString())); + Map map = JsonUtil.fromJson(result, Map.class); + return HugeAccess.fromMap(map); + } + + @SuppressWarnings("unchecked") + public HugeAccess findAccess(String graphSpace, Id id) { + String result = this.metaDriver.get(accessKey(graphSpace, + id.asString())); + if (StringUtils.isEmpty(result)) { + return null; + } + Map map = JsonUtil.fromJson(result, Map.class); + return HugeAccess.fromMap(map); + } + + @SuppressWarnings("unchecked") + public HugeAccess getAccess(String graphSpace, Id id) + throws IOException, ClassNotFoundException { + String result = this.metaDriver.get(accessKey(graphSpace, + id.asString())); + E.checkArgument(StringUtils.isNotEmpty(result), + "The access name '%s' is not existed", id.asString()); + Map map = JsonUtil.fromJson(result, Map.class); + return HugeAccess.fromMap(map); + } + + @SuppressWarnings("unchecked") + public List listAccess(String graphSpace, List ids) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map accessMap = + this.metaDriver.scanWithPrefix(accessListKey(graphSpace)); + for (Id id : ids) { + if (accessMap.containsKey(accessKey(graphSpace, id.asString()))) { + String accessString = accessMap.get(accessKey(graphSpace, + id.asString())); + Map map = JsonUtil.fromJson(accessString, + Map.class); + HugeAccess access = HugeAccess.fromMap(map); + result.add(access); + } + } + + return result; + } + + @SuppressWarnings("unchecked") + public List listAllAccess(String graphSpace, long limit) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map accessMap = + this.metaDriver.scanWithPrefix(accessListKey(graphSpace)); + for (Map.Entry item : accessMap.entrySet()) { + if (limit >= 0 && result.size() >= limit) { + break; + } + Map map = JsonUtil.fromJson(item.getValue(), + Map.class); + HugeAccess access = HugeAccess.fromMap(map); + result.add(access); + } + + return result; + } + + @SuppressWarnings("unchecked") + public List listAccessByRole(String graphSpace, + Id role, long limit) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map accessMap = this.metaDriver.scanWithPrefix( + accessListKeyByRole(graphSpace, role.asString())); + for (Map.Entry item : accessMap.entrySet()) { + if (limit >= 0 && result.size() >= limit) { + break; + } + Map map = JsonUtil.fromJson(item.getValue(), + Map.class); + HugeAccess access = HugeAccess.fromMap(map); + result.add(access); + } + + return result; + } + + public String targetFromAccess(String accessKey) { + E.checkArgument(StringUtils.isNotEmpty(accessKey), + "The access name '%s' is empty", accessKey); + E.checkArgument(accessKey.contains("->"), + "The access name '%s' is invalid", accessKey); + String[] items = accessKey.split("->"); + E.checkArgument(items.length == 3, + "The access name '%s' is invalid", accessKey); + return items[2]; + } + + public void clearGraphAuth(String graphSpace) { + E.checkArgument(StringUtils.isNotEmpty(graphSpace), + "The graphSpace is empty"); + String prefix = this.authPrefix(graphSpace); + this.metaDriver.deleteWithPrefix(prefix); + } + + @SuppressWarnings("unchecked") + public List listAccessByTarget(String graphSpace, + Id target, long limit) + throws IOException, + ClassNotFoundException { + List result = new ArrayList<>(); + Map accessMap = this.metaDriver.scanWithPrefix( + accessListKey(graphSpace)); + for (Map.Entry item : accessMap.entrySet()) { + if (limit >= 0 && result.size() >= limit) { + break; + } + String targetName = targetFromAccess(item.getKey()); + if (targetName.equals(target.asString())) { + Map map = JsonUtil.fromJson(item.getValue(), + Map.class); + HugeAccess access = HugeAccess.fromMap(map); + result.add(access); + } + } + + return result; + } + + public void listenAuthEvent(Consumer consumer) { + this.listen(this.authEventKey(), consumer); + } + + public void putAuthEvent(MetaManager.AuthEvent event) { + this.metaDriver.put(authEventKey(), JsonUtil.toJson(event.asMap())); + } + + public String belongId(String source, String target, String link) { + E.checkArgument(StringUtils.isNotEmpty(source) && + StringUtils.isNotEmpty(target), + "The source name '%s' or target name '%s' is empty", + source, target); + return String.join("->", source, link, target); + } + + public String accessId(String roleName, String targetName, + HugePermission permission) { + E.checkArgument(StringUtils.isNotEmpty(roleName) && + StringUtils.isNotEmpty(targetName), + "The role name '%s' or target name '%s' is empty", + roleName, targetName); + String code = String.valueOf(permission.code()); + return String.join("->", roleName, code, targetName); + } + + public String authEventKey() { + // HUGEGRAPH/{cluster}/AUTH_EVENT + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_AUTH_EVENT); + } + + private String userKey(String name) { + // HUGEGRAPH/{cluster}/AUTH/USER/{user} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_AUTH, + META_PATH_USER, + name); + } + + private String userListKey() { + // HUGEGRAPH/{cluster}/AUTH/USER + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_AUTH, + META_PATH_USER); + } + + private String authPrefix(String graphSpace) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphSpace}/AUTH + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_AUTH); + } + + private String groupKey(String group) { + // HUGEGRAPH/{cluster}/AUTH/GROUP/{group} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_AUTH, + META_PATH_GROUP, + group); + } + + private String groupListKey() { + // HUGEGRAPH/{cluster}/AUTH/GROUP + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_AUTH, + META_PATH_GROUP); + } + + private String roleKey(String graphSpace, String role) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphSpace}/AUTH/ROLE/{role} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_AUTH, + META_PATH_ROLE, + role); + } + + private String roleListKey(String graphSpace) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphSpace}/AUTH/ROLE + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_AUTH, + META_PATH_ROLE); + } + + private String targetKey(String graphSpace, String target) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphSpace}/AUTH/TARGET/{target} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_AUTH, + META_PATH_TARGET, + target); + } + + private String targetListKey(String graphSpace) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphSpace}/AUTH/TARGET + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_AUTH, + META_PATH_TARGET); + } + + private String belongKey(String graphSpace, String belong) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphSpace}/AUTH/BELONG/{belong} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_AUTH, + META_PATH_BELONG, + belong); + } + + private String belongListKey(String graphSpace) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphSpace}/AUTH/BELONG + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_AUTH, + META_PATH_BELONG); + } + + private String belongListKeyBySource(String graphSpace, String source) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphSpace}/AUTH/BELONG/{userName} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_AUTH, + META_PATH_BELONG, + source + "->"); + } + + private String accessKey(String graphSpace, String access) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphSpace}/AUTH/ACCESS/{role->op->target} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_AUTH, + META_PATH_ACCESS, + access); + } + + private String accessListKey(String graphSpace) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphSpace}/AUTH/ACCESS + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_AUTH, + META_PATH_ACCESS); + } + + private String accessListKeyByRole(String graphSpace, String roleName) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphSpace}/AUTH/ACCESS/{roleName} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_AUTH, + META_PATH_ACCESS, + roleName + "->"); + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/ConfigMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/ConfigMetaManager.java new file mode 100644 index 0000000000..280c80bc75 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/ConfigMetaManager.java @@ -0,0 +1,149 @@ +/* + * 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.hugegraph.meta.managers; + +import static org.apache.hugegraph.meta.MetaManager.META_PATH_DELIMITER; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GRAPHSPACE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GREMLIN_YAML; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_HUGEGRAPH; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_REST_PROPERTIES; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_SERVICE; + +import java.util.Map; +import java.util.function.Consumer; + +import org.apache.commons.lang3.StringUtils; +import org.apache.hugegraph.meta.MetaDriver; +import org.apache.hugegraph.util.JsonUtil; + +public class ConfigMetaManager extends AbstractMetaManager { + + public ConfigMetaManager(MetaDriver metaDriver, String cluster) { + super(metaDriver, cluster); + } + + @SuppressWarnings("unchecked") + public Map restProperties(String graphSpace, + String serviceId) { + Map map = null; + String result = this.metaDriver.get(restPropertiesKey(graphSpace, + serviceId)); + if (StringUtils.isNotEmpty(result)) { + map = JsonUtil.fromJson(result, Map.class); + } + return map; + } + + @SuppressWarnings("unchecked") + public Map restProperties(String graphSpace, + String serviceId, + Map properties) { + Map map; + String result = this.metaDriver.get(restPropertiesKey(graphSpace, + serviceId)); + if (StringUtils.isNotEmpty(result)) { + map = JsonUtil.fromJson(result, Map.class); + for (Map.Entry item : properties.entrySet()) { + map.put(item.getKey(), item.getValue()); + } + } else { + map = properties; + } + this.metaDriver.put(restPropertiesKey(graphSpace, serviceId), + JsonUtil.toJson(map)); + return map; + } + + @SuppressWarnings("unchecked") + public Map deleteRestProperties(String graphSpace, + String serviceId, + String key) { + Map map = null; + String result = this.metaDriver.get(restPropertiesKey(graphSpace, + serviceId)); + if (StringUtils.isNotEmpty(result)) { + map = JsonUtil.fromJson(result, Map.class); + map.remove(key); + this.metaDriver.put(restPropertiesKey(graphSpace, serviceId), + JsonUtil.toJson(map)); + } + return map; + } + + @SuppressWarnings("unchecked") + public Map clearRestProperties(String graphSpace, + String serviceId) { + Map map = null; + String key = restPropertiesKey(graphSpace, serviceId); + String result = this.metaDriver.get(key); + if (StringUtils.isNotEmpty(result)) { + map = JsonUtil.fromJson(result, Map.class); + this.metaDriver.delete(key); + } + return map; + } + + public String gremlinYaml(String graphSpace, String serviceId) { + return this.metaDriver.get(gremlinYamlKey(graphSpace, serviceId)); + } + + public String gremlinYaml(String graphSpace, String serviceId, + String yaml) { + this.metaDriver.put(gremlinYamlKey(graphSpace, serviceId), yaml); + return yaml; + } + + public void listenRestPropertiesUpdate(String graphSpace, + String serviceId, + Consumer consumer) { + this.listen(this.restPropertiesKey(graphSpace, serviceId), consumer); + } + + public void listenGremlinYamlUpdate(String graphSpace, + String serviceId, + Consumer consumer) { + this.listen(this.gremlinYamlKey(graphSpace, serviceId), consumer); + } + + + private String restPropertiesKey(String graphSpace, String serviceId) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/SERVICE/ + // {serviceId}/REST_PROPERTIES + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_SERVICE, + serviceId, + META_PATH_REST_PROPERTIES); + } + + private String gremlinYamlKey(String graphSpace, String serviceId) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/SERVICE/ + // {serviceId}/GREMLIN_YAML + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_SERVICE, + serviceId, + META_PATH_GREMLIN_YAML); + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/GraphMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/GraphMetaManager.java new file mode 100644 index 0000000000..859746bd9b --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/GraphMetaManager.java @@ -0,0 +1,284 @@ +/* + * 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.hugegraph.meta.managers; + +import static org.apache.hugegraph.meta.MetaManager.META_PATH_ADD; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_CLEAR; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_DELIMITER; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_EDGE_LABEL; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_EVENT; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GRAPH; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GRAPHSPACE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GRAPH_CONF; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_HUGEGRAPH; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_JOIN; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_REMOVE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_SCHEMA; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_UPDATE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_VERTEX_LABEL; + +import java.util.Map; +import java.util.function.Consumer; + +import org.apache.hugegraph.meta.MetaDriver; +import org.apache.hugegraph.type.define.CollectionType; +import org.apache.hugegraph.util.JsonUtil; +import org.apache.hugegraph.util.collection.CollectionFactory; +import org.apache.logging.log4j.util.Strings; + +public class GraphMetaManager extends AbstractMetaManager { + + public GraphMetaManager(MetaDriver metaDriver, String cluster) { + super(metaDriver, cluster); + } + + private static String graphName(String graphSpace, String name) { + return String.join(META_PATH_JOIN, graphSpace, name); + } + + public Map> graphConfigs(String graphSpace) { + Map> configs = + CollectionFactory.newMap(CollectionType.EC); + Map keyValues = this.metaDriver.scanWithPrefix( + this.graphConfPrefix(graphSpace)); + for (Map.Entry entry : keyValues.entrySet()) { + String key = entry.getKey(); + String[] parts = key.split(META_PATH_DELIMITER); + String name = parts[parts.length - 1]; + String graphName = String.join("-", graphSpace, name); + configs.put(graphName, configMap(entry.getValue())); + } + return configs; + } + + public void removeGraphConfig(String graphSpace, String graph) { + this.metaDriver.delete(this.graphConfKey(graphSpace, graph)); + } + + public void notifyGraphAdd(String graphSpace, String graph) { + this.metaDriver.put(this.graphAddKey(), + graphName(graphSpace, graph)); + } + + public void notifyGraphRemove(String graphSpace, String graph) { + this.metaDriver.put(this.graphRemoveKey(), + graphName(graphSpace, graph)); + } + + public void notifyGraphUpdate(String graphSpace, String graph) { + this.metaDriver.put(this.graphUpdateKey(), + graphName(graphSpace, graph)); + } + + public void notifyGraphClear(String graphSpace, String graph) { + this.metaDriver.put(this.graphClearKey(), + graphName(graphSpace, graph)); + } + + public void notifySchemaCacheClear(String graphSpace, String graph) { + this.metaDriver.put(this.schemaCacheClearKey(), + graphName(graphSpace, graph)); + } + + public void notifyGraphCacheClear(String graphSpace, String graph) { + this.metaDriver.put(this.graphCacheClearKey(), + graphName(graphSpace, graph)); + } + + /** + * 通知 点信息 cache clear + * + * @param graphSpace + * @param graph + */ + public void notifyGraphVertexCacheClear(String graphSpace, String graph) { + this.metaDriver.put(this.graphVertexCacheClearKey(), + graphName(graphSpace, graph)); + } + + /** + * 通知 边信息 cache clear + * + * @param graphSpace + * @param graph + */ + public void notifyGraphEdgeCacheClear(String graphSpace, String graph) { + this.metaDriver.put(this.graphEdgeCacheClearKey(), + graphName(graphSpace, graph)); + } + + public Map getGraphConfig(String graphSpace, String graph) { + return configMap(this.metaDriver.get(this.graphConfKey(graphSpace, + graph))); + } + + public void addGraphConfig(String graphSpace, String graph, + Map configs) { + this.metaDriver.put(this.graphConfKey(graphSpace, graph), + JsonUtil.toJson(configs)); + } + + public void updateGraphConfig(String graphSpace, String graph, + Map configs) { + this.metaDriver.put(this.graphConfKey(graphSpace, graph), + JsonUtil.toJson(configs)); + } + + public void listenGraphAdd(Consumer consumer) { + this.listen(this.graphAddKey(), consumer); + } + + public void listenGraphUpdate(Consumer consumer) { + this.listen(this.graphUpdateKey(), consumer); + } + + public void listenGraphRemove(Consumer consumer) { + this.listen(this.graphRemoveKey(), consumer); + } + + public void listenGraphClear(Consumer consumer) { + this.listen(this.graphClearKey(), consumer); + } + + public void listenSchemaCacheClear(Consumer consumer) { + this.listen(this.schemaCacheClearKey(), consumer); + } + + public void listenGraphCacheClear(Consumer consumer) { + this.listen(this.graphCacheClearKey(), consumer); + } + + public void listenGraphVertexCacheClear(Consumer consumer) { + this.listen(this.graphVertexCacheClearKey(), consumer); + } + + public void listenGraphEdgeCacheClear(Consumer consumer) { + this.listen(this.graphEdgeCacheClearKey(), consumer); + } + + private String graphConfPrefix(String graphSpace) { + return this.graphConfKey(graphSpace, Strings.EMPTY); + } + + private String graphConfKey(String graphSpace, String graph) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH_CONF/{graph} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_GRAPH_CONF, + graph); + } + + private String graphAddKey() { + // HUGEGRAPH/{cluster}/EVENT/GRAPH/ADD + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_GRAPH, + META_PATH_ADD); + } + + private String graphRemoveKey() { + // HUGEGRAPH/{cluster}/EVENT/GRAPH/REMOVE + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_GRAPH, + META_PATH_REMOVE); + } + + private String graphUpdateKey() { + // HUGEGRAPH/{cluster}/EVENT/GRAPH/UPDATE + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_GRAPH, + META_PATH_UPDATE); + } + + private String graphClearKey() { + // HUGEGRAPH/{cluster}/EVENT/GRAPH/CLEAR + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_GRAPH, + META_PATH_CLEAR); + } + + private String schemaCacheClearKey() { + // HUGEGRAPH/{cluster}/EVENT/GRAPH/SCHEMA/CLEAR + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_GRAPH, + META_PATH_SCHEMA, + META_PATH_CLEAR); + } + + private String graphCacheClearKey() { + // HUGEGRAPH/{cluster}/EVENT/GRAPH/GRAPH/CLEAR + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_GRAPH, + META_PATH_GRAPH, + META_PATH_CLEAR); + } + + /** + * pd监听 vertex label更新的key + * + * @return + */ + private String graphVertexCacheClearKey() { + // HUGEGRAPH/{cluster}/EVENT/GRAPH/GRAPH/META_PATH_VERTEX_LABEL/CLEAR + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_GRAPH, + META_PATH_GRAPH, + META_PATH_VERTEX_LABEL, + META_PATH_CLEAR); + } + + /** + * pd监听 edge label更新的key + * + * @return + */ + private String graphEdgeCacheClearKey() { + // HUGEGRAPH/{cluster}/EVENT/GRAPH/GRAPH/META_PATH_EDGE_LABEL/CLEAR + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_GRAPH, + META_PATH_GRAPH, + META_PATH_EDGE_LABEL, + META_PATH_CLEAR); + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/KafkaMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/KafkaMetaManager.java new file mode 100644 index 0000000000..67d469aa5a --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/KafkaMetaManager.java @@ -0,0 +1,46 @@ +/* + * 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.hugegraph.meta.managers; + +import static org.apache.hugegraph.meta.MetaManager.META_PATH_DELIMITER; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_HUGEGRAPH; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_KAFKA; + +import java.util.function.Consumer; + +import org.apache.hugegraph.meta.MetaDriver; + +public class KafkaMetaManager extends AbstractMetaManager { + + public KafkaMetaManager(MetaDriver metaDriver, String cluster) { + super(metaDriver, cluster); + } + + public void listenKafkaConfig(Consumer consumer) { + String prefix = this.kafkaPrefixKey(); + this.listenPrefix(prefix, consumer); + } + + private String kafkaPrefixKey() { + // HUGEGRAPH/{cluster}/KAFKA + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_KAFKA); + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/LockMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/LockMetaManager.java new file mode 100644 index 0000000000..7910887266 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/LockMetaManager.java @@ -0,0 +1,27 @@ +/* + * 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.hugegraph.meta.managers; + +import org.apache.hugegraph.meta.MetaDriver; + +public class LockMetaManager extends AbstractMetaManager { + + public LockMetaManager(MetaDriver metaDriver, String cluster) { + super(metaDriver, cluster); + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/SchemaMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/SchemaMetaManager.java new file mode 100644 index 0000000000..57e2839837 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/SchemaMetaManager.java @@ -0,0 +1,517 @@ +/* + * 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.hugegraph.meta.managers; + +import static org.apache.hugegraph.meta.MetaManager.META_PATH_DELIMITER; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_EDGE_LABEL; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GRAPHSPACE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_HUGEGRAPH; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_ID; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_INDEX_LABEL; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_NAME; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_PROPERTY_KEY; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_SCHEMA; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_VERTEX_LABEL; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import org.apache.hugegraph.HugeGraph; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.meta.MetaDriver; +import org.apache.hugegraph.meta.PdMetaDriver; +import org.apache.hugegraph.schema.EdgeLabel; +import org.apache.hugegraph.schema.IndexLabel; +import org.apache.hugegraph.schema.PropertyKey; +import org.apache.hugegraph.schema.VertexLabel; +import org.apache.hugegraph.util.JsonUtil; + +public class SchemaMetaManager extends AbstractMetaManager { + private final HugeGraph graph; + + public SchemaMetaManager(MetaDriver metaDriver, String cluster, HugeGraph graph) { + super(metaDriver, cluster); + this.graph = graph; + } + + public static void main(String[] args) { + MetaDriver metaDriver = new PdMetaDriver("127.0.0.1:8686"); + SchemaMetaManager schemaMetaManager = new SchemaMetaManager(metaDriver, "hg", null); + PropertyKey propertyKey = new PropertyKey(null, IdGenerator.of(5), "test"); + propertyKey.userdata("key1", "value1"); + propertyKey.userdata("key2", 23); + schemaMetaManager.addPropertyKey("DEFAULT1", "hugegraph", propertyKey); + +// PropertyKey propertyKey1 = schemaMetaManager.getPropertyKey("DEFAULT1", "hugegraph", +// IdGenerator.of(1)); + schemaMetaManager.removePropertyKey("DEFAULT", "hugegraph", IdGenerator.of(1)); + +// propertyKey1 = schemaMetaManager.getPropertyKey("DEFAULT1", "hugegraph", "test"); +// System.out.println(propertyKey1 ); +// +// propertyKey1 = schemaMetaManager.getPropertyKey("DEFAULT1", "hugegraph", "5"); +// System.out.println(propertyKey1 ); + } + + public void addPropertyKey(String graphSpace, String graph, + PropertyKey propertyKey) { + String content = serialize(propertyKey); + this.metaDriver.put(propertyKeyIdKey(graphSpace, graph, + propertyKey.id()), content); + this.metaDriver.put(propertyKeyNameKey(graphSpace, graph, + propertyKey.name()), content); + } + + public void updatePropertyKey(String graphSpace, String graph, + PropertyKey pkey) { + this.addPropertyKey(graphSpace, graph, pkey); + } + + @SuppressWarnings("unchecked") + public PropertyKey getPropertyKey(String graphSpace, String graph, + Id propertyKey) { + String content = this.metaDriver.get(propertyKeyIdKey(graphSpace, graph, + propertyKey)); + if (content == null || content.length() == 0) { + return null; + } else { + return PropertyKey.fromMap(JsonUtil.fromJson(content, Map.class), this.graph); + } + } + + @SuppressWarnings("unchecked") + public PropertyKey getPropertyKey(String graphSpace, String graph, + String propertyKey) { + String content = this.metaDriver.get(propertyKeyNameKey(graphSpace, + graph, + propertyKey)); + if (content == null || content.length() == 0) { + return null; + } else { + return PropertyKey.fromMap(JsonUtil.fromJson(content, Map.class), this.graph); + } + } + + @SuppressWarnings("unchecked") + public List getPropertyKeys(String graphSpace, String graph) { + Map propertyKeysKvs = this.metaDriver.scanWithPrefix( + propertyKeyPrefix(graphSpace, graph)); + List propertyKeys = + new ArrayList<>(propertyKeysKvs.size()); + for (String value : propertyKeysKvs.values()) { + propertyKeys.add(PropertyKey.fromMap(JsonUtil.fromJson(value, Map.class), this.graph)); + } + return propertyKeys; + } + + public Id removePropertyKey(String graphSpace, String graph, + Id propertyKey) { + PropertyKey p = this.getPropertyKey(graphSpace, graph, propertyKey); + this.metaDriver.delete(propertyKeyNameKey(graphSpace, graph, + p.name())); + this.metaDriver.delete(propertyKeyIdKey(graphSpace, graph, + propertyKey)); + return IdGenerator.ZERO; + } + + public void addVertexLabel(String graphSpace, String graph, + VertexLabel vertexLabel) { + String content = serialize(vertexLabel); + this.metaDriver.put(vertexLabelIdKey(graphSpace, graph, + vertexLabel.id()), content); + this.metaDriver.put(vertexLabelNameKey(graphSpace, graph, + vertexLabel.name()), content); + } + + public void updateVertexLabel(String graphSpace, String graph, + VertexLabel vertexLabel) { + this.addVertexLabel(graphSpace, graph, vertexLabel); + } + + @SuppressWarnings("unchecked") + public VertexLabel getVertexLabel(String graphSpace, String graph, + Id vertexLabel) { + String content = this.metaDriver.get(vertexLabelIdKey(graphSpace, graph, + vertexLabel)); + if (content == null || content.length() == 0) { + return null; + } else { + return VertexLabel.fromMap(JsonUtil.fromJson(content, Map.class), this.graph); + } + } + + @SuppressWarnings("unchecked") + public VertexLabel getVertexLabel(String graphSpace, String graph, + String vertexLabel) { + String content = this.metaDriver.get(vertexLabelNameKey(graphSpace, + graph, + vertexLabel)); + if (content == null || content.length() == 0) { + return null; + } else { + return VertexLabel.fromMap(JsonUtil.fromJson(content, Map.class), this.graph); + } + } + + @SuppressWarnings("unchecked") + public List getVertexLabels(String graphSpace, String graph) { + Map vertexLabelKvs = this.metaDriver.scanWithPrefix( + vertexLabelPrefix(graphSpace, graph)); + List vertexLabels = + new ArrayList<>(vertexLabelKvs.size()); + for (String value : vertexLabelKvs.values()) { + vertexLabels.add(VertexLabel.fromMap( + JsonUtil.fromJson(value, Map.class), this.graph)); + } + return vertexLabels; + } + + public Id removeVertexLabel(String graphSpace, String graph, + Id vertexLabel) { + VertexLabel v = this.getVertexLabel(graphSpace, graph, + vertexLabel); + this.metaDriver.delete(vertexLabelNameKey(graphSpace, graph, + v.name())); + this.metaDriver.delete(vertexLabelIdKey(graphSpace, graph, + vertexLabel)); + return IdGenerator.ZERO; + } + + public void addEdgeLabel(String graphSpace, String graph, + EdgeLabel edgeLabel) { + String content = serialize(edgeLabel); + this.metaDriver.put(edgeLabelIdKey(graphSpace, graph, + edgeLabel.id()), content); + this.metaDriver.put(edgeLabelNameKey(graphSpace, graph, + edgeLabel.name()), content); + } + + public void updateEdgeLabel(String graphSpace, String graph, + EdgeLabel edgeLabel) { + this.addEdgeLabel(graphSpace, graph, edgeLabel); + } + + @SuppressWarnings("unchecked") + public EdgeLabel getEdgeLabel(String graphSpace, String graph, + Id edgeLabel) { + String content = this.metaDriver.get(edgeLabelIdKey(graphSpace, graph, + edgeLabel)); + if (content == null || content.length() == 0) { + return null; + } else { + return EdgeLabel.fromMap(JsonUtil.fromJson(content, Map.class), this.graph); + } + } + + @SuppressWarnings("unchecked") + public EdgeLabel getEdgeLabel(String graphSpace, String graph, + String edgeLabel) { + String content = this.metaDriver.get(edgeLabelNameKey(graphSpace, + graph, + edgeLabel)); + if (content == null || content.length() == 0) { + return null; + } else { + return EdgeLabel.fromMap(JsonUtil.fromJson(content, Map.class), this.graph); + } + } + + @SuppressWarnings("unchecked") + public List getEdgeLabels(String graphSpace, String graph) { + Map edgeLabelKvs = this.metaDriver.scanWithPrefix( + edgeLabelPrefix(graphSpace, graph)); + List edgeLabels = + new ArrayList<>(edgeLabelKvs.size()); + for (String value : edgeLabelKvs.values()) { + edgeLabels.add(EdgeLabel.fromMap( + JsonUtil.fromJson(value, Map.class), this.graph)); + } + return edgeLabels; + } + + public Id removeEdgeLabel(String graphSpace, String graph, + Id edgeLabel) { + EdgeLabel e = this.getEdgeLabel(graphSpace, graph, + edgeLabel); + this.metaDriver.delete(edgeLabelNameKey(graphSpace, graph, + e.name())); + this.metaDriver.delete(edgeLabelIdKey(graphSpace, graph, + edgeLabel)); + return IdGenerator.ZERO; + } + + public void addIndexLabel(String graphSpace, String graph, + IndexLabel indexLabel) { + String content = serialize(indexLabel); + this.metaDriver.put(indexLabelIdKey(graphSpace, graph, + indexLabel.id()), content); + this.metaDriver.put(indexLabelNameKey(graphSpace, graph, + indexLabel.name()), content); + } + + public void updateIndexLabel(String graphSpace, String graph, + IndexLabel indexLabel) { + this.addIndexLabel(graphSpace, graph, indexLabel); + } + + @SuppressWarnings("unchecked") + public IndexLabel getIndexLabel(String graphSpace, String graph, + Id indexLabel) { + String content = this.metaDriver.get(indexLabelIdKey(graphSpace, graph, + indexLabel)); + if (content == null || content.length() == 0) { + return null; + } else { + return IndexLabel.fromMap(JsonUtil.fromJson(content, Map.class), this.graph); + } + } + + @SuppressWarnings("unchecked") + public IndexLabel getIndexLabel(String graphSpace, String graph, + String edgeLabel) { + String content = this.metaDriver.get(indexLabelNameKey(graphSpace, + graph, + edgeLabel)); + if (content == null || content.length() == 0) { + return null; + } else { + return IndexLabel.fromMap(JsonUtil.fromJson(content, Map.class), this.graph); + } + } + + @SuppressWarnings("unchecked") + public List getIndexLabels(String graphSpace, String graph) { + Map indexLabelKvs = this.metaDriver.scanWithPrefix( + indexLabelPrefix(graphSpace, graph)); + List indexLabels = + new ArrayList<>(indexLabelKvs.size()); + for (String value : indexLabelKvs.values()) { + indexLabels.add(IndexLabel.fromMap( + JsonUtil.fromJson(value, Map.class), this.graph)); + } + return indexLabels; + } + + public Id removeIndexLabel(String graphSpace, String graph, Id indexLabel) { + IndexLabel i = this.getIndexLabel(graphSpace, graph, + indexLabel); + this.metaDriver.delete(indexLabelNameKey(graphSpace, graph, + i.name())); + this.metaDriver.delete(indexLabelIdKey(graphSpace, graph, + indexLabel)); + return IdGenerator.ZERO; + } + + private String propertyKeyPrefix(String graphSpace, String graph) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph + // }/SCHEMA/PROPERTY_KEY/NAME + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA, + META_PATH_PROPERTY_KEY, + META_PATH_NAME); + } + + private String propertyKeyIdKey(String graphSpace, String graph, Id id) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph + // }/SCHEMA/PROPERTY_KEY/ID/{id} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA, + META_PATH_PROPERTY_KEY, + META_PATH_ID, + id.asString()); + } + + private String propertyKeyNameKey(String graphSpace, String graph, + String name) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph + // }/SCHEMA/PROPERTY_KEY/NAME/{name} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA, + META_PATH_PROPERTY_KEY, + META_PATH_NAME, + name); + } + + private String vertexLabelPrefix(String graphSpace, String graph) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph + // }/SCHEMA/VERTEX_LABEL/NAME + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA, + META_PATH_VERTEX_LABEL, + META_PATH_NAME); + } + + private String vertexLabelIdKey(String graphSpace, String graph, Id id) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph + // }/SCHEMA/VERTEX_LABEL/ID/{id} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA, + META_PATH_VERTEX_LABEL, + META_PATH_ID, + id.asString()); + } + + private String vertexLabelNameKey(String graphSpace, String graph, + String name) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph + // }/SCHEMA/VERTEX_LABEL/NAME/{name} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA, + META_PATH_VERTEX_LABEL, + META_PATH_NAME, + name); + } + + private String edgeLabelPrefix(String graphSpace, String graph) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph + // }/SCHEMA/PROPERTYKEY/NAME + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA, + META_PATH_EDGE_LABEL, + META_PATH_NAME); + } + + private String edgeLabelIdKey(String graphSpace, String graph, Id id) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph + // }/SCHEMA/PROPERTYKEY/ID/{id} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA, + META_PATH_EDGE_LABEL, + META_PATH_ID, + id.asString()); + } + + private String edgeLabelNameKey(String graphSpace, String graph, + String name) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph + // }/SCHEMA/EDGE_LABEL/NAME/{name} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA, + META_PATH_EDGE_LABEL, + META_PATH_NAME, + name); + } + + private String indexLabelPrefix(String graphSpace, String graph) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph + // }/SCHEMA/INDEX_LABEL/NAME + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA, + META_PATH_INDEX_LABEL, + META_PATH_NAME); + } + + private String indexLabelIdKey(String graphSpace, String graph, Id id) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph + // }/SCHEMA/INDEX_LABEL/ID/{id} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA, + META_PATH_INDEX_LABEL, + META_PATH_ID, + id.asString()); + } + + private String indexLabelNameKey(String graphSpace, String graph, + String name) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph + // }/SCHEMA/INDEX_LABEL/NAME/{name} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA, + META_PATH_INDEX_LABEL, + META_PATH_NAME, + name); + } + + private String graphNameKey(String graphSpace, String graph) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/GRAPH/{graph}/SCHEMA + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graph, + META_PATH_SCHEMA); + } + + public void clearAllSchema(String graphSpace, String graph) { + this.metaDriver.deleteWithPrefix(graphNameKey(graphSpace, graph)); + } + +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/SchemaTemplateMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/SchemaTemplateMetaManager.java new file mode 100644 index 0000000000..bc2f1448bc --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/SchemaTemplateMetaManager.java @@ -0,0 +1,107 @@ +/* + * 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.hugegraph.meta.managers; + +import static org.apache.hugegraph.meta.MetaManager.META_PATH_DELIMITER; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GRAPHSPACE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_HUGEGRAPH; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_SCHEMA_TEMPLATE; + +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +import org.apache.commons.lang3.StringUtils; +import org.apache.hugegraph.HugeException; +import org.apache.hugegraph.meta.MetaDriver; +import org.apache.hugegraph.space.SchemaTemplate; +import org.apache.hugegraph.util.JsonUtil; +import org.apache.logging.log4j.util.Strings; + +public class SchemaTemplateMetaManager extends AbstractMetaManager { + + public SchemaTemplateMetaManager(MetaDriver metaDriver, String cluster) { + super(metaDriver, cluster); + } + + public Set schemaTemplates(String graphSpace) { + Set result = new HashSet<>(); + Map keyValues = this.metaDriver.scanWithPrefix( + this.schemaTemplatePrefix(graphSpace)); + for (String key : keyValues.keySet()) { + String[] parts = key.split(META_PATH_DELIMITER); + result.add(parts[parts.length - 1]); + } + return result; + } + + @SuppressWarnings("unchecked") + public SchemaTemplate schemaTemplate(String graphSpace, + String schemaTemplate) { + String s = this.metaDriver.get(this.schemaTemplateKey(graphSpace, + schemaTemplate)); + if (StringUtils.isEmpty(s)) { + return null; + } + return SchemaTemplate.fromMap(JsonUtil.fromJson(s, Map.class)); + } + + public void addSchemaTemplate(String graphSpace, SchemaTemplate template) { + + String key = this.schemaTemplateKey(graphSpace, template.name()); + + String data = this.metaDriver.get(key); + if (StringUtils.isNotEmpty(data)) { + throw new HugeException("Cannot create schema template " + + "since it has been created"); + } + + this.metaDriver.put(this.schemaTemplateKey(graphSpace, template.name()), + JsonUtil.toJson(template.asMap())); + } + + public void updateSchemaTemplate(String graphSpace, + SchemaTemplate template) { + this.metaDriver.put(this.schemaTemplateKey(graphSpace, template.name()), + JsonUtil.toJson(template.asMap())); + } + + public void removeSchemaTemplate(String graphSpace, String name) { + this.metaDriver.delete(this.schemaTemplateKey(graphSpace, name)); + } + + public void clearSchemaTemplate(String graphSpace) { + String prefix = this.schemaTemplatePrefix(graphSpace); + this.metaDriver.deleteWithPrefix(prefix); + } + + private String schemaTemplatePrefix(String graphSpace) { + return this.schemaTemplateKey(graphSpace, Strings.EMPTY); + } + + private String schemaTemplateKey(String graphSpace, String schemaTemplate) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/SCHEMA_TEMPLATE + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_SCHEMA_TEMPLATE, + schemaTemplate); + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/ServiceMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/ServiceMetaManager.java new file mode 100644 index 0000000000..3c03be3433 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/ServiceMetaManager.java @@ -0,0 +1,170 @@ +/* + * 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.hugegraph.meta.managers; + +import static org.apache.hugegraph.meta.MetaManager.META_PATH_ADD; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_DELIMITER; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_EVENT; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GRAPHSPACE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_HUGEGRAPH; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_JOIN; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_REMOVE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_SERVICE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_SERVICE_CONF; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_UPDATE; + +import java.util.HashMap; +import java.util.Map; +import java.util.function.Consumer; + +import org.apache.commons.lang3.StringUtils; +import org.apache.hugegraph.meta.MetaDriver; +import org.apache.hugegraph.space.Service; +import org.apache.hugegraph.util.JsonUtil; +import org.apache.logging.log4j.util.Strings; + +public class ServiceMetaManager extends AbstractMetaManager { + + public ServiceMetaManager(MetaDriver metaDriver, String cluster) { + super(metaDriver, cluster); + } + + private static String serviceName(String graphSpace, String name) { + return String.join(META_PATH_JOIN, graphSpace, name); + } + + public Map serviceConfigs(String graphSpace) { + Map serviceMap = new HashMap<>(); + Map keyValues = this.metaDriver.scanWithPrefix( + this.serviceConfPrefix(graphSpace)); + for (Map.Entry entry : keyValues.entrySet()) { + String key = entry.getKey(); + String[] parts = key.split(META_PATH_DELIMITER); + serviceMap.put(parts[parts.length - 1], + JsonUtil.fromJson(entry.getValue(), Service.class)); + } + return serviceMap; + } + + public String getServiceRawConfig(String graphSpace, String service) { + return this.metaDriver.get(this.serviceConfKey(graphSpace, service)); + } + + public Service getServiceConfig(String graphSpace, String service) { + String s = this.getServiceRawConfig(graphSpace, service); + return this.parseServiceRawConfig(s); + } + + public Service parseServiceRawConfig(String serviceRawConf) { + return JsonUtil.fromJson(serviceRawConf, Service.class); + } + + public void notifyServiceAdd(String graphSpace, String name) { + this.metaDriver.put(this.serviceAddKey(), + serviceName(graphSpace, name)); + } + + public void notifyServiceRemove(String graphSpace, String name) { + this.metaDriver.put(this.serviceRemoveKey(), + serviceName(graphSpace, name)); + } + + public void notifyServiceUpdate(String graphSpace, String name) { + this.metaDriver.put(this.serviceUpdateKey(), + serviceName(graphSpace, name)); + } + + public Service service(String graphSpace, String name) { + String service = this.metaDriver.get(this.serviceConfKey(graphSpace, + name)); + if (StringUtils.isEmpty(service)) { + return null; + } + return JsonUtil.fromJson(service, Service.class); + } + + public void addServiceConfig(String graphSpace, Service service) { + this.metaDriver.put(this.serviceConfKey(graphSpace, service.name()), + JsonUtil.toJson(service)); + } + + public void removeServiceConfig(String graphSpace, String service) { + this.metaDriver.delete(this.serviceConfKey(graphSpace, service)); + } + + public void updateServiceConfig(String graphSpace, Service service) { + this.addServiceConfig(graphSpace, service); + } + + public void listenServiceAdd(Consumer consumer) { + this.listen(this.serviceAddKey(), consumer); + } + + public void listenServiceRemove(Consumer consumer) { + this.listen(this.serviceRemoveKey(), consumer); + } + + public void listenServiceUpdate(Consumer consumer) { + this.listen(this.serviceUpdateKey(), consumer); + } + + private String serviceConfPrefix(String graphSpace) { + return this.serviceConfKey(graphSpace, Strings.EMPTY); + } + + private String serviceAddKey() { + // HUGEGRAPH/{cluster}/EVENT/SERVICE/ADD + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_SERVICE, + META_PATH_ADD); + } + + private String serviceRemoveKey() { + // HUGEGRAPH/{cluster}/EVENT/SERVICE/REMOVE + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_SERVICE, + META_PATH_REMOVE); + } + + private String serviceUpdateKey() { + // HUGEGRAPH/{cluster}/EVENT/SERVICE/UPDATE + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_SERVICE, + META_PATH_UPDATE); + } + + private String serviceConfKey(String graphSpace, String name) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphspace}/SERVICE_CONF + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + META_PATH_SERVICE_CONF, + name); + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/SpaceMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/SpaceMetaManager.java new file mode 100644 index 0000000000..d9e1688247 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/SpaceMetaManager.java @@ -0,0 +1,202 @@ +/* + * 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.hugegraph.meta.managers; + +import static org.apache.hugegraph.meta.MetaManager.META_PATH_ADD; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_CONF; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_DELIMITER; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_EVENT; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GRAPHSPACE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GRAPHSPACE_LIST; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_HUGEGRAPH; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_REMOVE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_UPDATE; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.function.Consumer; + +import org.apache.commons.lang3.StringUtils; +import org.apache.hugegraph.meta.MetaDriver; +import org.apache.hugegraph.space.GraphSpace; +import org.apache.hugegraph.type.define.CollectionType; +import org.apache.hugegraph.util.JsonUtil; +import org.apache.hugegraph.util.collection.CollectionFactory; + +public class SpaceMetaManager extends AbstractMetaManager { + + public SpaceMetaManager(MetaDriver metaDriver, String cluster) { + super(metaDriver, cluster); + } + + public List listGraphSpace() { + List result = new ArrayList<>(); + Map graphSpaceMap = this.metaDriver.scanWithPrefix( + graphSpaceListKey()); + for (Map.Entry item : graphSpaceMap.entrySet()) { + result.add(item.getValue()); + } + + return result; + } + + public Map graphSpaceConfigs() { + Map keyValues = this.metaDriver.scanWithPrefix( + this.graphSpaceConfPrefix()); + Map configs = + CollectionFactory.newMap(CollectionType.EC); + for (Map.Entry entry : keyValues.entrySet()) { + String key = entry.getKey(); + String[] parts = key.split(META_PATH_DELIMITER); + configs.put(parts[parts.length - 1], + JsonUtil.fromJson(entry.getValue(), GraphSpace.class)); + } + return configs; + } + + public GraphSpace graphSpace(String name) { + String space = this.metaDriver.get(this.graphSpaceConfKey(name)); + if (StringUtils.isEmpty(space)) { + return null; + } + return JsonUtil.fromJson(space, GraphSpace.class); + } + + public GraphSpace getGraphSpaceConfig(String graphSpace) { + String gs = this.metaDriver.get(this.graphSpaceConfKey(graphSpace)); + if (StringUtils.isEmpty(gs)) { + return null; + } + return JsonUtil.fromJson(gs, GraphSpace.class); + } + + public void addGraphSpaceConfig(String name, GraphSpace space) { + this.metaDriver.put(this.graphSpaceConfKey(name), + JsonUtil.toJson(space)); + } + + public void removeGraphSpaceConfig(String name) { + this.metaDriver.delete(this.graphSpaceConfKey(name)); + } + + public void updateGraphSpaceConfig(String name, GraphSpace space) { + this.metaDriver.put(this.graphSpaceConfKey(name), + JsonUtil.toJson(space)); + } + + public void appendGraphSpaceList(String name) { + String key = this.graphSpaceListKey(name); + this.metaDriver.put(key, name); + } + + public void clearGraphSpaceList(String name) { + String key = this.graphSpaceListKey(name); + this.metaDriver.delete(key); + } + + public void listenGraphSpaceAdd(Consumer consumer) { + this.listen(this.graphSpaceAddKey(), consumer); + } + + public void listenGraphSpaceRemove(Consumer consumer) { + this.listen(this.graphSpaceRemoveKey(), consumer); + } + + public void listenGraphSpaceUpdate(Consumer consumer) { + this.listen(this.graphSpaceUpdateKey(), consumer); + } + + public void notifyGraphSpaceAdd(String graphSpace) { + this.metaDriver.put(this.graphSpaceAddKey(), graphSpace); + } + + public void notifyGraphSpaceRemove(String graphSpace) { + this.metaDriver.put(this.graphSpaceRemoveKey(), graphSpace); + } + + public void notifyGraphSpaceUpdate(String graphSpace) { + this.metaDriver.put(this.graphSpaceUpdateKey(), graphSpace); + } + + private String graphSpaceConfPrefix() { + // HUGEGRAPH/{cluster}/GRAPHSPACE/CONF + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + META_PATH_CONF); + } + + private String graphSpaceAddKey() { + // HUGEGRAPH/{cluster}/EVENT/GRAPHSPACE/ADD + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_GRAPHSPACE, + META_PATH_ADD); + } + + private String graphSpaceRemoveKey() { + // HUGEGRAPH/{cluster}/EVENT/GRAPHSPACE/REMOVE + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_GRAPHSPACE, + META_PATH_REMOVE); + } + + private String graphSpaceUpdateKey() { + // HUGEGRAPH/{cluster}/EVENT/GRAPHSPACE/UPDATE + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_EVENT, + META_PATH_GRAPHSPACE, + META_PATH_UPDATE); + } + + private String graphSpaceConfKey(String name) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/CONF/{graphspace} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + META_PATH_CONF, + name); + } + + private String graphSpaceListKey(String name) { + // HUGEGRAPH/{cluster}/GRAPHSPACE_LIST/{graphspace} + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE_LIST, + name); + } + + private String graphSpaceListKey() { + // HUGEGRAPH/{cluster}/GRAPHSPACE_LIST + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE_LIST); + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/TaskMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/TaskMetaManager.java new file mode 100644 index 0000000000..3ab16eced5 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/TaskMetaManager.java @@ -0,0 +1,76 @@ +/* + * 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.hugegraph.meta.managers; + +import static org.apache.hugegraph.meta.MetaManager.META_PATH_DELIMITER; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_GRAPHSPACE; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_HUGEGRAPH; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_TASK; +import static org.apache.hugegraph.meta.MetaManager.META_PATH_TASK_LOCK; + +import org.apache.hugegraph.meta.MetaDriver; +import org.apache.hugegraph.meta.lock.LockResult; + +public class TaskMetaManager extends AbstractMetaManager { + + private static final String TASK_STATUS_POSTFIX = "Status"; + private static final String TASK_PROGRESS_POSTFIX = "Progress"; + private static final String TASK_CONTEXT_POSTFIX = "Context"; + private static final String TASK_RETRY_POSTFIX = "Retry"; + + public TaskMetaManager(MetaDriver metaDriver, String cluster) { + super(metaDriver, cluster); + } + + public LockResult tryLockTask(String graphSpace, String graphName, + String taskId) { + String key = taskLockKey(graphSpace, graphName, taskId); + return this.tryLock(key); + } + + public boolean isLockedTask(String graphSpace, String graphName, + String taskId) { + + String key = taskLockKey(graphSpace, graphName, taskId); + // 判断当前任务是否锁定 + return metaDriver.isLocked(key); + } + + public void unlockTask(String graphSpace, String graphName, + String taskId, LockResult lockResult) { + + String key = taskLockKey(graphSpace, graphName, taskId); + + this.unlock(key, lockResult); + } + + private String taskLockKey(String graphSpace, + String graphName, + String taskId) { + // HUGEGRAPH/{cluster}/GRAPHSPACE/{graphSpace}/{graphName}/TASK/{id}/TASK_LOCK + return String.join(META_PATH_DELIMITER, + META_PATH_HUGEGRAPH, + this.cluster, + META_PATH_GRAPHSPACE, + graphSpace, + graphName, + META_PATH_TASK, + taskId, + META_PATH_TASK_LOCK); + } +} From 626bce28e33d3d3efabdd04139eeeefd320e821d Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Mon, 21 Aug 2023 23:10:01 +0800 Subject: [PATCH 06/26] chore: migrate org.apache.hugegraph.space --- .../apache/hugegraph/space/GraphSpace.java | 512 ++++++++++++++++++ .../hugegraph/space/SchemaTemplate.java | 140 +++++ .../org/apache/hugegraph/space/Service.java | 361 ++++++++++++ 3 files changed, 1013 insertions(+) create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/GraphSpace.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/SchemaTemplate.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/Service.java diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/GraphSpace.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/GraphSpace.java new file mode 100644 index 0000000000..047bd65f53 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/GraphSpace.java @@ -0,0 +1,512 @@ +/* + * 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.hugegraph.space; + +import java.util.Date; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.Map; + +import org.apache.commons.lang.StringUtils; +import org.apache.hugegraph.HugeException; +import org.apache.hugegraph.util.E; + +public class GraphSpace { + + public static final String DEFAULT_GRAPH_SPACE_SERVICE_NAME = "DEFAULT"; + public static final String DEFAULT_NICKNAME = "默认图空间"; + public static final String DEFAULT_GRAPH_SPACE_DESCRIPTION = + "The system default graph space"; + public static final String DEFAULT_CREATOR_NAME = "anonymous"; + + public static final int DEFAULT_CPU_LIMIT = 4; + public static final int DEFAULT_MEMORY_LIMIT = 8; + public static final int DEFAULT_STORAGE_LIMIT = 100; + + public static final int DEFAULT_MAX_GRAPH_NUMBER = 100; + public static final int DEFAULT_MAX_ROLE_NUMBER = 100; + private final String creator; + public int storageLimit; // GB + public String oltpNamespace; + private String name; + private String nickname; + private String description; + private int cpuLimit; + private int memoryLimit; // GB + private int computeCpuLimit; + private int computeMemoryLimit; // GB + private String olapNamespace; + private String storageNamespace; + private int maxGraphNumber; + private int maxRoleNumber; + private Boolean auth; + private Map configs; + private int cpuUsed; + private int memoryUsed; // GB + private int storageUsed; // GB + private int graphNumberUsed; + private int roleNumberUsed; + private String operatorImagePath = ""; // path of compute operator image + private String internalAlgorithmImageUrl = ""; + private Date createTime; + private Date updateTime; + + + public GraphSpace(String name) { + E.checkArgument(name != null && !StringUtils.isEmpty(name), + "The name of graph space can't be null or empty"); + this.name = name; + this.nickname = DEFAULT_NICKNAME; + + this.maxGraphNumber = DEFAULT_MAX_GRAPH_NUMBER; + this.maxRoleNumber = DEFAULT_MAX_ROLE_NUMBER; + + this.cpuLimit = DEFAULT_CPU_LIMIT; + this.memoryLimit = DEFAULT_MEMORY_LIMIT; + this.storageLimit = DEFAULT_STORAGE_LIMIT; + + this.computeCpuLimit = DEFAULT_CPU_LIMIT; + this.computeMemoryLimit = DEFAULT_MEMORY_LIMIT; + + this.auth = false; + this.creator = DEFAULT_CREATOR_NAME; + this.configs = new HashMap<>(); + } + + public GraphSpace(String name, String nickname, String description, + int cpuLimit, + int memoryLimit, int storageLimit, int maxGraphNumber, + int maxRoleNumber, boolean auth, String creator, + Map config) { + E.checkArgument(name != null && !StringUtils.isEmpty(name), + "The name of graph space can't be null or empty"); + E.checkArgument(cpuLimit > 0, "The cpu limit must > 0"); + E.checkArgument(memoryLimit > 0, "The memory limit must > 0"); + E.checkArgument(storageLimit > 0, "The storage limit must > 0"); + E.checkArgument(maxGraphNumber > 0, "The max graph number must > 0"); + this.name = name; + this.nickname = nickname; + this.description = description; + this.cpuLimit = cpuLimit; + this.memoryLimit = memoryLimit; + this.storageLimit = storageLimit; + this.maxGraphNumber = maxGraphNumber; + this.maxRoleNumber = maxRoleNumber; + + this.auth = auth; + if (config == null) { + this.configs = new HashMap<>(); + } else { + this.configs = config; + } + + this.createTime = new Date(); + this.updateTime = this.createTime; + this.creator = creator; + } + + public GraphSpace(String name, String nickname, String description, + int cpuLimit, + int memoryLimit, int storageLimit, int maxGraphNumber, + int maxRoleNumber, String oltpNamespace, + String olapNamespace, String storageNamespace, + int cpuUsed, int memoryUsed, int storageUsed, + int graphNumberUsed, int roleNumberUsed, + boolean auth, String creator, Map config) { + E.checkArgument(name != null && !StringUtils.isEmpty(name), + "The name of graph space can't be null or empty"); + E.checkArgument(cpuLimit > 0, "The cpu limit must > 0"); + E.checkArgument(memoryLimit > 0, "The memory limit must > 0"); + E.checkArgument(storageLimit > 0, "The storage limit must > 0"); + E.checkArgument(maxGraphNumber > 0, "The max graph number must > 0"); + this.name = name; + this.nickname = nickname; + this.description = description; + + this.cpuLimit = cpuLimit; + this.memoryLimit = memoryLimit; + this.storageLimit = storageLimit; + + this.maxGraphNumber = maxGraphNumber; + this.maxRoleNumber = maxRoleNumber; + + this.oltpNamespace = oltpNamespace; + this.olapNamespace = olapNamespace; + this.storageNamespace = storageNamespace; + + this.cpuUsed = cpuUsed; + this.memoryUsed = memoryUsed; + this.storageUsed = storageUsed; + + this.graphNumberUsed = graphNumberUsed; + this.roleNumberUsed = roleNumberUsed; + + this.auth = auth; + this.creator = creator; + + this.configs = new HashMap<>(); + if (config != null) { + this.configs = config; + } + } + + public String name() { + return this.name; + } + + public void name(String name) { + this.name = name; + } + + public String nickname() { + return this.nickname; + } + + public void nickname(String nickname) { + this.nickname = nickname; + } + + public String description() { + return this.description; + } + + public void description(String description) { + this.description = description; + } + + public int cpuLimit() { + return this.cpuLimit; + } + + public void cpuLimit(int cpuLimit) { + E.checkArgument(cpuLimit > 0, + "The cpu limit must be > 0, but got: %s", cpuLimit); + this.cpuLimit = cpuLimit; + } + + public int memoryLimit() { + return this.memoryLimit; + } + + public void memoryLimit(int memoryLimit) { + E.checkArgument(memoryLimit > 0, + "The memory limit must be > 0, but got: %s", + memoryLimit); + this.memoryLimit = memoryLimit; + } + + public int storageLimit() { + return this.storageLimit; + } + + public void storageLimit(int storageLimit) { + E.checkArgument(storageLimit > 0, + "The storage limit must be > 0, but got: %s", + storageLimit); + this.storageLimit = storageLimit; + } + + public void setStorageUsed(int storageUsed) { + this.storageUsed = storageUsed; + } + + public int computeCpuLimit() { + return this.computeCpuLimit; + } + + public void computeCpuLimit(int computeCpuLimit) { + E.checkArgument(computeCpuLimit >= 0, + "The compute cpu limit must be >= 0, but got: %s", computeCpuLimit); + this.computeCpuLimit = computeCpuLimit; + } + + public int computeMemoryLimit() { + return this.computeMemoryLimit; + } + + public void computeMemoryLimit(int computeMemoryLimit) { + E.checkArgument(computeMemoryLimit >= 0, + "The compute memory limit must be >= 0, but got: %s", + computeMemoryLimit); + this.computeMemoryLimit = computeMemoryLimit; + } + + public String oltpNamespace() { + return this.oltpNamespace; + } + + public void oltpNamespace(String oltpNamespace) { + this.oltpNamespace = oltpNamespace; + } + + public String olapNamespace() { + return this.olapNamespace; + } + + public void olapNamespace(String olapNamespace) { + this.olapNamespace = olapNamespace; + } + + public String storageNamespace() { + return this.storageNamespace; + } + + public void storageNamespace(String storageNamespace) { + this.storageNamespace = storageNamespace; + } + + public int maxGraphNumber() { + return this.maxGraphNumber; + } + + public void maxGraphNumber(int maxGraphNumber) { + this.maxGraphNumber = maxGraphNumber; + } + + public int maxRoleNumber() { + return this.maxRoleNumber; + } + + public void maxRoleNumber(int maxRoleNumber) { + this.maxRoleNumber = maxRoleNumber; + } + + public int graphNumberUsed() { + return this.graphNumberUsed; + } + + public void graphNumberUsed(int graphNumberUsed) { + this.graphNumberUsed = graphNumberUsed; + } + + public int roleNumberUsed() { + return this.roleNumberUsed; + } + + public void roleNumberUsed(int roleNumberUsed) { + this.roleNumberUsed = roleNumberUsed; + } + + public boolean auth() { + return this.auth; + } + + public void auth(boolean auth) { + this.auth = auth; + } + + public Map configs() { + return this.configs; + } + + public void configs(Map configs) { + this.configs.putAll(configs); + } + + public void operatorImagePath(String path) { + this.operatorImagePath = path; + } + + public String operatorImagePath() { + return this.operatorImagePath; + } + + public void internalAlgorithmImageUrl(String url) { + if (StringUtils.isNotBlank(url)) { + this.internalAlgorithmImageUrl = url; + } + } + + public String internalAlgorithmImageUrl() { + return this.internalAlgorithmImageUrl; + } + + public Date createTime() { + return this.createTime; + } + + public Date updateTime() { + return this.updateTime; + } + + public String creator() { + return this.creator; + } + + public void updateTime(Date update) { + this.updateTime = update; + } + + public void createTime(Date create) { + this.createTime = create; + } + + public void refreshUpdate() { + this.updateTime = new Date(); + } + + public Map info() { + Map infos = new LinkedHashMap<>(); + infos.put("name", this.name); + infos.put("nickname", this.nickname); + infos.put("description", this.description); + + infos.put("cpu_limit", this.cpuLimit); + infos.put("memory_limit", this.memoryLimit); + infos.put("storage_limit", this.storageLimit); + + infos.put("compute_cpu_limit", this.computeCpuLimit); + infos.put("compute_memory_limit", this.computeMemoryLimit); + + infos.put("oltp_namespace", this.oltpNamespace); + infos.put("olap_namespace", this.olapNamespace); + infos.put("storage_namespace", this.storageNamespace); + + infos.put("max_graph_number", this.maxGraphNumber); + infos.put("max_role_number", this.maxRoleNumber); + + infos.putAll(this.configs); + // sources used info is not automatically updated, it could be + // updated by pdClient of GraphManager + infos.put("cpu_used", this.cpuUsed); + infos.put("memory_used", this.memoryUsed); + infos.put("storage_used", this.storageUsed); + float storageUserPercent = Float.parseFloat( + String.format("%.2f", (float) this.storageUsed / + ((float) this.storageLimit * 1.0))); + infos.put("storage_percent", storageUserPercent); + infos.put("graph_number_used", this.graphNumberUsed); + infos.put("role_number_used", this.roleNumberUsed); + + infos.put("auth", this.auth); + + infos.put("operator_image_path", this.operatorImagePath); + infos.put("internal_algorithm_image_url", this.internalAlgorithmImageUrl); + + infos.put("create_time", this.createTime); + infos.put("update_time", this.updateTime); + infos.put("creator", this.creator); + return infos; + } + + private synchronized void incrCpuUsed(int acquiredCount) { + if (acquiredCount < 0) { + throw new HugeException("cannot increase cpu used since acquired count is negative"); + } + this.cpuUsed += acquiredCount; + } + + private synchronized void decrCpuUsed(int releasedCount) { + if (releasedCount < 0) { + throw new HugeException("cannot decrease cpu used since released count is negative"); + } + if (cpuUsed < releasedCount) { + cpuUsed = 0; + } else { + this.cpuUsed -= releasedCount; + } + } + + private synchronized void incrMemoryUsed(int acquiredCount) { + if (acquiredCount < 0) { + throw new HugeException("cannot increase memory used since acquired count is negative"); + } + this.memoryUsed += acquiredCount; + } + + private synchronized void decrMemoryUsed(int releasedCount) { + if (releasedCount < 0) { + throw new HugeException("cannot decrease memory used since released count is negative"); + } + if (memoryUsed < releasedCount) { + this.memoryUsed = 0; + } else { + this.memoryUsed -= releasedCount; + } + } + + /** + * Only limit the resource usage for oltp service under k8s + * + * @param service + * @return + */ + public boolean tryOfferResourceFor(Service service) { + if (!service.k8s()) { + return true; + } + int count = service.count(); + int leftCpu = this.cpuLimit - this.cpuUsed; + int leftMemory = this.memoryLimit - this.memoryUsed; + int acquiredCpu = service.cpuLimit() * count; + int acquiredMemory = service.memoryLimit() * count; + if (acquiredCpu > leftCpu || + acquiredMemory > leftMemory) { + return false; + } + this.incrCpuUsed(acquiredCpu); + this.incrMemoryUsed(acquiredMemory); + return true; + } + + public void recycleResourceFor(Service service) { + int count = service.count(); + this.decrCpuUsed(service.cpuLimit() * count); + this.decrMemoryUsed(service.memoryLimit() * count); + } + + public boolean tryOfferGraph() { + return this.tryOfferGraph(1); + } + + public boolean tryOfferGraph(int count) { + if (this.graphNumberUsed + count > this.maxGraphNumber) { + return false; + } + this.graphNumberUsed += count; + return true; + } + + public void recycleGraph() { + this.recycleGraph(1); + } + + public void recycleGraph(int count) { + this.graphNumberUsed -= count; + } + + public boolean tryOfferRole() { + return this.tryOfferRole(1); + } + + public boolean tryOfferRole(int count) { + if (this.roleNumberUsed + count > this.maxRoleNumber) { + return false; + } + this.roleNumberUsed += count; + return true; + } + + public void recycleRole() { + this.recycleRole(1); + } + + public void recycleRole(int count) { + this.roleNumberUsed -= count; + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/SchemaTemplate.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/SchemaTemplate.java new file mode 100644 index 0000000000..17e2eb5377 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/SchemaTemplate.java @@ -0,0 +1,140 @@ +/* + * 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.hugegraph.space; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.Map; + +import org.apache.hugegraph.util.E; + +import com.google.common.collect.ImmutableMap; + +public class SchemaTemplate { + + public static SimpleDateFormat FORMATTER = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + protected Date createTime; + protected Date updateTime; + protected String creator; + private String name; + private String schema; + + public SchemaTemplate(String name, String schema) { + E.checkArgument(name != null && !name.isEmpty(), + "The name of schema template can't be null or empty"); + E.checkArgument(schema != null && !schema.isEmpty(), + "The schema template can't be null or empty"); + this.name = name; + this.schema = schema; + this.createTime = new Date(); + this.updateTime = createTime; + } + + public SchemaTemplate(String name, String schema, Date create, String creator) { + E.checkArgument(name != null && !name.isEmpty(), + "The name of schema template can't be null or empty"); + E.checkArgument(schema != null && !schema.isEmpty(), + "The schema template can't be null or empty"); + this.name = name; + this.schema = schema; + this.createTime = create; + this.updateTime = createTime; + + this.creator = creator; + } + + public static SchemaTemplate fromMap(Map map) { + try { + SchemaTemplate template = new SchemaTemplate(map.get("name"), + map.get("schema"), + FORMATTER.parse(map.get("create")), + map.get("creator")); + + template.updateTime(FORMATTER.parse(map.get("update"))); + return template; + + } catch (ParseException e) { + e.printStackTrace(); + } + + return null; + } + + public String name() { + return this.name; + } + + public String schema() { + return this.schema; + } + + public void schema(String schema) { + this.schema = schema; + } + + public Date create() { + return this.createTime; + } + + public Date createTime() { + return this.createTime; + } + + public Date update() { + return this.updateTime; + } + + public Date updateTime() { + return this.updateTime; + } + + public void create(Date create) { + this.createTime = create; + } + + public String creator() { + return this.creator; + } + + public void creator(String creator) { + this.creator = creator; + } + + public void updateTime(Date updateTime) { + this.updateTime = updateTime; + } + + public void refreshUpdateTime() { + this.updateTime = new Date(); + } + + public Map asMap() { + String createStr = FORMATTER.format(this.createTime); + String updateStr = FORMATTER.format(this.updateTime); + return new ImmutableMap.Builder() + .put("name", this.name) + .put("schema", this.schema) + .put("create", createStr) + .put("create_time", createStr) + .put("update", updateStr) + .put("update_time", updateStr) + .put("creator", this.creator) + .build(); + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/Service.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/Service.java new file mode 100644 index 0000000000..bfd3fe6b14 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/Service.java @@ -0,0 +1,361 @@ +/* + * 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.hugegraph.space; + +import java.util.Date; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Set; + +import org.apache.commons.lang.StringUtils; +import org.apache.hugegraph.util.E; + +public class Service { + + public static final int DEFAULT_COUNT = 1; + public static final String DEFAULT_ROUTE_TYPE = "NodePort"; + public static final int DEFAULT_PORT = 0; + + public static final int DEFAULT_CPU_LIMIT = 4; + public static final int DEFAULT_MEMORY_LIMIT = 8; + public static final int DEFAULT_STORAGE_LIMIT = 100; + private final String creator; + private String name; + private ServiceType type; + private DeploymentType deploymentType; + private String description; + private Status status; + private int count; + private int running; + private int cpuLimit; + private int memoryLimit; // GB + private int storageLimit; // GB + private String routeType; + private int port; + private Set urls = new HashSet<>(); + private Set serverDdsUrls = new HashSet<>(); + private Set serverNodePortUrls = new HashSet<>(); + private String serviceId; + private String pdServiceId; + private Date createTime; + private Date updateTime; + + public Service(String name, String creator, ServiceType type, + DeploymentType deploymentType) { + E.checkArgument(name != null && !StringUtils.isEmpty(name), + "The name of service can't be null or empty"); + E.checkArgumentNotNull(type, "The type of service can't be null"); + E.checkArgumentNotNull(deploymentType, + "The deployment type of service can't be null"); + this.name = name; + this.type = type; + this.deploymentType = deploymentType; + this.status = Status.UNKNOWN; + this.count = DEFAULT_COUNT; + this.running = 0; + this.routeType = DEFAULT_ROUTE_TYPE; + this.port = DEFAULT_PORT; + this.cpuLimit = DEFAULT_CPU_LIMIT; + this.memoryLimit = DEFAULT_MEMORY_LIMIT; + this.storageLimit = DEFAULT_STORAGE_LIMIT; + + this.creator = creator; + this.createTime = new Date(); + this.updateTime = this.createTime; + } + + public Service(String name, String creator, String description, ServiceType type, + DeploymentType deploymentType, int count, int running, + int cpuLimit, int memoryLimit, int storageLimit, + String routeType, int port, Set urls) { + E.checkArgument(name != null && !StringUtils.isEmpty(name), + "The name of service can't be null or empty"); + E.checkArgumentNotNull(type, "The type of service can't be null"); + this.name = name; + this.description = description; + this.type = type; + this.status = Status.UNKNOWN; + this.deploymentType = deploymentType; + this.count = count; + this.running = running; + this.cpuLimit = cpuLimit; + this.memoryLimit = memoryLimit; + this.storageLimit = storageLimit; + this.routeType = routeType; + this.port = port; + this.urls = urls; + + this.creator = creator; + this.createTime = new Date(); + this.updateTime = this.createTime; + } + + public String name() { + return this.name; + } + + public String description() { + return this.description; + } + + public void description(String description) { + this.description = description; + } + + public ServiceType type() { + return this.type; + } + + public void type(ServiceType type) { + this.type = type; + } + + public DeploymentType deploymentType() { + return this.deploymentType; + } + + public void deploymentType(DeploymentType deploymentType) { + this.deploymentType = deploymentType; + } + + public Status status() { + return this.status; + } + + public void status(Status status) { + this.status = status; + } + + public int count() { + return this.count; + } + + public void count(int count) { + E.checkArgument(count > 0, + "The service count must be > 0, but got: %s", count); + this.count = count; + } + + public int running() { + return this.running; + } + + public void running(int running) { + E.checkArgument(running <= this.count, + "The running count must be < count %s, but got: %s", + this.count, running); + this.running = running; + } + + public int cpuLimit() { + return this.cpuLimit; + } + + public void cpuLimit(int cpuLimit) { + E.checkArgument(cpuLimit > 0, + "The cpu limit must be > 0, but got: %s", cpuLimit); + this.cpuLimit = cpuLimit; + } + + public int memoryLimit() { + return this.memoryLimit; + } + + public void memoryLimit(int memoryLimit) { + E.checkArgument(memoryLimit > 0, + "The memory limit must be > 0, but got: %s", + memoryLimit); + this.memoryLimit = memoryLimit; + } + + public int storageLimit() { + return this.storageLimit; + } + + public void storageLimit(int storageLimit) { + E.checkArgument(storageLimit > 0, + "The storage limit must be > 0, but got: %s", + storageLimit); + this.storageLimit = storageLimit; + } + + public String routeType() { + return this.routeType; + } + + public void routeType(String routeType) { + this.routeType = routeType; + } + + public int port() { + return this.port; + } + + public void port(int port) { + this.port = port; + } + + public Set urls() { + if (this.urls == null) { + this.urls = new HashSet<>(); + } + return this.urls; + } + + public void urls(Set urls) { + this.urls = urls; + } + + public Set serverDdsUrls() { + if (this.serverDdsUrls == null) { + this.serverDdsUrls = new HashSet<>(); + } + return this.serverDdsUrls; + } + + public void serverDdsUrls(Set urls) { + this.serverDdsUrls = urls; + } + + public Set serverNodePortUrls() { + if (this.serverNodePortUrls == null) { + this.serverNodePortUrls = new HashSet<>(); + } + return this.serverNodePortUrls; + } + + public void serverNodePortUrls(Set urls) { + this.serverNodePortUrls = urls; + } + + public void url(String url) { + if (this.urls == null) { + this.urls = new HashSet<>(); + } + this.urls.add(url); + } + + public boolean manual() { + return DeploymentType.MANUAL.equals(this.deploymentType); + } + + public boolean k8s() { + return DeploymentType.K8S.equals(this.deploymentType); + } + + public String creator() { + return this.creator; + } + + public Date createdTime() { + return this.createTime; + } + + public Date updateTime() { + return this.updateTime; + } + + public void createTime(Date create) { + this.createTime = create; + } + + public void updateTime(Date update) { + this.updateTime = update; + } + + public void refreshUpdate() { + this.updateTime = new Date(); + } + + public boolean sameService(Service other) { + if (other.deploymentType == DeploymentType.K8S || + this.deploymentType == DeploymentType.K8S) { + return true; + } + return (this.name.equals(other.name) && + this.type.equals(other.type) && + this.deploymentType == other.deploymentType && + this.urls.equals(other.urls) && + this.port == other.port); + } + + public Map info() { + Map infos = new LinkedHashMap<>(); + infos.put("name", this.name); + infos.put("type", this.type); + infos.put("deployment_type", this.deploymentType); + infos.put("description", this.description); + infos.put("status", this.status); + infos.put("count", this.count); + infos.put("running", this.running); + + infos.put("cpu_limit", this.cpuLimit); + infos.put("memory_limit", this.memoryLimit); + infos.put("storage_limit", this.storageLimit); + + infos.put("route_type", this.routeType); + infos.put("port", this.port); + infos.put("urls", this.urls); + infos.put("server_dds_urls", this.serverDdsUrls); + infos.put("server_node_port_urls", this.serverNodePortUrls); + + infos.put("service_id", this.serviceId); + infos.put("pd_service_id", this.pdServiceId); + + infos.put("creator", this.creator); + infos.put("create_time", this.createTime); + infos.put("update_time", this.updateTime); + + return infos; + } + + public String serviceId() { + return this.serviceId; + } + + public void serviceId(String serviceId) { + this.serviceId = serviceId; + } + + public String pdServiceId() { + return this.pdServiceId; + } + + public void pdServiceId(String serviceId) { + this.pdServiceId = serviceId; + } + + public enum DeploymentType { + MANUAL, + K8S, + } + + public enum ServiceType { + OLTP, + OLAP, + STORAGE + } + + public enum Status { + UNKNOWN, + STARTING, + RUNNING, + STOPPED + } +} From 178025136c8ce80dbf0dbf263b0df701e0af93d6 Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Mon, 21 Aug 2023 23:44:36 +0800 Subject: [PATCH 07/26] chore: adapt meta schema --- hugegraph-server/hugegraph-core/pom.xml | 16 ++ .../org/apache/hugegraph/auth/HugeAccess.java | 5 + .../org/apache/hugegraph/auth/HugeBelong.java | 14 + .../org/apache/hugegraph/auth/HugeGroup.java | 14 + .../org/apache/hugegraph/auth/HugeRole.java | 240 ++++++++++++++++++ .../org/apache/hugegraph/auth/HugeTarget.java | 18 ++ .../org/apache/hugegraph/auth/HugeUser.java | 14 + .../apache/hugegraph/auth/SchemaDefine.java | 22 ++ .../apache/hugegraph/schema/EdgeLabel.java | 170 +++++++++++++ .../apache/hugegraph/schema/IndexLabel.java | 73 ++++++ .../apache/hugegraph/schema/PropertyKey.java | 84 ++++++ .../hugegraph/schema/SchemaElement.java | 27 ++ .../apache/hugegraph/schema/VertexLabel.java | 112 ++++++++ .../backend/store/hstore/HstoreProvider.java | 9 +- .../backend/store/hstore/HstoreStore.java | 56 ++++ 15 files changed, 869 insertions(+), 5 deletions(-) create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeRole.java diff --git a/hugegraph-server/hugegraph-core/pom.xml b/hugegraph-server/hugegraph-core/pom.xml index 1c954e16f1..9b7b319073 100644 --- a/hugegraph-server/hugegraph-core/pom.xml +++ b/hugegraph-server/hugegraph-core/pom.xml @@ -241,6 +241,22 @@ gson 2.8.9 + + org.apache.hugegraph + hg-pd-client + ${revision} + + + io.etcd + jetcd-core + 0.5.9 + + + io.grpc + grpc-core + + + diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeAccess.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeAccess.java index d17131a29c..3749a314be 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeAccess.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeAccess.java @@ -229,4 +229,9 @@ private String[] initProperties() { return super.initProperties(props); } } + + public static HugeAccess fromMap(Map map) { + HugeAccess access = new HugeAccess(null, null, null); + return fromMap(map, access); + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeBelong.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeBelong.java index f91c26af0b..ffd5d3bc5f 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeBelong.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeBelong.java @@ -33,10 +33,15 @@ public class HugeBelong extends Relationship { + public static final String UG = "ug"; + public static final String UR = "ur"; + public static final String GR = "gr"; + public static final String ALL = "*"; private static final long serialVersionUID = -7242751631755533423L; private final Id user; private final Id group; + private String link; private String description; public HugeBelong(Id user, Id group) { @@ -75,6 +80,10 @@ public Id target() { return this.group; } + public String link() { + return this.link; + } + public String description() { return this.description; } @@ -196,4 +205,9 @@ private String[] initProperties() { return super.initProperties(props); } } + + public static HugeBelong fromMap(Map map) { + HugeBelong belong = new HugeBelong(null, null); + return fromMap(map, belong); + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeGroup.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeGroup.java index 1bced91d9f..acc7973043 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeGroup.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeGroup.java @@ -37,6 +37,7 @@ public class HugeGroup extends Entity { private static final long serialVersionUID = 2330399818352242686L; private String name; + private String nickname; private String description; public HugeGroup(String name) { @@ -68,6 +69,14 @@ public String name() { return this.name; } + public String nickname() { + return this.nickname; + } + + public void nickname(String nickname) { + this.nickname = nickname; + } + public String description() { return this.description; } @@ -195,4 +204,9 @@ protected String[] initProperties() { return super.initProperties(props); } } + + public static HugeGroup fromMap(Map map) { + HugeGroup group = new HugeGroup(""); + return fromMap(map, group); + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeRole.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeRole.java new file mode 100644 index 0000000000..ee5955bbaf --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeRole.java @@ -0,0 +1,240 @@ +/* + * 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.hugegraph.auth; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.commons.lang3.StringUtils; +import org.apache.hugegraph.HugeGraphParams; +import org.apache.hugegraph.auth.SchemaDefine.Entity; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.schema.VertexLabel; +import org.apache.hugegraph.util.E; +import org.apache.tinkerpop.gremlin.structure.Graph.Hidden; +import org.apache.tinkerpop.gremlin.structure.T; + +public class HugeRole extends Entity { + + private static final long serialVersionUID = 2330399818352242686L; + + private String name; + private String nickname; + private String graphSpace; + private String description; + + public HugeRole(Id id, String name, String graphSpace) { + this.id = id; + this.name = name; + this.graphSpace = graphSpace; + this.description = null; + } + + public HugeRole(String name, String graphSpace) { + this(StringUtils.isNotEmpty(name) ? IdGenerator.of(name) : null, + name, graphSpace); + } + + public HugeRole(Id id, String graphSpace) { + this(id, id.asString(), graphSpace); + } + + public static HugeRole fromMap(Map map) { + HugeRole role = new HugeRole("", ""); + return fromMap(map, role); + } + + public static Schema schema(HugeGraphParams graph) { + return new Schema(graph); + } + + @Override + public ResourceType type() { + return ResourceType.GRANT; + } + + @Override + public String label() { + return P.ROLE; + } + + @Override + public String name() { + return this.name; + } + + public void name(String name) { + this.name = name; + } + + public String nickname() { + return this.nickname; + } + + public void nickname(String nickname) { + this.nickname = nickname; + } + + public String graphSpace() { + return this.graphSpace; + } + + public String description() { + return this.description; + } + + public void description(String description) { + this.description = description; + } + + @Override + public String toString() { + return String.format("HugeGroup(%s)", this.id); + } + + @Override + protected boolean property(String key, Object value) { + if (super.property(key, value)) { + return true; + } + switch (key) { + case P.GRAPHSPACE: + this.graphSpace = (String) value; + break; + case P.NAME: + this.name = (String) value; + break; + case P.NICKNAME: + this.nickname = (String) value; + break; + case P.DESCRIPTION: + this.description = (String) value; + break; + default: + throw new AssertionError("Unsupported key: " + key); + } + return true; + } + + @Override + protected Object[] asArray() { + E.checkState(this.name != null, "Group name can't be null"); + + List list = new ArrayList<>(12); + + list.add(T.label); + list.add(P.ROLE); + + list.add(P.GRAPHSPACE); + list.add(this.graphSpace); + + list.add(P.NAME); + list.add(this.name); + + if (this.nickname != null) { + list.add(P.NICKNAME); + list.add(this.nickname); + } + + if (this.description != null) { + list.add(P.DESCRIPTION); + list.add(this.description); + } + + return super.asArray(list); + } + + @Override + public Map asMap() { + E.checkState(this.name != null, "Group name can't be null"); + + Map map = new HashMap<>(); + + map.put(Hidden.unHide(P.NAME), this.name); + map.put(Hidden.unHide(P.GRAPHSPACE), this.graphSpace); + if (this.description != null) { + map.put(Hidden.unHide(P.DESCRIPTION), this.description); + } + + if (this.nickname != null) { + map.put(Hidden.unHide(P.NICKNAME), this.nickname); + } + + return super.asMap(map); + } + + public static final class P { + + public static final String ROLE = Hidden.hide("role"); + + public static final String ID = T.id.getAccessor(); + public static final String LABEL = T.label.getAccessor(); + + public static final String NAME = "~role_name"; + public static final String NICKNAME = "~role_nickname"; + public static final String GRAPHSPACE = "~graphspace"; + public static final String DESCRIPTION = "~role_description"; + + public static String unhide(String key) { + final String prefix = Hidden.hide("role_"); + if (key.startsWith(prefix)) { + return key.substring(prefix.length()); + } + return key; + } + } + + public static final class Schema extends SchemaDefine { + + public Schema(HugeGraphParams graph) { + super(graph, P.ROLE); + } + + @Override + public void initSchemaIfNeeded() { + if (this.existVertexLabel(this.label)) { + return; + } + + String[] properties = this.initProperties(); + + // Create vertex label + VertexLabel label = this.schema().vertexLabel(this.label) + .properties(properties) + .usePrimaryKeyId() + .primaryKeys(P.NAME) + .nullableKeys(P.DESCRIPTION, P.NICKNAME) + .enableLabelIndex(true) + .build(); + this.graph.schemaTransaction().addVertexLabel(label); + } + + protected String[] initProperties() { + List props = new ArrayList<>(); + + props.add(createPropertyKey(P.NAME)); + props.add(createPropertyKey(P.DESCRIPTION)); + props.add(createPropertyKey(P.NICKNAME)); + + return super.initProperties(props); + } + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeTarget.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeTarget.java index ed4207565c..f4f9c1f050 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeTarget.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeTarget.java @@ -42,6 +42,7 @@ public class HugeTarget extends Entity { private String name; private String graph; + private String description; private String url; private List resources; @@ -92,6 +93,18 @@ public String graph() { return this.graph; } + public void graph(String graph) { + this.graph = graph; + } + + public String description() { + return this.description; + } + + public void description(String description) { + this.description = description; + } + public String url() { return this.url; } @@ -258,4 +271,9 @@ private String[] initProperties() { return super.initProperties(props); } } + + public static HugeTarget fromMap(Map map) { + HugeTarget target = new HugeTarget(null); + return fromMap(map, target); + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeUser.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeUser.java index cc386fe57d..510e837552 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeUser.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/HugeUser.java @@ -37,6 +37,7 @@ public class HugeUser extends Entity { private static final long serialVersionUID = -8951193710873772717L; private String name; + private String nickname; private String password; private String phone; private String email; @@ -74,6 +75,14 @@ public String name() { return this.name; } + public String nickname() { + return nickname; + } + + public void nickname(String nickname) { + this.nickname = nickname; + } + public String password() { return this.password; } @@ -281,4 +290,9 @@ private String[] initProperties() { return super.initProperties(props); } } + + public static HugeUser fromMap(Map map) { + HugeUser user = new HugeUser(""); + return fromMap(map, user); + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/SchemaDefine.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/SchemaDefine.java index 80020638b7..ff4c5fa2ed 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/SchemaDefine.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/SchemaDefine.java @@ -25,6 +25,7 @@ import org.apache.hugegraph.auth.HugeTarget.P; import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; import org.apache.hugegraph.schema.IndexLabel; import org.apache.hugegraph.schema.PropertyKey; import org.apache.hugegraph.schema.SchemaManager; @@ -245,6 +246,14 @@ public abstract static class Entity extends AuthElement private static final long serialVersionUID = 4113319546914811762L; + public static T fromMap(Map map, T entity) { + for (Map.Entry item : map.entrySet()) { + entity.property(Hidden.hide(item.getKey()), item.getValue()); + } + entity.id(IdGenerator.of(entity.name())); + return entity; + } + public static T fromVertex(Vertex vertex, T entity) { E.checkArgument(vertex.label().equals(entity.label()), "Illegal vertex label '%s' for entity '%s'", @@ -281,6 +290,19 @@ public abstract static class Relationship extends AuthElement { public abstract Id target(); + public void setId() { + this.id(IdGenerator.of(this.source().asString() + "->" + + this.target().asString())); + } + + public static T fromMap(Map map, T entity) { + for (Map.Entry item : map.entrySet()) { + entity.property(Hidden.hide(item.getKey()), item.getValue()); + } + entity.setId(); + return entity; + } + public static T fromEdge(Edge edge, T relationship) { E.checkArgument(edge.label().equals(relationship.label()), diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/EdgeLabel.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/EdgeLabel.java index 79380a0d41..d6bd642f6e 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/EdgeLabel.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/EdgeLabel.java @@ -20,14 +20,20 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; +import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; +import org.apache.commons.lang3.tuple.Pair; import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; import org.apache.hugegraph.schema.builder.SchemaBuilder; import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.type.define.Frequency; +import org.apache.hugegraph.type.define.SchemaStatus; import org.apache.hugegraph.util.E; import com.google.common.base.Objects; @@ -164,4 +170,168 @@ public interface Builder extends SchemaBuilder { Builder userdata(Map userdata); } + + @Override + public Map asMap() { + Map map = new HashMap<>(); + + if (this.sourceLabel() != null && this.sourceLabel() != NONE_ID) { + map.put(P.SOURCE_LABEL, this.sourceLabel().asString()); + } + + if (this.targetLabel() != null && this.targetLabel() != NONE_ID) { + map.put(P.TARGET_LABEL, this.targetLabel().asString()); + } + + if (this.properties() != null) { + map.put(P.PROPERTIES, this.properties()); + } + + if (this.nullableKeys() != null) { + map.put(P.NULLABLE_KEYS, this.nullableKeys()); + } + + if (this.indexLabels() != null) { + map.put(P.INDEX_LABELS, this.indexLabels()); + } + + if (this.ttlStartTime() != null) { + map.put(P.TT_START_TIME, this.ttlStartTime().asString()); + } + + if (this.sortKeys() != null) { + map.put(P.SORT_KEYS, this.sortKeys); + } + + //map.put(P.EDGELABEL_TYPE, this.edgeLabelType); + //if (this.fatherId() != null) { + // map.put(P.FATHER_ID, this.fatherId().asString()); + //} + map.put(P.ENABLE_LABEL_INDEX, this.enableLabelIndex()); + map.put(P.TTL, String.valueOf(this.ttl())); + //map.put(P.LINKS, this.links()); + map.put(P.FREQUENCY, this.frequency().toString()); + + return super.asMap(map); + } + + @SuppressWarnings("unchecked") + public static EdgeLabel fromMap(Map map, HugeGraph graph) { + Id id = IdGenerator.of((int) map.get(EdgeLabel.P.ID)); + String name = (String) map.get(EdgeLabel.P.NAME); + EdgeLabel edgeLabel = new EdgeLabel(graph, id, name); + for (Map.Entry entry : map.entrySet()) { + switch (entry.getKey()) { + case P.ID: + case P.NAME: + break; + case P.STATUS: + edgeLabel.status( + SchemaStatus.valueOf(((String) entry.getValue()).toUpperCase())); + break; + case P.USERDATA: + edgeLabel.userdata(new Userdata((Map) entry.getValue())); + break; + case P.PROPERTIES: + Set ids = ((List) entry.getValue()).stream().map( + IdGenerator::of).collect(Collectors.toSet()); + edgeLabel.properties(ids); + break; + case P.NULLABLE_KEYS: + ids = ((List) entry.getValue()).stream().map( + IdGenerator::of).collect(Collectors.toSet()); + edgeLabel.nullableKeys(ids); + break; + case P.INDEX_LABELS: + ids = ((List) entry.getValue()).stream().map( + IdGenerator::of).collect(Collectors.toSet()); + edgeLabel.addIndexLabels(ids.toArray(new Id[0])); + break; + case P.ENABLE_LABEL_INDEX: + boolean enableLabelIndex = (Boolean) entry.getValue(); + edgeLabel.enableLabelIndex(enableLabelIndex); + break; + case P.TTL: + long ttl = Long.parseLong((String) entry.getValue()); + edgeLabel.ttl(ttl); + break; + case P.TT_START_TIME: + long ttlStartTime = + Long.parseLong((String) entry.getValue()); + edgeLabel.ttlStartTime(IdGenerator.of(ttlStartTime)); + break; + //case P.LINKS: + // // TODO: serialize and deserialize + // List list = (List) entry.getValue(); + // for (Map m : list) { + // for (Object key : m.keySet()) { + // Id sid = IdGenerator.of(Long.parseLong((String) key)); + // Id tid = IdGenerator.of(Long.parseLong(String.valueOf(m.get(key)))); + // edgeLabel.links(Pair.of(sid, tid)); + // } + // } + // break; + case P.SOURCE_LABEL: + long sourceLabel = + Long.parseLong((String) entry.getValue()); + edgeLabel.sourceLabel(IdGenerator.of(sourceLabel)); + break; + case P.TARGET_LABEL: + long targetLabel = + Long.parseLong((String) entry.getValue()); + edgeLabel.targetLabel(IdGenerator.of(targetLabel)); + break; + //case P.FATHER_ID: + // long fatherId = + // Long.parseLong((String) entry.getValue()); + // edgeLabel.fatherId(IdGenerator.of(fatherId)); + // break; + //case P.EDGELABEL_TYPE: + // EdgeLabelType edgeLabelType = + // EdgeLabelType.valueOf( + // ((String) entry.getValue()).toUpperCase()); + // edgeLabel.edgeLabelType(edgeLabelType); + // break; + case P.FREQUENCY: + Frequency frequency = + Frequency.valueOf(((String) entry.getValue()).toUpperCase()); + edgeLabel.frequency(frequency); + break; + case P.SORT_KEYS: + ids = ((List) entry.getValue()).stream().map( + IdGenerator::of).collect(Collectors.toSet()); + edgeLabel.sortKeys(ids.toArray(new Id[0])); + break; + default: + throw new AssertionError(String.format( + "Invalid key '%s' for edge label", + entry.getKey())); + } + } + return edgeLabel; + } + + public static final class P { + + public static final String ID = "id"; + public static final String NAME = "name"; + + public static final String STATUS = "status"; + public static final String USERDATA = "userdata"; + + public static final String PROPERTIES = "properties"; + public static final String NULLABLE_KEYS = "nullableKeys"; + public static final String INDEX_LABELS = "indexLabels"; + + public static final String ENABLE_LABEL_INDEX = "enableLabelIndex"; + public static final String TTL = "ttl"; + public static final String TT_START_TIME = "ttlStartTime"; + public static final String LINKS = "links"; + public static final String SOURCE_LABEL = "sourceLabel"; + public static final String TARGET_LABEL = "targetLabel"; + public static final String EDGELABEL_TYPE = "edgeLabelType"; + public static final String FATHER_ID = "fatherId"; + public static final String FREQUENCY = "frequency"; + public static final String SORT_KEYS = "sortKeys"; + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/IndexLabel.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/IndexLabel.java index 54c33b53c3..473d912560 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/IndexLabel.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/IndexLabel.java @@ -20,8 +20,10 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; +import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.stream.Collectors; import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; @@ -29,6 +31,7 @@ import org.apache.hugegraph.schema.builder.SchemaBuilder; import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.type.define.IndexType; +import org.apache.hugegraph.type.define.SchemaStatus; import org.apache.hugegraph.util.E; import com.google.common.base.Objects; @@ -280,4 +283,74 @@ public interface Builder extends SchemaBuilder { Builder rebuild(boolean rebuild); } + @Override + public Map asMap() { + HashMap map = new HashMap<>(); + map.put(P.BASE_TYPE, this.baseType().name()); + map.put(P.BASE_VALUE, this.baseValue().asString()); + map.put(P.INDEX_TYPE, this.indexType().name()); + map.put(P.INDEX_FIELDS, this.indexFields()); + return super.asMap(map); + } + + @SuppressWarnings("unchecked") + public static IndexLabel fromMap(Map map, HugeGraph graph) { + Id id = IdGenerator.of((int) map.get(IndexLabel.P.ID)); + String name = (String) map.get(IndexLabel.P.NAME); + + IndexLabel indexLabel = new IndexLabel(graph, id, name); + for (Map.Entry entry : map.entrySet()) { + switch (entry.getKey()) { + case P.ID: + case P.NAME: + break; + case P.STATUS: + indexLabel.status( + SchemaStatus.valueOf(((String) entry.getValue()).toUpperCase())); + break; + case P.USERDATA: + indexLabel.userdata(new Userdata((Map) entry.getValue())); + break; + case P.BASE_TYPE: + HugeType hugeType = + HugeType.valueOf(((String) entry.getValue()).toUpperCase()); + indexLabel.baseType(hugeType); + break; + case P.BASE_VALUE: + long sourceLabel = + Long.parseLong((String) entry.getValue()); + indexLabel.baseValue(IdGenerator.of(sourceLabel)); + break; + case P.INDEX_TYPE: + IndexType indexType = + IndexType.valueOf(((String) entry.getValue()).toUpperCase()); + indexLabel.indexType(indexType); + break; + case P.INDEX_FIELDS: + List ids = ((List) entry.getValue()).stream().map( + IdGenerator::of).collect(Collectors.toList()); + indexLabel.indexFields(ids.toArray(new Id[0])); + break; + default: + throw new AssertionError(String.format( + "Invalid key '%s' for index label", + entry.getKey())); + } + } + return indexLabel; + } + + public static final class P { + + public static final String ID = "id"; + public static final String NAME = "name"; + + public static final String STATUS = "status"; + public static final String USERDATA = "userdata"; + + public static final String BASE_TYPE = "baseType"; + public static final String BASE_VALUE = "baseValue"; + public static final String INDEX_TYPE = "indexType"; + public static final String INDEX_FIELDS = "indexFields"; + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/PropertyKey.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/PropertyKey.java index f86bec0aec..59c1e73a4c 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/PropertyKey.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/PropertyKey.java @@ -20,6 +20,7 @@ import java.util.ArrayList; import java.util.Collection; import java.util.Collections; +import java.util.HashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; @@ -28,6 +29,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.HugeException; import org.apache.hugegraph.HugeGraph; +import org.apache.hugegraph.backend.id.IdGenerator; import org.apache.hugegraph.exception.NotSupportException; import org.apache.hugegraph.schema.builder.SchemaBuilder; import org.apache.hugegraph.type.HugeType; @@ -35,6 +37,7 @@ import org.apache.hugegraph.type.define.AggregateType; import org.apache.hugegraph.type.define.Cardinality; import org.apache.hugegraph.type.define.DataType; +import org.apache.hugegraph.type.define.SchemaStatus; import org.apache.hugegraph.type.define.WriteType; import org.apache.hugegraph.util.E; import org.apache.hugegraph.util.LongEncoding; @@ -409,4 +412,85 @@ public interface Builder extends SchemaBuilder { Builder userdata(Map userdata); } + + @Override + public Map asMap() { + Map map = new HashMap<>(); + + if (this.dataType != null) { + map.put(P.DATA_TYPE, this.dataType.string()); + } + + if (this.cardinality != null) { + map.put(P.CARDINALITY, this.cardinality.string()); + } + + if (this.aggregateType != null) { + map.put(P.AGGREGATE_TYPE, this.aggregateType.string()); + } + + if (this.writeType != null) { + map.put(P.WRITE_TYPE, this.writeType.string()); + } + + return super.asMap(map); + } + + @SuppressWarnings("unchecked") + public static PropertyKey fromMap(Map map, HugeGraph graph) { + Id id = IdGenerator.of((int) map.get(P.ID)); + String name = (String) map.get(P.NAME); + + PropertyKey propertyKey = new PropertyKey(graph, id, name); + for (Map.Entry entry : map.entrySet()) { + switch (entry.getKey()) { + case P.ID: + case P.NAME: + break; + case P.STATUS: + propertyKey.status( + SchemaStatus.valueOf(((String) entry.getValue()).toUpperCase())); + break; + case P.USERDATA: + propertyKey.userdata(new Userdata((Map) entry.getValue())); + break; + case P.AGGREGATE_TYPE: + propertyKey.aggregateType( + AggregateType.valueOf(((String) entry.getValue()).toUpperCase())); + break; + case P.WRITE_TYPE: + propertyKey.writeType( + WriteType.valueOf(((String) entry.getValue()).toUpperCase())); + break; + case P.DATA_TYPE: + propertyKey.dataType( + DataType.valueOf(((String) entry.getValue()).toUpperCase())); + break; + case P.CARDINALITY: + propertyKey.cardinality( + Cardinality.valueOf(((String) entry.getValue()).toUpperCase())); + break; + default: + throw new AssertionError(String.format( + "Invalid key '%s' for property key", + entry.getKey())); + } + } + return propertyKey; + } + + public static final class P { + + public static final String ID = "id"; + public static final String NAME = "name"; + + public static final String STATUS = "status"; + public static final String USERDATA = "userdata"; + + public static final String DATA_TYPE = "data_type"; + public static final String CARDINALITY = "cardinality"; + + public static final String AGGREGATE_TYPE = "aggregate_type"; + public static final String WRITE_TYPE = "write_type"; + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaElement.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaElement.java index 1e42767a0c..117a7c597f 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaElement.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaElement.java @@ -217,4 +217,31 @@ public Id task() { return this.task; } } + + public abstract Map asMap(); + + public Map asMap(Map map) { + E.checkState(this.id != null, + "Property key id can't be null"); + E.checkState(this.name != null, + "Property key name can't be null"); + E.checkState(this.status != null, + "Property status can't be null"); + + map.put(P.ID, this.id); + map.put(P.NAME, this.name); + map.put(P.STATUS, this.status.string()); + map.put(P.USERDATA, this.userdata); + + return map; + } + + public static final class P { + + public static final String ID = "id"; + public static final String NAME = "name"; + + public static final String STATUS = "status"; + public static final String USERDATA = "userdata"; + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/VertexLabel.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/VertexLabel.java index 2b3b8e9bf1..487323af10 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/VertexLabel.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/VertexLabel.java @@ -20,8 +20,11 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; +import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; @@ -29,6 +32,8 @@ import org.apache.hugegraph.schema.builder.SchemaBuilder; import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.type.define.IdStrategy; +import org.apache.hugegraph.type.define.SchemaStatus; + import com.google.common.base.Objects; public class VertexLabel extends SchemaLabel { @@ -132,4 +137,111 @@ public interface Builder extends SchemaBuilder { Builder userdata(Map userdata); } + + @Override + public Map asMap() { + HashMap map = new HashMap(); + + map.put(P.PROPERTIES, this.properties()); + + map.put(P.NULLABLE_KEYS, this.nullableKeys()); + + map.put(P.INDEX_LABELS, this.indexLabels()); + + map.put(P.ENABLE_LABEL_INDEX, this.enableLabelIndex()); + + map.put(P.TTL, String.valueOf(this.ttl())); + + map.put(P.TT_START_TIME, this.ttlStartTime().asString()); + + map.put(P.ID_STRATEGY, this.idStrategy().string()); + + map.put(P.PRIMARY_KEYS, this.primaryKeys()); + + return super.asMap(map); + } + + @SuppressWarnings("unchecked") + public static VertexLabel fromMap(Map map, HugeGraph graph) { + Id id = IdGenerator.of((int) map.get(VertexLabel.P.ID)); + String name = (String) map.get(VertexLabel.P.NAME); + + VertexLabel vertexLabel = new VertexLabel(graph, id, name); + for (Map.Entry entry : map.entrySet()) { + switch (entry.getKey()) { + case P.ID: + case P.NAME: + break; + case P.STATUS: + vertexLabel.status( + SchemaStatus.valueOf(((String) entry.getValue()).toUpperCase())); + break; + case P.USERDATA: + vertexLabel.userdata(new Userdata((Map) entry.getValue())); + break; + case P.PROPERTIES: + Set ids = ((List) entry.getValue()).stream().map( + IdGenerator::of).collect(Collectors.toSet()); + vertexLabel.properties(ids); + break; + case P.NULLABLE_KEYS: + ids = ((List) entry.getValue()).stream().map( + IdGenerator::of).collect(Collectors.toSet()); + vertexLabel.nullableKeys(ids); + break; + case P.INDEX_LABELS: + ids = ((List) entry.getValue()).stream().map( + IdGenerator::of).collect(Collectors.toSet()); + vertexLabel.addIndexLabels(ids.toArray(new Id[0])); + break; + case P.ENABLE_LABEL_INDEX: + boolean enableLabelIndex = (Boolean) entry.getValue(); + vertexLabel.enableLabelIndex(enableLabelIndex); + break; + case P.TTL: + long ttl = Long.parseLong((String) entry.getValue()); + vertexLabel.ttl(ttl); + break; + case P.TT_START_TIME: + long ttlStartTime = + Long.parseLong((String) entry.getValue()); + vertexLabel.ttlStartTime(IdGenerator.of(ttlStartTime)); + break; + case P.ID_STRATEGY: + IdStrategy idStrategy = + IdStrategy.valueOf(((String) entry.getValue()).toUpperCase()); + vertexLabel.idStrategy(idStrategy); + break; + case P.PRIMARY_KEYS: + ids = ((List) entry.getValue()).stream().map( + IdGenerator::of).collect(Collectors.toSet()); + vertexLabel.primaryKeys(ids.toArray(new Id[0])); + break; + default: + throw new AssertionError(String.format( + "Invalid key '%s' for vertex label", + entry.getKey())); + } + } + return vertexLabel; + } + + public static final class P { + + public static final String ID = "id"; + public static final String NAME = "name"; + + public static final String STATUS = "status"; + public static final String USERDATA = "userdata"; + + public static final String PROPERTIES = "properties"; + public static final String NULLABLE_KEYS = "nullableKeys"; + public static final String INDEX_LABELS = "indexLabels"; + + public static final String ENABLE_LABEL_INDEX = "enableLabelIndex"; + public static final String TTL = "ttl"; + public static final String TT_START_TIME = "ttlStartTime"; + public static final String ID_STRATEGY = "idStrategy"; + public static final String PRIMARY_KEYS = "primaryKeys"; + } } diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java index 0e144c8593..98ad217943 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java @@ -19,7 +19,6 @@ import org.apache.hugegraph.backend.store.AbstractBackendStoreProvider; import org.apache.hugegraph.backend.store.BackendStore; -import org.apache.hugegraph.backend.store.hstore.HstoreStore.HstoreGraphStore; import org.apache.hugegraph.config.HugeConfig; public class HstoreProvider extends AbstractBackendStoreProvider { @@ -35,21 +34,21 @@ public String type() { @Override public String driverVersion() { - return null; + return "1.12"; } @Override protected BackendStore newSchemaStore(HugeConfig config, String store) { - return new HstoreGraphStore(this, this.namespace(), store); + return new HstoreStore.HstoreSchemaStore(this, this.namespace(), store); } @Override protected BackendStore newGraphStore(HugeConfig config, String store) { - return null; + return new HstoreStore.HstoreGraphStore(this, this.namespace(), store); } @Override protected BackendStore newSystemStore(HugeConfig config, String store) { - return null; + return new HstoreStore.HstoreSystemStore(this, this.namespace(), store); } } diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java index d9888f4c9f..43c85d5e80 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java @@ -699,6 +699,62 @@ public void setCounterLowest(HugeType type, long lowest) { /***************************** Store defines *****************************/ + public static class HstoreSystemStore extends HstoreStore { + + public HstoreSystemStore(BackendStoreProvider provider, String namespace, String store) { + super(provider, namespace, store); + + registerTableManager(HugeTableType.VERTEX, + new HstoreTables.Vertex(store)); + } + + @Override + public boolean isSchemaStore() { + return true; + } + + @Override + public void increaseCounter(HugeType type, long num) { + throw new UnsupportedOperationException( + "HstoreSchemaStore.increaseCounter()"); + } + + @Override + public long getCounter(HugeType type) { + throw new UnsupportedOperationException( + "HstoreSchemaStore.getCounter()"); + } + + @Override + public String storedVersion() { + return "1.12"; + } + } + + public static class HstoreSchemaStore extends HstoreStore { + + public HstoreSchemaStore(BackendStoreProvider provider, String namespace, String store) { + super(provider, namespace, store); + } + + @Override + public boolean isSchemaStore() { + return true; + } + + @Override + public void increaseCounter(HugeType type, long num) { + throw new UnsupportedOperationException( + "HstoreSchemaStore.increaseCounter()"); + } + + @Override + public long getCounter(HugeType type) { + throw new UnsupportedOperationException( + "HstoreSchemaStore.getCounter()"); + } + } + public static class HstoreGraphStore extends HstoreStore { public HstoreGraphStore(BackendStoreProvider provider, From f613bfe168ff96d7573ab6d7c8c6745eefaeda99 Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Mon, 21 Aug 2023 23:59:54 +0800 Subject: [PATCH 08/26] chore: migrate SchemaTransactionV2 --- hugegraph-server/hugegraph-core/pom.xml | 5 + .../hugegraph/backend/tx/IdCounter.java | 161 ++++ .../backend/tx/SchemaTransactionV2.java | 718 ++++++++++++++++++ 3 files changed, 884 insertions(+) create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/IdCounter.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java diff --git a/hugegraph-server/hugegraph-core/pom.xml b/hugegraph-server/hugegraph-core/pom.xml index 9b7b319073..2a3168b289 100644 --- a/hugegraph-server/hugegraph-core/pom.xml +++ b/hugegraph-server/hugegraph-core/pom.xml @@ -246,6 +246,11 @@ hg-pd-client ${revision} + + org.apache.hugegraph + hg-store-common + ${revision} + io.etcd jetcd-core diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/IdCounter.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/IdCounter.java new file mode 100644 index 0000000000..5a1ea58d5f --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/IdCounter.java @@ -0,0 +1,161 @@ +/* + * 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.hugegraph.backend.tx; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicLong; + +import org.apache.hugegraph.backend.BackendException; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.pd.client.PDClient; +import org.apache.hugegraph.pd.client.PDConfig; +import org.apache.hugegraph.pd.common.PDException; +import org.apache.hugegraph.pd.grpc.Pdpb; +import org.apache.hugegraph.store.term.HgPair; +import org.apache.hugegraph.type.HugeType; +import org.apache.hugegraph.util.E; + +public class IdCounter { + + private static final int TIMES = 10000; + private static final int DELTA = 10000; + private static final String DELIMITER = "/"; + private static Map ids = new ConcurrentHashMap<>(); + private final PDClient pdClient; + private final String graphName; + + public IdCounter(PDClient pdClient, String graphName) { + this.graphName = graphName; + this.pdClient = pdClient; + } + + public static void main(String[] args) { + PDConfig pdConfig = PDConfig.of("127.0.0.1:8686"); + PDClient pdClient = PDClient.create(pdConfig); + IdCounter idCounters = new IdCounter(pdClient, "hugegraph"); + System.out.println(idCounters.nextId(HugeType.EDGE_LABEL)); + System.out.println(idCounters.nextId(HugeType.EDGE_LABEL)); + } + + public Id nextId(HugeType type) { + long counter = this.getCounter(type); + E.checkState(counter != 0L, "Please check whether '%s' is OK", + this.pdClient.toString()); + return IdGenerator.of(counter); + } + + public void setCounterLowest(HugeType type, long lowest) { + long current = this.getCounter(type); + if (current >= lowest) { + return; + } + long increment = lowest - current; + this.increaseCounter(type, increment); + } + + public long getCounter(HugeType type) { + return this.getCounterFromPd(type); + } + + public synchronized void increaseCounter(HugeType type, long lowest) { + String key = toKey(this.graphName, type); + getCounterFromPd(type); + HgPair idPair = ids.get(key); + AtomicLong currentId = idPair.getKey(); + AtomicLong maxId = idPair.getValue(); + if (currentId.longValue() >= lowest) { + return; + } + if (maxId.longValue() >= lowest) { + currentId.set(lowest); + return; + } + synchronized (ids) { + try { + this.pdClient.getIdByKey(key, + (int) (lowest - maxId.longValue())); + ids.remove(key); + } catch (Exception e) { + throw new BackendException(""); + } + } + } + + protected String toKey(String graphName, HugeType type) { + return new StringBuilder().append(graphName) + .append(DELIMITER) + .append(type.code()).toString(); + } + + public long getCounterFromPd(HugeType type) { + AtomicLong currentId; + AtomicLong maxId; + HgPair idPair; + String key = toKey(this.graphName, type); + if ((idPair = ids.get(key)) == null) { + synchronized (ids) { + if ((idPair = ids.get(key)) == null) { + try { + currentId = new AtomicLong(0); + maxId = new AtomicLong(0); + idPair = new HgPair(currentId, maxId); + ids.put(key, idPair); + } catch (Exception e) { + throw new BackendException(String.format( + "Failed to get the ID from pd,%s", e)); + } + } + } + } + currentId = idPair.getKey(); + maxId = idPair.getValue(); + for (int i = 0; i < TIMES; i++) { + synchronized (currentId) { + if ((currentId.incrementAndGet()) <= maxId.longValue()) { + return currentId.longValue(); + } + if (currentId.longValue() > maxId.longValue()) { + try { + Pdpb.GetIdResponse idByKey = pdClient.getIdByKey(key, DELTA); + idPair.getValue().getAndSet(idByKey.getId() + + idByKey.getDelta()); + idPair.getKey().getAndSet(idByKey.getId()); + } catch (Exception e) { + throw new BackendException(String.format( + "Failed to get the ID from pd,%s", e)); + } + } + } + } + E.checkArgument(false, + "Having made too many attempts to get the" + + " ID for type '%s'", type.name()); + return 0L; + } + + public void resetIdCounter(String graphName) { + try { + this.pdClient.resetIdByKey(graphName); + ids = new ConcurrentHashMap<>(); + } catch (PDException e) { + throw new RuntimeException(e); + } + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java new file mode 100644 index 0000000000..9e0dfd746d --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java @@ -0,0 +1,718 @@ +/* + * 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.hugegraph.backend.tx; + +import java.util.List; +import java.util.Set; +import java.util.function.Consumer; + +import org.apache.hugegraph.HugeGraph; +import org.apache.hugegraph.HugeGraphParams; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.config.CoreOptions; +import org.apache.hugegraph.exception.NotAllowException; +import org.apache.hugegraph.job.JobBuilder; +import org.apache.hugegraph.job.schema.EdgeLabelRemoveCallable; +import org.apache.hugegraph.job.schema.IndexLabelRemoveCallable; +import org.apache.hugegraph.job.schema.OlapPropertyKeyClearCallable; +import org.apache.hugegraph.job.schema.OlapPropertyKeyCreateCallable; +import org.apache.hugegraph.job.schema.OlapPropertyKeyRemoveCallable; +import org.apache.hugegraph.job.schema.RebuildIndexCallable; +import org.apache.hugegraph.job.schema.SchemaCallable; +import org.apache.hugegraph.job.schema.VertexLabelRemoveCallable; +import org.apache.hugegraph.meta.MetaDriver; +import org.apache.hugegraph.meta.MetaManager; +import org.apache.hugegraph.meta.PdMetaDriver; +import org.apache.hugegraph.meta.managers.SchemaMetaManager; +import org.apache.hugegraph.perf.PerfUtil.Watched; +import org.apache.hugegraph.schema.EdgeLabel; +import org.apache.hugegraph.schema.IndexLabel; +import org.apache.hugegraph.schema.PropertyKey; +import org.apache.hugegraph.schema.SchemaElement; +import org.apache.hugegraph.schema.SchemaLabel; +import org.apache.hugegraph.schema.Userdata; +import org.apache.hugegraph.schema.VertexLabel; +import org.apache.hugegraph.task.HugeTask; +import org.apache.hugegraph.type.HugeType; +import org.apache.hugegraph.type.define.GraphMode; +import org.apache.hugegraph.type.define.SchemaStatus; +import org.apache.hugegraph.type.define.WriteType; +import org.apache.hugegraph.util.DateUtil; +import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.LockUtil; +import org.apache.hugegraph.util.Log; +import org.apache.tinkerpop.gremlin.structure.Graph; +import org.slf4j.Logger; + +import com.google.common.collect.ImmutableSet; + +public class SchemaTransaction { + + protected static final Logger LOG = Log.logger(SchemaTransaction.class); + + private final String graphSpace; + private final String graph; + private final HugeGraphParams graphParams; + private final IdCounter idCounter; + private final SchemaMetaManager schemaMetaManager; + + public SchemaTransaction(MetaDriver metaDriver, + String cluster, + HugeGraphParams graphParams) { + E.checkNotNull(graphParams, "graphParams"); + this.graphParams = graphParams; + this.graphSpace = graphParams.graph().graphSpace(); + this.graph = graphParams.name(); + this.schemaMetaManager = + new SchemaMetaManager(metaDriver, cluster, this.graph()); + this.idCounter = new IdCounter(((PdMetaDriver) metaDriver).pdClient(), + idKeyName(this.graphSpace, this.graph)); + } + + private static void setCreateTimeIfNeeded(SchemaElement schema) { + if (!schema.userdata().containsKey(Userdata.CREATE_TIME)) { + schema.userdata(Userdata.CREATE_TIME, DateUtil.now()); + } + } + + /** + * 异步任务系列 + */ + private static Id asyncRun(HugeGraph graph, SchemaElement schema, + SchemaCallable callable) { + return asyncRun(graph, schema, callable, ImmutableSet.of()); + } + + @Watched(prefix = "schema") + private static Id asyncRun(HugeGraph graph, SchemaElement schema, + SchemaCallable callable, Set dependencies) { + E.checkArgument(schema != null, "Schema can't be null"); + String name = SchemaCallable.formatTaskName(schema.type(), + schema.id(), + schema.name()); + + JobBuilder builder = JobBuilder.of(graph).name(name) + .job(callable) + .dependencies(dependencies); + HugeTask task = builder.schedule(); + // If TASK_SYNC_DELETION is true, wait async thread done before + // continue. This is used when running tests. + if (graph.option(CoreOptions.TASK_SYNC_DELETION)) { + task.syncWait(); + } + return task.id(); + } + + public String idKeyName(String graphSpace, String graph) { + // {graphSpace}/{graph}/m "m" means "schema" + return String.join("/", graphSpace, graph, "m"); + } + + @Watched(prefix = "schema") + public List getPropertyKeys(boolean cache) { + return this.getAllSchema(HugeType.PROPERTY_KEY); + } + + @Watched(prefix = "schema") + public List getPropertyKeys() { + return this.getAllSchema(HugeType.PROPERTY_KEY); + } + + @Watched(prefix = "schema") + public List getVertexLabels() { + return this.getAllSchema(HugeType.VERTEX_LABEL); + } + + @Watched(prefix = "schema") + public List getEdgeLabels() { + return this.getAllSchema(HugeType.EDGE_LABEL); + } + + @Watched(prefix = "schema") + public List getIndexLabels() { + return this.getAllSchema(HugeType.INDEX_LABEL); + } + + @Watched(prefix = "schema") + public Id addPropertyKey(PropertyKey propertyKey) { + this.addSchema(propertyKey); + if (!propertyKey.olap()) { + return IdGenerator.ZERO; + } + return this.createOlapPk(propertyKey); + } + + @Watched(prefix = "schema") + public void updatePropertyKey(PropertyKey propertyKey) { + this.updateSchema(propertyKey, null); + } + + public void updatePropertyKey(PropertyKey old, PropertyKey update) { + this.removePropertyKey(old.id()); + this.addPropertyKey(update); + } + + @Watched(prefix = "schema") + public PropertyKey getPropertyKey(Id id) { + E.checkArgumentNotNull(id, "Property key id can't be null"); + return this.getSchema(HugeType.PROPERTY_KEY, id); + } + + @Watched(prefix = "schema") + public PropertyKey getPropertyKey(String name) { + E.checkArgumentNotNull(name, "Property key name can't be null"); + E.checkArgument(!name.isEmpty(), "Property key name can't be empty"); + return this.getSchema(HugeType.PROPERTY_KEY, name); + } + + @Watched(prefix = "schema") + public Id removePropertyKey(Id id) { + LOG.debug("SchemaTransaction remove property key '{}'", id); + PropertyKey propertyKey = this.getPropertyKey(id); + // If the property key does not exist, return directly + if (propertyKey == null) { + return null; + } + + List vertexLabels = this.getVertexLabels(); + for (VertexLabel vertexLabel : vertexLabels) { + if (vertexLabel.properties().contains(id)) { + throw new NotAllowException( + "Not allowed to remove property key: '%s' " + + "because the vertex label '%s' is still using it.", + propertyKey, vertexLabel.name()); + } + } + + List edgeLabels = this.getEdgeLabels(); + for (EdgeLabel edgeLabel : edgeLabels) { + if (edgeLabel.properties().contains(id)) { + throw new NotAllowException( + "Not allowed to remove property key: '%s' " + + "because the edge label '%s' is still using it.", + propertyKey, edgeLabel.name()); + } + } + if (propertyKey.oltp()) { + this.removeSchema(propertyKey); + return IdGenerator.ZERO; + } else { + return this.removeOlapPk(propertyKey); + } + } + + @Watched(prefix = "schema") + public void addVertexLabel(VertexLabel vertexLabel) { + this.addSchema(vertexLabel); + } + + @Watched(prefix = "schema") + public void updateVertexLabel(VertexLabel vertexLabel) { + this.updateSchema(vertexLabel, null); + } + + @Watched(prefix = "schema") + public VertexLabel getVertexLabel(Id id) { + E.checkArgumentNotNull(id, "Vertex label id can't be null"); + if (SchemaElement.OLAP_ID.equals(id)) { + return VertexLabel.OLAP_VL; + } + return this.getSchema(HugeType.VERTEX_LABEL, id); + } + + @Watched(prefix = "schema") + public VertexLabel getVertexLabel(String name) { + E.checkArgumentNotNull(name, "Vertex label name can't be null"); + E.checkArgument(!name.isEmpty(), "Vertex label name can't be empty"); + if (SchemaElement.OLAP.equals(name)) { + return VertexLabel.OLAP_VL; + } + return this.getSchema(HugeType.VERTEX_LABEL, name); + } + + @Watched(prefix = "schema") + public Id removeVertexLabel(Id id) { + LOG.debug("SchemaTransaction remove vertex label '{}'", id); + SchemaCallable callable = new VertexLabelRemoveCallable(); + VertexLabel schema = this.getVertexLabel(id); + return asyncRun(this.graph(), schema, callable); + } + + @Watched(prefix = "schema") + public void addEdgeLabel(EdgeLabel edgeLabel) { + this.addSchema(edgeLabel); + } + + @Watched(prefix = "schema") + public void updateEdgeLabel(EdgeLabel edgeLabel) { + this.updateSchema(edgeLabel, null); + } + + @Watched(prefix = "schema") + public EdgeLabel getEdgeLabel(Id id) { + E.checkArgumentNotNull(id, "Edge label id can't be null"); + return this.getSchema(HugeType.EDGE_LABEL, id); + } + + @Watched(prefix = "schema") + public EdgeLabel getEdgeLabel(String name) { + E.checkArgumentNotNull(name, "Edge label name can't be null"); + E.checkArgument(!name.isEmpty(), "Edge label name can't be empty"); + return this.getSchema(HugeType.EDGE_LABEL, name); + } + + @Watched(prefix = "schema") + public Id removeEdgeLabel(Id id) { + /* + * Call an asynchronous task and call back the corresponding + * removeSchema() method after the task ends to complete the delete + * schema operation + */ + LOG.debug("SchemaTransaction remove edge label '{}'", id); + EdgeLabel schema = this.getEdgeLabel(id); + if (schema.edgeLabelType().parent()) { + List edgeLabels = this.getEdgeLabels(); + for (EdgeLabel edgeLabel : edgeLabels) { + if (edgeLabel.edgeLabelType().sub() && + edgeLabel.fatherId() == id) { + throw new NotAllowException( + "Not allowed to remove a parent edge label: '%s' " + + "because the sub edge label '%s' is still existing", + schema.name(), edgeLabel.name()); + } + } + } + SchemaCallable callable = new EdgeLabelRemoveCallable(); + return asyncRun(this.graph(), schema, callable); + } + + @Watched(prefix = "schema") + public void addIndexLabel(SchemaLabel baseLabel, IndexLabel indexLabel) { + /* + * Create index and update index name in base-label(VL/EL) + * TODO: should wrap update base-label and create index in one tx. + */ + this.addSchema(indexLabel); + + if (baseLabel.equals(VertexLabel.OLAP_VL)) { + return; + } + + this.updateSchema(baseLabel, schema -> { + // NOTE: Do schema update in the lock block + baseLabel.addIndexLabel(indexLabel.id()); + }); + } + + @Watched(prefix = "schema") + public void updateIndexLabel(IndexLabel indexLabel) { + this.updateSchema(indexLabel, null); + } + + @Watched(prefix = "schema") + public IndexLabel getIndexLabel(Id id) { + E.checkArgumentNotNull(id, "Index label id can't be null"); + return this.getSchema(HugeType.INDEX_LABEL, id); + } + + @Watched(prefix = "schema") + public IndexLabel getIndexLabel(String name) { + E.checkArgumentNotNull(name, "Index label name can't be null"); + E.checkArgument(!name.isEmpty(), "Index label name can't be empty"); + return this.getSchema(HugeType.INDEX_LABEL, name); + } + + @Watched(prefix = "schema") + public Id removeIndexLabel(Id id) { + LOG.debug("SchemaTransaction remove index label '{}'", id); + SchemaCallable callable = new IndexLabelRemoveCallable(); + IndexLabel schema = this.getIndexLabel(id); + return asyncRun(this.graph(), schema, callable); + } + + // 通用性 的schema处理函数 + @Watched(prefix = "schema") + public void updateSchemaStatus(SchemaElement schema, SchemaStatus status) { + if (!this.existsSchemaId(schema.type(), schema.id())) { + LOG.warn("Can't update schema '{}', it may be deleted", schema); + return; + } + + this.updateSchema(schema, schemaToUpdate -> { + // NOTE: Do schema update in the lock block + schema.status(status); + }); + } + + @Watched(prefix = "schema") + public boolean existsSchemaId(HugeType type, Id id) { + return this.getSchema(type, id) != null; + } + + protected void updateSchema(SchemaElement schema, + Consumer updateCallback) { + LOG.debug("SchemaTransaction update {} with id '{}'", + schema.type(), schema.id()); + this.saveSchema(schema, true, updateCallback); + } + + protected void addSchema(SchemaElement schema) { + LOG.debug("SchemaTransaction add {} with id '{}'", + schema.type(), schema.id()); + setCreateTimeIfNeeded(schema); + this.saveSchema(schema, false, null); + } + + @SuppressWarnings("unchecked") + private void saveSchema(SchemaElement schema, boolean update, + Consumer updateCallback) { + // Lock for schema update + String spaceGraph = this.graphParams() + .graph().spaceGraphName(); + LockUtil.Locks locks = new LockUtil.Locks(spaceGraph); + try { + locks.lockWrites(LockUtil.hugeType2Group(schema.type()), schema.id()); + + if (updateCallback != null) { + // NOTE: Do schema update in the lock block + updateCallback.accept(schema); + } + // 调对应的方法 + switch (schema.type()) { + case PROPERTY_KEY: + this.schemaMetaManager.addPropertyKey(this.graphSpace, + this.graph, + (PropertyKey) schema); + break; + case VERTEX_LABEL: + this.schemaMetaManager.addVertexLabel(this.graphSpace, + this.graph, + (VertexLabel) schema); + // 点的label发生变化, 清空对应图的点缓存信息 + MetaManager.instance().notifyGraphVertexCacheClear(this.graphSpace, this.graph); + break; + case EDGE_LABEL: + this.schemaMetaManager.addEdgeLabel(this.graphSpace, + this.graph, + (EdgeLabel) schema); + // 边的label发生变化, 清空对应图的边缓存信息 + MetaManager.instance().notifyGraphEdgeCacheClear(this.graphSpace, this.graph); + break; + case INDEX_LABEL: + this.schemaMetaManager.addIndexLabel(this.graphSpace, + this.graph, + (IndexLabel) schema); + break; + default: + throw new AssertionError(String.format( + "Invalid key '%s' for saveSchema", schema.type())); + } + } finally { + locks.unlock(); + } + } + + @SuppressWarnings("unchecked") + protected T getSchema(HugeType type, Id id) { + LOG.debug("SchemaTransaction get {} by id '{}'", + type.readableName(), id); + switch (type) { + case PROPERTY_KEY: + return (T) this.schemaMetaManager.getPropertyKey(this.graphSpace, + this.graph, id); + case VERTEX_LABEL: + return (T) this.schemaMetaManager.getVertexLabel(this.graphSpace, + this.graph, id); + case EDGE_LABEL: + return (T) this.schemaMetaManager.getEdgeLabel(this.graphSpace, + this.graph, id); + case INDEX_LABEL: + return (T) this.schemaMetaManager.getIndexLabel(this.graphSpace, + this.graph, id); + default: + throw new AssertionError(String.format( + "Invalid type '%s' for getSchema", type)); + } + } + + /** + * Currently doesn't allow to exist schema with the same name + * + * @param type the query schema type + * @param name the query schema name + * @param SubClass of SchemaElement + * @return the queried schema object + */ + @SuppressWarnings("unchecked") + protected T getSchema(HugeType type, String name) { + LOG.debug("SchemaTransaction get {} by name '{}'", + type.readableName(), name); + switch (type) { + case PROPERTY_KEY: + return (T) this.schemaMetaManager.getPropertyKey(this.graphSpace, + this.graph, name); + case VERTEX_LABEL: + return (T) this.schemaMetaManager.getVertexLabel(this.graphSpace, + this.graph, name); + case EDGE_LABEL: + return (T) this.schemaMetaManager.getEdgeLabel(this.graphSpace, + this.graph, name); + case INDEX_LABEL: + return (T) this.schemaMetaManager.getIndexLabel(this.graphSpace, + this.graph, name); + default: + throw new AssertionError(String.format( + "Invalid type '%s' for getSchema", type)); + } + } + + @SuppressWarnings("unchecked") + protected List getAllSchema(HugeType type) { + LOG.debug("SchemaTransaction getAllSchema {}", type.readableName()); + switch (type) { + case PROPERTY_KEY: + return (List) this.schemaMetaManager.getPropertyKeys(this.graphSpace, + this.graph); + case VERTEX_LABEL: + return (List) this.schemaMetaManager.getVertexLabels(this.graphSpace, + this.graph); + case EDGE_LABEL: + return (List) this.schemaMetaManager.getEdgeLabels(this.graphSpace, this.graph); + case INDEX_LABEL: + return (List) this.schemaMetaManager.getIndexLabels(this.graphSpace, this.graph); + default: + throw new AssertionError(String.format( + "Invalid type '%s' for getSchema", type)); + } + } + + protected void removeSchema(SchemaElement schema) { + LOG.debug("SchemaTransaction remove {} by id '{}'", + schema.type(), schema.id()); + String spaceGraph = this.graphParams() + .graph().spaceGraphName(); + LockUtil.Locks locks = new LockUtil.Locks(spaceGraph); + try { + locks.lockWrites(LockUtil.hugeType2Group(schema.type()), + schema.id()); + switch (schema.type()) { + case PROPERTY_KEY: + this.schemaMetaManager.removePropertyKey(this.graphSpace, this.graph, + schema.id()); + break; + case VERTEX_LABEL: + this.schemaMetaManager.removeVertexLabel(this.graphSpace, this.graph, + schema.id()); + break; + case EDGE_LABEL: + this.schemaMetaManager.removeEdgeLabel(this.graphSpace, this.graph, + schema.id()); + break; + case INDEX_LABEL: + this.schemaMetaManager.removeIndexLabel(this.graphSpace, this.graph, + schema.id()); + break; + default: + throw new AssertionError(String.format( + "Invalid key '%s' for saveSchema", schema.type())); + } + } finally { + locks.unlock(); + } + } + + // olap 相关的方法 + public void createIndexLabelForOlapPk(PropertyKey propertyKey) { + WriteType writeType = propertyKey.writeType(); + if (writeType == WriteType.OLTP || + writeType == WriteType.OLAP_COMMON) { + return; + } + + String indexName = SchemaElement.OLAP + "_by_" + propertyKey.name(); + IndexLabel.Builder builder = this.graph().schema() + .indexLabel(indexName) + .onV(SchemaElement.OLAP) + .by(propertyKey.name()); + if (propertyKey.writeType() == WriteType.OLAP_SECONDARY) { + builder.secondary(); + } else { + assert propertyKey.writeType() == WriteType.OLAP_RANGE; + builder.range(); + } + builder.build(); + this.graph().addIndexLabel(VertexLabel.OLAP_VL, builder.build()); + } + + public Id removeOlapPk(PropertyKey propertyKey) { + LOG.debug("SchemaTransaction remove olap property key {} with id '{}'", + propertyKey.name(), propertyKey.id()); + SchemaCallable callable = new OlapPropertyKeyRemoveCallable(); + return asyncRun(this.graph(), propertyKey, callable); + } + + public void removeOlapPk(Id id) { + this.graphParams().loadGraphStore().removeOlapTable(id); + } + + public Id clearOlapPk(PropertyKey propertyKey) { + LOG.debug("SchemaTransaction clear olap property key {} with id '{}'", + propertyKey.name(), propertyKey.id()); + SchemaCallable callable = new OlapPropertyKeyClearCallable(); + return asyncRun(this.graph(), propertyKey, callable); + } + + public void clearOlapPk(Id id) { + this.graphParams().loadGraphStore().clearOlapTable(id); + } + + public Id createOlapPk(PropertyKey propertyKey) { + LOG.debug("SchemaTransaction create olap property key {} with id '{}'", + propertyKey.name(), propertyKey.id()); + SchemaCallable callable = new OlapPropertyKeyCreateCallable(); + return asyncRun(this.graph(), propertyKey, callable); + } + + // -- store 相关的方法，分为两类：1、olaptable相关 2、id生成策略 + // - 1、olaptable相关 + public void createOlapPk(Id id) { + this.graphParams().loadGraphStore().createOlapTable(id); + } + + public boolean existOlapTable(Id id) { + return this.graphParams().loadGraphStore().existOlapTable(id); + } + + public void initAndRegisterOlapTables() { + for (PropertyKey pk : this.getPropertyKeys()) { + if (pk.olap()) { + this.graphParams().loadGraphStore().checkAndRegisterOlapTable(pk.id()); + } + } + } + + // - 2、id生成策略 + @Watched(prefix = "schema") + public Id getNextId(HugeType type) { + LOG.debug("SchemaTransaction get next id for {}", type); + return this.idCounter.nextId(type); + } + + @Watched(prefix = "schema") + public void setNextIdLowest(HugeType type, long lowest) { + LOG.debug("SchemaTransaction set next id to {} for {}", lowest, type); + this.idCounter.setCounterLowest(type, lowest); + } + + @Watched(prefix = "schema") + public Id getNextSystemId() { + LOG.debug("SchemaTransaction get next system id"); + Id id = this.idCounter.nextId(HugeType.SYS_SCHEMA); + return IdGenerator.of(-id.asLong()); + } + + @Watched(prefix = "schema") + public Id validOrGenerateId(HugeType type, Id id, String name) { + boolean forSystem = Graph.Hidden.isHidden(name); + if (id != null) { + this.checkIdAndUpdateNextId(type, id, name, forSystem); + } else { + if (forSystem) { + id = this.getNextSystemId(); + } else { + id = this.getNextId(type); + } + } + return id; + } + + private void checkIdAndUpdateNextId(HugeType type, Id id, + String name, boolean forSystem) { + if (forSystem) { + if (id.number() && id.asLong() < 0) { + return; + } + throw new IllegalStateException(String.format( + "Invalid system id '%s'", id)); + } + E.checkState(id.number() && id.asLong() > 0L, + "Schema id must be number and >0, but got '%s'", id); + GraphMode mode = this.graphMode(); + E.checkState(mode == GraphMode.RESTORING, + "Can't build schema with provided id '%s' " + + "when graph '%s' in mode '%s'", id, this.graph, mode); + this.setNextIdLowest(type, id.asLong()); + } + + // 功能型函数 + public void checkSchemaName(String name) { + String illegalReg = this.graphParams().configuration() + .get(CoreOptions.SCHEMA_ILLEGAL_NAME_REGEX); + E.checkNotNull(name, "name"); + E.checkArgument(!name.isEmpty(), "The name can't be empty."); + E.checkArgument(name.length() < 256, + "The length of name must less than 256 bytes."); + E.checkArgument(!name.matches(illegalReg), + "Illegal schema name '%s'", name); + + final char[] filters = {'#', '>', ':', '!'}; + for (char c : filters) { + E.checkArgument(name.indexOf(c) == -1, + "The name can't contain character '%s'.", c); + } + } + + protected HugeGraphParams graphParams() { + return this.graphParams; + } + + public GraphMode graphMode() { + return this.graphParams().mode(); + } + + // 获取字段的方法 + public HugeGraph graph() { + return this.graphParams.graph(); + } + + // 重建索引 + @Watched(prefix = "schema") + public Id rebuildIndex(SchemaElement schema) { + return this.rebuildIndex(schema, ImmutableSet.of()); + } + + @Watched(prefix = "schema") + public Id rebuildIndex(SchemaElement schema, Set dependencies) { + LOG.debug("SchemaTransaction rebuild index for {} with id '{}'", + schema.type(), schema.id()); + SchemaCallable callable = new RebuildIndexCallable(); + return asyncRun(this.graph(), schema, callable, dependencies); + } + + /** + * 清除所有的schema信息 + */ + public void clear() { + this.schemaMetaManager.clearAllSchema(this.graphSpace, graph); + } + + public void resetIdCounter() { + this.idCounter.resetIdCounter(idKeyName(graphSpace, graph)); + } +} From d91e50a2673ba145d234d9db4905d1fdbf902eea Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Tue, 22 Aug 2023 00:02:34 +0800 Subject: [PATCH 09/26] chore: adapt SchemaTransactionV2 --- .../backend/tx/SchemaTransactionV2.java | 107 ++++++++++-------- .../hugegraph/schema/SchemaElement.java | 5 + 2 files changed, 63 insertions(+), 49 deletions(-) diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java index 9e0dfd746d..a78422be86 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java @@ -28,14 +28,14 @@ import org.apache.hugegraph.config.CoreOptions; import org.apache.hugegraph.exception.NotAllowException; import org.apache.hugegraph.job.JobBuilder; -import org.apache.hugegraph.job.schema.EdgeLabelRemoveCallable; -import org.apache.hugegraph.job.schema.IndexLabelRemoveCallable; -import org.apache.hugegraph.job.schema.OlapPropertyKeyClearCallable; -import org.apache.hugegraph.job.schema.OlapPropertyKeyCreateCallable; -import org.apache.hugegraph.job.schema.OlapPropertyKeyRemoveCallable; -import org.apache.hugegraph.job.schema.RebuildIndexCallable; -import org.apache.hugegraph.job.schema.SchemaCallable; -import org.apache.hugegraph.job.schema.VertexLabelRemoveCallable; +import org.apache.hugegraph.job.schema.EdgeLabelRemoveJob; +import org.apache.hugegraph.job.schema.IndexLabelRebuildJob; +import org.apache.hugegraph.job.schema.IndexLabelRemoveJob; +import org.apache.hugegraph.job.schema.OlapPropertyKeyClearJob; +import org.apache.hugegraph.job.schema.OlapPropertyKeyCreateJob; +import org.apache.hugegraph.job.schema.OlapPropertyKeyRemoveJob; +import org.apache.hugegraph.job.schema.SchemaJob; +import org.apache.hugegraph.job.schema.VertexLabelRemoveJob; import org.apache.hugegraph.meta.MetaDriver; import org.apache.hugegraph.meta.MetaManager; import org.apache.hugegraph.meta.PdMetaDriver; @@ -62,7 +62,7 @@ import com.google.common.collect.ImmutableSet; -public class SchemaTransaction { +public class SchemaTransactionV2 extends SchemaTransaction { protected static final Logger LOG = Log.logger(SchemaTransaction.class); @@ -72,12 +72,15 @@ public class SchemaTransaction { private final IdCounter idCounter; private final SchemaMetaManager schemaMetaManager; - public SchemaTransaction(MetaDriver metaDriver, + public SchemaTransactionV2(MetaDriver metaDriver, String cluster, HugeGraphParams graphParams) { + super(graphParams, null); E.checkNotNull(graphParams, "graphParams"); this.graphParams = graphParams; - this.graphSpace = graphParams.graph().graphSpace(); + // TODO: uncomment later - graph space + //this.graphSpace = graphParams.graph().graphSpace(); + this.graphSpace = ""; this.graph = graphParams.name(); this.schemaMetaManager = new SchemaMetaManager(metaDriver, cluster, this.graph()); @@ -95,20 +98,20 @@ private static void setCreateTimeIfNeeded(SchemaElement schema) { * 异步任务系列 */ private static Id asyncRun(HugeGraph graph, SchemaElement schema, - SchemaCallable callable) { - return asyncRun(graph, schema, callable, ImmutableSet.of()); + SchemaJob job) { + return asyncRun(graph, schema, job, ImmutableSet.of()); } @Watched(prefix = "schema") private static Id asyncRun(HugeGraph graph, SchemaElement schema, - SchemaCallable callable, Set dependencies) { + SchemaJob job, Set dependencies) { E.checkArgument(schema != null, "Schema can't be null"); - String name = SchemaCallable.formatTaskName(schema.type(), + String name = SchemaJob.formatTaskName(schema.type(), schema.id(), schema.name()); JobBuilder builder = JobBuilder.of(graph).name(name) - .job(callable) + .job(job) .dependencies(dependencies); HugeTask task = builder.schedule(); // If TASK_SYNC_DELETION is true, wait async thread done before @@ -249,9 +252,9 @@ public VertexLabel getVertexLabel(String name) { @Watched(prefix = "schema") public Id removeVertexLabel(Id id) { LOG.debug("SchemaTransaction remove vertex label '{}'", id); - SchemaCallable callable = new VertexLabelRemoveCallable(); + SchemaJob job = new VertexLabelRemoveJob(); VertexLabel schema = this.getVertexLabel(id); - return asyncRun(this.graph(), schema, callable); + return asyncRun(this.graph(), schema, job); } @Watched(prefix = "schema") @@ -286,20 +289,21 @@ public Id removeEdgeLabel(Id id) { */ LOG.debug("SchemaTransaction remove edge label '{}'", id); EdgeLabel schema = this.getEdgeLabel(id); - if (schema.edgeLabelType().parent()) { - List edgeLabels = this.getEdgeLabels(); - for (EdgeLabel edgeLabel : edgeLabels) { - if (edgeLabel.edgeLabelType().sub() && - edgeLabel.fatherId() == id) { - throw new NotAllowException( - "Not allowed to remove a parent edge label: '%s' " + - "because the sub edge label '%s' is still existing", - schema.name(), edgeLabel.name()); - } - } - } - SchemaCallable callable = new EdgeLabelRemoveCallable(); - return asyncRun(this.graph(), schema, callable); + // TODO: uncomment later - el + //if (schema.edgeLabelType().parent()) { + // List edgeLabels = this.getEdgeLabels(); + // for (EdgeLabel edgeLabel : edgeLabels) { + // if (edgeLabel.edgeLabelType().sub() && + // edgeLabel.fatherId() == id) { + // throw new NotAllowException( + // "Not allowed to remove a parent edge label: '%s' " + + // "because the sub edge label '%s' is still existing", + // schema.name(), edgeLabel.name()); + // } + // } + //} + SchemaJob job = new EdgeLabelRemoveJob(); + return asyncRun(this.graph(), schema, job); } @Watched(prefix = "schema") @@ -341,9 +345,9 @@ public IndexLabel getIndexLabel(String name) { @Watched(prefix = "schema") public Id removeIndexLabel(Id id) { LOG.debug("SchemaTransaction remove index label '{}'", id); - SchemaCallable callable = new IndexLabelRemoveCallable(); + SchemaJob job = new IndexLabelRemoveJob(); IndexLabel schema = this.getIndexLabel(id); - return asyncRun(this.graph(), schema, callable); + return asyncRun(this.graph(), schema, job); } // 通用性 的schema处理函数 @@ -383,8 +387,10 @@ protected void addSchema(SchemaElement schema) { private void saveSchema(SchemaElement schema, boolean update, Consumer updateCallback) { // Lock for schema update - String spaceGraph = this.graphParams() - .graph().spaceGraphName(); + // TODO: uncomment later - graph space + //String spaceGraph = this.graphParams() + // .graph().spaceGraphName(); + String spaceGraph = ""; LockUtil.Locks locks = new LockUtil.Locks(spaceGraph); try { locks.lockWrites(LockUtil.hugeType2Group(schema.type()), schema.id()); @@ -505,8 +511,10 @@ protected List getAllSchema(HugeType type) { protected void removeSchema(SchemaElement schema) { LOG.debug("SchemaTransaction remove {} by id '{}'", schema.type(), schema.id()); - String spaceGraph = this.graphParams() - .graph().spaceGraphName(); + // TODO: uncomment later - graph space + //String spaceGraph = this.graphParams() + // .graph().spaceGraphName(); + String spaceGraph = ""; LockUtil.Locks locks = new LockUtil.Locks(spaceGraph); try { locks.lockWrites(LockUtil.hugeType2Group(schema.type()), @@ -563,8 +571,8 @@ public void createIndexLabelForOlapPk(PropertyKey propertyKey) { public Id removeOlapPk(PropertyKey propertyKey) { LOG.debug("SchemaTransaction remove olap property key {} with id '{}'", propertyKey.name(), propertyKey.id()); - SchemaCallable callable = new OlapPropertyKeyRemoveCallable(); - return asyncRun(this.graph(), propertyKey, callable); + SchemaJob job = new OlapPropertyKeyRemoveJob(); + return asyncRun(this.graph(), propertyKey, job); } public void removeOlapPk(Id id) { @@ -574,8 +582,8 @@ public void removeOlapPk(Id id) { public Id clearOlapPk(PropertyKey propertyKey) { LOG.debug("SchemaTransaction clear olap property key {} with id '{}'", propertyKey.name(), propertyKey.id()); - SchemaCallable callable = new OlapPropertyKeyClearCallable(); - return asyncRun(this.graph(), propertyKey, callable); + SchemaJob job = new OlapPropertyKeyClearJob(); + return asyncRun(this.graph(), propertyKey, job); } public void clearOlapPk(Id id) { @@ -585,8 +593,8 @@ public void clearOlapPk(Id id) { public Id createOlapPk(PropertyKey propertyKey) { LOG.debug("SchemaTransaction create olap property key {} with id '{}'", propertyKey.name(), propertyKey.id()); - SchemaCallable callable = new OlapPropertyKeyCreateCallable(); - return asyncRun(this.graph(), propertyKey, callable); + SchemaJob job = new OlapPropertyKeyCreateJob(); + return asyncRun(this.graph(), propertyKey, job); } // -- store 相关的方法，分为两类：1、olaptable相关 2、id生成策略 @@ -595,9 +603,10 @@ public void createOlapPk(Id id) { this.graphParams().loadGraphStore().createOlapTable(id); } - public boolean existOlapTable(Id id) { - return this.graphParams().loadGraphStore().existOlapTable(id); - } + // TODO: uncomment later - olap + //public boolean existOlapTable(Id id) { + // return this.graphParams().loadGraphStore().existOlapTable(id); + //} public void initAndRegisterOlapTables() { for (PropertyKey pk : this.getPropertyKeys()) { @@ -701,8 +710,8 @@ public Id rebuildIndex(SchemaElement schema) { public Id rebuildIndex(SchemaElement schema, Set dependencies) { LOG.debug("SchemaTransaction rebuild index for {} with id '{}'", schema.type(), schema.id()); - SchemaCallable callable = new RebuildIndexCallable(); - return asyncRun(this.graph(), schema, callable, dependencies); + SchemaJob job = new IndexLabelRebuildJob(); + return asyncRun(this.graph(), schema, job, dependencies); } /** diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaElement.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaElement.java index 117a7c597f..05d91bec3d 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaElement.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaElement.java @@ -47,6 +47,11 @@ public abstract class SchemaElement implements Nameable, Typeable, protected static final int ILN_IL_ID = -6; protected static final int OLAP_VL_ID = -7; + // OLAP_ID means all of vertex label ids + public static final Id OLAP_ID = IdGenerator.of(-7); + // OLAP means all of vertex label names + public static final String OLAP = "~olap"; + public static final Id NONE_ID = IdGenerator.ZERO; public static final String UNDEF = "~undefined"; From cdc0f3a728c6184bad2f53295d4f61e90e0cfd88 Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Wed, 23 Aug 2023 00:17:45 +0800 Subject: [PATCH 10/26] refact: intro ISchemaTransaction for adaptation --- .../org/apache/hugegraph/HugeGraphParams.java | 3 +- .../apache/hugegraph/StandardHugeGraph.java | 26 +- .../cache/CachedSchemaTransactionV2.java | 469 ++++++++++++++++++ .../backend/tx/GraphIndexTransaction.java | 6 +- .../backend/tx/ISchemaTransaction.java | 92 ++++ .../backend/tx/SchemaTransaction.java | 2 +- .../backend/tx/SchemaTransactionV2.java | 18 +- .../job/schema/EdgeLabelRemoveJob.java | 3 +- .../job/schema/IndexLabelRebuildJob.java | 5 +- .../job/schema/IndexLabelRemoveJob.java | 3 +- .../job/schema/OlapPropertyKeyClearJob.java | 5 +- .../job/schema/OlapPropertyKeyCreateJob.java | 3 +- .../job/schema/OlapPropertyKeyRemoveJob.java | 3 +- .../hugegraph/job/schema/SchemaJob.java | 3 +- .../job/schema/VertexLabelRemoveJob.java | 3 +- .../hugegraph/schema/SchemaManager.java | 5 +- .../schema/builder/AbstractBuilder.java | 5 +- .../schema/builder/EdgeLabelBuilder.java | 5 +- .../schema/builder/IndexLabelBuilder.java | 5 +- .../schema/builder/PropertyKeyBuilder.java | 5 +- .../schema/builder/VertexLabelBuilder.java | 5 +- 21 files changed, 638 insertions(+), 36 deletions(-) create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedSchemaTransactionV2.java create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/ISchemaTransaction.java diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/HugeGraphParams.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/HugeGraphParams.java index e655b7c02e..dd611ae68c 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/HugeGraphParams.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/HugeGraphParams.java @@ -22,6 +22,7 @@ import org.apache.hugegraph.backend.store.BackendStore; import org.apache.hugegraph.backend.store.ram.RamTable; import org.apache.hugegraph.backend.tx.GraphTransaction; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.job.EphemeralJob; import org.apache.hugegraph.task.ServerInfoManager; @@ -46,7 +47,7 @@ public interface HugeGraphParams { GraphReadMode readMode(); - SchemaTransaction schemaTransaction(); + ISchemaTransaction schemaTransaction(); GraphTransaction systemTransaction(); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java index db37d0a4bd..a5204d2d10 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java @@ -37,6 +37,7 @@ import org.apache.hugegraph.backend.cache.CacheNotifier.SchemaCacheNotifier; import org.apache.hugegraph.backend.cache.CachedGraphTransaction; import org.apache.hugegraph.backend.cache.CachedSchemaTransaction; +import org.apache.hugegraph.backend.cache.CachedSchemaTransactionV2; import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; import org.apache.hugegraph.backend.id.SnowflakeIdGenerator; @@ -51,6 +52,8 @@ import org.apache.hugegraph.backend.store.raft.RaftBackendStoreProvider; import org.apache.hugegraph.backend.store.raft.RaftGroupManager; import org.apache.hugegraph.backend.store.ram.RamTable; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; +import org.apache.hugegraph.meta.MetaManager; import org.apache.hugegraph.task.EphemeralJobQueue; import org.apache.hugegraph.backend.tx.GraphTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; @@ -453,9 +456,18 @@ private void clearVertexCache() { } } - private SchemaTransaction openSchemaTransaction() throws HugeException { + private boolean isHstore() { + return "hstore".equals(this.backend()); + } + + private ISchemaTransaction openSchemaTransaction() throws HugeException { this.checkGraphNotClosed(); try { + if (isHstore()) { + return new CachedSchemaTransactionV2( + MetaManager.instance().metaDriver(), + MetaManager.instance().cluster(), this.params); + } return new CachedSchemaTransaction(this.params, loadSchemaStore()); } catch (BackendException e) { String message = "Failed to open schema transaction"; @@ -504,7 +516,7 @@ private BackendStore loadSystemStore() { } @Watched - private SchemaTransaction schemaTransaction() { + private ISchemaTransaction schemaTransaction() { this.checkGraphNotClosed(); /* * NOTE: each schema operation will be auto committed, @@ -1192,7 +1204,7 @@ public GraphReadMode readMode() { } @Override - public SchemaTransaction schemaTransaction() { + public ISchemaTransaction schemaTransaction() { return StandardHugeGraph.this.schemaTransaction(); } @@ -1443,7 +1455,7 @@ private void setClosed() { } } - private SchemaTransaction schemaTransaction() { + private ISchemaTransaction schemaTransaction() { return this.getOrNewTransaction().schemaTx; } @@ -1464,7 +1476,7 @@ private Txs getOrNewTransaction() { Txs txs = this.transactions.get(); if (txs == null) { - SchemaTransaction schemaTransaction = null; + ISchemaTransaction schemaTransaction = null; SysTransaction sysTransaction = null; GraphTransaction graphTransaction = null; try { @@ -1507,12 +1519,12 @@ private void destroyTransaction() { private static final class Txs { - private final SchemaTransaction schemaTx; + private final ISchemaTransaction schemaTx; private final SysTransaction systemTx; private final GraphTransaction graphTx; private long openedTime; - public Txs(SchemaTransaction schemaTx, SysTransaction systemTx, + public Txs(ISchemaTransaction schemaTx, SysTransaction systemTx, GraphTransaction graphTx) { assert schemaTx != null && systemTx != null && graphTx != null; this.schemaTx = schemaTx; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedSchemaTransactionV2.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedSchemaTransactionV2.java new file mode 100644 index 0000000000..6e5d6dca1f --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedSchemaTransactionV2.java @@ -0,0 +1,469 @@ +package org.apache.hugegraph.backend.cache; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Consumer; + +import org.apache.hugegraph.HugeGraphParams; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.store.ram.IntObjectMap; +import org.apache.hugegraph.backend.tx.SchemaTransactionV2; +import org.apache.hugegraph.config.CoreOptions; +import org.apache.hugegraph.event.EventHub; +import org.apache.hugegraph.event.EventListener; +import org.apache.hugegraph.meta.MetaDriver; +import org.apache.hugegraph.meta.MetaManager; +import org.apache.hugegraph.perf.PerfUtil; +import org.apache.hugegraph.schema.SchemaElement; +import org.apache.hugegraph.type.HugeType; +import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.Events; + +import com.google.common.collect.ImmutableSet; + +public class CachedSchemaTransactionV2 extends SchemaTransactionV2 { + private final Cache idCache; + private final Cache nameCache; + + private final SchemaCaches arrayCaches; + + private EventListener storeEventListener; + private EventListener cacheEventListener; + + public CachedSchemaTransactionV2(MetaDriver metaDriver, + String cluster, + HugeGraphParams graphParams) { + super(metaDriver, cluster, graphParams); + + final long capacity = graphParams.configuration() + .get(CoreOptions.SCHEMA_CACHE_CAPACITY); + this.idCache = this.cache("schema-id", capacity); + this.nameCache = this.cache("schema-name", capacity); + + SchemaCaches attachment = this.idCache.attachment(); + if (attachment == null) { + int acSize = (int) (capacity >> 3); + attachment = this.idCache.attachment(new SchemaCaches<>(acSize)); + } + this.arrayCaches = attachment; + this.listenChanges(); + } + + private static Id generateId(HugeType type, Id id) { + // NOTE: it's slower performance to use: + // String.format("%x-%s", type.code(), name) + return IdGenerator.of(type.string() + "-" + id.asString()); + } + + private static Id generateId(HugeType type, String name) { + return IdGenerator.of(type.string() + "-" + name); + } + + public void close() { + this.clearCache(false); + this.unlistenChanges(); + } + + private Cache cache(String prefix, long capacity) { + // TODO: uncomment later - graph space + //final String name = prefix + "-" + this.graph().spaceGraphName(); + final String name = prefix + "-" + ""; + // NOTE: must disable schema cache-expire due to getAllSchema() + return CacheManager.instance().cache(name, capacity); + } + + private void listenChanges() { + // Listen store event: "store.init", "store.clear", ... + Set storeEvents = ImmutableSet.of(Events.STORE_INIT, + Events.STORE_CLEAR, + Events.STORE_TRUNCATE); + this.storeEventListener = event -> { + if (storeEvents.contains(event.name())) { + LOG.debug("Graph {} clear schema cache on event '{}'", + this.graph(), event.name()); + this.clearCache(true); + return true; + } + return false; + }; + this.graphParams().loadGraphStore().provider().listen(this.storeEventListener); + + // Listen cache event: "cache"(invalid cache item) + this.cacheEventListener = event -> { + LOG.debug("Graph {} received schema cache event: {}", + this.graph(), event); + Object[] args = event.args(); + E.checkArgument(args.length > 0 && args[0] instanceof String, + "Expect event action argument"); + if (Cache.ACTION_INVALID.equals(args[0])) { + event.checkArgs(String.class, HugeType.class, Id.class); + HugeType type = (HugeType) args[1]; + Id id = (Id) args[2]; + this.arrayCaches.remove(type, id); + + id = generateId(type, id); + Object value = this.idCache.get(id); + if (value != null) { + // Invalidate id cache + this.idCache.invalidate(id); + + // Invalidate name cache + SchemaElement schema = (SchemaElement) value; + Id prefixedName = generateId(schema.type(), + schema.name()); + this.nameCache.invalidate(prefixedName); + } + this.resetCachedAll(type); + return true; + } else if (Cache.ACTION_CLEAR.equals(args[0])) { + event.checkArgs(String.class, HugeType.class); + this.clearCache(false); + return true; + } + return false; + }; + EventHub schemaEventHub = this.graphParams().schemaEventHub(); + if (!schemaEventHub.containsListener(Events.CACHE)) { + schemaEventHub.listen(Events.CACHE, this.cacheEventListener); + } + } + + public void clearCache(boolean notify) { + this.idCache.clear(); + this.nameCache.clear(); + this.arrayCaches.clear(); + } + + private void resetCachedAllIfReachedCapacity() { + if (this.idCache.size() >= this.idCache.capacity()) { + LOG.warn("Schema cache reached capacity({}): {}", + this.idCache.capacity(), this.idCache.size()); + this.cachedTypes().clear(); + } + } + + private void unlistenChanges() { + // Unlisten store event + this.graphParams().loadGraphStore().provider() + .unlisten(this.storeEventListener); + + // Unlisten cache event + EventHub schemaEventHub = this.graphParams().schemaEventHub(); + schemaEventHub.unlisten(Events.CACHE, this.cacheEventListener); + } + + private CachedTypes cachedTypes() { + return this.arrayCaches.cachedTypes(); + } + + private void resetCachedAll(HugeType type) { + // Set the cache all flag of the schema type to false + this.cachedTypes().put(type, false); + } + + private void invalidateCache(HugeType type, Id id) { + // remove from id cache and name cache + Id prefixedId = generateId(type, id); + Object value = this.idCache.get(prefixedId); + if (value != null) { + this.idCache.invalidate(prefixedId); + + SchemaElement schema = (SchemaElement) value; + Id prefixedName = generateId(schema.type(), schema.name()); + this.nameCache.invalidate(prefixedName); + } + + // remove from optimized array cache + this.arrayCaches.remove(type, id); + } + + @Override + protected void updateSchema(SchemaElement schema, + Consumer updateCallback) { + super.updateSchema(schema, updateCallback); + + this.updateCache(schema); + } + + @Override + protected void addSchema(SchemaElement schema) { + super.addSchema(schema); + + this.updateCache(schema); + + if (!this.graph().option(CoreOptions.TASK_SYNC_DELETION)) { + MetaManager.instance() + // TODO: uncomment later - graph space + //.notifySchemaCacheClear(this.graph().graphSpace(), + // this.graph().name()); + .notifySchemaCacheClear("", + this.graph().name()); + } + } + + private void updateCache(SchemaElement schema) { + this.resetCachedAllIfReachedCapacity(); + + // update id cache + Id prefixedId = generateId(schema.type(), schema.id()); + this.idCache.update(prefixedId, schema); + + // update name cache + Id prefixedName = generateId(schema.type(), schema.name()); + this.nameCache.update(prefixedName, schema); + + // update optimized array cache + this.arrayCaches.updateIfNeeded(schema); + } + + @Override + protected void removeSchema(SchemaElement schema) { + super.removeSchema(schema); + + this.invalidateCache(schema.type(), schema.id()); + + if (!this.graph().option(CoreOptions.TASK_SYNC_DELETION)) { + MetaManager.instance() + // TODO: uncomment later - graph space + //.notifySchemaCacheClear(this.graph().graphSpace(), + // this.graph().name()); + .notifySchemaCacheClear("", + this.graph().name()); + } + } + + @Override + @SuppressWarnings("unchecked") + protected T getSchema(HugeType type, Id id) { + // try get from optimized array cache + if (id.number() && id.asLong() > 0L) { + SchemaElement value = this.arrayCaches.get(type, id); + if (value != null) { + return (T) value; + } + } + + Id prefixedId = generateId(type, id); + Object value = this.idCache.get(prefixedId); + if (value == null) { + value = super.getSchema(type, id); + if (value != null) { + this.resetCachedAllIfReachedCapacity(); + + this.idCache.update(prefixedId, value); + + SchemaElement schema = (SchemaElement) value; + Id prefixedName = generateId(schema.type(), schema.name()); + this.nameCache.update(prefixedName, schema); + } + } + + // update optimized array cache + this.arrayCaches.updateIfNeeded((SchemaElement) value); + + return (T) value; + } + + @Override + @SuppressWarnings("unchecked") + protected T getSchema(HugeType type, + String name) { + Id prefixedName = generateId(type, name); + Object value = this.nameCache.get(prefixedName); + if (value == null) { + value = super.getSchema(type, name); + if (value != null) { + this.resetCachedAllIfReachedCapacity(); + + this.nameCache.update(prefixedName, value); + + SchemaElement schema = (SchemaElement) value; + Id prefixedId = generateId(schema.type(), schema.id()); + this.idCache.update(prefixedId, schema); + } + } + return (T) value; + } + + @Override + protected List getAllSchema(HugeType type) { + Boolean cachedAll = this.cachedTypes().getOrDefault(type, false); + List results; + if (cachedAll) { + results = new ArrayList<>(); + // Get from cache + this.idCache.traverse(value -> { + @SuppressWarnings("unchecked") + T schema = (T) value; + if (schema.type() == type) { + results.add(schema); + } + }); + return results; + } else { + results = super.getAllSchema(type); + long free = this.idCache.capacity() - this.idCache.size(); + if (results.size() <= free) { + // Update cache + for (T schema : results) { + Id prefixedId = generateId(schema.type(), schema.id()); + this.idCache.update(prefixedId, schema); + + Id prefixedName = generateId(schema.type(), schema.name()); + this.nameCache.update(prefixedName, schema); + } + this.cachedTypes().putIfAbsent(type, true); + } + return results; + } + } + + @Override + public void clear() { + // Clear schema info firstly + super.clear(); + this.clearCache(false); + } + + private static final class SchemaCaches { + + private final int size; + + private final IntObjectMap pks; + private final IntObjectMap vls; + private final IntObjectMap els; + private final IntObjectMap ils; + + private final CachedTypes cachedTypes; + + public SchemaCaches(int size) { + // TODO: improve size of each type for optimized array cache + this.size = size; + + this.pks = new IntObjectMap<>(size); + this.vls = new IntObjectMap<>(size); + this.els = new IntObjectMap<>(size); + this.ils = new IntObjectMap<>(size); + + this.cachedTypes = new CachedTypes(); + } + + public void updateIfNeeded(V schema) { + if (schema == null) { + return; + } + Id id = schema.id(); + if (id.number() && id.asLong() > 0L) { + this.set(schema.type(), id, schema); + } + } + + @PerfUtil.Watched + public V get(HugeType type, Id id) { + assert id.number(); + long longId = id.asLong(); + if (longId <= 0L) { + assert false : id; + return null; + } + int key = (int) longId; + if (key >= this.size) { + return null; + } + switch (type) { + case PROPERTY_KEY: + return this.pks.get(key); + case VERTEX_LABEL: + return this.vls.get(key); + case EDGE_LABEL: + return this.els.get(key); + case INDEX_LABEL: + return this.ils.get(key); + default: + return null; + } + } + + public void set(HugeType type, Id id, V value) { + assert id.number(); + long longId = id.asLong(); + if (longId <= 0L) { + assert false : id; + return; + } + int key = (int) longId; + if (key >= this.size) { + return; + } + switch (type) { + case PROPERTY_KEY: + this.pks.set(key, value); + break; + case VERTEX_LABEL: + this.vls.set(key, value); + break; + case EDGE_LABEL: + this.els.set(key, value); + break; + case INDEX_LABEL: + this.ils.set(key, value); + break; + default: + // pass + break; + } + } + + public void remove(HugeType type, Id id) { + assert id.number(); + long longId = id.asLong(); + if (longId <= 0L) { + return; + } + int key = (int) longId; + V value = null; + if (key >= this.size) { + return; + } + switch (type) { + case PROPERTY_KEY: + this.pks.set(key, value); + break; + case VERTEX_LABEL: + this.vls.set(key, value); + break; + case EDGE_LABEL: + this.els.set(key, value); + break; + case INDEX_LABEL: + this.ils.set(key, value); + break; + default: + // pass + break; + } + } + + public void clear() { + this.pks.clear(); + this.vls.clear(); + this.els.clear(); + this.ils.clear(); + + this.cachedTypes.clear(); + } + + public CachedTypes cachedTypes() { + return this.cachedTypes; + } + } + + private static class CachedTypes + extends ConcurrentHashMap { + + private static final long serialVersionUID = -2215549791679355996L; + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphIndexTransaction.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphIndexTransaction.java index bc0bc0be11..4362a69867 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphIndexTransaction.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphIndexTransaction.java @@ -191,7 +191,7 @@ private void updateVertexOlapIndex(HugeVertex vertex, boolean removed) { * @param removed remove or add index */ protected void updateIndex(Id ilId, HugeElement element, boolean removed) { - SchemaTransaction schema = this.params().schemaTransaction(); + ISchemaTransaction schema = this.params().schemaTransaction(); IndexLabel indexLabel = schema.getIndexLabel(ilId); E.checkArgument(indexLabel != null, "Not exist index label with id '%s'", ilId); @@ -730,7 +730,7 @@ private PageIds doIndexQueryOnce(IndexLabel indexLabel, @Watched(prefix = "index") private Set collectMatchedIndexes(ConditionQuery query) { - SchemaTransaction schema = this.params().schemaTransaction(); + ISchemaTransaction schema = this.params().schemaTransaction(); Id label = query.condition(HugeKeys.LABEL); List schemaLabels; @@ -780,7 +780,7 @@ private Set collectMatchedIndexes(ConditionQuery query) { @Watched(prefix = "index") private MatchedIndex collectMatchedIndex(SchemaLabel schemaLabel, ConditionQuery query) { - SchemaTransaction schema = this.params().schemaTransaction(); + ISchemaTransaction schema = this.params().schemaTransaction(); Set ils = InsertionOrderUtil.newSet(); for (Id il : schemaLabel.indexLabels()) { IndexLabel indexLabel = schema.getIndexLabel(il); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/ISchemaTransaction.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/ISchemaTransaction.java new file mode 100644 index 0000000000..1f77e55ad9 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/ISchemaTransaction.java @@ -0,0 +1,92 @@ +package org.apache.hugegraph.backend.tx; + +import java.util.Collection; +import java.util.List; +import java.util.Set; + +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.schema.EdgeLabel; +import org.apache.hugegraph.schema.IndexLabel; +import org.apache.hugegraph.schema.PropertyKey; +import org.apache.hugegraph.schema.SchemaElement; +import org.apache.hugegraph.schema.SchemaLabel; +import org.apache.hugegraph.schema.VertexLabel; +import org.apache.hugegraph.type.HugeType; +import org.apache.hugegraph.type.define.GraphMode; +import org.apache.hugegraph.type.define.SchemaStatus; + +public interface ISchemaTransaction { + List getPropertyKeys(); + + Id removePropertyKey(Id pkey); + + PropertyKey getPropertyKey(Id id); + + PropertyKey getPropertyKey(String name); + + Id clearOlapPk(PropertyKey propertyKey); + + void addVertexLabel(VertexLabel label); + + void updateVertexLabel(VertexLabel label); + + Id removeVertexLabel(Id label); + + List getVertexLabels(); + + VertexLabel getVertexLabel(Id id); + + VertexLabel getVertexLabel(String name); + + List getEdgeLabels(); + + Id addPropertyKey(PropertyKey pkey); + + void updatePropertyKey(PropertyKey pkey); + + void updateEdgeLabel(EdgeLabel label); + + void addEdgeLabel(EdgeLabel label); + + Id removeEdgeLabel(Id id); + + EdgeLabel getEdgeLabel(Id id); + + EdgeLabel getEdgeLabel(String name); + + void addIndexLabel(SchemaLabel schemaLabel, IndexLabel indexLabel); + + void updateIndexLabel(IndexLabel label); + + Id removeIndexLabel(Id id); + + Id rebuildIndex(SchemaElement schema); + + Id rebuildIndex(SchemaElement schema, Set dependencies); + + List getIndexLabels(); + + IndexLabel getIndexLabel(Id id); + + IndexLabel getIndexLabel(String name); + + void close(); + + Id getNextId(HugeType type); + + Id validOrGenerateId(HugeType type, Id id, String name); + + void checkSchemaName(String name); + + String graphName(); + + void updateSchemaStatus(SchemaElement element, SchemaStatus status); + + GraphMode graphMode(); + + boolean existsSchemaId(HugeType type, Id id); + + void removeIndexLabelFromBaseLabel(IndexLabel indexLabel); + + void createIndexLabelForOlapPk(PropertyKey propertyKey); +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransaction.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransaction.java index 82ec7a20e2..69b13869a2 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransaction.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransaction.java @@ -68,7 +68,7 @@ import org.apache.hugegraph.util.LockUtil; import com.google.common.collect.ImmutableSet; -public class SchemaTransaction extends IndexableTransaction { +public class SchemaTransaction extends IndexableTransaction implements ISchemaTransaction { private final SchemaIndexTransaction indexTx; private final SystemSchemaStore systemSchemaStore; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java index a78422be86..1b5cbe4bb1 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java @@ -62,7 +62,7 @@ import com.google.common.collect.ImmutableSet; -public class SchemaTransactionV2 extends SchemaTransaction { +public class SchemaTransactionV2 implements ISchemaTransaction { protected static final Logger LOG = Log.logger(SchemaTransaction.class); @@ -75,7 +75,6 @@ public class SchemaTransactionV2 extends SchemaTransaction { public SchemaTransactionV2(MetaDriver metaDriver, String cluster, HugeGraphParams graphParams) { - super(graphParams, null); E.checkNotNull(graphParams, "graphParams"); this.graphParams = graphParams; // TODO: uncomment later - graph space @@ -342,6 +341,11 @@ public IndexLabel getIndexLabel(String name) { return this.getSchema(HugeType.INDEX_LABEL, name); } + @Override + public void close() { + + } + @Watched(prefix = "schema") public Id removeIndexLabel(Id id) { LOG.debug("SchemaTransaction remove index label '{}'", id); @@ -369,6 +373,11 @@ public boolean existsSchemaId(HugeType type, Id id) { return this.getSchema(type, id) != null; } + @Override + public void removeIndexLabelFromBaseLabel(IndexLabel indexLabel) { + + } + protected void updateSchema(SchemaElement schema, Consumer updateCallback) { LOG.debug("SchemaTransaction update {} with id '{}'", @@ -687,6 +696,11 @@ public void checkSchemaName(String name) { } } + @Override + public String graphName() { + return this.graph; + } + protected HugeGraphParams graphParams() { return this.graphParams; } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/EdgeLabelRemoveJob.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/EdgeLabelRemoveJob.java index af2fb65f78..e05563b868 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/EdgeLabelRemoveJob.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/EdgeLabelRemoveJob.java @@ -21,6 +21,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.tx.GraphTransaction; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.schema.EdgeLabel; import org.apache.hugegraph.type.define.SchemaStatus; @@ -43,7 +44,7 @@ public Object execute() { private static void removeEdgeLabel(HugeGraphParams graph, Id id) { GraphTransaction graphTx = graph.graphTransaction(); - SchemaTransaction schemaTx = graph.schemaTransaction(); + ISchemaTransaction schemaTx = graph.schemaTransaction(); EdgeLabel edgeLabel = schemaTx.getEdgeLabel(id); // If the edge label does not exist, return directly if (edgeLabel == null) { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/IndexLabelRebuildJob.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/IndexLabelRebuildJob.java index 7e047a0632..0c5624af1a 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/IndexLabelRebuildJob.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/IndexLabelRebuildJob.java @@ -24,6 +24,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.tx.GraphTransaction; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.type.define.SchemaStatus; @@ -83,7 +84,7 @@ private void rebuildIndex(SchemaElement schema) { } private void rebuildIndex(SchemaLabel label, Collection indexLabelIds) { - SchemaTransaction schemaTx = this.params().schemaTransaction(); + ISchemaTransaction schemaTx = this.params().schemaTransaction(); GraphTransaction graphTx = this.params().graphTransaction(); Consumer indexUpdater = (elem) -> { @@ -148,7 +149,7 @@ private void rebuildIndex(SchemaLabel label, Collection indexLabelIds) { } private void removeIndex(Collection indexLabelIds) { - SchemaTransaction schemaTx = this.params().schemaTransaction(); + ISchemaTransaction schemaTx = this.params().schemaTransaction(); GraphTransaction graphTx = this.params().graphTransaction(); for (Id id : indexLabelIds) { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/IndexLabelRemoveJob.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/IndexLabelRemoveJob.java index 113507c994..f5c52348cc 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/IndexLabelRemoveJob.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/IndexLabelRemoveJob.java @@ -19,6 +19,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.tx.GraphTransaction; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.schema.IndexLabel; import org.apache.hugegraph.type.define.SchemaStatus; @@ -40,7 +41,7 @@ public Object execute() { protected static void removeIndexLabel(HugeGraphParams graph, Id id) { GraphTransaction graphTx = graph.graphTransaction(); - SchemaTransaction schemaTx = graph.schemaTransaction(); + ISchemaTransaction schemaTx = graph.schemaTransaction(); IndexLabel indexLabel = schemaTx.getIndexLabel(id); // If the index label does not exist, return directly if (indexLabel == null) { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/OlapPropertyKeyClearJob.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/OlapPropertyKeyClearJob.java index f28f0af276..af47ae00cf 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/OlapPropertyKeyClearJob.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/OlapPropertyKeyClearJob.java @@ -19,6 +19,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.tx.GraphTransaction; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.schema.IndexLabel; import org.apache.hugegraph.type.define.SchemaStatus; @@ -50,7 +51,7 @@ protected static void clearIndexLabel(HugeGraphParams graph, Id id) { return; } GraphTransaction graphTx = graph.graphTransaction(); - SchemaTransaction schemaTx = graph.schemaTransaction(); + ISchemaTransaction schemaTx = graph.schemaTransaction(); IndexLabel indexLabel = schemaTx.getIndexLabel(olapIndexLabel); // If the index label does not exist, return directly if (indexLabel == null) { @@ -80,7 +81,7 @@ protected static void clearIndexLabel(HugeGraphParams graph, Id id) { } protected static Id findOlapIndexLabel(HugeGraphParams graph, Id olap) { - SchemaTransaction schemaTx = graph.schemaTransaction(); + ISchemaTransaction schemaTx = graph.schemaTransaction(); for (IndexLabel indexLabel : schemaTx.getIndexLabels()) { if (indexLabel.indexFields().contains(olap)) { return indexLabel.id(); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/OlapPropertyKeyCreateJob.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/OlapPropertyKeyCreateJob.java index 578f874734..db56515318 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/OlapPropertyKeyCreateJob.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/OlapPropertyKeyCreateJob.java @@ -17,6 +17,7 @@ package org.apache.hugegraph.job.schema; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.schema.PropertyKey; @@ -29,7 +30,7 @@ public String type() { @Override public Object execute() { - SchemaTransaction schemaTx = this.params().schemaTransaction(); + ISchemaTransaction schemaTx = this.params().schemaTransaction(); PropertyKey propertyKey = schemaTx.getPropertyKey(this.schemaId()); // Create olap index label schema schemaTx.createIndexLabelForOlapPk(propertyKey); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/OlapPropertyKeyRemoveJob.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/OlapPropertyKeyRemoveJob.java index a9a5c4153e..81a56a0be6 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/OlapPropertyKeyRemoveJob.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/OlapPropertyKeyRemoveJob.java @@ -18,6 +18,7 @@ package org.apache.hugegraph.job.schema; import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.schema.PropertyKey; @@ -42,7 +43,7 @@ public Object execute() { } // Remove olap property key - SchemaTransaction schemaTx = this.params().schemaTransaction(); + ISchemaTransaction schemaTx = this.params().schemaTransaction(); PropertyKey propertyKey = schemaTx.getPropertyKey(olap); removeSchema(schemaTx, propertyKey); return null; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/SchemaJob.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/SchemaJob.java index 166f310dc3..28d47877bb 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/SchemaJob.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/SchemaJob.java @@ -22,6 +22,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.job.SysJob; import org.apache.hugegraph.schema.SchemaElement; @@ -85,7 +86,7 @@ public static String formatTaskName(HugeType type, Id id, String name) { * @param tx The remove operation actual executer * @param schema the schema to be removed */ - protected static void removeSchema(SchemaTransaction tx, + protected static void removeSchema(ISchemaTransaction tx, SchemaElement schema) { try { Method method = SchemaTransaction.class diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/VertexLabelRemoveJob.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/VertexLabelRemoveJob.java index 0f7fe942bd..4f7c926240 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/VertexLabelRemoveJob.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/VertexLabelRemoveJob.java @@ -22,6 +22,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.tx.GraphTransaction; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.schema.EdgeLabel; import org.apache.hugegraph.schema.VertexLabel; @@ -46,7 +47,7 @@ public Object execute() { private static void removeVertexLabel(HugeGraphParams graph, Id id) { GraphTransaction graphTx = graph.graphTransaction(); - SchemaTransaction schemaTx = graph.schemaTransaction(); + ISchemaTransaction schemaTx = graph.schemaTransaction(); VertexLabel vertexLabel = schemaTx.getVertexLabel(id); // If the vertex label does not exist, return directly if (vertexLabel == null) { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaManager.java index ec55a823f9..0b31ab9698 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaManager.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaManager.java @@ -20,6 +20,7 @@ import java.util.List; import java.util.stream.Collectors; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.tinkerpop.gremlin.structure.Graph; @@ -34,10 +35,10 @@ public class SchemaManager { - private final SchemaTransaction transaction; + private final ISchemaTransaction transaction; private HugeGraph graph; - public SchemaManager(SchemaTransaction transaction, HugeGraph graph) { + public SchemaManager(ISchemaTransaction transaction, HugeGraph graph) { E.checkNotNull(transaction, "transaction"); E.checkNotNull(graph, "graph"); this.transaction = transaction; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/AbstractBuilder.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/AbstractBuilder.java index 7c1620fda7..3e2859f236 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/AbstractBuilder.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/AbstractBuilder.java @@ -22,6 +22,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.schema.IndexLabel; import org.apache.hugegraph.schema.PropertyKey; @@ -38,10 +39,10 @@ public abstract class AbstractBuilder { - private final SchemaTransaction transaction; + private final ISchemaTransaction transaction; private final HugeGraph graph; - public AbstractBuilder(SchemaTransaction transaction, HugeGraph graph) { + public AbstractBuilder(ISchemaTransaction transaction, HugeGraph graph) { E.checkNotNull(transaction, "transaction"); E.checkNotNull(graph, "graph"); this.transaction = transaction; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/EdgeLabelBuilder.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/EdgeLabelBuilder.java index 87ec1d78bf..a5ff1e8ae1 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/EdgeLabelBuilder.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/EdgeLabelBuilder.java @@ -29,6 +29,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.schema.PropertyKey; import org.apache.hugegraph.schema.Userdata; @@ -62,7 +63,7 @@ public class EdgeLabelBuilder extends AbstractBuilder private Userdata userdata; private boolean checkExist; - public EdgeLabelBuilder(SchemaTransaction transaction, + public EdgeLabelBuilder(ISchemaTransaction transaction, HugeGraph graph, String name) { super(transaction, graph); E.checkNotNull(name, "name"); @@ -81,7 +82,7 @@ public EdgeLabelBuilder(SchemaTransaction transaction, this.checkExist = true; } - public EdgeLabelBuilder(SchemaTransaction transaction, + public EdgeLabelBuilder(ISchemaTransaction transaction, HugeGraph graph, EdgeLabel copy) { super(transaction, graph); E.checkNotNull(copy, "copy"); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/IndexLabelBuilder.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/IndexLabelBuilder.java index 8ab7197b5a..1484b05dcf 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/IndexLabelBuilder.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/IndexLabelBuilder.java @@ -27,6 +27,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.HugeException; import org.apache.hugegraph.HugeGraph; @@ -64,7 +65,7 @@ public class IndexLabelBuilder extends AbstractBuilder private boolean checkExist; private boolean rebuild; - public IndexLabelBuilder(SchemaTransaction transaction, + public IndexLabelBuilder(ISchemaTransaction transaction, HugeGraph graph, String name) { super(transaction, graph); E.checkNotNull(name, "name"); @@ -79,7 +80,7 @@ public IndexLabelBuilder(SchemaTransaction transaction, this.rebuild = true; } - public IndexLabelBuilder(SchemaTransaction transaction, + public IndexLabelBuilder(ISchemaTransaction transaction, HugeGraph graph, IndexLabel copy) { super(transaction, graph); E.checkNotNull(copy, "copy"); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/PropertyKeyBuilder.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/PropertyKeyBuilder.java index 63a3371f65..54684a3e34 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/PropertyKeyBuilder.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/PropertyKeyBuilder.java @@ -22,6 +22,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.schema.PropertyKey; import org.apache.hugegraph.schema.SchemaElement; @@ -53,7 +54,7 @@ public class PropertyKeyBuilder extends AbstractBuilder private boolean checkExist; private Userdata userdata; - public PropertyKeyBuilder(SchemaTransaction transaction, + public PropertyKeyBuilder(ISchemaTransaction transaction, HugeGraph graph, String name) { super(transaction, graph); E.checkNotNull(name, "name"); @@ -67,7 +68,7 @@ public PropertyKeyBuilder(SchemaTransaction transaction, this.checkExist = true; } - public PropertyKeyBuilder(SchemaTransaction transaction, + public PropertyKeyBuilder(ISchemaTransaction transaction, HugeGraph graph, PropertyKey copy) { super(transaction, graph); E.checkNotNull(copy, "copy"); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/VertexLabelBuilder.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/VertexLabelBuilder.java index c59933f365..42115d8d7c 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/VertexLabelBuilder.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/VertexLabelBuilder.java @@ -29,6 +29,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.backend.tx.SchemaTransaction; import org.apache.hugegraph.schema.PropertyKey; import org.apache.hugegraph.schema.Userdata; @@ -59,7 +60,7 @@ public class VertexLabelBuilder extends AbstractBuilder private Userdata userdata; private boolean checkExist; - public VertexLabelBuilder(SchemaTransaction transaction, + public VertexLabelBuilder(ISchemaTransaction transaction, HugeGraph graph, String name) { super(transaction, graph); E.checkNotNull(name, "name"); @@ -76,7 +77,7 @@ public VertexLabelBuilder(SchemaTransaction transaction, this.checkExist = true; } - public VertexLabelBuilder(SchemaTransaction transaction, + public VertexLabelBuilder(ISchemaTransaction transaction, HugeGraph graph, VertexLabel copy) { super(transaction, graph); E.checkNotNull(copy, "copy"); From 8d0f0530537dce09ccd59f4ea92890e5aed14d11 Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Wed, 23 Aug 2023 22:26:27 +0800 Subject: [PATCH 11/26] fix: init meta server --- .../org/apache/hugegraph/StandardHugeGraph.java | 17 +++++++++++++---- .../backend/tx/SchemaTransactionV2.java | 6 ++---- .../backend/store/hstore/HstoreStore.java | 5 +---- 3 files changed, 16 insertions(+), 12 deletions(-) diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java index a5204d2d10..21a24c8492 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java @@ -18,6 +18,7 @@ package org.apache.hugegraph; import java.util.Collection; +import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.Set; @@ -52,11 +53,8 @@ import org.apache.hugegraph.backend.store.raft.RaftBackendStoreProvider; import org.apache.hugegraph.backend.store.raft.RaftGroupManager; import org.apache.hugegraph.backend.store.ram.RamTable; -import org.apache.hugegraph.backend.tx.ISchemaTransaction; -import org.apache.hugegraph.meta.MetaManager; -import org.apache.hugegraph.task.EphemeralJobQueue; import org.apache.hugegraph.backend.tx.GraphTransaction; -import org.apache.hugegraph.backend.tx.SchemaTransaction; +import org.apache.hugegraph.backend.tx.ISchemaTransaction; import org.apache.hugegraph.config.CoreOptions; import org.apache.hugegraph.config.HugeConfig; import org.apache.hugegraph.config.TypedOption; @@ -72,6 +70,7 @@ import org.apache.hugegraph.masterelection.RoleElectionStateMachine; import org.apache.hugegraph.masterelection.StandardClusterRoleStore; import org.apache.hugegraph.masterelection.StandardRoleElectionStateMachine; +import org.apache.hugegraph.meta.MetaManager; import org.apache.hugegraph.perf.PerfUtil.Watched; import org.apache.hugegraph.rpc.RpcServiceConfig4Client; import org.apache.hugegraph.rpc.RpcServiceConfig4Server; @@ -87,6 +86,7 @@ import org.apache.hugegraph.structure.HugeFeatures; import org.apache.hugegraph.structure.HugeVertex; import org.apache.hugegraph.structure.HugeVertexProperty; +import org.apache.hugegraph.task.EphemeralJobQueue; import org.apache.hugegraph.task.ServerInfoManager; import org.apache.hugegraph.task.TaskManager; import org.apache.hugegraph.task.TaskScheduler; @@ -179,6 +179,8 @@ public class StandardHugeGraph implements HugeGraph { private final RamTable ramtable; + private final MetaManager metaManager = MetaManager.instance(); + public StandardHugeGraph(HugeConfig config) { this.params = new StandardHugeGraphParams(); this.configuration = config; @@ -460,10 +462,17 @@ private boolean isHstore() { return "hstore".equals(this.backend()); } + private void initMetaManager() { + this.metaManager.connect("hg", MetaManager.MetaDriverType.PD, + "ca", "ca", "ca", + Collections.singletonList("127.0.0.1:8686")); + } + private ISchemaTransaction openSchemaTransaction() throws HugeException { this.checkGraphNotClosed(); try { if (isHstore()) { + initMetaManager(); return new CachedSchemaTransactionV2( MetaManager.instance().metaDriver(), MetaManager.instance().cluster(), this.params); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java index 1b5cbe4bb1..a6aa285576 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java @@ -399,8 +399,7 @@ private void saveSchema(SchemaElement schema, boolean update, // TODO: uncomment later - graph space //String spaceGraph = this.graphParams() // .graph().spaceGraphName(); - String spaceGraph = ""; - LockUtil.Locks locks = new LockUtil.Locks(spaceGraph); + LockUtil.Locks locks = new LockUtil.Locks(graph); try { locks.lockWrites(LockUtil.hugeType2Group(schema.type()), schema.id()); @@ -523,8 +522,7 @@ protected void removeSchema(SchemaElement schema) { // TODO: uncomment later - graph space //String spaceGraph = this.graphParams() // .graph().spaceGraphName(); - String spaceGraph = ""; - LockUtil.Locks locks = new LockUtil.Locks(spaceGraph); + LockUtil.Locks locks = new LockUtil.Locks(graph); try { locks.lockWrites(LockUtil.hugeType2Group(schema.type()), schema.id()); diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java index 43c85d5e80..ada9c868f9 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java @@ -699,13 +699,10 @@ public void setCounterLowest(HugeType type, long lowest) { /***************************** Store defines *****************************/ - public static class HstoreSystemStore extends HstoreStore { + public static class HstoreSystemStore extends HstoreGraphStore { public HstoreSystemStore(BackendStoreProvider provider, String namespace, String store) { super(provider, namespace, store); - - registerTableManager(HugeTableType.VERTEX, - new HstoreTables.Vertex(store)); } @Override From 5a2af2933eba747918619bdd8b8dbff5d85aa36c Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Thu, 24 Aug 2023 22:11:26 +0800 Subject: [PATCH 12/26] fix: avoid typecast from UnmodifiableRandomAccessList class java.util.Collections cannot be cast to class java.util.ArrayList --- .../apache/hugegraph/backend/store/hstore/HstoreTable.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTable.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTable.java index ef412d8ced..7abe92c0f8 100755 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTable.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTable.java @@ -245,7 +245,7 @@ protected byte[] getOwnerId(HugeType type, Id id) { @Override public void insert(Session session, BackendEntry entry) { byte[] owner = entry.type().isEdge() ? getInsertEdgeOwner(entry) : getInsertOwner(entry); - ArrayList columns = (ArrayList) entry.columns(); + ArrayList columns = new ArrayList<>(entry.columns()); for (int i = 0; i < columns.size(); i++) { BackendColumn col = columns.get(i); session.put(this.table(), owner, col.name, col.value); @@ -254,7 +254,7 @@ public void insert(Session session, BackendEntry entry) { public void insert(Session session, BackendEntry entry, boolean isEdge) { byte[] owner = isEdge ? getInsertEdgeOwner(entry) : getInsertOwner(entry); - ArrayList columns = (ArrayList) entry.columns(); + ArrayList columns = new ArrayList<>(entry.columns()); for (int i = 0; i < columns.size(); i++) { BackendColumn col = columns.get(i); session.put(this.table(), owner, col.name, col.value); From bd75b68b3122ff28a41400dcc21ffe6f1716e298 Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Mon, 28 Aug 2023 14:27:29 +0800 Subject: [PATCH 13/26] refact: query task and server info by graph tx --- .../apache/hugegraph/StandardHugeGraph.java | 3 ++ .../backend/store/BackendStoreInfo.java | 3 ++ .../backend/tx/GraphTransaction.java | 30 +++++++++++++- .../apache/hugegraph/schema/IndexLabel.java | 2 + .../hugegraph/structure/HugeVertex.java | 8 ++++ .../hugegraph/task/ServerInfoManager.java | 6 +-- .../hugegraph/task/StandardTaskScheduler.java | 10 ++--- .../apache/hugegraph/type/HugeTableType.java | 3 +- .../org/apache/hugegraph/type/HugeType.java | 3 +- .../backend/store/hstore/HstoreProvider.java | 4 +- .../backend/store/hstore/HstoreStore.java | 39 +++++-------------- .../backend/store/hstore/HstoreTables.java | 13 +++++++ .../client/grpc/GrpcStoreNodeSessionImpl.java | 1 + .../store/business/BusinessHandler.java | 3 +- 14 files changed, 84 insertions(+), 44 deletions(-) diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java index 21a24c8492..68c08ec2f4 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java @@ -521,6 +521,9 @@ private BackendStore loadGraphStore() { } private BackendStore loadSystemStore() { + if (isHstore()) { + return this.storeProvider.loadGraphStore(this.configuration); + } return this.storeProvider.loadSystemStore(this.configuration); } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreInfo.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreInfo.java index 966d21fe88..24de32215e 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreInfo.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreInfo.java @@ -41,6 +41,9 @@ public boolean exists() { } public boolean checkVersion() { + if ("hstore".equals(this.storeProvider.type())) { // skip for hstore now + return true; + } String driverVersion = this.storeProvider.driverVersion(); String storedVersion = this.storeProvider.loadSystemStore(this.config) .storedVersion(); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java index ea1196eaef..dc52a2e05e 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java @@ -734,16 +734,42 @@ public Vertex queryVertex(Object vertexId) { return vertex; } + public Iterator queryTaskInfos(Query query) { + return this.queryVertices(query); + } + + public Iterator queryTaskInfos(Object... vertexIds) { + return this.queryVerticesByIds(vertexIds, false, false, + HugeType.TASK); + } + + public Iterator queryServerInfos(Query query) { + return this.queryVertices(query); + } + + public Iterator queryServerInfos(Object... vertexIds) { + return this.queryVerticesByIds(vertexIds, false, false, + HugeType.SERVER); + } + + protected Iterator queryVerticesByIds(Object[] vertexIds, + boolean adjacentVertex, + boolean checkMustExist) { + return this.queryVerticesByIds(vertexIds, adjacentVertex, checkMustExist, + HugeType.VERTEX); + } + protected Iterator queryVerticesByIds(Object[] vertexIds, boolean adjacentVertex, - boolean checkMustExist) { + boolean checkMustExist, + HugeType type) { Query.checkForceCapacity(vertexIds.length); // NOTE: allowed duplicated vertices if query by duplicated ids List ids = InsertionOrderUtil.newList(); Map vertices = new HashMap<>(vertexIds.length); - IdQuery query = new IdQuery(HugeType.VERTEX); + IdQuery query = new IdQuery(type); for (Object vertexId : vertexIds) { HugeVertex vertex; Id id = HugeVertex.getIdValue(vertexId); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/IndexLabel.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/IndexLabel.java index 473d912560..090cf6dffe 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/IndexLabel.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/IndexLabel.java @@ -167,6 +167,8 @@ public Object validValue(Object value) { public static IndexLabel label(HugeType type) { switch (type) { + case TASK: + case SERVER: case VERTEX: return VL_IL; case EDGE: diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeVertex.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeVertex.java index c270312b09..731bfa4446 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeVertex.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeVertex.java @@ -43,6 +43,8 @@ import org.apache.hugegraph.schema.EdgeLabel; import org.apache.hugegraph.schema.PropertyKey; import org.apache.hugegraph.schema.VertexLabel; +import org.apache.hugegraph.task.HugeServerInfo; +import org.apache.hugegraph.task.HugeTask; import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.type.define.Cardinality; import org.apache.hugegraph.type.define.CollectionType; @@ -90,6 +92,12 @@ public HugeVertex(final HugeGraph graph, Id id, VertexLabel label) { @Override public HugeType type() { + if (label != null && label.name().equals(HugeTask.P.TASK)) { + return HugeType.TASK; + } + if (label != null && label.name().equals(HugeServerInfo.P.SERVER)) { + return HugeType.SERVER; + } return HugeType.VERTEX; } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/ServerInfoManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/ServerInfoManager.java index e8cccf88e3..7a49bc32bc 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/ServerInfoManager.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/ServerInfoManager.java @@ -319,7 +319,7 @@ private HugeServerInfo selfServerInfo() { private HugeServerInfo serverInfo(Id server) { return this.call(() -> { - Iterator vertices = this.tx().queryVertices(server); + Iterator vertices = this.tx().queryServerInfos(server); Vertex vertex = QueryResults.one(vertices); if (vertex == null) { return null; @@ -347,7 +347,7 @@ private HugeServerInfo removeServerInfo(Id server) { } LOG.info("Remove server info: {}", server); return this.call(() -> { - Iterator vertices = this.tx().queryVertices(server); + Iterator vertices = this.tx().queryServerInfos(server); Vertex vertex = QueryResults.one(vertices); if (vertex == null) { return null; @@ -382,7 +382,7 @@ protected Iterator serverInfos(long limit, String page) { private Iterator serverInfos(Map conditions, long limit, String page) { return this.call(() -> { - ConditionQuery query = new ConditionQuery(HugeType.VERTEX); + ConditionQuery query = new ConditionQuery(HugeType.SERVER); if (page != null) { query.page(page); } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/StandardTaskScheduler.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/StandardTaskScheduler.java index 9eda3f6b02..41f7aa01ea 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/StandardTaskScheduler.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/StandardTaskScheduler.java @@ -523,7 +523,7 @@ public Iterator> tasks(TaskStatus status, public HugeTask findTask(Id id) { HugeTask result = this.call(() -> { - Iterator vertices = this.tx().queryVertices(id); + Iterator vertices = this.tx().queryTaskInfos(id); Vertex vertex = QueryResults.one(vertices); if (vertex == null) { return null; @@ -573,7 +573,7 @@ public HugeTask delete(Id id) { } return this.call(() -> { - Iterator vertices = this.tx().queryVertices(id); + Iterator vertices = this.tx().queryTaskInfos(id); HugeVertex vertex = (HugeVertex) QueryResults.one(vertices); if (vertex == null) { return null; @@ -666,7 +666,7 @@ private Iterator> queryTask(String key, Object value, private Iterator> queryTask(Map conditions, long limit, String page) { return this.call(() -> { - ConditionQuery query = new ConditionQuery(HugeType.VERTEX); + ConditionQuery query = new ConditionQuery(HugeType.TASK); if (page != null) { query.page(page); } @@ -691,7 +691,7 @@ private Iterator> queryTask(Map conditions, private Iterator> queryTask(List ids) { return this.call(() -> { Object[] idArray = ids.toArray(new Id[0]); - Iterator vertices = this.tx().queryVertices(idArray); + Iterator vertices = this.tx().queryTaskInfos(idArray); Iterator> tasks = new MapperIterator<>(vertices, HugeTask::fromVertex); // Convert iterator to list to avoid across thread tx accessed @@ -756,7 +756,7 @@ public HugeVertex constructVertex(HugeTask task) { public void deleteIndex(HugeVertex vertex) { // Delete the old record if exist - Iterator old = this.queryVertices(vertex.id()); + Iterator old = this.queryTaskInfos(vertex.id()); HugeVertex oldV = (HugeVertex) QueryResults.one(old); if (oldV == null) { return; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeTableType.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeTableType.java index 97722438a1..a3edf746ff 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeTableType.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeTableType.java @@ -32,7 +32,8 @@ public enum HugeTableType implements SerialEnum { IN_EDGE(3, "IE"), // 入边表 ALL_INDEX_TABLE(4, "INDEX"), // 索引表 TASK_INFO_TABLE(5, "TASK"), // 任务信息表 - OLAP_TABLE(6, "OLAP"); // OLAP 表 + OLAP_TABLE(6, "OLAP"), // OLAP 表 + SERVER_INFO_TABLE(7, "SERVER"); // SERVER 信息表 private static final Map ALL_NAME = new HashMap<>(); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java index 388dfccf07..75883747bc 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java @@ -66,6 +66,7 @@ public enum HugeType implements SerialEnum { UNIQUE_INDEX(178, "UI"), TASK(180, "T"), + SERVER(181, "SR"), // System schema SYS_SCHEMA(250, "SS"), @@ -115,7 +116,7 @@ public boolean isGraph() { } public boolean isVertex() { - return this == HugeType.VERTEX; + return this == HugeType.VERTEX || this == HugeType.TASK || this == HugeType.SERVER; } public boolean isEdge() { diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java index 98ad217943..f9d48d36c9 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreProvider.java @@ -34,7 +34,7 @@ public String type() { @Override public String driverVersion() { - return "1.12"; + return "1.13"; } @Override @@ -49,6 +49,6 @@ protected BackendStore newGraphStore(HugeConfig config, String store) { @Override protected BackendStore newSystemStore(HugeConfig config, String store) { - return new HstoreStore.HstoreSystemStore(this, this.namespace(), store); + return null; } } diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java index ada9c868f9..588aa5f530 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreStore.java @@ -129,6 +129,9 @@ protected final HstoreTable table(HugeType type) { case TASK: table = HugeTableType.TASK_INFO_TABLE; break; + case SERVER: + table = HugeTableType.SERVER_INFO_TABLE; + break; case SEARCH_INDEX: case SHARD_INDEX: case SECONDARY_INDEX: @@ -699,35 +702,6 @@ public void setCounterLowest(HugeType type, long lowest) { /***************************** Store defines *****************************/ - public static class HstoreSystemStore extends HstoreGraphStore { - - public HstoreSystemStore(BackendStoreProvider provider, String namespace, String store) { - super(provider, namespace, store); - } - - @Override - public boolean isSchemaStore() { - return true; - } - - @Override - public void increaseCounter(HugeType type, long num) { - throw new UnsupportedOperationException( - "HstoreSchemaStore.increaseCounter()"); - } - - @Override - public long getCounter(HugeType type) { - throw new UnsupportedOperationException( - "HstoreSchemaStore.getCounter()"); - } - - @Override - public String storedVersion() { - return "1.12"; - } - } - public static class HstoreSchemaStore extends HstoreStore { public HstoreSchemaStore(BackendStoreProvider provider, String namespace, String store) { @@ -770,6 +744,8 @@ public HstoreGraphStore(BackendStoreProvider provider, new HstoreTables.OlapTable(store)); registerTableManager(HugeTableType.TASK_INFO_TABLE, new HstoreTables.TaskInfo(store)); + registerTableManager(HugeTableType.SERVER_INFO_TABLE, + new HstoreTables.ServerInfo(store)); } @Override @@ -827,4 +803,9 @@ public void clearOlapTable(Id pkId) { public void removeOlapTable(Id pkId) { } } + + @Override + public String storedVersion() { + return "1.13"; + } } diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTables.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTables.java index d1ca9e9057..f4ebf7ebef 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTables.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreTables.java @@ -64,6 +64,19 @@ protected BackendColumnIterator queryById(Session session, Id id) { } } + public static class ServerInfo extends HstoreTable { + public static final String TABLE = HugeTableType.SERVER_INFO_TABLE.string(); + + public ServerInfo(String database) { + super(database, TABLE); + } + + @Override + protected BackendColumnIterator queryById(Session session, Id id) { + return this.getById(session, id); + } + } + public static class Edge extends HstoreTable { public static final String TABLE_SUFFIX = HugeType.EDGE.string(); diff --git a/hugegraph-store/hg-store-client/src/main/java/org/apache/hugegraph/store/client/grpc/GrpcStoreNodeSessionImpl.java b/hugegraph-store/hg-store-client/src/main/java/org/apache/hugegraph/store/client/grpc/GrpcStoreNodeSessionImpl.java index afa831573b..180d3357f7 100644 --- a/hugegraph-store/hg-store-client/src/main/java/org/apache/hugegraph/store/client/grpc/GrpcStoreNodeSessionImpl.java +++ b/hugegraph-store/hg-store-client/src/main/java/org/apache/hugegraph/store/client/grpc/GrpcStoreNodeSessionImpl.java @@ -70,6 +70,7 @@ class GrpcStoreNodeSessionImpl implements HgStoreNodeSession { put("g+index", 4); put("g+task", 5); put("g+olap", 6); + put("g+server", 7); }}; private final HgStoreNode storeNode; private final String graphName; diff --git a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/business/BusinessHandler.java b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/business/BusinessHandler.java index b8d51184d8..62ded85ece 100644 --- a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/business/BusinessHandler.java +++ b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/business/BusinessHandler.java @@ -50,9 +50,10 @@ public interface BusinessHandler extends DBSessionBuilder { String tableIndex = "g+index"; String tableTask = "g+task"; String tableOlap = "g+olap"; + String tableServer = "g+server"; String[] tables = new String[]{tableUnknown, tableVertex, tableOutEdge, tableInEdge, tableIndex, - tableTask, tableOlap}; + tableTask, tableOlap, tableServer}; void doPut(String graph, int code, String table, byte[] key, byte[] value) throws HgStoreException; From bd10b4bf4ea45130beaba13886305b6fc5e383e9 Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Mon, 28 Aug 2023 14:50:53 +0800 Subject: [PATCH 14/26] fix: register task and server table for rocksdb BE --- .../backend/store/rocksdb/RocksDBStore.java | 5 +++ .../backend/store/rocksdb/RocksDBTables.java | 42 +++++++++++++++++++ 2 files changed, 47 insertions(+) diff --git a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java index 2dba5fa766..9cf3ba97e7 100644 --- a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java +++ b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java @@ -1121,6 +1121,11 @@ public RocksDBSystemStore(BackendStoreProvider provider, super(provider, database, store); this.meta = new RocksDBTables.Meta(database); + + registerTableManager(HugeType.TASK, + new RocksDBTables.TaskInfo(database)); + registerTableManager(HugeType.SERVER, + new RocksDBTables.ServerInfo(database)); } @Override diff --git a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTables.java b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTables.java index 06c2d91a1a..b1724cb5f3 100644 --- a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTables.java +++ b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTables.java @@ -188,6 +188,48 @@ protected BackendColumnIterator queryByIds(RocksDBSessions.Session session, } } + public static class TaskInfo extends RocksDBTable { + + public static final String TABLE = HugeType.TASK.string(); + + public TaskInfo(String database) { + super(database, TABLE); + } + + @Override + protected BackendColumnIterator queryById(RocksDBSessions.Session session, Id id) { + return this.getById(session, id); + } + + @Override + protected BackendColumnIterator queryByIds(RocksDBSessions.Session session, + Collection ids) { + // TODO: use getByIds() after batch version multi-get is ready + return super.queryByIds(session, ids); + } + } + + public static class ServerInfo extends RocksDBTable { + + public static final String TABLE = HugeType.SERVER.string(); + + public ServerInfo(String database) { + super(database, TABLE); + } + + @Override + protected BackendColumnIterator queryById(RocksDBSessions.Session session, Id id) { + return this.getById(session, id); + } + + @Override + protected BackendColumnIterator queryByIds(RocksDBSessions.Session session, + Collection ids) { + // TODO: use getByIds() after batch version multi-get is ready + return super.queryByIds(session, ids); + } + } + public static class Edge extends RocksDBTable { public static final String TABLE_SUFFIX = HugeType.EDGE.string(); From 293486f9e6b7e191e17cd100bfb32d456540d457 Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Mon, 28 Aug 2023 14:54:03 +0800 Subject: [PATCH 15/26] chore: add example for hstore BE scanning tables --- .../apache/hugegraph/example/ExampleNew.java | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 hugegraph-server/hugegraph-example/src/main/java/org/apache/hugegraph/example/ExampleNew.java diff --git a/hugegraph-server/hugegraph-example/src/main/java/org/apache/hugegraph/example/ExampleNew.java b/hugegraph-server/hugegraph-example/src/main/java/org/apache/hugegraph/example/ExampleNew.java new file mode 100644 index 0000000000..1c9b4413b3 --- /dev/null +++ b/hugegraph-server/hugegraph-example/src/main/java/org/apache/hugegraph/example/ExampleNew.java @@ -0,0 +1,51 @@ +package org.apache.hugegraph.example; + +import static org.apache.hugegraph.backend.page.PageState.EMPTY_BYTES; + +import org.apache.hugegraph.pd.client.PDConfig; +import org.apache.hugegraph.store.HgKvEntry; +import org.apache.hugegraph.store.HgKvIterator; +import org.apache.hugegraph.store.HgKvStore; +import org.apache.hugegraph.store.HgStoreClient; +import org.apache.hugegraph.store.HgStoreSession; + +public class ExampleNew { + public static void main(String[] args) throws Exception { + testScanTable("hugegraph", "g+v"); // why should with "g+"? + } + + private static void testScanTable(String graph, String table) { + /* + * Valid table is: + * g+v + * g+oe + * g+ie + * g+olap + * g+task + * g+index + * g+server + */ + HgStoreClient storeClient = HgStoreClient.create( + PDConfig.of("127.0.0.1:8686").setEnableCache(false)); + String storeTemplate = "%s/g"; + String store = String.format(storeTemplate, graph); + HgStoreSession session = storeClient.openSession(store); + + try (HgKvIterator iterators = session.scanIterator(table, + 0, 100000000, + HgKvStore.SCAN_HASHCODE, + EMPTY_BYTES)) { + int count = 0; + while (iterators.hasNext()) { + count++; + HgKvEntry next = iterators.next(); + System.out.println(new String(next.key()) + + " <====> " + + new String(next.value())); + } + System.out.println(count); + } catch (Exception e) { + e.printStackTrace(); + } + } +} From 46b81207bebd0f56799a9129bf7d5dc9778ffb43 Mon Sep 17 00:00:00 2001 From: V_Galaxy Date: Tue, 29 Aug 2023 13:16:09 +0800 Subject: [PATCH 16/26] fix: register task and server table for other BEs --- .../store/cassandra/CassandraStore.java | 3 ++ .../apache/hugegraph/StandardHugeGraph.java | 2 +- .../backend/store/BackendFeatures.java | 2 + .../backend/store/BackendStoreInfo.java | 2 +- .../backend/store/BackendStoreProvider.java | 4 ++ .../backend/tx/GraphIndexTransaction.java | 4 +- .../backend/tx/GraphTransaction.java | 12 +++++- .../hugegraph/task/ServerInfoManager.java | 7 +++- .../hugegraph/task/StandardTaskScheduler.java | 7 +++- .../org/apache/hugegraph/type/HugeType.java | 4 +- .../backend/store/hbase/HbaseStore.java | 3 ++ .../backend/store/hstore/HstoreFeatures.java | 2 + .../backend/store/mysql/MysqlStore.java | 3 ++ .../postgresql/PostgresqlStoreProvider.java | 3 ++ .../backend/store/rocksdb/RocksDBStore.java | 6 +-- .../backend/store/rocksdb/RocksDBTables.java | 42 ------------------- 16 files changed, 51 insertions(+), 55 deletions(-) diff --git a/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraStore.java b/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraStore.java index b4b1bf4351..e310969980 100644 --- a/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraStore.java +++ b/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraStore.java @@ -789,6 +789,9 @@ public CassandraSystemStore(BackendStoreProvider provider, String keyspace, Stri super(provider, keyspace, store); this.meta = new CassandraTables.Meta(); + + registerTableManager(HugeType.TASK, this.table(HugeType.VERTEX)); + registerTableManager(HugeType.SERVER, this.table(HugeType.VERTEX)); } @Override diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java index 68c08ec2f4..a27daba290 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java @@ -459,7 +459,7 @@ private void clearVertexCache() { } private boolean isHstore() { - return "hstore".equals(this.backend()); + return this.storeProvider.isHstore(); } private void initMetaManager() { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendFeatures.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendFeatures.java index dc32653d74..53ca20bfb5 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendFeatures.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendFeatures.java @@ -31,6 +31,8 @@ default boolean supportsSnapshot() { return false; } + default boolean supportsTaskAndServerVertex() { return false; } + boolean supportsScanToken(); boolean supportsScanKeyPrefix(); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreInfo.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreInfo.java index 24de32215e..b6b09d2a9f 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreInfo.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreInfo.java @@ -41,7 +41,7 @@ public boolean exists() { } public boolean checkVersion() { - if ("hstore".equals(this.storeProvider.type())) { // skip for hstore now + if (this.storeProvider.isHstore()) { // skip for hstore now return true; } String driverVersion = this.storeProvider.driverVersion(); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreProvider.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreProvider.java index a5e80510ed..0117e0bc74 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreProvider.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreProvider.java @@ -73,4 +73,8 @@ public interface BackendStoreProvider { void onCloneConfig(HugeConfig config, String newGraph); void onDeleteConfig(HugeConfig config); + + default boolean isHstore() { + return "hstore".equals(type()); + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphIndexTransaction.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphIndexTransaction.java index 4362a69867..1ff4a9bb34 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphIndexTransaction.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphIndexTransaction.java @@ -1748,7 +1748,9 @@ protected long removeIndexLeft(ConditionQuery query, HugeElement element) { if (element.type() != HugeType.VERTEX && element.type() != HugeType.EDGE_OUT && - element.type() != HugeType.EDGE_IN) { + element.type() != HugeType.EDGE_IN && + element.type() != HugeType.TASK && + element.type() != HugeType.SERVER) { throw new HugeException("Only accept element of type VERTEX " + "and EDGE to remove left index, " + "but got: '%s'", element.type()); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java index dc52a2e05e..7b5289237b 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java @@ -739,8 +739,12 @@ public Iterator queryTaskInfos(Query query) { } public Iterator queryTaskInfos(Object... vertexIds) { + if (this.graph().backendStoreFeatures().supportsTaskAndServerVertex()) { + return this.queryVerticesByIds(vertexIds, false, false, + HugeType.TASK); + } return this.queryVerticesByIds(vertexIds, false, false, - HugeType.TASK); + HugeType.VERTEX); } public Iterator queryServerInfos(Query query) { @@ -748,8 +752,12 @@ public Iterator queryServerInfos(Query query) { } public Iterator queryServerInfos(Object... vertexIds) { + if (this.graph().backendStoreFeatures().supportsTaskAndServerVertex()) { + return this.queryVerticesByIds(vertexIds, false, false, + HugeType.SERVER); + } return this.queryVerticesByIds(vertexIds, false, false, - HugeType.SERVER); + HugeType.VERTEX); } protected Iterator queryVerticesByIds(Object[] vertexIds, diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/ServerInfoManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/ServerInfoManager.java index 7a49bc32bc..b33dc0f45b 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/ServerInfoManager.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/ServerInfoManager.java @@ -382,7 +382,12 @@ protected Iterator serverInfos(long limit, String page) { private Iterator serverInfos(Map conditions, long limit, String page) { return this.call(() -> { - ConditionQuery query = new ConditionQuery(HugeType.SERVER); + ConditionQuery query; + if (this.graph.backendStoreFeatures().supportsTaskAndServerVertex()) { + query = new ConditionQuery(HugeType.SERVER); + } else { + query = new ConditionQuery(HugeType.VERTEX); + } if (page != null) { query.page(page); } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/StandardTaskScheduler.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/StandardTaskScheduler.java index 41f7aa01ea..50d0a13c7d 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/StandardTaskScheduler.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/StandardTaskScheduler.java @@ -666,7 +666,12 @@ private Iterator> queryTask(String key, Object value, private Iterator> queryTask(Map conditions, long limit, String page) { return this.call(() -> { - ConditionQuery query = new ConditionQuery(HugeType.TASK); + ConditionQuery query; + if (this.graph.backendStoreFeatures().supportsTaskAndServerVertex()) { + query = new ConditionQuery(HugeType.TASK); + } else { + query = new ConditionQuery(HugeType.VERTEX); + } if (page != null) { query.page(page); } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java index 75883747bc..87a10a65d3 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java @@ -65,8 +65,8 @@ public enum HugeType implements SerialEnum { SHARD_INDEX(175, "HI"), UNIQUE_INDEX(178, "UI"), - TASK(180, "T"), - SERVER(181, "SR"), + TASK(180, "TASK"), + SERVER(181, "SERVER"), // System schema SYS_SCHEMA(250, "SS"), diff --git a/hugegraph-server/hugegraph-hbase/src/main/java/org/apache/hugegraph/backend/store/hbase/HbaseStore.java b/hugegraph-server/hugegraph-hbase/src/main/java/org/apache/hugegraph/backend/store/hbase/HbaseStore.java index 4ec7f7db7f..bb856a88e3 100644 --- a/hugegraph-server/hugegraph-hbase/src/main/java/org/apache/hugegraph/backend/store/hbase/HbaseStore.java +++ b/hugegraph-server/hugegraph-hbase/src/main/java/org/apache/hugegraph/backend/store/hbase/HbaseStore.java @@ -564,6 +564,9 @@ public HbaseSystemStore(HugeConfig config, BackendStoreProvider provider, super(config, provider, namespace, store); this.meta = new HbaseTables.Meta(); + + registerTableManager(HugeType.TASK, this.table(HugeType.VERTEX)); + registerTableManager(HugeType.SERVER, this.table(HugeType.VERTEX)); } @Override diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreFeatures.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreFeatures.java index 3e6c03e0c1..3af6f803bc 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreFeatures.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/HstoreFeatures.java @@ -128,4 +128,6 @@ public boolean supportsOlapProperties() { return true; } + @Override + public boolean supportsTaskAndServerVertex() { return true; } } diff --git a/hugegraph-server/hugegraph-mysql/src/main/java/org/apache/hugegraph/backend/store/mysql/MysqlStore.java b/hugegraph-server/hugegraph-mysql/src/main/java/org/apache/hugegraph/backend/store/mysql/MysqlStore.java index bb99cdbd58..fd3a7584e0 100644 --- a/hugegraph-server/hugegraph-mysql/src/main/java/org/apache/hugegraph/backend/store/mysql/MysqlStore.java +++ b/hugegraph-server/hugegraph-mysql/src/main/java/org/apache/hugegraph/backend/store/mysql/MysqlStore.java @@ -486,6 +486,9 @@ public MysqlSystemStore(BackendStoreProvider provider, super(provider, database, store); this.meta = new MysqlTables.Meta(); + + registerTableManager(HugeType.TASK, this.table(HugeType.VERTEX)); + registerTableManager(HugeType.SERVER, this.table(HugeType.VERTEX)); } @Override diff --git a/hugegraph-server/hugegraph-postgresql/src/main/java/org/apache/hugegraph/backend/store/postgresql/PostgresqlStoreProvider.java b/hugegraph-server/hugegraph-postgresql/src/main/java/org/apache/hugegraph/backend/store/postgresql/PostgresqlStoreProvider.java index 2431779a28..f96d57ad3b 100644 --- a/hugegraph-server/hugegraph-postgresql/src/main/java/org/apache/hugegraph/backend/store/postgresql/PostgresqlStoreProvider.java +++ b/hugegraph-server/hugegraph-postgresql/src/main/java/org/apache/hugegraph/backend/store/postgresql/PostgresqlStoreProvider.java @@ -192,6 +192,9 @@ public PostgresqlSystemStore(BackendStoreProvider provider, super(provider, database, store); this.meta = new PostgresqlTables.Meta(); + + registerTableManager(HugeType.TASK, this.table(HugeType.VERTEX)); + registerTableManager(HugeType.SERVER, this.table(HugeType.VERTEX)); } @Override diff --git a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java index 9cf3ba97e7..d20f8ac2a6 100644 --- a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java +++ b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java @@ -1122,10 +1122,8 @@ public RocksDBSystemStore(BackendStoreProvider provider, this.meta = new RocksDBTables.Meta(database); - registerTableManager(HugeType.TASK, - new RocksDBTables.TaskInfo(database)); - registerTableManager(HugeType.SERVER, - new RocksDBTables.ServerInfo(database)); + registerTableManager(HugeType.TASK, this.table(HugeType.VERTEX)); + registerTableManager(HugeType.SERVER, this.table(HugeType.VERTEX)); } @Override diff --git a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTables.java b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTables.java index b1724cb5f3..06c2d91a1a 100644 --- a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTables.java +++ b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTables.java @@ -188,48 +188,6 @@ protected BackendColumnIterator queryByIds(RocksDBSessions.Session session, } } - public static class TaskInfo extends RocksDBTable { - - public static final String TABLE = HugeType.TASK.string(); - - public TaskInfo(String database) { - super(database, TABLE); - } - - @Override - protected BackendColumnIterator queryById(RocksDBSessions.Session session, Id id) { - return this.getById(session, id); - } - - @Override - protected BackendColumnIterator queryByIds(RocksDBSessions.Session session, - Collection ids) { - // TODO: use getByIds() after batch version multi-get is ready - return super.queryByIds(session, ids); - } - } - - public static class ServerInfo extends RocksDBTable { - - public static final String TABLE = HugeType.SERVER.string(); - - public ServerInfo(String database) { - super(database, TABLE); - } - - @Override - protected BackendColumnIterator queryById(RocksDBSessions.Session session, Id id) { - return this.getById(session, id); - } - - @Override - protected BackendColumnIterator queryByIds(RocksDBSessions.Session session, - Collection ids) { - // TODO: use getByIds() after batch version multi-get is ready - return super.queryByIds(session, ids); - } - } - public static class Edge extends RocksDBTable { public static final String TABLE_SUFFIX = HugeType.EDGE.string(); From a40e808164643bcb6c54c3579da6f2d376978e58 Mon Sep 17 00:00:00 2001 From: heiyan Date: Sat, 2 Sep 2023 22:21:19 +0800 Subject: [PATCH 17/26] build: remove system dependency to hugegraph-core in hg-store-core --- .../backend/query/ConditionQuery.java | 12 + .../serializer/AbstractSerializer.java | 9 + .../backend/serializer/BinarySerializer.java | 40 ++ .../backend/serializer/BytesBuffer.java | 4 + .../backend/serializer/GraphSerializer.java | 3 + .../backend/serializer/TextSerializer.java | 10 + .../apache/hugegraph/schema/EdgeLabel.java | 6 + .../apache/hugegraph/structure/HugeEdge.java | 65 +++ .../hugegraph/type/define/EdgeLabelType.java | 70 +++ hugegraph-store/hg-store-core/pom.xml | 13 +- .../business/AbstractSelectIterator.java | 2 +- .../assembly/ext-lib/hugegraph-core-1.5.0.jar | Bin 1530741 -> 0 bytes .../assembly/ext-lib/hugegraph-core-1.5.0.pom | 441 ------------------ hugegraph-store/hg-store-node/pom.xml | 11 - hugegraph-store/hg-store-test/pom.xml | 10 - 15 files changed, 224 insertions(+), 472 deletions(-) create mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/EdgeLabelType.java delete mode 100644 hugegraph-store/hg-store-dist/src/assembly/ext-lib/hugegraph-core-1.5.0.jar delete mode 100644 hugegraph-store/hg-store-dist/src/assembly/ext-lib/hugegraph-core-1.5.0.pom diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java index 7fe6b33442..afb132758c 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java @@ -687,6 +687,18 @@ public static String concatValues(Object value) { } } + public static ConditionQuery fromBytes(byte[] bytes) { + Gson gson = new GsonBuilder() + .registerTypeAdapter(Condition.class, new QueryAdapter()) + .registerTypeAdapter(Id.class, new QueryIdAdapter()) + .setDateFormat("yyyy-MM-dd HH:mm:ss.SSS") + .create(); + String cqs = new String(bytes, StandardCharsets.UTF_8); + ConditionQuery conditionQuery = gson.fromJson(cqs, ConditionQuery.class); + + return conditionQuery; + } + private static boolean needConvertNumber(Object value) { // Numeric or date values should be converted to number from string return NumericUtil.isNumber(value) || value instanceof Date; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/AbstractSerializer.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/AbstractSerializer.java index 6be90d894c..c3c9d3e232 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/AbstractSerializer.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/AbstractSerializer.java @@ -17,14 +17,19 @@ package org.apache.hugegraph.backend.serializer; +import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.backend.BackendException; +import org.apache.hugegraph.backend.id.EdgeId; import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.query.ConditionQuery; import org.apache.hugegraph.backend.query.IdQuery; import org.apache.hugegraph.backend.query.Query; import org.apache.hugegraph.backend.store.BackendEntry; +import org.apache.hugegraph.iterator.CIter; +import org.apache.hugegraph.structure.HugeVertex; import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.config.HugeConfig; +import org.apache.tinkerpop.gremlin.structure.Edge; public abstract class AbstractSerializer implements GraphSerializer, SchemaSerializer { @@ -89,4 +94,8 @@ public Query writeQuery(Query query) { return query; } + + public CIter readEdges(HugeGraph graph, BackendEntry bytesEntry) { + throw new RuntimeException("Method not implemented error."); + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BinarySerializer.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BinarySerializer.java index 92809e823c..c33168b009 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BinarySerializer.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BinarySerializer.java @@ -17,6 +17,8 @@ package org.apache.hugegraph.backend.serializer; +import static org.apache.hugegraph.schema.SchemaElement.UNDEF; + import java.util.Arrays; import java.util.Collection; import java.util.Iterator; @@ -33,7 +35,10 @@ import org.apache.hugegraph.backend.page.PageState; import org.apache.hugegraph.backend.store.BackendEntry; import org.apache.hugegraph.backend.store.BackendEntry.BackendColumn; +import org.apache.hugegraph.iterator.CIter; +import org.apache.hugegraph.iterator.MapperIterator; import org.apache.hugegraph.type.HugeType; +import org.apache.hugegraph.type.define.EdgeLabelType; import org.apache.hugegraph.util.*; import org.apache.hugegraph.backend.query.Condition; import org.apache.hugegraph.backend.query.Condition.RangeConditions; @@ -68,6 +73,7 @@ import org.apache.hugegraph.type.define.WriteType; import org.apache.hugegraph.util.JsonUtil; import org.apache.hugegraph.util.StringEncoding; +import org.apache.tinkerpop.gremlin.structure.Edge; public class BinarySerializer extends AbstractSerializer { @@ -523,6 +529,40 @@ public HugeEdge readEdge(HugeGraph graph, BackendEntry bytesEntry) { return edges.iterator().next(); } + @Override + public CIter readEdges(HugeGraph graph, BackendEntry bytesEntry) { + + BinaryBackendEntry entry = this.convertEntry(bytesEntry); + + // Parse id + Id id = entry.id().origin(); + Id vid = id.edge() ? ((EdgeId) id).ownerVertexId() : id; + HugeVertex vertex = new HugeVertex(graph, vid, VertexLabel.NONE); + + // Parse all properties and edges of a Vertex + Iterator iterator = entry.columns().iterator(); + for (int index = 0; iterator.hasNext(); index++) { + BackendColumn col = iterator.next(); + if (entry.type().isEdge()) { + // NOTE: the entry id type is vertex even if entry type is edge + // Parse vertex edges + this.parseColumn(col, vertex); + } else { + assert entry.type().isVertex(); + // Parse vertex properties + assert entry.columnsSize() >= 1 : entry.columnsSize(); + if (index == 0) { + this.parseVertex(col.value, vertex); + } else { + this.parseVertexOlap(col.value, vertex); + } + } + } + // convert to CIter + return new MapperIterator<>(vertex.getEdges().iterator(), + (edge) -> edge); + } + @Override public BackendEntry writeIndex(HugeIndex index) { BinaryBackendEntry entry; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BytesBuffer.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BytesBuffer.java index da66cc4f3e..38250b43fe 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BytesBuffer.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BytesBuffer.java @@ -597,6 +597,10 @@ public void writeProperty(DataType dataType, Object value) { } } + public static byte getType(int value) { + return (byte) (value & 0x3f); + } + public Object readProperty(DataType dataType) { switch (dataType) { case BOOLEAN: diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/GraphSerializer.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/GraphSerializer.java index c67b597486..052c3e1196 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/GraphSerializer.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/GraphSerializer.java @@ -22,12 +22,14 @@ import org.apache.hugegraph.backend.query.ConditionQuery; import org.apache.hugegraph.backend.query.Query; import org.apache.hugegraph.backend.store.BackendEntry; +import org.apache.hugegraph.iterator.CIter; import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.structure.HugeEdge; import org.apache.hugegraph.structure.HugeEdgeProperty; import org.apache.hugegraph.structure.HugeIndex; import org.apache.hugegraph.structure.HugeVertex; import org.apache.hugegraph.structure.HugeVertexProperty; +import org.apache.tinkerpop.gremlin.structure.Edge; public interface GraphSerializer { @@ -44,6 +46,7 @@ public interface GraphSerializer { BackendEntry writeEdgeProperty(HugeEdgeProperty prop); HugeEdge readEdge(HugeGraph graph, BackendEntry entry); + CIter readEdges(HugeGraph graph, BackendEntry bytesEntry); BackendEntry writeIndex(HugeIndex index); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/TextSerializer.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/TextSerializer.java index 26efef6e2b..7a11d18e2f 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/TextSerializer.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/TextSerializer.java @@ -30,6 +30,7 @@ import org.apache.hugegraph.config.HugeConfig; import org.apache.commons.lang.NotImplementedException; +import org.apache.hugegraph.iterator.CIter; import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.util.JsonUtil; import org.apache.hugegraph.backend.id.EdgeId; @@ -66,6 +67,8 @@ import org.apache.hugegraph.type.define.SchemaStatus; import org.apache.hugegraph.type.define.WriteType; import org.apache.hugegraph.util.E; +import org.apache.tinkerpop.gremlin.structure.Edge; + import com.google.common.collect.ImmutableMap; public class TextSerializer extends AbstractSerializer { @@ -352,6 +355,13 @@ public HugeEdge readEdge(HugeGraph graph, BackendEntry backendEntry) { throw new NotImplementedException("Unsupported readEdge()"); } + @Override + public CIter readEdges(HugeGraph graph, BackendEntry bytesEntry) { + E.checkNotNull(graph, "serializer graph"); + // TODO: implement + throw new NotImplementedException("Unsupported readEdges()"); + } + @Override public BackendEntry writeIndex(HugeIndex index) { TextBackendEntry entry = newBackendEntry(index.type(), index.id()); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/EdgeLabel.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/EdgeLabel.java index d6bd642f6e..d027dd2f58 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/EdgeLabel.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/EdgeLabel.java @@ -32,6 +32,7 @@ import org.apache.hugegraph.schema.builder.SchemaBuilder; import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.type.HugeType; +import org.apache.hugegraph.type.define.EdgeLabelType; import org.apache.hugegraph.type.define.Frequency; import org.apache.hugegraph.type.define.SchemaStatus; import org.apache.hugegraph.util.E; @@ -45,6 +46,7 @@ public class EdgeLabel extends SchemaLabel { private Id targetLabel = NONE_ID; private Frequency frequency; private List sortKeys; + private EdgeLabelType edgeLabelType; public EdgeLabel(final HugeGraph graph, Id id, String name) { super(graph, id, name); @@ -61,6 +63,10 @@ public Frequency frequency() { return this.frequency; } + public void edgeLabelType(EdgeLabelType type) { + this.edgeLabelType = type; + } + public void frequency(Frequency frequency) { this.frequency = frequency; } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeEdge.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeEdge.java index d08c4c21a3..275a8c54fa 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeEdge.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeEdge.java @@ -540,4 +540,69 @@ public static HugeEdge constructEdge(HugeVertex ownerVertex, return edge; } + + public static HugeEdge constructEdgeWithoutLabel(HugeVertex ownerVertex, + boolean isOutEdge, + String sortValues, + Id otherVertexId) { + HugeGraph graph = ownerVertex.graph(); + HugeVertex otherVertex = new HugeVertex(graph, otherVertexId, + VertexLabel.NONE); + ownerVertex.propNotLoaded(); + otherVertex.propNotLoaded(); + + HugeEdge edge = new HugeEdge(graph, null, EdgeLabel.NONE); + edge.name(sortValues); + edge.vertices(isOutEdge, ownerVertex, otherVertex); + edge.assignId(); + + if (isOutEdge) { + ownerVertex.addOutEdge(edge); + otherVertex.addInEdge(edge.switchOwner()); + } else { + ownerVertex.addInEdge(edge); + otherVertex.addOutEdge(edge.switchOwner()); + } + + return edge; + } + + public static HugeEdge constructEdgeWithoutGraph(HugeVertex ownerVertex, + boolean isOutEdge, + EdgeLabel edgeLabel, + String sortValues, + Id otherVertexId) { + Id ownerLabelId = edgeLabel.sourceLabel(); + Id otherLabelId = edgeLabel.targetLabel(); + VertexLabel srcLabel = new VertexLabel(null, ownerLabelId, "UNDEF"); + VertexLabel tgtLabel = new VertexLabel(null, otherLabelId, "UNDEF"); + + VertexLabel otherVertexLabel; + if (isOutEdge) { + ownerVertex.correctVertexLabel(srcLabel); + otherVertexLabel = tgtLabel; + } else { + ownerVertex.correctVertexLabel(tgtLabel); + otherVertexLabel = srcLabel; + } + HugeVertex otherVertex = new HugeVertex(null, otherVertexId, + otherVertexLabel); + ownerVertex.propNotLoaded(); + otherVertex.propNotLoaded(); + + HugeEdge edge = new HugeEdge(null, null, edgeLabel); + edge.name(sortValues); + edge.vertices(isOutEdge, ownerVertex, otherVertex); + edge.assignId(); + + if (isOutEdge) { + ownerVertex.addOutEdge(edge); + otherVertex.addInEdge(edge.switchOwner()); + } else { + ownerVertex.addInEdge(edge); + otherVertex.addOutEdge(edge.switchOwner()); + } + + return edge; + } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/EdgeLabelType.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/EdgeLabelType.java new file mode 100644 index 0000000000..912ed43d55 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/EdgeLabelType.java @@ -0,0 +1,70 @@ +/* + * 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.hugegraph.type.define; + +public enum EdgeLabelType implements SerialEnum { + + + NORMAL(1, "NORMAL"), + + PARENT(2, "PARENT"), + + SUB(3, "SUB"), + + GENERAL(4, "GENERAL"), + ; + + static { + SerialEnum.register(EdgeLabelType.class); + } + + private final byte code; + private final String name; + + EdgeLabelType(int code, String name) { + assert code < 256; + this.code = (byte) code; + this.name = name; + } + + @Override + public byte code() { + return this.code; + } + + public String string() { + return this.name; + } + + public boolean normal() { + return this == NORMAL; + } + + public boolean parent() { + return this == PARENT; + } + + public boolean sub() { + return this == SUB; + } + + public boolean general() { + return this == GENERAL; + } + +} diff --git a/hugegraph-store/hg-store-core/pom.xml b/hugegraph-store/hg-store-core/pom.xml index e8232672b2..4c3ae2269b 100644 --- a/hugegraph-store/hg-store-core/pom.xml +++ b/hugegraph-store/hg-store-core/pom.xml @@ -104,22 +104,17 @@ ${revision} compile - org.apache.hugegraph - hg-store-common + hugegraph-core ${revision} - org.apache.hugegraph - hugegraph-core - ${hugegraph.core.version} - system - - ${top.level.dir}/hg-store-dist/src/assembly/ext-lib/hugegraph-core-1.5.0.jar - + hg-store-common + ${revision} + org.apache.tinkerpop diff --git a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/business/AbstractSelectIterator.java b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/business/AbstractSelectIterator.java index eb9928aa59..6972b41266 100644 --- a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/business/AbstractSelectIterator.java +++ b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/business/AbstractSelectIterator.java @@ -48,7 +48,7 @@ public HugeElement parseEntry(BackendEntry entry, boolean isVertex) { return this.serializer.readVertex(null, entry); } else { CIter itr = - this.serializer.readEdges(null, entry, true, false); + this.serializer.readEdges(null, entry); // Iterator itr = this.serializer.readEdges( // null, entry, true, false).iterator(); diff --git a/hugegraph-store/hg-store-dist/src/assembly/ext-lib/hugegraph-core-1.5.0.jar b/hugegraph-store/hg-store-dist/src/assembly/ext-lib/hugegraph-core-1.5.0.jar deleted file mode 100644 index 72a4b205198c34d9d01f37127802bc636c55afa6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1530741 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 z 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%0DtGZB+hWCWTkr{2V8P;0CT3y8&X;UILBQUwMoL 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≻x_Kop@h3l>L~8tY+YaGzKXVO-ZFb_*M0Zcn1VwGbi7I+(jZ*(6 z3a&CJo>eQG`eLjC`oYTRfCavrV|AzS(_$m1@G%G|Keb;T8#%QI&J&kSr7l(s`4AFvvtf$~0`#`?p?ms#>2n$(a zkB(PzNtbvf7f^c`f{cFa7#f76(9^Vcm=9az(vxfim#5qpLyZn|B&cHWu1;+i6dNNEL z07pcp&UqvLPA+d*Zz&Av;Nh(BC)bi2>j6>zOz;K>KfeP{{S@zvf?w}g44iJ4OYk-R zdMzvxf!#4u|5n0Y7hZv`f5ASBasP3ZQ@+Kj5nQN=EtMaR@!R7WXChPL34t(E{{GZC z&Z$t zEW#ll@*sO`l!J7Re)hd}@}~~w*CxH8g$^PK-g#yYF<0S@oYL9aVz+dTctEasa=o;* z&9`&$Br>x2M}`=}oDxBpO_nxLzwU6Nx=Y0{z1ofDmGx#Rdw|8AioXzC=*(V7wv}|j zdlT^vs9m>LtOH&7L#epl>F-zTvemn<<)D^iYsItpJHo!k0~1(`18Q%ivzy7${|-`N zfVoiFP*)uPsl2hB4uem$r0We-Wm<%Yi3#1141edjv#<8gAQ>y>TqFbD=`VQucO{wR z?-!74o6b(MtFYaKz!Ax`&K`+1a8AWl(g+KV`WQoI4Al_~VJphtE63Yr=dOfCQK&`rozfp9UmkZJ zAr0Q0#}1OGpYtGjKh6Cuj*i}vzjFFd4QT)pK^FmF59>(Xid5afI(DUjz5de* z+9V?o*MWHFXY&}X_IGf6=C{mm9kR|_5h2M{h_mg2yz0eKQ64VsjwHi#I7wzQlDzUz zCz7y3(%n<$&swmD<)*Vx##5KmJ#loTc|V8NQ!D-u3KHiD2Fkqb*Ar(U;(oobQ|0Zt za~PHWFo}i}UJlJyhqUvkzrpbjq5TO&jQS!YX`w$tr=Cdfs)ra&PoF^0^0Y?JbX~rS zk;NwSe0ab~y@vn3NLZ%4cs{`y3g(7Mdye1?R_#Q#BEnf@()DNCmBIU zEl<^-=0|e915HxhVRGF#7uOpQFY3#TTxrWAWH^cBlJSGX?4@aWnD#FpgLi}HG7_yk zrp4Dfd9o9o_8PjO)0iAiC(eS`R&=5hgSomVSF3@O>utkX$VDvJ9mVwYBJ~bdL1~*8s(o7rol3NIUQdvWZ!=CnEqRgAs4)?f|015#c$b( z$JQDkjjCt(Sx6nhLp`Ji?{aesdsI*8r@AAj4Gy2?*|m5J7e{|ZpM1i64u(fHX($Sc zN8PMR7|LHAdO{Z&;)~$PITRU!Eo1$+ll%YQqJlldpA1*df+?(=qpzHuQrOSTWFN`; z30;JJ@5w74af0Zv38maKZdPO}gPNb6qe0Cwi#9QzU0!Yv*NoX_hqFE1&gscoc}!iR zwJ~_IJgRYAIH}VaKW9d@uLaw8{~Xr7^{jn2c7zW{AbCD3=Z7P7KXde0ZuDB(4eTG} ze1)Z)(o&w{?$E>2(P(ARS+>k!)6-Mr@dtS_@V=JaXW>1DHxsJb@R){jkGZs(`H#0# zj;A2hsQCfHY<5*8;|M539k=BcTi6z61VF8SX9L9h>d#EYOd0dX^>O79Wqr`kU zUlUfnNu)w5G0)hYGHapY<*qTyxq~-ru(bs}s#$Z_u*UH&xinmy4}wNu_;5cJz`WZ) z8MlnXlMC}){3q*jsv;lZs7zPU|U@-m20RGCCtzPg}o7m6!?&`tFgEgTW==Y3( zW~q3S7Y~s%3BGNn2n8k0=f9Y@MzJ@Wa0AGqeC$iL;<4>rk<;4|_iRyKFTy6$ZVaLd zxpb-}g~Nm?-3J6lKMiGw2~F^C(U@P*u&3=+&92GSPKzw2?siy}BnHbRE`Ib?XC8_00Q zow)jiQHroo^$Ng9X13&jU)Fh+~^+WH@4{2jZjI={6lZrF3Ga%k4peT9fY9;rk^F5YUH&gj zk^C*DZb0ZQLMIS<_9Llb5c>17C=hyP86HiJjmRN9GVlVaW#dock1o-P0bFrxYe?t_ zz7Z$ci2-C{JTdTfJd>lefIu#s8T`b+EhpJYseaPZb?MP(24L+tWcV@nbl47({4=O# zbU~Lttz5$vMZq@!UFLlogsOj=*h)l==aSM{yg^~jRhaxHgNm=#yh-f{pASJ1LFYq`C2HqG zSRw3uh@m%~580>}CYn{3dxOvdfD7M8iMkb`oAV(Nm0&+FO8wBlY4xaXppiyw4DgIb z6s=$d@(*Z|x;vy%*y)f)bLT@Ej~jG{H2hd<)K6-aR!7chutOTnT@Pt|#uoN%k;V5= zbdR{;R9|mrzpo|HISq8j|3^&ZoQ7TAq}~w0y-y7(p4t&cio0_gj6@AM z7~WW=#cI(jzBzaFijTsd42$O>9lnIUrrDrHrtJ(>{$(1u!w#b0w4DK2r+-jC#A6?s zrU8{0o0j!4j8p0W+25OVIOU@DaCGMe=8^KRMX8!m;7zn^Uk=5pe}g+)q6PMmunKf& z&Y|7dh<+@9{JG=DA1u|!kJm3XzNewqXjC8jazmW1FaN|%NsDGZmRKRc0KYrNnDaLJ zWzyxuk$4T#brUf9A#LjRVOzA<7KUjM#O=_xrECkbvjcaQar)mQ`3d~7&G3`?gha!n+>|hlCl#_Sp*`PSp(T`P=r|{_+w!t?}rHM$UJZDDfF+rf-<9@<{NAoJj50_^|B7ahtKPD z##B6=@j}=J07tCHEiq5jse5MX+Qot_c3(o|N6s5(z8f^k-gHv4Oeh{-GG5yRjK<+nvSh zoc?}wE?cV>R-_AVT~06&dZ`YHIH|rI!DCXgnwCj=1w7>R$~y^nbR0WC+O`iDYcDSX!F9jbbSG(*F8|B`pi$8 zJr(o2pE(sHc&>_pG-EQO&9XROm{GRNY$;%k8_62C&|-GKA6z>Hxe=l0`$G}D3HATEk=7%I8{7_=)!$Np z7hO-)g$(i%b=eCr`+Qz@4*9$Hrotn_>IZ^=egx(&En@I(q2{I7y)&n#M1LBAxeL$3 zN0DIeFv|Ub!zJ|lq};!-j(&S}r}Y@ymw$Rd z=a#v~a2|bK@T>FbYmH_mdBOBw)YsVz(SO9P@9P9a^n=hMbvS!n9QFDZWaj67#Utp3 zaC~n%%>wtNa!=CWj!6t4E!08B9>&dmqY68QOzPr=sT|KxKWFEuWwy78_~VoRdjF#l ze|(kw;9LY-L6!bI@D+C{{%|a8>TGqGoWzqslM?(lA0fAVozAbWJ<88j$D9Sm>1OAp zE_bbT38;ya((9wy0e`56OJHA``p|xs6R8dA02vy@5{k})~T@l5y6gW&T z9oF2_RXPkmske7H(Kw=}+N~Yv=t_R9;%M?q6-SXTD?E%OZ&q}Fje@EZmrk{y#*R@? z1aCeN6sk^SOSya)9b6A{2Un*enMJu?474SQ)_PIN!O+mIwCxQgY4W(yw_W z=k2;k&bJzMk(`~%j8uIz=R~=&H6#^p!AQk+|3e`$t-%@C3;Wv4jfj?_597ZQ^gfJM zmu)_@`~&1~z58NVZ>fd$&x7{=%@D>xJG(CmE544=}mCK1FK9@sQCP<3O1euk!H4?mw~6#fyH+ z!yNZ9M#3C_Y0!l^ZZSl{95)!c33J?-7!GqhiNzGozn@fpiYff>Q94V(!JvJV=B~aR z=tH5nL55N^?nGGD5uZ2K$tnm>N7_fN?HGJpTIq_l)H^Yd9G!f{RiQ?TDaHAXt~D^s zAds@j$GA2Taa@05lin`F_~0_kU~8&4pf;Tdhx`2vQ$U}d&KoRvtLVJYNLaBJvv>0& z?>@tK{~F0wH4GXId$#%!qz9fe#6TwO@At+P829Q996b}qjx9$A*bscU+)Irn3oUw) z?4RML-!sSp%K8^fBqOj+`|r;FpCeHmQef;1l!Z>Y0lh#uZss49LZKK~tbyw&?<9(q zTM=gc?z}+X*Z=I>tP|$|Gnhl8)3`sfwbKBrE^rl|gwQ%0&i+?ZxT~KD-Vl9!dv`sZ zHX_{9R9LK>^18Ejbnpn2R#z6t*I7esr3w4=>N;7e2MEy%F)R$axQUl_oX2@}hCk@f ztHa6@$AhbI3}Q@Iuj@|7)&CmDVZ8TEVNgOkr>{81Ddy{Gmxlkl{hS7X?jgtDC!7s( zL~mu?=07}$7R|vuFFwjw95nb(!@lBcJ7FpNei~nW9^Z{?ag~NW&N*K{+2;&8r0iFk zpDaRT8uDmup+FXGY5%9aZ;x-P$`($V(3Vn~f(44828mjrl$I7~DPYqkZ31cOKzXQW z8j_S|=*uRBq71^cFrJCQI^+15(Qh2bJ6Gq9cXWK9a~&*ieBL5HFV2V~YC;831bNB% z*4mGgb54^A)%m_ZuIESDIs5Fr_S$Q&{aAaiy;eLu+3m@;;u@Hwm5Q>%K#qti%I?TJ z+575+D9Ub=E6Pfhy_@udG?|+0!{lmnb(HuvA;T1T=A1mXoJKyy)wVBYgxW{;8HpM) zHx06g??DQjxKYy}b~N9iq->X*vP+0rkcFbcCJ0hiZ|c2_5O!5HfkDW+icvL#Y~ij0 znyzCcT|P)6=}SP;9vMl;bE^OC-HN!vi2)=v1%_hM-B7q8ZF?->7&@{aL8xqWX(>|kM<;lBkKQB^{W9dw z4{bDAI*v#aPjLSN%-~pN_+}e6T@`CNFKsz@6v*=kT+_fE_9>lT@7%rD>+zlb=Z>-a1awLfi> zMoF{sUAVp!KDEITDmmOxj#kffw&1*EG$w}5)*TbJ5lc?NIk4h?jR?Hjp1>-bP-qJl zlY|palLYLmBh)Yg@BRnUY{Gf;33Z7AKW zxZc6~5iFBzMcY@6vhUe>3J-3sr{`1-VUIQMNbf^7;`9lgD}d5^mI%a3hoStRksMJv zzq{!ATmJ?1x2WrH`F~gcC3fK*nLPrVB{NJy(7aUm zI@Zv67g2e$Qv2|k@RyBN@C==UaZR~pFHtv!RjF0@ybdy4Z5NK>gk=-<<5q3Rvnv^` zQVAb}IM_QpYA=b{FFhK#me?;f7wu^~LJXMV4CN61X$$(3iShT(!`sV<0n^vfa6?|V zeCGw}V@0239|V_CGyLf=qh(s4vBp{qTRf(#4O>c5h_%v}&DyuEMW5VOZxzC5CNW$4 zF5c=+w+B}zGmD8vTgdU21|5Id-93U?4|4~aD=kX_Jn95<3gYs1sVG@VM10hnK??sz zSYFis(HiFeC^@eGqjg-_#TFWR<7~3GI&vo2TfJc>-&-9~%FdGk(%Ap1)lk!J8FgLS z14ZxNc7|`9r78=H?wu+8Q+=a}ir2kACpxt#?QMukdmCgPY?5JB52ENtgKXLzlJk(C zkW=D?)Yw~(ZBm(y$Q!t6RiY14H|K@cUZvrC2&c`c;&3(Uq2)kYizz`)Uo?31j#%57d{b#V|NN>zV1bWYGwVx*(ZzK{1nA0i`! zV6+C4>a0SxWVx>-#T;77I$>nNH#i9W7-Yx8Fgh%(j{NC7Ml2^0c41LBA>7pvFoG?Z zg^iC)KpDWWr7{7A)NILXPc+{wmM{6+T@-DbP0#j{iS|~%?t1>nZ}0pvs;N;J!$lF= z!yt?Ar?`uvWQB_&=;D%#qSq9NcP3GzbWbfLOvc>Ue2G%Z=sCCy?^DyCYWvnyC7v;3 zQ18xS+!w2&chQR8MJpgYyT!zzQh>$ zZo-O921KKiAL@M)yT-SZQ6o5N5iyRl&=$O&`$M$d=LqU|1QX48m0^2jusU=98TefY zgIGsIJ8o}qekvX%+jaUkLO;?9OH#R}JQ^ye7Z29j&B0`VAoQB|e}pGVMLUGVb#oA+ zS=eUYe;VOcx?c+YNF28vS8wxl886#{!*M9-p_Z>++EbCLAxn(oY&{4OxY|Ppj2f&2 ztg&ESR*`HF=Av<`w`KIdMd8n2iSUJ85M`GX@pcqUMCb@kv)^OVZ+rt7$$@sY44ct) zPO!nG56;hkX^z_KzpXIu4I%vX*Bf6Fb_9}(_8K+FYMDi^r0uCl#?!0)2chP(QK5&}3H@0;*;U}Kqi`7j(H3F| zo4cKY_R?8lK*v?AVRM0wWXsbi~m4u9hrLtswL4CjPLk)Y|}c+dw?) zQKwfgPpAHd9YIuBM3Rwu0fUl>G`da?imhYj!R6GOMyd-1pSOWWXmcEKQgK~yWW z`^=N(7YN7qe`GFprW@{fhunXw$i^(4-Q)(B$(a$BfWFI=xTYyl=VY*}WitrM;XA+S9Wl^7=g zx9zuwW=$te5&pPj>WMZyP}NVrszKhxCu6vbMFe$RV3LpGl|Qf zcjXgJ3&Kz`W{JE`H85Hvv2+Cb2T;hRnMx#N+C_okb==<%no?hnrqq!#OZ)Mux-^z} z_7Tz4w{km9i=v0yH?Sr1QYr0OvfMpFB(wr1p;hA~)eB=(I~}94U?JP6sT10Wa2B~1 zUCFIAmB8Gl3$K_;x3!Zao0%)(*y!SizAk!gq3lG%#$?yW4MGW6SXL$mU^2>t9-6rmewG4vFh zcsGz_XqlrAXroJ`<1;_L#w}euzP|X%kA=#wBey)M#D|U#o+E4Lk%O4z_pqKgJa7d4 zg}7hj5d1{)vrl;4zU{ouzTrF-{T{-@8{z@iu-SoEZA0ZSOs%BSpPov8#<+stE<@)i z()M!UZ>U}p{&s`#_nO=Qo1#rR8*u4+4_PKe9Z`@ZHsLKP)jhbN##NQDZ~rI94HI`C zH(WQUda_1y+<*(7CE1Y-y21RLa|%0BzL1JnH|KOS1S7O!^p0 zdY;^GdW-nBBj;aHkS~(^FOV+s3>7xAqcDyWc>%vgsEC$c&W2n==TzM1wo~{UZ$-P7 zIL=4LoS~y*ltUYNAB!)n-AaYENmE#l!Ra3tVf_lG|H%c@d%0lR$;@BGaG$$WC9*Az zDYDt9WEySB^Rxv||-zgW33(?|Sf(+gh2R*AI!JRXvxbnaq# z-DsxlE?$oCxdWGW;p5p<-W#Z`# z*d?nbz_oAA)s&}q_< z9dDCi%L(+Cp6d`AOoesupQTdxyG8iMM(jd^RAR%$IPs?z^6W?kA;K=~sT4k`6yBHo z&XUbOL+6$Rwhm{0XX!FL(;=K;XAkH+t$Y$$gTGwYWq20%8aj5?%Z(i*naREZ)YzIQ zN=9|f`#%P<*gzaJcO21L#y6OZR$-?_IBXsF+5R)ALHRrpH{EYIbfzAAh&WJwi}9JT zmtR{RCpY6kd>4=fZu5j>KJN%$(+Yx5fPhLAR%QI z-n0l|M2f0)y7!{jW58)|We6lEt{;7h%ZU&4vFq{g6J&Nhj1J*rri=Vj!g@oPDzb&! z{cS?Kzdn-OFJ0*_7lDfaEA1{U9jPRIW~GLIcalrphxAA$f)erbC*dLFKL+2?S<2mVg3%&P2CB7tT_Q&ve3wNfo z2+vWL`v3-2a{2k31p9tiHopfI@|{-I%v4_ zFcDZ!5vtVbGEBB$OEOAJP=ElLYEUyEb%*dHy)DEJzW`cgirw8)C)n`fr;hsS(}jDk zLBRvK6eW*f8Ttwn%2I=6sL$LUEFz7o-uihj|l}kkcR52D5euOF-aoi#FOO zg<7diCTsh&$qi|WHaSupZIkP-R=KA$@$+FjSSux3eRNTs)BdYQglovH@}i9$1_b1 zZ>an{@fG56cV$*d=Mh8a>vT8%^_h%3hECKh49@_Xl-%9`^5WyfxJ6kOn^rsL(B=4p z(G1zRE=WWoZaB@9MK{R|)^1W=R>SXNj1*3Ug==M-4;{B~ll< zKNI`9KWmrVpULb{6D&oGaMIA}iefp-1Px*qX29Q)1gQ&hmtn!=kdF=f#BA)vQSvf+ z@1O4`#4)7-(|0t>5F$DrA+)?RNiqwq5YFd}CpMvfLT!(@UuEJs`rovL)(+J$2b`nE zqj>%ka_PMh37-UYoS(qhTcIkSE58eKZU1e-)!->z?V$!#DIcn(`w-N{qQd&PBiItd z`uJu&ajyugFGJ@qNIeToYX6FhuO!F#IrdhV#<|RPiV*P zN|;E^lCRMUTnHv9>iLqqo=d3i+lm=dubG4k_=m>P1^ne_iL~&fk=pMpi6(2o-nfP( zbDzfZ@3-kVh5LB9k?9n0+6+l@{t%D5Dp-y;;idQA_<4DFx{=@6-$(BAvs61#WM3;X z{k@La-O+Si=kV-rtSNleI9$VzHAU7@nfrn1q(t=b^&vSy%rJ%b8L6u`^qBZ6p5tXv zxuqov4^JDzj~QvX2}J(aiIV(7CDcc&EtD;{g^?%oOPOZqyqgHZ+)t}T z<)_tFbT}|k;iEOZZ5LN|O%7js1v3qdo9xNGuc2HJ%I4^%9 z;=Fg`ISi3wu*Z^hBUNj);H^6KnAk;)*6b;e8tNnD&)h4}073tKlsCZNSOWymS?&xi z^&q`8dIR98L`MJJiH!bo=b($#R!DxYAij?hzg$iGiFJ~HTxuUPnfe1=EcpZFM8Af6 z0#(`{$qc`G8IpW4RZ{Kkp%mZl04k4=x|JYc8Yx1&vO1MfOws#prd9cCTSHIZ@vo zg#Fsi(w`#z>-SRnR$_UZGss?YFJx0Zos1Q9J81G)x^oOIc@I@2zbA$!^pjkB{?}3M zdB~yO10rhV&r&V&P1L#9KZzFkR_5L7Q&h&VGd*Y{-Da6Ol~ivlyJ}9fRZ~sjyT`Ht z>GaoFE8Yw*>lDVE)tg+bR!hc6wd%*}burhDH|gZHigDG!PL;du+-2F9q*mO!+ezHl zvJ3xBYITgNzAwu&%8VW#fJm57!Y=||FgrzF`C8sms}s~Mh0fSA3Ybj*R;P|jFQlbn z>61W?t+6b5Z&kO{Ze>ed&24#ar**nLSKd;OqqhH1Kq~Tk`q`Ho<tQkCRKqLhW|Qg(oC-D--MSC#*Ze&=PN2Q4%Y=fR(u8--*(Ueb%+AZ z@kn(uOE(f;A`hID<9G8}74_Rj^~G;VG!gp$9L4SzRN-0c$+h0+sXOGrWycUq!xJIPr z2#idz2L$0hnms1N&ua8kCFdbcRI|rq2`;0WJ-MWDiDnP6PM2=jd?nND!Hw^~X<4p% zjOk)8ONq@LM76*SfXJeiYW2)A3nyc#^<<)2PbO3A$t2b-9HI8)C$l$)A6y4`$DDUvxX`8 z$nlYHlQMmyqnB`fBT^<;@JVm$vJ?FyVTX+`YXR9@NwcSo%x>@6LcgJ!J>68Z2Y9Ly zcmU{BLNsb{ztl$YH*6U>H>7`@OdZhHur@ucw+Z`g6LwgF1((kaE<38X2*>t^$CJ(2 zG;(~nma6SI_MEZ>i)*tcEQgSvMXEeL}L|^Py5d;`yOu zf3P)$>pq6X7!Y5@}!z%syx84RF?-;vF=FF)6UJcc{0%d@ilDCf*Xh9 zh7)z3N0sV4tR1aI-vq7z=>dqjkq~pj%Rs!5z-znpQTC*S!?A@EuM_9ct#pr%QcOmV zNH5jmFcB?|-=%Xcj)$2Qq^y3FPO|u3mQA}|Itczafo^4?PTZtcn{C^99kC|c$&SOb zaHy(9{G}{+;HQqY5DRNM9l5ILF}2u&dDs%Q=q9vXv6V7p7^-@$#Uugv4h`Rq_M?JY zyZfA7_zE-B8n#qZa|`d-v|k&x92GNUnW{Vcog;3@&ELjsY}UZKzb_N*;OLz2l?K#+E58 z0-)8AZtA*F;crZ5=$uL95pscjTi(gumt`Y>%oOcNxqgzN^W52}-pfU^OS-i4c}U4I zxYt%I?R=8_Ql<@L_w$gU6Wx(X795}<9UwJWL2!rv9Hs) z08I1z3X`-^v>amqTuZnkjWSP5q>83GJzh#Rn53!!o~;tr(A6VgjtBR(;Y)|&a06fGiC4@@68szvnZ{yQ`u01`XFRof@JGg zDWsCi&6jYwndelAnGWLXn8=!crAi^tcgg(>=8kJO9c)n6M7@x{4ADm0B<)HgzO5h} zgi3EXDur)Or5w>7sbU{$u@Y33_iodA5)vmW7T}*9LvSMqJ7bWg39>W@0vn_yawFaR z{Ovf2v;J{T!C9{lQFGSckh8XGQ2VkmPB#CnV%>r{JtKHr5yTsrj73 zn=Yh$eYf)76`bP}x9u6T!ab3ZYMH|^k-_C3QaX2v+y-X6dgpVYK;-z>`N?ko zfL|fEs_)v|2|w39pssAVxwFsK9*ltQAVIoZIPja{cZrc_X9&84M5=OeQ_K#>jk`371 z_ZLH$Ln>=_4isMDRUUPS>rj$F%pGv!I5iBR(3`5}An58kzLlswcoe7(@i}&g8-Iio z5aZ$P`~VOtQ@T#m7t$T*0&AvT@HSkgs6Aa6_^n_cu@?=dUeLA(!B7_vLnzz8O9puM zwI{dBjK$&u#$vj`0@F_V8fwiVh@>>byfmH_W;6FYpQ+|_ETu^&k$>qulE#OHF=-iWN179Y%!Ob-vscscICt*4b0VcMDa zEpt=ZCztZ+eA5FTI_*3w*Lk(|@b7MRhVyulqoxgoD0AyygffTLOC69MDNUksy0ttE zRqRvRS!u93vI|L5V)gMSlV|FM)VfZ33-R>?FjZj28b7LCVAHO!>}3(CF_;dF5O4O? zaL{sOQ57rDsMz{50h&oDP$`ov!PeBBxgcebSn|)5!@-t`J38}3^JhtDdt%}~mckz$ z3lg_@|6YO)&BTCzQ35RyI%{M*8HD9}I5lYy@}NJL!8#{*XN}Of`EB`mwdZZzzi{#G z&wopNpun8F!t4lveylT9A-5d!&=bG$@&4?;6VnFpxgD|ZQwo5b;}rA3)>yHlM`Bu! zxkiw0{OHn~Pnw8e{u}`^8+;h%pgxXE z2^Y_5#X?daLBp-kfzzO!QgtXpWN07uEKX!MwDZfh?rf$5jm}<3`tn9J(LzdZn%%Y1 z=TKf98Hij7_ayPHtx6{o5!|1G?7Q##Vgw_|iolh7WAKy(L7lOPwvvUYLowjg?aOcF z9*F2ER@WyoNY*w!k{%YNu|ODX`?c=(Sn9lG>K)C|oiy@|vJhPs@$rOp!)F1$dZ4sc z&U2ars>J3FeEzwQeLtJ?Du*$lA9cbMm6a#tv4%n`bwD)ajFQ}T3W%CU1mo@s-~9a4 z-(Znjdo{2=_=Uh+tWF*$0+K76IUEnQ%|ew5;w-hUIlAzs?ycZ{-16Q6fi{kj6$ z9I^!|$<%KGLhjuz&zY4h^@W9kZ+X@50S%)s$TuAYf}V0WZ>J+lR_z-w1K1VjK%QEZ^+9XA@Q zV+zw=(UXgcz@T$yY|vE`tgv3 zDzYZC(attkMtIakm!Z@E#?$AIfdt4bd8|KXKfLDe&{oeypa9ptR1HoT@N$wg`&Cl3 zw+D_=F2Fvej5D!r*KfXWrybo&eJ=cdE> z?8vdPn1EUy4q8nh^VAxh=@4@IFt$06V!o{~c4qcrFqW7kE@u2Ck>x!YNirgjreTk* zS#NcUcU@+wfwk4SbVJxtW{A9`snQ1e`P=yzD$PG1qN}@0@XM(y?3>;) zRK7IR8wz}VhV&-1@ExCRC%$z1{Y~%VDGj-&l-W-I+Fv^7mI2gSYdw-(=C3{uQDNm2 zko%_qUirC$uos@m>`Vf|_Ugpn zuFI~=bl%A5yGpaWle^@-T+mp$uhp`o7d*`up6hUcNRh-)ewZeYhi)(p59LIW3BO7L zGY2xowgacJFivuj_FWYoJ`7vx+c|00un&|pa$XK)8g91v^MA962F2kyCJ9NUw+g@$^6>2xMmL?^Prcu^w7 zD@5G&vHQ=6zfI4;ImRS^e)cuo@+<7U3zDf?yTa{Ws4bz<~Cw)6>S`{98wPB3m`i$;QZUpxV;0@dT!t!5fcpNg!>(-Zv2wPlziIpvJ z@`;~)F8dear9=BGIZtkTgoU5j?AAank=w50b70|tZA6Psx{I$e=OFS6$#jDs}6fvX-5Qx3q?OAwc zMsG^{?Ge?`ox6TO=lKc_-xW;YDHk*B?Z1RjYL}K?H>=mE#o(q$7M-B^lKR~YZqmJn zOM&y!G*W~&n;D~n$k--Uwlz##(CO;cRdda4^i$E$iSrLgUHC`5h6v*&N!-Qb8_FR# z|GMxd@wO*y2r>>S>pp4?0U>4a=0?Hlj21YPLK9t(U}G@EeAc4?4f4E~_=Pomiu{4A z)&nnRXa)%-S^9_n+y%fCkd1`#9urh$(%8wL+2W}0;MxiW1RYJ=U*^troxtKIeEP+K za(&z4qxAv=b*y5WJ#ph==kose-M?_5KR4UCv9$95k)`*csHMk8+t9-91#YM`{Q$IH zFrji;e$Dbz)UvIzjayiUKrF1Vb?5NO&1)GR=J+k~bR_=aE1_D}=oj2Rf7Ya_Q$G!% z@V5SkylhD?ec!Ft%F(mMOYdV!p%%*MXPm1BV{uiv?m^Rw7TwIX)-IQOwQn)?r?OAa6ffo;Nh6A!Fwz@bm+OTwWjH!N0jME$nZ5Z&MbC=w}Z()yJc*tJn|Q{lGr1yMh?1&Sd=@X(Lk@BSRt63wN_QQ8!cw&5Ft`DeQi*T zqSI*T>&M;CPY`cqQIw3?jalY=50ejz{2@v2ZR@%UH^~u}lLPMP#N9yQ$lXnHICjd> z>%W8-l^#yKo0p7sE;zdmx3rnkf|rT|OC*Xvg6>-t^?nJKhr=^7THUokUkFm$_kpZ$ zO#kRRIjsZxnZ+3xy0U(^*=_(9OC7)k6K!l46k6pHSCmm}`C{O1$aeFSBT0YhW*PFn zQ0*fDdU!hw(pY|k2n_(vXcL^6;18wEFyrm~y*fqcbY2AEUgyr8_z2(?HrhC_)>6m= zH;Pewu1t>++zwhfWC`}i7Ogni!^$Y@WK3`^@r+wQ>;VJcx6^k=q$eA&?InBaWu>if z>KZA@bA^V`s6=pM^(?Zv2{}9&BB5jO9(5C_&-~=8Ns}&m;^TSPM&FZ1&N;+e2ix+X zf@!2%3cKqiFN%)}GO#G)db1%h72cEwJVwx;! zfq9>H^;n;6v|%UxhXB9VMyM2ozEUti=zg|Xwoa?-xOZDd#qQ|!m4^cvoc>^a`tC33 z3x-WO66DOxOrv*3HV%Up-Neizu`G^V9suBb|NGqfM#{eX_Y>%s6OoHY@d;b$ zlo)>Y^TsnEetLjW0V6QC)bT^$0{{CR>)xY}f{PFPkB%mZ$1==Did~>F0Zw|7nDH$YE4vr1I${r!{av)e)$z@Vvdi1((##@GVhoEvDL$S zs^afPx>vbok@Ct{I=zsiP;Er-Ktm-yxTMDCcKO}Cs{#?D+MJTXr)ecnzb-f;muCFI z=1rhv{JRrg+y<$Jn}HsE#6%@dp9jZ-o5`uisb_cIk($DYe}F)JpKHjYFTR1OX38i?IoLP z#QQZ}@(OrQ1M1eW3JEy|GCud80g6kURo@$do6dJtuT-h2b+uG8LOhBA-WmC)?*yi= zzN;?@BR!2A{v$notQ(kzGlj2O2ll&@e~d^qa!5ARr)G zpdiX};1F;iFfcG6cik{rh@koISdbtfPp}{$4Brnpx>zz9I~ki=nKN0rTbf(C7&}=p zxp_O8Gf96p)s0Q;%+e#7FJqYe>kD8Qs`kVHZ{R>k1AnV8VL;P+PS`lb zWm0u&<8$lG*87F+PV2Fd5U3NB(UNF?6FyrTsj2X=23Kd~{XSk#`*cF9dFQ?)!`9)? z<+$gc)Hm(0lg=`tA_*bh(^+snm>WBGsv>|83`+*c07xz#U%5VKNb6}v>JzQsyLOtA z({b^4;MXe!@SM+ibz-0rxUJ@Xy+4$sD9PsNP{V7TmKERPauTI8Kh;^RDecM9@35~9 zMr!zb zGRsD4RbCzNPYW|GPi{Rf2aDL#a=EEcDD)DWLDG1+34d3CY*J8hss{9DA3Afy_d9Z`m|V4 zP2OYGeUCso#K@vU_KlDh2qT6pD40br+7c*$a_%@bS}2ym*$38|-Zy1Pdp=v& zDLLBdy_{Gj4ZrZe`YwjQkT=zVxR?St6;V(c4{(g)`ozaMCK4JiJilMUE4dlHy0dBD zc(z|$b}3{1qJ7HuAPlu`dAgNZV!6yW)NU!R*e=%eeZsE@F;e;(n|m;fNpq(%^!^g( z{Sm#u>f8mPY=(VgH$GAVWUfqjVKc4C|&%Xb{%B5^qo{VuWlF+nc zvp$3`oig3PLh#h-Ifah7a2Wy{(7Ar{YmuuY7noP-*)g1@6eYAiQhP$|({wXNu{LO#aKQLRCy`4TgDOfW{yJg+<{O(; z=EP4rh=P&@tj&CoV$qxvk_l*EtdZ%)O;H z8hNg>>I;sb9iXK^&pvUn`o(l;EDopd8s1-iW!3sk&7++K`~Z*eD*lxRT5?tRXHn(s zG6kptR~4apjNF<`#4`e^LNJ{>EG{t|nutOgfV>K?>OTJ4taAv5kd%k$jQkhTusVgY zkV;{|y*+-u!eVLIwg8z<*+%;u3f20JBUEqq|xQ@s(b+&k3p^*^`Ts%7@P|QzZR%qXDAsmwof>h`ApY zW1*U73!quAq3S6fv@;}c+m+xv1j7OyM*XPOb4VYud=IglC!U3Y^UT%hPq-d)Aa2Q8 zTOP>d?qLEWSqRXkfkkn6st#}FCn3Y1p#Krv|0=8hS8#8>1$REv5V`$ZXrI1s+W%H? zm0cX2EUf>dxc^IS?c-P+`h_vXk3&QIXwa^HlUlz}KvGkvlFNzT!FFE)9z)FQ(%i{w z(@3F53rMl>$OqNgvgWdTz5qrba{Q$kC8IEz_g!kl)kHA&E3JN1+x=qo4A^*@VLHYN zRK_>5+FMWOozLMzGE3B4p(^`B9Qv}&E43DS_flOx2`SYl&_<`jEvWYoxI#VEDK(7K z-2D><^4z?K=V>>7JdP!7oeZA3zrIbB`gKxJhNVpcBCW$@+)jrSl>P(Af9>}F1?2V{ zkjapH2WT)5kVx?V1`u0rS0*`bS8*3>4|5lCmj6BcB&|Cv2&065O^wN%wNNTcPZX4J zuzstHrG)53N%(PYiG60~#s|eS~MmC?q zzH6~?WeHo=|JkeKs)JYeAl6eN)+2F}+PWa$Glp)#fPELS6G@PoFqiJ-Zgo4EgfD%; zTbHveDpt$!I^?e2W}2qpy9O55I`yb-+U6;qvk0h{{qrAkI)315R(|RVdLK*XLMu^F zoxgB6emshK>%nu9pVuxprJrqLEvnvy7qK5pdPtH_ z{X{LO`Us3YqVbFw`(~QDf?V0pby6B6T@#0RuXaIS*^gwn(?5Bm$3k)JCMUT92*#2Ft%-bvb#n8554{?iT+=Dov!mxEPltCASeh3 z>HlB6**Kao$vT?+?>LL^lO6aEttw<%<8-JWzSlqgmzTUg<{t1r<- zGUDd!xxu&Y#!q^MS+}hg!seHV!A$#^>FjGn&;Oy7H9ljqo!+0_ZoJ<)>L2OWO%>`l z2G+a1`a`3ZPU}_RmB5q5EaRPPsEv*vCgJwKutz(2rhFP+pu-5bEyciKM}p+Byj8<# zl6509UtCGI1-8oR6COSOPmKO668|qoXh-Uy@ZTZG009C*`QKrr;cD*ke{hOZRdJkG z#u31lwY5Da$W{Bd$g&ERu_}cwB|XWCj`;|B@X?}QP;DzigC3YzcejT|{IE%E4s@u1 zDRe*2HW}*D2)QoYG4rx&mP=Ilxsy)&RPpd!C!v)v0a2tz1hazPy z&afd)Ec*r92}2$BjTgaOtbU0sUhymH#&t+9#70BEj<_YT}Pwn4b(<8<;8 zY+TQK?CZ&*13E!64-J>=`?WHBaI7YGy#DQEvM=*OQ^J86`bvH_cZ#ye)}Z|f!ryfJ z=-nL~N?eam%in!(xq;m)B@Taye_b!wGVdLWXJx>662O;8V=F*%oIueIV*HxTKcitG zn_gn!uo1osoqy5PpRzqIunIwI(eh7qisP=NC?_M3Z1r zs}m<1Kky0ci*7al5Fc(hK2y&zPmd1`eji$7V6+S-tO(*^iX z2>w?R{a920f7wlgz#`ClPfqh+s! zuYnT4$wZHzHg6&~Co5CJU>#Bowc>^TKFom1Skm)46<}d6rj`8;F6Q_vhCj4g+u^{r<24^wHXIbDfhh z(EQam^=mN+669jq13pYd(W^g;rcliM&_v;^(*zHV<@z~^8kz4H$d_^|PSJObgM0m)4b~dxEsbSfYYfj+uQk6V(7U;If z#8Y+frAj*vS)N)ciE_EwYW8Xuqd)8E4F(kCko^uWcCb44pef3<=1_Cnqp@7tOS3ua zd`bbW$|r`+xQL(ctig88k|_?4=X()aRBFcYKlBI1&)w&vn;H=JDJ6+RW`ovU zj-L6P5sq?Oi!u?M*JrgX?F0gH7a86EDr6`edRxTXq~{q>)_q%9MNYbMt}IST<6~oS zv?X&~xn1dN!nAGWHmi#!e(iJiB|lvw`iuwZAWSyohBzvawdE> z)9=fE$jGH=^}7j=Mb%Gb85hG@Ibk3PW$tO;t+t8P+l|HIyf9JeeN9G?Ff%g~X>|^s z$zcwxx*r;Ei_x(th+0iglnREYt?*8O7J-JRXRlhv3+#%*dIq!Ep_3fQwH<-z9v*0-*x3gq_cG#Vd z6{BB|bQV{uI=LwY0ENqeYaU9!SFQ4_sqtKDfg2}4gf}0U?=E3-P@YP46AQ|yv98Vg zj8wbViOXHDcvWn9^-3=V!&)o;-c-E58LdW)A-2q^K#O2Lc4Pz@hJBvXVm_6>-ZCD> zL!@(gCeX|AW=%fF)bK-8zndJ<<#_&LU()SJ#j(@_;xUmdp&;GtObgF3=?L}Ik3FJr z=7+ec(7-cU4G^d7mSF0~1c;7oan!8MX!9_GIH;6~I$W|@riG_th(*+zby791c{KlR z-UHYtp(q@`$0)OOLL;hs&R-;QCY1Dg(GJwkeV(<4lW2Jk9Dn^|JeS2}H)2_ErG{xW zH;0nMvXfgk<1LC!E8C1b$_$#2Ob2kbHB`#jXa0;$Nt_1QBcwjRZxhxj>xFh4)LCAiEG`d-x@iZ>ZgHZ z4639Xf2C&w-;}*l>%2L5fDq|{K_~C9=`w4u2huN}JmE%vJl}tY%DSTi%O)mN32Pf| z7nzgWlI2Lm$ps683`S8$!m`r(+GfJSv2Z9n7-x7oaPzP~A^)S9|5X|PU(GBHZGo_2 z0ReG$`)_8&|CzR^xtsjYB+dUBmY4isf2uDneepai94SyT!Hc2cEJyzM{p*L#BB)3j zh)7EkNXQR_F%U8t%4vC&rX`!X$|c=&#_}bs^d=8feK1tW8Z13MO#9~L8V$YX7~OT< zDv7(V-1n_c`F;q|^OfuOR`ac{>n-1{F3Z5mbZFvLF>xyVd*FlKR<42$FdxWI zF61k}b-o`_@)8LIN(T_70!I9Rrb3Wj03iR>K4A2|j8bU#7;rnI5HLTZbh{AnhI`HR zikl30yk#n$VERy>oPqsy{GmV9!}KAI`N|58ssUu2D zv~mHRg63~te>$IEz2Xy;I5b)SM>IW3hc79IYVCrl$7-)HS+u>?>OyLez@{+IP{_)j zgt{clf`qzsB8fXSyGl?&j#(wks{B|Sv&z1mD7-y2G1o^%9cy$(v?4%KHpZ`#Q*Wta zNU&Ml_80V*8Je7Vg=LmaCcr^$;_#SWt>$JS*QNxR!yr_3VA=eDWSVLdCttOtju?Qc zVryP_eqh-J6#qCQXcp-(sZ{vQ>=jbsV_q@E8l2J8oN=a4f;LmINo!nbhIFY?bJwV1 z2%r+%Q(eROp$Wk32e2*ux;rWap>dC@=-w#<+&QS(2OE^jxt41fP{zI%8X45q{*Kog zkLV^Bt3#8}BU}0=tkJaQN_kzRsJ?CGx!;)&prfy@yR!SJ4100q;|$-Xs=^`6znr7A zBdVg@!R8XT3QJ>!F;7qHug%sXo7U1YeVxS~Ua8%tW~&{^S#bMt7*{wQ{=n2Zt!?tH z)qO{leEWjwRFqj8PdoX>DxUG(5@TLVrA2^3uF~e@qEb17fx4PjSEa*K;aLTnO{VPe z@ZLG?0K@LvW8(N@%{l4$-fr4s>SM!E^PGF?!lS8(94nqJ)a%9CNym}X9}c8>wKskz z)irtBtmH)Z#FxRbe2Yl~X1Qe&H?%lgCH^uO2fJK$6T$_o6-GS`Ew(zJrH~6iycpmMUET=yKAM;-9xD|TD31RqX^5#z?y2*2rnR5QN{6yA@n&HU}rB?oj z>L1byU_hC0bo?{U)}I1~zDM$=NPp}9c^NYy4Y>B#j6L4>PZ=wl;^lhhKUCzbEurpr zHh8%iG-Xzh-=n;a($f^w2_bb$97$#u%D@QMwQ>3gQs!*p#58kXcO@52%^jGPdI2oA zN5+V(Lrl||y-P>%mt-Ga2%{Si4H=pSIGl?la7+p(P77KhgMm~fp0S-RN}x8A#0mhL>d zq6?-9x{QDiw(8R2h{K`%8ip}xvA4oMdx>U#Z0yuTGEJN& z;|S4p9^a;m&n%BCE+ik*&sbxS^_NZr2USnH&mJ}#P zK419GFlaSJ-nlrV%gj_LV?%qo06@33i*gOWVFYfQ1<6Mj)py0!vc^f9_5-!;Z9m@5 zhNaP!sR&hSqz5{r5rO3W5~n`Yc9`;ZjO$9wqD(?uTxSreKb36L-rdhPGa zD8gk*q}tWh?Aey=VMPCCD>4v_mf>;`{UUBrQKUcaiTDe^QXZ=odhQuv|L{j{g8Va4 z>9Bm;q_MC;5T)dZK!p~9DY2Q(sro#xZQ?oO;f`>P0wHlggMpsJP-~DK36mr}Tt?Vq z71hInB$8s8j~mv+NT2w0oAGRLQpASj?UtJNVFX(xi1 znpSk1<0PY*PewYHL{idQtSGk>*RlV54ovARt~JGA;&-jV(e$}U!2aQ4_srGxk`UsS z#OdML{`$}>-MXGb>oAz4Dst5{WiThUlp((>sZ@{aYelrbc@iXisDeivvg8C_%KjsH zg&`HvFvD7Lei8d?&9(9?o(vhLHO%)kr}7HD%x9Dxe4ig}ltqIe^*Vg|TkHOS9!7Ca zkl8BGw-fbuKML(?5HDVCTa@7&=+Gn>M+_rn$}^kXYWGDEU>th<5b5906L&swx+IoO&AtHrB zO_bSKmh_lzmqAi2drBBO#nZpU`_u8E7+Z^!^lEE`wCWfNImras*p@|)W^j77XYB{h zk3QAs%6Akq!a|?44x?th2d%ekH*2mXMY&5=LiqutKmwBr=pTs9_@PUom4tNX8VU27 zoT{2w2|optA*$=iv#4c;O)|Vq*x)E!;LsYpaFC%x%Z5y3v@P1q4awUDmw%5wS4O}s z67fG_l}9i!54j*`mfa)n*v3~FpnGXa zx)b184$`A0R)`qYgi3KNk$f(9MzPC?n_9ofcJ?pD;iRu|AnGv)Df69){!#9cV8NM2 z)@S>ZxhXFlv-A|VcohdWw4_IsY1N}`d~5C5R;goLP;g?Ns+CtIp}E?oNy&!c-xkJ|lbW{4;wT`i{xK@ue>omQ|lS=nb=X}a-@uG9N0t1;5zn#V_5~}U#igbk5N8- zs?hBO9kjlRg<7c0)eHF!RjyoV^r0p9GMOC1n-tNz>k7=jWIY3|SVnu<7ziwJ$C>E| zit_%b*Cv|d8V)oe5C_eSasqb(N?*?z;B%CajqmCnCi2@h#$?J*9e&T+_iN-Jm<>5kju35(5Gsl@5U2mZ z6`i)2I< zOX^3ET`cGDLH6(}SdqFp!^*Bk%Mp?t$6w{ZfYsZ7Hhng=fExwI{iMx zzIe>_0p|qwSot3>h->z^WQKhVpY6gG@|W>y9^6`vK5y$L;uVaoCRx5$jj=_Ah`LCw z!FMY)TeYZrO_N+Sfx^Ld92G+}gP7%%ZE(>9rWN;mW4fEU0Dr@#29-{0Fep&F^H&9G z6?RS4N-`8akOq8H=SVt^BIi=)O7pPTsKWGQ`F-|@3_E#HEw;P?%MN--ab8sjJKz4_ zgHy`$0}(s&V#vObAOVNWTrqBv8(Tz#LcM^yCkNYV$lZ<%U zv5z3>O%-=hsy66ADjW4v+Kail-8gNl)*;f(cb`jScIf~!K6ah)FUFNBA6ypm!kcQu>A{T$NuVsoc56Yf$kR?#FD!Xco_i8e*V!hhk2g7s^_w!JE%eNzx= zl{k6VL5hj^whyi8mJH*k>=T7L6EpKh#>o)gLB9p7K$J+Vt2V_++U;nR(#*v88_rLA z1dr-u{K*m?-JSxTjWCmj+?Era>BwrtR!&Onp~2QT!OlOWyUNb~)#ms8(w#I}($Y>^ z*m^-AphmgtRA~O*MV?v;((R0EW{v)ewD?P#Ir}_>vGm$>y3AAth{fJ}sOc%C%0rt1 zdMh5rM-WZEFEvG15^t5XW;yuQHZrAz2ys^mX%6)Q2E0lb@F$yM51rSpy2Q7moFH>x zpjov#hc;6umB^!BeiYTOlZihXuSp`hE+hZVysN{qvK)DPSX}x0cxLf8EStH{T$^?5 ze-HFCc7V=%)GC-gE-H%-4?dy5jA@h`hm*S<{3`Vfs+BHR_$1SN28dJ zZIqxq^Yr*c97A7WsIKK-s?W~n;<;;`oP5Amb3rkBCU{UzwpQyZR^!TPWf|*mY*l|X zK;TxKQjSd4p}Wi#@#wh8Jm%sdsdR0wic28uD18}ht5ay;OpcJuC_pdJ-mBVgmac63^)vYagjTy=3|DXQ2xV)>pok?1G7$NC(P(`d&d25o9;*89+(HD}>9Wdy#06;u1^mtG9rv3bpo)?jH4*&KV6@Vn3 z5V|NcdAG7{H01jVe-k~QJ6Q4&4hRscm=8Gmd>^CMcup>3-{}HO&i{EI)6xwPGEdjs zQ2NeyD<%lV|GE7ON1mpJlq&(MD*|rCfmp&Em(RhTbykssr(K{`@j=45TJ$voL;EnO z^POjxO*gxPGM{+OWgF^AlDYF7b}va#!*XOoJZMVhu)fihA6`&ww@iV$TcZi2v-lUT z6&zx)=t!jNIze38%XqdeY4OTPyCLYvg~lmOuH9Ba|g>!#wEBR~v@TWH;m)*lrXNZwD6_sSc8a``XtXutGE4CU=REg$n1Bx3& z^$#GQmXJV}z3UI3LimC&>^YP-exE?l52k@g26dVA`6w^!!U=0U0~wA73SDWf;CZcl z%9W6<$DcRN`5prHh4}1xT0h59Q9L=HLvg^^!@*~_=pSbGKYuoB;p|xn%Id>38ynDy z3YEwW@q^q?mq`*udJ_4)t0Tc-5`{gPJp8FZY^f;tLZJ?Zu?F!L3a0mJml^R9Dy;@* z&pDUp?c>xWf_p{S-;MXP5!Pk*(LDv9g~-xc7CDr^m*dMnUliHTplz99I!59(R2kZO zJ;W4{)%`AVzbHI8Y1yNk@=l7WdfEvK-u(5 zuE7&Q-kd(2_s9sARCScLD`E1I@y_dU0;vma;%esyyen?{`k&jYU_4Az+_IDwH4VO8 z{#JUYXi$h%iLx|EQQ_za8umJV=7vy8nk=JR7)Y?Pe=sVbVHx_MFtFa^;A$5hNam@~ ziYte|)5R=)+Kfg7{=xZ2BF@rNIRM<~cvq$)f#NSe^GfFPz8PMrl3%%dIqxEUnLF*EL=f@Kl>h+7qr<#Xc&l4U=wTB zubQ-+l_38h%K;_lhDsV=g`ccWX&xp|fgx*isBuh)M^N`6uYJ||I%bgmeHR|Ob7{Aa zvf3jKyuLa=QyF&hN1i~do}upfU{1ftnk?ubuM6IU#h@iH#%%5TA}7stDi~|#&2u*? z>Z;`MYhWOo80wIr1~bHdNy%_$WIEM5IjT%+O797drxpCH<1d`|ix-jjtYH^v#T+d! z-&|XgSz{pi>9aO!>NX3-R1${%n~5{pDl6pU20i%QYE5E_5QA-WRf1t1H1fELgchua zat1;ihMGW6dHUGjT$r zE29MN^E?nED2IQ$A>R|U{z74(Fhlago9N{c%<0^FXQ}QK)F+ClEPd_`-v^Q;4MK`| z9>2GGdw`=8Hr6{^YL3{8|07DNMCcyDC;fQNw=-<(81q5PP%Lo&@xfCt{j=|QK?(@= z5%VPvxba=A*ttzjN7NW3;t2b&p+7E1UsYA(HkvvFYYuy_fXTKYd{+m%Owa$IZ3+ax z^vwToXu3Z7v_ZzMlJX8(n*m>P_39oKdBi8G-r6HMGa#xI+%cBqMCQEn3S$XM;0V8! zHYLcTx}lCU>Vc3nfY4I!+aIl4PAoBv4BANxwH7qx*E+j#j${cNxxcLsQ;`hJ%Wv>a z;_Wq^J1h8i#^eVEfD!s5-8DvKE!D2w)u)kfH_tkGX7+GDC;Ny72vOzisye! z?|UH?qzuTtxaUPC4bi=rUz)jkBMQ}-Hu4+JynCa`zWOl=O_v4Bf&ylIy;zkB0)|0& z!0|Xr(wJ(lUNVMoWsLSWktn^F&%fZtxgGn9M4Q zQw0~5#9Z+&I5d4x&27x7-9F{_6XlhBA!q#@ys>OVwZ>Va=!U3}73UT_`6u;SVt$Az zBHn-8GRM+a?Z2qhGfEpm7uBkgSDPtf#7E)Lw!8KN*1HW%(3RjZ)B6b<|(nEXE~Sm>tGXd{JmdO?UF|9;G?FQ!-V@tng3VFrXH6t?m`MOj=xNnN2k^kf}|9*F|QFh3*X#tYNXm&*e zVBUe+mem|1*jm(7E$Zd9t7>3h)JFnPq!uK8xGau&4!>~dyXX>W3}p<4en|D4#SZGn zX@Vq?$`556!u}KbkL3I431as4Tt@gqn12K?*D-w;NFDl}qsmcO!Y^=9*utwWx*^M3 zg!LQkqcV))3e6xKhcu72y(kqE_a+eYcN>uU{-~FCe)x~rebcQ5uSU`XBwr}pLZ~eQ zQBeKybU(@#l=G0_bKwaL`j?vU_P8Ukm18Z{;EP*v58=H@3=kUpf{*7p$^#J}YdRxa zoEa|n{s&+07-UPgrEQnF%eHOXwq3Q$wr%dRZQC|>*|u$4Z#}2Gzdrrrd=WEZW#-CQ zKXS~NbF7i$zV5*X{Mu*x-;(eCJw1C#4}>`qboY!q4^Vn{l6tqRn#0WsfM1?K)8P3T zBN&050PXuid-yLc@I~Ndv3$T|K5l+i)gqR#-2R)C8f)OyK0Z5V$N%#Y?PD^l+Y0+2 z9K3Zj=ynYH-3{G|9Bgwu4k^*9X9!_nxPazaIgTU(a>wgoVfC zJbzfb&QXG8Rk`Z{&RX5q_!mEr)d1O8;JR8m2__K~?}D0L?qvw!#)HPmFe`c4$g_6* zKKK6{qChdUkcdV_8s73+UB~cBwlnilEAx}>@E?iac>OVf*|2Yj)MLo=?csS=zOi$Q z(qUUdydes&K)OqL6f@H_=ja$smQFJ5Z-HO1Z{dGsmIJh9>4!L|TY{+|TG+)5AjOr27Gracs=Z$aRG#Ci}c#7(ivEYV~S%6ta7@ zv8tesTy{|*))rW-P(Yxy@7!T$MSk#^LK?qguC;f)N^<5AFItv&B~_+SBNXm71Ybqs zW!-GZY_Yyv?M&DEzIwTEqgo9RbP97S@?auz3GO-*dq&}Qys>PT<;uQ6u8U}=!CxTV zIo+Pijc~AqFt-JX;Gv`U*=6>Kv!<$;L#GQ&wuFywO-ff^;rl@!tiP}~r_dC!bcJ1S z2S=Fb^2pqwdB#)bEWJ2PZ&A22YlKZaQA}K57^iA_9e+n~_yktGa=x6|0?_$|djZGp zR&-)MlAlF+A+_91c0x9ECE9`}+1@^O!ZdZfxOBrb^Z?)YM7Z8P*9LIC3Ut0go=xX| zNqqtSG=Uv#-)(-NJ-lIU4}9--?0|3jq|5oWQUU%&6Yuoueul?Hnpt2FDkh|avCjPL8l8|?Z1*w9K&pp70 zl*IgLjMn}`%UqlZ*ZyR&fA!B$Yp>9WPFl6pzN)^Zc8#K{74>1RUdIjC115yZBC6xMiS-F0y)+=e>umdE9oj;rfc70a37+@nL{x}_XFA`)e}1I?p=`o z-gG)<^ztBUBABIJ0Deq$d7DyPcyF0^4GaciOlh9iIqd6)eZ#e@6c6Ba??~vzqojpF z1&siuV>z?r2Y$0cA#MNx$%3y|7jxR&YX!W!12@Bh$5h9}HXAUI2Lprg?**gcD52K}4K%zyE#5y#5{{MQ~n+N~Xk z%Uz`(K!{@zH%@Lx=-90d+rpc`S8D1Y${|&kmH1Y4>N4m3A;<uH0)!yRU7xqt~XCxb`@3?k-kdfmxMA&vWCFT91I6$4j)hbAyk}xSu+l zZLb61h*vLlJ$7(eyAhlfGF@oDlZ!e>h(&PKH3xJn#7>uOsTsSHj{ID6pyLp9==_{H za1(1ec*)Kly%orHA$tr2LI%DSr3|E0S^6G4c!3s=e(Ze3aT*ucH6f#$Vl3|z`JIKP zMmY3LNXIM6m(|%SkDjNCugdB&+tsAiDIS?an-ccUyLw<#;6tDUyz(ia1R%{?@2coI zLJi}gp?EmHA&f@wDjOA_cQL2e3@h{r6y_tKn8gdtc-4DRA`in@6oKs`Cj=%;nc+1i z_o)IKrGT0heus>bi>V^*sN$Pm17+TZDgH<)K4}5({Trs3Y5~4o7N#g;fu1IrZlKih zL^w;%Lt;Uo_pj7F4g><}_65|XiJBQ(hhWDl%GzY~j2FP*pa-8dhgX42O}6YIO&E%_ zFwQ=+^y|qzv#^jNs}3MAn)+==TLDi(gM7Vt=HXoHL{VLTQQcfo9X9jD0J%{FM?AYK zzI`TiL45&4*jGf^2JJbebX`v=Kc&W9c*!E{lQ9LyXuP@dsn@9Vc*=y$Yy7M3&l;Uj zq$5}|;%Xj8$D>hyVKgc!mt1M%=r905EY)_Ec}Gt?Et7mV7f&K(`@TY%iPd{h8u3miA5=C` zKKBn;X0o21E!}Q!-|!l2vbc{jSQiA*ciObnqtY1zdBDOUhG-%6bOpk2bAe8FOy1Vi z`@!kTPJwii)NF$VVOKG!V{&@`z~U*lpv*p_%4CuSY3KrVb{^^th6U@inxh-V zm}x~YwyLRJmtctB8|ea_e8h`|%J6de;D<_6kgc-RE2}f9uWr?W=i=%{b@DB3Qzo9! zr^Lc@g~|tXQ~I{NzK_!4J)Sb~w}!|@=7|>@8Rv6sCV32%d1S(QP%Og2*+v+Otp4P?P$Nz->a0a#wl%7TD#TM{z5ws@yZ7? z4<`VAm0~|^>qV-t(8qd^a34%O^(G&X~qEv{L>Y;dM;1nhy zvS~_Wt1IpOGFeNUW%G=MvN&QnoaTQQM|j00WzQ0+$cvRqxG7E-%5qzKC9>}3luG=v zIGx4Mf*OV377U%v3gs+%ur9WfI3KTb!Qp=)7yC7oGOLgD5duycNCYan&mY19ptb?9 z<0s)l0<5hnKmkO&XOg0Dnk(iNO8D#T+?dbVTZ8MSFrPY`ObJ91Oyj3!4Fn#hWs{aU zlIvRYPuRo4s6;{Brk6_h;Z>mDR0k)QJ5p5c^>%@fs8Cre9?zmSL9Vo5Fbuysg}za5 zR`H5;EQmamzH#4N8?4nd&oG@Sdgyq^Z7HYB<1L~*WVgqEm39BE?C$4vuHqG%P*HP) ze?%yaQCxNmZugf{);&~OTy~3ZPb(?4y#sQFrc>PB8$4V0Dqc&LOgNDNPXL?qge3)i z)X<@n@sKQ$_>5ECD2}U&b?HNa;zXG(aEcNwG1!rb5G5m)7C$1^A1k2$)FG1w6;J&= z3#kNvdNmKJR83wPAu+Bkt$AcH$B34Y+-ClRf09W*D3&1mIb>&(p*+tf<*?K~t+sEI zO|Y3?Nz$A)zVc9QJ(tkqd1}dIhHRKOSCp-R6e*@QKh>`<6iUeQmQ6m|h6~PzW-&TJlJmmJat`;RSB;31mMi9cakO7rb#;E6dH9JTiOBUW!dUGV6pK zqnu&T#Ea-{$O{84-^0L5U}W{_E~@z z5GB!)e&SI$^^IEpwrcq{w)sYp4Pr>_MAV;Y3=BFji{Uk*BYz{)I1P9Q`?41CGlaH@ zNg&rvXouJ@o3W{sWHc!llOCN{JD?d`6CIC;B^ww;udog6sFPAL!AcX+P%#00<7bW` z>=>b?N*U0EhcZdw>US;f&7%dIL8rfVHD*C-K(9D0 zq}r43a|TMO+*1sACPJw|*Jt#*7-@kjY|H9h;E;mx3Q zs#t}ZnrMTzFmO_es)H(wwv>M_=wxa+nM#|=K%CIB(8 zL-cAmv5?${^WsX@vdSoLkckR)oosm}gG<>V@1W4uIa~~ab8I7d0Xe!DSxKWo4UrNs zwAMUzJpKd9uQqmbotNu7Bb&LOx#fd?y};?rah*wU*v=2kW(2{`f%9PDJnHZ6eA@g~ zFs62Z1trpp=8bf~7_wD$GhP(QItFKQonOL&qFzaXTEQmhL#l<>yI1d^5c_#&AqU>i zt=T>}Y@N04>gQ-WSLDQ^>cb*^YN3WVMPRoC5o`WXq8;=CDvA)r6mFi*;8z|+(AbME zYKlqHIK&>39);la$DUfpA~K&UYX8K7+qU=qdUwx=~72+d22DYw_Uj+Z@sXkkriX+c{#JH9>^ox@KoW}}5DWhuqCFs-5lr7Evfwa7}_zMgjyE}%l6 z81tRsMDNlh9y0lB1)3Jy>F`T?YoU3dZQ*S+uf=xdqj_y2w)cZY$$R8eZB0{LkMcD> zpXGUDH*#7#X`X91jOaz7S&+Vb+HT%H3|*GN%SNd&$c5AaK}XlTcDC$1YIzG^Qx=t^ zPF*vd-1?RL3m_M-pO^C8o?&7ORVmfY`1T`vgeURG zxeAK#f$$^@Sh^ zOM`?A5XI@i;{ik)*(E}Z^c%2TO%b@)HMKl7J>47EEZ{U}!ROiWx&699$Yo()Zox}H6I-aTwzKYaP#kP&nawBU>B#ZY*uqQt!vUKG$9D7gs*M>Y^`n)0DWtZ)?9pcpR0IcdCM`px zH$l}TJbMJwDYylWJ?fVqNr4s$9AO3DlP0m1cS_JRr#M2}s=n0ISM8~~H&SfS#^UI= zr>c!lpt@^U-z?ErA)z=?ZlDz7-8a))?_BD)2f2>yLup*8zDiJn*4>tu6 z7dWVH755&D{nJCyEnC^33kE*MF|s_q4;E}oT>`SLJVnsmmI>??(NCxJdZ>?ipf<9v zy1SD^xruhP{-Q$Jqq)02khouJcb87zldMZdu1j~Yg|BOy2;-V~pYh_??^^zG~?5_96SMEF`9t zG4{;xs>Q|nNAFbH*P6A>^DujD$;r1T&R_3v@-YerN6Ur9wGq%*yct5pSLxkFU~#tD zSW9hQ)l|dW(tLZVtpf0ZO{cr6TjlWmcD1dj8!$ps%Uh~Lq@f!JD8ysFZ1ay#u?nh& zxA-*h z@gYSWzj@kpriqO%q`@Zqg_F&Tw0ixuduDTHL%}Sb3q6H5@-oehEY3aaO+>F*ureWI zRly%Wvx*r&e#MpB_tTi`L&2S5c+UXP;~yo?@zEz9>uZ*jJzovtntItUCNdL%jE69a z+7d!vdfG3rJ8$e=nHbFYVH#`s`IJITLwr+K4X~VL_U0y1gY7v58r8TDV znA2OyK3Asc*~39IHfo+~nyqbH{^F1zhz+uu@fn(VkNh>S!KzKDqxEaGY6;UXDO;QH z6s%#!dbH3p%IZncQ>HiM0;5<1sqgQ?Y383?<8WDdF@!%B7jmgCPwFRC0VZB;BK8q0 zEU^;0WPp+Gd`^Q-Pi2n~)tAWWP2FJNkIHy2+oviWs+ow3nsgDAAGE>SRX4!WY?*8M z+3O|f{kSKCzIAbNq4B@hfVWJ^TuPIE8QDZ0+Tbxfdj zn-Ahwve3otV7Z!jJQ)5VqW)!$^U;9H-U{hCI0#~mqqJPV_xx)@L8ZJTV_@spKXQ_` z}A(g&kH*J1yak;>brgZ#;cK8M7q{}n)D?#A#dpguEJ~N=JSXzD;9K|Q5|61k6 zTbhOrS1ciVm7~kyW#qtPate?r&8l{uXTy9qi111SAV73%0z0;N)5nsgEHTbp{A{%{ zNXD2VJ{UETxEQdDE(_N}7EUtf6giCsqY>>rZOP3#y-^sNtaT(P3aHsV{4=ZsHD47@ z`G*Z7Lkf6u6=Hy-HG4}z$FbP$V8N=k{6v~nAkoT{HU5C9$f8$yOZLaOUZ)`R6d^I3 zu*!so3&7*2ILI4@?fpiEOze&=?_zuylz;pFn%j>z^Ah+0KfhNENYpF`+h6x^wUTdT zMW4cA$RldyZS^{*E;kkVSRyk)L==-EvnzzjHxWbrK@f#^IDpAF6vH$q7g7fWF|E5N zT7DA>Iv|G3n}16mW5zvZi0K{9TXie;TG}sX_Cd^7bj#rJdq3t@Ac~JxK4%A^*fHXx zu@~~~(a5`)k1gzl99h3uN-~uKTOEpW?FopUNj;JFRvmUOZ(n**LI`|J!qYUrn{Vo#s3D^!%PAg5sT{v?uMHR3t*B$V~c zF26f9EgB`GNPP>`z$H0CLW=0ZS9O1S)|6SbO}fB!hAVB#s=lLc54Bbutz(yz`H~@u zZ(3LWB?8m;PtUKF1m}%_H!4iuq#RMwG1qG>n)K;EquoQg%P&|TGQ~`?b2i6uo=%?- z_aBN zQzl&vulu=po7F?p5+~f#d^C^@S`wJwk=bJPx-R^9(iR_%U!dGG0%gNSbJi!u(rD7V zKB5KB^8&?(CF|GW20mrCHSkyuS_r&Gw(}=34`flklRdL9E%_%R$qTQsz_LoAW$(gx zu+OTcfScFMUp(Ie`+SUEk8&TT3&r1g+cPh8A8JwGL%z!|cmY<2%4>i>9kzA(@X;U) zr(!H$C2m_iFVmRc89$GZ5A!=kj=l)Z*wPcROta%==;9o-Uuwo<&-mCiUD|5~^+KiWguJ}EL z-bx8!+S{0y{-E0L`Ud&$G%psIbUCE1$yVfeNeK)KrU`#1T^ElLHkn5iv+mPwjC9*# zx`4*-J!1;GguRTSSCe&jbd3~!P2oBbHca4S8 zFtzCk;(NSFr_6%2Kq(d$XN@ike2d+VuISodmIo7A+HNHR^XpFCuSy8vFzao4BIPcvw7X z*>aQ)?Ze`NH82KjBr+J&oQAG!Q;*biPECyaaY`Jovy-v2mgAJtmNOj;=`GJNlz#01 zhCGJ*3^+Oe>~42{MKtLA)0KDHwLz4$94#%$hNGLx72dlQa4;ASgBp%^j!nm1R<&$t zQ)90x*XQRGFfhiw&9iDoLjyF4=MO<`3iYgBP!zQm@je|oS70Q(oHCmr5`4;m(X;n& zTSUo3uj$J>?YhbYPA+1CygWhxw7vq12evqLiv*qCx;fJ4@ut%GjW zPL|kuDQLv^-}Rmo1fV&chXN=7&k`l5)RYuV4$#LR*=l$5oqJqLnul#+ zgM?0mO>|w$cIZt-Tcuj&I=7SHf0mp)Y+*MqH*FB7NIPI!csM&|LLN@wWSbRy9G?Ju zk%wfD8?eP&pE;D)Z9qtx_1c$ZiH z;=$f6J%gVFruvS&@d`8De$w*<9EZ|3WPiL6rX%1HMB|a@K1005$nP*fzbU+`QMn;4 z%KNd->U){9a`TABXcfTCivbX{;`%v*xEOOIViJiYA}Hex=_M{SIbM^I*u?^UiEG?Q zK)JpX&3a07t<(5JVTvGxTPA-=Mlw5 z0w4gR8O-kj`PREYTqArW#rdv5EB9gDNdgF97Q}E`;Q)n!z2>T7jL?h{8fvm{RpF+{E%T$<=RSkL4=o}*I zbrJPqmjm&+CPLJ9EBl?&&0zZq_!R(nH>E= z2g%T>DB{r+Z8lkA%`}Rrf-1TKZo~y*ZDO`MUM=W)RIEa zJe`pz7w^1!339Zq2LosmEkrWF?3+5(J*+Uj-`LAi$4_cd{byyjz)9BiV8hS&lD*Pv z3xbB*1c7SpRTN}dMjVXI&yEQq|?^!)U-K)@8CQvDJT3b&H9w=nki>+`S|3XRpwio zURU;S+{>K4W+&0_Plj^LViIt3k9URgt7z&fjJ$M1SzODSKfXaghK&&Un!=dJn5Q{MLn9{%I z*V<QZgGBYCy?o1W3XFfwnFaO&2hFY>Hu6n@E;z#wym2)?o0Gu$i>awos#;xWr z4I^OJ1ub8bez68wwBbElB~)(ERIcSTdi5~MtSY5dE9id6Yd_E{!%|SP5mIRbPQ41Y z-UdI%6$tS_bkq&C&hbb3gt-0YUics*jzW4M_UJ6(|3nXkkJ!Vo1zCisd?RlnE-@0Wpl)*lgGn~P+0&2Aqc}Ga_lwMHue(?KwUkP4xGrxHK z4-m1z=>Qg^fXqWjtD>FMIcVw!%K&if3P%pZ=Bt(zON<7p z2ZCd(Y87`&@*4N$drfupI~El5V^Qbjr23b#<7yvAYcyoTTftL_ZELD=i>34=>p}^5eae2KE`~rbe#+g=#Zqxp;z(XiIvKdWnbQqC8Q1u&jN=qRL=;dN}}x4&A-KO~x+# zOSJqe!Kam<*GPtMe=Is&XlUvC`t})|jyc6M_jQ+I_5%UIAa8fyk1l~_7DjnxzS$|# z!+yyFUw8gpn?sApRHInc1VEV4TjgF0(rI%DDmt zqzy)pR&pN;Y9C^RelYt(4<_mgAhb5{Koc87Hf1tWf%W9pjgGJ<{KS0s~N|I zWT$l}*`1pPwf?T2y}l*cI}{h3{%}|m(*sae9=%5$(#aY!6=es#s+s(*-(OOq<&RKI zWJz-Dwcc-j2#scu-nRoXwc%z?`fy@b5ypZ<>xk55n-s||QJQfA#-~NleE;;3aQ$|h z#HW~9K)lN^FnEmRm|2(?(ao;7S&l6bq=h!=o(qcTxPMEU} zoNz8H4BntuO4xg5FM-~Gva5PUYS{)SGBx#G_6!@5Z$~a^7Cesg_gs1D4%TQ4*ywAG zw!whCG(XHb#ei!NSrUSAi0N<~E2S{dFA*&4CNUtuR~p`Jc{>uQznT4jC)iXFvlXH? zSVd~yKW_0u`f8O+aXHhqtl6XKi(zjw%sk_Vd5pRXY}2l&BCl1cYJXm>Up(Kx|Ha?@ z_wwui7H0q9Z}y8OJVO1j?)1R`0GR(%Vb<}7e{8K!Ct+h`>?W;mU~EPFe{p2W{{m0) zWE9&gNh*zf`alovDnh#fP#_?tN&VNi3n(GPk)SzXMr* z6FL;N2#vWCZlAtlGp3Z%zBn%n! zWOQa_D?SBA$F^#QCo3^K!nKFw#wW8>0vDIh@F$LrpgFdr&^zr`w}oXl-uJ%KrDb${ z%#52N?4CM2E5$**oFb51o^hOojbvqbIgR9c*jO2F#a2p~#J56@#C|w#kc-xhlj+Ps zA1ES_cp0}V%)mx&fBEQ*9HIL_Eztx^B3+}Erq-u607UgEg~;x@_ffr-=%(}neSeij zYYC_-jl}}!qy05wpJB5UO1TbzeyPsv1|k|$oAm`0rZV-Bp%Rn(_s$<6IaIgu-g$Pz z8|o-E3q+COMTBYh|R|0?@usah*xsUZ8%5?lR7h1wOd zTC8T}ccU<`XcB>sg152|Pl69pj7m9(r>5>mn=Ec*oY&o9<9mhX+-Gwt4#TP1<}CQm zM!_ky#6js>sqJzuUsu6CAqs1mQ|0~NeS;M*Yw9>AC6zC;W_<-!-=Kv1k4l=s)*(eJr*pg-<9S|tB6Skn!$_c^7W)BA;gdPc zIPbhdzLsGMYSQi?7S3knxUMo7qH>qP`ftP=N)0P%&Tje{7aJDj>V~NnK%IRRhu?~c z@=N8bpmn+9V=k=X8Hw%8pco3ysKHhP<>73%$>Hl^W$ME?pt_|mi0&x5{!}aS3j7Me zy~W{(V^B^ZTS#}xb-|1SMM$TJ&rtbobqlq0l^*mJ#AH3o?=pynQg>^DhTJU-uRf6gu&rd=_-5Rq-UF(&DjR% z9LAwcOU~m0qgsiSAa7Wf~I1Tv>Gn9> zVS0jm6L6xVlEDh(%v{^~;{yHaAxLd=3xgj}a^e+rqshn3y&oMop2pqV5cw~EDEFj;#@HqCCIx`7Tj2MZ*b5?|hYp>RoybRVC|Gj|`hLUiex5q8s99k=8h|A4=P_k|?@swCu_S5;LNv*GcpOYFuW ztMA>$Y=P-7BRqjdkMI>Nd?=e;5z!0XKkT}HU)=uhvX{|6YU%TX+a3SeX8$Aa)7i<~ zicZMZ#?kqQ_~}Tjs`leFVD~?~&m_fh*&oz34=@TjAwE>M?ks3-9yA)MyfZWtPJT^)`;vNQq_4+U90n zy&c6f6TR?Y2r@J`G+GrM(P$6B57DH{WqtjX6Q6p7&YWsRlrmb-$29Q>Q!15b$30}# zpN|%!$yg)Rt&M`K4~;G)g>#iMyRT~1$HR3Q0pVT9sPKmDX(c=%7jpU`1HQ_+Jg8Ef zux6i7-r#HArLv}(oe+oxVd2E95y+?Tq7Vs(YPEN_(1gD*(8=7^<|okqb13@rirdz~{lB)kE)7pNWHpp;8N_eudCSoDhhVv^c{6_`LGV4W)rln?aZ#|l% zT$q`7094KMg8XJp%?i~jP3y(-&jG#<-b+)S<0<0RiL1(0nb_-b@0{%)RN-{j^Mu1L zpXn5!dPvJ=X)gg9?hu+z=|GCMdMI5-**gk2Y)4#-5UkfC4B2u_>+aE;WiauZGaEPi z7?p>6d&;p#n`dOlaI5Epzilf+l1TUIkW)3Dt05TdtsY&>gF{QoKVL?65HB8!GSu*1 z4RKe?wKC)sg}YyJ(;hi0L?&$TjBX~ta_@>#)KDI_DRPevQjopjpxf;;PqEv%5GL~PIG0qfUD6o*oBf$nI=2nL^ znP65W#_ASXl>eq7SZ>J;j>kqM$hiw{BNP0ig%ihY1 ze>*ID9CBtshJdAzp3xx#f3#~1U7&k1o=7w2WH#0f#GEHtFan&ZRl7=t@%SakOlvuJ zsApP$%>d)bQg)eMIb5*NT~=-!On?yI^wfK_)D@(n!Q;}UGD(xPSmzZZMZOcI zd?*hCT;>r2Que$5>ee8q&>{BgX`&7>HpEo%GQyMHi&$EUW(bMMAb~k`ot>)aFaB-z zt%D3Ejf?Df34o0vxzBPWO*BN{jEhbSbb;Q_ha0CScvh1)Xt(AA z3U4t`QAvag{vOy*7d39H)^zDYku#sOY|c;^I5pY&%U6O3Sr8W!bAK}s7J!YM@DrE2 z%t|d*fne@)>Ms0&4{D!3s*FN#zu~UBU5v>p*o@**J;`esO#z&OurX}0c5f~xQ8uN} zWI^8rpWkfI*pHqsW`1`ecEsxFapXdgT~d~`956^#JfomsmMCpnEOHSM6x2w`BTV93 z8n1&D+7G$y#dwfhF&Q7)Rtv<;^15vN^I-1E8naN^tr`TRsCpt5my*2pTcK>ei=tZ@ z!!zxZBp!3<7|Z#nbL$GyJSFRWfcmAhXikl(bCvC`}-ZZou%!25PuKph))cy4hTU z4<)gV5E6-vf}u-ccbmij*Gf1Lc-r#@h}BJgdQk303GVk_5y(Sx+gAAC=NS|=vSFwF z;UJ2EqsnN}LtMi~!(HKgLbu`CCH>&r=c5@Ky~}YACLa(3micdB3EVLH zEb-kE;9V9REl{kLSU8A%PAXmZVLB;x%V{*JasLDrw9lzBOLv9Msv=7u7Q2pSNy?~0 zkG-j?T<5Avr?AM*STuZbqH1jwim6m(U3HapBby_B!%IDLsW4q^b)xzRRJL%#sG5B5 z^3R>mc^Mfe8%)*5#A!mN%-YpDHo4yrQ{QZ+USujm65CIt7{cgR=~x|rNrI`!*v1Lj zubpg&YacV`@v0o9F(35iysUXk1-QD&F18P3g^%{GxG{O)ykMQ$K!kGbJArbiwptg* z+85QNG&RQ}-eXcxB}~>MNxwjR>;4uGDUB1#BUMowDesX=<)gGg{ytsKLw7C(;IA9H zrfM=#%*fWE#41yZ!nOd!_2nb}hCJZ@v$4N0-A77ECq|oOJR$^uWDmo7FKNiL6?zUz ztD{4z`eTVJe~GG2LJ>O#Sq4N)jVeALxk!rGlA0%c?}RjmZMY@nP-!~=dGIQyFSx2u zmk5tPgyGEk>3(Xvt8rj^9a?ZrovGYW>Y~IGXEE*ajiC+puzzoE@l-%&9fN!Q~ z7{4PCHG2AI31Rk;oJ3H{{9Sc+q815DCVyis8cX67-?-$bWqXT&{F<49FPq{p-Uk_K zY$279TxmbtXv`flu?7CHO4yxCVM`#VI79sOilFCyWRfB(b`-(`y&)pH3>juV z?AEEgrqBayk!hZbN4y?NM2t(n92qC8AUvA2PjQr%v)F-p0+G3lLF=Y)DDy$MKv0;f6Nu}uwxh-2geBH zP-0a?j6q~T+kiX9f^PA?%*WQFWLvEMS;>i;KNU{F$xB~(c9udtq&_0r;OEysWh`Dm z?8h=?t+8jUMU)e%4s{C? zJ|J)OFMlx%rb&bRq+XCnXLtb{w?WEfK=Q%w)4TI%n0_c(fXJe7iydN-8;l^IfSgHfgdTuj=<^*JA7;e4)D>PL?h!g)YINjD8TBO9S+Uk8~W6b)3m-|Qn-QyEZIZx z^Xinl)kKNE>|9qVsB37`_H(ja9bYN5J0AIEr{Y}c5+7hL=e60(ys|y$^uW9u(Dn&G z+#p%p(vEZs**;M819Mat2Wdso$DinYq@H#Pgmz*j~L?$0N>dFzS<)> zI1(C-0+d$~+!wI?vv4nAVwTNT`#n9={m?eXEZDBuCmCZ?O0SQfy`;ZQ2_P0Dd=`hnt` zXSt_9K(-6<$@BED{Py3o*#FIM|8Xk_ol9e5ga!ZzMFRj3`%n3;x$VFF(8T_+M^loM zm9aH)wlXIEuhSp*G-F}opK^}5zLmMh|NNyHRD*O=UPSqt_9nPCW?cP^%1A(+FW4U+ zCu5W=4j~nw;RgbrKQugH$ViXX0DyoJVXzr)pi)RlTN1>*ksXUF=$b- zq*}GKHaKmu?zk--kAe8f|Jgmo=6IC(o$a~Rw(fi7dB+FG2c*aOmA6NTg0@bNma;Mv zD0Od#(OqWH5i)K)GKj)@(VN7Y8E9+XDmk!7SzVV0z*ThLH0PeO&|Re;43lA>#az8? zS00jtX%o9-1H)#~DlssLX){|ZHc*9WGjG=s5){&fc{TGR9qeGxu#XA3HhZZK z$qn%&sg)b_W?j%P3AtXizOln#ig?HK$*M0WV=|LU*E$s$B&2WJ zxPFt0d#pLoMT-f=xtSMss{MD(fT+LA6jy;P27yWSJpk9#7ff^l4T?1=fWcA8%H(oq z|Ib)q*5|9^)Za8!mKqjTblKH;b7KbIg!NzJZWp;$^dAoKG-y2t51i|U2)Z-lGVYdM z#oO~1AnYO5*4yw9^W8He?u#3BG7SA6HAb-P+B1?e&~F>(isjk_u76FVqU6!(Sv3;k z*5pctH6!gg8aP2#waA%+c2gmOBv zMKu{cQG!0|YBPl_?WxyC8YAWvnDCRB)KOV@xX;T#6h(d3n2b@}-^G#zp@_T-!~r=( zxtCID=OX86)&aQyNIR z^0p?ED#?LH4}19>bBnTD*l=Iettq>bw+iX8#IftSbQQsoyu}F4)uH@`*ZzC;-2t$eC>^52`Q5 zcg&e)qQqn(tWy9a>USh9;HlYTbLsR$D{}h-kZn$c4)p{gXumZ>@~Krl8|HFP8lQEv zdaK24I6Uq)6)og87`?r#!u5NA%1b`gpuG~iJz(jzasT-R7!T&pxKc*QD~H!Z$A@{h z1kTs*2I5It9SmCIF7;+hfpiLwOTkeAoj#usibUc>$i#=IkzQg1mqDe4gy@`lk3aO* z$wtxCQ7ER7V*wXG?iKWCkM*)Ca*Y3vv2zTr?A_LVr-P1dc5K@n+qP{d-LY-kb~?6g zJ6W-_V&~?+_o+Jj+^SReR*es{X04Cw_s*xrc;4|ysjUFAPIb3Vn0|+mZ{nvcB;*if zR;SYURJ<2w&h}X!?rtvk=Y-MHqVQ%bL`7Bq>OqTIYHV(ScOnYj_3r6+ku@n0hZu%GTwENB^ zpmwK%b25-p&$scZ?+$GS{mQ?8l>_FKwuKaQ4CQKvM)SzaXq6{O#s-VreQGv}7TGal zmZBt1;yWwWhUF%P+1R>y+;SxA05K9X<{4xa^D1y4eXW4{n<_uq=&0CsM2z|$vG=*? z>ZaC+Lw0AxV(&V!lx5h;5JzV$=B)v#gQSXFCXAuUCRS~0t8^w9*)<{6-E@`4fGyG+ z|Bj8537cE3qx%D$75=C)D`O3r3w`!UZ6~jdYcYgz4xLj=H3wJR(*89iCS%JZniMDk z{Q4_Ray5o5gSEJAW)4NhJ#=}3i_HWh2;Q2dLo4>B)Oh{mx?YTwS{{5yde2MV0=MEH zx-sE>8^{fp_;^SW#%RTMeG&n%e`3QhAsu9GeZ&t79d~NmalV={P&YQjAc$<)(t(D6|V&AsRBLmsq@4 z_v_(YGU*>`F*bDaEH_j15=t|YoGbG(QrQ8GYfldy zJZvgJ3gvh_Y$EX6-|>F0A$JapZ(-P2zyzwJI7UWD1a?vVEWRhqtpO&M5bSvMHp7*X+l;n7#jABgK08nt-$1*DSPD=tG0hmsTGB73&7hcmFyezi6$|<(c^0;VT@pHFY=0N3@0(Y z-JT(lbyePmA#5A`jnr>kr*@9=XvE~WFHuy2XyO5D&4O*>%tK`ki~El&JYtpwo|Of} zg#}5e44#e)#K{~PeFl|fR+(j<*zn&UNB* zq=0WaRQN>~0LC_L9y#uT2WTeA(eVU=G{=>C(78ZS zmYq_?xq&I(R$*xVV$4{Qg4w)g?w1<{t#iqofE#6&bF;CQX7sEfDD-SNTO=Yi15!jC zSieX;!uo22L33(!QKgC$yzFhm!rCk$XGWum`joa#9*ZIPE2TZftpk-6XQ}F;A*q!R zgJxQg%CRt=Wg?0LwiVTBB8oki6?QSzo;`$>hdt$RUIZ)7AqDZ1;dYoOjXc$}>-H#X zz69m4Wwe^FsYpmhqu^gkk?UI3Kod!P=?7}jl6-wQD^iAmlI!~7e(H}P+a*aPM1r1S zO{{zXUgaQHH3QC|*4s@j7}^Sr?h$(^DP}k=Km|;rVnEdak}z<$hYg6l)Sw!40k9B$ zvW8U}GJ-Y?y@j~wiivDWH1SY{X--Z^NA#(|*4x$~?V15-Qs(v7%X`vDbEIW~P|@@D0K;qy-$`ai|^ zf6MfLW~)knzrtv~1`N($vsKamr%d;-`!9*EYU1epUo(9vM-Mxt|4XHJs%RTy1E0y=eaPVD0_!@_^SvD?N-T!WE7xYJ?epOl-ju3|Sq-NVs%n zumNclpGRDQmCiefC{6+c+l$pOfz{@i-iwi$MAV#JE|SI4$=OhN3cffuu%!fXQLbu+ zNnt;JNbh7BcP3Zq!aO}Hxvc9DA>eI|xsg7*_&Y1%Bp}m51+}p_xm>%93r)9fK~rT` z+9aB-VV}n?87~Xr5-QCAvPvUeW>=3~bJluN{ZMtXlJdS>^U%a3?G1G|lXE2!l7`E5 zvX0q@T)pHXy!>zNSjz$O6l}lEO|D~xEo$&z0$JF(@~K$s3>?OW7EM$4TRo|}6?^Kx zh1KQZ)!1l*yvvaUx`dPVw{p*rBR!I^yzKy{JG-l~`?Z{@iA$ELrb&l%`vQ+D!_p=r zq=jW-iaY{W@A6Jpmf`Lq4H`ONJV)JW-o~Vk-vFtnE5pFj)AjO?x{ecd(hqSI-o<7w z;V393*f?cBUEpmzv@irYpFLXfMNkJK2fQrLr-Yk?oG)_jsjBN_b4 z;2-mqB`#3@j%=G?X>|Lzu5N`;z0i*Z#@uNV3FsfU-Ms@q!FUPXT)v5>e{wXzA_tU&L@m2;$=8Ggtn@4#*|iXB-gr z*dTL?ukoUR9s=CElyz{we`rE_oA)NAwJppIgo1SVuRV2rNz!@lTD(j;h%TO zA=Ug2lW`9d5mmI1r2bncXFwFyvcDZdIPEicdxiSJKT{WW?cI2BSNemOsb9RsDqa!A z3YyoJ^8}Ev5jA4>4_^NX(f`D2__}BQ@Cz@qFT6zl|MB{7$ISmimmG=$;>T1|5k`}v z(!eX+7hNK#Xc3r#sG;EamJDQFnN8#uef8_sZX%vvZ0XJXkVgp%v-_af%QUfxKr=5` zk$Id*oAA7y%;ap?_VL^TwMSrP6po7~3Yx_n${iHPjv@5dGLRm*cg1w;OEo@DU6R@S z`n!|FSHSjiR#0HJ)wfY5Z$@?0<^Vec(zhyAc7~{$U0NTL1WGE^uprPU^WC!!JPddm zn=3Pa5)1hdTSK_avIOy(U0bTe9#}8cOJUbs3u>5~G?PfO)g-cR&Y_z#%S}nC&aw{d z7=&U4&lFd2qrTbXBTdXsx_o(-!c}Q+^C>LP_Ddv=CV-}>K7%e))d|nc-BdR0Evn>6 zKuc0DtYED|fySnepRgyc6pR#Yy|Ly=*hmfF^h_PECE%JYoiCL@HEre=jkyk?NfNCR zv^g32S7jU^rn+BV2_=otXK(OE`J3e!S@e9BVkY5=xh#F!hJ%gZ+B*Wcb$~Wb(bgNk znBH>b{<5$DzS^^}t%=f4kI!rZ1O)>$Adpukjqj(r0V-4jj@QTww z2Q?AcEUKu@R|DxXci+fx3m#<$5DctfO_<7jgc2p)kpW2=3cx8FmsO0;r9-4Z%t?0-ph<3i59EFE}%A_OwE+m{5% z)EtudS`|kA0gEZI(*j*B5BI%ARZ85lI^i&w9Km&3aUjFn5XIXtE>1ap4%&u5A$7!C z`{t@Y_KN@H)lKrV=6FTmsdUZtWg&ns&48qXRibQ^H3+{Z)A>Z=QgomEAF%!tpZ^By zpZ3zz%HWXKmnVoH;oCRf|0h`gqrD_y{C|J0CeRjiHPaLP`Mo-C8U^>hme?mGZUkD?heIq$H1`5;*Rw4a9p?8?@rk5m|d6R zN1?A1y6zAQX85S#^vESjaqTIr<9{WCNeN(GA<8uL_? z9b*wDGL*}bnxlZl`uvPBT*?N)QCeEMRLiP-xJKe4thYhv?KQ*WRiWfOAMyhFayV6# z5EqW@=@N47eVr|An7m9~rWU1!5h-iA?`Nt+5rpl2qt`lsL1*ZWCuL@35w)bqblYYJ z=e;shmC16$l-BaHF^IIa;yhFtDWyY+^hJu^4aTbX&JxEE4Ck9gXqQzcc9$ean&TIC zk0Md!kca+6!nRpizuh5&QD$dVUVPXDG5Dao09W6q1KfJu9hDmVzWM2J&Ba-net1K_ z-EpwAEc3oU>GyTz+$IWbus)q@E{+V}6bRviib7Y`WdB0)9WNYVnnwRfY)em_Ds7Mc z7{A>ks?uzmKgPGU`Si|jbnuk;XzS#rMPvJ$?^I9vc~l{M{B$GjHng(h4S)GT)o_x4 z9caicyyemRjyjdbT2VTAoZp_c`KL?=Ij#7xt#oxN(}G)oX6#rrCX$q9yd|JrVBdJ( zL2d|I)nsEh;OCMt&j7gqPrL(G&X{{7ITM|}Jj5_caKtBGVWfh#VTcS&M5+y-BF2?8VS)WqwS_Ku2k= ztnCr56vnkznDIJc*>o{Z4Qu2S$-^3CCiM@)BzBASV z;Dr9oF?$@0o-X_73gn4Ar=&9nWZI?U$xYS#Mk}&!HJzt=t++-Mt!rFCfmDzsBHQ8o)gVc$K$xd zj~t4HT(S*> zNJ=2D3Ou~%=b)g#;7l=TEE}r?(#Eobo~ib%!Z6%|0C-|;SqofrL4)1Yap_)U!`U&% zUW>2i(Z=IV{9h=N{M+~U)yK;}S6fcgT^oP;5xQ1xVZTWyZ955~T}}tN0ZHMyufQyL zIx2S&GGmQ+I`VfbWJg%>y+=U33wL8~84!HpL-+@CfCopiZ{Q#C+;3wNDSF&M);Bn} zXB)b%Xgdy|+f#9{9j5_9*W|YMbj|kcHG(W=u+PMx8&K};W%})fe&eMA=G*6J6~faE zVZaB5&wD8S=i#`Iw(pbN$F&|Dzk?u@_ZUJBC(wy!=eu9XvBEb!1~o{+Eay7T+HRp0 zD4n=|j7dKyyz4GdzMmaI#B%%4W^~EnJYC10qi&&m>BncN;Q2XZ+Onm+@9D=mA*6=B zD3*i2+IGCXaT9-x4={RSRYI}%;{XCx856tV_Qvh8X++Hpjp;gQptEY#BZ>YF)@@*4 zpo$nqk_}lJX2KLwI0!aSEDEQQjp60@L6t;6!P?}*SR2-(Y#|Oa*DJ9wCJ__^o#&rr zNcBuxdgx3UsT#6cRFy6A)43N~eu_id**HBM=gQu<4(`a-!nwI-ae(*XNTEMs)HGw>zr{KR_vDmA z!QdJYfp@4A(gvWWgpX_IMo_CKRFf2;s~v<@46=FvG##>FZU*7rc11s~WkQ~kQS1=e zfd{6S_At%12je#BEt`aFOmlA6zT9|#bq@fYL$lHban~N=BiDeJtiNkF8UD;bz?*AA zf^hvR)HVhJ=U_hosmpVju!&=!;O&61#9iCkWhV{R2?wqx=V5?C4?h2k2x-Ol%_!v38R6(oo%);A} z)oaNgTwgl8b$co86)x>!VQHS--a3hL4l&klR}7uzh+_mcHoZzCv%Ot0mKCj{;aA&}VBRcN-@1sNzVC+C%wrg47lZBY z>7q$^Vfpvf{0PkaHM2ez1(l{>@V8ty>ZdPwv1h<$R$QwtcDyR_f*Q7hcj`1V%3U3w z_}Yl_qr!$#7C{0O3!k*?|4{z+J~&qzHlILFfDEHiEQpMU7uRu zLQC$(>iAOq0EX5ecI-ubG^2x%pFe}%CT{V=UbDJHA59^48(fy zmB}9oD>WCd@l4B8rxL_EyTbh(+0LD|&jD-v0QHa@!7!y+ma!q1oIVW3V2~s*Oyf2Q z0%xC4T9S9g4q1F5ma?hdkz^*b2Y3FFgZpilfzu-BJlFVQV+L)0rW}<f}$drSSd0{ScdEk*1$ka#7E5j@V-Hi-7 zm2BMKS=$b!X2-DAfL9~4C)RDv!P_xj_hVWWgfePaB8-Rg!v(VW!+Gt5ZY0e=L z(~KDhC1ril#^EfUp3_Z+0r9%Alp!uYL_>s4td`sG#!dc|Gv3SYO~^IU`=T^#(zL4} zNm-TVe7heT6S9wSkTOUpEN;{6x}8fUrgDZvUsJ7_b2mPcqcYf3IOkMCBT!C2j+q49 zek|GFZ|N_wqAXxv!VvxHxL%pbEQ|f?;^TK8a@O~Wqtxff@eyvOm=|?}o(X!ncg5!- zNiBr4QyV_;E+Q%OeRS!ZqYFSHFMNjX#K_oWQCZ#8Q#uoYmH&Kq_T8Yrk13NMFRSJdh((gHoV_e0ov!Y*%N3^VZ`sh%UavOf$H2L<(+?l#GM z=6Ei$@lnHzZx>m;u{A0vHFH8TwF$aP0{P1>ip44@JAzyj2bwP;nM6*A%XJc4AiKLY zk$qrcCV3HQe>7#@VzrG)IOJ%5@+3oCp`yR~fOy>8R!p)zcZ<(tqVLW|9*3Ghe||Dk z99dey6BW+8HLZ$1ca!XYTDv-b%$6T09MWS;49M5>;brQxu+m1FNaMul{wixPUif>y zl5BQ(fGbQF_cpvd8Ro>0lImTY3v1|c(+f2s`$N^?juzoqu7Q(o-K>5GgINfB(&3Q^Ty!wWmakygFlY9fsjyRyp!Fc^pX9-KT}lLU)nw$>c0)_pY59HENDs zubu>v5g|QjaYybEegMrGfTR5OqXVx(vr|N3gDTw}w=a=p26-P@>Iw}3qgqoaJCPmc zt!h*&V+rGKUJuWKr1C-8dQ1M5MAt-L9da1ogU<*SSn?UZbH4dv*D;T)w-L}>%=PzPtDZwVzB zg0Lf`^CtX;nwMKLK07!)FwF{t(RovRlN_!BsHH!#ZtKnO5?p6Ta~)a%*xR0}+;uSQ zLbojdGCCckTT261F2Lv~&^YuE4KZzt60AXjx*EDIG@rS_oWb?|w|E4yV*ov%CjBXc z?t|_lFXD0Fwe6|IT?>OC6ai}ZRG&dG|JD`BuOgsow~G^?2M#FcN`G<#;TvxF5W^sd z_&f!m0L$P%{bQVgSO}k)^gjmH7jARm3Hrq#4_32Af98eKJ3ryVn*(C$1Pr&eQ#F1D z(G~qYu}AEhLE3?lS#wDvX4T;`rlU8i6GU7uR7&wsTn0)SW=t%b5CGM59tH(<(65UK z(1|j+mN6)mt!{&Qn*@zSnq~;-3UhTaFE3A_=OUH_ear|6k}1yRr7397^OXtDsn3hM z0|)Di3LD0{#uEaq0=Z?{oLBYWf2GD=lv55Kw?tGx2X)}AOrN;Ze?=n04ICTAoP)S%2hq0SQiYs2w&3QC$Hl8NN#aK^FrJwh=|m4{VI~nlu!*J^9dO8? zH@G6QRc|#yJoq8fBL>rA{9fkn+b@ z(?){9J!|-1(I}HMxCb-oB#(!8aXJe6Wscm+&H?E>GU>>rgfVmKgp3)6&oBq*bY$a{ zTsUQ9>0{@^a>u@JRE%Re7SqYak~7_DK<+U)U&AuaEz_AbNU{&n=s9>~vv;IpiZd&t z?FeS)X{NBU1n@xFm>SWWL zxwQUbJ9Z>2!)LqJj@YMc)26|3X$8AYF#c=oLgCI<(MTtkB*O(!E0iL2z=Suw<2N}c z(#EnRyy@*E{Su=t5vXqb&*s7Jr1awS3 zbJVHUzvYi&C>ox3(GD>?bLZ2|-6M6U^s(7TFgtd~(v{t>HipkGlc=Fnlc-NqJt=6m zX|p~mS)8jGXSM!qg=P86^|-|sjE>txK1Jt-=3{20K>Q3w30e(`R&}3KWmL@;x18y; z+tJCdD+Va+_qQSF23aQ91uJe7{K=-zEGznPyusxOjBoMacdJ0c(eaJ8M>g5?@&Wjb z;He{$TdR7=bSaE3F};Eq0Th~!E*1TrY|7aU&W&J~cHSP|jbwQM{FwxDG$fHZv=o6y zvK^q=`3dGNDN*A&tj}qh9`;$&^TVak8d@+9TcZ>@Q1Yd6w8Gh=u|qUr`SdBbBU-U` z?Otb}HHt1s^j+va||TN0(kqJ_>sorx7J~3XUYnuB}60t90D1{=AEHGrdD1 zg?(IW#A;M)R3HuViJNly*c#~IUaAz=GmhV)e4@!M66Rpkw}&X2x>+X0AiRuLqQy%E zGaQ?1yN6}Fd?4x(65YHfsKD zaZ3MiIs!vk-pX;YeYdg&xw9#itCiJVzERd5q#5ZttRVSh6*R$BQ$-{pY`6WW66dW> zH^pqQY%1%(S**%)`LXrOh*b2MZjQP`Rr+WBcxw9tDalTYLVV9^ zW(&bH#E0X4<-rKA3zDiCh(L?M&RCsU9L+H(NhYo#YaZmWtgeQN_ID5$=@y~}OJcTk ztH@-1vyAS}j2mRMNS>1?^E;)9a)n8(lR~?PO2X|f`5+Egy|4W7luS*PZpTYNxyY?5 z+ajH=V!O48j?iX&601r?x#ejxO9^kQRqx(<-^%RV!r>N-6xiz2sjFam{4{RQN5f)Z zmZQb+?o}iUkQ3f<3U~Z%>lYm8t(f=WuEiGSDbvXcpgNk)e2V%nR2>Ly9WS=qo zayCnIQ;9^Yl5-g4>I~|(A;18hFM1|**WjJzX(KUl4d?rwFUC#QqKxD!;<VBGV20jiImbU z`9TlX&@{|fEWNe^c4fTK6s)e*DV{7799ML#e}5>uai_ayU=RQx{VcaTf)V}1U5aVW zy5S#n=jY^L)y_@cq{4N_Q1m0Daj`48QAO38x6A!`*8^pqVJnx+ZfgL4o9glhS_vn0 zN!3Fzjxv$3t|o0>MTqv98ZjhHw6UND9fPDDwMV#LS!KX9-tD2Nr;4FCGT;={QB47OQ!9fnngBAA4;EwOl<-6 zP6Wf6sGck-)7dDW12v}=y~i`0o`7?j5gTN{C?%==ihy(-c~ViadY*h1-eF8~--$+M zX#(Z70fe=bkLV)>#>J6YgN;2&aI{Ry(8C7lVi@&OFl65jNv8zYFS_Uh2+H#6d!{()7_58pZ~;WTA2`z$+<>D&RnCXN6Hs%wSgd#t8}**vAmQesWGWgIQB zTyb?7-TMBg#oVeEP4FRjJ9Apb0Dla#QDa+!uUoYoRqb=qZb37NSw%HXMOjkdu0{c+5<`AY~gkK!1{knU_()Pu*cO zWiY5r{jbI?D1^j~^2&VB zwnKcr)%393=z{b)h(XI+%H`#+xhn>k7HaXz@CW*Iqd-^RR){oWt;)5I;7TjWy~hhZ z4}XRuoOp>-C1a^Jk#{ajqy8o^KCMEX24{fq_G z>GlbjhofogI?qLprF3JMJoR+67O4u*OC`>v=97%ej>Q{<1Y_{Fpg}`^Us37#J}qyq zo?6|yIsW8+ma4(N`!3DljEA(Q@P=CT74mF(S$raBO_Sl+Q@}<`{zLV~4a|T6O(yM^${9_`9?HKMEo036t{~Y(%&r)`rC~Gq}{C2_~7u`!uyw?Z|g?* zRDS$Y|7|dQ3*eBSsu!O#+rv=PpGDnrJ4%Zm6CFPAKNjA9dK%nwgZY1LSj&NdxOL#R zO!=NKjH7dLcZa?It=s1D9Bcy~0Dr7?gS>wMzS@Ce{mMhi-E+AL!+BSD@$CnzQ`yM| zhzGtLs`Kl7>^2RroWB?Qoxlp57ZP@c4HP}}@gUuCGpP1L_a|Grq#?Y{IAKh+QxAlb z0pdhJp8O9Z13u}%1Ov8(e#+W!vIP%R=Duv|q1gBM#<}6}6W|{;I(5ji5*J;*AuRzA zSC%8WaWPj|%HiI^q;;Uv59j_M5RRZoP5rqPxVJR0(f-`fLdaVPDpw&Q22ZY-NI`K> zInY&d3YZ70pu^vV4V+QKU3*gTXNHUY_~>}=0AEkTd4ED5Nhdc_gjL!=$9NX-=R07= zQZD_VeeoFlw%w7pr8nRc^6hauU9sXFWynriqRGRg^HNaq8C)!C=;o2zrKK+oncJk< zySWs-t5~`ZfokzDu*q%mih4i#PuehXXCQ;@sV00)oONWEnRj8Y;|tY#!Dpax%I?7` z$pBv-hhu*=LNGhQROvz-yju9zxlaDdVdNFxgkwJNsa`G)42)SXsLYTHdp_4WUN8&* zSBtnsjBTlJ8E>c;WViv?aDwhE`<+k9#(u`yrJ!JlPdgABh-pK1i=)wljel>x^D9orZ&X`9_%XM?tuI z&N2h~1-6v)U`|MG1KXk~0=K>nN$$=9>k_8ntOlGz;=1-=EplQWnERyk;i@E21A(Ic zixq_a4YuZfreg}0^WdQG$+p3s&6`ze2qCU1tv2ljNNyY^W$V?&9XO|teSpJ@nd7Fb zK++^mu%d}9lpv+&InArf&DrTCi5Y-N7#dwtGOY;jM{|+ObG^BpJG;+8V)s^z2D0>g?xL2OFNt+2MlO5Wx=! zk0Wid~jM5+Gl(OQAQB>gs64%8l?;E>=i|y9^gc>ig zXYp!8s+QA7YCPu%hR70Uh{PJwv>#5h4>4jCVAhXp)_14D90UvS+C{c+gSg9(fp_?B zK1P^qu3jz>WtnJhY>P@`YAIhMa8?rgiWMqUOX0FS_-lgWf*D$$Dpnus#F|qTlMCk6 z+_r044vkAa1bgg3$U`Ilr52ryoxF={-ez5>X}W$pT&oI_F|dq`e#f7@S0)}uR!6FA zo@b?MpE=ExF35lbgd7yJ`q;QJT7y{rw%*D;+Q9SQA!V=wc=u$O=62#S5?#;x?9_PcxRZ& zU#>phgarpOR)oDiRG~i;`$GLm8u=td?Tw+3eNPpCgEINfUyynYBk~XiL55x@^HuKO zvrFrJ$wZn+FcVN$+5A~#8OLf11WapC?2{LL+9*FgW2*z~aqIj)mStQg$Xt~T8b_mD zSVBXh&L_X}d6d0#7fhpkZP0bRATeZ1w2d2xN0bI{lj6|vi0gvwhrmF987HO?#D0Q) ze&Z5%;qmUwO*~>b>MwAVB71~vHLM~i>N}K0!||G zLJ=Pb1e5ZE#EPl>{c`**r9yXDSQ=1yB)prbc89>1dK)pD0!8 zIh0o1^R*8`eOG#cXJQuW?YS6M7==bQpmZ!6?PCKb?$}jd-W&2N2r>c`vdcUfu#Et<-am1In(Ie^MBiLfbwD@s&qQb83EA(#UgT^7@qh}lN)MVS@ z_*|BQ`@MA|%RSfA#qx6%U*I&hMZN=c7pew$Dt?!sMf3 zxb2#|BMnmyHTfkFJ^Vzo!mAyRY=m$5E-PP`{CeKJ(nWxQQe{G)W#9@pYWhagz#R!RhHaq0IXS)LrRr&u$S#0FyZ&oFe&STNp1eTZ>QfYj|8m=J zIzuVDw(&rrec5zDEEyu7_6J29f|(L!?+;97!DUK+(rH&*B9Pme9c%*(G;9ea^rAr@ zaYa3C-qgCl_84)K-$*KwOQBAL38O%o`KW z*bt7K6+SN2+8R31UePg(PxW&gK2HB4%;9$fQJV(;X_SGCIrY7I|0zi zt4052!aM}*7@+U0fyTX^(y2*;{dF7QMo(B^Fz}9s;U5AQ{S&XBd{g`!WYWB z8bVhv8j<`~ns{G?0J=UAW8?EaIpBpdQxsvb8v78_@-pw@LOEP$71z>p~8(_zo0)*8a z$PFbQ=^AdRwqZa_2dWfWY{)mZb|@){!`W5Wq|4gkt?ZpXgUE!!0+am|C=Vp5=#W@xHL)l*)HcpS(pAFIDBI0@%Q1zA!guRIB77r~Rl&`UF9 zFUEHr|CDs>XO2G}ZEA5?TkS}}h!&4X7Uwxv+i(c>&R+J+;Ct^3<%M?wn4&pShDeQe zmCT*1sB$*2{TmV*y>!si?W4eRLXl0F1R!Ppy+yu@o}i1OiGupSt4Mkww-3T_fI{$t zsbfRfJ0tAvE`Cm?(kA#9jXhb{1!aZ`Ortg%}gL-5?`8Nf+T{6eo&Iy8!ftV$%l-Dk%;A#FuAQ)q`@ ztKR6ubL^_N#OB|`V903OmY5x$1C52I;xA@epq#1A*tbO@-9%sbtcmwMv|kYmuB|u9 zl{@LFpjxpQer0|m9t@MGDG#MxWYEY={MolhYaF9Sk#D&v5R@4QYNe5-0J1GNsr_EXElLEwbhO-P_D^A304F0xA7XIi_}^`Znp!QFyb zH3>1Mdz(h*xq}eM8jAv#r%YEnLn6kl1ZGiDsE^B4|zV}im6P8SE z*cr#5IKu*dQIEUfdAvBe6JMQ^+G)LE!o2b8_|2JEI}HMFS}i>K2=W+lAjih#eZ!a} zlDdwZk!eauE-kW;UfFFFLrNrj_nr8So3#5g7k2l`xcMqhv`en<(>L=nq!#rP+-yf| zr~gwPc+D7i-K{+D^F3v^M48+N!fo&98WG>u#&~8LKv;f)&?i;6!(Z@N0|in81LcE) z{ie0wSJD?oaWg~cd`^GkPMXV49UF&Gwd-;&{I6JPi)Y9;(;(`JjU(Vmp*%zgv8QMAow}& zuqWz?$evcr4E}HE;q&N1!|67#Y==kFaeXz8dGUt`o#LX^&;CBebn_vBo z8_Gtn@i?9|8!uOLDi@NLM(Iy5g1pFqU)PdO2RG^n$v5?d3dJd;)lW%S+~N*b#+6_j zVseitX9PcA2uK91B_WfBHO+A=>T#5-XsI|CDeTg$ssy>dwbuK7Gq^ui^Ic@UbEY+L z!835-HEt4M6G$9mkPR@zu(pd; zRpeRPD721!nK(^%k`PW5+T~9K5&& z-n|ZGXB)J?n4h=PW3WS{OAyds_MIRdaY0O-BAP*!-n=U-Q3U(eOB}fX(c~*I(rrB_ zp!rf9v3vc4rUNagIn1CthB@+7qPa5>1Afcks3XUDXzg2&r|!;48EdeGgke~eG-XO= zNP=W24@VkPhEiQkpIe=uM4zTWWKozEc!xQqO2x>;Q4}k9``Uwk@X;?)SS8qHL+a}Q z_&(!+y;k85+lWmw<5AlJ)xRhecmtME>Nfn}D<0+J@t1#zHs>#^ikx_3qHk9pr*!Bb z9p%-*J!u{PsOkSzP8!mCH3GR6==juW;#CQ5dF4l5KU2o=Nb!PXXcvdr5CCkTT zlCNP=-FlelK0*N~#L;@>Mj4q@*nn6xOfqxK>GdMZ%(WO4l0wEn!$>SQ5n*H05-i$L z{zgC~^@pRkDMS+tR^?B!`1b80d}?SF9K|DW$oi#VG-vQ=Vl;)pAz1r!X5&nKh=nh? z4&`G-sCtK-R0njpM-vnNBM@9oshXw#7Hf)ua}t)?Jb3=AEP~NG&3-a__e$QIRnUL4 zU2a!+n#VK!{R9TN+}^%3E!X1&Bw5$rW}(Qv87Y+s;=>7RrZ1=4?spCH`$h0P#5R)j zx_^74;kfBj@c1YIa=?oG>36mJYI9S=+;|x7 zVcPw>L9ala2z#+|K(SAwJrWZM^F`iwx*w(_fZN z7MVQSL`6vg2@7*w76~ip$@;(xd2;j1gaY+kny z!2@sU#N4Y5$lz{m9gogx(dwncx%_G`wy5u*cXpP*5-6ev+k z(?9E{vP;1|D|c)cI$MXu$z;!cR1AFg`9*a_HZE?5Sw!;Lzn5oMn|_~AMx~{IfMoC& zzaY=1`mzFWNTe#EEM_tf&1uxHaBiMo7hgV%<>7`rh2HNSu;tHOxQb0?1%0JJArudz zO{3zZ=a`~>u^)#8g~H@n1a-sCbj$G2esZRvQ{IUs#DS$@NQn{+l=uP&B-uhBgjkL- zm46h}(YEbJCOmiLmPZWMnKR{CLa2x2Gh)}185s!57kf~qK?Yg$gIy?YAVG_o4`WX9 zTJEolw9@HFW0N`vmJeZn2hz0`OC@L(fHY=3%t1u#rE|*c6Aa7e5)-c$H7`sd{;`x^ ziiTs69A8fm^1FM@7s(T+s8ipmPuFH3BMv#amfPJ(vkIL!Fs4qx3NNi1?bT&nIyr-@ zzy(w2rtcWSfT^oQ&_sDBG&EkLU^8+Z{rvDl-;P~q+I8`JFKBr8=@mu!+`rr~<}j6B z3yj-{ZL;0P`9A&Lt!0i)WqtpYo@N?Ww=tlf?M)-Ye_qJid}#0DUh!P8PDS2~$6mfE zonLI5*i>}0eLkC3By$8u!^(UzR=>nj$G|4ysal<3i#wjMtIbMw^mv@E(6%91mdv!A zOCNt1L|X2$08f*PyEEgc_e;vQ8p;0dj=g$_W5^2KB79-Cp7QO(%}BkKmkV zheL{j)f#vHXsVtL65#E00WNJ)Da>D$HQQW)lX^Id1758Fw8zU{w{&6nCnBzQpXybH8-VkO}SJa-Z<6uA! z*wlln8!{f-amE2;f78)Nmzz+=3z<6+C_&N9JPAbTlzjs&M*%^EQ9`(|Ab**;6h^#I zmMpBcB8PAvW#~RRA{&^5uw4o$@0p7$nGGXhrZ>V>JY4(Q zaGk0=cwb)Wt6eX0KK-@N!A^u(YWcXlka9l|)}9}c(e-cyoIpEIX<)oVwOWN##3;0# zdd&t)E@hqYaD4nlef<3W*k8eM9LRxAO-{Ay7~zpLUAntFhxSWEJBl6Q%uQt`)N4}& zGIx17v8_O9G5G((*gJ-2x~yBH>7?VNW81cE+fGMsY}>YN+qP{x9d>MY@MX@m_E~eE z>+J9BKkxNc{eA8l$(aMV;Mby+H-!2`hIiZnWs~tzq-VEt>lr&xCt7S%&W@I-gH`cjiEcs1JtMMap z)+&lrlcF3Hb@@OR?;*XpdRe8)%0f%YO}5)6oOlu6#Bqc4!`|Yo063C%_$U)2QHJI# z?~h;9+>NlH6kuktGH-lZighAL1WZ$b>KKWiGtCwCgCr~x6ugDF$@&t$c=op?gV(H# zAj$fy?9cF$IAz}@VwYSd8aeznspT+I7`aPU7>t3hMcUeXwBdC-Fy|-UB}hwW)G4 z4jovhc%ZdPc`|ql3u<#?MQ!fR{jN7-{4aTGVFuDqP>tI~nqu-Ao#`xBdX2k4RU@S8 zxI_24YFFB@HD@%;oRW@p=SQy>NYU-Gy+ta@HI48 zmvH$@V~>Sawim!_R+QG3x~a{|bV3{Y*0F0JmEVZvT)b7wbP=4zxJ+F?@}q7Xm#a|z zk^MH@D8_Jx)C1cq{M_yhWdc_$SLcx(45xlX;W&{edH_+I->ani6Msl6%<)Bf>aa+I zcBPB*g3)f}#opP{?US0mZ!&QN1-x zpt#Z?d}83bYD305iNJhS^8UXWhIg!{SPM2yhoioKa;1vSV6;LuTyIe`oz5FCjxENs z4p2-Tv#}J+n-0?y8{gwaex9_wsbTu<2)te8e&87OW(|JoxIJIZ9P$}KdB!6=(<=SS z3;4#ziS|rPWXpN6D&$oU=>hrN&D|^1*2|U(T*CZ4o||;o~oll=Y5LCYc^wHlj%aV6U;au4fX+ zbVvQw^K5LhGpV#+X*`QIe^Ji8Xyy|sQ)m!OHl2AV*ypqSlc3zntB>5g)99eh#nNvASW$R zkS^xoe27gUh4ReeWp9-EyiWZG1@-5K?w)tORILXq!~#kQfS-=&xWsz+m_hWZ;?YUZ~m~D8J(sHWttqs*iqv7Q%=$h^n=S%#V z?2?0~-0jAD7#z$z(p+JP^uUX5(zB|vpdFBfyhC@AOr813OtH&eou|})<9?GIk7nzZ zN|Mv-q?+6rJCQ=2R#rY9k9GsdK$JCbuh*r06hCF&HIkjD(1-lpnpm3{2%ymCfP|&U z`wB89sr-d50ajnbe%cUmVtDUiSpwza1oILK{@aA#M> z{$pbh*b-k$~!cDe1Wu-wHI#qJSSU$tP@a}R}>1jC*|5sZfVvuu98w7%RusP^4Ok)-#Ec&J zgb?522h^Y-fa`2Cd?QsTUd;eS)3zLjFnKu7OoAjTN{ER^>v*lb@Rskdr*{9`cK!Da z*;fj^C>z+9BQpXJ5X1ktA#=2MGIVsZ2mEbZCvR`_Ww!13ZyV+&H7&KTw1E#<#8mj; zKOz^PdGm;ZdbL$(rb7l&(8<88$e^7vqzgv)lZ6QqTAe#pE?$;9I$kFM?bNC(!^Be2z7@=RR(;Ir?*p2xsOBn2lqL+V!gg7Wh{Ab*W%`G`TVL{n`K=9Hh znZ-duNf|?fp&>fdNy|p`$) zb*i4^RIzp*(kBKZdvXSIydHzj2>pr^mmvTd%7(})6||Qtu?FWSCf#pN1?zIucJ=+I z@N1Z!CuD?h4GygZIjqj?btpr;T}vbEL6u;yjbYun4|kR&Y+Ltz_nI`R5)4hLFsaqV z8z^1CYQm1h9_3aG2$j3ejUmRLIih`m`*By;nu+59KSH%jgi-czHsVf-eVWKI^pVuS z7C>i!3rQ#0zLzKdzTJlrFy44;a1600^*&N&A!nrkB;&N6W`7Bz@l9Ib48YTm4j}!- zBZ~VJ41pCq1i|7DL%sC!04@Dv6t_tZQO&dl0}h%){ey^~rdgUR+u^YW`^YRxj234J z&Wyhi(P3&5U6Pl^ucBEw9f=5D$2z-G>#L|b6I9f-%4W{jZ}%2AotW~_ApxWU&~Td` zC@78TTeQbSPnviWg|Jb{)5O!q%FyM83TkC5)JjS(kb!CwNb+?Xs-&umbz!UhFE2r5 zcM%gX?@LY3eoz>do8=jcd$^v@KX(Wr-wC_+lk&S|@QIo(a-}iWI3^0m)RR>9C8tz= zH)c;?lX^32TbOVU|8bU~-3s8WGI#7%rk~oVxwguaeh2??$O&;jw^D@1dp^Y5?tEJ; zw$ql?c@;+G#6!<5?11+=CwLdYE`0Z`{!M@j*fA^O4T$v~tFTw*``ZQYr_S>gKKzu{ zDffi!w&Ilrp->BfNPY`Kq;N>ftSwfa4J3mveH1u+VO`GUkNk|z;IS_wlN(|}_8@{x zp~Opm7k^Nl5Fmzq1$u^kyXV13vAq%;eCnJQ?^UfGG2J)xych4qPgsm^kUEISkOhc5 zy^zb4-nxXiq}K!Nf<$ry#5!#a?W0c+-a<${dOztR!}Z8Jpt*zR2%&%T$M+NAYG>x} z&bXgm=G(2w<<6rX;LQ!fYyA*zp2hA6NXFrt%EXU5A&um5+`3s&I;tVNx>9(h+kfTS zorCiXSyp^B1U23k2Z>lL#X%|wWxAL6)eCEx(m63xVYg{oj$5>ZO$Xd<*sUeT z{Gte7a4KEbzHdS*r3pY{ku{fGBFCPBeyd5e_^|kh?C-9Pd!SiC^3;?lOeV zVspN6$m^98OUsEi;Irz7^J-Nt#VunNqf$|Y^TKwsWusu~#1#$k7FmH^e6fLj_pf%q z=BA`9`@`ApDz1RA?6opsV2-wRKq7wM(&hJ2%SJ??e&62ul7KlBc^oyx%qzqCQ@{q} zA+>F0IzCEl2f}9{=eT5<(4Jljwvrj##rCr*9vfZdNRRd>Ly#?8V)0@nShZ8UtZ6rl zHMEE1u6wz`@4Im$KjyKT-~W;c|H(c7VWq!QaCO5%{|k?#~ML?_HcUI?wH^Ce7iyO-5@_fAJGIhR9A}`!Q@>+ z7(ilKo4r;JQO&V5cP$pGk!yDJ44!d{ZeB7J%LA+8S(q{g8H0>>7 zTy*l4QwoV5W2Mzj1z5OSbX2}@Z`9&$G}I2WpMN;qD3%{s0WL|`YSAv~KYU+4WdlZ{ zsXBgbfpxJjwn%%ax2*Ccvt|56Gr?o_hlXxA(Q%4}swmmAwDbsA2`gG_G8LskK0Xcc z3G{Z-ZwY!BxXXe(^46V>tPdgfILjuo{^v<(IQ(g;r{pj%|RIQQawwOj8 z7_Ot(5{``ncFmbILWc>LSLt>Lje6r24YXM46QvW4iNkL-ykWvOYqi$0O=D|9%0&zZ zyTNdPBK7b{fHjbz$7pV1V#`&cBw3Nk3!G0EuDjPB&M2;SM0wTCm&Y~;nD?A(quXLl zq?mV2H_c{JdaW@ctzG%TRHg5U`}&b^vf1O8)}zIVYNllI@pxA~0PmJKboAbj&dS^L z+3zI{`tY~=%t4;78NG&l9;MD%8jol5YqOFQG^0fsHWnB54HacJ@Ca+sZ@wf-9v%>f zQLNTbI9Ta@BELUgMalV8=&gY<8eZ>*Nq)%2-%(%3$U)2|%~x6QZ{~YxHd$>!*p~k2 zqNQH=r}OkAMb6yT81=36Qg^K_q}8dmdsQ80HLgn;^|!!S6t@_LBRaiH?s`PENUqc% zcLSyTq5FIsebhbzrur1(frcqwoU(twL7U~WhAgsw3O%amR_0c4e} zMdlQ`Tgcwwcsy&fX}9*)G}>M7e-{!jmmQ+(Ei_mCR=@Op)EEIDI-7m+-Jx~zH_Ej4 zLCG%ujr%KG=)EN@$VmeWO!24iIfsZ4%OJ<{qHAmL_mOr?yo$c(G;@&AYmPBF$yx14 zFeGL+K_w(+=dfVjys`@Itn!RL7D@QX#12AqiV$#i<1@3?B!cp$ynDLPPe(m+T!@fu)$S#Qw2PX6dIZ(%t5Q#J7ozc=eOL7tePuVtu;eSTM4usXb+`J0 zTiAHfBspxE7eZA|@)%r!G_f|!bN4`MyG)Lxz}Fh~C?@uhJL$kDiWw!UF&M9y_EVod zkbF^Y5pJ1G{A_}3l58Sb#2KWLP=>uA{Dz+XE?56JzA(@|!kce)VXfG5Z_s}=vi}5z z|3JoHo)PJH#a#Sfrc<<_KtS~WQzL7kZ)~AY=V)VVW=N;}*RPXrD~Svl8(Xf7OcA%krf=5_>3qPM^eV)C1B8fx2I`hj{;4G9Xc=Lp#=Rh{) zPqxD{H(J#(hfp&uPmb8Tyu5mWXsF#-$NQ>75*jGa8m3&eSl&HP(&oNCF%iZy%y}Sz zPF#0nIn2niW7Q|2(0D@pL~ak%w!-_8(n$o{JDdyxt7`*QVsP$I2Q6IDZAdO|(;=wP z3o`^y$dhXYO{Vh>lJ2O7Rms4PODodTFXqLU_@5Ap-3+o$OC7~r?cd~rjzomY5r6hc zp8GT=J_;)zj4}e>A1k0qMZS5QA!M!)t|(PDA6ZD+ z#87ui&K+`}h11$=QfAV?aPrI*lsWj7s@_)~##s@-zsC{cFQ|&HQNR70cm&w7hgMj1xoK? z^R-R^r|+Jv2zEjdV(|k$+$n+D7;G29?pPH@z`D0jq~HB<30#*%u9Q5V7*10p8bMPe zR$>Vs!aBK$380N)Orc;pIl|QkEzdUf5y%c_IIo%Ii!mxTyjGwdlLiisXB~l8q0HMN zwKO5EVvw-d@^wzBCB&WOkjO|cq?r+!xQ=~IFJ9o4nZ=nFap74S`MUBf=L7Orb^fyk z|9f@TMA|nHer>aEzX*-%e^Z@GZq|lh2}j2Ns!}I2OQZiX1J6=jQ$sRA{*-Bk95BTf zrwnxx5y}@WTUNF81HzO5Ml2LQWt0v!5*Oc_9F#=cFn@YaTL7Oii|KyWYl_NtH~+Kw z`-8(u?&^so7-CMzb9D2n!(nAdht%ie&zT`m$W2zD6+4kWFeE}kWHt)J;V>5Bd8%0}fy zj^z3n?z~%MdOEGKY&0Y`G8Ap`q`e%>*inPuR~yy|x2ly}t+-GY7Gb2wb_uqWjU6<@ zD|3j>-raRuqT~E~OeB4Yw8i5($;y8>xti&#GLfdyJLt+MZ6+EVpX&lRDEtIt? zhxra_*i;$vjvQ%h(g>3B>1a$v$+dZ;P0jnnA0Cu_DKy+^k(Xp5U^-wvB>At_r{bD5 z(xc4XzU3R2l_>-lUY)$5Maa>o>NW&?EIDaUafs?OliWM%)=7f3wKY3yf0X1T9ka+A z_Ju-As_x5MUOzFP3-^oRsFjYXXF!@h)g+(hd0X#oA*i9MgOqh{Et61-ObsU*peUu3 zX>2Z;5@FG8T3IvxF_JdMNLe4~QFWO7F@-9XsM%vxjDRd#O{Vv$X%)dPbM&XIHYqO= zF(^LIoQPAXs6avUPpSuoN3Gf*3Wj$lNiF~&&ghQ*ISc)5h~eBG8mGnJ1VjJZ_dYrLnWT&b1xT83QNmNxsi%J-Ql=!^mr(3Jfv+jL!Dm zQdHsg4pu^7k zZHgT>8G2(**t7O9+Oy)I8e{h`8)Ns-o)UY^)U-vp2+Gg1*lO&OaDwIldre*|z_Wp| zk`UF{!H`h`iW$2f%|rmV9{M=pLx~i_nlw`2N7|AuCbjH{r$EUrPBmWVYy9IB_nF8* z>?u_WRpG)Q;Qp8AkeNvI9ry3ztR*Z| z{d`-LMaZ5XxaDd^Fq#rA&1M5Zire`;jIyuaXdUYj3Y5s4^Ra-P=hlW_I?gT;-%Z(H z+Ct`%qb%`HE=e&o$?iABTGT?JgtPp>;l20v2;3Q+Vp9VG9~UI5A$Eb>!&u|i1>*I< zyooW$=HC4nEq!`%Nlx)G@7l-VV?f!sXp?q%_iR7FJm$A|#ffn|5aH$=QykAXQ)15W za(mt91f9KHQM8WXurlldXr1)Z>v=6h(0S#ms7$Xdhu` zqeX>UvAt^MYqBGNf?k+u1>vB4eiqcTs~?2jZ_9!kv|W$syd`vo*omCv0yz~ko9yWe z+XL?3!~cVNMUUr++0U7nyj+AgeGFojbY|`FC52H(xOa^Ir zjI+XEs(kcp)POHcNyX3yfwuB;zY<-yEHWiukotMm3&~1At;S`ahIt|5an&4S|*9i7~G?o3R~N?+!sM#E@f0ClKE@JHLaUrAwUSC!r%s zxOpw3F==7duCtFlFzA4)1x zkdf=>hxeLL%TpE*M(#>I{>HId0ImSX@*UA195!sEsM0F0*{CD+xgiuBQReO2mnUZ< zd{h`XqDz7oQ-jTRrx7pj&z*0XyZmB5SYSIi6-!ZKhq8m)gT25m{5B{PXJDpu$#D|o z+Ag3LvN-zVJWtb+KInIg4?PIwFG!v;307`_<#ZSevB*GzBT=Hi3zhu_&FAyLhH@JT z;Z>pRnmzjPm7<$g8;Z2=3e9Urz5t8c^P}O+<3o(^I|lQMO`a(bhd(p7(i-tOiCgiU zcvQ1~*svwFntMdF>1mf6c?&~oqa$2`Bm(3DW#!dfI)Y%{!k~THPsm4GrSg8Q8e?|U z=6-@IDlrSA(h(wZ$vF}SWeP=OM8-=o?x9tc~a#UFrU|Nc-DlRoPzO+Tklp?<-x8`0oh?r!OyKfCI6ljhVIM zUxR;(yH%=MHdrFaAH&WrSr11?#iXssz{Ep#o7Qy5nwi0keykMHLbVbS6IPaVkEkvy zTQ~)QKK;-&onU2Fn3V7{+`x!}o&38&J-&m7lj~twgCfoX$;Q)}X&gIGQ<+R>HXpBh zR6un3rFnS2nM+;EVk#ZKFR;^Pq(R8;0#F(#X-y&a^RZ{ff@*|q5o^j@iCc7&r##W2 zDXUFgVKKlSRJR;y77RlH*4Htu3TUcJsSf2T4dm1#vP}1fmGx61TPzr~&f3gbcANEm z7M0f$D6@fQ;-s-|2l=6{4V%p$L3?JoJ}W=ekTe&jae*t@Qrohgw|S7V5SVq zazT!c+zQEzMw#78BdCtg9zn{SmvHb$CjKX34NKB$R>0$MJsL2=NYi-oR_CsAe#z81 zs!)9jtT{*&qD85U$?)xW8QCkl2VzYT)geS7b#{(jP3JWIz`t-4#3JFH;Vf3CO6NK~BFdo;nqEshvJ zniF+xb-HN}$A49DR`0e)6Bj#nM!BG)ey+qX+|X_(@E0Vy(>$#PcE&Ah(4bh$Zm)j+hJ;e!!Xqc9;w5-b$<&UH|El&;%FdHZqZ zcCRne@$`bxfD45#<0rXSr)T;-K?A!>X+_X9o(IFvw`^$>F{ zCZQw}|J}FmK=~ARl@xev5$8J}nHs#EIru^2EzN7<6@9K}%)kMbg=HU-E9P~T$u)IQ zQu23by-Z855hNlx5O3i0$~7F@qna?X7I=eaWCg|_^p*np&zPrR8@X%pSTT5^BQfYI z-nVYd@O!+Z>-77)q_Nj3wR5D;#4?HqN>qI|O26PA8lDhzw}gL^x?u_6c{4PDM(rYD z%UUsw$>MZGjH2EHReL`^1^hYwDYHG)yGRPAg>1;qkL)9={sM|L4w5PFJ!E#+l0}rk z|D6K+4$h|8%~d~h$PRtbEW>-i!M`$)j_aB%pHjA*{Q+D=pFQe#2Go2Y+2Ied5W$}Y zt}Nsz2bToxyAw%?$Zh;DT^EhP8NC9TH)>t{J{v|psB#K;Bxew7a)KX7T!OyqfAh&d z!REiiP%a(Njo%jx6@9@F=l=qR{stU<153a^Q0QNxU6$&jQK(ljRr z@*7elCTry-N|~EV2`QAq{TLG$b#O42zhC3~X2W~42i=ZZStRx6D4?gT{cUPxhvp>#RZTB}(5Pe!;Bvz1?ljmzPAF;kL%-5I5( z`_S?oW4DA~u7|>})6a-dC|XOuvyvaO_}YsXWKI5;@_e!4j78-X`c)TDkzGvwZ8RHo z5O0S-nqJU%B3<<~R7>#=r49KjZ!n-V1FYC91PvSMHOUjjOnXE~rnFb=?TsY#?%}bj zo-~A^=|Njb?Fc&pM-e1sCf;;ZiKDH6rmdt=dRW<|IjL`tx2Ws@#~@4PZasfYXBurC)Ja?zPO4+x~E_C`mc&Gd@pav~bPJ)QULZsrgN^CSa9kA#)k?IoGzwM<) z@)_Y;Zbp}AG3^3u7vo4~0_(gZ$;}gCC82&%$iSUn?Oy` zny2genAc!P_3mlW@oXFMh&zTVsShDR9^Iu4fd2(v8c>#J7%CJl!#=~%k8vynfoA77 zPjZFnLJM4dkGoxhK%pbZX9GPZyK@egdHC+vN5l+J^2uj$3hc#IJ_M4~Yq!CR>)Rh5 zmg~f{-D++(e}|Y?&pg7c2KQXKJ%HjZ3}EN9O)^B9;pce9)}d@S9&!*C(M#5$(;5;} z{zXj`K38M!FG)gqSbNDWyPq5FkG#Mfhzhe{xeki()aV7T?~My_(vIP{Ca|)IUFoq| zzyj&%zwNJaato1{l#_Q^km8;31dnB3a%=-(gH3d6N&n21kL9OqErcD-yK&N+H-B5sqx7!{;;Ey1Q8yq{Sl=&{Fv3o-9!-xte zK2{@7N40qQ&5VyfBB$+fu|X)s8j8an_=H;qIAT-FSQ#Um8c8wuy!)zuUOP$`Z`oIB zne=0>6~h~Hz_rV`IELVo;{rc18br9>p7&dBH`p(NCsoK_405V-V=vhDbU>j!Kky65 zZ$(_jm=s+2PIbvr4C{y-FaK=aKrf2^41S9R+tg$;D{Sj6^x%H@JDU2RaP}Xd`>S!L z-uM&%`_gbifBY}{En9t)uPe+p_Kt#XLN-p;juJ-yYM7E<_L@lZjkp(;ZNVPR#Qk4T^ z%6fAcUUySmR>pxuUsHC)b#M|(mU+qIl)`$5c>}?ilUc}t6N9nuQ_sY1Y2VE{it5i0 z+a~v@JOYD~Hh&QYclOK=2Md0jWeLR4Gzk?vWg3}E=zgd;@_})}Zj6IceOs#hisq>k z`OkR=Q)ux8?2AwS=qO0lAR05c9lhs)%NwLKQenyXxt2#_CQ}p;Cr&l4Qwe=FaRz ztnH?dv?J94EBZDBrW7aT1^nqONJ7?hlKP_pm$DKN7i3xtL>xQTW(FlKh$Fz9||2BHBv z15-#k3HMbxN%x%^kpj}s7cPs6oY~e)MlYGW-v>rq=i_d`wiB&y$BYNqKdu$YcnzZCP=EVmJA;&9PXzBvR!{pd=YM-H99S#e`$npnsrqb--UPyo<5 z4ICvGq>1*3gkj?&px_4NGSgc zHZ;|0C&E3hz`lL4vQFCvuEH||O6-7cYsyPfF8b2y(q(qpI+bpITX|+5hECth*3tFe6VFnD>ZApVe^RiLxEdys;b-VC zlScKGxa+jYnVY0Ydd^a6xt!TZ28To{hL+z7?)XIU6Pdx4bZUTqaNf>+FmR1>xa5kEA_iNXs*|C-jE6J-ppl836EP9VzL zTC>MkN+`{vUEzepD|lQHP0$R^As7+b5i;)x2lNsrr|jpd%jHM!o_~Ks`}oiqRJ1q12%`) zXhIPqv)vz}$n4a6nrw!4RN*f`1T1YSzZ|=Z(0d%a51|W$4o?x=-Ls6E2Jf2Ge1$(@-nMAmD@Mf zN*bE5x?n{q*hEC(Zx&mDR`u}p`cK0YA8<~?H&(-N?|NJyi>T&eBQqbQBR88J8O+}r zzw_B%@%-Mt%lzGG^?Y~r(+8X$m9%0bQ6F!#&Ymm6O^->g# z)?hs*gVET3R6ltFZ#;G1hHr0Tgz@NQ0@S({ow!zx*fCO0c4k`YIDI+%HPU)zd@?y# zTA8w)MRnOyi|j^mxiP$4bqR_@hh{0W^?p2FlSJvkSf*vUA$V$#eqDNzlsFD58HyZIqUF*H>?hkS=7?=DU$+dkyvix(L0iFGTU# z%vduMKp7@EIag$(cr&?THS_yUYMU^&N4=;>PI=XllZEO;iUiVlI%pMli3V7TPEkw} zj3l7-!MaPcM-H!D-Fo}75vSg8&3RMoeu+{mN3XqzVIe*?a`;1RV7kayv|(cXce>^> zrO1P*w+3CU(d%{UgQsf*XMrbDEPo9{LFKZZJd<~k4a!g+=2u~OX*Cxzx_`h?zkoF zhDgb{Yp&F>#`@6X_U}IB^3LGF$ja--A497Z@$i#hArHAfSzIaGv69gD2T#@^1{ zWPJlFB~L-fyMSekt5aF8s^X**d@(ep2n=41ykrdrt*wy=3QQaS;+q})k+KzW9d$di z;e2QhE)P4Kh+A)7)U42pl}>MC&R}MQJqyxZZ7e12Pj`hNp?f}%Uqg1=OR?9C61bW8 zJP#g1ydsQEyjkys1>N{tXT(dUPxISIJHg0u-2P;|*AUw>-`s+i;XNC@rOsR+et9_V zgJ+V+3^EL09U$)=wCK}Mf+s`p}jWPAK|;FM433sUgL4SgLLb-hJ4UchCXl^4e$n}2r=$= zbMGP`-u^yG{U^x%cldkmY*j$`lCHD9AW-W6Pi}B-hhS{@r~iNZBAUAP3FJ7{`+qHZ~qAY{vk*@zV_EN90P%!^%_8h*VMbO{b+B zNpd0?V=sP?q4pLdLaU174+g{Xf!kfc5Fjg)8;I6>U3l>R%(?M=dp)A@^S*sVLiHSv$X;6ehX_nCJ}qg)K;kwFCsxpISLROy{fCEh>C@@doFG zqj54yAk*z^^aKX7NN%2p>6Y$)Gdm))&ib`(54qICha8bje$fKCW`D?#H=9J$R9gv05|QZ`uGKe*xl$g^g(%(&MXx!K>k;= zsmYGRBRDR|$g2i>;6QTx0Qzv+?k@;Z#buVuG5C5qu*}S?7bA?K5A$(b`mi!(jtt7I zmC?@4f_LshCq+L_4_}6~$Tdq(1UnzpH5dW8$v;QJuLw!S2 z0G*t%u_-{`R_Lz*v8ukM6X5@y%2cE*^%Zl5{9*l5C`14XA{0(o_yQX2yD+=}e-tq+ zwK+Yl&Blgv?R2cOWPZ2OoeU=Y?;D^s=yS8{Qq`PotSNakJERi?+K=f}$j zkuM21L;)HTCrm1)vC}gHSxg4!Q5}AhNEWd5n4tu23k$V{`kZYD!2xR3_#*Xy_BaKa zw0CcVh(2lsr~>(2Kz`cpno0k3n#SSI)b9v?JWB~7(i+X?!)gXR`!PA?w>27c%+qYFvPKPLID~D0I-RI+ET&SDGp4o28IQM;-llh$dhhx5d2iM~3R>{roB7efJJ z*s7<8or1Cad56IuoK7}I|MH~3n2Mund@Xj!V(s#QW!{0v)2Y~iE?Q8>dgV|WlrdUL z7WcMapY5OjqnSa##{>k%OD`_8)AY5+;(9I!Hr6G!613iv_`!7#NBs@Go6YEjUf3km zz?Y6)swB@5XMkNSe$3(lo)umm!VB-052g=vGP~$6C!|p|P)0@Qd;UUagp^~h1n9lK zBJyE6DH0?x2wZ~ugTUD8+a7|*D=3?MRE?2^F^3@{PKi<8c{50!13)|@pLp+j1*tzD zCIr}-Zy%lY70?ZP7tu1Ug(6H?mNa_QSpdBHib+)phb7?kD zG}Z(3-AcRaVS?D~=V3o^Xn866o+N3kvOQ)2F}TDTiI?z{H|Fo%KcIiDu79qf|E#XR z+T1V=8Lxsbr6q&;{~{}Y-Nx6av(mTzYHRHs=#;)zm6g8C*PP71rv3%%U7C=t$cGpo z-BZRU^%(JhAiYLp_`vTFQV_f1_zZz0-{avMw4up=jKxx0v)Z{Ng!42uFKKSLH!hj; zY?L>d4^hG2bcedYf9(}d&k@f{9f zPI8&peNMvTxCl7@cmvT(toVxaOASmo2BdXg317hxzv}Z2eH?O~pt!3P<8h2h@Fky+ zF}^D+`;acoWZh%F3l{$zzo)7@UtxR~P3%F5*$KPwp)>vvVE$AW_sL%oxtqygksr7d*1){9StJ^^n2 zdf}q~WqxvuGVM|?lrkD$3aL*WA@(i(9JxvGMn039gtbO|@!oA{Z&xs(Bs^VS&E|ChmpUbj$&etu{(_=b45! zs!i(9rrs#ut4n-iQ2cgTyS_8P+)+fgd7zqkd~ z@m5JtOZgxFW4o4nr}DlFb9Vgo8(EJ=GI)JW2C#fxmO^KX-O!PcK3x?c%P1!S3X>YY z6fq5Y@yx1Iv2Rj(?QR`PnXSOEfFdDk7}wSGCy8 zVy@@8a0Mm|#Q!lo>B50;Y|vWt(zI2a-)PLq-VO>d{$>bX=T_ARgz8K9K!bCoa;lZr z#l>Nnq+qFn@}g|SSd{HIo(te^(WaNGn9wZQB;?Z&<-VoCJrE%G=f8J$vbd>k4hzYv z%fJl;)ik&R)u;{tH~3}>T--}me57%uaGfS_;iV=xL#-dKA%Or0zPZnJFfXoK;s_EF zl+;;HKR~rrg&eB0WpaxYxKV<)oXVpm0&0=wUPs&*ie~<{@Msp@QJ}ULgaOUY#J&sT z!1ab3lnJ_maV0saA&jhXFKi?uu__PO(eLZlNLo@#FHt_BnY9T_ClN@6>SjD+2lQsb ziQg2`^zPS?rh4cw%D}5A-U!-mYrzm^rR2e)b6spVB3@1<53$j& zUHr5W+NNFH-8yZpl;T&inp+l^BqA#3nKf}tuiA#Fz*=9)K8Ny?jb+Y|TGTKfzi+h)!6xgxlX`Sug$@34k@fpvU8~Vzl|z{NpyTbT%ha<`&||$=-omk?w%kIE z>6JOlmSF^CN|km!vQH9Ag=(cH!K3ThnERkMA39b?S7oO$)IOj^PR5n73B;fx28*U+j zc)1NI+hbBFk4WeBQh6gM0zuh8tgkR$s-Zhovxe|;DGR@ew+m*K4Eh%g`dJ*SQf<=( z<-#G^=2J*`b@EJx0u2rNtsFa2Yt`~h1_Om0(Zt6CQl)au&J_lDFDk#$5Yzq!#cE-3 z%i#PfYzH{M=}h;5mF?N%APdhZtgb3p@u0_Onv3n|s*kRWE^qd-s=TF&YmCU!CYG8M z*PQ+=?HIQWhOrI@8>s`%HS769b~o73C= z0Iu>rXHtqZ?i8p}gBDTh;Xg_Nn033YJ!epS9ceN!RZ$n!a%buUj#B@$j?P6rjegYA z(Qsp0kf1;~_G_bbTWT%@>PmG&2!%B0EO}|IwxIRIA_0y@?(_??L>lZh5WjX^E z*yhx+X%v@q{1cDyMZ!Y&T6tZ`{lUNjS8Hl?NqdCWO^Qcwgc9_dDZ z_#g5s+D5BJxEaDoL>eM+6$JvC64^%7;Ugt9v)7uRuXA7>VVJs$>J;XJs<_F(S4`I;1jFIfaY35N+iMHQv0%WHm)d8q-nbVckkmXIK`+OXRs& z(v;bg{1+qU!?shQNK&!*4mSZ=xHrm zlnhmAV}u;%iXe;R;Ov8dtyY;rvmBzQV?e^ldOfHL53?q47zrg?j>f}kFv1RhWda&# z_ruybD3ds5b4WW_DjU)@@reW#JrZ!9n2-M!Dsq0>Bx1foNRKFU6FWW-Qco@kusiE_ z$=eiaz_|uCN1bXT(KCJN2cjh z0SwT^w^7)mKvsIzb-1|@1{Bk^AbrRIbL%z(=?~r3t4rw8eQTtpR57 zkTlCn(aV5xpCbwlViSpUOl--pf;pWNF$J@@!V!{BMnO zyFl%2rXa1rmY@CmFh^nxqSD6<&5L$E zbID&86V#6E+SQGqfO%+h{2$8RDY&!n+ZK&&r(@f;ZQHi_i*4KLIGvtR)W->fmm9Al0szCVmB`_ga5lL3cJRec(TKgWUu9A^+&*d& zAI7w@?-udNB7ERx`e2YC;vbslFCyLp{Pe=JvJYQ3EbtHCAugKFo_S^eNa?~Uxfh=! zIGv?#c)9Me=5(cawh!N}z4+%}fAXe(MiHK{_}(~KJ>XBCkWU9WD9#~#-EpqS&|Wy3 zd69feh>0F(09&l0(uIp&1m`+YG1__66bfhHNi&K`iMAA27a#znFG(cd73)9p`r#qc zryb*4e?%9<_zYSMg6#R@VvY_UTlq1GJbC*(p@sxjmzNOSyW2R~3nwV1Bn-QG&e{F`++|vrH*Trm39$zbnQGG}brQSv1X(yVu`W&~uI8Iv>x8l{&p)0pW zd^Fz`+sc0T&;Ql-;y>@YCI|8%n4FWGu9!50^0A-9HP?l6zyofqsduzJJ>Xeue`j`L zJXKFq5lO6=V4WIETz|TA9t+#`VAB38)#qL zk6)?y`la`829_N>y~fQffhmR~jp^epT&#palv{(Uy5XkCeF$PeI!b+HEAauL9RL~P z1eF;VTs!jsRG0cKw&)_8=AxgaanFG+|G_~O82ei1G?$_M!)I{&p+z;*6P>}D` z;9+;VopN?Q9)NW=v2?ZknO@UTko%{@({Q_lcY|@IOzHBxG>>|-GzGWi?TEYOZ4R<^ zSN6PguLU??h4viJk8RNpZ1Dqj=we22z{?J3`M~ace0TCZ=jzwlbaF@qjVB?=L)-f{ zyHji<>fS&yz{i|!&HUtn{oWDt*;7&b zwe;U^$p6{!{-3QdbZH2H`Ns{}@ndbG{l8J3MsBW_|7Fh?HnVlGw;)yg@8&mE^}mgf zI6P_9lwiXAShk{FApt2V%O+wqp(YkZHNKjhAjf0!}OhWigrYv47U?$EPy8&x`i z>&96Bz$NdM;cCI*pO9zPjpdsFq886*-t29H(S^}(J^RHh zoF;KSNF~!tZC|-zlFFWo@b1>(1S(qFSs|{qT{zTcf;;c_?cLk3dFa*@%r^PD!-4Jr zPz!a}&yYYi>Ss{doW78-=16$k ztd+jz$oY%{arq^l{!_$BHtvoMbXPSa^BLYgV?z|*MUUagNt6l0|bSQ zm1}4Lm_sVJu4jU+uNkZ(g(9hbm9TS>#Gn(;jcD&Q%zIzr78K;NKawW)HPT_Pl|2pp z6|PtLa?Spk5M48xr0d-$%(4U?4FXEa|3nlZX7;O?4w4&_;U45Mt%tXKcSFwDEq?`y zh!|6@QA`qjF~vtGo!^m0T3)GynuzIsWgr_xc0W7470)nH7{FZ~9q=eU!D+p@mXp25XXz9CF0R_g9B=WyGz;1a{Tvj zv?u+5ruIQrdFhK7C7&q0MWyp_U*WMkJWr8U(;0u`@rhok-J;`}qwSLZ1)5JZ@yaoV zFwd+Qv3LX1RO~t~-!4)HNKJ;}8L1Zw$l_^ysdbhgAnliki){;jqrZw^IWUqRvZzfe zR$o(HN1QQKHq+{=xkGPL^N}p9pd3{^!7tQ>eQf`SminJJ?tkCK|2UHcNNzVnehA+d zG$0_(|IfSl-)xkqnYop{8L80E?G&>$v-^?L|F2nt=BEpq1>U!LH4d840kfWM+Q!zOw%Rs83#Gv21Qvxq0I#2KHT; z^HK<(pWNKG*O$qN=KMAJiiT7wneYkz(rsdGlN$+@S((}{);(8MRFfB$y3}=;v}R`~ z`sz)IyAuK+$yiNUWi(XY*=UNhhaz^UE)nG8@vpf7JCXY+l@BE$rGE3j;;XFKmP^253Q5%u6#HxHBi1WpnRfd( zsCM@p=4XTxe z&jya^sMHtr8YR?AW}C)Twe#1|3%vLOfKYEg6rK}UOfc>i_?Y@CG^7UY;caQRnXypa zm>CzZv!*J|u?MHjPP8WFlfE;%P(_iP)yt%^VhV2`D%{P!Sp=znsoa54@c)wO!7YqaKC&ej$irJ+_bX@EO>al96y_%^P>fuD2TC1rR zZ^LK4Z24@qs9I|334o9rVZVRGkd1E7nr|i6@Nz(^`Q}0Nu zQg%Epek;nT+Df&T9uQhhStW?3>#oN;VJ*t@%-sxcSBP96)Kcb2lUhYM5))FBY?KXnDI+>5H#k`|0+ z9~sMGQLg)v?Ob|>bUiv~2?W+oG)u*q@00?Tm33j)ba~IAKJi{#I4@ggUh#(L>^o0= z?|4uVOk=)+aOxIzE*kPOe~{;#k?z|<9YD*E5HyiHz^L5O)gT!P-#|d>S8Skk1#i^C z&()801E!OG_yfFoBMv>GJdleHrc7|$9aAYkyM9E{8iBA$8k4etO0l3m11_8=Ts|!T zPsoZYFt_SQ5bL7_D4rP!uOp`L{=c}X<3bl9ufmRy?(Ln;iQ*$#XdO^q7(|8B=Rtr>~3mhw6 zG(3+kcp;j2exv=Pe?XDYpTiIaUyOmeg&zrIfl`$?16eM>t&XF`%@XUn@xm_c9SniZ z5ThsGGq$!jlsfmKbw|BnPE*|%tdblZ>C>V`znd~yrA-4c!E?#h;i8Tj_0ii7Q8^hs zlCxvpNVi3uZVq)E0M$m5bfU!Fl6wmL*~3~+?$qUrwDHV3r_!Z(JjX|zMB`-*=D#Qn z-_p4033za684etA^N^v*>2XUT`RGp9zUY5JC6;b0NcPDvT1J9+O0k!EP-e60>?>gegU+=VI;@tVt##qpZo_y9YN1P z_$^J|2b=2$1iN1}$qQ)PN8HvYpZrdI9EVAYcTA5ETw;f1o>x!aKwYwzF^909TAaYS zVuRo0*zb=oEu5Wt(3gPh6r0Tw-p_Bju^-pV5Kon;aiXtZcKiS?^@*5Rl%kOb09y{_ zNSSE}1?+1;^@By_mO(bLXU@sLc>YV?;u92cKVP=jzkd5;J=w1e)}A{ym{T>y55ze> z+s{>l=yT)Z-B7SEoH8gMeotgh%Y#YYtMeC~v)(wZrB zdLI_)Tf_(1U{G3pB>o2U5BaI^LB`Q__czFYkk0?aGyfau{AU0cE&<&H^)udn{^>ku z{y&k_ohQPV|Y)?^7tHvBM5%j^|W4TdZ(7DqXmEGFM?pO=sU9-bzK&}w)Pc{nq5 zG;(rcdT(K}9BPfGifZ*`d*H!qTwGT@-zyd?XL)xn_OWf(n!X%pJ`3=+{QQP9fV};C zN(Au!En`)l^eeH#V;;!x0owc7fqU#F`*iG-=3~Gtkx2b4F5{00DFTAlgUt+iIxJ+^JJ7$CXIMGn|Yx_=tT1)X8ljy#tO3h$h2u)j3TUFfO@78vJ96F1KAkM}?NQFxMQLDA|OWEq( zJZMx8+0K+&Urn&=eA7L2{cO!%YG|z&U@Z6VbChpZ0qi`OY-MRm@?Ne}nmM(j=^tc| zJ6Ms?Bcg7DPzU;Y4h(KPZuifTBQmW}X7xdxQer$wuWW>PdL&(E*$@-jl>{^pDBE-r zEr4!=qISPGMpuqHz&o-JJt}DmrCrEQ5C)Bxw2yr?MR62LT$u7x^mRNYInGD;MZz;@ zcUzeta}jF0J;<4aF;_8An%G{{dcZ(Vls`AJnry`Nh-{%+M&Ba##%+&(oG#5dty|>X z75ez>*a0c%pfHr z^uHee8$idZ+vwn^A^9nwtRSUUCxdyH)JNMCpFmqapZXJQ!WurRb|ErYtNCVo@H+Ff}E2m+sy@kM{I@r`$xCS0Q;gF*w5e3j=o0HyXW+lPHFC?M23ofMjkBRKdlTxhq|oaAYMjX%<&6RwgbZ zBYZf@jr?)E4?Abe*2YwGB>nZvc3flfU@Azm^;&Uk~ zJw?}R+RDmo!V8b74@r;p zE>w4_(KZhzMH&Uk4DP}85CCFRiax`R5P5~Tf{kC$nnlkEZCmLbcnn%O2&%V0<2H;v z`RC7l3Ehs}$V?*NZ`x9t{(tQ;_76xc=_lS{;=`flX}A+EY-9sSM&5({DNdkzD9+6I zy-A6XLX?IoLm16w7f{~6##kXlB(&zpt=#&`?=wD0Dn$iS%Zb%JrT=+ODDG}3P+O>P z>LcgU?BZZ=@9~7~m@%MIlu4if|Awenn;gl{Bp4J916ch7 z8)tp&XD(f6ylNDjMT>dLTb{q%kB6z0Py8i=Ur{n>9F{(K`t{d}$FNvDPp9Zt14br8 zQp5(f&-iFNzo(zA>Wmy_dzedMPNF5}enBuow^Q|kqWs`wkV`q!ijMtM+ag+Q#V)gM zZUU_-t&5CqVKmf*RF)Q*U6xfYYK-j?>&fr)67?TVelLbabf`(KZP?SlyxzqY#1>eA zoi$)yXn(Q6+H%>}_dRID(>*|fewgL%R`_!0w$fq??6!+)I07LBf@1QG!K#SeiG}KQ z;T6|eKKJh1$*TBGfZy8zVgW)hm?0GM#sG+YBAO+A5aA`^PBmJm4AOS78{G;G_fC?d zUePvKf@efrJMM>nzl?m~DCUiV%7HgNkm(L&1)SB~cHEcMIx0!X-bk9GKk0{H(k`0nE_I89fp9 z@B9oWir8l*p*ME#?VS=6`wjRV^Dhe{|oQzkq;*{%<8y<;S0IYUFGx>1JW}U!HGLRV#ZNGiOBy z$N!h*^0yYW585I6x4#s50}mV*23IkYaS>O-p|TP&RuWQB;0$R9#QL78M-r{A`O@kt zkiK0LevQQWton?0Q*)!5j-V8hYGb%|Q+SsSVEfrOeXW~=Wi@w`He<%Xujlp8^XK+! z*Yi_4rUB0fYry?r459iSH+a}wT9ylV|hr+nHU%_7A7ebQ_hJ9f0h8x0s-v|N3+v9$iBbHAea=p;_ zo2@M%e(HS_82-3$Gv2=N_`5F(Qy=C4Ul{AU{5ArpJtp3%9Y`;(UjtYO^_(1x#T00` zL&)F?dsO0{S)u%6`4&NqK4}8^$}#;IIL-X!Iy7KWlOgseN`b3aO|9l| zVSq4Ny=eCgWIB1$-m8^@!c{66OwEM+%Gs8#HP-!h^J+~g4Yl>Tm=cV7lTx7~^rwrG z+BJKu_C?&~B&poAn&Dv9n%=s!8DbG{PfE6OL~U(j$_+akan*(*8>_Ndk4otIUAE#Z zV7hQM8QO}+VJ*7)P}jzA$JvfVDhI(>sN*q0d6E=o9rlgm%#L6jO+lQko=^sJQ3)+}_8Lhanw)hDn>Jre6Ofjm5* z)tt8V6l^s;9`q%yjYV6GK|8p+AS*Pzm0L!W*poxjTzSrHSKbS2cz zhr$m4YBC$uTn)RT;9rUaH%sQ33|eIe2Q7&$60q2*ipZAEpAxX;(lGXA%sfNG7}9rt zp&RsSnEA*JF5kkVSIx>oZqxS5qub0(lx-{5Bcwx3j9M@#C;E8X(>X7iw94*W_*5K8bKEdg zO3{}Sf6sZcS!MTLU2K<1*kTK)-jaN17Wmz5X)wW|SOfWj+~4b)+%4rI^X-NWp7OU< zhBca|8m*~)w%e<=3IC1sE7~jj;bBd5>I$S?-&OK<3>C zE(+bHL7DV(H2}gH?fb4uv@$bN532Z>a%{iHgbP6gq~>3))XGe9@5=WKR9E*O7nTd` z812*t8g1$6;I-H{O-YC2%MrA)lEsIB+vd+bT!d>e6i&4ey*rUGR45T`4x(VKDKG|P zDB2kuR&z3s={- zaI15$sSsK5V}m!`N^*FGfR?xfR9ar9eVB3hpSk1f!m^2ETMDx?PvEIuH0ZPC&wVCc z;O$9a|Fdh1vRU|iC{__w)fUp5abV{nzxD3GM#1@qMv?EcS zgtA1y(8#x6DB=y=gtA;9sIQv|4KGC1A8YU*(Fi1Rf!9nn%{$%&$BYL)sw6Ctlo92e z@kC164xAO$RAO3T^ppiMUSTm#Hju?q^kgH&jrfBXGpQsHKfpC zMWTb~Qw~OtdHiSc_P+F>$70GFEHN!{u294h^Szlp5ya9|=sh}w_MPsHV4Q-)3iE~d z!W=>oK%wi+ileIl98z%>iKO;5qiQY=3vXC;NKBB7spX*S zOn&-t%ui+_aUS1*3+hjHVqSKH#r64p454%mJ9iu!{R2^sGpij_Y2Z&!t9k(3wp%{G zCAfAw&KHB?>|=<=lHXgcG~q`IX;+0iMUh1nW#UIQne4~*NUmHZN7pweBq0lMKH8y_p!dAe;+ixqb zbr?YM`xkjNTrNFdXl1wXw8o~d7^{k>JCw!6`0RzYu@~OaY=)8AX+6pZ4I>^f_$icP z4pfFf6br#*WB|^+s37on#-rjAsscZ3B46dR;T!V8L+I46{#A+RW7FttBAJ!~-S)|F zth>wr$1!N`#IUOeu$=Mf$dGEjfOe&Y`RZLDj2YVfc_c32xl7Xr9!28KNUk|OetMUA zXM;S5p3&rvMJZ2oty)8lQl~qdel7{G{Jd4+^jeEj5vX|MSxSr!DVNcsn97C`vxF=0 z-;FqKbNH;%&jn)b%M`LU&10#gsi|qydlkC5B-6C|n5Bn=r82&9svsY-_``o?8QZS5&p}~ICNqlGQlG!t+MWrf0RE8f-p{oZ zv#(yEEK8S`p7<8Hy&wE*D8-!9cvA%ZcL?Oxgs7|+<5Crnr(`P7i3o|i`GT=O5~-c! z?snuSO$8F0i#~LHH5ftMelF%C)X7vUf{l~Z0dU;ej-No#0FpI^eU}8OB-qUwbZmpx z>2K_)M+>T@{Qio$`|>1x!KMe|UnS{2%yc)V+~{WfnL(740%1tdYNd{-C(vxu^@OYP z7cO~DLwz!laopnZSFG{!dxoQAdcwbY*lLcM;~RMwIHRJ6Y(7jBS*FLj)c2vt3kAC} zk~i0L_FML~Eo=w0Dd3_;qhc*dgf!+>L@1tj)qF5N4DvK??=ilfr>b7`WE5pF&5A;{ z4&?I4wxrSknD#?-TNmydxBs;gCF*~G@&66euYRaA6Hf$bb@rb*2-Ag z-b&oa#Z|@3mEP3r=l#+b-cxn4>4b|V*>t9t#d0A6nfzA>)F51B7S;eRGwKu(3(}#) z8VnH}Y6N*8xdov$$gaHdW)4r*)7Dn}+PaRugTr`NR~Osi5JOHXvV$TtpCf{rSzeq5C?A&nEw~<4N15wrQFlu*LPfI!GF~|A;$G)<^cQ zY3iSo96SkU2+z*1vi;Viq}3;{hBlc(BTHVP4wR;oB$PqDDmc<;I){BxjI&(OR-$&@ z{+%poX=}9UqO9?>=l5gHR%)2z;yawCJBYQGfkSGi<@Sy7RFvPYO156BZnPiFFw0Kq z;YldVe=C2H!4T+fwZ2KVK-|<)){0lq*J?Xw-jQ1#LVpLEg|bA-mt) zDhND`2Z}qcVY*DRzs7zYH`_!z3I@b z5?T0JM|ou9+m6fHIp~BM9?_#xWg&7c6K?Q!1zP(t9JX)Pfp&EzrRm|HFMHE3>d%tZ ze0H_J(kl8dgmrGL=%ZlU^54cYz`8OK#%7@{0~X2Ll5>sxTSF7v4UY)!i+ychyzZ(l!Xo$pz~l!bvoBfxO$FS^G_+ zmayoB1s8ua*Uco93H?oo(D3Ep#`d`%fvWs^*O90vTTCMNJY_{i*&+^39?mdT%RfS{5%)Ra zY=NHp)LUGM=CVtDos=5>^nE+{vPa2-n8s^VDo17|2s<@IRIh zH0BP0k;A)RyS}(BiHN7we(GCkUtbUL97x0xvF>_e!;OT94OP*b^~o%>Seu9YoA5jbfGKjgpy=WErfMQ0G^mr zh*6GVf<{5`Iqnl*c~%xzlZtPE z4Ug#GMT#dWO+2S&sXst=2yG`59osHtd=9^7U8?vTB1cIisT&y_vakmt!oSwC+ijvv z7wvQYkb6Ma%1<{ZqQ28h|2gGK;y_B%)A`-VE|r@{+=d`oX%*knE!X4CtE{jGs+eMM zM+Qmi5Y5Hf9TP{PNbMVtV>ZcJ!3`Oa@IgN$`L@c-n2C_pqNIGz0qVpKF{}?29=Q8T zSM+SGDTS^UFEnw9@rwX_E&M7f4d_Y^H+~ARGjvwm>Nafd6XWG$pbHm_#S<&P47s9K zOOP?W$}b|ve-UCILH%@d(9H$n2L4z2wwM

JGayQs3zEPfmFUi#ZWH<3!N{egXFKCm+DG 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 nK68v)*cmmV^J{ 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%0DIX+0+FG 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
  1. HQSU?+k3fZ2|@l^AEgijKR0o0dMIJj)-A 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

    &D^5av`T$Lgkl`vH%Sq{5Q8jJp)G`3898fftj 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%0Aw`23k~o@2Z4rwFNH2jk0A zChE*juRMcCFe0Z%4d0m5)VoNu)bOujC*o{X+ei;*QjhRN=1ABh3Id9tE~V8WbPB(3 z?Q#;&Vd+{{PL)#)qm@hvQ3i{uu@_xK7<6{T6|v5!r%1uyfx5F$e`}{abf9Jb@eThI zop6$q+gTRr?}USqu6V%4({wT(n+-mFi1e9)s_=ekzr&T$5Y<94bxQx>twi-{RaUV_ ztcIaMgVyXY1tiP*9#FoQ5y_OBPxjB-Kr$zX$f ztg!Iwsx?UwBT;r@(xZnZfL%PxRQdJ_tEP0|b!l~x_M!8995tTC{Eb#)@8L|Q!y#{m zX5YnK$WN(z7S?A+pE zkbW^haZ&ers`#%6)#*G$Fe4s0?barhYoE(Rn4YBO2U=lE2|aex@YgAt=<>j}RddtAR5Mrn4JxrBURYI|2pb{fjJ0$_aI0Q#r z+*u&kj{qBLaTjf{vwmC_dRaW9pbzFUUIJ(=yRf{s0!ge+8WC=qKLIa1&VM4Vd#YWn z^XmwOdTzWCUK}<0AuQ5WzgGkKgdE)|FK0w8)U+NpcrUXKI9ivO7o-+=5R_P#l?&k* z7tZO&*R+n~xaF2Id)PiD&N*`NWuHxIly#c(X>FBsOCWaRob?zM=GO%CnCX~{-CF|j zcEj?}!Fm~2nf;`IeOa17CRV(Af${97zIa&DzrJT~TG0dZG*zpA9Pw=syGBSr=Gu@z z8q+%16n3I|hU^R-$z?>-^Lqi8QHrgzXLhU7uc9Nf(dbw9 zt^+E^<}Ey}LbG`Kr^~0s%ueB&gRTne4^HXBeur@9v;_H*bGwcOdq5eFd!dIs-k_mIDvONx#>$`Q>d#1u8I}1do93{sCMmnF&0HVFK$pQ%HeaZ|*x+(sn zL4n!IkDv=`>P9=iZty@To$O&4{u5F-Gp~THp}U+vVcQQ(N}wBZ7CyfL6tK@ck+xka z{WoYmgDa@pKus|-UYQTIcZk1Gj(?Vh|1KKgHQbQHXdoaFpU{`=|0)`W21b@Z8)JGW zH~POj&A&PL$_@rLj-RZlPXvra5om4e0+a@td?NS%q~~{QLVGDMEq&yUPi|`Hf`UUu z5y2;slK7Y9`Gd=Y27(I(fUi{*(=*eL_Zgd{1&eNUxHK-ST36>S&r2GiX^Oz^hPVh? zUT$k%T0Cy84{IhLazFN@rb{rPAm98NrMJE6zTR}4dCPs+9(5$g_eK_ouAU6MbQ=zS z{PsE+sCFxdQS&Jw-uv@l=kAsO;r9V6g2`@g!=H}64{f)>!727`w{N3795E;jp7X-r z4J{hl%fl}2_Tmsqy`Ti?Fxo$@fbiMfC5&Q}Y05-oF^}^19HNP^_YBq*O~i=1St0JyT3HPRrWh~Re$Fpwq*-}3AE_2||X%r_q4tFHaX&3#f8T-R9ci%G3 z`lYE-2N&FMlnKk`1F^gIO){ti7kJBxvF;RT369-w5VPrz^}ZiwQED}U>zoMk>X4L; z1d6g~Ib>btb1GA>ElXsy>*5x>JB&XUgV5e7`k{NCC~6XE!3CuJNT1+Y6rbpJ3&}8U zT@$80VQQ~U4$vgYRNu;0+AAwM82 zAqg#s0;qzevDL*}oyAn|vJe(tDCpA^GCu%#N9y9u6<#jUmWyz#>xxn6Vn&iFd9XBV z#umW^7&)$sTaiy%MUk#oKD6OqFjR2QUjjUZVqKM6&-!HmEXvho749|^SumpospE8x zD1f08mI6v4mG|dyWg@)Kl^wtXGXA%;MV`5obwC-G+tgyqnbe_xFpII3R`P721TO`~ z@#%KhT#DiWAc0|W(~Ju(M!6L;p}UiG6MyNjW7Fm$pVSO)t}I?1b1qSWv%dUss9kte zUopge%S+ewC&@S`p&mI#aH5Ch5LEqRH95y|Na5Zm8_e?A{5vnIU1>GhD#nOV2sjxo zYsP$bHNY@ANpxL=rc6xrJiP8gEAY3nSlS$gj=9rF3uZbVZFDnoN={A;*~764ImSBv z@dF@PZo)JppczZL^aY8f)rKWNv2qYOqTG;zvlm654hR-;QVl4QxHcZQ>Yut`w(w&x z-yI&zKMO&Oyp*PiDlU#iWOgL0mbI6PI88aXF9sLXf+{=+SDzIpQ@g8ibUlU2T-IX5 z9G5ZrDWN3|Nk0`@q-L*7=!bT#&<$`@fQ)8n&)Q1I*=&;ny<0BB|8ns`8+ zK(-j`H$UDm^$6TtZR)o?dhMr4>ZHt3nonOyHBs=zo~y@@!$KlgXWKFach~bU^mHs3 zo<-@8(f(ue4F@SE(M4i_ZlEQ88Eao*&x|2Oyp9j`)=(lj$ztk9GXr`!Ca*?6`jG@_ zx&$>FtGEL#cU_fSgZ}k_c@3f|PQaYWwN2Ln8(}bp1uw$TkyNnkl7+C=vQG zYNL00|L>#~yVh?V5qSI*%-yhX{vt#vaY)g2j~}jm7lAf}nY8lgs|T5|bbzld_u3%p zx&8PCo&)LGGIX+Od}+m=ZsTSq;%QY4W#Z#|Yz<@WBx?fTzJXC9wv`Z!LBk40mGROL9`MlTp-qYTBQbW8%Y=mv zY;%3Y9#kpvl9Dwh_CR-}G2uDO+HyOm#Q3n${iRE7d%(b47OM=IB>lIUAi3|0HWYL< z?fqfSEEH6!&7NP_S1~QC;fJt1bSVZ7owf^t3)Q7)vZ1ge2OFk2sco(Kgk^sQXR5PG z8IC7~#O}=m?Rh^#d*lMHOA*Z6_@C_IYL@KqYF19LJ5&qLPdwn*cL4(lt>-~~qw0+V zJKrPw;VP(>PQG?1%tErhAbP9Mim|*w<*nzvUH^L)$F-+h|ZF;ypU{F%vs;r zcY1k6*pNz3QfD<}Sql=|l)N1snHhKLA^iB#>s<6Oy8e3Cwy%e$-cD7wTq`F0-d7+6 z_O3i>D|wo#_>!EY^1kf!V+UVq>7`UwRu(97x)5+Rd&2Bg3g9*~B^2~<&jYy5Z3SG- zoisYthU_dHv#g8eV%$SSUlncz^pq)J@DI|aF>DF)5%|mvZ3c}nC1mVuyq>h}dyg?Wn zuSAU1BMN`z1lmKfkoZ0cAU9E8JHG<8BwXdk`oe`rB8{cJRWrwaqAB?K!;qY%8=9W- zIrdY|=$>KElH=2ji^7L`b;+EZ{fTI0F`6XYqoQlr((FOp`>nlu-sm1Ve#Cp>Xde-N z^!oq+e?A7QN4U?A`ZhK5in*DS;{c!hIr>vI>~0#gSId{^yd8^s?zLy$w|q5m2Dwx0 zxA^y>x!hBF?6>6c8&KW(6We>&Xx(_B_rMx*ZB+S?Be_PtS9@xirzLxqQ`<<=S8Xkg zWmETPe(XqW>~6`A#S^`ITewd9(7X?Eem9xIkNI=#x7h936B!Sw!P;A#=$JYCXjySP zv7_-e?ChiwF6X#ssm3p^W^4tX?f1Ar{b`&6jcZn-112k0@R^OfhTVy1kls^dR-#_Y z9MyT0R&-NGB{N852via`lzF}}M2k7^3fc0EPgR=}XX@Np*}qiCgMJXAE(SIJQlu{V zq8ktzn2AoZzMvRX@_!in2Io%0EzM4MY}-zLv7L@Pwr$(CZQHhO+qP|YHuv6{nmb#& zvs?Am_ZPf%&Uwyxpi)MGvum$w>G~D0`h|KH_E(UBY`xEeCR0u;hw#*Wm$7d1q}0{! z3YV5kNYr8~Yw4S3hp~+0MuwJr7`T*tLT;~`OYS;V&^uG>U4D!GPB_7_Na`+8{~UPX zDv;S99{i5Zsyn5FHf>L$5vQo3PqiimPr1j`T+1_-e6&S2w(R(;MBd0VFtLNa43N<3 zE?b*4!H~OCsH0s(qbhD;(&d2yRh9-LsnJ)ZHd7}-={6IT%BxX2$S#g2tBw;1 zb@nUr!s6GT72~*$l<|ye5(C$Q5%+ErP}TFYiaPi?C334##N|vvv*v?4N6hqjw*Y4r zj%bm z7;0~<0f>j1azKLN8{%E5z~Dww0*&=`abh)I!{-#P9eoR1Ua=e~R=&x(DTvf@9RceM zOHh2N1o&vgh=4w+VbXWU^R7Y0ajP3$Ns4=u;hoZ{sAtSLgRnU>%Q-eP6LkH0>8kK~ zP%X#4=&S}_(8mE?SUg_nP5mW(-*gz3x|~gXUkM>RFlMX_dq&5*v*=i~r$Zij=2pLK zU%3Y}_%qhVn5`_rY>A>NE;uluWrC~hae64<-{`frW4iD;kFk+NzI5w?EO7!XY4C{J zS#kHQkiZN_Hw}q^$ktVC%a}8NNJ)|7u?gq?tc^*x2I;^nWoPjS<~FHNySMj|z4@TI zOrdXvvvudJv4NcuC*AvuizRyUyw=pE(uQfm-jHcTZY+0rAA#m|>XL*{ouh2d>rt<~ zH$fi~d_*-zzK^xt<2Ps^>&W``^H`atK18aLJbmEOiwC|TxM4w!L{xdD zEN1SGYZvgP+ALjZiJ8cWeF&bU&_^|fLi&|xGIi4M(cjT-!!U!9eAv29b)lfjq~Ak0 zUdDpyc5)7xNpmMxF3x?gA4g>vsSxd{>ikk4ENAm9?B4K(nslFQCP}3Wvf!0k`4vLN z(Q)eXXL?|aUwNTZ2qSF0N?DdOjGeHdNG==$QC*S|Wl{Cdx9mMTGhS;hEX%Ddj>>0evT9sNLxdH! zmyzV^09;Hup<4$^tQjdFA)foDVrbPZ1vqM1x)K@zBPB-m8W3_5&5ataslld{xqext z1o5QN-5jP2)5F)W?vKR<9jg_EDNR%2c?44gq1uvIZidIBWaoQWRoZd5-c{!_USQi= zc!s#$0EDp(;xRv#OynlLNhLij0*gYAkdY}!k>&vwjKxSdWAi`SRs|0%nnTv7p_!{$ zHIaHXnEJJnrc?aW$CQ(LI$DR+v-!Cpu^9$(N1>E~q-8y>YP6FiU|F1%U+aNx#B+U) zI-0%fbsP0*hCF>NY0*gjYn;V%zNd6Rm`%TI_NX)h%lTaJo-N3QOFxu)FXdia`6D%h z&lj&@T4GOmO4jf&c$Bp8?A7whztz^|Pir@gr+WCoPRL;I) z+hFF#P?1AUZy_O8F<5={T&(`W4-_yLPB8p7`aO8DdJpaoC;~c-7CV=B>Mf_&*TDlx z-T)o59YtZi1Fwj+$nc4!lg$zab;EZ0S&PWk$l7S#i#ECJ%v%j*Vi9%Ny$YhlcUvdc zA?`r??>oSt8ZO>;qajii6SfMMb95p@4bh9m*mL9?1jKxCGWZm>C#5DL@5-~ z?IcI1EXA$5sonbK3VWp{>^>&v$W6`t3a)^#{u1JaHjk?Q62gn$ffkZvT!9#kR}Aif z)06S#kC^VM^A_2~%WUmZe|=)@9QQvMaF?GcD@c^iWrtKy`T=5eYS8_ydTe8Z;2Pw@ zdRgfHBzsg9XvRduLj)vKy)b%QRwzg}s(&|0NOyVYF*NlcvrrCSVoQ3)^ANjH6kozq zs%o@Hj~spt)n_O(-c9RKIn|}MkQ`ymyE5x@RI3%$13&N6Y)mq21q*NZPv33OFzskr zvEQ;6J@m3)qthU=70c>Owvy3pSfQ;vl1}ZPW>1s97<1L8j7GPdyMApM@1)cyv%v2E z1fAWrSHa&RREHc$ZIsHc$Er6I5-PONP&r?V4tLUPnSO-sh|V?I}!(ZE?y}sGD|#cWg|PX8g3QlD>Csr5w_E%INWhTC+5@9^1Dv<)J15nv`nt*wAr=?s7U%&#N}ysyR54nSj!HCnJX zz)KAWH$M=s7;jV|=$5PnEoZa1?A2NV>rbCOjE$g)R%vV4h44syR0^n8=`y+79QG(A zHTEY8U-p8=UD}42Ky1}|4)!6X6VT~aV7w{X`=EnW38UG?1)~8b zF-Y80nPJ*gh}bl4MxMu47aM+*yWdnXk*n#V4il{_Bu8C@#2Zfhajr}MehbUysi(a> ziqM@!$yT;K2oEVC1S9YX zjxDzVZPN>F!v|6xNuV_yyE}xvGZE|0Md-_k1q*_p-+0bO3cg^ke}+|)x`KUX`*S^# z$_heX!2>**#dhI%q(N}6Z)<1kylR)+9vp@gb+zWsjuybqE=NPR+7B?(rQ>pH?+P=xVdFN~>LQHgw2o<7)wG*2&Y(^tC9hD_Nnto=pAU|kmW5_m|AqR0bxeX+?&M`LUR%ZIjM2pg@n zf5O3DH4*DrTF%DB*Ma3^OA`#dL zD3O)?k}b;llK{D~%(YQ*JIp@%e!1%fZbXm%2Bk3P`FG7Af;-ybbcw4Ri3F@rMv)&I z3_htKG*bcgl1{yx?COKEjM6ENcB}7FaP)7q5944BRT<*b0UnXcbgy2SuW5|kx~l7g zHaNyAHVK+Hz+x9NQLX%Lm4_)uob9GD7u`Rnf7ll(bpQ=xjS*%Kvc6JuK2~4AV=``z z|8+F1%=~=hHln+_jBYmgxXnLO2dkdTodQloKa#`Mkmr5I}`Q|71isq$R#w zXLzg(5v-CxcD)&=l?X9PrGQ+gsos6$MhUlyxI(ILL zgZs(YkZvdLKYPe+qG)u{QBvBs`1O@qY45kcv5R=Cx8Z&)rJDLH6XN~Q<<49t_k@Ey z==!D|x+vCnr{h1PAbu*nD@!n)=d_2c=wfU#Fe<2zV$*61aEU7Sx3)#}!rdQirWf)+ zbKG;c@Yz-_nbb2KVifBhymlc2FiZ z=>mmscd~Dc&G+k(H+n+mDmPb_kaBT{gjV+xIquoMb2G4OOp`~1B;mjMdPcXqcdyT! z0X!9E(5JPG-$8pTWzBm^O>5v$d&g4EmMNA6mTVplwW@eCB; z{HC_qzfb&G0{K%tOpWI#Bsb80^_vgT(RE;G;l2F$h4%u*5wNW}+VlZFPn@=Df6e~9 zVL!!v?0i*)`t^SF{Ntk68Cjwfya$?pNED>l1HPM%96+A(6jmBWC`M^SSKjAWDYuAF zpdkxNs*o{M9B^UIV zswcl7#c~mk^!s^;`Xyz}RfaxD^g2L?Ta>9VRrrH!Ho>U(b^vdOXiZ>Y&!<+!Mg)xX zh<-L?QOTr9a3-lvT*u3J*C>3uDxXB01u`Udb_#GKo^4R?Z|bLRH2_bCT0!v9P(kqf zm*(C+-|z{HUj%+cw>hh$ti%vDmyrbd2K6r%|{jw5?0l5@%zQRmv{7#zmG zMP#Kj#K|9a#5O;qmKrEcXEKB#iLO(q3fHywwQ@Eu9>uJNRI%`|)*s+IN+xkKnD#eK z%Gqj@WipYdv6czaS+iB~z|AGM{PY%YdM`H`k5c^uo6;nZFIHutDm=S8QB@+^@e1>yPqQkmv<#j#}s|@;x(F_lXD|=JoH+({5c@*9z--Q00D|l4r+RpFon;K`y zVP%$%^og~^(uOc5r2HzSyiPMamJtNAPG9Ued@_sE8F#j+><_FfuFjsLgOwyvpQ=KH zN-`4*P)Lv2TD9xPS%kT~RNk$xKMD}3Ba6%^sY|0ttjw4-4#QnjSjTG*VDU%S(+C!8 z%HOetV6`||suX|D&|krHA}ZfyX+R)eo{K?rGAxQ{37<{}j@h3#Tn{ylbUFU};>4MS zvgI^XZ%CF!%brlfVjf+*0|6twHxAiFI8;r^mcMK6BG!-7BHypsBHufYnblj5`F1M` z5eXnaucPvm`YoApa*l{kaH~a6*2Go3>zc7>1Fhf3Itu0IiMTy;BiT{1qmJ1XnY?oT zwO!U5Ue&X&p7`OEOhyJH-Y>aQNI)?nQX|g)+*shI{z&aGjv^3tox14RS_Ym-6BpCb zw-eHjLR6Zke*l7w+zb~j5vC-$*kq%qzb!{sWs^h9#adMYPMaeE96WwzcS zaUOPM#;P~${C!}(esZVgedE)5hY)LW2-f>FZtRx~pPS5i7V@HKHIbn4NUGqXRkW z;nCILBkBH0?|qV5f5Uq5*sS^6KpG!2CHhs|eX)6l4fUSa3qkTyt)R7&r-cj|M(CGu z*02l{6P~=iv;qjNj(zwOYMwszW9-q6kj68p9`1%0ENhdH0NTtPu9lh=L^V}&!20>L zCdYPOXvT<@R9#5y-yh4n!7F37oL&+?J^}(iDDG=QkiCL*Kd?h)y5cvhRhtj1)_p6x_yBf}l1cN)!-?4%oV;r{xzpOCQS`0Arykc@EyvH_DS;+# zo@@H?dMWs88(Ogjr%2G{cC*H3(!BTS858+EDf(jnsY{Vu%XgC=yBf2r+Kdg=lr*Hu z843JX{lM44LwrY7_Cc7cDyp@m7$pWanYS|a^%ArC zXUG z92oe&x9R_C;Quf^u^PSJoBnR#TnPUI2lqcO!2hj*f2$zu4CVjn(I#qTWc{Dr``a0J z7{d#Vx&l5tRPka#3dcZi!g8^fJp$s8js=}yBjk6l3sIw@#%KL@F{0IAS}YBcD$C8lX07K``K%F;^X~l{aYFVy#>oR>_FW{ zkF>Y1-iZVQ!%Rp_2$EeklsH8lx)s67$%`z!UK{XvGH^_q$ zwo^TjlQm{eyE#%5o??lMN}Wc?DVm;0mFo5@UdQF{@>KKX$dHDh#AdW7)Y4FeUrMNr zL8;OdCE~PHDf)QgR3y`1gOu9zre7abC*(NrBsmb#n{*l&Q?a6#E>tXKJT;F$S8mUP zBupd_S>*tzC#>)9OGAwpy+NLRz=oFRbTasf*gkY5(t?kxVxgG_lu5H8XVO8Ev`e7r zS*y1n7vc3ecCn{QM=>Q57Zi!8AQkF8RO(koULc)t zn6e2&70PNwYqxe6v^Y)GP(c(uR_J!9Q(?9ocEU)P&za9TxFdytS!b$}Ry{J*wVYbf zz8Y=hA5E9$F5vI&GFXakmm$<{h}(;xxWz5MxYI`z9ENx}bwT9j&`X)QQN+>iUp{Sm zcbyDhjjd2YU>E6Ub?`vip1Z~Fs?M#;dQQ0x0sDZ~{;=p`svz)SQx7!rr({v#PJ$Kke{= z-92+F{vpP9P9q>Q{5|^Pe2?hJOrOy*axK2VtiMgiW=CgzT>| zMyD-7+vhL-3h&V`@qR}*_h#dezvMA=LlHv(gBALyb$dW730IvosX5Y7h!*xU$D{s# z4g)jIA0uaOjXw$}ptNRA*@8;^3M==(EvraZ=G0Yzpi^sE~BuaJ_dj{S=2#r8Fuy^h;I#hSjKctvjvQ zjwy4JnS0o;!#28_J1QH315BtANAEJ_?iclAOG6IkSonE1_D)FQ#l_b*oGPH!&C?cY zhr}sBHaRKOmEuSvGIlK=+e@_n8d#|WekJ`_V^UzMr&z6yKD6t@oWg9PRyh_~Ybx(N z-@FWo7F*1NBkvp2Y6v8`7wMG%A)%CchBs5B9XYZ}eG2d1_=;3G`%wBx<_z8oss0xh zkm$E1Av7#!7usMmmgI8vWgEEBu4<|TT{J!l`8$!nR_-RaWKr<+MV5#LC6X%NKwBN; zmYtQ}8S4S)XT6s4&$X>VInQg+-^1&(v51`ExJNSEyCI;4gm7~Ifi z9S$QaRh2*wg0!XqNNGH(A|-l?XeHTZKWq$Ud5T^!MR~Il4EZdJXr%`okfe5819t4A z$KS`2Bt7lG&wwV_F{Gc{x~?O;?VymXgT*f%Y1+mzgWC8Dwpd~!$Lb|*z15Ukfj-=V zK-ct?95UfjT;tWBTNW9D)$T-)ttDKpd&qAd6VI(dW6g`TQ9X(!tQ=c{i;^XgC8{Da zUKRN)L%lQIIi<@vpnZ;u-oZRrCmX*z{RS$=hHzP~a(pXAkR@&!m3MK`w1&a@A~msA z(0V|h054>?k>Vp)jvh8gLFTOsoylwd&?X1?e{h~>_XHNMMAhg=o=vCFi>Krl+@ipm zT_1@071i%u3g;$_zXaGN+yDpA~16-L_^0Ob#$JNDxr&NKSEY4gj?Mx3<-`8!ke zBnKruv&$6bs_!eJ<^n~suG(A0MB4iVTk%>1y(GOYkB_)4M@O8e<5t>&6>Bm(TIY3l zXf$9dI{uR5(dv`;Lyn!$PH?H6LezT+{Q+TU@X93Z(29V14b5t`^9SWuS)uYJPtF`# zb^ak~RFJy42Ao6t2ANTLJD0RY4z*8@qheV}8znB0vksf${!dBI*ow}8eCSGC4TBVn z2fjEBjE<*bwz`uvyT18ZR-x|&eHu=ILxiKpcu4rQsTrFzjy+p8?>G({d9InxGmcQYshnZv!Xu7XNXX{8=3|bF zP%okC0%b9Uro2_9gXJzr1=s)7PX7CZ@L#jTKcot16JY$j-;`su?@+D(t9J4~X9xX% z8VC#gz1~)2g+9N3p6-D7u+O= z&vnlvf^BHR?p=udSZxWy99_yW&d^>M1Hw5b!0krH1O2cAkh36i$&ce;#fK|`P`eFW zaom|N#5t|#4V5N5L<_!47kQgeVZvDIt9Tzx!Ce?H@oU1?)18s)m;?1|*8sFw31$SsI_j0o>H}Br@~8P` zt3F;V*hbkTJ%KC})Vg!E9gkKzYq9ax!TiPh zaS>&S#}34|z$s><4U_DNZNV3G4Pq(+cej#qqxX`_#v3A{>Rl=NP5!RKM1be7U~vI9 za}>+@>Neo68{*y9X>BGuxvqd^F9CHeC){w*SA7q_VO*SdWKS>YFwVx61_c9>lH z-B&Wj203#s0#K(N*I%5o`aMDU`Fc9IRj|`O(Ph5lDs(m=TmURAg=SxKJBlU_9ndOq zuRYsYbQg%uarK34wqMr!K|xdbP8u4c;bGS7P8*}g)W|?%vEJw+h3)MKqjVcaa z^U(R*T;J%MT3_h{rR=d?Mvtmo{YS5&K57J>m8l+Tk6x#aqbjB32vKt>7Wrth_Ddk= z0kn;I+f{I`GSo5)MLC)Nq=C>XhhL7X2a85r?v2X;HHCS4!O(1+;c zU_~pQ|EH*{D{|ytY+*3qlp5Ei8SD zy3l*X4Csn3`+{}hCECBkM!*mTwJzk7hLSv7Vxx0o#7jRDIDSh(_jb<~?eA!x;4ah> zi1EB*h`5zB+8xss9(fN8@%3#Ly;Gn*pAaGROL$DyZ-ie!td zOzFYR&@HR$AeP!8oXYc~KnVdViuJiBv%;m_kAWQE($alNGckqzWSj88fKT9!FjDLM zZ617jWtU=hS4|U00ep!|1M1HQic8tU2TgH?9#2?nCNWX7XL7Q)A#CP;nKuq!R9j5) zLHiGU_wSYXzt`x!ouaR!@A_Os{6DyD{~v0!!GEl2|B3Sch3y8_z+BY76A-JZ-be53 zsWJ@X`M{;}Tm+r=VswTfbTWXPdf4(s$6S)K4wFp?xC`k)_@Nx;Q8|1PXoP*6bb)Pb z=J?4I6gf_}+^>_Qgr{4tRh25pRvB)XU%TF~IFA1sf3taI?qJH z-0NH;(uZ4Lxmcxb?ul8YZSR>_r)};*tg;S|!Z$oZ(`oJRQLMVogs{4XI**Y(Hp7Kp zK>c5f{HzswqOI?DI3c^#VSMpiXMOPQx3X*g@G9Ogg77})fq-?sfOx6;s^0=Yx}Wq& zV3qmL_{@Qmup@Dcm?peRI`yHcv2>d>kJRi-KBmi=hrz#@jBvPX+ zECv>nH{vRVYH%2i-}OnF@$+}np~G3~7p100KUwy3e^4REcLtei5ccFUAzQ=0MlGS0 z062qiw36iA@epCpPcY%F@tXEA2RdWs_7usuKU-N=qlTE&+U#un-E^C=&=v=is@9i{ zFG7eeoMMnu^A;py4$1s!XdaQGTZLlsh(`T6XZiDL$|agVF- zZ4T;c5eW?Ldc2kW41QpBTEj%H?U|DZGZ87>csD?NhKJE~pbr(B8l&h}5hoSY#0{-u z+EW0N{Q0t6z;yhdp=V42Zi*SH^l*g{R~GvH2r`Gh)fkb|UKfiVa4?oR!Qukt-a*Ecjvoe2mCDPIRlJ*9r1a})wRi@B;qzv@Fex|FWz10AQQf*DDhFchv6T&!9hx#IR24C!HsF0j9%wY=$@RT_vQkLc{FZ0Q}u z73ml};-p~lBb1Q}c$cAOo=Pe-;YE_CVdY^EvfL7aw^CbF(hIn<8R?L4ZA{5G`vf*` zz~~1}J|3pRnrxQe7gJI>KjDthM1ZJM_HGADFJs(fCOU?}Uq|`yLdPflkt{*j#Hf^E z?SzTM6h{wiGNRR54}X7PBre%uie`XO9P$T;;!`TqVm^t*RH<^werYcFd!|GjGwW}H z*iM3)t*Zvk?Ea|^U-wt+-?~81U7sj&374V*TCuJmaQW}dY-6fAy@JN^<*3zZ7L#>S za)IzDz2znHgLY)%$blbUKinz1YK|1`v{(`k#grgPW3ERjZ2}J(n@>VF8$wVo;Y=Ov z^fkjh*223Xg#?A7b)7C5P3wE?jE#ai*>x`WRbqv%u|iBpC&vZaB9R9fwU

    1lk|+ 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

  2. )0wq{T1e)*snFLQ9sM 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

    VUoky1CC~=e`9Y?4HPGUuJOaS{;0Ceh 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 diff --git a/hugegraph-store/hg-store-dist/src/assembly/ext-lib/hugegraph-core-1.5.0.pom b/hugegraph-store/hg-store-dist/src/assembly/ext-lib/hugegraph-core-1.5.0.pom deleted file mode 100644 index 90d828a15b..0000000000 --- a/hugegraph-store/hg-store-dist/src/assembly/ext-lib/hugegraph-core-1.5.0.pom +++ /dev/null @@ -1,441 +0,0 @@ - - - - 4.0.0 - - org.apache.hugegraph - hugegraph - 1.5.0 - - org.apache.hugegraph - hugegraph-core - 1.5.0 - - - Apache License, Version 2.0 - https://www.apache.org/licenses/LICENSE-2.0.txt - repo - - - - ${basedir}/.. - 5.6.0 - - - - org.apache.hugegraph - hugegraph-common - 1.0.1 - - - jakarta.activation - jakarta.activation-api - - - jakarta.xml.bind - jakarta.xml.bind-api - - - org.glassfish.jersey.core - jersey-client - - - org.apache.commons - commons-text - - - com.google.errorprone - error_prone_annotations - - - org.glassfish.jersey.core - jersey-common - - - - - org.apache.hugegraph - hg-pd-client - ${pdclient.version} - - - org.projectlombok - lombok - - - com.google.errorprone - error_prone_annotations - - - - - io.netty - netty-buffer - 4.1.52.Final - - - org.apache.tinkerpop - gremlin-core - - - org.yaml - snakeyaml - - - org.apache.commons - commons-lang3 - - - org.apache.commons - commons-configuration2 - - - org.apache.commons - commons-text - - - - - org.apache.tinkerpop - gremlin-groovy - - - com.github.jeremyh - jBCrypt - - - org.apache.commons - commons-lang3 - - - - - org.apache.tinkerpop - tinkergraph-gremlin - - - org.apache.commons - commons-lang3 - - - - - org.apache.tinkerpop - gremlin-test - - - org.apache.tinkerpop - gremlin-driver - - - org.apache.commons - commons-lang3 - - - io.netty - netty-all - - - - - com.google.protobuf - protobuf-java - 3.17.3 - - - org.caffinitas.ohc - ohc-core - 0.7.0 - - - com.google.guava - guava - - - - - com.github.ben-manes.caffeine - caffeine - - - org.apdplat - word - 1.3 - - - ch.qos.logback - logback-classic - - - - - org.ansj - ansj_seg - 5.1.6 - - - com.hankcs - hanlp - portable-1.5.0 - - - org.apache.lucene - lucene-analyzers-smartcn - 7.4.0 - - - org.apache.lucene - lucene-core - 7.4.0 - - - com.huaban - jieba-analysis - 1.0.2 - - - org.apache.commons - commons-lang3 - - - - - org.lionsoul - jcseg-core - 2.2.0 - - - com.chenlb.mmseg4j - mmseg4j-core - 1.10.0 - - - com.janeluo - ikanalyzer - 2012_u6 - - - org.lz4 - lz4-java - 1.7.1 - - - org.apache.commons - commons-compress - 1.20 - - - org.eclipse.collections - eclipse-collections-api - 10.4.0 - - - org.eclipse.collections - eclipse-collections - 10.4.0 - - - it.unimi.dsi - fastutil - 8.1.0 - - - io.jsonwebtoken - jjwt-api - 0.11.2 - - - io.jsonwebtoken - jjwt-impl - 0.11.2 - runtime - - - io.jsonwebtoken - jjwt-jackson - 0.11.2 - runtime - - - com.fasterxml.jackson.core - jackson-databind - - - - - io.etcd - jetcd-core - 0.5.9 - - - io.netty - netty-handler - - - com.google.errorprone - error_prone_annotations - - - - - com.google.code.gson - gson - 2.8.9 - - - io.netty - netty-tcnative-boringssl-static - 2.0.26.Final - runtime - - - io.netty - netty-handler - 4.1.52.Final - - - io.netty - netty-all - 4.1.52.Final - - - io.fabric8 - kubernetes-client - ${fabric8.version} - - - com.fasterxml.jackson.core - jackson-core - - - com.fasterxml.jackson.core - jackson-annotations - - - com.fasterxml.jackson.core - jackson-databind - - - - - org.apache.hugegraph - computer-k8s - 1.0.0 - - - org.apache.hugegraph - hugegraph-common - - - org.apache.hugegraph - hugegraph-client - - - - - org.apache.commons - commons-text - 1.10.0 - - - org.apache.kafka - kafka-clients - 3.4.0 - - - io.dropwizard.metrics - metrics-core - - - org.glassfish.jersey.core - jersey-client - ${jersey.version} - - - org.glassfish.hk2 - hk2-locator - - - - - org.glassfish.hk2 - hk2-locator - 3.0.1 - - - org.apache.hugegraph - hg-store-common - ${hgstore-common.version} - - - - - - true - ${basedir}/src/main/resources - - - false - src/main/jni - - - - - ${basedir}/src/test/resources - - - ${basedir}/target - - - maven-clean-plugin - 3.0.0 - - - - ${top.level.dir} - - *.tar.gz - - false - - - ${final.name} - - - - - - maven-jar-plugin - 3.0.2 - - - true - - false - true - - - 3.6.3.0 - - - - - - - diff --git a/hugegraph-store/hg-store-node/pom.xml b/hugegraph-store/hg-store-node/pom.xml index 22bffb49c1..ec0edf4824 100644 --- a/hugegraph-store/hg-store-node/pom.xml +++ b/hugegraph-store/hg-store-node/pom.xml @@ -121,17 +121,6 @@ org.apache.hugegraph hg-store-core - - - org.apache.hugegraph - hugegraph-core - ${hugegraph.core.version} - system - - ${top.level.dir}/hg-store-dist/src/assembly/ext-lib/hugegraph-core-1.5.0.jar - - - com.taobao.arthas diff --git a/hugegraph-store/hg-store-test/pom.xml b/hugegraph-store/hg-store-test/pom.xml index 31ec720766..d66a36b62b 100644 --- a/hugegraph-store/hg-store-test/pom.xml +++ b/hugegraph-store/hg-store-test/pom.xml @@ -210,16 +210,6 @@ ${revision} compile - - - org.apache.hugegraph - hugegraph-core - ${hugegraph.core.version} - system - - ${top.level.dir}/hg-store-dist/src/assembly/ext-lib/hugegraph-core-1.5.0.jar - - From 3125222cc38b7ae23730b0c050f75d483ba9769a Mon Sep 17 00:00:00 2001 From: VGalaxies Date: Sun, 10 Sep 2023 22:30:34 +0800 Subject: [PATCH 18/26] chore: remove author comments --- .../main/java/org/apache/hugegraph/pd/client/PDClient.java | 2 -- .../src/main/java/org/apache/hugegraph/pd/rest/API.java | 5 ----- .../apache/hugegraph/backend/store/hstore/fake/IdClient.java | 4 ---- .../hugegraph/backend/store/hstore/fake/PDIdClient.java | 4 ---- 4 files changed, 15 deletions(-) diff --git a/hugegraph-pd/hg-pd-client/src/main/java/org/apache/hugegraph/pd/client/PDClient.java b/hugegraph-pd/hg-pd-client/src/main/java/org/apache/hugegraph/pd/client/PDClient.java index ae57e622cb..6c86f96376 100644 --- a/hugegraph-pd/hg-pd-client/src/main/java/org/apache/hugegraph/pd/client/PDClient.java +++ b/hugegraph-pd/hg-pd-client/src/main/java/org/apache/hugegraph/pd/client/PDClient.java @@ -54,8 +54,6 @@ /** * PD客户端实现类 - * - * @author yanjinbing */ @Slf4j public class PDClient { diff --git a/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/rest/API.java b/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/rest/API.java index a4b83333ed..dca1d58d02 100644 --- a/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/rest/API.java +++ b/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/rest/API.java @@ -136,11 +136,6 @@ public String toJSON(Exception exception) { return builder; } - /** - * @param object - * @return - * @author tianxiaohui - */ public String toJSON(Object object) { ObjectMapper mapper = new ObjectMapper(); try { diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/IdClient.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/IdClient.java index 582e7da678..3e42bce2d7 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/IdClient.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/IdClient.java @@ -23,10 +23,6 @@ import org.apache.hugegraph.backend.store.hstore.HstoreSessions; import org.apache.hugegraph.pd.grpc.Pdpb; -/** - * @author zhangyingjie - * @date 2022/1/17 - **/ public abstract class IdClient { protected HstoreSessions.Session session; diff --git a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/PDIdClient.java b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/PDIdClient.java index 2a8806a770..0dbfc56eec 100644 --- a/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/PDIdClient.java +++ b/hugegraph-server/hugegraph-hstore/src/main/java/org/apache/hugegraph/backend/store/hstore/fake/PDIdClient.java @@ -22,10 +22,6 @@ import org.apache.hugegraph.pd.client.PDClient; import org.apache.hugegraph.pd.grpc.Pdpb; -/** - * @author zhangyingjie - * @date 2022/1/17 - **/ public class PDIdClient extends IdClient { PDClient pdClient; From dc2c9ad543dd87d702f91a9bf8c5bfa9c5effff6 Mon Sep 17 00:00:00 2001 From: VGalaxies Date: Sun, 10 Sep 2023 22:37:00 +0800 Subject: [PATCH 19/26] chore: remove AbstractDistributedLock class and lock method --- .../apache/hugegraph/meta/EtcdMetaDriver.java | 25 +++------ .../apache/hugegraph/meta/MetaManager.java | 16 ------ .../apache/hugegraph/meta/PdMetaDriver.java | 46 ++--------------- .../meta/lock/AbstractDistributedLock.java | 51 ------------------- ...utedLock.java => EtcdDistributedLock.java} | 34 +++++++------ .../hugegraph/meta/lock/LockResult.java | 6 +-- .../meta/lock/PdDistributedLock.java | 22 +++----- .../meta/managers/AbstractMetaManager.java | 22 -------- 8 files changed, 40 insertions(+), 182 deletions(-) delete mode 100644 hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/AbstractDistributedLock.java rename hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/{DistributedLock.java => EtcdDistributedLock.java} (85%) diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/EtcdMetaDriver.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/EtcdMetaDriver.java index e07eecb9f5..8c9600e6b9 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/EtcdMetaDriver.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/EtcdMetaDriver.java @@ -29,7 +29,7 @@ import org.apache.commons.io.FileUtils; import org.apache.hugegraph.HugeException; -import org.apache.hugegraph.meta.lock.DistributedLock; +import org.apache.hugegraph.meta.lock.EtcdDistributedLock; import org.apache.hugegraph.meta.lock.LockResult; import org.apache.hugegraph.type.define.CollectionType; import org.apache.hugegraph.util.E; @@ -57,8 +57,8 @@ public class EtcdMetaDriver implements MetaDriver { - private Client client; - private DistributedLock lock; + private final Client client; + private final EtcdDistributedLock lock; public EtcdMetaDriver(String trustFile, String clientCertFile, String clientKeyFile, Object... endpoints) { @@ -67,13 +67,13 @@ public EtcdMetaDriver(String trustFile, String clientCertFile, SslContext sslContext = openSslContext(trustFile, clientCertFile, clientKeyFile); this.client = builder.sslContext(sslContext).build(); - this.lock = DistributedLock.getInstance(this.client); + this.lock = EtcdDistributedLock.getInstance(this.client); } public EtcdMetaDriver(Object... endpoints) { ClientBuilder builder = this.etcdMetaDriverBuilder(endpoints); this.client = builder.build(); - this.lock = DistributedLock.getInstance(this.client); + this.lock = EtcdDistributedLock.getInstance(this.client); } private static ByteSequence toByteSequence(String content) { @@ -165,7 +165,7 @@ public String get(String key) { throw new HugeException("Failed to get key '%s' from etcd", e, key); } - if (keyValues.size() > 0) { + if (!keyValues.isEmpty()) { return keyValues.get(0).getValue().toString(Charset.defaultCharset()); } @@ -230,7 +230,7 @@ public Map scanWithPrefix(String prefix) { CollectionType.JCF, size); for (KeyValue kv : response.getKvs()) { String key = kv.getKey().toString(Charset.defaultCharset()); - String value = kv.getValue().size() == 0 ? "" : + String value = kv.getValue().isEmpty() ? "" : kv.getValue().toString(Charset.defaultCharset()); keyValues.put(key, value); } @@ -283,22 +283,13 @@ public LockResult tryLock(String key, long ttl, long timeout) { return this.lock.tryLock(key, ttl, timeout); } - @Override - public LockResult lock(String key, long ttl) { - return this.lock.lock(key, ttl); - } - @Override public boolean isLocked(String key) { try { long size = this.client.getKVClient().get(toByteSequence(key)) .get().getCount(); - if (size > 0) { - return true; - } else { - return false; - } + return size > 0; } catch (InterruptedException | ExecutionException e) { throw new HugeException("Failed to check is locked '%s'", e, key); } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaManager.java index 39314cf484..1662b114d4 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaManager.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaManager.java @@ -509,22 +509,6 @@ public void notifyGraphEdgeCacheClear(String graphSpace, String graph) { this.graphMetaManager.notifyGraphEdgeCacheClear(graphSpace, graph); } - public LockResult lock(String... keys) { - return this.lockMetaManager.lock(keys); - } - - public LockResult lock(long ttl, String... keys) { - return this.lockMetaManager.lock(ttl, keys); - } - - public LockResult lock(String key, long ttl) { - return this.lockMetaManager.lock(key, ttl); - } - - public LockResult lock(String key) { - return this.lockMetaManager.lock(key); - } - public LockResult tryLock(String key) { return this.lockMetaManager.tryLock(key); } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/PdMetaDriver.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/PdMetaDriver.java index 1e4813a195..f7da14196c 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/PdMetaDriver.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/PdMetaDriver.java @@ -17,9 +17,7 @@ package org.apache.hugegraph.meta; -import java.text.SimpleDateFormat; import java.util.ArrayList; -import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -44,35 +42,15 @@ public class PdMetaDriver implements MetaDriver { - KvClient client = null; - PDClient pdClient = null; - private PdDistributedLock lock; + private final KvClient client; + private final PDClient pdClient; + private final PdDistributedLock lock; public PdMetaDriver(String pdPeer) { PDConfig pdConfig = PDConfig.of(pdPeer); this.client = new KvClient<>(pdConfig); this.pdClient = PDClient.create(pdConfig); - lock = new PdDistributedLock(this.client); - } - - public static void main(String[] args) { - PDConfig pdConfig = PDConfig.of("127.0.0.1:8686"); - KvClient client = new KvClient<>(pdConfig); - ScanPrefixResponse contents; - try { - contents = client.scanPrefix("HUGEGRAPH/METRICS"); - Map map = contents.getKvsMap(); - for (Map.Entry entry : map.entrySet()) { - System.out.println(entry.getKey() + ":" + entry.getValue()); - } - System.out.println(map.size()); - } catch (PDException e) { - e.printStackTrace(); - } - Date dNow = new Date(); - System.out.println(dNow); - SimpleDateFormat ft = new SimpleDateFormat("HHmmss"); - System.out.println("当前时间为: " + ft.format(dNow)); + this.lock = new PdDistributedLock(this.client); } public PDClient pdClient() { @@ -179,22 +157,6 @@ public Map extractKVFromResponse(T response) { return resultMap; } - @Override - public LockResult lock(String key, long ttl) { - while (true) { - LockResult lock = this.lock.lock(key, ttl); - if (lock.lockSuccess()) { - return lock; - } else { - try { - Thread.sleep(1000L); - } catch (Exception e) { - - } - } - } - } - @Override public LockResult tryLock(String key, long ttl, long timeout) { return this.lock.lock(key, ttl); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/AbstractDistributedLock.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/AbstractDistributedLock.java deleted file mode 100644 index 4cc9aacf26..0000000000 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/AbstractDistributedLock.java +++ /dev/null @@ -1,51 +0,0 @@ -/* - * 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.hugegraph.meta.lock; - -import org.apache.hugegraph.pd.client.KvClient; - -import io.etcd.jetcd.Client; - -/** - * @author zhangyingjie - * @date 2022/6/18 - **/ -public abstract class AbstractDistributedLock { - - private static volatile AbstractDistributedLock defaultLock; - - public static AbstractDistributedLock getInstance(AutoCloseable client) { - if (defaultLock == null) { - synchronized (AbstractDistributedLock.class) { - if (defaultLock == null) { - if (client instanceof Client) { - defaultLock = DistributedLock.getInstance((Client) client); - } else { - defaultLock = new PdDistributedLock((KvClient) client); - } - - } - } - } - return defaultLock; - } - - public abstract LockResult lock(String key, long ttl); - - public abstract void unLock(String key, LockResult lockResult); -} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/DistributedLock.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/EtcdDistributedLock.java similarity index 85% rename from hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/DistributedLock.java rename to hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/EtcdDistributedLock.java index 5e45806fc5..6cbea56c6f 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/DistributedLock.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/EtcdDistributedLock.java @@ -19,8 +19,8 @@ import java.nio.charset.Charset; import java.util.concurrent.ExecutionException; -import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; @@ -33,26 +33,33 @@ import io.etcd.jetcd.Lease; import io.etcd.jetcd.Lock; -public class DistributedLock extends AbstractDistributedLock { +public class EtcdDistributedLock { - protected static final Logger LOG = Log.logger(DistributedLock.class); - private static final long UNLIMIT_TIMEOUT = -1L; + protected static final Logger LOG = Log.logger(EtcdDistributedLock.class); + private static final long UNLIMITED_TIMEOUT = -1L; private final static Object mutex = new Object(); - private static DistributedLock lockProvider = null; + private static EtcdDistributedLock lockProvider = null; private final KV kvClient; private final Lock lockClient; private final Lease leaseClient; - private DistributedLock(Client client) { + private static final int poolSize = 8; + private final ScheduledExecutorService service = new ScheduledThreadPoolExecutor(poolSize, r -> { + Thread t = new Thread(r, "keepalive"); + t.setDaemon(true); + return t; + }); + + private EtcdDistributedLock(Client client) { this.kvClient = client.getKVClient(); this.lockClient = client.getLockClient(); this.leaseClient = client.getLeaseClient(); } - public static DistributedLock getInstance(Client client) { + public static EtcdDistributedLock getInstance(Client client) { synchronized (mutex) { if (null == lockProvider) { - lockProvider = new DistributedLock(client); + lockProvider = new EtcdDistributedLock(client); } } return lockProvider; @@ -64,13 +71,10 @@ private static ByteSequence toByteSequence(String content) { public LockResult tryLock(String lockName, long ttl, long timeout) { LockResult lockResult = new LockResult(); - ScheduledExecutorService service = - Executors.newSingleThreadScheduledExecutor(); - lockResult.lockSuccess(false); lockResult.setService(service); - Long leaseId; + long leaseId; try { leaseId = this.leaseClient.grant(ttl).get().getID(); @@ -89,7 +93,7 @@ public LockResult tryLock(String lockName, long ttl, long timeout) { period, period, TimeUnit.SECONDS); try { - if (timeout == UNLIMIT_TIMEOUT) { + if (timeout == UNLIMITED_TIMEOUT) { this.lockClient.lock(toByteSequence(lockName), leaseId).get(); } else { @@ -117,12 +121,10 @@ public LockResult tryLock(String lockName, long ttl, long timeout) { return lockResult; } - @Override public LockResult lock(String lockName, long ttl) { - return tryLock(lockName, ttl, UNLIMIT_TIMEOUT); + return tryLock(lockName, ttl, UNLIMITED_TIMEOUT); } - @Override public void unLock(String lockName, LockResult lockResult) { LOG.debug("Thread {} start to unlock {}", Thread.currentThread().getName(), lockName); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/LockResult.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/LockResult.java index 4357cc9a80..6909b73183 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/LockResult.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/LockResult.java @@ -25,7 +25,7 @@ public class LockResult { private boolean lockSuccess; private long leaseId; private ScheduledExecutorService service; - private ScheduledFuture future; + private ScheduledFuture future; public void lockSuccess(boolean isLockSuccess) { this.lockSuccess = isLockSuccess; @@ -51,11 +51,11 @@ public void setService(ScheduledExecutorService service) { this.service = service; } - public ScheduledFuture getFuture() { + public ScheduledFuture getFuture() { return future; } - public void setFuture(ScheduledFuture future) { + public void setFuture(ScheduledFuture future) { this.future = future; } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/PdDistributedLock.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/PdDistributedLock.java index 59f7f93801..d060a43efb 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/PdDistributedLock.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/PdDistributedLock.java @@ -27,25 +27,20 @@ import org.apache.hugegraph.pd.common.PDException; import org.apache.hugegraph.pd.grpc.kv.LockResponse; -/** - * @author zhangyingjie - * @date 2022/6/18 - **/ -public class PdDistributedLock extends AbstractDistributedLock { +public class PdDistributedLock { - private static int poolSize = 8; - private final KvClient client; - private ScheduledExecutorService service = new ScheduledThreadPoolExecutor(poolSize, r -> { - Thread t = new Thread(r); + private static final int poolSize = 8; + private final KvClient client; + private final ScheduledExecutorService service = new ScheduledThreadPoolExecutor(poolSize, r -> { + Thread t = new Thread(r, "keepalive"); t.setDaemon(true); return t; }); - public PdDistributedLock(KvClient client) { + public PdDistributedLock(KvClient client) { this.client = client; } - @Override public LockResult lock(String key, long second) { long ttl = second * 1000L; try { @@ -69,12 +64,11 @@ public LockResult lock(String key, long second) { } } - @Override public void unLock(String key, LockResult lockResult) { try { LockResponse response = this.client.unlock(key); boolean succeed = response.getSucceed(); - if (succeed == false) { + if (!succeed) { throw new HugeException("Failed to unlock '%s' to pd", key); } if (lockResult.getFuture() != null) { @@ -95,6 +89,4 @@ public boolean keepAlive(String key) { throw new HugeException("Failed to keepAlive '%s' to pd", key); } } - - } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/AbstractMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/AbstractMetaManager.java index 254068335a..b1928d38eb 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/AbstractMetaManager.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/AbstractMetaManager.java @@ -26,7 +26,6 @@ import java.util.function.Consumer; import org.apache.commons.lang3.StringUtils; -import org.apache.hugegraph.HugeException; import org.apache.hugegraph.auth.SchemaDefine; import org.apache.hugegraph.meta.MetaDriver; import org.apache.hugegraph.meta.lock.LockResult; @@ -79,27 +78,6 @@ public void putOrDeleteRaw(String key, String val) { } } - public LockResult lock(String... keys) { - return this.lock(LOCK_DEFAULT_LEASE, keys); - } - - public LockResult lock(long ttl, String... keys) { - String key = String.join(META_PATH_DELIMITER, keys); - return this.lock(key, ttl); - } - - public LockResult lock(String key, long ttl) { - LockResult lockResult = this.metaDriver.lock(key, ttl); - if (!lockResult.lockSuccess()) { - throw new HugeException("Failed to lock '%s'", key); - } - return lockResult; - } - - public LockResult lock(String key) { - return this.metaDriver.lock(key, LOCK_DEFAULT_LEASE); - } - public LockResult tryLock(String key) { return this.metaDriver.tryLock(key, LOCK_DEFAULT_LEASE, LOCK_DEFAULT_TIMEOUT); From 087f0bf5634b109c172e0c8cec6da86dc82973fa Mon Sep 17 00:00:00 2001 From: VGalaxies Date: Sun, 10 Sep 2023 22:52:30 +0800 Subject: [PATCH 20/26] chore: replace HashMap with ImmutableMap --- .../hugegraph/backend/query/Condition.java | 84 ++++++++++++++++++- .../query/serializer/QueryAdapter.java | 22 +++-- .../query/serializer/QueryIdAdapter.java | 24 +++--- 3 files changed, 103 insertions(+), 27 deletions(-) diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java index b56cf1c702..e6f04a9615 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java @@ -17,6 +17,7 @@ package org.apache.hugegraph.backend.query; +import java.io.Serializable; import java.util.ArrayList; import java.util.Collection; import java.util.Date; @@ -47,7 +48,8 @@ public enum ConditionType { NONE, RELATION, AND, - OR; + OR, + NOT; } public enum RelationType implements BiPredicate { @@ -300,7 +302,8 @@ public boolean isRelation() { public boolean isLogic() { return this.type() == ConditionType.AND || - this.type() == ConditionType.OR; + this.type() == ConditionType.OR || + this.type() == ConditionType.NOT; } public boolean isFlattened() { @@ -315,6 +318,10 @@ public static Condition or(Condition left, Condition right) { return new Or(left, right); } + public static Condition not(Condition condition) { + return new Not(condition); + } + public static Relation eq(HugeKeys key, Object value) { return new SyspropRelation(key, RelationType.EQ, value); } @@ -536,6 +543,79 @@ public Condition copy() { } } + public static class Not extends Condition implements Serializable { + Condition condition; + + public Not(Condition condition) { + super(); + this.condition = condition; + } + + public Condition condition() { + return condition; + } + + @Override + public ConditionType type() { + return ConditionType.NOT; + } + + @Override + public boolean test(Object value) { + return !this.condition.test(value); + } + + @Override + public boolean test(HugeElement element) { + return !this.condition.test(element); + } + + @Override + public Condition copy() { + return new Not(this.condition.copy()); + } + + @Override + public boolean isSysprop() { + return this.condition.isSysprop(); + } + + @Override + public List relations() { + return new ArrayList(this.condition.relations()); + } + + @Override + public Condition replace(Relation from, Relation to) { + this.condition = this.condition.replace(from, to); + return this; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(64); + sb.append(this.type().name()).append(' '); + sb.append(this.condition); + return sb.toString(); + } + + @Override + public boolean equals(Object object) { + if (!(object instanceof Not)) { + return false; + } + Not other = (Not) object; + return this.type().equals(other.type()) && + this.condition.equals(other.condition()); + } + + @Override + public int hashCode() { + return this.type().hashCode() ^ + this.condition.hashCode(); + } + } + public abstract static class Relation extends Condition { // Relational operator (like: =, >, <, in, ...) diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryAdapter.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryAdapter.java index afe00e32d7..041a75cba2 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryAdapter.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryAdapter.java @@ -20,13 +20,13 @@ import java.lang.reflect.Type; import java.util.ArrayList; import java.util.Date; -import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.hugegraph.backend.query.Condition; import org.apache.hugegraph.type.define.Directions; +import com.google.common.collect.ImmutableMap; import com.google.gson.JsonDeserializationContext; import com.google.gson.JsonElement; import com.google.gson.JsonObject; @@ -37,17 +37,15 @@ public class QueryAdapter extends AbstractSerializerAdapter { - static HashMap cls; - - static { - cls = new HashMap() {{ - //put("N", Condition.Not.class); - put("A", Condition.And.class); - put("O", Condition.Or.class); - put("S", Condition.SyspropRelation.class); - put("U", Condition.UserpropRelation.class); - }}; - } + static ImmutableMap cls = + ImmutableMap.builder() + // TODO: uncomment later + .put("N", Condition.Not.class) + .put("A", Condition.And.class) + .put("O", Condition.Or.class) + .put("S", Condition.SyspropRelation.class) + .put("U", Condition.UserpropRelation.class) + .build(); static boolean isPrimitive(Class clz) { try { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryIdAdapter.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryIdAdapter.java index 64e7e1a09f..d22db48a29 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryIdAdapter.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/QueryIdAdapter.java @@ -18,7 +18,6 @@ package org.apache.hugegraph.backend.query.serializer; import java.lang.reflect.Type; -import java.util.HashMap; import java.util.Map; import org.apache.hugegraph.backend.id.EdgeId; @@ -26,20 +25,19 @@ import org.apache.hugegraph.backend.id.IdGenerator; import org.apache.hugegraph.backend.serializer.BinaryBackendEntry; -public class QueryIdAdapter extends AbstractSerializerAdapter { +import com.google.common.collect.ImmutableMap; - static HashMap cls; +public class QueryIdAdapter extends AbstractSerializerAdapter { - static { - cls = new HashMap() {{ - put("E", EdgeId.class); - put("S", IdGenerator.StringId.class); - put("L", IdGenerator.LongId.class); - put("U", IdGenerator.UuidId.class); - put("O", IdGenerator.ObjectId.class); - put("B", BinaryBackendEntry.BinaryId.class); - }}; - } + static ImmutableMap cls = + ImmutableMap.builder() + .put("E", EdgeId.class) + .put("S", IdGenerator.StringId.class) + .put("L", IdGenerator.LongId.class) + .put("U", IdGenerator.UuidId.class) + .put("O", IdGenerator.ObjectId.class) + .put("B", BinaryBackendEntry.BinaryId.class) + .build(); @Override public Map validType() { From 9d11f9db9c3e106f79e9d9cdcad838e109cebe51 Mon Sep 17 00:00:00 2001 From: VGalaxies Date: Sun, 10 Sep 2023 22:54:22 +0800 Subject: [PATCH 21/26] chore: code review --- .../backend/query/ConditionQuery.java | 11 +++---- .../serializer/AbstractSerializerAdapter.java | 1 + .../hugegraph/backend/tx/IdCounter.java | 29 ++++--------------- .../backend/tx/SchemaTransactionV2.java | 4 --- .../org/apache/hugegraph/meta/MetaDriver.java | 3 -- .../hugegraph/space/SchemaTemplate.java | 2 +- 6 files changed, 13 insertions(+), 37 deletions(-) diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java index afb132758c..7804388ca2 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java @@ -77,6 +77,12 @@ public class ConditionQuery extends IdQuery { private static final List EMPTY_CONDITIONS = ImmutableList.of(); + private static final Gson gson = new GsonBuilder() + .registerTypeAdapter(Condition.class, new QueryAdapter()) + .registerTypeAdapter(Id.class, new QueryIdAdapter()) + .setDateFormat("yyyy-MM-dd HH:mm:ss.SSS") + .create(); + // Conditions will be contacted with `and` by default private List conditions = EMPTY_CONDITIONS; @@ -890,11 +896,6 @@ public interface ResultsFilter { } public byte[] bytes() { - Gson gson = new GsonBuilder() - .registerTypeAdapter(Condition.class, new QueryAdapter()) - .registerTypeAdapter(Id.class, new QueryIdAdapter()) - .setDateFormat("yyyy-MM-dd HH:mm:ss.SSS") - .create(); String cqs = gson.toJson(this); return cqs.getBytes(StandardCharsets.UTF_8); } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/AbstractSerializerAdapter.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/AbstractSerializerAdapter.java index 1a1f8ecba3..1a66ddf074 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/AbstractSerializerAdapter.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/serializer/AbstractSerializerAdapter.java @@ -31,6 +31,7 @@ import com.google.gson.JsonSerializationContext; import com.google.gson.JsonSerializer; +// TODO: optimize by binary protocol public abstract class AbstractSerializerAdapter implements JsonSerializer, JsonDeserializer { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/IdCounter.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/IdCounter.java index 5a1ea58d5f..87a10ce2c8 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/IdCounter.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/IdCounter.java @@ -25,8 +25,6 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; import org.apache.hugegraph.pd.client.PDClient; -import org.apache.hugegraph.pd.client.PDConfig; -import org.apache.hugegraph.pd.common.PDException; import org.apache.hugegraph.pd.grpc.Pdpb; import org.apache.hugegraph.store.term.HgPair; import org.apache.hugegraph.type.HugeType; @@ -37,7 +35,8 @@ public class IdCounter { private static final int TIMES = 10000; private static final int DELTA = 10000; private static final String DELIMITER = "/"; - private static Map ids = new ConcurrentHashMap<>(); + private static final Map> ids = + new ConcurrentHashMap<>(); private final PDClient pdClient; private final String graphName; @@ -46,14 +45,6 @@ public IdCounter(PDClient pdClient, String graphName) { this.pdClient = pdClient; } - public static void main(String[] args) { - PDConfig pdConfig = PDConfig.of("127.0.0.1:8686"); - PDClient pdClient = PDClient.create(pdConfig); - IdCounter idCounters = new IdCounter(pdClient, "hugegraph"); - System.out.println(idCounters.nextId(HugeType.EDGE_LABEL)); - System.out.println(idCounters.nextId(HugeType.EDGE_LABEL)); - } - public Id nextId(HugeType type) { long counter = this.getCounter(type); E.checkState(counter != 0L, "Please check whether '%s' is OK", @@ -89,11 +80,10 @@ public synchronized void increaseCounter(HugeType type, long lowest) { } synchronized (ids) { try { - this.pdClient.getIdByKey(key, - (int) (lowest - maxId.longValue())); + this.pdClient.getIdByKey(key, (int) (lowest - maxId.longValue())); ids.remove(key); } catch (Exception e) { - throw new BackendException(""); + throw new BackendException(e); } } } @@ -115,7 +105,7 @@ public long getCounterFromPd(HugeType type) { try { currentId = new AtomicLong(0); maxId = new AtomicLong(0); - idPair = new HgPair(currentId, maxId); + idPair = new HgPair<>(currentId, maxId); ids.put(key, idPair); } catch (Exception e) { throw new BackendException(String.format( @@ -149,13 +139,4 @@ public long getCounterFromPd(HugeType type) { " ID for type '%s'", type.name()); return 0L; } - - public void resetIdCounter(String graphName) { - try { - this.pdClient.resetIdByKey(graphName); - ids = new ConcurrentHashMap<>(); - } catch (PDException e) { - throw new RuntimeException(e); - } - } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java index a6aa285576..8aa9272d6e 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/SchemaTransactionV2.java @@ -732,8 +732,4 @@ public Id rebuildIndex(SchemaElement schema, Set dependencies) { public void clear() { this.schemaMetaManager.clearAllSchema(this.graphSpace, graph); } - - public void resetIdCounter() { - this.idCounter.resetIdCounter(idKeyName(graphSpace, graph)); - } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaDriver.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaDriver.java index 9b949b01cd..2d0936498f 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaDriver.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaDriver.java @@ -50,9 +50,6 @@ public interface MetaDriver { */ public Map extractKVFromResponse(T response); - @Deprecated - public LockResult lock(String key, long ttl); - public LockResult tryLock(String key, long ttl, long timeout); /** diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/SchemaTemplate.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/SchemaTemplate.java index 17e2eb5377..d0f5d6c3d4 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/SchemaTemplate.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/space/SchemaTemplate.java @@ -32,7 +32,7 @@ public class SchemaTemplate { protected Date createTime; protected Date updateTime; protected String creator; - private String name; + private final String name; private String schema; public SchemaTemplate(String name, String schema) { From d818aefbb7b268b94e8b5136943be96c19c1208b Mon Sep 17 00:00:00 2001 From: VGalaxies Date: Sun, 10 Sep 2023 23:04:41 +0800 Subject: [PATCH 22/26] chore: load driver version in graph store for hstore --- .../hugegraph/backend/store/BackendStoreInfo.java | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreInfo.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreInfo.java index b6b09d2a9f..77d4fd51bf 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreInfo.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/BackendStoreInfo.java @@ -41,12 +41,14 @@ public boolean exists() { } public boolean checkVersion() { - if (this.storeProvider.isHstore()) { // skip for hstore now - return true; + BackendStore store; + if (this.storeProvider.isHstore()) { + store = this.storeProvider.loadGraphStore(this.config); + } else { + store = this.storeProvider.loadSystemStore(this.config); } String driverVersion = this.storeProvider.driverVersion(); - String storedVersion = this.storeProvider.loadSystemStore(this.config) - .storedVersion(); + String storedVersion = store.storedVersion(); if (!driverVersion.equals(storedVersion)) { LOG.error("The backend driver version '{}' is inconsistent with " + "the data version '{}' of backend store for graph '{}'", From 1a7f6cbdbff3f076c8763d3577e2484210d17625 Mon Sep 17 00:00:00 2001 From: VGalaxies Date: Mon, 11 Sep 2023 19:12:37 +0800 Subject: [PATCH 23/26] fix: index serialization and deserialization logic --- .../hugegraph/backend/serializer/BytesBuffer.java | 8 ++++---- .../org/apache/hugegraph/structure/HugeIndex.java | 15 +++++++++------ 2 files changed, 13 insertions(+), 10 deletions(-) diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BytesBuffer.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BytesBuffer.java index 38250b43fe..52534bf0bd 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BytesBuffer.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BytesBuffer.java @@ -756,11 +756,11 @@ public BytesBuffer writeIndexId(Id id, HugeType type, boolean withEnding) { public BinaryId readIndexId(HugeType type) { byte[] id; if (type.isRange4Index()) { - // IndexLabel 4 bytes + fieldValue 4 bytes - id = this.read(8); + // HugeTypeCode 1 byte + IndexLabel 4 bytes + fieldValue 4 bytes + id = this.read(9); } else if (type.isRange8Index()) { - // IndexLabel 4 bytes + fieldValue 8 bytes - id = this.read(12); + // HugeTypeCode 1 byte + IndexLabel 4 bytes + fieldValue 8 bytes + id = this.read(13); } else { assert type.isStringIndex(); id = this.readBytesWithEnding(); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeIndex.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeIndex.java index 4f5d8d04c4..d1c7b1bf06 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeIndex.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeIndex.java @@ -44,6 +44,7 @@ public class HugeIndex implements GraphType, Cloneable { private Object fieldValues; private IndexLabel indexLabel; private Set elementIds; + private static final int HUGE_TYPE_CODE_LENGTH = 1; public HugeIndex(HugeGraph graph, IndexLabel indexLabel) { E.checkNotNull(graph, "graph"); @@ -210,11 +211,12 @@ public static Id formatIndexId(HugeType type, Id indexLabelId, * index label in front(hugegraph-1317) */ String strIndexLabelId = IdGenerator.asStoredString(indexLabelId); - return SplicingIdGenerator.splicing(strIndexLabelId, value); + return SplicingIdGenerator.splicing(type.string(), strIndexLabelId, value); } else { assert type.isRangeIndex(); int length = type.isRange4Index() ? 4 : 8; - BytesBuffer buffer = BytesBuffer.allocate(4 + length); + BytesBuffer buffer = BytesBuffer.allocate(HUGE_TYPE_CODE_LENGTH + 4 + length); + buffer.write(type.code()); buffer.writeInt(SchemaElement.schemaId(indexLabelId)); if (fieldValues != null) { E.checkState(fieldValues instanceof Number, @@ -234,15 +236,16 @@ public static HugeIndex parseIndexId(HugeGraph graph, HugeType type, if (type.isStringIndex()) { Id idObject = IdGenerator.of(id, IdType.STRING); String[] parts = SplicingIdGenerator.parse(idObject); - E.checkState(parts.length == 2, "Invalid secondary index id"); - Id label = IdGenerator.ofStoredString(parts[0], IdType.LONG); + E.checkState(parts.length == 3, "Invalid secondary index id"); + Id label = IdGenerator.ofStoredString(parts[1], IdType.LONG); indexLabel = IndexLabel.label(graph, label); - values = parts[1]; + values = parts[2]; } else { assert type.isRange4Index() || type.isRange8Index(); final int labelLength = 4; E.checkState(id.length > labelLength, "Invalid range index id"); BytesBuffer buffer = BytesBuffer.wrap(id); + buffer.read(HUGE_TYPE_CODE_LENGTH); Id label = IdGenerator.of(buffer.readInt()); indexLabel = IndexLabel.label(graph, label); List fields = indexLabel.indexFields(); @@ -252,7 +255,7 @@ public static HugeIndex parseIndexId(HugeGraph graph, HugeType type, "Invalid range index field type"); Class clazz = dataType.isNumber() ? dataType.clazz() : DataType.LONG.clazz(); - values = bytes2number(buffer.read(id.length - labelLength), clazz); + values = bytes2number(buffer.read(id.length - labelLength - HUGE_TYPE_CODE_LENGTH), clazz); } HugeIndex index = new HugeIndex(graph, indexLabel); index.fieldValues(values); From c38b67c9674ba70025489bd87596f9a25ee118f7 Mon Sep 17 00:00:00 2001 From: VGalaxies Date: Mon, 11 Sep 2023 20:48:32 +0800 Subject: [PATCH 24/26] fix: convertTaskOrServerToVertex for other BEs --- .../hugegraph/backend/store/cassandra/CassandraStore.java | 5 +---- .../hugegraph/backend/store/AbstractBackendStore.java | 7 +++++++ .../hugegraph/backend/store/memory/InMemoryDBStore.java | 8 +++----- .../apache/hugegraph/backend/store/hbase/HbaseStore.java | 5 +---- .../apache/hugegraph/backend/store/mysql/MysqlStore.java | 5 +---- .../backend/store/postgresql/PostgresqlStoreProvider.java | 3 --- .../hugegraph/backend/store/rocksdb/RocksDBStore.java | 5 +---- 7 files changed, 14 insertions(+), 24 deletions(-) diff --git a/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraStore.java b/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraStore.java index e310969980..5cce218d3b 100644 --- a/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraStore.java +++ b/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraStore.java @@ -594,7 +594,7 @@ protected Collection tables() { @Override protected final CassandraTable table(HugeType type) { - return this.table(type.string()); + return this.table(convertTaskOrServerToVertex(type).string()); } protected final CassandraTable table(String name) { @@ -789,9 +789,6 @@ public CassandraSystemStore(BackendStoreProvider provider, String keyspace, Stri super(provider, keyspace, store); this.meta = new CassandraTables.Meta(); - - registerTableManager(HugeType.TASK, this.table(HugeType.VERTEX)); - registerTableManager(HugeType.SERVER, this.table(HugeType.VERTEX)); } @Override diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/AbstractBackendStore.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/AbstractBackendStore.java index 4e87ff589a..00fdcb929a 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/AbstractBackendStore.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/AbstractBackendStore.java @@ -80,6 +80,13 @@ public String toString() { protected abstract BackendTable table(HugeType type); + protected static HugeType convertTaskOrServerToVertex(HugeType type) { + if (HugeType.TASK.equals(type) || HugeType.SERVER.equals(type)) { + return HugeType.VERTEX; + } + return type; + } + // NOTE: Need to support passing null protected abstract Session session(HugeType type); } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/memory/InMemoryDBStore.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/memory/InMemoryDBStore.java index 4a088637a0..1e31a38d36 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/memory/InMemoryDBStore.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/store/memory/InMemoryDBStore.java @@ -27,10 +27,6 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.query.Query; import org.apache.hugegraph.backend.serializer.TextBackendEntry; -import org.apache.hugegraph.type.HugeType; -import org.apache.hugegraph.type.define.Action; -import org.slf4j.Logger; - import org.apache.hugegraph.backend.store.AbstractBackendStore; import org.apache.hugegraph.backend.store.BackendAction; import org.apache.hugegraph.backend.store.BackendEntry; @@ -39,7 +35,9 @@ import org.apache.hugegraph.backend.store.BackendSession; import org.apache.hugegraph.backend.store.BackendStoreProvider; import org.apache.hugegraph.config.HugeConfig; +import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.util.Log; +import org.slf4j.Logger; /** * NOTE: @@ -95,7 +93,7 @@ protected Collection tables() { @Override protected final InMemoryDBTable table(HugeType type) { assert type != null; - InMemoryDBTable table = this.tables.get(type); + InMemoryDBTable table = this.tables.get(convertTaskOrServerToVertex(type)); if (table == null) { throw new BackendException("Unsupported table type: %s", type); } diff --git a/hugegraph-server/hugegraph-hbase/src/main/java/org/apache/hugegraph/backend/store/hbase/HbaseStore.java b/hugegraph-server/hugegraph-hbase/src/main/java/org/apache/hugegraph/backend/store/hbase/HbaseStore.java index bb856a88e3..4fa738ce4c 100644 --- a/hugegraph-server/hugegraph-hbase/src/main/java/org/apache/hugegraph/backend/store/hbase/HbaseStore.java +++ b/hugegraph-server/hugegraph-hbase/src/main/java/org/apache/hugegraph/backend/store/hbase/HbaseStore.java @@ -96,7 +96,7 @@ protected void registerTableManager(HugeType type, HbaseTable table) { @Override protected final HbaseTable table(HugeType type) { assert type != null; - HbaseTable table = this.tables.get(type); + HbaseTable table = this.tables.get(convertTaskOrServerToVertex(type)); if (table == null) { throw new BackendException("Unsupported table type: %s", type); } @@ -564,9 +564,6 @@ public HbaseSystemStore(HugeConfig config, BackendStoreProvider provider, super(config, provider, namespace, store); this.meta = new HbaseTables.Meta(); - - registerTableManager(HugeType.TASK, this.table(HugeType.VERTEX)); - registerTableManager(HugeType.SERVER, this.table(HugeType.VERTEX)); } @Override diff --git a/hugegraph-server/hugegraph-mysql/src/main/java/org/apache/hugegraph/backend/store/mysql/MysqlStore.java b/hugegraph-server/hugegraph-mysql/src/main/java/org/apache/hugegraph/backend/store/mysql/MysqlStore.java index fd3a7584e0..99f8cabda4 100644 --- a/hugegraph-server/hugegraph-mysql/src/main/java/org/apache/hugegraph/backend/store/mysql/MysqlStore.java +++ b/hugegraph-server/hugegraph-mysql/src/main/java/org/apache/hugegraph/backend/store/mysql/MysqlStore.java @@ -349,7 +349,7 @@ protected Collection tables() { @Override protected final MysqlTable table(HugeType type) { assert type != null; - MysqlTable table = this.tables.get(type); + MysqlTable table = this.tables.get(convertTaskOrServerToVertex(type)); if (table == null) { throw new BackendException("Unsupported table type: %s", type); } @@ -486,9 +486,6 @@ public MysqlSystemStore(BackendStoreProvider provider, super(provider, database, store); this.meta = new MysqlTables.Meta(); - - registerTableManager(HugeType.TASK, this.table(HugeType.VERTEX)); - registerTableManager(HugeType.SERVER, this.table(HugeType.VERTEX)); } @Override diff --git a/hugegraph-server/hugegraph-postgresql/src/main/java/org/apache/hugegraph/backend/store/postgresql/PostgresqlStoreProvider.java b/hugegraph-server/hugegraph-postgresql/src/main/java/org/apache/hugegraph/backend/store/postgresql/PostgresqlStoreProvider.java index f96d57ad3b..2431779a28 100644 --- a/hugegraph-server/hugegraph-postgresql/src/main/java/org/apache/hugegraph/backend/store/postgresql/PostgresqlStoreProvider.java +++ b/hugegraph-server/hugegraph-postgresql/src/main/java/org/apache/hugegraph/backend/store/postgresql/PostgresqlStoreProvider.java @@ -192,9 +192,6 @@ public PostgresqlSystemStore(BackendStoreProvider provider, super(provider, database, store); this.meta = new PostgresqlTables.Meta(); - - registerTableManager(HugeType.TASK, this.table(HugeType.VERTEX)); - registerTableManager(HugeType.SERVER, this.table(HugeType.VERTEX)); } @Override diff --git a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java index d20f8ac2a6..1d0cdba7b6 100644 --- a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java +++ b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java @@ -151,7 +151,7 @@ protected void unregisterTableManager(String name) { @Override protected final RocksDBTable table(HugeType type) { - RocksDBTable table = this.tables.get(type); + RocksDBTable table = this.tables.get(convertTaskOrServerToVertex(type)); if (table == null) { throw new BackendException("Unsupported table: '%s'", type); } @@ -1121,9 +1121,6 @@ public RocksDBSystemStore(BackendStoreProvider provider, super(provider, database, store); this.meta = new RocksDBTables.Meta(database); - - registerTableManager(HugeType.TASK, this.table(HugeType.VERTEX)); - registerTableManager(HugeType.SERVER, this.table(HugeType.VERTEX)); } @Override From e33a510a1c35ed6cce9929fc10861d9a22ddb681 Mon Sep 17 00:00:00 2001 From: VGalaxies Date: Thu, 14 Sep 2023 14:38:23 +0800 Subject: [PATCH 25/26] chore: init meta server in ctor of StandardHugeGraph --- .../main/java/org/apache/hugegraph/StandardHugeGraph.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java index a27daba290..c2ea1ea43d 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java @@ -226,6 +226,10 @@ public StandardHugeGraph(HugeConfig config) { throw new HugeException(message, e); } + if (isHstore()) { + initMetaManager(); + } + try { this.tx = new TinkerPopTransaction(this); boolean supportsPersistence = this.backendStoreFeatures().supportsPersistence(); @@ -472,7 +476,6 @@ private ISchemaTransaction openSchemaTransaction() throws HugeException { this.checkGraphNotClosed(); try { if (isHstore()) { - initMetaManager(); return new CachedSchemaTransactionV2( MetaManager.instance().metaDriver(), MetaManager.instance().cluster(), this.params); From e10eea7d90ca070f641632c89fb973a954cd94c6 Mon Sep 17 00:00:00 2001 From: VGalaxies Date: Mon, 18 Sep 2023 10:26:29 +0800 Subject: [PATCH 26/26] chore: add comments for lock module --- .../org/apache/hugegraph/meta/lock/EtcdDistributedLock.java | 1 + .../java/org/apache/hugegraph/meta/lock/PdDistributedLock.java | 2 ++ 2 files changed, 3 insertions(+) diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/EtcdDistributedLock.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/EtcdDistributedLock.java index 6cbea56c6f..ed62a429f0 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/EtcdDistributedLock.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/EtcdDistributedLock.java @@ -160,6 +160,7 @@ public static class KeepAliveTask implements Runnable { @Override public void run() { + // TODO: calculate the time interval between the calls this.leaseClient.keepAliveOnce(this.leaseId); } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/PdDistributedLock.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/PdDistributedLock.java index d060a43efb..7da78af063 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/PdDistributedLock.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/lock/PdDistributedLock.java @@ -52,6 +52,7 @@ public LockResult lock(String key, long second) { result.lockSuccess(true); long period = ttl - ttl / 4; ScheduledFuture future = service.scheduleAtFixedRate(() -> { + // TODO: why synchronized? synchronized (result) { keepAlive(key); } @@ -72,6 +73,7 @@ public void unLock(String key, LockResult lockResult) { throw new HugeException("Failed to unlock '%s' to pd", key); } if (lockResult.getFuture() != null) { + // TODO: why synchronized? synchronized (lockResult) { lockResult.getFuture().cancel(true); }

    3. 1u_$W` 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 )XSVjo`+3Q|n3` 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