diff options
author | Henri Herscher <henri@oreka.org> | 2005-10-20 13:40:58 +0000 |
---|---|---|
committer | Henri Herscher <henri@oreka.org> | 2005-10-20 13:40:58 +0000 |
commit | 7e1d63dd9fd149e4934bf77095c8610fac786b04 (patch) | |
tree | 5fe486a1b0300c3b84fb559107a868e5cc2c95da /orktrack/src/net/sf | |
parent | 467768fc956fc3e5a253373f26c71c681b31b6b8 (diff) |
First checkin
git-svn-id: https://oreka.svn.sourceforge.net/svnroot/oreka/trunk@2 09dcff7a-b715-0410-9601-b79a96267cd0
Diffstat (limited to 'orktrack/src/net/sf')
17 files changed, 2242 insertions, 0 deletions
diff --git a/orktrack/src/net/sf/oreka/orktrack/CommandServlet.java b/orktrack/src/net/sf/oreka/orktrack/CommandServlet.java new file mode 100644 index 0000000..cf8fc1a --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/CommandServlet.java @@ -0,0 +1,115 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack; + +import java.io.IOException; +import java.io.PrintWriter; + +import javax.servlet.ServletException; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import net.sf.oreka.OrkException; +import net.sf.oreka.OrkObjectFactory; +import net.sf.oreka.messages.AsyncMessage; +import net.sf.oreka.messages.SimpleResponseMessage; +import net.sf.oreka.messages.SyncMessage; +import net.sf.oreka.messages.test.TestMessage; +import net.sf.oreka.serializers.ServletRequestSerializer; +import net.sf.oreka.serializers.SingleLineSerializer; + +import org.apache.log4j.Logger; + +public class CommandServlet extends HttpServlet { + + static Logger logger = Logger.getLogger(CommandServlet.class); + + public void doGet(HttpServletRequest request, HttpServletResponse response) + throws IOException, ServletException + { + OrkObjectFactory.instance().registerOrkObject(new TestMessage()); + + ServletRequestSerializer ser = new ServletRequestSerializer(); + + try { + SyncMessage obj = (SyncMessage)ser.deSerialize(request); + AsyncMessage rsp = obj.process(); + SingleLineSerializer ser2 = new SingleLineSerializer(); + PrintWriter out = response.getWriter(); + out.println(ser2.serialize(rsp)); + } + catch (Exception e) { + SimpleResponseMessage rsp = new SimpleResponseMessage(); + rsp.setComment(e.getMessage()); + rsp.setSuccess(false); + SingleLineSerializer ser2 = new SingleLineSerializer(); + PrintWriter out = response.getWriter(); + try { + out.println(ser2.serialize(rsp)); + } + catch (OrkException ae) { + out.println("Error:" + ae.getMessage()); + } + } + +// SingleLineSerializer ser2 = new SingleLineSerializer(); +// try { +// OrkObject obj = ser.deSerialize(request); +// response.setContentType("text/html"); +// PrintWriter out = response.getWriter(); +// out.println("<html>"); +// out.println("<head>"); +// out.println("<title>Sucess</title>"); +// out.println("</head>"); +// out.println("<body>"); +// out.println("<h1>"); +// out.println(ser2.serialize(obj)); +// out.println("</h1>"); +// out.println("</body>"); +// out.println("</html>"); +// } +// catch (OrkException e) { +// response.setContentType("text/html"); +// PrintWriter out = response.getWriter(); +// out.println("<html>"); +// out.println("<head>"); +// out.println("<title>Error</title>"); +// out.println("</head>"); +// out.println("<body>"); +// out.println("<h1>"); +// out.println(e.getMessage()); +// out.println("</h1>"); +// out.println("</body>"); +// out.println("</html>"); +// } + +// logger.log(Level.INFO, request.getPathInfo()); +// logger.log(Level.INFO, request.getRequestURL()); +// logger.log(Level.INFO, request.getQueryString()); +// logger.log(Level.INFO, request.getParameter("toto")); +// logger.log(Level.INFO, request.getParameter("titi")); +// +// response.setContentType("text/html"); +// PrintWriter out = response.getWriter(); +// out.println("<html>"); +// out.println("<head>"); +// out.println("<title>Hello World!</title>"); +// out.println("</head>"); +// out.println("<body>"); +// out.println("<h1>Hello World!</h1>"); +// out.println("</body>"); +// out.println("</html>"); + } +} diff --git a/orktrack/src/net/sf/oreka/orktrack/ConfigManager.java b/orktrack/src/net/sf/oreka/orktrack/ConfigManager.java new file mode 100644 index 0000000..1ac9039 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/ConfigManager.java @@ -0,0 +1,86 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +/** + * + */ +package net.sf.oreka.orktrack; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.InputStream; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; + +import net.sf.oreka.OrkException; +import net.sf.oreka.serializers.DomSerializer; + +import org.apache.log4j.Logger; +import org.w3c.dom.Document; + +/** + * This singleton class manages all application configuration parameters + */ +public class ConfigManager { + + static ConfigManager configManager = null; + + Logger log = null; + OrkTrackConfig config = null; + + private ConfigManager() { + config = new OrkTrackConfig(); + log = LogManager.getInstance().getConfigLogger(); + } + + public static ConfigManager getInstance() + { + if (configManager == null) + { + configManager = new ConfigManager(); + } + return configManager; + } + + public void load(String filename) { + + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + try { + File file = new File(filename); + DocumentBuilder builder = factory.newDocumentBuilder(); + InputStream is = new FileInputStream(file); + Document doc = builder.parse(is); + DomSerializer ser = new DomSerializer(); + config = (OrkTrackConfig)ser.deSerialize(doc.getFirstChild()); + } + catch (OrkException e) { + log.error("ConfigManager.load: deserialization error:" + e.getMessage()); + } + catch (FileNotFoundException e) { + log.error("ConfigManager.load config file does not exist:" + filename + " check your web.xml"); + } + catch (Exception e) { + log.error("ConfigManager.load: exception:" + e.getMessage()); + } + } + + public OrkTrackConfig getConfig() { + return config; + } + + public void setConfig(OrkTrackConfig config) { + this.config = config; + } +} diff --git a/orktrack/src/net/sf/oreka/orktrack/ContextListener.java b/orktrack/src/net/sf/oreka/orktrack/ContextListener.java new file mode 100644 index 0000000..b8bf558 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/ContextListener.java @@ -0,0 +1,90 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack; + +import javax.servlet.ServletContext; +import javax.servlet.ServletContextEvent; +import javax.servlet.ServletContextListener; + +import org.apache.log4j.Logger; + +public class ContextListener implements ServletContextListener { + + Logger log = LogManager.getInstance().getContextLogger(); + + public void contextDestroyed(ServletContextEvent arg0) { + + log.info(OrkTrack.APP_NAME + " shutting down."); + } + + public void contextInitialized(ServletContextEvent servletContextEvent) { + + ServletContext context = servletContextEvent.getServletContext(); + String log4jConfigFile = context.getInitParameter("Log4jConfigFile"); + +// boolean complainAboutLog4jConfigFile = false; +// if (log4jConfigFile != null) { +// LogManager.getInstance().configure(log4jConfigFile); +// } +// else { +// complainAboutLog4jConfigFile = true; +// } + if (log4jConfigFile == null) { + System.out.println("Log4jConfigFile context-param missing in web.xml"); + } + +// log.info("========================================"); +// log.info(OrkTrack.APP_NAME + " starting ..."); + +// if(complainAboutLog4jConfigFile) { +// log.warn("contextInitialized: Log4jConfigFile context-param missing in web.xml"); +// } + + // Register all OrkObjects +// OrkObjectFactory.instance().registerOrkObject(new OrkTrackConfig()); + + String configFile = context.getInitParameter("ConfigFile"); +// if (configFile != null) { +// ConfigManager.getInstance().load(configFile); +// } +// else { +// log.error("contextInitialized: ConfigFile context-param missing in web.xml"); +// } + if (configFile == null) { + System.out.println("ConfigFile context-param missing in web.xml"); + } + + String hibernateConfigFile = context.getInitParameter("HibernateConfigFile"); +// if (hibernateConfigFile != null) { +// try { +// HibernateManager.configure(hibernateConfigFile); +// } +// catch (Exception e) { +// log.error("contextInitialized: Error configuring Hibernate:" + e.getMessage()); +// } +// } +// else { +// log.error("contextInitialized: HibernateConfigFile context-param missing in web.xml"); +// } + if (hibernateConfigFile == null) { + System.out.println("HibernateConfigFile context-param missing in web.xml"); + } + + //PortManager.instance().initialize(); + + OrkTrack.initialize(log4jConfigFile, hibernateConfigFile, configFile); + } + + +} diff --git a/orktrack/src/net/sf/oreka/orktrack/LogManager.java b/orktrack/src/net/sf/oreka/orktrack/LogManager.java new file mode 100644 index 0000000..1c5be27 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/LogManager.java @@ -0,0 +1,126 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack; + +import java.io.File; + +import org.apache.log4j.BasicConfigurator; +import org.apache.log4j.Level; +import org.apache.log4j.Logger; +import org.apache.log4j.PropertyConfigurator; + +/** + * This singleton class manages all application log4j loggers + */ +public class LogManager { + + static LogManager logManager = null; + + Logger rootLogger = null; + Logger configLogger = null; + Logger contextLogger = null; + Logger portLogger = null; + Logger userLogger = null; + + private LogManager() + { + rootLogger = Logger.getRootLogger(); + rootLogger.setLevel(Level.INFO); + configLogger = Logger.getLogger("config"); + contextLogger = Logger.getLogger("context"); + portLogger = Logger.getLogger("port"); + userLogger = Logger.getLogger("user"); + + BasicConfigurator.configure(); // in case there is no properties file + } + + public static LogManager getInstance() + { + if (logManager == null) + { + logManager = new LogManager(); + } + return logManager; + } + + public void configure(String filename) { + + // Check wether filename is valid + File file = new File(filename); + if (file.exists()) { + // Attempt to configure log4j + PropertyConfigurator.configure(filename); + } + else { + configLogger.warn("Log4j properties file does not exist:" + filename + " check your web.xml"); + } + } + + /** + * @return Returns the rootLogger. + */ + public Logger getRootLogger() { + return rootLogger; + } + + + /** + * @param rootLogger The rootLogger to set. + */ + public void setRootLogger(Logger rootLogger) { + this.rootLogger = rootLogger; + } + + /** + * @return Returns the configLogger. + */ + public Logger getConfigLogger() { + return configLogger; + } + + + /** + * @param configLogger The configLogger to set. + */ + public void setConfigLogger(Logger configLogger) { + this.configLogger = configLogger; + } + + public Logger getContextLogger() { + return contextLogger; + } + + public void setContextLogger(Logger contextLogger) { + this.contextLogger = contextLogger; + } + + public Logger getPortLogger() { + return portLogger; + } + + public void setPortLogger(Logger portLogger) { + this.portLogger = portLogger; + } + + public Logger getUserLogger() { + return userLogger; + } + + public void setUserLogger(Logger userLogger) { + this.userLogger = userLogger; + } + + + +}
\ No newline at end of file diff --git a/orktrack/src/net/sf/oreka/orktrack/OrkTest.java b/orktrack/src/net/sf/oreka/orktrack/OrkTest.java new file mode 100644 index 0000000..b1750b3 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/OrkTest.java @@ -0,0 +1,24 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack; + +import org.apache.log4j.Logger; + +public class OrkTest { + + public static void main(String args[]) throws Exception + { + Logger log = LogManager.getInstance().getContextLogger(); + } +} diff --git a/orktrack/src/net/sf/oreka/orktrack/OrkTrack.java b/orktrack/src/net/sf/oreka/orktrack/OrkTrack.java new file mode 100644 index 0000000..5bd8a9c --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/OrkTrack.java @@ -0,0 +1,74 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +/** + * + */ +package net.sf.oreka.orktrack; + +import net.sf.oreka.OrkObjectFactory; +import net.sf.oreka.HibernateManager; +import net.sf.oreka.orktrack.messages.MetadataMessage; +import net.sf.oreka.orktrack.messages.TapeMessage; +import net.sf.oreka.orktrack.messages.UserStateMessage; + +import org.apache.log4j.Level; +import org.apache.log4j.Logger; + + + +public class OrkTrack { + + public static final String APP_NAME = "OrkTrack"; + + public OrkTrack() { + + LogManager.getInstance().getConfigLogger().log(Level.INFO, "Entering OrkTrack"); + } + + public static void initialize(String log4jConfigFile, String hibernateConfigFile, String configFile) { + + LogManager.getInstance().configure(log4jConfigFile); + Logger log = LogManager.getInstance().getRootLogger(); + log.info("========================================"); + log.info(OrkTrack.APP_NAME + " starting ..."); + + // Register all OrkObjects + OrkObjectFactory.instance().registerOrkObject(new OrkTrackConfig()); + OrkObjectFactory.instance().registerOrkObject(new MetadataMessage()); + OrkObjectFactory.instance().registerOrkObject(new TapeMessage()); + OrkObjectFactory.instance().registerOrkObject(new UserStateMessage()); + + ConfigManager.getInstance().load(configFile); + + try { + HibernateManager.configure(hibernateConfigFile); + } + catch (Exception e) { + log.error("OrkTrack.initialize: Error configuring Hibernate:" + e.getMessage()); + } + + ServiceManager.initialize(); + PortManager.instance().initialize(); + ProgramManager.instance().load(); + } + + public static void main(String[] args) + { + //System.out.println("hello"); + //RecSegment seg = new RecSegment(); + //System.out.println(seg.getDuration()); + OrkTrack orkTrack = new OrkTrack(); + } + +} diff --git a/orktrack/src/net/sf/oreka/orktrack/OrkTrackConfig.java b/orktrack/src/net/sf/oreka/orktrack/OrkTrackConfig.java new file mode 100644 index 0000000..24d0489 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/OrkTrackConfig.java @@ -0,0 +1,46 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack; + +import net.sf.oreka.OrkException; +import net.sf.oreka.OrkObject; +import net.sf.oreka.serializers.OrkSerializer; + +public class OrkTrackConfig implements OrkObject { + + boolean ctiDriven = false; + + public void define(OrkSerializer serializer) throws OrkException { + + ctiDriven = serializer.booleanValue("ctidriven", ctiDriven, true); + } + + public String getOrkClassName() { + return "orktrackconfig"; + } + + public void validate() { + + } + + public boolean isCtiDriven() { + return ctiDriven; + } + + public void setCtiDriven(boolean ctiDriven) { + this.ctiDriven = ctiDriven; + } + + +} diff --git a/orktrack/src/net/sf/oreka/orktrack/Port.java b/orktrack/src/net/sf/oreka/orktrack/Port.java new file mode 100644 index 0000000..5831841 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/Port.java @@ -0,0 +1,274 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack; + +import java.util.ArrayList; +import java.util.Date; +import java.util.Iterator; +import java.util.LinkedList; + +import net.sf.oreka.orktrack.messages.MetadataMessage; +import net.sf.oreka.orktrack.messages.TapeMessage; +import net.sf.oreka.persistent.RecPort; +import net.sf.oreka.persistent.RecPortFace; +import net.sf.oreka.persistent.RecSegment; +import net.sf.oreka.persistent.RecTape; +import net.sf.oreka.persistent.Service; +import net.sf.oreka.persistent.User; + +import org.apache.log4j.Logger; +import org.hibernate.Session; + +public class Port { + + public ArrayList<RecPortFace> portFaces = new ArrayList<RecPortFace>(); + private RecPort recPort = null; + private TapeMessage lastTapeMessage = null; + private MetadataMessage lastMetadataMessage = null; + private User user = null; + + private LinkedList<RecSegment> recSegments = new LinkedList<RecSegment> (); + private LinkedList<RecTape> recTapes = new LinkedList<RecTape> (); + + Logger log = null; + + public Port(RecPort recPort) { + this.recPort = recPort; + log = LogManager.getInstance().portLogger; + } + + private synchronized void addTapeToLocalCache(RecTape tape) { + + if (recTapes.size() > 50) { + recTapes.removeLast(); + } + recTapes.addFirst(tape); + } + + private synchronized void addSegmentToLocalCache(RecSegment seg) { + + if (recSegments.size() > 50) { + recSegments.removeLast(); + } + recSegments.addFirst(seg); + } + + private boolean areTogether(RecTape tape, RecSegment seg) { + + boolean result = false; + long segStartTime = seg.getTimestamp().getTime(); + long tapeStartTime = tape.getTimestamp().getTime(); + long segStopTime = segStartTime + seg.getDuration(); + long tapeStopTime = tapeStartTime + tape.getDuration(); + + if( segStartTime > tapeStartTime || + (tapeStartTime - segStartTime) < 3000 ) { + + if ( segStopTime < tapeStopTime || + (segStopTime-tapeStopTime) < 3000 ) { + + result = true; + } + } + return result; + } + + private void joinTogether(RecTape tape, RecSegment seg, Session hbnSession) { + + seg.setRecTape(tape); + seg.setRecTapeOffset(seg.getTimestamp().getTime() - tape.getTimestamp().getTime()); + hbnSession.save(seg); + } + + private synchronized void findAndAssociateTape(RecSegment segment, Session hbnSession) { + + // Iterate over tapes and find the ones corresponding to this segment + Iterator<RecTape> it = recTapes.iterator(); + boolean foundOne = false; + boolean done = false; + while (it.hasNext() && !done) { + RecTape tape = it.next(); + if (areTogether(tape, segment)) { + joinTogether(tape, segment, hbnSession); + log.info("#" + recPort.getId() + ": associating segment:" + segment.getId() + " with tape:" + tape.getId()); + foundOne = true; + } + else { + if (foundOne) { + done = true; + } + } + } + } + + private synchronized void findAndAssociateSegment(RecTape tape, Session hbnSession) { + + // Iterate over segments and find the ones corresponding to this tape + Iterator<RecSegment> it = recSegments.iterator(); + boolean foundOne = false; + boolean done = false; + while (it.hasNext() && !done) { + RecSegment segment = it.next(); + if (areTogether(tape, segment)) { + joinTogether(tape, segment, hbnSession); + log.info("#" + recPort.getId() + ": associating segment:" + segment.getId() + " with tape:" + tape.getId()); + foundOne = true; + } + else { + if (foundOne) { + done = true; + } + } + } + } + + public void notifyMetadataMessage(MetadataMessage metadataMessage, Session hbnSession, Service srv) { + + long duration = 0; + Date startDate = null; + + if (metadataMessage.getStage() == TapeMessage.CaptureStage.start) { + lastMetadataMessage = metadataMessage; + } + else if (metadataMessage.getStage() == TapeMessage.CaptureStage.stop) { + + if (lastMetadataMessage != null) { + duration = ((long)metadataMessage.getTimestamp() - (long)lastMetadataMessage.getTimestamp())*1000; + startDate = new Date((long)lastMetadataMessage.getTimestamp()*1000); + } + } + else if (metadataMessage.getStage() == TapeMessage.CaptureStage.complete) { + duration = (long)metadataMessage.getDuration()*1000; + startDate = new Date(metadataMessage.getTimestamp()*1000); + } + + if (startDate != null) { + + if (srv.isRecordMaster()) { + // create segment + RecSegment recSegment = new RecSegment(); + recSegment.setTimestamp(startDate); + recSegment.setDirection(metadataMessage.getDirection()); + recSegment.setDuration(duration); + recSegment.setLocalParty(metadataMessage.getLocalParty()); + recSegment.setLocalEntryPoint(metadataMessage.getLocalEntryPoint()); + recSegment.setRecSessionOffset(0); + recSegment.setPort(recPort); + + if(metadataMessage.getLocalParty() != "") { + User user = UserManager.instance().getByLoginString(metadataMessage.getLocalParty(), hbnSession); + recSegment.setUser(user); + } + + // is this retained by a program ? + if (ProgramManager.instance().filterSegmentAgainstAllPrograms(recSegment, hbnSession)) { + // Try to find associated tape and link it to this + addSegmentToLocalCache(recSegment); + findAndAssociateTape(recSegment, hbnSession); + hbnSession.save(recSegment); + log.info("#" + metadataMessage.getCapturePort() + ": written segment " + recSegment.getId()); + } + else { + log.info("#" + metadataMessage.getCapturePort() + ": metadata message discarded"); + } + } + } + } + + public void notifyTapeMessage(TapeMessage tapeMessage, Session hbnSession, Service srv) { + + if (tapeMessage.getStage() == TapeMessage.CaptureStage.start) { + lastTapeMessage = tapeMessage; + } + else { + // Tape stop + if (lastTapeMessage == null) { + log.warn("Port: notifyTapeMessage: stop without a previous tape message"); + } + else if (lastTapeMessage.getStage() != TapeMessage.CaptureStage.start) { + log.warn("Port: notifyTapeMessage: stop without a start"); + } + else if (tapeMessage.getStage() == TapeMessage.CaptureStage.stop){ + boolean generateSegment = false; + if (portFaces.size() == 1 || srv.isRecordMaster()) { + generateSegment = true; + } + + TapeMessage startMessage = lastTapeMessage; + TapeMessage stopMessage = tapeMessage; + long duration = (stopMessage.getTimestamp() - startMessage.getTimestamp())*1000; + long date = ((long)startMessage.getTimestamp()) * 1000; + Date timestamp = new Date(date); + + // create a new tape record + RecTape recTape = new RecTape(); + recTape.setDirection(stopMessage.getDirection()); + recTape.setDuration(duration); + recTape.setExpiryTimestamp(new Date()); + recTape.setFilename(stopMessage.getFilename()); + recTape.setLocalParty(stopMessage.getLocalParty()); + recTape.setPort(recPort); + recTape.setRemoteParty(stopMessage.getRemoteParty()); + recTape.setTimestamp(timestamp); + recTape.setService(srv); + hbnSession.save(recTape); + log.info("#" + tapeMessage.getCapturePort() + ": written tape " + recTape.getId()); + + if (generateSegment) { + RecSegment recSegment = new RecSegment(); + recSegment.setTimestamp(timestamp); + recSegment.setDirection(stopMessage.getDirection()); + recSegment.setDuration(duration); + recSegment.setLocalParty(stopMessage.getLocalParty()); + recSegment.setLocalEntryPoint(stopMessage.getLocalEntryPoint()); + recSegment.setRecTape(recTape); + recSegment.setPort(recPort); + + if(stopMessage.getLocalParty() != "") { + User user = UserManager.instance().getByLoginString(stopMessage.getLocalParty(), hbnSession); + recSegment.setUser(user); + } + if (ProgramManager.instance().filterSegmentAgainstAllPrograms(recSegment, hbnSession)) { + hbnSession.save(recSegment); + log.info("#" + tapeMessage.getCapturePort() + ": written segment " + recSegment.getId()); + } + else { + log.info("#" + tapeMessage.getCapturePort() + ": tape message discarded"); } + } + else { + // segments are generated by metadata messages + addTapeToLocalCache(recTape); + findAndAssociateSegment(recTape, hbnSession); + } + } + } + } + + public RecPort getRecPort() { + return recPort; + } + + public void setRecPort(RecPort recPort) { + this.recPort = recPort; + } + + public User getUser() { + return user; + } + + public void setUser(User user) { + this.user = user; + } + +} diff --git a/orktrack/src/net/sf/oreka/orktrack/PortManager.java b/orktrack/src/net/sf/oreka/orktrack/PortManager.java new file mode 100644 index 0000000..09c18e9 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/PortManager.java @@ -0,0 +1,166 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; + +import net.sf.oreka.HibernateManager; +import net.sf.oreka.persistent.RecPort; +import net.sf.oreka.persistent.RecPortFace; +import net.sf.oreka.persistent.Service; + +import org.apache.log4j.Logger; +import org.hibernate.Session; +import org.hibernate.Transaction; + +/** Singleton class that manages activity on all capture ports */ +public class PortManager { + + HashMap<Integer, Port> portById = new HashMap<Integer, Port>(); + HashMap<String, Port> portByName = new HashMap<String, Port>(); + + static PortManager portManager = null; + Logger log = null; + + private PortManager () { + log = LogManager.getInstance().portLogger; + } + + public static PortManager instance() { + if (portManager == null) { + portManager = new PortManager(); + } + return portManager; + } + + public Port getPort(String name) { + return portByName.get(name); + } + + public Port getAndCreatePort(String name, Session hbnSession, Service service) { + + Port port = portByName.get(name); + if (port == null) { + + port = createPort(name, hbnSession, service); + } + return port; + } + + public synchronized Port createPort(String name, Session hbnSession, Service service) { + + RecPort recPort = null; + + RecPortFace portFace = (RecPortFace)hbnSession.get(RecPortFace.class, name); + if (portFace == null) { + portFace = new RecPortFace(); + portFace.setName(name); + portFace.setRecPort(recPort); + portFace.setService(service); + + recPort = new RecPort(); + portFace.setRecPort(recPort); + } + else { + portFace.setRecPort(recPort); + portFace.setService(service); + recPort = portFace.getRecPort(); + } + + hbnSession.save(recPort); + hbnSession.save(portFace); + + log.info("created port:" + recPort.getId() + " with face:" + name); + + Port port = new Port(recPort); + port.portFaces.add(portFace); + portById.put(recPort.getId(), port); + portByName.put(portFace.getName(), port); + return port; + } + + // for testing purposes + public void addPort(String face1, String face2, Session hbnSession) { + + RecPort recPort = new RecPort(); + Port port = new Port(recPort); + RecPortFace portFace1 = new RecPortFace(); + portFace1.setName(face1); + portFace1.setRecPort(recPort); + RecPortFace portFace2 = new RecPortFace(); + portFace2.setName(face2); + portFace2.setRecPort(recPort); + + hbnSession.save(recPort); + hbnSession.save(portFace1); + hbnSession.save(portFace2); + + port.portFaces.add(portFace1); + port.portFaces.add(portFace2); + portByName.put(face1, port); + portByName.put(face2, port); + portById.put(1, port); + } + + public void initialize() { + + try { + Session session = HibernateManager.getSession(); + Transaction tx = session.beginTransaction(); + + Iterator portFaces = session.createQuery( + "from RecPortFace") + .list() + .iterator(); + + while ( portFaces.hasNext() ) { + RecPortFace portFace = (RecPortFace)portFaces.next(); + + int portId = portFace.getRecPort().getId(); + Port port = portById.get(portId); + if(port == null) { + RecPort recPort = (RecPort)session.get(RecPort.class, portId); + if (recPort != null) { + port = new Port(recPort); + portById.put(portId, port); + } + } + port.portFaces.add(portFace); + portByName.put(portFace.getName(), port); + } + tx.commit(); + session.close(); + } + catch (Exception e) { + log.warn("HibernateManager.initialize: could not initialize", e); + } + } + + public RecPort getRecPortByFace(String face, Session hbnSession) { + RecPort port = null; + List ports = hbnSession.createQuery( + "from RecPortFace as pf join pf.recPort as p where pf.name=:face") + .setString("face", face) + .list(); + if (ports.size() > 0) { + Object[] row = (Object[])ports.get(0); + if (row.length > 1) { + port = (RecPort)row[1]; + } + } + return port; + } +} diff --git a/orktrack/src/net/sf/oreka/orktrack/ProgramManager.java b/orktrack/src/net/sf/oreka/orktrack/ProgramManager.java new file mode 100644 index 0000000..6b8a54c --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/ProgramManager.java @@ -0,0 +1,158 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack; + +import java.util.ArrayList; +import java.util.List; + +import net.sf.oreka.Direction; +import net.sf.oreka.HibernateManager; +import net.sf.oreka.persistent.RecProgram; +import net.sf.oreka.persistent.RecSegment; + +import org.apache.log4j.Logger; +import org.hibernate.HibernateException; +import org.hibernate.Session; +import org.hibernate.Transaction; + +public class ProgramManager { + + private Logger log = null; + + private static ProgramManager programManager = null; + private ArrayList<RecProgram> recPrograms = new ArrayList<RecProgram>(); + + private ProgramManager() { + log = LogManager.getInstance().getPortLogger();; + } + + public static ProgramManager instance() { + + if (programManager == null) { + programManager = new ProgramManager(); + } + return programManager; + } + + public void load() { + + Session hbnSession = null; + Transaction tx = null; + + try { + hbnSession = HibernateManager.getSession(); + tx = hbnSession.beginTransaction(); + + List progs = hbnSession.createQuery( + "from RecProgram as prg where prg.active=:active and prg.discarded=:discarded") + .setBoolean("active", true) + .setBoolean("discarded", false) + .list(); + + recPrograms = new ArrayList<RecProgram>(progs); + tx.commit(); + } + catch (Exception e) { + log.error("Could not load programs", e); + } + finally { + hbnSession.close(); + } + } + + public void addProgram(RecProgram prog) { + + recPrograms.add(prog); + } + + public boolean filterSegmentAgainstAllPrograms(RecSegment seg, Session hbnSession) { + + boolean result = false; + // Iterate over programs + ArrayList<RecProgram> progs = recPrograms; + for(int i=0; i<progs.size(); i++) { + if(filterSegmentAgainstProgram(seg, progs.get(i), hbnSession)) { + result = true; + } + } + return result; + } + + public boolean filterSegmentAgainstProgram(RecSegment seg, RecProgram prog, Session hbnSession) { + + boolean drop = false; + boolean result = false; + + if ( prog.getDirection() != Direction.ALL && + seg.getDirection() != prog.getDirection()) { + drop = true; + } + + if ( !drop && prog.getMaxDuration() > 0 && + (seg.getDuration() > (prog.getMaxDuration()*1000))) { + drop = true; + } + + if ( !drop && prog.getMinDuration() > 0 && + (seg.getDuration() < (prog.getMinDuration()*1000))) { + drop = true; + } + + if (!drop && prog.getRandomPercent() != 0.0) { + double randomNumber = java.lang.Math.random(); + if (randomNumber > prog.getRandomPercent()) { + drop = true; + } + } + + if ( !drop && prog.getLocalParty().length() > 0 && + (!seg.getLocalParty().equals(prog.getLocalParty())) ) { + drop = true; + } + + if ( !drop && prog.getRemoteParty().length() > 0 && + (!seg.getRemoteParty().equals(prog.getRemoteParty())) ) { + drop = true; + } + + if ( !drop && + (prog.getTargetUser() != null) && + (seg.getUser().getId() != prog.getTargetUser().getId()) ) { + drop = true; + } + + if ( !drop && + (prog.getTargetPort() != null) && + (seg.getPort().getId() != prog.getTargetPort().getId()) ) { + drop = true; + } + + if ( !drop && + prog.getRecordedSoFar() < prog.getRecPerCycle() ) + drop = true; + + if(drop == false) { + // All criteria have passed, the segment is accepted by the program + prog.setRecordedSoFar(prog.getRecordedSoFar() + 1); + hbnSession.update(prog); + seg.getRecPrograms().add(prog); + result = true; + } + return result; + } + + public void filterTime() { + ; + } +} diff --git a/orktrack/src/net/sf/oreka/orktrack/ServiceManager.java b/orktrack/src/net/sf/oreka/orktrack/ServiceManager.java new file mode 100644 index 0000000..b29c13e --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/ServiceManager.java @@ -0,0 +1,54 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack; + +import java.util.List; + +import net.sf.oreka.persistent.Service; + +import org.apache.log4j.Logger; +import org.hibernate.Session; + +public class ServiceManager { + + static Logger log = null; + + static void initialize() { + log = LogManager.getInstance().getPortLogger(); + } + + public static Service retrieveOrCreate(String name, Session hbnSession) { + Service service = retrieveByName(name, hbnSession); + if (service == null) { + log.info("Creating service:" + name); + service = new Service(); + service.setName(name); + hbnSession.save(service); + } + return service; + } + + public static Service retrieveByName(String name, Session hbnSession) { + + Service service = null; + List services = hbnSession.createQuery( + "from Service as srv where srv.name=:name") + .setString("name", name) + .list(); + if (services.size() > 0) { + service = (Service)services.get(0); + } + return service; + } +} diff --git a/orktrack/src/net/sf/oreka/orktrack/UserManager.java b/orktrack/src/net/sf/oreka/orktrack/UserManager.java new file mode 100644 index 0000000..4c5ce02 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/UserManager.java @@ -0,0 +1,66 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack; + +import java.util.HashMap; +import java.util.List; + +import net.sf.oreka.persistent.User; + +import org.apache.log4j.Logger; +import org.hibernate.Session; + +public class UserManager { + + private static Logger log = null; + private static UserManager userManager = null; + + private HashMap<User, Port> userLocations = new HashMap<User, Port>(); + + private UserManager() { + log = LogManager.getInstance().getUserLogger(); + } + + public static UserManager instance() { + + if(userManager == null) { + userManager = new UserManager(); + } + return userManager; + } + + public User getByLoginString(String loginString, Session hbnSession) { + + User user = null; + List users = hbnSession.createQuery( + "from LoginString as ls join ls.user as usr where ls.loginString=:loginstring") + .setString("loginstring", loginString) + .list(); + if (users.size() > 0) { + Object[] row = (Object[])users.get(0); + if (row.length > 1) { + user = (User)row[1]; + } + } + return user; + } + + public synchronized void setUserLocation(User user, Port port) { + userLocations.put(user, port); + } + + public synchronized Port getUserLocation(User user) { + return userLocations.get(user); + } +} diff --git a/orktrack/src/net/sf/oreka/orktrack/messages/MetadataMessage.java b/orktrack/src/net/sf/oreka/orktrack/messages/MetadataMessage.java new file mode 100644 index 0000000..d6a2062 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/messages/MetadataMessage.java @@ -0,0 +1,207 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack.messages; + +import org.apache.log4j.Logger; +import org.hibernate.Session; +import org.hibernate.Transaction; + +import net.sf.oreka.OrkException; +import net.sf.oreka.Direction; +import net.sf.oreka.HibernateManager; +import net.sf.oreka.messages.AsyncMessage; +import net.sf.oreka.messages.SimpleResponseMessage; +import net.sf.oreka.messages.SyncMessage; +import net.sf.oreka.orktrack.LogManager; +import net.sf.oreka.orktrack.Port; +import net.sf.oreka.orktrack.PortManager; +import net.sf.oreka.orktrack.ServiceManager; +import net.sf.oreka.orktrack.messages.TapeMessage.CaptureStage; +import net.sf.oreka.persistent.Service; +import net.sf.oreka.serializers.OrkSerializer; +import net.sf.oreka.serializers.SingleLineSerializer; + +public class MetadataMessage extends SyncMessage { + + Logger log = null; + + CaptureStage stage = CaptureStage.unkn; + int timestamp = 0; + int duration = 0; + String capturePort = ""; + String localParty = ""; + String localEntryPoint = ""; + String remoteParty = ""; + Direction direction = Direction.UNKN; + String loginString = ""; + String service = ""; + + public MetadataMessage() { + log = LogManager.getInstance().getPortLogger(); + } + + @Override + public AsyncMessage process() { + + SimpleResponseMessage response = new SimpleResponseMessage(); + Session session = null; + Transaction tx = null; + try { + session = HibernateManager.getSession(); + tx = session.beginTransaction(); + boolean success = false; + + SingleLineSerializer ser = new SingleLineSerializer(); + log.info("Message: " + ser.serialize(this)); + + Service service = ServiceManager.retrieveByName(this.service, session); + + if (service != null) { + Port port = PortManager.instance().getAndCreatePort(this.getCapturePort(), session, service); + port.notifyMetadataMessage(this, session, service); + success = true; + } + else { + response.setComment("service:" + this.service + " does not exist"); + log.error("MetadataMessage.process: service" + this.service + " does not exist"); + } + + response.setSuccess(success); + if (success) {tx.commit();} + else {tx.rollback();} + } + catch (Exception e) { + if (tx != null) {tx.rollback();} + log.error("TapeMessage.process: ", e); + response.setSuccess(false); + response.setComment(e.getMessage()); + } + finally { + if(session != null) {session.close();} + } + return response; + } + + public void define(OrkSerializer serializer) throws OrkException { + + stage = (CaptureStage)serializer.enumValue("stage", stage, true); + timestamp = serializer.intValue("timestamp", timestamp, true); + duration = serializer.intValue("duration", duration, false); + capturePort = serializer.stringValue("capturePort", capturePort, true); + localParty = serializer.stringValue("localParty", localParty, false); + localEntryPoint = serializer.stringValue("localEntryPoint", localEntryPoint, false); + remoteParty = serializer.stringValue("remoteParty", remoteParty, false); + direction = (Direction)serializer.enumValue("direction", direction, false); + loginString = serializer.stringValue("loginString", loginString, false); + service = serializer.stringValue("service", service, true); + } + + public String getOrkClassName() { + return "metadata"; + } + + public void validate() { + // TODO Auto-generated method stub + + } + + public String getCapturePort() { + return capturePort; + } + + public void setCapturePort(String capturePort) { + this.capturePort = capturePort; + } + + public Direction getDirection() { + return direction; + } + + public void setDirection(Direction direction) { + this.direction = direction; + } + + public int getDuration() { + return duration; + } + + public void setDuration(int duration) { + this.duration = duration; + } + + public String getLocalEntryPoint() { + return localEntryPoint; + } + + public void setLocalEntryPoint(String localEntryPoint) { + this.localEntryPoint = localEntryPoint; + } + + public String getLocalParty() { + return localParty; + } + + public void setLocalParty(String localParty) { + this.localParty = localParty; + } + + public Logger getLog() { + return log; + } + + public void setLog(Logger log) { + this.log = log; + } + + public String getLoginString() { + return loginString; + } + + public void setLoginString(String loginString) { + this.loginString = loginString; + } + + public String getRemoteParty() { + return remoteParty; + } + + public void setRemoteParty(String remoteParty) { + this.remoteParty = remoteParty; + } + + public String getService() { + return service; + } + + public void setService(String service) { + this.service = service; + } + + public CaptureStage getStage() { + return stage; + } + + public void setStage(CaptureStage stage) { + this.stage = stage; + } + + public int getTimestamp() { + return timestamp; + } + + public void setTimestamp(int timestamp) { + this.timestamp = timestamp; + } + +} diff --git a/orktrack/src/net/sf/oreka/orktrack/messages/TapeMessage.java b/orktrack/src/net/sf/oreka/orktrack/messages/TapeMessage.java new file mode 100644 index 0000000..12c66b2 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/messages/TapeMessage.java @@ -0,0 +1,202 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack.messages; + +import net.sf.oreka.OrkException; +import net.sf.oreka.Direction; +import net.sf.oreka.HibernateManager; +import net.sf.oreka.messages.AsyncMessage; +import net.sf.oreka.messages.SimpleResponseMessage; +import net.sf.oreka.messages.SyncMessage; +import net.sf.oreka.orktrack.LogManager; +import net.sf.oreka.orktrack.Port; +import net.sf.oreka.orktrack.PortManager; +import net.sf.oreka.orktrack.ServiceManager; +import net.sf.oreka.persistent.Service; +import net.sf.oreka.serializers.OrkSerializer; +import net.sf.oreka.serializers.SingleLineSerializer; + +import org.apache.log4j.Logger; +import org.hibernate.Session; +import org.hibernate.Transaction; + +public class TapeMessage extends SyncMessage { + + public enum CaptureStage {start , stop, complete, unkn}; + + Logger log = null; + + CaptureStage stage = CaptureStage.unkn; + int timestamp = 0; + int duration = 0; + String filename = ""; + String capturePort = ""; + String localParty = ""; + String localEntryPoint = ""; + String remoteParty = ""; + Direction direction = Direction.UNKN; + String loginString = ""; + String service = ""; + + public TapeMessage() { + log = LogManager.getInstance().getPortLogger(); + } + + public String getService() { + return service; + } + + public void setService(String service) { + this.service = service; + } + + @Override + public AsyncMessage process() { + + SimpleResponseMessage response = new SimpleResponseMessage(); + Session session = null; + Transaction tx = null; + + try { + session = HibernateManager.getSession(); + tx = session.beginTransaction(); + + SingleLineSerializer ser = new SingleLineSerializer(); + log.info("Message: " + ser.serialize(this)); + + Service service = ServiceManager.retrieveOrCreate(this.service, session); + + Port port = PortManager.instance().getAndCreatePort(this.getCapturePort(), session, service); + port.notifyTapeMessage(this, session, service); + + response.setSuccess(true); + tx.commit(); + } + catch (Exception e) { + if (tx != null) {tx.rollback();} + log.error("TapeMessage.process: ", e); + response.setSuccess(false); + response.setComment(e.getMessage()); + } + finally { + if(session != null) {session.close();} + } + return response; + } + + public void define(OrkSerializer serializer) throws OrkException { + + stage = (CaptureStage)serializer.enumValue("stage", stage, true); + timestamp = serializer.intValue("timestamp", timestamp, true); + duration = serializer.intValue("duration", duration, true); + filename = serializer.stringValue("filename", filename, true); + capturePort = serializer.stringValue("capturePort", capturePort, true); + localParty = serializer.stringValue("localParty", localParty, false); + localEntryPoint = serializer.stringValue("localEntryPoint", localEntryPoint, false); + remoteParty = serializer.stringValue("remoteParty", remoteParty, false); + direction = (Direction)serializer.enumValue("direction", direction, false); + loginString = serializer.stringValue("loginString", loginString, false); + service = serializer.stringValue("service", service, true); + } + + public String getOrkClassName() { + return "tape"; + } + + public void validate() { + // TODO Auto-generated method stub + + } + + public String getCapturePort() { + return capturePort; + } + + public void setCapturePort(String capturePort) { + this.capturePort = capturePort; + } + + public Direction getDirection() { + return direction; + } + + public void setDirection(Direction direction) { + this.direction = direction; + } + + public String getFilename() { + return filename; + } + + public void setFilename(String filename) { + this.filename = filename; + } + + public String getLocalEntryPoint() { + return localEntryPoint; + } + + public void setLocalEntryPoint(String localEntryPoint) { + this.localEntryPoint = localEntryPoint; + } + + public String getLocalParty() { + return localParty; + } + + public void setLocalParty(String localParty) { + this.localParty = localParty; + } + + public String getLoginString() { + return loginString; + } + + public void setLoginString(String loginString) { + this.loginString = loginString; + } + + public String getRemoteParty() { + return remoteParty; + } + + public void setRemoteParty(String remoteParty) { + this.remoteParty = remoteParty; + } + + public CaptureStage getStage() { + return stage; + } + + public void setStage(CaptureStage stage) { + this.stage = stage; + } + + public int getTimestamp() { + return timestamp; + } + + public void setTimestamp(int timestamp) { + this.timestamp = timestamp; + } + + public int getDuration() { + return duration; + } + + public void setDuration(int duration) { + this.duration = duration; + } + +} diff --git a/orktrack/src/net/sf/oreka/orktrack/messages/UserStateMessage.java b/orktrack/src/net/sf/oreka/orktrack/messages/UserStateMessage.java new file mode 100644 index 0000000..9800e24 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/messages/UserStateMessage.java @@ -0,0 +1,119 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack.messages; + +import net.sf.oreka.OrkException; +import net.sf.oreka.HibernateManager; +import net.sf.oreka.messages.AsyncMessage; +import net.sf.oreka.messages.SimpleResponseMessage; +import net.sf.oreka.messages.SyncMessage; +import net.sf.oreka.orktrack.LogManager; +import net.sf.oreka.orktrack.Port; +import net.sf.oreka.orktrack.PortManager; +import net.sf.oreka.orktrack.UserManager; +import net.sf.oreka.persistent.User; +import net.sf.oreka.serializers.OrkSerializer; + +import org.apache.log4j.Logger; +import org.hibernate.Session; +import org.hibernate.Transaction; + +public class UserStateMessage extends SyncMessage { + + public enum UserState {login, logout, unkn}; + + private Logger log = null; + + private UserState userState = UserState.unkn; + private String loginString = ""; + private String recPort = ""; + + public UserStateMessage() { + log = LogManager.getInstance().getPortLogger(); + } + + @Override + public AsyncMessage process() { + + SimpleResponseMessage response = new SimpleResponseMessage(); + + Session hbnSession = null; + Transaction tx = null; + try { + String comment = ""; + boolean success = false; + hbnSession = HibernateManager.getSession(); + tx = hbnSession.beginTransaction(); + // find out user + User user = UserManager.instance().getByLoginString(loginString, hbnSession); + if (user == null) { + comment = "Could not find user for login string:" + loginString; + log.warn(comment); + } + else { + // find out port + Port port = PortManager.instance().getPort(recPort); + if (port == null) { + comment = "Could not find port for face:" + recPort; + log.warn(comment); + } + else { + if(userState == UserState.login) { + port.setUser(user); + UserManager.instance().setUserLocation(user, port); + log.info("user:" + loginString + " logging onto:" + recPort); + } + else if (userState == UserState.logout) { + port.setUser(null); + UserManager.instance().setUserLocation(user, null); + log.info("user:" + loginString + " logging out of:" + recPort); + } + success = true; + } + } + + response.setComment(comment); + response.setSuccess(success); + tx.commit(); + } + catch (Exception e) { + if (tx != null) {tx.rollback();} + log.error("TapeMessage.process: ", e); + response.setSuccess(false); + response.setComment(e.getMessage()); + } + finally { + if(hbnSession != null) {hbnSession.close();} + } + + return response; + } + + public void define(OrkSerializer serializer) throws OrkException { + + userState = (UserState)serializer.enumValue("userstate", userState, true); + loginString = serializer.stringValue("loginstring", loginString, true); + recPort = serializer.stringValue("recport", recPort, true); + } + + public String getOrkClassName() { + return "userstate"; + } + + public void validate() { + // TODO Auto-generated method stub + + } + +} diff --git a/orktrack/src/net/sf/oreka/orktrack/test/PortTest.java b/orktrack/src/net/sf/oreka/orktrack/test/PortTest.java new file mode 100644 index 0000000..2c16784 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/test/PortTest.java @@ -0,0 +1,307 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack.test; + +import java.util.Date; +import java.util.GregorianCalendar; +import java.util.Iterator; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; +import net.sf.oreka.Direction; +import net.sf.oreka.HibernateManager; +import net.sf.oreka.orktrack.OrkTrack; +import net.sf.oreka.orktrack.PortManager; +import net.sf.oreka.orktrack.ProgramManager; +import net.sf.oreka.orktrack.ServiceManager; +import net.sf.oreka.orktrack.messages.MetadataMessage; +import net.sf.oreka.orktrack.messages.TapeMessage; +import net.sf.oreka.persistent.LoginString; +import net.sf.oreka.persistent.RecProgram; +import net.sf.oreka.persistent.RecSegment; +import net.sf.oreka.persistent.RecTape; +import net.sf.oreka.persistent.Service; +import net.sf.oreka.persistent.User; + +import org.hibernate.Session; +import org.hibernate.Transaction; + +public class PortTest extends TestCase { + + public static void main (String[] args) { + junit.textui.TestRunner.run (suite()); + } + protected void setUp() throws Exception { + OrkTrack.initialize("C:/oreka/log4j.properties", "C:/oreka/hsqldb.hbm.xml", "C:/oreka/orktrack.config.xml"); + } + public static Test suite() { + return new TestSuite(PortTest.class); + } + +// === commented out because touches private elements +// public void testAreTogether() { +// +// Port port = new Port(); +// +// long now = new Date().getTime(); +// RecTape tape = new RecTape(); +// tape.setTimestamp(new Date(now)); +// tape.setDuration(10000); +// +// RecSegment seg = new RecSegment(); +// seg.setTimestamp(new Date(now)); +// seg.setDuration(10000); +// +// assertTrue(port.areTogether(tape, seg)); +// +// tape.setTimestamp(new Date(now-2000)); +// assertTrue(port.areTogether(tape, seg)); +// +// tape.setTimestamp(new Date(now-4000)); +// assertFalse(port.areTogether(tape, seg)); +// +// tape.setTimestamp(new Date(now)); +// seg.setDuration(12000); +// assertTrue(port.areTogether(tape, seg)); +// +// seg.setDuration(14000); +// assertFalse(port.areTogether(tape, seg)); +// +// tape.setTimestamp(new Date(now)); +// tape.setDuration(10000); +// seg.setTimestamp(new Date(now+5000)); +// seg.setDuration(5000); +// assertTrue(port.areTogether(tape, seg)); +// +// seg.setDuration(8000); +// assertFalse(port.areTogether(tape, seg)); +// +// } + +//=== commented out because touches private elements +// public void testFindAndAssociateTape() throws Exception { +// +// Session hbnSession = HibernateManager.getSession(); +// Transaction tx = hbnSession.beginTransaction(); +// +// // case 1, a segment arrives after a tape +// Port port = new Port(); +// RecTape tape1 = new RecTape(); // older tape +// RecTape tape2 = new RecTape(); // newer tape +// RecTape fooTape = new RecTape(); // this is the one +// long now = new Date().getTime(); +// fooTape.setTimestamp(new Date(now)); +// tape1.setTimestamp(new Date(now-10000)); +// tape2.setTimestamp(new Date(now+10000)); +// fooTape.setDuration(10000); +// tape1.setDuration(10000); +// tape2.setDuration(10000); +// +// port.recTapes.addFirst(tape1); +// port.recTapes.addFirst(fooTape); +// port.recTapes.addFirst(tape2); +// +// RecSegment seg = new RecSegment(); +// seg.setTimestamp(new Date(now)); +// seg.setDuration(5000); +// port.findAndAssociateTape(seg, hbnSession); +// +// assertTrue(seg.getRecTape() == fooTape); +// assertTrue(seg.getRecTapeOffset() == 0); +// +// // case 2, a second segment arrives and is part of the same tape +// RecSegment seg2 = new RecSegment(); +// seg2.setTimestamp(new Date(now+4000)); +// seg2.setDuration(5000); +// port.findAndAssociateTape(seg2, hbnSession); +// +// assertTrue(seg2.getRecTape() == fooTape); +// assertTrue(seg2.getRecTapeOffset() == 4000); +// +// hbnSession.close(); +// } + +// public void testTapeMessage() throws Exception { +// +// // Generate start and stop messages +// TapeMessage startMsg = new TapeMessage(); +// startMsg.setCapturePort("port1"); +// startMsg.setService("service1"); +// startMsg.setStage(TapeMessage.CaptureStage.start); +// long startTime = new Date().getTime(); +// int startTimestamp = (int)(startTime/1000); +// startMsg.setTimestamp(startTimestamp); +// +// startMsg.process(); +// +// TapeMessage stopMsg = new TapeMessage(); +// stopMsg.setCapturePort("port1"); +// stopMsg.setDirection(Direction.in); +// stopMsg.setFilename("test.wav"); +// stopMsg.setLocalEntryPoint("dnis1"); +// stopMsg.setLocalParty("9833"); +// stopMsg.setRemoteParty("514-425-5678"); +// stopMsg.setService("service1"); +// stopMsg.setStage(TapeMessage.CaptureStage.stop); +// stopMsg.setTimestamp(startTimestamp + 10); +// +// stopMsg.process(); +// +// // verify database entities. +// Session hbnSession = HibernateManager.getSession(); +// Transaction tx = hbnSession.beginTransaction(); +// long time = ((long)startTimestamp)*1000; +// GregorianCalendar cal = new GregorianCalendar(); +// cal.setTimeInMillis(time); +// +// RecSegment seg = null; +// Iterator segments = hbnSession.createQuery( +// "from RecSegment as seg where seg.timestamp=:date") +// .setCalendar("date", cal) +// .list() +// .iterator(); +// if(segments.hasNext()) { +// seg = (RecSegment)segments.next(); +// assertTrue(seg.getLocalParty().equals("9833")); +// +// RecTape tape = seg.getRecTape(); +// assertTrue(tape.getFilename().equals("test.wav")); +// } +// else { +// fail(); +// } +// tx.commit(); +// hbnSession.close(); +// } + + public void testTapeAndMetadataMessage() throws Exception { + + Session hbnSession = HibernateManager.getSession(); + Transaction tx = hbnSession.beginTransaction(); + Service recService = ServiceManager.retrieveOrCreate("recservice", hbnSession); + Service ctiService = ServiceManager.retrieveOrCreate("ctiservice", hbnSession); + ctiService.setRecordMaster(true); + hbnSession.save(recService); + + User user = new User(); + user.setFirstname("salisse"); + LoginString ls = new LoginString(); + ls.setUser(user); + ls.setLoginString("1973"); + hbnSession.save(user); + hbnSession.save(ls); + + PortManager.instance().addPort("recport", "ctiport", hbnSession); + + // create program that does not filter anything + RecProgram prog1 = new RecProgram(); + hbnSession.save(prog1); + ProgramManager.instance().addProgram(prog1); + + tx.commit(); + hbnSession.close(); + + + + // Generate tape start and stop messages + TapeMessage startMsg = new TapeMessage(); + startMsg.setCapturePort("recport"); + startMsg.setService("recservice"); + startMsg.setStage(TapeMessage.CaptureStage.start); + long startTime = new Date().getTime(); + int startTimestamp = (int)(startTime/1000); + startMsg.setTimestamp(startTimestamp); + + startMsg.process(); + + TapeMessage stopMsg = new TapeMessage(); + stopMsg.setCapturePort("recport"); + stopMsg.setService("recservice"); + stopMsg.setDirection(Direction.IN); + stopMsg.setFilename("test.wav"); + stopMsg.setLocalEntryPoint("dnis1"); + stopMsg.setLocalParty("9833"); + stopMsg.setRemoteParty("514-425-5678"); + stopMsg.setStage(TapeMessage.CaptureStage.stop); + stopMsg.setTimestamp(startTimestamp + 10); + + stopMsg.process(); + + // Generate metadata start and stop messages + MetadataMessage mdStartMsg = new MetadataMessage(); + mdStartMsg.setStage(TapeMessage.CaptureStage.start); + mdStartMsg.setTimestamp(startTimestamp + 3); + mdStartMsg.setCapturePort("ctiport"); + mdStartMsg.setService("ctiservice"); + + mdStartMsg.process(); + + MetadataMessage mdStopMsg = new MetadataMessage(); + mdStopMsg.setStage(TapeMessage.CaptureStage.stop); + mdStopMsg.setLocalParty("1973"); + mdStopMsg.setTimestamp(startTimestamp + 5); + mdStopMsg.setCapturePort("ctiport"); + mdStopMsg.setService("ctiservice"); + + mdStopMsg.process(); + + // verify database entities. + hbnSession = HibernateManager.getSession(); + tx = hbnSession.beginTransaction(); + long time = ((long)(startTimestamp+3))*1000; + GregorianCalendar cal = new GregorianCalendar(); + cal.setTimeInMillis(time); + + RecSegment seg = null; + Iterator segments = hbnSession.createQuery( + "from RecSegment as seg where seg.timestamp=:date") + .setCalendar("date", cal) + .list() + .iterator(); + if(segments.hasNext()) { + seg = (RecSegment)segments.next(); + assertTrue(seg.getLocalParty().equals("1973")); + assertTrue(seg.getRecTapeOffset() == 3000); + + RecTape tape = seg.getRecTape(); + assertTrue(tape.getFilename().equals("test.wav")); + + User user2 = seg.getUser(); + assertTrue(user.getId() == user2.getId()); + } + else { + fail(); + } + tx.commit(); + hbnSession.close(); + } + +// public void testUserManager() throws Exception { +// +// Session hbnSession = HibernateManager.getSession(); +// Transaction tx = hbnSession.beginTransaction(); +// User user = new User(); +// user.setFirstname("salisse"); +// LoginString ls = new LoginString(); +// ls.setUser(user); +// ls.setLoginString("4568"); +// hbnSession.save(user); +// hbnSession.save(ls); +// User user2 = UserManager.getByLoginString("4568", hbnSession); +// assertTrue(user.getFirstname().equals(user2.getFirstname())); +// tx.commit(); +// hbnSession.close(); +// } +} diff --git a/orktrack/src/net/sf/oreka/orktrack/test/ProgramTest.java b/orktrack/src/net/sf/oreka/orktrack/test/ProgramTest.java new file mode 100644 index 0000000..8195398 --- /dev/null +++ b/orktrack/src/net/sf/oreka/orktrack/test/ProgramTest.java @@ -0,0 +1,128 @@ +/* + * Oreka -- A media capture and retrieval platform + * + * Copyright (C) 2005, orecx LLC + * + * http://www.orecx.com + * + * This program is free software, distributed under the terms of + * the GNU General Public License. + * Please refer to http://www.gnu.org/copyleft/gpl.html + * + */ + +package net.sf.oreka.orktrack.test; + +import java.util.Iterator; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; +import net.sf.oreka.Direction; +import net.sf.oreka.HibernateManager; +import net.sf.oreka.orktrack.OrkTrack; +import net.sf.oreka.orktrack.ProgramManager; +import net.sf.oreka.persistent.LoginString; +import net.sf.oreka.persistent.RecProgram; +import net.sf.oreka.persistent.RecSegment; +import net.sf.oreka.persistent.User; + +import org.hibernate.Session; +import org.hibernate.Transaction; + +public class ProgramTest extends TestCase { + + public static void main (String[] args) { + junit.textui.TestRunner.run (suite()); + } + protected void setUp() throws Exception { + OrkTrack.initialize("C:/oreka/log4j.properties", "C:/oreka/mysql.hbm.xml", "C:/oreka/orktrack.config.xml"); + } + public static Test suite() { + return new TestSuite(ProgramTest.class); + } + + public void test1() throws Exception { + + + Session hbnSession = HibernateManager.getSession(); + Transaction tx = hbnSession.beginTransaction(); + + // create a user + User user = new User(); + user.setFirstname("mawagade"); + hbnSession.save(user); + LoginString ls = new LoginString(); + ls.setLoginString("1234"); + ls.setUser(user); + hbnSession.save(ls); + + // create a program + RecProgram prog1 = new RecProgram(); + prog1.setDirection(Direction.IN); + prog1.setTargetUser(user); + hbnSession.save(prog1); + + tx.commit(); + hbnSession.close(); + + ProgramManager.instance().load(); + + RecSegment seg = new RecSegment(); + seg.setDirection(Direction.IN); + seg.setUser(user); + + hbnSession = HibernateManager.getSession(); + tx = hbnSession.beginTransaction(); + if (ProgramManager.instance().filterSegmentAgainstAllPrograms(seg, hbnSession)) { + hbnSession.save(seg); + } + tx.commit(); + hbnSession.close(); + + // verify result + hbnSession = HibernateManager.getSession(); + tx = hbnSession.beginTransaction(); + RecProgram prog = (RecProgram)hbnSession.load(RecProgram.class, prog1.getId()); + assertTrue(prog.getRecordedSoFar() == 1); + Iterator<RecSegment> it = prog.getRecSegments().iterator(); + assertTrue(it.next().getId() == seg.getId()); + tx.commit(); + hbnSession.close(); + } + +// public void testManyToMany() throws Exception { +// +// Session hbnSession = HibernateManager.getSession(); +// Transaction tx = hbnSession.beginTransaction(); +// +// // Create two programs +// RecProgram prog1 = new RecProgram(); +// hbnSession.save(prog1); +// RecProgram prog2 = new RecProgram(); +// hbnSession.save(prog2); +// +// // create 1000 segments +// for(int i=0; i<1000; i++) { +// RecSegment seg = new RecSegment(); +// seg.getRecPrograms().add(prog1); +// seg.getRecPrograms().add(prog2); +// hbnSession.save(seg); +// } +// +// tx.commit(); +// hbnSession.close(); +// +// hbnSession = HibernateManager.getSession(); +// tx = hbnSession.beginTransaction(); +// +// // create a new segment and add it to the program +// RecProgram prog = (RecProgram)hbnSession.load(RecProgram.class, prog2.getId()); +// RecSegment seg = new RecSegment(); +// seg.getRecPrograms().add(prog); +// hbnSession.save(seg); +// +// tx.commit(); +// hbnSession.close(); +// } +} |