OOOXPVerifier(OOPrivate) Category Reference

Instance Methods
(id)	- initWithPath:
(void)	- run
(void)	- setUpLogOverrides
(void)	- registerBaseStages
(void)	- buildDependencyGraph
(void)	- runStages
(BOOL)	- setUpDependencies:forStage:
(void)	- setUpDependents:forStage:
(void)	- dumpDebugGraphviz

Detailed Description

Definition at line 65 of file OOOXPVerifier.m.

Method Documentation

buildDependencyGraph

- (void) buildDependencyGraph

Extends class OOOXPVerifier.

Definition at line 394 of file OOOXPVerifier.m.

{
    NSAutoreleasePool       *pool = nil;
    NSArray                 *stageKeys = nil;
    NSEnumerator            *stageEnum = nil;
    NSString                *stageKey = nil;
    OOOXPVerifierStage      *stage = nil;
    NSString                *name = nil;
    NSMutableDictionary     *dependenciesByStage = nil,
                            *dependentsByStage = nil;
    NSSet                   *dependencies = nil,
                            *dependents = nil;
    NSValue                 *key = nil;
    
    pool = [[NSAutoreleasePool alloc] init];
    
    /*  Iterate over all stages, getting dependency and dependent sets.
        This is done in advance so that -dependencies and -dependents may
        register stages.
    */
    dependenciesByStage = [NSMutableDictionary dictionary];
    dependentsByStage = [NSMutableDictionary dictionary];
    
    for (;;)
    {
        /*  Loop while there are stages whose dependency lists haven't been
            checked. This is an indeterminate loop since new ones can be
            added.
        */
        stage = [_waitingStages anyObject];
        if (stage == nil)  break;
        [_waitingStages removeObject:stage];
        
        key = [NSValue valueWithNonretainedObject:stage];
        
        dependencies = [stage dependencies];
        if (dependencies != nil)
        {
            [dependenciesByStage setObject:dependencies
                                    forKey:key];
        }
        
        dependents = [stage dependents];
        if (dependents != nil)
        {
            [dependentsByStage setObject:dependents
                                  forKey:key];
        }
    }
    [_waitingStages release];
    _waitingStages = nil;
    _openForRegistration = NO;
    
    // Iterate over all stages, resolving dependencies.
    stageKeys = [_stagesByName allKeys];    // Get the keys up front because we may need to remove entries from dictionary.
    
    for (stageEnum = [stageKeys objectEnumerator]; (stageKey = [stageEnum nextObject]); )
    {
        stage = [_stagesByName objectForKey:stageKey];
        if (stage == nil)  continue;
        
        // Sanity check
        name = [stage name];
        if (![stageKey isEqualToString:name])
        {
            OOLog(@"verifyOXP.buildDependencyGraph.badName", @"***** Stage name appears to have changed from \"%@\" to \"%@\" for verifier stage %@, removing.", stageKey, name, stage);
            [_stagesByName removeObjectForKey:stageKey];
            continue;
        }
        
        // Get dependency set
        key = [NSValue valueWithNonretainedObject:stage];
        dependencies = [dependenciesByStage objectForKey:key];
        
        if (dependencies != nil && ![self setUpDependencies:dependencies forStage:stage])
        {
            [_stagesByName removeObjectForKey:stageKey];
        }
    }
    
    /*  Iterate over all stages again, resolving reverse dependencies.
        This is done in a separate pass because reverse dependencies are "weak"
        while forward dependencies are "strong". 
    */
    stageKeys = [_stagesByName allKeys];
    
    for (stageEnum = [stageKeys objectEnumerator]; (stageKey = [stageEnum nextObject]); )
    {
        stage = [_stagesByName objectForKey:stageKey];
        if (stage == nil)  continue;
        
        // Get dependent set
        key = [NSValue valueWithNonretainedObject:stage];
        dependents = [dependentsByStage objectForKey:key];
        
        if (dependents != nil)
        {
            [self setUpDependents:dependents forStage:stage];
        }
    }
    
    _waitingStages = [[NSMutableSet alloc] initWithArray:[_stagesByName allValues]];
    [_waitingStages makeObjectsPerformSelector:@selector(dependencyRegistrationComplete)];
    
    if ([[NSUserDefaults standardUserDefaults] boolForKey:@"oxp-verifier-dump-debug-graphviz"])
    {
        [self dumpDebugGraphviz];
    }
    
    [pool release];
}

References buildDependencyGraph, OOOXPVerifierStage::dependencies, OOOXPVerifierStage::dependents, OOOXPVerifier::dumpDebugGraphviz, OOOXPVerifierStage::name, nil, OOLog, and OOOXPVerifier::setUpDependents:forStage:.

Referenced by buildDependencyGraph.

Here is the call graph for this function:

Here is the caller graph for this function:

dumpDebugGraphviz

- (void) dumpDebugGraphviz

Extends class OOOXPVerifier.

Definition at line 644 of file OOOXPVerifier.m.

{
    NSMutableString             *graphViz = nil;
    NSDictionary                *graphVizTemplate = nil;
    NSString                    *template = nil,
                                *startTemplate = nil,
                                *endTemplate = nil;
    NSEnumerator                *stageEnum = nil;
    OOOXPVerifierStage          *stage = nil;
    NSSet                       *deps = nil;
    NSEnumerator                *depEnum = nil;
    OOOXPVerifierStage          *dep = nil;
    
    graphVizTemplate = [self configurationDictionaryForKey:@"debugGraphvizTempate"];
    graphViz = [NSMutableString stringWithFormat:[graphVizTemplate oo_stringForKey:@"preamble"], [NSDate date]];
    
    /*  Pass 1: enumerate over graph setting node attributes for each stage.
        We use pointers as node names for simplicity of generation.
    */
    template = [graphVizTemplate oo_stringForKey:@"node"];
    for (stageEnum = [_stagesByName objectEnumerator]; (stage = [stageEnum nextObject]); )
    {
        [graphViz appendFormat:template, stage, [stage class], [stage name]];
    }
    
    [graphViz appendString:[graphVizTemplate oo_stringForKey:@"forwardPreamble"]];
    
    /*  Pass 2: enumerate over graph setting forward arcs for each dependency.
    */
    template = [graphVizTemplate oo_stringForKey:@"forwardArc"];
    startTemplate = [graphVizTemplate oo_stringForKey:@"startArc"];
    for (stageEnum = [_stagesByName objectEnumerator]; (stage = [stageEnum nextObject]); )
    {
        deps = [stage resolvedDependencies];
        if ([deps count] != 0)
        {
            for (depEnum = [deps objectEnumerator]; (dep = [depEnum nextObject]); )
            {
                [graphViz appendFormat:template, dep, stage];
            }
        }
        else
        {
            [graphViz appendFormat:startTemplate, stage];
        }
    }
    
    [graphViz appendString:[graphVizTemplate oo_stringForKey:@"backwardPreamble"]];
    
    /*  Pass 3: enumerate over graph setting backward arcs for each dependent.
    */
    template = [graphVizTemplate oo_stringForKey:@"backwardArc"];
    endTemplate = [graphVizTemplate oo_stringForKey:@"endArc"];
    for (stageEnum = [_stagesByName objectEnumerator]; (stage = [stageEnum nextObject]); )
    {
        deps = [stage resolvedDependents];
        if ([deps count] != 0)
        {
            for (depEnum = [deps objectEnumerator]; (dep = [depEnum nextObject]); )
            {
                [graphViz appendFormat:template, dep, stage];
            }
        }
        else
        {
            [graphViz appendFormat:endTemplate, stage];
        }
    }
    
    [graphViz appendString:[graphVizTemplate oo_stringForKey:@"postamble"]];
    
    // Write file
    [ResourceManager writeDiagnosticString:graphViz toFileNamed:@"OXPVerifierStageDependencies.dot"];
}

References OOOXPVerifier::configurationDictionaryForKey:, count, dumpDebugGraphviz, OOOXPVerifierStage::name, nil, OOOXPVerifierStage::resolvedDependencies, OOOXPVerifierStage::resolvedDependents, and ResourceManager::writeDiagnosticString:toFileNamed:.

Referenced by dumpDebugGraphviz.

Here is the call graph for this function:

Here is the caller graph for this function:

initWithPath:

- (id) initWithPath:

(NSString *)

path

Extends class OOOXPVerifier.

Definition at line 268 of file OOOXPVerifier.m.

                  :(NSString *)path
{
    self = [super init];
 
    OOSetStandardsForOXPVerifierMode();
 
    NSString *verifierPListPath = [[[ResourceManager builtInPath] stringByAppendingPathComponent:@"Config"] stringByAppendingPathComponent:@"verifyOXP.plist"];
    _verifierPList = [[NSDictionary dictionaryWithContentsOfFile:verifierPListPath] retain];
    
    _basePath = [path copy];
    _displayName = [[NSFileManager defaultManager] displayNameAtPath:_basePath];
    if (_displayName == nil)  _displayName = [_basePath lastPathComponent];
    [_displayName retain];
    
    _stagesByName = [[NSMutableDictionary alloc] init];
    _waitingStages = [[NSMutableSet alloc] init];
    
    if (_verifierPList == nil ||
        _basePath == nil)
    {
        OOLog(@"verifyOXP.setup.failed", @"%@", @"***** ERROR: failed to set up OXP verifier.");
        [self release];
        return nil;
    }
    
    _openForRegistration = YES;
    
    return self;
}

References ResourceManager::builtInPath, nil, OOLog, and OOSetStandardsForOXPVerifierMode().

Here is the call graph for this function:

registerBaseStages

- (void) registerBaseStages

Extends class OOOXPVerifier.

Definition at line 354 of file OOOXPVerifier.m.

{
    NSAutoreleasePool       *pool = nil;
    NSSet                   *stages = nil;
    NSSet                   *excludeStages = nil;
    NSEnumerator            *stageEnum = nil;
    NSString                *stageName = nil;
    Class                   stageClass = Nil;
    OOOXPVerifierStage      *stage = nil;
    
    pool = [[NSAutoreleasePool alloc] init];
    
    // Load stages specified as array of class names in verifyOXP.plist
    stages = [self configurationSetForKey:@"stages"];
    excludeStages = [self configurationSetForKey:@"excludeStages"];
    if ([excludeStages count] != 0)
    {
        stages = [[stages mutableCopy] autorelease];
        [(NSMutableSet *)stages minusSet:excludeStages];
    }
    for (stageEnum = [stages objectEnumerator]; (stageName = [stageEnum nextObject]); )
    {
        if ([stageName isKindOfClass:[NSString class]])
        {
            stageClass = NSClassFromString(stageName);
            if (stageClass == Nil)
            {
                OOLog(@"verifyOXP.registration.failed", @"Attempt to register unknown class %@ as a verifier stage, ignoring.", stageName);
                continue;
            }
            stage = [[stageClass alloc] init];
            [self registerStage:stage];
            [stage release];
        }
    }
    
    [pool release];
}

References OOOXPVerifier::configurationSetForKey:, count, nil, OOLog, registerBaseStages, and OOOXPVerifier::registerStage:.

Referenced by registerBaseStages.

Here is the call graph for this function:

Here is the caller graph for this function:

run

- (void) run

Extends class OOOXPVerifier.

Definition at line 299 of file OOOXPVerifier.m.

{
    NoteVerificationStage(_displayName, @"");
    
    [self setUpLogOverrides];
    
    /*  We need to be able to look up internal files, but not other OXP files.
        To do this without clobbering the disk cache, we disable cache writes.
    */
    [[OOCacheManager sharedCache] flush];
    [[OOCacheManager sharedCache] setAllowCacheWrites:NO];
    /* FIXME: the OXP verifier should load files from OXPs which have
     * been explicitly listed as required_oxps in the
     * manifest. Reading the manifest from the OXP being verified and
     * setting 'id:<its identifier>' below will do this. */
    [ResourceManager setUseAddOns:SCENARIO_OXP_DEFINITION_NONE];
    
    SwitchLogFile(_displayName);
    OOLog(@"verifyOXP.start", @"Running OXP verifier for %@", _basePath);//_displayName);
    
    [self registerBaseStages];
    [self buildDependencyGraph];
    [self runStages];
    
    NoteVerificationStage(_displayName, @"");
    OOLog(@"verifyOXP.done", @"%@", @"OXP verification complete.");
    
    OpenLogFile(_displayName);
}

References OOOXPVerifier::buildDependencyGraph, OOCacheManager::flush, NoteVerificationStage(), OOLog, OpenLogFile(), OOOXPVerifier::registerBaseStages, run, OOOXPVerifier::runStages, OOCacheManager::setAllowCacheWrites:, OOOXPVerifier::setUpLogOverrides, ResourceManager::setUseAddOns:, OOCacheManager::sharedCache, and SwitchLogFile().

Referenced by run.

Here is the call graph for this function:

Here is the caller graph for this function:

runStages

- (void) runStages

Extends class OOOXPVerifier.

Definition at line 507 of file OOOXPVerifier.m.

{
    NSAutoreleasePool       *pool = nil;
    NSEnumerator            *stageEnum = nil;
    OOOXPVerifierStage      *candidateStage = nil,
                            *stageToRun = nil;
    NSString                *stageName = nil;
    
    // Loop while there are still stages to run.
    for (;;)
    {
        pool = [[NSAutoreleasePool alloc] init];
        
        // Look through queue for a stage that's ready
        stageToRun = nil;
        for (stageEnum = [_waitingStages objectEnumerator]; (candidateStage = [stageEnum nextObject]); )
        {
            if ([candidateStage canRun])
            {
                stageToRun = candidateStage;
                break;
            }
        }
        if (stageToRun == nil)
        {
            // No more runnable stages
            [pool release];
            break;
        }
        
        stageName = nil;
        OOLogPushIndent();
        @try
        {
            stageName = [stageToRun name];
            if ([stageToRun shouldRun])
            {
                NoteVerificationStage(_displayName, stageName);
                OOLog(@"verifyOXP.runStage", @"%@", stageName);
                OOLogIndent();
                [stageToRun performRun];
            }
            else
            {
                OOLog(@"verifyOXP.verbose.skipStage", @"- Skipping stage: %@ (nothing to do).", stageName);
                [stageToRun noteSkipped];
            }
        }
        @catch (NSException *exception)
        {
            if (stageName == nil)  stageName = [[stageToRun class] description];
            OOLog(@"verifyOXP.exception", @"***** Exception occurred when running OXP verifier stage \"%@\": %@: %@", stageName, [exception name], [exception reason]);
        }
        OOLogPopIndent();
        
        [_waitingStages removeObject:stageToRun];
        [pool release];
    }
    
    pool = [[NSAutoreleasePool alloc] init];
    
    if ([_waitingStages count] != 0)
    {
        OOLog(@"verifyOXP.incomplete", @"%@", @"Some verifier stages could not be run:");
        OOLogIndent();
        for (stageEnum = [_waitingStages objectEnumerator]; (candidateStage = [stageEnum nextObject]); )
        {
            OOLog(@"verifyOXP.incomplete.item", @"%@", candidateStage);
        }
        OOLogOutdent();
    }
    [_waitingStages release];
    _waitingStages = nil;
    
    [pool release];
}

References count, nil, NoteVerificationStage(), OOLog, OOLogIndent(), OOLogOutdent(), OOLogPopIndent(), OOLogPushIndent(), and runStages.

Referenced by runStages.

Here is the call graph for this function:

Here is the caller graph for this function:

setUpDependencies:forStage:

- (BOOL) setUpDependencies:		(NSSet *)	dependencies
forStage:		(OOOXPVerifierStage *)	stage

Extends class OOOXPVerifier.

Definition at line 585 of file OOOXPVerifier.m.

                         :(NSSet *)dependencies
                 forStage:(OOOXPVerifierStage *)stage
{
    NSString                *depName = nil;
    NSEnumerator            *depEnum = nil;
    OOOXPVerifierStage      *depStage = nil;
    
    // Iterate over dependencies, connecting them up.
    for (depEnum = [dependencies objectEnumerator]; (depName = [depEnum nextObject]); )
    {
        depStage = [_stagesByName objectForKey:depName];
        if (depStage == nil)
        {
            OOLog(@"verifyOXP.buildDependencyGraph.unresolved", @"Verifier stage %@ has unresolved dependency \"%@\", skipping.", stage, depName);
            return NO;
        }
        
        if ([depStage isDependentOf:stage])
        {
            OOLog(@"verifyOXP.buildDependencyGraph.circularReference", @"Verifier stages %@ and %@ have a dependency loop, skipping.", stage, depStage);
            [_stagesByName removeObjectForKey:depName];
            return NO;
        }
        
        [stage registerDependency:depStage];
    }
    
    return YES;
}

References nil, and OOLog.

setUpDependents:forStage:

- (void) setUpDependents:		(NSSet *)	dependents
forStage:		(OOOXPVerifierStage *)	stage

Extends class OOOXPVerifier.

Definition at line 616 of file OOOXPVerifier.m.

                       :(NSSet *)dependents
               forStage:(OOOXPVerifierStage *)stage
{
    NSString                *depName = nil;
    NSEnumerator            *depEnum = nil;
    OOOXPVerifierStage      *depStage = nil;
    
    // Iterate over dependents, connecting them up.
    for (depEnum = [dependents objectEnumerator]; (depName = [depEnum nextObject]); )
    {
        depStage = [_stagesByName objectForKey:depName];
        if (depStage == nil)
        {
            OOLog(@"verifyOXP.buildDependencyGraph.unresolved", @"Verifier stage %@ has unresolved dependent \"%@\".", stage, depName);
            continue;   // Unresolved/conflicting dependents are non-fatal
        }
        
        if ([stage isDependentOf:depStage])
        {
            OOLog(@"verifyOXP.buildDependencyGraph.circularReference", @"Verifier stage %@ lists %@ as both dependent and dependency (possibly indirectly); will execute %@ after %@.", stage, depStage, stage, depStage);
            continue;
        }
        
        [depStage registerDependency:stage];
    }
}

References nil, and OOLog.

setUpLogOverrides

- (void) setUpLogOverrides

Extends class OOOXPVerifier.

Definition at line 330 of file OOOXPVerifier.m.

{
    NSDictionary            *overrides = nil;
    NSEnumerator            *messageClassEnum = nil;
    NSString                *messageClass = nil;
    id                      verbose = nil;
    
    OOLogSetShowMessageClassTemporary([_verifierPList oo_boolForKey:@"logShowMessageClassOverride" defaultValue:NO]);
    
    overrides = [_verifierPList oo_dictionaryForKey:@"logControlOverride"];
    for (messageClassEnum = [overrides keyEnumerator]; (messageClass = [messageClassEnum nextObject]); )
    {
        OOLogSetDisplayMessagesInClass(messageClass, [overrides oo_boolForKey:messageClass defaultValue:NO]);
    }
    
    /*  Since actually editing logControlOverride is a pain, we also allow
        overriding verifyOXP.verbose through user defaults. This is at least
        as much a pain under GNUstep, but very convenient under OS X.
    */
    verbose = [[NSUserDefaults standardUserDefaults] objectForKey:@"oxp-verifier-verbose-logging"];
    if (verbose != nil)  OOLogSetDisplayMessagesInClass(@"verifyOXP.verbose", OOBooleanFromObject(verbose, NO));
}

References nil, OOBooleanFromObject(), OOLogSetDisplayMessagesInClass(), OOLogSetShowMessageClassTemporary(), and setUpLogOverrides.

Referenced by setUpLogOverrides.

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• src/Core/OXPVerifier/OOOXPVerifier.m