org.cloudgraph.hbase.io.DistributedGraphWriter Maven / Gradle / Ivy

Go to download
/**
 *        CloudGraph Community Edition (CE) License
 * 
 * This is a community release of CloudGraph, a dual-license suite of
 * Service Data Object (SDO) 2.1 services designed for relational and 
 * big-table style "cloud" databases, such as HBase and others. 
 * This particular copy of the software is released under the 
 * version 2 of the GNU General Public License. CloudGraph was developed by 
 * TerraMeta Software, Inc.
 * 
 * Copyright (c) 2013, TerraMeta Software, Inc. All rights reserved.
 * 
 * General License information can be found below.
 * 
 * This distribution may include materials developed by third
 * parties. For license and attribution notices for these
 * materials, please refer to the documentation that accompanies
 * this distribution (see the "Licenses for Third-Party Components"
 * appendix) or view the online documentation at 
 * . 
 */
package org.cloudgraph.hbase.io;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.cloudgraph.config.CloudGraphConfig;
import org.cloudgraph.config.TableConfig;
import org.cloudgraph.state.StateMarshalingContext;
import org.plasma.sdo.PlasmaType;

import commonj.sdo.DataGraph;
import commonj.sdo.DataObject;
import commonj.sdo.Type;


/**
 * Encapsulates one or more
 * graph table writer components for federation across
 * multiple physical tables and/or physical table rows. 
 * Maps physical configured
 * table names to respective table writers. In most usage
 * scenarios, a "root" table writer is typically added 
 * initially, then other writers are incrementally added
 * as association target types are detected and found configured as
 * graph roots within another distinct table context. 
 * 
 * Acts as a container for one or more {@link TableWriter} elements
 * encapsulating a set of component table write operations 
 * for federation across multiple tables, or a single table
 * in the most simple (degenerate) case.  
 * 
 * @see org.cloudgraph.hbase.io.GraphTableWriter
 * @see org.cloudgraph.state.GraphTable
 * 
 * @author Scott Cinnamond
 * @since 0.5.1
 */
public class DistributedGraphWriter extends WriterSupport
    implements DistributedWriter {

    private static Log log = LogFactory.getLog(DistributedGraphWriter.class);
	private TableWriter rootWriter;
	private Map tableWriterMap = new HashMap();
	/** maps table writers to graph-root types */
	private Map> tableWriterTypeMap = new HashMap>();
	private StateMarshalingContext marshallingContext;
	
	@SuppressWarnings("unused")
	private DistributedGraphWriter() {}
	
	public DistributedGraphWriter(DataGraph dataGraph,
			TableWriterCollector collector,
			StateMarshalingContext marshallingContext) throws IOException {
		this.marshallingContext = marshallingContext;
		this.rootWriter = collector.getRootTableWriter();
		for (TableWriter tableWriter : collector.getTableWriters()) {
			tableWriter.setFederatedOperation(this);
			tableWriterMap.put(tableWriter.getTableConfig().getName(), 
					tableWriter);
			List list = new ArrayList();
			for (RowWriter rowWriter : tableWriter.getAllRowWriters()) {
				if (!list.contains(rowWriter.getRootType()))
					list.add(rowWriter.getRootType());
			}
			tableWriterTypeMap.put(tableWriter, list);
		}
		this.rowWriterMap = collector.getRowWriterMap();
	}	
	
	/**
	 * Returns the table writer for the given 
	 * configured table name, or null of not exists.
	 * @param tableName the name of the configured table. 
	 * @return the table writer for the given 
	 * configured table name, or null of not exists.
	 */
	@Override
	public TableWriter getTableWriter(String tableName) {
		return this.tableWriterMap.get(tableName);
	}

	/**
	 * Adds the given table writer to the container
	 * @param writer the table writer. 
	 */
	@Override
	public void addTableWriter(TableWriter writer) {
		String name = writer.getTableConfig().getName();
		if (this.tableWriterMap.get(name) != null)
			throw new OperationException("table writer for '" + 
				name + "' already exists");
		this.tableWriterMap.put(name, writer);
	}

	/**
	 * Returns the count of table writers for this 
	 * container.
	 * @return the count of table writers for this 
	 * container
	 */
	@Override
	public int getTableWriterCount() {
		return this.tableWriterMap.size();
	}

    /**
     * Returns all table writers for the this container
     * @return all table writers for the this container
     */
    public List getTableWriters() {
    	List result = new ArrayList();
    	result.addAll(this.tableWriterMap.values());
    	return result;
    }
    
    /**
     * Returns the table writer associated with the
     * data graph root. 
     * @return the table writer associated with the
     * data graph root.
     */
    public TableWriter getRootTableWriter() {
    	return this.rootWriter;
    }

    /**
     * Sets the table writer associated with the
     * data graph root. 
     * @param writer the table writer
     */
    public void setRootTableWriter(TableWriter writer) {
    	this.rootWriter = writer;
    	this.tableWriterMap.put(rootWriter.getTableConfig().getName(), rootWriter);
    }    
    
    /**
     * Returns the row writer associated with the given data object
     * @param dataObject the data object
     * @return the row writer associated with the given data object
     * @throws IllegalArgumentException if the given data object
     * is not associated with any row writer.
     */
    @Override
    public RowWriter getRowWriter(DataObject dataObject) {
    	RowWriter result = rowWriterMap.get(dataObject);
    	if (result == null)
    		throw new IllegalArgumentException("the given data object of type "
    		   + dataObject.getType().getURI() + "#" + dataObject.getType().getName()		
    	       + " is not associated with any row writer");
    	return result;
    }
    
    /**
     * Returns the row writer associated with the given data object
     * or null if no row writer is associated.
     * @param dataObject the data object
     * @return the row writer associated with the given data 
     * object or null if no row writer is associated.
     */
    @Override
    public RowWriter findRowWriter(DataObject dataObject) {
    	return rowWriterMap.get(dataObject);
    }
    
    /**
     * Creates and returns a new row writer associated 
     * with the given data object.
     * @param dataObject the data object
     * @return a new row writer associated 
     * with the given data object.
     * @throws IOException 
     * @throws IllegalArgumentException if the given data object
     * is already associated with a row writer.
     */
    @Override
    public RowWriter createRowWriter(DataObject dataObject) throws IOException {
		PlasmaType type = (PlasmaType)dataObject.getType();
		TableConfig table = CloudGraphConfig.getInstance().findTable(type);
    	RowWriter rowWriter = this.rowWriterMap.get(dataObject);
    	if (rowWriter != null)
    		throw new IllegalArgumentException("the given data object "
	    			+ dataObject.toString()	
	    	        + " is already associated with a row writer");

		if (table == null) {
			if (log.isDebugEnabled())
	    		log.debug("creating unbound writer for: " + dataObject);
	    	
    		rowWriter = getContainerRowWriter(dataObject);
    		if (log.isDebugEnabled())
    		    log.debug("associating " 
    		       + type.toString() + " with table '"
    		       + rowWriter.getTableWriter().getTableConfig().getName() + "'");
    		rowWriter.addDataObject(dataObject);
    	    this.rowWriterMap.put(dataObject, rowWriter);
		}
		else {
	        // a table is configured with this type as root
			TableWriter tableWriter = (TableWriter)tableWriterMap.get(table.getName());
			if (tableWriter == null) {
				tableWriter = new GraphTableWriter(
		        		table, this);
				rowWriter = createRowWriter(tableWriter, dataObject);
		        tableWriter = rowWriter.getTableWriter();
		        tableWriterMap.put(tableWriter.getTableConfig().getName(), tableWriter);
			}
			else { // just add a row writer to existing table writer    			
				rowWriter = this.addRowWriter(
						dataObject, tableWriter);
			}
			if (log.isDebugEnabled())
			    log.debug("associating (root) " 
			       + dataObject.getType().toString() + " with table '"
			       + rowWriter.getTableWriter().getTableConfig().getName() + "'");
			
	    	this.rowWriterMap.put(dataObject, rowWriter);
			
		}
		return rowWriter;
    }
    

	/**
	 * Returns true if only one table operation exists
	 * with only one associated (root) type for this
	 * operation. 
	 * @return true if only one table operation exists
	 * with only one associated (root) type for this
	 * operation. 
	 */
    public boolean hasSingleRootType() {
        if (this.getTableWriterCount() == 1 &&
        	this.getTypes(this.rootWriter).size() == 1) {
        	return true;
        }
        else
        	return false;
    }

    /**
     * Returns a list of types associated
     * with the given table operation. 
     * @param reader the table operation
     * @return a list of types associated
     * with the given table operation. 
     */
	@Override
	public List getTypes(TableWriter operation) {
		return this.tableWriterTypeMap.get(operation);
	}

	@Override
	public StateMarshalingContext getMarshallingContext() {
		return this.marshallingContext;
	}
}