com.sun.jmx.examples.scandir.config.ResultRecord Java Examples

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

private boolean logResult(File file,Action[] actions) {
    try {
        logManager.log(new ResultRecord(config, actions,file));
        return true;
    } catch (Exception x) {
        LOG.fine("Failed to log: "+file.getAbsolutePath());
    }
    return false;
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

private void logToFile(ResultRecord record) throws IOException {
    final String basename;
    final long   maxRecords;
    synchronized (this) {
        if (logFile == null) return;
        basename = getLogFileName(false);
        maxRecords = fileCapacity;
    }

    // Get the stream into which we should log.
    final OutputStream stream =
            checkLogFile(basename,maxRecords,false);

    // logging to file now disabled - too bad.
    if (stream == null) return;

    synchronized (this) {
        try {
            XmlConfigUtils.write(record,stream,true);
            stream.flush();
            // don't increment logCount if we were not logging in logStream.
            if (stream == logStream) logCount++;
        } catch (JAXBException x) {
            final IllegalArgumentException iae =
                    new IllegalArgumentException("bad record",x);
            LOG.finest("Failed to log record: "+x);
            throw iae;
        }
    }
}
 

private void logToMemory(ResultRecord record) {

        final boolean before = memCapacityReached;
        final boolean after;
        synchronized(this) {
            memoryLog.add(record);
            after = memCapacityReached;
        }
        if (before==false && after==true)
            sendNotification(new Notification(MEMORY_LOG_MAX_CAPACITY,
                    objectName,
                    getNextSeqNumber(),"memory log capacity reached"));
    }
 

private void logToFile(ResultRecord record) throws IOException {
    final String basename;
    final long   maxRecords;
    synchronized (this) {
        if (logFile == null) return;
        basename = getLogFileName(false);
        maxRecords = fileCapacity;
    }

    // Get the stream into which we should log.
    final OutputStream stream =
            checkLogFile(basename,maxRecords,false);

    // logging to file now disabled - too bad.
    if (stream == null) return;

    synchronized (this) {
        try {
            XmlConfigUtils.write(record,stream,true);
            stream.flush();
            // don't increment logCount if we were not logging in logStream.
            if (stream == logStream) logCount++;
        } catch (JAXBException x) {
            final IllegalArgumentException iae =
                    new IllegalArgumentException("bad record",x);
            LOG.finest("Failed to log record: "+x);
            throw iae;
        }
    }
}
 

private boolean logResult(File file,Action[] actions) {
    try {
        logManager.log(new ResultRecord(config, actions,file));
        return true;
    } catch (Exception x) {
        LOG.fine("Failed to log: "+file.getAbsolutePath());
    }
    return false;
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

private void logToMemory(ResultRecord record) {

        final boolean before = memCapacityReached;
        final boolean after;
        synchronized(this) {
            memoryLog.add(record);
            after = memCapacityReached;
        }
        if (before==false && after==true)
            sendNotification(new Notification(MEMORY_LOG_MAX_CAPACITY,
                    objectName,
                    getNextSeqNumber(),"memory log capacity reached"));
    }
 

private void logToFile(ResultRecord record) throws IOException {
    final String basename;
    final long   maxRecords;
    synchronized (this) {
        if (logFile == null) return;
        basename = getLogFileName(false);
        maxRecords = fileCapacity;
    }

    // Get the stream into which we should log.
    final OutputStream stream =
            checkLogFile(basename,maxRecords,false);

    // logging to file now disabled - too bad.
    if (stream == null) return;

    synchronized (this) {
        try {
            XmlConfigUtils.write(record,stream,true);
            stream.flush();
            // don't increment logCount if we were not logging in logStream.
            if (stream == logStream) logCount++;
        } catch (JAXBException x) {
            final IllegalArgumentException iae =
                    new IllegalArgumentException("bad record",x);
            LOG.finest("Failed to log record: "+x);
            throw iae;
        }
    }
}
 

private boolean logResult(File file,Action[] actions) {
    try {
        logManager.log(new ResultRecord(config, actions,file));
        return true;
    } catch (Exception x) {
        LOG.fine("Failed to log: "+file.getAbsolutePath());
    }
    return false;
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

private void logToMemory(ResultRecord record) {

        final boolean before = memCapacityReached;
        final boolean after;
        synchronized(this) {
            memoryLog.add(record);
            after = memCapacityReached;
        }
        if (before==false && after==true)
            sendNotification(new Notification(MEMORY_LOG_MAX_CAPACITY,
                    objectName,
                    getNextSeqNumber(),"memory log capacity reached"));
    }
 

private void logToFile(ResultRecord record) throws IOException {
    final String basename;
    final long   maxRecords;
    synchronized (this) {
        if (logFile == null) return;
        basename = getLogFileName(false);
        maxRecords = fileCapacity;
    }

    // Get the stream into which we should log.
    final OutputStream stream =
            checkLogFile(basename,maxRecords,false);

    // logging to file now disabled - too bad.
    if (stream == null) return;

    synchronized (this) {
        try {
            XmlConfigUtils.write(record,stream,true);
            stream.flush();
            // don't increment logCount if we were not logging in logStream.
            if (stream == logStream) logCount++;
        } catch (JAXBException x) {
            final IllegalArgumentException iae =
                    new IllegalArgumentException("bad record",x);
            LOG.finest("Failed to log record: "+x);
            throw iae;
        }
    }
}
 

private boolean logResult(File file,Action[] actions) {
    try {
        logManager.log(new ResultRecord(config, actions,file));
        return true;
    } catch (Exception x) {
        LOG.fine("Failed to log: "+file.getAbsolutePath());
    }
    return false;
}
 

private boolean logResult(File file,Action[] actions) {
    try {
        logManager.log(new ResultRecord(config, actions,file));
        return true;
    } catch (Exception x) {
        LOG.fine("Failed to log: "+file.getAbsolutePath());
    }
    return false;
}
 

private void logToMemory(ResultRecord record) {

        final boolean before = memCapacityReached;
        final boolean after;
        synchronized(this) {
            memoryLog.add(record);
            after = memCapacityReached;
        }
        if (before==false && after==true)
            sendNotification(new Notification(MEMORY_LOG_MAX_CAPACITY,
                    objectName,
                    getNextSeqNumber(),"memory log capacity reached"));
    }
 

private void logToFile(ResultRecord record) throws IOException {
    final String basename;
    final long   maxRecords;
    synchronized (this) {
        if (logFile == null) return;
        basename = getLogFileName(false);
        maxRecords = fileCapacity;
    }

    // Get the stream into which we should log.
    final OutputStream stream =
            checkLogFile(basename,maxRecords,false);

    // logging to file now disabled - too bad.
    if (stream == null) return;

    synchronized (this) {
        try {
            XmlConfigUtils.write(record,stream,true);
            stream.flush();
            // don't increment logCount if we were not logging in logStream.
            if (stream == logStream) logCount++;
        } catch (JAXBException x) {
            final IllegalArgumentException iae =
                    new IllegalArgumentException("bad record",x);
            LOG.finest("Failed to log record: "+x);
            throw iae;
        }
    }
}
 

private boolean logResult(File file,Action[] actions) {
    try {
        logManager.log(new ResultRecord(config, actions,file));
        return true;
    } catch (Exception x) {
        LOG.fine("Failed to log: "+file.getAbsolutePath());
    }
    return false;
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

private void logToMemory(ResultRecord record) {

        final boolean before = memCapacityReached;
        final boolean after;
        synchronized(this) {
            memoryLog.add(record);
            after = memCapacityReached;
        }
        if (before==false && after==true)
            sendNotification(new Notification(MEMORY_LOG_MAX_CAPACITY,
                    objectName,
                    getNextSeqNumber(),"memory log capacity reached"));
    }
 

private void logToFile(ResultRecord record) throws IOException {
    final String basename;
    final long   maxRecords;
    synchronized (this) {
        if (logFile == null) return;
        basename = getLogFileName(false);
        maxRecords = fileCapacity;
    }

    // Get the stream into which we should log.
    final OutputStream stream =
            checkLogFile(basename,maxRecords,false);

    // logging to file now disabled - too bad.
    if (stream == null) return;

    synchronized (this) {
        try {
            XmlConfigUtils.write(record,stream,true);
            stream.flush();
            // don't increment logCount if we were not logging in logStream.
            if (stream == logStream) logCount++;
        } catch (JAXBException x) {
            final IllegalArgumentException iae =
                    new IllegalArgumentException("bad record",x);
            LOG.finest("Failed to log record: "+x);
            throw iae;
        }
    }
}
 

private boolean logResult(File file,Action[] actions) {
    try {
        logManager.log(new ResultRecord(config, actions,file));
        return true;
    } catch (Exception x) {
        LOG.fine("Failed to log: "+file.getAbsolutePath());
    }
    return false;
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

private void logToMemory(ResultRecord record) {

        final boolean before = memCapacityReached;
        final boolean after;
        synchronized(this) {
            memoryLog.add(record);
            after = memCapacityReached;
        }
        if (before==false && after==true)
            sendNotification(new Notification(MEMORY_LOG_MAX_CAPACITY,
                    objectName,
                    getNextSeqNumber(),"memory log capacity reached"));
    }
 

private void logToFile(ResultRecord record) throws IOException {
    final String basename;
    final long   maxRecords;
    synchronized (this) {
        if (logFile == null) return;
        basename = getLogFileName(false);
        maxRecords = fileCapacity;
    }

    // Get the stream into which we should log.
    final OutputStream stream =
            checkLogFile(basename,maxRecords,false);

    // logging to file now disabled - too bad.
    if (stream == null) return;

    synchronized (this) {
        try {
            XmlConfigUtils.write(record,stream,true);
            stream.flush();
            // don't increment logCount if we were not logging in logStream.
            if (stream == logStream) logCount++;
        } catch (JAXBException x) {
            final IllegalArgumentException iae =
                    new IllegalArgumentException("bad record",x);
            LOG.finest("Failed to log record: "+x);
            throw iae;
        }
    }
}
 

private boolean logResult(File file,Action[] actions) {
    try {
        logManager.log(new ResultRecord(config, actions,file));
        return true;
    } catch (Exception x) {
        LOG.fine("Failed to log: "+file.getAbsolutePath());
    }
    return false;
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

private void logToMemory(ResultRecord record) {

        final boolean before = memCapacityReached;
        final boolean after;
        synchronized(this) {
            memoryLog.add(record);
            after = memCapacityReached;
        }
        if (before==false && after==true)
            sendNotification(new Notification(MEMORY_LOG_MAX_CAPACITY,
                    objectName,
                    getNextSeqNumber(),"memory log capacity reached"));
    }
 

private void logToFile(ResultRecord record) throws IOException {
    final String basename;
    final long   maxRecords;
    synchronized (this) {
        if (logFile == null) return;
        basename = getLogFileName(false);
        maxRecords = fileCapacity;
    }

    // Get the stream into which we should log.
    final OutputStream stream =
            checkLogFile(basename,maxRecords,false);

    // logging to file now disabled - too bad.
    if (stream == null) return;

    synchronized (this) {
        try {
            XmlConfigUtils.write(record,stream,true);
            stream.flush();
            // don't increment logCount if we were not logging in logStream.
            if (stream == logStream) logCount++;
        } catch (JAXBException x) {
            final IllegalArgumentException iae =
                    new IllegalArgumentException("bad record",x);
            LOG.finest("Failed to log record: "+x);
            throw iae;
        }
    }
}