AbstractMuxConnection.java

/* $HeadURL::                                                                            $
 * $Id$
 *
 * Copyright (c) 2009-2010 DuraSpace
 * http://duraspace.org
 *
 * In collaboration with Topaz Inc.
 * http://www.topazproject.org
 *
 * 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 org.akubraproject.mux;

import java.io.IOException;

import java.net.URI;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.transaction.Transaction;

import com.google.common.collect.Iterators;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.akubraproject.Blob;
import org.akubraproject.BlobStore;
import org.akubraproject.BlobStoreConnection;
import org.akubraproject.UnsupportedIdException;
import org.akubraproject.impl.AbstractBlobStoreConnection;

/**
 * An abstract base class for connections returned by multiplexing BlobStores. Sub-class
 * implementations must provide a {@link #getStore} implementation. Additionally for multiplexing
 * content addressable stores, sub-classes must override the default implementation of {@link
 * org.akubraproject.impl.AbstractBlobStoreConnection#getBlob(java.io.InputStream, long,
 * Map)} and direct the call to the appropriate backing store. Note that the returned Blob from
 * the backing store must be wrapped so that the {@link
 * org.akubraproject.Blob#getConnection()} of the returned Blob will return this connection
 * object.
 *
 * @author Pradeep Krishnan
 *
 * @see #getStore(URI, Map)
 * @see #getStores(String)
 * @see #getConnection(BlobStore, Map)
 * @see MuxBlob
 */
public abstract class AbstractMuxConnection extends AbstractBlobStoreConnection {
  private static final Logger log = LoggerFactory.getLogger(AbstractBlobStoreConnection.class);

  /**
   * The transaction to pass to while opening connections to the backing stores. Note that
   * this transaction is only passed to transaction capable stores. A null is passed for
   * non-transactional stores.
   *
   * @see #getConnection(BlobStore, Map)
   */
  protected final Transaction txn;

  /**
   * A map of store-ids to connections.
   *
   * @see #getConnection(BlobStore, Map)
   * @see #close()
   */
  protected Map<URI, BlobStoreConnection> cons = new HashMap<URI, BlobStoreConnection>();

  /**
   * Creates a new AbstractMuxConnection object.
   *
   * @param store the mux store
   * @param txn the txn passed in by the user
   */
  public AbstractMuxConnection(BlobStore store, Transaction txn) {
    super(store);
    this.txn = txn;
  }

  /**
   * Gets the backing store where the given blob is persisted.
   *
   * @param blobId the blob id (can be null)
   * @param hints A set of hints to allow the implementation to optimize the operation (can be
   *        null)
   *
   * @return the store. Cannot be null and must be one of the backing stores.
   *
   * @throws IOException for IO errors
   * @throws UnsupportedIdException if blobId is not in a recognized/usable pattern by any of the
   *         backing stores
   */
  public abstract BlobStore getStore(URI blobId, Map<String, String> hints)
                              throws IOException, UnsupportedIdException;

  /**
   * Gets the set of a backing stores matching the given blobId prefix. By default the
   * returned set is the set of all backing stores. Override in sub-classes to narrow down the
   * set.
   *
   * @param prefix the blobId prefix or null
   *
   * @return the set of stores matching the blobId prefix
   */
  public Set<BlobStore> getStores(String prefix) {
    return new HashSet<BlobStore>(((AbstractMuxStore) getBlobStore()).getBackingStores());
  }

  /**
   * Closes this connection and all underlying connections created using {@link
   * #getConnection(BlobStore, Map)}.
   */
  @Override
  public void close() {
    super.close();

    if (cons != null) {
      for (BlobStoreConnection con : cons.values())
        con.close();

      cons.clear();
      cons = null;
    }
  }

  /**
   * Lookup/Create a connection to the given backing store.
   *
   * @param store the backing store
   * @param hints A set of hints to allow the implementation to optimize the operation (can be
   *              null)
   *
   * @return the backing store connection or null
   *
   * @throws IOException on an error in opening a connection to the backing store
   * @throws UnsupportedOperationException on an error in opening a connection to the backing store
   */
  protected BlobStoreConnection getConnection(BlobStore store, Map<String, String> hints)
                                       throws IOException {
    if (store == null)
      return null;

    if (cons == null)
      throw new IllegalStateException("Connection closed.");

    BlobStoreConnection con = cons.get(store.getId());

    if (con == null) {
      con = store.openConnection(txn, hints);
      cons.put(store.getId(), con);
    }

    return con;
  }

  @Override
  public Blob getBlob(URI blobId, Map<String, String> hints)
               throws IOException {
    return new MuxBlob(getConnection(getStore(blobId, hints), hints).getBlob(blobId, hints), this);
  }

  @Override
  public Iterator<URI> listBlobIds(String filterPrefix) throws IOException {
    List<Iterator<URI>> iterators = new ArrayList<Iterator<URI>>();

    for (BlobStore store : getStores(filterPrefix))
      iterators.add(getConnection(store, null).listBlobIds(filterPrefix));

    return Iterators.concat(iterators.iterator());
  }

  @Override
  public void sync() throws IOException {
    if (cons == null)
      throw new IllegalStateException("Connection closed.");

    Exception exc = null;

    for (BlobStoreConnection con : cons.values()) {
      try {
        con.sync();
      } catch (Exception e) {
        if (exc == null)
          exc = e;
        else
          log.warn("Error sync'ing connection " + con, e);
      }
    }

    if (exc instanceof IOException)
      throw (IOException) exc;
    if (exc instanceof RuntimeException)
      throw (RuntimeException) exc;
  }
}