Anleitung zur Erstellung einens neuen Content-Parsers für YaCy.

Inhaltsverzeichnis

1 Java Package anlegen
2 Parser Klasse erstellen
3 Implementierung des Parsers
4 Build File erstellen
5 YaCy Kompilieren
6 YaCy Starten
7 Parser aktivieren

Java Package anlegen

Zunächst muß ein neues Subpackage vom Java Package de.anomic.plasma.parser anlegt werden.

z.B. für einen Parser mit der Kurzbezeichnung sfw

de.anomic.plasma.parser.swf

Parser Klasse erstellen

Danach muß in diesem Verzeichnis eine neue Parser Klasse anlegen werden, deren Name dem folgenden Schema entspricht: [Parser-Kurzbezeichnung]Parser.java.

z.B.

swfParser.java

Implementierung des Parsers

Die neue Klasse muß das Interface de.anomic.plasma.parser.Parser implementieren und sollte von der abstrakten Klasse de.anomic.plasma.parser.AbstractParser abgeleitet sein.

Der grundlegende Aufbau der Klasse könnte so aussehen:

package de.anomic.plasma.parser.swf;

import java.io.InputStream;
import de.anomic.net.URL;
import java.util.Hashtable;

import de.anomic.plasma.plasmaParserDocument;
import de.anomic.plasma.parser.AbstractParser;
import de.anomic.plasma.parser.Parser;
import de.anomic.plasma.parser.ParserException;

public class swfParser extends AbstractParser implements Parser {

    /**
     * a list of mime types that are supported by this parser class
     * @see #getSupportedMimeTypes()
     */
    public static final Hashtable SUPPORTED_MIME_TYPES = new Hashtable();    
    static { 
        SUPPORTED_MIME_TYPES.put("application/x-shockwave-flash","swf");  
    }       
    
    public swfParser() {        
        super();
        this.parserName = "Macromedia Flash Parser";
        this.parserVersionNr = "0.1"; 
    }
    
    /**
     * returns a hashtable containing the mimetypes that are supported by this class
     */
    public Hashtable getSupportedMimeTypes() {
        return SUPPORTED_MIME_TYPES;
    }
    
    /*
     * parses the source documents and returns a plasmaParserDocument containing
     * all extracted information about the parsed document
     */ 
    public plasmaParserDocument parse(URL location, String mimeType, String charset, InputStream source) throws ParserException, InterruptedException {
        try {
           // TODO: add your individual parser code here

           // As the result of parsing this function must return a plasmaParserDocument object
            plasmaParserDocument theDoc = new plasmaParserDocument(
                    location,     // url of the source document
                    mimeType,     // the documents mime type
                    charset,      // charset of the document text
                    keywors,      // a list of extracted keywords
                    shortTitle,   // a short document title
                    longTitle,    // a long document title
                    sections,     // an array of section headlines
                    abstract,     // an abstract
                    bodyText,     // the parsed document text
                    anchors,      // a map of extracted anchors
                    images);      // a treeset of image URLs
            return theDoc;
        } catch (Exception e) { 
            if (e instanceof InterruptedException) throw (InterruptedException) e;

            // if an unexpected error occures just log the error and raise a new ParserException            
            String errorMsg = "Unable to parse the swf document '" + location + "':" + e.getMessage();
            this.theLogger.logSevere(errorMsg);            
            throw new ParserException(errorMsg, location);
        }
    }
    
    public void reset() {
	// this code is executed if the parser class is returned into the parser pool
    	super.reset();
    }

Konstruktor: swfParser()

   public swfParser() {        
       super();
       this.parserName = "Macromedia Flash Parser"; 
       this.parserVersionNr = "0.1"; 
   }

Benötigte Libraries definieren:

Im Konstruktor der Klasse wird der Konstruktor der Superklasse aufgerufen und diesem ein String-Array mit Namen der zum Betrieb der Klasse benötigten Java Libraries (Jar Dateien) übergeben.

super();

Im obigen Beispiel wird z.B. die jar Datei javaswf.jar zum Betrieb der Klasse zwingend benötigt. Dieses String Array wird dann beim Laden der Klasse verwendet um zu überprüfen ob alle benötigten Libraries im Java Classpath vorhanden sind. Fehlt eine der angegebenen Libraries wird im YaCy log eine Fehlermeldung ausgegeben und der Parser nicht aktiviert.

Parsername und Versionsnummer setzten:

Außerdem wird im Konstruktor der Name und die Versionsnummer des Parsers gesetzt, welche dann bei der Konfiguration der Parser über die Weboberfläche angezeigt werden.

this.parserName = "Macromedia Flash Parser";
this.parserVersionNr = "0.1";

Funktion: getSupportedMimeTypes()

   public Hashtable getSupportedMimeTypes() {
       return SUPPORTED_MIME_TYPES;
   }

Diese Funktion liefert als Output-Parameter eine Hashtable zurück, die angibt welche Mime-Types und File-Extensions von der Parser-Klasse unterstützt werden.

Key eines Hashtable Eintrags ist der Mime-Type-Name, z.B. application/x-shockwave-flash.

Value ist eine kommaseparierte Liste an File-Extensions die eine Datei mit diesem MimeType haben kann, z.B. swf

Diese Hashtable mit Mime-Types und File-Extensions wird von YaCy benutzt um festzustellen, ob ein vom Crawler zu ladendes Dokument überhaupt geparst werden kann. Dazu sieht YaCy in den Hashtables aller geladenen und aktivierten Parser nach, ob der Mime-Type des Dokumentes vorhanden ist und auch die File-Extension der Dokument-URL unterstützt wird. Ist beides der Fall wird das Dokument heruntergeladen und der entsprechenden Parser-Klasse zum Parsen übergeben.

Funktion: parse(URL location, String mimeType, String charset, InputStream source)

public plasmaParserDocument parse(URL location, String mimeType, String charset, InputStream source) 
   throws ParserException, InterruptedException 
{
   [...]
}

In dieser Funktion findet der eigentliche Parsing-Vorgang statt.

Input Parameter:

Als Input-Parameter erhält die Funktion die URL (Variable location), den Mime-Type (Variable mimeType) und die Zeichenkodierung (Variable charset) des zu parsenden Dokumentes sowie einen InputStream (Variable source) über den der Dokumenten-Text abgerufen werden kann.

Rückgabewert:

Nach dem erfolgreichen Parsen des Quell-Dokuments muss diese Funktion ein plasmaParserDocument Objekt zurückliefern welches folgenden Aufbau hat:

           plasmaParserDocument theDoc = new plasmaParserDocument(
                   location,     // url of the source document
                   mimeType,     // the documents mime type
                   charset,      // charset of the document text
                   keywors,      // a list of extracted keywords
                   shortTitle,   // a short document title
                   longTitle,    // a long document title
                   sections,     // an array of section headlines
                   abstract,     // an abstract
                   bodyText,     // the parsed document text
                   anchors,      // a map of extracted anchors
                   images);      // a treeset of image URLs

Dieses Objekt enthält alle vom Quell-Dokument extrahierten Informationen wie extrahierte Schlagwörter (Keywords), einen Kurztitel, einen langen Dokument-Titel, mehrere Headlines, ein Kurzbeschreibung, den vollständig extrahierten Text sowie Liste von im Dokument gefundenen Links und Referenzen auf Bilder.

Im Fehlerfall:

Im Fehlerfall sollte die Parser-Klasse den Fehler loggen (eine Logger Klasse ist über die Variable theLogger erreichbar) und danach eine ParserException werfen.

       } catch (Exception e) { 
           if (e instanceof InterruptedException) throw (InterruptedException) e;

           // if an unexpected error occures just log the error and raise a new ParserException            
           String errorMsg = "Unable to parse the swf document '" + location + "':" + e.getMessage();
           this.theLogger.logSevere(errorMsg);            
           throw new ParserException(errorMsg, location);
       }

Funktion: reset()

Achtung: Die Parser Klasse wird nach ihrer Verwendung nicht dem Java Garbage Collector übergeben, sondern in einem Object Pool zur Wiederverwendung aufbewahrt. Daher muß die Klasse so programmiert sein, daß alle internen Variablen vor einer neuerlichen Verwendung der Klasse wieder einen gültigen Status erreichen. Die kann z.B. in der Funktion reset() durchgeführt werden die aufgerufen wird, bevor die Klasse in den Objekt Pool zurückgegeben wird.

Build File erstellen

Jeder YaCy Parser muß sein eigenes Ant Build File mitbringen, welches dann beim Kompilieren automatisch vom YaCy Main-Build File aufgerufen wird.

Der grundlegende Aufbau des Build-Files könnte so aussehen:

<?xml version="1.0"?>
<project name="YACY - swfParser" default="dist">
    <description>A class to parse swf files</description>
 
    <!-- the parsers short name -->
    <property name="parserShortName" value="swf"/>
    
    <!-- parser version number -->
    <property name="parserVersion" value="0.1"/>

    <property name="parserLongName" value="yacyContentParser_${parserShortName}"/>    	
    <property name="parserArchive" location="${release}/${parserLongName}_${parserVersion}.tgz"/>	    	
    	
    <!-- compile the sources of this parser -->
    <target name="compile">
  	  <javac srcdir="${src}/de/anomic/plasma/parser/${parserShortName}" destdir="${build}" source="${javacSource}" target="${javacTarget}" debug="true" debuglevel="lines,vars,source">
  	  	<classpath>
  	  	  <pathelement location="${build}" />	
  	  	</classpath>
  	  </javac>    	
    </target>
	
    <!-- add all parts of this parser into a single zip file -->
    <target name="zip" depends="compile">
  	  <tar destfile="${parserArchive}" compression="gzip">	  	
		<!-- source files of this parser -->
  	  	<tarfileset dir="${src}/de/anomic/plasma/parser/${parserShortName}" 
  	  				prefix="${releaseFileParentDir}/source/de/anomic/plasma/parser/${parserShortName}"
			  	  	dirmode="755" mode="644"/>
  	  	<!-- class files of this parser -->
  	  	<tarfileset dir="${build}/de/anomic/plasma/parser/${parserShortName}" 
  	  				prefix="${releaseFileParentDir}/classes/de/anomic/plasma/parser/${parserShortName}"
			  	  	dirmode="755" mode="644"/>	  	
  	  </tar>    	
    </target>	

    <!-- just copy all parts of this parser into the release directory -->
    <target name="copy" depends="compile">
        <!-- copy source code files -->
        <copy todir="${release}/source/de/anomic/plasma/parser/${parserShortName}">
             <fileset dir="${src}/de/anomic/plasma/parser/${parserShortName}" includes="**/*"/> 
        </copy>        
	
        <!-- copy compiled classes -->
        <copy todir="${release}/classes/de/anomic/plasma/parser/${parserShortName}">
             <fileset dir="${build}/de/anomic/plasma/parser/${parserShortName}" includes="**/*"/> 
        </copy>         
    </target> 
     
    <target name="dist" depends="compile,zip" description="Compile and zip the parser"/>        
	
</project>

In dem meisten Fällen kann obiges Build-File fast zur gänze übernommen werden. Änderungen sind nur an folgenden Stellen notwendig:

Parser Kurzname und Version setzten:

    <property name="parserShortName" value="swf"/>
    <property name="parserVersion" value="0.1"/>

Note: Diese Kurzbezeichnung ist der Java Package Name des Parsers.

YaCy Kompilieren

Beim Kompilieren von YaCy mittels Ant wird dann automatisch das Build File des neuen Parsers aufgerufen und es erscheint im Erfolgsfall folgende Meldung auf der Konsole

[...]
compile:
    [javac] Compiling 1 source file to D:\yacy\classes
copy:
     [copy] Copying 1 files to D:\yacy\RELEASE\EXT\source\de\anomic\plasma\parser\swf
     [copy] Copying 1 files to D:\yacy\RELEASE\EXT\classes\de\anomic\plasma\parser\swf
[...]

YaCy Starten

Beim Start von YaCy erscheinen im Logfile Meldungen über alle gefundenen und erfolgreichen geladenen Parser. Z.B.

S 2006/09/08 17:22:34 PLASMA Starting Parser
I 2006/09/08 17:22:34 PARSER Searching for additional content parsers in package de.anomic.plasma.parser
[...]
I 2006/09/08 17:22:34 PARSER Found functional parser for mimeType 'application/x-shockwave-flash'.
	Name:    Macromedia Flash Parser
	Version: 0.1
	Class:   de.anomic.plasma.parser.swf.swfParser
	Dependencies: javaswf.jar
[...]
S 2006/09/08 17:22:34 PLASMA Parser: Initializing Extension Mappings for Media/Parser
S 2006/09/08 17:22:34 PLASMA Parser: Initializing Mime Types

Parser aktivieren

Im letzten Schritt muß der neue Parser noch über die YaCy Weboberfläche aktiviert werden um seine Funktion aufnehmen zu können. http://localhost:8090/Settings_p.html?page=parser

De:NewParser

Inhaltsverzeichnis

Java Package anlegen

Parser Klasse erstellen

Implementierung des Parsers

Konstruktor: swfParser()

Funktion: getSupportedMimeTypes()

Funktion: parse(URL location, String mimeType, String charset, InputStream source)

Funktion: reset()

Build File erstellen

YaCy Kompilieren

YaCy Starten

Parser aktivieren

Navigationsmenü

Meine Werkzeuge

Namensräume

Varianten

Ansichten

Mehr

Suche

Gemeinschaftsportal

Navigation

Werkzeuge