* 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.

*/

*/

  public static final String _rcsid = "@(#)$Id: WikiConnector.java 1328336 2012-04-20 11:48:16Z ridder $";

  // Activities that we know about

 

  /** Fetch activity */

  protected final static String ACTIVITY_FETCH = "fetch document";

  /** Activities list */

  protected static final String[] activitiesList = new String[]{ACTIVITY_FETCH};

  /** Has setup been called? */

  protected boolean hasBeenSetup = false;

 

  /** Server name */

  protected String server = null;

 

  /** Base URL */

  protected String baseURL = null;

 

  /** Connection management */

  protected MultiThreadedHttpConnectionManager connectionManager = null;

  /** Constructor.

  */

  public WikiConnector()

  {

  }

  /** List the activities we might report on.

  */

  @Override

  public String[] getActivitiesList()

  {

    return activitiesList;

  }

  /** For any given document, list the bins that it is a member of.

  */

  @Override

  public String[] getBinNames(String documentIdentifier)

  {

    // Return the host name

    return new String[]{server};

  }

  /** Connect.

  *@param configParameters is the set of configuration parameters, which

  * in this case describe the target appliance, basic auth configuration, etc.

  */

  @Override

  public void connect(ConfigParams configParameters)

  {

    super.connect(configParameters);

    server = params.getParameter(WikiConfig.PARAM_SERVER);

  }

  protected void getSession()

    throws ManifoldCFException, ServiceInterruption

  {

    if (hasBeenSetup == false)

    {

      String protocol = params.getParameter(WikiConfig.PARAM_PROTOCOL);

      if (protocol == null || protocol.length() == 0)

        protocol = "http";

      String portString = params.getParameter(WikiConfig.PARAM_PORT);

      if (portString == null || portString.length() == 0)

        portString = null;

      String path = params.getParameter(WikiConfig.PARAM_PATH);

      if (path == null)

        path = "/w";

     

      baseURL = protocol + "://" + server + ((portString!=null)?":" + portString:"") + path + "/api.php?format=xml&";

      // Set up connection manager

      connectionManager = new MultiThreadedHttpConnectionManager();

      connectionManager.getParams().setMaxTotalConnections(1);

      hasBeenSetup = true;

    }

  }

 

  /** Check status of connection.

  */

  @Override

  public String check()

    throws ManifoldCFException

  {

    try

    {

      // Destroy saved session setup and repeat it

      hasBeenSetup = false;

      performCheck();

      return super.check();

    }

    catch (ServiceInterruption e)

    {

      return "Transient error: "+e.getMessage();

    }

    catch (ManifoldCFException e)

    {

      if (e.getErrorCode() == ManifoldCFException.INTERRUPTED)

        throw e;

      return "Error: "+e.getMessage();

    }

  }

  /** This method is periodically called for all connectors that are connected but not

  * in active use.

  */

  @Override

  public void poll()

    throws ManifoldCFException

  {

    if (connectionManager != null)

      connectionManager.closeIdleConnections(60000L);

  }

  /** Close the connection.  Call this before discarding the connection.

  */

  @Override

  public void disconnect()

    throws ManifoldCFException

  {

    hasBeenSetup = false;

    server = null;

    baseURL = null;

   

    if (connectionManager != null)

    {

      connectionManager.shutdown();

      connectionManager = null;

    }

    super.disconnect();

  }

  /** Get the maximum number of documents to amalgamate together into one batch, for this connector.

  *@return the maximum number. 0 indicates "unlimited".

  */

  @Override

  public int getMaxDocumentRequest()

  {

    return 20;

  }

  /** Queue "seed" documents.  Seed documents are the starting places for crawling activity.  Documents

  * are seeded when this method calls appropriate methods in the passed in ISeedingActivity object.

  *

  * This method can choose to find repository changes that happen only during the specified time interval.

  * The seeds recorded by this method will be viewed by the framework based on what the

  * getConnectorModel() method returns.

  *

  * It is not a big problem if the connector chooses to create more seeds than are

  * strictly necessary; it is merely a question of overall work required.

  *

  * The times passed to this method may be interpreted for greatest efficiency.  The time ranges

  * any given job uses with this connector will not overlap, but will proceed starting at 0 and going

  * to the "current time", each time the job is run.  For continuous crawling jobs, this method will

  * be called once, when the job starts, and at various periodic intervals as the job executes.

  *

  * When a job's specification is changed, the framework automatically resets the seeding start time to 0.  The

  * seeding start time may also be set to 0 on each job run, depending on the connector model returned by

  * getConnectorModel().

  *

  * Note that it is always ok to send MORE documents rather than less to this method.

  *@param activities is the interface this method should use to perform whatever framework actions are desired.

  *@param spec is a document specification (that comes from the job).

  *@param startTime is the beginning of the time range to consider, inclusive.

  *@param endTime is the end of the time range to consider, exclusive.

  */

  @Override

  public void addSeedDocuments(ISeedingActivity activities, DocumentSpecification spec,

    long startTime, long endTime)

    throws ManifoldCFException, ServiceInterruption

  {

    // Scan specification nodes and extract prefixes and namespaces

    boolean seenAny = false;

    for (int i = 0 ; i < spec.getChildCount() ; i++)

    {

      SpecificationNode sn = spec.getChild(i);

      if (sn.getType().equals(WikiConfig.NODE_NAMESPACE_TITLE_PREFIX))

      {

        String namespace = sn.getAttributeValue(WikiConfig.ATTR_NAMESPACE);

        String titleprefix = sn.getAttributeValue(WikiConfig.ATTR_TITLEPREFIX);

        listAllPages(activities,namespace,titleprefix,startTime,endTime);

        seenAny = true;

      }

    }

    if (!seenAny)

      listAllPages(activities,null,null,startTime,endTime);

  }

  /** Get document versions given an array of document identifiers.

  * This method is called for EVERY document that is considered. It is

  * therefore important to perform as little work as possible here.

  *@param documentIdentifiers is the array of local document identifiers, as understood by this connector.

  *@param oldVersions is the corresponding array of version strings that have been saved for the document identifiers.

  *   A null value indicates that this is a first-time fetch, while an empty string indicates that the previous document

  *   had an empty version string.

  *@param activities is the interface this method should use to perform whatever framework actions are desired.

  *@param spec is the current document specification for the current job.  If there is a dependency on this

  * specification, then the version string should include the pertinent data, so that reingestion will occur

  * when the specification changes.  This is primarily useful for metadata.

  *@param jobMode is an integer describing how the job is being run, whether continuous or once-only.

  *@param usesDefaultAuthority will be true only if the authority in use for these documents is the default one.

  *@return the corresponding version strings, with null in the places where the document no longer exists.

  * Empty version strings indicate that there is no versioning ability for the corresponding document, and the document

  * will always be processed.

  */

  @Override

  public String[] getDocumentVersions(String[] documentIdentifiers, String[] oldVersions, IVersionActivity activities,

    DocumentSpecification spec, int jobMode, boolean usesDefaultAuthority)

    throws ManifoldCFException, ServiceInterruption

  {

    Map<String,String> versions = new HashMap<String,String>();

    getTimestamps(documentIdentifiers,versions,activities);

    String[] rval = new String[documentIdentifiers.length];

    for (int i = 0 ; i < rval.length ; i++)

    {

      rval[i] = versions.get(documentIdentifiers[i]);

    }

    return rval;

  }

 

  /** Process a set of documents.

  * This is the method that should cause each document to be fetched, processed, and the results either added

  * to the queue of documents for the current job, and/or entered into the incremental ingestion manager.

  * The document specification allows this class to filter what is done based on the job.

  *@param documentIdentifiers is the set of document identifiers to process.

  *@param versions is the corresponding document versions to process, as returned by getDocumentVersions() above.

  *       The implementation may choose to ignore this parameter and always process the current version.

  *@param activities is the interface this method should use to queue up new document references

  * and ingest documents.

  *@param spec is the document specification.

  *@param scanOnly is an array corresponding to the document identifiers.  It is set to true to indicate when the processing

  * should only find other references, and should not actually call the ingestion methods.

  *@param jobMode is an integer describing how the job is being run, whether continuous or once-only.

  */

  public void processDocuments(String[] documentIdentifiers, String[] versions, IProcessActivity activities,

    DocumentSpecification spec, boolean[] scanOnly, int jobMode)

    throws ManifoldCFException, ServiceInterruption

  {

    Map<String,String> urls = new HashMap<String,String>();

    getDocURLs(documentIdentifiers,urls);

    for (int i = 0 ; i < documentIdentifiers.length ; i++)

    {

      if (!scanOnly[i])

      {

        String url = urls.get(documentIdentifiers[i]);

        if (url != null)

          getDocInfo(documentIdentifiers[i], versions[i], url, activities);

      }

    }

  }

 

  // UI support methods.

  //

  // These support methods come in two varieties.  The first bunch is involved in setting up connection configuration information.  The second bunch

  // is involved in presenting and editing document specification information for a job.  The two kinds of methods are accordingly treated differently,

  // in that the first bunch cannot assume that the current connector object is connected, while the second bunch can.  That is why the first bunch

  // receives a thread context argument for all UI methods, while the second bunch does not need one (since it has already been applied via the connect()

  // method, above).

   

  /** Output the configuration header section.

  * This method is called in the head section of the connector's configuration page.  Its purpose is to add the required tabs to the list, and to output any

  * javascript methods that might be needed by the configuration editing HTML.

  *@param threadContext is the local thread context.

  *@param out is the output to which any HTML should be sent.

  *@param parameters are the configuration parameters, as they currently exist, for this connection being configured.

  *@param tabsArray is an array of tab names.  Add to this array any tab names that are specific to the connector.

  */

  @Override

  public void outputConfigurationHeader(IThreadContext threadContext, IHTTPOutput out,

    Locale locale, ConfigParams parameters, List<String> tabsArray)

    throws ManifoldCFException, IOException

  {

    tabsArray.add(Messages.getString(locale,"WikiConnector.Server"));

    out.print(