google.registry.model.server.ServerSecret.java Source code

Introduction

Here is the source code for google.registry.model.server.ServerSecret.java

Source

// Copyright 2017 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.server;

import static google.registry.model.ofy.ObjectifyService.ofy;
import static google.registry.model.ofy.Ofy.RECOMMENDED_MEMCACHE_EXPIRATION;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.primitives.Longs;
import com.googlecode.objectify.Work;
import com.googlecode.objectify.annotation.Cache;
import com.googlecode.objectify.annotation.Entity;
import com.googlecode.objectify.annotation.Unindex;
import google.registry.model.annotations.NotBackedUp;
import google.registry.model.annotations.NotBackedUp.Reason;
import google.registry.model.common.CrossTldSingleton;
import java.nio.ByteBuffer;
import java.util.UUID;
import java.util.concurrent.ExecutionException;

/** A secret number used for generating tokens (such as XSRF tokens). */
@Entity
@Cache(expirationSeconds = RECOMMENDED_MEMCACHE_EXPIRATION)
@Unindex
@NotBackedUp(reason = Reason.AUTO_GENERATED)
public class ServerSecret extends CrossTldSingleton {

    /**
     * Cache of the singleton ServerSecret instance that creates it if not present.
     *
     * <p>The key is meaningless since there is only one instance; this is essentially a memoizing
     * Supplier that can be reset for testing purposes.
     */
    private static final LoadingCache<Class<ServerSecret>, ServerSecret> CACHE = CacheBuilder.newBuilder()
            .build(new CacheLoader<Class<ServerSecret>, ServerSecret>() {
                @Override
                public ServerSecret load(Class<ServerSecret> unused) {
                    // Fast path - non-transactional load to hit memcache.
                    ServerSecret secret = ofy().load().entity(new ServerSecret()).now();
                    if (secret != null) {
                        return secret;
                    }
                    // Slow path - transactionally create a new ServerSecret (once per app setup).
                    return ofy().transact(new Work<ServerSecret>() {
                        @Override
                        public ServerSecret run() {
                            // Check again for an existing secret within the transaction to avoid races.
                            ServerSecret secret = ofy().load().entity(new ServerSecret()).now();
                            if (secret == null) {
                                UUID uuid = UUID.randomUUID();
                                secret = create(uuid.getMostSignificantBits(), uuid.getLeastSignificantBits());
                                ofy().saveWithoutBackup().entity(secret).now();
                            }
                            return secret;
                        }
                    });
                }
            });

    /** Returns the global ServerSecret instance, creating it if one isn't already in Datastore. */
    public static ServerSecret get() {
        try {
            return CACHE.get(ServerSecret.class);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }

    /** Most significant 8 bytes of the UUID value. */
    long mostSignificant;

    /** Least significant 8 bytes of the UUID value. */
    long leastSignificant;

    @VisibleForTesting
    static ServerSecret create(long mostSignificant, long leastSignificant) {
        ServerSecret secret = new ServerSecret();
        secret.mostSignificant = mostSignificant;
        secret.leastSignificant = leastSignificant;
        return secret;
    }

    /** Returns the value of this ServerSecret as a UUID. */
    public UUID asUuid() {
        return new UUID(mostSignificant, leastSignificant);
    }

    /** Returns the value of this ServerSecret as a byte array. */
    public byte[] asBytes() {
        return ByteBuffer.allocate(Longs.BYTES * 2).putLong(mostSignificant).putLong(leastSignificant).array();
    }

    @VisibleForTesting
    static void resetCache() {
        CACHE.invalidateAll();
    }
}