fr.efl.chaine.xslt

Class GauloisPipe

java.lang.Object

fr.efl.chaine.xslt.GauloisPipe

public class GauloisPipe
extends Object

The saxon pipe.

Field Summary

Fields

Modifier and Type	Field and Description
static String	GAULOIS_DEBUG_DIR_PROPERTY The property name to specify the debug output directory
static String	INSTANCE_DEFAULT_NAME

Constructor Summary

Constructors

Constructor and Description
GauloisPipe(SaxonConfigurationFactory configurationFactory) Constructs a new GauloisPipe.
GauloisPipe(SaxonConfigurationFactory configurationFactory, List<String> inputs, String outputDirectory, List<String> templatePaths, int nbThreads, String instanceName) The constructor with detail config.

Method Summary

Modifier and Type	Method and Description
protected URIResolver	buildUriResolver(URIResolver defaultUriResolver) Build the uri resolver.
void	collectError(Exception ex, String... message) Adds an error to the error reporting system
void	collectError(GauloisRunException ex, String... message)
void	doPostCloseService(ExecutionContext context)
void	execute(Pipe pipe, ParametrableFile input, net.sf.saxon.s9api.MessageListener listener, Map<String,OutputStream>... outputs) Execute the pipe for the specified input stream to the specified serializer.
Config	getConfig() Returns the config the gaulois-pipe is configured to process.
protected String	getCurrentDirUri()
DatatypeFactory	getDatatypeFactory()
int	getDocumentCacheSize() Returns ...
List<String>	getErrors()
String	getInstanceName()
protected ThreadFactory	getThreadFactory()
URIResolver	getUriResolver()
int	getXsltCacheSize() Returns...
void	launch() Launch the pipe.
static void	main(String[] args) Main entry point of saxon xslt pipe.
Config	parseCommandLine(String[] args)
protected void	sendError(String error)
void	setConfig(Config config)
void	setInstanceName(String instanceName)
void	setMessageListenerclass(Class messageListenerclass) Set the MessageListener class to use.
void	setThreadFactory(ThreadFactory threadFactory) Sets the ThreadFactory to be used by executors.
protected void	startErrorCollector()
protected int	terminateErrorCollector()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

INSTANCE_DEFAULT_NAME

public static final String INSTANCE_DEFAULT_NAME

See Also:

Constant Field Values

GAULOIS_DEBUG_DIR_PROPERTY

public static final transient String GAULOIS_DEBUG_DIR_PROPERTY

The property name to specify the debug output directory

See Also:

Constant Field Values

Constructor Detail

GauloisPipe

public GauloisPipe(SaxonConfigurationFactory configurationFactory)
            throws InvalidSyntaxException

Constructs a new GauloisPipe. This constructor is the main one, the other one is only for backward compatibility.

Parameters:

configurationFactory - The configuration factory to use

Throws:

InvalidSyntaxException

GauloisPipe

public GauloisPipe(SaxonConfigurationFactory configurationFactory,
                   List<String> inputs,
                   String outputDirectory,
                   List<String> templatePaths,
                   int nbThreads,
                   String instanceName)
            throws InvalidSyntaxException

The constructor with detail config. It shouldn't be used anymore.

Parameters:

configurationFactory - The Saxon's Configuration factory to use

inputs - the input files

outputDirectory - the output directory

templatePaths - the template paths

nbThreads - the nbThreads

instanceName - The instance name to use in the logs

Throws:

InvalidSyntaxException - If config's syntax is incorrect

Method Detail

launch

public void launch()
            throws InvalidSyntaxException,
                   FileNotFoundException,
                   net.sf.saxon.s9api.SaxonApiException,
                   URISyntaxException,
                   IOException

Launch the pipe.

Throws:

InvalidSyntaxException - If config's syntax is incorrect

FileNotFoundException - If a file is not found...

net.sf.saxon.s9api.SaxonApiException - If a SaxonApi problem occurs

URISyntaxException - Because MVN forces to have comments...

IOException

getDocumentCacheSize

public int getDocumentCacheSize()

Returns ...

Returns:

the size of the document cache. Mainly used for UT

getXsltCacheSize

public int getXsltCacheSize()

Returns...

Returns:

the size of XSLT cache. Mainly used by UT

getErrors

public List<String> getErrors()

getConfig

public Config getConfig()

Returns the config the gaulois-pipe is configured to process. Pipe is inside the config.

Returns:

The actual config.

execute

public void execute(Pipe pipe,
                    ParametrableFile input,
                    net.sf.saxon.s9api.MessageListener listener,
                    Map<String,OutputStream>... outputs)
             throws net.sf.saxon.s9api.SaxonApiException,
                    MalformedURLException,
                    InvalidSyntaxException,
                    URISyntaxException,
                    FileNotFoundException,
                    IOException

Execute the pipe for the specified input stream to the specified serializer.
Warning: this method is public, but should not be called outside of gaulois-pipe, as it doesn't use thread pool. Really be carfull if you need to use it. If outputs is provided, it must be a single Map, that contains OutputStream where to redirect output to. The map's key entries are the //output/@id defined in config file. Only output that have an @id may be redirected to an existing OutputStream.

Parameters:

pipe - the pipe to run

input - the specified input stream

listener - the message listener to use

outputs - An optional map that contains OutputStream to bind to cfg:output elements.

Throws:

net.sf.saxon.s9api.SaxonApiException - when a problem occurs

MalformedURLException - When an URL is not correctly formed

InvalidSyntaxException - When config file is invalid

URISyntaxException - When URI is invalid

FileNotFoundException - And when the file can not be found !

IOException

buildUriResolver

protected URIResolver buildUriResolver(URIResolver defaultUriResolver)

Build the uri resolver.

Parameters:

defaultUriResolver - Default Saxon's URIResolver

Returns:

the uri resolver built

doPostCloseService

public void doPostCloseService(ExecutionContext context)

main

public static void main(String[] args)

Main entry point of saxon xslt pipe.
The arguments are :

• --config config-file.xml the pipe-definition config file (optional)
• -o, --output outputDirectory the output directory
• -n,--nbthreads n the number of threads
• PARAMS p1=v1 p2=v2 the parameters to give to XSL
• XSL f1.xsl f2.xsl ... the stylesheets list used by the pipe
• FILES file1.xml file2.xml ... the files to process

If --config option is given, it must be in first position, and all other options may be ignored. It is impossible to overwrite a config-file.xml option via command-line option, but it is possible to add XSL, input files and parameters

It is possible to define a pipe parameter for a single input file or a single XSL : just add parenthesis after the file/xsl URI, with comma-separated list of parameter=value

Command samples :

• GauloisPipe -o path/to/out -n 4 PARAMS p1=xxx p2=yyy XSL path/to/xslt1 ... path/to/xsltN FILES path/to/input1 ... path/to/inputN
  • Executes with 4 threads the pipe xslt1 to xsltN on input1 to inputN, and writes output to path/to/out
• SaxonPipe --config config.xml FILES f12.xml(foo=bar)
  • Executes pipe defined in config.xml on files defined in config.xml AND on f12.xml, with param foo=bar

Files whom size is over multi-thread limit (default is 10Mb) are processed first, on a single-thread waiting queue. Then, files whom size is under limit are processed on the multi-threaded waiting queue.

Using config file gives much more control on Saxon-pipe on things taht can't be set via command-line :

• pipe definition is enhanced
• output naming strategy can be defined
• pattern-matching and recursion can be applied on input-files
• file-process order and on multi-thread limit size can be defined

Parameters:

args - the arguments

setMessageListenerclass

public void setMessageListenerclass(Class messageListenerclass)

Set the MessageListener class to use. The only way to set a message listener is to define its class. Gaulois-pipe wille create an instance of this class, calling the default constructor. This method must be called before the launch() call.

Parameters:

messageListenerclass - The class of the listener to use

parseCommandLine

public Config parseCommandLine(String[] args)
                        throws InvalidSyntaxException

Throws:

InvalidSyntaxException

getUriResolver

public URIResolver getUriResolver()

setInstanceName

public void setInstanceName(String instanceName)

setConfig

public void setConfig(Config config)

getInstanceName

public String getInstanceName()

setThreadFactory

public void setThreadFactory(ThreadFactory threadFactory)

Sets the ThreadFactory to be used by executors. If not defined, Executors.defaultThreadFactory() is used. Warning: if you define your own ThreadFactory, be aware that log messages may change, as thread names are defined by the ThreadFactory, not by gaulois-pipe.

Parameters:

threadFactory - The threadFactory to use

getThreadFactory

protected ThreadFactory getThreadFactory()

collectError

public void collectError(Exception ex,
                         String... message)

Adds an error to the error reporting system

Parameters:

ex - The exception thrown to be reported

message - Optionnal messages to report

collectError

public void collectError(GauloisRunException ex,
                         String... message)

sendError

protected void sendError(String error)

startErrorCollector

protected void startErrorCollector()

terminateErrorCollector

protected int terminateErrorCollector()

getCurrentDirUri

protected String getCurrentDirUri()

getDatatypeFactory

public DatatypeFactory getDatatypeFactory()