Upgrade to Atomix 3.0-rc5
* Upgrade Raft primitives to Atomix 3.0
* Replace cluster store and messaging implementations with Atomix cluster management/messaging
* Add test scripts for installing/starting Atomix cluster
* Replace core primitives with Atomix primitives.
Change-Id: I7623653c81292a34f21b01f5f38ca11b5ef15cad
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/cluster/impl/AtomixClusterStore.java b/core/store/primitives/src/main/java/org/onosproject/store/cluster/impl/AtomixClusterStore.java
new file mode 100644
index 0000000..0afc462
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/cluster/impl/AtomixClusterStore.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.cluster.impl;
+
+import java.time.Instant;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import com.google.common.collect.Maps;
+import io.atomix.cluster.ClusterMembershipEvent;
+import io.atomix.cluster.ClusterMembershipEventListener;
+import io.atomix.cluster.ClusterMembershipService;
+import io.atomix.cluster.Member;
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.onlab.packet.IpAddress;
+import org.onosproject.cluster.ClusterEvent;
+import org.onosproject.cluster.ClusterStore;
+import org.onosproject.cluster.ClusterStoreDelegate;
+import org.onosproject.cluster.ControllerNode;
+import org.onosproject.cluster.DefaultControllerNode;
+import org.onosproject.cluster.Node;
+import org.onosproject.cluster.NodeId;
+import org.onosproject.core.Version;
+import org.onosproject.core.VersionService;
+import org.onosproject.store.AbstractStore;
+import org.onosproject.store.impl.AtomixManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Atomix cluster store.
+ */
+@Component(immediate = true)
+@Service
+public class AtomixClusterStore extends AbstractStore<ClusterEvent, ClusterStoreDelegate> implements ClusterStore {
+ private static final String INSTANCE_ID_NULL = "Instance ID cannot be null";
+
+ private static final String STATE_KEY = "state";
+ private static final String VERSION_KEY = "version";
+
+ private final Logger log = LoggerFactory.getLogger(getClass());
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected AtomixManager atomixManager;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected VersionService versionService;
+
+ private ClusterMembershipService membershipService;
+ private ControllerNode localNode;
+ private final Map<NodeId, ControllerNode> nodes = Maps.newConcurrentMap();
+ private final Map<NodeId, ControllerNode.State> states = Maps.newConcurrentMap();
+ private final Map<NodeId, Version> versions = Maps.newConcurrentMap();
+ private final Map<NodeId, Instant> updates = Maps.newConcurrentMap();
+ private final ClusterMembershipEventListener membershipEventListener = this::changeMembership;
+
+ @Activate
+ public void activate() {
+ membershipService = atomixManager.getAtomix().getMembershipService();
+ membershipService.addListener(membershipEventListener);
+ membershipService.getMembers().forEach(member -> {
+ ControllerNode node = toControllerNode(member);
+ nodes.put(node.id(), node);
+ updateState(node, member);
+ updateVersion(node, member);
+ });
+ membershipService.getLocalMember().properties().put(STATE_KEY, ControllerNode.State.ACTIVE.name());
+ membershipService.getLocalMember().properties().put(VERSION_KEY, versionService.version().toString());
+ localNode = toControllerNode(membershipService.getLocalMember());
+ states.put(localNode.id(), ControllerNode.State.ACTIVE);
+ versions.put(localNode.id(), versionService.version());
+ log.info("Started");
+ }
+
+ @Deactivate
+ public void deactivate() {
+ membershipService.removeListener(membershipEventListener);
+ log.info("Stopped");
+ }
+
+ private void changeMembership(ClusterMembershipEvent event) {
+ ControllerNode node = nodes.get(NodeId.nodeId(event.subject().id().id()));
+ switch (event.type()) {
+ case MEMBER_ADDED:
+ case METADATA_CHANGED:
+ if (node == null) {
+ node = toControllerNode(event.subject());
+ nodes.put(node.id(), node);
+ notifyDelegate(new ClusterEvent(ClusterEvent.Type.INSTANCE_ADDED, node));
+ }
+ updateVersion(node, event.subject());
+ updateState(node, event.subject());
+ break;
+ case MEMBER_REMOVED:
+ if (node != null
+ && states.put(node.id(), ControllerNode.State.INACTIVE) != ControllerNode.State.INACTIVE) {
+ notifyDelegate(new ClusterEvent(ClusterEvent.Type.INSTANCE_DEACTIVATED, node));
+ notifyDelegate(new ClusterEvent(ClusterEvent.Type.INSTANCE_REMOVED, node));
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ private void updateState(ControllerNode node, Member member) {
+ String state = member.properties().getProperty(STATE_KEY);
+ if (state == null || !state.equals(ControllerNode.State.READY.name())) {
+ if (states.put(node.id(), ControllerNode.State.ACTIVE) != ControllerNode.State.ACTIVE) {
+ log.info("Updated node {} state to {}", node.id(), ControllerNode.State.ACTIVE);
+ markUpdated(node.id());
+ notifyDelegate(new ClusterEvent(ClusterEvent.Type.INSTANCE_ACTIVATED, node));
+ }
+ } else {
+ if (states.put(node.id(), ControllerNode.State.READY) != ControllerNode.State.READY) {
+ log.info("Updated node {} state to {}", node.id(), ControllerNode.State.READY);
+ markUpdated(node.id());
+ notifyDelegate(new ClusterEvent(ClusterEvent.Type.INSTANCE_READY, node));
+ }
+ }
+ }
+
+ private void updateVersion(ControllerNode node, Member member) {
+ String versionString = member.properties().getProperty(VERSION_KEY);
+ if (versionString != null) {
+ Version version = Version.version(versionString);
+ if (!Objects.equals(versions.put(node.id(), version), version)) {
+ log.info("Updated node {} version to {}", node.id(), version);
+ }
+ }
+ }
+
+ private void markUpdated(NodeId nodeId) {
+ updates.put(nodeId, Instant.now());
+ }
+
+ private ControllerNode toControllerNode(Member member) {
+ return new DefaultControllerNode(
+ NodeId.nodeId(member.id().id()),
+ IpAddress.valueOf(member.address().address()),
+ member.address().port());
+ }
+
+ @Override
+ public ControllerNode getLocalNode() {
+ return toControllerNode(membershipService.getLocalMember());
+ }
+
+ @Override
+ public Set<Node> getStorageNodes() {
+ return membershipService.getMembers()
+ .stream()
+ .filter(member -> !Objects.equals(member.properties().getProperty("type"), "onos"))
+ .map(this::toControllerNode)
+ .collect(Collectors.toSet());
+ }
+
+ @Override
+ public Set<ControllerNode> getNodes() {
+ return membershipService.getMembers()
+ .stream()
+ .filter(member -> Objects.equals(member.properties().getProperty("type"), "onos"))
+ .map(this::toControllerNode)
+ .collect(Collectors.toSet());
+ }
+
+ @Override
+ public ControllerNode getNode(NodeId nodeId) {
+ Member member = membershipService.getMember(nodeId.id());
+ return member != null ? toControllerNode(member) : null;
+ }
+
+ @Override
+ public ControllerNode.State getState(NodeId nodeId) {
+ checkNotNull(nodeId, INSTANCE_ID_NULL);
+ return states.get(nodeId);
+ }
+
+ @Override
+ public Version getVersion(NodeId nodeId) {
+ checkNotNull(nodeId, INSTANCE_ID_NULL);
+ return versions.get(nodeId);
+ }
+
+ @Override
+ public Instant getLastUpdatedInstant(NodeId nodeId) {
+ checkNotNull(nodeId, INSTANCE_ID_NULL);
+ return updates.get(nodeId);
+ }
+
+ @Override
+ public void markFullyStarted(boolean started) {
+ ControllerNode.State state = started ? ControllerNode.State.READY : ControllerNode.State.ACTIVE;
+ states.put(localNode.id(), state);
+ membershipService.getLocalMember().properties().setProperty(STATE_KEY, state.name());
+ }
+
+ @Override
+ public ControllerNode addNode(NodeId nodeId, IpAddress ip, int tcpPort) {
+ checkNotNull(nodeId, INSTANCE_ID_NULL);
+ ControllerNode node = new DefaultControllerNode(nodeId, ip, tcpPort);
+ nodes.put(node.id(), node);
+ ControllerNode.State state = node.equals(localNode)
+ ? ControllerNode.State.ACTIVE : ControllerNode.State.INACTIVE;
+ membershipService.getMember(node.id().id()).properties().setProperty(STATE_KEY, state.name());
+ notifyDelegate(new ClusterEvent(ClusterEvent.Type.INSTANCE_ADDED, node));
+ return node;
+ }
+
+ @Override
+ public void removeNode(NodeId nodeId) {
+ checkNotNull(nodeId, INSTANCE_ID_NULL);
+ ControllerNode node = nodes.remove(nodeId);
+ if (node != null) {
+ states.remove(nodeId);
+ notifyDelegate(new ClusterEvent(ClusterEvent.Type.INSTANCE_REMOVED, node));
+ }
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/package-info.java b/core/store/primitives/src/main/java/org/onosproject/store/cluster/impl/package-info.java
similarity index 76%
copy from core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/package-info.java
copy to core/store/primitives/src/main/java/org/onosproject/store/cluster/impl/package-info.java
index aa11664..23bd9c4 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/package-info.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/cluster/impl/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2016-present Open Networking Foundation
+ * Copyright 2018-present Open Networking Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,6 +15,6 @@
*/
/**
- * State machine implementation classes for distributed primitives.
+ * Implementation classes for cluster stores.
*/
-package org.onosproject.store.primitives.resources.impl;
+package org.onosproject.store.cluster.impl;
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/cluster/messaging/impl/AtomixMessagingManager.java b/core/store/primitives/src/main/java/org/onosproject/store/cluster/messaging/impl/AtomixMessagingManager.java
new file mode 100644
index 0000000..46b27bf
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/cluster/messaging/impl/AtomixMessagingManager.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.cluster.messaging.impl;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+
+import io.atomix.utils.net.Address;
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.onlab.packet.IpAddress;
+import org.onosproject.store.cluster.messaging.Endpoint;
+import org.onosproject.store.cluster.messaging.MessagingService;
+import org.onosproject.store.impl.AtomixManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Atomix messaging manager.
+ */
+@Component(immediate = true)
+@Service
+public class AtomixMessagingManager implements MessagingService {
+
+ private final Logger log = LoggerFactory.getLogger(getClass());
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected AtomixManager atomixManager;
+
+ private io.atomix.cluster.messaging.MessagingService messagingService;
+
+ @Activate
+ public void activate() {
+ messagingService = atomixManager.getAtomix().getMessagingService();
+ log.info("Started");
+ }
+
+ @Deactivate
+ public void deactivate() {
+ log.info("Stopped");
+ }
+
+ private Address toAddress(Endpoint ep) {
+ return new Address(ep.host().toString(), ep.port(), ep.host().toInetAddress());
+ }
+
+ private Endpoint toEndpoint(Address address) {
+ return new Endpoint(IpAddress.valueOf(address.address()), address.port());
+ }
+
+ @Override
+ public CompletableFuture<Void> sendAsync(Endpoint ep, String type, byte[] payload) {
+ return messagingService.sendAsync(toAddress(ep), type, payload);
+ }
+
+ @Override
+ public CompletableFuture<byte[]> sendAndReceive(Endpoint ep, String type, byte[] payload) {
+ return messagingService.sendAndReceive(toAddress(ep), type, payload);
+ }
+
+ @Override
+ public CompletableFuture<byte[]> sendAndReceive(Endpoint ep, String type, byte[] payload, Executor executor) {
+ return messagingService.sendAndReceive(toAddress(ep), type, payload, executor);
+ }
+
+ @Override
+ public void registerHandler(String type, BiConsumer<Endpoint, byte[]> handler, Executor executor) {
+ BiConsumer<Address, byte[]> consumer = (address, payload) -> handler.accept(toEndpoint(address), payload);
+ messagingService.registerHandler(type, consumer, executor);
+ }
+
+ @Override
+ public void registerHandler(String type, BiFunction<Endpoint, byte[], byte[]> handler, Executor executor) {
+ BiFunction<Address, byte[], byte[]> function = (address, payload) ->
+ handler.apply(toEndpoint(address), payload);
+ messagingService.registerHandler(type, function, executor);
+ }
+
+ @Override
+ public void registerHandler(String type, BiFunction<Endpoint, byte[], CompletableFuture<byte[]>> handler) {
+ BiFunction<Address, byte[], CompletableFuture<byte[]>> function = (address, payload) ->
+ handler.apply(toEndpoint(address), payload);
+ messagingService.registerHandler(type, function);
+ }
+
+ @Override
+ public void unregisterHandler(String type) {
+ messagingService.unregisterHandler(type);
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/package-info.java b/core/store/primitives/src/main/java/org/onosproject/store/cluster/messaging/impl/package-info.java
similarity index 76%
rename from core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/package-info.java
rename to core/store/primitives/src/main/java/org/onosproject/store/cluster/messaging/impl/package-info.java
index aa11664..b88387a 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/package-info.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/cluster/messaging/impl/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2016-present Open Networking Foundation
+ * Copyright 2018-present Open Networking Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,6 +15,6 @@
*/
/**
- * State machine implementation classes for distributed primitives.
+ * Implementation classes for cluster messaging.
*/
-package org.onosproject.store.primitives.resources.impl;
+package org.onosproject.store.cluster.messaging.impl;
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/impl/AtomixManager.java b/core/store/primitives/src/main/java/org/onosproject/store/impl/AtomixManager.java
new file mode 100644
index 0000000..43cde78
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/impl/AtomixManager.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.impl;
+
+import java.util.stream.Collectors;
+
+import io.atomix.cluster.discovery.BootstrapDiscoveryProvider;
+import io.atomix.core.Atomix;
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.onosproject.cluster.ClusterMetadataService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Atomix manager.
+ */
+@Component(immediate = true)
+@Service(value = AtomixManager.class)
+public class AtomixManager {
+
+ private final Logger log = LoggerFactory.getLogger(getClass());
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected ClusterMetadataService metadataService;
+
+ private Atomix atomix;
+
+ /**
+ * Returns the Atomix instance.
+ *
+ * @return the Atomix instance
+ */
+ public Atomix getAtomix() {
+ return atomix;
+ }
+
+ @Activate
+ public void activate() {
+ atomix = createAtomix();
+ atomix.start().join();
+ log.info("Started");
+ }
+
+ @Deactivate
+ public void deactivate() {
+ atomix.stop().join();
+ log.info("Stopped");
+ }
+
+ private Atomix createAtomix() {
+ return Atomix.builder(getClass().getClassLoader())
+ .withClusterId(metadataService.getClusterMetadata().getName())
+ .withMemberId(metadataService.getLocalNode().id().id())
+ .withAddress(metadataService.getLocalNode().ip().toString(), metadataService.getLocalNode().tcpPort())
+ .withProperty("type", "onos")
+ .withMembershipProvider(BootstrapDiscoveryProvider.builder()
+ .withNodes(metadataService.getClusterMetadata().getStorageNodes().stream()
+ .map(node -> io.atomix.cluster.Node.builder()
+ .withId(node.id().id())
+ .withAddress(node.ip().toString(), node.tcpPort())
+ .build())
+ .collect(Collectors.toList()))
+ .build())
+ .build();
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/package-info.java b/core/store/primitives/src/main/java/org/onosproject/store/impl/package-info.java
similarity index 76%
copy from core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/package-info.java
copy to core/store/primitives/src/main/java/org/onosproject/store/impl/package-info.java
index aa11664..6f34a50 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/package-info.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/impl/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2016-present Open Networking Foundation
+ * Copyright 2018-present Open Networking Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,6 +15,6 @@
*/
/**
- * State machine implementation classes for distributed primitives.
+ * Implementation classes for various Distributed primitives.
*/
-package org.onosproject.store.primitives.resources.impl;
+package org.onosproject.store.impl;
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AntiEntropyAdvertisement.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AntiEntropyAdvertisement.java
index 373273c..0004fe1 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AntiEntropyAdvertisement.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AntiEntropyAdvertisement.java
@@ -15,13 +15,12 @@
*/
package org.onosproject.store.primitives.impl;
+import java.util.Map;
+
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableMap;
-
import org.onosproject.cluster.NodeId;
-import java.util.Map;
-
import static com.google.common.base.Preconditions.checkNotNull;
/**
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicCounter.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicCounter.java
new file mode 100644
index 0000000..ce5c248
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicCounter.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.concurrent.CompletableFuture;
+
+import org.onosproject.store.service.AsyncAtomicCounter;
+
+/**
+ * Atomix atomic counter.
+ */
+public class AtomixAtomicCounter implements AsyncAtomicCounter {
+ private final io.atomix.core.counter.AsyncAtomicCounter atomixCounter;
+
+ public AtomixAtomicCounter(io.atomix.core.counter.AsyncAtomicCounter atomixCounter) {
+ this.atomixCounter = atomixCounter;
+ }
+
+ @Override
+ public String name() {
+ return atomixCounter.name();
+ }
+
+ @Override
+ public CompletableFuture<Long> incrementAndGet() {
+ return atomixCounter.incrementAndGet();
+ }
+
+ @Override
+ public CompletableFuture<Long> getAndIncrement() {
+ return atomixCounter.getAndIncrement();
+ }
+
+ @Override
+ public CompletableFuture<Long> getAndAdd(long delta) {
+ return atomixCounter.getAndAdd(delta);
+ }
+
+ @Override
+ public CompletableFuture<Long> addAndGet(long delta) {
+ return atomixCounter.addAndGet(delta);
+ }
+
+ @Override
+ public CompletableFuture<Long> get() {
+ return atomixCounter.get();
+ }
+
+ @Override
+ public CompletableFuture<Void> set(long value) {
+ return atomixCounter.set(value);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> compareAndSet(long expectedValue, long updateValue) {
+ return atomixCounter.compareAndSet(expectedValue, updateValue);
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicCounterBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicCounterBuilder.java
new file mode 100644
index 0000000..b18c128
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicCounterBuilder.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.service.AsyncAtomicCounter;
+import org.onosproject.store.service.AtomicCounterBuilder;
+
+/**
+ * Default {@link org.onosproject.store.service.AsyncAtomicCounter} builder.
+ */
+public class AtomixAtomicCounterBuilder extends AtomicCounterBuilder {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixAtomicCounterBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public AsyncAtomicCounter build() {
+ return new AtomixAtomicCounter(atomix.atomicCounterBuilder(name())
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ .withSerializer(new AtomixSerializerAdapter(serializer()))
+ .build()
+ .async());
+ }
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicCounterMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicCounterMap.java
new file mode 100644
index 0000000..fc0aca1
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicCounterMap.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.concurrent.CompletableFuture;
+
+import org.onosproject.store.service.AsyncAtomicCounterMap;
+
+/**
+ * Atomix atomic counter map.
+ */
+public class AtomixAtomicCounterMap<K> implements AsyncAtomicCounterMap<K> {
+ private final io.atomix.core.map.AsyncAtomicCounterMap<K> atomixMap;
+
+ public AtomixAtomicCounterMap(io.atomix.core.map.AsyncAtomicCounterMap<K> atomixMap) {
+ this.atomixMap = atomixMap;
+ }
+
+ @Override
+ public String name() {
+ return atomixMap.name();
+ }
+
+ @Override
+ public CompletableFuture<Long> incrementAndGet(K key) {
+ return atomixMap.incrementAndGet(key);
+ }
+
+ @Override
+ public CompletableFuture<Long> decrementAndGet(K key) {
+ return atomixMap.decrementAndGet(key);
+ }
+
+ @Override
+ public CompletableFuture<Long> getAndIncrement(K key) {
+ return atomixMap.getAndIncrement(key);
+ }
+
+ @Override
+ public CompletableFuture<Long> getAndDecrement(K key) {
+ return atomixMap.getAndDecrement(key);
+ }
+
+ @Override
+ public CompletableFuture<Long> addAndGet(K key, long delta) {
+ return atomixMap.addAndGet(key, delta);
+ }
+
+ @Override
+ public CompletableFuture<Long> getAndAdd(K key, long delta) {
+ return atomixMap.getAndAdd(key, delta);
+ }
+
+ @Override
+ public CompletableFuture<Long> get(K key) {
+ return atomixMap.get(key);
+ }
+
+ @Override
+ public CompletableFuture<Long> put(K key, long newValue) {
+ return atomixMap.put(key, newValue);
+ }
+
+ @Override
+ public CompletableFuture<Long> putIfAbsent(K key, long newValue) {
+ return atomixMap.putIfAbsent(key, newValue);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> replace(K key, long expectedOldValue, long newValue) {
+ return atomixMap.replace(key, expectedOldValue, newValue);
+ }
+
+ @Override
+ public CompletableFuture<Long> remove(K key) {
+ return atomixMap.remove(key);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> remove(K key, long value) {
+ return atomixMap.remove(key, value);
+ }
+
+ @Override
+ public CompletableFuture<Integer> size() {
+ return atomixMap.size();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> isEmpty() {
+ return atomixMap.isEmpty();
+ }
+
+ @Override
+ public CompletableFuture<Void> clear() {
+ return atomixMap.clear();
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicCounterMapBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicCounterMapBuilder.java
new file mode 100644
index 0000000..03177bf
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicCounterMapBuilder.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.service.AsyncAtomicCounterMap;
+import org.onosproject.store.service.AtomicCounterMap;
+import org.onosproject.store.service.AtomicCounterMapBuilder;
+
+/**
+ * Default {@link org.onosproject.store.service.AsyncAtomicCounterMap} builder.
+ *
+ * @param <K> type for tree value
+ */
+public class AtomixAtomicCounterMapBuilder<K> extends AtomicCounterMapBuilder<K> {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixAtomicCounterMapBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public AtomicCounterMap<K> build() {
+ return buildAsyncMap().asAtomicCounterMap();
+ }
+
+ @Override
+ public AsyncAtomicCounterMap<K> buildAsyncMap() {
+ return new AtomixAtomicCounterMap<K>(atomix.<K>atomicCounterMapBuilder(name())
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ .withSerializer(new AtomixSerializerAdapter(serializer()))
+ .build()
+ .async());
+ }
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicIdGenerator.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicIdGenerator.java
new file mode 100644
index 0000000..2bafa0b
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicIdGenerator.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.concurrent.CompletableFuture;
+
+import org.onosproject.store.service.AsyncAtomicIdGenerator;
+
+/**
+ * Atomix atomic ID generator.
+ */
+public class AtomixAtomicIdGenerator implements AsyncAtomicIdGenerator {
+ private final io.atomix.core.idgenerator.AsyncAtomicIdGenerator atomixIdGenerator;
+
+ public AtomixAtomicIdGenerator(io.atomix.core.idgenerator.AsyncAtomicIdGenerator atomixIdGenerator) {
+ this.atomixIdGenerator = atomixIdGenerator;
+ }
+
+ @Override
+ public String name() {
+ return atomixIdGenerator.name();
+ }
+
+ @Override
+ public CompletableFuture<Long> nextId() {
+ return atomixIdGenerator.nextId();
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicIdGeneratorBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicIdGeneratorBuilder.java
new file mode 100644
index 0000000..2b7bd85
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicIdGeneratorBuilder.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.service.AsyncAtomicIdGenerator;
+import org.onosproject.store.service.AtomicIdGeneratorBuilder;
+
+/**
+ * Default {@link org.onosproject.store.service.AsyncAtomicIdGenerator} builder.
+ */
+public class AtomixAtomicIdGeneratorBuilder extends AtomicIdGeneratorBuilder {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixAtomicIdGeneratorBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public AsyncAtomicIdGenerator build() {
+ return new AtomixAtomicIdGenerator(atomix.atomicIdGeneratorBuilder(name())
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ .withSerializer(new AtomixSerializerAdapter(serializer()))
+ .build()
+ .async());
+ }
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicValue.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicValue.java
new file mode 100644
index 0000000..977b206
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicValue.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+
+import com.google.common.collect.Maps;
+import org.onosproject.store.service.AsyncAtomicValue;
+import org.onosproject.store.service.AtomicValueEvent;
+import org.onosproject.store.service.AtomicValueEventListener;
+
+/**
+ * Atomix atomic value.
+ */
+public class AtomixAtomicValue<V> implements AsyncAtomicValue<V> {
+ private final io.atomix.core.value.AsyncAtomicValue<V> atomixValue;
+ private final Map<AtomicValueEventListener<V>, io.atomix.core.value.AtomicValueEventListener<V>> listenerMap =
+ Maps.newIdentityHashMap();
+
+ public AtomixAtomicValue(io.atomix.core.value.AsyncAtomicValue<V> atomixValue) {
+ this.atomixValue = atomixValue;
+ }
+
+ @Override
+ public String name() {
+ return atomixValue.name();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> compareAndSet(V expect, V update) {
+ return atomixValue.compareAndSet(expect, update);
+ }
+
+ @Override
+ public CompletableFuture<V> get() {
+ return atomixValue.get();
+ }
+
+ @Override
+ public CompletableFuture<V> getAndSet(V value) {
+ return atomixValue.getAndSet(value);
+ }
+
+ @Override
+ public CompletableFuture<Void> set(V value) {
+ return atomixValue.set(value);
+ }
+
+ @Override
+ public synchronized CompletableFuture<Void> addListener(AtomicValueEventListener<V> listener) {
+ io.atomix.core.value.AtomicValueEventListener<V> atomixListener = event ->
+ listener.event(new AtomicValueEvent<V>(
+ name(),
+ event.newValue(),
+ event.oldValue()));
+ listenerMap.put(listener, atomixListener);
+ return atomixValue.addListener(atomixListener);
+ }
+
+ @Override
+ public synchronized CompletableFuture<Void> removeListener(AtomicValueEventListener<V> listener) {
+ io.atomix.core.value.AtomicValueEventListener<V> atomixListener = listenerMap.remove(listener);
+ if (atomixListener != null) {
+ return atomixValue.removeListener(atomixListener);
+ }
+ return CompletableFuture.completedFuture(null);
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicValueBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicValueBuilder.java
new file mode 100644
index 0000000..6b2e5df
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixAtomicValueBuilder.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.service.AsyncAtomicValue;
+import org.onosproject.store.service.AtomicValueBuilder;
+
+/**
+ * Default {@link org.onosproject.store.service.AsyncAtomicValue} builder.
+ *
+ * @param <V> type for set value
+ */
+public class AtomixAtomicValueBuilder<V> extends AtomicValueBuilder<V> {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixAtomicValueBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public AsyncAtomicValue<V> build() {
+ return new AtomixAtomicValue<V>(atomix.<V>atomicValueBuilder(name())
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ .withSerializer(new AtomixSerializerAdapter(serializer()))
+ .build()
+ .async());
+ }
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentMap.java
new file mode 100644
index 0000000..d1a601d
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentMap.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.BiFunction;
+import java.util.function.Predicate;
+
+import com.google.common.base.Throwables;
+import com.google.common.collect.Maps;
+import io.atomix.core.collection.impl.TranscodingAsyncDistributedCollection;
+import io.atomix.core.set.impl.TranscodingAsyncDistributedSet;
+import org.onosproject.store.primitives.MapUpdate;
+import org.onosproject.store.primitives.TransactionId;
+import org.onosproject.store.service.AsyncConsistentMap;
+import org.onosproject.store.service.AsyncIterator;
+import org.onosproject.store.service.ConsistentMapException;
+import org.onosproject.store.service.MapEvent;
+import org.onosproject.store.service.MapEventListener;
+import org.onosproject.store.service.TransactionLog;
+import org.onosproject.store.service.Version;
+import org.onosproject.store.service.Versioned;
+
+/**
+ * Atomix consistent map.
+ */
+public class AtomixConsistentMap<K, V> implements AsyncConsistentMap<K, V> {
+ private final io.atomix.core.map.AsyncAtomicMap<K, V> atomixMap;
+ private final Map<MapEventListener<K, V>, io.atomix.core.map.AtomicMapEventListener<K, V>> listenerMap =
+ Maps.newIdentityHashMap();
+
+ public AtomixConsistentMap(io.atomix.core.map.AsyncAtomicMap<K, V> atomixMap) {
+ this.atomixMap = atomixMap;
+ }
+
+ @Override
+ public String name() {
+ return atomixMap.name();
+ }
+
+ @Override
+ public CompletableFuture<Integer> size() {
+ return atomixMap.size();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> containsKey(K key) {
+ return atomixMap.containsKey(key);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> containsValue(V value) {
+ return atomixMap.containsValue(value);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> get(K key) {
+ return atomixMap.get(key).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> getOrDefault(K key, V defaultValue) {
+ return atomixMap.getOrDefault(key, defaultValue).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> computeIf(
+ K key, Predicate<? super V> condition, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ return adapt(atomixMap.computeIf(key, condition, remappingFunction).thenApply(this::toVersioned));
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> put(K key, V value) {
+ return adapt(atomixMap.put(key, value).thenApply(this::toVersioned));
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> putAndGet(K key, V value) {
+ return adapt(atomixMap.putAndGet(key, value).thenApply(this::toVersioned));
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> remove(K key) {
+ return adapt(atomixMap.remove(key).thenApply(this::toVersioned));
+ }
+
+ @Override
+ public CompletableFuture<Void> clear() {
+ return atomixMap.clear();
+ }
+
+ @Override
+ public CompletableFuture<Set<K>> keySet() {
+ return CompletableFuture.completedFuture(atomixMap.keySet().sync());
+ }
+
+ @Override
+ public CompletableFuture<Collection<Versioned<V>>> values() {
+ return CompletableFuture.completedFuture(
+ new TranscodingAsyncDistributedCollection<Versioned<V>, io.atomix.utils.time.Versioned<V>>(
+ atomixMap.values(),
+ v -> new io.atomix.utils.time.Versioned<>(v.value(), v.version()),
+ v -> new Versioned<>(v.value(), v.version())).sync());
+ }
+
+ @Override
+ public CompletableFuture<Set<Map.Entry<K, Versioned<V>>>> entrySet() {
+ return CompletableFuture.completedFuture(
+ new TranscodingAsyncDistributedSet<Map.Entry<K, Versioned<V>>,
+ Map.Entry<K, io.atomix.utils.time.Versioned<V>>>(
+ atomixMap.entrySet(),
+ e -> Maps.immutableEntry(e.getKey(),
+ new io.atomix.utils.time.Versioned<>(e.getValue().value(), e.getValue().version())),
+ e -> Maps.immutableEntry(e.getKey(), new Versioned<>(e.getValue().value(), e.getValue().version())))
+ .sync());
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> putIfAbsent(K key, V value) {
+ return adapt(atomixMap.putIfAbsent(key, value).thenApply(this::toVersioned));
+ }
+
+ @Override
+ public CompletableFuture<Boolean> remove(K key, V value) {
+ return adapt(atomixMap.remove(key, value));
+ }
+
+ @Override
+ public CompletableFuture<Boolean> remove(K key, long version) {
+ return adapt(atomixMap.remove(key, version));
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> replace(K key, V value) {
+ return adapt(atomixMap.replace(key, value).thenApply(this::toVersioned));
+ }
+
+ @Override
+ public CompletableFuture<Boolean> replace(K key, V oldValue, V newValue) {
+ return adapt(atomixMap.replace(key, oldValue, newValue));
+ }
+
+ @Override
+ public CompletableFuture<Boolean> replace(K key, long oldVersion, V newValue) {
+ return adapt(atomixMap.replace(key, oldVersion, newValue));
+ }
+
+ @Override
+ public CompletableFuture<AsyncIterator<Map.Entry<K, Versioned<V>>>> iterator() {
+ io.atomix.core.iterator.AsyncIterator<Map.Entry<K, io.atomix.utils.time.Versioned<V>>> atomixIterator
+ = atomixMap.entrySet().iterator();
+ return CompletableFuture.completedFuture(new AsyncIterator<Map.Entry<K, Versioned<V>>>() {
+ @Override
+ public CompletableFuture<Boolean> hasNext() {
+ return atomixIterator.hasNext();
+ }
+
+ @Override
+ public CompletableFuture<Map.Entry<K, Versioned<V>>> next() {
+ return atomixIterator.next()
+ .thenApply(entry -> Maps.immutableEntry(entry.getKey(), toVersioned(entry.getValue())));
+ }
+ });
+ }
+
+ @Override
+ public synchronized CompletableFuture<Void> addListener(MapEventListener<K, V> listener, Executor executor) {
+ io.atomix.core.map.AtomicMapEventListener<K, V> atomixListener = event ->
+ listener.event(new MapEvent<K, V>(
+ MapEvent.Type.valueOf(event.type().name()),
+ name(),
+ event.key(),
+ toVersioned(event.newValue()),
+ toVersioned(event.oldValue())));
+ listenerMap.put(listener, atomixListener);
+ return atomixMap.addListener(atomixListener, executor);
+ }
+
+ @Override
+ public CompletableFuture<Void> removeListener(MapEventListener<K, V> listener) {
+ io.atomix.core.map.AtomicMapEventListener<K, V> atomixListener = listenerMap.remove(listener);
+ if (atomixListener != null) {
+ return atomixMap.removeListener(atomixListener);
+ }
+ return CompletableFuture.completedFuture(null);
+ }
+
+ @Override
+ public CompletableFuture<Version> begin(TransactionId transactionId) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<K, V>> transactionLog) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<K, V>> transactionLog) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Void> commit(TransactionId transactionId) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Void> rollback(TransactionId transactionId) {
+ throw new UnsupportedOperationException();
+ }
+
+ private <T> CompletableFuture<T> adapt(CompletableFuture<T> future) {
+ CompletableFuture<T> newFuture = new CompletableFuture<>();
+ future.whenComplete((result, error) -> {
+ if (error == null) {
+ newFuture.complete(result);
+ } else {
+ Throwable cause = Throwables.getRootCause(error);
+ if (cause instanceof io.atomix.primitive.PrimitiveException.ConcurrentModification) {
+ newFuture.completeExceptionally(
+ new ConsistentMapException.ConcurrentModification(cause.getMessage()));
+ } else if (cause instanceof io.atomix.primitive.PrimitiveException.Timeout) {
+ newFuture.completeExceptionally(new ConsistentMapException.Timeout(cause.getMessage()));
+ } else if (cause instanceof io.atomix.primitive.PrimitiveException.Interrupted) {
+ newFuture.completeExceptionally(new ConsistentMapException.Interrupted());
+ } else if (cause instanceof io.atomix.primitive.PrimitiveException.Unavailable) {
+ newFuture.completeExceptionally(new ConsistentMapException.Unavailable());
+ } else if (cause instanceof io.atomix.primitive.PrimitiveException) {
+ newFuture.completeExceptionally(new ConsistentMapException(cause.getMessage()));
+ }
+ }
+ });
+ return newFuture;
+ }
+
+ private Versioned<V> toVersioned(io.atomix.utils.time.Versioned<V> versioned) {
+ return versioned != null
+ ? new Versioned<>(versioned.value(), versioned.version(), versioned.creationTime())
+ : null;
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentMapBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentMapBuilder.java
new file mode 100644
index 0000000..0eadcde
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentMapBuilder.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2016-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.service.AsyncConsistentMap;
+import org.onosproject.store.service.ConsistentMap;
+import org.onosproject.store.service.ConsistentMapBuilder;
+
+/**
+ * Default {@link AsyncConsistentMap} builder.
+ *
+ * @param <K> type for map key
+ * @param <V> type for map value
+ */
+public class AtomixConsistentMapBuilder<K, V> extends ConsistentMapBuilder<K, V> {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixConsistentMapBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public ConsistentMap<K, V> build() {
+ return buildAsyncMap().asConsistentMap();
+ }
+
+ @Override
+ public AsyncConsistentMap<K, V> buildAsyncMap() {
+ return new AtomixConsistentMap<>(atomix.<K, V>atomicMapBuilder(name())
+ .withRegistrationRequired()
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ .withCacheEnabled(relaxedReadConsistency())
+ .withSerializer(new AtomixSerializerAdapter(serializer()))
+ .build()
+ .async());
+ }
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentMultimap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentMultimap.java
new file mode 100644
index 0000000..6627a81
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentMultimap.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.Function;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multiset;
+import io.atomix.core.map.impl.TranscodingAsyncDistributedMap;
+import org.onosproject.store.service.AsyncConsistentMultimap;
+import org.onosproject.store.service.AsyncIterator;
+import org.onosproject.store.service.MultimapEvent;
+import org.onosproject.store.service.MultimapEventListener;
+import org.onosproject.store.service.Versioned;
+
+/**
+ * Atomix consistent map.
+ */
+public class AtomixConsistentMultimap<K, V> implements AsyncConsistentMultimap<K, V> {
+ private final io.atomix.core.multimap.AsyncAtomicMultimap<K, V> atomixMultimap;
+ private final Map<MultimapEventListener<K, V>, io.atomix.core.multimap.AtomicMultimapEventListener<K, V>>
+ listenerMap = Maps.newIdentityHashMap();
+
+ public AtomixConsistentMultimap(io.atomix.core.multimap.AsyncAtomicMultimap<K, V> atomixMultimap) {
+ this.atomixMultimap = atomixMultimap;
+ }
+
+ @Override
+ public String name() {
+ return atomixMultimap.name();
+ }
+
+ @Override
+ public CompletableFuture<Integer> size() {
+ return atomixMultimap.size();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> containsKey(K key) {
+ return atomixMultimap.containsKey(key);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> containsValue(V value) {
+ return atomixMultimap.containsValue(value);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> isEmpty() {
+ return atomixMultimap.isEmpty();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> containsEntry(K key, V value) {
+ return atomixMultimap.containsEntry(key, value);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> put(K key, V value) {
+ return atomixMultimap.put(key, value);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<Collection<? extends V>>> putAndGet(K key, V value) {
+ return atomixMultimap.put(key, value).thenCompose(v -> atomixMultimap.get(key)).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> remove(K key, V value) {
+ return atomixMultimap.remove(key, value);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<Collection<? extends V>>> removeAndGet(K key, V value) {
+ return atomixMultimap.remove(key, value).thenCompose(v -> atomixMultimap.get(key)).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> removeAll(K key, Collection<? extends V> values) {
+ return atomixMultimap.removeAll(key, values);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<Collection<? extends V>>> removeAll(K key) {
+ return atomixMultimap.removeAll(key).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> putAll(K key, Collection<? extends V> values) {
+ return atomixMultimap.putAll(key, values);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public CompletableFuture<Versioned<Collection<? extends V>>> replaceValues(K key, Collection<V> values) {
+ return atomixMultimap.replaceValues(key, values).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Void> clear() {
+ return atomixMultimap.clear();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public CompletableFuture<Versioned<Collection<? extends V>>> get(K key) {
+ return atomixMultimap.get(key).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Set<K>> keySet() {
+ return CompletableFuture.completedFuture(atomixMultimap.keySet().sync());
+ }
+
+ @Override
+ public CompletableFuture<Multiset<K>> keys() {
+ return CompletableFuture.completedFuture(atomixMultimap.keys().sync());
+ }
+
+ @Override
+ public CompletableFuture<Multiset<V>> values() {
+ return CompletableFuture.completedFuture(atomixMultimap.values().sync());
+ }
+
+ @Override
+ public CompletableFuture<Collection<Map.Entry<K, V>>> entries() {
+ return CompletableFuture.completedFuture(atomixMultimap.entries().sync());
+ }
+
+ @Override
+ public CompletableFuture<AsyncIterator<Map.Entry<K, V>>> iterator() {
+ return CompletableFuture.completedFuture(new AtomixIterator<>(atomixMultimap.entries().iterator()));
+ }
+
+ @Override
+ public CompletableFuture<Map<K, Collection<V>>> asMap() {
+ return CompletableFuture.completedFuture(
+ new TranscodingAsyncDistributedMap<K, Collection<V>, K, io.atomix.utils.time.Versioned<Collection<V>>>(
+ atomixMultimap.asMap(),
+ Function.identity(),
+ Function.identity(),
+ v -> new io.atomix.utils.time.Versioned<>(v, 0),
+ v -> v.value()).sync());
+ }
+
+ @Override
+ public synchronized CompletableFuture<Void> addListener(MultimapEventListener<K, V> listener, Executor executor) {
+ io.atomix.core.multimap.AtomicMultimapEventListener<K, V> atomixListener = event ->
+ listener.event(new MultimapEvent<K, V>(
+ name(),
+ event.key(),
+ event.newValue(),
+ event.oldValue()));
+ listenerMap.put(listener, atomixListener);
+ return atomixMultimap.addListener(atomixListener, executor);
+ }
+
+ @Override
+ public CompletableFuture<Void> removeListener(MultimapEventListener<K, V> listener) {
+ io.atomix.core.multimap.AtomicMultimapEventListener<K, V> atomixListener = listenerMap.remove(listener);
+ if (atomixListener != null) {
+ return atomixMultimap.removeListener(atomixListener);
+ }
+ return CompletableFuture.completedFuture(null);
+ }
+
+ private Versioned<Collection<? extends V>> toVersioned(
+ io.atomix.utils.time.Versioned<Collection<V>> versioned) {
+ return versioned != null
+ ? new Versioned<>(versioned.value(), versioned.version(), versioned.creationTime())
+ : null;
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentMultimapBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentMultimapBuilder.java
new file mode 100644
index 0000000..88f6bd2
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentMultimapBuilder.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.service.AsyncConsistentMultimap;
+import org.onosproject.store.service.ConsistentMultimap;
+import org.onosproject.store.service.ConsistentMultimapBuilder;
+
+/**
+ * Default {@link AsyncConsistentMultimap} builder.
+ *
+ * @param <K> type for multimap key
+ * @param <V> type for multimap value
+ */
+public class AtomixConsistentMultimapBuilder<K, V> extends ConsistentMultimapBuilder<K, V> {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixConsistentMultimapBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public AsyncConsistentMultimap<K, V> buildMultimap() {
+ return new AtomixConsistentMultimap<>(atomix.<K, V>atomicMultimapBuilder(name())
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ .withCacheEnabled(relaxedReadConsistency())
+ .withSerializer(new AtomixSerializerAdapter(serializer()))
+ .build()
+ .async());
+ }
+
+ @Override
+ public ConsistentMultimap<K, V> build() {
+ return buildMultimap().asMultimap();
+ }
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentTreeMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentTreeMap.java
new file mode 100644
index 0000000..a7bedbb
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentTreeMap.java
@@ -0,0 +1,345 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.NavigableSet;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.BiFunction;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import com.google.common.base.Throwables;
+import com.google.common.collect.Maps;
+import io.atomix.core.collection.impl.TranscodingAsyncDistributedCollection;
+import io.atomix.core.map.impl.DelegatingAsyncDistributedNavigableMap;
+import org.onosproject.store.primitives.MapUpdate;
+import org.onosproject.store.primitives.TransactionId;
+import org.onosproject.store.service.AsyncConsistentTreeMap;
+import org.onosproject.store.service.AsyncIterator;
+import org.onosproject.store.service.ConsistentMapException;
+import org.onosproject.store.service.MapEvent;
+import org.onosproject.store.service.MapEventListener;
+import org.onosproject.store.service.TransactionLog;
+import org.onosproject.store.service.Version;
+import org.onosproject.store.service.Versioned;
+
+/**
+ * Atomix consistent tree map.
+ */
+public class AtomixConsistentTreeMap<V> implements AsyncConsistentTreeMap<V> {
+ private final io.atomix.core.map.AsyncAtomicNavigableMap<String, V> atomixTreeMap;
+ private final Map<MapEventListener<String, V>, io.atomix.core.map.AtomicMapEventListener<String, V>> listenerMap =
+ Maps.newIdentityHashMap();
+
+ public AtomixConsistentTreeMap(io.atomix.core.map.AsyncAtomicNavigableMap<String, V> atomixTreeMap) {
+ this.atomixTreeMap = atomixTreeMap;
+ }
+
+ @Override
+ public String name() {
+ return atomixTreeMap.name();
+ }
+
+ @Override
+ public CompletableFuture<Integer> size() {
+ return atomixTreeMap.size();
+ }
+
+ @Override
+ public CompletableFuture<String> firstKey() {
+ return atomixTreeMap.firstKey();
+ }
+
+ @Override
+ public CompletableFuture<String> lastKey() {
+ return atomixTreeMap.lastKey();
+ }
+
+ @Override
+ public CompletableFuture<Map.Entry<String, Versioned<V>>> ceilingEntry(String key) {
+ return atomixTreeMap.ceilingEntry(key).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Map.Entry<String, Versioned<V>>> floorEntry(String key) {
+ return atomixTreeMap.floorEntry(key).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Map.Entry<String, Versioned<V>>> higherEntry(String key) {
+ return atomixTreeMap.higherEntry(key).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Map.Entry<String, Versioned<V>>> lowerEntry(String key) {
+ return atomixTreeMap.lowerEntry(key).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Map.Entry<String, Versioned<V>>> firstEntry() {
+ return atomixTreeMap.firstEntry().thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Map.Entry<String, Versioned<V>>> lastEntry() {
+ return atomixTreeMap.lastEntry().thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Map.Entry<String, Versioned<V>>> pollFirstEntry() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Map.Entry<String, Versioned<V>>> pollLastEntry() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> containsKey(String key) {
+ return atomixTreeMap.containsKey(key);
+ }
+
+ @Override
+ public CompletableFuture<String> lowerKey(String key) {
+ return atomixTreeMap.lowerKey(key);
+ }
+
+ @Override
+ public CompletableFuture<String> floorKey(String key) {
+ return atomixTreeMap.floorKey(key);
+ }
+
+ @Override
+ public CompletableFuture<String> ceilingKey(String key) {
+ return atomixTreeMap.ceilingKey(key);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> get(String key) {
+ return atomixTreeMap.get(key).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<String> higherKey(String key) {
+ return atomixTreeMap.higherKey(key);
+ }
+
+ @Override
+ public CompletableFuture<NavigableSet<String>> navigableKeySet() {
+ return CompletableFuture.completedFuture(atomixTreeMap.navigableKeySet().sync());
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> getOrDefault(String key, V defaultValue) {
+ return atomixTreeMap.getOrDefault(key, defaultValue).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<NavigableMap<String, V>> subMap(
+ String upperKey, String lowerKey, boolean inclusiveUpper, boolean inclusiveLower) {
+ return CompletableFuture.completedFuture(
+ new DelegatingAsyncDistributedNavigableMap<>(
+ atomixTreeMap.subMap(lowerKey, inclusiveLower, upperKey, inclusiveUpper)).sync());
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> computeIf(
+ String key,
+ Predicate<? super V> condition, BiFunction<? super String, ? super V, ? extends V> remappingFunction) {
+ return adapt(atomixTreeMap.computeIf(key, condition, remappingFunction)).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> put(String key, V value) {
+ return adapt(atomixTreeMap.put(key, value)).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> putAndGet(String key, V value) {
+ return adapt(atomixTreeMap.putAndGet(key, value)).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> remove(String key) {
+ return adapt(atomixTreeMap.remove(key)).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Set<String>> keySet() {
+ return CompletableFuture.completedFuture(atomixTreeMap.keySet().sync());
+ }
+
+ @Override
+ public CompletableFuture<Set<Map.Entry<String, Versioned<V>>>> entrySet() {
+ return CompletableFuture.completedFuture(atomixTreeMap.entrySet().stream()
+ .map(this::toVersioned)
+ .collect(Collectors.toSet()));
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> putIfAbsent(String key, V value) {
+ return adapt(atomixTreeMap.putIfAbsent(key, value)).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> remove(String key, V value) {
+ return adapt(atomixTreeMap.remove(key, value));
+ }
+
+ @Override
+ public CompletableFuture<Boolean> remove(String key, long version) {
+ return adapt(atomixTreeMap.remove(key, version));
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> replace(String key, V value) {
+ return adapt(atomixTreeMap.replace(key, value)).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> replace(String key, V oldValue, V newValue) {
+ return adapt(atomixTreeMap.replace(key, oldValue, newValue));
+ }
+
+ @Override
+ public CompletableFuture<Boolean> replace(String key, long oldVersion, V newValue) {
+ return adapt(atomixTreeMap.replace(key, oldVersion, newValue));
+ }
+
+ @Override
+ public CompletableFuture<Boolean> containsValue(V value) {
+ return atomixTreeMap.containsValue(value);
+ }
+
+ @Override
+ public CompletableFuture<AsyncIterator<Map.Entry<String, Versioned<V>>>> iterator() {
+ io.atomix.core.iterator.AsyncIterator<Map.Entry<String, io.atomix.utils.time.Versioned<V>>> atomixIterator
+ = atomixTreeMap.entrySet().iterator();
+ return CompletableFuture.completedFuture(new AsyncIterator<Map.Entry<String, Versioned<V>>>() {
+ @Override
+ public CompletableFuture<Boolean> hasNext() {
+ return atomixIterator.hasNext();
+ }
+
+ @Override
+ public CompletableFuture<Map.Entry<String, Versioned<V>>> next() {
+ return atomixIterator.next()
+ .thenApply(entry -> Maps.immutableEntry(entry.getKey(), toVersioned(entry.getValue())));
+ }
+ });
+ }
+
+ @Override
+ public CompletableFuture<Void> clear() {
+ return atomixTreeMap.clear();
+ }
+
+ @Override
+ public CompletableFuture<Collection<Versioned<V>>> values() {
+ return CompletableFuture.completedFuture(
+ new TranscodingAsyncDistributedCollection<Versioned<V>, io.atomix.utils.time.Versioned<V>>(
+ atomixTreeMap.values(),
+ e -> new io.atomix.utils.time.Versioned<>(e.value(), e.version()),
+ e -> new Versioned<>(e.value(), e.version())).sync());
+ }
+
+ @Override
+ public synchronized CompletableFuture<Void> addListener(MapEventListener<String, V> listener, Executor executor) {
+ io.atomix.core.map.AtomicMapEventListener<String, V> atomixListener = event ->
+ listener.event(new MapEvent<String, V>(
+ MapEvent.Type.valueOf(event.type().name()),
+ name(),
+ event.key(),
+ toVersioned(event.newValue()),
+ toVersioned(event.oldValue())));
+ listenerMap.put(listener, atomixListener);
+ return atomixTreeMap.addListener(atomixListener, executor);
+ }
+
+ @Override
+ public CompletableFuture<Void> removeListener(MapEventListener<String, V> listener) {
+ io.atomix.core.map.AtomicMapEventListener<String, V> atomixListener = listenerMap.remove(listener);
+ if (atomixListener != null) {
+ return atomixTreeMap.removeListener(atomixListener);
+ }
+ return CompletableFuture.completedFuture(null);
+ }
+
+ @Override
+ public CompletableFuture<Version> begin(TransactionId transactionId) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<String, V>> transactionLog) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<String, V>> transactionLog) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Void> commit(TransactionId transactionId) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Void> rollback(TransactionId transactionId) {
+ throw new UnsupportedOperationException();
+ }
+
+ private <T> CompletableFuture<T> adapt(CompletableFuture<T> future) {
+ CompletableFuture<T> newFuture = new CompletableFuture<>();
+ future.whenComplete((result, error) -> {
+ if (error == null) {
+ newFuture.complete(result);
+ } else {
+ Throwable cause = Throwables.getRootCause(error);
+ if (cause instanceof io.atomix.primitive.PrimitiveException.ConcurrentModification) {
+ newFuture.completeExceptionally(
+ new ConsistentMapException.ConcurrentModification(error.getMessage()));
+ } else if (cause instanceof io.atomix.primitive.PrimitiveException.Timeout) {
+ newFuture.completeExceptionally(new ConsistentMapException.Timeout(error.getMessage()));
+ } else if (cause instanceof io.atomix.primitive.PrimitiveException.Interrupted) {
+ newFuture.completeExceptionally(new ConsistentMapException.Interrupted());
+ } else if (cause instanceof io.atomix.primitive.PrimitiveException.Unavailable) {
+ newFuture.completeExceptionally(new ConsistentMapException.Unavailable());
+ } else if (cause instanceof io.atomix.primitive.PrimitiveException) {
+ newFuture.completeExceptionally(new ConsistentMapException(cause.getMessage()));
+ }
+ }
+ });
+ return newFuture;
+ }
+
+ private Versioned<V> toVersioned(io.atomix.utils.time.Versioned<V> versioned) {
+ return versioned != null
+ ? new Versioned<>(versioned.value(), versioned.version(), versioned.creationTime())
+ : null;
+ }
+
+ private Map.Entry<String, Versioned<V>> toVersioned(Map.Entry<String, io.atomix.utils.time.Versioned<V>> entry) {
+ return entry != null ? Maps.immutableEntry(entry.getKey(), toVersioned(entry.getValue())) : null;
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentTreeMapBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentTreeMapBuilder.java
new file mode 100644
index 0000000..14178fd
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixConsistentTreeMapBuilder.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.service.AsyncConsistentTreeMap;
+import org.onosproject.store.service.ConsistentTreeMap;
+import org.onosproject.store.service.ConsistentTreeMapBuilder;
+
+/**
+ * Default {@link org.onosproject.store.service.AsyncConsistentTreeMap} builder.
+ *
+ * @param <V> type for set value
+ */
+public class AtomixConsistentTreeMapBuilder<V> extends ConsistentTreeMapBuilder<V> {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixConsistentTreeMapBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public ConsistentTreeMap<V> build() {
+ return buildTreeMap().asTreeMap();
+ }
+
+ @Override
+ public AsyncConsistentTreeMap<V> buildTreeMap() {
+ return new AtomixConsistentTreeMap<>(atomix.<String, V>atomicNavigableMapBuilder(name())
+ .withRegistrationRequired()
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ .withCacheEnabled(relaxedReadConsistency())
+ .withSerializer(new AtomixSerializerAdapter(serializer()))
+ .build()
+ .async());
+ }
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedLock.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedLock.java
new file mode 100644
index 0000000..ef2f502
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedLock.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.time.Duration;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+import org.onosproject.store.service.AsyncDistributedLock;
+import org.onosproject.store.service.Version;
+
+/**
+ * Atomix distributed lock.
+ */
+public class AtomixDistributedLock implements AsyncDistributedLock {
+ private final io.atomix.core.lock.AsyncAtomicLock atomixLock;
+
+ public AtomixDistributedLock(io.atomix.core.lock.AsyncAtomicLock atomixLock) {
+ this.atomixLock = atomixLock;
+ }
+
+ @Override
+ public String name() {
+ return atomixLock.name();
+ }
+
+ @Override
+ public CompletableFuture<Version> lock() {
+ return atomixLock.lock().thenApply(this::toVersion);
+ }
+
+ @Override
+ public CompletableFuture<Optional<Version>> tryLock() {
+ return atomixLock.tryLock().thenApply(optional -> optional.map(this::toVersion));
+ }
+
+ @Override
+ public CompletableFuture<Optional<Version>> tryLock(Duration timeout) {
+ return atomixLock.tryLock(timeout).thenApply(optional -> optional.map(this::toVersion));
+ }
+
+ @Override
+ public CompletableFuture<Void> unlock() {
+ return atomixLock.unlock();
+ }
+
+ private Version toVersion(io.atomix.utils.time.Version version) {
+ return new Version(version.value());
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedLockBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedLockBuilder.java
new file mode 100644
index 0000000..e16a610
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedLockBuilder.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.service.AsyncDistributedLock;
+import org.onosproject.store.service.DistributedLockBuilder;
+
+/**
+ * Default {@link org.onosproject.store.service.AsyncDistributedLock} builder.
+ */
+public class AtomixDistributedLockBuilder extends DistributedLockBuilder {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixDistributedLockBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public AsyncDistributedLock build() {
+ return new AtomixDistributedLock(atomix.atomicLockBuilder(name())
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ .withSerializer(new AtomixSerializerAdapter(serializer()))
+ .build()
+ .async());
+ }
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedSet.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedSet.java
new file mode 100644
index 0000000..e1aadb3
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedSet.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+import com.google.common.collect.Maps;
+import org.onosproject.store.service.AsyncDistributedSet;
+import org.onosproject.store.service.SetEvent;
+import org.onosproject.store.service.SetEventListener;
+
+/**
+ * Atomix distributed set.
+ */
+public class AtomixDistributedSet<E> implements AsyncDistributedSet<E> {
+ private final io.atomix.core.set.AsyncDistributedSet<E> atomixSet;
+ private final Map<SetEventListener<E>, io.atomix.core.collection.CollectionEventListener<E>> listenerMap =
+ Maps.newIdentityHashMap();
+
+ public AtomixDistributedSet(io.atomix.core.set.AsyncDistributedSet<E> atomixSet) {
+ this.atomixSet = atomixSet;
+ }
+
+ @Override
+ public String name() {
+ return atomixSet.name();
+ }
+
+ @Override
+ public CompletableFuture<Integer> size() {
+ return atomixSet.size();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> add(E element) {
+ return atomixSet.add(element);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> remove(E element) {
+ return atomixSet.remove(element);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> isEmpty() {
+ return atomixSet.isEmpty();
+ }
+
+ @Override
+ public CompletableFuture<Void> clear() {
+ return atomixSet.clear();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> contains(E element) {
+ return atomixSet.contains(element);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> addAll(Collection<? extends E> c) {
+ return atomixSet.addAll(c);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> containsAll(Collection<? extends E> c) {
+ return atomixSet.containsAll(c);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> retainAll(Collection<? extends E> c) {
+ return atomixSet.retainAll(c);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> removeAll(Collection<? extends E> c) {
+ return atomixSet.removeAll(c);
+ }
+
+ @Override
+ public CompletableFuture<? extends Set<E>> getAsImmutableSet() {
+ return CompletableFuture.completedFuture(atomixSet.stream().collect(Collectors.toSet()));
+ }
+
+ @Override
+ public synchronized CompletableFuture<Void> addListener(SetEventListener<E> listener) {
+ io.atomix.core.collection.CollectionEventListener<E> atomixListener = event ->
+ listener.event(new SetEvent<E>(
+ name(),
+ SetEvent.Type.valueOf(event.type().name()),
+ event.element()));
+ listenerMap.put(listener, atomixListener);
+ return atomixSet.addListener(atomixListener);
+ }
+
+ @Override
+ public CompletableFuture<Void> removeListener(SetEventListener<E> listener) {
+ io.atomix.core.collection.CollectionEventListener<E> atomixListener = listenerMap.remove(listener);
+ if (atomixListener != null) {
+ return atomixSet.removeListener(atomixListener);
+ }
+ return CompletableFuture.completedFuture(null);
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedSetBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedSetBuilder.java
new file mode 100644
index 0000000..73c6f9d
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedSetBuilder.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.service.AsyncDistributedSet;
+import org.onosproject.store.service.DistributedSetBuilder;
+
+/**
+ * Default {@link org.onosproject.store.service.AsyncDistributedSet} builder.
+ *
+ * @param <E> type for set value
+ */
+public class AtomixDistributedSetBuilder<E> extends DistributedSetBuilder<E> {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixDistributedSetBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public AsyncDistributedSet<E> build() {
+ return new AtomixDistributedSet<E>(atomix.<E>setBuilder(name())
+ .withRegistrationRequired()
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ // TODO: Enable caching for DistributedSet in Atomix
+ .withSerializer(new AtomixSerializerAdapter(serializer()))
+ .build()
+ .async());
+ }
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedTopic.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedTopic.java
similarity index 78%
rename from core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedTopic.java
rename to core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedTopic.java
index 7581c37..01b7da8 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedTopic.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedTopic.java
@@ -20,30 +20,29 @@
import java.util.concurrent.Executor;
import java.util.function.Consumer;
-import org.onosproject.store.service.AsyncAtomicValue;
-import org.onosproject.store.service.AtomicValueEventListener;
+import com.google.common.collect.Maps;
+import io.atomix.core.value.AsyncAtomicValue;
+import io.atomix.core.value.AtomicValueEventListener;
import org.onosproject.store.service.DistributedPrimitive;
import org.onosproject.store.service.Topic;
-import com.google.common.collect.Maps;
-
/**
* Default implementation of {@link Topic}.
*
* @param <T> topic message type.
*/
-public class DefaultDistributedTopic<T> implements Topic<T> {
+public class AtomixDistributedTopic<T> implements Topic<T> {
- private final AsyncAtomicValue<T> atomicValue;
+ private final AsyncAtomicValue<T> atomixValue;
private final Map<Consumer<T>, AtomicValueEventListener<T>> callbacks = Maps.newIdentityHashMap();
- DefaultDistributedTopic(AsyncAtomicValue<T> atomicValue) {
- this.atomicValue = atomicValue;
+ AtomixDistributedTopic(AsyncAtomicValue<T> atomixValue) {
+ this.atomixValue = atomixValue;
}
@Override
public String name() {
- return atomicValue.name();
+ return atomixValue.name();
}
@Override
@@ -52,13 +51,8 @@
}
@Override
- public CompletableFuture<Void> destroy() {
- return atomicValue.destroy();
- }
-
- @Override
public CompletableFuture<Void> publish(T message) {
- return atomicValue.set(message);
+ return atomixValue.set(message);
}
@Override
@@ -66,7 +60,7 @@
AtomicValueEventListener<T> valueListener =
event -> executor.execute(() -> callback.accept(event.newValue()));
if (callbacks.putIfAbsent(callback, valueListener) == null) {
- return atomicValue.addListener(valueListener);
+ return atomixValue.addListener(valueListener);
}
return CompletableFuture.completedFuture(null);
}
@@ -75,8 +69,13 @@
public CompletableFuture<Void> unsubscribe(Consumer<T> callback) {
AtomicValueEventListener<T> valueListener = callbacks.remove(callback);
if (valueListener != null) {
- return atomicValue.removeListener(valueListener);
+ return atomixValue.removeListener(valueListener);
}
return CompletableFuture.completedFuture(null);
}
+
+ @Override
+ public CompletableFuture<Void> destroy() {
+ return atomixValue.close();
+ }
}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedTopicBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedTopicBuilder.java
new file mode 100644
index 0000000..34dda44
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDistributedTopicBuilder.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.service.Topic;
+import org.onosproject.store.service.TopicBuilder;
+
+/**
+ * Default topic builder.
+ */
+public class AtomixDistributedTopicBuilder<T> extends TopicBuilder<T> {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixDistributedTopicBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public Topic<T> build() {
+ return new AtomixDistributedTopic<>(atomix.<T>atomicValueBuilder(name())
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ .withSerializer(new AtomixSerializerAdapter(serializer()))
+ .build()
+ .async());
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDocumentTree.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDocumentTree.java
new file mode 100644
index 0000000..4bbc822
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDocumentTree.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+import com.google.common.collect.Maps;
+import org.onosproject.store.primitives.NodeUpdate;
+import org.onosproject.store.primitives.TransactionId;
+import org.onosproject.store.service.AsyncDocumentTree;
+import org.onosproject.store.service.DocumentPath;
+import org.onosproject.store.service.DocumentTreeEvent;
+import org.onosproject.store.service.DocumentTreeListener;
+import org.onosproject.store.service.TransactionLog;
+import org.onosproject.store.service.Version;
+import org.onosproject.store.service.Versioned;
+
+/**
+ * Atomix document tree.
+ */
+public class AtomixDocumentTree<V> implements AsyncDocumentTree<V> {
+ private final io.atomix.core.tree.AsyncAtomicDocumentTree<V> atomixTree;
+ private final Map<DocumentTreeListener<V>, io.atomix.core.tree.DocumentTreeEventListener<V>> listenerMap =
+ Maps.newIdentityHashMap();
+
+ public AtomixDocumentTree(io.atomix.core.tree.AsyncAtomicDocumentTree<V> atomixTree) {
+ this.atomixTree = atomixTree;
+ }
+
+ @Override
+ public String name() {
+ return atomixTree.name();
+ }
+
+ @Override
+ public DocumentPath root() {
+ return toOnosPath(atomixTree.root());
+ }
+
+ @Override
+ public CompletableFuture<Map<String, Versioned<V>>> getChildren(DocumentPath path) {
+ return atomixTree.getChildren(toAtomixPath(path))
+ .thenApply(map -> map.entrySet().stream()
+ .collect(Collectors.toMap(e -> e.getKey(),
+ e -> toVersioned(e.getValue()))));
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> get(DocumentPath path) {
+ return atomixTree.get(toAtomixPath(path)).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> set(DocumentPath path, V value) {
+ return atomixTree.set(toAtomixPath(path), value).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> create(DocumentPath path, V value) {
+ return atomixTree.create(toAtomixPath(path), value);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> createRecursive(DocumentPath path, V value) {
+ return atomixTree.createRecursive(toAtomixPath(path), value);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> replace(DocumentPath path, V newValue, long version) {
+ return atomixTree.replace(toAtomixPath(path), newValue, version);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> replace(DocumentPath path, V newValue, V currentValue) {
+ return atomixTree.replace(toAtomixPath(path), newValue, currentValue);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<V>> removeNode(DocumentPath path) {
+ return atomixTree.removeNode(toAtomixPath(path)).thenApply(this::toVersioned);
+ }
+
+ @Override
+ public synchronized CompletableFuture<Void> addListener(DocumentPath path, DocumentTreeListener<V> listener) {
+ io.atomix.core.tree.DocumentTreeEventListener<V> atomixListener = event ->
+ listener.event(new DocumentTreeEvent<V>(
+ DocumentPath.from(event.path().pathElements()),
+ DocumentTreeEvent.Type.valueOf(event.type().name()),
+ event.newValue().map(this::toVersioned),
+ event.oldValue().map(this::toVersioned)));
+ listenerMap.put(listener, atomixListener);
+ return atomixTree.addListener(toAtomixPath(path), atomixListener);
+ }
+
+ @Override
+ public CompletableFuture<Void> removeListener(DocumentTreeListener<V> listener) {
+ io.atomix.core.tree.DocumentTreeEventListener<V> atomixListener = listenerMap.remove(listener);
+ if (atomixListener != null) {
+ return atomixTree.removeListener(atomixListener);
+ }
+ return CompletableFuture.completedFuture(null);
+ }
+
+ @Override
+ public CompletableFuture<Version> begin(TransactionId transactionId) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> prepare(TransactionLog<NodeUpdate<V>> transactionLog) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<NodeUpdate<V>> transactionLog) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Void> commit(TransactionId transactionId) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public CompletableFuture<Void> rollback(TransactionId transactionId) {
+ throw new UnsupportedOperationException();
+ }
+
+ private DocumentPath toOnosPath(io.atomix.core.tree.DocumentPath path) {
+ return DocumentPath.from(path.pathElements());
+ }
+
+ private io.atomix.core.tree.DocumentPath toAtomixPath(DocumentPath path) {
+ return io.atomix.core.tree.DocumentPath.from(path.pathElements());
+ }
+
+ private Versioned<V> toVersioned(io.atomix.utils.time.Versioned<V> versioned) {
+ return versioned != null
+ ? new Versioned<>(versioned.value(), versioned.version(), versioned.creationTime())
+ : null;
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDocumentTreeBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDocumentTreeBuilder.java
new file mode 100644
index 0000000..91dea85
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixDocumentTreeBuilder.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.service.AsyncDocumentTree;
+import org.onosproject.store.service.DocumentTreeBuilder;
+
+/**
+ * Default {@link org.onosproject.store.service.AsyncDocumentTree} builder.
+ *
+ * @param <V> type for tree value
+ */
+public class AtomixDocumentTreeBuilder<V> extends DocumentTreeBuilder<V> {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixDocumentTreeBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public AsyncDocumentTree<V> build() {
+ return buildDocumentTree();
+ }
+
+ @Override
+ public AsyncDocumentTree<V> buildDocumentTree() {
+ return new AtomixDocumentTree<>(atomix.<V>atomicDocumentTreeBuilder(name())
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ // TODO: Enable caching for DocumentTree in Atomix
+ .withSerializer(new AtomixSerializerAdapter(serializer()))
+ .build()
+ .async());
+ }
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixIterator.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixIterator.java
new file mode 100644
index 0000000..c3288d3
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixIterator.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.concurrent.CompletableFuture;
+
+import org.onosproject.store.service.AsyncIterator;
+
+/**
+ * Atomix asynchronous iterator.
+ */
+public class AtomixIterator<T> implements AsyncIterator<T> {
+ private final io.atomix.core.iterator.AsyncIterator<T> atomixIterator;
+
+ public AtomixIterator(io.atomix.core.iterator.AsyncIterator<T> atomixIterator) {
+ this.atomixIterator = atomixIterator;
+ }
+
+ @Override
+ public CompletableFuture<Boolean> hasNext() {
+ return atomixIterator.hasNext();
+ }
+
+ @Override
+ public CompletableFuture<T> next() {
+ return atomixIterator.next();
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixLeaderElector.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixLeaderElector.java
new file mode 100644
index 0000000..1098981
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixLeaderElector.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+import com.google.common.collect.Maps;
+import io.atomix.core.election.LeadershipEventListener;
+import org.onosproject.cluster.Leader;
+import org.onosproject.cluster.Leadership;
+import org.onosproject.cluster.NodeId;
+import org.onosproject.event.Change;
+import org.onosproject.store.service.AsyncLeaderElector;
+
+/**
+ * Atomix leader elector.
+ */
+public class AtomixLeaderElector implements AsyncLeaderElector {
+ private final io.atomix.core.election.AsyncLeaderElector<NodeId> atomixElector;
+ private final NodeId localNodeId;
+ private final Map<Consumer<Change<Leadership>>, LeadershipEventListener<NodeId>> listenerMap =
+ Maps.newIdentityHashMap();
+
+ public AtomixLeaderElector(io.atomix.core.election.AsyncLeaderElector<NodeId> atomixElector, NodeId localNodeId) {
+ this.atomixElector = atomixElector;
+ this.localNodeId = localNodeId;
+ }
+
+ @Override
+ public String name() {
+ return atomixElector.name();
+ }
+
+ @Override
+ public CompletableFuture<Leadership> run(String topic, NodeId nodeId) {
+ return atomixElector.run(topic, nodeId).thenApply(leadership -> toLeadership(topic, leadership));
+ }
+
+ @Override
+ public CompletableFuture<Void> withdraw(String topic) {
+ return atomixElector.withdraw(topic, localNodeId);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> anoint(String topic, NodeId nodeId) {
+ return atomixElector.anoint(topic, nodeId);
+ }
+
+ @Override
+ public CompletableFuture<Void> evict(NodeId nodeId) {
+ return atomixElector.evict(nodeId);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> promote(String topic, NodeId nodeId) {
+ return atomixElector.promote(topic, nodeId);
+ }
+
+ @Override
+ public CompletableFuture<Leadership> getLeadership(String topic) {
+ return atomixElector.getLeadership(topic).thenApply(leadership -> toLeadership(topic, leadership));
+ }
+
+ @Override
+ public CompletableFuture<Map<String, Leadership>> getLeaderships() {
+ return atomixElector.getLeaderships()
+ .thenApply(leaderships -> leaderships.entrySet().stream()
+ .collect(Collectors.toMap(e -> e.getKey(), e -> toLeadership(e.getKey(), e.getValue()))));
+ }
+
+ @Override
+ public CompletableFuture<Void> addChangeListener(Consumer<Change<Leadership>> consumer) {
+ LeadershipEventListener<NodeId> atomixListener = event ->
+ consumer.accept(new Change<>(
+ toLeadership(event.topic(), event.oldLeadership()),
+ toLeadership(event.topic(), event.newLeadership())));
+ listenerMap.put(consumer, atomixListener);
+ return atomixElector.addListener(atomixListener);
+ }
+
+ @Override
+ public CompletableFuture<Void> removeChangeListener(Consumer<Change<Leadership>> consumer) {
+ LeadershipEventListener<NodeId> atomixListener = listenerMap.remove(consumer);
+ if (atomixListener != null) {
+ return atomixElector.removeListener(atomixListener);
+ }
+ return CompletableFuture.completedFuture(null);
+ }
+
+ private Leadership toLeadership(String topic, io.atomix.core.election.Leadership<NodeId> leadership) {
+ return leadership != null
+ ? new Leadership(topic, toLeader(leadership.leader()), leadership.candidates())
+ : null;
+ }
+
+ private Leader toLeader(io.atomix.core.election.Leader<NodeId> leader) {
+ return leader != null ? new Leader(leader.id(), leader.term(), leader.timestamp()) : null;
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixLeaderElectorBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixLeaderElectorBuilder.java
new file mode 100644
index 0000000..feb8127
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixLeaderElectorBuilder.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.cluster.NodeId;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.AsyncLeaderElector;
+import org.onosproject.store.service.LeaderElectorBuilder;
+import org.onosproject.store.service.Serializer;
+
+/**
+ * Default {@link org.onosproject.store.service.AsyncLeaderElector} builder.
+ */
+public class AtomixLeaderElectorBuilder extends LeaderElectorBuilder {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+ private final NodeId localNodeId;
+
+ public AtomixLeaderElectorBuilder(Atomix atomix, String group, NodeId localNodeId) {
+ this.atomix = atomix;
+ this.group = group;
+ this.localNodeId = localNodeId;
+ }
+
+ @Override
+ public AsyncLeaderElector build() {
+ Serializer serializer = Serializer.using(KryoNamespaces.API);
+ return new AtomixLeaderElector(atomix.<NodeId>leaderElectorBuilder(name())
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ // TODO: Enable caching for LeaderElector in Atomix
+ .withSerializer(new AtomixSerializerAdapter(serializer))
+ .build()
+ .async(), localNodeId);
+ }
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixSerializerAdapter.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixSerializerAdapter.java
similarity index 80%
rename from core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixSerializerAdapter.java
rename to core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixSerializerAdapter.java
index abb1580..46ca0b8 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixSerializerAdapter.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixSerializerAdapter.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2017-present Open Networking Foundation
+ * Copyright 2018-present Open Networking Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -13,14 +13,14 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.store.primitives.resources.impl;
+package org.onosproject.store.primitives.impl;
import org.onosproject.store.service.Serializer;
/**
- * ONOS to Atomix serializer adapter.
+ * Atomix serializer.
*/
-public class AtomixSerializerAdapter implements io.atomix.serializer.Serializer {
+public class AtomixSerializerAdapter implements io.atomix.utils.serializer.Serializer {
private final Serializer serializer;
public AtomixSerializerAdapter(Serializer serializer) {
@@ -36,4 +36,4 @@
public <T> T decode(byte[] bytes) {
return serializer.decode(bytes);
}
-}
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixTransactionContext.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixTransactionContext.java
new file mode 100644
index 0000000..9260591
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixTransactionContext.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import io.atomix.core.transaction.AsyncTransaction;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.primitives.TransactionId;
+import org.onosproject.store.service.CommitStatus;
+import org.onosproject.store.service.DistributedPrimitive;
+import org.onosproject.store.service.Serializer;
+import org.onosproject.store.service.StorageException;
+import org.onosproject.store.service.TransactionContext;
+import org.onosproject.store.service.TransactionalMap;
+
+/**
+ * Atomix transaction context.
+ */
+public class AtomixTransactionContext implements TransactionContext {
+ private static final int MAX_RETRIES = 5;
+
+ private final AsyncTransaction atomixTransaction;
+ private final String group;
+
+ public AtomixTransactionContext(AsyncTransaction atomixTransaction, String group) {
+ this.atomixTransaction = atomixTransaction;
+ this.group = group;
+ }
+
+ @Override
+ public String name() {
+ return atomixTransaction.name();
+ }
+
+ @Override
+ public TransactionId transactionId() {
+ return TransactionId.from(atomixTransaction.transactionId().id());
+ }
+
+ @Override
+ public boolean isOpen() {
+ return atomixTransaction.isOpen();
+ }
+
+ @Override
+ public void begin() {
+ try {
+ atomixTransaction.begin().get(DistributedPrimitive.DEFAULT_OPERATION_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException e) {
+ throw new StorageException.Interrupted();
+ } catch (TimeoutException e) {
+ throw new StorageException.Timeout();
+ } catch (ExecutionException e) {
+ throw new StorageException.Unavailable();
+ }
+ }
+
+ @Override
+ public CompletableFuture<CommitStatus> commit() {
+ return atomixTransaction.commit().thenApply(status -> CommitStatus.valueOf(status.name()));
+ }
+
+ @Override
+ public void abort() {
+ try {
+ atomixTransaction.abort().get(DistributedPrimitive.DEFAULT_OPERATION_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException e) {
+ throw new StorageException.Interrupted();
+ } catch (TimeoutException e) {
+ throw new StorageException.Timeout();
+ } catch (ExecutionException e) {
+ throw new StorageException.Unavailable();
+ }
+ }
+
+ @Override
+ public <K, V> TransactionalMap<K, V> getTransactionalMap(String mapName, Serializer serializer) {
+ return new AtomixTransactionalMap<>(atomixTransaction.<K, V>mapBuilder(mapName)
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withSerializer(new AtomixSerializerAdapter(serializer))
+ .build());
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixTransactionContextBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixTransactionContextBuilder.java
new file mode 100644
index 0000000..70ef628
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixTransactionContextBuilder.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.core.transaction.Isolation;
+import org.onosproject.store.service.TransactionContext;
+import org.onosproject.store.service.TransactionContextBuilder;
+
+/**
+ * Atomix transaction context builder.
+ */
+public class AtomixTransactionContextBuilder extends TransactionContextBuilder {
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixTransactionContextBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public TransactionContext build() {
+ return new AtomixTransactionContext(atomix.transactionBuilder()
+ .withIsolation(Isolation.REPEATABLE_READS)
+ .build()
+ .async(), group);
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixTransactionalMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixTransactionalMap.java
new file mode 100644
index 0000000..8577a84
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixTransactionalMap.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import org.onosproject.store.service.TransactionalMap;
+
+/**
+ * Atomix transactional map.
+ */
+public class AtomixTransactionalMap<K, V> implements TransactionalMap<K, V> {
+ private final io.atomix.core.transaction.TransactionalMap<K, V> atomixMap;
+
+ public AtomixTransactionalMap(io.atomix.core.transaction.TransactionalMap<K, V> atomixMap) {
+ this.atomixMap = atomixMap;
+ }
+
+ @Override
+ public V get(K key) {
+ return atomixMap.get(key);
+ }
+
+ @Override
+ public boolean containsKey(K key) {
+ return atomixMap.containsKey(key);
+ }
+
+ @Override
+ public V put(K key, V value) {
+ return atomixMap.put(key, value);
+ }
+
+ @Override
+ public V remove(K key) {
+ return atomixMap.remove(key);
+ }
+
+ @Override
+ public V putIfAbsent(K key, V value) {
+ return atomixMap.putIfAbsent(key, value);
+ }
+
+ @Override
+ public boolean remove(K key, V value) {
+ return atomixMap.remove(key, value);
+ }
+
+ @Override
+ public boolean replace(K key, V oldValue, V newValue) {
+ return atomixMap.replace(key, oldValue, newValue);
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixWorkQueue.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixWorkQueue.java
new file mode 100644
index 0000000..d3b9907
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixWorkQueue.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import java.util.Collection;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+import org.onosproject.store.service.Task;
+import org.onosproject.store.service.WorkQueue;
+import org.onosproject.store.service.WorkQueueStats;
+
+/**
+ * Atomix work queue.
+ */
+public class AtomixWorkQueue<E> implements WorkQueue<E> {
+ private final io.atomix.core.workqueue.AsyncWorkQueue<E> atomixWorkQueue;
+
+ public AtomixWorkQueue(io.atomix.core.workqueue.AsyncWorkQueue<E> atomixWorkQueue) {
+ this.atomixWorkQueue = atomixWorkQueue;
+ }
+
+ @Override
+ public String name() {
+ return atomixWorkQueue.name();
+ }
+
+ @Override
+ public CompletableFuture<Void> addMultiple(Collection<E> items) {
+ return atomixWorkQueue.addMultiple(items);
+ }
+
+ @Override
+ public CompletableFuture<Collection<Task<E>>> take(int maxItems) {
+ return atomixWorkQueue.take(maxItems)
+ .thenApply(tasks -> tasks.stream()
+ .map(task -> new Task<>(task.taskId(), task.payload()))
+ .collect(Collectors.toList()));
+ }
+
+ @Override
+ public CompletableFuture<Void> complete(Collection<String> taskIds) {
+ return atomixWorkQueue.complete(taskIds);
+ }
+
+ @Override
+ public CompletableFuture<Void> registerTaskProcessor(
+ Consumer<E> taskProcessor, int parallelism, Executor executor) {
+ return atomixWorkQueue.registerTaskProcessor(taskProcessor, parallelism, executor);
+ }
+
+ @Override
+ public CompletableFuture<Void> stopProcessing() {
+ return atomixWorkQueue.stopProcessing();
+ }
+
+ @Override
+ public CompletableFuture<WorkQueueStats> stats() {
+ return atomixWorkQueue.stats()
+ .thenApply(stats -> WorkQueueStats.builder()
+ .withTotalCompleted(stats.totalCompleted())
+ .withTotalInProgress(stats.totalInProgress())
+ .withTotalPending(stats.totalPending())
+ .build());
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixWorkQueueBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixWorkQueueBuilder.java
new file mode 100644
index 0000000..9c65106
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/AtomixWorkQueueBuilder.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed 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.onosproject.store.primitives.impl;
+
+import io.atomix.core.Atomix;
+import io.atomix.primitive.Recovery;
+import io.atomix.protocols.raft.MultiRaftProtocol;
+import org.onosproject.store.service.WorkQueue;
+import org.onosproject.store.service.WorkQueueBuilder;
+
+/**
+ * Default {@link org.onosproject.store.service.WorkQueue} builder.
+ *
+ * @param <E> type for set value
+ */
+public class AtomixWorkQueueBuilder<E> extends WorkQueueBuilder<E> {
+ private static final int MAX_RETRIES = 5;
+ private final Atomix atomix;
+ private final String group;
+
+ public AtomixWorkQueueBuilder(Atomix atomix, String group) {
+ this.atomix = atomix;
+ this.group = group;
+ }
+
+ @Override
+ public WorkQueue<E> build() {
+ return new AtomixWorkQueue<>(atomix.<E>workQueueBuilder(name())
+ .withProtocol(MultiRaftProtocol.builder(group)
+ .withRecoveryStrategy(Recovery.RECOVER)
+ .withMaxRetries(MAX_RETRIES)
+ .build())
+ .withReadOnly(readOnly())
+ .withSerializer(new AtomixSerializerAdapter(serializer()))
+ .build()
+ .async());
+ }
+}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CachingAsyncConsistentMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CachingAsyncConsistentMap.java
deleted file mode 100644
index a25fb79..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CachingAsyncConsistentMap.java
+++ /dev/null
@@ -1,245 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import static org.slf4j.LoggerFactory.getLogger;
-
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.Executor;
-import java.util.function.BiFunction;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-
-import com.google.common.util.concurrent.MoreExecutors;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.MapEventListener;
-import org.onosproject.store.service.Versioned;
-import org.slf4j.Logger;
-
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
-
-import static org.onosproject.store.service.DistributedPrimitive.Status.INACTIVE;
-import static org.onosproject.store.service.DistributedPrimitive.Status.SUSPENDED;
-
-/**
- * {@code AsyncConsistentMap} that caches entries on read.
- * <p>
- * The cache entries are automatically invalidated when updates are detected either locally or
- * remotely.
- * <p> This implementation only attempts to serve cached entries for {@link AsyncConsistentMap#get get}
- * {@link AsyncConsistentMap#getOrDefault(Object, Object) getOrDefault}, and
- * {@link AsyncConsistentMap#containsKey(Object) containsKey} calls. All other calls skip the cache
- * and directly go the backing map.
- *
- * @param <K> key type
- * @param <V> value type
- */
-public class CachingAsyncConsistentMap<K, V> extends DelegatingAsyncConsistentMap<K, V> {
- private static final int DEFAULT_CACHE_SIZE = 10000;
- private final Logger log = getLogger(getClass());
-
- private final Map<MapEventListener<K, V>, Executor> mapEventListeners = new ConcurrentHashMap<>();
- private final LoadingCache<K, CompletableFuture<Versioned<V>>> cache;
- private final AsyncConsistentMap<K, V> backingMap;
- private final MapEventListener<K, V> cacheUpdater;
- private final Consumer<Status> statusListener;
-
- /**
- * Default constructor.
- *
- * @param backingMap a distributed, strongly consistent map for backing
- */
- public CachingAsyncConsistentMap(AsyncConsistentMap<K, V> backingMap) {
- this(backingMap, DEFAULT_CACHE_SIZE);
- }
-
- /**
- * Constructor to configure cache size.
- *
- * @param backingMap a distributed, strongly consistent map for backing
- * @param cacheSize the maximum size of the cache
- */
- public CachingAsyncConsistentMap(AsyncConsistentMap<K, V> backingMap, int cacheSize) {
- super(backingMap);
- this.backingMap = backingMap;
- cache = CacheBuilder.newBuilder()
- .maximumSize(cacheSize)
- .build(CacheLoader.from(CachingAsyncConsistentMap.super::get));
- cacheUpdater = event -> {
- Versioned<V> newValue = event.newValue();
- if (newValue == null) {
- cache.invalidate(event.key());
- } else {
- cache.put(event.key(), CompletableFuture.completedFuture(newValue));
- }
- mapEventListeners.forEach((listener, executor) -> executor.execute(() -> listener.event(event)));
- };
- statusListener = status -> {
- log.debug("{} status changed to {}", this.name(), status);
- // If the status of the underlying map is SUSPENDED or INACTIVE
- // we can no longer guarantee that the cache will be in sync.
- if (status == SUSPENDED || status == INACTIVE) {
- cache.invalidateAll();
- }
- };
- super.addListener(cacheUpdater, MoreExecutors.directExecutor());
- super.addStatusChangeListener(statusListener);
- }
-
- @Override
- public CompletableFuture<Void> destroy() {
- super.removeStatusChangeListener(statusListener);
- return super.destroy().thenCompose(v -> removeListener(cacheUpdater));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> get(K key) {
- return cache.getUnchecked(key)
- .whenComplete((r, e) -> {
- if (e != null) {
- cache.invalidate(key);
- }
- });
- }
-
- @Override
- public CompletableFuture<Versioned<V>> getOrDefault(K key, V defaultValue) {
- return cache.getUnchecked(key).thenCompose(r -> {
- if (r == null) {
- CompletableFuture<Versioned<V>> versioned = backingMap.getOrDefault(key, defaultValue);
- cache.put(key, versioned);
- return versioned;
- } else {
- return CompletableFuture.completedFuture(r);
- }
- }).whenComplete((r, e) -> {
- if (e != null) {
- cache.invalidate(key);
- }
- });
- }
-
- @Override
- public CompletableFuture<Versioned<V>> computeIf(K key,
- Predicate<? super V> condition,
- BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
- return super.computeIf(key, condition, remappingFunction)
- .whenComplete((r, e) -> cache.invalidate(key));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> put(K key, V value) {
- return super.put(key, value)
- .whenComplete((r, e) -> cache.invalidate(key));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putAndGet(K key, V value) {
- return super.putAndGet(key, value)
- .whenComplete((r, e) -> cache.invalidate(key));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putIfAbsent(K key, V value) {
- return super.putIfAbsent(key, value)
- .whenComplete((r, e) -> cache.invalidate(key));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> remove(K key) {
- return super.remove(key)
- .whenComplete((r, e) -> cache.invalidate(key));
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(K key) {
- return cache.getUnchecked(key).thenApply(Objects::nonNull)
- .whenComplete((r, e) -> {
- if (e != null) {
- cache.invalidate(key);
- }
- });
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return super.clear()
- .whenComplete((r, e) -> cache.invalidateAll());
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, V value) {
- return super.remove(key, value)
- .whenComplete((r, e) -> {
- if (r) {
- cache.invalidate(key);
- }
- });
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, long version) {
- return super.remove(key, version)
- .whenComplete((r, e) -> {
- if (r) {
- cache.invalidate(key);
- }
- });
- }
-
- @Override
- public CompletableFuture<Versioned<V>> replace(K key, V value) {
- return super.replace(key, value)
- .whenComplete((r, e) -> cache.invalidate(key));
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K key, V oldValue, V newValue) {
- return super.replace(key, oldValue, newValue)
- .whenComplete((r, e) -> {
- if (r) {
- cache.invalidate(key);
- }
- });
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K key, long oldVersion, V newValue) {
- return super.replace(key, oldVersion, newValue)
- .whenComplete((r, e) -> {
- if (r) {
- cache.invalidate(key);
- }
- });
- }
-
- @Override
- public CompletableFuture<Void> addListener(MapEventListener<K, V> listener, Executor executor) {
- mapEventListeners.put(listener, executor);
- return CompletableFuture.completedFuture(null);
- }
-
- @Override
- public CompletableFuture<Void> removeListener(MapEventListener<K, V> listener) {
- mapEventListeners.remove(listener);
- return CompletableFuture.completedFuture(null);
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CachingAsyncConsistentMultimap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CachingAsyncConsistentMultimap.java
deleted file mode 100644
index 3d49f7f..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CachingAsyncConsistentMultimap.java
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.Executor;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
-
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.util.concurrent.MoreExecutors;
-import org.onosproject.store.service.AsyncConsistentMultimap;
-import org.onosproject.store.service.MultimapEventListener;
-import org.onosproject.store.service.Versioned;
-import org.slf4j.Logger;
-
-import static org.onosproject.store.service.DistributedPrimitive.Status.INACTIVE;
-import static org.onosproject.store.service.DistributedPrimitive.Status.SUSPENDED;
-import static org.slf4j.LoggerFactory.getLogger;
-
-/**
- * Caching {@link AsyncConsistentMultimap} implementation.
- */
-public class CachingAsyncConsistentMultimap<K, V> extends DelegatingAsyncConsistentMultimap<K, V> {
- private static final int DEFAULT_CACHE_SIZE = 10000;
- private final Logger log = getLogger(getClass());
-
- private final Map<MultimapEventListener<K, V>, Executor> mapEventListeners = new ConcurrentHashMap<>();
- private final LoadingCache<K, CompletableFuture<Versioned<Collection<? extends V>>>> cache;
- private final MultimapEventListener<K, V> cacheUpdater;
- private final Consumer<Status> statusListener;
-
- /**
- * Default constructor.
- *
- * @param backingMap a distributed, strongly consistent map for backing
- */
- public CachingAsyncConsistentMultimap(AsyncConsistentMultimap<K, V> backingMap) {
- this(backingMap, DEFAULT_CACHE_SIZE);
- }
-
- /**
- * Constructor to configure cache size.
- *
- * @param backingMap a distributed, strongly consistent map for backing
- * @param cacheSize the maximum size of the cache
- */
- public CachingAsyncConsistentMultimap(AsyncConsistentMultimap<K, V> backingMap, int cacheSize) {
- super(backingMap);
- cache = CacheBuilder.newBuilder()
- .maximumSize(cacheSize)
- .build(CacheLoader.from(CachingAsyncConsistentMultimap.super::get));
- cacheUpdater = event -> {
- V oldValue = event.oldValue();
- V newValue = event.newValue();
- CompletableFuture<Versioned<Collection<? extends V>>> future = cache.getUnchecked(event.key());
- switch (event.type()) {
- case INSERT:
- if (future.isDone()) {
- Versioned<Collection<? extends V>> oldVersioned = future.join();
- Versioned<Collection<? extends V>> newVersioned = new Versioned<>(
- ImmutableSet.<V>builder().addAll(oldVersioned.value()).add(newValue).build(),
- oldVersioned.version(),
- oldVersioned.creationTime());
- cache.put(event.key(), CompletableFuture.completedFuture(newVersioned));
- } else {
- cache.put(event.key(), future.thenApply(versioned -> new Versioned<>(
- ImmutableSet.<V>builder().addAll(versioned.value()).add(newValue).build(),
- versioned.version(),
- versioned.creationTime())));
- }
- break;
- case REMOVE:
- if (future.isDone()) {
- Versioned<Collection<? extends V>> oldVersioned = future.join();
- cache.put(event.key(), CompletableFuture.completedFuture(new Versioned<>(oldVersioned.value()
- .stream()
- .filter(value -> !Objects.equals(value, oldValue))
- .collect(Collectors.toSet()), oldVersioned.version(), oldVersioned.creationTime())));
- } else {
- cache.put(event.key(), future.thenApply(versioned -> new Versioned<>(versioned.value()
- .stream()
- .filter(value -> !Objects.equals(value, oldValue))
- .collect(Collectors.toSet()), versioned.version(), versioned.creationTime())));
- }
- break;
- default:
- break;
- }
- mapEventListeners.forEach((listener, executor) -> executor.execute(() -> listener.event(event)));
- };
- statusListener = status -> {
- log.debug("{} status changed to {}", this.name(), status);
- // If the status of the underlying map is SUSPENDED or INACTIVE
- // we can no longer guarantee that the cache will be in sync.
- if (status == SUSPENDED || status == INACTIVE) {
- cache.invalidateAll();
- }
- };
- super.addListener(cacheUpdater, MoreExecutors.directExecutor());
- super.addStatusChangeListener(statusListener);
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(K key) {
- return get(key).thenApply(value -> value != null && !value.value().isEmpty());
- }
-
- @Override
- public CompletableFuture<Boolean> put(K key, V value) {
- return super.put(key, value)
- .whenComplete((r, e) -> cache.invalidate(key));
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, V value) {
- return super.remove(key, value)
- .whenComplete((r, e) -> cache.invalidate(key));
- }
-
- @Override
- public CompletableFuture<Boolean> removeAll(K key, Collection<? extends V> values) {
- return super.removeAll(key, values)
- .whenComplete((r, e) -> cache.invalidate(key));
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>> removeAll(K key) {
- return super.removeAll(key)
- .whenComplete((r, e) -> cache.invalidate(key));
- }
-
- @Override
- public CompletableFuture<Boolean> putAll(K key, Collection<? extends V> values) {
- return super.putAll(key, values)
- .whenComplete((r, e) -> cache.invalidate(key));
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>> replaceValues(K key, Collection<V> values) {
- return super.replaceValues(key, values)
- .whenComplete((r, e) -> cache.invalidate(key));
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return super.clear()
- .whenComplete((r, e) -> cache.invalidateAll());
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>> get(K key) {
- return cache.getUnchecked(key)
- .whenComplete((r, e) -> {
- if (e != null) {
- cache.invalidate(key);
- }
- });
- }
-
- @Override
- public CompletableFuture<Void> addListener(MultimapEventListener<K, V> listener, Executor executor) {
- mapEventListeners.put(listener, executor);
- return CompletableFuture.completedFuture(null);
- }
-
- @Override
- public CompletableFuture<Void> removeListener(MultimapEventListener<K, V> listener) {
- mapEventListeners.remove(listener);
- return CompletableFuture.completedFuture(null);
- }
-
- @Override
- public CompletableFuture<Void> destroy() {
- super.removeStatusChangeListener(statusListener);
- return super.destroy().thenCompose(v -> removeListener(cacheUpdater));
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CachingAsyncDocumentTree.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CachingAsyncDocumentTree.java
deleted file mode 100644
index eece91e..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CachingAsyncDocumentTree.java
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Map;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
-
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
-import com.google.common.collect.Maps;
-import org.onosproject.store.service.AsyncDocumentTree;
-import org.onosproject.store.service.DocumentPath;
-import org.onosproject.store.service.DocumentTreeEvent;
-import org.onosproject.store.service.DocumentTreeListener;
-import org.onosproject.store.service.Versioned;
-import org.slf4j.Logger;
-
-import static org.onosproject.store.service.DistributedPrimitive.Status.INACTIVE;
-import static org.onosproject.store.service.DistributedPrimitive.Status.SUSPENDED;
-import static org.slf4j.LoggerFactory.getLogger;
-
-/**
- * Caching asynchronous document tree.
- */
-public class CachingAsyncDocumentTree<V> extends DelegatingAsyncDocumentTree<V> implements AsyncDocumentTree<V> {
- private static final int DEFAULT_CACHE_SIZE = 10000;
- private final Logger log = getLogger(getClass());
-
- private final Map<DocumentTreeListener<V>, DocumentTreeListener<V>> eventListeners = Maps.newConcurrentMap();
- private final LoadingCache<DocumentPath, CompletableFuture<Versioned<V>>> cache;
- private final DocumentTreeListener<V> cacheUpdater;
- private final Consumer<Status> statusListener;
-
- /**
- * Default constructor.
- *
- * @param backingTree a distributed, strongly consistent map for backing
- */
- public CachingAsyncDocumentTree(AsyncDocumentTree<V> backingTree) {
- this(backingTree, DEFAULT_CACHE_SIZE);
- }
-
- /**
- * Constructor to configure cache size.
- *
- * @param backingTree a distributed, strongly consistent map for backing
- * @param cacheSize the maximum size of the cache
- */
- public CachingAsyncDocumentTree(AsyncDocumentTree<V> backingTree, int cacheSize) {
- super(backingTree);
- cache = CacheBuilder.newBuilder()
- .maximumSize(cacheSize)
- .build(CacheLoader.from(CachingAsyncDocumentTree.super::get));
- cacheUpdater = event -> {
- if (!event.newValue().isPresent()) {
- cache.invalidate(event.path());
- } else {
- cache.put(event.path(), CompletableFuture.completedFuture(event.newValue().get()));
- }
- eventListeners.values().forEach(listener -> listener.event(event));
- };
- statusListener = status -> {
- log.debug("{} status changed to {}", this.name(), status);
- // If the status of the underlying map is SUSPENDED or INACTIVE
- // we can no longer guarantee that the cache will be in sync.
- if (status == SUSPENDED || status == INACTIVE) {
- cache.invalidateAll();
- }
- };
- super.addListener(root(), cacheUpdater);
- super.addStatusChangeListener(statusListener);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> get(DocumentPath path) {
- return cache.getUnchecked(path);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> set(DocumentPath path, V value) {
- return super.set(path, value)
- .whenComplete((r, e) -> cache.invalidate(path));
- }
-
- @Override
- public CompletableFuture<Boolean> create(DocumentPath path, V value) {
- return super.create(path, value)
- .whenComplete((r, e) -> cache.invalidate(path));
- }
-
- @Override
- public CompletableFuture<Boolean> createRecursive(DocumentPath path, V value) {
- return super.createRecursive(path, value)
- .whenComplete((r, e) -> cache.invalidate(path));
- }
-
- @Override
- public CompletableFuture<Boolean> replace(DocumentPath path, V newValue, long version) {
- return super.replace(path, newValue, version)
- .whenComplete((r, e) -> {
- if (r) {
- cache.invalidate(path);
- }
- });
- }
-
- @Override
- public CompletableFuture<Boolean> replace(DocumentPath path, V newValue, V currentValue) {
- return super.replace(path, newValue, currentValue)
- .whenComplete((r, e) -> {
- if (r) {
- cache.invalidate(path);
- }
- });
- }
-
- @Override
- public CompletableFuture<Versioned<V>> removeNode(DocumentPath path) {
- return super.removeNode(path)
- .whenComplete((r, e) -> cache.invalidate(path));
- }
-
- @Override
- public CompletableFuture<Void> addListener(DocumentPath path, DocumentTreeListener<V> listener) {
- eventListeners.put(listener, new InternalListener(path, listener));
- return CompletableFuture.completedFuture(null);
- }
-
- @Override
- public CompletableFuture<Void> removeListener(DocumentTreeListener<V> listener) {
- eventListeners.remove(listener);
- return CompletableFuture.completedFuture(null);
- }
-
- private class InternalListener implements DocumentTreeListener<V> {
- private final DocumentPath path;
- private final DocumentTreeListener<V> listener;
-
- public InternalListener(DocumentPath path, DocumentTreeListener<V> listener) {
- this.path = path;
- this.listener = listener;
- }
-
- @Override
- public void event(DocumentTreeEvent<V> event) {
- if (event.path().isDescendentOf(path)) {
- listener.event(event);
- }
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CachingAsyncLeaderElector.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CachingAsyncLeaderElector.java
deleted file mode 100644
index 91dcca5..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CachingAsyncLeaderElector.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
-
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
-import org.onosproject.cluster.Leadership;
-import org.onosproject.cluster.NodeId;
-import org.onosproject.event.Change;
-import org.onosproject.store.service.AsyncLeaderElector;
-
-/**
- * Caching async leader elector.
- */
-public class CachingAsyncLeaderElector extends DelegatingAsyncLeaderElector {
- private final LoadingCache<String, CompletableFuture<Leadership>> cache;
- private final Consumer<Change<Leadership>> cacheUpdater;
- private final Consumer<Status> statusListener;
-
- public CachingAsyncLeaderElector(AsyncLeaderElector delegateLeaderElector) {
- super(delegateLeaderElector);
- cache = CacheBuilder.newBuilder()
- .maximumSize(1000)
- .build(CacheLoader.from(super::getLeadership));
-
- cacheUpdater = change -> {
- Leadership leadership = change.newValue();
- cache.put(leadership.topic(), CompletableFuture.completedFuture(leadership));
- };
- statusListener = status -> {
- if (status == Status.SUSPENDED || status == Status.INACTIVE) {
- cache.invalidateAll();
- }
- };
- addChangeListener(cacheUpdater);
- addStatusChangeListener(statusListener);
- }
-
- @Override
- public CompletableFuture<Leadership> getLeadership(String topic) {
- return cache.getUnchecked(topic)
- .whenComplete((r, e) -> {
- if (e != null) {
- cache.invalidate(topic);
- }
- });
- }
-
- @Override
- public CompletableFuture<Leadership> run(String topic, NodeId nodeId) {
- return super.run(topic, nodeId).whenComplete((r, e) -> cache.invalidate(topic));
- }
-
- @Override
- public CompletableFuture<Void> withdraw(String topic) {
- return super.withdraw(topic).whenComplete((r, e) -> cache.invalidate(topic));
- }
-
- @Override
- public CompletableFuture<Boolean> anoint(String topic, NodeId nodeId) {
- return super.anoint(topic, nodeId).whenComplete((r, e) -> cache.invalidate(topic));
- }
-
- @Override
- public CompletableFuture<Boolean> promote(String topic, NodeId nodeId) {
- return super.promote(topic, nodeId).whenComplete((r, e) -> cache.invalidate(topic));
- }
-
- @Override
- public CompletableFuture<Void> evict(NodeId nodeId) {
- return super.evict(nodeId).whenComplete((r, e) -> cache.invalidateAll());
- }
-
- @Override
- public CompletableFuture<Void> destroy() {
- removeStatusChangeListener(statusListener);
- return removeChangeListener(cacheUpdater);
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CompatibleValue.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CompatibleValue.java
deleted file mode 100644
index 73c4d12..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CompatibleValue.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.core.Version;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-
-/**
- * Compatibility wrapper for primitive values.
- */
-public class CompatibleValue<T> {
- private final T value;
- private final Version version;
-
- public CompatibleValue(T value, Version version) {
- this.value = value;
- this.version = version;
- }
-
- /**
- * Returns the wrapped value.
- *
- * @return the wrapped value
- */
- public T value() {
- return value;
- }
-
- /**
- * Returns the compatibilty version.
- *
- * @return the compatibility version
- */
- public Version version() {
- return version;
- }
-
- @Override
- public String toString() {
- return toStringHelper(this)
- .add("value", value)
- .add("version", version)
- .toString();
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CoordinationManager.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CoordinationManager.java
index 1f6310f..aa9a78ef 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CoordinationManager.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/CoordinationManager.java
@@ -15,9 +15,12 @@
*/
package org.onosproject.store.primitives.impl;
+import java.util.List;
import java.util.function.Supplier;
import java.util.stream.Collectors;
+import io.atomix.core.Atomix;
+import io.atomix.primitive.partition.PartitionGroup;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
@@ -26,14 +29,10 @@
import org.apache.felix.scr.annotations.Service;
import org.onosproject.cluster.ClusterService;
import org.onosproject.cluster.ControllerNode;
-import org.onosproject.cluster.DefaultPartition;
import org.onosproject.cluster.NodeId;
-import org.onosproject.cluster.PartitionId;
import org.onosproject.persistence.PersistenceService;
import org.onosproject.store.cluster.messaging.ClusterCommunicationService;
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncAtomicValue;
+import org.onosproject.store.impl.AtomixManager;
import org.onosproject.store.service.AsyncConsistentMultimap;
import org.onosproject.store.service.AsyncConsistentTreeMap;
import org.onosproject.store.service.AsyncDocumentTree;
@@ -54,17 +53,15 @@
import org.onosproject.store.service.TopicBuilder;
import org.onosproject.store.service.TransactionContextBuilder;
import org.onosproject.store.service.WorkQueue;
+import org.onosproject.store.service.WorkQueueBuilder;
import org.slf4j.Logger;
-import java.util.List;
-
import static org.onosproject.security.AppGuard.checkPermission;
import static org.onosproject.security.AppPermission.Type.STORAGE_WRITE;
import static org.slf4j.LoggerFactory.getLogger;
/**
- * Implementation of {@code CoordinationService} that uses a {@link StoragePartition} that spans all the nodes
- * in the cluster regardless of version.
+ * Implementation of {@code CoordinationService} that uses the Atomix management partition group.
*/
@Service
@Component(immediate = true)
@@ -81,23 +78,16 @@
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected PersistenceService persistenceService;
- private StoragePartition partition;
- private DistributedPrimitiveCreator primitiveCreator;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected AtomixManager atomixManager;
+
+ private Atomix atomix;
+ private PartitionGroup group;
@Activate
public void activate() {
- partition = new StoragePartition(
- new DefaultPartition(
- PartitionId.from(0),
- null,
- clusterService.getNodes()
- .stream()
- .map(ControllerNode::id)
- .collect(Collectors.toSet())),
- clusterCommunicator,
- clusterService);
- partition.open().join();
- primitiveCreator = partition.client();
+ atomix = atomixManager.getAtomix();
+ group = atomix.getPartitionService().getSystemPartitionGroup();
log.info("Started");
}
@@ -112,134 +102,146 @@
final NodeId localNodeId = clusterService.getLocalNode().id();
Supplier<List<NodeId>> peersSupplier = () -> clusterService.getNodes().stream()
- .map(ControllerNode::id)
- .filter(nodeId -> !nodeId.equals(localNodeId))
- .filter(id -> clusterService.getState(id).isActive())
- .collect(Collectors.toList());
+ .map(ControllerNode::id)
+ .filter(nodeId -> !nodeId.equals(localNodeId))
+ .filter(id -> clusterService.getState(id).isActive())
+ .collect(Collectors.toList());
Supplier<List<NodeId>> bootstrapPeersSupplier = () -> clusterService.getNodes()
- .stream()
- .map(ControllerNode::id)
- .filter(id -> !localNodeId.equals(id))
- .filter(id -> clusterService.getState(id).isActive())
- .collect(Collectors.toList());
+ .stream()
+ .map(ControllerNode::id)
+ .filter(id -> !localNodeId.equals(id))
+ .filter(id -> clusterService.getState(id).isActive())
+ .collect(Collectors.toList());
return new EventuallyConsistentMapBuilderImpl<>(
- localNodeId,
- clusterCommunicator,
- persistenceService,
- peersSupplier,
- bootstrapPeersSupplier
+ localNodeId,
+ clusterCommunicator,
+ persistenceService,
+ peersSupplier,
+ bootstrapPeersSupplier
);
}
@Override
public <K, V> ConsistentMapBuilder<K, V> consistentMapBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultConsistentMapBuilder<>(primitiveCreator);
+ return new AtomixConsistentMapBuilder<>(atomix, group.name());
}
@Override
public <V> DocumentTreeBuilder<V> documentTreeBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultDocumentTreeBuilder<>(primitiveCreator);
+ return new AtomixDocumentTreeBuilder<>(atomix, group.name());
}
@Override
public <V> ConsistentTreeMapBuilder<V> consistentTreeMapBuilder() {
- return new DefaultConsistentTreeMapBuilder<>(primitiveCreator);
+ return new AtomixConsistentTreeMapBuilder<>(atomix, group.name());
}
@Override
public <K, V> ConsistentMultimapBuilder<K, V> consistentMultimapBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultConsistentMultimapBuilder<>(primitiveCreator);
+ return new AtomixConsistentMultimapBuilder<>(atomix, group.name());
}
@Override
public <K> AtomicCounterMapBuilder<K> atomicCounterMapBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultAtomicCounterMapBuilder<>(primitiveCreator);
+ return new AtomixAtomicCounterMapBuilder<>(atomix, group.name());
}
@Override
public <E> DistributedSetBuilder<E> setBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultDistributedSetBuilder<>(this::<E, Boolean>consistentMapBuilder);
+ return new AtomixDistributedSetBuilder<>(atomix, group.name());
}
@Override
public AtomicCounterBuilder atomicCounterBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultAtomicCounterBuilder(primitiveCreator);
+ return new AtomixAtomicCounterBuilder(atomix, group.name());
}
@Override
public AtomicIdGeneratorBuilder atomicIdGeneratorBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultAtomicIdGeneratorBuilder(primitiveCreator);
+ return new AtomixAtomicIdGeneratorBuilder(atomix, group.name());
}
@Override
public <V> AtomicValueBuilder<V> atomicValueBuilder() {
checkPermission(STORAGE_WRITE);
- Supplier<ConsistentMapBuilder<String, byte[]>> mapBuilderSupplier =
- () -> this.<String, byte[]>consistentMapBuilder()
- .withName("onos-atomic-values")
- .withSerializer(Serializer.using(KryoNamespaces.BASIC));
- return new DefaultAtomicValueBuilder<>(mapBuilderSupplier);
+ return new AtomixAtomicValueBuilder<>(atomix, group.name());
}
@Override
public TransactionContextBuilder transactionContextBuilder() {
- throw new UnsupportedOperationException();
+ checkPermission(STORAGE_WRITE);
+ return new AtomixTransactionContextBuilder(atomix, group.name());
}
@Override
public LeaderElectorBuilder leaderElectorBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultLeaderElectorBuilder(primitiveCreator);
+ return new AtomixLeaderElectorBuilder(atomix, group.name(), clusterService.getLocalNode().id());
}
@Override
public <T> TopicBuilder<T> topicBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultDistributedTopicBuilder<>(atomicValueBuilder());
+ return new AtomixDistributedTopicBuilder<>(atomix, group.name());
+ }
+
+ @Override
+ public <E> WorkQueueBuilder<E> workQueueBuilder() {
+ checkPermission(STORAGE_WRITE);
+ return new AtomixWorkQueueBuilder<>(atomix, group.name());
}
@Override
public <E> WorkQueue<E> getWorkQueue(String name, Serializer serializer) {
checkPermission(STORAGE_WRITE);
- return primitiveCreator.newWorkQueue(name, serializer);
+ return this.<E>workQueueBuilder()
+ .withName(name)
+ .withSerializer(serializer)
+ .build();
}
@Override
public <V> AsyncDocumentTree<V> getDocumentTree(String name, Serializer serializer) {
checkPermission(STORAGE_WRITE);
- return primitiveCreator.newAsyncDocumentTree(name, serializer);
+ return this.<V>documentTreeBuilder()
+ .withName(name)
+ .withSerializer(serializer)
+ .build();
}
@Override
- public <K, V> AsyncConsistentMultimap<K, V> getAsyncSetMultimap(
- String name, Serializer serializer) {
+ public <K, V> AsyncConsistentMultimap<K, V> getAsyncSetMultimap(String name, Serializer serializer) {
checkPermission(STORAGE_WRITE);
- return primitiveCreator.newAsyncConsistentSetMultimap(name,
- serializer);
+ return this.<K, V>consistentMultimapBuilder()
+ .withName(name)
+ .withSerializer(serializer)
+ .buildMultimap();
}
@Override
- public <V> AsyncConsistentTreeMap<V> getAsyncTreeMap(
- String name, Serializer serializer) {
+ public <V> AsyncConsistentTreeMap<V> getAsyncTreeMap(String name, Serializer serializer) {
checkPermission(STORAGE_WRITE);
- return primitiveCreator.newAsyncConsistentTreeMap(name, serializer);
+ return this.<V>consistentTreeMapBuilder()
+ .withName(name)
+ .withSerializer(serializer)
+ .buildTreeMap();
}
@Override
public <T> Topic<T> getTopic(String name, Serializer serializer) {
- AsyncAtomicValue<T> atomicValue = this.<T>atomicValueBuilder()
- .withName("topic-" + name)
- .withSerializer(serializer)
- .build();
- return new DefaultDistributedTopic<>(atomicValue);
+ checkPermission(STORAGE_WRITE);
+ return this.<T>topicBuilder()
+ .withName(name)
+ .withSerializer(serializer)
+ .build();
}
}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAsyncAtomicValue.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAsyncAtomicValue.java
deleted file mode 100644
index 33af601..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAsyncAtomicValue.java
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import com.google.common.collect.Maps;
-import org.onosproject.store.service.AsyncAtomicValue;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.AtomicValueEvent;
-import org.onosproject.store.service.AtomicValueEventListener;
-import org.onosproject.store.service.MapEvent;
-import org.onosproject.store.service.MapEventListener;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.Versioned;
-import org.onosproject.utils.MeteringAgent;
-
-import java.util.Map;
-import java.util.concurrent.CompletableFuture;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * Default implementation of a {@code AsyncAtomicValue}.
- *
- * @param <V> value type
- */
-public class DefaultAsyncAtomicValue<V> implements AsyncAtomicValue<V> {
-
- private final String name;
- private final Serializer serializer;
- private final AsyncConsistentMap<String, byte[]> backingMap;
- private final Map<AtomicValueEventListener<V>, MapEventListener<String, byte[]>> listeners =
- Maps.newIdentityHashMap();
- private final MeteringAgent monitor;
-
- private static final String COMPONENT_NAME = "atomicValue";
- private static final String GET = "get";
- private static final String GET_AND_SET = "getAndSet";
- private static final String SET = "set";
- private static final String COMPARE_AND_SET = "compareAndSet";
- private static final String ADD_LISTENER = "addListener";
- private static final String REMOVE_LISTENER = "removeListener";
- private static final String NOTIFY_LISTENER = "notifyListener";
- private static final String DESTROY = "destroy";
-
- public DefaultAsyncAtomicValue(String name, Serializer serializer, AsyncConsistentMap<String, byte[]> backingMap) {
- this.name = checkNotNull(name, "name must not be null");
- this.serializer = checkNotNull(serializer, "serializer must not be null");
- this.backingMap = checkNotNull(backingMap, "backingMap must not be null");
- this.monitor = new MeteringAgent(COMPONENT_NAME, name, true);
- }
-
- //Bypass osgi error with 'activated' MeteringAgent parameter set to false
- DefaultAsyncAtomicValue(String name, Serializer serializer, AsyncConsistentMap<String, byte[]> backingMap,
- MeteringAgent meteringAgent) {
- this.name = checkNotNull(name, "name must not be null");
- this.serializer = checkNotNull(serializer, "serializer must not be null");
- this.backingMap = checkNotNull(backingMap, "backingMap must not be null");
- this.monitor = meteringAgent;
-
- }
-
- @Override
- public String name() {
- return name;
- }
-
- @Override
- public CompletableFuture<Void> destroy() {
- final MeteringAgent.Context newTimer = monitor.startTimer(DESTROY);
- return backingMap.remove(name)
- .whenComplete((r, e) -> newTimer.stop(e))
- .thenApply(v -> null);
- }
-
- @Override
- public CompletableFuture<Boolean> compareAndSet(V expect, V update) {
- final MeteringAgent.Context newTimer = monitor.startTimer(COMPARE_AND_SET);
- return backingMap.replace(name, serializer.encode(expect), serializer.encode(update))
- .whenComplete((r, e) -> newTimer.stop(e));
- }
-
- @Override
- public CompletableFuture<V> get() {
- final MeteringAgent.Context newTimer = monitor.startTimer(GET);
- return backingMap.get(name)
- .thenApply(Versioned::valueOrNull)
- .thenApply(v -> v == null ? null : serializer.<V>decode(v))
- .whenComplete((r, e) -> newTimer.stop(e));
- }
-
- @Override
- public CompletableFuture<V> getAndSet(V value) {
- final MeteringAgent.Context newTimer = monitor.startTimer(GET_AND_SET);
- if (value == null) {
- return backingMap.remove(name)
- .thenApply(Versioned::valueOrNull)
- .thenApply(v -> v == null ? null : serializer.<V>decode(v))
- .whenComplete((r, e) -> newTimer.stop(e));
- }
- return backingMap.put(name, serializer.encode(value))
- .thenApply(Versioned::valueOrNull)
- .thenApply(v -> v == null ? null : serializer.<V>decode(v))
- .whenComplete((r, e) -> newTimer.stop(e));
- }
-
- @Override
- public CompletableFuture<Void> set(V value) {
- final MeteringAgent.Context newTimer = monitor.startTimer(SET);
- if (value == null) {
- return backingMap.remove(name)
- .whenComplete((r, e) -> newTimer.stop(e))
- .thenApply(v -> null);
-
- }
- return backingMap.put(name, serializer.encode(value))
- .whenComplete((r, e) -> newTimer.stop(e))
- .thenApply(v -> null);
- }
-
- @Override
- public CompletableFuture<Void> addListener(AtomicValueEventListener<V> listener) {
- checkNotNull(listener, "listener must not be null");
- final MeteringAgent.Context newTimer = monitor.startTimer(ADD_LISTENER);
- MapEventListener<String, byte[]> mapListener =
- listeners.computeIfAbsent(listener, key -> new InternalMapValueEventListener(listener));
- return backingMap.addListener(mapListener).whenComplete((r, e) -> newTimer.stop(e));
- }
-
- @Override
- public CompletableFuture<Void> removeListener(AtomicValueEventListener<V> listener) {
- checkNotNull(listener, "listener must not be null");
- final MeteringAgent.Context newTimer = monitor.startTimer(REMOVE_LISTENER);
- MapEventListener<String, byte[]> mapListener = listeners.remove(listener);
- if (mapListener != null) {
- return backingMap.removeListener(mapListener)
- .whenComplete((r, e) -> newTimer.stop(e));
- } else {
- newTimer.stop(null);
- return CompletableFuture.completedFuture(null);
- }
- }
-
- private class InternalMapValueEventListener implements MapEventListener<String, byte[]> {
-
- private final AtomicValueEventListener<V> listener;
-
- InternalMapValueEventListener(AtomicValueEventListener<V> listener) {
- this.listener = listener;
- }
-
- @Override
- public void event(MapEvent<String, byte[]> event) {
- if (event.key().equals(name)) {
- final MeteringAgent.Context newTimer = monitor.startTimer(NOTIFY_LISTENER);
- byte[] rawNewValue = Versioned.valueOrNull(event.newValue());
- byte[] rawOldValue = Versioned.valueOrNull(event.oldValue());
-
- try {
- listener.event(new AtomicValueEvent<>(name,
- rawNewValue == null ? null : serializer.decode(rawNewValue),
- rawOldValue == null ? null : serializer.decode(rawOldValue)));
- newTimer.stop(null);
- } catch (Exception e) {
- newTimer.stop(e);
- throw new IllegalStateException(e.getCause());
- }
- }
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAsyncDistributedSet.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAsyncDistributedSet.java
deleted file mode 100644
index d79c618..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAsyncDistributedSet.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.stream.Collectors;
-
-import org.onlab.util.Tools;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.AsyncDistributedSet;
-import org.onosproject.store.service.MapEvent;
-import org.onosproject.store.service.MapEventListener;
-import org.onosproject.store.service.SetEvent;
-import org.onosproject.store.service.SetEventListener;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import org.onosproject.utils.MeteringAgent;
-
-/**
- * Implementation of {@link AsyncDistributedSet}.
- *
- * @param <E> set entry type
- */
-public class DefaultAsyncDistributedSet<E> implements AsyncDistributedSet<E> {
-
- private static final String CONTAINS = "contains";
- private static final String PRIMITIVE_NAME = "distributedSet";
- private static final String SIZE = "size";
- private static final String IS_EMPTY = "isEmpty";
- private static final String ADD = "add";
- private static final String REMOVE = "remove";
- private static final String CONTAINS_ALL = "containsAll";
- private static final String ADD_ALL = "addAll";
- private static final String RETAIN_ALL = "retainAll";
- private static final String REMOVE_ALL = "removeAll";
- private static final String CLEAR = "clear";
- private static final String GET_AS_IMMUTABLE_SET = "getAsImmutableSet";
-
- private final String name;
- private final AsyncConsistentMap<E, Boolean> backingMap;
- private final Map<SetEventListener<E>, MapEventListener<E, Boolean>> listenerMapping = Maps.newIdentityHashMap();
- private final MeteringAgent monitor;
-
- public DefaultAsyncDistributedSet(AsyncConsistentMap<E, Boolean> backingMap, String name, boolean meteringEnabled) {
- this.backingMap = backingMap;
- this.name = name;
- monitor = new MeteringAgent(PRIMITIVE_NAME, name, meteringEnabled);
- }
-
- @Override
- public String name() {
- return name;
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- final MeteringAgent.Context timer = monitor.startTimer(SIZE);
- return backingMap.size().whenComplete((r, e) -> timer.stop(null));
- }
-
- @Override
- public CompletableFuture<Boolean> isEmpty() {
- final MeteringAgent.Context timer = monitor.startTimer(IS_EMPTY);
- return backingMap.isEmpty().whenComplete((r, e) -> timer.stop(null));
- }
-
- @Override
- public CompletableFuture<Boolean> contains(E element) {
- final MeteringAgent.Context timer = monitor.startTimer(CONTAINS);
- return backingMap.containsKey(element).whenComplete((r, e) -> timer.stop(null));
- }
-
- @Override
- public CompletableFuture<Boolean> add(E entry) {
- final MeteringAgent.Context timer = monitor.startTimer(ADD);
- return backingMap.putIfAbsent(entry, true).thenApply(Objects::isNull).whenComplete((r, e) -> timer.stop(null));
- }
-
- @Override
- public CompletableFuture<Boolean> remove(E entry) {
- final MeteringAgent.Context timer = monitor.startTimer(REMOVE);
- return backingMap.remove(entry, true).whenComplete((r, e) -> timer.stop(null));
- }
-
- @Override
- public CompletableFuture<Boolean> containsAll(Collection<? extends E> c) {
- final MeteringAgent.Context timer = monitor.startTimer(CONTAINS_ALL);
- return Tools.allOf(c.stream().map(this::contains).collect(Collectors.toList())).thenApply(v ->
- v.stream().reduce(Boolean::logicalAnd).orElse(true)).whenComplete((r, e) -> timer.stop(null));
- }
-
- @Override
- public CompletableFuture<Boolean> addAll(Collection<? extends E> c) {
- final MeteringAgent.Context timer = monitor.startTimer(ADD_ALL);
- return Tools.allOf(c.stream().map(this::add).collect(Collectors.toList())).thenApply(v ->
- v.stream().reduce(Boolean::logicalOr).orElse(false)).whenComplete((r, e) -> timer.stop(null));
- }
-
- @Override
- public CompletableFuture<Boolean> retainAll(Collection<? extends E> c) {
- final MeteringAgent.Context timer = monitor.startTimer(RETAIN_ALL);
- return backingMap.keySet().thenApply(set -> Sets.difference(set, Sets.newHashSet(c)))
- .thenCompose(this::removeAll)
- .whenComplete((r, e) -> timer.stop(null));
- }
-
- @Override
- public CompletableFuture<Boolean> removeAll(Collection<? extends E> c) {
- final MeteringAgent.Context timer = monitor.startTimer(REMOVE_ALL);
- return Tools.allOf(c.stream().map(this::remove).collect(Collectors.toList())).thenApply(v ->
- v.stream().reduce(Boolean::logicalOr).orElse(false)).whenComplete((r, e) -> timer.stop(null));
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- final MeteringAgent.Context timer = monitor.startTimer(CLEAR);
- return backingMap.clear().whenComplete((r, e) -> timer.stop(null));
- }
-
- @Override
- public CompletableFuture<? extends Set<E>> getAsImmutableSet() {
- final MeteringAgent.Context timer = monitor.startTimer(GET_AS_IMMUTABLE_SET);
- return backingMap.keySet().thenApply(s -> ImmutableSet.copyOf(s)).whenComplete((r, e) -> timer.stop(null));
- }
-
- @Override
- public CompletableFuture<Void> addListener(SetEventListener<E> listener) {
- MapEventListener<E, Boolean> mapEventListener = mapEvent -> {
- if (mapEvent.type() == MapEvent.Type.INSERT) {
- listener.event(new SetEvent<>(name, SetEvent.Type.ADD, mapEvent.key()));
- } else if (mapEvent.type() == MapEvent.Type.REMOVE) {
- listener.event(new SetEvent<>(name, SetEvent.Type.REMOVE, mapEvent.key()));
- }
- };
- if (listenerMapping.putIfAbsent(listener, mapEventListener) == null) {
- return backingMap.addListener(mapEventListener);
- }
- return CompletableFuture.completedFuture(null);
- }
-
- @Override
- public CompletableFuture<Void> removeListener(SetEventListener<E> listener) {
- MapEventListener<E, Boolean> mapEventListener = listenerMapping.remove(listener);
- if (mapEventListener != null) {
- return backingMap.removeListener(mapEventListener);
- }
- return CompletableFuture.completedFuture(null);
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAtomicCounterBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAtomicCounterBuilder.java
deleted file mode 100644
index 11a0724..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAtomicCounterBuilder.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
-import org.onosproject.store.service.AsyncAtomicCounter;
-import org.onosproject.store.service.AtomicCounterBuilder;
-
-/**
- * Default implementation of AtomicCounterBuilder.
- */
-public class DefaultAtomicCounterBuilder extends AtomicCounterBuilder {
-
- private final DistributedPrimitiveCreator primitiveCreator;
-
- public DefaultAtomicCounterBuilder(DistributedPrimitiveCreator primitiveCreator) {
- this.primitiveCreator = primitiveCreator;
- }
-
- @Override
- public AsyncAtomicCounter build() {
- return primitiveCreator.newAsyncCounter(name());
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAtomicCounterMapBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAtomicCounterMapBuilder.java
deleted file mode 100644
index d5a143a..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAtomicCounterMapBuilder.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
-import org.onosproject.store.service.AsyncAtomicCounterMap;
-import org.onosproject.store.service.AtomicCounterMap;
-import org.onosproject.store.service.AtomicCounterMapBuilder;
-
-/**
- * Default {@code AtomicCounterMapBuilder}.
- */
-public class DefaultAtomicCounterMapBuilder<K> extends AtomicCounterMapBuilder<K> {
-
- private final DistributedPrimitiveCreator primitiveCreator;
-
- public DefaultAtomicCounterMapBuilder(DistributedPrimitiveCreator primitiveCreator) {
- this.primitiveCreator = primitiveCreator;
- }
-
- @Override
- public AsyncAtomicCounterMap<K> buildAsyncMap() {
- return primitiveCreator.newAsyncAtomicCounterMap(name(), serializer());
- }
-
- @Override
- public AtomicCounterMap<K> build() {
- return buildAsyncMap().asAtomicCounterMap();
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAtomicIdGeneratorBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAtomicIdGeneratorBuilder.java
deleted file mode 100644
index c9e8486..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAtomicIdGeneratorBuilder.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
-import org.onosproject.store.service.AsyncAtomicIdGenerator;
-import org.onosproject.store.service.AtomicIdGeneratorBuilder;
-
-/**
- * Default implementation of AtomicIdGeneratorBuilder.
- */
-public class DefaultAtomicIdGeneratorBuilder extends AtomicIdGeneratorBuilder {
-
- private final DistributedPrimitiveCreator primitiveCreator;
-
- public DefaultAtomicIdGeneratorBuilder(DistributedPrimitiveCreator primitiveCreator) {
- this.primitiveCreator = primitiveCreator;
- }
-
- @Override
- public AsyncAtomicIdGenerator build() {
- return primitiveCreator.newAsyncIdGenerator(name());
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAtomicValueBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAtomicValueBuilder.java
deleted file mode 100644
index 9058189..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAtomicValueBuilder.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.function.Supplier;
-
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncAtomicValue;
-import org.onosproject.store.service.AtomicValueBuilder;
-import org.onosproject.store.service.ConsistentMapBuilder;
-import org.onosproject.store.service.Serializer;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * Default implementation of AtomicValueBuilder.
- *
- * @param <V> value type
- */
-public class DefaultAtomicValueBuilder<V> extends AtomicValueBuilder<V> {
-
- private ConsistentMapBuilder<String, byte[]> mapBuilder;
-
- public DefaultAtomicValueBuilder(Supplier<ConsistentMapBuilder<String, byte[]>> mapBuilderSupplier) {
- mapBuilder = mapBuilderSupplier.get();
- }
-
- @Override
- public AsyncAtomicValue<V> build() {
- if (compatibilityFunction != null) {
- Serializer serializer = Serializer.using(KryoNamespaces.API, CompatibleValue.class);
-
- AsyncAtomicValue<CompatibleValue<byte[]>> rawValue = new DefaultAsyncAtomicValue<>(
- checkNotNull(name()), serializer, mapBuilder.buildAsyncMap());
-
- AsyncAtomicValue<CompatibleValue<V>> compatibleValue =
- DistributedPrimitives.newTranscodingAtomicValue(
- rawValue,
- value -> value == null ? null :
- new CompatibleValue<byte[]>(serializer().encode(value.value()), value.version()),
- value -> value == null ? null :
- new CompatibleValue<V>(serializer().decode(value.value()), value.version()));
- return DistributedPrimitives.newCompatibleAtomicValue(compatibleValue, compatibilityFunction, version());
- }
- return new DefaultAsyncAtomicValue<>(
- checkNotNull(name()),
- checkNotNull(serializer()),
- mapBuilder.buildAsyncMap());
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultConsistentMapBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultConsistentMapBuilder.java
deleted file mode 100644
index d6b9441..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultConsistentMapBuilder.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.ConsistentMap;
-import org.onosproject.store.service.ConsistentMapBuilder;
-import org.onosproject.store.service.Serializer;
-
-/**
- * Default {@link AsyncConsistentMap} builder.
- *
- * @param <K> type for map key
- * @param <V> type for map value
- */
-public class DefaultConsistentMapBuilder<K, V> extends ConsistentMapBuilder<K, V> {
-
- private final DistributedPrimitiveCreator primitiveCreator;
-
- public DefaultConsistentMapBuilder(DistributedPrimitiveCreator primitiveCreator) {
- this.primitiveCreator = primitiveCreator;
- }
-
- @Override
- public ConsistentMap<K, V> build() {
- return buildAsyncMap().asConsistentMap();
- }
-
- @Override
- public AsyncConsistentMap<K, V> buildAsyncMap() {
- AsyncConsistentMap<K, V> map;
-
- // If a compatibility function is defined, we don't assume CompatibleValue and Version is registered in
- // the user-provided serializer since it's an implementation detail. Instead, we use the user-provided
- // serializer to convert the CompatibleValue value to a raw byte[] and use a separate serializer to encode
- // the CompatibleValue to binary.
- if (compatibilityFunction != null) {
- Serializer serializer = serializer();
-
- // Convert the byte[] value to CompatibleValue<byte[]>
- AsyncConsistentMap<K, CompatibleValue<byte[]>> rawMap = primitiveCreator.newAsyncConsistentMap(
- withSerializer(Serializer.using(KryoNamespaces.API, CompatibleValue.class)));
-
- // Convert the CompatibleValue<byte[]> value to CompatibleValue<V> using the user-provided serializer.
- AsyncConsistentMap<K, CompatibleValue<V>> compatibleMap =
- DistributedPrimitives.newTranscodingMap(
- rawMap,
- key -> key,
- key -> key,
- value -> value == null ? null :
- new CompatibleValue<byte[]>(serializer.encode(value.value()), value.version()),
- value -> value == null ? null :
- new CompatibleValue<V>(serializer.decode(value.value()), value.version()));
- map = DistributedPrimitives.newCompatibleMap(compatibleMap, compatibilityFunction, version());
- } else {
- map = primitiveCreator.newAsyncConsistentMap(name(), serializer());
- }
-
- map = nullValues() ? map : DistributedPrimitives.newNotNullMap(map);
- map = relaxedReadConsistency() ? DistributedPrimitives.newCachingMap(map) : map;
- map = readOnly() ? DistributedPrimitives.newUnmodifiableMap(map) : map;
- return meteringEnabled() ? DistributedPrimitives.newMeteredMap(map) : map;
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultConsistentMultimapBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultConsistentMultimapBuilder.java
deleted file mode 100644
index 18ea1f1..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultConsistentMultimapBuilder.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright 2016 Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
-import org.onosproject.store.service.AsyncConsistentMultimap;
-import org.onosproject.store.service.ConsistentMultimap;
-import org.onosproject.store.service.ConsistentMultimapBuilder;
-
-/**
- * Default {@link AsyncConsistentMultimap} builder.
- */
-public class DefaultConsistentMultimapBuilder<K, V>
- extends ConsistentMultimapBuilder<K, V> {
-
- private final DistributedPrimitiveCreator primitiveCreator;
-
- public DefaultConsistentMultimapBuilder(
- DistributedPrimitiveCreator primitiveCreator) {
- this.primitiveCreator = primitiveCreator;
- }
-
- @Override
- public AsyncConsistentMultimap<K, V> buildMultimap() {
- return primitiveCreator.newAsyncConsistentSetMultimap(name(), serializer());
- }
-
- @Override
- public ConsistentMultimap<K, V> build() {
- AsyncConsistentMultimap<K, V> multimap = buildMultimap();
- if (relaxedReadConsistency()) {
- multimap = new CachingAsyncConsistentMultimap<>(multimap);
- }
- return multimap.asMultimap();
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultConsistentTreeMapBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultConsistentTreeMapBuilder.java
deleted file mode 100644
index b80d93e..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultConsistentTreeMapBuilder.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
-import org.onosproject.store.service.AsyncConsistentTreeMap;
-import org.onosproject.store.service.ConsistentTreeMap;
-import org.onosproject.store.service.ConsistentTreeMapBuilder;
-
-/**
- * Default {@link org.onosproject.store.service.AsyncConsistentTreeMap} builder.
- *
- * @param <V> type for map value
- */
-public class DefaultConsistentTreeMapBuilder<V> extends ConsistentTreeMapBuilder<V> {
-
- private final DistributedPrimitiveCreator primitiveCreator;
-
- public DefaultConsistentTreeMapBuilder(DistributedPrimitiveCreator primitiveCreator) {
- this.primitiveCreator = primitiveCreator;
- }
-
- @Override
- public AsyncConsistentTreeMap<V> buildTreeMap() {
- return primitiveCreator.newAsyncConsistentTreeMap(name(), serializer());
- }
-
- @Override
- public ConsistentTreeMap<V> build() {
- return buildTreeMap().asTreeMap();
- }
-
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedDocumentTree.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedDocumentTree.java
deleted file mode 100644
index 8d4f9c3..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedDocumentTree.java
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Map;
-import java.util.concurrent.CompletableFuture;
-
-import org.onosproject.store.primitives.NodeUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.AsyncDocumentTree;
-import org.onosproject.store.service.DocumentPath;
-import org.onosproject.store.service.DocumentTreeEvent;
-import org.onosproject.store.service.DocumentTreeListener;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.Versioned;
-
-import com.google.common.collect.Maps;
-
-/**
- * Default implementation of {@link AsyncDocumentTree}.
- * <p>
- * This implementation delegates execution to a backing tree implemented on top of Atomix framework.
- *
- * @param <V> tree node value type.
- */
-public class DefaultDistributedDocumentTree<V> implements AsyncDocumentTree<V> {
-
- private final String name;
- private final AsyncDocumentTree<byte[]> backingTree;
- private final Serializer serializer;
- private final Map<DocumentTreeListener<V>, InternalBackingDocumentTreeListener> listeners =
- Maps.newIdentityHashMap();
-
- DefaultDistributedDocumentTree(String name, AsyncDocumentTree<byte[]> backingTree, Serializer serializer) {
- this.name = name;
- this.backingTree = backingTree;
- this.serializer = serializer;
- }
-
- @Override
- public String name() {
- return name;
- }
-
- @Override
- public Type primitiveType() {
- return backingTree.primitiveType();
- }
-
- @Override
- public DocumentPath root() {
- return backingTree.root();
- }
-
- @Override
- public CompletableFuture<Map<String, Versioned<V>>> getChildren(DocumentPath path) {
- return backingTree.getChildren(path)
- .thenApply(map -> Maps.transformValues(map, v -> v.map(serializer::decode)));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> get(DocumentPath path) {
- return backingTree.get(path)
- .thenApply(v -> v == null ? null : v.map(serializer::decode));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> set(DocumentPath path, V value) {
- return backingTree.set(path, serializer.encode(value))
- .thenApply(v -> v == null ? null : v.map(serializer::decode));
- }
-
- @Override
- public CompletableFuture<Boolean> create(DocumentPath path, V value) {
- return backingTree.create(path, serializer.encode(value));
- }
-
- @Override
- public CompletableFuture<Boolean> createRecursive(DocumentPath path, V value) {
- return backingTree.createRecursive(path, serializer.encode(value));
- }
-
- @Override
- public CompletableFuture<Boolean> replace(DocumentPath path, V newValue, long version) {
- return backingTree.replace(path, serializer.encode(newValue), version);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(DocumentPath path, V newValue, V currentValue) {
- return backingTree.replace(path, serializer.encode(newValue), serializer.encode(currentValue));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> removeNode(DocumentPath path) {
- return backingTree.removeNode(path)
- .thenApply(v -> v == null ? null : v.map(serializer::decode));
- }
-
-
- @Override
- public CompletableFuture<Version> begin(TransactionId transactionId) {
- return backingTree.begin(transactionId);
- }
-
- @Override
- public CompletableFuture<Boolean> prepare(TransactionLog<NodeUpdate<V>> transactionLog) {
- return backingTree.prepare(transactionLog.map(record -> record.map(serializer::encode)));
- }
-
- @Override
- public CompletableFuture<Void> commit(TransactionId transactionId) {
- return backingTree.commit(transactionId);
- }
-
- @Override
- public CompletableFuture<Void> rollback(TransactionId transactionId) {
- return backingTree.rollback(transactionId);
- }
-
- @Override
- public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<NodeUpdate<V>> transactionLog) {
- return backingTree.prepareAndCommit(transactionLog.map(record -> record.map(serializer::encode)));
- }
-
-
- @Override
- public CompletableFuture<Void> addListener(DocumentPath path, DocumentTreeListener<V> listener) {
- synchronized (listeners) {
- InternalBackingDocumentTreeListener backingListener =
- listeners.computeIfAbsent(listener, k -> new InternalBackingDocumentTreeListener(listener));
- return backingTree.addListener(path, backingListener);
- }
- }
-
- @Override
- public CompletableFuture<Void> removeListener(DocumentTreeListener<V> listener) {
- synchronized (listeners) {
- InternalBackingDocumentTreeListener backingListener = listeners.remove(listener);
- if (backingListener != null) {
- return backingTree.removeListener(backingListener);
- } else {
- return CompletableFuture.completedFuture(null);
- }
- }
- }
-
- private class InternalBackingDocumentTreeListener implements DocumentTreeListener<byte[]> {
-
- private final DocumentTreeListener<V> listener;
-
- InternalBackingDocumentTreeListener(DocumentTreeListener<V> listener) {
- this.listener = listener;
- }
-
- @Override
- public void event(DocumentTreeEvent<byte[]> event) {
- listener.event(new DocumentTreeEvent<V>(event.path(),
- event.type(),
- event.newValue().map(v -> v.map(serializer::decode)),
- event.oldValue().map(v -> v.map(serializer::decode))));
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedLockBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedLockBuilder.java
deleted file mode 100644
index fffebcc..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedLockBuilder.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
-import org.onosproject.store.service.AsyncDistributedLock;
-import org.onosproject.store.service.DistributedLockBuilder;
-
-/**
- * Default implementation of DistributedLockBuilder.
- */
-public class DefaultDistributedLockBuilder extends DistributedLockBuilder {
-
- private final DistributedPrimitiveCreator primitiveCreator;
-
- public DefaultDistributedLockBuilder(DistributedPrimitiveCreator primitiveCreator) {
- this.primitiveCreator = primitiveCreator;
- }
-
- @Override
- public AsyncDistributedLock build() {
- return primitiveCreator.newAsyncDistributedLock(name());
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedSetBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedSetBuilder.java
deleted file mode 100644
index a601239..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedSetBuilder.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.function.Supplier;
-
-import org.onosproject.core.ApplicationId;
-import org.onosproject.store.service.AsyncDistributedSet;
-import org.onosproject.store.service.ConsistentMapBuilder;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.DistributedSetBuilder;
-
-/**
- * Default distributed set builder.
- *
- * @param <E> type for set elements
- */
-public class DefaultDistributedSetBuilder<E> extends DistributedSetBuilder<E> {
-
- private String name;
- private ConsistentMapBuilder<E, Boolean> mapBuilder;
- private boolean metering = true;
-
- public DefaultDistributedSetBuilder(Supplier<ConsistentMapBuilder<E, Boolean>> mapBuilderSupplier) {
- this.mapBuilder = mapBuilderSupplier.get();
- mapBuilder.withMeteringDisabled();
- }
-
- @Override
- public DistributedSetBuilder<E> withName(String name) {
- mapBuilder.withName(name);
- this.name = name;
- return this;
- }
-
- @Override
- public DistributedSetBuilder<E> withApplicationId(ApplicationId id) {
- mapBuilder.withApplicationId(id);
- return this;
- }
-
- @Override
- public DistributedSetBuilder<E> withPurgeOnUninstall() {
- mapBuilder.withPurgeOnUninstall();
- return this;
- }
-
- @Override
- public DistributedSetBuilder<E> withSerializer(Serializer serializer) {
- mapBuilder.withSerializer(serializer);
- return this;
- }
-
- @Override
- public DistributedSetBuilder<E> withUpdatesDisabled() {
- mapBuilder.withUpdatesDisabled();
- return this;
- }
-
- @Override
- public DistributedSetBuilder<E> withRelaxedReadConsistency() {
- mapBuilder.withRelaxedReadConsistency();
- return this;
- }
-
- @Override
- public DistributedSetBuilder<E> withMeteringDisabled() {
- metering = false;
- return this;
- }
-
- @Override
- public AsyncDistributedSet<E> build() {
- return new DefaultAsyncDistributedSet<E>(mapBuilder.buildAsyncMap(), name, metering);
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedTopicBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedTopicBuilder.java
deleted file mode 100644
index 21ca7a1..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedTopicBuilder.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.function.BiFunction;
-
-import org.onosproject.core.Version;
-import org.onosproject.store.service.AtomicValueBuilder;
-import org.onosproject.store.service.RevisionType;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.Topic;
-import org.onosproject.store.service.TopicBuilder;
-
-/**
- * Default topic builder.
- */
-public class DefaultDistributedTopicBuilder<T> extends TopicBuilder<T> {
- private final AtomicValueBuilder<T> valueBuilder;
-
- public DefaultDistributedTopicBuilder(AtomicValueBuilder<T> valueBuilder) {
- this.valueBuilder = valueBuilder;
- }
-
- @Override
- public TopicBuilder<T> withName(String name) {
- valueBuilder.withName(name);
- return this;
- }
-
- @Override
- public TopicBuilder<T> withSerializer(Serializer serializer) {
- valueBuilder.withSerializer(serializer);
- return this;
- }
-
- @Override
- public TopicBuilder<T> withVersion(Version version) {
- valueBuilder.withVersion(version);
- return this;
- }
-
- @Override
- public TopicBuilder<T> withRevisionType(RevisionType revisionType) {
- valueBuilder.withRevisionType(revisionType);
- return this;
- }
-
- @Override
- public TopicBuilder<T> withCompatibilityFunction(BiFunction<T, Version, T> compatibilityFunction) {
- valueBuilder.withCompatibilityFunction(compatibilityFunction);
- return this;
- }
-
- @Override
- public Topic<T> build() {
- return new DefaultDistributedTopic<>(valueBuilder.build());
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedWorkQueue.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedWorkQueue.java
deleted file mode 100644
index 11895db..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDistributedWorkQueue.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
-
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.Task;
-import org.onosproject.store.service.WorkQueue;
-import org.onosproject.store.service.WorkQueueStats;
-
-import com.google.common.collect.Collections2;
-
-/**
- * Default implementation of {@link WorkQueue}.
- *
- * @param <E> task payload type.
- */
-public class DefaultDistributedWorkQueue<E> implements WorkQueue<E> {
-
- private final WorkQueue<byte[]> backingQueue;
- private final Serializer serializer;
-
- public DefaultDistributedWorkQueue(WorkQueue<byte[]> backingQueue, Serializer serializer) {
- this.backingQueue = backingQueue;
- this.serializer = serializer;
- }
-
- @Override
- public String name() {
- return backingQueue.name();
- }
-
- @Override
- public CompletableFuture<Void> addMultiple(Collection<E> items) {
- return backingQueue.addMultiple(items.stream()
- .map(serializer::encode)
- .collect(Collectors.toCollection(ArrayList::new)));
- }
-
- private Collection<Task<E>> decodeCollection(Collection<Task<byte[]>> tasks) {
- return Collections2.transform(tasks, task -> task.map(serializer::decode));
- }
-
- @Override
- public CompletableFuture<Collection<Task<E>>> take(int maxTasks) {
- return backingQueue.take(maxTasks)
- .thenApply(this::decodeCollection);
- }
-
- @Override
- public CompletableFuture<Void> complete(Collection<String> ids) {
- return backingQueue.complete(ids);
- }
-
- @Override
- public CompletableFuture<WorkQueueStats> stats() {
- return backingQueue.stats();
- }
-
- @Override
- public CompletableFuture<Void> registerTaskProcessor(Consumer<E> callback,
- int parallelism,
- Executor executor) {
- Consumer<byte[]> backingQueueCallback = payload -> callback.accept(serializer.decode(payload));
- return backingQueue.registerTaskProcessor(backingQueueCallback, parallelism, executor);
- }
-
- @Override
- public CompletableFuture<Void> stopProcessing() {
- return backingQueue.stopProcessing();
- }
-
- @Override
- public CompletableFuture<Void> destroy() {
- return backingQueue.destroy();
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDocumentTreeBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDocumentTreeBuilder.java
deleted file mode 100644
index f0da9ab..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultDocumentTreeBuilder.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
-import org.onosproject.store.service.AsyncDocumentTree;
-import org.onosproject.store.service.DocumentTreeBuilder;
-
-/**
- * Default {@link AsyncDocumentTree} builder.
- *
- * @param <V> type for document tree value
- */
-public class DefaultDocumentTreeBuilder<V> extends DocumentTreeBuilder<V> {
-
- private final DistributedPrimitiveCreator primitiveCreator;
-
- public DefaultDocumentTreeBuilder(DistributedPrimitiveCreator primitiveCreator) {
- this.primitiveCreator = primitiveCreator;
- }
-
- @Override
- public AsyncDocumentTree<V> buildDocumentTree() {
- return primitiveCreator.newAsyncDocumentTree(name(), serializer(), ordering());
- }
-
- //TODO
- /*
- public ConsistentDocumentTree<V> build() {
- return buildDocumentTree().asDocumentTree();
- }
- }*/
- //writing a dummy implementation till we have ConsistentDocumentTree.
- @Deprecated
- @Override
- public AsyncDocumentTree<V> build() {
- AsyncDocumentTree<V> tree = primitiveCreator.newAsyncDocumentTree(name(), serializer(), ordering());
- tree = relaxedReadConsistency() ? DistributedPrimitives.newCachingDocumentTree(tree) : tree;
- return tree;
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultLeaderElectorBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultLeaderElectorBuilder.java
deleted file mode 100644
index 21ddf03..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultLeaderElectorBuilder.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
-import org.onosproject.store.service.AsyncLeaderElector;
-import org.onosproject.store.service.LeaderElectorBuilder;
-
-import java.util.concurrent.TimeUnit;
-
-/**
- * Default implementation of {@code LeaderElectorBuilder}.
- */
-public class DefaultLeaderElectorBuilder extends LeaderElectorBuilder {
-
- private final DistributedPrimitiveCreator primitiveCreator;
-
- public DefaultLeaderElectorBuilder(DistributedPrimitiveCreator primitiveCreator) {
- this.primitiveCreator = primitiveCreator;
- }
-
- @Override
- public AsyncLeaderElector build() {
- AsyncLeaderElector leaderElector = primitiveCreator.newAsyncLeaderElector(name(), electionTimeoutMillis(),
- TimeUnit.MILLISECONDS);
- if (relaxedReadConsistency()) {
- leaderElector = new CachingAsyncLeaderElector(leaderElector);
- }
- return leaderElector;
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultTransactionContext.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultTransactionContext.java
deleted file mode 100644
index 19ea562..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultTransactionContext.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.CommitStatus;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.TransactionContext;
-import org.onosproject.store.service.TransactionalMap;
-import org.onosproject.utils.MeteringAgent;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-import static com.google.common.base.Preconditions.checkState;
-
-/**
- * Default implementation of transaction context.
- */
-public class DefaultTransactionContext implements TransactionContext {
- private final Logger log = LoggerFactory.getLogger(getClass());
- private final AtomicBoolean isOpen = new AtomicBoolean(false);
- private final TransactionId transactionId;
- private final TransactionCoordinator transactionCoordinator;
- private final MeteringAgent monitor;
-
- public DefaultTransactionContext(TransactionId transactionId, TransactionCoordinator transactionCoordinator) {
- this.transactionId = transactionId;
- this.transactionCoordinator = transactionCoordinator;
- this.monitor = new MeteringAgent("transactionContext", "*", true);
- }
-
- @Override
- public String name() {
- return transactionId.toString();
- }
-
- @Override
- public TransactionId transactionId() {
- return transactionId;
- }
-
- @Override
- public boolean isOpen() {
- return isOpen.get();
- }
-
- @Override
- public void begin() {
- if (isOpen.compareAndSet(false, true)) {
- log.trace("Opened transaction {}", transactionId);
- } else {
- throw new IllegalStateException("TransactionContext is already open");
- }
- }
-
- @Override
- public CompletableFuture<CommitStatus> commit() {
- checkState(isOpen.get(), "Transaction not open");
- final MeteringAgent.Context timer = monitor.startTimer("commit");
- log.debug("Committing transaction {}", transactionId);
- return transactionCoordinator.commit().whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public void abort() {
- if (isOpen.compareAndSet(true, false)) {
- log.debug("Aborted transaction {}", transactionId);
- }
- }
-
- @Override
- public <K, V> TransactionalMap<K, V> getTransactionalMap(String mapName, Serializer serializer) {
- return transactionCoordinator.getTransactionalMap(mapName, serializer);
- }
-
- @Override
- public String toString() {
- return toStringHelper(this)
- .add("transactionId", transactionId)
- .toString();
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultTransactionContextBuilder.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultTransactionContextBuilder.java
deleted file mode 100644
index ecbb1d2..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultTransactionContextBuilder.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.TransactionContext;
-import org.onosproject.store.service.TransactionContextBuilder;
-
-/**
- * Default Transaction Context Builder.
- */
-public class DefaultTransactionContextBuilder extends TransactionContextBuilder {
-
- private final TransactionId transactionId;
- private final TransactionManager transactionManager;
-
- public DefaultTransactionContextBuilder(TransactionId transactionId, TransactionManager transactionManager) {
- this.transactionId = transactionId;
- this.transactionManager = transactionManager;
- }
-
- @Override
- public TransactionContext build() {
- return new DefaultTransactionContext(transactionId,
- new TransactionCoordinator(transactionId, transactionManager));
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultTransactionalMapParticipant.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultTransactionalMapParticipant.java
deleted file mode 100644
index 14346ce..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultTransactionalMapParticipant.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Map;
-import java.util.stream.Stream;
-
-import com.google.common.collect.Maps;
-import org.apache.commons.lang3.tuple.Pair;
-import org.onosproject.store.primitives.MapUpdate;
-import org.onosproject.store.service.ConsistentMap;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.Versioned;
-
-/**
- * Repeatable read based map participant.
- */
-public class DefaultTransactionalMapParticipant<K, V> extends TransactionalMapParticipant<K, V> {
- private final Map<K, Versioned<V>> readCache = Maps.newConcurrentMap();
-
- public DefaultTransactionalMapParticipant(
- ConsistentMap<K, V> backingMap, Transaction<MapUpdate<K, V>> transaction) {
- super(backingMap, transaction);
- }
-
- @Override
- protected V read(K key) {
- Versioned<V> value = backingMap.getOrDefault(key, null);
- readCache.put(key, value);
- return value.value();
- }
-
- @Override
- public boolean hasPendingUpdates() {
- return !writeCache.isEmpty() || !deleteSet.isEmpty();
- }
-
- @Override
- protected Stream<MapUpdate<K, V>> records(Version lockVersion) {
- return Stream.concat(deleteStream(), writeStream(lockVersion));
- }
-
- /**
- * Returns a transaction record stream for deleted keys.
- */
- private Stream<MapUpdate<K, V>> deleteStream() {
- return deleteSet.stream()
- .map(key -> Pair.of(key, readCache.get(key)))
- .map(e -> MapUpdate.<K, V>newBuilder()
- .withType(MapUpdate.Type.REMOVE_IF_VERSION_MATCH)
- .withKey(e.getKey())
- .withVersion(e.getValue().version())
- .build());
- }
-
- /**
- * Returns a transaction record stream for updated keys.
- */
- private Stream<MapUpdate<K, V>> writeStream(Version lockVersion) {
- return writeCache.entrySet().stream()
- .map(entry -> {
- Versioned<V> original = readCache.get(entry.getKey());
- return MapUpdate.<K, V>newBuilder()
- .withType(MapUpdate.Type.PUT_IF_VERSION_MATCH)
- .withKey(entry.getKey())
- .withValue(entry.getValue())
- .withVersion(Math.max(original.version(), lockVersion.value()))
- .build();
- });
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultTransactionalSet.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultTransactionalSet.java
deleted file mode 100644
index a2bac21..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultTransactionalSet.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.TransactionContext;
-import org.onosproject.store.service.TransactionalMap;
-import org.onosproject.store.service.TransactionalSet;
-
-/**
- * Default TransactionalSet implementation that provides a repeatable reads
- * transaction isolation level.
- *
- * @param <E> element type.
- */
-public class DefaultTransactionalSet<E> implements TransactionalSet<E> {
-
- private TransactionalMap<E, Boolean> map;
-
- // dummy value to associate with an Object in the backing map
- private static final Boolean PRESENT = Boolean.TRUE;
-
- public DefaultTransactionalSet(
- String name,
- TransactionContext txContext,
- Serializer serializer) {
- map = txContext.getTransactionalMap(name, serializer);
- }
-
- @Override
- public boolean add(E e) {
- return map.put(e, PRESENT) == null;
- }
-
- @Override
- public boolean remove(E e) {
- return map.remove(e) != null;
- }
-
- @Override
- public boolean contains(E e) {
- return map.get(e) != null;
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncConsistentMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncConsistentMap.java
deleted file mode 100644
index 193a250..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncConsistentMap.java
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.Map.Entry;
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.function.BiFunction;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-
-import com.google.common.base.MoreObjects;
-import org.onosproject.store.primitives.MapUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.AsyncIterator;
-import org.onosproject.store.service.MapEventListener;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.Versioned;
-
-/**
- * {@code AsyncConsistentMap} that merely delegates control to
- * another AsyncConsistentMap.
- *
- * @param <K> key type
- * @param <V> value type
- */
-public class DelegatingAsyncConsistentMap<K, V>
- extends DelegatingDistributedPrimitive implements AsyncConsistentMap<K, V> {
-
- private final AsyncConsistentMap<K, V> delegateMap;
-
- DelegatingAsyncConsistentMap(AsyncConsistentMap<K, V> delegateMap) {
- super(delegateMap);
- this.delegateMap = delegateMap;
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- return delegateMap.size();
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(K key) {
- return delegateMap.containsKey(key);
- }
-
- @Override
- public CompletableFuture<Boolean> containsValue(V value) {
- return delegateMap.containsValue(value);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> get(K key) {
- return delegateMap.get(key);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> getOrDefault(K key, V defaultValue) {
- return delegateMap.getOrDefault(key, defaultValue);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> computeIf(K key,
- Predicate<? super V> condition,
- BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
- return delegateMap.computeIf(key, condition, remappingFunction);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> put(K key, V value) {
- return delegateMap.put(key, value);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putAndGet(K key, V value) {
- return delegateMap.putAndGet(key, value);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> remove(K key) {
- return delegateMap.remove(key);
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return delegateMap.clear();
- }
-
- @Override
- public CompletableFuture<Set<K>> keySet() {
- return delegateMap.keySet();
- }
-
- @Override
- public CompletableFuture<Collection<Versioned<V>>> values() {
- return delegateMap.values();
- }
-
- @Override
- public CompletableFuture<Set<Entry<K, Versioned<V>>>> entrySet() {
- return delegateMap.entrySet();
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putIfAbsent(K key, V value) {
- return delegateMap.putIfAbsent(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, V value) {
- return delegateMap.remove(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, long version) {
- return delegateMap.remove(key, version);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> replace(K key, V value) {
- return delegateMap.replace(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K key, V oldValue, V newValue) {
- return delegateMap.replace(key, oldValue, newValue);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K key, long oldVersion, V newValue) {
- return delegateMap.replace(key, oldVersion, newValue);
- }
-
- @Override
- public CompletableFuture<AsyncIterator<Entry<K, Versioned<V>>>> iterator() {
- return delegateMap.iterator();
- }
-
- @Override
- public CompletableFuture<Void> addListener(MapEventListener<K, V> listener, Executor executor) {
- return delegateMap.addListener(listener, executor);
- }
-
- @Override
- public CompletableFuture<Void> removeListener(MapEventListener<K, V> listener) {
- return delegateMap.removeListener(listener);
- }
-
- @Override
- public CompletableFuture<Version> begin(TransactionId transactionId) {
- return delegateMap.begin(transactionId);
- }
-
- @Override
- public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<K, V>> transactionLog) {
- return delegateMap.prepare(transactionLog);
- }
-
- @Override
- public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<K, V>> transactionLog) {
- return delegateMap.prepareAndCommit(transactionLog);
- }
-
- @Override
- public CompletableFuture<Void> commit(TransactionId transactionId) {
- return delegateMap.commit(transactionId);
- }
-
- @Override
- public CompletableFuture<Void> rollback(TransactionId transactionId) {
- return delegateMap.rollback(transactionId);
- }
-
- @Override
- public void addStatusChangeListener(Consumer<Status> listener) {
- delegateMap.addStatusChangeListener(listener);
- }
-
- @Override
- public void removeStatusChangeListener(Consumer<Status> listener) {
- delegateMap.removeStatusChangeListener(listener);
- }
-
- @Override
- public Collection<Consumer<Status>> statusChangeListeners() {
- return delegateMap.statusChangeListeners();
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("delegateMap", delegateMap)
- .toString();
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(delegateMap);
- }
-
- @Override
- public boolean equals(Object other) {
- if (other instanceof DelegatingAsyncConsistentMap) {
- DelegatingAsyncConsistentMap<K, V> that = (DelegatingAsyncConsistentMap) other;
- return this.delegateMap.equals(that.delegateMap);
- }
- return false;
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncConsistentMultimap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncConsistentMultimap.java
deleted file mode 100644
index 779bb7a..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncConsistentMultimap.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import com.google.common.collect.Multiset;
-import org.onosproject.store.service.AsyncConsistentMultimap;
-import org.onosproject.store.service.AsyncIterator;
-import org.onosproject.store.service.MultimapEventListener;
-import org.onosproject.store.service.Versioned;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-
-import java.util.concurrent.Executor;
-
-/**
- * {@code AsyncConsistentMultimap} that merely delegates control to
- * another AsyncConsistentMultimap.
- *
- * @param <K> key type
- * @param <V> value type
- */
-public class DelegatingAsyncConsistentMultimap<K, V>
- extends DelegatingDistributedPrimitive implements AsyncConsistentMultimap<K, V> {
-
- private final AsyncConsistentMultimap<K, V> delegateMap;
-
- public DelegatingAsyncConsistentMultimap(
- AsyncConsistentMultimap<K, V> delegateMap) {
- super(delegateMap);
- this.delegateMap = delegateMap;
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- return delegateMap.size();
- }
-
- @Override
- public CompletableFuture<Boolean> isEmpty() {
- return delegateMap.isEmpty();
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(K key) {
- return delegateMap.containsKey(key);
- }
-
- @Override
- public CompletableFuture<Boolean> containsValue(V value) {
- return delegateMap.containsValue(value);
- }
-
- @Override
- public CompletableFuture<Boolean> containsEntry(K key, V value) {
- return delegateMap.containsEntry(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> put(K key, V value) {
- return delegateMap.put(key, value);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>> putAndGet(K key, V value) {
- return delegateMap.putAndGet(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, V value) {
- return delegateMap.remove(key, value);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>> removeAndGet(K key, V value) {
- return delegateMap.removeAndGet(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> removeAll(
- K key, Collection<? extends V> values) {
- return delegateMap.removeAll(key, values);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>>
- removeAll(K key) {
- return delegateMap.removeAll(key);
- }
-
- @Override
- public CompletableFuture<Boolean> putAll(
- K key, Collection<? extends V> values) {
- return delegateMap.putAll(key, values);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>>
- replaceValues(K key, Collection<V> values) {
- return delegateMap.replaceValues(key, values);
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return delegateMap.clear();
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>> get(K key) {
- return delegateMap.get(key);
- }
-
- @Override
- public CompletableFuture<Set<K>> keySet() {
- return delegateMap.keySet();
- }
-
- @Override
- public CompletableFuture<Multiset<K>> keys() {
- return delegateMap.keys();
- }
-
- @Override
- public CompletableFuture<Multiset<V>> values() {
- return delegateMap.values();
- }
-
- @Override
- public CompletableFuture<AsyncIterator<Map.Entry<K, V>>> iterator() {
- return delegateMap.iterator();
- }
-
- @Override
- public CompletableFuture<Collection<Map.Entry<K, V>>> entries() {
- return delegateMap.entries();
- }
-
- @Override
- public CompletableFuture<Void> addListener(MultimapEventListener<K, V> listener, Executor executor) {
- return delegateMap.addListener(listener, executor);
- }
-
- @Override
- public CompletableFuture<Void> removeListener(MultimapEventListener<K, V> listener) {
- return delegateMap.removeListener(listener);
- }
-
- @Override
- public CompletableFuture<Map<K, Collection<V>>> asMap() {
- return delegateMap.asMap();
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncConsistentTreeMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncConsistentTreeMap.java
deleted file mode 100644
index b3a1f95..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncConsistentTreeMap.java
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.NavigableMap;
-import java.util.NavigableSet;
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.function.BiFunction;
-import java.util.function.Predicate;
-
-import org.onosproject.store.primitives.MapUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.AsyncConsistentTreeMap;
-import org.onosproject.store.service.AsyncIterator;
-import org.onosproject.store.service.MapEventListener;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.Versioned;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * A {@link AsyncConsistentTreeMap} that delegates control to another instance
- * of {@link AsyncConsistentTreeMap}.
- */
-public class DelegatingAsyncConsistentTreeMap<V>
- extends DelegatingDistributedPrimitive implements AsyncConsistentTreeMap<V> {
-
- private final AsyncConsistentTreeMap<V> delegateMap;
-
- DelegatingAsyncConsistentTreeMap(AsyncConsistentTreeMap<V> delegateMap) {
- super(delegateMap);
- this.delegateMap = checkNotNull(delegateMap,
- "delegate map cannot be null");
- }
-
- @Override
- public CompletableFuture<String> firstKey() {
- return delegateMap.firstKey();
- }
-
- @Override
- public CompletableFuture<String> lastKey() {
- return delegateMap.lastKey();
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V>>> ceilingEntry(String key) {
- return delegateMap.ceilingEntry(key);
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V>>> floorEntry(String key) {
- return delegateMap.floorEntry(key);
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V>>> higherEntry(String key) {
- return delegateMap.higherEntry(key);
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V>>> lowerEntry(String key) {
- return delegateMap.lowerEntry(key);
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V>>> firstEntry() {
- return delegateMap.firstEntry();
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V>>> lastEntry() {
- return delegateMap.lastEntry();
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V>>> pollFirstEntry() {
- return delegateMap.pollFirstEntry();
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V>>> pollLastEntry() {
- return delegateMap.pollLastEntry();
- }
-
- @Override
- public CompletableFuture<String> lowerKey(String key) {
- return delegateMap.lowerKey(key);
- }
-
- @Override
- public CompletableFuture<String> floorKey(String key) {
- return delegateMap.floorKey(key);
- }
-
- @Override
- public CompletableFuture<String> ceilingKey(String key) {
- return delegateMap.ceilingKey(key);
- }
-
- @Override
- public CompletableFuture<String> higherKey(String key) {
- return delegateMap.higherKey(key);
- }
-
- @Override
- public CompletableFuture<NavigableSet<String>> navigableKeySet() {
- return delegateMap.navigableKeySet();
- }
-
- @Override
- public CompletableFuture<NavigableMap<String, V>> subMap(
- String upperKey,
- String lowerKey,
- boolean inclusiveUpper,
- boolean inclusiveLower) {
- return delegateMap.subMap(upperKey, lowerKey,
- inclusiveUpper, inclusiveLower);
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- return delegateMap.size();
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(String key) {
- return delegateMap.containsKey(key);
- }
-
- @Override
- public CompletableFuture<Boolean> containsValue(V value) {
- return delegateMap.containsValue(value);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> get(String key) {
- return delegateMap.get(key);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> getOrDefault(String key, V defaultValue) {
- return delegateMap.getOrDefault(key, defaultValue);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> computeIf(
- String key,
- Predicate<? super V> condition,
- BiFunction<? super String, ? super V,
- ? extends V> remappingFunction) {
- return delegateMap.computeIf(key, condition, remappingFunction);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> put(String key, V value) {
- return delegateMap.put(key, value);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putAndGet(String key, V value) {
- return delegateMap.putAndGet(key, value);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> remove(String key) {
- return delegateMap.remove(key);
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return delegateMap.clear();
- }
-
- @Override
- public CompletableFuture<Set<String>> keySet() {
- return delegateMap.keySet();
- }
-
- @Override
- public CompletableFuture<Collection<Versioned<V>>> values() {
- return delegateMap.values();
- }
-
- @Override
- public CompletableFuture<Set<Map.Entry<String, Versioned<V>>>> entrySet() {
- return delegateMap.entrySet();
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putIfAbsent(String key, V value) {
- return delegateMap.putIfAbsent(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> remove(String key, V value) {
- return delegateMap.remove(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> remove(String key, long version) {
- return delegateMap.remove(key, version);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> replace(String key, V value) {
- return delegateMap.replace(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(String key, V oldValue,
- V newValue) {
- return delegateMap.replace(key, oldValue, newValue);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(String key, long oldVersion,
- V newValue) {
- return delegateMap.replace(key, oldVersion, newValue);
- }
-
- @Override
- public CompletableFuture<AsyncIterator<Map.Entry<String, Versioned<V>>>> iterator() {
- return delegateMap.iterator();
- }
-
- @Override
- public CompletableFuture<Void> addListener(
- MapEventListener<String, V> listener, Executor executor) {
- return delegateMap.addListener(listener, executor);
- }
-
- @Override
- public CompletableFuture<Void> removeListener(
- MapEventListener<String, V> listener) {
- return delegateMap.removeListener(listener);
- }
-
- @Override
- public CompletableFuture<Version> begin(TransactionId transactionId) {
- return delegateMap.begin(transactionId);
- }
-
- @Override
- public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<String, V>> transactionLog) {
- return delegateMap.prepare(transactionLog);
- }
-
- @Override
- public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<String, V>> transactionLog) {
- return delegateMap.prepareAndCommit(transactionLog);
- }
-
- @Override
- public CompletableFuture<Void> commit(TransactionId transactionId) {
- return delegateMap.commit(transactionId);
- }
-
- @Override
- public CompletableFuture<Void> rollback(TransactionId transactionId) {
- return delegateMap.rollback(transactionId);
- }
-
- @Override
- public boolean equals(Object other) {
- if (other instanceof DelegatingAsyncConsistentTreeMap) {
- DelegatingAsyncConsistentTreeMap<V> that =
- (DelegatingAsyncConsistentTreeMap) other;
- return this.delegateMap.equals(that.delegateMap);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(delegateMap);
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncDocumentTree.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncDocumentTree.java
deleted file mode 100644
index 6182c48..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncDocumentTree.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.CompletableFuture;
-
-import com.google.common.base.MoreObjects;
-import org.onosproject.store.primitives.NodeUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.AsyncDocumentTree;
-import org.onosproject.store.service.DocumentPath;
-import org.onosproject.store.service.DocumentTreeListener;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.Versioned;
-
-/**
- * Document tree that delegates to an underlying instance.
- */
-public class DelegatingAsyncDocumentTree<V> extends DelegatingDistributedPrimitive implements AsyncDocumentTree<V> {
- private final AsyncDocumentTree<V> delegateTree;
-
- public DelegatingAsyncDocumentTree(AsyncDocumentTree<V> delegateTree) {
- super(delegateTree);
- this.delegateTree = delegateTree;
- }
-
- @Override
- public DocumentPath root() {
- return delegateTree.root();
- }
-
- @Override
- public CompletableFuture<Map<String, Versioned<V>>> getChildren(DocumentPath path) {
- return delegateTree.getChildren(path);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> get(DocumentPath path) {
- return delegateTree.get(path);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> set(DocumentPath path, V value) {
- return delegateTree.set(path, value);
- }
-
- @Override
- public CompletableFuture<Boolean> create(DocumentPath path, V value) {
- return delegateTree.create(path, value);
- }
-
- @Override
- public CompletableFuture<Boolean> createRecursive(DocumentPath path, V value) {
- return delegateTree.createRecursive(path, value);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(DocumentPath path, V newValue, long version) {
- return delegateTree.replace(path, newValue, version);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(DocumentPath path, V newValue, V currentValue) {
- return delegateTree.replace(path, newValue, currentValue);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> removeNode(DocumentPath path) {
- return delegateTree.removeNode(path);
- }
-
- @Override
- public CompletableFuture<Void> addListener(DocumentPath path, DocumentTreeListener<V> listener) {
- return delegateTree.addListener(path, listener);
- }
-
- @Override
- public CompletableFuture<Void> removeListener(DocumentTreeListener<V> listener) {
- return delegateTree.removeListener(listener);
- }
-
- @Override
- public CompletableFuture<Version> begin(TransactionId transactionId) {
- return delegateTree.begin(transactionId);
- }
-
- @Override
- public CompletableFuture<Boolean> prepare(TransactionLog<NodeUpdate<V>> transactionLog) {
- return delegateTree.prepare(transactionLog);
- }
-
- @Override
- public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<NodeUpdate<V>> transactionLog) {
- return delegateTree.prepareAndCommit(transactionLog);
- }
-
- @Override
- public CompletableFuture<Void> commit(TransactionId transactionId) {
- return delegateTree.commit(transactionId);
- }
-
- @Override
- public CompletableFuture<Void> rollback(TransactionId transactionId) {
- return delegateTree.rollback(transactionId);
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("delegateTree", delegateTree)
- .toString();
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(delegateTree);
- }
-
- @Override
- public boolean equals(Object other) {
- if (other instanceof DelegatingAsyncDocumentTree) {
- DelegatingAsyncDocumentTree<V> that = (DelegatingAsyncDocumentTree) other;
- return this.delegateTree.equals(that.delegateTree);
- }
- return false;
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncLeaderElector.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncLeaderElector.java
deleted file mode 100644
index 0235616..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingAsyncLeaderElector.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Map;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
-
-import org.onosproject.cluster.Leadership;
-import org.onosproject.cluster.NodeId;
-import org.onosproject.event.Change;
-import org.onosproject.store.service.AsyncLeaderElector;
-
-/**
- * Delegating leader elector.
- */
-public class DelegatingAsyncLeaderElector extends DelegatingDistributedPrimitive implements AsyncLeaderElector {
-
- private final AsyncLeaderElector delegateLeaderElector;
-
- public DelegatingAsyncLeaderElector(AsyncLeaderElector delegateLeaderElector) {
- super(delegateLeaderElector);
- this.delegateLeaderElector = delegateLeaderElector;
- }
-
- @Override
- public CompletableFuture<Leadership> run(String topic, NodeId nodeId) {
- return delegateLeaderElector.run(topic, nodeId);
- }
-
- @Override
- public CompletableFuture<Void> withdraw(String topic) {
- return delegateLeaderElector.withdraw(topic);
- }
-
- @Override
- public CompletableFuture<Boolean> anoint(String topic, NodeId nodeId) {
- return delegateLeaderElector.anoint(topic, nodeId);
- }
-
- @Override
- public CompletableFuture<Void> evict(NodeId nodeId) {
- return delegateLeaderElector.evict(nodeId);
- }
-
- @Override
- public CompletableFuture<Boolean> promote(String topic, NodeId nodeId) {
- return delegateLeaderElector.promote(topic, nodeId);
- }
-
- @Override
- public CompletableFuture<Leadership> getLeadership(String topic) {
- return delegateLeaderElector.getLeadership(topic);
- }
-
- @Override
- public CompletableFuture<Map<String, Leadership>> getLeaderships() {
- return delegateLeaderElector.getLeaderships();
- }
-
- @Override
- public CompletableFuture<Void> addChangeListener(Consumer<Change<Leadership>> consumer) {
- return delegateLeaderElector.addChangeListener(consumer);
- }
-
- @Override
- public CompletableFuture<Void> removeChangeListener(Consumer<Change<Leadership>> consumer) {
- return delegateLeaderElector.removeChangeListener(consumer);
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingDistributedPrimitive.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingDistributedPrimitive.java
deleted file mode 100644
index ff6876f..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DelegatingDistributedPrimitive.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.Objects;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
-
-import com.google.common.base.MoreObjects;
-import org.onosproject.core.ApplicationId;
-import org.onosproject.store.service.DistributedPrimitive;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * Base class for primitive delegates.
- */
-public abstract class DelegatingDistributedPrimitive implements DistributedPrimitive {
- private final DistributedPrimitive primitive;
-
- public DelegatingDistributedPrimitive(DistributedPrimitive primitive) {
- this.primitive = checkNotNull(primitive);
- }
-
- @Override
- public String name() {
- return primitive.name();
- }
-
- @Override
- public Type primitiveType() {
- return primitive.primitiveType();
- }
-
- @Override
- public ApplicationId applicationId() {
- return primitive.applicationId();
- }
-
- @Override
- public CompletableFuture<Void> destroy() {
- return primitive.destroy();
- }
-
- @Override
- public void addStatusChangeListener(Consumer<Status> listener) {
- primitive.addStatusChangeListener(listener);
- }
-
- @Override
- public void removeStatusChangeListener(Consumer<Status> listener) {
- primitive.removeStatusChangeListener(listener);
- }
-
- @Override
- public Collection<Consumer<Status>> statusChangeListeners() {
- return primitive.statusChangeListeners();
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("delegate", primitive)
- .toString();
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(primitive);
- }
-
- @Override
- public boolean equals(Object other) {
- return other instanceof DelegatingDistributedPrimitive
- && primitive.equals(((DelegatingDistributedPrimitive) other).primitive);
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DistributedPrimitives.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DistributedPrimitives.java
deleted file mode 100644
index 9b209ba..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DistributedPrimitives.java
+++ /dev/null
@@ -1,267 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.function.BiFunction;
-import java.util.function.Function;
-
-import org.onosproject.core.Version;
-import org.onosproject.store.service.AsyncAtomicCounterMap;
-import org.onosproject.store.service.AsyncAtomicValue;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.AsyncConsistentMultimap;
-import org.onosproject.store.service.AsyncConsistentTreeMap;
-import org.onosproject.store.service.AsyncDistributedSet;
-import org.onosproject.store.service.AsyncDocumentTree;
-
-/**
- * Misc utilities for working with {@code DistributedPrimitive}s.
- */
-public final class DistributedPrimitives {
-
- private DistributedPrimitives() {}
-
- /**
- * Creates an instance of {@code AsyncDistributedSet} that is backed by a {@code AsyncConsistentMap}.
- *
- * @param map backing map
- * @return set
- * @param <E> set element type
- */
- public static <E> AsyncDistributedSet<E> newSetFromMap(AsyncConsistentMap<E, Boolean> map) {
- return new DefaultAsyncDistributedSet<>(map, map.name(), true);
- }
-
- /**
- * Creates an instance of {@code AsyncConsistentMap} that records metrics for all its operations.
- *
- * @param map map whose operations are to be metered
- * @return metered map
- * @param <K> map key type
- * @param <V> map value type
- */
- public static <K, V> AsyncConsistentMap<K, V> newMeteredMap(AsyncConsistentMap<K, V> map) {
- return new MeteredAsyncConsistentMap<>(map);
- }
-
- /**
- * Creates an instance of {@code AsyncConsistentMap} that caches entries on get.
- *
- * @param map backing map
- * @return caching map
- * @param <K> map key type
- * @param <V> map value type
- */
- public static <K, V> AsyncConsistentMap<K, V> newCachingMap(AsyncConsistentMap<K, V> map) {
- return new CachingAsyncConsistentMap<>(map);
- }
-
- /**
- * Creates an instance of {@code AsyncConsistentMap} that disallows updates.
- *
- * @param map backing map
- * @return unmodifiable map
- * @param <K> map key type
- * @param <V> map value type
- */
- public static <K, V> AsyncConsistentMap<K, V> newUnmodifiableMap(AsyncConsistentMap<K, V> map) {
- return new UnmodifiableAsyncConsistentMap<>(map);
- }
-
- /**
- * Creates an instance of {@code AsyncConsistentMap} that disallows null values.
- *
- * @param map backing map
- * @return not null map
- * @param <K> map key type
- * @param <V> map value type
- */
- public static <K, V> AsyncConsistentMap<K, V> newNotNullMap(AsyncConsistentMap<K, V> map) {
- return new NotNullAsyncConsistentMap<>(map);
- }
-
- /**
- * Creates an instance of {@code AsyncConsistentMap} that converts values from other versions.
- *
- * @param map backing map
- * @param compatibilityFunction the compatibility function
- * @param version local node version
- * @param <K> map key type
- * @param <V> map value type
- * @return compatible map
- */
- public static <K, V> AsyncConsistentMap<K, V> newCompatibleMap(
- AsyncConsistentMap<K, CompatibleValue<V>> map,
- BiFunction<V, Version, V> compatibilityFunction,
- Version version) {
- Function<V, CompatibleValue<V>> encoder = value -> new CompatibleValue<>(value, version);
- Function<CompatibleValue<V>, V> decoder = value -> {
- if (!value.version().equals(version)) {
- return compatibilityFunction.apply(value.value(), value.version());
- }
- return value.value();
- };
- return new TranscodingAsyncConsistentMap<>(map, k -> k, k -> k, encoder, decoder);
- }
-
- /**
- * Creates an instance of {@code AsyncAtomicValue} that transforms value types.
- *
- * @param value backing value
- * @param valueEncoder transformer for value type of returned value to value type of input value
- * @param valueDecoder transformer for value type of input value to value type of returned value
- * @param <V1> returned value type
- * @param <V2> input value type
- * @return new counter map
- */
- public static <V1, V2> AsyncAtomicValue<V1> newTranscodingAtomicValue(AsyncAtomicValue<V2> value,
- Function<V1, V2> valueEncoder,
- Function<V2, V1> valueDecoder) {
- return new TranscodingAsyncAtomicValue<>(value, valueEncoder, valueDecoder);
- }
-
- /**
- * Creates an instance of {@code AsyncAtomicValue} that converts values from other versions.
- *
- * @param atomicValue backing value
- * @param compatibilityFunction the compatibility function
- * @param version local node version
- * @param <V> value type
- * @return compatible map
- */
- public static <V> AsyncAtomicValue<V> newCompatibleAtomicValue(
- AsyncAtomicValue<CompatibleValue<V>> atomicValue,
- BiFunction<V, Version, V> compatibilityFunction,
- Version version) {
- Function<V, CompatibleValue<V>> encoder = value -> new CompatibleValue<>(value, version);
- Function<CompatibleValue<V>, V> decoder = value -> {
- if (!value.version().equals(version)) {
- return compatibilityFunction.apply(value.value(), value.version());
- }
- return value.value();
- };
- return new TranscodingAsyncAtomicValue<>(atomicValue, encoder, decoder);
- }
-
- /**
- * Creates an instance of {@code AsyncAtomicCounterMap} that transforms key types.
- *
- * @param map backing map
- * @param keyEncoder transformer for key type of returned map to key type of input map
- * @param keyDecoder transformer for key type of input map to key type of returned map
- * @param <K1> returned map key type
- * @param <K2> input map key type
- * @return new counter map
- */
- public static <K1, K2> AsyncAtomicCounterMap<K1> newTranscodingAtomicCounterMap(AsyncAtomicCounterMap<K2> map,
- Function<K1, K2> keyEncoder,
- Function<K2, K1> keyDecoder) {
- return new TranscodingAsyncAtomicCounterMap<>(map, keyEncoder, keyDecoder);
- }
-
- /**
- * Creates an instance of {@code AsyncConsistentMap} that transforms operations inputs and applies them
- * to corresponding operation in a different typed map and returns the output after reverse transforming it.
- *
- * @param map backing map
- * @param keyEncoder transformer for key type of returned map to key type of input map
- * @param keyDecoder transformer for key type of input map to key type of returned map
- * @param valueEncoder transformer for value type of returned map to value type of input map
- * @param valueDecoder transformer for value type of input map to value type of returned map
- * @param <K1> returned map key type
- * @param <K2> input map key type
- * @param <V1> returned map value type
- * @param <V2> input map key type
- * @return new map
- */
- public static <K1, V1, K2, V2> AsyncConsistentMap<K1, V1> newTranscodingMap(AsyncConsistentMap<K2, V2> map,
- Function<K1, K2> keyEncoder,
- Function<K2, K1> keyDecoder,
- Function<V1, V2> valueEncoder,
- Function<V2, V1> valueDecoder) {
- return new TranscodingAsyncConsistentMap<K1, V1, K2, V2>(map,
- keyEncoder,
- keyDecoder,
- valueEncoder,
- valueDecoder);
- }
-
- /**
- * Creates an instance of {@code DistributedTreeMap} that transforms operations inputs and applies them
- * to corresponding operation in a different typed map and returns the output after reverse transforming it.
- *
- * @param map backing map
- * @param valueEncoder transformer for value type of returned map to value type of input map
- * @param valueDecoder transformer for value type of input map to value type of returned map
- * @param <V1> returned map value type
- * @param <V2> input map key type
- * @return new map
- */
- public static <V1, V2> AsyncConsistentTreeMap<V1> newTranscodingTreeMap(
- AsyncConsistentTreeMap<V2> map,
- Function<V1, V2> valueEncoder,
- Function<V2, V1> valueDecoder) {
- return new TranscodingAsyncConsistentTreeMap<>(map,
- valueEncoder,
- valueDecoder);
- }
-
- /**
- * Creates an instance of {@code AsyncConsistentMultimap} that transforms
- * operations inputs and applies them to corresponding operation in a
- * differently typed map and returns the output after reverse transforming
- * it.
- *
- * @param multimap backing multimap
- * @param keyEncoder transformer for key type of returned map to key type
- * of input map
- * @param keyDecoder transformer for key type of input map to key type of
- * returned map
- * @param valueEncoder transformer for value type of returned map to value
- * type of input map
- * @param valueDecoder transformer for value type of input map to value
- * type of returned map
- * @param <K1> returned map key type
- * @param <K2> input map key type
- * @param <V1> returned map value type
- * @param <V2> input map key type
- * @return new map
- */
- public static <K1, V1, K2, V2> AsyncConsistentMultimap<K1, V1>
- newTranscodingMultimap(AsyncConsistentMultimap<K2, V2> multimap,
- Function<K1, K2> keyEncoder,
- Function<K2, K1> keyDecoder,
- Function<V1, V2> valueEncoder,
- Function<V2, V1> valueDecoder) {
- return new TranscodingAsyncConsistentMultimap<>(multimap,
- keyEncoder,
- keyDecoder,
- valueDecoder,
- valueEncoder);
- }
-
- /**
- * Creates an instance of {@code AsyncDocumentTree} that caches values on get.
- *
- * @param tree backing tree
- * @return caching tree
- * @param <V> tree value type
- */
- public static <V> AsyncDocumentTree<V> newCachingDocumentTree(AsyncDocumentTree<V> tree) {
- return new CachingAsyncDocumentTree<V>(tree);
- }
-
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/EventuallyConsistentMapBuilderImpl.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/EventuallyConsistentMapBuilderImpl.java
index df35bd6..da00555 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/EventuallyConsistentMapBuilderImpl.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/EventuallyConsistentMapBuilderImpl.java
@@ -15,14 +15,6 @@
*/
package org.onosproject.store.primitives.impl;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.cluster.NodeId;
-import org.onosproject.persistence.PersistenceService;
-import org.onosproject.store.Timestamp;
-import org.onosproject.store.cluster.messaging.ClusterCommunicationService;
-import org.onosproject.store.service.EventuallyConsistentMap;
-import org.onosproject.store.service.EventuallyConsistentMapBuilder;
-
import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutorService;
@@ -31,6 +23,14 @@
import java.util.function.BiFunction;
import java.util.function.Supplier;
+import org.onlab.util.KryoNamespace;
+import org.onosproject.cluster.NodeId;
+import org.onosproject.persistence.PersistenceService;
+import org.onosproject.store.Timestamp;
+import org.onosproject.store.cluster.messaging.ClusterCommunicationService;
+import org.onosproject.store.service.EventuallyConsistentMap;
+import org.onosproject.store.service.EventuallyConsistentMapBuilder;
+
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/EventuallyConsistentMapImpl.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/EventuallyConsistentMapImpl.java
index 74e567b..762689c 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/EventuallyConsistentMapImpl.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/EventuallyConsistentMapImpl.java
@@ -15,6 +15,31 @@
*/
package org.onosproject.store.primitives.impl;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.Timer;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
@@ -42,31 +67,6 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-import java.util.Timer;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static java.util.concurrent.Executors.newSingleThreadScheduledExecutor;
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/FederatedDistributedPrimitiveCreator.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/FederatedDistributedPrimitiveCreator.java
deleted file mode 100644
index 3fe721f..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/FederatedDistributedPrimitiveCreator.java
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.function.Function;
-
-import com.google.common.base.Charsets;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import com.google.common.hash.Funnel;
-import com.google.common.hash.Funnels;
-import com.google.common.hash.Hashing;
-import org.onlab.util.HexString;
-import org.onosproject.cluster.PartitionId;
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
-import org.onosproject.store.service.AsyncAtomicCounter;
-import org.onosproject.store.service.AsyncAtomicCounterMap;
-import org.onosproject.store.service.AsyncAtomicIdGenerator;
-import org.onosproject.store.service.AsyncAtomicValue;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.AsyncConsistentMultimap;
-import org.onosproject.store.service.AsyncConsistentTreeMap;
-import org.onosproject.store.service.AsyncDistributedLock;
-import org.onosproject.store.service.AsyncDistributedSet;
-import org.onosproject.store.service.AsyncDocumentTree;
-import org.onosproject.store.service.AsyncLeaderElector;
-import org.onosproject.store.service.AtomicCounterMapOptions;
-import org.onosproject.store.service.AtomicCounterOptions;
-import org.onosproject.store.service.AtomicIdGeneratorOptions;
-import org.onosproject.store.service.AtomicValueOptions;
-import org.onosproject.store.service.ConsistentMapOptions;
-import org.onosproject.store.service.ConsistentMultimapOptions;
-import org.onosproject.store.service.ConsistentTreeMapOptions;
-import org.onosproject.store.service.DistributedLockOptions;
-import org.onosproject.store.service.DistributedSetOptions;
-import org.onosproject.store.service.DocumentPath;
-import org.onosproject.store.service.DocumentTreeOptions;
-import org.onosproject.store.service.LeaderElectorOptions;
-import org.onosproject.store.service.WorkQueue;
-import org.onosproject.store.service.WorkQueueOptions;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * {@code DistributedPrimitiveCreator} that federates responsibility for creating
- * distributed primitives to a collection of other {@link DistributedPrimitiveCreator creators}.
- */
-public class FederatedDistributedPrimitiveCreator implements DistributedPrimitiveCreator {
-
- private static final Funnel<Iterable<? extends CharSequence>> STR_LIST_FUNNEL =
- Funnels.sequentialFunnel(Funnels.unencodedCharsFunnel());
-
- private final TreeMap<PartitionId, DistributedPrimitiveCreator> members;
- private final List<PartitionId> sortedMemberPartitionIds;
- private final int buckets;
-
- public FederatedDistributedPrimitiveCreator(Map<PartitionId, DistributedPrimitiveCreator> members, int buckets) {
- this.members = Maps.newTreeMap();
- this.members.putAll(checkNotNull(members));
- this.sortedMemberPartitionIds = Lists.newArrayList(members.keySet());
- this.buckets = buckets;
- }
-
- @Override
- public <K, V> AsyncConsistentMap<K, V> newAsyncConsistentMap(ConsistentMapOptions options) {
- Map<PartitionId, AsyncConsistentMap<byte[], byte[]>> maps =
- Maps.transformValues(members,
- partition -> DistributedPrimitives.newTranscodingMap(
- partition.<String, byte[]>newAsyncConsistentMap(options.name(), null),
- HexString::toHexString,
- HexString::fromHexString,
- Function.identity(),
- Function.identity()));
- Hasher<byte[]> hasher = key -> {
- int bucket = Math.abs(Hashing.murmur3_32().hashBytes(key).asInt()) % buckets;
- return sortedMemberPartitionIds.get(Hashing.consistentHash(bucket, sortedMemberPartitionIds.size()));
- };
- AsyncConsistentMap<byte[], byte[]> partitionedMap =
- new PartitionedAsyncConsistentMap<>(options.name(), maps, hasher);
- return DistributedPrimitives.newTranscodingMap(partitionedMap,
- key -> options.serializer().encode(key),
- bytes -> options.serializer().decode(bytes),
- value -> value == null ? null : options.serializer().encode(value),
- bytes -> options.serializer().decode(bytes));
- }
-
- @Override
- public <V> AsyncConsistentTreeMap<V> newAsyncConsistentTreeMap(ConsistentTreeMapOptions options) {
- return getCreator(options.name()).newAsyncConsistentTreeMap(options.name(), options.serializer());
- }
-
- @Override
- public <K, V> AsyncConsistentMultimap<K, V> newAsyncConsistentSetMultimap(ConsistentMultimapOptions options) {
- Map<PartitionId, AsyncConsistentMultimap<byte[], byte[]>> maps =
- Maps.transformValues(members,
- partition -> DistributedPrimitives.newTranscodingMultimap(
- partition.<String, byte[]>newAsyncConsistentSetMultimap(options.name(), null),
- HexString::toHexString,
- HexString::fromHexString,
- Function.identity(),
- Function.identity()));
- Hasher<byte[]> hasher = key -> {
- int bucket = Math.abs(Hashing.murmur3_32().hashBytes(key).asInt()) % buckets;
- return sortedMemberPartitionIds.get(Hashing.consistentHash(bucket, sortedMemberPartitionIds.size()));
- };
- AsyncConsistentMultimap<byte[], byte[]> partitionedMap =
- new PartitionedAsyncConsistentMultimap<>(options.name(), maps, hasher);
- return DistributedPrimitives.newTranscodingMultimap(partitionedMap,
- key -> options.serializer().encode(key),
- bytes -> options.serializer().decode(bytes),
- value -> value == null ? null : options.serializer().encode(value),
- bytes -> options.serializer().decode(bytes));
- }
-
- @Override
- public <E> AsyncDistributedSet<E> newAsyncDistributedSet(DistributedSetOptions options) {
- return DistributedPrimitives.newSetFromMap(newAsyncConsistentMap(options.name(), options.serializer()));
- }
-
- @Override
- public <K> AsyncAtomicCounterMap<K> newAsyncAtomicCounterMap(AtomicCounterMapOptions options) {
- return getCreator(options.name()).newAsyncAtomicCounterMap(options);
- }
-
- @Override
- public AsyncAtomicCounter newAsyncCounter(AtomicCounterOptions options) {
- return getCreator(options.name()).newAsyncCounter(options);
- }
-
- @Override
- public AsyncAtomicIdGenerator newAsyncIdGenerator(AtomicIdGeneratorOptions options) {
- return getCreator(options.name()).newAsyncIdGenerator(options);
- }
-
- @Override
- public <V> AsyncAtomicValue<V> newAsyncAtomicValue(AtomicValueOptions options) {
- return getCreator(options.name()).newAsyncAtomicValue(options);
- }
-
- @Override
- public AsyncDistributedLock newAsyncDistributedLock(DistributedLockOptions options) {
- return getCreator(options.name()).newAsyncDistributedLock(options);
- }
-
- @Override
- public AsyncLeaderElector newAsyncLeaderElector(LeaderElectorOptions options) {
- Map<PartitionId, AsyncLeaderElector> leaderElectors =
- Maps.transformValues(members,
- partition -> partition.newAsyncLeaderElector(options));
- Hasher<String> hasher = topic -> {
- int hashCode = Hashing.sha256().hashString(topic, Charsets.UTF_8).asInt();
- return sortedMemberPartitionIds.get(Math.abs(hashCode) % members.size());
- };
- return new PartitionedAsyncLeaderElector(options.name(), leaderElectors, hasher);
- }
-
- @Override
- public <E> WorkQueue<E> newWorkQueue(WorkQueueOptions options) {
- return getCreator(options.name()).newWorkQueue(options);
- }
-
- @Override
- public <V> AsyncDocumentTree<V> newAsyncDocumentTree(DocumentTreeOptions options) {
- Map<PartitionId, AsyncDocumentTree<V>> trees =
- Maps.transformValues(members, part -> part.<V>newAsyncDocumentTree(options));
- Hasher<DocumentPath> hasher = key -> {
- int bucket = (key == null) ? 0 :
- Math.abs(Hashing.murmur3_32()
- .hashObject(key.pathElements(), STR_LIST_FUNNEL)
- .asInt()) % buckets;
- return sortedMemberPartitionIds.get(Hashing.consistentHash(bucket, sortedMemberPartitionIds.size()));
- };
- return new PartitionedAsyncDocumentTree<>(options.name(), trees, hasher);
- }
-
- @Override
- public Set<String> getAsyncConsistentMapNames() {
- return members.values()
- .stream()
- .map(DistributedPrimitiveCreator::getAsyncConsistentMapNames)
- .reduce(Sets::union)
- .orElse(ImmutableSet.of());
- }
-
- @Override
- public Set<String> getAsyncAtomicCounterNames() {
- return members.values()
- .stream()
- .map(DistributedPrimitiveCreator::getAsyncAtomicCounterNames)
- .reduce(Sets::union)
- .orElse(ImmutableSet.of());
- }
-
- @Override
- public Set<String> getWorkQueueNames() {
- return members.values()
- .stream()
- .map(DistributedPrimitiveCreator::getWorkQueueNames)
- .reduce(Sets::union)
- .orElse(ImmutableSet.of());
- }
-
- /**
- * Returns the {@code DistributedPrimitiveCreator} to use for hosting a primitive.
- * @param name primitive name
- * @return primitive creator
- */
- private DistributedPrimitiveCreator getCreator(String name) {
- int hashCode = Hashing.sha256().hashString(name, Charsets.UTF_8).asInt();
- return members.get(sortedMemberPartitionIds.get(Math.abs(hashCode) % members.size()));
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/Hasher.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/Hasher.java
deleted file mode 100644
index 5714e33..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/Hasher.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.cluster.PartitionId;
-
-/**
- * Interface for mapping from an object to {@link PartitionId}.
- *
- * @param <K> object type.
- */
-public interface Hasher<K> {
- /**
- * Returns the {@link PartitionId} to which the specified object maps.
- * @param object object
- * @return partition identifier
- */
- PartitionId hash(K object);
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/Managed.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/Managed.java
deleted file mode 100644
index 1d5977f..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/Managed.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.concurrent.CompletableFuture;
-
-/**
- * Interface for types that can be asynchronously opened and closed.
- */
-public interface Managed<T> {
-
- /**
- * Opens the managed object.
- *
- * @return A completable future to be completed once the object has been opened.
- */
- CompletableFuture<Void> open();
-
- /**
- * Closes the managed object.
- *
- * @return A completable future to be completed once the object has been closed.
- */
- CompletableFuture<Void> close();
-
- /**
- * Return {@code true} if the managed object is open.
- * @return {@code true} if open
- */
- boolean isOpen();
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/MapValue.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/MapValue.java
index 1c6845d..3175963 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/MapValue.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/MapValue.java
@@ -15,10 +15,9 @@
*/
package org.onosproject.store.primitives.impl;
-import org.onosproject.store.Timestamp;
-
import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
+import org.onosproject.store.Timestamp;
import static com.google.common.base.Preconditions.checkNotNull;
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/MeteredAsyncConsistentMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/MeteredAsyncConsistentMap.java
deleted file mode 100644
index de53121..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/MeteredAsyncConsistentMap.java
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import com.google.common.collect.Maps;
-import org.onosproject.store.primitives.MapUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.MapEvent;
-import org.onosproject.store.service.MapEventListener;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.Versioned;
-import org.onosproject.utils.MeteringAgent;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.Predicate;
-
-/**
- * {@link AsyncConsistentMap} that meters all its operations.
- *
- * @param <K> key type
- * @param <V> value type
- */
-public class MeteredAsyncConsistentMap<K, V> extends DelegatingAsyncConsistentMap<K, V> {
-
- private static final String PRIMITIVE_NAME = "consistentMap";
- private static final String SIZE = "size";
- private static final String IS_EMPTY = "isEmpty";
- private static final String CONTAINS_KEY = "containsKey";
- private static final String CONTAINS_VALUE = "containsValue";
- private static final String GET = "get";
- private static final String GET_OR_DEFAULT = "getOrDefault";
- private static final String COMPUTE_IF = "computeIf";
- private static final String PUT = "put";
- private static final String PUT_AND_GET = "putAndGet";
- private static final String PUT_IF_ABSENT = "putIfAbsent";
- private static final String REMOVE = "remove";
- private static final String CLEAR = "clear";
- private static final String KEY_SET = "keySet";
- private static final String VALUES = "values";
- private static final String ENTRY_SET = "entrySet";
- private static final String REPLACE = "replace";
- private static final String COMPUTE_IF_ABSENT = "computeIfAbsent";
- private static final String BEGIN = "begin";
- private static final String PREPARE = "prepare";
- private static final String COMMIT = "commit";
- private static final String ROLLBACK = "rollback";
- private static final String PREPARE_AND_COMMIT = "prepareAndCommit";
- private static final String ADD_LISTENER = "addListener";
- private static final String REMOVE_LISTENER = "removeListener";
- private static final String NOTIFY_LISTENER = "notifyListener";
-
- private final Map<MapEventListener<K, V>, InternalMeteredMapEventListener> listeners =
- Maps.newIdentityHashMap();
- private final MeteringAgent monitor;
-
- public MeteredAsyncConsistentMap(AsyncConsistentMap<K, V> backingMap) {
- super(backingMap);
- this.monitor = new MeteringAgent(PRIMITIVE_NAME, backingMap.name(), true);
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- final MeteringAgent.Context timer = monitor.startTimer(SIZE);
- return super.size()
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Boolean> isEmpty() {
- final MeteringAgent.Context timer = monitor.startTimer(IS_EMPTY);
- return super.isEmpty()
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(K key) {
- final MeteringAgent.Context timer = monitor.startTimer(CONTAINS_KEY);
- return super.containsKey(key)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Boolean> containsValue(V value) {
- final MeteringAgent.Context timer = monitor.startTimer(CONTAINS_VALUE);
- return super.containsValue(value)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> get(K key) {
- final MeteringAgent.Context timer = monitor.startTimer(GET);
- return super.get(key)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> getOrDefault(K key, V defaultValue) {
- final MeteringAgent.Context timer = monitor.startTimer(GET_OR_DEFAULT);
- return super.getOrDefault(key, defaultValue)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> computeIfAbsent(K key,
- Function<? super K, ? extends V> mappingFunction) {
- final MeteringAgent.Context timer = monitor.startTimer(COMPUTE_IF_ABSENT);
- return super.computeIfAbsent(key, mappingFunction)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> computeIf(K key,
- Predicate<? super V> condition,
- BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
- final MeteringAgent.Context timer = monitor.startTimer(COMPUTE_IF);
- return super.computeIf(key, condition, remappingFunction)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> put(K key, V value) {
- final MeteringAgent.Context timer = monitor.startTimer(PUT);
- return super.put(key, value)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putAndGet(K key, V value) {
- final MeteringAgent.Context timer = monitor.startTimer(PUT_AND_GET);
- return super.putAndGet(key, value)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> remove(K key) {
- final MeteringAgent.Context timer = monitor.startTimer(REMOVE);
- return super.remove(key)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- final MeteringAgent.Context timer = monitor.startTimer(CLEAR);
- return super.clear()
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Set<K>> keySet() {
- final MeteringAgent.Context timer = monitor.startTimer(KEY_SET);
- return super.keySet()
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Collection<Versioned<V>>> values() {
- final MeteringAgent.Context timer = monitor.startTimer(VALUES);
- return super.values()
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Set<Entry<K, Versioned<V>>>> entrySet() {
- final MeteringAgent.Context timer = monitor.startTimer(ENTRY_SET);
- return super.entrySet()
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putIfAbsent(K key, V value) {
- final MeteringAgent.Context timer = monitor.startTimer(PUT_IF_ABSENT);
- return super.putIfAbsent(key, value)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, V value) {
- final MeteringAgent.Context timer = monitor.startTimer(REMOVE);
- return super.remove(key, value)
- .whenComplete((r, e) -> timer.stop(e));
-
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, long version) {
- final MeteringAgent.Context timer = monitor.startTimer(REMOVE);
- return super.remove(key, version)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> replace(K key, V value) {
- final MeteringAgent.Context timer = monitor.startTimer(REPLACE);
- return super.replace(key, value)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K key, V oldValue, V newValue) {
- final MeteringAgent.Context timer = monitor.startTimer(REPLACE);
- return super.replace(key, oldValue, newValue)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K key, long oldVersion, V newValue) {
- final MeteringAgent.Context timer = monitor.startTimer(REPLACE);
- return super.replace(key, oldVersion, newValue)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Void> addListener(MapEventListener<K, V> listener, Executor executor) {
- final MeteringAgent.Context timer = monitor.startTimer(ADD_LISTENER);
- synchronized (listeners) {
- InternalMeteredMapEventListener meteredListener =
- listeners.computeIfAbsent(listener, k -> new InternalMeteredMapEventListener(listener));
- return super.addListener(meteredListener, executor)
- .whenComplete((r, e) -> timer.stop(e));
- }
- }
-
- @Override
- public CompletableFuture<Void> removeListener(MapEventListener<K, V> listener) {
- final MeteringAgent.Context timer = monitor.startTimer(REMOVE_LISTENER);
- InternalMeteredMapEventListener meteredListener = listeners.remove(listener);
- if (meteredListener != null) {
- return super.removeListener(meteredListener)
- .whenComplete((r, e) -> timer.stop(e));
- } else {
- timer.stop(null);
- return CompletableFuture.completedFuture(null);
- }
- }
-
- @Override
- public CompletableFuture<Version> begin(TransactionId transactionId) {
- final MeteringAgent.Context timer = monitor.startTimer(BEGIN);
- return super.begin(transactionId)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<K, V>> transactionLog) {
- final MeteringAgent.Context timer = monitor.startTimer(PREPARE);
- return super.prepare(transactionLog)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Void> commit(TransactionId transactionId) {
- final MeteringAgent.Context timer = monitor.startTimer(COMMIT);
- return super.commit(transactionId)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Void> rollback(TransactionId transactionId) {
- final MeteringAgent.Context timer = monitor.startTimer(ROLLBACK);
- return super.rollback(transactionId)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- @Override
- public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<K, V>> transactionLog) {
- final MeteringAgent.Context timer = monitor.startTimer(PREPARE_AND_COMMIT);
- return super.prepareAndCommit(transactionLog)
- .whenComplete((r, e) -> timer.stop(e));
- }
-
- private class InternalMeteredMapEventListener implements MapEventListener<K, V> {
-
- private final MapEventListener<K, V> listener;
-
- InternalMeteredMapEventListener(MapEventListener<K, V> listener) {
- this.listener = listener;
- }
-
- @Override
- public void event(MapEvent<K, V> event) {
- final MeteringAgent.Context timer = monitor.startTimer(NOTIFY_LISTENER);
- try {
- listener.event(event);
- timer.stop(null);
- } catch (Exception e) {
- timer.stop(e);
- throw new IllegalStateException(e);
- }
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/NotNullAsyncConsistentMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/NotNullAsyncConsistentMap.java
deleted file mode 100644
index 9282cbf..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/NotNullAsyncConsistentMap.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.stream.Collectors;
-
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.Versioned;
-
-/**
- * {@link org.onosproject.store.service.AsyncConsistentMap} that doesn't allow null values.
- */
-public class NotNullAsyncConsistentMap<K, V> extends DelegatingAsyncConsistentMap<K, V> {
- private final AsyncConsistentMap<K, V> delegateMap;
-
- public NotNullAsyncConsistentMap(AsyncConsistentMap<K, V> delegateMap) {
- super(delegateMap);
- this.delegateMap = delegateMap;
- }
-
- @Override
- public CompletableFuture<Boolean> containsValue(V value) {
- if (value == null) {
- return CompletableFuture.completedFuture(false);
- }
- return super.containsValue(value);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> get(K key) {
- return super.get(key).thenApply(v -> v != null && v.value() == null ? null : v);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> getOrDefault(K key, V defaultValue) {
- return super.getOrDefault(key, defaultValue).thenApply(v -> v != null && v.value() == null ? null : v);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> put(K key, V value) {
- if (value == null) {
- return super.remove(key);
- }
- return super.put(key, value);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putAndGet(K key, V value) {
- if (value == null) {
- return super.remove(key).thenApply(v -> null);
- }
- return super.putAndGet(key, value);
- }
-
- @Override
- public CompletableFuture<Collection<Versioned<V>>> values() {
- return super.values().thenApply(value -> value.stream()
- .filter(v -> v.value() != null)
- .collect(Collectors.toList()));
- }
-
- @Override
- public CompletableFuture<Set<Map.Entry<K, Versioned<V>>>> entrySet() {
- return super.entrySet().thenApply(entries -> entries.stream()
- .filter(e -> e.getValue().value() != null)
- .collect(Collectors.toSet()));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putIfAbsent(K key, V value) {
- if (value == null) {
- return super.remove(key);
- }
- return super.putIfAbsent(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, V value) {
- if (value == null) {
- return CompletableFuture.completedFuture(false);
- }
- return super.remove(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, long version) {
- return super.remove(key, version);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> replace(K key, V value) {
- if (value == null) {
- return super.remove(key);
- }
- return super.replace(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K key, V oldValue, V newValue) {
- if (oldValue == null) {
- return super.putIfAbsent(key, newValue).thenApply(Objects::isNull);
- } else if (newValue == null) {
- return super.remove(key, oldValue);
- }
- return super.replace(key, oldValue, newValue);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K key, long oldVersion, V newValue) {
- return super.replace(key, oldVersion, newValue);
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionManager.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionManager.java
index 28cc69e..f9a8ec0 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionManager.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionManager.java
@@ -17,32 +17,22 @@
package org.onosproject.store.primitives.impl;
import java.util.List;
-import java.util.Map;
import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Maps;
+import io.atomix.cluster.MemberId;
+import io.atomix.primitive.partition.PartitionGroup;
+import io.atomix.protocols.raft.MultiRaftProtocol;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.ReferenceCardinality;
import org.apache.felix.scr.annotations.Service;
-import org.onlab.util.Tools;
-import org.onosproject.cluster.ClusterMetadata;
-import org.onosproject.cluster.ClusterMetadataDiff;
-import org.onosproject.cluster.ClusterMetadataEvent;
-import org.onosproject.cluster.ClusterMetadataEventListener;
-import org.onosproject.cluster.ClusterMetadataService;
-import org.onosproject.cluster.ClusterService;
import org.onosproject.cluster.NodeId;
-import org.onosproject.cluster.PartitionDiff;
import org.onosproject.cluster.PartitionId;
import org.onosproject.event.AbstractListenerManager;
-import org.onosproject.store.cluster.messaging.ClusterCommunicationService;
+import org.onosproject.store.impl.AtomixManager;
import org.onosproject.store.primitives.DistributedPrimitiveCreator;
import org.onosproject.store.primitives.PartitionAdminService;
import org.onosproject.store.primitives.PartitionEvent;
@@ -67,74 +57,52 @@
private final Logger log = getLogger(getClass());
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected ClusterCommunicationService clusterCommunicator;
+ protected AtomixManager atomixManager;
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected ClusterMetadataService metadataService;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected ClusterService clusterService;
-
- private final Map<PartitionId, StoragePartition> partitions = Maps.newConcurrentMap();
- private final AtomicReference<ClusterMetadata> currentClusterMetadata = new AtomicReference<>();
-
- private final ClusterMetadataEventListener metadataListener = new InternalClusterMetadataListener();
+ private PartitionGroup partitionGroup;
@Activate
public void activate() {
+ partitionGroup = atomixManager.getAtomix().getPartitionService().getPartitionGroup(MultiRaftProtocol.TYPE);
eventDispatcher.addSink(PartitionEvent.class, listenerRegistry);
- currentClusterMetadata.set(metadataService.getClusterMetadata());
-
- metadataService.addListener(metadataListener);
-
- currentClusterMetadata.get()
- .getPartitions()
- .forEach(partition -> partitions.put(partition.getId(), new StoragePartition(
- partition,
- clusterCommunicator,
- clusterService)));
- CompletableFuture.allOf(partitions.values().stream()
- .map(StoragePartition::open)
- .toArray(CompletableFuture[]::new))
- .join();
log.info("Started");
}
@Deactivate
public void deactivate() {
- metadataService.removeListener(metadataListener);
eventDispatcher.removeSink(PartitionEvent.class);
-
- CompletableFuture.allOf(partitions.values().stream()
- .map(StoragePartition::close)
- .toArray(CompletableFuture[]::new))
- .join();
log.info("Stopped");
}
@Override
public int getNumberOfPartitions() {
checkPermission(PARTITION_READ);
- return partitions.size();
+ return partitionGroup.getPartitions().size();
}
@Override
public Set<PartitionId> getAllPartitionIds() {
checkPermission(PARTITION_READ);
- return partitions.keySet();
+ return partitionGroup.getPartitionIds().stream()
+ .map(partitionId -> PartitionId.from(partitionId.id()))
+ .collect(Collectors.toSet());
}
@Override
public DistributedPrimitiveCreator getDistributedPrimitiveCreator(PartitionId partitionId) {
checkPermission(PARTITION_READ);
- return partitions.get(partitionId).client();
+ throw new UnsupportedOperationException();
}
@Override
public Set<NodeId> getConfiguredMembers(PartitionId partitionId) {
checkPermission(PARTITION_READ);
- StoragePartition partition = partitions.get(partitionId);
- return ImmutableSet.copyOf(partition.getMembers());
+ io.atomix.primitive.partition.PartitionId atomixPartitionId =
+ io.atomix.primitive.partition.PartitionId.from(partitionGroup.name(), partitionId.id());
+ return partitionGroup.getPartition(atomixPartitionId).members()
+ .stream()
+ .map(member -> NodeId.nodeId(member.id()))
+ .collect(Collectors.toSet());
}
@Override
@@ -147,36 +115,30 @@
@Override
public List<PartitionInfo> partitionInfo() {
- return partitions.values()
- .stream()
- .flatMap(x -> Tools.stream(x.info()))
- .collect(Collectors.toList());
- }
-
- private void processMetadataUpdate(ClusterMetadata clusterMetadata) {
- ClusterMetadataDiff diffExaminer =
- new ClusterMetadataDiff(currentClusterMetadata.get(), clusterMetadata);
- diffExaminer.partitionDiffs()
- .values()
- .stream()
- .filter(PartitionDiff::hasChanged)
- .forEach(diff -> partitions.get(diff.partitionId()).onUpdate(diff.newValue()));
- currentClusterMetadata.set(clusterMetadata);
- }
-
- private class InternalClusterMetadataListener implements ClusterMetadataEventListener {
- @Override
- public void event(ClusterMetadataEvent event) {
- processMetadataUpdate(event.subject());
- }
+ checkPermission(PARTITION_READ);
+ return partitionGroup.getPartitions()
+ .stream()
+ .map(partition -> {
+ MemberId primary = partition.primary();
+ return new PartitionInfo(
+ PartitionId.from(partition.id().id()),
+ partition.term(),
+ partition.members().stream().map(member -> member.id()).collect(Collectors.toList()),
+ primary != null ? primary.id() : null);
+ })
+ .collect(Collectors.toList());
}
@Override
public List<PartitionClientInfo> partitionClientInfo() {
- return partitions.values()
- .stream()
- .map(StoragePartition::client)
- .map(StoragePartitionClient::clientInfo)
- .collect(Collectors.toList());
+ checkPermission(PARTITION_READ);
+ return partitionGroup.getPartitions()
+ .stream()
+ .map(partition -> new PartitionClientInfo(
+ PartitionId.from(partition.id().id()),
+ partition.members().stream()
+ .map(member -> NodeId.nodeId(member.id()))
+ .collect(Collectors.toList())))
+ .collect(Collectors.toList());
}
}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedAsyncConsistentMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedAsyncConsistentMap.java
deleted file mode 100644
index 38ba0f3..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedAsyncConsistentMap.java
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.NoSuchElementException;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.function.BiFunction;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
-import org.onlab.util.Match;
-import org.onlab.util.Tools;
-import org.onosproject.cluster.PartitionId;
-import org.onosproject.store.primitives.MapUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.AsyncIterator;
-import org.onosproject.store.service.MapEventListener;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.Versioned;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Maps;
-
-/**
- * {@link AsyncConsistentMap} that has its entries partitioned horizontally across
- * several {@link AsyncConsistentMap maps}.
- *
- * @param <K> key type
- * @param <V> value type
- */
-public class PartitionedAsyncConsistentMap<K, V> implements AsyncConsistentMap<K, V> {
-
- private final String name;
- private final TreeMap<PartitionId, AsyncConsistentMap<K, V>> partitions = Maps.newTreeMap();
- private final Hasher<K> keyHasher;
-
- public PartitionedAsyncConsistentMap(String name,
- Map<PartitionId, AsyncConsistentMap<K, V>> partitions,
- Hasher<K> keyHasher) {
- this.name = name;
- this.partitions.putAll(checkNotNull(partitions));
- this.keyHasher = checkNotNull(keyHasher);
- }
-
- @Override
- public String name() {
- return name;
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- return Tools.allOf(getMaps().stream().map(m -> m.size()).collect(Collectors.toList()),
- Math::addExact,
- 0);
- }
-
- @Override
- public CompletableFuture<Boolean> isEmpty() {
- return size().thenApply(size -> size == 0);
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(K key) {
- return getMap(key).containsKey(key);
- }
-
- @Override
- public CompletableFuture<Boolean> containsValue(V value) {
- return Tools.firstOf(getMaps().stream().map(m -> m.containsValue(value)).collect(Collectors.toList()),
- Match.ifValue(true),
- false);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> get(K key) {
- return getMap(key).get(key);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> getOrDefault(K key, V defaultValue) {
- return getMap(key).getOrDefault(key, defaultValue);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> computeIf(K key,
- Predicate<? super V> condition,
- BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
- return getMap(key).computeIf(key, condition, remappingFunction);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> put(K key, V value) {
- return getMap(key).put(key, value);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putAndGet(K key, V value) {
- return getMap(key).putAndGet(key, value);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> remove(K key) {
- return getMap(key).remove(key);
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return CompletableFuture.allOf(getMaps().stream()
- .map(map -> map.clear())
- .toArray(CompletableFuture[]::new));
- }
-
- @Override
- public CompletableFuture<Set<K>> keySet() {
- return Tools.allOf(getMaps().stream().map(m -> m.keySet()).collect(Collectors.toList()),
- (s1, s2) -> ImmutableSet.<K>builder().addAll(s1).addAll(s2).build(),
- ImmutableSet.of());
- }
-
- @Override
- public CompletableFuture<Collection<Versioned<V>>> values() {
- return Tools.allOf(getMaps().stream().map(m -> m.values()).collect(Collectors.toList()),
- (c1, c2) -> ImmutableList.<Versioned<V>>builder().addAll(c1).addAll(c2).build(),
- ImmutableList.of());
- }
-
- @Override
- public CompletableFuture<Set<Entry<K, Versioned<V>>>> entrySet() {
- return Tools.allOf(getMaps().stream().map(m -> m.entrySet()).collect(Collectors.toList()),
- (s1, s2) -> ImmutableSet.<Entry<K, Versioned<V>>>builder().addAll(s1).addAll(s2).build(),
- ImmutableSet.of());
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putIfAbsent(K key, V value) {
- return getMap(key).putIfAbsent(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, V value) {
- return getMap(key).remove(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, long version) {
- return getMap(key).remove(key, version);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> replace(K key, V value) {
- return getMap(key).replace(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K key, V oldValue, V newValue) {
- return getMap(key).replace(key, oldValue, newValue);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K key, long oldVersion, V newValue) {
- return getMap(key).replace(key, oldVersion, newValue);
- }
-
- @Override
- public CompletableFuture<AsyncIterator<Entry<K, Versioned<V>>>> iterator() {
- return Tools.allOf(getMaps().stream().map(m -> m.iterator()).collect(Collectors.toList()))
- .thenApply(PartitionedMultimapIterator::new);
- }
-
- @Override
- public CompletableFuture<Void> addListener(MapEventListener<K, V> listener, Executor executor) {
- return CompletableFuture.allOf(getMaps().stream()
- .map(map -> map.addListener(listener, executor))
- .toArray(CompletableFuture[]::new));
- }
-
- @Override
- public CompletableFuture<Void> removeListener(MapEventListener<K, V> listener) {
- return CompletableFuture.allOf(getMaps().stream()
- .map(map -> map.removeListener(listener))
- .toArray(CompletableFuture[]::new));
- }
-
- @Override
- public CompletableFuture<Version> begin(TransactionId transactionId) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<K, V>> transactionLog) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<K, V>> transactionLog) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public CompletableFuture<Void> commit(TransactionId transactionId) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public CompletableFuture<Void> rollback(TransactionId transactionId) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public void addStatusChangeListener(Consumer<Status> listener) {
- partitions.values().forEach(map -> map.addStatusChangeListener(listener));
- }
-
- @Override
- public void removeStatusChangeListener(Consumer<Status> listener) {
- partitions.values().forEach(map -> map.removeStatusChangeListener(listener));
- }
-
- @Override
- public Collection<Consumer<Status>> statusChangeListeners() {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Returns the map (partition) to which the specified key maps.
- * @param key key
- * @return AsyncConsistentMap to which key maps
- */
- private AsyncConsistentMap<K, V> getMap(K key) {
- return partitions.get(keyHasher.hash(key));
- }
-
- /**
- * Returns all the constituent maps.
- * @return collection of maps.
- */
- private Collection<AsyncConsistentMap<K, V>> getMaps() {
- return partitions.values();
- }
-
- private class PartitionedMultimapIterator<K, V> implements AsyncIterator<Map.Entry<K, Versioned<V>>> {
- private final Iterator<AsyncIterator<Entry<K, Versioned<V>>>> iterators;
- private volatile AsyncIterator<Entry<K, Versioned<V>>> iterator;
-
- public PartitionedMultimapIterator(List<AsyncIterator<Entry<K, Versioned<V>>>> iterators) {
- this.iterators = iterators.iterator();
- }
-
- @Override
- public CompletableFuture<Boolean> hasNext() {
- if (iterator == null && iterators.hasNext()) {
- iterator = iterators.next();
- }
- if (iterator == null) {
- return CompletableFuture.completedFuture(false);
- }
- return iterator.hasNext()
- .thenCompose(hasNext -> {
- if (!hasNext) {
- iterator = null;
- return hasNext();
- }
- return CompletableFuture.completedFuture(true);
- });
- }
-
- @Override
- public CompletableFuture<Entry<K, Versioned<V>>> next() {
- if (iterator == null && iterators.hasNext()) {
- iterator = iterators.next();
- }
- if (iterator == null) {
- return Tools.exceptionalFuture(new NoSuchElementException());
- }
- return iterator.next();
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedAsyncConsistentMultimap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedAsyncConsistentMultimap.java
deleted file mode 100644
index a4e0bf9..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedAsyncConsistentMultimap.java
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.NoSuchElementException;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
-
-import com.google.common.collect.HashMultiset;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Multiset;
-import com.google.common.collect.Multisets;
-import org.onlab.util.Match;
-import org.onlab.util.Tools;
-import org.onosproject.cluster.PartitionId;
-import org.onosproject.store.service.AsyncConsistentMultimap;
-import org.onosproject.store.service.AsyncIterator;
-import org.onosproject.store.service.MultimapEventListener;
-import org.onosproject.store.service.Versioned;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * {@link AsyncConsistentMultimap} that has its entries partitioned horizontally across
- * several {@link AsyncConsistentMultimap maps}.
- *
- * @param <K> key type
- * @param <V> value type
- */
-public class PartitionedAsyncConsistentMultimap<K, V> implements AsyncConsistentMultimap<K, V> {
-
- private final String name;
- private final TreeMap<PartitionId, AsyncConsistentMultimap<K, V>> partitions = Maps.newTreeMap();
- private final Hasher<K> keyHasher;
-
- public PartitionedAsyncConsistentMultimap(String name,
- Map<PartitionId, AsyncConsistentMultimap<K, V>> partitions,
- Hasher<K> keyHasher) {
- this.name = name;
- this.partitions.putAll(checkNotNull(partitions));
- this.keyHasher = checkNotNull(keyHasher);
- }
-
- @Override
- public String name() {
- return name;
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- return Tools.allOf(getMultimaps().stream().map(m -> m.size()).collect(Collectors.toList()),
- Math::addExact,
- 0);
- }
-
- @Override
- public CompletableFuture<Boolean> isEmpty() {
- return size().thenApply(size -> size == 0);
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(K key) {
- return getMultimap(key).containsKey(key);
- }
-
- @Override
- public CompletableFuture<Boolean> containsValue(V value) {
- return Tools.firstOf(getMultimaps().stream().map(m -> m.containsValue(value)).collect(Collectors.toList()),
- Match.ifValue(true),
- false);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>> get(K key) {
- return getMultimap(key).get(key);
- }
-
- @Override
- public CompletableFuture<Boolean> containsEntry(K key, V value) {
- return getMultimap(key).containsEntry(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> put(K key, V value) {
- return getMultimap(key).put(key, value);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>> putAndGet(K key, V value) {
- return getMultimap(key).putAndGet(key, value);
- }
-
- @Override
- public CompletableFuture<Boolean> removeAll(K key, Collection<? extends V> values) {
- return getMultimap(key).removeAll(key, values);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>> removeAll(K key) {
- return getMultimap(key).removeAll(key);
- }
-
- @Override
- public CompletableFuture<Boolean> putAll(K key, Collection<? extends V> values) {
- return getMultimap(key).putAll(key, values);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>> replaceValues(K key, Collection<V> values) {
- return getMultimap(key).replaceValues(key, values);
- }
-
- @Override
- public CompletableFuture<Map<K, Collection<V>>> asMap() {
- throw new UnsupportedOperationException("Expensive operation.");
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return CompletableFuture.allOf(getMultimaps().stream()
- .map(map -> map.clear())
- .toArray(CompletableFuture[]::new));
- }
-
- @Override
- public CompletableFuture<Set<K>> keySet() {
- return Tools.allOf(getMultimaps().stream().map(m -> m.keySet()).collect(Collectors.toList()),
- (s1, s2) -> ImmutableSet.<K>builder().addAll(s1).addAll(s2).build(),
- ImmutableSet.of());
- }
-
- @Override
- public CompletableFuture<Multiset<K>> keys() {
- return Tools.allOf(getMultimaps().stream().map(m -> m.keys()).collect(Collectors.toList()))
- .thenApply(results -> results.stream().reduce(Multisets::sum).orElse(HashMultiset.create()));
- }
-
- @Override
- public CompletableFuture<Multiset<V>> values() {
- return Tools.allOf(getMultimaps().stream().map(m -> m.values()).collect(Collectors.toList()))
- .thenApply(results -> results.stream().reduce(Multisets::sum).orElse(HashMultiset.create()));
- }
-
- @Override
- public CompletableFuture<Collection<Entry<K, V>>> entries() {
- return Tools.allOf(getMultimaps().stream().map(m -> m.entries()).collect(Collectors.toList()))
- .thenApply(results -> results.stream().reduce((s1, s2) -> ImmutableList.copyOf(Iterables.concat(s1, s2)))
- .orElse(ImmutableList.of()));
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, V value) {
- return getMultimap(key).remove(key, value);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V>>> removeAndGet(K key, V value) {
- return getMultimap(key).removeAndGet(key, value);
- }
-
- @Override
- public CompletableFuture<AsyncIterator<Entry<K, V>>> iterator() {
- return Tools.allOf(getMultimaps().stream().map(m -> m.iterator()).collect(Collectors.toList()))
- .thenApply(PartitionedMultimapIterator::new);
- }
-
- @Override
- public CompletableFuture<Void> addListener(MultimapEventListener<K, V> listener, Executor executor) {
- return CompletableFuture.allOf(getMultimaps().stream()
- .map(map -> map.addListener(listener, executor))
- .toArray(CompletableFuture[]::new));
- }
-
- @Override
- public CompletableFuture<Void> removeListener(MultimapEventListener<K, V> listener) {
- return CompletableFuture.allOf(getMultimaps().stream()
- .map(map -> map.removeListener(listener))
- .toArray(CompletableFuture[]::new));
- }
-
- @Override
- public void addStatusChangeListener(Consumer<Status> listener) {
- partitions.values().forEach(map -> map.addStatusChangeListener(listener));
- }
-
- @Override
- public void removeStatusChangeListener(Consumer<Status> listener) {
- partitions.values().forEach(map -> map.removeStatusChangeListener(listener));
- }
-
- @Override
- public Collection<Consumer<Status>> statusChangeListeners() {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Returns the map (partition) to which the specified key maps.
- *
- * @param key key
- * @return AsyncConsistentMap to which key maps
- */
- private AsyncConsistentMultimap<K, V> getMultimap(K key) {
- return partitions.get(keyHasher.hash(key));
- }
-
- /**
- * Returns all the constituent maps.
- *
- * @return collection of maps.
- */
- private Collection<AsyncConsistentMultimap<K, V>> getMultimaps() {
- return partitions.values();
- }
-
- private class PartitionedMultimapIterator<K, V> implements AsyncIterator<Map.Entry<K, V>> {
- private final Iterator<AsyncIterator<Entry<K, V>>> iterators;
- private volatile AsyncIterator<Entry<K, V>> iterator;
-
- public PartitionedMultimapIterator(List<AsyncIterator<Entry<K, V>>> iterators) {
- this.iterators = iterators.iterator();
- }
-
- @Override
- public CompletableFuture<Boolean> hasNext() {
- if (iterator == null && iterators.hasNext()) {
- iterator = iterators.next();
- }
- if (iterator == null) {
- return CompletableFuture.completedFuture(false);
- }
- return iterator.hasNext()
- .thenCompose(hasNext -> {
- if (!hasNext) {
- iterator = null;
- return hasNext();
- }
- return CompletableFuture.completedFuture(true);
- });
- }
-
- @Override
- public CompletableFuture<Entry<K, V>> next() {
- if (iterator == null && iterators.hasNext()) {
- iterator = iterators.next();
- }
- if (iterator == null) {
- return Tools.exceptionalFuture(new NoSuchElementException());
- }
- return iterator.next();
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedAsyncDocumentTree.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedAsyncDocumentTree.java
deleted file mode 100644
index 2d42d4f..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedAsyncDocumentTree.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.TreeMap;
-import java.util.concurrent.CompletableFuture;
-import java.util.stream.Collectors;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Maps;
-import org.onlab.util.Tools;
-import org.onosproject.cluster.PartitionId;
-import org.onosproject.store.primitives.NodeUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.AsyncDocumentTree;
-import org.onosproject.store.service.DocumentPath;
-import org.onosproject.store.service.DocumentTreeListener;
-import org.onosproject.store.service.NoSuchDocumentPathException;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.Versioned;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * Partitioned asynchronous document tree.
- */
-public class PartitionedAsyncDocumentTree<V> implements AsyncDocumentTree<V> {
-
- private final String name;
- private final TreeMap<PartitionId, AsyncDocumentTree<V>> partitions = Maps.newTreeMap();
- private final Hasher<DocumentPath> pathHasher;
-
- public PartitionedAsyncDocumentTree(
- String name,
- Map<PartitionId, AsyncDocumentTree<V>> partitions,
- Hasher<DocumentPath> pathHasher) {
- this.name = name;
- this.partitions.putAll(checkNotNull(partitions));
- this.pathHasher = checkNotNull(pathHasher);
- }
-
- @Override
- public String name() {
- return name;
- }
-
- @Override
- public DocumentPath root() {
- return DocumentPath.ROOT;
- }
-
- /**
- * Returns the document tree (partition) to which the specified path maps.
- *
- * @param path path
- * @return AsyncConsistentMap to which path maps
- */
- private AsyncDocumentTree<V> partition(DocumentPath path) {
- return partitions.get(pathHasher.hash(path));
- }
-
- /**
- * Returns all the constituent trees.
- *
- * @return collection of partitions.
- */
- private Collection<AsyncDocumentTree<V>> partitions() {
- return partitions.values();
- }
-
- @Override
- public CompletableFuture<Map<String, Versioned<V>>> getChildren(DocumentPath path) {
- return Tools.allOf(partitions().stream()
- .map(partition -> partition.getChildren(path).exceptionally(r -> null))
- .collect(Collectors.toList())).thenApply(allChildren -> {
- Map<String, Versioned<V>> children = Maps.newLinkedHashMap();
- allChildren.stream().filter(Objects::nonNull).forEach(children::putAll);
- return children;
- });
- }
-
- @Override
- public CompletableFuture<Versioned<V>> get(DocumentPath path) {
- return partition(path).get(path);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> set(DocumentPath path, V value) {
- return partition(path).set(path, value);
- }
-
- @Override
- public CompletableFuture<Boolean> create(DocumentPath path, V value) {
- if (path.parent() == null) {
- // create value on root
- return partition(path).createRecursive(path, value);
- }
- // TODO: This operation is not atomic
- return partition(path.parent()).get(path.parent()).thenCompose(parentValue -> {
- if (parentValue == null) {
- return Tools.exceptionalFuture(new NoSuchDocumentPathException(String.valueOf(path.parent())));
- } else {
- // not atomic: parent did exist at some point, so moving forward
- return partition(path).createRecursive(path, value);
- }
- });
- }
-
- @Override
- public CompletableFuture<Boolean> createRecursive(DocumentPath path, V value) {
- return partition(path).createRecursive(path, value);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(DocumentPath path, V newValue, long version) {
- return partition(path).replace(path, newValue, version);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(DocumentPath path, V newValue, V currentValue) {
- return partition(path).replace(path, newValue, currentValue);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> removeNode(DocumentPath path) {
- return partition(path).removeNode(path);
- }
-
- @Override
- public CompletableFuture<Void> addListener(DocumentPath path, DocumentTreeListener<V> listener) {
- return CompletableFuture.allOf(partitions().stream()
- .map(map -> map.addListener(path, listener))
- .toArray(CompletableFuture[]::new));
- }
-
- @Override
- public CompletableFuture<Void> removeListener(DocumentTreeListener<V> listener) {
- return CompletableFuture.allOf(partitions().stream()
- .map(map -> map.removeListener(listener))
- .toArray(CompletableFuture[]::new));
- }
-
- @Override
- public CompletableFuture<Version> begin(TransactionId transactionId) {
- return partitions().stream()
- .map(p -> p.begin(transactionId))
- // returning lowest Version
- .reduce((f1, f2) -> f1.thenCombine(f2, Tools::min))
- .orElse(Tools.exceptionalFuture(new IllegalStateException("Empty partitions?")));
- }
-
- @Override
- public CompletableFuture<Boolean> prepare(TransactionLog<NodeUpdate<V>> transactionLog) {
- Map<AsyncDocumentTree<V>, List<NodeUpdate<V>>> perPart =
- transactionLog.records().stream()
- .collect(Collectors.groupingBy(nu -> partition(nu.path())));
-
- // must walk all partitions to ensure empty TransactionLog will
- // be issued against no-op partitions in order for commit to succeed
- return partitions().stream()
- .map(p -> p.prepare(new TransactionLog<>(transactionLog.transactionId(),
- transactionLog.version(),
- perPart.getOrDefault(p, ImmutableList.of()))))
- .reduce((f1, f2) -> f1.thenCombine(f2, Boolean::logicalAnd))
- .orElse(CompletableFuture.completedFuture(true));
- }
-
- @Override
- public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<NodeUpdate<V>> transactionLog) {
- // Note: cannot call prepareAndCommit on each partition,
- // must check all partitions are prepare()-ed first.
- return prepare(transactionLog)
- .thenApply(prepOk -> {
- if (prepOk) {
- commit(transactionLog.transactionId());
- return true;
- } else {
- return false;
- }
- });
-
- }
-
- @Override
- public CompletableFuture<Void> commit(TransactionId transactionId) {
- return CompletableFuture.allOf(partitions().stream()
- .map(p -> p.commit(transactionId))
- .toArray(CompletableFuture[]::new)
- );
- }
-
- @Override
- public CompletableFuture<Void> rollback(TransactionId transactionId) {
- return CompletableFuture.allOf(partitions().stream()
- .map(p -> p.rollback(transactionId))
- .toArray(CompletableFuture[]::new)
- );
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedAsyncLeaderElector.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedAsyncLeaderElector.java
deleted file mode 100644
index 78bcf82..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedAsyncLeaderElector.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.TreeMap;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
-
-import org.onosproject.cluster.Leadership;
-import org.onosproject.cluster.NodeId;
-import org.onosproject.cluster.PartitionId;
-import org.onosproject.event.Change;
-import org.onosproject.store.service.AsyncLeaderElector;
-import com.google.common.collect.Maps;
-
-/**
- * {@link AsyncLeaderElector} that has its topics partitioned horizontally across
- * several {@link AsyncLeaderElector leader electors}.
- */
-public class PartitionedAsyncLeaderElector implements AsyncLeaderElector {
-
- private final String name;
- private final TreeMap<PartitionId, AsyncLeaderElector> partitions = Maps.newTreeMap();
- private final Hasher<String> topicHasher;
-
- public PartitionedAsyncLeaderElector(String name,
- Map<PartitionId, AsyncLeaderElector> partitions,
- Hasher<String> topicHasher) {
- this.name = name;
- this.partitions.putAll(checkNotNull(partitions));
- this.topicHasher = checkNotNull(topicHasher);
- }
-
- @Override
- public String name() {
- return name;
- }
-
- @Override
- public CompletableFuture<Leadership> run(String topic, NodeId nodeId) {
- return getLeaderElector(topic).run(topic, nodeId);
- }
-
- @Override
- public CompletableFuture<Void> withdraw(String topic) {
- return getLeaderElector(topic).withdraw(topic);
- }
-
- @Override
- public CompletableFuture<Boolean> anoint(String topic, NodeId nodeId) {
- return getLeaderElector(topic).anoint(topic, nodeId);
- }
-
- @Override
- public CompletableFuture<Boolean> promote(String topic, NodeId nodeId) {
- return getLeaderElector(topic).promote(topic, nodeId);
- }
-
- @Override
- public CompletableFuture<Void> evict(NodeId nodeId) {
- return CompletableFuture.allOf(getLeaderElectors().stream()
- .map(le -> le.evict(nodeId))
- .toArray(CompletableFuture[]::new));
- }
-
- @Override
- public CompletableFuture<Leadership> getLeadership(String topic) {
- return getLeaderElector(topic).getLeadership(topic);
- }
-
- @Override
- public CompletableFuture<Map<String, Leadership>> getLeaderships() {
- Map<String, Leadership> leaderships = Maps.newConcurrentMap();
- return CompletableFuture.allOf(getLeaderElectors().stream()
- .map(le -> le.getLeaderships()
- .thenAccept(m -> leaderships.putAll(m)))
- .toArray(CompletableFuture[]::new))
- .thenApply(v -> leaderships);
- }
-
- @Override
- public CompletableFuture<Void> addChangeListener(Consumer<Change<Leadership>> listener) {
- return CompletableFuture.allOf(getLeaderElectors().stream()
- .map(map -> map.addChangeListener(listener))
- .toArray(CompletableFuture[]::new));
- }
-
- @Override
- public CompletableFuture<Void> removeChangeListener(Consumer<Change<Leadership>> listener) {
- return CompletableFuture.allOf(getLeaderElectors().stream()
- .map(map -> map.removeChangeListener(listener))
- .toArray(CompletableFuture[]::new));
- }
-
- /**
- * Returns the leaderElector (partition) to which the specified topic maps.
- * @param topic topic name
- * @return AsyncLeaderElector to which topic maps
- */
- private AsyncLeaderElector getLeaderElector(String topic) {
- return partitions.get(topicHasher.hash(topic));
- }
-
- /**
- * Returns all the constituent leader electors.
- * @return collection of leader electors.
- */
- private Collection<AsyncLeaderElector> getLeaderElectors() {
- return partitions.values();
- }
-
- @Override
- public void addStatusChangeListener(Consumer<Status> listener) {
- partitions.values().forEach(elector -> elector.addStatusChangeListener(listener));
- }
-
- @Override
- public void removeStatusChangeListener(Consumer<Status> listener) {
- partitions.values().forEach(elector -> elector.removeStatusChangeListener(listener));
- }
-
- @Override
- public Collection<Consumer<Status>> statusChangeListeners() {
- throw new UnsupportedOperationException();
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedTransactionalMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedTransactionalMap.java
deleted file mode 100644
index 4f6d5b6..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/PartitionedTransactionalMap.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.Map;
-
-import com.google.common.base.MoreObjects;
-import org.onosproject.cluster.PartitionId;
-import org.onosproject.store.service.TransactionalMap;
-
-/**
- * Partitioned transactional map.
- */
-public class PartitionedTransactionalMap<K, V> implements TransactionalMap<K, V> {
- protected final Map<PartitionId, TransactionalMapParticipant<K, V>> partitions;
- protected final Hasher<K> hasher;
-
- public PartitionedTransactionalMap(
- Map<PartitionId, TransactionalMapParticipant<K, V>> partitions, Hasher<K> hasher) {
- this.partitions = partitions;
- this.hasher = hasher;
- }
-
- /**
- * Returns the collection of map partitions.
- *
- * @return a collection of map partitions
- */
- @SuppressWarnings("unchecked")
- Collection<TransactionParticipant> participants() {
- return (Collection) partitions.values();
- }
-
- /**
- * Returns the partition for the given key.
- *
- * @param key the key for which to return the partition
- * @return the partition for the given key
- */
- private TransactionalMap<K, V> partition(K key) {
- return partitions.get(hasher.hash(key));
- }
-
- @Override
- public V get(K key) {
- return partition(key).get(key);
- }
-
- @Override
- public boolean containsKey(K key) {
- return partition(key).containsKey(key);
- }
-
- @Override
- public V put(K key, V value) {
- return partition(key).put(key, value);
- }
-
- @Override
- public V remove(K key) {
- return partition(key).remove(key);
- }
-
- @Override
- public V putIfAbsent(K key, V value) {
- return partition(key).putIfAbsent(key, value);
- }
-
- @Override
- public boolean remove(K key, V value) {
- return partition(key).remove(key, value);
- }
-
- @Override
- public boolean replace(K key, V oldValue, V newValue) {
- return partition(key).replace(key, oldValue, newValue);
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(this)
- .add("partitions", partitions.values())
- .toString();
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/RaftClientCommunicator.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/RaftClientCommunicator.java
deleted file mode 100644
index 45f40ae..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/RaftClientCommunicator.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-import io.atomix.protocols.raft.cluster.MemberId;
-import io.atomix.protocols.raft.protocol.CloseSessionRequest;
-import io.atomix.protocols.raft.protocol.CloseSessionResponse;
-import io.atomix.protocols.raft.protocol.CommandRequest;
-import io.atomix.protocols.raft.protocol.CommandResponse;
-import io.atomix.protocols.raft.protocol.HeartbeatRequest;
-import io.atomix.protocols.raft.protocol.HeartbeatResponse;
-import io.atomix.protocols.raft.protocol.KeepAliveRequest;
-import io.atomix.protocols.raft.protocol.KeepAliveResponse;
-import io.atomix.protocols.raft.protocol.MetadataRequest;
-import io.atomix.protocols.raft.protocol.MetadataResponse;
-import io.atomix.protocols.raft.protocol.OpenSessionRequest;
-import io.atomix.protocols.raft.protocol.OpenSessionResponse;
-import io.atomix.protocols.raft.protocol.PublishRequest;
-import io.atomix.protocols.raft.protocol.QueryRequest;
-import io.atomix.protocols.raft.protocol.QueryResponse;
-import io.atomix.protocols.raft.protocol.RaftClientProtocol;
-import io.atomix.protocols.raft.protocol.ResetRequest;
-import io.atomix.protocols.raft.session.SessionId;
-import org.onosproject.cluster.NodeId;
-import org.onosproject.store.cluster.messaging.ClusterCommunicationService;
-import org.onosproject.store.service.Serializer;
-
-/**
- * Raft client protocol that uses a cluster communicator.
- */
-public class RaftClientCommunicator extends RaftCommunicator implements RaftClientProtocol {
-
- public RaftClientCommunicator(
- String prefix,
- Serializer serializer,
- ClusterCommunicationService clusterCommunicator) {
- super(new RaftMessageContext(prefix), serializer, clusterCommunicator);
- }
-
- @Override
- public CompletableFuture<OpenSessionResponse> openSession(MemberId memberId, OpenSessionRequest request) {
- return sendAndReceive(context.openSessionSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<CloseSessionResponse> closeSession(MemberId memberId, CloseSessionRequest request) {
- return sendAndReceive(context.closeSessionSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<KeepAliveResponse> keepAlive(MemberId memberId, KeepAliveRequest request) {
- return sendAndReceive(context.keepAliveSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<QueryResponse> query(MemberId memberId, QueryRequest request) {
- return sendAndReceive(context.querySubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<CommandResponse> command(MemberId memberId, CommandRequest request) {
- return sendAndReceive(context.commandSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<MetadataResponse> metadata(MemberId memberId, MetadataRequest request) {
- return sendAndReceive(context.metadataSubject, request, memberId);
- }
-
- @Override
- public void registerHeartbeatHandler(Function<HeartbeatRequest, CompletableFuture<HeartbeatResponse>> function) {
- clusterCommunicator.addSubscriber(context.heartbeatSubject, serializer::decode, function, serializer::encode);
- }
-
- @Override
- public void unregisterHeartbeatHandler() {
- clusterCommunicator.removeSubscriber(context.heartbeatSubject);
- }
-
- @Override
- public void reset(Collection<MemberId> members, ResetRequest request) {
- Set<NodeId> nodes = members.stream().map(m -> NodeId.nodeId(m.id())).collect(Collectors.toSet());
- clusterCommunicator.multicast(
- request,
- context.resetSubject(request.session()),
- serializer::encode,
- nodes);
- }
-
- @Override
- public void registerPublishListener(SessionId sessionId, Consumer<PublishRequest> listener, Executor executor) {
- clusterCommunicator.addSubscriber(
- context.publishSubject(sessionId.id()),
- serializer::decode,
- listener,
- executor);
- }
-
- @Override
- public void unregisterPublishListener(SessionId sessionId) {
- clusterCommunicator.removeSubscriber(context.publishSubject(sessionId.id()));
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/RaftCommunicator.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/RaftCommunicator.java
deleted file mode 100644
index 1117ab9..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/RaftCommunicator.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.net.ConnectException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionException;
-
-import io.atomix.protocols.raft.RaftException;
-import io.atomix.protocols.raft.cluster.MemberId;
-import org.onosproject.cluster.NodeId;
-import org.onosproject.store.cluster.messaging.ClusterCommunicationService;
-import org.onosproject.store.cluster.messaging.MessageSubject;
-import org.onosproject.store.cluster.messaging.MessagingException;
-import org.onosproject.store.service.Serializer;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * Abstract base class for Raft protocol client/server.
- */
-public abstract class RaftCommunicator {
- protected final RaftMessageContext context;
- protected final Serializer serializer;
- protected final ClusterCommunicationService clusterCommunicator;
-
- public RaftCommunicator(
- RaftMessageContext context,
- Serializer serializer,
- ClusterCommunicationService clusterCommunicator) {
- this.context = checkNotNull(context, "context cannot be null");
- this.serializer = checkNotNull(serializer, "serializer cannot be null");
- this.clusterCommunicator = checkNotNull(clusterCommunicator, "clusterCommunicator cannot be null");
- }
-
- protected <T, U> CompletableFuture<U> sendAndReceive(MessageSubject subject, T request, MemberId memberId) {
- CompletableFuture<U> future = new CompletableFuture<>();
- clusterCommunicator.<T, U>sendAndReceive(
- request, subject, serializer::encode, serializer::decode, NodeId.nodeId(memberId.id()))
- .whenComplete((result, error) -> {
- if (error == null) {
- future.complete(result);
- } else {
- if (error instanceof CompletionException) {
- error = error.getCause();
- }
- if (error instanceof MessagingException.NoRemoteHandler) {
- error = new ConnectException(error.getMessage());
- } else if (error instanceof MessagingException.RemoteHandlerFailure
- || error instanceof MessagingException.ProtocolException) {
- error = new RaftException.ProtocolException(error.getMessage());
- }
- future.completeExceptionally(error);
- }
- });
- return future;
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/RaftMessageContext.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/RaftMessageContext.java
deleted file mode 100644
index 9f1f1bc..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/RaftMessageContext.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onosproject.store.cluster.messaging.MessageSubject;
-
-/**
- * Protocol message context.
- */
-final class RaftMessageContext {
- private final String prefix;
- final MessageSubject heartbeatSubject;
- final MessageSubject openSessionSubject;
- final MessageSubject closeSessionSubject;
- final MessageSubject keepAliveSubject;
- final MessageSubject querySubject;
- final MessageSubject commandSubject;
- final MessageSubject metadataSubject;
- final MessageSubject joinSubject;
- final MessageSubject leaveSubject;
- final MessageSubject configureSubject;
- final MessageSubject reconfigureSubject;
- final MessageSubject installSubject;
- final MessageSubject pollSubject;
- final MessageSubject voteSubject;
- final MessageSubject appendSubject;
- final MessageSubject transferSubject;
-
- RaftMessageContext(String prefix) {
- this.prefix = prefix;
- this.heartbeatSubject = getSubject(prefix, "heartbeat");
- this.openSessionSubject = getSubject(prefix, "open");
- this.closeSessionSubject = getSubject(prefix, "close");
- this.keepAliveSubject = getSubject(prefix, "keep-alive");
- this.querySubject = getSubject(prefix, "query");
- this.commandSubject = getSubject(prefix, "command");
- this.metadataSubject = getSubject(prefix, "metadata");
- this.joinSubject = getSubject(prefix, "join");
- this.leaveSubject = getSubject(prefix, "leave");
- this.configureSubject = getSubject(prefix, "configure");
- this.reconfigureSubject = getSubject(prefix, "reconfigure");
- this.installSubject = getSubject(prefix, "install");
- this.pollSubject = getSubject(prefix, "poll");
- this.voteSubject = getSubject(prefix, "vote");
- this.appendSubject = getSubject(prefix, "append");
- this.transferSubject = getSubject(prefix, "transfer");
- }
-
- private static MessageSubject getSubject(String prefix, String type) {
- if (prefix == null) {
- return new MessageSubject(type);
- } else {
- return new MessageSubject(String.format("%s-%s", prefix, type));
- }
- }
-
- /**
- * Returns the publish subject for the given session.
- *
- * @param sessionId the session for which to return the publish subject
- * @return the publish subject for the given session
- */
- MessageSubject publishSubject(long sessionId) {
- if (prefix == null) {
- return new MessageSubject(String.format("publish-%d", sessionId));
- } else {
- return new MessageSubject(String.format("%s-publish-%d", prefix, sessionId));
- }
- }
-
- /**
- * Returns the reset subject for the given session.
- *
- * @param sessionId the session for which to return the reset subject
- * @return the reset subject for the given session
- */
- MessageSubject resetSubject(long sessionId) {
- if (prefix == null) {
- return new MessageSubject(String.format("reset-%d", sessionId));
- } else {
- return new MessageSubject(String.format("%s-reset-%d", prefix, sessionId));
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/RaftServerCommunicator.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/RaftServerCommunicator.java
deleted file mode 100644
index f58db45..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/RaftServerCommunicator.java
+++ /dev/null
@@ -1,324 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-import io.atomix.protocols.raft.cluster.MemberId;
-import io.atomix.protocols.raft.protocol.AppendRequest;
-import io.atomix.protocols.raft.protocol.AppendResponse;
-import io.atomix.protocols.raft.protocol.CloseSessionRequest;
-import io.atomix.protocols.raft.protocol.CloseSessionResponse;
-import io.atomix.protocols.raft.protocol.CommandRequest;
-import io.atomix.protocols.raft.protocol.CommandResponse;
-import io.atomix.protocols.raft.protocol.ConfigureRequest;
-import io.atomix.protocols.raft.protocol.ConfigureResponse;
-import io.atomix.protocols.raft.protocol.HeartbeatRequest;
-import io.atomix.protocols.raft.protocol.HeartbeatResponse;
-import io.atomix.protocols.raft.protocol.InstallRequest;
-import io.atomix.protocols.raft.protocol.InstallResponse;
-import io.atomix.protocols.raft.protocol.JoinRequest;
-import io.atomix.protocols.raft.protocol.JoinResponse;
-import io.atomix.protocols.raft.protocol.KeepAliveRequest;
-import io.atomix.protocols.raft.protocol.KeepAliveResponse;
-import io.atomix.protocols.raft.protocol.LeaveRequest;
-import io.atomix.protocols.raft.protocol.LeaveResponse;
-import io.atomix.protocols.raft.protocol.MetadataRequest;
-import io.atomix.protocols.raft.protocol.MetadataResponse;
-import io.atomix.protocols.raft.protocol.OpenSessionRequest;
-import io.atomix.protocols.raft.protocol.OpenSessionResponse;
-import io.atomix.protocols.raft.protocol.PollRequest;
-import io.atomix.protocols.raft.protocol.PollResponse;
-import io.atomix.protocols.raft.protocol.PublishRequest;
-import io.atomix.protocols.raft.protocol.QueryRequest;
-import io.atomix.protocols.raft.protocol.QueryResponse;
-import io.atomix.protocols.raft.protocol.RaftServerProtocol;
-import io.atomix.protocols.raft.protocol.ReconfigureRequest;
-import io.atomix.protocols.raft.protocol.ReconfigureResponse;
-import io.atomix.protocols.raft.protocol.ResetRequest;
-import io.atomix.protocols.raft.protocol.TransferRequest;
-import io.atomix.protocols.raft.protocol.TransferResponse;
-import io.atomix.protocols.raft.protocol.VoteRequest;
-import io.atomix.protocols.raft.protocol.VoteResponse;
-import io.atomix.protocols.raft.session.SessionId;
-import org.onosproject.cluster.NodeId;
-import org.onosproject.store.cluster.messaging.ClusterCommunicationService;
-import org.onosproject.store.service.Serializer;
-
-/**
- * Raft server protocol that uses a {@link ClusterCommunicationService}.
- */
-public class RaftServerCommunicator extends RaftCommunicator implements RaftServerProtocol {
-
- public RaftServerCommunicator(
- String prefix,
- Serializer serializer,
- ClusterCommunicationService clusterCommunicator) {
- super(new RaftMessageContext(prefix), serializer, clusterCommunicator);
- }
-
- @Override
- public CompletableFuture<OpenSessionResponse> openSession(MemberId memberId, OpenSessionRequest request) {
- return sendAndReceive(context.openSessionSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<CloseSessionResponse> closeSession(MemberId memberId, CloseSessionRequest request) {
- return sendAndReceive(context.closeSessionSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<KeepAliveResponse> keepAlive(MemberId memberId, KeepAliveRequest request) {
- return sendAndReceive(context.keepAliveSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<QueryResponse> query(MemberId memberId, QueryRequest request) {
- return sendAndReceive(context.querySubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<CommandResponse> command(MemberId memberId, CommandRequest request) {
- return sendAndReceive(context.commandSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<MetadataResponse> metadata(MemberId memberId, MetadataRequest request) {
- return sendAndReceive(context.metadataSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<JoinResponse> join(MemberId memberId, JoinRequest request) {
- return sendAndReceive(context.joinSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<LeaveResponse> leave(MemberId memberId, LeaveRequest request) {
- return sendAndReceive(context.leaveSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<ConfigureResponse> configure(MemberId memberId, ConfigureRequest request) {
- return sendAndReceive(context.configureSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<ReconfigureResponse> reconfigure(MemberId memberId, ReconfigureRequest request) {
- return sendAndReceive(context.reconfigureSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<InstallResponse> install(MemberId memberId, InstallRequest request) {
- return sendAndReceive(context.installSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<PollResponse> poll(MemberId memberId, PollRequest request) {
- return sendAndReceive(context.pollSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<VoteResponse> vote(MemberId memberId, VoteRequest request) {
- return sendAndReceive(context.voteSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<AppendResponse> append(MemberId memberId, AppendRequest request) {
- return sendAndReceive(context.appendSubject, request, memberId);
- }
-
- @Override
- public CompletableFuture<TransferResponse> transfer(MemberId memberId, TransferRequest request) {
- return sendAndReceive(context.transferSubject, request, memberId);
- }
-
- @Override
- public void publish(MemberId memberId, PublishRequest request) {
- clusterCommunicator.unicast(request,
- context.publishSubject(request.session()), serializer::encode, NodeId.nodeId(memberId.id()));
- }
-
- @Override
- public CompletableFuture<HeartbeatResponse> heartbeat(MemberId memberId, HeartbeatRequest request) {
- return sendAndReceive(context.heartbeatSubject, request, memberId);
- }
-
- @Override
- public void registerOpenSessionHandler(
- Function<OpenSessionRequest, CompletableFuture<OpenSessionResponse>> handler) {
- clusterCommunicator.addSubscriber(context.openSessionSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterOpenSessionHandler() {
- clusterCommunicator.removeSubscriber(context.openSessionSubject);
- }
-
- @Override
- public void registerCloseSessionHandler(
- Function<CloseSessionRequest, CompletableFuture<CloseSessionResponse>> handler) {
- clusterCommunicator.addSubscriber(context.closeSessionSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterCloseSessionHandler() {
- clusterCommunicator.removeSubscriber(context.closeSessionSubject);
- }
-
- @Override
- public void registerKeepAliveHandler(Function<KeepAliveRequest, CompletableFuture<KeepAliveResponse>> handler) {
- clusterCommunicator.addSubscriber(context.keepAliveSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterKeepAliveHandler() {
- clusterCommunicator.removeSubscriber(context.keepAliveSubject);
- }
-
- @Override
- public void registerQueryHandler(Function<QueryRequest, CompletableFuture<QueryResponse>> handler) {
- clusterCommunicator.addSubscriber(context.querySubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterQueryHandler() {
- clusterCommunicator.removeSubscriber(context.querySubject);
- }
-
- @Override
- public void registerCommandHandler(Function<CommandRequest, CompletableFuture<CommandResponse>> handler) {
- clusterCommunicator.addSubscriber(context.commandSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterCommandHandler() {
- clusterCommunicator.removeSubscriber(context.commandSubject);
- }
-
- @Override
- public void registerMetadataHandler(Function<MetadataRequest, CompletableFuture<MetadataResponse>> handler) {
- clusterCommunicator.addSubscriber(context.metadataSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterMetadataHandler() {
- clusterCommunicator.removeSubscriber(context.metadataSubject);
- }
-
- @Override
- public void registerJoinHandler(Function<JoinRequest, CompletableFuture<JoinResponse>> handler) {
- clusterCommunicator.addSubscriber(context.joinSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterJoinHandler() {
- clusterCommunicator.removeSubscriber(context.joinSubject);
- }
-
- @Override
- public void registerLeaveHandler(Function<LeaveRequest, CompletableFuture<LeaveResponse>> handler) {
- clusterCommunicator.addSubscriber(context.leaveSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterLeaveHandler() {
- clusterCommunicator.removeSubscriber(context.leaveSubject);
- }
-
- @Override
- public void registerConfigureHandler(Function<ConfigureRequest, CompletableFuture<ConfigureResponse>> handler) {
- clusterCommunicator.addSubscriber(context.configureSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterConfigureHandler() {
- clusterCommunicator.removeSubscriber(context.configureSubject);
- }
-
- @Override
- public void registerReconfigureHandler(
- Function<ReconfigureRequest, CompletableFuture<ReconfigureResponse>> handler) {
- clusterCommunicator.addSubscriber(context.reconfigureSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterReconfigureHandler() {
- clusterCommunicator.removeSubscriber(context.reconfigureSubject);
- }
-
- @Override
- public void registerInstallHandler(Function<InstallRequest, CompletableFuture<InstallResponse>> handler) {
- clusterCommunicator.addSubscriber(context.installSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterInstallHandler() {
- clusterCommunicator.removeSubscriber(context.installSubject);
- }
-
- @Override
- public void registerPollHandler(Function<PollRequest, CompletableFuture<PollResponse>> handler) {
- clusterCommunicator.addSubscriber(context.pollSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterPollHandler() {
- clusterCommunicator.removeSubscriber(context.pollSubject);
- }
-
- @Override
- public void registerVoteHandler(Function<VoteRequest, CompletableFuture<VoteResponse>> handler) {
- clusterCommunicator.addSubscriber(context.voteSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterVoteHandler() {
- clusterCommunicator.removeSubscriber(context.voteSubject);
- }
-
- @Override
- public void registerAppendHandler(Function<AppendRequest, CompletableFuture<AppendResponse>> handler) {
- clusterCommunicator.addSubscriber(context.appendSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterAppendHandler() {
- clusterCommunicator.removeSubscriber(context.appendSubject);
- }
-
- @Override
- public void registerTransferHandler(Function<TransferRequest, CompletableFuture<TransferResponse>> handler) {
- clusterCommunicator.addSubscriber(context.transferSubject, serializer::decode, handler, serializer::encode);
- }
-
- @Override
- public void unregisterTransferHandler() {
- clusterCommunicator.removeSubscriber(context.transferSubject);
- }
-
- @Override
- public void registerResetListener(SessionId sessionId, Consumer<ResetRequest> listener, Executor executor) {
- clusterCommunicator.addSubscriber(context.resetSubject(sessionId.id()), serializer::decode, listener, executor);
- }
-
- @Override
- public void unregisterResetListener(SessionId sessionId) {
- clusterCommunicator.removeSubscriber(context.resetSubject(sessionId.id()));
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StorageManager.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StorageManager.java
index 719a96e..dd71e38 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StorageManager.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StorageManager.java
@@ -18,11 +18,17 @@
import java.util.Collection;
import java.util.List;
import java.util.Map;
-import java.util.UUID;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import com.google.common.collect.Maps;
+import io.atomix.core.Atomix;
+import io.atomix.core.counter.AtomicCounter;
+import io.atomix.core.counter.AtomicCounterType;
+import io.atomix.core.map.AtomicMapType;
+import io.atomix.core.workqueue.WorkQueueType;
+import io.atomix.primitive.partition.PartitionGroup;
+import io.atomix.protocols.raft.MultiRaftProtocol;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
@@ -34,15 +40,12 @@
import org.onosproject.cluster.Member;
import org.onosproject.cluster.MembershipService;
import org.onosproject.cluster.NodeId;
-import org.onosproject.cluster.PartitionId;
import org.onosproject.persistence.PersistenceService;
import org.onosproject.store.cluster.messaging.ClusterCommunicationService;
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
+import org.onosproject.store.impl.AtomixManager;
import org.onosproject.store.primitives.PartitionAdminService;
-import org.onosproject.store.primitives.PartitionService;
import org.onosproject.store.primitives.TransactionId;
import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncAtomicValue;
import org.onosproject.store.service.AsyncConsistentMultimap;
import org.onosproject.store.service.AsyncConsistentTreeMap;
import org.onosproject.store.service.AsyncDocumentTree;
@@ -50,7 +53,6 @@
import org.onosproject.store.service.AtomicCounterMapBuilder;
import org.onosproject.store.service.AtomicIdGeneratorBuilder;
import org.onosproject.store.service.AtomicValueBuilder;
-import org.onosproject.store.service.ConsistentMap;
import org.onosproject.store.service.ConsistentMapBuilder;
import org.onosproject.store.service.ConsistentMultimapBuilder;
import org.onosproject.store.service.ConsistentTreeMapBuilder;
@@ -68,6 +70,7 @@
import org.onosproject.store.service.TopicBuilder;
import org.onosproject.store.service.TransactionContextBuilder;
import org.onosproject.store.service.WorkQueue;
+import org.onosproject.store.service.WorkQueueBuilder;
import org.onosproject.store.service.WorkQueueStats;
import org.slf4j.Logger;
@@ -82,8 +85,6 @@
@Component(immediate = true)
public class StorageManager implements StorageService, StorageAdminService {
- private static final int BUCKETS = 128;
-
private final Logger log = getLogger(getClass());
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
@@ -96,26 +97,21 @@
protected PersistenceService persistenceService;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected PartitionService partitionService;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected PartitionAdminService partitionAdminService;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected MembershipService membershipService;
- private final Supplier<TransactionId> transactionIdGenerator =
- () -> TransactionId.from(UUID.randomUUID().toString());
- private DistributedPrimitiveCreator federatedPrimitiveCreator;
- private TransactionManager transactionManager;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected AtomixManager atomixManager;
+
+ private Atomix atomix;
+ private PartitionGroup group;
@Activate
public void activate() {
- Map<PartitionId, DistributedPrimitiveCreator> partitionMap = Maps.newHashMap();
- partitionService.getAllPartitionIds().stream()
- .forEach(id -> partitionMap.put(id, partitionService.getDistributedPrimitiveCreator(id)));
- federatedPrimitiveCreator = new FederatedDistributedPrimitiveCreator(partitionMap, BUCKETS);
- transactionManager = new TransactionManager(this, partitionService, BUCKETS);
+ atomix = atomixManager.getAtomix();
+ group = atomix.getPartitionService().getPartitionGroup(MultiRaftProtocol.TYPE);
log.info("Started");
}
@@ -137,175 +133,212 @@
// Use the MembershipService to provide peers for the map that are isolated within the current version.
Supplier<List<NodeId>> peersSupplier = () -> membershipService.getMembers().stream()
- .map(Member::nodeId)
- .filter(nodeId -> !nodeId.equals(localNodeId))
- .filter(id -> clusterService.getState(id).isActive())
- .collect(Collectors.toList());
+ .map(Member::nodeId)
+ .filter(nodeId -> !nodeId.equals(localNodeId))
+ .filter(id -> clusterService.getState(id).isActive())
+ .collect(Collectors.toList());
// If this is the first node in its version, bootstrap from the previous version. Otherwise, bootstrap the
// map from members isolated within the current version.
Supplier<List<NodeId>> bootstrapPeersSupplier = () -> {
if (membershipService.getMembers().size() == 1) {
return clusterService.getNodes()
- .stream()
- .map(ControllerNode::id)
- .filter(id -> !localNodeId.equals(id))
- .filter(id -> clusterService.getState(id).isActive())
- .collect(Collectors.toList());
+ .stream()
+ .map(ControllerNode::id)
+ .filter(id -> !localNodeId.equals(id))
+ .filter(id -> clusterService.getState(id).isActive())
+ .collect(Collectors.toList());
} else {
return membershipService.getMembers()
- .stream()
- .map(Member::nodeId)
- .filter(id -> !localNodeId.equals(id))
- .filter(id -> clusterService.getState(id).isActive())
- .collect(Collectors.toList());
+ .stream()
+ .map(Member::nodeId)
+ .filter(id -> !localNodeId.equals(id))
+ .filter(id -> clusterService.getState(id).isActive())
+ .collect(Collectors.toList());
}
};
return new EventuallyConsistentMapBuilderImpl<>(
- localNodeId,
- clusterCommunicator,
- persistenceService,
- peersSupplier,
- bootstrapPeersSupplier
+ localNodeId,
+ clusterCommunicator,
+ persistenceService,
+ peersSupplier,
+ bootstrapPeersSupplier
);
}
@Override
public <K, V> ConsistentMapBuilder<K, V> consistentMapBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultConsistentMapBuilder<>(federatedPrimitiveCreator);
+ return new AtomixConsistentMapBuilder<>(atomix, group.name());
}
@Override
public <V> DocumentTreeBuilder<V> documentTreeBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultDocumentTreeBuilder<V>(federatedPrimitiveCreator);
+ return new AtomixDocumentTreeBuilder<V>(atomix, group.name());
}
@Override
public <V> ConsistentTreeMapBuilder<V> consistentTreeMapBuilder() {
- return new DefaultConsistentTreeMapBuilder<V>(
- federatedPrimitiveCreator);
+ return new AtomixConsistentTreeMapBuilder<>(atomix, group.name());
}
@Override
public <K, V> ConsistentMultimapBuilder<K, V> consistentMultimapBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultConsistentMultimapBuilder<K, V>(
- federatedPrimitiveCreator);
+ return new AtomixConsistentMultimapBuilder<>(atomix, group.name());
}
@Override
public <K> AtomicCounterMapBuilder<K> atomicCounterMapBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultAtomicCounterMapBuilder<>(federatedPrimitiveCreator);
+ return new AtomixAtomicCounterMapBuilder<>(atomix, group.name());
}
@Override
public <E> DistributedSetBuilder<E> setBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultDistributedSetBuilder<>(() -> this.<E, Boolean>consistentMapBuilder());
+ return new AtomixDistributedSetBuilder<>(atomix, group.name());
}
@Override
public AtomicCounterBuilder atomicCounterBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultAtomicCounterBuilder(federatedPrimitiveCreator);
+ return new AtomixAtomicCounterBuilder(atomix, group.name());
}
@Override
public AtomicIdGeneratorBuilder atomicIdGeneratorBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultAtomicIdGeneratorBuilder(federatedPrimitiveCreator);
+ return new AtomixAtomicIdGeneratorBuilder(atomix, group.name());
}
@Override
public <V> AtomicValueBuilder<V> atomicValueBuilder() {
checkPermission(STORAGE_WRITE);
- Supplier<ConsistentMapBuilder<String, byte[]>> mapBuilderSupplier =
- () -> this.<String, byte[]>consistentMapBuilder()
- .withName("onos-atomic-values")
- .withSerializer(Serializer.using(KryoNamespaces.BASIC));
- return new DefaultAtomicValueBuilder<>(mapBuilderSupplier);
+ return new AtomixAtomicValueBuilder<>(atomix, group.name());
}
@Override
public TransactionContextBuilder transactionContextBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultTransactionContextBuilder(transactionIdGenerator.get(), transactionManager);
+ return new AtomixTransactionContextBuilder(atomix, group.name());
}
@Override
public DistributedLockBuilder lockBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultDistributedLockBuilder(federatedPrimitiveCreator);
+ return new AtomixDistributedLockBuilder(atomix, group.name());
}
@Override
public LeaderElectorBuilder leaderElectorBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultLeaderElectorBuilder(federatedPrimitiveCreator);
+ return new AtomixLeaderElectorBuilder(atomix, group.name(), clusterService.getLocalNode().id());
}
@Override
public <T> TopicBuilder<T> topicBuilder() {
checkPermission(STORAGE_WRITE);
- return new DefaultDistributedTopicBuilder<>(atomicValueBuilder());
+ return new AtomixDistributedTopicBuilder<>(atomix, group.name());
+ }
+
+ @Override
+ public <E> WorkQueueBuilder<E> workQueueBuilder() {
+ checkPermission(STORAGE_WRITE);
+ return new AtomixWorkQueueBuilder<>(atomix, group.name());
}
@Override
public <E> WorkQueue<E> getWorkQueue(String name, Serializer serializer) {
checkPermission(STORAGE_WRITE);
- return federatedPrimitiveCreator.newWorkQueue(name, serializer);
+ return this.<E>workQueueBuilder()
+ .withName(name)
+ .withSerializer(serializer)
+ .build();
}
@Override
public <V> AsyncDocumentTree<V> getDocumentTree(String name, Serializer serializer) {
checkPermission(STORAGE_WRITE);
- return federatedPrimitiveCreator.newAsyncDocumentTree(name, serializer);
+ return this.<V>documentTreeBuilder()
+ .withName(name)
+ .withSerializer(serializer)
+ .build();
}
@Override
- public <K, V> AsyncConsistentMultimap<K, V> getAsyncSetMultimap(
- String name, Serializer serializer) {
+ public <K, V> AsyncConsistentMultimap<K, V> getAsyncSetMultimap(String name, Serializer serializer) {
checkPermission(STORAGE_WRITE);
- return federatedPrimitiveCreator.newAsyncConsistentSetMultimap(name,
- serializer);
+ return new AtomixConsistentMultimapBuilder<K, V>(atomix, group.name())
+ .withName(name)
+ .withSerializer(serializer)
+ .buildMultimap();
}
@Override
- public <V> AsyncConsistentTreeMap<V> getAsyncTreeMap(
- String name, Serializer serializer) {
+ public <V> AsyncConsistentTreeMap<V> getAsyncTreeMap(String name, Serializer serializer) {
checkPermission(STORAGE_WRITE);
- return federatedPrimitiveCreator.newAsyncConsistentTreeMap(name,
- serializer);
+ return this.<V>consistentTreeMapBuilder()
+ .withName(name)
+ .withSerializer(serializer)
+ .buildTreeMap();
+ }
+
+ @Override
+ public <T> Topic<T> getTopic(String name, Serializer serializer) {
+ checkPermission(STORAGE_WRITE);
+ return this.<T>topicBuilder()
+ .withName(name)
+ .withSerializer(serializer)
+ .build();
}
@Override
public List<MapInfo> getMapInfo() {
- return listMapInfo(federatedPrimitiveCreator);
+ Serializer serializer = Serializer.using(KryoNamespaces.BASIC);
+ return atomix.getPrimitives(AtomicMapType.instance())
+ .stream()
+ .map(info -> {
+ io.atomix.core.map.AtomicMap<String, byte[]> map =
+ atomix.<String, byte[]>atomicMapBuilder(info.name())
+ .withSerializer(new AtomixSerializerAdapter(serializer))
+ .build();
+ int size = map.size();
+ map.close();
+ return new MapInfo(info.name(), size);
+ }).collect(Collectors.toList());
}
@Override
public Map<String, Long> getCounters() {
- Map<String, Long> counters = Maps.newConcurrentMap();
- federatedPrimitiveCreator.getAsyncAtomicCounterNames()
- .forEach(name -> counters.put(name,
- federatedPrimitiveCreator.newAsyncCounter(name).asAtomicCounter().get()));
- return counters;
+ return atomix.getPrimitives(AtomicCounterType.instance())
+ .stream()
+ .map(info -> {
+ AtomicCounter counter = atomix.atomicCounterBuilder(info.name()).build();
+ long value = counter.get();
+ counter.close();
+ return Maps.immutableEntry(info.name(), value);
+ }).collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()));
}
@Override
public Map<String, WorkQueueStats> getQueueStats() {
- Map<String, WorkQueueStats> workQueueStats = Maps.newConcurrentMap();
- federatedPrimitiveCreator.getWorkQueueNames()
- .forEach(name -> workQueueStats.put(name,
- federatedPrimitiveCreator.newWorkQueue(name,
- Serializer.using(KryoNamespaces.BASIC))
- .stats()
- .join()));
- return workQueueStats;
+ Serializer serializer = Serializer.using(KryoNamespaces.BASIC);
+ return atomix.getPrimitives(WorkQueueType.instance())
+ .stream()
+ .map(info -> {
+ io.atomix.core.workqueue.WorkQueue queue = atomix.workQueueBuilder(info.name())
+ .withSerializer(new AtomixSerializerAdapter(serializer))
+ .build();
+ io.atomix.core.workqueue.WorkQueueStats stats = queue.stats();
+ return Maps.immutableEntry(info.name(), WorkQueueStats.builder()
+ .withTotalCompleted(stats.totalCompleted())
+ .withTotalInProgress(stats.totalInProgress())
+ .withTotalPending(stats.totalPending())
+ .build());
+ }).collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()));
}
@Override
@@ -315,27 +348,9 @@
@Override
public Collection<TransactionId> getPendingTransactions() {
- return transactionManager.getPendingTransactions();
- }
-
- private List<MapInfo> listMapInfo(DistributedPrimitiveCreator creator) {
- Serializer serializer = Serializer.using(KryoNamespaces.BASIC);
- return creator.getAsyncConsistentMapNames()
- .stream()
- .map(name -> {
- ConsistentMap<String, byte[]> map =
- creator.<String, byte[]>newAsyncConsistentMap(name, serializer)
- .asConsistentMap();
- return new MapInfo(name, map.size());
- }).collect(Collectors.toList());
- }
-
- @Override
- public <T> Topic<T> getTopic(String name, Serializer serializer) {
- AsyncAtomicValue<T> atomicValue = this.<T>atomicValueBuilder()
- .withName("topic-" + name)
- .withSerializer(serializer)
- .build();
- return new DefaultDistributedTopic<>(atomicValue);
+ return atomix.getTransactionService().getActiveTransactions()
+ .stream()
+ .map(transactionId -> TransactionId.from(transactionId.id()))
+ .collect(Collectors.toList());
}
}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StorageNamespaces.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StorageNamespaces.java
deleted file mode 100644
index 4eaac99..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StorageNamespaces.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedList;
-
-import io.atomix.protocols.raft.RaftError;
-import io.atomix.protocols.raft.ReadConsistency;
-import io.atomix.protocols.raft.cluster.MemberId;
-import io.atomix.protocols.raft.cluster.RaftMember;
-import io.atomix.protocols.raft.cluster.impl.DefaultRaftMember;
-import io.atomix.protocols.raft.event.RaftEvent;
-import io.atomix.protocols.raft.event.impl.DefaultEventType;
-import io.atomix.protocols.raft.operation.OperationType;
-import io.atomix.protocols.raft.operation.RaftOperation;
-import io.atomix.protocols.raft.operation.impl.DefaultOperationId;
-import io.atomix.protocols.raft.protocol.AppendRequest;
-import io.atomix.protocols.raft.protocol.AppendResponse;
-import io.atomix.protocols.raft.protocol.CloseSessionRequest;
-import io.atomix.protocols.raft.protocol.CloseSessionResponse;
-import io.atomix.protocols.raft.protocol.CommandRequest;
-import io.atomix.protocols.raft.protocol.CommandResponse;
-import io.atomix.protocols.raft.protocol.ConfigureRequest;
-import io.atomix.protocols.raft.protocol.ConfigureResponse;
-import io.atomix.protocols.raft.protocol.HeartbeatRequest;
-import io.atomix.protocols.raft.protocol.HeartbeatResponse;
-import io.atomix.protocols.raft.protocol.InstallRequest;
-import io.atomix.protocols.raft.protocol.InstallResponse;
-import io.atomix.protocols.raft.protocol.JoinRequest;
-import io.atomix.protocols.raft.protocol.JoinResponse;
-import io.atomix.protocols.raft.protocol.KeepAliveRequest;
-import io.atomix.protocols.raft.protocol.KeepAliveResponse;
-import io.atomix.protocols.raft.protocol.LeaveRequest;
-import io.atomix.protocols.raft.protocol.LeaveResponse;
-import io.atomix.protocols.raft.protocol.MetadataRequest;
-import io.atomix.protocols.raft.protocol.MetadataResponse;
-import io.atomix.protocols.raft.protocol.OpenSessionRequest;
-import io.atomix.protocols.raft.protocol.OpenSessionResponse;
-import io.atomix.protocols.raft.protocol.PollRequest;
-import io.atomix.protocols.raft.protocol.PollResponse;
-import io.atomix.protocols.raft.protocol.PublishRequest;
-import io.atomix.protocols.raft.protocol.QueryRequest;
-import io.atomix.protocols.raft.protocol.QueryResponse;
-import io.atomix.protocols.raft.protocol.RaftResponse;
-import io.atomix.protocols.raft.protocol.ReconfigureRequest;
-import io.atomix.protocols.raft.protocol.ReconfigureResponse;
-import io.atomix.protocols.raft.protocol.ResetRequest;
-import io.atomix.protocols.raft.protocol.VoteRequest;
-import io.atomix.protocols.raft.protocol.VoteResponse;
-import io.atomix.protocols.raft.service.PropagationStrategy;
-import io.atomix.protocols.raft.session.RaftSessionMetadata;
-import io.atomix.protocols.raft.session.SessionId;
-import io.atomix.protocols.raft.storage.log.entry.CloseSessionEntry;
-import io.atomix.protocols.raft.storage.log.entry.CommandEntry;
-import io.atomix.protocols.raft.storage.log.entry.ConfigurationEntry;
-import io.atomix.protocols.raft.storage.log.entry.InitializeEntry;
-import io.atomix.protocols.raft.storage.log.entry.KeepAliveEntry;
-import io.atomix.protocols.raft.storage.log.entry.MetadataEntry;
-import io.atomix.protocols.raft.storage.log.entry.OpenSessionEntry;
-import io.atomix.protocols.raft.storage.log.entry.QueryEntry;
-import io.atomix.protocols.raft.storage.system.Configuration;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-
-/**
- * Storage serializer namespaces.
- */
-public final class StorageNamespaces {
-
- /**
- * Raft protocol namespace.
- */
- public static final KryoNamespace RAFT_PROTOCOL = KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID)
- .register(OpenSessionRequest.class)
- .register(OpenSessionResponse.class)
- .register(CloseSessionRequest.class)
- .register(CloseSessionResponse.class)
- .register(KeepAliveRequest.class)
- .register(KeepAliveResponse.class)
- .register(HeartbeatRequest.class)
- .register(HeartbeatResponse.class)
- .register(QueryRequest.class)
- .register(QueryResponse.class)
- .register(CommandRequest.class)
- .register(CommandResponse.class)
- .register(MetadataRequest.class)
- .register(MetadataResponse.class)
- .register(JoinRequest.class)
- .register(JoinResponse.class)
- .register(LeaveRequest.class)
- .register(LeaveResponse.class)
- .register(ConfigureRequest.class)
- .register(ConfigureResponse.class)
- .register(ReconfigureRequest.class)
- .register(ReconfigureResponse.class)
- .register(InstallRequest.class)
- .register(InstallResponse.class)
- .register(PollRequest.class)
- .register(PollResponse.class)
- .register(VoteRequest.class)
- .register(VoteResponse.class)
- .register(AppendRequest.class)
- .register(AppendResponse.class)
- .register(PublishRequest.class)
- .register(ResetRequest.class)
- .register(RaftResponse.Status.class)
- .register(RaftError.class)
- .register(RaftError.Type.class)
- .register(RaftOperation.class)
- .register(DefaultOperationId.class)
- .register(OperationType.class)
- .register(RaftEvent.class)
- .register(DefaultEventType.class)
- .register(RaftSessionMetadata.class)
- .register(CloseSessionEntry.class)
- .register(CommandEntry.class)
- .register(ConfigurationEntry.class)
- .register(InitializeEntry.class)
- .register(KeepAliveEntry.class)
- .register(MetadataEntry.class)
- .register(OpenSessionEntry.class)
- .register(QueryEntry.class)
- .register(ReadConsistency.class)
- .register(ArrayList.class)
- .register(LinkedList.class)
- .register(Collections.emptyList().getClass())
- .register(HashSet.class)
- .register(DefaultRaftMember.class)
- .register(MemberId.class)
- .register(SessionId.class)
- .register(RaftMember.Type.class)
- .register(Instant.class)
- .register(Configuration.class)
- .register(PropagationStrategy.class)
- .build("RaftProtocol");
-
- /**
- * Raft storage namespace.
- */
- public static final KryoNamespace RAFT_STORAGE = KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 100)
- .register(CloseSessionEntry.class)
- .register(CommandEntry.class)
- .register(ConfigurationEntry.class)
- .register(InitializeEntry.class)
- .register(KeepAliveEntry.class)
- .register(MetadataEntry.class)
- .register(OpenSessionEntry.class)
- .register(QueryEntry.class)
- .register(RaftOperation.class)
- .register(DefaultOperationId.class)
- .register(OperationType.class)
- .register(ReadConsistency.class)
- .register(ArrayList.class)
- .register(HashSet.class)
- .register(DefaultRaftMember.class)
- .register(MemberId.class)
- .register(RaftMember.Type.class)
- .register(Instant.class)
- .register(Configuration.class)
- .register(PropagationStrategy.class)
- .build("RaftStorage");
-
- private StorageNamespaces() {
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StoragePartition.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StoragePartition.java
deleted file mode 100644
index 2a29114..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StoragePartition.java
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.io.File;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
-import com.google.common.collect.Collections2;
-import com.google.common.collect.ImmutableMap;
-import io.atomix.protocols.raft.cluster.MemberId;
-import io.atomix.protocols.raft.service.RaftService;
-import org.onosproject.cluster.ClusterService;
-import org.onosproject.cluster.NodeId;
-import org.onosproject.cluster.Partition;
-import org.onosproject.cluster.PartitionId;
-import org.onosproject.core.Version;
-import org.onosproject.store.cluster.messaging.ClusterCommunicationService;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapService;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapService;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapService;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapService;
-import org.onosproject.store.primitives.resources.impl.AtomixCounterService;
-import org.onosproject.store.primitives.resources.impl.AtomixDistributedLockService;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeService;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorService;
-import org.onosproject.store.primitives.resources.impl.AtomixWorkQueueService;
-import org.onosproject.store.service.DistributedPrimitive;
-import org.onosproject.store.service.Ordering;
-import org.onosproject.store.service.PartitionInfo;
-import org.onosproject.store.service.Serializer;
-
-/**
- * Storage partition.
- */
-public class StoragePartition implements Managed<StoragePartition> {
-
- static final String PARTITIONS_DIR =
- System.getProperty("karaf.data") + "/db/partitions/";
-
- protected final AtomicBoolean isOpened = new AtomicBoolean(false);
- protected final ClusterCommunicationService clusterCommunicator;
- protected Partition partition;
- protected NodeId localNodeId;
- protected StoragePartitionServer server;
- protected StoragePartitionClient client;
-
- public static final Map<String, Supplier<RaftService>> RAFT_SERVICES =
- ImmutableMap.<String, Supplier<RaftService>>builder()
- .put(DistributedPrimitive.Type.CONSISTENT_MAP.name(), AtomixConsistentMapService::new)
- .put(DistributedPrimitive.Type.CONSISTENT_TREEMAP.name(), AtomixConsistentTreeMapService::new)
- .put(DistributedPrimitive.Type.CONSISTENT_MULTIMAP.name(), AtomixConsistentSetMultimapService::new)
- .put(DistributedPrimitive.Type.COUNTER_MAP.name(), AtomixAtomicCounterMapService::new)
- .put(DistributedPrimitive.Type.COUNTER.name(), AtomixCounterService::new)
- .put(DistributedPrimitive.Type.LEADER_ELECTOR.name(), AtomixLeaderElectorService::new)
- .put(DistributedPrimitive.Type.WORK_QUEUE.name(), AtomixWorkQueueService::new)
- .put(DistributedPrimitive.Type.DOCUMENT_TREE.name(),
- () -> new AtomixDocumentTreeService(Ordering.NATURAL))
- .put(String.format("%s-%s", DistributedPrimitive.Type.DOCUMENT_TREE.name(), Ordering.NATURAL),
- () -> new AtomixDocumentTreeService(Ordering.NATURAL))
- .put(String.format("%s-%s", DistributedPrimitive.Type.DOCUMENT_TREE.name(), Ordering.INSERTION),
- () -> new AtomixDocumentTreeService(Ordering.INSERTION))
- .put(DistributedPrimitive.Type.LOCK.name(), AtomixDistributedLockService::new)
- .build();
-
- public StoragePartition(
- Partition partition,
- ClusterCommunicationService clusterCommunicator,
- ClusterService clusterService) {
- this.partition = partition;
- this.clusterCommunicator = clusterCommunicator;
- this.localNodeId = clusterService.getLocalNode().id();
- }
-
- /**
- * Returns the partition client instance.
- * @return client
- */
- public StoragePartitionClient client() {
- return client;
- }
-
- @Override
- public CompletableFuture<Void> open() {
- if (partition.getMembers().contains(localNodeId)) {
- return openServer()
- .thenCompose(v -> openClient())
- .thenAccept(v -> isOpened.set(true))
- .thenApply(v -> null);
- }
- return openClient()
- .thenAccept(v -> isOpened.set(true))
- .thenApply(v -> null);
- }
-
- @Override
- public CompletableFuture<Void> close() {
- // We do not explicitly close the server and instead let the cluster
- // deal with this as an unclean exit.
- return closeClient();
- }
-
- /**
- * Deletes the partition.
- *
- * @return future to be completed once the partition has been deleted
- */
- public CompletableFuture<Void> delete() {
- return closeServer().thenCompose(v -> closeClient()).thenRun(() -> deleteServer());
- }
-
- /**
- * Returns the partition data folder.
- *
- * @return the partition data folder
- */
- public File getDataFolder() {
- return new File(PARTITIONS_DIR + partition.getId());
- }
-
- /**
- * Returns the partition name.
- *
- * @return the partition name
- */
- public String getName() {
- return partition.getId().toString();
- }
-
- /**
- * Returns the identifier of the {@link Partition partition} associated with this instance.
- *
- * @return partition identifier
- */
- public PartitionId getId() {
- return partition.getId();
- }
-
- /**
- * Returns the partition version.
- *
- * @return the partition version
- */
- public Version getVersion() {
- return partition.getVersion();
- }
-
- /**
- * Returns the identifiers of partition members.
- * @return partition member instance ids
- */
- public Collection<NodeId> getMembers() {
- return partition.getMembers();
- }
-
- /**
- * Returns the {@link MemberId identifiers} of partition members.
- * @return partition member identifiers
- */
- public Collection<MemberId> getMemberIds() {
- return Collections2.transform(getMembers(), n -> MemberId.from(n.id()));
- }
-
- /**
- * Attempts to rejoin the partition.
- * @return future that is completed after the operation is complete
- */
- protected CompletableFuture<Void> openServer() {
- StoragePartitionServer server = new StoragePartitionServer(
- this,
- MemberId.from(localNodeId.id()),
- clusterCommunicator);
- return server.open().thenRun(() -> this.server = server);
- }
-
- /**
- * Attempts to join the partition as a new member.
- * @return future that is completed after the operation is complete
- */
- private CompletableFuture<Void> joinCluster() {
- Set<NodeId> otherMembers = partition.getMembers()
- .stream()
- .filter(nodeId -> !nodeId.equals(localNodeId))
- .collect(Collectors.toSet());
- StoragePartitionServer server = new StoragePartitionServer(this,
- MemberId.from(localNodeId.id()),
- clusterCommunicator);
- return server.join(Collections2.transform(otherMembers, n -> MemberId.from(n.id())))
- .thenRun(() -> this.server = server);
- }
-
- private CompletableFuture<StoragePartitionClient> openClient() {
- client = new StoragePartitionClient(this,
- MemberId.from(localNodeId.id()),
- new RaftClientCommunicator(
- String.format("partition-%s-%s", partition.getId(), partition.getVersion()),
- Serializer.using(StorageNamespaces.RAFT_PROTOCOL),
- clusterCommunicator));
- return client.open().thenApply(v -> client);
- }
-
- /**
- * Closes the partition server if it was previously opened.
- * @return future that is completed when the operation completes
- */
- public CompletableFuture<Void> leaveCluster() {
- return server != null
- ? server.closeAndExit().thenRun(() -> server.delete())
- : CompletableFuture.completedFuture(null);
- }
-
- @Override
- public boolean isOpen() {
- return isOpened.get();
- }
-
- private CompletableFuture<Void> closeServer() {
- if (server != null) {
- return server.close();
- }
- return CompletableFuture.completedFuture(null);
- }
-
- private void deleteServer() {
- if (server != null) {
- server.delete();
- }
- }
-
- private CompletableFuture<Void> closeClient() {
- if (client != null) {
- return client.close();
- }
- return CompletableFuture.completedFuture(null);
- }
-
- /**
- * Returns the partition information if this partition is locally managed i.e.
- * this node is a active member of the partition.
- * @return partition info
- */
- public Optional<PartitionInfo> info() {
- return server != null && server.isOpen() ? Optional.of(server.info()) : Optional.empty();
- }
-
- /**
- * Process updates to partitions and handles joining or leaving a partition.
- * @param newValue new Partition
- */
- void onUpdate(Partition newValue) {
- boolean wasPresent = partition.getMembers().contains(localNodeId);
- boolean isPresent = newValue.getMembers().contains(localNodeId);
- this.partition = newValue;
- if ((wasPresent && isPresent) || (!wasPresent && !isPresent)) {
- // no action needed
- return;
- }
- // Only need to do action if our membership changed
- if (wasPresent) {
- leaveCluster();
- } else {
- joinCluster();
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StoragePartitionClient.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StoragePartitionClient.java
deleted file mode 100644
index 5fa7383..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StoragePartitionClient.java
+++ /dev/null
@@ -1,436 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.time.Duration;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.stream.Collectors;
-
-import com.google.common.base.Suppliers;
-import io.atomix.protocols.raft.RaftClient;
-import io.atomix.protocols.raft.ReadConsistency;
-import io.atomix.protocols.raft.cluster.MemberId;
-import io.atomix.protocols.raft.protocol.RaftClientProtocol;
-import io.atomix.protocols.raft.proxy.CommunicationStrategy;
-import io.atomix.protocols.raft.service.PropagationStrategy;
-import io.atomix.protocols.raft.session.RaftSessionMetadata;
-import org.onlab.util.HexString;
-import org.onosproject.store.primitives.DistributedPrimitiveCreator;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMap;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMap;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimap;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMap;
-import org.onosproject.store.primitives.resources.impl.AtomixCounter;
-import org.onosproject.store.primitives.resources.impl.AtomixDistributedLock;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTree;
-import org.onosproject.store.primitives.resources.impl.AtomixIdGenerator;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElector;
-import org.onosproject.store.primitives.resources.impl.AtomixWorkQueue;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncAtomicCounter;
-import org.onosproject.store.service.AsyncAtomicCounterMap;
-import org.onosproject.store.service.AsyncAtomicIdGenerator;
-import org.onosproject.store.service.AsyncAtomicValue;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.AsyncConsistentMultimap;
-import org.onosproject.store.service.AsyncConsistentTreeMap;
-import org.onosproject.store.service.AsyncDistributedLock;
-import org.onosproject.store.service.AsyncDistributedSet;
-import org.onosproject.store.service.AsyncDocumentTree;
-import org.onosproject.store.service.AsyncLeaderElector;
-import org.onosproject.store.service.AtomicCounterMapOptions;
-import org.onosproject.store.service.AtomicCounterOptions;
-import org.onosproject.store.service.AtomicIdGeneratorOptions;
-import org.onosproject.store.service.AtomicValueOptions;
-import org.onosproject.store.service.ConsistentMapOptions;
-import org.onosproject.store.service.ConsistentMultimapOptions;
-import org.onosproject.store.service.ConsistentTreeMapOptions;
-import org.onosproject.store.service.DistributedLockOptions;
-import org.onosproject.store.service.DistributedPrimitive;
-import org.onosproject.store.service.DistributedSetOptions;
-import org.onosproject.store.service.DocumentTreeOptions;
-import org.onosproject.store.service.LeaderElectorOptions;
-import org.onosproject.store.service.PartitionClientInfo;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.WorkQueue;
-import org.onosproject.store.service.WorkQueueOptions;
-import org.slf4j.Logger;
-
-import static org.slf4j.LoggerFactory.getLogger;
-
-/**
- * StoragePartition client.
- */
-public class StoragePartitionClient implements DistributedPrimitiveCreator, Managed<StoragePartitionClient> {
-
- private static final int MAX_RETRIES = 8;
- private static final String ATOMIC_VALUES_CONSISTENT_MAP_NAME = "onos-atomic-values";
-
- private static final String MIN_TIMEOUT_PROPERTY = "onos.cluster.raft.client.minTimeoutMillis";
- private static final String MAX_TIMEOUT_PROPERTY = "onos.cluster.raft.client.maxTimeoutMillis";
-
- private static final Duration MIN_TIMEOUT;
- private static final Duration MAX_TIMEOUT;
-
- private static final long DEFAULT_MIN_TIMEOUT_MILLIS = 5000;
- private static final long DEFAULT_MAX_TIMEOUT_MILLIS = 30000;
-
- static {
- Duration minTimeout;
- try {
- minTimeout = Duration.ofMillis(Long.parseLong(
- System.getProperty(MIN_TIMEOUT_PROPERTY,
- String.valueOf(DEFAULT_MIN_TIMEOUT_MILLIS))));
- } catch (NumberFormatException e) {
- minTimeout = Duration.ofMillis(DEFAULT_MIN_TIMEOUT_MILLIS);
- }
- MIN_TIMEOUT = minTimeout;
-
- Duration maxTimeout;
- try {
- maxTimeout = Duration.ofMillis(Long.parseLong(
- System.getProperty(MAX_TIMEOUT_PROPERTY,
- String.valueOf(DEFAULT_MAX_TIMEOUT_MILLIS))));
- } catch (NumberFormatException e) {
- maxTimeout = Duration.ofMillis(DEFAULT_MAX_TIMEOUT_MILLIS);
- }
- MAX_TIMEOUT = maxTimeout;
- }
-
- private final Logger log = getLogger(getClass());
-
- private final StoragePartition partition;
- private final MemberId localMemberId;
- private final RaftClientProtocol protocol;
- private RaftClient client;
- private final com.google.common.base.Supplier<AsyncConsistentMap<String, byte[]>> onosAtomicValuesMap =
- Suppliers.memoize(() -> newAsyncConsistentMap(ATOMIC_VALUES_CONSISTENT_MAP_NAME,
- Serializer.using(KryoNamespaces.BASIC)));
-
- public StoragePartitionClient(StoragePartition partition, MemberId localMemberId, RaftClientProtocol protocol) {
- this.partition = partition;
- this.localMemberId = localMemberId;
- this.protocol = protocol;
- }
-
- @Override
- public CompletableFuture<Void> open() {
- synchronized (StoragePartitionClient.this) {
- client = newRaftClient(protocol);
- }
- return client.connect(partition.getMemberIds()).whenComplete((r, e) -> {
- if (e == null) {
- log.info("Successfully started client for partition {}", partition.getId());
- } else {
- log.info("Failed to start client for partition {}", partition.getId(), e);
- }
- }).thenApply(v -> null);
- }
-
- @Override
- public CompletableFuture<Void> close() {
- return client != null ? client.close() : CompletableFuture.completedFuture(null);
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public <K, V> AsyncConsistentMap<K, V> newAsyncConsistentMap(ConsistentMapOptions options) {
- AtomixConsistentMap rawMap =
- new AtomixConsistentMap(client.newProxyBuilder()
- .withName(options.name())
- .withServiceType(DistributedPrimitive.Type.CONSISTENT_MAP.name())
- .withReadConsistency(ReadConsistency.SEQUENTIAL)
- .withCommunicationStrategy(CommunicationStrategy.ANY)
- .withMinTimeout(MIN_TIMEOUT)
- .withMaxTimeout(MAX_TIMEOUT)
- .withMaxRetries(MAX_RETRIES)
- .withRevision(options.version() != null && options.revisionType() != null
- ? options.version().toInt() : 1)
- .withPropagationStrategy(options.revisionType() != null
- ? PropagationStrategy.valueOf(options.revisionType().name())
- : PropagationStrategy.NONE)
- .build()
- .open()
- .join());
-
- if (options.serializer() != null) {
- return DistributedPrimitives.newTranscodingMap(rawMap,
- key -> HexString.toHexString(options.serializer().encode(key)),
- string -> options.serializer().decode(HexString.fromHexString(string)),
- value -> value == null ? null : options.serializer().encode(value),
- bytes -> options.serializer().decode(bytes));
- }
- return (AsyncConsistentMap<K, V>) rawMap;
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public <V> AsyncConsistentTreeMap<V> newAsyncConsistentTreeMap(ConsistentTreeMapOptions options) {
- AtomixConsistentTreeMap rawMap =
- new AtomixConsistentTreeMap(client.newProxyBuilder()
- .withName(options.name())
- .withServiceType(DistributedPrimitive.Type.CONSISTENT_TREEMAP.name())
- .withReadConsistency(ReadConsistency.SEQUENTIAL)
- .withCommunicationStrategy(CommunicationStrategy.ANY)
- .withMinTimeout(MIN_TIMEOUT)
- .withMaxTimeout(MAX_TIMEOUT)
- .withMaxRetries(MAX_RETRIES)
- .withRevision(options.version() != null && options.revisionType() != null
- ? options.version().toInt() : 1)
- .withPropagationStrategy(options.revisionType() != null
- ? PropagationStrategy.valueOf(options.revisionType().name())
- : PropagationStrategy.NONE)
- .build()
- .open()
- .join());
-
- if (options.serializer() != null) {
- return DistributedPrimitives.newTranscodingTreeMap(
- rawMap,
- value -> value == null ? null : options.serializer().encode(value),
- bytes -> options.serializer().decode(bytes));
- }
- return (AsyncConsistentTreeMap<V>) rawMap;
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public <K, V> AsyncConsistentMultimap<K, V> newAsyncConsistentSetMultimap(ConsistentMultimapOptions options) {
- AtomixConsistentSetMultimap rawMap =
- new AtomixConsistentSetMultimap(client.newProxyBuilder()
- .withName(options.name())
- .withServiceType(DistributedPrimitive.Type.CONSISTENT_MULTIMAP.name())
- .withReadConsistency(ReadConsistency.SEQUENTIAL)
- .withCommunicationStrategy(CommunicationStrategy.ANY)
- .withMinTimeout(MIN_TIMEOUT)
- .withMaxTimeout(MAX_TIMEOUT)
- .withMaxRetries(MAX_RETRIES)
- .withRevision(options.version() != null && options.revisionType() != null
- ? options.version().toInt() : 1)
- .withPropagationStrategy(options.revisionType() != null
- ? PropagationStrategy.valueOf(options.revisionType().name())
- : PropagationStrategy.NONE)
- .build()
- .open()
- .join());
-
- if (options.serializer() != null) {
- return DistributedPrimitives.newTranscodingMultimap(
- rawMap,
- key -> HexString.toHexString(options.serializer().encode(key)),
- string -> options.serializer().decode(HexString.fromHexString(string)),
- value -> options.serializer().encode(value),
- bytes -> options.serializer().decode(bytes));
- }
- return (AsyncConsistentMultimap<K, V>) rawMap;
- }
-
- @Override
- public <E> AsyncDistributedSet<E> newAsyncDistributedSet(DistributedSetOptions options) {
- return DistributedPrimitives.newSetFromMap(newAsyncConsistentMap(options.name(), options.serializer()));
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public <K> AsyncAtomicCounterMap<K> newAsyncAtomicCounterMap(AtomicCounterMapOptions options) {
- AtomixAtomicCounterMap rawMap = new AtomixAtomicCounterMap(client.newProxyBuilder()
- .withName(options.name())
- .withServiceType(DistributedPrimitive.Type.COUNTER_MAP.name())
- .withReadConsistency(ReadConsistency.LINEARIZABLE_LEASE)
- .withCommunicationStrategy(CommunicationStrategy.LEADER)
- .withMinTimeout(MIN_TIMEOUT)
- .withMaxTimeout(MAX_TIMEOUT)
- .withMaxRetries(MAX_RETRIES)
- .withRevision(options.version() != null && options.revisionType() != null
- ? options.version().toInt() : 1)
- .withPropagationStrategy(options.revisionType() != null
- ? PropagationStrategy.valueOf(options.revisionType().name())
- : PropagationStrategy.NONE)
- .build()
- .open()
- .join());
-
- if (options.serializer() != null) {
- return DistributedPrimitives.newTranscodingAtomicCounterMap(
- rawMap,
- key -> HexString.toHexString(options.serializer().encode(key)),
- string -> options.serializer().decode(HexString.fromHexString(string)));
- }
- return (AsyncAtomicCounterMap<K>) rawMap;
- }
-
- @Override
- public AsyncAtomicCounter newAsyncCounter(AtomicCounterOptions options) {
- return new AtomixCounter(client.newProxyBuilder()
- .withName(options.name())
- .withServiceType(DistributedPrimitive.Type.COUNTER.name())
- .withReadConsistency(ReadConsistency.LINEARIZABLE_LEASE)
- .withCommunicationStrategy(CommunicationStrategy.LEADER)
- .withMinTimeout(MIN_TIMEOUT)
- .withMaxTimeout(MAX_TIMEOUT)
- .withMaxRetries(MAX_RETRIES)
- .withRevision(options.version() != null && options.revisionType() != null
- ? options.version().toInt() : 1)
- .withPropagationStrategy(options.revisionType() != null
- ? PropagationStrategy.valueOf(options.revisionType().name())
- : PropagationStrategy.NONE)
- .build()
- .open()
- .join());
- }
-
- @Override
- public AsyncAtomicIdGenerator newAsyncIdGenerator(AtomicIdGeneratorOptions options) {
- return new AtomixIdGenerator(newAsyncCounter(options.name()));
- }
-
- @Override
- public <V> AsyncAtomicValue<V> newAsyncAtomicValue(AtomicValueOptions options) {
- return new DefaultAsyncAtomicValue<>(options.name(), options.serializer(), onosAtomicValuesMap.get());
- }
-
- @Override
- public <E> WorkQueue<E> newWorkQueue(WorkQueueOptions options) {
- AtomixWorkQueue atomixWorkQueue = new AtomixWorkQueue(client.newProxyBuilder()
- .withName(options.name())
- .withServiceType(DistributedPrimitive.Type.WORK_QUEUE.name())
- .withReadConsistency(ReadConsistency.LINEARIZABLE_LEASE)
- .withCommunicationStrategy(CommunicationStrategy.LEADER)
- .withMinTimeout(MIN_TIMEOUT)
- .withMaxTimeout(MAX_TIMEOUT)
- .withMaxRetries(MAX_RETRIES)
- .withRevision(options.version() != null && options.revisionType() != null
- ? options.version().toInt() : 1)
- .withPropagationStrategy(options.revisionType() != null
- ? PropagationStrategy.valueOf(options.revisionType().name())
- : PropagationStrategy.NONE)
- .build()
- .open()
- .join());
- return new DefaultDistributedWorkQueue<>(atomixWorkQueue, options.serializer());
- }
-
- @Override
- public <V> AsyncDocumentTree<V> newAsyncDocumentTree(DocumentTreeOptions options) {
- String serviceType = String.format("%s-%s", DistributedPrimitive.Type.DOCUMENT_TREE.name(), options.ordering());
- AtomixDocumentTree atomixDocumentTree = new AtomixDocumentTree(client.newProxyBuilder()
- .withName(options.name())
- .withServiceType(serviceType)
- .withReadConsistency(ReadConsistency.SEQUENTIAL)
- .withCommunicationStrategy(CommunicationStrategy.ANY)
- .withMinTimeout(MIN_TIMEOUT)
- .withMaxTimeout(MAX_TIMEOUT)
- .withMaxRetries(MAX_RETRIES)
- .withRevision(options.version() != null && options.revisionType() != null
- ? options.version().toInt() : 1)
- .withPropagationStrategy(options.revisionType() != null
- ? PropagationStrategy.valueOf(options.revisionType().name())
- : PropagationStrategy.NONE)
- .build()
- .open()
- .join());
- return new DefaultDistributedDocumentTree<>(options.name(), atomixDocumentTree, options.serializer());
- }
-
- @Override
- public AsyncDistributedLock newAsyncDistributedLock(DistributedLockOptions options) {
- return new AtomixDistributedLock(client.newProxyBuilder()
- .withName(options.name())
- .withServiceType(DistributedPrimitive.Type.LOCK.name())
- .withReadConsistency(ReadConsistency.LINEARIZABLE)
- .withCommunicationStrategy(CommunicationStrategy.LEADER)
- .withMinTimeout(MIN_TIMEOUT)
- .withMaxTimeout(MIN_TIMEOUT)
- .withMaxRetries(MAX_RETRIES)
- .withRevision(options.version() != null && options.revisionType() != null
- ? options.version().toInt() : 1)
- .withPropagationStrategy(options.revisionType() != null
- ? PropagationStrategy.valueOf(options.revisionType().name())
- : PropagationStrategy.NONE)
- .build()
- .open()
- .join());
- }
-
- @Override
- public AsyncLeaderElector newAsyncLeaderElector(LeaderElectorOptions options) {
- return new AtomixLeaderElector(client.newProxyBuilder()
- .withName(options.name())
- .withServiceType(DistributedPrimitive.Type.LEADER_ELECTOR.name())
- .withReadConsistency(ReadConsistency.LINEARIZABLE)
- .withCommunicationStrategy(CommunicationStrategy.LEADER)
- .withMinTimeout(Duration.ofMillis(options.electionTimeoutMillis()))
- .withMaxTimeout(MIN_TIMEOUT)
- .withMaxRetries(MAX_RETRIES)
- .withRevision(options.version() != null && options.revisionType() != null
- ? options.version().toInt() : 1)
- .withPropagationStrategy(options.revisionType() != null
- ? PropagationStrategy.valueOf(options.revisionType().name())
- : PropagationStrategy.NONE)
- .build()
- .open()
- .join());
- }
-
- @Override
- public Set<String> getAsyncConsistentMapNames() {
- return client.metadata().getSessions(DistributedPrimitive.Type.CONSISTENT_MAP.name())
- .join()
- .stream()
- .map(RaftSessionMetadata::serviceName)
- .collect(Collectors.toSet());
- }
-
- @Override
- public Set<String> getAsyncAtomicCounterNames() {
- return client.metadata().getSessions(DistributedPrimitive.Type.COUNTER.name())
- .join()
- .stream()
- .map(RaftSessionMetadata::serviceName)
- .collect(Collectors.toSet());
- }
-
- @Override
- public Set<String> getWorkQueueNames() {
- return client.metadata().getSessions(DistributedPrimitive.Type.WORK_QUEUE.name())
- .join()
- .stream()
- .map(RaftSessionMetadata::serviceName)
- .collect(Collectors.toSet());
- }
-
- @Override
- public boolean isOpen() {
- return client != null;
- }
-
- /**
- * Returns the {@link PartitionClientInfo information} for this client.
- * @return partition client information
- */
- public PartitionClientInfo clientInfo() {
- return new PartitionClientInfo(partition.getId(), partition.getMembers());
- }
-
- private RaftClient newRaftClient(RaftClientProtocol protocol) {
- return RaftClient.newBuilder()
- .withClientId("partition-" + partition.getId())
- .withMemberId(localMemberId)
- .withProtocol(protocol)
- .build();
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StoragePartitionDetails.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StoragePartitionDetails.java
deleted file mode 100644
index 1bed89d..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StoragePartitionDetails.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.Set;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-import io.atomix.protocols.raft.cluster.RaftMember;
-import org.onosproject.cluster.PartitionId;
-import org.onosproject.store.service.PartitionInfo;
-
-import com.google.common.base.MoreObjects;
-import com.google.common.collect.ImmutableSet;
-
-/**
- * Operational details for a {@code StoragePartition}.
- */
-public class StoragePartitionDetails {
-
- private final PartitionId partitionId;
- private final Set<RaftMember> activeMembers;
- private final Set<RaftMember> configuredMembers;
- private final RaftMember leader;
- private final long leaderTerm;
-
- public StoragePartitionDetails(PartitionId partitionId,
- Collection<RaftMember> activeMembers,
- Collection<RaftMember> configuredMembers,
- RaftMember leader,
- long leaderTerm) {
- this.partitionId = partitionId;
- this.activeMembers = ImmutableSet.copyOf(activeMembers);
- this.configuredMembers = ImmutableSet.copyOf(configuredMembers);
- this.leader = leader;
- this.leaderTerm = leaderTerm;
- }
-
- /**
- * Returns the set of active members.
- * @return active members
- */
- public Set<RaftMember> activeMembers() {
- return activeMembers;
- }
-
- /**
- * Returns the set of configured members.
- * @return configured members
- */
- public Set<RaftMember> configuredMembers() {
- return configuredMembers;
- }
-
- /**
- * Returns the partition leader.
- * @return leader
- */
- public RaftMember leader() {
- return leader;
- }
-
- /**
- * Returns the partition leader term.
- * @return leader term
- */
- public long leaderTerm() {
- return leaderTerm;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("activeMembers", activeMembers)
- .add("configuredMembers", configuredMembers)
- .add("leader", leader)
- .add("leaderTerm", leaderTerm)
- .toString();
- }
-
- /**
- * Returns the details as an instance of {@code PartitionInfo}.
- * @return partition info
- */
- public PartitionInfo toPartitionInfo() {
- Function<RaftMember, String> memberToString =
- m -> m == null ? "none" : m.memberId().toString();
- return new PartitionInfo(partitionId,
- leaderTerm,
- activeMembers.stream().map(memberToString).collect(Collectors.toList()),
- memberToString.apply(leader));
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StoragePartitionServer.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StoragePartitionServer.java
deleted file mode 100644
index f2600e8..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/StoragePartitionServer.java
+++ /dev/null
@@ -1,340 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.FileVisitResult;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.SimpleFileVisitor;
-import java.nio.file.attribute.BasicFileAttributes;
-import java.time.Duration;
-import java.util.Collection;
-import java.util.concurrent.CompletableFuture;
-import java.util.stream.Collectors;
-
-import io.atomix.protocols.raft.RaftServer;
-import io.atomix.protocols.raft.cluster.MemberId;
-import io.atomix.protocols.raft.storage.RaftStorage;
-import io.atomix.storage.StorageLevel;
-import org.onosproject.cluster.Partition;
-import org.onosproject.store.cluster.messaging.ClusterCommunicationService;
-import org.onosproject.store.primitives.resources.impl.AtomixSerializerAdapter;
-import org.onosproject.store.service.PartitionInfo;
-import org.onosproject.store.service.Serializer;
-import org.slf4j.Logger;
-
-import static org.slf4j.LoggerFactory.getLogger;
-
-/**
- * {@link StoragePartition} server.
- */
-public class StoragePartitionServer implements Managed<StoragePartitionServer> {
-
- private final Logger log = getLogger(getClass());
-
- private static final String ELECTION_TIMEOUT_MILLIS_PROPERTY = "onos.cluster.raft.electionTimeoutMillis";
- private static final String ELECTION_THRESHOLD_PROPERTY = "onos.cluster.raft.electionFailureThreshold";
- private static final String SESSION_THRESHOLD_PROPERTY = "onos.cluster.raft.sessionFailureThreshold";
- private static final String HEARTBEAT_INTERVAL_MILLIS_PROPERTY = "onos.cluster.raft.heartbeatIntervalMillis";
- private static final String MAX_SEGMENT_SIZE_PROPERTY = "onos.cluster.raft.storage.maxSegmentSize";
- private static final String STORAGE_LEVEL_PROPERTY = "onos.cluster.raft.storage.level";
- private static final String FLUSH_ON_COMMIT_PROPERTY = "onos.cluster.raft.storage.flushOnCommit";
-
- private static final long ELECTION_TIMEOUT_MILLIS;
- private static final int ELECTION_THRESHOLD;
- private static final int SESSION_THRESHOLD;
- private static final long HEARTBEAT_INTERVAL_MILLIS;
- private static final int MAX_SEGMENT_SIZE;
- private static final StorageLevel STORAGE_LEVEL;
- private static final boolean FLUSH_ON_COMMIT;
-
- private static final int DEFAULT_MAX_SEGMENT_SIZE = 1024 * 1024 * 64;
- private static final long DEFAULT_ELECTION_TIMEOUT_MILLIS = 2500;
- private static final int DEFAULT_ELECTION_THRESHOLD = 12;
- private static final int DEFAULT_SESSION_THRESHOLD = 10;
- private static final long DEFAULT_HEARTBEAT_INTERVAL_MILLIS = 500;
- private static final StorageLevel DEFAULT_STORAGE_LEVEL = StorageLevel.MAPPED;
- private static final boolean DEFAULT_FLUSH_ON_COMMIT = false;
-
- static {
- int maxSegmentSize;
- try {
- maxSegmentSize = Integer.parseInt(System.getProperty(
- MAX_SEGMENT_SIZE_PROPERTY,
- String.valueOf(DEFAULT_MAX_SEGMENT_SIZE)));
- } catch (NumberFormatException e) {
- maxSegmentSize = DEFAULT_MAX_SEGMENT_SIZE;
- }
- MAX_SEGMENT_SIZE = maxSegmentSize;
-
- long electionTimeoutMillis;
- try {
- electionTimeoutMillis = Long.parseLong(System.getProperty(
- ELECTION_TIMEOUT_MILLIS_PROPERTY,
- String.valueOf(DEFAULT_ELECTION_TIMEOUT_MILLIS)));
- } catch (NumberFormatException e) {
- electionTimeoutMillis = DEFAULT_ELECTION_TIMEOUT_MILLIS;
- }
- ELECTION_TIMEOUT_MILLIS = electionTimeoutMillis;
-
- int electionFailureThreshold;
- try {
- electionFailureThreshold = Integer.parseInt(System.getProperty(
- ELECTION_THRESHOLD_PROPERTY,
- String.valueOf(DEFAULT_ELECTION_THRESHOLD)));
- } catch (NumberFormatException e) {
- electionFailureThreshold = DEFAULT_ELECTION_THRESHOLD;
- }
- ELECTION_THRESHOLD = electionFailureThreshold;
-
- int sessionFailureThreshold;
- try {
- sessionFailureThreshold = Integer.parseInt(System.getProperty(
- SESSION_THRESHOLD_PROPERTY,
- String.valueOf(DEFAULT_SESSION_THRESHOLD)));
- } catch (NumberFormatException e) {
- sessionFailureThreshold = DEFAULT_SESSION_THRESHOLD;
- }
- SESSION_THRESHOLD = sessionFailureThreshold;
-
- long heartbeatIntervalMillis;
- try {
- heartbeatIntervalMillis = Long.parseLong(System.getProperty(
- HEARTBEAT_INTERVAL_MILLIS_PROPERTY,
- String.valueOf(DEFAULT_HEARTBEAT_INTERVAL_MILLIS)));
- } catch (NumberFormatException e) {
- heartbeatIntervalMillis = DEFAULT_HEARTBEAT_INTERVAL_MILLIS;
- }
- HEARTBEAT_INTERVAL_MILLIS = heartbeatIntervalMillis;
-
- StorageLevel storageLevel;
- try {
- storageLevel = StorageLevel.valueOf(System.getProperty(
- STORAGE_LEVEL_PROPERTY,
- DEFAULT_STORAGE_LEVEL.name()).toUpperCase());
- } catch (IllegalArgumentException e) {
- storageLevel = DEFAULT_STORAGE_LEVEL;
- }
- STORAGE_LEVEL = storageLevel;
-
- boolean flushOnCommit;
- try {
- flushOnCommit = Boolean.parseBoolean(System.getProperty(
- FLUSH_ON_COMMIT_PROPERTY,
- String.valueOf(DEFAULT_FLUSH_ON_COMMIT)));
- } catch (Exception e) {
- flushOnCommit = DEFAULT_FLUSH_ON_COMMIT;
- }
- FLUSH_ON_COMMIT = flushOnCommit;
- }
-
- private final MemberId localMemberId;
- private final StoragePartition partition;
- private final ClusterCommunicationService clusterCommunicator;
- private RaftServer server;
-
- public StoragePartitionServer(
- StoragePartition partition,
- MemberId localMemberId,
- ClusterCommunicationService clusterCommunicator) {
- this.partition = partition;
- this.localMemberId = localMemberId;
- this.clusterCommunicator = clusterCommunicator;
- }
-
- @Override
- public CompletableFuture<Void> open() {
- log.info("Starting server for partition {} ({})", partition.getId(), partition.getVersion());
- CompletableFuture<RaftServer> serverOpenFuture;
- if (partition.getMemberIds().contains(localMemberId)) {
- if (server != null && server.isRunning()) {
- return CompletableFuture.completedFuture(null);
- }
- synchronized (this) {
- server = buildServer();
- }
- serverOpenFuture = server.bootstrap(partition.getMemberIds());
- } else {
- serverOpenFuture = CompletableFuture.completedFuture(null);
- }
- return serverOpenFuture.whenComplete((r, e) -> {
- if (e == null) {
- log.info("Successfully started server for partition {} ({})",
- partition.getId(), partition.getVersion());
- } else {
- log.info("Failed to start server for partition {} ({})",
- partition.getId(), partition.getVersion(), e);
- }
- }).thenApply(v -> null);
- }
-
- @Override
- public CompletableFuture<Void> close() {
- return server.shutdown();
- }
-
- /**
- * Closes the server and exits the partition.
- * @return future that is completed when the operation is complete
- */
- public CompletableFuture<Void> closeAndExit() {
- return server.leave();
- }
-
- /**
- * Deletes the server.
- */
- public void delete() {
- try {
- Files.walkFileTree(partition.getDataFolder().toPath(), new SimpleFileVisitor<Path>() {
- @Override
- public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
- Files.delete(file);
- return FileVisitResult.CONTINUE;
- }
- @Override
- public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
- Files.delete(dir);
- return FileVisitResult.CONTINUE;
- }
- });
- } catch (IOException e) {
- log.error("Failed to delete partition: {}", e);
- }
- }
-
- /**
- * Forks the existing partition into a new partition.
- *
- * @param fromPartition the partition from which to fork the server
- * @return future to be completed once the fork operation is complete
- */
- public CompletableFuture<Void> fork(Partition fromPartition) {
- log.info("Forking server for partition {} ({}->{})",
- partition.getId(), fromPartition.getVersion(), partition.getVersion());
- RaftServer.Builder builder = RaftServer.newBuilder(localMemberId)
- .withName(String.format("partition-%s", fromPartition.getId()))
- .withProtocol(new RaftServerCommunicator(
- String.format("partition-%s-%s", fromPartition.getId(), fromPartition.getVersion()),
- Serializer.using(StorageNamespaces.RAFT_PROTOCOL),
- clusterCommunicator))
- .withElectionTimeout(Duration.ofMillis(ELECTION_TIMEOUT_MILLIS))
- .withHeartbeatInterval(Duration.ofMillis(HEARTBEAT_INTERVAL_MILLIS))
- .withElectionThreshold(ELECTION_THRESHOLD)
- .withSessionFailureThreshold(SESSION_THRESHOLD)
- .withStorage(RaftStorage.newBuilder()
- .withPrefix(String.format("partition-%s", partition.getId()))
- .withStorageLevel(STORAGE_LEVEL)
- .withFlushOnCommit(FLUSH_ON_COMMIT)
- .withSerializer(new AtomixSerializerAdapter(Serializer.using(StorageNamespaces.RAFT_STORAGE)))
- .withDirectory(partition.getDataFolder())
- .withMaxSegmentSize(MAX_SEGMENT_SIZE)
- .build());
- StoragePartition.RAFT_SERVICES.forEach(builder::addService);
- RaftServer server = builder.build();
-
- // Create a collection of members currently in the source partition.
- Collection<MemberId> members = fromPartition.getMembers()
- .stream()
- .map(id -> MemberId.from(id.id()))
- .collect(Collectors.toList());
-
- // If this node is a member of the partition, join the partition. Otherwise, listen to the partition.
- CompletableFuture<RaftServer> future = members.contains(localMemberId)
- ? server.bootstrap(members) : server.listen(members);
-
- // TODO: We should leave the cluster for nodes that aren't normally members to ensure the source
- // cluster's configuration is kept consistent for rolling back upgrades, but Atomix deletes configuration
- // files when a node leaves the cluster so we can't do that here.
- return future.thenCompose(v -> server.shutdown())
- .thenCompose(v -> {
- // Delete the cluster configuration file from the forked partition.
- try {
- Files.delete(new File(
- partition.getDataFolder(),
- String.format("partition-%s.conf", partition.getId())).toPath());
- } catch (IOException e) {
- log.error("Failed to delete partition configuration: {}", e);
- }
-
- // Build and bootstrap a new server.
- this.server = buildServer();
- return this.server.bootstrap();
- }).whenComplete((r, e) -> {
- if (e == null) {
- log.info("Successfully forked server for partition {} ({}->{})",
- partition.getId(), fromPartition.getVersion(), partition.getVersion());
- } else {
- log.info("Failed to fork server for partition {} ({}->{})",
- partition.getId(), fromPartition.getVersion(), partition.getVersion(), e);
- }
- }).thenApply(v -> null);
- }
-
- private RaftServer buildServer() {
- RaftServer.Builder builder = RaftServer.newBuilder(localMemberId)
- .withName(String.format("partition-%s", partition.getId()))
- .withProtocol(new RaftServerCommunicator(
- String.format("partition-%s-%s", partition.getId(), partition.getVersion()),
- Serializer.using(StorageNamespaces.RAFT_PROTOCOL),
- clusterCommunicator))
- .withElectionTimeout(Duration.ofMillis(ELECTION_TIMEOUT_MILLIS))
- .withHeartbeatInterval(Duration.ofMillis(HEARTBEAT_INTERVAL_MILLIS))
- .withElectionThreshold(ELECTION_THRESHOLD)
- .withSessionFailureThreshold(SESSION_THRESHOLD)
- .withStorage(RaftStorage.newBuilder()
- .withPrefix(String.format("partition-%s", partition.getId()))
- .withStorageLevel(STORAGE_LEVEL)
- .withFlushOnCommit(FLUSH_ON_COMMIT)
- .withSerializer(new AtomixSerializerAdapter(Serializer.using(StorageNamespaces.RAFT_STORAGE)))
- .withDirectory(partition.getDataFolder())
- .withMaxSegmentSize(MAX_SEGMENT_SIZE)
- .build());
- StoragePartition.RAFT_SERVICES.forEach(builder::addService);
- return builder.build();
- }
-
- public CompletableFuture<Void> join(Collection<MemberId> otherMembers) {
- log.info("Joining partition {} ({})", partition.getId(), partition.getName());
- server = buildServer();
- return server.join(otherMembers).whenComplete((r, e) -> {
- if (e == null) {
- log.info("Successfully joined partition {} ({})", partition.getId(), partition.getName());
- } else {
- log.info("Failed to join partition {} ({})", partition.getId(), partition.getName(), e);
- }
- }).thenApply(v -> null);
- }
-
- @Override
- public boolean isOpen() {
- return server.isRunning();
- }
-
- /**
- * Returns the partition information.
- * @return partition info
- */
- public PartitionInfo info() {
- return new StoragePartitionDetails(partition.getId(),
- server.cluster().getMembers(),
- server.cluster().getMembers(),
- server.cluster().getLeader(),
- server.cluster().getTerm()).toPartitionInfo();
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/Transaction.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/Transaction.java
deleted file mode 100644
index 28074e2..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/Transaction.java
+++ /dev/null
@@ -1,296 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Transactional;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.TransactionContext;
-import org.onosproject.store.service.TransactionException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-import static com.google.common.base.Preconditions.checkState;
-
-/**
- * Manages a transaction within the context of a single primitive.
- * <p>
- * The {@code Transaction} object is used to manage the transaction for a single partition primitive that implements
- * the {@link Transactional} interface. It's used as a proxy for {@link TransactionContext}s to manage the transaction
- * as it relates to a single piece of atomic state.
- */
-public class Transaction<T> {
-
- /**
- * Transaction state.
- * <p>
- * The transaction state is used to indicate the phase within which the transaction is currently running.
- */
- enum State {
-
- /**
- * Active transaction state.
- * <p>
- * The {@code ACTIVE} state represents a transaction in progress. Active transactions may or may not affect
- * concurrently running transactions depending on the transaction's isolation level.
- */
- ACTIVE,
-
- /**
- * Preparing transaction state.
- * <p>
- * Once a transaction commitment begins, it enters the {@code PREPARING} phase of the two-phase commit protocol.
- */
- PREPARING,
-
- /**
- * Prepared transaction state.
- * <p>
- * Once the first phase of the two-phase commit protocol is complete, the transaction's state is set to
- * {@code PREPARED}.
- */
- PREPARED,
-
- /**
- * Committing transaction state.
- * <p>
- * The {@code COMMITTING} state represents a transaction within the second phase of the two-phase commit
- * protocol.
- */
- COMMITTING,
-
- /**
- * Committed transaction state.
- * <p>
- * Once the second phase of the two-phase commit protocol is complete, the transaction's state is set to
- * {@code COMMITTED}.
- */
- COMMITTED,
-
- /**
- * Rolling back transaction state.
- * <p>
- * In the event of a two-phase lock failure, when the transaction is rolled back it will enter the
- * {@code ROLLING_BACK} state while the rollback is in progress.
- */
- ROLLING_BACK,
-
- /**
- * Rolled back transaction state.
- * <p>
- * Once a transaction has been rolled back, it will enter the {@code ROLLED_BACK} state.
- */
- ROLLED_BACK,
- }
-
- private static final String TX_OPEN_ERROR = "transaction already open";
- private static final String TX_CLOSED_ERROR = "transaction not open";
- private static final String TX_INACTIVE_ERROR = "transaction is not active";
- private static final String TX_UNPREPARED_ERROR = "transaction has not been prepared";
-
- protected final Logger log = LoggerFactory.getLogger(getClass());
- protected final TransactionId transactionId;
- protected final Transactional<T> transactionalObject;
- private final AtomicBoolean open = new AtomicBoolean();
- private volatile State state = State.ACTIVE;
- private volatile Version lock;
-
- public Transaction(TransactionId transactionId, Transactional<T> transactionalObject) {
- this.transactionId = transactionId;
- this.transactionalObject = transactionalObject;
- }
-
- /**
- * Returns the transaction identifier.
- *
- * @return the transaction identifier
- */
- public TransactionId transactionId() {
- return transactionId;
- }
-
- /**
- * Returns the current transaction state.
- *
- * @return the current transaction state
- */
- public State state() {
- return state;
- }
-
- /**
- * Returns a boolean indicating whether the transaction is open.
- *
- * @return indicates whether the transaction is open
- */
- public boolean isOpen() {
- return open.get();
- }
-
- /**
- * Opens the transaction, throwing an {@link IllegalStateException} if it's already open.
- */
- protected void open() {
- if (!open.compareAndSet(false, true)) {
- throw new IllegalStateException(TX_OPEN_ERROR);
- }
- }
-
- /**
- * Checks that the transaction is open and throws an {@link IllegalStateException} if not.
- */
- protected void checkOpen() {
- checkState(isOpen(), TX_CLOSED_ERROR);
- }
-
- /**
- * Checks that the transaction state is {@code ACTIVE} and throws an {@link IllegalStateException} if not.
- */
- protected void checkActive() {
- checkState(state == State.ACTIVE, TX_INACTIVE_ERROR);
- }
-
- /**
- * Checks that the transaction state is {@code PREPARED} and throws an {@link IllegalStateException} if not.
- */
- protected void checkPrepared() {
- checkState(state == State.PREPARED, TX_UNPREPARED_ERROR);
- }
-
- /**
- * Updates the transaction state.
- *
- * @param state the updated transaction state
- */
- protected void setState(State state) {
- this.state = state;
- }
-
- /**
- * Begins the transaction.
- * <p>
- * Locks are acquired when the transaction is begun to prevent concurrent transactions from operating on the shared
- * resource to which this transaction relates.
- *
- * @return a completable future to be completed once the transaction has been started
- */
- public CompletableFuture<Version> begin() {
- log.debug("Beginning transaction {} for {}", transactionId, transactionalObject);
- open();
- return transactionalObject.begin(transactionId).thenApply(lock -> {
- this.lock = lock;
- log.trace("Transaction lock acquired: {}", lock);
- return lock;
- });
- }
-
- /**
- * Prepares the transaction.
- * <p>
- * When preparing the transaction, the given list of updates for the shared resource will be prepared, and
- * concurrent modification checks will be performed. The returned future may be completed with a
- * {@link TransactionException} if a concurrent modification is detected for an isolation level that does
- * not allow such modifications.
- *
- * @param updates the transaction updates
- * @return a completable future to be completed once the transaction has been prepared
- */
- public CompletableFuture<Boolean> prepare(List<T> updates) {
- checkOpen();
- checkActive();
- log.debug("Preparing transaction {} for {}", transactionId, transactionalObject);
- Version lock = this.lock;
- checkState(lock != null, TX_INACTIVE_ERROR);
- setState(State.PREPARING);
- return transactionalObject.prepare(new TransactionLog<T>(transactionId, lock.value(), updates))
- .thenApply(succeeded -> {
- setState(State.PREPARED);
- return succeeded;
- });
- }
-
- /**
- * Prepares and commits the transaction in a single atomic operation.
- * <p>
- * Both the prepare and commit phases of the protocol must be executed within a single atomic operation. This method
- * is used to optimize committing transactions that operate only on a single partition within a single primitive.
- *
- * @param updates the transaction updates
- * @return a completable future to be completed once the transaction has been prepared
- */
- public CompletableFuture<Boolean> prepareAndCommit(List<T> updates) {
- checkOpen();
- checkActive();
- log.debug("Preparing and committing transaction {} for {}", transactionId, transactionalObject);
- Version lock = this.lock;
- checkState(lock != null, TX_INACTIVE_ERROR);
- setState(State.PREPARING);
- return transactionalObject.prepareAndCommit(new TransactionLog<T>(transactionId, lock.value(), updates))
- .thenApply(succeeded -> {
- setState(State.COMMITTED);
- return succeeded;
- });
- }
-
- /**
- * Commits the transaction.
- * <p>
- * Performs the second phase of the two-phase commit protocol, committing the previously
- * {@link #prepare(List) prepared} updates.
- *
- * @return a completable future to be completed once the transaction has been committed
- */
- public CompletableFuture<Void> commit() {
- checkOpen();
- checkPrepared();
- log.debug("Committing transaction {} for {}", transactionId, transactionalObject);
- setState(State.COMMITTING);
- return transactionalObject.commit(transactionId).thenRun(() -> {
- setState(State.COMMITTED);
- });
- }
-
- /**
- * Rolls back the transaction.
- * <p>
- * Rolls back the first phase of the two-phase commit protocol, cancelling prepared updates.
- *
- * @return a completable future to be completed once the transaction has been rolled back
- */
- public CompletableFuture<Void> rollback() {
- checkOpen();
- checkPrepared();
- log.debug("Rolling back transaction {} for {}", transactionId, transactionalObject);
- setState(State.ROLLING_BACK);
- return transactionalObject.rollback(transactionId).thenRun(() -> {
- setState(State.ROLLED_BACK);
- });
- }
-
- @Override
- public String toString() {
- return toStringHelper(this)
- .add("transactionId", transactionId)
- .add("state", state)
- .toString();
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TransactionCoordinator.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TransactionCoordinator.java
deleted file mode 100644
index 23d4399..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TransactionCoordinator.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.stream.Collectors;
-
-import com.google.common.collect.Sets;
-import org.onlab.util.Tools;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.CommitStatus;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.TransactionalMap;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-
-/**
- * Transaction coordinator.
- */
-public class TransactionCoordinator {
- private final Logger log = LoggerFactory.getLogger(getClass());
- protected final TransactionId transactionId;
- protected final TransactionManager transactionManager;
- protected final Set<TransactionParticipant> transactionParticipants = Sets.newConcurrentHashSet();
-
- public TransactionCoordinator(TransactionId transactionId, TransactionManager transactionManager) {
- this.transactionId = transactionId;
- this.transactionManager = transactionManager;
- }
-
- /**
- * Returns a transactional map for this transaction.
- *
- * @param name the transactional map name
- * @param serializer the serializer
- * @param <K> key type
- * @param <V> value type
- * @return a transactional map for this transaction
- */
- public <K, V> TransactionalMap<K, V> getTransactionalMap(String name, Serializer serializer) {
- PartitionedTransactionalMap<K, V> map = transactionManager.getTransactionalMap(name, serializer, this);
- transactionParticipants.addAll(map.participants());
- return map;
- }
-
- /**
- * Commits the transaction.
- *
- * @return the transaction commit status
- */
- public CompletableFuture<CommitStatus> commit() {
- long totalParticipants = transactionParticipants.stream()
- .filter(TransactionParticipant::hasPendingUpdates)
- .count();
-
- if (totalParticipants == 0) {
- log.debug("No transaction participants, skipping commit", totalParticipants);
- return CompletableFuture.completedFuture(CommitStatus.SUCCESS);
- } else if (totalParticipants == 1) {
- log.debug("Committing transaction {} via 1 participant", transactionId);
- return transactionParticipants.stream()
- .filter(TransactionParticipant::hasPendingUpdates)
- .findFirst()
- .get()
- .prepareAndCommit()
- .thenApply(v -> v ? CommitStatus.SUCCESS : CommitStatus.FAILURE);
- } else {
- log.debug("Committing transaction {} via {} participants", transactionId, totalParticipants);
- Set<TransactionParticipant> transactionParticipants = this.transactionParticipants.stream()
- .filter(TransactionParticipant::hasPendingUpdates)
- .collect(Collectors.toSet());
-
- CompletableFuture<CommitStatus> status = transactionManager.updateState(
- transactionId, Transaction.State.PREPARING)
- .thenCompose(v -> prepare(transactionParticipants))
- .thenCompose(result -> result
- ? transactionManager.updateState(transactionId, Transaction.State.COMMITTING)
- .thenCompose(v -> commit(transactionParticipants))
- .thenApply(v -> CommitStatus.SUCCESS)
- : transactionManager.updateState(transactionId, Transaction.State.ROLLING_BACK)
- .thenCompose(v -> rollback(transactionParticipants))
- .thenApply(v -> CommitStatus.FAILURE));
- return status.thenCompose(v -> transactionManager.remove(transactionId).thenApply(u -> v));
- }
- }
-
- /**
- * Performs the prepare phase of the two-phase commit protocol for the given transaction participants.
- *
- * @param transactionParticipants the transaction participants for which to prepare the transaction
- * @return a completable future indicating whether <em>all</em> prepares succeeded
- */
- protected CompletableFuture<Boolean> prepare(Set<TransactionParticipant> transactionParticipants) {
- log.trace("Preparing transaction {} via {}", transactionId, transactionParticipants);
- return Tools.allOf(transactionParticipants.stream()
- .map(TransactionParticipant::prepare)
- .collect(Collectors.toList()))
- .thenApply(list -> list.stream().reduce(Boolean::logicalAnd).orElse(true));
- }
-
- /**
- * Performs the commit phase of the two-phase commit protocol for the given transaction participants.
- *
- * @param transactionParticipants the transaction participants for which to commit the transaction
- * @return a completable future to be completed once the commits are complete
- */
- protected CompletableFuture<Void> commit(Set<TransactionParticipant> transactionParticipants) {
- log.trace("Committing transaction {} via {}", transactionId, transactionParticipants);
- return CompletableFuture.allOf(transactionParticipants.stream()
- .map(TransactionParticipant::commit)
- .toArray(CompletableFuture[]::new));
- }
-
- /**
- * Rolls back transactions for the given participants.
- *
- * @param transactionParticipants the transaction participants for which to roll back the transaction
- * @return a completable future to be completed once the rollbacks are complete
- */
- protected CompletableFuture<Void> rollback(Set<TransactionParticipant> transactionParticipants) {
- log.trace("Rolling back transaction {} via {}", transactionId, transactionParticipants);
- return CompletableFuture.allOf(transactionParticipants.stream()
- .map(TransactionParticipant::rollback)
- .toArray(CompletableFuture[]::new));
- }
-
- @Override
- public String toString() {
- return toStringHelper(this)
- .add("transactionId", transactionId)
- .add("participants", transactionParticipants)
- .toString();
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TransactionManager.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TransactionManager.java
deleted file mode 100644
index 7d8d4c4..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TransactionManager.java
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
-
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.hash.Hashing;
-import com.google.common.util.concurrent.Futures;
-import org.onosproject.cluster.PartitionId;
-import org.onosproject.store.primitives.MapUpdate;
-import org.onosproject.store.primitives.PartitionService;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.StorageService;
-import org.onosproject.store.service.TransactionException;
-
-/**
- * Transaction manager for managing state shared across multiple transactions.
- */
-public class TransactionManager {
- private static final int DEFAULT_CACHE_SIZE = 100;
-
- private final PartitionService partitionService;
- private final List<PartitionId> sortedPartitions;
- private final AsyncConsistentMap<TransactionId, Transaction.State> transactions;
- private final long cacheSize;
- private final int buckets;
- private final Map<PartitionId, Cache<String, CachedMap>> partitionCache = Maps.newConcurrentMap();
-
- public TransactionManager(StorageService storageService, PartitionService partitionService, int buckets) {
- this(storageService, partitionService, DEFAULT_CACHE_SIZE, buckets);
- }
-
- public TransactionManager(
- StorageService storageService,
- PartitionService partitionService,
- int cacheSize,
- int buckets) {
- this.partitionService = partitionService;
- this.cacheSize = cacheSize;
- this.buckets = buckets;
- this.transactions = storageService.<TransactionId, Transaction.State>consistentMapBuilder()
- .withName("onos-transactions")
- .withSerializer(Serializer.using(KryoNamespaces.API,
- Transaction.class,
- Transaction.State.class))
- .buildAsyncMap();
- this.sortedPartitions = Lists.newArrayList(partitionService.getAllPartitionIds());
- Collections.sort(sortedPartitions);
- }
-
- /**
- * Returns the collection of currently pending transactions.
- *
- * @return a collection of currently pending transactions
- */
- public Collection<TransactionId> getPendingTransactions() {
- return Futures.getUnchecked(transactions.keySet());
- }
-
- /**
- * Returns a partitioned transactional map for use within a transaction context.
- * <p>
- * The transaction coordinator will return a map that takes advantage of caching that's shared across transaction
- * contexts.
- *
- * @param name the map name
- * @param serializer the map serializer
- * @param transactionCoordinator the transaction coordinator for which the map is being created
- * @param <K> key type
- * @param <V> value type
- * @return a partitioned transactional map
- */
- <K, V> PartitionedTransactionalMap<K, V> getTransactionalMap(
- String name,
- Serializer serializer,
- TransactionCoordinator transactionCoordinator) {
- Map<PartitionId, TransactionalMapParticipant<K, V>> partitions = new HashMap<>();
- for (PartitionId partitionId : partitionService.getAllPartitionIds()) {
- partitions.put(partitionId, getTransactionalMapPartition(
- name, partitionId, serializer, transactionCoordinator));
- }
-
- Hasher<K> hasher = key -> {
- int bucket = Math.abs(Hashing.murmur3_32().hashBytes(serializer.encode(key)).asInt()) % buckets;
- int partition = Hashing.consistentHash(bucket, sortedPartitions.size());
- return sortedPartitions.get(partition);
- };
- return new PartitionedTransactionalMap<>(partitions, hasher);
- }
-
- @SuppressWarnings("unchecked")
- private <K, V> TransactionalMapParticipant<K, V> getTransactionalMapPartition(
- String mapName,
- PartitionId partitionId,
- Serializer serializer,
- TransactionCoordinator transactionCoordinator) {
- Cache<String, CachedMap> mapCache = partitionCache.computeIfAbsent(partitionId, p ->
- CacheBuilder.newBuilder().maximumSize(cacheSize / partitionService.getNumberOfPartitions()).build());
- try {
- CachedMap<K, V> cachedMap = mapCache.get(mapName,
- () -> new CachedMap<>(partitionService.getDistributedPrimitiveCreator(partitionId)
- .newAsyncConsistentMap(mapName, serializer)));
-
- Transaction<MapUpdate<K, V>> transaction = new Transaction<>(
- transactionCoordinator.transactionId,
- cachedMap.baseMap);
- return new DefaultTransactionalMapParticipant<>(cachedMap.cachedMap.asConsistentMap(), transaction);
- } catch (ExecutionException e) {
- throw new TransactionException(e);
- }
- }
-
- /**
- * Updates the state of a transaction in the transaction registry.
- *
- * @param transactionId the transaction identifier
- * @param state the state of the transaction
- * @return a completable future to be completed once the transaction state has been updated in the registry
- */
- CompletableFuture<Void> updateState(TransactionId transactionId, Transaction.State state) {
- return transactions.put(transactionId, state).thenApply(v -> null);
- }
-
- /**
- * Removes the given transaction from the transaction registry.
- *
- * @param transactionId the transaction identifier
- * @return a completable future to be completed once the transaction state has been removed from the registry
- */
- CompletableFuture<Void> remove(TransactionId transactionId) {
- return transactions.remove(transactionId).thenApply(v -> null);
- }
-
- private static class CachedMap<K, V> {
- private final AsyncConsistentMap<K, V> baseMap;
- private final AsyncConsistentMap<K, V> cachedMap;
-
- public CachedMap(AsyncConsistentMap<K, V> baseMap) {
- this.baseMap = baseMap;
- this.cachedMap = DistributedPrimitives.newCachingMap(baseMap);
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TransactionParticipant.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TransactionParticipant.java
deleted file mode 100644
index 02da9d9..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TransactionParticipant.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.concurrent.CompletableFuture;
-
-/**
- * Participant in a two-phase commit protocol.
- */
-public interface TransactionParticipant {
-
- /**
- * Returns a boolean indicating whether the participant has pending updates.
- *
- * @return indicates whether the participant has pending updates
- */
- boolean hasPendingUpdates();
-
- /**
- * Executes the prepare phase.
- *
- * @return {@code true} is successful; {@code false} otherwise
- */
- CompletableFuture<Boolean> prepare();
-
- /**
- * Attempts to execute the commit phase for previously prepared transaction.
- *
- * @return future that is completed when the operation completes
- */
- CompletableFuture<Void> commit();
-
- /**
- * Executes the prepare and commit phases atomically.
- *
- * @return {@code true} is successful; {@code false} otherwise
- */
- CompletableFuture<Boolean> prepareAndCommit();
-
- /**
- * Attempts to execute the rollback phase for previously prepared transaction.
- *
- * @return future that is completed when the operation completes
- */
- CompletableFuture<Void> rollback();
-
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TransactionalMapParticipant.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TransactionalMapParticipant.java
deleted file mode 100644
index 3cb87a4..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TransactionalMapParticipant.java
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import com.google.common.base.MoreObjects;
-import com.google.common.base.Objects;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import org.onosproject.store.primitives.MapUpdate;
-import org.onosproject.store.service.ConsistentMap;
-import org.onosproject.store.service.DistributedPrimitive;
-import org.onosproject.store.service.TransactionException;
-import org.onosproject.store.service.TransactionalMap;
-import org.onosproject.store.service.Version;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-
-/**
- * Base class for participants within a single {@link TransactionalMap}.
- * <p>
- * This class provides the basic functionality required by transactional map participants and provides methods
- * for defining operations specific to individual isolation levels.
- *
- * @param <K> key type
- * @param <V> value type.
- */
-public abstract class TransactionalMapParticipant<K, V> implements TransactionalMap<K, V>, TransactionParticipant {
- private static final String TX_CLOSED_ERROR = "Transaction is closed";
- private static final String ERROR_NULL_VALUE = "Null values are not allowed";
- private static final String ERROR_NULL_KEY = "Null key is not allowed";
-
- protected final ConsistentMap<K, V> backingMap;
- protected final Transaction<MapUpdate<K, V>> transaction;
- protected final Map<K, V> writeCache = Maps.newConcurrentMap();
- protected final Set<K> deleteSet = Sets.newConcurrentHashSet();
- protected volatile Version lock;
-
- protected TransactionalMapParticipant(
- ConsistentMap<K, V> backingMap,
- Transaction<MapUpdate<K, V>> transaction) {
- this.backingMap = backingMap;
- this.transaction = transaction;
- }
-
- /**
- * Starts the transaction for this partition when a read occurs.
- * <p>
- * Acquiring a pessimistic lock at the start of the transaction ensures that underlying cached maps have been
- * synchronized prior to a read.
- */
- private void beginTransaction() {
- if (lock == null) {
- synchronized (this) {
- if (lock == null) {
- try {
- lock = transaction.begin()
- .get(DistributedPrimitive.DEFAULT_OPERATION_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
- } catch (InterruptedException e) {
- Thread.currentThread().interrupt();
- throw new TransactionException.Interrupted();
- } catch (TimeoutException e) {
- throw new TransactionException.Timeout();
- } catch (ExecutionException e) {
- throw new TransactionException(e.getCause());
- }
- }
- }
- }
- }
-
- @Override
- public V get(K key) {
- // Start the transaction for this primitive/partition if necessary.
- beginTransaction();
-
- checkState(transaction.isOpen(), TX_CLOSED_ERROR);
- checkNotNull(key, ERROR_NULL_KEY);
-
- if (deleteSet.contains(key)) {
- return null;
- }
-
- V latest = writeCache.get(key);
- if (latest != null) {
- return latest;
- } else {
- return read(key);
- }
- }
-
- /**
- * Executes a get operation based on the transaction isolation level.
- *
- * @param key the key to look up
- * @return the value
- */
- protected abstract V read(K key);
-
- @Override
- public boolean containsKey(K key) {
- return get(key) != null;
- }
-
- @Override
- public V put(K key, V value) {
- checkNotNull(value, ERROR_NULL_VALUE);
-
- V latest = get(key);
- writeCache.put(key, value);
- deleteSet.remove(key);
- return latest;
- }
-
- @Override
- public V remove(K key) {
- V latest = get(key);
- if (latest != null) {
- writeCache.remove(key);
- deleteSet.add(key);
- }
- return latest;
- }
-
- @Override
- public boolean remove(K key, V value) {
- checkNotNull(value, ERROR_NULL_VALUE);
-
- V latest = get(key);
- if (Objects.equal(value, latest)) {
- remove(key);
- return true;
- }
- return false;
- }
-
- @Override
- public boolean replace(K key, V oldValue, V newValue) {
- checkNotNull(oldValue, ERROR_NULL_VALUE);
- checkNotNull(newValue, ERROR_NULL_VALUE);
-
- V latest = get(key);
- if (Objects.equal(oldValue, latest)) {
- put(key, newValue);
- return true;
- }
- return false;
- }
-
- @Override
- public V putIfAbsent(K key, V value) {
- checkNotNull(value, ERROR_NULL_VALUE);
-
- V latest = get(key);
- if (latest == null) {
- put(key, value);
- }
- return latest;
- }
-
- @Override
- public CompletableFuture<Boolean> prepare() {
- return transaction.prepare(log(lock));
- }
-
- @Override
- public CompletableFuture<Void> commit() {
- return transaction.commit();
- }
-
- @Override
- public CompletableFuture<Boolean> prepareAndCommit() {
- return transaction.prepareAndCommit(log(lock));
- }
-
- @Override
- public CompletableFuture<Void> rollback() {
- return transaction.rollback();
- }
-
- /**
- * Returns a list of updates performed within this map partition.
- *
- * @param lockVersion the global transaction lock version
- * @return a list of map updates
- */
- protected List<MapUpdate<K, V>> log(Version lockVersion) {
- return records(lockVersion).collect(Collectors.toList());
- }
-
- /**
- * Returns a stream of updates performed within this map partition.
- *
- * @param lockVersion the global transaction lock version
- * @return a stream of map updates
- */
- protected abstract Stream<MapUpdate<K, V>> records(Version lockVersion);
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(this)
- .add("backingMap", backingMap)
- .toString();
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncAtomicCounterMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncAtomicCounterMap.java
deleted file mode 100644
index 550465d..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncAtomicCounterMap.java
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import org.onlab.util.Tools;
-import org.onosproject.store.service.AsyncAtomicCounterMap;
-
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Function;
-
-/**
- * An {@code AsyncAtomicCounterMap} that transcodes keys.
- */
-public class TranscodingAsyncAtomicCounterMap<K1, K2> implements AsyncAtomicCounterMap<K1> {
- private final AsyncAtomicCounterMap<K2> backingMap;
- private final Function<K1, K2> keyEncoder;
- private final Function<K2, K1> keyDecoder;
-
- public TranscodingAsyncAtomicCounterMap(AsyncAtomicCounterMap<K2> backingMap,
- Function<K1, K2> keyEncoder, Function<K2, K1> keyDecoder) {
- this.backingMap = backingMap;
- this.keyEncoder = k -> k == null ? null : keyEncoder.apply(k);
- this.keyDecoder = k -> k == null ? null : keyDecoder.apply(k);
- }
-
- @Override
- public String name() {
- return backingMap.name();
- }
-
- @Override
- public CompletableFuture<Long> incrementAndGet(K1 key) {
- try {
- return backingMap.incrementAndGet(keyEncoder.apply(key));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Long> decrementAndGet(K1 key) {
- try {
- return backingMap.decrementAndGet(keyEncoder.apply(key));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Long> getAndIncrement(K1 key) {
- try {
- return backingMap.getAndIncrement(keyEncoder.apply(key));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Long> getAndDecrement(K1 key) {
- try {
- return backingMap.getAndDecrement(keyEncoder.apply(key));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Long> addAndGet(K1 key, long delta) {
- try {
- return backingMap.addAndGet(keyEncoder.apply(key), delta);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Long> getAndAdd(K1 key, long delta) {
- try {
- return backingMap.getAndAdd(keyEncoder.apply(key), delta);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Long> get(K1 key) {
- try {
- return backingMap.get(keyEncoder.apply(key));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Long> put(K1 key, long newValue) {
- try {
- return backingMap.put(keyEncoder.apply(key), newValue);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Long> putIfAbsent(K1 key, long newValue) {
- try {
- return backingMap.putIfAbsent(keyEncoder.apply(key), newValue);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K1 key, long expectedOldValue, long newValue) {
- try {
- return backingMap.replace(keyEncoder.apply(key), expectedOldValue, newValue);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Long> remove(K1 key) {
- try {
- return backingMap.remove(keyEncoder.apply(key));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K1 key, long value) {
- try {
- return backingMap.remove(keyEncoder.apply(key), value);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- try {
- return backingMap.size();
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> isEmpty() {
- try {
- return backingMap.isEmpty();
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- try {
- return backingMap.clear();
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncAtomicValue.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncAtomicValue.java
deleted file mode 100644
index 24dd35d..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncAtomicValue.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-import com.google.common.collect.Maps;
-import org.onosproject.store.service.AsyncAtomicValue;
-import org.onosproject.store.service.AtomicValueEvent;
-import org.onosproject.store.service.AtomicValueEventListener;
-
-/**
- * An {@code AsyncAtomicValue} that transcodes values.
- */
-public class TranscodingAsyncAtomicValue<V1, V2> implements AsyncAtomicValue<V1> {
- private final AsyncAtomicValue<V2> backingValue;
- private final Function<V1, V2> valueEncoder;
- private final Function<V2, V1> valueDecoder;
- private final Map<AtomicValueEventListener<V1>, InternalValueEventListener> listeners = Maps.newIdentityHashMap();
-
- public TranscodingAsyncAtomicValue(
- AsyncAtomicValue<V2> backingValue, Function<V1, V2> valueEncoder, Function<V2, V1> valueDecoder) {
- this.backingValue = backingValue;
- this.valueEncoder = k -> k == null ? null : valueEncoder.apply(k);
- this.valueDecoder = k -> k == null ? null : valueDecoder.apply(k);
- }
-
- @Override
- public String name() {
- return backingValue.name();
- }
-
- @Override
- public CompletableFuture<Boolean> compareAndSet(V1 expect, V1 update) {
- return backingValue.compareAndSet(valueEncoder.apply(expect), valueEncoder.apply(update));
- }
-
- @Override
- public CompletableFuture<V1> get() {
- return backingValue.get().thenApply(valueDecoder);
- }
-
- @Override
- public CompletableFuture<V1> getAndSet(V1 value) {
- return backingValue.getAndSet(valueEncoder.apply(value)).thenApply(valueDecoder);
- }
-
- @Override
- public CompletableFuture<Void> set(V1 value) {
- return backingValue.set(valueEncoder.apply(value));
- }
-
- @Override
- public CompletableFuture<Void> addListener(AtomicValueEventListener<V1> listener) {
- synchronized (listeners) {
- InternalValueEventListener backingMapListener =
- listeners.computeIfAbsent(listener, k -> new InternalValueEventListener(listener));
- return backingValue.addListener(backingMapListener);
- }
- }
-
- @Override
- public CompletableFuture<Void> removeListener(AtomicValueEventListener<V1> listener) {
- synchronized (listeners) {
- InternalValueEventListener backingMapListener = listeners.remove(listener);
- if (backingMapListener != null) {
- return backingValue.removeListener(backingMapListener);
- } else {
- return CompletableFuture.completedFuture(null);
- }
- }
- }
-
- @Override
- public void addStatusChangeListener(Consumer<Status> listener) {
- backingValue.addStatusChangeListener(listener);
- }
-
- @Override
- public void removeStatusChangeListener(Consumer<Status> listener) {
- backingValue.removeStatusChangeListener(listener);
- }
-
- @Override
- public Collection<Consumer<Status>> statusChangeListeners() {
- return backingValue.statusChangeListeners();
- }
-
- private class InternalValueEventListener implements AtomicValueEventListener<V2> {
- private final AtomicValueEventListener<V1> listener;
-
- InternalValueEventListener(AtomicValueEventListener<V1> listener) {
- this.listener = listener;
- }
-
- @Override
- public void event(AtomicValueEvent<V2> event) {
- listener.event(new AtomicValueEvent<>(
- event.name(),
- event.newValue() != null ? valueDecoder.apply(event.newValue()) : null,
- event.oldValue() != null ? valueDecoder.apply(event.oldValue()) : null));
- }
- }
-
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncConsistentMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncConsistentMap.java
deleted file mode 100644
index d68ada5..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncConsistentMap.java
+++ /dev/null
@@ -1,374 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import com.google.common.collect.Maps;
-import org.onlab.util.Tools;
-import org.onosproject.store.primitives.MapUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.AsyncIterator;
-import org.onosproject.store.service.MapEvent;
-import org.onosproject.store.service.MapEventListener;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.Versioned;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.function.BiFunction;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
-/**
- * An {@code AsyncConsistentMap} that maps its operations to operations on a
- * differently typed {@code AsyncConsistentMap} by transcoding operation inputs and outputs.
- *
- * @param <K2> key type of other map
- * @param <V2> value type of other map
- * @param <K1> key type of this map
- * @param <V1> value type of this map
- */
-public class TranscodingAsyncConsistentMap<K1, V1, K2, V2> implements AsyncConsistentMap<K1, V1> {
-
- private final AsyncConsistentMap<K2, V2> backingMap;
- private final Function<K1, K2> keyEncoder;
- private final Function<K2, K1> keyDecoder;
- private final Function<V2, V1> valueDecoder;
- private final Function<V1, V2> valueEncoder;
- private final Function<Versioned<V2>, Versioned<V1>> versionedValueTransform;
- private final Map<MapEventListener<K1, V1>, InternalBackingMapEventListener> listeners =
- Maps.newIdentityHashMap();
-
- public TranscodingAsyncConsistentMap(AsyncConsistentMap<K2, V2> backingMap,
- Function<K1, K2> keyEncoder,
- Function<K2, K1> keyDecoder,
- Function<V1, V2> valueEncoder,
- Function<V2, V1> valueDecoder) {
- this.backingMap = backingMap;
- this.keyEncoder = k -> k == null ? null : keyEncoder.apply(k);
- this.keyDecoder = k -> k == null ? null : keyDecoder.apply(k);
- this.valueEncoder = v -> v == null ? null : valueEncoder.apply(v);
- this.valueDecoder = v -> v == null ? null : valueDecoder.apply(v);
- this.versionedValueTransform = v -> v == null ? null : v.map(valueDecoder);
- }
-
- @Override
- public String name() {
- return backingMap.name();
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- return backingMap.size();
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(K1 key) {
- try {
- return backingMap.containsKey(keyEncoder.apply(key));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> containsValue(V1 value) {
- try {
- return backingMap.containsValue(valueEncoder.apply(value));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> get(K1 key) {
- try {
- return backingMap.get(keyEncoder.apply(key)).thenApply(versionedValueTransform);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> getOrDefault(K1 key, V1 defaultValue) {
- try {
- return backingMap.getOrDefault(keyEncoder.apply(key), valueEncoder.apply(defaultValue))
- .thenApply(versionedValueTransform);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> computeIf(K1 key,
- Predicate<? super V1> condition,
- BiFunction<? super K1, ? super V1, ? extends V1> remappingFunction) {
- try {
- return backingMap.computeIf(keyEncoder.apply(key),
- v -> condition.test(valueDecoder.apply(v)),
- (k, v) -> valueEncoder.apply(remappingFunction.apply(keyDecoder.apply(k),
- valueDecoder.apply(v))))
- .thenApply(versionedValueTransform);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> put(K1 key, V1 value) {
- try {
- return backingMap.put(keyEncoder.apply(key), valueEncoder.apply(value))
- .thenApply(versionedValueTransform);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> putAndGet(K1 key, V1 value) {
- try {
- return backingMap.putAndGet(keyEncoder.apply(key), valueEncoder.apply(value))
- .thenApply(versionedValueTransform);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> remove(K1 key) {
- try {
- return backingMap.remove(keyEncoder.apply(key)).thenApply(versionedValueTransform);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return backingMap.clear();
- }
-
- @Override
- public CompletableFuture<Set<K1>> keySet() {
- return backingMap.keySet()
- .thenApply(s -> s.stream().map(keyDecoder).collect(Collectors.toSet()));
- }
-
- @Override
- public CompletableFuture<Collection<Versioned<V1>>> values() {
- return backingMap.values()
- .thenApply(c -> c.stream().map(versionedValueTransform).collect(Collectors.toList()));
- }
-
- @Override
- public CompletableFuture<Set<Entry<K1, Versioned<V1>>>> entrySet() {
- return backingMap.entrySet()
- .thenApply(s -> s.stream()
- .map(e -> Maps.immutableEntry(keyDecoder.apply(e.getKey()),
- versionedValueTransform.apply(e.getValue())))
- .collect(Collectors.toSet()));
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> putIfAbsent(K1 key, V1 value) {
- try {
- return backingMap.putIfAbsent(keyEncoder.apply(key), valueEncoder.apply(value))
- .thenApply(versionedValueTransform);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K1 key, V1 value) {
- try {
- return backingMap.remove(keyEncoder.apply(key), valueEncoder.apply(value));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K1 key, long version) {
- try {
- return backingMap.remove(keyEncoder.apply(key), version);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> replace(K1 key, V1 value) {
- try {
- return backingMap.replace(keyEncoder.apply(key), valueEncoder.apply(value))
- .thenApply(versionedValueTransform);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K1 key, V1 oldValue, V1 newValue) {
- try {
- return backingMap.replace(keyEncoder.apply(key),
- valueEncoder.apply(oldValue),
- valueEncoder.apply(newValue));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K1 key, long oldVersion, V1 newValue) {
- try {
- return backingMap.replace(keyEncoder.apply(key), oldVersion, valueEncoder.apply(newValue));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<AsyncIterator<Entry<K1, Versioned<V1>>>> iterator() {
- return backingMap.iterator().thenApply(TranscodingIterator::new);
- }
-
- @Override
- public CompletableFuture<Void> addListener(MapEventListener<K1, V1> listener, Executor executor) {
- synchronized (listeners) {
- InternalBackingMapEventListener backingMapListener =
- listeners.computeIfAbsent(listener, k -> new InternalBackingMapEventListener(listener));
- return backingMap.addListener(backingMapListener, executor);
- }
- }
-
- @Override
- public CompletableFuture<Void> removeListener(MapEventListener<K1, V1> listener) {
- synchronized (listeners) {
- InternalBackingMapEventListener backingMapListener = listeners.remove(listener);
- if (backingMapListener != null) {
- return backingMap.removeListener(backingMapListener);
- } else {
- return CompletableFuture.completedFuture(null);
- }
- }
- }
-
- @Override
- public CompletableFuture<Version> begin(TransactionId transactionId) {
- try {
- return backingMap.begin(transactionId);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<K1, V1>> transactionLog) {
- try {
- return backingMap.prepare(transactionLog.map(record -> record.map(keyEncoder, valueEncoder)));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<K1, V1>> transactionLog) {
- try {
- return backingMap.prepareAndCommit(transactionLog.map(record -> record.map(keyEncoder, valueEncoder)));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Void> commit(TransactionId transactionId) {
- try {
- return backingMap.commit(transactionId);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Void> rollback(TransactionId transactionId) {
- try {
- return backingMap.rollback(transactionId);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public void addStatusChangeListener(Consumer<Status> listener) {
- backingMap.addStatusChangeListener(listener);
- }
-
- @Override
- public void removeStatusChangeListener(Consumer<Status> listener) {
- backingMap.removeStatusChangeListener(listener);
- }
-
- @Override
- public Collection<Consumer<Status>> statusChangeListeners() {
- return backingMap.statusChangeListeners();
- }
-
- private class TranscodingIterator implements AsyncIterator<Entry<K1, Versioned<V1>>> {
- private final AsyncIterator<Map.Entry<K2, Versioned<V2>>> iterator;
-
- public TranscodingIterator(AsyncIterator<Map.Entry<K2, Versioned<V2>>> iterator) {
- this.iterator = iterator;
- }
-
- @Override
- public CompletableFuture<Boolean> hasNext() {
- return iterator.hasNext();
- }
-
- @Override
- public CompletableFuture<Map.Entry<K1, Versioned<V1>>> next() {
- return iterator.next().thenApply(entry ->
- Maps.immutableEntry(keyDecoder.apply(entry.getKey()), entry.getValue().map(valueDecoder)));
- }
- }
-
- private class InternalBackingMapEventListener implements MapEventListener<K2, V2> {
-
- private final MapEventListener<K1, V1> listener;
-
- InternalBackingMapEventListener(MapEventListener<K1, V1> listener) {
- this.listener = listener;
- }
-
- @Override
- public void event(MapEvent<K2, V2> event) {
- listener.event(new MapEvent<K1, V1>(
- event.type(),
- event.name(),
- keyDecoder.apply(event.key()),
- event.newValue() != null ? event.newValue().map(valueDecoder) : null,
- event.oldValue() != null ? event.oldValue().map(valueDecoder) : null));
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncConsistentMultimap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncConsistentMultimap.java
deleted file mode 100644
index 6fab8c8..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncConsistentMultimap.java
+++ /dev/null
@@ -1,381 +0,0 @@
-/*
- * Copyright 2016 Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.Collection;
-import java.util.EnumSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.function.BiConsumer;
-import java.util.function.BinaryOperator;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Supplier;
-import java.util.stream.Collector;
-import java.util.stream.Collectors;
-
-import com.google.common.collect.ImmutableMultiset;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Multiset;
-import org.onlab.util.Tools;
-import org.onosproject.store.service.AsyncConsistentMultimap;
-import org.onosproject.store.service.AsyncIterator;
-import org.onosproject.store.service.MultimapEvent;
-import org.onosproject.store.service.MultimapEventListener;
-import org.onosproject.store.service.Versioned;
-
-/**
- * An {@link AsyncConsistentMultimap} that maps its operation to operations to
- * a differently typed {@link AsyncConsistentMultimap} by transcoding operation
- * inputs and outputs while maintaining version numbers.
- *
- * @param <K2> key type of other map
- * @param <V2> value type of other map
- * @param <K1> key type of this map
- * @param <V1> value type of this map
- */
-public class TranscodingAsyncConsistentMultimap<K1, V1, K2, V2>
- implements AsyncConsistentMultimap<K1, V1> {
-
- private final AsyncConsistentMultimap<K2, V2> backingMap;
- private final Function<K1, K2> keyEncoder;
- private final Function<K2, K1> keyDecoder;
- private final Function<V2, V1> valueDecoder;
- private final Function<V1, V2> valueEncoder;
- private final Function<? extends Versioned<V2>,
- ? extends Versioned<V1>> versionedValueTransform;
- private final Function<Versioned<Collection<? extends V2>>,
- Versioned<Collection<? extends V1>>> versionedValueCollectionDecode;
- private final Function<Collection<? extends V1>, Collection<V2>>
- valueCollectionEncode;
- private final Map<MultimapEventListener<K1, V1>, InternalBackingMultimapEventListener> listeners =
- Maps.newIdentityHashMap();
-
- public TranscodingAsyncConsistentMultimap(
- AsyncConsistentMultimap<K2, V2> backingMap,
- Function<K1, K2> keyEncoder,
- Function<K2, K1> keyDecoder,
- Function<V2, V1> valueDecoder,
- Function<V1, V2> valueEncoder) {
- this.backingMap = backingMap;
- this.keyEncoder = k -> k == null ? null : keyEncoder.apply(k);
- this.keyDecoder = k -> k == null ? null : keyDecoder.apply(k);
- this.valueDecoder = v -> v == null ? null : valueDecoder.apply(v);
- this.valueEncoder = v -> v == null ? null : valueEncoder.apply(v);
- this.versionedValueTransform = v -> v == null ? null :
- v.map(valueDecoder);
- this.versionedValueCollectionDecode = v -> v == null ? null :
- new Versioned<>(
- v.value()
- .stream()
- .map(valueDecoder)
- .collect(Collectors.toSet()),
- v.version(),
- v.creationTime());
- this.valueCollectionEncode = v -> v == null ? null :
- v.stream().map(valueEncoder).collect(Collectors.toSet());
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- return backingMap.size();
- }
-
- @Override
- public CompletableFuture<Boolean> isEmpty() {
- return backingMap.isEmpty();
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(K1 key) {
- try {
- return backingMap.containsKey(keyEncoder.apply(key));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> containsValue(V1 value) {
- try {
- return backingMap.containsValue(valueEncoder.apply(value));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> containsEntry(K1 key, V1 value) {
- try {
- return backingMap.containsEntry(keyEncoder.apply(key),
- valueEncoder.apply(value));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> put(K1 key, V1 value) {
- try {
- return backingMap.put(keyEncoder.apply(key),
- valueEncoder.apply(value));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V1>>> putAndGet(K1 key, V1 value) {
- try {
- return backingMap.putAndGet(keyEncoder.apply(key), valueEncoder.apply(value))
- .thenApply(versionedValueCollectionDecode);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K1 key, V1 value) {
- try {
- return backingMap.remove(keyEncoder.apply(key), valueEncoder
- .apply(value));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V1>>> removeAndGet(K1 key, V1 value) {
- try {
- return backingMap.removeAndGet(keyEncoder.apply(key), valueEncoder.apply(value))
- .thenApply(versionedValueCollectionDecode);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean> removeAll(
- K1 key, Collection<? extends V1> values) {
- try {
- return backingMap.removeAll(
- keyEncoder.apply(key),
- values.stream().map(valueEncoder).collect(
- Collectors.toSet()));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V1>>>
- removeAll(K1 key) {
- try {
- return backingMap.removeAll(keyEncoder.apply(key))
- .thenApply(versionedValueCollectionDecode);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Boolean>
- putAll(K1 key, Collection<? extends V1> values) {
- try {
- return backingMap.putAll(keyEncoder.apply(key),
- valueCollectionEncode.apply(values));
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V1>>>
- replaceValues(K1 key, Collection<V1> values) {
- try {
- return backingMap.replaceValues(keyEncoder.apply(key),
- valueCollectionEncode.apply(values))
- .thenApply(versionedValueCollectionDecode);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return backingMap.clear();
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends V1>>> get(K1 key) {
- try {
- return backingMap.get(keyEncoder.apply(key))
- .thenApply(versionedValueCollectionDecode);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Set<K1>> keySet() {
- return backingMap.keySet().thenApply(s -> s.stream()
- .map(keyDecoder)
- .collect(Collectors.toSet()));
- }
-
- @Override
- public CompletableFuture<Multiset<K1>> keys() {
- return backingMap.keys().thenApply(s -> s.stream().map(keyDecoder)
- .collect(new MultisetCollector<>()));
- }
-
- @Override
- public CompletableFuture<Multiset<V1>> values() {
- return backingMap.values().thenApply(s ->
- s.stream().map(valueDecoder).collect(new MultisetCollector<>()));
- }
-
- @Override
- public CompletableFuture<Collection<Map.Entry<K1, V1>>> entries() {
- return backingMap.entries().thenApply(s -> s.stream()
- .map(e -> Maps.immutableEntry(keyDecoder.apply(e.getKey()),
- valueDecoder.apply(e.getValue())))
- .collect(Collectors.toSet()));
- }
-
- @Override
- public CompletableFuture<AsyncIterator<Map.Entry<K1, V1>>> iterator() {
- return backingMap.iterator().thenApply(TranscodingIterator::new);
- }
-
- @Override
- public CompletableFuture<Map<K1, Collection<V1>>> asMap() {
- throw new UnsupportedOperationException("Unsupported operation.");
- }
-
- @Override
- public String name() {
- return backingMap.name();
- }
-
- @Override
- public CompletableFuture<Void> addListener(MultimapEventListener<K1, V1> listener, Executor executor) {
- synchronized (listeners) {
- InternalBackingMultimapEventListener backingMapListener =
- listeners.computeIfAbsent(listener, k -> new InternalBackingMultimapEventListener(listener));
- return backingMap.addListener(backingMapListener, executor);
- }
- }
-
- @Override
- public CompletableFuture<Void> removeListener(MultimapEventListener<K1, V1> listener) {
- synchronized (listeners) {
- InternalBackingMultimapEventListener backingMapListener = listeners.remove(listener);
- if (backingMapListener != null) {
- return backingMap.removeListener(backingMapListener);
- } else {
- return CompletableFuture.completedFuture(null);
- }
- }
- }
-
- @Override
- public void addStatusChangeListener(Consumer<Status> listener) {
- backingMap.addStatusChangeListener(listener);
- }
-
- @Override
- public void removeStatusChangeListener(Consumer<Status> listener) {
- backingMap.removeStatusChangeListener(listener);
- }
-
- @Override
- public Collection<Consumer<Status>> statusChangeListeners() {
- return backingMap.statusChangeListeners();
- }
-
- private class MultisetCollector<T> implements Collector<T,
- ImmutableMultiset.Builder<T>,
- Multiset<T>> {
-
- @Override
- public Supplier<ImmutableMultiset.Builder<T>> supplier() {
- return ImmutableMultiset::builder;
- }
-
- @Override
- public BiConsumer<ImmutableMultiset.Builder<T>, T> accumulator() {
- return ((builder, t) -> builder.add(t));
- }
-
- @Override
- public BinaryOperator<ImmutableMultiset.Builder<T>> combiner() {
- return (a, b) -> {
- a.addAll(b.build());
- return a;
- };
- }
-
- @Override
- public Function<ImmutableMultiset.Builder<T>, Multiset<T>> finisher() {
- return ImmutableMultiset.Builder::build;
- }
-
- @Override
- public Set<Characteristics> characteristics() {
- return EnumSet.of(Characteristics.UNORDERED);
- }
- }
-
- private class TranscodingIterator implements AsyncIterator<Map.Entry<K1, V1>> {
- private final AsyncIterator<Map.Entry<K2, V2>> iterator;
-
- public TranscodingIterator(AsyncIterator<Map.Entry<K2, V2>> iterator) {
- this.iterator = iterator;
- }
-
- @Override
- public CompletableFuture<Boolean> hasNext() {
- return iterator.hasNext();
- }
-
- @Override
- public CompletableFuture<Map.Entry<K1, V1>> next() {
- return iterator.next().thenApply(entry ->
- Maps.immutableEntry(keyDecoder.apply(entry.getKey()), valueDecoder.apply(entry.getValue())));
- }
- }
-
- private class InternalBackingMultimapEventListener implements MultimapEventListener<K2, V2> {
-
- private final MultimapEventListener<K1, V1> listener;
-
- InternalBackingMultimapEventListener(MultimapEventListener<K1, V1> listener) {
- this.listener = listener;
- }
-
- @Override
- public void event(MultimapEvent<K2, V2> event) {
- listener.event(new MultimapEvent(event.name(),
- keyDecoder.apply(event.key()),
- valueDecoder.apply(event.newValue()),
- valueDecoder.apply(event.oldValue())));
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncConsistentTreeMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncConsistentTreeMap.java
deleted file mode 100644
index d8e686e..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/TranscodingAsyncConsistentTreeMap.java
+++ /dev/null
@@ -1,437 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import com.google.common.collect.Maps;
-import org.onlab.util.Tools;
-import org.onosproject.store.primitives.MapUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.service.AsyncConsistentTreeMap;
-import org.onosproject.store.service.AsyncIterator;
-import org.onosproject.store.service.MapEvent;
-import org.onosproject.store.service.MapEventListener;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.Versioned;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.NavigableMap;
-import java.util.NavigableSet;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
-/**
- * An {@code AsyncConsistentTreeMap} that maps its operations to operations on
- * a differently typed {@code AsyncConsistentTreeMap} by transcoding operation
- * inputs and outputs.
- *
- * @param <V2> value type of other map
- * @param <V1> value type of this map
- */
-public class TranscodingAsyncConsistentTreeMap<V1, V2>
- implements AsyncConsistentTreeMap<V1> {
- private final AsyncConsistentTreeMap<V2> backingMap;
- private final Function<V2, V1> valueDecoder;
- private final Function<V1, V2> valueEncoder;
- private final Function<Versioned<V2>, Versioned<V1>>
- versionedValueTransform;
- private final Map<MapEventListener<String, V1>,
- TranscodingAsyncConsistentTreeMap.InternalBackingMapEventListener>
- listeners = Maps.newIdentityHashMap();
-
- public TranscodingAsyncConsistentTreeMap(
- AsyncConsistentTreeMap<V2> backingMap,
- Function<V1, V2> valueEncoder,
- Function<V2, V1> valueDecoder) {
- this.backingMap = backingMap;
- this.valueEncoder = v -> v == null ? null : valueEncoder.apply(v);
- this.valueDecoder = v -> v == null ? null : valueDecoder.apply(v);
- this.versionedValueTransform = v -> v == null ? null :
- v.map(valueDecoder);
- }
-
- @Override
- public CompletableFuture<String> firstKey() {
- return backingMap.firstKey();
- }
-
- @Override
- public CompletableFuture<String> lastKey() {
- return backingMap.lastKey();
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V1>>>
- ceilingEntry(String key) {
- return backingMap.ceilingEntry(key)
- .thenApply(
- entry ->
- Maps.immutableEntry(
- entry.getKey(),
- versionedValueTransform
- .apply(entry.getValue())));
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V1>>>
- floorEntry(String key) {
- return backingMap.floorEntry(key)
- .thenApply(
- entry ->
- Maps.immutableEntry(
- entry.getKey(),
- versionedValueTransform
- .apply(entry.getValue())));
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V1>>>
- higherEntry(String key) {
- return backingMap
- .higherEntry(key)
- .thenApply(entry ->
- Maps.immutableEntry(
- entry.getKey(),
- versionedValueTransform
- .apply(entry.getValue())));
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V1>>>
- lowerEntry(String key) {
- return backingMap.lowerEntry(key).thenApply(
- entry ->
- Maps.immutableEntry(
- entry.getKey(),
- versionedValueTransform
- .apply(entry.getValue())));
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V1>>>
- firstEntry() {
- return backingMap.firstEntry()
- .thenApply(entry ->
- Maps.immutableEntry(
- entry.getKey(),
- versionedValueTransform
- .apply(entry.getValue())));
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V1>>>
- lastEntry() {
- return backingMap.lastEntry()
- .thenApply(
- entry -> Maps.immutableEntry(
- entry.getKey(),
- versionedValueTransform
- .apply(entry.getValue())));
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V1>>>
- pollFirstEntry() {
- return backingMap.pollFirstEntry()
- .thenApply(
- entry -> Maps.immutableEntry(
- entry.getKey(),
- versionedValueTransform
- .apply(entry.getValue())));
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V1>>>
- pollLastEntry() {
- return backingMap.pollLastEntry()
- .thenApply(entry -> Maps.immutableEntry(
- entry.getKey(),
- versionedValueTransform.apply(entry.getValue())));
- }
-
- @Override
- public CompletableFuture<String> lowerKey(String key) {
- return backingMap.lowerKey(key);
- }
-
- @Override
- public CompletableFuture<String> floorKey(String key) {
- return backingMap.floorKey(key);
- }
-
- @Override
- public CompletableFuture<String> ceilingKey(String key) {
- return backingMap.ceilingKey(key);
- }
-
- @Override
- public CompletableFuture<String> higherKey(String key) {
- return backingMap.higherKey(key);
- }
-
- @Override
- public CompletableFuture<NavigableSet<String>> navigableKeySet() {
- return backingMap.navigableKeySet();
- }
-
- @Override
- public CompletableFuture<NavigableMap<String, V1>> subMap(
- String upperKey,
- String lowerKey,
- boolean inclusiveUpper,
- boolean inclusiveLower) {
- throw new UnsupportedOperationException("This operation is not yet" +
- "supported.");
- }
-
- @Override
- public String name() {
- return backingMap.name();
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- return backingMap.size();
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(String key) {
- return backingMap.containsKey(key);
- }
-
- @Override
- public CompletableFuture<Boolean> containsValue(V1 value) {
- return backingMap.containsValue(valueEncoder.apply(value));
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> get(String key) {
- return backingMap.get(key).thenApply(versionedValueTransform);
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> getOrDefault(String key, V1 defaultValue) {
- return backingMap.getOrDefault(key, valueEncoder.apply(defaultValue)).thenApply(versionedValueTransform);
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> computeIf(
- String key, Predicate<? super V1> condition,
- BiFunction<? super String, ? super V1, ? extends V1>
- remappingFunction) {
- try {
- return backingMap
- .computeIf(
- key,
- v -> condition.test(valueDecoder.apply(v)),
- (k, v) -> valueEncoder
- .apply(
- remappingFunction.apply(
- key,
- valueDecoder.apply(v))))
- .thenApply(versionedValueTransform);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> put(String key, V1 value) {
- return backingMap.put(key, valueEncoder.apply(value))
- .thenApply(versionedValueTransform);
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> putAndGet(String key, V1 value) {
- return backingMap.putAndGet(key, valueEncoder.apply(value))
- .thenApply(versionedValueTransform);
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> remove(String key) {
- return backingMap.remove(key).thenApply(versionedValueTransform);
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return backingMap.clear();
- }
-
- @Override
- public CompletableFuture<Set<String>> keySet() {
- return backingMap.keySet();
- }
-
- @Override
- public CompletableFuture<Collection<Versioned<V1>>> values() {
- return backingMap.values().thenApply(valueSet -> valueSet.stream()
- .map(versionedValueTransform).collect(Collectors.toSet()));
- }
-
- @Override
- public CompletableFuture<Set<Map.Entry<String, Versioned<V1>>>>
- entrySet() {
- return backingMap.entrySet()
- .thenApply(
- entries -> entries
- .stream()
- .map(entry ->
- Maps.immutableEntry(
- entry.getKey(),
- versionedValueTransform
- .apply(entry.getValue())
- ))
- .collect(Collectors.toSet()));
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> putIfAbsent(String key, V1 value) {
- return backingMap.putIfAbsent(key, valueEncoder.apply(value))
- .thenApply(versionedValueTransform);
- }
-
- @Override
- public CompletableFuture<Boolean> remove(String key, V1 value) {
- return backingMap.remove(key, valueEncoder.apply(value));
- }
-
- @Override
- public CompletableFuture<Boolean> remove(String key, long version) {
- return backingMap.remove(key, version);
- }
-
- @Override
- public CompletableFuture<Versioned<V1>> replace(String key, V1 value) {
- return backingMap.replace(key, valueEncoder.apply(value))
- .thenApply(versionedValueTransform);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(String key, V1 oldValue,
- V1 newValue) {
- return backingMap.replace(key, valueEncoder.apply(oldValue),
- valueEncoder.apply(newValue));
- }
-
- @Override
- public CompletableFuture<Boolean> replace(String key, long oldVersion,
- V1 newValue) {
- return backingMap.replace(key, oldVersion,
- valueEncoder.apply(newValue));
- }
-
- @Override
- public CompletableFuture<AsyncIterator<Map.Entry<String, Versioned<V1>>>> iterator() {
- return backingMap.iterator().thenApply(TranscodingIterator::new);
- }
-
- @Override
- public CompletableFuture<Void> addListener(
- MapEventListener<String, V1> listener,
- Executor executor) {
- InternalBackingMapEventListener backingMapEventListener =
- listeners.computeIfAbsent(
- listener,
- k -> new InternalBackingMapEventListener(listener));
- return backingMap.addListener(backingMapEventListener, executor);
- }
-
- @Override
- public CompletableFuture<Void> removeListener(
- MapEventListener<String, V1> listener) {
- InternalBackingMapEventListener backingMapEventListener =
- listeners.remove(listener);
- if (backingMapEventListener == null) {
- return CompletableFuture.completedFuture(null);
- } else {
- return backingMap.removeListener(backingMapEventListener);
- }
- }
-
- @Override
- public CompletableFuture<Version> begin(TransactionId transactionId) {
- throw new UnsupportedOperationException("This operation is not yet supported.");
- }
-
- @Override
- public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<String, V1>> transactionLog) {
- throw new UnsupportedOperationException("This operation is not yet supported.");
- }
-
- @Override
- public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<String, V1>> transactionLog) {
- throw new UnsupportedOperationException("This operation is not yet supported.");
- }
-
- @Override
- public CompletableFuture<Void> commit(TransactionId transactionId) {
- throw new UnsupportedOperationException("This operation is not yet supported.");
- }
-
- @Override
- public CompletableFuture<Void> rollback(TransactionId transactionId) {
- throw new UnsupportedOperationException("This operation is not yet supported.");
- }
-
- private class TranscodingIterator implements AsyncIterator<Map.Entry<String, Versioned<V1>>> {
- private final AsyncIterator<Map.Entry<String, Versioned<V2>>> iterator;
-
- public TranscodingIterator(AsyncIterator<Map.Entry<String, Versioned<V2>>> iterator) {
- this.iterator = iterator;
- }
-
- @Override
- public CompletableFuture<Boolean> hasNext() {
- return iterator.hasNext();
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<V1>>> next() {
- return iterator.next().thenApply(entry ->
- Maps.immutableEntry(entry.getKey(), entry.getValue().map(valueDecoder)));
- }
- }
-
- private class InternalBackingMapEventListener
- implements MapEventListener<String, V2> {
-
- private final MapEventListener<String, V1> listener;
-
- InternalBackingMapEventListener(
- MapEventListener<String, V1> listener) {
- this.listener = listener;
- }
-
- @Override
- public void event(MapEvent<String, V2> event) {
- listener.event(new MapEvent<String, V1>(
- event.type(),
- event.name(),
- event.key(),
- event.newValue() != null ?
- event.newValue().map(valueDecoder) : null,
- event.oldValue() != null ?
- event.oldValue().map(valueDecoder) : null));
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/UnmodifiableAsyncConsistentMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/UnmodifiableAsyncConsistentMap.java
deleted file mode 100644
index 65378b9..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/UnmodifiableAsyncConsistentMap.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.impl;
-
-import java.util.concurrent.CompletableFuture;
-import java.util.function.BiFunction;
-import java.util.function.Predicate;
-
-import org.onlab.util.Tools;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.Versioned;
-
-/**
- * An unmodifiable {@link AsyncConsistentMap}.
- * <p>
- * Any attempt to update the map through this instance will cause the
- * operation to be completed with an {@link UnsupportedOperationException}.
- *
- * @param <K> key type
- * @param <V> value type
- */
-public class UnmodifiableAsyncConsistentMap<K, V> extends DelegatingAsyncConsistentMap<K, V> {
-
- private static final String ERROR_MSG = "map updates are not allowed";
-
- public UnmodifiableAsyncConsistentMap(AsyncConsistentMap<K, V> backingMap) {
- super(backingMap);
- }
-
- @Override
- public CompletableFuture<Versioned<V>> computeIf(K key,
- Predicate<? super V> condition,
- BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
- return Tools.exceptionalFuture(new UnsupportedOperationException(""));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> put(K key, V value) {
- return Tools.exceptionalFuture(new UnsupportedOperationException(ERROR_MSG));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putAndGet(K key, V value) {
- return Tools.exceptionalFuture(new UnsupportedOperationException(ERROR_MSG));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> remove(K key) {
- return Tools.exceptionalFuture(new UnsupportedOperationException(ERROR_MSG));
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return Tools.exceptionalFuture(new UnsupportedOperationException(ERROR_MSG));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> putIfAbsent(K key, V value) {
- return Tools.exceptionalFuture(new UnsupportedOperationException(ERROR_MSG));
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, V value) {
- return Tools.exceptionalFuture(new UnsupportedOperationException(ERROR_MSG));
- }
-
- @Override
- public CompletableFuture<Boolean> remove(K key, long version) {
- return Tools.exceptionalFuture(new UnsupportedOperationException(ERROR_MSG));
- }
-
- @Override
- public CompletableFuture<Versioned<V>> replace(K key, V value) {
- return Tools.exceptionalFuture(new UnsupportedOperationException(ERROR_MSG));
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K key, V oldValue, V newValue) {
- return Tools.exceptionalFuture(new UnsupportedOperationException(ERROR_MSG));
- }
-
- @Override
- public CompletableFuture<Boolean> replace(K key, long oldVersion, V newValue) {
- return Tools.exceptionalFuture(new UnsupportedOperationException(ERROR_MSG));
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/UpdateEntry.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/UpdateEntry.java
index 42bf1f9..680795c 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/UpdateEntry.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/UpdateEntry.java
@@ -15,10 +15,10 @@
*/
package org.onosproject.store.primitives.impl;
-import static com.google.common.base.Preconditions.checkNotNull;
-
import com.google.common.base.MoreObjects;
+import static com.google.common.base.Preconditions.checkNotNull;
+
/**
* Describes a single update event in an EventuallyConsistentMap.
*/
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/UpdateRequest.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/UpdateRequest.java
index 7563469..cb3db2f 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/UpdateRequest.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/UpdateRequest.java
@@ -15,12 +15,12 @@
*/
package org.onosproject.store.primitives.impl;
+import java.util.Set;
+
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableSet;
import org.onosproject.cluster.NodeId;
-import java.util.Set;
-
import static com.google.common.base.Preconditions.checkNotNull;
/**
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/package-info.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/package-info.java
index 21824a7..e151e54 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/package-info.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/package-info.java
@@ -15,6 +15,6 @@
*/
/**
- * Implementation classes for various Distributed primitives.
+ * Implementation classes for store utilities.
*/
package org.onosproject.store.primitives.impl;
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AbstractRaftPrimitive.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AbstractRaftPrimitive.java
deleted file mode 100644
index 17b8ef8..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AbstractRaftPrimitive.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.Collection;
-import java.util.Set;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
-import io.atomix.protocols.raft.proxy.RaftProxy;
-import org.onosproject.store.service.DistributedPrimitive;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * Abstract base class for primitives that interact with Raft replicated state machines via proxy.
- */
-public abstract class AbstractRaftPrimitive implements DistributedPrimitive {
- private final Function<RaftProxy.State, Status> mapper = state -> {
- switch (state) {
- case CONNECTED:
- return Status.ACTIVE;
- case SUSPENDED:
- return Status.SUSPENDED;
- case CLOSED:
- return Status.INACTIVE;
- default:
- throw new IllegalStateException("Unknown state " + state);
- }
- };
-
- protected final RaftProxy proxy;
- private final Set<Consumer<Status>> statusChangeListeners = Sets.newCopyOnWriteArraySet();
-
- public AbstractRaftPrimitive(RaftProxy proxy) {
- this.proxy = checkNotNull(proxy, "proxy cannot be null");
- proxy.addStateChangeListener(this::onStateChange);
- }
-
- @Override
- public String name() {
- return proxy.name();
- }
-
- /**
- * Handles a Raft session state change.
- *
- * @param state the updated Raft session state
- */
- private void onStateChange(RaftProxy.State state) {
- statusChangeListeners.forEach(listener -> listener.accept(mapper.apply(state)));
- }
-
- @Override
- public void addStatusChangeListener(Consumer<Status> listener) {
- statusChangeListeners.add(listener);
- }
-
- @Override
- public void removeStatusChangeListener(Consumer<Status> listener) {
- statusChangeListeners.remove(listener);
- }
-
- @Override
- public Collection<Consumer<Status>> statusChangeListeners() {
- return ImmutableSet.copyOf(statusChangeListeners);
- }
-
- @Override
- public String toString() {
- return toStringHelper(this)
- .add("proxy", proxy)
- .toString();
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixAtomicCounterMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixAtomicCounterMap.java
deleted file mode 100644
index 9d25e26..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixAtomicCounterMap.java
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.concurrent.CompletableFuture;
-
-import io.atomix.protocols.raft.proxy.RaftProxy;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.AddAndGet;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.DecrementAndGet;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.Get;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GetAndAdd;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GetAndDecrement;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GetAndIncrement;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.IncrementAndGet;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.Put;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.PutIfAbsent;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.Remove;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.RemoveValue;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.Replace;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncAtomicCounterMap;
-import org.onosproject.store.service.Serializer;
-
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.ADD_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.CLEAR;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.DECREMENT_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GET_AND_ADD;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GET_AND_DECREMENT;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GET_AND_INCREMENT;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.INCREMENT_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.IS_EMPTY;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.PUT;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.PUT_IF_ABSENT;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.REMOVE;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.REMOVE_VALUE;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.REPLACE;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.SIZE;
-
-/**
- * {@code AsyncAtomicCounterMap} implementation backed by Atomix.
- */
-public class AtomixAtomicCounterMap extends AbstractRaftPrimitive implements AsyncAtomicCounterMap<String> {
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixAtomicCounterMapOperations.NAMESPACE)
- .build());
-
- public AtomixAtomicCounterMap(RaftProxy proxy) {
- super(proxy);
- }
-
- @Override
- public CompletableFuture<Long> incrementAndGet(String key) {
- return proxy.invoke(INCREMENT_AND_GET, SERIALIZER::encode, new IncrementAndGet(key), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> decrementAndGet(String key) {
- return proxy.invoke(DECREMENT_AND_GET, SERIALIZER::encode, new DecrementAndGet(key), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> getAndIncrement(String key) {
- return proxy.invoke(GET_AND_INCREMENT, SERIALIZER::encode, new GetAndIncrement(key), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> getAndDecrement(String key) {
- return proxy.invoke(GET_AND_DECREMENT, SERIALIZER::encode, new GetAndDecrement(key), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> addAndGet(String key, long delta) {
- return proxy.invoke(ADD_AND_GET, SERIALIZER::encode, new AddAndGet(key, delta), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> getAndAdd(String key, long delta) {
- return proxy.invoke(GET_AND_ADD, SERIALIZER::encode, new GetAndAdd(key, delta), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> get(String key) {
- return proxy.invoke(GET, SERIALIZER::encode, new Get(key), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> put(String key, long newValue) {
- return proxy.invoke(PUT, SERIALIZER::encode, new Put(key, newValue), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> putIfAbsent(String key, long newValue) {
- return proxy.invoke(PUT_IF_ABSENT, SERIALIZER::encode, new PutIfAbsent(key, newValue), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> replace(String key, long expectedOldValue, long newValue) {
- return proxy.invoke(
- REPLACE,
- SERIALIZER::encode,
- new Replace(key, expectedOldValue, newValue),
- SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> remove(String key) {
- return proxy.invoke(REMOVE, SERIALIZER::encode, new Remove(key), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> remove(String key, long value) {
- return proxy.invoke(REMOVE_VALUE, SERIALIZER::encode, new RemoveValue(key, value), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- return proxy.invoke(SIZE, SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> isEmpty() {
- return proxy.invoke(IS_EMPTY, SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return proxy.invoke(CLEAR);
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixAtomicCounterMapOperations.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixAtomicCounterMapOperations.java
deleted file mode 100644
index 7b2cba2..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixAtomicCounterMapOperations.java
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import io.atomix.protocols.raft.operation.OperationId;
-import io.atomix.protocols.raft.operation.OperationType;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-
-/**
- * Atomic counter map commands.
- */
-public enum AtomixAtomicCounterMapOperations implements OperationId {
- PUT(OperationType.COMMAND),
- PUT_IF_ABSENT(OperationType.COMMAND),
- GET(OperationType.QUERY),
- REPLACE(OperationType.COMMAND),
- REMOVE(OperationType.COMMAND),
- REMOVE_VALUE(OperationType.COMMAND),
- GET_AND_INCREMENT(OperationType.COMMAND),
- GET_AND_DECREMENT(OperationType.COMMAND),
- INCREMENT_AND_GET(OperationType.COMMAND),
- DECREMENT_AND_GET(OperationType.COMMAND),
- ADD_AND_GET(OperationType.COMMAND),
- GET_AND_ADD(OperationType.COMMAND),
- SIZE(OperationType.QUERY),
- IS_EMPTY(OperationType.QUERY),
- CLEAR(OperationType.COMMAND);
-
- private final OperationType type;
-
- AtomixAtomicCounterMapOperations(OperationType type) {
- this.type = type;
- }
-
- @Override
- public String id() {
- return name();
- }
-
- @Override
- public OperationType type() {
- return type;
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID)
- .register(IncrementAndGet.class)
- .register(DecrementAndGet.class)
- .register(GetAndIncrement.class)
- .register(GetAndDecrement.class)
- .register(AddAndGet.class)
- .register(GetAndAdd.class)
- .register(Get.class)
- .register(Put.class)
- .register(PutIfAbsent.class)
- .register(Replace.class)
- .register(Remove.class)
- .register(RemoveValue.class)
- .build("AtomixAtomicCounterMapOperations");
-
- public abstract static class AtomicCounterMapOperation<V> {
- }
-
- public abstract static class KeyOperation extends AtomicCounterMapOperation {
- private String key;
-
- public KeyOperation() {
- }
-
- public KeyOperation(String key) {
- this.key = key;
- }
-
- public String key() {
- return key;
- }
- }
-
- public static class KeyValueOperation extends KeyOperation {
- private long value;
-
- public KeyValueOperation() {
- }
-
- public KeyValueOperation(String key, long value) {
- super(key);
- this.value = value;
- }
-
- public long value() {
- return value;
- }
- }
-
- public static class Get extends KeyOperation {
- public Get() {
- }
-
- public Get(String key) {
- super(key);
- }
- }
-
- public static class Put extends KeyValueOperation {
- public Put() {
- }
-
- public Put(String key, long value) {
- super(key, value);
- }
- }
-
- public static class PutIfAbsent extends KeyValueOperation {
- public PutIfAbsent() {
- }
-
- public PutIfAbsent(String key, long value) {
- super(key, value);
- }
- }
-
- public static class Replace extends KeyOperation {
- private long replace;
- private long value;
-
- public Replace() {
- }
-
- public Replace(String key, long replace, long value) {
- super(key);
- this.replace = replace;
- this.value = value;
- }
-
- public long replace() {
- return replace;
- }
-
- public long value() {
- return value;
- }
- }
-
- public static class Remove extends KeyOperation {
- public Remove() {
- }
-
- public Remove(String key) {
- super(key);
- }
- }
-
- public static class RemoveValue extends KeyValueOperation {
- public RemoveValue() {
- }
-
- public RemoveValue(String key, long value) {
- super(key, value);
- }
- }
-
- public static class IncrementAndGet extends KeyOperation {
- public IncrementAndGet() {
- }
-
- public IncrementAndGet(String key) {
- super(key);
- }
- }
-
- public static class DecrementAndGet extends KeyOperation {
- public DecrementAndGet(String key) {
- super(key);
- }
-
- public DecrementAndGet() {
- }
- }
-
- public static class GetAndIncrement extends KeyOperation {
- public GetAndIncrement() {
- }
-
- public GetAndIncrement(String key) {
- super(key);
- }
- }
-
- public static class GetAndDecrement extends KeyOperation {
- public GetAndDecrement() {
- }
-
- public GetAndDecrement(String key) {
- super(key);
- }
- }
-
- public abstract static class DeltaOperation extends KeyOperation {
- private long delta;
-
- public DeltaOperation() {
- }
-
- public DeltaOperation(String key, long delta) {
- super(key);
- this.delta = delta;
- }
-
- public long delta() {
- return delta;
- }
- }
-
- public static class AddAndGet extends DeltaOperation {
- public AddAndGet() {
- }
-
- public AddAndGet(String key, long delta) {
- super(key, delta);
- }
- }
-
- public static class GetAndAdd extends DeltaOperation {
- public GetAndAdd() {
- }
-
- public GetAndAdd(String key, long delta) {
- super(key, delta);
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixAtomicCounterMapService.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixAtomicCounterMapService.java
deleted file mode 100644
index 354db26..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixAtomicCounterMapService.java
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import io.atomix.protocols.raft.service.AbstractRaftService;
-import io.atomix.protocols.raft.service.Commit;
-import io.atomix.protocols.raft.service.RaftServiceExecutor;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotReader;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotWriter;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.AddAndGet;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.DecrementAndGet;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.Get;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GetAndAdd;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GetAndDecrement;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GetAndIncrement;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.IncrementAndGet;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.Put;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.PutIfAbsent;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.Remove;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.RemoveValue;
-import org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.Replace;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.Serializer;
-
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.ADD_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.CLEAR;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.DECREMENT_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GET_AND_ADD;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GET_AND_DECREMENT;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.GET_AND_INCREMENT;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.INCREMENT_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.IS_EMPTY;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.PUT;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.PUT_IF_ABSENT;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.REMOVE;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.REMOVE_VALUE;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.REPLACE;
-import static org.onosproject.store.primitives.resources.impl.AtomixAtomicCounterMapOperations.SIZE;
-
-/**
- * Atomic counter map state for Atomix.
- * <p>
- * The counter map state is implemented as a snapshottable state machine. Snapshots are necessary
- * since incremental compaction is impractical for counters where the value of a counter is the sum
- * of all its increments. Note that this snapshotting large state machines may risk blocking of the
- * Raft cluster with the current implementation of snapshotting in Copycat.
- */
-public class AtomixAtomicCounterMapService extends AbstractRaftService {
-
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixAtomicCounterMapOperations.NAMESPACE)
- .build());
-
- private Map<String, Long> map = new HashMap<>();
-
- @Override
- protected void configure(RaftServiceExecutor executor) {
- executor.register(PUT, SERIALIZER::decode, this::put, SERIALIZER::encode);
- executor.register(PUT_IF_ABSENT, SERIALIZER::decode, this::putIfAbsent, SERIALIZER::encode);
- executor.register(GET, SERIALIZER::decode, this::get, SERIALIZER::encode);
- executor.register(REPLACE, SERIALIZER::decode, this::replace, SERIALIZER::encode);
- executor.register(REMOVE, SERIALIZER::decode, this::remove, SERIALIZER::encode);
- executor.register(REMOVE_VALUE, SERIALIZER::decode, this::removeValue, SERIALIZER::encode);
- executor.register(GET_AND_INCREMENT, SERIALIZER::decode, this::getAndIncrement, SERIALIZER::encode);
- executor.register(GET_AND_DECREMENT, SERIALIZER::decode, this::getAndDecrement, SERIALIZER::encode);
- executor.register(INCREMENT_AND_GET, SERIALIZER::decode, this::incrementAndGet, SERIALIZER::encode);
- executor.register(DECREMENT_AND_GET, SERIALIZER::decode, this::decrementAndGet, SERIALIZER::encode);
- executor.register(ADD_AND_GET, SERIALIZER::decode, this::addAndGet, SERIALIZER::encode);
- executor.register(GET_AND_ADD, SERIALIZER::decode, this::getAndAdd, SERIALIZER::encode);
- executor.register(SIZE, this::size, SERIALIZER::encode);
- executor.register(IS_EMPTY, this::isEmpty, SERIALIZER::encode);
- executor.register(CLEAR, this::clear);
- }
-
- @Override
- public void snapshot(SnapshotWriter writer) {
- writer.writeObject(map, SERIALIZER::encode);
- }
-
- @Override
- public void install(SnapshotReader reader) {
- map = reader.readObject(SERIALIZER::decode);
- }
-
- /**
- * Returns the primitive value for the given primitive wrapper.
- */
- private long primitive(Long value) {
- if (value != null) {
- return value;
- } else {
- return 0;
- }
- }
-
- /**
- * Handles a {@link Put} command which implements {@link AtomixAtomicCounterMap#put(String, long)}.
- *
- * @param commit put commit
- * @return put result
- */
- protected long put(Commit<Put> commit) {
- return primitive(map.put(commit.value().key(), commit.value().value()));
- }
-
- /**
- * Handles a {@link PutIfAbsent} command which implements {@link AtomixAtomicCounterMap#putIfAbsent(String, long)}.
- *
- * @param commit putIfAbsent commit
- * @return putIfAbsent result
- */
- protected long putIfAbsent(Commit<PutIfAbsent> commit) {
- return primitive(map.putIfAbsent(commit.value().key(), commit.value().value()));
- }
-
- /**
- * Handles a {@link Get} query which implements {@link AtomixAtomicCounterMap#get(String)}}.
- *
- * @param commit get commit
- * @return get result
- */
- protected long get(Commit<Get> commit) {
- return primitive(map.get(commit.value().key()));
- }
-
- /**
- * Handles a {@link Replace} command which implements {@link AtomixAtomicCounterMap#replace(String, long, long)}.
- *
- * @param commit replace commit
- * @return replace result
- */
- protected boolean replace(Commit<Replace> commit) {
- Long value = map.get(commit.value().key());
- if (value == null) {
- if (commit.value().replace() == 0) {
- map.put(commit.value().key(), commit.value().value());
- return true;
- } else {
- return false;
- }
- } else if (value == commit.value().replace()) {
- map.put(commit.value().key(), commit.value().value());
- return true;
- }
- return false;
- }
-
- /**
- * Handles a {@link Remove} command which implements {@link AtomixAtomicCounterMap#remove(String)}.
- *
- * @param commit remove commit
- * @return remove result
- */
- protected long remove(Commit<Remove> commit) {
- return primitive(map.remove(commit.value().key()));
- }
-
- /**
- * Handles a {@link RemoveValue} command which implements {@link AtomixAtomicCounterMap#remove(String, long)}.
- *
- * @param commit removeValue commit
- * @return removeValue result
- */
- protected boolean removeValue(Commit<RemoveValue> commit) {
- Long value = map.get(commit.value().key());
- if (value == null) {
- if (commit.value().value() == 0) {
- map.remove(commit.value().key());
- return true;
- }
- return false;
- } else if (value == commit.value().value()) {
- map.remove(commit.value().key());
- return true;
- }
- return false;
- }
-
- /**
- * Handles a {@link GetAndIncrement} command which implements
- * {@link AtomixAtomicCounterMap#getAndIncrement(String)}.
- *
- * @param commit getAndIncrement commit
- * @return getAndIncrement result
- */
- protected long getAndIncrement(Commit<GetAndIncrement> commit) {
- long value = primitive(map.get(commit.value().key()));
- map.put(commit.value().key(), value + 1);
- return value;
- }
-
- /**
- * Handles a {@link GetAndDecrement} command which implements
- * {@link AtomixAtomicCounterMap#getAndDecrement(String)}.
- *
- * @param commit getAndDecrement commit
- * @return getAndDecrement result
- */
- protected long getAndDecrement(Commit<GetAndDecrement> commit) {
- long value = primitive(map.get(commit.value().key()));
- map.put(commit.value().key(), value - 1);
- return value;
- }
-
- /**
- * Handles a {@link IncrementAndGet} command which implements
- * {@link AtomixAtomicCounterMap#incrementAndGet(String)}.
- *
- * @param commit incrementAndGet commit
- * @return incrementAndGet result
- */
- protected long incrementAndGet(Commit<IncrementAndGet> commit) {
- long value = primitive(map.get(commit.value().key()));
- map.put(commit.value().key(), ++value);
- return value;
- }
-
- /**
- * Handles a {@link DecrementAndGet} command which implements
- * {@link AtomixAtomicCounterMap#decrementAndGet(String)}.
- *
- * @param commit decrementAndGet commit
- * @return decrementAndGet result
- */
- protected long decrementAndGet(Commit<DecrementAndGet> commit) {
- long value = primitive(map.get(commit.value().key()));
- map.put(commit.value().key(), --value);
- return value;
- }
-
- /**
- * Handles a {@link AddAndGet} command which implements {@link AtomixAtomicCounterMap#addAndGet(String, long)}.
- *
- * @param commit addAndGet commit
- * @return addAndGet result
- */
- protected long addAndGet(Commit<AddAndGet> commit) {
- long value = primitive(map.get(commit.value().key()));
- value += commit.value().delta();
- map.put(commit.value().key(), value);
- return value;
- }
-
- /**
- * Handles a {@link GetAndAdd} command which implements {@link AtomixAtomicCounterMap#getAndAdd(String, long)}.
- *
- * @param commit getAndAdd commit
- * @return getAndAdd result
- */
- protected long getAndAdd(Commit<GetAndAdd> commit) {
- long value = primitive(map.get(commit.value().key()));
- map.put(commit.value().key(), value + commit.value().delta());
- return value;
- }
-
- /**
- * Handles a {@code Size} query which implements {@link AtomixAtomicCounterMap#size()}.
- *
- * @param commit size commit
- * @return size result
- */
- protected int size(Commit<Void> commit) {
- return map.size();
- }
-
- /**
- * Handles an {@code IsEmpty} query which implements {@link AtomixAtomicCounterMap#isEmpty()}.
- *
- * @param commit isEmpty commit
- * @return isEmpty result
- */
- protected boolean isEmpty(Commit<Void> commit) {
- return map.isEmpty();
- }
-
- /**
- * Handles a {@code Clear} command which implements {@link AtomixAtomicCounterMap#clear()}.
- *
- * @param commit clear commit
- */
- protected void clear(Commit<Void> commit) {
- map.clear();
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMap.java
deleted file mode 100644
index 0514333..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMap.java
+++ /dev/null
@@ -1,530 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.ConcurrentModificationException;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.NoSuchElementException;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.Executor;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.Predicate;
-
-import io.atomix.protocols.raft.proxy.RaftProxy;
-import org.onlab.util.KryoNamespace;
-import org.onlab.util.Tools;
-import org.onosproject.store.primitives.MapUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ContainsKey;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ContainsValue;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.Get;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.GetOrDefault;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.Put;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.Remove;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.RemoveValue;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.RemoveVersion;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.Replace;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ReplaceValue;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ReplaceVersion;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.TransactionBegin;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.TransactionCommit;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.TransactionPrepare;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.TransactionPrepareAndCommit;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.TransactionRollback;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncConsistentMap;
-import org.onosproject.store.service.AsyncIterator;
-import org.onosproject.store.service.ConsistentMapException;
-import org.onosproject.store.service.MapEvent;
-import org.onosproject.store.service.MapEventListener;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.Versioned;
-
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapEvents.CHANGE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ADD_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.BEGIN;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.CLEAR;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.CLOSE_ITERATOR;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.COMMIT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.CONTAINS_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.CONTAINS_VALUE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ENTRY_SET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.GET_OR_DEFAULT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.IS_EMPTY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.IteratorBatch;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.IteratorPosition;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.KEY_SET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.NEXT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.OPEN_ITERATOR;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.PREPARE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.PREPARE_AND_COMMIT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.PUT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.PUT_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.PUT_IF_ABSENT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REMOVE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REMOVE_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REMOVE_VALUE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REMOVE_VERSION;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REPLACE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REPLACE_VALUE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REPLACE_VERSION;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ROLLBACK;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.SIZE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.VALUES;
-
-/**
- * Distributed resource providing the {@link AsyncConsistentMap} primitive.
- */
-public class AtomixConsistentMap extends AbstractRaftPrimitive implements AsyncConsistentMap<String, byte[]> {
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixConsistentMapOperations.NAMESPACE)
- .register(AtomixConsistentMapEvents.NAMESPACE)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 100)
- .build());
-
- private final Map<MapEventListener<String, byte[]>, Executor> mapEventListeners = new ConcurrentHashMap<>();
-
- public AtomixConsistentMap(RaftProxy proxy) {
- super(proxy);
- proxy.addEventListener(CHANGE, SERIALIZER::decode, this::handleEvent);
- proxy.addStateChangeListener(state -> {
- if (state == RaftProxy.State.CONNECTED && isListening()) {
- proxy.invoke(ADD_LISTENER);
- }
- });
- }
-
- protected Serializer serializer() {
- return SERIALIZER;
- }
-
- private void handleEvent(List<MapEvent<String, byte[]>> events) {
- events.forEach(event ->
- mapEventListeners.forEach((listener, executor) -> executor.execute(() -> listener.event(event))));
- }
-
- @Override
- public CompletableFuture<Boolean> isEmpty() {
- return proxy.invoke(IS_EMPTY, serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- return proxy.invoke(SIZE, serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(String key) {
- return proxy.invoke(CONTAINS_KEY, serializer()::encode, new ContainsKey(key), serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> containsValue(byte[] value) {
- return proxy.invoke(CONTAINS_VALUE, serializer()::encode, new ContainsValue(value), serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Versioned<byte[]>> get(String key) {
- return proxy.invoke(GET, serializer()::encode, new Get(key), serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Versioned<byte[]>> getOrDefault(String key, byte[] defaultValue) {
- return proxy.invoke(
- GET_OR_DEFAULT,
- serializer()::encode,
- new GetOrDefault(key, defaultValue),
- serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Set<String>> keySet() {
- return proxy.invoke(KEY_SET, serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Collection<Versioned<byte[]>>> values() {
- return proxy.invoke(VALUES, serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Set<Entry<String, Versioned<byte[]>>>> entrySet() {
- return proxy.invoke(ENTRY_SET, serializer()::decode);
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public CompletableFuture<Versioned<byte[]>> put(String key, byte[] value) {
- return proxy.<Put, MapEntryUpdateResult<String, byte[]>>invoke(
- PUT,
- serializer()::encode,
- new Put(key, value),
- serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenApply(v -> v.result());
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public CompletableFuture<Versioned<byte[]>> putAndGet(String key, byte[] value) {
- return proxy.<Put, MapEntryUpdateResult<String, byte[]>>invoke(
- PUT_AND_GET,
- serializer()::encode,
- new Put(key, value),
- serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenApply(v -> v.result());
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public CompletableFuture<Versioned<byte[]>> putIfAbsent(String key, byte[] value) {
- return proxy.<Put, MapEntryUpdateResult<String, byte[]>>invoke(
- PUT_IF_ABSENT,
- serializer()::encode,
- new Put(key, value),
- serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenApply(v -> v.result());
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public CompletableFuture<Versioned<byte[]>> remove(String key) {
- return proxy.<Remove, MapEntryUpdateResult<String, byte[]>>invoke(
- REMOVE,
- serializer()::encode,
- new Remove(key),
- serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenApply(v -> v.result());
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public CompletableFuture<Boolean> remove(String key, byte[] value) {
- return proxy.<RemoveValue, MapEntryUpdateResult<String, byte[]>>invoke(
- REMOVE_VALUE,
- serializer()::encode,
- new RemoveValue(key, value),
- serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenApply(v -> v.updated());
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public CompletableFuture<Boolean> remove(String key, long version) {
- return proxy.<RemoveVersion, MapEntryUpdateResult<String, byte[]>>invoke(
- REMOVE_VERSION,
- serializer()::encode,
- new RemoveVersion(key, version),
- serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenApply(v -> v.updated());
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public CompletableFuture<Versioned<byte[]>> replace(String key, byte[] value) {
- return proxy.<Replace, MapEntryUpdateResult<String, byte[]>>invoke(
- REPLACE,
- serializer()::encode,
- new Replace(key, value),
- serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenApply(v -> v.result());
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public CompletableFuture<Boolean> replace(String key, byte[] oldValue, byte[] newValue) {
- return proxy.<ReplaceValue, MapEntryUpdateResult<String, byte[]>>invoke(
- REPLACE_VALUE,
- serializer()::encode,
- new ReplaceValue(key, oldValue, newValue),
- serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenApply(v -> v.updated());
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public CompletableFuture<Boolean> replace(String key, long oldVersion, byte[] newValue) {
- return proxy.<ReplaceVersion, MapEntryUpdateResult<String, byte[]>>invoke(
- REPLACE_VERSION,
- serializer()::encode,
- new ReplaceVersion(key, oldVersion, newValue),
- serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenApply(v -> v.updated());
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return proxy.<MapEntryUpdateResult.Status>invoke(CLEAR, serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenApply(v -> null);
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public CompletableFuture<Versioned<byte[]>> computeIf(String key,
- Predicate<? super byte[]> condition,
- BiFunction<? super String, ? super byte[], ? extends byte[]> remappingFunction) {
- return get(key).thenCompose(r1 -> {
- byte[] existingValue = r1 == null ? null : r1.value();
- // if the condition evaluates to false, return existing value.
- if (!condition.test(existingValue)) {
- return CompletableFuture.completedFuture(r1);
- }
-
- byte[] computedValue;
- try {
- computedValue = remappingFunction.apply(key, existingValue);
- } catch (Exception e) {
- return Tools.exceptionalFuture(e);
- }
-
- if (computedValue == null && r1 == null) {
- return CompletableFuture.completedFuture(null);
- }
-
- if (r1 == null) {
- return proxy.<Put, MapEntryUpdateResult<String, byte[]>>invoke(
- PUT_IF_ABSENT,
- serializer()::encode,
- new Put(key, computedValue),
- serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenCompose(r -> checkLocked(r))
- .thenApply(result -> new Versioned<>(computedValue, result.version()));
- } else if (computedValue == null) {
- return proxy.<RemoveVersion, MapEntryUpdateResult<String, byte[]>>invoke(
- REMOVE_VERSION,
- serializer()::encode,
- new RemoveVersion(key, r1.version()),
- serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenCompose(r -> checkLocked(r))
- .thenApply(v -> null);
- } else {
- return proxy.<ReplaceVersion, MapEntryUpdateResult<String, byte[]>>invoke(
- REPLACE_VERSION,
- serializer()::encode,
- new ReplaceVersion(key, r1.version(), computedValue),
- serializer()::decode)
- .whenComplete((r, e) -> throwIfLocked(r))
- .thenCompose(r -> checkLocked(r))
- .thenApply(result -> result.status() == MapEntryUpdateResult.Status.OK
- ? new Versioned(computedValue, result.version()) : result.result());
- }
- });
- }
-
- private CompletableFuture<MapEntryUpdateResult<String, byte[]>> checkLocked(
- MapEntryUpdateResult<String, byte[]> result) {
- if (result.status() == MapEntryUpdateResult.Status.PRECONDITION_FAILED ||
- result.status() == MapEntryUpdateResult.Status.WRITE_LOCK) {
- return Tools.exceptionalFuture(new ConsistentMapException.ConcurrentModification());
- }
- return CompletableFuture.completedFuture(result);
- }
-
- @Override
- public synchronized CompletableFuture<Void> addListener(MapEventListener<String, byte[]> listener,
- Executor executor) {
- if (mapEventListeners.isEmpty()) {
- return proxy.invoke(ADD_LISTENER).thenRun(() -> mapEventListeners.put(listener, executor));
- } else {
- mapEventListeners.put(listener, executor);
- return CompletableFuture.completedFuture(null);
- }
- }
-
- @Override
- public synchronized CompletableFuture<Void> removeListener(MapEventListener<String, byte[]> listener) {
- if (mapEventListeners.remove(listener) != null && mapEventListeners.isEmpty()) {
- return proxy.invoke(REMOVE_LISTENER).thenApply(v -> null);
- }
- return CompletableFuture.completedFuture(null);
- }
-
- private void throwIfLocked(MapEntryUpdateResult<String, byte[]> result) {
- if (result != null) {
- throwIfLocked(result.status());
- }
- }
-
- private void throwIfLocked(MapEntryUpdateResult.Status status) {
- if (status == MapEntryUpdateResult.Status.WRITE_LOCK) {
- throw new ConcurrentModificationException("Cannot update map: Another transaction in progress");
- }
- }
-
- @Override
- public CompletableFuture<Version> begin(TransactionId transactionId) {
- return proxy.<TransactionBegin, Long>invoke(
- BEGIN,
- serializer()::encode,
- new TransactionBegin(transactionId),
- serializer()::decode)
- .thenApply(Version::new);
- }
-
- @Override
- public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<String, byte[]>> transactionLog) {
- return proxy.<TransactionPrepare, PrepareResult>invoke(
- PREPARE,
- serializer()::encode,
- new TransactionPrepare(transactionLog),
- serializer()::decode)
- .thenApply(v -> v == PrepareResult.OK);
- }
-
- @Override
- public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<String, byte[]>> transactionLog) {
- return proxy.<TransactionPrepareAndCommit, PrepareResult>invoke(
- PREPARE_AND_COMMIT,
- serializer()::encode,
- new TransactionPrepareAndCommit(transactionLog),
- serializer()::decode)
- .thenApply(v -> v == PrepareResult.OK);
- }
-
- @Override
- public CompletableFuture<Void> commit(TransactionId transactionId) {
- return proxy.<TransactionCommit, CommitResult>invoke(
- COMMIT,
- serializer()::encode,
- new TransactionCommit(transactionId),
- serializer()::decode)
- .thenApply(v -> null);
- }
-
- @Override
- public CompletableFuture<Void> rollback(TransactionId transactionId) {
- return proxy.invoke(
- ROLLBACK,
- serializer()::encode,
- new TransactionRollback(transactionId),
- serializer()::decode)
- .thenApply(v -> null);
- }
-
- private boolean isListening() {
- return !mapEventListeners.isEmpty();
- }
-
- @Override
- public CompletableFuture<AsyncIterator<Entry<String, Versioned<byte[]>>>> iterator() {
- return proxy.<Long>invoke(OPEN_ITERATOR, SERIALIZER::decode)
- .thenApply(ConsistentMultimapIterator::new);
- }
-
- /**
- * Consistent multimap iterator.
- */
- private class ConsistentMultimapIterator implements AsyncIterator<Map.Entry<String, Versioned<byte[]>>> {
- private final long id;
- private volatile CompletableFuture<IteratorBatch> batch;
- private volatile CompletableFuture<Void> closeFuture;
-
- ConsistentMultimapIterator(long id) {
- this.id = id;
- this.batch = CompletableFuture.completedFuture(
- new IteratorBatch(0, Collections.emptyList()));
- }
-
- /**
- * Returns the current batch iterator or lazily fetches the next batch from the cluster.
- *
- * @return the next batch iterator
- */
- private CompletableFuture<Iterator<Entry<String, Versioned<byte[]>>>> batch() {
- return batch.thenCompose(iterator -> {
- if (iterator != null && !iterator.hasNext()) {
- batch = fetch(iterator.position());
- return batch.thenApply(Function.identity());
- }
- return CompletableFuture.completedFuture(iterator);
- });
- }
-
- /**
- * Fetches the next batch of entries from the cluster.
- *
- * @param position the position from which to fetch the next batch
- * @return the next batch of entries from the cluster
- */
- private CompletableFuture<IteratorBatch> fetch(int position) {
- return proxy.<IteratorPosition, IteratorBatch>invoke(
- NEXT,
- SERIALIZER::encode,
- new IteratorPosition(id, position),
- SERIALIZER::decode)
- .thenCompose(batch -> {
- if (batch == null) {
- return close().thenApply(v -> null);
- }
- return CompletableFuture.completedFuture(batch);
- });
- }
-
- /**
- * Closes the iterator.
- *
- * @return future to be completed once the iterator has been closed
- */
- private CompletableFuture<Void> close() {
- if (closeFuture == null) {
- synchronized (this) {
- if (closeFuture == null) {
- closeFuture = proxy.invoke(CLOSE_ITERATOR, SERIALIZER::encode, id);
- }
- }
- }
- return closeFuture;
- }
-
- @Override
- public CompletableFuture<Boolean> hasNext() {
- return batch().thenApply(iterator -> iterator != null && iterator.hasNext());
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<byte[]>>> next() {
- return batch().thenCompose(iterator -> {
- if (iterator == null) {
- return Tools.exceptionalFuture(new NoSuchElementException());
- }
- return CompletableFuture.completedFuture(iterator.next());
- });
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapEvents.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapEvents.java
deleted file mode 100644
index a0429da..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapEvents.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import io.atomix.protocols.raft.event.EventType;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.MapEvent;
-
-/**
- * Atomix consistent map events.
- */
-public enum AtomixConsistentMapEvents implements EventType {
- CHANGE;
-
- @Override
- public String id() {
- return name();
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 50)
- .register(MapEvent.class)
- .register(MapEvent.Type.class)
- .register(byte[].class)
- .build("AtomixConsistentMapEvents");
-
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapOperations.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapOperations.java
deleted file mode 100644
index 4f131ef..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapOperations.java
+++ /dev/null
@@ -1,648 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Map;
-
-import com.google.common.collect.Maps;
-import io.atomix.protocols.raft.operation.OperationId;
-import io.atomix.protocols.raft.operation.OperationType;
-import io.atomix.utils.ArraySizeHashPrinter;
-import org.onlab.util.KryoNamespace;
-import org.onlab.util.Match;
-import org.onosproject.store.primitives.MapUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Versioned;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * {@link AtomixConsistentMap} resource state machine operations.
- */
-public enum AtomixConsistentMapOperations implements OperationId {
- IS_EMPTY(OperationType.QUERY),
- SIZE(OperationType.QUERY),
- CONTAINS_KEY(OperationType.QUERY),
- CONTAINS_VALUE(OperationType.QUERY),
- GET(OperationType.QUERY),
- GET_OR_DEFAULT(OperationType.QUERY),
- KEY_SET(OperationType.QUERY),
- VALUES(OperationType.QUERY),
- ENTRY_SET(OperationType.QUERY),
- PUT(OperationType.COMMAND),
- PUT_IF_ABSENT(OperationType.COMMAND),
- PUT_AND_GET(OperationType.COMMAND),
- REMOVE(OperationType.COMMAND),
- REMOVE_VALUE(OperationType.COMMAND),
- REMOVE_VERSION(OperationType.COMMAND),
- REPLACE(OperationType.COMMAND),
- REPLACE_VALUE(OperationType.COMMAND),
- REPLACE_VERSION(OperationType.COMMAND),
- CLEAR(OperationType.COMMAND),
- ADD_LISTENER(OperationType.COMMAND),
- REMOVE_LISTENER(OperationType.COMMAND),
- BEGIN(OperationType.COMMAND),
- PREPARE(OperationType.COMMAND),
- PREPARE_AND_COMMIT(OperationType.COMMAND),
- COMMIT(OperationType.COMMAND),
- ROLLBACK(OperationType.COMMAND),
- OPEN_ITERATOR(OperationType.COMMAND),
- NEXT(OperationType.QUERY),
- CLOSE_ITERATOR(OperationType.COMMAND);
-
- private final OperationType type;
-
- AtomixConsistentMapOperations(OperationType type) {
- this.type = type;
- }
-
- @Override
- public String id() {
- return name();
- }
-
- @Override
- public OperationType type() {
- return type;
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID)
- .register(ContainsKey.class)
- .register(ContainsValue.class)
- .register(Get.class)
- .register(GetOrDefault.class)
- .register(Put.class)
- .register(Remove.class)
- .register(RemoveValue.class)
- .register(RemoveVersion.class)
- .register(Replace.class)
- .register(ReplaceValue.class)
- .register(ReplaceVersion.class)
- .register(TransactionBegin.class)
- .register(TransactionPrepare.class)
- .register(TransactionPrepareAndCommit.class)
- .register(TransactionCommit.class)
- .register(TransactionRollback.class)
- .register(TransactionId.class)
- .register(TransactionLog.class)
- .register(MapUpdate.class)
- .register(MapUpdate.Type.class)
- .register(PrepareResult.class)
- .register(CommitResult.class)
- .register(RollbackResult.class)
- .register(Match.class)
- .register(MapEntryUpdateResult.class)
- .register(MapEntryUpdateResult.Status.class)
- .register(Versioned.class)
- .register(byte[].class)
- .register(Maps.immutableEntry("", "").getClass())
- .register(IteratorBatch.class)
- .register(IteratorPosition.class)
- .build("AtomixConsistentMapOperations");
-
- /**
- * Abstract map command.
- */
- @SuppressWarnings("serial")
- public abstract static class MapOperation {
- @Override
- public String toString() {
- return toStringHelper(getClass())
- .toString();
- }
- }
-
- /**
- * Abstract key-based query.
- */
- @SuppressWarnings("serial")
- public abstract static class KeyOperation extends MapOperation {
- protected String key;
-
- public KeyOperation() {
- }
-
- public KeyOperation(String key) {
- this.key = checkNotNull(key, "key cannot be null");
- }
-
- /**
- * Returns the key.
- * @return key
- */
- public String key() {
- return key;
- }
-
- @Override
- public String toString() {
- return toStringHelper(getClass())
- .add("key", key)
- .toString();
- }
- }
-
- /**
- * Abstract value-based query.
- */
- @SuppressWarnings("serial")
- public abstract static class ValueOperation extends MapOperation {
- protected byte[] value;
-
- public ValueOperation() {
- }
-
- public ValueOperation(byte[] value) {
- this.value = value;
- }
-
- /**
- * Returns the value.
- * @return value
- */
- public byte[] value() {
- return value;
- }
-
- @Override
- public String toString() {
- return toStringHelper(getClass())
- .add("value", value)
- .toString();
- }
- }
-
- /**
- * Abstract key/value operation.
- */
- @SuppressWarnings("serial")
- public abstract static class KeyValueOperation extends KeyOperation {
- protected byte[] value;
-
- public KeyValueOperation() {
- }
-
- public KeyValueOperation(String key, byte[] value) {
- super(key);
- this.value = value;
- }
-
- /**
- * Returns the value.
- * @return value
- */
- public byte[] value() {
- return value;
- }
-
- @Override
- public String toString() {
- return toStringHelper(getClass())
- .add("key", key)
- .add("value", ArraySizeHashPrinter.of(value))
- .toString();
- }
- }
-
- /**
- * Abstract key/version operation.
- */
- @SuppressWarnings("serial")
- public abstract static class KeyVersionOperation extends KeyOperation {
- protected long version;
-
- public KeyVersionOperation() {
- }
-
- public KeyVersionOperation(String key, long version) {
- super(key);
- this.version = version;
- }
-
- /**
- * Returns the version.
- * @return version
- */
- public long version() {
- return version;
- }
-
- @Override
- public String toString() {
- return toStringHelper(getClass())
- .add("key", key)
- .add("version", version)
- .toString();
- }
- }
-
- /**
- * Contains key command.
- */
- @SuppressWarnings("serial")
- public static class ContainsKey extends KeyOperation {
- public ContainsKey() {
- }
-
- public ContainsKey(String key) {
- super(key);
- }
- }
-
- /**
- * Contains value command.
- */
- @SuppressWarnings("serial")
- public static class ContainsValue extends ValueOperation {
- public ContainsValue() {
- }
-
- public ContainsValue(byte[] value) {
- super(value);
- }
- }
-
- /**
- * Map put operation.
- */
- public static class Put extends KeyValueOperation {
- public Put() {
- }
-
- public Put(String key, byte[] value) {
- super(key, value);
- }
- }
-
- /**
- * Remove operation.
- */
- public static class Remove extends KeyOperation {
- public Remove() {
- }
-
- public Remove(String key) {
- super(key);
- }
- }
-
- /**
- * Remove if value match operation.
- */
- public static class RemoveValue extends KeyValueOperation {
- public RemoveValue() {
- }
-
- public RemoveValue(String key, byte[] value) {
- super(key, value);
- }
- }
-
- /**
- * Remove if version match operation.
- */
- public static class RemoveVersion extends KeyVersionOperation {
- public RemoveVersion() {
- }
-
- public RemoveVersion(String key, long version) {
- super(key, version);
- }
- }
-
- /**
- * Replace operation.
- */
- public static class Replace extends KeyValueOperation {
- public Replace() {
- }
-
- public Replace(String key, byte[] value) {
- super(key, value);
- }
- }
-
- /**
- * Replace by value operation.
- */
- public static class ReplaceValue extends KeyOperation {
- private byte[] oldValue;
- private byte[] newValue;
-
- public ReplaceValue() {
- }
-
- public ReplaceValue(String key, byte[] oldValue, byte[] newValue) {
- super(key);
- this.oldValue = oldValue;
- this.newValue = newValue;
- }
-
- public byte[] oldValue() {
- return oldValue;
- }
-
- public byte[] newValue() {
- return newValue;
- }
-
- @Override
- public String toString() {
- return toStringHelper(this)
- .add("key", key)
- .add("oldValue", ArraySizeHashPrinter.of(oldValue))
- .add("newValue", ArraySizeHashPrinter.of(newValue))
- .toString();
- }
- }
-
- /**
- * Replace by version operation.
- */
- public static class ReplaceVersion extends KeyOperation {
- private long oldVersion;
- private byte[] newValue;
-
- public ReplaceVersion() {
- }
-
- public ReplaceVersion(String key, long oldVersion, byte[] newValue) {
- super(key);
- this.oldVersion = oldVersion;
- this.newValue = newValue;
- }
-
- public long oldVersion() {
- return oldVersion;
- }
-
- public byte[] newValue() {
- return newValue;
- }
-
- @Override
- public String toString() {
- return toStringHelper(this)
- .add("key", key)
- .add("oldVersion", oldVersion)
- .add("newValue", ArraySizeHashPrinter.of(newValue))
- .toString();
- }
- }
-
- /**
- * Transaction begin command.
- */
- public static class TransactionBegin extends MapOperation {
- private TransactionId transactionId;
-
- public TransactionBegin() {
- }
-
- public TransactionBegin(TransactionId transactionId) {
- this.transactionId = transactionId;
- }
-
- public TransactionId transactionId() {
- return transactionId;
- }
- }
-
- /**
- * Map prepare command.
- */
- @SuppressWarnings("serial")
- public static class TransactionPrepare extends MapOperation {
- private TransactionLog<MapUpdate<String, byte[]>> transactionLog;
-
- public TransactionPrepare() {
- }
-
- public TransactionPrepare(TransactionLog<MapUpdate<String, byte[]>> transactionLog) {
- this.transactionLog = transactionLog;
- }
-
- public TransactionLog<MapUpdate<String, byte[]>> transactionLog() {
- return transactionLog;
- }
-
- @Override
- public String toString() {
- return toStringHelper(getClass())
- .add("transactionLog", transactionLog)
- .toString();
- }
- }
-
- /**
- * Map prepareAndCommit command.
- */
- @SuppressWarnings("serial")
- public static class TransactionPrepareAndCommit extends TransactionPrepare {
- public TransactionPrepareAndCommit() {
- }
-
- public TransactionPrepareAndCommit(TransactionLog<MapUpdate<String, byte[]>> transactionLog) {
- super(transactionLog);
- }
- }
-
- /**
- * Map transaction commit command.
- */
- @SuppressWarnings("serial")
- public static class TransactionCommit extends MapOperation {
- private TransactionId transactionId;
-
- public TransactionCommit() {
- }
-
- public TransactionCommit(TransactionId transactionId) {
- this.transactionId = transactionId;
- }
-
- /**
- * Returns the transaction identifier.
- * @return transaction id
- */
- public TransactionId transactionId() {
- return transactionId;
- }
-
- @Override
- public String toString() {
- return toStringHelper(getClass())
- .add("transactionId", transactionId)
- .toString();
- }
- }
-
- /**
- * Map transaction rollback command.
- */
- @SuppressWarnings("serial")
- public static class TransactionRollback extends MapOperation {
- private TransactionId transactionId;
-
- public TransactionRollback() {
- }
-
- public TransactionRollback(TransactionId transactionId) {
- this.transactionId = transactionId;
- }
-
- /**
- * Returns the transaction identifier.
- * @return transaction id
- */
- public TransactionId transactionId() {
- return transactionId;
- }
-
- @Override
- public String toString() {
- return toStringHelper(getClass())
- .add("transactionId", transactionId)
- .toString();
- }
- }
-
- /**
- * Get query.
- */
- @SuppressWarnings("serial")
- public static class Get extends KeyOperation {
- public Get() {
- }
-
- public Get(String key) {
- super(key);
- }
- }
-
- /**
- * Get or default query.
- */
- @SuppressWarnings("serial")
- public static class GetOrDefault extends KeyOperation {
- private byte[] defaultValue;
-
- public GetOrDefault() {
- }
-
- public GetOrDefault(String key, byte[] defaultValue) {
- super(key);
- this.defaultValue = defaultValue;
- }
-
- /**
- * Returns the default value.
- *
- * @return the default value
- */
- public byte[] defaultValue() {
- return defaultValue;
- }
-
- @Override
- public String toString() {
- return toStringHelper(this)
- .add("key", key)
- .add("defaultValue", ArraySizeHashPrinter.of(defaultValue))
- .toString();
- }
- }
-
- /**
- * Iterator position.
- */
- public static class IteratorPosition {
- private long iteratorId;
- private int position;
-
- private IteratorPosition() {
- }
-
- public IteratorPosition(long iteratorId, int position) {
- this.iteratorId = iteratorId;
- this.position = position;
- }
-
- public long iteratorId() {
- return iteratorId;
- }
-
- public int position() {
- return position;
- }
- }
-
- /**
- * Iterator batch.
- */
- public static class IteratorBatch implements Iterator<Map.Entry<String, Versioned<byte[]>>> {
- private int position;
- private Collection<Map.Entry<String, Versioned<byte[]>>> entries;
- private transient volatile Iterator<Map.Entry<String, Versioned<byte[]>>> iterator;
-
- private IteratorBatch() {
- }
-
- public IteratorBatch(int position, Collection<Map.Entry<String, Versioned<byte[]>>> entries) {
- this.position = position;
- this.entries = entries;
- }
-
- public int position() {
- return position;
- }
-
- public Collection<Map.Entry<String, Versioned<byte[]>>> entries() {
- return entries;
- }
-
- private Iterator<Map.Entry<String, Versioned<byte[]>>> iterator() {
- Iterator<Map.Entry<String, Versioned<byte[]>>> iterator = this.iterator;
- if (iterator == null) {
- synchronized (entries) {
- iterator = this.iterator;
- if (iterator == null) {
- iterator = entries.iterator();
- this.iterator = iterator;
- }
- }
- }
- return iterator;
- }
-
- @Override
- public boolean hasNext() {
- return iterator().hasNext();
- }
-
- @Override
- public Map.Entry<String, Versioned<byte[]>> next() {
- return iterator().next();
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapService.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapService.java
deleted file mode 100644
index 0fcf3b5..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapService.java
+++ /dev/null
@@ -1,1131 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import io.atomix.protocols.raft.service.AbstractRaftService;
-import io.atomix.protocols.raft.service.Commit;
-import io.atomix.protocols.raft.service.RaftServiceExecutor;
-import io.atomix.protocols.raft.session.RaftSession;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotReader;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotWriter;
-import org.onlab.util.KryoNamespace;
-import org.onlab.util.Match;
-import org.onosproject.store.primitives.MapUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ContainsKey;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ContainsValue;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.Get;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.GetOrDefault;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.Put;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.Remove;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.RemoveValue;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.RemoveVersion;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.Replace;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ReplaceValue;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ReplaceVersion;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.TransactionBegin;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.TransactionCommit;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.TransactionPrepare;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.TransactionPrepareAndCommit;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.TransactionRollback;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.MapEvent;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Versioned;
-
-import static com.google.common.base.Preconditions.checkState;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapEvents.CHANGE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ADD_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.BEGIN;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.CLEAR;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.CLOSE_ITERATOR;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.COMMIT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.CONTAINS_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.CONTAINS_VALUE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ENTRY_SET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.GET_OR_DEFAULT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.IS_EMPTY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.IteratorBatch;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.IteratorPosition;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.KEY_SET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.NEXT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.OPEN_ITERATOR;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.PREPARE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.PREPARE_AND_COMMIT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.PUT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.PUT_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.PUT_IF_ABSENT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REMOVE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REMOVE_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REMOVE_VALUE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REMOVE_VERSION;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REPLACE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REPLACE_VALUE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.REPLACE_VERSION;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.ROLLBACK;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.SIZE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentMapOperations.VALUES;
-
-/**
- * State Machine for {@link AtomixConsistentMap} resource.
- */
-public class AtomixConsistentMapService extends AbstractRaftService {
-
- private static final int MAX_ITERATOR_BATCH_SIZE = 1024 * 32;
-
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixConsistentMapOperations.NAMESPACE)
- .register(AtomixConsistentMapEvents.NAMESPACE)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 100)
- .register(TransactionScope.class)
- .register(TransactionLog.class)
- .register(TransactionId.class)
- .register(MapEntryValue.class)
- .register(MapEntryValue.Type.class)
- .register(new HashMap().keySet().getClass())
- .build());
-
- protected Map<Long, RaftSession> listeners = new LinkedHashMap<>();
- private Map<String, MapEntryValue> map;
- protected Set<String> preparedKeys = Sets.newHashSet();
- private Map<Long, IteratorContext> iterators = Maps.newHashMap();
- protected Map<TransactionId, TransactionScope> activeTransactions = Maps.newHashMap();
- protected long currentVersion;
-
- public AtomixConsistentMapService() {
- map = createMap();
- }
-
- protected Map<String, MapEntryValue> createMap() {
- return Maps.newConcurrentMap();
- }
-
- protected Map<String, MapEntryValue> entries() {
- return map;
- }
-
- protected Serializer serializer() {
- return SERIALIZER;
- }
-
- @Override
- public void snapshot(SnapshotWriter writer) {
- writer.writeObject(Sets.newHashSet(listeners.keySet()), serializer()::encode);
- writer.writeObject(preparedKeys, serializer()::encode);
- writer.writeObject(entries(), serializer()::encode);
- writer.writeObject(activeTransactions, serializer()::encode);
- writer.writeLong(currentVersion);
-
- Map<Long, Long> iterators = Maps.newHashMap();
- this.iterators.forEach((id, context) -> iterators.put(id, context.sessionId));
- writer.writeObject(iterators, serializer()::encode);
- }
-
- @Override
- public void install(SnapshotReader reader) {
- listeners = new LinkedHashMap<>();
- for (Long sessionId : reader.<Set<Long>>readObject(serializer()::decode)) {
- listeners.put(sessionId, sessions().getSession(sessionId));
- }
- preparedKeys = reader.readObject(serializer()::decode);
- map = reader.readObject(serializer()::decode);
- activeTransactions = reader.readObject(serializer()::decode);
- currentVersion = reader.readLong();
-
- Map<Long, Long> iterators = reader.readObject(serializer()::decode);
- this.iterators = Maps.newHashMap();
- iterators.forEach((id, session) ->
- this.iterators.put(id, new IteratorContext(session, entries().entrySet().iterator())));
- }
-
- @Override
- protected void configure(RaftServiceExecutor executor) {
- // Listeners
- executor.register(ADD_LISTENER, (Commit<Void> c) -> listen(c.session()));
- executor.register(REMOVE_LISTENER, (Commit<Void> c) -> unlisten(c.session()));
- // Queries
- executor.register(CONTAINS_KEY, serializer()::decode, this::containsKey, serializer()::encode);
- executor.register(CONTAINS_VALUE, serializer()::decode, this::containsValue, serializer()::encode);
- executor.register(ENTRY_SET, (Commit<Void> c) -> entrySet(), serializer()::encode);
- executor.register(GET, serializer()::decode, this::get, serializer()::encode);
- executor.register(GET_OR_DEFAULT, serializer()::decode, this::getOrDefault, serializer()::encode);
- executor.register(IS_EMPTY, (Commit<Void> c) -> isEmpty(), serializer()::encode);
- executor.register(KEY_SET, (Commit<Void> c) -> keySet(), serializer()::encode);
- executor.register(SIZE, (Commit<Void> c) -> size(), serializer()::encode);
- executor.register(VALUES, (Commit<Void> c) -> values(), serializer()::encode);
- // Commands
- executor.register(PUT, serializer()::decode, this::put, serializer()::encode);
- executor.register(PUT_IF_ABSENT, serializer()::decode, this::putIfAbsent, serializer()::encode);
- executor.register(PUT_AND_GET, serializer()::decode, this::putAndGet, serializer()::encode);
- executor.register(REMOVE, serializer()::decode, this::remove, serializer()::encode);
- executor.register(REMOVE_VALUE, serializer()::decode, this::removeValue, serializer()::encode);
- executor.register(REMOVE_VERSION, serializer()::decode, this::removeVersion, serializer()::encode);
- executor.register(REPLACE, serializer()::decode, this::replace, serializer()::encode);
- executor.register(REPLACE_VALUE, serializer()::decode, this::replaceValue, serializer()::encode);
- executor.register(REPLACE_VERSION, serializer()::decode, this::replaceVersion, serializer()::encode);
- executor.register(CLEAR, (Commit<Void> c) -> clear(), serializer()::encode);
- executor.register(BEGIN, serializer()::decode, this::begin, serializer()::encode);
- executor.register(PREPARE, serializer()::decode, this::prepare, serializer()::encode);
- executor.register(PREPARE_AND_COMMIT, serializer()::decode, this::prepareAndCommit, serializer()::encode);
- executor.register(COMMIT, serializer()::decode, this::commit, serializer()::encode);
- executor.register(ROLLBACK, serializer()::decode, this::rollback, serializer()::encode);
- executor.register(OPEN_ITERATOR, this::openIterator, serializer()::encode);
- executor.register(NEXT, serializer()::decode, this::next, serializer()::encode);
- executor.register(CLOSE_ITERATOR, serializer()::decode, this::closeIterator);
- }
-
- /**
- * Handles a contains key commit.
- *
- * @param commit containsKey commit
- * @return {@code true} if map contains key
- */
- protected boolean containsKey(Commit<? extends ContainsKey> commit) {
- MapEntryValue value = entries().get(commit.value().key());
- return value != null && value.type() != MapEntryValue.Type.TOMBSTONE;
- }
-
- /**
- * Handles a contains value commit.
- *
- * @param commit containsValue commit
- * @return {@code true} if map contains value
- */
- protected boolean containsValue(Commit<? extends ContainsValue> commit) {
- Match<byte[]> valueMatch = Match.ifValue(commit.value().value());
- return entries().values().stream()
- .filter(value -> value.type() != MapEntryValue.Type.TOMBSTONE)
- .anyMatch(value -> valueMatch.matches(value.value()));
- }
-
- /**
- * Handles a get commit.
- *
- * @param commit get commit
- * @return value mapped to key
- */
- protected Versioned<byte[]> get(Commit<? extends Get> commit) {
- return toVersioned(entries().get(commit.value().key()));
- }
-
- /**
- * Handles a get or default commit.
- *
- * @param commit get or default commit
- * @return value mapped to key
- */
- protected Versioned<byte[]> getOrDefault(Commit<? extends GetOrDefault> commit) {
- MapEntryValue value = entries().get(commit.value().key());
- if (value == null) {
- return new Versioned<>(commit.value().defaultValue(), 0);
- } else if (value.type() == MapEntryValue.Type.TOMBSTONE) {
- return new Versioned<>(commit.value().defaultValue(), value.version);
- } else {
- return new Versioned<>(value.value(), value.version);
- }
- }
-
- /**
- * Handles a size commit.
- *
- * @return number of entries in map
- */
- protected int size() {
- return (int) entries().values().stream()
- .filter(value -> value.type() != MapEntryValue.Type.TOMBSTONE)
- .count();
- }
-
- /**
- * Handles an is empty commit.
- *
- * @return {@code true} if map is empty
- */
- protected boolean isEmpty() {
- return entries().values().stream()
- .noneMatch(value -> value.type() != MapEntryValue.Type.TOMBSTONE);
- }
-
- /**
- * Handles a keySet commit.
- *
- * @return set of keys in map
- */
- protected Set<String> keySet() {
- return entries().entrySet().stream()
- .filter(entry -> entry.getValue().type() != MapEntryValue.Type.TOMBSTONE)
- .map(Map.Entry::getKey)
- .collect(Collectors.toSet());
- }
-
- /**
- * Handles a values commit.
- *
- * @return collection of values in map
- */
- protected Collection<Versioned<byte[]>> values() {
- return entries().entrySet().stream()
- .filter(entry -> entry.getValue().type() != MapEntryValue.Type.TOMBSTONE)
- .map(entry -> toVersioned(entry.getValue()))
- .collect(Collectors.toList());
- }
-
- /**
- * Handles a entry set commit.
- *
- * @return set of map entries
- */
- protected Set<Map.Entry<String, Versioned<byte[]>>> entrySet() {
- return entries().entrySet().stream()
- .filter(entry -> entry.getValue().type() != MapEntryValue.Type.TOMBSTONE)
- .map(e -> Maps.immutableEntry(e.getKey(), toVersioned(e.getValue())))
- .collect(Collectors.toSet());
- }
-
- /**
- * Returns a boolean indicating whether the given MapEntryValues are equal.
- *
- * @param oldValue the first value to compare
- * @param newValue the second value to compare
- * @return indicates whether the two values are equal
- */
- protected boolean valuesEqual(MapEntryValue oldValue, MapEntryValue newValue) {
- return (oldValue == null && newValue == null)
- || (oldValue != null && newValue != null && valuesEqual(oldValue.value(), newValue.value()));
- }
-
- /**
- * Returns a boolean indicating whether the given entry values are equal.
- *
- * @param oldValue the first value to compare
- * @param newValue the second value to compare
- * @return indicates whether the two values are equal
- */
- protected boolean valuesEqual(byte[] oldValue, byte[] newValue) {
- return (oldValue == null && newValue == null)
- || (oldValue != null && newValue != null && Arrays.equals(oldValue, newValue));
- }
-
- /**
- * Returns a boolean indicating whether the given MapEntryValue is null or a tombstone.
- *
- * @param value the value to check
- * @return indicates whether the given value is null or is a tombstone
- */
- protected boolean valueIsNull(MapEntryValue value) {
- return value == null || value.type() == MapEntryValue.Type.TOMBSTONE;
- }
-
- /**
- * Handles a put commit.
- *
- * @param commit put commit
- * @return map entry update result
- */
- protected MapEntryUpdateResult<String, byte[]> put(Commit<? extends Put> commit) {
- String key = commit.value().key();
- MapEntryValue oldValue = entries().get(key);
- MapEntryValue newValue = new MapEntryValue(MapEntryValue.Type.VALUE, commit.index(), commit.value().value());
-
- // If the value is null or a tombstone, this is an insert.
- // Otherwise, only update the value if it has changed to reduce the number of events.
- if (valueIsNull(oldValue)) {
- // If the key has been locked by a transaction, return a WRITE_LOCK error.
- if (preparedKeys.contains(key)) {
- return new MapEntryUpdateResult<>(
- MapEntryUpdateResult.Status.WRITE_LOCK,
- commit.index(),
- key,
- toVersioned(oldValue));
- }
- entries().put(commit.value().key(),
- new MapEntryValue(MapEntryValue.Type.VALUE, newValue.version(), newValue.value()));
- Versioned<byte[]> result = toVersioned(oldValue);
- publish(new MapEvent<>(MapEvent.Type.INSERT, "", key, toVersioned(newValue), result));
- return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.OK, commit.index(), key, result);
- } else if (!valuesEqual(oldValue, newValue)) {
- // If the key has been locked by a transaction, return a WRITE_LOCK error.
- if (preparedKeys.contains(key)) {
- return new MapEntryUpdateResult<>(
- MapEntryUpdateResult.Status.WRITE_LOCK,
- commit.index(),
- key,
- toVersioned(oldValue));
- }
- entries().put(commit.value().key(),
- new MapEntryValue(MapEntryValue.Type.VALUE, newValue.version(), newValue.value()));
- Versioned<byte[]> result = toVersioned(oldValue);
- publish(new MapEvent<>(MapEvent.Type.UPDATE, "", key, toVersioned(newValue), result));
- return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.OK, commit.index(), key, result);
- }
- // If the value hasn't changed, return a NOOP result.
- return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.NOOP, commit.index(), key, toVersioned(oldValue));
- }
-
- /**
- * Handles a putIfAbsent commit.
- *
- * @param commit putIfAbsent commit
- * @return map entry update result
- */
- protected MapEntryUpdateResult<String, byte[]> putIfAbsent(Commit<? extends Put> commit) {
- String key = commit.value().key();
- MapEntryValue oldValue = entries().get(key);
-
- // If the value is null, this is an INSERT.
- if (valueIsNull(oldValue)) {
- // If the key has been locked by a transaction, return a WRITE_LOCK error.
- if (preparedKeys.contains(key)) {
- return new MapEntryUpdateResult<>(
- MapEntryUpdateResult.Status.WRITE_LOCK,
- commit.index(),
- key,
- toVersioned(oldValue));
- }
- MapEntryValue newValue = new MapEntryValue(
- MapEntryValue.Type.VALUE,
- commit.index(),
- commit.value().value());
- entries().put(commit.value().key(), newValue);
- Versioned<byte[]> result = toVersioned(newValue);
- publish(new MapEvent<>(MapEvent.Type.INSERT, "", key, result, null));
- return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.OK, commit.index(), key, null);
- }
- return new MapEntryUpdateResult<>(
- MapEntryUpdateResult.Status.PRECONDITION_FAILED,
- commit.index(),
- key,
- toVersioned(oldValue));
- }
-
- /**
- * Handles a putAndGet commit.
- *
- * @param commit putAndGet commit
- * @return map entry update result
- */
- protected MapEntryUpdateResult<String, byte[]> putAndGet(Commit<? extends Put> commit) {
- String key = commit.value().key();
- MapEntryValue oldValue = entries().get(key);
- MapEntryValue newValue = new MapEntryValue(MapEntryValue.Type.VALUE, commit.index(), commit.value().value());
-
- // If the value is null or a tombstone, this is an insert.
- // Otherwise, only update the value if it has changed to reduce the number of events.
- if (valueIsNull(oldValue)) {
- // If the key has been locked by a transaction, return a WRITE_LOCK error.
- if (preparedKeys.contains(key)) {
- return new MapEntryUpdateResult<>(
- MapEntryUpdateResult.Status.WRITE_LOCK,
- commit.index(),
- key,
- toVersioned(oldValue));
- }
- entries().put(commit.value().key(), newValue);
- Versioned<byte[]> result = toVersioned(newValue);
- publish(new MapEvent<>(MapEvent.Type.INSERT, "", key, result, null));
- return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.OK, commit.index(), key, result);
- } else if (!valuesEqual(oldValue, newValue)) {
- // If the key has been locked by a transaction, return a WRITE_LOCK error.
- if (preparedKeys.contains(key)) {
- return new MapEntryUpdateResult<>(
- MapEntryUpdateResult.Status.WRITE_LOCK,
- commit.index(),
- key,
- toVersioned(oldValue));
- }
- entries().put(commit.value().key(), newValue);
- Versioned<byte[]> result = toVersioned(newValue);
- publish(new MapEvent<>(MapEvent.Type.UPDATE, "", key, result, toVersioned(oldValue)));
- return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.OK, commit.index(), key, result);
- }
- return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.NOOP, commit.index(), key, toVersioned(oldValue));
- }
-
- /**
- * Handles a remove commit.
- *
- * @param index the commit index
- * @param key the key to remove
- * @param predicate predicate to determine whether to remove the entry
- * @return map entry update result
- */
- private MapEntryUpdateResult<String, byte[]> removeIf(long index, String key, Predicate<MapEntryValue> predicate) {
- MapEntryValue value = entries().get(key);
-
- // If the value does not exist or doesn't match the predicate, return a PRECONDITION_FAILED error.
- if (valueIsNull(value) || !predicate.test(value)) {
- return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.PRECONDITION_FAILED, index, key, null);
- }
-
- // If the key has been locked by a transaction, return a WRITE_LOCK error.
- if (preparedKeys.contains(key)) {
- return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.WRITE_LOCK, index, key, null);
- }
-
- // If no transactions are active, remove the key. Otherwise, replace it with a tombstone.
- if (activeTransactions.isEmpty()) {
- entries().remove(key);
- } else {
- entries().put(key, new MapEntryValue(MapEntryValue.Type.TOMBSTONE, index, null));
- }
-
- Versioned<byte[]> result = toVersioned(value);
- publish(new MapEvent<>(MapEvent.Type.REMOVE, "", key, null, result));
- return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.OK, index, key, result);
- }
-
- /**
- * Handles a remove commit.
- *
- * @param commit remove commit
- * @return map entry update result
- */
- protected MapEntryUpdateResult<String, byte[]> remove(Commit<? extends Remove> commit) {
- return removeIf(commit.index(), commit.value().key(), v -> true);
- }
-
- /**
- * Handles a removeValue commit.
- *
- * @param commit removeValue commit
- * @return map entry update result
- */
- protected MapEntryUpdateResult<String, byte[]> removeValue(Commit<? extends RemoveValue> commit) {
- return removeIf(commit.index(), commit.value().key(), v ->
- valuesEqual(v, new MapEntryValue(MapEntryValue.Type.VALUE, commit.index(), commit.value().value())));
- }
-
- /**
- * Handles a removeVersion commit.
- *
- * @param commit removeVersion commit
- * @return map entry update result
- */
- protected MapEntryUpdateResult<String, byte[]> removeVersion(Commit<? extends RemoveVersion> commit) {
- return removeIf(commit.index(), commit.value().key(), v -> v.version() == commit.value().version());
- }
-
- /**
- * Handles a replace commit.
- *
- * @param index the commit index
- * @param key the key to replace
- * @param newValue the value with which to replace the key
- * @param predicate a predicate to determine whether to replace the key
- * @return map entry update result
- */
- private MapEntryUpdateResult<String, byte[]> replaceIf(
- long index, String key, MapEntryValue newValue, Predicate<MapEntryValue> predicate) {
- MapEntryValue oldValue = entries().get(key);
-
- // If the key is not set or the current value doesn't match the predicate, return a PRECONDITION_FAILED error.
- if (valueIsNull(oldValue) || !predicate.test(oldValue)) {
- return new MapEntryUpdateResult<>(
- MapEntryUpdateResult.Status.PRECONDITION_FAILED,
- index,
- key,
- toVersioned(oldValue));
- }
-
- // If the key has been locked by a transaction, return a WRITE_LOCK error.
- if (preparedKeys.contains(key)) {
- return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.WRITE_LOCK, index, key, null);
- }
-
- entries().put(key, newValue);
- Versioned<byte[]> result = toVersioned(oldValue);
- publish(new MapEvent<>(MapEvent.Type.UPDATE, "", key, toVersioned(newValue), result));
- return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.OK, index, key, result);
- }
-
- /**
- * Handles a replace commit.
- *
- * @param commit replace commit
- * @return map entry update result
- */
- protected MapEntryUpdateResult<String, byte[]> replace(Commit<? extends Replace> commit) {
- MapEntryValue value = new MapEntryValue(MapEntryValue.Type.VALUE, commit.index(), commit.value().value());
- return replaceIf(commit.index(), commit.value().key(), value, v -> true);
- }
-
- /**
- * Handles a replaceValue commit.
- *
- * @param commit replaceValue commit
- * @return map entry update result
- */
- protected MapEntryUpdateResult<String, byte[]> replaceValue(Commit<? extends ReplaceValue> commit) {
- MapEntryValue value = new MapEntryValue(MapEntryValue.Type.VALUE, commit.index(), commit.value().newValue());
- return replaceIf(commit.index(), commit.value().key(), value,
- v -> valuesEqual(v.value(), commit.value().oldValue()));
- }
-
- /**
- * Handles a replaceVersion commit.
- *
- * @param commit replaceVersion commit
- * @return map entry update result
- */
- protected MapEntryUpdateResult<String, byte[]> replaceVersion(Commit<? extends ReplaceVersion> commit) {
- MapEntryValue value = new MapEntryValue(MapEntryValue.Type.VALUE, commit.index(), commit.value().newValue());
- return replaceIf(commit.index(), commit.value().key(), value,
- v -> v.version() == commit.value().oldVersion());
- }
-
- /**
- * Handles a clear commit.
- *
- * @return clear result
- */
- protected MapEntryUpdateResult.Status clear() {
- Iterator<Map.Entry<String, MapEntryValue>> iterator = entries().entrySet().iterator();
- Map<String, MapEntryValue> entriesToAdd = new HashMap<>();
- while (iterator.hasNext()) {
- Map.Entry<String, MapEntryValue> entry = iterator.next();
- String key = entry.getKey();
- MapEntryValue value = entry.getValue();
- if (!valueIsNull(value)) {
- Versioned<byte[]> removedValue = new Versioned<>(value.value(), value.version());
- publish(new MapEvent<>(MapEvent.Type.REMOVE, "", key, null, removedValue));
- if (activeTransactions.isEmpty()) {
- iterator.remove();
- } else {
- entriesToAdd.put(key, new MapEntryValue(MapEntryValue.Type.TOMBSTONE, value.version, null));
- }
- }
- }
- entries().putAll(entriesToAdd);
- return MapEntryUpdateResult.Status.OK;
- }
-
- /**
- * Handles an open iterator commit.
- *
- * @param commit the open iterator commit
- * @return iterator identifier
- */
- protected long openIterator(Commit<Void> commit) {
- iterators.put(commit.index(), new IteratorContext(
- commit.session().sessionId().id(),
- entries().entrySet().iterator()));
- return commit.index();
- }
-
- /**
- * Handles an iterator next commit.
- *
- * @param commit the next commit
- * @return a list of entries to iterate
- */
- protected IteratorBatch next(Commit<IteratorPosition> commit) {
- final long iteratorId = commit.value().iteratorId();
- final int position = commit.value().position();
-
- IteratorContext context = iterators.get(iteratorId);
- if (context == null) {
- return null;
- }
-
- List<Map.Entry<String, Versioned<byte[]>>> entries = new ArrayList<>();
- int size = 0;
- while (context.iterator.hasNext()) {
- context.position++;
- if (context.position > position) {
- Map.Entry<String, MapEntryValue> entry = context.iterator.next();
- String key = entry.getKey();
- Versioned<byte[]> value = toVersioned(entry.getValue());
- size += key.length();
- size += value.value() != null ? value.value().length : 0;
- entries.add(Maps.immutableEntry(key, value));
-
- if (size >= MAX_ITERATOR_BATCH_SIZE) {
- break;
- }
- }
- }
-
- if (entries.isEmpty()) {
- return null;
- }
- return new IteratorBatch(context.position, entries);
- }
-
- /**
- * Handles a close iterator commit.
- *
- * @param commit the close iterator commit
- */
- protected void closeIterator(Commit<Long> commit) {
- iterators.remove(commit.value());
- }
-
- /**
- * Handles a listen commit.
- *
- * @param session listen session
- */
- protected void listen(RaftSession session) {
- listeners.put(session.sessionId().id(), session);
- }
-
- /**
- * Handles an unlisten commit.
- *
- * @param session unlisten session
- */
- protected void unlisten(RaftSession session) {
- listeners.remove(session.sessionId().id());
- }
-
- /**
- * Handles a begin commit.
- *
- * @param commit transaction begin commit
- * @return transaction state version
- */
- protected long begin(Commit<? extends TransactionBegin> commit) {
- long version = commit.index();
- activeTransactions.put(commit.value().transactionId(), new TransactionScope(version));
- return version;
- }
-
- /**
- * Handles an prepare and commit commit.
- *
- * @param commit transaction prepare and commit commit
- * @return prepare result
- */
- protected PrepareResult prepareAndCommit(Commit<? extends TransactionPrepareAndCommit> commit) {
- TransactionId transactionId = commit.value().transactionLog().transactionId();
- PrepareResult prepareResult = prepare(commit);
- TransactionScope transactionScope = activeTransactions.remove(transactionId);
- if (prepareResult == PrepareResult.OK) {
- this.currentVersion = commit.index();
- transactionScope = transactionScope.prepared(commit);
- commitTransaction(transactionScope);
- }
- discardTombstones();
- return prepareResult;
- }
-
- /**
- * Handles an prepare commit.
- *
- * @param commit transaction prepare commit
- * @return prepare result
- */
- protected PrepareResult prepare(Commit<? extends TransactionPrepare> commit) {
- try {
- TransactionLog<MapUpdate<String, byte[]>> transactionLog = commit.value().transactionLog();
-
- // Iterate through records in the transaction log and perform isolation checks.
- for (MapUpdate<String, byte[]> record : transactionLog.records()) {
- String key = record.key();
-
- // If the record is a VERSION_MATCH then check that the record's version matches the current
- // version of the state machine.
- if (record.type() == MapUpdate.Type.VERSION_MATCH && key == null) {
- if (record.version() > currentVersion) {
- return PrepareResult.OPTIMISTIC_LOCK_FAILURE;
- } else {
- continue;
- }
- }
-
- // If the prepared keys already contains the key contained within the record, that indicates a
- // conflict with a concurrent transaction.
- if (preparedKeys.contains(key)) {
- return PrepareResult.CONCURRENT_TRANSACTION;
- }
-
- // Read the existing value from the map.
- MapEntryValue existingValue = entries().get(key);
-
- // Note: if the existing value is null, that means the key has not changed during the transaction,
- // otherwise a tombstone would have been retained.
- if (existingValue == null) {
- // If the value is null, ensure the version is equal to the transaction version.
- if (record.version() != transactionLog.version()) {
- return PrepareResult.OPTIMISTIC_LOCK_FAILURE;
- }
- } else {
- // If the value is non-null, compare the current version with the record version.
- if (existingValue.version() > record.version()) {
- return PrepareResult.OPTIMISTIC_LOCK_FAILURE;
- }
- }
- }
-
- // No violations detected. Mark modified keys locked for transactions.
- transactionLog.records().forEach(record -> {
- if (record.type() != MapUpdate.Type.VERSION_MATCH) {
- preparedKeys.add(record.key());
- }
- });
-
- // Update the transaction scope. If the transaction scope is not set on this node, that indicates the
- // coordinator is communicating with another node. Transactions assume that the client is communicating
- // with a single leader in order to limit the overhead of retaining tombstones.
- TransactionScope transactionScope = activeTransactions.get(transactionLog.transactionId());
- if (transactionScope == null) {
- activeTransactions.put(
- transactionLog.transactionId(),
- new TransactionScope(transactionLog.version(), commit.value().transactionLog()));
- return PrepareResult.PARTIAL_FAILURE;
- } else {
- activeTransactions.put(
- transactionLog.transactionId(),
- transactionScope.prepared(commit));
- return PrepareResult.OK;
- }
- } catch (Exception e) {
- logger().warn("Failure applying {}", commit, e);
- throw new IllegalStateException(e);
- }
- }
-
- /**
- * Handles an commit commit (ha!).
- *
- * @param commit transaction commit commit
- * @return commit result
- */
- protected CommitResult commit(Commit<? extends TransactionCommit> commit) {
- TransactionId transactionId = commit.value().transactionId();
- TransactionScope transactionScope = activeTransactions.remove(transactionId);
- if (transactionScope == null) {
- return CommitResult.UNKNOWN_TRANSACTION_ID;
- }
-
- try {
- this.currentVersion = commit.index();
- return commitTransaction(transactionScope);
- } catch (Exception e) {
- logger().warn("Failure applying {}", commit, e);
- throw new IllegalStateException(e);
- } finally {
- discardTombstones();
- }
- }
-
- /**
- * Applies committed operations to the state machine.
- */
- private CommitResult commitTransaction(TransactionScope transactionScope) {
- TransactionLog<MapUpdate<String, byte[]>> transactionLog = transactionScope.transactionLog();
- boolean retainTombstones = !activeTransactions.isEmpty();
-
- List<MapEvent<String, byte[]>> eventsToPublish = Lists.newArrayList();
- for (MapUpdate<String, byte[]> record : transactionLog.records()) {
- if (record.type() == MapUpdate.Type.VERSION_MATCH) {
- continue;
- }
-
- String key = record.key();
- checkState(preparedKeys.remove(key), "key is not prepared");
-
- if (record.type() == MapUpdate.Type.LOCK) {
- continue;
- }
-
- MapEntryValue previousValue = entries().remove(key);
- MapEntryValue newValue = null;
-
- // If the record is not a delete, create a transactional commit.
- if (record.type() != MapUpdate.Type.REMOVE_IF_VERSION_MATCH) {
- newValue = new MapEntryValue(MapEntryValue.Type.VALUE, currentVersion, record.value());
- } else if (retainTombstones) {
- // For deletes, if tombstones need to be retained then create and store a tombstone commit.
- newValue = new MapEntryValue(MapEntryValue.Type.TOMBSTONE, currentVersion, null);
- }
-
- MapEvent<String, byte[]> event;
- if (newValue != null) {
- entries().put(key, newValue);
- if (!valueIsNull(newValue)) {
- if (!valueIsNull(previousValue)) {
- event = new MapEvent<>(
- MapEvent.Type.UPDATE,
- "",
- key,
- toVersioned(newValue),
- toVersioned(previousValue));
- } else {
- event = new MapEvent<>(
- MapEvent.Type.INSERT,
- "",
- key,
- toVersioned(newValue),
- null);
- }
- } else {
- event = new MapEvent<>(
- MapEvent.Type.REMOVE,
- "",
- key,
- null,
- toVersioned(previousValue));
- }
- } else {
- event = new MapEvent<>(
- MapEvent.Type.REMOVE,
- "",
- key,
- null,
- toVersioned(previousValue));
- }
- eventsToPublish.add(event);
- }
- publish(eventsToPublish);
- return CommitResult.OK;
- }
-
- /**
- * Handles an rollback commit (ha!).
- *
- * @param commit transaction rollback commit
- * @return rollback result
- */
- protected RollbackResult rollback(Commit<? extends TransactionRollback> commit) {
- TransactionId transactionId = commit.value().transactionId();
- TransactionScope transactionScope = activeTransactions.remove(transactionId);
- if (transactionScope == null) {
- return RollbackResult.UNKNOWN_TRANSACTION_ID;
- } else if (!transactionScope.isPrepared()) {
- discardTombstones();
- return RollbackResult.OK;
- } else {
- try {
- transactionScope.transactionLog().records()
- .forEach(record -> {
- if (record.type() != MapUpdate.Type.VERSION_MATCH) {
- preparedKeys.remove(record.key());
- }
- });
- return RollbackResult.OK;
- } finally {
- discardTombstones();
- }
- }
-
- }
-
- /**
- * Discards tombstones no longer needed by active transactions.
- */
- private void discardTombstones() {
- if (activeTransactions.isEmpty()) {
- Iterator<Map.Entry<String, MapEntryValue>> iterator = entries().entrySet().iterator();
- while (iterator.hasNext()) {
- MapEntryValue value = iterator.next().getValue();
- if (value.type() == MapEntryValue.Type.TOMBSTONE) {
- iterator.remove();
- }
- }
- } else {
- long lowWaterMark = activeTransactions.values().stream()
- .mapToLong(TransactionScope::version)
- .min().getAsLong();
- Iterator<Map.Entry<String, MapEntryValue>> iterator = entries().entrySet().iterator();
- while (iterator.hasNext()) {
- MapEntryValue value = iterator.next().getValue();
- if (value.type() == MapEntryValue.Type.TOMBSTONE && value.version < lowWaterMark) {
- iterator.remove();
- }
- }
- }
- }
-
- /**
- * Utility for turning a {@code MapEntryValue} to {@code Versioned}.
- *
- * @param value map entry value
- * @return versioned instance
- */
- protected Versioned<byte[]> toVersioned(MapEntryValue value) {
- return value != null && value.type() != MapEntryValue.Type.TOMBSTONE
- ? new Versioned<>(value.value(), value.version()) : null;
- }
-
- /**
- * Publishes an event to listeners.
- *
- * @param event event to publish
- */
- private void publish(MapEvent<String, byte[]> event) {
- publish(Lists.newArrayList(event));
- }
-
- /**
- * Publishes events to listeners.
- *
- * @param events list of map event to publish
- */
- private void publish(List<MapEvent<String, byte[]>> events) {
- listeners.values().forEach(session -> {
- session.publish(CHANGE, serializer()::encode, events);
- });
- }
-
- @Override
- public void onExpire(RaftSession session) {
- closeListener(session.sessionId().id());
- }
-
- @Override
- public void onClose(RaftSession session) {
- closeListener(session.sessionId().id());
- }
-
- private void closeListener(Long sessionId) {
- listeners.remove(sessionId);
- }
-
- /**
- * Interface implemented by map values.
- */
- protected static class MapEntryValue {
- protected final Type type;
- protected final long version;
- protected final byte[] value;
-
- MapEntryValue(Type type, long version, byte[] value) {
- this.type = type;
- this.version = version;
- this.value = value;
- }
-
- /**
- * Returns the value type.
- *
- * @return the value type
- */
- Type type() {
- return type;
- }
-
- /**
- * Returns the version of the value.
- *
- * @return version
- */
- long version() {
- return version;
- }
-
- /**
- * Returns the raw {@code byte[]}.
- *
- * @return raw value
- */
- byte[] value() {
- return value;
- }
-
- /**
- * Value type.
- */
- enum Type {
- VALUE,
- TOMBSTONE,
- }
- }
-
- /**
- * Map transaction scope.
- */
- protected static final class TransactionScope {
- private final long version;
- private final TransactionLog<MapUpdate<String, byte[]>> transactionLog;
-
- private TransactionScope(long version) {
- this(version, null);
- }
-
- private TransactionScope(long version, TransactionLog<MapUpdate<String, byte[]>> transactionLog) {
- this.version = version;
- this.transactionLog = transactionLog;
- }
-
- /**
- * Returns the transaction version.
- *
- * @return the transaction version
- */
- long version() {
- return version;
- }
-
- /**
- * Returns whether this is a prepared transaction scope.
- *
- * @return whether this is a prepared transaction scope
- */
- boolean isPrepared() {
- return transactionLog != null;
- }
-
- /**
- * Returns the transaction commit log.
- *
- * @return the transaction commit log
- */
- TransactionLog<MapUpdate<String, byte[]>> transactionLog() {
- checkState(isPrepared());
- return transactionLog;
- }
-
- /**
- * Returns a new transaction scope with a prepare commit.
- *
- * @param commit the prepare commit
- * @return new transaction scope updated with the prepare commit
- */
- TransactionScope prepared(Commit<? extends TransactionPrepare> commit) {
- return new TransactionScope(version, commit.value().transactionLog());
- }
- }
-
- private static class IteratorContext {
- private final long sessionId;
- private final Iterator<Map.Entry<String, MapEntryValue>> iterator;
- private int position = 0;
-
- IteratorContext(long sessionId, Iterator<Map.Entry<String, MapEntryValue>> iterator) {
- this.sessionId = sessionId;
- this.iterator = iterator;
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentSetMultimap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentSetMultimap.java
deleted file mode 100644
index b04c9dd..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentSetMultimap.java
+++ /dev/null
@@ -1,354 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.ConcurrentModificationException;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.Executor;
-import java.util.function.Function;
-
-import com.google.common.collect.Lists;
-import com.google.common.collect.Multiset;
-import io.atomix.protocols.raft.proxy.RaftProxy;
-import org.onlab.util.KryoNamespace;
-import org.onlab.util.Tools;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncConsistentMultimap;
-import org.onosproject.store.service.AsyncIterator;
-import org.onosproject.store.service.MultimapEvent;
-import org.onosproject.store.service.MultimapEventListener;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.Versioned;
-
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapEvents.CHANGE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.ADD_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.CLEAR;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.CLOSE_ITERATOR;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.CONTAINS_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.CONTAINS_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.CONTAINS_VALUE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.ContainsEntry;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.ContainsKey;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.ContainsValue;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.ENTRIES;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.Get;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.IS_EMPTY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.IteratorBatch;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.IteratorPosition;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.KEYS;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.KEY_SET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.MultiRemove;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.NEXT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.OPEN_ITERATOR;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.PUT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.PUT_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.Put;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.REMOVE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.REMOVE_ALL;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.REMOVE_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.REMOVE_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.REPLACE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.RemoveAll;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.Replace;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.SIZE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.VALUES;
-
-
-/**
- * Set based implementation of the {@link AsyncConsistentMultimap}.
- * <p>
- * Note: this implementation does not allow null entries or duplicate entries.
- */
-public class AtomixConsistentSetMultimap
- extends AbstractRaftPrimitive
- implements AsyncConsistentMultimap<String, byte[]> {
-
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixConsistentSetMultimapOperations.NAMESPACE)
- .register(AtomixConsistentSetMultimapEvents.NAMESPACE)
- .build());
-
- private final Map<MultimapEventListener<String, byte[]>, Executor> mapEventListeners = new ConcurrentHashMap<>();
-
- public AtomixConsistentSetMultimap(RaftProxy proxy) {
- super(proxy);
- proxy.addEventListener(CHANGE, SERIALIZER::decode, this::handleChange);
- proxy.addStateChangeListener(state -> {
- if (state == RaftProxy.State.CONNECTED && isListening()) {
- proxy.invoke(ADD_LISTENER);
- }
- });
- }
-
- private void handleChange(List<MultimapEvent<String, byte[]>> events) {
- events.forEach(event ->
- mapEventListeners.forEach((listener, executor) -> executor.execute(() -> listener.event(event))));
- }
-
- @Override
- public CompletableFuture<Integer> size() {
- return proxy.invoke(SIZE, SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> isEmpty() {
- return proxy.invoke(IS_EMPTY, SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> containsKey(String key) {
- return proxy.invoke(CONTAINS_KEY, SERIALIZER::encode, new ContainsKey(key), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> containsValue(byte[] value) {
- return proxy.invoke(CONTAINS_VALUE, SERIALIZER::encode, new ContainsValue(value), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> containsEntry(String key, byte[] value) {
- return proxy.invoke(CONTAINS_ENTRY, SERIALIZER::encode, new ContainsEntry(key, value), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> put(String key, byte[] value) {
- return proxy.invoke(
- PUT,
- SERIALIZER::encode,
- new Put(key, Lists.newArrayList(value), null),
- SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends byte[]>>> putAndGet(String key, byte[] value) {
- return proxy.invoke(
- PUT_AND_GET,
- SERIALIZER::encode,
- new Put(key, Lists.newArrayList(value), null),
- SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> remove(String key, byte[] value) {
- return proxy.invoke(REMOVE, SERIALIZER::encode, new MultiRemove(key,
- Lists.newArrayList(value),
- null), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends byte[]>>> removeAndGet(String key, byte[] value) {
- return proxy.invoke(REMOVE_AND_GET, SERIALIZER::encode, new MultiRemove(key,
- Lists.newArrayList(value),
- null), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> removeAll(String key, Collection<? extends byte[]> values) {
- return proxy.invoke(
- REMOVE,
- SERIALIZER::encode,
- new MultiRemove(key, (Collection<byte[]>) values, null),
- SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends byte[]>>> removeAll(String key) {
- return proxy.invoke(REMOVE_ALL, SERIALIZER::encode, new RemoveAll(key, null), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> putAll(
- String key, Collection<? extends byte[]> values) {
- return proxy.invoke(PUT, SERIALIZER::encode, new Put(key, values, null), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends byte[]>>> replaceValues(
- String key, Collection<byte[]> values) {
- return proxy.invoke(
- REPLACE,
- SERIALIZER::encode,
- new Replace(key, values, null),
- SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Void> clear() {
- return proxy.invoke(CLEAR);
- }
-
- @Override
- public CompletableFuture<Versioned<Collection<? extends byte[]>>> get(String key) {
- return proxy.invoke(GET, SERIALIZER::encode, new Get(key), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Set<String>> keySet() {
- return proxy.invoke(KEY_SET, SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Multiset<String>> keys() {
- return proxy.invoke(KEYS, SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Multiset<byte[]>> values() {
- return proxy.invoke(VALUES, SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Collection<Map.Entry<String, byte[]>>> entries() {
- return proxy.invoke(ENTRIES, SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<AsyncIterator<Map.Entry<String, byte[]>>> iterator() {
- return proxy.<Long>invoke(OPEN_ITERATOR, SERIALIZER::decode).thenApply(ConsistentMultimapIterator::new);
- }
-
- /**
- * Consistent multimap iterator.
- */
- private class ConsistentMultimapIterator implements AsyncIterator<Map.Entry<String, byte[]>> {
- private final long id;
- private volatile CompletableFuture<IteratorBatch> batch;
- private volatile CompletableFuture<Void> closeFuture;
-
- ConsistentMultimapIterator(long id) {
- this.id = id;
- this.batch = CompletableFuture.completedFuture(
- new IteratorBatch(0, Collections.emptyList()));
- }
-
- /**
- * Returns the current batch iterator or lazily fetches the next batch from the cluster.
- *
- * @return the next batch iterator
- */
- private CompletableFuture<Iterator<Map.Entry<String, byte[]>>> batch() {
- return batch.thenCompose(iterator -> {
- if (iterator != null && !iterator.hasNext()) {
- batch = fetch(iterator.position());
- return batch.thenApply(Function.identity());
- }
- return CompletableFuture.completedFuture(iterator);
- });
- }
-
- /**
- * Fetches the next batch of entries from the cluster.
- *
- * @param position the position from which to fetch the next batch
- * @return the next batch of entries from the cluster
- */
- private CompletableFuture<IteratorBatch> fetch(int position) {
- return proxy.<IteratorPosition, IteratorBatch>invoke(
- NEXT,
- SERIALIZER::encode,
- new IteratorPosition(id, position),
- SERIALIZER::decode)
- .thenCompose(batch -> {
- if (batch == null) {
- return close().thenApply(v -> null);
- }
- return CompletableFuture.completedFuture(batch);
- });
- }
-
- /**
- * Closes the iterator.
- *
- * @return future to be completed once the iterator has been closed
- */
- private CompletableFuture<Void> close() {
- if (closeFuture == null) {
- synchronized (this) {
- if (closeFuture == null) {
- closeFuture = proxy.invoke(CLOSE_ITERATOR, SERIALIZER::encode, id);
- }
- }
- }
- return closeFuture;
- }
-
- @Override
- public CompletableFuture<Boolean> hasNext() {
- return batch().thenApply(iterator -> iterator != null && iterator.hasNext());
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, byte[]>> next() {
- return batch().thenCompose(iterator -> {
- if (iterator == null) {
- return Tools.exceptionalFuture(new NoSuchElementException());
- }
- return CompletableFuture.completedFuture(iterator.next());
- });
- }
- }
-
- @Override
- public CompletableFuture<Void> addListener(MultimapEventListener<String, byte[]> listener, Executor executor) {
- if (mapEventListeners.isEmpty()) {
- return proxy.invoke(ADD_LISTENER).thenRun(() -> mapEventListeners.put(listener, executor));
- } else {
- mapEventListeners.put(listener, executor);
- return CompletableFuture.completedFuture(null);
- }
- }
-
- @Override
- public CompletableFuture<Void> removeListener(MultimapEventListener<String, byte[]> listener) {
- if (mapEventListeners.remove(listener) != null && mapEventListeners.isEmpty()) {
- return proxy.invoke(REMOVE_LISTENER).thenApply(v -> null);
- }
- return CompletableFuture.completedFuture(null);
- }
-
- @Override
- public CompletableFuture<Map<String, Collection<byte[]>>> asMap() {
- throw new UnsupportedOperationException("Expensive operation.");
- }
-
- /**
- * Helper to check if there was a lock based issue.
- *
- * @param status the status of an update result
- */
- private void throwIfLocked(MapEntryUpdateResult.Status status) {
- if (status == MapEntryUpdateResult.Status.WRITE_LOCK) {
- throw new ConcurrentModificationException("Cannot update map: " +
- "Another transaction " +
- "in progress");
- }
- }
-
- private boolean isListening() {
- return !mapEventListeners.isEmpty();
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentSetMultimapEvents.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentSetMultimapEvents.java
deleted file mode 100644
index 83908ae..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentSetMultimapEvents.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import io.atomix.protocols.raft.event.EventType;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.MultimapEvent;
-
-/**
- * Atomix consistent set multimap events.
- */
-public enum AtomixConsistentSetMultimapEvents implements EventType {
- CHANGE,
- ENTRY;
-
- @Override
- public String id() {
- return name();
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 50)
- .register(MultimapEvent.class)
- .register(MultimapEvent.Type.class)
- .register(byte[].class)
- .build("AtomixConsistentSetMultimapEvents");
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentSetMultimapOperations.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentSetMultimapOperations.java
deleted file mode 100644
index 4d38d71..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentSetMultimapOperations.java
+++ /dev/null
@@ -1,464 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Map;
-
-import com.google.common.base.MoreObjects;
-import com.google.common.collect.Maps;
-import io.atomix.protocols.raft.operation.OperationId;
-import io.atomix.protocols.raft.operation.OperationType;
-import org.onlab.util.KryoNamespace;
-import org.onlab.util.Match;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.Versioned;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * AsyncConsistentMultimap state machine commands.
- */
-public enum AtomixConsistentSetMultimapOperations implements OperationId {
- GET(OperationType.QUERY),
- SIZE(OperationType.QUERY),
- IS_EMPTY(OperationType.QUERY),
- CONTAINS_KEY(OperationType.QUERY),
- CONTAINS_VALUE(OperationType.QUERY),
- CONTAINS_ENTRY(OperationType.QUERY),
- KEY_SET(OperationType.QUERY),
- KEYS(OperationType.QUERY),
- VALUES(OperationType.QUERY),
- ENTRIES(OperationType.QUERY),
- PUT(OperationType.COMMAND),
- PUT_AND_GET(OperationType.COMMAND),
- REMOVE(OperationType.COMMAND),
- REMOVE_AND_GET(OperationType.COMMAND),
- REMOVE_ALL(OperationType.COMMAND),
- REPLACE(OperationType.COMMAND),
- CLEAR(OperationType.COMMAND),
- ADD_LISTENER(OperationType.COMMAND),
- REMOVE_LISTENER(OperationType.COMMAND),
- OPEN_ITERATOR(OperationType.COMMAND),
- NEXT(OperationType.QUERY),
- CLOSE_ITERATOR(OperationType.COMMAND);
-
- private final OperationType type;
-
- AtomixConsistentSetMultimapOperations(OperationType type) {
- this.type = type;
- }
-
- @Override
- public String id() {
- return name();
- }
-
- @Override
- public OperationType type() {
- return type;
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID)
- .register(ContainsEntry.class)
- .register(ContainsKey.class)
- .register(ContainsValue.class)
- .register(Get.class)
- .register(MultiRemove.class)
- .register(Put.class)
- .register(RemoveAll.class)
- .register(Replace.class)
- .register(Match.class)
- .register(Versioned.class)
- .register(ArrayList.class)
- .register(Maps.immutableEntry("", "").getClass())
- .register(IteratorBatch.class)
- .register(IteratorPosition.class)
- .build("AtomixConsistentSetMultimapOperations");
-
- /**
- * Abstract multimap command.
- */
- @SuppressWarnings("serial")
- public abstract static class MultimapOperation {
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .toString();
- }
- }
-
- /**
- * Abstract key-based multimap query.
- */
- @SuppressWarnings("serial")
- public abstract static class KeyOperation extends MultimapOperation {
- protected String key;
-
- public KeyOperation() {
- }
-
- public KeyOperation(String key) {
- this.key = checkNotNull(key);
- }
-
- public String key() {
- return key;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("key", key)
- .toString();
- }
- }
-
- /**
- * Abstract value-based query.
- */
- @SuppressWarnings("serial")
- public abstract static class ValueOperation extends MultimapOperation {
- protected byte[] value;
-
- public ValueOperation() {
- }
-
- public ValueOperation(byte[] value) {
- this.value = checkNotNull(value);
- }
-
- /**
- * Returns the value.
- *
- * @return value.
- */
- public byte[] value() {
- return value;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("value", value)
- .toString();
- }
- }
-
- /**
- * Contains key query.
- */
- @SuppressWarnings("serial")
- public static class ContainsKey extends KeyOperation {
- public ContainsKey() {
- }
-
- public ContainsKey(String key) {
- super(key);
- }
- }
-
- /**
- * Contains value query.
- */
- @SuppressWarnings("serial")
- public static class ContainsValue extends ValueOperation {
- public ContainsValue() {
- }
-
- public ContainsValue(byte[] value) {
- super(value);
- }
- }
-
- /**
- * Contains entry query.
- */
- @SuppressWarnings("serial")
- public static class ContainsEntry extends MultimapOperation {
- protected String key;
- protected byte[] value;
-
- public ContainsEntry() {
- }
-
- public ContainsEntry(String key, byte[] value) {
- this.key = checkNotNull(key);
- this.value = checkNotNull(value);
- }
-
- public String key() {
- return key;
- }
-
- public byte[] value() {
- return value;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("key", key)
- .add("value", value)
- .toString();
- }
- }
-
- /**
- * Remove command, backs remove and removeAll's that return booleans.
- */
- @SuppressWarnings("serial")
- public static class RemoveAll extends MultimapOperation {
- private String key;
- private Match<Long> versionMatch;
-
- public RemoveAll() {
- }
-
- public RemoveAll(String key, Match<Long> versionMatch) {
- this.key = checkNotNull(key);
- this.versionMatch = versionMatch;
- }
-
- public String key() {
- return this.key;
- }
-
- public Match<Long> versionMatch() {
- return versionMatch;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("key", key)
- .add("versionMatch", versionMatch)
- .toString();
- }
- }
-
- /**
- * Remove command, backs remove and removeAll's that return booleans.
- */
- @SuppressWarnings("serial")
- public static class MultiRemove extends MultimapOperation {
- private String key;
- private Collection<byte[]> values;
- private Match<Long> versionMatch;
-
- public MultiRemove() {
- }
-
- public MultiRemove(String key, Collection<byte[]> valueMatches,
- Match<Long> versionMatch) {
- this.key = checkNotNull(key);
- this.values = valueMatches;
- this.versionMatch = versionMatch;
- }
-
- public String key() {
- return this.key;
- }
-
- public Collection<byte[]> values() {
- return values;
- }
-
- public Match<Long> versionMatch() {
- return versionMatch;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("key", key)
- .add("values", values)
- .add("versionMatch", versionMatch)
- .toString();
- }
- }
-
- /**
- * Command to back the put and putAll methods.
- */
- @SuppressWarnings("serial")
- public static class Put extends MultimapOperation {
- private String key;
- private Collection<? extends byte[]> values;
- private Match<Long> versionMatch;
-
- public Put() {
- }
-
- public Put(String key, Collection<? extends byte[]> values, Match<Long> versionMatch) {
- this.key = checkNotNull(key);
- this.values = values;
- this.versionMatch = versionMatch;
- }
-
- public String key() {
- return key;
- }
-
- public Collection<? extends byte[]> values() {
- return values;
- }
-
- public Match<Long> versionMatch() {
- return versionMatch;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("key", key)
- .add("values", values)
- .add("versionMatch", versionMatch)
- .toString();
- }
- }
-
- /**
- * Replace command, returns the collection that was replaced.
- */
- @SuppressWarnings("serial")
- public static class Replace extends MultimapOperation {
- private String key;
- private Collection<byte[]> values;
- private Match<Long> versionMatch;
-
- public Replace() {
- }
-
- public Replace(String key, Collection<byte[]> values,
- Match<Long> versionMatch) {
- this.key = checkNotNull(key);
- this.values = values;
- this.versionMatch = versionMatch;
- }
-
- public String key() {
- return this.key;
- }
-
- public Match<Long> versionMatch() {
- return versionMatch;
- }
-
- public Collection<byte[]> values() {
- return values;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("key", key)
- .add("values", values)
- .add("versionMatch", versionMatch)
- .toString();
- }
- }
-
- /**
- * Get value query.
- */
- public static class Get extends KeyOperation {
- public Get() {
- }
-
- public Get(String key) {
- super(key);
- }
- }
-
- /**
- * Iterator position.
- */
- public static class IteratorPosition {
- private long iteratorId;
- private int position;
-
- private IteratorPosition() {
- }
-
- public IteratorPosition(long iteratorId, int position) {
- this.iteratorId = iteratorId;
- this.position = position;
- }
-
- public long iteratorId() {
- return iteratorId;
- }
-
- public int position() {
- return position;
- }
- }
-
- /**
- * Iterator batch.
- */
- public static class IteratorBatch implements Iterator<Map.Entry<String, byte[]>> {
- private int position;
- private Collection<Map.Entry<String, byte[]>> entries;
- private transient volatile Iterator<Map.Entry<String, byte[]>> iterator;
-
- private IteratorBatch() {
- }
-
- public IteratorBatch(int position, Collection<Map.Entry<String, byte[]>> entries) {
- this.position = position;
- this.entries = entries;
- }
-
- public int position() {
- return position;
- }
-
- public Collection<Map.Entry<String, byte[]>> entries() {
- return entries;
- }
-
- private Iterator<Map.Entry<String, byte[]>> iterator() {
- Iterator<Map.Entry<String, byte[]>> iterator = this.iterator;
- if (iterator == null) {
- synchronized (entries) {
- iterator = this.iterator;
- if (iterator == null) {
- iterator = entries.iterator();
- this.iterator = iterator;
- }
- }
- }
- return iterator;
- }
-
- @Override
- public boolean hasNext() {
- return iterator().hasNext();
- }
-
- @Override
- public Map.Entry<String, byte[]> next() {
- return iterator().next();
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentSetMultimapService.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentSetMultimapService.java
deleted file mode 100644
index fd2e676..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentSetMultimapService.java
+++ /dev/null
@@ -1,884 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Comparator;
-import java.util.EnumSet;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.function.BiConsumer;
-import java.util.function.BinaryOperator;
-import java.util.function.Function;
-import java.util.function.Supplier;
-import java.util.stream.Collector;
-import java.util.stream.Collectors;
-
-import com.esotericsoftware.kryo.Kryo;
-import com.esotericsoftware.kryo.io.Input;
-import com.esotericsoftware.kryo.io.Output;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.HashMultiset;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Multiset;
-import com.google.common.collect.Sets;
-import io.atomix.protocols.raft.service.AbstractRaftService;
-import io.atomix.protocols.raft.service.Commit;
-import io.atomix.protocols.raft.service.RaftServiceExecutor;
-import io.atomix.protocols.raft.session.RaftSession;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotReader;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotWriter;
-import org.onlab.util.KryoNamespace;
-import org.onlab.util.Match;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.MultimapEvent;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.Versioned;
-
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapEvents.CHANGE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.ADD_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.CLEAR;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.CLOSE_ITERATOR;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.CONTAINS_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.CONTAINS_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.CONTAINS_VALUE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.ContainsEntry;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.ContainsKey;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.ContainsValue;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.ENTRIES;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.Get;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.IS_EMPTY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.IteratorBatch;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.IteratorPosition;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.KEYS;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.KEY_SET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.MultiRemove;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.MultimapOperation;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.NEXT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.OPEN_ITERATOR;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.PUT;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.PUT_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.Put;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.REMOVE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.REMOVE_ALL;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.REMOVE_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.REMOVE_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.REPLACE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.RemoveAll;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.Replace;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.SIZE;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentSetMultimapOperations.VALUES;
-
-/**
- * State Machine for {@link AtomixConsistentSetMultimap} resource.
- */
-public class AtomixConsistentSetMultimapService extends AbstractRaftService {
- private static final int MAX_ITERATOR_BATCH_SIZE = 1024 * 32;
-
- private final Serializer serializer = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixConsistentSetMultimapOperations.NAMESPACE)
- .register(AtomixConsistentSetMultimapEvents.NAMESPACE)
- .register(ByteArrayComparator.class)
- .register(new HashMap().keySet().getClass())
- .register(TreeSet.class)
- .register(new com.esotericsoftware.kryo.Serializer<NonTransactionalCommit>() {
- @Override
- public void write(Kryo kryo, Output output, NonTransactionalCommit object) {
- kryo.writeClassAndObject(output, object.valueSet);
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public NonTransactionalCommit read(Kryo kryo, Input input, Class<NonTransactionalCommit> type) {
- NonTransactionalCommit commit = new NonTransactionalCommit();
- commit.valueSet.addAll((Collection<byte[]>) kryo.readClassAndObject(input));
- return commit;
- }
- }, NonTransactionalCommit.class)
- .build());
-
- private AtomicLong globalVersion = new AtomicLong(1);
- private Map<Long, RaftSession> listeners = new LinkedHashMap<>();
- private Map<String, MapEntryValue> backingMap = Maps.newConcurrentMap();
- private Map<Long, IteratorContext> iterators = Maps.newHashMap();
-
- @Override
- public void snapshot(SnapshotWriter writer) {
- writer.writeLong(globalVersion.get());
- writer.writeObject(Sets.newHashSet(listeners.keySet()), serializer::encode);
- writer.writeObject(backingMap, serializer::encode);
-
- Map<Long, Long> iterators = Maps.newHashMap();
- this.iterators.forEach((id, context) -> iterators.put(id, context.sessionId));
- writer.writeObject(iterators, serializer::encode);
- }
-
- @Override
- public void install(SnapshotReader reader) {
- globalVersion = new AtomicLong(reader.readLong());
-
- listeners = new LinkedHashMap<>();
- for (Long sessionId : reader.<Set<Long>>readObject(serializer::decode)) {
- listeners.put(sessionId, sessions().getSession(sessionId));
- }
-
- backingMap = reader.readObject(serializer::decode);
-
- Map<Long, Long> iterators = reader.readObject(serializer::decode);
- this.iterators = Maps.newHashMap();
- iterators.forEach((id, session) ->
- this.iterators.put(id, new IteratorContext(session, backingMap.entrySet().iterator())));
- }
-
- @Override
- protected void configure(RaftServiceExecutor executor) {
- executor.register(SIZE, this::size, serializer::encode);
- executor.register(IS_EMPTY, this::isEmpty, serializer::encode);
- executor.register(CONTAINS_KEY, serializer::decode, this::containsKey, serializer::encode);
- executor.register(CONTAINS_VALUE, serializer::decode, this::containsValue, serializer::encode);
- executor.register(CONTAINS_ENTRY, serializer::decode, this::containsEntry, serializer::encode);
- executor.register(CLEAR, this::clear);
- executor.register(KEY_SET, this::keySet, serializer::encode);
- executor.register(KEYS, this::keys, serializer::encode);
- executor.register(VALUES, this::values, serializer::encode);
- executor.register(ENTRIES, this::entries, serializer::encode);
- executor.register(GET, serializer::decode, this::get, serializer::encode);
- executor.register(REMOVE_ALL, serializer::decode, this::removeAll, serializer::encode);
- executor.register(REMOVE, serializer::decode, this::multiRemove, serializer::encode);
- executor.register(REMOVE_AND_GET, serializer::decode, this::removeAndGet, serializer::encode);
- executor.register(PUT, serializer::decode, this::put, serializer::encode);
- executor.register(PUT_AND_GET, serializer::decode, this::putAndGet, serializer::encode);
- executor.register(REPLACE, serializer::decode, this::replace, serializer::encode);
- executor.register(ADD_LISTENER, this::listen);
- executor.register(REMOVE_LISTENER, this::unlisten);
- executor.register(OPEN_ITERATOR, this::openIterator, serializer::encode);
- executor.register(NEXT, serializer::decode, this::next, serializer::encode);
- executor.register(CLOSE_ITERATOR, serializer::decode, this::closeIterator);
- }
-
- @Override
- public void onExpire(RaftSession session) {
- listeners.remove(session.sessionId().id());
- iterators.entrySet().removeIf(entry -> entry.getValue().sessionId == session.sessionId().id());
- }
-
- @Override
- public void onClose(RaftSession session) {
- listeners.remove(session.sessionId().id());
- iterators.entrySet().removeIf(entry -> entry.getValue().sessionId == session.sessionId().id());
- }
-
- /**
- * Handles a Size commit.
- *
- * @param commit Size commit
- * @return number of unique key value pairs in the multimap
- */
- protected int size(Commit<Void> commit) {
- return backingMap.values()
- .stream()
- .map(valueCollection -> valueCollection.values().size())
- .collect(Collectors.summingInt(size -> size));
- }
-
- /**
- * Handles an IsEmpty commit.
- *
- * @param commit IsEmpty commit
- * @return true if the multimap contains no key-value pairs, else false
- */
- protected boolean isEmpty(Commit<Void> commit) {
- return backingMap.isEmpty();
- }
-
- /**
- * Handles a contains key commit.
- *
- * @param commit ContainsKey commit
- * @return returns true if the key is in the multimap, else false
- */
- protected boolean containsKey(Commit<? extends ContainsKey> commit) {
- return backingMap.containsKey(commit.value().key());
- }
-
- /**
- * Handles a ContainsValue commit.
- *
- * @param commit ContainsValue commit
- * @return true if the value is in the multimap, else false
- */
- protected boolean containsValue(Commit<? extends ContainsValue> commit) {
- if (backingMap.values().isEmpty()) {
- return false;
- }
- Match<byte[]> match = Match.ifValue(commit.value().value());
- return backingMap
- .values()
- .stream()
- .anyMatch(valueList ->
- valueList
- .values()
- .stream()
- .anyMatch(byteValue ->
- match.matches(byteValue)));
- }
-
- /**
- * Handles a ContainsEntry commit.
- *
- * @param commit ContainsEntry commit
- * @return true if the key-value pair exists, else false
- */
- protected boolean containsEntry(Commit<? extends ContainsEntry> commit) {
- MapEntryValue entryValue =
- backingMap.get(commit.value().key());
- if (entryValue == null) {
- return false;
- } else {
- Match valueMatch = Match.ifValue(commit.value().value());
- return entryValue
- .values()
- .stream()
- .anyMatch(byteValue -> valueMatch.matches(byteValue));
- }
- }
-
- /**
- * Handles a Clear commit.
- *
- * @param commit Clear commit
- */
- protected void clear(Commit<Void> commit) {
- backingMap.clear();
- }
-
- /**
- * Handles a KeySet commit.
- *
- * @param commit KeySet commit
- * @return a set of all keys in the multimap
- */
- protected Set<String> keySet(Commit<Void> commit) {
- return ImmutableSet.copyOf(backingMap.keySet());
- }
-
- /**
- * Handles a Keys commit.
- *
- * @param commit Keys commit
- * @return a multiset of keys with each key included an equal number of
- * times to the total key-value pairs in which that key participates
- */
- protected Multiset<String> keys(Commit<Void> commit) {
- Multiset keys = HashMultiset.create();
- backingMap.forEach((key, mapEntryValue) -> {
- keys.add(key, mapEntryValue.values().size());
- });
- return keys;
- }
-
- /**
- * Handles a Values commit.
- *
- * @param commit Values commit
- * @return the set of values in the multimap with duplicates included
- */
- protected Multiset<byte[]> values(Commit<Void> commit) {
- return backingMap
- .values()
- .stream()
- .collect(new HashMultisetValueCollector());
- }
-
- /**
- * Handles an Entries commit.
- *
- * @param commit Entries commit
- * @return a set of all key-value pairs in the multimap
- */
- protected Collection<Map.Entry<String, byte[]>> entries(Commit<Void> commit) {
- return backingMap
- .entrySet()
- .stream()
- .collect(new EntrySetCollector());
- }
-
- /**
- * Handles a Get commit.
- *
- * @param commit Get commit
- * @return the collection of values associated with the key or an empty
- * list if none exist
- */
- protected Versioned<Collection<? extends byte[]>> get(Commit<? extends Get> commit) {
- return toVersioned(backingMap.get(commit.value().key()));
- }
-
- /**
- * Handles a removeAll commit, and returns the previous mapping.
- *
- * @param commit removeAll commit
- * @return collection of removed values
- */
- protected Versioned<Collection<? extends byte[]>> removeAll(Commit<? extends RemoveAll> commit) {
- String key = commit.value().key();
-
- if (!backingMap.containsKey(key)) {
- return new Versioned<>(Sets.newHashSet(), -1);
- }
-
- Versioned<Collection<? extends byte[]>> removedValues =
- backingMap.get(key).addCommit(commit);
- publish(removedValues.value().stream()
- .map(value -> new MultimapEvent<String, byte[]>(
- "", key, null, value))
- .collect(Collectors.toList()));
- return removedValues;
- }
-
- /**
- * Handles a multiRemove commit, returns true if the remove results in any
- * change.
- * @param commit multiRemove commit
- * @return true if any change results, else false
- */
- protected boolean multiRemove(Commit<? extends MultiRemove> commit) {
- String key = commit.value().key();
-
- if (!backingMap.containsKey(key)) {
- return false;
- }
-
- Versioned<Collection<? extends byte[]>> removedValues = backingMap
- .get(key)
- .addCommit(commit);
-
- if (removedValues != null) {
- if (removedValues.value().isEmpty()) {
- backingMap.remove(key);
- }
-
- publish(removedValues.value().stream()
- .map(value -> new MultimapEvent<String, byte[]>(
- "", key, null, value))
- .collect(Collectors.toList()));
- return true;
- }
-
- return false;
- }
-
- /**
- * Handles a removeAndGet commit.
- *
- * @param commit multiRemove commit
- * @return the updated values or null if the values are empty
- */
- protected Versioned<Collection<? extends byte[]>> removeAndGet(Commit<? extends MultiRemove> commit) {
- String key = commit.value().key();
-
- if (!backingMap.containsKey(key)) {
- return null;
- }
-
- Versioned<Collection<? extends byte[]>> removedValues = backingMap
- .get(key)
- .addCommit(commit);
-
- if (removedValues != null) {
- if (removedValues.value().isEmpty()) {
- backingMap.remove(key);
- }
-
- publish(removedValues.value().stream()
- .map(value -> new MultimapEvent<String, byte[]>(
- "", key, null, value))
- .collect(Collectors.toList()));
- }
-
- return toVersioned(backingMap.get(key));
- }
-
- /**
- * Handles a put commit, returns true if any change results from this
- * commit.
- * @param commit a put commit
- * @return true if this commit results in a change, else false
- */
- protected boolean put(Commit<? extends Put> commit) {
- String key = commit.value().key();
- if (commit.value().values().isEmpty()) {
- return false;
- }
- if (!backingMap.containsKey(key)) {
- backingMap.put(key, new NonTransactionalCommit());
- }
-
- Versioned<Collection<? extends byte[]>> addedValues = backingMap
- .get(key)
- .addCommit(commit);
-
- if (addedValues != null) {
- publish(addedValues.value().stream()
- .map(value -> new MultimapEvent<String, byte[]>(
- "", key, value, null))
- .collect(Collectors.toList()));
- return true;
- }
-
- return false;
- }
-
- /**
- * Handles a putAndGet commit.
- *
- * @param commit a put commit
- * @return the updated values
- */
- protected Versioned<Collection<? extends byte[]>> putAndGet(Commit<? extends Put> commit) {
- String key = commit.value().key();
- if (commit.value().values().isEmpty()) {
- return null;
- }
- if (!backingMap.containsKey(key)) {
- backingMap.put(key, new NonTransactionalCommit());
- }
-
- Versioned<Collection<? extends byte[]>> addedValues = backingMap
- .get(key)
- .addCommit(commit);
-
- if (addedValues != null) {
- publish(addedValues.value().stream()
- .map(value -> new MultimapEvent<String, byte[]>(
- "", key, value, null))
- .collect(Collectors.toList()));
- }
-
- return toVersioned(backingMap.get(key));
- }
-
- protected Versioned<Collection<? extends byte[]>> replace(
- Commit<? extends Replace> commit) {
- String key = commit.value().key();
- if (!backingMap.containsKey(key)) {
- backingMap.put(key, new NonTransactionalCommit());
- }
-
- Versioned<Collection<? extends byte[]>> values = backingMap.get(commit.value().key()).addCommit(commit);
- if (values != null) {
- Set<byte[]> addedValues = Sets.newTreeSet(new ByteArrayComparator());
- addedValues.addAll(commit.value().values());
-
- Set<byte[]> removedValues = Sets.newTreeSet(new ByteArrayComparator());
- removedValues.addAll(values.value());
-
- List<MultimapEvent<String, byte[]>> events = Lists.newArrayList();
- Sets.difference(removedValues, addedValues)
- .forEach(value -> events.add(new MultimapEvent<>("", key, null, value)));
- Sets.difference(addedValues, removedValues)
- .forEach(value -> events.add(new MultimapEvent<>("", key, value, null)));
-
- publish(events);
- }
- return values;
- }
-
- /**
- * Handles a listen commit.
- *
- * @param commit listen commit
- */
- protected void listen(Commit<Void> commit) {
- listeners.put(commit.session().sessionId().id(), commit.session());
- }
-
- /**
- * Handles an unlisten commit.
- *
- * @param commit unlisten commit
- */
- protected void unlisten(Commit<Void> commit) {
- listeners.remove(commit.session().sessionId().id());
- }
-
- /**
- * Handles an open iterator commit.
- *
- * @param commit the open iterator commit
- * @return iterator identifier
- */
- protected long openIterator(Commit<Void> commit) {
- iterators.put(commit.index(), new IteratorContext(
- commit.session().sessionId().id(),
- backingMap.entrySet().iterator()));
- return commit.index();
- }
-
- /**
- * Handles an iterator next commit.
- *
- * @param commit the next commit
- * @return a list of entries to iterate
- */
- protected IteratorBatch next(Commit<IteratorPosition> commit) {
- final long iteratorId = commit.value().iteratorId();
- final int position = commit.value().position();
-
- IteratorContext context = iterators.get(iteratorId);
- if (context == null) {
- return null;
- }
-
- List<Map.Entry<String, byte[]>> entries = new ArrayList<>();
- int size = 0;
- while (context.iterator.hasNext()) {
- context.position++;
- if (context.position > position) {
- Map.Entry<String, MapEntryValue> entry = context.iterator.next();
- String key = entry.getKey();
- int keySize = key.length();
- for (byte[] value : entry.getValue().values()) {
- entries.add(Maps.immutableEntry(key, value));
- size += keySize;
- size += value.length;
- }
-
- if (size >= MAX_ITERATOR_BATCH_SIZE) {
- break;
- }
- }
- }
-
- if (entries.isEmpty()) {
- return null;
- }
- return new IteratorBatch(context.position, entries);
- }
-
- /**
- * Handles a close iterator commit.
- *
- * @param commit the close iterator commit
- */
- protected void closeIterator(Commit<Long> commit) {
- iterators.remove(commit.value());
- }
-
- /**
- * Publishes events to listeners.
- *
- * @param events list of map event to publish
- */
- private void publish(List<MultimapEvent<String, byte[]>> events) {
- listeners.values().forEach(session -> session.publish(CHANGE, serializer::encode, events));
- }
-
- private interface MapEntryValue {
-
- /**
- * Returns the list of raw {@code byte[]'s}.
- *
- * @return list of raw values
- */
- Collection<? extends byte[]> values();
-
- /**
- * Returns the version of the value.
- *
- * @return version
- */
- long version();
-
- /**
- * Add a new commit and modifies the set of values accordingly.
- * In the case of a replace or removeAll it returns the set of removed
- * values. In the case of put or multiRemove it returns null for no
- * change and a set of the added or removed values respectively if a
- * change resulted.
- *
- * @param commit the commit to be added
- */
- Versioned<Collection<? extends byte[]>> addCommit(
- Commit<? extends MultimapOperation> commit);
- }
-
- private class NonTransactionalCommit implements MapEntryValue {
- private long version;
- private final TreeSet<byte[]> valueSet = Sets.newTreeSet(new ByteArrayComparator());
-
- public NonTransactionalCommit() {
- //Set the version to current it will only be updated once this is
- // populated
- this.version = globalVersion.get();
- }
-
- @Override
- public Collection<? extends byte[]> values() {
- return ImmutableSet.copyOf(valueSet);
- }
-
- @Override
- public long version() {
- return version;
- }
-
- @Override
- public Versioned<Collection<? extends byte[]>> addCommit(
- Commit<? extends MultimapOperation> commit) {
- Preconditions.checkNotNull(commit);
- Preconditions.checkNotNull(commit.value());
- Versioned<Collection<? extends byte[]>> retVersion;
-
- if (commit.value() instanceof Put) {
- //Using a treeset here sanitizes the input, removing duplicates
- Set<byte[]> valuesToAdd =
- Sets.newTreeSet(new ByteArrayComparator());
- ((Put) commit.value()).values().forEach(value -> {
- if (!valueSet.contains(value)) {
- valuesToAdd.add(value);
- }
- });
- if (valuesToAdd.isEmpty()) {
- //Do not increment or add the commit if no change resulted
- return null;
- }
- retVersion = new Versioned<>(valuesToAdd, version);
- valuesToAdd.forEach(value -> valueSet.add(value));
- version++;
- return retVersion;
-
- } else if (commit.value() instanceof Replace) {
- //Will this work?? Need to check before check-in!
- Set<byte[]> removedValues = Sets.newHashSet();
- removedValues.addAll(valueSet);
- retVersion = new Versioned<>(removedValues, version);
- valueSet.clear();
- Set<byte[]> valuesToAdd =
- Sets.newTreeSet(new ByteArrayComparator());
- ((Replace) commit.value()).values().forEach(value -> {
- valuesToAdd.add(value);
- });
- if (valuesToAdd.isEmpty()) {
- version = globalVersion.incrementAndGet();
- backingMap.remove(((Replace) commit.value()).key());
- return retVersion;
- }
- valuesToAdd.forEach(value -> valueSet.add(value));
- version = globalVersion.incrementAndGet();
- return retVersion;
-
- } else if (commit.value() instanceof RemoveAll) {
- Set<byte[]> removed = Sets.newHashSet();
- //We can assume here that values only appear once and so we
- //do not need to sanitize the return for duplicates.
- removed.addAll(valueSet);
- retVersion = new Versioned<>(removed, version);
- valueSet.clear();
- //In the case of a removeAll all commits will be removed and
- //unlike the multiRemove case we do not need to consider
- //dependencies among additive and removal commits.
-
- //Save the key for use after the commit is closed
- String key = ((RemoveAll) commit.value()).key();
- version = globalVersion.incrementAndGet();
- backingMap.remove(key);
- return retVersion;
-
- } else if (commit.value() instanceof MultiRemove) {
- //Must first calculate how many commits the removal depends on.
- //At this time we also sanitize the removal set by adding to a
- //set with proper handling of byte[] equality.
- Set<byte[]> removed = Sets.newHashSet();
- ((MultiRemove) commit.value()).values().forEach(value -> {
- if (valueSet.contains(value)) {
- removed.add(value);
- }
- });
- //If there is nothing to be removed no action should be taken.
- if (removed.isEmpty()) {
- return null;
- }
- //Save key in case countdown results in closing the commit.
- String removedKey = ((MultiRemove) commit.value()).key();
- removed.forEach(removedValue -> {
- valueSet.remove(removedValue);
- });
- //The version is updated locally as well as globally even if
- //this object will be removed from the map in case any other
- //party still holds a reference to this object.
- retVersion = new Versioned<>(removed, version);
- version = globalVersion.incrementAndGet();
- if (valueSet.isEmpty()) {
- backingMap.remove(removedKey);
- }
- return retVersion;
-
- } else {
- throw new IllegalArgumentException();
- }
- }
- }
-
- /**
- * A collector that creates MapEntryValues and creates a multiset of all
- * values in the map an equal number of times to the number of sets in
- * which they participate.
- */
- private class HashMultisetValueCollector implements
- Collector<MapEntryValue,
- HashMultiset<byte[]>,
- HashMultiset<byte[]>> {
-
- @Override
- public Supplier<HashMultiset<byte[]>> supplier() {
- return HashMultiset::create;
- }
-
- @Override
- public BiConsumer<HashMultiset<byte[]>, MapEntryValue> accumulator() {
- return (multiset, mapEntryValue) ->
- multiset.addAll(mapEntryValue.values());
- }
-
- @Override
- public BinaryOperator<HashMultiset<byte[]>> combiner() {
- return (setOne, setTwo) -> {
- setOne.addAll(setTwo);
- return setOne;
- };
- }
-
- @Override
- public Function<HashMultiset<byte[]>,
- HashMultiset<byte[]>> finisher() {
- return Function.identity();
- }
-
- @Override
- public Set<Characteristics> characteristics() {
- return EnumSet.of(Characteristics.UNORDERED);
- }
- }
-
- /**
- * A collector that creates Entries of {@code <String, MapEntryValue>} and
- * creates a set of entries all key value pairs in the map.
- */
- private class EntrySetCollector implements
- Collector<Map.Entry<String, MapEntryValue>,
- Set<Map.Entry<String, byte[]>>,
- Set<Map.Entry<String, byte[]>>> {
- private Set<Map.Entry<String, byte[]>> set = null;
-
- @Override
- public Supplier<Set<Map.Entry<String, byte[]>>> supplier() {
- return () -> {
- if (set == null) {
- set = Sets.newHashSet();
- }
- return set;
- };
- }
-
- @Override
- public BiConsumer<Set<Map.Entry<String, byte[]>>,
- Map.Entry<String, MapEntryValue>> accumulator() {
- return (set, entry) -> {
- entry
- .getValue()
- .values()
- .forEach(byteValue ->
- set.add(Maps.immutableEntry(entry.getKey(),
- byteValue)));
- };
- }
-
- @Override
- public BinaryOperator<Set<Map.Entry<String, byte[]>>> combiner() {
- return (setOne, setTwo) -> {
- setOne.addAll(setTwo);
- return setOne;
- };
- }
-
- @Override
- public Function<Set<Map.Entry<String, byte[]>>,
- Set<Map.Entry<String, byte[]>>> finisher() {
- return (unused) -> set;
- }
-
- @Override
- public Set<Characteristics> characteristics() {
- return EnumSet.of(Characteristics.UNORDERED);
- }
- }
- /**
- * Utility for turning a {@code MapEntryValue} to {@code Versioned}.
- * @param value map entry value
- * @return versioned instance or an empty list versioned -1 if argument is
- * null
- */
- private Versioned<Collection<? extends byte[]>> toVersioned(
- MapEntryValue value) {
- return value == null ? new Versioned<>(Lists.newArrayList(), -1) :
- new Versioned<>(value.values(),
- value.version());
- }
-
- private static class ByteArrayComparator implements Comparator<byte[]> {
-
- @Override
- public int compare(byte[] o1, byte[] o2) {
- if (Arrays.equals(o1, o2)) {
- return 0;
- } else {
- for (int i = 0; i < o1.length && i < o2.length; i++) {
- if (o1[i] < o2[i]) {
- return -1;
- } else if (o1[i] > o2[i]) {
- return 1;
- }
- }
- return o1.length > o2.length ? 1 : -1;
- }
- }
- }
-
- private static class IteratorContext {
- private final long sessionId;
- private final Iterator<Map.Entry<String, MapEntryValue>> iterator;
- private int position = 0;
-
- IteratorContext(long sessionId, Iterator<Map.Entry<String, MapEntryValue>> iterator) {
- this.sessionId = sessionId;
- this.iterator = iterator;
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentTreeMap.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentTreeMap.java
deleted file mode 100644
index 25c4d84..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentTreeMap.java
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.NavigableMap;
-import java.util.NavigableSet;
-import java.util.TreeMap;
-import java.util.concurrent.CompletableFuture;
-
-import io.atomix.protocols.raft.proxy.RaftProxy;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.FloorEntry;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.HigherEntry;
-import org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.LowerEntry;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncConsistentTreeMap;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Versioned;
-
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.CEILING_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.CEILING_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.CeilingEntry;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.CeilingKey;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.FIRST_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.FIRST_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.FLOOR_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.FLOOR_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.FloorKey;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.HIGHER_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.HIGHER_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.HigherKey;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.LAST_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.LAST_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.LOWER_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.LOWER_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.LowerKey;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.POLL_FIRST_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.POLL_LAST_ENTRY;
-
-/**
- * Implementation of {@link AsyncConsistentTreeMap}.
- */
-public class AtomixConsistentTreeMap extends AtomixConsistentMap implements AsyncConsistentTreeMap<byte[]> {
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixConsistentMapOperations.NAMESPACE)
- .register(AtomixConsistentTreeMapOperations.NAMESPACE)
- .register(AtomixConsistentMapEvents.NAMESPACE)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 150)
- .register(AtomixConsistentMapService.TransactionScope.class)
- .register(TransactionLog.class)
- .register(TransactionId.class)
- .register(AtomixConsistentMapService.MapEntryValue.class)
- .register(AtomixConsistentMapService.MapEntryValue.Type.class)
- .register(new HashMap().keySet().getClass())
- .register(TreeMap.class)
- .build());
-
- public AtomixConsistentTreeMap(RaftProxy proxy) {
- super(proxy);
- }
-
- @Override
- protected Serializer serializer() {
- return SERIALIZER;
- }
-
- @Override
- public CompletableFuture<String> firstKey() {
- return proxy.invoke(FIRST_KEY, serializer()::decode);
- }
-
- @Override
- public CompletableFuture<String> lastKey() {
- return proxy.invoke(LAST_KEY, serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<byte[]>>> ceilingEntry(String key) {
- return proxy.invoke(CEILING_ENTRY, serializer()::encode, new CeilingEntry(key), serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<byte[]>>> floorEntry(String key) {
- return proxy.invoke(FLOOR_ENTRY, serializer()::encode, new FloorEntry(key), serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<byte[]>>> higherEntry(
- String key) {
- return proxy.invoke(HIGHER_ENTRY, serializer()::encode, new HigherEntry(key), serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<byte[]>>> lowerEntry(
- String key) {
- return proxy.invoke(LOWER_ENTRY, serializer()::encode, new LowerEntry(key), serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<byte[]>>> firstEntry() {
- return proxy.invoke(FIRST_ENTRY, serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<byte[]>>> lastEntry() {
- return proxy.invoke(LAST_ENTRY, serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<byte[]>>> pollFirstEntry() {
- return proxy.invoke(POLL_FIRST_ENTRY, serializer()::decode);
- }
-
- @Override
- public CompletableFuture<Map.Entry<String, Versioned<byte[]>>> pollLastEntry() {
- return proxy.invoke(POLL_LAST_ENTRY, serializer()::decode);
- }
-
- @Override
- public CompletableFuture<String> lowerKey(String key) {
- return proxy.invoke(LOWER_KEY, serializer()::encode, new LowerKey(key), serializer()::decode);
- }
-
- @Override
- public CompletableFuture<String> floorKey(String key) {
- return proxy.invoke(FLOOR_KEY, serializer()::encode, new FloorKey(key), serializer()::decode);
- }
-
- @Override
- public CompletableFuture<String> ceilingKey(String key) {
- return proxy.invoke(CEILING_KEY, serializer()::encode, new CeilingKey(key), serializer()::decode);
- }
-
- @Override
- public CompletableFuture<String> higherKey(String key) {
- return proxy.invoke(HIGHER_KEY, serializer()::encode, new HigherKey(key), serializer()::decode);
- }
-
- @Override
- public CompletableFuture<NavigableSet<String>> navigableKeySet() {
- throw new UnsupportedOperationException("This operation is not yet supported.");
- }
-
- @Override
- public CompletableFuture<NavigableMap<String, byte[]>> subMap(
- String upperKey, String lowerKey, boolean inclusiveUpper,
- boolean inclusiveLower) {
- throw new UnsupportedOperationException("This operation is not yet supported.");
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentTreeMapOperations.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentTreeMapOperations.java
deleted file mode 100644
index 74ae7eb..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentTreeMapOperations.java
+++ /dev/null
@@ -1,415 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.AbstractMap;
-
-import com.google.common.base.MoreObjects;
-import com.google.common.collect.Maps;
-import io.atomix.protocols.raft.operation.OperationId;
-import io.atomix.protocols.raft.operation.OperationType;
-import org.onlab.util.KryoNamespace;
-import org.onlab.util.Match;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.Versioned;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * {@link org.onosproject.store.service.AsyncConsistentTreeMap} Resource
- * state machine operations.
- */
-public enum AtomixConsistentTreeMapOperations implements OperationId {
- SUB_MAP(OperationType.QUERY),
- FIRST_KEY(OperationType.QUERY),
- LAST_KEY(OperationType.QUERY),
- FIRST_ENTRY(OperationType.QUERY),
- LAST_ENTRY(OperationType.QUERY),
- POLL_FIRST_ENTRY(OperationType.QUERY),
- POLL_LAST_ENTRY(OperationType.QUERY),
- LOWER_ENTRY(OperationType.QUERY),
- LOWER_KEY(OperationType.QUERY),
- FLOOR_ENTRY(OperationType.QUERY),
- FLOOR_KEY(OperationType.QUERY),
- CEILING_ENTRY(OperationType.QUERY),
- CEILING_KEY(OperationType.QUERY),
- HIGHER_ENTRY(OperationType.QUERY),
- HIGHER_KEY(OperationType.QUERY);
-
- private final OperationType type;
-
- AtomixConsistentTreeMapOperations(OperationType type) {
- this.type = type;
- }
-
- @Override
- public String id() {
- return name();
- }
-
- @Override
- public OperationType type() {
- return type;
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 100)
- .register(LowerKey.class)
- .register(LowerEntry.class)
- .register(HigherKey.class)
- .register(HigherEntry.class)
- .register(FloorKey.class)
- .register(FloorEntry.class)
- .register(CeilingKey.class)
- .register(CeilingEntry.class)
- .register(Versioned.class)
- .register(AbstractMap.SimpleImmutableEntry.class)
- .register(Maps.immutableEntry("", "").getClass())
- .build("AtomixConsistentTreeMapOperations");
-
- /**
- * Abstract treeMap command.
- */
- @SuppressWarnings("serial")
- public abstract static class TreeOperation {
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .toString();
- }
- }
-
- /**
- * Abstract key-based query.
- */
- @SuppressWarnings("serial")
- public abstract static class KeyOperation extends TreeOperation {
- protected String key;
-
- public KeyOperation(String key) {
- this.key = checkNotNull(key);
- }
-
- public KeyOperation() {
- }
-
- public String key() {
- return key;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("key", key)
- .toString();
- }
- }
-
- /**
- * Abstract value-based query.
- */
- @SuppressWarnings("serial")
- public abstract static class ValueOperation extends TreeOperation {
- protected byte[] value;
-
- public ValueOperation() {}
-
- public ValueOperation(byte[] value) {
- this.value = checkNotNull(value);
- }
-
- public byte[] value() {
- return value;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("value", value)
- .toString();
- }
- }
-
- /**
- * Contains key command.
- */
- @SuppressWarnings("serial")
- public static class ContainsKey extends KeyOperation {
-
- public ContainsKey(String key) {
- super(key);
- }
-
- public ContainsKey() {
- }
- }
- /**
- * Contains value command.
- */
- @SuppressWarnings("serial")
- public static class ContainsValue extends ValueOperation {
- public ContainsValue() {
- }
-
- public ContainsValue(byte[] value) {
- super(value);
- }
-
- }
-
- /**
- * AsyncConsistentTreeMap update command.
- */
- @SuppressWarnings("serial")
- public static class UpdateAndGet extends TreeOperation {
- private String key;
- private byte[] value;
- private Match<byte[]> valueMatch;
- private Match<Long> versionMatch;
- public UpdateAndGet() {
- }
-
- public UpdateAndGet(String key,
- byte[] value,
- Match<byte[]> valueMatch,
- Match<Long> versionMatch) {
- this.key = key;
- this.value = value;
- this.valueMatch = valueMatch;
- this.versionMatch = versionMatch;
- }
-
- public String key() {
- return this.key;
- }
-
- public byte[] value() {
- return this.value;
- }
-
- public Match<byte[]> valueMatch() {
- return this.valueMatch;
- }
-
- public Match<Long> versionMatch() {
- return this.versionMatch;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("key", key)
- .add("value", value)
- .add("valueMatch", valueMatch)
- .add("versionMatch", versionMatch)
- .toString();
- }
- }
-
- /**
- * Get query.
- */
- @SuppressWarnings("serial")
- public static class Get extends KeyOperation {
- public Get() {
- }
-
- public Get(String key) {
- super(key);
- }
- }
-
- /**
- * Get or default query.
- */
- @SuppressWarnings("serial")
- public static class GetOrDefault extends KeyOperation {
- private byte[] defaultValue;
-
- public GetOrDefault() {
- }
-
- public GetOrDefault(String key, byte[] defaultValue) {
- super(key);
- this.defaultValue = defaultValue;
- }
-
- /**
- * Returns the default value.
- *
- * @return the default value
- */
- public byte[] defaultValue() {
- return defaultValue;
- }
- }
-
- /**
- * Query returns the entry associated with the largest key less than the
- * passed in key.
- */
- @SuppressWarnings("serial")
- public static class LowerEntry extends KeyOperation {
- public LowerEntry() {
- }
-
- public LowerEntry(String key) {
- super(key);
- }
- }
-
- /**
- * Query returns the largest key less than the specified key.
- */
- @SuppressWarnings("serial")
- public static class LowerKey extends KeyOperation {
- public LowerKey() {
- }
-
- public LowerKey(String key) {
- super(key);
- }
- }
-
- /**
- * Query returns the entry associated with the largest key smaller than or
- * equal to the specified key.
- */
- @SuppressWarnings("serial")
- public static class FloorEntry extends KeyOperation {
- public FloorEntry() {
- }
-
- public FloorEntry(String key) {
- super(key);
- }
- }
-
- /**
- * Query returns the largest key smaller than or equal to the passed in
- * key.
- */
- @SuppressWarnings("serial")
- public static class FloorKey extends KeyOperation {
- public FloorKey() {
- }
-
- public FloorKey(String key) {
- super(key);
- }
- }
-
- /**
- * Returns the entry associated with the smallest key larger than or equal
- * to the specified key.
- */
- @SuppressWarnings("serial")
- public static class CeilingEntry extends KeyOperation {
- public CeilingEntry() {
- }
-
- public CeilingEntry(String key) {
- super(key);
- }
- }
-
- /**
- * Returns the smallest key larger than or equal to the specified key.
- */
- @SuppressWarnings("serial")
- public static class CeilingKey extends KeyOperation {
- public CeilingKey() {
- }
-
- public CeilingKey(String key) {
- super(key);
- }
- }
-
- /**
- * Returns the entry associated with the smallest key larger than the
- * specified key.
- */
- @SuppressWarnings("serial")
- public static class HigherEntry extends KeyOperation {
- public HigherEntry() {
- }
-
- public HigherEntry(String key) {
- super(key);
- }
- }
-
- /**
- * Returns the smallest key larger than the specified key.
- */
- @SuppressWarnings("serial")
- public static class HigherKey extends KeyOperation {
- public HigherKey() {
- }
-
- public HigherKey(String key) {
- super(key);
- }
- }
-
- @SuppressWarnings("serial")
- public static class SubMap<K, V> extends TreeOperation {
- private K fromKey;
- private K toKey;
- private boolean inclusiveFrom;
- private boolean inclusiveTo;
-
- public SubMap() {
- }
-
- public SubMap(K fromKey, K toKey, boolean inclusiveFrom,
- boolean inclusiveTo) {
- this.fromKey = fromKey;
- this.toKey = toKey;
- this.inclusiveFrom = inclusiveFrom;
- this.inclusiveTo = inclusiveTo;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("getFromKey", fromKey)
- .add("getToKey", toKey)
- .add("inclusiveFromBound", inclusiveFrom)
- .add("inclusiveToBound", inclusiveTo)
- .toString();
- }
-
- public K fromKey() {
- return fromKey;
- }
-
- public K toKey() {
- return toKey;
- }
-
- public boolean isInclusiveFrom() {
- return inclusiveFrom;
- }
-
- public boolean isInclusiveTo() {
- return inclusiveTo;
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentTreeMapService.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentTreeMapService.java
deleted file mode 100644
index 89c8da6..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentTreeMapService.java
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.NavigableMap;
-import java.util.TreeMap;
-import java.util.concurrent.ConcurrentSkipListMap;
-
-import com.google.common.collect.Maps;
-import io.atomix.protocols.raft.service.Commit;
-import io.atomix.protocols.raft.service.RaftServiceExecutor;
-import io.atomix.protocols.raft.session.RaftSession;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Versioned;
-
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.CEILING_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.CEILING_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.CeilingEntry;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.CeilingKey;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.FIRST_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.FIRST_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.FLOOR_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.FLOOR_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.FloorEntry;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.FloorKey;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.HIGHER_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.HIGHER_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.HigherEntry;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.HigherKey;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.LAST_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.LAST_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.LOWER_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.LOWER_KEY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.LowerEntry;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.LowerKey;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.POLL_FIRST_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.POLL_LAST_ENTRY;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.SUB_MAP;
-import static org.onosproject.store.primitives.resources.impl.AtomixConsistentTreeMapOperations.SubMap;
-
-/**
- * State machine corresponding to {@link AtomixConsistentTreeMap} backed by a
- * {@link TreeMap}.
- */
-public class AtomixConsistentTreeMapService extends AtomixConsistentMapService {
-
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixConsistentMapOperations.NAMESPACE)
- .register(AtomixConsistentTreeMapOperations.NAMESPACE)
- .register(AtomixConsistentMapEvents.NAMESPACE)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 150)
- .register(TransactionScope.class)
- .register(TransactionLog.class)
- .register(TransactionId.class)
- .register(MapEntryValue.class)
- .register(MapEntryValue.Type.class)
- .register(new HashMap().keySet().getClass())
- .register(ConcurrentSkipListMap.class)
- .build());
-
- @Override
- protected NavigableMap<String, MapEntryValue> createMap() {
- return new ConcurrentSkipListMap<>();
- }
-
- @Override
- protected NavigableMap<String, MapEntryValue> entries() {
- return (NavigableMap<String, MapEntryValue>) super.entries();
- }
-
- @Override
- protected Serializer serializer() {
- return SERIALIZER;
- }
-
- @Override
- public void configure(RaftServiceExecutor executor) {
- super.configure(executor);
- executor.register(SUB_MAP, serializer()::decode, this::subMap, serializer()::encode);
- executor.register(FIRST_KEY, (Commit<Void> c) -> firstKey(), serializer()::encode);
- executor.register(LAST_KEY, (Commit<Void> c) -> lastKey(), serializer()::encode);
- executor.register(FIRST_ENTRY, (Commit<Void> c) -> firstEntry(), serializer()::encode);
- executor.register(LAST_ENTRY, (Commit<Void> c) -> lastEntry(), serializer()::encode);
- executor.register(POLL_FIRST_ENTRY, (Commit<Void> c) -> pollFirstEntry(), serializer()::encode);
- executor.register(POLL_LAST_ENTRY, (Commit<Void> c) -> pollLastEntry(), serializer()::encode);
- executor.register(LOWER_ENTRY, serializer()::decode, this::lowerEntry, serializer()::encode);
- executor.register(LOWER_KEY, serializer()::decode, this::lowerKey, serializer()::encode);
- executor.register(FLOOR_ENTRY, serializer()::decode, this::floorEntry, serializer()::encode);
- executor.register(FLOOR_KEY, serializer()::decode, this::floorKey, serializer()::encode);
- executor.register(CEILING_ENTRY, serializer()::decode, this::ceilingEntry, serializer()::encode);
- executor.register(CEILING_KEY, serializer()::decode, this::ceilingKey, serializer()::encode);
- executor.register(HIGHER_ENTRY, serializer()::decode, this::higherEntry, serializer()::encode);
- executor.register(HIGHER_KEY, serializer()::decode, this::higherKey, serializer()::encode);
- }
-
- protected NavigableMap<String, MapEntryValue> subMap(
- Commit<? extends SubMap> commit) {
- // Do not support this until lazy communication is possible. At present
- // it transmits up to the entire map.
- SubMap<String, MapEntryValue> subMap = commit.value();
- return entries().subMap(subMap.fromKey(), subMap.isInclusiveFrom(),
- subMap.toKey(), subMap.isInclusiveTo());
- }
-
- protected String firstKey() {
- return isEmpty() ? null : entries().firstKey();
- }
-
- protected String lastKey() {
- return isEmpty() ? null : entries().lastKey();
- }
-
- protected Map.Entry<String, Versioned<byte[]>> higherEntry(Commit<? extends HigherEntry> commit) {
- return isEmpty() ? null : toVersionedEntry(entries().higherEntry(commit.value().key()));
- }
-
- protected Map.Entry<String, Versioned<byte[]>> firstEntry() {
- return isEmpty() ? null : toVersionedEntry(entries().firstEntry());
- }
-
- protected Map.Entry<String, Versioned<byte[]>> lastEntry() {
- return isEmpty() ? null : toVersionedEntry(entries().lastEntry());
- }
-
- protected Map.Entry<String, Versioned<byte[]>> pollFirstEntry() {
- return toVersionedEntry(entries().pollFirstEntry());
- }
-
- protected Map.Entry<String, Versioned<byte[]>> pollLastEntry() {
- return toVersionedEntry(entries().pollLastEntry());
- }
-
- protected Map.Entry<String, Versioned<byte[]>> lowerEntry(Commit<? extends LowerEntry> commit) {
- return toVersionedEntry(entries().lowerEntry(commit.value().key()));
- }
-
- protected String lowerKey(Commit<? extends LowerKey> commit) {
- return entries().lowerKey(commit.value().key());
- }
-
- protected Map.Entry<String, Versioned<byte[]>> floorEntry(Commit<? extends FloorEntry> commit) {
- return toVersionedEntry(entries().floorEntry(commit.value().key()));
- }
-
- protected String floorKey(Commit<? extends FloorKey> commit) {
- return entries().floorKey(commit.value().key());
- }
-
- protected Map.Entry<String, Versioned<byte[]>> ceilingEntry(Commit<CeilingEntry> commit) {
- return toVersionedEntry(entries().ceilingEntry(commit.value().key()));
- }
-
- protected String ceilingKey(Commit<CeilingKey> commit) {
- return entries().ceilingKey(commit.value().key());
- }
-
- protected String higherKey(Commit<HigherKey> commit) {
- return entries().higherKey(commit.value().key());
- }
-
- private Map.Entry<String, Versioned<byte[]>> toVersionedEntry(
- Map.Entry<String, MapEntryValue> entry) {
- return entry == null || valueIsNull(entry.getValue())
- ? null : Maps.immutableEntry(entry.getKey(), toVersioned(entry.getValue()));
- }
-
- @Override
- public void onExpire(RaftSession session) {
- closeListener(session.sessionId().id());
- }
-
- @Override
- public void onClose(RaftSession session) {
- closeListener(session.sessionId().id());
- }
-
- private void closeListener(Long sessionId) {
- listeners.remove(sessionId);
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixCounter.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixCounter.java
deleted file mode 100644
index 9c579d6..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixCounter.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.concurrent.CompletableFuture;
-
-import io.atomix.protocols.raft.proxy.RaftProxy;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncAtomicCounter;
-import org.onosproject.store.service.Serializer;
-
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.ADD_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.AddAndGet;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.COMPARE_AND_SET;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.CompareAndSet;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.GET_AND_ADD;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.GET_AND_INCREMENT;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.GetAndAdd;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.INCREMENT_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.SET;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.Set;
-
-/**
- * Atomix counter implementation.
- */
-public class AtomixCounter extends AbstractRaftPrimitive implements AsyncAtomicCounter {
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixCounterOperations.NAMESPACE)
- .build());
-
- public AtomixCounter(RaftProxy proxy) {
- super(proxy);
- }
-
- private long nullOrZero(Long value) {
- return value != null ? value : 0;
- }
-
- @Override
- public CompletableFuture<Long> get() {
- return proxy.<Long>invoke(GET, SERIALIZER::decode).thenApply(this::nullOrZero);
- }
-
- @Override
- public CompletableFuture<Void> set(long value) {
- return proxy.invoke(SET, SERIALIZER::encode, new Set(value));
- }
-
- @Override
- public CompletableFuture<Boolean> compareAndSet(long expectedValue, long updateValue) {
- return proxy.invoke(COMPARE_AND_SET, SERIALIZER::encode,
- new CompareAndSet(expectedValue, updateValue), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> addAndGet(long delta) {
- return proxy.invoke(ADD_AND_GET, SERIALIZER::encode, new AddAndGet(delta), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> getAndAdd(long delta) {
- return proxy.invoke(GET_AND_ADD, SERIALIZER::encode, new GetAndAdd(delta), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> incrementAndGet() {
- return proxy.invoke(INCREMENT_AND_GET, SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Long> getAndIncrement() {
- return proxy.invoke(GET_AND_INCREMENT, SERIALIZER::decode);
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixCounterOperations.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixCounterOperations.java
deleted file mode 100644
index 67ff936..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixCounterOperations.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import io.atomix.protocols.raft.operation.OperationId;
-import io.atomix.protocols.raft.operation.OperationType;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-
-/**
- * Counter commands.
- */
-public enum AtomixCounterOperations implements OperationId {
- SET(OperationType.COMMAND),
- COMPARE_AND_SET(OperationType.COMMAND),
- INCREMENT_AND_GET(OperationType.COMMAND),
- GET_AND_INCREMENT(OperationType.COMMAND),
- ADD_AND_GET(OperationType.COMMAND),
- GET_AND_ADD(OperationType.COMMAND),
- GET(OperationType.QUERY);
-
- private final OperationType type;
-
- AtomixCounterOperations(OperationType type) {
- this.type = type;
- }
-
- @Override
- public String id() {
- return name();
- }
-
- @Override
- public OperationType type() {
- return type;
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID)
- .register(Get.class)
- .register(Set.class)
- .register(CompareAndSet.class)
- .register(AddAndGet.class)
- .register(GetAndAdd.class)
- .build("AtomixCounterOperations");
-
- /**
- * Abstract value command.
- */
- public abstract static class ValueOperation {
- }
-
- /**
- * Get query.
- */
- public static class Get extends ValueOperation {
- }
-
- /**
- * Set command.
- */
- public static class Set extends ValueOperation {
- private Long value;
-
- public Set() {
- }
-
- public Set(Long value) {
- this.value = value;
- }
-
- /**
- * Returns the command value.
- *
- * @return The command value.
- */
- public Long value() {
- return value;
- }
-
- @Override
- public String toString() {
- return String.format("%s[value=%s]", getClass().getSimpleName(), value);
- }
- }
-
- /**
- * Compare and set command.
- */
- public static class CompareAndSet extends ValueOperation {
- private Long expect;
- private Long update;
-
- public CompareAndSet() {
- }
-
- public CompareAndSet(Long expect, Long update) {
- this.expect = expect;
- this.update = update;
- }
-
- /**
- * Returns the expected value.
- *
- * @return The expected value.
- */
- public Long expect() {
- return expect;
- }
-
- /**
- * Returns the updated value.
- *
- * @return The updated value.
- */
- public Long update() {
- return update;
- }
-
- @Override
- public String toString() {
- return String.format("%s[expect=%s, update=%s]", getClass().getSimpleName(), expect, update);
- }
- }
-
- /**
- * Delta command.
- */
- public abstract static class DeltaOperation extends ValueOperation {
- private long delta;
-
- public DeltaOperation() {
- }
-
- public DeltaOperation(long delta) {
- this.delta = delta;
- }
-
- /**
- * Returns the delta.
- *
- * @return The delta.
- */
- public long delta() {
- return delta;
- }
- }
-
- /**
- * Get and add command.
- */
- public static class GetAndAdd extends DeltaOperation {
- public GetAndAdd() {
- }
-
- public GetAndAdd(long delta) {
- super(delta);
- }
- }
-
- /**
- * Add and get command.
- */
- public static class AddAndGet extends DeltaOperation {
- public AddAndGet() {
- }
-
- public AddAndGet(long delta) {
- super(delta);
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixCounterService.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixCounterService.java
deleted file mode 100644
index a56478b..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixCounterService.java
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.Objects;
-
-import io.atomix.protocols.raft.service.AbstractRaftService;
-import io.atomix.protocols.raft.service.Commit;
-import io.atomix.protocols.raft.service.RaftServiceExecutor;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotReader;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotWriter;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.Serializer;
-
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.ADD_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.AddAndGet;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.COMPARE_AND_SET;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.CompareAndSet;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.GET_AND_ADD;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.GET_AND_INCREMENT;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.GetAndAdd;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.INCREMENT_AND_GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.SET;
-import static org.onosproject.store.primitives.resources.impl.AtomixCounterOperations.Set;
-
-/**
- * Atomix long state.
- */
-public class AtomixCounterService extends AbstractRaftService {
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixCounterOperations.NAMESPACE)
- .build());
-
- private Long value = 0L;
-
- @Override
- protected void configure(RaftServiceExecutor executor) {
- executor.register(SET, SERIALIZER::decode, this::set);
- executor.register(GET, this::get, SERIALIZER::encode);
- executor.register(COMPARE_AND_SET, SERIALIZER::decode, this::compareAndSet, SERIALIZER::encode);
- executor.register(INCREMENT_AND_GET, this::incrementAndGet, SERIALIZER::encode);
- executor.register(GET_AND_INCREMENT, this::getAndIncrement, SERIALIZER::encode);
- executor.register(ADD_AND_GET, SERIALIZER::decode, this::addAndGet, SERIALIZER::encode);
- executor.register(GET_AND_ADD, SERIALIZER::decode, this::getAndAdd, SERIALIZER::encode);
- }
-
- @Override
- public void snapshot(SnapshotWriter writer) {
- writer.writeLong(value);
- }
-
- @Override
- public void install(SnapshotReader reader) {
- value = reader.readLong();
- }
-
- /**
- * Handles a set commit.
- *
- * @param commit the commit to handle
- */
- protected void set(Commit<Set> commit) {
- value = commit.value().value();
- }
-
- /**
- * Handles a get commit.
- *
- * @param commit the commit to handle
- * @return counter value
- */
- protected Long get(Commit<Void> commit) {
- return value;
- }
-
- /**
- * Handles a compare and set commit.
- *
- * @param commit the commit to handle
- * @return counter value
- */
- protected boolean compareAndSet(Commit<CompareAndSet> commit) {
- if (Objects.equals(value, commit.value().expect())) {
- value = commit.value().update();
- return true;
- }
- return false;
- }
-
- /**
- * Handles an increment and get commit.
- *
- * @param commit the commit to handle
- * @return counter value
- */
- protected long incrementAndGet(Commit<Void> commit) {
- Long oldValue = value;
- value = oldValue + 1;
- return value;
- }
-
- /**
- * Handles a get and increment commit.
- *
- * @param commit the commit to handle
- * @return counter value
- */
- protected long getAndIncrement(Commit<Void> commit) {
- Long oldValue = value;
- value = oldValue + 1;
- return oldValue;
- }
-
- /**
- * Handles an add and get commit.
- *
- * @param commit the commit to handle
- * @return counter value
- */
- protected long addAndGet(Commit<AddAndGet> commit) {
- Long oldValue = value;
- value = oldValue + commit.value().delta();
- return value;
- }
-
- /**
- * Handles a get and add commit.
- *
- * @param commit the commit to handle
- * @return counter value
- */
- protected long getAndAdd(Commit<GetAndAdd> commit) {
- Long oldValue = value;
- value = oldValue + commit.value().delta();
- return oldValue;
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDistributedLock.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDistributedLock.java
deleted file mode 100644
index c234be3..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDistributedLock.java
+++ /dev/null
@@ -1,247 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.time.Duration;
-import java.util.Map;
-import java.util.Optional;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.Consumer;
-
-import com.google.common.collect.Maps;
-import io.atomix.protocols.raft.proxy.RaftProxy;
-import org.onlab.util.KryoNamespace;
-import org.onlab.util.OrderedExecutor;
-import org.onlab.util.SharedScheduledExecutors;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncDistributedLock;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.Version;
-
-import static org.onlab.util.Tools.orderedFuture;
-import static org.onosproject.store.primitives.resources.impl.AtomixDistributedLockEvents.FAILED;
-import static org.onosproject.store.primitives.resources.impl.AtomixDistributedLockEvents.LOCKED;
-import static org.onosproject.store.primitives.resources.impl.AtomixDistributedLockOperations.LOCK;
-import static org.onosproject.store.primitives.resources.impl.AtomixDistributedLockOperations.Lock;
-import static org.onosproject.store.primitives.resources.impl.AtomixDistributedLockOperations.UNLOCK;
-import static org.onosproject.store.primitives.resources.impl.AtomixDistributedLockOperations.Unlock;
-
-/**
- * Atomix lock implementation.
- * <p>
- * This {@link org.onosproject.store.service.DistributedLock} implementation uses a {@link RaftProxy} to interact
- * with a {@link AtomixDistributedLockService} replicated state machine.
- */
-public class AtomixDistributedLock extends AbstractRaftPrimitive implements AsyncDistributedLock {
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixDistributedLockOperations.NAMESPACE)
- .register(AtomixDistributedLockEvents.NAMESPACE)
- .build());
-
- private final ScheduledExecutorService scheduledExecutor;
- private final Executor orderedExecutor;
- private final Map<Integer, LockAttempt> attempts = Maps.newConcurrentMap();
- private final AtomicInteger id = new AtomicInteger();
- private final AtomicInteger lock = new AtomicInteger();
-
- public AtomixDistributedLock(RaftProxy proxy) {
- super(proxy);
- this.scheduledExecutor = SharedScheduledExecutors.getPoolThreadExecutor();
- this.orderedExecutor = new OrderedExecutor(scheduledExecutor);
- proxy.addEventListener(LOCKED, SERIALIZER::decode, this::handleLocked);
- proxy.addEventListener(FAILED, SERIALIZER::decode, this::handleFailed);
- }
-
- /**
- * Handles a {@code LOCKED} event.
- *
- * @param event the event to handle
- */
- private void handleLocked(LockEvent event) {
- // Remove the LockAttempt from the attempts map and complete it with the lock version if it exists.
- // If the attempt no longer exists, it likely was expired by a client-side timer.
- LockAttempt attempt = attempts.remove(event.id());
- if (attempt != null) {
- attempt.complete(new Version(event.version()));
- }
- }
-
- /**
- * Handles a {@code FAILED} event.
- *
- * @param event the event to handle
- */
- private void handleFailed(LockEvent event) {
- // Remove the LockAttempt from the attempts map and complete it with a null value if it exists.
- // If the attempt no longer exists, it likely was expired by a client-side timer.
- LockAttempt attempt = attempts.remove(event.id());
- if (attempt != null) {
- attempt.complete(null);
- }
- }
-
- @Override
- public CompletableFuture<Version> lock() {
- // Create and register a new attempt and invoke the LOCK operation on the replicated state machine.
- LockAttempt attempt = new LockAttempt();
- proxy.invoke(LOCK, SERIALIZER::encode, new Lock(attempt.id(), -1)).whenComplete((result, error) -> {
- if (error != null) {
- attempt.completeExceptionally(error);
- }
- });
-
- // Return an ordered future that can safely be blocked inside the executor thread.
- return orderedFuture(attempt, orderedExecutor, scheduledExecutor);
- }
-
- @Override
- public CompletableFuture<Optional<Version>> tryLock() {
- // If the proxy is currently disconnected from the cluster, we can just fail the lock attempt here.
- RaftProxy.State state = proxy.getState();
- if (state != RaftProxy.State.CONNECTED) {
- return CompletableFuture.completedFuture(Optional.empty());
- }
-
- // Create and register a new attempt and invoke the LOCK operation on teh replicated state machine with
- // a 0 timeout. The timeout will cause the state machine to immediately reject the request if the lock is
- // already owned by another process.
- LockAttempt attempt = new LockAttempt();
- proxy.invoke(LOCK, SERIALIZER::encode, new Lock(attempt.id(), 0)).whenComplete((result, error) -> {
- if (error != null) {
- attempt.completeExceptionally(error);
- }
- });
-
- // Return an ordered future that can safely be blocked inside the executor thread.
- return orderedFuture(attempt, orderedExecutor, scheduledExecutor)
- .thenApply(Optional::ofNullable);
- }
-
- @Override
- public CompletableFuture<Optional<Version>> tryLock(Duration timeout) {
- // Create a lock attempt with a client-side timeout and fail the lock if the timer expires.
- // Because time does not progress at the same rate on different nodes, we can't guarantee that
- // the lock won't be granted to this process after it's expired here. Thus, if this timer expires and
- // we fail the lock on the client, we also still need to send an UNLOCK command to the cluster in case it's
- // later granted by the cluster. Note that the semantics of the Raft client will guarantee this operation
- // occurs after any prior LOCK attempt, and the Raft client will retry the UNLOCK request until successful.
- // Additionally, sending the unique lock ID with the command ensures we won't accidentally unlock a different
- // lock call also granted to this process.
- LockAttempt attempt = new LockAttempt(timeout, a -> {
- a.complete(null);
- proxy.invoke(UNLOCK, SERIALIZER::encode, new Unlock(a.id()));
- });
-
- // Invoke the LOCK operation on the replicated state machine with the given timeout. If the lock is currently
- // held by another process, the state machine will add the attempt to a queue and publish a FAILED event if
- // the timer expires before this process can be granted the lock. If the client cannot reach the Raft cluster,
- // the client-side timer will expire the attempt.
- proxy.invoke(LOCK, SERIALIZER::encode, new Lock(attempt.id(), timeout.toMillis()))
- .whenComplete((result, error) -> {
- if (error != null) {
- attempt.completeExceptionally(error);
- }
- });
-
- // Return an ordered future that can safely be blocked inside the executor thread.
- return orderedFuture(attempt, orderedExecutor, scheduledExecutor)
- .thenApply(Optional::ofNullable);
- }
-
- @Override
- public CompletableFuture<Void> unlock() {
- // Use the current lock ID to ensure we only unlock the lock currently held by this process.
- int lock = this.lock.getAndSet(0);
- if (lock != 0) {
- return orderedFuture(
- proxy.invoke(UNLOCK, SERIALIZER::encode, new Unlock(lock)),
- orderedExecutor,
- scheduledExecutor);
- }
- return CompletableFuture.completedFuture(null);
- }
-
- /**
- * Closes the lock.
- *
- * @return a future to be completed once the lock has been closed
- */
- public CompletableFuture<Void> close() {
- return proxy.close();
- }
-
- /**
- * Lock attempt.
- */
- private class LockAttempt extends CompletableFuture<Version> {
- private final int id;
- private final ScheduledFuture<?> scheduledFuture;
-
- LockAttempt() {
- this(null, null);
- }
-
- LockAttempt(Duration duration, Consumer<LockAttempt> callback) {
- this.id = AtomixDistributedLock.this.id.incrementAndGet();
- this.scheduledFuture = duration != null && callback != null
- ? scheduledExecutor.schedule(() -> callback.accept(this), duration.toMillis(), TimeUnit.MILLISECONDS)
- : null;
- attempts.put(id, this);
- }
-
- /**
- * Returns the lock attempt ID.
- *
- * @return the lock attempt ID
- */
- int id() {
- return id;
- }
-
- @Override
- public boolean complete(Version version) {
- if (isDone()) {
- return super.complete(null);
- }
- cancel();
- if (version != null) {
- lock.set(id);
- return super.complete(version);
- } else {
- return super.complete(null);
- }
- }
-
- @Override
- public boolean completeExceptionally(Throwable ex) {
- cancel();
- return super.completeExceptionally(ex);
- }
-
- private void cancel() {
- if (scheduledFuture != null) {
- scheduledFuture.cancel(false);
- }
- attempts.remove(id);
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDistributedLockEvents.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDistributedLockEvents.java
deleted file mode 100644
index e6d2b2a..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDistributedLockEvents.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import io.atomix.protocols.raft.event.EventType;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-
-/**
- * Raft value events.
- */
-public enum AtomixDistributedLockEvents implements EventType {
- LOCKED("lock"),
- FAILED("fail");
-
- private final String id;
-
- AtomixDistributedLockEvents(String id) {
- this.id = id;
- }
-
- @Override
- public String id() {
- return id;
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 50)
- .register(LockEvent.class)
- .register(byte[].class)
- .build(AtomixDistributedLockEvents.class.getSimpleName());
-
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDistributedLockOperations.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDistributedLockOperations.java
deleted file mode 100644
index 5cfbc84..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDistributedLockOperations.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import io.atomix.protocols.raft.operation.OperationId;
-import io.atomix.protocols.raft.operation.OperationType;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-
-/**
- * {@link org.onosproject.store.service.DistributedLock} operations.
- * <p>
- * WARNING: Do not refactor enum values. Only add to them.
- * Changing values risk breaking the ability to backup/restore/upgrade clusters.
- */
-public enum AtomixDistributedLockOperations implements OperationId {
- LOCK(OperationType.COMMAND),
- UNLOCK(OperationType.COMMAND);
-
- private final OperationType type;
-
- AtomixDistributedLockOperations(OperationType type) {
- this.type = type;
- }
-
- @Override
- public String id() {
- return name();
- }
-
- @Override
- public OperationType type() {
- return type;
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID)
- .register(Lock.class)
- .register(Unlock.class)
- .build(AtomixDistributedLockOperations.class.getSimpleName());
-
- /**
- * Abstract lock operation.
- */
- public abstract static class LockOperation {
- @Override
- public String toString() {
- return toStringHelper(this).toString();
- }
- }
-
- /**
- * Lock command.
- */
- public static class Lock extends LockOperation {
- private final int id;
- private final long timeout;
-
- public Lock() {
- this(0, 0);
- }
-
- public Lock(int id, long timeout) {
- this.id = id;
- this.timeout = timeout;
- }
-
- /**
- * Returns the lock identifier.
- *
- * @return the lock identifier
- */
- public int id() {
- return id;
- }
-
- /**
- * Returns the lock attempt timeout.
- *
- * @return the lock attempt timeout
- */
- public long timeout() {
- return timeout;
- }
-
- @Override
- public String toString() {
- return toStringHelper(this)
- .add("id", id)
- .add("timeout", timeout)
- .toString();
- }
- }
-
- /**
- * Unlock command.
- */
- public static class Unlock extends LockOperation {
- private final int id;
-
- public Unlock(int id) {
- this.id = id;
- }
-
- /**
- * Returns the lock identifier.
- *
- * @return the lock identifier
- */
- public int id() {
- return id;
- }
-
- @Override
- public String toString() {
- return toStringHelper(this)
- .add("id", id)
- .toString();
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDistributedLockService.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDistributedLockService.java
deleted file mode 100644
index e730ffd..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDistributedLockService.java
+++ /dev/null
@@ -1,268 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.time.Duration;
-import java.util.ArrayDeque;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Queue;
-
-import io.atomix.protocols.raft.service.AbstractRaftService;
-import io.atomix.protocols.raft.service.Commit;
-import io.atomix.protocols.raft.service.RaftServiceExecutor;
-import io.atomix.protocols.raft.session.RaftSession;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotReader;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotWriter;
-import io.atomix.utils.concurrent.Scheduled;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.Serializer;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-import static org.onosproject.store.primitives.resources.impl.AtomixDistributedLockEvents.FAILED;
-import static org.onosproject.store.primitives.resources.impl.AtomixDistributedLockEvents.LOCKED;
-import static org.onosproject.store.primitives.resources.impl.AtomixDistributedLockOperations.LOCK;
-import static org.onosproject.store.primitives.resources.impl.AtomixDistributedLockOperations.Lock;
-import static org.onosproject.store.primitives.resources.impl.AtomixDistributedLockOperations.UNLOCK;
-import static org.onosproject.store.primitives.resources.impl.AtomixDistributedLockOperations.Unlock;
-
-/**
- * Raft atomic value service.
- */
-public class AtomixDistributedLockService extends AbstractRaftService {
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixDistributedLockOperations.NAMESPACE)
- .register(AtomixDistributedLockEvents.NAMESPACE)
- .register(LockHolder.class)
- .register(ArrayDeque.class)
- .build());
-
- private LockHolder lock;
- private Queue<LockHolder> queue = new ArrayDeque<>();
- private final Map<Long, Scheduled> timers = new HashMap<>();
-
- @Override
- protected void configure(RaftServiceExecutor executor) {
- executor.register(LOCK, SERIALIZER::decode, this::lock);
- executor.register(UNLOCK, SERIALIZER::decode, this::unlock);
- }
-
- @Override
- public void snapshot(SnapshotWriter writer) {
- writer.writeObject(lock, SERIALIZER::encode);
- writer.writeObject(queue, SERIALIZER::encode);
- }
-
- @Override
- public void install(SnapshotReader reader) {
- lock = reader.readObject(SERIALIZER::decode);
- queue = reader.readObject(SERIALIZER::decode);
-
- // After the snapshot is installed, we need to cancel any existing timers and schedule new ones based on the
- // state provided by the snapshot.
- timers.values().forEach(Scheduled::cancel);
- timers.clear();
- for (LockHolder holder : queue) {
- if (holder.expire > 0) {
- timers.put(holder.index,
- scheduler().schedule(Duration.ofMillis(holder.expire - wallClock().getTime().unixTimestamp()),
- () -> {
- timers.remove(holder.index);
- queue.remove(holder);
- RaftSession session = sessions().getSession(holder.session);
- if (session != null && session.getState().active()) {
- session.publish(FAILED, SERIALIZER::encode, new LockEvent(holder.id, holder.index));
- }
- }));
- }
- }
- }
-
- @Override
- public void onExpire(RaftSession session) {
- releaseSession(session);
- }
-
- @Override
- public void onClose(RaftSession session) {
- releaseSession(session);
- }
-
- /**
- * Applies a lock commit.
- *
- * @param commit the lock commit
- */
- protected void lock(Commit<Lock> commit) {
- // If the lock is not already owned, immediately grant the lock to the requester.
- // Note that we still have to publish an event to the session. The event is guaranteed to be received
- // by the client-side primitive after the LOCK response.
- if (lock == null) {
- lock = new LockHolder(
- commit.value().id(),
- commit.index(),
- commit.session().sessionId().id(),
- 0);
- commit.session().publish(
- LOCKED,
- SERIALIZER::encode,
- new LockEvent(commit.value().id(), commit.index()));
- // If the timeout is 0, that indicates this is a tryLock request. Immediately fail the request.
- } else if (commit.value().timeout() == 0) {
- commit.session().publish(FAILED, SERIALIZER::encode, new LockEvent(commit.value().id(), commit.index()));
- // If a timeout exists, add the request to the queue and set a timer. Note that the lock request expiration
- // time is based on the *state machine* time - not the system time - to ensure consistency across servers.
- } else if (commit.value().timeout() > 0) {
- LockHolder holder = new LockHolder(
- commit.value().id(),
- commit.index(),
- commit.session().sessionId().id(),
- wallClock().getTime().unixTimestamp() + commit.value().timeout());
- queue.add(holder);
- timers.put(commit.index(), scheduler().schedule(Duration.ofMillis(commit.value().timeout()), () -> {
- // When the lock request timer expires, remove the request from the queue and publish a FAILED
- // event to the session. Note that this timer is guaranteed to be executed in the same thread as the
- // state machine commands, so there's no need to use a lock here.
- timers.remove(commit.index());
- queue.remove(holder);
- if (commit.session().getState().active()) {
- commit.session().publish(
- FAILED,
- SERIALIZER::encode,
- new LockEvent(commit.value().id(), commit.index()));
- }
- }));
- // If the lock is -1, just add the request to the queue with no expiration.
- } else {
- LockHolder holder = new LockHolder(
- commit.value().id(),
- commit.index(),
- commit.session().sessionId().id(),
- 0);
- queue.add(holder);
- }
- }
-
- /**
- * Applies an unlock commit.
- *
- * @param commit the unlock commit
- */
- protected void unlock(Commit<Unlock> commit) {
- if (lock != null) {
- // If the commit's session does not match the current lock holder, ignore the request.
- if (lock.session != commit.session().sessionId().id()) {
- return;
- }
-
- // If the current lock ID does not match the requested lock ID, ignore the request. This ensures that
- // internal releases of locks that were never acquired by the client-side primitive do not cause
- // legitimate locks to be unlocked.
- if (lock.id != commit.value().id()) {
- return;
- }
-
- // The lock has been released. Populate the lock from the queue.
- lock = queue.poll();
- while (lock != null) {
- // If the waiter has a lock timer, cancel the timer.
- Scheduled timer = timers.remove(lock.index);
- if (timer != null) {
- timer.cancel();
- }
-
- // If the lock session is for some reason inactive, continue on to the next waiter. Otherwise,
- // publish a LOCKED event to the new lock holder's session.
- RaftSession session = sessions().getSession(lock.session);
- if (session == null || !session.getState().active()) {
- lock = queue.poll();
- } else {
- session.publish(
- LOCKED,
- SERIALIZER::encode,
- new LockEvent(lock.id, commit.index()));
- break;
- }
- }
- }
- }
-
- /**
- * Handles a session that has been closed by a client or expired by the cluster.
- * <p>
- * When a session is removed, if the session is the current lock holder then the lock is released and the next
- * session waiting in the queue is granted the lock. Additionally, all pending lock requests for the session
- * are removed from the lock queue.
- *
- * @param session the closed session
- */
- private void releaseSession(RaftSession session) {
- // Remove all instances of the session from the lock queue.
- queue.removeIf(lock -> lock.session == session.sessionId().id());
-
- // If the removed session is the current holder of the lock, nullify the lock and attempt to grant it
- // to the next waiter in the queue.
- if (lock != null && lock.session == session.sessionId().id()) {
- lock = queue.poll();
- while (lock != null) {
- // If the waiter has a lock timer, cancel the timer.
- Scheduled timer = timers.remove(lock.index);
- if (timer != null) {
- timer.cancel();
- }
-
- // If the lock session is inactive, continue on to the next waiter. Otherwise,
- // publish a LOCKED event to the new lock holder's session.
- RaftSession lockSession = sessions().getSession(lock.session);
- if (lockSession == null || !lockSession.getState().active()) {
- lock = queue.poll();
- } else {
- lockSession.publish(
- LOCKED,
- SERIALIZER::encode,
- new LockEvent(lock.id, lock.index));
- break;
- }
- }
- }
- }
-
- private class LockHolder {
- private final int id;
- private final long index;
- private final long session;
- private final long expire;
-
- public LockHolder(int id, long index, long session, long expire) {
- this.id = id;
- this.index = index;
- this.session = session;
- this.expire = expire;
- }
-
- @Override
- public String toString() {
- return toStringHelper(this)
- .add("id", id)
- .add("index", index)
- .add("session", session)
- .add("expire", expire)
- .toString();
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDocumentTree.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDocumentTree.java
deleted file mode 100644
index 877d3fe..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDocumentTree.java
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.Executor;
-
-import com.google.common.util.concurrent.MoreExecutors;
-import io.atomix.protocols.raft.proxy.RaftProxy;
-import org.onlab.util.KryoNamespace;
-import org.onlab.util.Match;
-import org.onlab.util.Tools;
-import org.onosproject.store.primitives.NodeUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.Get;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.GetChildren;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.Listen;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.Unlisten;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.Update;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.TransactionBegin;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.TransactionPrepare;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.TransactionPrepareAndCommit;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.TransactionCommit;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.TransactionRollback;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncDocumentTree;
-import org.onosproject.store.service.DocumentPath;
-import org.onosproject.store.service.DocumentTreeEvent;
-import org.onosproject.store.service.DocumentTreeListener;
-import org.onosproject.store.service.IllegalDocumentModificationException;
-import org.onosproject.store.service.NoSuchDocumentPathException;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Version;
-import org.onosproject.store.service.Versioned;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeEvents.CHANGE;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.BEGIN;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.PREPARE;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.PREPARE_AND_COMMIT;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.COMMIT;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.ROLLBACK;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.CLEAR;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.GET_CHILDREN;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.UPDATE;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.ADD_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.REMOVE_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.DocumentTreeResult.Status.ILLEGAL_MODIFICATION;
-import static org.onosproject.store.primitives.resources.impl.DocumentTreeResult.Status.INVALID_PATH;
-import static org.onosproject.store.primitives.resources.impl.DocumentTreeResult.Status.OK;
-
-/**
- * Distributed resource providing the {@link AsyncDocumentTree} primitive.
- */
-public class AtomixDocumentTree extends AbstractRaftPrimitive implements AsyncDocumentTree<byte[]> {
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixDocumentTreeOperations.NAMESPACE)
- .register(AtomixDocumentTreeEvents.NAMESPACE)
- .build());
-
- private final Map<DocumentTreeListener<byte[]>, InternalListener> eventListeners = new ConcurrentHashMap<>();
-
- public AtomixDocumentTree(RaftProxy proxy) {
- super(proxy);
- proxy.addStateChangeListener(state -> {
- if (state == RaftProxy.State.CONNECTED && isListening()) {
- proxy.invoke(ADD_LISTENER, SERIALIZER::encode, new Listen());
- }
- });
- proxy.addEventListener(CHANGE, SERIALIZER::decode, this::processTreeUpdates);
- }
-
- @Override
- public Type primitiveType() {
- return Type.DOCUMENT_TREE;
- }
-
- @Override
- public CompletableFuture<Void> destroy() {
- return proxy.invoke(CLEAR);
- }
-
- @Override
- public DocumentPath root() {
- return DocumentPath.ROOT;
- }
-
- @Override
- public CompletableFuture<Map<String, Versioned<byte[]>>> getChildren(DocumentPath path) {
- return proxy.<GetChildren, DocumentTreeResult<Map<String, Versioned<byte[]>>>>invoke(
- GET_CHILDREN,
- SERIALIZER::encode,
- new GetChildren(checkNotNull(path)),
- SERIALIZER::decode)
- .thenCompose(result -> {
- if (result.status() == INVALID_PATH) {
- return Tools.exceptionalFuture(new NoSuchDocumentPathException());
- } else if (result.status() == ILLEGAL_MODIFICATION) {
- return Tools.exceptionalFuture(new IllegalDocumentModificationException());
- } else {
- return CompletableFuture.completedFuture(result);
- }
- }).thenApply(result -> result.result());
- }
-
- @Override
- public CompletableFuture<Versioned<byte[]>> get(DocumentPath path) {
- return proxy.invoke(GET, SERIALIZER::encode, new Get(checkNotNull(path)), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Versioned<byte[]>> set(DocumentPath path, byte[] value) {
- return proxy.<Update, DocumentTreeResult<Versioned<byte[]>>>invoke(UPDATE,
- SERIALIZER::encode,
- new Update(checkNotNull(path), Optional.ofNullable(value), Match.any(), Match.any()),
- SERIALIZER::decode)
- .thenCompose(result -> {
- if (result.status() == INVALID_PATH) {
- return Tools.exceptionalFuture(new NoSuchDocumentPathException());
- } else if (result.status() == ILLEGAL_MODIFICATION) {
- return Tools.exceptionalFuture(new IllegalDocumentModificationException());
- } else {
- return CompletableFuture.completedFuture(result);
- }
- }).thenApply(result -> result.result());
- }
-
- @Override
- public CompletableFuture<Boolean> create(DocumentPath path, byte[] value) {
- return createInternal(path, value)
- .thenCompose(status -> {
- if (status == ILLEGAL_MODIFICATION) {
- return Tools.exceptionalFuture(new IllegalDocumentModificationException());
- }
- return CompletableFuture.completedFuture(true);
- });
- }
-
- @Override
- public CompletableFuture<Boolean> createRecursive(DocumentPath path, byte[] value) {
- return createInternal(path, value)
- .thenCompose(status -> {
- if (status == ILLEGAL_MODIFICATION) {
- return createRecursive(path.parent(), null)
- .thenCompose(r -> createInternal(path, value).thenApply(v -> true));
- }
- return CompletableFuture.completedFuture(status == OK);
- });
- }
-
- @Override
- public CompletableFuture<Boolean> replace(DocumentPath path, byte[] newValue, long version) {
- return proxy.<Update, DocumentTreeResult<byte[]>>invoke(UPDATE,
- SERIALIZER::encode,
- new Update(checkNotNull(path),
- Optional.ofNullable(newValue),
- Match.any(),
- Match.ifValue(version)), SERIALIZER::decode)
- .thenApply(result -> result.updated());
- }
-
- @Override
- public CompletableFuture<Boolean> replace(DocumentPath path, byte[] newValue, byte[] currentValue) {
- return proxy.<Update, DocumentTreeResult<byte[]>>invoke(UPDATE,
- SERIALIZER::encode,
- new Update(checkNotNull(path),
- Optional.ofNullable(newValue),
- Match.ifValue(currentValue),
- Match.any()),
- SERIALIZER::decode)
- .thenCompose(result -> {
- if (result.status() == INVALID_PATH) {
- return Tools.exceptionalFuture(new NoSuchDocumentPathException());
- } else if (result.status() == ILLEGAL_MODIFICATION) {
- return Tools.exceptionalFuture(new IllegalDocumentModificationException());
- } else {
- return CompletableFuture.completedFuture(result);
- }
- }).thenApply(result -> result.updated());
- }
-
- @Override
- public CompletableFuture<Versioned<byte[]>> removeNode(DocumentPath path) {
- if (path.equals(DocumentPath.from("root"))) {
- return Tools.exceptionalFuture(new IllegalDocumentModificationException());
- }
- return proxy.<Update, DocumentTreeResult<Versioned<byte[]>>>invoke(UPDATE,
- SERIALIZER::encode,
- new Update(checkNotNull(path), null, Match.any(), Match.ifNotNull()),
- SERIALIZER::decode)
- .thenCompose(result -> {
- if (result.status() == INVALID_PATH) {
- return Tools.exceptionalFuture(new NoSuchDocumentPathException());
- } else if (result.status() == ILLEGAL_MODIFICATION) {
- return Tools.exceptionalFuture(new IllegalDocumentModificationException());
- } else {
- return CompletableFuture.completedFuture(result);
- }
- }).thenApply(result -> result.result());
- }
-
- @Override
- public CompletableFuture<Void> addListener(DocumentPath path, DocumentTreeListener<byte[]> listener) {
- checkNotNull(path);
- checkNotNull(listener);
- InternalListener internalListener = new InternalListener(path, listener, MoreExecutors.directExecutor());
- // TODO: Support API that takes an executor
- if (!eventListeners.containsKey(listener)) {
- return proxy.invoke(ADD_LISTENER, SERIALIZER::encode, new Listen(path))
- .thenRun(() -> eventListeners.put(listener, internalListener));
- }
- return CompletableFuture.completedFuture(null);
- }
-
- @Override
- public CompletableFuture<Void> removeListener(DocumentTreeListener<byte[]> listener) {
- checkNotNull(listener);
- InternalListener internalListener = eventListeners.remove(listener);
- if (internalListener != null && eventListeners.isEmpty()) {
- return proxy.invoke(REMOVE_LISTENER, SERIALIZER::encode, new Unlisten(internalListener.path))
- .thenApply(v -> null);
- }
- return CompletableFuture.completedFuture(null);
- }
-
- private CompletableFuture<DocumentTreeResult.Status> createInternal(DocumentPath path, byte[] value) {
- return proxy.<Update, DocumentTreeResult<byte[]>>invoke(UPDATE,
- SERIALIZER::encode,
- new Update(checkNotNull(path), Optional.ofNullable(value), Match.any(), Match.ifNull()),
- SERIALIZER::decode)
- .thenApply(result -> result.status());
- }
-
- private boolean isListening() {
- return !eventListeners.isEmpty();
- }
-
- private void processTreeUpdates(List<DocumentTreeEvent<byte[]>> events) {
- events.forEach(event -> eventListeners.values().forEach(listener -> listener.event(event)));
- }
-
- @Override
- public CompletableFuture<Version> begin(TransactionId transactionId) {
- return proxy.<TransactionBegin, Long>invoke(
- BEGIN,
- SERIALIZER::encode,
- new TransactionBegin(transactionId),
- SERIALIZER::decode)
- .thenApply(Version::new);
- }
-
- @Override
- public CompletableFuture<Boolean> prepare(TransactionLog<NodeUpdate<byte[]>> transactionLog) {
- return proxy.<TransactionPrepare, PrepareResult>invoke(
- PREPARE,
- SERIALIZER::encode,
- new TransactionPrepare(transactionLog),
- SERIALIZER::decode)
- .thenApply(v -> v == PrepareResult.OK);
- }
-
- @Override
- public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<NodeUpdate<byte[]>> transactionLog) {
- return proxy.<TransactionPrepareAndCommit, PrepareResult>invoke(
- PREPARE_AND_COMMIT,
- SERIALIZER::encode,
- new TransactionPrepareAndCommit(transactionLog),
- SERIALIZER::decode)
- .thenApply(v -> v == PrepareResult.OK);
- }
-
- @Override
- public CompletableFuture<Void> commit(TransactionId transactionId) {
- return proxy.<TransactionCommit, CommitResult>invoke(
- COMMIT,
- SERIALIZER::encode,
- new TransactionCommit(transactionId),
- SERIALIZER::decode)
- .thenApply(v -> null);
- }
-
- @Override
- public CompletableFuture<Void> rollback(TransactionId transactionId) {
- return proxy.invoke(
- ROLLBACK,
- SERIALIZER::encode,
- new TransactionRollback(transactionId),
- SERIALIZER::decode)
- .thenApply(v -> null);
- }
-
- private class InternalListener implements DocumentTreeListener<byte[]> {
-
- private final DocumentPath path;
- private final DocumentTreeListener<byte[]> listener;
- private final Executor executor;
-
- public InternalListener(DocumentPath path, DocumentTreeListener<byte[]> listener, Executor executor) {
- this.path = path;
- this.listener = listener;
- this.executor = executor;
- }
-
- @Override
- public void event(DocumentTreeEvent<byte[]> event) {
- if (event.path().isDescendentOf(path)) {
- executor.execute(() -> listener.event(event));
- }
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDocumentTreeEvents.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDocumentTreeEvents.java
deleted file mode 100644
index 47dcd31..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDocumentTreeEvents.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import io.atomix.protocols.raft.event.EventType;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.DocumentTreeEvent;
-
-/**
- * Atomix document tree events.
- */
-public enum AtomixDocumentTreeEvents implements EventType {
- CHANGE;
-
- @Override
- public String id() {
- return name();
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 50)
- .register(DocumentTreeEvent.class)
- .register(DocumentTreeEvent.Type.class)
- .build("AtomixDocumentTreeEvents");
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDocumentTreeOperations.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDocumentTreeOperations.java
deleted file mode 100644
index 6ec6091..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDocumentTreeOperations.java
+++ /dev/null
@@ -1,370 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.LinkedHashMap;
-import java.util.Optional;
-
-import com.google.common.base.MoreObjects;
-import io.atomix.protocols.raft.operation.OperationId;
-import io.atomix.protocols.raft.operation.OperationType;
-import org.onlab.util.KryoNamespace;
-import org.onlab.util.Match;
-import org.onosproject.store.primitives.NodeUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.DocumentPath;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Versioned;
-
-/**
- * {@link AtomixDocumentTree} resource state machine operations.
- */
-public enum AtomixDocumentTreeOperations implements OperationId {
- ADD_LISTENER(OperationType.COMMAND),
- REMOVE_LISTENER(OperationType.COMMAND),
- GET(OperationType.QUERY),
- GET_CHILDREN(OperationType.QUERY),
- UPDATE(OperationType.COMMAND),
- CLEAR(OperationType.COMMAND),
- BEGIN(OperationType.COMMAND),
- PREPARE(OperationType.COMMAND),
- PREPARE_AND_COMMIT(OperationType.COMMAND),
- COMMIT(OperationType.COMMAND),
- ROLLBACK(OperationType.COMMAND);
-
- private final OperationType type;
-
- AtomixDocumentTreeOperations(OperationType type) {
- this.type = type;
- }
-
- @Override
- public String id() {
- return name();
- }
-
- @Override
- public OperationType type() {
- return type;
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID)
- .register(LinkedHashMap.class)
- .register(Listen.class)
- .register(Unlisten.class)
- .register(Get.class)
- .register(GetChildren.class)
- .register(Update.class)
- .register(TransactionBegin.class)
- .register(TransactionPrepare.class)
- .register(TransactionPrepareAndCommit.class)
- .register(TransactionCommit.class)
- .register(TransactionRollback.class)
- .register(TransactionId.class)
- .register(TransactionLog.class)
- .register(PrepareResult.class)
- .register(CommitResult.class)
- .register(RollbackResult.class)
- .register(NodeUpdate.class)
- .register(NodeUpdate.Type.class)
- .register(DocumentPath.class)
- .register(Match.class)
- .register(Versioned.class)
- .register(DocumentTreeResult.class)
- .register(DocumentTreeResult.Status.class)
- .build("AtomixDocumentTreeOperations");
-
- /**
- * Base class for document tree operations.
- */
- public abstract static class DocumentTreeOperation {
- }
-
- /**
- * Base class for document tree operations that serialize a {@link DocumentPath}.
- */
- @SuppressWarnings("serial")
- public abstract static class PathOperation extends DocumentTreeOperation {
- private DocumentPath path;
-
- PathOperation(DocumentPath path) {
- this.path = path;
- }
-
- public DocumentPath path() {
- return path;
- }
- }
-
- /**
- * DocumentTree#get query.
- */
- @SuppressWarnings("serial")
- public static class Get extends PathOperation {
- public Get() {
- super(null);
- }
-
- public Get(DocumentPath path) {
- super(path);
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("path", path())
- .toString();
- }
- }
-
- /**
- * DocumentTree#getChildren query.
- */
- @SuppressWarnings("serial")
- public static class GetChildren extends PathOperation {
- public GetChildren() {
- super(null);
- }
-
- public GetChildren(DocumentPath path) {
- super(path);
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("path", path())
- .toString();
- }
- }
-
- /**
- * DocumentTree update command.
- */
- @SuppressWarnings("serial")
- public static class Update extends PathOperation {
- private Optional<byte[]> value;
- private Match<byte[]> valueMatch;
- private Match<Long> versionMatch;
-
- public Update() {
- super(null);
- this.value = null;
- this.valueMatch = null;
- this.versionMatch = null;
- }
-
- public Update(DocumentPath path, Optional<byte[]> value, Match<byte[]> valueMatch, Match<Long> versionMatch) {
- super(path);
- this.value = value;
- this.valueMatch = valueMatch;
- this.versionMatch = versionMatch;
- }
-
- public Optional<byte[]> value() {
- return value;
- }
-
- public Match<byte[]> valueMatch() {
- return valueMatch;
- }
-
- public Match<Long> versionMatch() {
- return versionMatch;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("path", path())
- .add("value", value)
- .add("valueMatch", valueMatch)
- .add("versionMatch", versionMatch)
- .toString();
- }
- }
-
- /**
- * Change listen.
- */
- @SuppressWarnings("serial")
- public static class Listen extends PathOperation {
- public Listen() {
- this(DocumentPath.from("root"));
- }
-
- public Listen(DocumentPath path) {
- super(path);
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("path", path())
- .toString();
- }
- }
-
- /**
- * Change unlisten.
- */
- @SuppressWarnings("serial")
- public static class Unlisten extends PathOperation {
- public Unlisten() {
- this(DocumentPath.from("root"));
- }
-
- public Unlisten(DocumentPath path) {
- super(path);
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("path", path())
- .toString();
- }
- }
-
- /**
- * Transaction begin command.
- */
- public static class TransactionBegin extends PathOperation {
- private TransactionId transactionId;
-
- public TransactionBegin() {
- super(null);
- }
-
- public TransactionBegin(TransactionId transactionId) {
- super(DocumentPath.from(transactionId.toString()));
- this.transactionId = transactionId;
- }
-
- public TransactionId transactionId() {
- return transactionId;
- }
- }
-
- /**
- * Transaction prepare command.
- */
- @SuppressWarnings("serial")
- public static class TransactionPrepare extends PathOperation {
- private TransactionLog<NodeUpdate<byte[]>> transactionLog;
-
- public TransactionPrepare() {
- super(null);
- }
-
- public TransactionPrepare(TransactionLog<NodeUpdate<byte[]>> transactionLog) {
- super(DocumentPath.from(transactionLog.transactionId().toString()));
- this.transactionLog = transactionLog;
- }
-
- public TransactionLog<NodeUpdate<byte[]>> transactionLog() {
- return transactionLog;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("transactionLog", transactionLog)
- .toString();
- }
- }
-
- /**
- * Transaction prepareAndCommit command.
- */
- @SuppressWarnings("serial")
- public static class TransactionPrepareAndCommit extends TransactionPrepare {
- public TransactionPrepareAndCommit() {
- }
-
- public TransactionPrepareAndCommit(TransactionLog<NodeUpdate<byte[]>> transactionLog) {
- super(transactionLog);
- }
- }
-
- /**
- * Transaction commit command.
- */
- @SuppressWarnings("serial")
- public static class TransactionCommit extends PathOperation {
- private TransactionId transactionId;
-
- public TransactionCommit() {
- super(null);
- }
-
- public TransactionCommit(TransactionId transactionId) {
- super(DocumentPath.from(transactionId.toString()));
- this.transactionId = transactionId;
- }
-
- /**
- * Returns the transaction identifier.
- * @return transaction id
- */
- public TransactionId transactionId() {
- return transactionId;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("transactionId", transactionId)
- .toString();
- }
- }
-
- /**
- * Transaction rollback command.
- */
- @SuppressWarnings("serial")
- public static class TransactionRollback extends PathOperation {
- private TransactionId transactionId;
-
- public TransactionRollback() {
- super(null);
- }
-
- public TransactionRollback(TransactionId transactionId) {
- super(DocumentPath.from(transactionId.toString()));
- this.transactionId = transactionId;
- }
-
- /**
- * Returns the transaction identifier.
- * @return transaction id
- */
- public TransactionId transactionId() {
- return transactionId;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("transactionId", transactionId)
- .toString();
- }
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDocumentTreeService.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDocumentTreeService.java
deleted file mode 100644
index 41a1a9f..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixDocumentTreeService.java
+++ /dev/null
@@ -1,622 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Queue;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.stream.Collectors;
-
-import com.esotericsoftware.kryo.Kryo;
-import com.esotericsoftware.kryo.io.Input;
-import com.esotericsoftware.kryo.io.Output;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Queues;
-import com.google.common.collect.Sets;
-import io.atomix.protocols.raft.event.EventType;
-import io.atomix.protocols.raft.service.AbstractRaftService;
-import io.atomix.protocols.raft.service.Commit;
-import io.atomix.protocols.raft.service.RaftServiceExecutor;
-import io.atomix.protocols.raft.session.RaftSession;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotReader;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotWriter;
-import org.onlab.util.KryoNamespace;
-import org.onlab.util.Match;
-import org.onosproject.store.primitives.NodeUpdate;
-import org.onosproject.store.primitives.TransactionId;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.Get;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.GetChildren;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.Listen;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.Unlisten;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.Update;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.TransactionBegin;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.TransactionPrepare;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.TransactionPrepareAndCommit;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.TransactionCommit;
-import org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.TransactionRollback;
-
-import org.onosproject.store.primitives.resources.impl.DocumentTreeResult.Status;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.DocumentPath;
-import org.onosproject.store.service.DocumentTree;
-import org.onosproject.store.service.DocumentTreeEvent;
-import org.onosproject.store.service.DocumentTreeEvent.Type;
-import org.onosproject.store.service.IllegalDocumentModificationException;
-import org.onosproject.store.service.NoSuchDocumentPathException;
-import org.onosproject.store.service.Ordering;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.TransactionLog;
-import org.onosproject.store.service.Versioned;
-
-import static com.google.common.base.Preconditions.checkState;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeEvents.CHANGE;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.BEGIN;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.PREPARE;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.PREPARE_AND_COMMIT;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.COMMIT;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.ROLLBACK;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.CLEAR;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.GET;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.GET_CHILDREN;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.UPDATE;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.ADD_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixDocumentTreeOperations.REMOVE_LISTENER;
-
-/**
- * State Machine for {@link AtomixDocumentTree} resource.
- */
-public class AtomixDocumentTreeService extends AbstractRaftService {
- private final Serializer serializer = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixDocumentTreeOperations.NAMESPACE)
- .register(AtomixDocumentTreeEvents.NAMESPACE)
- .register(new com.esotericsoftware.kryo.Serializer<Listener>() {
- @Override
- public void write(Kryo kryo, Output output, Listener listener) {
- output.writeLong(listener.session.sessionId().id());
- kryo.writeObject(output, listener.path);
- }
-
- @Override
- public Listener read(Kryo kryo, Input input, Class<Listener> type) {
- return new Listener(sessions().getSession(input.readLong()),
- kryo.readObjectOrNull(input, DocumentPath.class));
- }
- }, Listener.class)
- .register(Versioned.class)
- .register(DocumentPath.class)
- .register(new LinkedHashMap().keySet().getClass())
- .register(TreeMap.class)
- .register(Ordering.class)
- .register(TransactionScope.class)
- .register(TransactionLog.class)
- .register(TransactionId.class)
- .register(SessionListenCommits.class)
- .register(new com.esotericsoftware.kryo.Serializer<DefaultDocumentTree>() {
- @Override
- public void write(Kryo kryo, Output output, DefaultDocumentTree object) {
- kryo.writeObject(output, object.root);
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public DefaultDocumentTree read(Kryo kryo, Input input, Class<DefaultDocumentTree> type) {
- return new DefaultDocumentTree(versionCounter::incrementAndGet,
- kryo.readObject(input, DefaultDocumentTreeNode.class));
- }
- }, DefaultDocumentTree.class)
- .register(DefaultDocumentTreeNode.class)
- .build());
-
- private Map<Long, SessionListenCommits> listeners = new HashMap<>();
- private AtomicLong versionCounter = new AtomicLong(0);
- private DocumentTree<byte[]> docTree;
- private Map<TransactionId, TransactionScope> activeTransactions = Maps.newHashMap();
- private Set<DocumentPath> preparedKeys = Sets.newHashSet();
-
- public AtomixDocumentTreeService(Ordering ordering) {
- this.docTree = new DefaultDocumentTree<>(versionCounter::incrementAndGet, ordering);
- }
-
- @Override
- public void snapshot(SnapshotWriter writer) {
- writer.writeLong(versionCounter.get());
- writer.writeObject(listeners, serializer::encode);
- writer.writeObject(docTree, serializer::encode);
- writer.writeObject(preparedKeys, serializer::encode);
- writer.writeObject(activeTransactions, serializer::encode);
- }
-
- @Override
- public void install(SnapshotReader reader) {
- versionCounter = new AtomicLong(reader.readLong());
- listeners = reader.readObject(serializer::decode);
- docTree = reader.readObject(serializer::decode);
- preparedKeys = reader.readObject(serializer::decode);
- activeTransactions = reader.readObject(serializer::decode);
- }
-
- @Override
- protected void configure(RaftServiceExecutor executor) {
- // Listeners
- executor.register(ADD_LISTENER, serializer::decode, this::listen);
- executor.register(REMOVE_LISTENER, serializer::decode, this::unlisten);
- // queries
- executor.register(GET, serializer::decode, this::get, serializer::encode);
- executor.register(GET_CHILDREN, serializer::decode, this::getChildren, serializer::encode);
- // commands
- executor.register(UPDATE, serializer::decode, this::update, serializer::encode);
- executor.register(CLEAR, this::clear);
- executor.register(BEGIN, serializer::decode, this::begin, serializer::encode);
- executor.register(PREPARE, serializer::decode, this::prepare, serializer::encode);
- executor.register(PREPARE_AND_COMMIT, serializer::decode, this::prepareAndCommit, serializer::encode);
- executor.register(COMMIT, serializer::decode, this::commit, serializer::encode);
- executor.register(ROLLBACK, serializer::decode, this::rollback, serializer::encode);
- }
-
- /**
- * Returns a boolean indicating whether the given path is currently locked by a transaction.
- *
- * @param path the path to check
- * @return whether the given path is locked by a running transaction
- */
- private boolean isLocked(DocumentPath path) {
- return preparedKeys.contains(path);
- }
-
- protected void listen(Commit<? extends Listen> commit) {
- Long sessionId = commit.session().sessionId().id();
- listeners.computeIfAbsent(sessionId, k -> new SessionListenCommits())
- .add(new Listener(commit.session(), commit.value().path()));
- }
-
- protected void unlisten(Commit<? extends Unlisten> commit) {
- Long sessionId = commit.session().sessionId().id();
- SessionListenCommits listenCommits = listeners.get(sessionId);
- if (listenCommits != null) {
- listenCommits.remove(commit);
- }
- }
-
- protected Versioned<byte[]> get(Commit<? extends Get> commit) {
- try {
- Versioned<byte[]> value = docTree.get(commit.value().path());
- return value == null ? null : value.map(node -> node);
- } catch (IllegalStateException e) {
- return null;
- }
- }
-
- protected DocumentTreeResult<Map<String, Versioned<byte[]>>> getChildren(Commit<? extends GetChildren> commit) {
- try {
- return DocumentTreeResult.ok(docTree.getChildren(commit.value().path()));
- } catch (NoSuchDocumentPathException e) {
- return DocumentTreeResult.invalidPath();
- }
- }
-
- protected DocumentTreeResult<Versioned<byte[]>> update(Commit<? extends Update> commit) {
- DocumentTreeResult<Versioned<byte[]>> result = null;
- DocumentPath path = commit.value().path();
-
- // If the path is locked by a transaction, return a WRITE_LOCK error.
- if (isLocked(path)) {
- return DocumentTreeResult.writeLock();
- }
-
- Versioned<byte[]> currentValue = docTree.get(path);
- try {
- Match<Long> versionMatch = commit.value().versionMatch();
- Match<byte[]> valueMatch = commit.value().valueMatch();
-
- if (versionMatch.matches(currentValue == null ? null : currentValue.version())
- && valueMatch.matches(currentValue == null ? null : currentValue.value())) {
- if (commit.value().value() == null) {
- Versioned<byte[]> oldValue = docTree.removeNode(path);
- result = new DocumentTreeResult<>(Status.OK, oldValue);
- if (oldValue != null) {
- notifyListeners(new DocumentTreeEvent<>(
- path,
- Type.DELETED,
- Optional.empty(),
- Optional.of(oldValue)));
- }
- } else {
- Versioned<byte[]> oldValue = docTree.set(path, commit.value().value().orElse(null));
- Versioned<byte[]> newValue = docTree.get(path);
- result = new DocumentTreeResult<>(Status.OK, newValue);
- if (oldValue == null) {
- notifyListeners(new DocumentTreeEvent<>(
- path,
- Type.CREATED,
- Optional.of(newValue),
- Optional.empty()));
- } else {
- notifyListeners(new DocumentTreeEvent<>(
- path,
- Type.UPDATED,
- Optional.of(newValue),
- Optional.of(oldValue)));
- }
- }
- } else {
- result = new DocumentTreeResult<>(
- commit.value().value() == null ? Status.INVALID_PATH : Status.NOOP,
- currentValue);
- }
- } catch (IllegalDocumentModificationException e) {
- result = DocumentTreeResult.illegalModification();
- } catch (NoSuchDocumentPathException e) {
- result = DocumentTreeResult.invalidPath();
- } catch (Exception e) {
- logger().error("Failed to apply {} to state machine", commit.value(), e);
- throw new IllegalStateException(e);
- }
- return result;
- }
-
- protected void clear(Commit<Void> commit) {
- Queue<DocumentPath> toClearQueue = Queues.newArrayDeque();
- Map<String, Versioned<byte[]>> topLevelChildren = docTree.getChildren(DocumentPath.from("root"));
- toClearQueue.addAll(topLevelChildren.keySet()
- .stream()
- .map(name -> new DocumentPath(name, DocumentPath.from("root")))
- .collect(Collectors.toList()));
- while (!toClearQueue.isEmpty()) {
- DocumentPath path = toClearQueue.remove();
- Map<String, Versioned<byte[]>> children = docTree.getChildren(path);
- if (children.size() == 0) {
- docTree.removeNode(path);
- } else {
- children.keySet().forEach(name -> toClearQueue.add(new DocumentPath(name, path)));
- toClearQueue.add(path);
- }
- }
- }
-
- /**
- * Handles a begin commit.
- *
- * @param commit transaction begin commit
- * @return transaction state version
- */
- protected long begin(Commit<? extends TransactionBegin> commit) {
- long version = commit.index();
- activeTransactions.put(commit.value().transactionId(), new TransactionScope(version));
- return version;
- }
-
- /**
- * Handles an prepare commit.
- *
- * @param commit transaction prepare commit
- * @return prepare result
- */
- protected PrepareResult prepare(Commit<? extends TransactionPrepare> commit) {
- try {
- TransactionLog<NodeUpdate<byte[]>> transactionLog = commit.value().transactionLog();
- // Iterate through records in the transaction log and perform isolation checks.
- for (NodeUpdate<byte[]> record : transactionLog.records()) {
- DocumentPath path = record.path();
-
- // If the prepared keys already contains the key contained within the record, that indicates a
- // conflict with a concurrent transaction.
- if (preparedKeys.contains(path)) {
- return PrepareResult.CONCURRENT_TRANSACTION;
- }
-
- // Read the existing value from the map.
- Versioned<byte[]> existingValue = docTree.get(path);
-
- // If the update is an UPDATE_NODE or DELETE_NODE, verify that versions match.
- switch (record.type()) {
- case UPDATE_NODE:
- case DELETE_NODE:
- if (existingValue == null || existingValue.version() != record.version()) {
- return PrepareResult.OPTIMISTIC_LOCK_FAILURE;
- }
- default:
- break;
- }
- }
-
- // No violations detected. Mark modified keys locked for transactions.
- transactionLog.records().forEach(record -> {
- preparedKeys.add(record.path());
- });
-
- // Update the transaction scope. If the transaction scope is not set on this node, that indicates the
- // coordinator is communicating with another node. Transactions assume that the client is communicating
- // with a single leader in order to limit the overhead of retaining tombstones.
- TransactionScope transactionScope = activeTransactions.get(transactionLog.transactionId());
- if (transactionScope == null) {
- activeTransactions.put(
- transactionLog.transactionId(),
- new TransactionScope(transactionLog.version(), commit.value().transactionLog()));
- return PrepareResult.PARTIAL_FAILURE;
- } else {
- activeTransactions.put(
- transactionLog.transactionId(),
- transactionScope.prepared(commit));
- return PrepareResult.OK;
- }
- } catch (Exception e) {
- logger().warn("Failure applying {}", commit, e);
- throw new IllegalStateException(e);
- }
- }
-
- /**
- * Handles an prepare and commit commit.
- *
- * @param commit transaction prepare and commit commit
- * @return prepare result
- */
- protected PrepareResult prepareAndCommit(Commit<? extends TransactionPrepareAndCommit> commit) {
- TransactionId transactionId = commit.value().transactionLog().transactionId();
- PrepareResult prepareResult = prepare(commit);
- TransactionScope transactionScope = activeTransactions.remove(transactionId);
- if (prepareResult == PrepareResult.OK) {
- transactionScope = transactionScope.prepared(commit);
- commitTransaction(transactionScope);
- }
- return prepareResult;
- }
-
- /**
- * Applies committed operations to the state machine.
- */
- private CommitResult commitTransaction(TransactionScope transactionScope) {
- TransactionLog<NodeUpdate<byte[]>> transactionLog = transactionScope.transactionLog();
-
- List<DocumentTreeEvent<byte[]>> eventsToPublish = Lists.newArrayList();
- DocumentTreeEvent<byte[]> start = new DocumentTreeEvent<>(
- DocumentPath.from(transactionScope.transactionLog().transactionId().toString()),
- Type.TRANSACTION_START,
- Optional.empty(),
- Optional.empty());
- eventsToPublish.add(start);
-
- for (NodeUpdate<byte[]> record : transactionLog.records()) {
- DocumentPath path = record.path();
- checkState(preparedKeys.remove(path), "path is not prepared");
-
- // FIXME revisit this block, it never respects NodeUpdate type
-
- Versioned<byte[]> previousValue = null;
- try {
- previousValue = docTree.removeNode(path);
- } catch (NoSuchDocumentPathException e) {
- logger().info("Value is being inserted first time");
- }
-
- if (record.value() != null) {
- if (docTree.create(path, record.value())) {
- Versioned<byte[]> newValue = docTree.get(path);
- eventsToPublish.add(new DocumentTreeEvent<>(
- path,
- Optional.ofNullable(newValue),
- Optional.ofNullable(previousValue)));
- }
- } else if (previousValue != null) {
- eventsToPublish.add(new DocumentTreeEvent<>(
- path,
- Optional.empty(),
- Optional.of(previousValue)));
- }
- }
-
- DocumentTreeEvent<byte[]> end = new DocumentTreeEvent<>(
- DocumentPath.from(transactionScope.transactionLog().transactionId().toString()),
- Type.TRANSACTION_END,
- Optional.empty(),
- Optional.empty());
- eventsToPublish.add(end);
- publish(eventsToPublish);
-
- return CommitResult.OK;
- }
-
- /**
- * Handles an commit commit (ha!).
- *
- * @param commit transaction commit commit
- * @return commit result
- */
- protected CommitResult commit(Commit<? extends TransactionCommit> commit) {
- TransactionId transactionId = commit.value().transactionId();
- TransactionScope transactionScope = activeTransactions.remove(transactionId);
- if (transactionScope == null) {
- return CommitResult.UNKNOWN_TRANSACTION_ID;
- }
- try {
- return commitTransaction(transactionScope);
- } catch (Exception e) {
- logger().warn("Failure applying {}", commit, e);
- throw new IllegalStateException(e);
- }
- }
-
- /**
- * Handles an rollback commit (ha!).
- *
- * @param commit transaction rollback commit
- * @return rollback result
- */
- protected RollbackResult rollback(Commit<? extends TransactionRollback> commit) {
- TransactionId transactionId = commit.value().transactionId();
- TransactionScope transactionScope = activeTransactions.remove(transactionId);
- if (transactionScope == null) {
- return RollbackResult.UNKNOWN_TRANSACTION_ID;
- } else if (!transactionScope.isPrepared()) {
- return RollbackResult.OK;
- } else {
- transactionScope.transactionLog().records()
- .forEach(record -> {
- preparedKeys.remove(record.path());
- });
- return RollbackResult.OK;
- }
-
- }
-
- /**
- * Map transaction scope.
- */
- private static final class TransactionScope {
- private final long version;
- private final TransactionLog<NodeUpdate<byte[]>> transactionLog;
-
- private TransactionScope(long version) {
- this(version, null);
- }
-
- private TransactionScope(long version, TransactionLog<NodeUpdate<byte[]>> transactionLog) {
- this.version = version;
- this.transactionLog = transactionLog;
- }
-
- /**
- * Returns the transaction version.
- *
- * @return the transaction version
- */
- long version() {
- return version;
- }
-
- /**
- * Returns whether this is a prepared transaction scope.
- *
- * @return whether this is a prepared transaction scope
- */
- boolean isPrepared() {
- return transactionLog != null;
- }
-
- /**
- * Returns the transaction commit log.
- *
- * @return the transaction commit log
- */
- TransactionLog<NodeUpdate<byte[]>> transactionLog() {
- checkState(isPrepared(), "Transaction not prepared");
- return transactionLog;
- }
-
- /**
- * Returns a new transaction scope with a prepare commit.
- *
- * @param commit the prepare commit
- * @return new transaction scope updated with the prepare commit
- */
- TransactionScope prepared(Commit<? extends TransactionPrepare> commit) {
- return new TransactionScope(version, commit.value().transactionLog());
- }
- }
-
- private void publish(List<DocumentTreeEvent<byte[]>> events) {
- listeners.values().forEach(session -> {
- session.publish(CHANGE, events);
- });
- }
-
- private void notifyListeners(DocumentTreeEvent<byte[]> event) {
- listeners.values()
- .stream()
- .filter(l -> event.path().isDescendentOf(l.leastCommonAncestorPath()))
- .forEach(listener -> listener.publish(CHANGE, Arrays.asList(event)));
- }
-
- @Override
- public void onExpire(RaftSession session) {
- closeListener(session.sessionId().id());
- }
-
- @Override
- public void onClose(RaftSession session) {
- closeListener(session.sessionId().id());
- }
-
- private void closeListener(Long sessionId) {
- listeners.remove(sessionId);
- }
-
- private class SessionListenCommits {
- private final List<Listener> listeners = Lists.newArrayList();
- private DocumentPath leastCommonAncestorPath;
-
- public void add(Listener listener) {
- listeners.add(listener);
- recomputeLeastCommonAncestor();
- }
-
- public void remove(Commit<? extends Unlisten> commit) {
- // Remove the first listen commit with path matching path in unlisten commit
- Iterator<Listener> iterator = listeners.iterator();
- while (iterator.hasNext()) {
- Listener listener = iterator.next();
- if (listener.path().equals(commit.value().path())) {
- iterator.remove();
- }
- }
- recomputeLeastCommonAncestor();
- }
-
- public DocumentPath leastCommonAncestorPath() {
- return leastCommonAncestorPath;
- }
-
- public <M> void publish(EventType topic, M message) {
- listeners.stream().findAny().ifPresent(listener ->
- listener.session().publish(topic, serializer::encode, message));
- }
-
- private void recomputeLeastCommonAncestor() {
- this.leastCommonAncestorPath = DocumentPath.leastCommonAncestor(listeners.stream()
- .map(Listener::path)
- .collect(Collectors.toList()));
- }
- }
-
- private static class Listener {
- private final RaftSession session;
- private final DocumentPath path;
-
- public Listener(RaftSession session, DocumentPath path) {
- this.session = session;
- this.path = path;
- }
-
- public DocumentPath path() {
- return path;
- }
-
- public RaftSession session() {
- return session;
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixIdGenerator.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixIdGenerator.java
deleted file mode 100644
index 0fa6c7b..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixIdGenerator.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.atomic.AtomicLong;
-
-import org.onosproject.store.service.AsyncAtomicCounter;
-import org.onosproject.store.service.AsyncAtomicIdGenerator;
-
-/**
- * {@code AsyncAtomicIdGenerator} implementation backed by Atomix
- * {@link AsyncAtomicCounter}.
- */
-public class AtomixIdGenerator implements AsyncAtomicIdGenerator {
-
- private static final long DEFAULT_BATCH_SIZE = 1000;
- private final AsyncAtomicCounter counter;
- private final long batchSize;
- private CompletableFuture<Long> reserveFuture;
- private long base;
- private final AtomicLong delta = new AtomicLong();
-
- public AtomixIdGenerator(AsyncAtomicCounter counter) {
- this(counter, DEFAULT_BATCH_SIZE);
- }
-
- AtomixIdGenerator(AsyncAtomicCounter counter, long batchSize) {
- this.counter = counter;
- this.batchSize = batchSize;
- }
-
- @Override
- public String name() {
- return counter.name();
- }
-
- @Override
- public synchronized CompletableFuture<Long> nextId() {
- long nextDelta = delta.incrementAndGet();
- if ((base == 0 && reserveFuture == null) || nextDelta > batchSize) {
- delta.set(0);
- long delta = this.delta.incrementAndGet();
- return reserve().thenApply(base -> base + delta);
- } else {
- return reserveFuture.thenApply(base -> base + nextDelta);
- }
- }
-
- private CompletableFuture<Long> reserve() {
- if (reserveFuture == null || reserveFuture.isDone()) {
- reserveFuture = counter.getAndAdd(batchSize);
- } else {
- reserveFuture = reserveFuture.thenCompose(v -> counter.getAndAdd(batchSize));
- }
- reserveFuture = reserveFuture.thenApply(base -> {
- this.base = base;
- return base;
- });
- return reserveFuture;
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixLeaderElector.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixLeaderElector.java
deleted file mode 100644
index 53c7094..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixLeaderElector.java
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
-
-import com.google.common.collect.Sets;
-import io.atomix.protocols.raft.proxy.RaftProxy;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.cluster.Leadership;
-import org.onosproject.cluster.NodeId;
-import org.onosproject.event.Change;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.Anoint;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.GetElectedTopics;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.GetLeadership;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.Promote;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.Run;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.Withdraw;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.AsyncLeaderElector;
-import org.onosproject.store.service.Serializer;
-
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorEvents.CHANGE;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.ADD_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.ANOINT;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.EVICT;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.GET_ALL_LEADERSHIPS;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.GET_ELECTED_TOPICS;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.GET_LEADERSHIP;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.PROMOTE;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.REMOVE_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.RUN;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.WITHDRAW;
-
-/**
- * Distributed resource providing the {@link AsyncLeaderElector} primitive.
- */
-public class AtomixLeaderElector extends AbstractRaftPrimitive implements AsyncLeaderElector {
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.API)
- .register(AtomixLeaderElectorOperations.NAMESPACE)
- .register(AtomixLeaderElectorEvents.NAMESPACE)
- .build());
-
- private final Set<Consumer<Change<Leadership>>> leadershipChangeListeners = Sets.newCopyOnWriteArraySet();
-
- public AtomixLeaderElector(RaftProxy proxy) {
- super(proxy);
- proxy.addStateChangeListener(state -> {
- if (state == RaftProxy.State.CONNECTED && isListening()) {
- proxy.invoke(ADD_LISTENER);
- }
- });
- proxy.addEventListener(CHANGE, SERIALIZER::decode, this::handleEvent);
- }
-
- private void handleEvent(List<Change<Leadership>> changes) {
- changes.forEach(change -> leadershipChangeListeners.forEach(l -> l.accept(change)));
- }
-
- @Override
- public CompletableFuture<Leadership> run(String topic, NodeId nodeId) {
- return proxy.<Run, Leadership>invoke(RUN, SERIALIZER::encode, new Run(topic, nodeId), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Void> withdraw(String topic) {
- return proxy.invoke(WITHDRAW, SERIALIZER::encode, new Withdraw(topic));
- }
-
- @Override
- public CompletableFuture<Boolean> anoint(String topic, NodeId nodeId) {
- return proxy.<Anoint, Boolean>invoke(ANOINT, SERIALIZER::encode, new Anoint(topic, nodeId), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Boolean> promote(String topic, NodeId nodeId) {
- return proxy.<Promote, Boolean>invoke(
- PROMOTE, SERIALIZER::encode, new Promote(topic, nodeId), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Void> evict(NodeId nodeId) {
- return proxy.invoke(EVICT, SERIALIZER::encode, new AtomixLeaderElectorOperations.Evict(nodeId));
- }
-
- @Override
- public CompletableFuture<Leadership> getLeadership(String topic) {
- return proxy.invoke(GET_LEADERSHIP, SERIALIZER::encode, new GetLeadership(topic), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Map<String, Leadership>> getLeaderships() {
- return proxy.invoke(GET_ALL_LEADERSHIPS, SERIALIZER::decode);
- }
-
- public CompletableFuture<Set<String>> getElectedTopics(NodeId nodeId) {
- return proxy.invoke(GET_ELECTED_TOPICS, SERIALIZER::encode, new GetElectedTopics(nodeId), SERIALIZER::decode);
- }
-
- @Override
- public synchronized CompletableFuture<Void> addChangeListener(Consumer<Change<Leadership>> consumer) {
- if (leadershipChangeListeners.isEmpty()) {
- return proxy.invoke(ADD_LISTENER).thenRun(() -> leadershipChangeListeners.add(consumer));
- } else {
- leadershipChangeListeners.add(consumer);
- return CompletableFuture.completedFuture(null);
- }
- }
-
- @Override
- public synchronized CompletableFuture<Void> removeChangeListener(Consumer<Change<Leadership>> consumer) {
- if (leadershipChangeListeners.remove(consumer) && leadershipChangeListeners.isEmpty()) {
- return proxy.invoke(REMOVE_LISTENER).thenApply(v -> null);
- }
- return CompletableFuture.completedFuture(null);
- }
-
- private boolean isListening() {
- return !leadershipChangeListeners.isEmpty();
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixLeaderElectorEvents.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixLeaderElectorEvents.java
deleted file mode 100644
index 3c5a2c7..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixLeaderElectorEvents.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import io.atomix.protocols.raft.event.EventType;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-
-/**
- * Atomix leader elector events.
- */
-public enum AtomixLeaderElectorEvents implements EventType {
- CHANGE;
-
- @Override
- public String id() {
- return name();
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 50)
- .build("AtomixLeaderElectorEvents");
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixLeaderElectorOperations.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixLeaderElectorOperations.java
deleted file mode 100644
index c778cea..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixLeaderElectorOperations.java
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import com.google.common.base.MoreObjects;
-import io.atomix.protocols.raft.operation.OperationId;
-import io.atomix.protocols.raft.operation.OperationType;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.cluster.NodeId;
-import org.onosproject.store.serializers.KryoNamespaces;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * {@link AtomixLeaderElector} resource state machine operations.
- */
-public enum AtomixLeaderElectorOperations implements OperationId {
- ADD_LISTENER(OperationType.COMMAND),
- REMOVE_LISTENER(OperationType.COMMAND),
- RUN(OperationType.COMMAND),
- WITHDRAW(OperationType.COMMAND),
- ANOINT(OperationType.COMMAND),
- PROMOTE(OperationType.COMMAND),
- EVICT(OperationType.COMMAND),
- GET_LEADERSHIP(OperationType.QUERY),
- GET_ALL_LEADERSHIPS(OperationType.QUERY),
- GET_ELECTED_TOPICS(OperationType.QUERY);
-
- private final OperationType type;
-
- AtomixLeaderElectorOperations(OperationType type) {
- this.type = type;
- }
-
- @Override
- public String id() {
- return name();
- }
-
- @Override
- public OperationType type() {
- return type;
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .register(KryoNamespaces.API)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID)
- .register(Run.class)
- .register(Withdraw.class)
- .register(Anoint.class)
- .register(Promote.class)
- .register(Evict.class)
- .register(GetLeadership.class)
- .register(GetElectedTopics.class)
- .build("AtomixLeaderElectorOperations");
-
- /**
- * Abstract election query.
- */
- @SuppressWarnings("serial")
- public abstract static class ElectionOperation {
- }
-
- /**
- * Abstract election topic query.
- */
- @SuppressWarnings("serial")
- public abstract static class TopicOperation extends ElectionOperation {
- String topic;
-
- public TopicOperation() {
- }
-
- public TopicOperation(String topic) {
- this.topic = checkNotNull(topic);
- }
-
- /**
- * Returns the topic.
- * @return topic
- */
- public String topic() {
- return topic;
- }
- }
-
- /**
- * GetLeader query.
- */
- @SuppressWarnings("serial")
- public static class GetLeadership extends TopicOperation {
-
- public GetLeadership() {
- }
-
- public GetLeadership(String topic) {
- super(topic);
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("topic", topic)
- .toString();
- }
- }
-
- /**
- * GetElectedTopics query.
- */
- @SuppressWarnings("serial")
- public static class GetElectedTopics extends ElectionOperation {
- private NodeId nodeId;
-
- public GetElectedTopics() {
- }
-
- public GetElectedTopics(NodeId nodeId) {
- checkArgument(nodeId != null, "nodeId cannot be null");
- this.nodeId = nodeId;
- }
-
- /**
- * Returns the nodeId to check.
- *
- * @return The nodeId to check.
- */
- public NodeId nodeId() {
- return nodeId;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("nodeId", nodeId)
- .toString();
- }
- }
-
- /**
- * Enter and run for leadership.
- */
- @SuppressWarnings("serial")
- public static class Run extends ElectionOperation {
- private String topic;
- private NodeId nodeId;
-
- public Run() {
- }
-
- public Run(String topic, NodeId nodeId) {
- this.topic = topic;
- this.nodeId = nodeId;
- }
-
- /**
- * Returns the topic.
- *
- * @return topic
- */
- public String topic() {
- return topic;
- }
-
- /**
- * Returns the nodeId.
- *
- * @return the nodeId
- */
- public NodeId nodeId() {
- return nodeId;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("topic", topic)
- .add("nodeId", nodeId)
- .toString();
- }
- }
-
- /**
- * Withdraw from a leadership contest.
- */
- @SuppressWarnings("serial")
- public static class Withdraw extends ElectionOperation {
- private String topic;
-
- public Withdraw() {
- }
-
- public Withdraw(String topic) {
- this.topic = topic;
- }
-
- /**
- * Returns the topic.
- *
- * @return The topic
- */
- public String topic() {
- return topic;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("topic", topic)
- .toString();
- }
- }
-
- /**
- * Command for administratively changing the leadership state for a node.
- */
- @SuppressWarnings("serial")
- public abstract static class ElectionChangeOperation extends ElectionOperation {
- private String topic;
- private NodeId nodeId;
-
- ElectionChangeOperation() {
- topic = null;
- nodeId = null;
- }
-
- public ElectionChangeOperation(String topic, NodeId nodeId) {
- this.topic = topic;
- this.nodeId = nodeId;
- }
-
- /**
- * Returns the topic.
- *
- * @return The topic
- */
- public String topic() {
- return topic;
- }
-
- /**
- * Returns the nodeId to make leader.
- *
- * @return The nodeId
- */
- public NodeId nodeId() {
- return nodeId;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("topic", topic)
- .add("nodeId", nodeId)
- .toString();
- }
- }
-
- /**
- * Command for administratively anoint a node as leader.
- */
- @SuppressWarnings("serial")
- public static class Anoint extends ElectionChangeOperation {
-
- private Anoint() {
- }
-
- public Anoint(String topic, NodeId nodeId) {
- super(topic, nodeId);
- }
- }
-
- /**
- * Command for administratively promote a node as top candidate.
- */
- @SuppressWarnings("serial")
- public static class Promote extends ElectionChangeOperation {
-
- private Promote() {
- }
-
- public Promote(String topic, NodeId nodeId) {
- super(topic, nodeId);
- }
- }
-
- /**
- * Command for administratively evicting a node from all leadership topics.
- */
- @SuppressWarnings("serial")
- public static class Evict extends ElectionOperation {
- private NodeId nodeId;
-
- public Evict() {
- }
-
- public Evict(NodeId nodeId) {
- this.nodeId = nodeId;
- }
-
- /**
- * Returns the node identifier.
- *
- * @return The nodeId
- */
- public NodeId nodeId() {
- return nodeId;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("nodeId", nodeId)
- .toString();
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixLeaderElectorService.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixLeaderElectorService.java
deleted file mode 100644
index dcddcfc..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixLeaderElectorService.java
+++ /dev/null
@@ -1,539 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
-import com.google.common.base.MoreObjects;
-import com.google.common.base.Objects;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import io.atomix.protocols.raft.service.AbstractRaftService;
-import io.atomix.protocols.raft.service.Commit;
-import io.atomix.protocols.raft.service.RaftServiceExecutor;
-import io.atomix.protocols.raft.session.RaftSession;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotReader;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotWriter;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.cluster.Leader;
-import org.onosproject.cluster.Leadership;
-import org.onosproject.cluster.NodeId;
-import org.onosproject.event.Change;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.Anoint;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.Evict;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.GetElectedTopics;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.GetLeadership;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.Promote;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.Run;
-import org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.Withdraw;
-import org.onosproject.store.service.Serializer;
-
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorEvents.CHANGE;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.ADD_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.ANOINT;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.EVICT;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.GET_ALL_LEADERSHIPS;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.GET_ELECTED_TOPICS;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.GET_LEADERSHIP;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.PROMOTE;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.REMOVE_LISTENER;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.RUN;
-import static org.onosproject.store.primitives.resources.impl.AtomixLeaderElectorOperations.WITHDRAW;
-
-/**
- * State machine for {@link AtomixLeaderElector} resource.
- */
-public class AtomixLeaderElectorService extends AbstractRaftService {
-
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(AtomixLeaderElectorOperations.NAMESPACE)
- .register(AtomixLeaderElectorEvents.NAMESPACE)
- .register(ElectionState.class)
- .register(Registration.class)
- .register(new LinkedHashMap<>().keySet().getClass())
- .build());
-
- private Map<String, AtomicLong> termCounters = new HashMap<>();
- private Map<String, ElectionState> elections = new HashMap<>();
- private Map<Long, RaftSession> listeners = new LinkedHashMap<>();
-
- @Override
- public void snapshot(SnapshotWriter writer) {
- writer.writeObject(Sets.newHashSet(listeners.keySet()), SERIALIZER::encode);
- writer.writeObject(termCounters, SERIALIZER::encode);
- writer.writeObject(elections, SERIALIZER::encode);
- logger().debug("Took state machine snapshot");
- }
-
- @Override
- public void install(SnapshotReader reader) {
- listeners = new LinkedHashMap<>();
- for (Long sessionId : reader.<Set<Long>>readObject(SERIALIZER::decode)) {
- listeners.put(sessionId, sessions().getSession(sessionId));
- }
- termCounters = reader.readObject(SERIALIZER::decode);
- elections = reader.readObject(SERIALIZER::decode);
- logger().debug("Reinstated state machine from snapshot");
- }
-
- @Override
- protected void configure(RaftServiceExecutor executor) {
- // Notification
- executor.register(ADD_LISTENER, this::listen);
- executor.register(REMOVE_LISTENER, this::unlisten);
- // Commands
- executor.register(RUN, SERIALIZER::decode, this::run, SERIALIZER::encode);
- executor.register(WITHDRAW, SERIALIZER::decode, this::withdraw);
- executor.register(ANOINT, SERIALIZER::decode, this::anoint, SERIALIZER::encode);
- executor.register(PROMOTE, SERIALIZER::decode, this::promote, SERIALIZER::encode);
- executor.register(EVICT, SERIALIZER::decode, this::evict);
- // Queries
- executor.register(GET_LEADERSHIP, SERIALIZER::decode, this::getLeadership, SERIALIZER::encode);
- executor.register(GET_ALL_LEADERSHIPS, this::allLeaderships, SERIALIZER::encode);
- executor.register(GET_ELECTED_TOPICS, SERIALIZER::decode, this::electedTopics, SERIALIZER::encode);
- }
-
- private void notifyLeadershipChange(Leadership previousLeadership, Leadership newLeadership) {
- notifyLeadershipChanges(Lists.newArrayList(new Change<>(previousLeadership, newLeadership)));
- }
-
- private void notifyLeadershipChanges(List<Change<Leadership>> changes) {
- if (changes.isEmpty()) {
- return;
- }
- listeners.values().forEach(session -> session.publish(CHANGE, SERIALIZER::encode, changes));
- }
-
- /**
- * Applies listen commits.
- *
- * @param commit listen commit
- */
- public void listen(Commit<Void> commit) {
- listeners.put(commit.session().sessionId().id(), commit.session());
- }
-
- /**
- * Applies unlisten commits.
- *
- * @param commit unlisten commit
- */
- public void unlisten(Commit<Void> commit) {
- listeners.remove(commit.session().sessionId().id());
- }
-
- /**
- * Applies an {@link AtomixLeaderElectorOperations.Run} commit.
- * @param commit commit entry
- * @return topic leader. If no previous leader existed this is the node that just entered the race.
- */
- public Leadership run(Commit<? extends Run> commit) {
- try {
- String topic = commit.value().topic();
- Leadership oldLeadership = leadership(topic);
- Registration registration = new Registration(commit.value().nodeId(), commit.session().sessionId().id());
- elections.compute(topic, (k, v) -> {
- if (v == null) {
- return new ElectionState(registration, termCounter(topic)::incrementAndGet);
- } else {
- if (!v.isDuplicate(registration)) {
- return new ElectionState(v).addRegistration(registration, termCounter(topic)::incrementAndGet);
- } else {
- return v;
- }
- }
- });
- Leadership newLeadership = leadership(topic);
-
- if (!Objects.equal(oldLeadership, newLeadership)) {
- notifyLeadershipChange(oldLeadership, newLeadership);
- }
- return newLeadership;
- } catch (Exception e) {
- logger().error("State machine operation failed", e);
- throw new IllegalStateException(e);
- }
- }
-
- /**
- * Applies an {@link AtomixLeaderElectorOperations.Withdraw} commit.
- * @param commit withdraw commit
- */
- public void withdraw(Commit<? extends Withdraw> commit) {
- try {
- String topic = commit.value().topic();
- Leadership oldLeadership = leadership(topic);
- elections.computeIfPresent(topic, (k, v) -> v.cleanup(commit.session(),
- termCounter(topic)::incrementAndGet));
- Leadership newLeadership = leadership(topic);
- if (!Objects.equal(oldLeadership, newLeadership)) {
- notifyLeadershipChange(oldLeadership, newLeadership);
- }
- } catch (Exception e) {
- logger().error("State machine operation failed", e);
- throw new IllegalStateException(e);
- }
- }
-
- /**
- * Applies an {@link AtomixLeaderElectorOperations.Anoint} commit.
- * @param commit anoint commit
- * @return {@code true} if changes were made and the transfer occurred; {@code false} if it did not.
- */
- public boolean anoint(Commit<? extends Anoint> commit) {
- try {
- String topic = commit.value().topic();
- NodeId nodeId = commit.value().nodeId();
- Leadership oldLeadership = leadership(topic);
- ElectionState electionState = elections.computeIfPresent(topic,
- (k, v) -> v.transferLeadership(nodeId, termCounter(topic)));
- Leadership newLeadership = leadership(topic);
- if (!Objects.equal(oldLeadership, newLeadership)) {
- notifyLeadershipChange(oldLeadership, newLeadership);
- }
- return (electionState != null &&
- electionState.leader() != null &&
- commit.value().nodeId().equals(electionState.leader().nodeId()));
- } catch (Exception e) {
- logger().error("State machine operation failed", e);
- throw new IllegalStateException(e);
- }
- }
-
- /**
- * Applies an {@link AtomixLeaderElectorOperations.Promote} commit.
- * @param commit promote commit
- * @return {@code true} if changes desired end state is achieved.
- */
- public boolean promote(Commit<? extends Promote> commit) {
- try {
- String topic = commit.value().topic();
- NodeId nodeId = commit.value().nodeId();
- Leadership oldLeadership = leadership(topic);
- if (oldLeadership == null || !oldLeadership.candidates().contains(nodeId)) {
- return false;
- }
- elections.computeIfPresent(topic, (k, v) -> v.promote(nodeId));
- Leadership newLeadership = leadership(topic);
- if (!Objects.equal(oldLeadership, newLeadership)) {
- notifyLeadershipChange(oldLeadership, newLeadership);
- }
- return true;
- } catch (Exception e) {
- logger().error("State machine operation failed", e);
- throw new IllegalStateException(e);
- }
- }
-
- /**
- * Applies an {@link AtomixLeaderElectorOperations.Evict} commit.
- * @param commit evict commit
- */
- public void evict(Commit<? extends Evict> commit) {
- try {
- List<Change<Leadership>> changes = Lists.newArrayList();
- NodeId nodeId = commit.value().nodeId();
- Set<String> topics = Maps.filterValues(elections, e -> e.candidates().contains(nodeId)).keySet();
- topics.forEach(topic -> {
- Leadership oldLeadership = leadership(topic);
- elections.compute(topic, (k, v) -> v.evict(nodeId, termCounter(topic)::incrementAndGet));
- Leadership newLeadership = leadership(topic);
- if (!Objects.equal(oldLeadership, newLeadership)) {
- changes.add(new Change<>(oldLeadership, newLeadership));
- }
- });
- notifyLeadershipChanges(changes);
- } catch (Exception e) {
- logger().error("State machine operation failed", e);
- throw new IllegalStateException(e);
- }
- }
-
- /**
- * Applies an {@link AtomixLeaderElectorOperations.GetLeadership} commit.
- * @param commit GetLeadership commit
- * @return leader
- */
- public Leadership getLeadership(Commit<? extends GetLeadership> commit) {
- String topic = commit.value().topic();
- try {
- return leadership(topic);
- } catch (Exception e) {
- logger().error("State machine operation failed", e);
- throw new IllegalStateException(e);
- }
- }
-
- /**
- * Applies an {@link AtomixLeaderElectorOperations.GetElectedTopics} commit.
- * @param commit commit entry
- * @return set of topics for which the node is the leader
- */
- public Set<String> electedTopics(Commit<? extends GetElectedTopics> commit) {
- try {
- NodeId nodeId = commit.value().nodeId();
- return ImmutableSet.copyOf(Maps.filterEntries(elections, e -> {
- Leader leader = leadership(e.getKey()).leader();
- return leader != null && leader.nodeId().equals(nodeId);
- }).keySet());
- } catch (Exception e) {
- logger().error("State machine operation failed", e);
- throw new IllegalStateException(e);
- }
- }
-
- /**
- * Applies an {@link AtomixLeaderElectorOperations#GET_ALL_LEADERSHIPS} commit.
- * @param commit GetAllLeaderships commit
- * @return topic to leader mapping
- */
- public Map<String, Leadership> allLeaderships(Commit<Void> commit) {
- Map<String, Leadership> result = new HashMap<>();
- try {
- result.putAll(Maps.transformEntries(elections, (k, v) -> leadership(k)));
- return result;
- } catch (Exception e) {
- logger().error("State machine operation failed", e);
- throw new IllegalStateException(e);
- }
- }
-
- private Leadership leadership(String topic) {
- return new Leadership(topic,
- leader(topic),
- candidates(topic));
- }
-
- private Leader leader(String topic) {
- ElectionState electionState = elections.get(topic);
- return electionState == null ? null : electionState.leader();
- }
-
- private List<NodeId> candidates(String topic) {
- ElectionState electionState = elections.get(topic);
- return electionState == null ? new LinkedList<>() : electionState.candidates();
- }
-
- private void onSessionEnd(RaftSession session) {
- listeners.remove(session.sessionId().id());
- Set<String> topics = ImmutableSet.copyOf(elections.keySet());
- List<Change<Leadership>> changes = Lists.newArrayList();
- for (String topic: topics) {
- Leadership oldLeadership = leadership(topic);
- elections.compute(topic, (k, v) -> v.cleanup(session, termCounter(topic)::incrementAndGet));
- Leadership newLeadership = leadership(topic);
- if (!Objects.equal(oldLeadership, newLeadership)) {
- changes.add(new Change<>(oldLeadership, newLeadership));
- }
- }
- notifyLeadershipChanges(changes);
- }
-
- private static class Registration {
- private final NodeId nodeId;
- private final long sessionId;
-
- public Registration(NodeId nodeId, long sessionId) {
- this.nodeId = nodeId;
- this.sessionId = sessionId;
- }
-
- public NodeId nodeId() {
- return nodeId;
- }
-
- public long sessionId() {
- return sessionId;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("nodeId", nodeId)
- .add("sessionId", sessionId)
- .toString();
- }
- }
-
- private static class ElectionState {
- final Registration leader;
- final long term;
- final long termStartTime;
- final List<Registration> registrations;
-
- public ElectionState(Registration registration, Supplier<Long> termCounter) {
- registrations = Arrays.asList(registration);
- term = termCounter.get();
- termStartTime = System.currentTimeMillis();
- leader = registration;
- }
-
- public ElectionState(ElectionState other) {
- registrations = Lists.newArrayList(other.registrations);
- leader = other.leader;
- term = other.term;
- termStartTime = other.termStartTime;
- }
-
- public ElectionState(List<Registration> registrations,
- Registration leader,
- long term,
- long termStartTime) {
- this.registrations = Lists.newArrayList(registrations);
- this.leader = leader;
- this.term = term;
- this.termStartTime = termStartTime;
- }
-
- public ElectionState cleanup(RaftSession session, Supplier<Long> termCounter) {
- Optional<Registration> registration =
- registrations.stream().filter(r -> r.sessionId() == session.sessionId().id()).findFirst();
- if (registration.isPresent()) {
- List<Registration> updatedRegistrations =
- registrations.stream()
- .filter(r -> r.sessionId() != session.sessionId().id())
- .collect(Collectors.toList());
- if (leader.sessionId() == session.sessionId().id()) {
- if (!updatedRegistrations.isEmpty()) {
- return new ElectionState(updatedRegistrations,
- updatedRegistrations.get(0),
- termCounter.get(),
- System.currentTimeMillis());
- } else {
- return new ElectionState(updatedRegistrations, null, term, termStartTime);
- }
- } else {
- return new ElectionState(updatedRegistrations, leader, term, termStartTime);
- }
- } else {
- return this;
- }
- }
-
- public ElectionState evict(NodeId nodeId, Supplier<Long> termCounter) {
- Optional<Registration> registration =
- registrations.stream().filter(r -> r.nodeId.equals(nodeId)).findFirst();
- if (registration.isPresent()) {
- List<Registration> updatedRegistrations =
- registrations.stream()
- .filter(r -> !r.nodeId().equals(nodeId))
- .collect(Collectors.toList());
- if (leader.nodeId().equals(nodeId)) {
- if (!updatedRegistrations.isEmpty()) {
- return new ElectionState(updatedRegistrations,
- updatedRegistrations.get(0),
- termCounter.get(),
- System.currentTimeMillis());
- } else {
- return new ElectionState(updatedRegistrations, null, term, termStartTime);
- }
- } else {
- return new ElectionState(updatedRegistrations, leader, term, termStartTime);
- }
- } else {
- return this;
- }
- }
-
- public boolean isDuplicate(Registration registration) {
- return registrations.stream().anyMatch(r -> r.sessionId() == registration.sessionId());
- }
-
- public Leader leader() {
- if (leader == null) {
- return null;
- } else {
- NodeId leaderNodeId = leader.nodeId();
- return new Leader(leaderNodeId, term, termStartTime);
- }
- }
-
- public List<NodeId> candidates() {
- return registrations.stream().map(registration -> registration.nodeId()).collect(Collectors.toList());
- }
-
- public ElectionState addRegistration(Registration registration, Supplier<Long> termCounter) {
- if (!registrations.stream().anyMatch(r -> r.sessionId() == registration.sessionId())) {
- List<Registration> updatedRegistrations = new LinkedList<>(registrations);
- updatedRegistrations.add(registration);
- boolean newLeader = leader == null;
- return new ElectionState(updatedRegistrations,
- newLeader ? registration : leader,
- newLeader ? termCounter.get() : term,
- newLeader ? System.currentTimeMillis() : termStartTime);
- }
- return this;
- }
-
- public ElectionState transferLeadership(NodeId nodeId, AtomicLong termCounter) {
- Registration newLeader = registrations.stream()
- .filter(r -> r.nodeId().equals(nodeId))
- .findFirst()
- .orElse(null);
- if (newLeader != null) {
- return new ElectionState(registrations,
- newLeader,
- termCounter.incrementAndGet(),
- System.currentTimeMillis());
- } else {
- return this;
- }
- }
-
- public ElectionState promote(NodeId nodeId) {
- Registration registration = registrations.stream()
- .filter(r -> r.nodeId().equals(nodeId))
- .findFirst()
- .orElse(null);
- List<Registration> updatedRegistrations = Lists.newArrayList();
- updatedRegistrations.add(registration);
- registrations.stream()
- .filter(r -> !r.nodeId().equals(nodeId))
- .forEach(updatedRegistrations::add);
- return new ElectionState(updatedRegistrations,
- leader,
- term,
- termStartTime);
-
- }
- }
-
- @Override
- public void onExpire(RaftSession session) {
- onSessionEnd(session);
- }
-
- @Override
- public void onClose(RaftSession session) {
- onSessionEnd(session);
- }
-
- private AtomicLong termCounter(String topic) {
- return termCounters.computeIfAbsent(topic, k -> new AtomicLong(0));
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixValue.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixValue.java
deleted file mode 100644
index a4cdd52..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixValue.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-
-import org.onlab.util.Tools;
-import org.onosproject.store.service.AsyncAtomicValue;
-import org.onosproject.store.service.AtomicValueEvent;
-import org.onosproject.store.service.AtomicValueEventListener;
-import org.onosproject.store.service.MapEventListener;
-import org.onosproject.store.service.Versioned;
-
-import com.google.common.collect.Sets;
-
-/**
- * Implementation of {@link AsyncAtomicValue} backed by {@link AtomixConsistentMap}.
- */
-public class AtomixValue implements AsyncAtomicValue<String> {
-
- private final String name;
- private final AtomixConsistentMap atomixMap;
- private MapEventListener<String, byte[]> mapEventListener;
- private final Set<AtomicValueEventListener<String>> listeners = Sets.newIdentityHashSet();
-
- AtomixValue(String name, AtomixConsistentMap atomixMap) {
- this.name = name;
- this.atomixMap = atomixMap;
- }
-
- @Override
- public CompletableFuture<Boolean> compareAndSet(String expect, String update) {
- return atomixMap.replace(name, Tools.getBytesUtf8(expect), Tools.getBytesUtf8(update));
- }
-
- @Override
- public CompletableFuture<String> get() {
- return atomixMap.get(name)
- .thenApply(v -> v != null ? Tools.toStringUtf8(v.value()) : null);
- }
-
- @Override
- public CompletableFuture<String> getAndSet(String value) {
- return atomixMap.put(name, Tools.getBytesUtf8(value))
- .thenApply(v -> v != null ? Tools.toStringUtf8(v.value()) : null);
- }
-
- @Override
- public CompletableFuture<Void> set(String value) {
- return getAndSet(value).thenApply(v -> null);
- }
-
- @Override
- public CompletableFuture<Void> addListener(AtomicValueEventListener<String> listener) {
- // TODO: synchronization
- if (mapEventListener == null) {
- mapEventListener = event -> {
- Versioned<byte[]> newValue = event.newValue();
- Versioned<byte[]> oldValue = event.oldValue();
- if (Objects.equals(event.key(), name)) {
- listener.event(new AtomicValueEvent<>(name,
- newValue == null ? null : Tools.toStringUtf8(newValue.value()),
- oldValue == null ? null : Tools.toStringUtf8(oldValue.value())));
- }
- };
- return atomixMap.addListener(mapEventListener).whenComplete((r, e) -> {
- if (e == null) {
- listeners.add(listener);
- } else {
- mapEventListener = null;
- }
- });
- } else {
- listeners.add(listener);
- return CompletableFuture.completedFuture(null);
- }
- }
-
- @Override
- public CompletableFuture<Void> removeListener(AtomicValueEventListener<String> listener) {
- // TODO: synchronization
- listeners.remove(listener);
- if (listeners.isEmpty()) {
- return atomixMap.removeListener(mapEventListener);
- } else {
- return CompletableFuture.completedFuture(null);
- }
- }
-
- @Override
- public String name() {
- return null;
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixWorkQueue.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixWorkQueue.java
deleted file mode 100644
index 73bc802..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixWorkQueue.java
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Timer;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Consumer;
-
-import com.google.common.collect.ImmutableList;
-import io.atomix.protocols.raft.proxy.RaftProxy;
-import org.onlab.util.AbstractAccumulator;
-import org.onlab.util.Accumulator;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.Add;
-import org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.Complete;
-import org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.Take;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.Task;
-import org.onosproject.store.service.WorkQueue;
-import org.onosproject.store.service.WorkQueueStats;
-import org.slf4j.Logger;
-
-import static java.util.concurrent.Executors.newSingleThreadExecutor;
-import static org.onlab.util.Tools.groupedThreads;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueEvents.TASK_AVAILABLE;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.ADD;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.CLEAR;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.COMPLETE;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.REGISTER;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.STATS;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.TAKE;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.UNREGISTER;
-import static org.slf4j.LoggerFactory.getLogger;
-
-/**
- * Distributed resource providing the {@link WorkQueue} primitive.
- */
-public class AtomixWorkQueue extends AbstractRaftPrimitive implements WorkQueue<byte[]> {
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixWorkQueueOperations.NAMESPACE)
- .register(AtomixWorkQueueEvents.NAMESPACE)
- .build());
-
- private final Logger log = getLogger(getClass());
- private final ExecutorService executor = newSingleThreadExecutor(groupedThreads("AtomixWorkQueue", "%d", log));
- private final AtomicReference<TaskProcessor> taskProcessor = new AtomicReference<>();
- private final Timer timer = new Timer("atomix-work-queue-completer");
- private final AtomicBoolean isRegistered = new AtomicBoolean(false);
-
- public AtomixWorkQueue(RaftProxy proxy) {
- super(proxy);
- proxy.addStateChangeListener(state -> {
- if (state == RaftProxy.State.CONNECTED && isRegistered.get()) {
- proxy.invoke(REGISTER);
- }
- });
- proxy.addEventListener(TASK_AVAILABLE, this::resumeWork);
- }
-
- @Override
- public CompletableFuture<Void> destroy() {
- executor.shutdown();
- timer.cancel();
- return proxy.invoke(CLEAR);
- }
-
- @Override
- public CompletableFuture<Void> addMultiple(Collection<byte[]> items) {
- if (items.isEmpty()) {
- return CompletableFuture.completedFuture(null);
- }
- return proxy.invoke(ADD, SERIALIZER::encode, new Add(items));
- }
-
- @Override
- public CompletableFuture<Collection<Task<byte[]>>> take(int maxTasks) {
- if (maxTasks <= 0) {
- return CompletableFuture.completedFuture(ImmutableList.of());
- }
- return proxy.invoke(TAKE, SERIALIZER::encode, new Take(maxTasks), SERIALIZER::decode);
- }
-
- @Override
- public CompletableFuture<Void> complete(Collection<String> taskIds) {
- if (taskIds.isEmpty()) {
- return CompletableFuture.completedFuture(null);
- }
- return proxy.invoke(COMPLETE, SERIALIZER::encode, new Complete(taskIds));
- }
-
- @Override
- public CompletableFuture<Void> registerTaskProcessor(Consumer<byte[]> callback,
- int parallelism,
- Executor executor) {
- Accumulator<String> completedTaskAccumulator =
- new CompletedTaskAccumulator(timer, 50, 50); // TODO: make configurable
- taskProcessor.set(new TaskProcessor(callback,
- parallelism,
- executor,
- completedTaskAccumulator));
- return register().thenCompose(v -> take(parallelism))
- .thenAccept(taskProcessor.get());
- }
-
- @Override
- public CompletableFuture<Void> stopProcessing() {
- return unregister();
- }
-
- @Override
- public CompletableFuture<WorkQueueStats> stats() {
- return proxy.invoke(STATS, SERIALIZER::decode);
- }
-
- private void resumeWork() {
- TaskProcessor activeProcessor = taskProcessor.get();
- if (activeProcessor == null) {
- return;
- }
- this.take(activeProcessor.headRoom())
- .whenCompleteAsync((tasks, e) -> activeProcessor.accept(tasks), executor);
- }
-
- private CompletableFuture<Void> register() {
- return proxy.invoke(REGISTER).thenRun(() -> isRegistered.set(true));
- }
-
- private CompletableFuture<Void> unregister() {
- return proxy.invoke(UNREGISTER).thenRun(() -> isRegistered.set(false));
- }
-
- // TaskId accumulator for paced triggering of task completion calls.
- private class CompletedTaskAccumulator extends AbstractAccumulator<String> {
- CompletedTaskAccumulator(Timer timer, int maxTasksToBatch, int maxBatchMillis) {
- super(timer, maxTasksToBatch, maxBatchMillis, Integer.MAX_VALUE);
- }
-
- @Override
- public void processItems(List<String> items) {
- complete(items);
- }
- }
-
- private class TaskProcessor implements Consumer<Collection<Task<byte[]>>> {
-
- private final AtomicInteger headRoom;
- private final Consumer<byte[]> backingConsumer;
- private final Executor executor;
- private final Accumulator<String> taskCompleter;
-
- public TaskProcessor(Consumer<byte[]> backingConsumer,
- int parallelism,
- Executor executor,
- Accumulator<String> taskCompleter) {
- this.backingConsumer = backingConsumer;
- this.headRoom = new AtomicInteger(parallelism);
- this.executor = executor;
- this.taskCompleter = taskCompleter;
- }
-
- public int headRoom() {
- return headRoom.get();
- }
-
- @Override
- public void accept(Collection<Task<byte[]>> tasks) {
- if (tasks == null) {
- return;
- }
- headRoom.addAndGet(-1 * tasks.size());
- tasks.forEach(task ->
- executor.execute(() -> {
- try {
- backingConsumer.accept(task.payload());
- taskCompleter.add(task.taskId());
- } catch (Exception e) {
- log.debug("Task execution failed", e);
- } finally {
- headRoom.incrementAndGet();
- resumeWork();
- }
- }));
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixWorkQueueEvents.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixWorkQueueEvents.java
deleted file mode 100644
index 5458300..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixWorkQueueEvents.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import io.atomix.protocols.raft.event.EventType;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-
-/**
- * Atomix work queue events.
- */
-public enum AtomixWorkQueueEvents implements EventType {
- TASK_AVAILABLE;
-
- @Override
- public String id() {
- return name();
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 50)
- .build("AtomixWorkQueueEvents");
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixWorkQueueOperations.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixWorkQueueOperations.java
deleted file mode 100644
index 2452cf8..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixWorkQueueOperations.java
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.Collection;
-
-import com.google.common.base.MoreObjects;
-import io.atomix.protocols.raft.operation.OperationId;
-import io.atomix.protocols.raft.operation.OperationType;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.Task;
-import org.onosproject.store.service.WorkQueueStats;
-
-/**
- * {@link AtomixWorkQueue} resource state machine operations.
- */
-public enum AtomixWorkQueueOperations implements OperationId {
- STATS(OperationType.QUERY),
- REGISTER(OperationType.COMMAND),
- UNREGISTER(OperationType.COMMAND),
- ADD(OperationType.COMMAND),
- TAKE(OperationType.COMMAND),
- COMPLETE(OperationType.COMMAND),
- CLEAR(OperationType.COMMAND);
-
- private final OperationType type;
-
- AtomixWorkQueueOperations(OperationType type) {
- this.type = type;
- }
-
- @Override
- public String id() {
- return name();
- }
-
- @Override
- public OperationType type() {
- return type;
- }
-
- public static final KryoNamespace NAMESPACE = KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID)
- .register(Add.class)
- .register(Take.class)
- .register(Complete.class)
- .register(Task.class)
- .register(WorkQueueStats.class)
- .build("AtomixWorkQueueOperations");
-
- /**
- * Work queue operation.
- */
- public abstract static class WorkQueueOperation {
- }
-
- /**
- * Command to add a collection of tasks to the queue.
- */
- @SuppressWarnings("serial")
- public static class Add extends WorkQueueOperation {
- private Collection<byte[]> items;
-
- private Add() {
- }
-
- public Add(Collection<byte[]> items) {
- this.items = items;
- }
-
- public Collection<byte[]> items() {
- return items;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("items", items)
- .toString();
- }
- }
-
- /**
- * Command to take a task from the queue.
- */
- @SuppressWarnings("serial")
- public static class Take extends WorkQueueOperation {
- private int maxTasks;
-
- private Take() {
- }
-
- public Take(int maxTasks) {
- this.maxTasks = maxTasks;
- }
-
- public int maxTasks() {
- return maxTasks;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("maxTasks", maxTasks)
- .toString();
- }
- }
-
- @SuppressWarnings("serial")
- public static class Complete extends WorkQueueOperation {
- private Collection<String> taskIds;
-
- private Complete() {
- }
-
- public Complete(Collection<String> taskIds) {
- this.taskIds = taskIds;
- }
-
- public Collection<String> taskIds() {
- return taskIds;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("taskIds", taskIds)
- .toString();
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixWorkQueueService.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixWorkQueueService.java
deleted file mode 100644
index 4540aa5..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixWorkQueueService.java
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Queue;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-
-import com.google.common.base.MoreObjects;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Queues;
-import com.google.common.collect.Sets;
-import io.atomix.protocols.raft.service.AbstractRaftService;
-import io.atomix.protocols.raft.service.Commit;
-import io.atomix.protocols.raft.service.RaftServiceExecutor;
-import io.atomix.protocols.raft.session.RaftSession;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotReader;
-import io.atomix.protocols.raft.storage.snapshot.SnapshotWriter;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.Add;
-import org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.Complete;
-import org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.Take;
-import org.onosproject.store.serializers.KryoNamespaces;
-import org.onosproject.store.service.Serializer;
-import org.onosproject.store.service.Task;
-import org.onosproject.store.service.WorkQueueStats;
-
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueEvents.TASK_AVAILABLE;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.ADD;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.CLEAR;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.COMPLETE;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.REGISTER;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.STATS;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.TAKE;
-import static org.onosproject.store.primitives.resources.impl.AtomixWorkQueueOperations.UNREGISTER;
-
-/**
- * State machine for {@link AtomixWorkQueue} resource.
- */
-public class AtomixWorkQueueService extends AbstractRaftService {
-
- private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.newBuilder()
- .register(KryoNamespaces.BASIC)
- .register(AtomixWorkQueueOperations.NAMESPACE)
- .register(AtomixWorkQueueEvents.NAMESPACE)
- .register(TaskAssignment.class)
- .register(new HashMap().keySet().getClass())
- .register(ArrayDeque.class)
- .build());
-
- private final AtomicLong totalCompleted = new AtomicLong(0);
-
- private Queue<Task<byte[]>> unassignedTasks = Queues.newArrayDeque();
- private Map<String, TaskAssignment> assignments = Maps.newHashMap();
- private Map<Long, RaftSession> registeredWorkers = Maps.newHashMap();
-
- @Override
- public void snapshot(SnapshotWriter writer) {
- writer.writeObject(Sets.newHashSet(registeredWorkers.keySet()), SERIALIZER::encode);
- writer.writeObject(assignments, SERIALIZER::encode);
- writer.writeObject(unassignedTasks, SERIALIZER::encode);
- writer.writeLong(totalCompleted.get());
- }
-
- @Override
- public void install(SnapshotReader reader) {
- registeredWorkers = Maps.newHashMap();
- for (Long sessionId : reader.<Set<Long>>readObject(SERIALIZER::decode)) {
- registeredWorkers.put(sessionId, sessions().getSession(sessionId));
- }
- assignments = reader.readObject(SERIALIZER::decode);
- unassignedTasks = reader.readObject(SERIALIZER::decode);
- totalCompleted.set(reader.readLong());
- }
-
- @Override
- protected void configure(RaftServiceExecutor executor) {
- executor.register(STATS, this::stats, SERIALIZER::encode);
- executor.register(REGISTER, this::register);
- executor.register(UNREGISTER, this::unregister);
- executor.register(ADD, SERIALIZER::decode, this::add);
- executor.register(TAKE, SERIALIZER::decode, this::take, SERIALIZER::encode);
- executor.register(COMPLETE, SERIALIZER::decode, this::complete);
- executor.register(CLEAR, this::clear);
- }
-
- protected WorkQueueStats stats(Commit<Void> commit) {
- return WorkQueueStats.builder()
- .withTotalCompleted(totalCompleted.get())
- .withTotalPending(unassignedTasks.size())
- .withTotalInProgress(assignments.size())
- .build();
- }
-
- protected void clear(Commit<Void> commit) {
- unassignedTasks.clear();
- assignments.clear();
- registeredWorkers.clear();
- totalCompleted.set(0);
- }
-
- protected void register(Commit<Void> commit) {
- registeredWorkers.put(commit.session().sessionId().id(), commit.session());
- }
-
- protected void unregister(Commit<Void> commit) {
- registeredWorkers.remove(commit.session().sessionId().id());
- }
-
- protected void add(Commit<? extends Add> commit) {
- Collection<byte[]> items = commit.value().items();
-
- AtomicInteger itemIndex = new AtomicInteger(0);
- items.forEach(item -> {
- String taskId = String.format("%d:%d:%d", commit.session().sessionId().id(),
- commit.index(),
- itemIndex.getAndIncrement());
- unassignedTasks.add(new Task<>(taskId, item));
- });
-
- // Send an event to all sessions that have expressed interest in task processing
- // and are not actively processing a task.
- registeredWorkers.values().forEach(session -> session.publish(TASK_AVAILABLE));
- // FIXME: This generates a lot of event traffic.
- }
-
- protected Collection<Task<byte[]>> take(Commit<? extends Take> commit) {
- try {
- if (unassignedTasks.isEmpty()) {
- return ImmutableList.of();
- }
- long sessionId = commit.session().sessionId().id();
- int maxTasks = commit.value().maxTasks();
- return IntStream.range(0, Math.min(maxTasks, unassignedTasks.size()))
- .mapToObj(i -> {
- Task<byte[]> task = unassignedTasks.poll();
- String taskId = task.taskId();
- TaskAssignment assignment = new TaskAssignment(sessionId, task);
-
- // bookkeeping
- assignments.put(taskId, assignment);
-
- return task;
- })
- .collect(Collectors.toCollection(ArrayList::new));
- } catch (Exception e) {
- logger().warn("State machine update failed", e);
- throw new IllegalStateException(e);
- }
- }
-
- protected void complete(Commit<? extends Complete> commit) {
- long sessionId = commit.session().sessionId().id();
- try {
- commit.value().taskIds().forEach(taskId -> {
- TaskAssignment assignment = assignments.get(taskId);
- if (assignment != null && assignment.sessionId() == sessionId) {
- assignments.remove(taskId);
- // bookkeeping
- totalCompleted.incrementAndGet();
- }
- });
- } catch (Exception e) {
- logger().warn("State machine update failed", e);
- throw new IllegalStateException(e);
- }
- }
-
- @Override
- public void onExpire(RaftSession session) {
- evictWorker(session.sessionId().id());
- }
-
- @Override
- public void onClose(RaftSession session) {
- evictWorker(session.sessionId().id());
- }
-
- private void evictWorker(long sessionId) {
- registeredWorkers.remove(sessionId);
-
- // TODO: Maintain an index of tasks by session for efficient access.
- Iterator<Map.Entry<String, TaskAssignment>> iter = assignments.entrySet().iterator();
- while (iter.hasNext()) {
- Map.Entry<String, TaskAssignment> entry = iter.next();
- TaskAssignment assignment = entry.getValue();
- if (assignment.sessionId() == sessionId) {
- unassignedTasks.add(assignment.task());
- iter.remove();
- }
- }
- }
-
- private static class TaskAssignment {
- private final long sessionId;
- private final Task<byte[]> task;
-
- public TaskAssignment(long sessionId, Task<byte[]> task) {
- this.sessionId = sessionId;
- this.task = task;
- }
-
- public long sessionId() {
- return sessionId;
- }
-
- public Task<byte[]> task() {
- return task;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("sessionId", sessionId)
- .add("task", task)
- .toString();
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/CommitResult.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/CommitResult.java
deleted file mode 100644
index 5b1da77..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/CommitResult.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-/**
- * Response enum for two phase commit operation.
- */
-public enum CommitResult {
- /**
- * Signifies a successful commit execution.
- */
- OK,
-
- /**
- * Signifies a failure due to unrecognized transaction identifier.
- */
- UNKNOWN_TRANSACTION_ID,
-
- /**
- * Signifies a failure to get participants to agree to commit (during prepare stage).
- */
- FAILURE_TO_PREPARE,
-
- /**
- * Failure during commit phase.
- */
- FAILURE_DURING_COMMIT
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/DefaultDocumentTree.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/DefaultDocumentTree.java
deleted file mode 100644
index 2d5832c..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/DefaultDocumentTree.java
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.concurrent.atomic.AtomicLong;
-
-import org.onosproject.store.service.DocumentPath;
-import org.onosproject.store.service.DocumentTree;
-import org.onosproject.store.service.DocumentTreeListener;
-import org.onosproject.store.service.DocumentTreeNode;
-import org.onosproject.store.service.IllegalDocumentModificationException;
-import org.onosproject.store.service.NoSuchDocumentPathException;
-import org.onosproject.store.service.Ordering;
-import org.onosproject.store.service.Versioned;
-
-import com.google.common.base.Supplier;
-import com.google.common.collect.Maps;
-
-/**
- * Simple implementation of a {@link DocumentTree}.
- *
- * @param <V> tree node value type
- */
-public class DefaultDocumentTree<V> implements DocumentTree<V> {
-
- private static final DocumentPath ROOT_PATH = DocumentPath.from("root");
- final DefaultDocumentTreeNode<V> root;
- private final Supplier<Long> versionSupplier;
-
- public DefaultDocumentTree() {
- AtomicLong versionCounter = new AtomicLong(0);
- versionSupplier = versionCounter::incrementAndGet;
- root = new DefaultDocumentTreeNode<>(ROOT_PATH, null, versionSupplier.get(), Ordering.NATURAL, null);
- }
-
- public DefaultDocumentTree(Supplier<Long> versionSupplier, Ordering ordering) {
- root = new DefaultDocumentTreeNode<>(ROOT_PATH, null, versionSupplier.get(), ordering, null);
- this.versionSupplier = versionSupplier;
- }
-
- DefaultDocumentTree(Supplier<Long> versionSupplier, DefaultDocumentTreeNode<V> root) {
- this.root = root;
- this.versionSupplier = versionSupplier;
- }
-
- @Override
- public String name() {
- return null;
- }
-
- @Override
- public DocumentPath root() {
- return ROOT_PATH;
- }
-
- @Override
- public Map<String, Versioned<V>> getChildren(DocumentPath path) {
- DocumentTreeNode<V> node = getNode(path);
- if (node != null) {
- Map<String, Versioned<V>> childrenValues = Maps.newLinkedHashMap();
- node.children().forEachRemaining(n -> childrenValues.put(simpleName(n.path()), n.value()));
- return childrenValues;
- }
- throw new NoSuchDocumentPathException();
- }
-
- @Override
- public Versioned<V> get(DocumentPath path) {
- DocumentTreeNode<V> currentNode = getNode(path);
- return currentNode != null ? currentNode.value() : null;
- }
-
- @Override
- public Versioned<V> set(DocumentPath path, V value) {
- checkRootModification(path);
- DefaultDocumentTreeNode<V> node = getNode(path);
- if (node != null) {
- return node.update(value, versionSupplier.get());
- } else {
- create(path, value);
- return null;
- }
- }
-
- @Override
- public boolean create(DocumentPath path, V value) {
- checkRootModification(path);
- DocumentTreeNode<V> node = getNode(path);
- if (node != null) {
- return false;
- }
- DocumentPath parentPath = path.parent();
- DefaultDocumentTreeNode<V> parentNode = getNode(parentPath);
- if (parentNode == null) {
- throw new IllegalDocumentModificationException();
- }
- parentNode.addChild(simpleName(path), value, versionSupplier.get());
- return true;
- }
-
- @Override
- public boolean createRecursive(DocumentPath path, V value) {
- checkRootModification(path);
- DocumentTreeNode<V> node = getNode(path);
- if (node != null) {
- return false;
- }
- DocumentPath parentPath = path.parent();
- if (getNode(parentPath) == null) {
- createRecursive(parentPath, null);
- }
- DefaultDocumentTreeNode<V> parentNode = getNode(parentPath);
- if (parentNode == null) {
- throw new IllegalDocumentModificationException();
- }
- parentNode.addChild(simpleName(path), value, versionSupplier.get());
- return true;
- }
-
- @Override
- public boolean replace(DocumentPath path, V newValue, long version) {
- checkRootModification(path);
- DocumentTreeNode<V> node = getNode(path);
- if (node != null && node.value() != null && node.value().version() == version) {
- set(path, newValue);
- return true;
- }
- return false;
- }
-
- @Override
- public boolean replace(DocumentPath path, V newValue, V expectedValue) {
- checkRootModification(path);
- if (Objects.equals(newValue, expectedValue)) {
- return false;
- }
- DocumentTreeNode<V> node = getNode(path);
- V prevValue = Optional.ofNullable(node)
- .map(DocumentTreeNode::value)
- .map(Versioned::valueOrNull)
- .orElse(null);
- if (Objects.equals(prevValue, expectedValue)) {
- set(path, newValue);
- return true;
- }
- return false;
- }
-
- @Override
- public Versioned<V> removeNode(DocumentPath path) {
- checkRootModification(path);
- DefaultDocumentTreeNode<V> nodeToRemove = getNode(path);
- if (nodeToRemove == null) {
- throw new NoSuchDocumentPathException();
- }
- if (nodeToRemove.hasChildren()) {
- throw new IllegalDocumentModificationException();
- }
- DefaultDocumentTreeNode<V> parent = (DefaultDocumentTreeNode<V>) nodeToRemove.parent();
- parent.removeChild(simpleName(path));
- return nodeToRemove.value();
- }
-
- @Override
- public void addListener(DocumentPath path, DocumentTreeListener<V> listener) {
- // TODO Auto-generated method stub
- }
-
- @Override
- public void removeListener(DocumentTreeListener<V> listener) {
- // TODO Auto-generated method stub
- }
-
- private DefaultDocumentTreeNode<V> getNode(DocumentPath path) {
- Iterator<String> pathElements = path.pathElements().iterator();
- DefaultDocumentTreeNode<V> currentNode = root;
- checkArgument("root".equals(pathElements.next()), "Path should start with root: %s", path);
- while (pathElements.hasNext() && currentNode != null) {
- currentNode = (DefaultDocumentTreeNode<V>) currentNode.child(pathElements.next());
- }
- return currentNode;
- }
-
- private String simpleName(DocumentPath path) {
- return path.pathElements().get(path.pathElements().size() - 1);
- }
-
- private void checkRootModification(DocumentPath path) {
- if (ROOT_PATH.equals(path)) {
- throw new IllegalDocumentModificationException();
- }
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/DefaultDocumentTreeNode.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/DefaultDocumentTreeNode.java
deleted file mode 100644
index 0f5d66a..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/DefaultDocumentTreeNode.java
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Objects;
-
-import org.onosproject.store.service.DocumentPath;
-import org.onosproject.store.service.DocumentTreeNode;
-import org.onosproject.store.service.Ordering;
-import org.onosproject.store.service.Versioned;
-
-import com.google.common.base.MoreObjects;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-
-/**
- * A {@code DocumentTree} node.
- */
-public class DefaultDocumentTreeNode<V> implements DocumentTreeNode<V> {
- private final DocumentPath key;
- private Versioned<V> value;
- private final Map<String, DocumentTreeNode<V>> children;
- private final Ordering ordering;
- private final DocumentTreeNode<V> parent;
-
- public DefaultDocumentTreeNode(DocumentPath key,
- V value,
- long version,
- Ordering ordering,
- DocumentTreeNode<V> parent) {
- this.key = checkNotNull(key);
- this.value = new Versioned<>(value, version);
- this.ordering = ordering;
- this.parent = parent;
-
- switch (ordering) {
- case INSERTION:
- children = Maps.newLinkedHashMap();
- break;
- case NATURAL:
- default:
- children = Maps.newTreeMap();
- break;
- }
- }
-
- @Override
- public DocumentPath path() {
- return key;
- }
-
- @Override
- public Versioned<V> value() {
- return value;
- }
-
- @Override
- public Iterator<DocumentTreeNode<V>> children() {
- return ImmutableList.copyOf(children.values()).iterator();
- }
-
- @Override
- public DocumentTreeNode<V> child(String name) {
- return children.get(name);
- }
-
-
- public DocumentTreeNode<V> parent() {
- return parent;
- }
-
- /**
- * Adds a new child only if one does not exist with the name.
- * @param name relative path name of the child node
- * @param newValue new value to set
- * @param newVersion new version to set
- * @return previous value; can be {@code null} if no child currently exists with that relative path name.
- * a non null return value indicates child already exists and no modification occurred.
- */
- public Versioned<V> addChild(String name, V newValue, long newVersion) {
- DefaultDocumentTreeNode<V> child = (DefaultDocumentTreeNode<V>) children.get(name);
- if (child != null) {
- return child.value();
- }
- children.put(name, new DefaultDocumentTreeNode<>(
- new DocumentPath(name, path()), newValue, newVersion, ordering, this));
- return null;
- }
-
- /**
- * Updates the node value.
- *
- * @param newValue new value to set
- * @param newVersion new version to set
- * @return previous value
- */
- public Versioned<V> update(V newValue, long newVersion) {
- Versioned<V> previousValue = value;
- value = new Versioned<>(newValue, newVersion);
- return previousValue;
- }
-
-
- /**
- * Removes a child node.
- *
- * @param name the name of child node to be removed
- * @return {@code true} if the child set was modified as a result of this call, {@code false} otherwise
- */
- public boolean removeChild(String name) {
- return children.remove(name) != null;
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(this.key);
- }
-
- @Override
- public boolean equals(Object obj) {
- if (obj instanceof DefaultDocumentTreeNode) {
- DefaultDocumentTreeNode<V> that = (DefaultDocumentTreeNode<V>) obj;
- if (this.parent.equals(that.parent)) {
- if (this.children.size() == that.children.size()) {
- return Sets.symmetricDifference(this.children.keySet(), that.children.keySet()).isEmpty();
- }
- }
- }
- return false;
- }
-
- @Override
- public String toString() {
- MoreObjects.ToStringHelper helper =
- MoreObjects.toStringHelper(getClass())
- .add("parent", this.parent)
- .add("key", this.key)
- .add("value", this.value);
- for (DocumentTreeNode<V> child : children.values()) {
- helper = helper.add("child", "\n" + child.path().pathElements()
- .get(child.path().pathElements().size() - 1) +
- " : " + child.value());
- }
- return helper.toString();
- }
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/DocumentTreeResult.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/DocumentTreeResult.java
deleted file mode 100644
index bf544dd..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/DocumentTreeResult.java
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import com.google.common.base.MoreObjects;
-
-/**
- * Result of a document tree operation.
- *
- * @param <V> value type
- */
-public class DocumentTreeResult<V> {
-
- public enum Status {
- /**
- * Indicates a successful update.
- */
- OK,
-
- /**
- * Indicates a noop i.e. existing and new value are both same.
- */
- NOOP,
-
- /**
- * Indicates a failed update due to a write lock.
- */
- WRITE_LOCK,
-
- /**
- * Indicates a failed update due to a invalid path.
- */
- INVALID_PATH,
-
- /**
- * Indicates a failed update due to a illegal modification attempt.
- */
- ILLEGAL_MODIFICATION,
- }
-
- @SuppressWarnings("unchecked")
- public static final DocumentTreeResult WRITE_LOCK =
- new DocumentTreeResult(Status.WRITE_LOCK, null);
-
- @SuppressWarnings("unchecked")
- public static final DocumentTreeResult INVALID_PATH =
- new DocumentTreeResult(Status.INVALID_PATH, null);
-
- @SuppressWarnings("unchecked")
- public static final DocumentTreeResult ILLEGAL_MODIFICATION =
- new DocumentTreeResult(Status.ILLEGAL_MODIFICATION, null);
-
- /**
- * Returns a successful result.
- *
- * @param result the operation result
- * @param <V> the result value type
- * @return successful result
- */
- public static <V> DocumentTreeResult<V> ok(V result) {
- return new DocumentTreeResult<V>(Status.OK, result);
- }
-
- /**
- * Returns a {@code WRITE_LOCK} error result.
- *
- * @param <V> the result value type
- * @return write lock result
- */
- @SuppressWarnings("unchecked")
- public static <V> DocumentTreeResult<V> writeLock() {
- return WRITE_LOCK;
- }
-
- /**
- * Returns an {@code INVALID_PATH} result.
- *
- * @param <V> the result value type
- * @return invalid path result
- */
- @SuppressWarnings("unchecked")
- public static <V> DocumentTreeResult<V> invalidPath() {
- return INVALID_PATH;
- }
-
- /**
- * Returns an {@code ILLEGAL_MODIFICATION} result.
- *
- * @param <V> the result value type
- * @return illegal modification result
- */
- @SuppressWarnings("unchecked")
- public static <V> DocumentTreeResult<V> illegalModification() {
- return ILLEGAL_MODIFICATION;
- }
-
- private final Status status;
- private final V result;
-
- public DocumentTreeResult(Status status, V result) {
- this.status = status;
- this.result = result;
- }
-
- public Status status() {
- return status;
- }
-
- public V result() {
- return result;
- }
-
- public boolean updated() {
- return status == Status.OK;
- }
-
- public boolean created() {
- return updated() && result == null;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("status", status)
- .add("value", result)
- .toString();
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/LockEvent.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/LockEvent.java
deleted file mode 100644
index cddb41f..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/LockEvent.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-
-/**
- * Locked event.
- */
-public class LockEvent {
- private final int id;
- private final long version;
-
- public LockEvent() {
- this(0, 0);
- }
-
- public LockEvent(int id, long version) {
- this.id = id;
- this.version = version;
- }
-
- /**
- * Returns the lock ID.
- *
- * @return The lock ID.
- */
- public int id() {
- return id;
- }
-
- /**
- * Returns the lock version.
- *
- * @return The lock version.
- */
- public long version() {
- return version;
- }
-
- @Override
- public String toString() {
- return toStringHelper(this)
- .add("id", id)
- .add("version", version)
- .toString();
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/MapEntryUpdateResult.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/MapEntryUpdateResult.java
deleted file mode 100644
index 4bc783b..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/MapEntryUpdateResult.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-import com.google.common.base.MoreObjects;
-import org.onosproject.store.service.Versioned;
-
-/**
- * Result of a map entry update operation.
- * <p>
- * Both old and new values are accessible along with a flag that indicates if the
- * the value was updated. If flag is false, oldValue and newValue both
- * point to the same unmodified value.
- *
- * @param <K> key type
- * @param <V> result type
- */
-public class MapEntryUpdateResult<K, V> {
-
- public enum Status {
-
- /**
- * Indicates a successful update.
- */
- OK,
-
- /**
- * Indicates a noop i.e. existing and new value are both null.
- */
- NOOP,
-
- /**
- * Indicates a failed update due to a write lock.
- */
- WRITE_LOCK,
-
- /**
- * Indicates a failed update due to a precondition check failure.
- */
- PRECONDITION_FAILED
- }
-
- private final Status status;
- private final long version;
- private final K key;
- private final Versioned<V> result;
-
- public MapEntryUpdateResult(Status status, long version, K key, Versioned<V> result) {
- this.status = status;
- this.version = version;
- this.key = key;
- this.result = result;
- }
-
- /**
- * Returns {@code true} if the update was successful.
- * @return {@code true} if yes, {@code false} otherwise
- */
- public boolean updated() {
- return status == Status.OK;
- }
-
- /**
- * Returns the update status.
- * @return update status
- */
- public Status status() {
- return status;
- }
-
- /**
- * Returns the result version.
- * @return result version
- */
- public long version() {
- return version;
- }
-
- /**
- * Returns the value.
- * @return the value associated with key if updated was successful, otherwise current value
- */
- public Versioned<V> result() {
- return result;
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(MapEntryUpdateResult.class)
- .add("status", status)
- .add("key", key)
- .add("result", result)
- .toString();
- }
-}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/PrepareResult.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/PrepareResult.java
deleted file mode 100644
index f4e2bdc..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/PrepareResult.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-/**
- * Response enum for two phase commit prepare operation.
- */
-public enum PrepareResult {
- /**
- * Signifies a successful execution of the prepare operation.
- */
- OK,
-
- /**
- * Signifies some participants in a distributed prepare operation failed.
- */
- PARTIAL_FAILURE,
-
- /**
- * Signifies a failure to another transaction locking the underlying state.
- */
- CONCURRENT_TRANSACTION,
-
- /**
- * Signifies a optimistic lock failure. This can happen if underlying state has changed since it was last read.
- */
- OPTIMISTIC_LOCK_FAILURE,
-}
\ No newline at end of file
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/RollbackResult.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/RollbackResult.java
deleted file mode 100644
index 3c6558b..0000000
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/RollbackResult.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright 2016-present Open Networking Foundation
- *
- * Licensed 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.onosproject.store.primitives.resources.impl;
-
-/**
- * Response enum for two phase commit rollback operation.
- */
-public enum RollbackResult {
- /**
- * Signifies a successful rollback execution.
- */
- OK,
-
- /**
- * Signifies a failure due to unrecognized transaction identifier.
- */
- UNKNOWN_TRANSACTION_ID,
-}