google.registry.model.ofy.CommitLogCheckpoint.java Source code

Introduction

Here is the source code for google.registry.model.ofy.CommitLogCheckpoint.java

Source

// Copyright 2016 The Nomulus Authors. All Rights Reserved.
//
// 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 google.registry.model.ofy;

import static com.google.common.base.Preconditions.checkArgument;
import static org.joda.time.DateTimeZone.UTC;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.googlecode.objectify.Key;
import com.googlecode.objectify.annotation.Entity;
import com.googlecode.objectify.annotation.Id;
import com.googlecode.objectify.annotation.Parent;
import google.registry.model.ImmutableObject;
import google.registry.model.annotations.NotBackedUp;
import google.registry.model.annotations.NotBackedUp.Reason;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.joda.time.DateTime;

/**
 * Entity representing a point-in-time consistent view of datastore, based on commit logs.
 *
 * <p>Conceptually, this entity consists of two pieces of information: the checkpoint "wall" time
 * and a set of bucket checkpoint times.  The former is the ID for this checkpoint (constrained
 * to be unique upon checkpoint creation) and also represents the approximate wall time of the
 * consistent datastore view this checkpoint represents.  The latter is really a mapping from
 * bucket ID to timestamp, where the timestamp dictates the upper bound (inclusive) on commit logs
 * from that bucket to include when restoring the datastore to this checkpoint.
 */
@Entity
@NotBackedUp(reason = Reason.COMMIT_LOGS)
public class CommitLogCheckpoint extends ImmutableObject {

    /** Shared singleton parent entity for commit log checkpoints. */
    @Parent
    Key<CommitLogCheckpointRoot> parent = CommitLogCheckpointRoot.getKey();

    /** The checkpoint's approximate "wall" time (in millis since the epoch). */
    @Id
    long checkpointTime;

    /** Bucket checkpoint times for this checkpoint, ordered to match up with buckets 1-N. */
    List<DateTime> bucketTimestamps = new ArrayList<>();

    public DateTime getCheckpointTime() {
        return new DateTime(checkpointTime, UTC);
    }

    /** Returns the bucket checkpoint times as a map from bucket ID to commit timestamp. */
    public ImmutableMap<Integer, DateTime> getBucketTimestamps() {
        ImmutableMap.Builder<Integer, DateTime> builder = new ImmutableMap.Builder<>();
        for (int i = 0; i < bucketTimestamps.size(); ++i) {
            // Add 1 to map the bucket timestamps properly to buckets indexed from 1-N.
            builder.put(i + 1, bucketTimestamps.get(i));
        }
        return builder.build();
    }

    /**
     * Creates a CommitLogCheckpoint for the given wall time and bucket checkpoint times, specified
     * as a map from bucket ID to bucket commit timestamp.
     */
    public static CommitLogCheckpoint create(DateTime checkpointTime,
            ImmutableMap<Integer, DateTime> bucketTimestamps) {
        checkArgument(Objects.equals(CommitLogBucket.getBucketIds().asList(), bucketTimestamps.keySet().asList()),
                "Bucket ids are incorrect: %s", bucketTimestamps.keySet());
        CommitLogCheckpoint instance = new CommitLogCheckpoint();
        instance.checkpointTime = checkpointTime.getMillis();
        instance.bucketTimestamps = ImmutableList.copyOf(bucketTimestamps.values());
        return instance;
    }

    /** Creates a key for the CommitLogCheckpoint for the given wall time. */
    public static Key<CommitLogCheckpoint> createKey(DateTime checkpointTime) {
        return Key.create(CommitLogCheckpointRoot.getKey(), CommitLogCheckpoint.class, checkpointTime.getMillis());
    }
}