2 * Copyright (c) 2015 Brocade Communications Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.controller.cluster.datastore.persisted;
10 import static com.google.common.base.Verify.verifyNotNull;
11 import static java.util.Objects.requireNonNull;
13 import com.google.common.collect.ImmutableList;
14 import java.io.Externalizable;
15 import java.io.IOException;
16 import java.io.ObjectInput;
17 import java.io.ObjectOutput;
18 import java.io.Serializable;
19 import java.util.ArrayList;
20 import java.util.List;
21 import org.eclipse.jdt.annotation.NonNull;
22 import org.eclipse.jdt.annotation.Nullable;
23 import org.opendaylight.controller.cluster.raft.persisted.Snapshot;
26 * Stores a snapshot of the internal state of a data store.
28 * @author Thomas Pantelis
30 public final class DatastoreSnapshot implements Serializable {
31 interface SerialForm extends Externalizable {
33 DatastoreSnapshot datastoreSnapshot();
37 void resolveTo(@NonNull DatastoreSnapshot newDatastoreSnapshot);
40 default void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
41 final var type = (String)in.readObject();
42 final var snapshot = (ShardManagerSnapshot) in.readObject();
44 final int size = in.readInt();
45 var localShardSnapshots = new ArrayList<ShardSnapshot>(size);
46 for (int i = 0; i < size; i++) {
47 localShardSnapshots.add((ShardSnapshot) in.readObject());
50 resolveTo(new DatastoreSnapshot(type, snapshot, localShardSnapshots));
54 default void writeExternal(ObjectOutput out) throws IOException {
55 final var datastoreSnapshot = datastoreSnapshot();
56 out.writeObject(datastoreSnapshot.type);
57 out.writeObject(datastoreSnapshot.shardManagerSnapshot);
59 out.writeInt(datastoreSnapshot.shardSnapshots.size());
60 for (ShardSnapshot shardSnapshot: datastoreSnapshot.shardSnapshots) {
61 out.writeObject(shardSnapshot);
66 private static final class Proxy implements SerialForm {
67 private static final long serialVersionUID = 1L;
69 private DatastoreSnapshot datastoreSnapshot;
71 // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
72 // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
73 @SuppressWarnings("checkstyle:RedundantModifier")
78 Proxy(final DatastoreSnapshot datastoreSnapshot) {
79 this.datastoreSnapshot = requireNonNull(datastoreSnapshot);
83 public DatastoreSnapshot datastoreSnapshot() {
84 return datastoreSnapshot;
88 public void resolveTo(DatastoreSnapshot newDatastoreSnapshot) {
89 datastoreSnapshot = requireNonNull(newDatastoreSnapshot);
93 public Object readResolve() {
94 return verifyNotNull(datastoreSnapshot);
98 private static final long serialVersionUID = 1L;
100 private final @NonNull String type;
101 private final ShardManagerSnapshot shardManagerSnapshot;
102 private final @NonNull ImmutableList<ShardSnapshot> shardSnapshots;
104 public DatastoreSnapshot(@NonNull String type, @Nullable ShardManagerSnapshot shardManagerSnapshot,
105 @NonNull List<ShardSnapshot> shardSnapshots) {
106 this.type = requireNonNull(type);
107 this.shardManagerSnapshot = shardManagerSnapshot;
108 this.shardSnapshots = ImmutableList.copyOf(shardSnapshots);
111 public @NonNull String getType() {
115 public @Nullable ShardManagerSnapshot getShardManagerSnapshot() {
116 return shardManagerSnapshot;
119 public @NonNull List<ShardSnapshot> getShardSnapshots() {
120 return shardSnapshots;
123 private Object writeReplace() {
124 return new Proxy(this);
127 public static final class ShardSnapshot implements Serializable {
128 interface SerialForm extends Externalizable {
130 ShardSnapshot shardSnapshot();
132 Object readResolve();
134 void resolveTo(String name, Snapshot snapshot);
137 default void writeExternal(ObjectOutput out) throws IOException {
138 final var shardSnapshot = shardSnapshot();
139 out.writeObject(shardSnapshot.name);
140 out.writeObject(shardSnapshot.snapshot);
144 default void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
145 resolveTo((String) in.readObject(), (Snapshot) in.readObject());
149 private static final class Proxy implements SerialForm {
150 private static final long serialVersionUID = 1L;
152 private ShardSnapshot shardSnapshot;
154 // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
155 // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
156 @SuppressWarnings("checkstyle:RedundantModifier")
158 // For Externalizable
161 Proxy(final ShardSnapshot shardSnapshot) {
162 this.shardSnapshot = shardSnapshot;
166 public ShardSnapshot shardSnapshot() {
167 return shardSnapshot;
171 public void resolveTo(final String name, final Snapshot snapshot) {
172 shardSnapshot = new ShardSnapshot(name, snapshot);
176 public Object readResolve() {
177 return verifyNotNull(shardSnapshot);
181 private static final long serialVersionUID = 1L;
183 private final @NonNull String name;
184 private final @NonNull Snapshot snapshot;
186 public ShardSnapshot(@NonNull String name, @NonNull Snapshot snapshot) {
187 this.name = requireNonNull(name);
188 this.snapshot = requireNonNull(snapshot);
191 public @NonNull String getName() {
195 public @NonNull Snapshot getSnapshot() {
199 private Object writeReplace() {
200 return new Proxy(this);