Droolstest.java

package com.sample;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Random;
import java.util.concurrent.TimeUnit;

import org.drools.KnowledgeBase;
import org.drools.KnowledgeBaseConfiguration;
import org.drools.KnowledgeBaseFactory;
import org.drools.builder.KnowledgeBuilder;
import org.drools.builder.KnowledgeBuilderError;
import org.drools.builder.KnowledgeBuilderErrors;
import org.drools.builder.KnowledgeBuilderFactory;
import org.drools.builder.ResourceType;
import org.drools.conf.EventProcessingOption;
import org.drools.io.ResourceFactory;
import org.drools.runtime.KnowledgeSessionConfiguration;
import org.drools.runtime.StatefulKnowledgeSession;
import org.drools.runtime.conf.ClockTypeOption;
import org.drools.time.SessionPseudoClock;

/**
 * This is a sample class to launch a rule.
 */
public class DroolsTest {

    static class rulesThread extends Thread {
        StatefulKnowledgeSession _ksession;
        public rulesThread(StatefulKnowledgeSession k) {
            _ksession = k;
        }
        public void run() {
            _ksession.fireUntilHalt();
        }
    }

    public static final void main(String[] args) {
        try {
            //generate rawEvent
            generateRawEvents("rawEvents.source");
            // load up the knowledge base
            KnowledgeBase kbase = readKnowledgeBase();
            KnowledgeSessionConfiguration config = KnowledgeBaseFactory.newKnowledgeSessionConfiguration();
            config.setOption( ClockTypeOption.get("pseudo") );
            StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession(config, null);
            // go !
            rulesThread mt = new rulesThread(ksession);
            mt.start();
            System.out.println("sending events");
            sendEvents("rawEvents.source", ksession);
            System.out.println("no more events to send");
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }

    @SuppressWarnings("restriction")
    private static void sendEvents(String filePath, StatefulKnowledgeSession ksession) {
        try {
            FileInputStream fstream = new FileInputStream(filePath);
            DataInputStream in = new DataInputStream(fstream);
            BufferedReader br = new BufferedReader(new InputStreamReader(in));
            SessionPseudoClock clock = ksession.getSessionClock();
            String strLine;
            //Read File Line By Line
            while ((strLine = br.readLine()) != null)   {
                RawEvent re = new RawEvent();
                if (re.parse(strLine)) {
                    clock.advanceTime( re.getTimestamp().getTime() - clock.getCurrentTime() , TimeUnit.MILLISECONDS );
                    ksession.insert(re);
                }
            }
            fstream.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    private static KnowledgeBase readKnowledgeBase() throws Exception {
        KnowledgeBaseConfiguration config = KnowledgeBaseFactory.newKnowledgeBaseConfiguration();
        config.setOption( EventProcessingOption.STREAM );
        KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
        kbuilder.add(ResourceFactory.newClassPathResource("Sample.drl"), ResourceType.DRL);
        KnowledgeBuilderErrors errors = kbuilder.getErrors();
        if (errors.size() > 0) {
            for (KnowledgeBuilderError error: errors) {
                System.err.println(error);
            }
            throw new IllegalArgumentException("Could not parse knowledge.");
        }
        KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase(config);
        kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());
        return kbase;
    }

    private static long rand(Random r, long s, long e) {
        return (long)((e - s + 1) * r.nextDouble())+s;
    }

    private static void generateRawEvents(String filePath) {
        DateFormat formatter = new SimpleDateFormat("yyyy MMM dd HH:mm:ss");
        Date startDay = new Date();
        Random  source = new Random();
        long nbscenario = 10;
        ArrayList<RawEvent> list = new ArrayList<RawEvent>();
        for (long curScenar = 0 ; curScenar < nbscenario ; curScenar++) {
            long beg = startDay.getTime()+ rand(source, 1, 1*60*60*24*3) * 1000;
            long end = beg+rand(source, 1, 1*60*60*12/3) * 1000;
            long id = rand(source, 0, 20);
            System.out.println(id);
            while (beg < end) {
                RawEvent tmp = new RawEvent();
                tmp.parse("timestamp="+formatter.format(new Date(beg))+", test="+(rand(source, 0, 500) == 0)+", id="+id);
                list.add(tmp);
                beg += rand(source, 0, 89) * 1000;
            }
        }
        Collections.sort(list);
        try {
            FileOutputStream sourcefile = new FileOutputStream(filePath, false);
            for (RawEvent s : list) {
                sourcefile.write((s.toString()+'\n').getBytes());
            }
            sourcefile.close();
        }
        catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}