Infrastructure

package org.dataone.cn.rest;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import org.dataone.client.v1.itk.D1Client;

import org.dataone.service.exceptions.InvalidToken;

import org.dataone.service.exceptions.NotAuthorized;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.types.v1.DescribeResponse;

import org.dataone.service.types.v1.Identifier;

import org.dataone.service.types.v1.NodeReference;

/**

 * A proof-of-concept class to address the feature request to confirm the 

 * navigatability of the location header in the resolve response.

 * 

 * The basic idea is that mn.describe is called against all completed replicas

 * concurrently, and use the url of the first sucessful responder.

 * 

 * This call represents the Runnable that sets the state of a shared object,

 * another class called ConfirmedNode.

 * 

 * Lightweight implementation requires correct use of 

 * 

 * @author rnahf

 *

 */

class UrlChecker implements Runnable {

    /** the amount of time to wait for a response from all of the checks */

    static final int CALL_TIMEOUT_MS = 30_000;

    private NodeReference node;

    private Identifier pid;

    private ConfirmedNode result;

    UrlChecker(NodeReference node, Identifier pid, ConfirmedNode result) {

        this.node = node;

        this.pid = pid;

        this.result = result;

    }

    @Override

    public void run() {

        try {

            DescribeResponse dr = D1Client.getMN(node).describe(pid);

            if (dr != null) {

                result.setNodeReference(node);

            }

        } catch (InvalidToken | NotAuthorized | NotImplemented | ServiceFailure

                | NotFound e) {

            ; // do nothing except return

        } 

    }

    /**

     * this is an example workflow that probably could be improved

     * @throws InterruptedException

     */

    public static void main() throws InterruptedException {

        // TODO: the real solution will have to handle the executor lifecycle (shutdown)

        // TODO: match the number of threads in the pool to the number of nodes to check,

        // since it will never be too many...

        // Q: should we use the fork-join pool since thread number should be low

        ExecutorService es = Executors.newFixedThreadPool(5);

        ConfirmedNode cn = new ConfirmedNode();

        // create the runnables

        UrlChecker curl1 = new UrlChecker(new NodeReference(), new Identifier(), cn);

        UrlChecker curl2 = new UrlChecker(new NodeReference(), new Identifier(), cn);

        // run the runnables

        es.submit(curl1);

        es.submit(curl2);

        // wait for result, but not forever

        long start = System.currentTimeMillis();

        NodeReference validNode = null;

        do {

            Thread.sleep(50);

            validNode = cn.getNodeReference();

            if (validNode != null) {

                break;

            }

        } while (System.currentTimeMillis() - start < CALL_TIMEOUT_MS);

    }

}