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(final 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(final 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")
79 public DatastoreSnapshot datastoreSnapshot() {
80 return datastoreSnapshot;
84 public void resolveTo(final DatastoreSnapshot newDatastoreSnapshot) {
85 datastoreSnapshot = requireNonNull(newDatastoreSnapshot);
89 public Object readResolve() {
90 return verifyNotNull(datastoreSnapshot);
95 private static final long serialVersionUID = 1L;
97 private final @NonNull String type;
98 private final ShardManagerSnapshot shardManagerSnapshot;
99 private final @NonNull ImmutableList<ShardSnapshot> shardSnapshots;
101 public DatastoreSnapshot(final @NonNull String type, final @Nullable ShardManagerSnapshot shardManagerSnapshot,
102 final @NonNull List<ShardSnapshot> shardSnapshots) {
103 this.type = requireNonNull(type);
104 this.shardManagerSnapshot = shardManagerSnapshot;
105 this.shardSnapshots = ImmutableList.copyOf(shardSnapshots);
108 public @NonNull String getType() {
112 public @Nullable ShardManagerSnapshot getShardManagerSnapshot() {
113 return shardManagerSnapshot;
116 public @NonNull List<ShardSnapshot> getShardSnapshots() {
117 return shardSnapshots;
121 private Object writeReplace() {
125 public static final class ShardSnapshot implements Serializable {
126 interface SerialForm extends Externalizable {
128 ShardSnapshot shardSnapshot();
130 Object readResolve();
132 void resolveTo(String name, Snapshot snapshot);
135 default void writeExternal(final ObjectOutput out) throws IOException {
136 final var shardSnapshot = shardSnapshot();
137 out.writeObject(shardSnapshot.name);
138 out.writeObject(shardSnapshot.snapshot);
142 default void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
143 resolveTo((String) in.readObject(), (Snapshot) in.readObject());
147 private static final class Proxy implements SerialForm {
149 private static final long serialVersionUID = 1L;
151 private ShardSnapshot shardSnapshot;
153 // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
154 // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
155 @SuppressWarnings("checkstyle:RedundantModifier")
157 // For Externalizable
160 Proxy(final ShardSnapshot shardSnapshot) {
161 this.shardSnapshot = shardSnapshot;
165 public ShardSnapshot shardSnapshot() {
166 return shardSnapshot;
170 public void resolveTo(final String name, final Snapshot snapshot) {
171 shardSnapshot = new ShardSnapshot(name, snapshot);
175 public Object readResolve() {
176 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(final @NonNull String name, final @NonNull Snapshot snapshot) {
187 this.name = requireNonNull(name);
188 this.snapshot = requireNonNull(snapshot);
191 public @NonNull String getName() {
195 public @NonNull Snapshot getSnapshot() {
200 private Object writeReplace() {
201 return new Proxy(this);