OOAsyncLogger Class Reference

Inheritance diagram for OOAsyncLogger:

Collaboration diagram for OOAsyncLogger:

Instance Methods
(void)	- asyncLogMessage:
(void)	- endLogging
(void)	- changeFile
(BOOL)	- startLogging
(void)	- loggerThread
(void)	- flushLog
(id)	- init [implementation]
(void)	- dealloc [implementation]

Private Attributes
OOAsyncQueue *	messageQueue
NSConditionLock *	threadStateMonitor
NSFileHandle *	logFile
NSTimer *	flushTimer

Detailed Description

Definition at line 89 of file OOLogOutputHandler.m.

Method Documentation

asyncLogMessage:

- (void) asyncLogMessage:

(NSString *)

message

Definition at line 387 of file OOLogOutputHandler.m.

                       :(NSString *)message
{
    // Don't log of saturated flag is set.
    if (sSaturated)  return;
    
    if (message != nil)
    {
        message = [message stringByAppendingString:@"\n"];
        
#if OOLITE_WINDOWS
        // Convert Unix line endings to Windows ones.
        NSArray *messageComponents = [message componentsSeparatedByString:@"\n"];
        message = [messageComponents componentsJoinedByString:@"\r\n"];
#endif
        
        [messageQueue enqueue:[message dataUsingEncoding:NSUTF8StringEncoding]];
        
        if (flushTimer == nil)
        {
            // No pending flush
            flushTimer = [NSTimer scheduledTimerWithTimeInterval:kFlushInterval target:self selector:@selector(flushLog) userInfo:nil repeats:NO];
        }
    }
}

References OOAsyncQueue::enqueue:, flushTimer, nil, and sSaturated.

Referenced by endLogging, and OOLogOutputHandlerPrint().

Here is the call graph for this function:

Here is the caller graph for this function:

changeFile

- (void) changeFile

Definition at line 380 of file OOLogOutputHandler.m.

{
    [self endLogging];
    if (![self startLogging])  sWriteToStderr = YES;
}

References changeFile, endLogging, startLogging, and sWriteToStderr.

Referenced by changeFile, and OOLogOutputHandlerChangeLogFile().

Here is the call graph for this function:

Here is the caller graph for this function:

dealloc

- (void) dealloc

implementation

Definition at line 284 of file OOLogOutputHandler.m.

{
    DESTROY(messageQueue);
    DESTROY(threadStateMonitor);
    DESTROY(logFile);
    // We don't own a reference to flushTimer.
    
    [super dealloc];
}

References dealloc, DESTROY, logFile, messageQueue, and threadStateMonitor.

Referenced by dealloc.

Here is the call graph for this function:

Here is the caller graph for this function:

endLogging

- (void) endLogging

Definition at line 362 of file OOLogOutputHandler.m.

{
    NSString                *postamble = nil;
    
    if (messageQueue != nil && threadStateMonitor != nil)
    {
        // We're fully inited; write postamble, wait for worker thread to terminate cleanly, and close file.
        postamble = [NSString stringWithFormat:@"\nClosing log at %@.", [NSDate date]];
        [self asyncLogMessage:postamble];
        [messageQueue enqueue:@"die"];  // Kill message
        [threadStateMonitor lockWhenCondition:kConditionReadyToDealloc];
        [threadStateMonitor unlock];
        
        [logFile closeFile];
    }
}

References asyncLogMessage:, endLogging, OOAsyncQueue::enqueue:, messageQueue, nil, and threadStateMonitor.

Referenced by changeFile, endLogging, and OOLogOutputHandlerClose().

Here is the call graph for this function:

Here is the caller graph for this function:

flushLog

- (void) flushLog

Definition at line 413 of file OOLogOutputHandler.m.

{
    flushTimer = nil;
    [messageQueue enqueue:@"flush"];
}

References OOAsyncQueue::enqueue:, flushLog, flushTimer, and nil.

Referenced by flushLog.

Here is the call graph for this function:

Here is the caller graph for this function:

init

- (id) init

implementation

Definition at line 245 of file OOLogOutputHandler.m.

{
    BOOL                OK = YES;
    NSString            *logPath = nil;
    NSString            *oldPath = nil;
    NSFileManager       *fmgr = nil;
    
    self = [super init];
    if (self == nil)  OK = NO;
    
    if (OK)
    {
        fmgr = [NSFileManager defaultManager];
        logPath = OOLogHandlerGetLogPath();
        
        // If there is an existing file, move it to Previous.log.
        if ([fmgr fileExistsAtPath:logPath])
        {
            oldPath = [OOLogHandlerGetLogBasePath() stringByAppendingPathComponent:@"Previous.log"];
            [fmgr oo_removeItemAtPath:oldPath];
            if (![fmgr oo_moveItemAtPath:logPath toPath:oldPath])
            {
                if (![fmgr oo_removeItemAtPath:logPath])
                {
                    NSLog(@"Log setup: could not move or delete existing log at %@, will log to stdout instead.", logPath);
                    OK = NO;
                }
            }
        }
    }
    
    if (OK)  OK = [self startLogging];
    
    if (!OK)  DESTROY(self);
    
    return self;
}

References DESTROY, init, nil, NSLog, OOLogHandlerGetLogPath(), and startLogging.

Referenced by init.

Here is the call graph for this function:

Here is the caller graph for this function:

loggerThread

- (void) loggerThread

Definition at line 420 of file OOLogOutputHandler.m.

{
    id                  message = nil;
    NSAutoreleasePool   *rootPool = nil, *pool = nil;
    NSUInteger          size = 0;
    
    rootPool = [[NSAutoreleasePool alloc] init];
    [NSThread ooSetCurrentThreadName:@"OOLogOutputHandler logging thread"];
    
    // Signal readiness
    [messageQueue retain];
    [threadStateMonitor lock];
    [threadStateMonitor unlockWithCondition:kConditionWorking];
    
    @try
    {
        for (;;)
        {
            pool = [[NSAutoreleasePool alloc] init];
            
            message = [messageQueue dequeue];
            
            if (!sSaturated && [message isKindOfClass:[NSData class]])
            {
                size += [message length];
                if (size > 1 << 30) // 1 GiB
                {
                    sSaturated = YES;
#if OOLITE_WINDOWS
                    message = @"\r\n\r\n\r\n***** LOG TRUNCATED DUE TO EXCESSIVE LENGTH *****\r\n";
#else
                    message = @"\n\n\n***** LOG TRUNCATED DUE TO EXCESSIVE LENGTH *****\n";
#endif
                    message = [message dataUsingEncoding:NSUTF8StringEncoding];
                }
                
                [logFile writeData:message];
            }
            else if ([message isEqual:@"flush"])
            {
                [logFile synchronizeFile];
            }
            else if ([message isEqual:@"die"])
            {
                break;
            }
            
            [pool release];
        }
    }
    @catch (NSException *exception) {}
    [pool release];
    
    // Clean up; after this, ivars are out of bounds.
    [messageQueue release];
    [threadStateMonitor lock];
    [threadStateMonitor unlockWithCondition:kConditionReadyToDealloc];
    
    [rootPool release];
}

References OOAsyncQueue::dequeue, loggerThread, nil, and sSaturated.

Referenced by loggerThread.

Here is the call graph for this function:

Here is the caller graph for this function:

startLogging

- (BOOL) startLogging

Definition at line 295 of file OOLogOutputHandler.m.

{
    BOOL                OK = YES;
    NSString            *logPath = nil;
    NSFileManager       *fmgr = nil;
    
    fmgr = [NSFileManager defaultManager];
    
    if (OK)
    {
        messageQueue = [[OOAsyncQueue alloc] init];
        if (messageQueue == nil)  OK = NO;
    }
    
    if (OK)
    {
        // set up threadStateMonitor -- used as a binary semaphore of sorts to check when the worker thread starts and stops.
        threadStateMonitor = [[NSConditionLock alloc] initWithCondition:kConditionReadyToDealloc];
        if (threadStateMonitor == nil)  OK = NO;
        [threadStateMonitor setName:@"OOLogOutputHandler thread state monitor"];
    }
    
    if (OK)
    {
        // Create work thread to actually handle messages.
        // This needs to be done early to avoid messy state if something goes wrong.
        [NSThread detachNewThreadSelector:@selector(loggerThread) toTarget:self withObject:nil];
        // Wait for it to start.
        if (![threadStateMonitor lockWhenCondition:kConditionWorking beforeDate:[NSDate dateWithTimeIntervalSinceNow:5.0]])
        {
            // If it doesn't signal a start within five seconds, assume something's wrong.
            // Send kill signal, just in case it comes to life...
            [messageQueue enqueue:@"die"];
            // ...and stop -dealloc from waiting for thread death
            [threadStateMonitor release];
            threadStateMonitor = nil;
            OK = NO;
        }
        [threadStateMonitor unlockWithCondition:kConditionWorking];
    }
    
    if (OK)
    {
        logPath = OOLogHandlerGetLogPath();
        OK = (logPath != nil);
    }
    
    if (OK)
    {
        // Create shiny new log file
        OK = [fmgr createFileAtPath:logPath contents:nil attributes:nil];
        if (OK)
        {
            logFile = [[NSFileHandle fileHandleForWritingAtPath:logPath] retain];
            OK = (logFile != nil);
        }
        if (!OK)
        {
            NSLog(@"Log setup: could not open log at %@, will log to stdout instead.", logPath);
            OK = NO;
        }
    }
    
    return OK;
}

References OOAsyncQueue::enqueue:, kConditionWorking, logFile, messageQueue, nil, NSLog, OOLogHandlerGetLogPath(), startLogging, and threadStateMonitor.

Referenced by changeFile, init, and startLogging.

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

flushTimer

- (NSTimer*) flushTimer

private

Definition at line 95 of file OOLogOutputHandler.m.

Referenced by asyncLogMessage:, and flushLog.

logFile

- (NSFileHandle*) logFile

private

Definition at line 94 of file OOLogOutputHandler.m.

Referenced by dealloc, and startLogging.

messageQueue

- (OOAsyncQueue*) messageQueue

private

Definition at line 92 of file OOLogOutputHandler.m.

Referenced by dealloc, endLogging, and startLogging.

threadStateMonitor

- (NSConditionLock*) threadStateMonitor

private

Definition at line 93 of file OOLogOutputHandler.m.

Referenced by dealloc, endLogging, and startLogging.

---

The documentation for this class was generated from the following file:

• src/Core/OOLogOutputHandler.m