manifoldcf-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From kwri...@apache.org
Subject svn commit: r1495814 [2/2] - in /manifoldcf/branches/CONNECTORS-703/framework/pull-agent/src/main/java/org/apache/manifoldcf/authorities: authorities/ interfaces/ mapconnmgr/ mappers/ mapping/
Date Sun, 23 Jun 2013 13:10:03 GMT
Added: manifoldcf/branches/CONNECTORS-703/framework/pull-agent/src/main/java/org/apache/manifoldcf/authorities/mapping/MappingConnectionManager.java
URL: http://svn.apache.org/viewvc/manifoldcf/branches/CONNECTORS-703/framework/pull-agent/src/main/java/org/apache/manifoldcf/authorities/mapping/MappingConnectionManager.java?rev=1495814&view=auto
==============================================================================
--- manifoldcf/branches/CONNECTORS-703/framework/pull-agent/src/main/java/org/apache/manifoldcf/authorities/mapping/MappingConnectionManager.java
(added)
+++ manifoldcf/branches/CONNECTORS-703/framework/pull-agent/src/main/java/org/apache/manifoldcf/authorities/mapping/MappingConnectionManager.java
Sun Jun 23 13:10:02 2013
@@ -0,0 +1,668 @@
+/* $Id$ */
+
+/**
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements. See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You 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.apache.manifoldcf.authorities.mapping;
+
+import org.apache.manifoldcf.core.interfaces.*;
+import org.apache.manifoldcf.authorities.interfaces.*;
+import java.util.*;
+import org.apache.manifoldcf.authorities.interfaces.CacheKeyFactory;
+import org.apache.manifoldcf.authorities.system.ManifoldCF;
+
+/** Implementation of the authority connection manager functionality.
+ * 
+ * <br><br>
+ * <b>authconnectors</b>
+ * <table border="1" cellpadding="3" cellspacing="0">
+ * <tr class="TableHeadingColor">
+ * <th>Field</th><th>Type</th><th>Description&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</th>
+ * <tr><td>authorityname</td><td>VARCHAR(32)</td><td>Primary
Key</td></tr>
+ * <tr><td>description</td><td>VARCHAR(255)</td><td></td></tr>
+ * <tr><td>classname</td><td>VARCHAR(255)</td><td></td></tr>
+ * <tr><td>maxcount</td><td>BIGINT</td><td></td></tr>
+ * <tr><td>configxml</td><td>LONGTEXT</td><td></td></tr>
+ * </table>
+ * <br><br>
+ * 
+ */
+public class MappingConnectionManager extends org.apache.manifoldcf.core.database.BaseTable
implements IMappingConnectionManager
+{
+  public static final String _rcsid = "@(#)$Id$";
+
+  // Special field suffix
+  private final static String passwordSuffix = "password";
+
+  protected final static String nameField = "authorityname";      // Changed this to work
around a bug in postgresql
+  protected final static String descriptionField = "description";
+  protected final static String classNameField = "classname";
+  protected final static String maxCountField = "maxcount";
+  protected final static String configField = "configxml";
+
+  protected static Random random = new Random();
+
+  // Cache manager
+  ICacheManager cacheManager;
+  // Thread context
+  IThreadContext threadContext;
+
+  /** Constructor.
+  *@param threadContext is the thread context.
+  */
+  public MappingConnectionManager(IThreadContext threadContext, IDBInterface database)
+    throws ManifoldCFException
+  {
+    super(database,"mapconnections");
+
+    cacheManager = CacheManagerFactory.make(threadContext);
+    this.threadContext = threadContext;
+  }
+
+  /** Install the manager.
+  */
+  public void install()
+    throws ManifoldCFException
+  {
+    // Always do a loop, in case upgrade needs it.
+    while (true)
+    {
+      Map existing = getTableSchema(null,null);
+      if (existing == null)
+      {
+        // Install the "objects" table.
+        HashMap map = new HashMap();
+        map.put(nameField,new ColumnDescription("VARCHAR(32)",true,false,null,null,false));
+        map.put(descriptionField,new ColumnDescription("VARCHAR(255)",false,true,null,null,false));
+        map.put(classNameField,new ColumnDescription("VARCHAR(255)",false,false,null,null,false));
+        map.put(maxCountField,new ColumnDescription("BIGINT",false,false,null,null,false));
+        map.put(configField,new ColumnDescription("LONGTEXT",false,true,null,null,false));
+        performCreate(map,null);
+      }
+      else
+      {
+        // Upgrade code goes here
+      }
+
+      // Index management goes here
+
+      break;
+    }
+  }
+
+  /** Uninstall the manager.
+  */
+  public void deinstall()
+    throws ManifoldCFException
+  {
+    performDrop(null);
+  }
+
+  /** Export configuration */
+  public void exportConfiguration(java.io.OutputStream os)
+    throws java.io.IOException, ManifoldCFException
+  {
+    // Write a version indicator
+    ManifoldCF.writeDword(os,1);
+    // Get the authority list
+    IMappingConnection[] list = getAllConnections();
+    // Write the number of authorities
+    ManifoldCF.writeDword(os,list.length);
+    // Loop through the list and write the individual authority info
+    int i = 0;
+    while (i < list.length)
+    {
+      IMappingConnection conn = list[i++];
+      ManifoldCF.writeString(os,conn.getName());
+      ManifoldCF.writeString(os,conn.getDescription());
+      ManifoldCF.writeString(os,conn.getClassName());
+      ManifoldCF.writeString(os,conn.getConfigParams().toXML());
+      ManifoldCF.writeDword(os,conn.getMaxConnections());
+    }
+  }
+
+  /** Import configuration */
+  public void importConfiguration(java.io.InputStream is)
+    throws java.io.IOException, ManifoldCFException
+  {
+    int version = ManifoldCF.readDword(is);
+    if (version != 1)
+      throw new java.io.IOException("Unknown authority configuration version: "+Integer.toString(version));
+    int count = ManifoldCF.readDword(is);
+    int i = 0;
+    while (i < count)
+    {
+      IMappingConnection conn = create();
+      conn.setName(ManifoldCF.readString(is));
+      conn.setDescription(ManifoldCF.readString(is));
+      conn.setClassName(ManifoldCF.readString(is));
+      conn.getConfigParams().fromXML(ManifoldCF.readString(is));
+      conn.setMaxConnections(ManifoldCF.readDword(is));
+      // Attempt to save this connection
+      save(conn);
+      i++;
+    }
+  }
+
+  /** Obtain a list of the repository connections, ordered by name.
+  *@return an array of connection objects.
+  */
+  public IMappingConnection[] getAllConnections()
+    throws ManifoldCFException
+  {
+    beginTransaction();
+    try
+    {
+      // Read all the tools
+      StringSetBuffer ssb = new StringSetBuffer();
+      ssb.add(getMappingConnectionsKey());
+      StringSet localCacheKeys = new StringSet(ssb);
+      IResultSet set = performQuery("SELECT "+nameField+",lower("+nameField+") AS sortfield
FROM "+getTableName()+" ORDER BY sortfield ASC",null,
+        localCacheKeys,null);
+      String[] names = new String[set.getRowCount()];
+      int i = 0;
+      while (i < names.length)
+      {
+        IResultRow row = set.getRow(i);
+        names[i] = row.getValue(nameField).toString();
+        i++;
+      }
+      return loadMultiple(names);
+    }
+    catch (ManifoldCFException e)
+    {
+      signalRollback();
+      throw e;
+    }
+    catch (Error e)
+    {
+      signalRollback();
+      throw e;
+    }
+    finally
+    {
+      endTransaction();
+    }
+  }
+
+  /** Load a mapping connection by name.
+  *@param name is the name of the mapping connection.
+  *@return the loaded connection object, or null if not found.
+  */
+  public IMappingConnection load(String name)
+    throws ManifoldCFException
+  {
+    return loadMultiple(new String[]{name})[0];
+  }
+
+  /** Load multiple mapping connections by name.
+  *@param names are the names to load.
+  *@return the loaded connection objects.
+  */
+  public IMappingConnection[] loadMultiple(String[] names)
+    throws ManifoldCFException
+  {
+    // Build description objects
+    MappingConnectionDescription[] objectDescriptions = new MappingConnectionDescription[names.length];
+    int i = 0;
+    StringSetBuffer ssb = new StringSetBuffer();
+    while (i < names.length)
+    {
+      ssb.clear();
+      ssb.add(getMappingConnectionKey(names[i]));
+      objectDescriptions[i] = new MappingConnectionDescription(names[i],new StringSet(ssb));
+      i++;
+    }
+
+    MappingConnectionExecutor exec = new MappingConnectionExecutor(this,objectDescriptions);
+    cacheManager.findObjectsAndExecute(objectDescriptions,null,exec,getTransactionID());
+    return exec.getResults();
+  }
+
+  /** Create a new repository connection object.
+  *@return the new object.
+  */
+  public IMappingConnection create()
+    throws ManifoldCFException
+  {
+    MappingConnection rval = new MappingConnection();
+    return rval;
+  }
+
+  /** Save a mapping connection object.
+  *@param object is the object to save.
+  *@return true if the object is created, false otherwise.
+  */
+  public boolean save(IMappingConnection object)
+    throws ManifoldCFException
+  {
+    StringSetBuffer ssb = new StringSetBuffer();
+    ssb.add(getMappingConnectionsKey());
+    ssb.add(getMappingConnectionKey(object.getName()));
+    StringSet cacheKeys = new StringSet(ssb);
+    while (true)
+    {
+      long sleepAmt = 0L;
+      try
+      {
+        ICacheHandle ch = cacheManager.enterCache(null,cacheKeys,getTransactionID());
+        try
+        {
+          beginTransaction();
+          try
+          {
+            //performLock();
+            ManifoldCF.noteConfigurationChange();
+            boolean isNew = object.getIsNew();
+            // See whether the instance exists
+            ArrayList params = new ArrayList();
+            String query = buildConjunctionClause(params,new ClauseDescription[]{
+              new UnitaryClause(nameField,object.getName())});
+            IResultSet set = performQuery("SELECT * FROM "+getTableName()+" WHERE "+
+              query+" FOR UPDATE",params,null,null);
+            HashMap values = new HashMap();
+            values.put(descriptionField,object.getDescription());
+            values.put(classNameField,object.getClassName());
+            values.put(maxCountField,new Long((long)object.getMaxConnections()));
+            values.put(configField,object.getConfigParams().toXML());
+
+            boolean isCreated;
+            
+            if (set.getRowCount() > 0)
+            {
+              // If the object is supposedly new, it is bad that we found one that already
exists.
+              if (isNew)
+                throw new ManifoldCFException("Authority connection '"+object.getName()+"'
already exists");
+              isCreated = false;
+              // Update
+              params.clear();
+              query = buildConjunctionClause(params,new ClauseDescription[]{
+                new UnitaryClause(nameField,object.getName())});
+              performUpdate(values," WHERE "+query,params,null);
+            }
+            else
+            {
+              // If the object is not supposed to be new, it is bad that we did not find
one.
+              if (!isNew)
+                throw new ManifoldCFException("Authority connection '"+object.getName()+"'
no longer exists");
+              isCreated = true;
+              // Insert
+              values.put(nameField,object.getName());
+              // We only need the general key because this is new.
+              performInsert(values,null);
+            }
+
+            cacheManager.invalidateKeys(ch);
+            return isCreated;
+          }
+          catch (ManifoldCFException e)
+          {
+            signalRollback();
+            throw e;
+          }
+          catch (Error e)
+          {
+            signalRollback();
+            throw e;
+          }
+          finally
+          {
+            endTransaction();
+          }
+        }
+        finally
+        {
+          cacheManager.leaveCache(ch);
+        }
+      }
+      catch (ManifoldCFException e)
+      {
+        // Is this a deadlock exception?  If so, we want to try again.
+        if (e.getErrorCode() != ManifoldCFException.DATABASE_TRANSACTION_ABORT)
+          throw e;
+        sleepAmt = getSleepAmt();
+      }
+      finally
+      {
+        sleepFor(sleepAmt);
+      }
+    }
+  }
+
+  /** Delete an authority connection.
+  *@param name is the name of the connection to delete.  If the
+  * name does not exist, no error is returned.
+  */
+  public void delete(String name)
+    throws ManifoldCFException
+  {
+    // MHL to check on legality of deletion
+
+    StringSetBuffer ssb = new StringSetBuffer();
+    ssb.add(getMappingConnectionsKey());
+    ssb.add(getMappingConnectionKey(name));
+    StringSet cacheKeys = new StringSet(ssb);
+    ICacheHandle ch = cacheManager.enterCache(null,cacheKeys,getTransactionID());
+    try
+    {
+      beginTransaction();
+      try
+      {
+        // Check if anything refers to this connection name
+        // MHL
+        //if (repoManager.isReferenced(name))
+        //  throw new ManifoldCFException("Can't delete mapping connection '"+name+"': existing
mapping connections refer to it");
+        ManifoldCF.noteConfigurationChange();
+        ArrayList params = new ArrayList();
+        String query = buildConjunctionClause(params,new ClauseDescription[]{
+          new UnitaryClause(nameField,name)});
+        performDelete("WHERE "+query,params,null);
+        cacheManager.invalidateKeys(ch);
+      }
+      catch (ManifoldCFException e)
+      {
+        signalRollback();
+        throw e;
+      }
+      catch (Error e)
+      {
+        signalRollback();
+        throw e;
+      }
+      finally
+      {
+        endTransaction();
+      }
+    }
+    finally
+    {
+      cacheManager.leaveCache(ch);
+    }
+
+  }
+
+  /** Get the mapping connection name column.
+  *@return the name column.
+  */
+  public String getMappingNameColumn()
+  {
+    return nameField;
+  }
+
+  // Caching strategy: Individual connection descriptions are cached, and there is a global
cache key for the list of
+  // repository connections.
+
+  /** Construct a key which represents the general list of mapping connectors.
+  *@return the cache key.
+  */
+  protected static String getMappingConnectionsKey()
+  {
+    return CacheKeyFactory.makeMappingConnectionsKey();
+  }
+
+  /** Construct a key which represents an individual mapping connection.
+  *@param connectionName is the name of the connector.
+  *@return the cache key.
+  */
+  protected static String getMappingConnectionKey(String connectionName)
+  {
+    return CacheKeyFactory.makeMappingConnectionKey(connectionName);
+  }
+
+  // Other utility methods.
+
+  /** Fetch multiple mapping connections at a single time.
+  *@param connectionNames are a list of connection names.
+  *@return the corresponding mapping connection objects.
+  */
+  protected MappingConnection[] getMappingConnectionsMultiple(String[] connectionNames)
+    throws ManifoldCFException
+  {
+    MappingConnection[] rval = new MappingConnection[connectionNames.length];
+    HashMap returnIndex = new HashMap();
+    int i = 0;
+    while (i < connectionNames.length)
+    {
+      rval[i] = null;
+      returnIndex.put(connectionNames[i],new Integer(i));
+      i++;
+    }
+    beginTransaction();
+    try
+    {
+      i = 0;
+      ArrayList params = new ArrayList();
+      int j = 0;
+      int maxIn = maxClauseGetMappingConnectionsChunk();
+      while (i < connectionNames.length)
+      {
+        if (j == maxIn)
+        {
+          getMappingConnectionsChunk(rval,returnIndex,params);
+          params.clear();
+          j = 0;
+        }
+        params.add(connectionNames[i]);
+        i++;
+        j++;
+      }
+      if (j > 0)
+        getMappingConnectionsChunk(rval,returnIndex,params);
+      return rval;
+    }
+    catch (Error e)
+    {
+      signalRollback();
+      throw e;
+    }
+    catch (ManifoldCFException e)
+    {
+      signalRollback();
+      throw e;
+    }
+    finally
+    {
+      endTransaction();
+    }
+  }
+
+  /** Find the maximum number of clauses for getMappingConnectionsChunk.
+  */
+  protected int maxClauseGetMappingConnectionsChunk()
+  {
+    return findConjunctionClauseMax(new ClauseDescription[]{});
+  }
+    
+  /** Read a chunk of mapping connections.
+  *@param rval is the place to put the read policies.
+  *@param returnIndex is a map from the object id (resource id) and the rval index.
+  *@param params is the set of parameters.
+  */
+  protected void getMappingConnectionsChunk(MappingConnection[] rval, Map returnIndex, ArrayList
params)
+    throws ManifoldCFException
+  {
+    ArrayList list = new ArrayList();
+    String query = buildConjunctionClause(list,new ClauseDescription[]{
+      new MultiClause(nameField,params)});
+    IResultSet set = performQuery("SELECT * FROM "+getTableName()+" WHERE "+
+      query,list,null,null);
+    int i = 0;
+    while (i < set.getRowCount())
+    {
+      IResultRow row = set.getRow(i++);
+      String name = row.getValue(nameField).toString();
+      int index = ((Integer)returnIndex.get(name)).intValue();
+      MappingConnection rc = new MappingConnection();
+      rc.setIsNew(false);
+      rc.setName(name);
+      rc.setDescription((String)row.getValue(descriptionField));
+      rc.setClassName((String)row.getValue(classNameField));
+      rc.setMaxConnections((int)((Long)row.getValue(maxCountField)).longValue());
+      String xml = (String)row.getValue(configField);
+      if (xml != null && xml.length() > 0)
+        rc.getConfigParams().fromXML(xml);
+      rval[index] = rc;
+    }
+  }
+
+  // The cached instance will be a MappingConnection.  The cached version will be duplicated
when it is returned
+  // from the cache.
+  //
+  // The description object is based completely on the name.
+
+  /** This is the object description for a mapping connection object.
+  */
+  protected static class MappingConnectionDescription extends org.apache.manifoldcf.core.cachemanager.BaseDescription
+  {
+    protected String connectionName;
+    protected String criticalSectionName;
+    protected StringSet cacheKeys;
+
+    public MappingConnectionDescription(String connectionName, StringSet invKeys)
+    {
+      super("mappingconnectioncache");
+      this.connectionName = connectionName;
+      criticalSectionName = getClass().getName()+"-"+connectionName;
+      cacheKeys = invKeys;
+    }
+
+    public String getConnectionName()
+    {
+      return connectionName;
+    }
+
+    public int hashCode()
+    {
+      return connectionName.hashCode();
+    }
+
+    public boolean equals(Object o)
+    {
+      if (!(o instanceof MappingConnectionDescription))
+        return false;
+      MappingConnectionDescription d = (MappingConnectionDescription)o;
+      return d.connectionName.equals(connectionName);
+    }
+
+    public String getCriticalSectionName()
+    {
+      return criticalSectionName;
+    }
+
+    /** Get the cache keys for an object (which may or may not exist yet in
+    * the cache).  This method is called in order for cache manager to throw the correct
locks.
+    * @return the object's cache keys, or null if the object should not
+    * be cached.
+    */
+    public StringSet getObjectKeys()
+    {
+      return cacheKeys;
+    }
+
+  }
+
+  /** This is the executor object for locating mapping connection objects.
+  */
+  protected static class MappingConnectionExecutor extends org.apache.manifoldcf.core.cachemanager.ExecutorBase
+  {
+    // Member variables
+    protected MappingConnectionManager thisManager;
+    protected MappingConnection[] returnValues;
+    protected HashMap returnMap = new HashMap();
+
+    /** Constructor.
+    *@param manager is the ToolManager.
+    *@param objectDescriptions are the object descriptions.
+    */
+    public MappingConnectionExecutor(MappingConnectionManager manager, MappingConnectionDescription[]
objectDescriptions)
+    {
+      super();
+      thisManager = manager;
+      returnValues = new MappingConnection[objectDescriptions.length];
+      int i = 0;
+      while (i < objectDescriptions.length)
+      {
+        returnMap.put(objectDescriptions[i].getConnectionName(),new Integer(i));
+        i++;
+      }
+    }
+
+    /** Get the result.
+    *@return the looked-up or read cached instances.
+    */
+    public MappingConnection[] getResults()
+    {
+      return returnValues;
+    }
+
+    /** Create a set of new objects to operate on and cache.  This method is called only
+    * if the specified object(s) are NOT available in the cache.  The specified objects
+    * should be created and returned; if they are not created, it means that the
+    * execution cannot proceed, and the execute() method will not be called.
+    * @param objectDescriptions is the set of unique identifier of the object.
+    * @return the newly created objects to cache, or null, if any object cannot be created.
+    *  The order of the returned objects must correspond to the order of the object descriptinos.
+    */
+    public Object[] create(ICacheDescription[] objectDescriptions) throws ManifoldCFException
+    {
+      // Turn the object descriptions into the parameters for the ToolInstance requests
+      String[] connectionNames = new String[objectDescriptions.length];
+      int i = 0;
+      while (i < connectionNames.length)
+      {
+        MappingConnectionDescription desc = (MappingConnectionDescription)objectDescriptions[i];
+        connectionNames[i] = desc.getConnectionName();
+        i++;
+      }
+
+      return thisManager.getMappingConnectionsMultiple(connectionNames);
+    }
+
+
+    /** Notify the implementing class of the existence of a cached version of the
+    * object.  The object is passed to this method so that the execute() method below
+    * will have it available to operate on.  This method is also called for all objects
+    * that are freshly created as well.
+    * @param objectDescription is the unique identifier of the object.
+    * @param cachedObject is the cached object.
+    */
+    public void exists(ICacheDescription objectDescription, Object cachedObject) throws ManifoldCFException
+    {
+      // Cast what came in as what it really is
+      MappingConnectionDescription objectDesc = (MappingConnectionDescription)objectDescription;
+      MappingConnection ci = (MappingConnection)cachedObject;
+
+      // Duplicate it!
+      if (ci != null)
+        ci = ci.duplicate();
+
+      // In order to make the indexes line up, we need to use the hashtable built by
+      // the constructor.
+      returnValues[((Integer)returnMap.get(objectDesc.getConnectionName())).intValue()] =
ci;
+    }
+
+    /** Perform the desired operation.  This method is called after either createGetObject()
+    * or exists() is called for every requested object.
+    */
+    public void execute() throws ManifoldCFException
+    {
+      // Does nothing; we only want to fetch objects in this cacher.
+    }
+
+
+  }
+
+}

Propchange: manifoldcf/branches/CONNECTORS-703/framework/pull-agent/src/main/java/org/apache/manifoldcf/authorities/mapping/MappingConnectionManager.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: manifoldcf/branches/CONNECTORS-703/framework/pull-agent/src/main/java/org/apache/manifoldcf/authorities/mapping/MappingConnectionManager.java
------------------------------------------------------------------------------
    svn:keywords = Id



Mime
View raw message