private void init()
    {
        File configFile = 
            new File(
                    FileUtils.getClusterConfigDirectory(), 
                    "reportengine.properties"
                    );
        
        this.config = new EngineConfig();
        
        Properties configuration = new Properties();
        try {
            configuration.load(new FileInputStream(configFile));
            
            for(Object key : configuration.keySet())
            {
                if(IPlatformConfig.BIRT_HOME.equals(key))
                {
                    File home = new File(
                                FileUtils.getHomeDirectory(),
                                configuration.getProperty(key.toString())
                            );
                    
                    if(home.exists() && home.canRead())
                    {
                        this.config.setEngineHome(home.getAbsolutePath());
                    }
                    else
                    {
                        Logger.error(this, 
                                "ReportEngine root folder could not be initialized for folder "
                                +home.getAbsolutePath()
                                );
                    }
                }
                else if(key != null)
                {
                    this.config.setProperty(
                            key.toString(), 
                            configuration.getProperty(key.toString())
                            );
                }
            }
            
        } catch (FileNotFoundException e) {
            Logger.error(this, "Error reading report engine configuration", e);
        } catch (IOException e) {
            Logger.error(this, "Error reading report engine configuration", e);
        }
    }

class ReportExecutionCallable implements Callable<Void>
{
    private final Report report;

    private final Collection<ReportParameter> parameters;

    private final ReportOutputFormat format;

    private final OutputStream out;

    public ReportExecutionCallable(Report report,
            Collection<ReportParameter> parameters, ReportOutputFormat format,
            OutputStream out)
    {
        if (report == null)
        {
            throw new IllegalArgumentException("Can't create report execution "
                    + "callable for report = null.");
        }

        if (out == null)
        {
            throw new IllegalArgumentException("Can't create report execution "
                    + "callable. The output stream that the report "
                    + "should be written to is null.");
        }

        this.report = report;
        this.parameters = (parameters == null) ? new ArrayList<ReportParameter>()
                : parameters;
        this.format = (format == null) ? report.getDefaultOutputFormat()
                : format;
        this.out = out;
    }

    public Void call() throws Exception
    {
        IReportEngine reportEngine = MyReportEngineConfig.getInstance()
                .getReportEngine();

        String reportFile = ReportingUtils.getReportFilePath(report);
        IReportRunnable design = reportEngine.openReportDesign(reportFile);

        IRunAndRenderTask task = reportEngine.createRunAndRenderTask(design);

        RenderOption renderOption = new RenderOption();
        renderOption.setOutputFormat(format.getFormatterName());
        renderOption.setOutputStream(out);

        task.setRenderOption(renderOption);

        Map<String, Object> parametersMap = new HashMap<String, Object>();

        Collection<ReportParameter> reportParameters = report
                .getReportParameters();

        addToParametersMap(reportParameters, parametersMap);
        addToParametersMap(parameters, parametersMap);

        task.setParameterValues(parametersMap);

        if (!task.validateParameters())
        {
            throw new IllegalArgumentException(
                    "Report parameter validation failed.");
        }

        task.run();

        task.close();

        return null;
    }

    private void addToParametersMap(Collection<ReportParameter> parameters,
            Map<String, Object> parametersMap)
    {
        for (ReportParameter parameter : parameters)
        {
            // TODO parameter value might not be a string
            parametersMap.put(parameter.getName(), parameter.getValue());
        }
    }
}