You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@gump.apache.org by bo...@apache.org on 2009/03/02 06:00:12 UTC
svn commit: r749185 [2/3] - in /gump/live: ./
python/gump/actor/document/xdocs/ python/gump/core/model/
python/gump/core/update/ python/gump/test/ python/gump/util/process/
Modified: gump/live/python/gump/actor/document/xdocs/documenter.py
URL: http://svn.apache.org/viewvc/gump/live/python/gump/actor/document/xdocs/documenter.py?rev=749185&r1=749184&r2=749185&view=diff
==============================================================================
--- gump/live/python/gump/actor/document/xdocs/documenter.py (original)
+++ gump/live/python/gump/actor/document/xdocs/documenter.py Mon Mar 2 05:00:11 2009
@@ -6,9 +6,9 @@
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
-#
+#
# http://www.apache.org/licenses/LICENSE-2.0
-#
+#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,665 +20,711 @@
XDOC generation.
"""
-import socket
-import time
import os
+import StringIO
import sys
-import logging
-from string import lower,replace
-from xml.sax.saxutils import escape
+import time
from shutil import copyfile
+from xml.sax.saxutils import escape
from gump import log
-from gump.core.config import *
from gump.actor.document.documenter import Documenter
from gump.actor.document.text.documenter import TextDocumenter
-from gump.actor.document.xdocs.xdoc import *
-from gump.actor.document.xdocs.resolver import *
-from gump.util import *
-from gump.util.timing import *
-from gump.util.tools import syncDirectories,copyDirectories,wipeDirectoryTree
-
+from gump.actor.document.xdocs.config import XDocConfig
+from gump.actor.document.xdocs.resolver import XDocResolver, \
+ getDepthForObject, getRelativeLocation
+from gump.actor.document.xdocs.xdoc import XDocDocument
+from gump.core.config import default, dir, setting
from gump.core.language.path import AnnotatedPath
-
-from gump.core.model.stats import *
-from gump.core.model.project import ProjectStatistics
-from gump.core.model.state import *
-from gump.core.model.workspace import Workspace
-from gump.core.model.module import Module
-from gump.core.model.project import Project
from gump.core.model.misc import Resultable
-
+from gump.core.model.project import Project
+from gump.core.model.repository import SCM_TYPE_CVS, SCM_TYPE_P4
+from gump.core.model.state import REASON_BUILD_FAILED, REASON_PACKAGE, \
+ REASON_UNSET, reasonDescription, STATE_COMPLETE, STATE_FAILED, \
+ STATE_PREREQ_FAILED, STATE_SUCCESS, STATE_UNSET, stateDescription, stateName
+from gump.core.model.stats import INSIGNIFICANT_DURATION, SIGNIFICANT_DURATION
+from gump.core.model.workspace import Workspace
from gump.tool.guru.stats import StatisticsGuru
from gump.tool.guru.xref import XRefGuru
+from gump.tool.shared.comparator import compareProjectsByFullDependeeCount
+from gump.util import createOrderedList, getBeanAttributes, gumpSafeName, \
+ inspectGarbageCollection
+from gump.util.note import Annotatable, levelName
+from gump.util.timing import getGeneralSinceDescription, secsToElapsedTimeString
+from gump.util.tools import syncDirectories, copyDirectories, wipeDirectoryTree
+from gump.util.work import CommandWorkItem, TimedWorkItem, Workable, \
+ workTypeName
-from gump.core.run.gumprun import *
-
-from gump.tool.shared.comparator import *
-
class XDocDocumenter(Documenter):
-
+
def __init__(self, run, dirBase, urlBase):
- Documenter.__init__(self, run)
-
+ Documenter.__init__(self, run)
+
# Configuration can be overridden to be
# XDOCS, not the default of XHTML.
- self.config=XDocConfig(not run.getOptions().isXDocs())
-
- resolver=XDocResolver(dirBase,urlBase,self.config)
- self.setResolver(resolver)
-
+ self.config = XDocConfig(not run.getOptions().isXDocs())
+
+ resolver = XDocResolver(dirBase, urlBase, self.config)
+ self.setResolver(resolver)
+
def prepareRun(self):
-
+
log.debug('--- Prepare for Documenting Results')
# Seed with default/site skins/etc.
self.prepareXDoc()
-
- def processModule(self,module):
- verbose=self.run.getOptions().isVerbose()
- debug=self.run.getOptions().isDebug()
- self.documentModule(module,True)
+
+ def processModule(self, module):
+ self.documentModule(module, True)
self.syncObject(module)
-
- def processProject(self,project):
-
- verbose=self.run.getOptions().isVerbose()
- debug=self.run.getOptions().isDebug()
- self.documentProject(project,True)
-
+
+ def processProject(self, project):
+ self.documentProject(project, True)
self.syncObject(project)
-
+
# Do once every ...
if 0 == (project.getPositionIndex() % 5):
- self.documentBuildLog(True)
+ self.documentBuildLog(True)
self.syncBuildLog()
-
+
def documentRun(self):
-
+
log.debug('--- Documenting Results')
# Document...
- self.documentRunDetails()
- self.documentWorkspace()
+ self.documentRunDetails()
+ self.documentWorkspace()
self.documentEverythingElse()
-
+
# Once a day...
if self.run.getOptions().isOfficial():
self.documentStatistics()
self.documentXRef()
-
+
#####################################################################
#
# XDocing...
def getXDocWorkDirectory(self):
- if hasattr(self,'workDir'): return self.workDir
- wdir=os.path.abspath(os.path.join(
- self.workspace.getBaseDirectory(),'xdocs-work'))
+ if hasattr(self, 'workDir'):
+ return self.workDir
+ wdir = os.path.abspath(os.path.join(
+ self.workspace.getBaseDirectory(), 'xdocs-work'))
if self.config.isXdocs():
- wdir=os.path.abspath(os.path.join(wdir,'content'))
+ wdir = os.path.abspath(os.path.join(wdir, 'content'))
if not os.path.exists(wdir):
- os.makedirs(wdir)
- self.workDir=wdir
+ os.makedirs(wdir)
+ self.workDir = wdir
return self.workDir
-
+
def getXDocLogDirectory(self):
- if hasattr(self,'logDir'): return self.logDir
- ldir=self.workspace.getLogDirectory()
+ if hasattr(self, 'logDir'):
+ return self.logDir
+ ldir = self.workspace.getLogDirectory()
if self.config.isXdocs():
- ldir=os.path.abspath(os.path.join(ldir,'content'))
+ ldir = os.path.abspath(os.path.join(ldir, 'content'))
if not os.path.exists(ldir):
- os.makedirs(ldir)
- self.logDir=ldir
+ os.makedirs(ldir)
+ self.logDir = ldir
return self.logDir
-
+
def getXDocTemplateDirectory(self):
- """ Template (XDoc skin/config) """
- templateName='forrest'
+ """ Template (XDoc skin/config) """
+ templateName = 'forrest'
if self.config.isXhtml():
- templateName='xhtml'
- fdir=os.path.abspath(os.path.join(dir.template,templateName))
+ templateName = 'xhtml'
+ fdir = os.path.abspath(os.path.join(dir.template, templateName))
if self.config.isXdocs():
- fdir=os.path.abspath(os.path.join(fdir,'content'))
- return fdir
-
+ fdir = os.path.abspath(os.path.join(fdir, 'content'))
+ return fdir
+
def getXDocSiteTemplateDirectory(self):
- """ Site Template (XDoc skin/config tweaks) """
- templateName='site-forrest'
+ """ Site Template (XDoc skin/config tweaks) """
+ templateName = 'site-forrest'
if self.config.isXhtml():
- templateName='site-xhtml'
- fdir=os.path.abspath(os.path.join(dir.template,templateName))
+ templateName = 'site-xhtml'
+ fdir = os.path.abspath(os.path.join(dir.template, templateName))
if self.config.isXdocs():
- fdir=os.path.abspath(os.path.join(fdir,'content'))
- return fdir
-
- def prepareXDoc(self):
- """
-
+ fdir = os.path.abspath(os.path.join(fdir, 'content'))
+ return fdir
+
+ def prepareXDoc(self):
+ """
+
Copy the main template (perhaps with site tweaks) to prepare
-
- """
- log.info('Prepare XDoc work with template')
- xdocLogDir=self.getXDocLogDirectory()
-
+
+ """
+ log.info('Prepare XDoc work with template')
+
# First deleted the work tree (if exists), then ensure created
- xdocWorkDir=self.getXDocWorkDirectory()
+ xdocWorkDir = self.getXDocWorkDirectory()
wipeDirectoryTree(xdocWorkDir)
-
+
# Sync in the defaults [i.e. cleans also]
- xdocTemplate=self.getXDocTemplateDirectory()
- syncDirectories( xdocTemplate, \
- xdocWorkDir, \
- self.workspace)
-
- # Copy over the local site defaults (if any)
- xdocSiteTemplate=self.getXDocSiteTemplateDirectory()
+ xdocTemplate = self.getXDocTemplateDirectory()
+ syncDirectories(xdocTemplate,
+ xdocWorkDir,
+ self.workspace)
+
+ # Copy over the local site defaults (if any)
+ xdocSiteTemplate = self.getXDocSiteTemplateDirectory()
if os.path.exists(xdocSiteTemplate):
- log.info('Prepare XDoc work with *site* template')
- copyDirectories(xdocSiteTemplate, \
- xdocWorkDir, \
- self.workspace)
-
- def syncObject(self,object):
+ log.info('Prepare XDoc work with *site* template')
+ copyDirectories(xdocSiteTemplate,
+ xdocWorkDir,
+ self.workspace)
+
+ def syncObject(self, obj):
# Get relative path
- objDir=self.resolver.getDirectoryRelativePath(object).serialize()
-
+ objDir = self.resolver.getDirectoryRelativePath(obj).serialize()
+
# Get relative to (1) work [source] (2) log [target] & sync
-
+
# Move xdocs from work directory to log
- xdocWorkDir=self.getXDocWorkDirectory()
- logDirectory=self.getXDocLogDirectory()
-
- workContents=os.path.abspath(os.path.join(xdocWorkDir,objDir))
- logContents=os.path.abspath(os.path.join(logDirectory,objDir))
-
- success=True
+ xdocWorkDir = self.getXDocWorkDirectory()
+ logDirectory = self.getXDocLogDirectory()
+
+ workContents = os.path.abspath(os.path.join(xdocWorkDir, objDir))
+ logContents = os.path.abspath(os.path.join(logDirectory, objDir))
+
+ success = True
try:
- if os.path.exists(workContents):
+ if os.path.exists(workContents):
# Sync over public pages...
- copyDirectories(workContents,logContents)
- except:
- log.error('--- Failed to sync ['+`objDir`+'] (work->log)', exc_info=1)
- success=False
-
- if self.config.isXdocs():
+ copyDirectories(workContents, logContents)
+ except:
+ log.error('--- Failed to sync [' + `objDir` + '] (work->log)',
+ exc_info = 1)
+ success = False
+
+ if self.config.isXdocs():
# Move contents/xdocs from work directory to log
# (Note: Forrest has contents/X and contents/xdocs/X)
- xdocWorkDir=os.path.abspath(os.path.join(xdocWorkDir,'xdocs'))
- logDirectory=os.path.abspath(os.path.join(logDirectory,'xdocs'))
-
- workContents=os.path.abspath(os.path.join(xdocWorkDir,objDir))
- logContents=os.path.abspath(os.path.join(logDirectory,objDir))
-
+ xdocWorkDir = os.path.abspath(os.path.join(xdocWorkDir, 'xdocs'))
+ logDirectory = os.path.abspath(os.path.join(logDirectory, 'xdocs'))
+
+ workContents = os.path.abspath(os.path.join(xdocWorkDir, objDir))
+ logContents = os.path.abspath(os.path.join(logDirectory, objDir))
+
try:
- if os.path.exists(workContents):
+ if os.path.exists(workContents):
# Sync over public pages...
- copyDirectories(workContents,logContents)
- except:
- log.error('--- Failed to sync xdocs ['+`objDir`+'] (work->log)', exc_info=1)
- success=False
-
+ copyDirectories(workContents, logContents)
+ except:
+ log.error('--- Failed to sync xdocs [' + `objDir` + \
+ '] (work->log)', exc_info = 1)
+ success = False
+
return success
-
- def syncBuildLog(self):
-
- logSpec=self.resolver.getFileSpec(self.workspace, 'buildLog')
-
- xdocWorkDir=self.getXDocWorkDirectory()
- logDirectory=self.getXDocLogDirectory()
-
- if self.config.isXdocs():
+
+ def syncBuildLog(self):
+
+ logSpec = self.resolver.getFileSpec(self.workspace, 'buildLog')
+
+ xdocWorkDir = self.getXDocWorkDirectory()
+ logDirectory = self.getXDocLogDirectory()
+
+ if self.config.isXdocs():
# Move contents/xdocs from work directory to log
# (Note: Forrest has contents/X and contents/xdocs/X)
- xdocWorkDir=os.path.abspath(os.path.join(xdocWorkDir,'xdocs'))
- logDirectory=os.path.abspath(os.path.join(logDirectory,'xdocs'))
-
+ xdocWorkDir = os.path.abspath(os.path.join(xdocWorkDir, 'xdocs'))
+ logDirectory = os.path.abspath(os.path.join(logDirectory, 'xdocs'))
+
# Current status
- logSource=os.path.abspath(
- os.path.join(xdocWorkDir,logSpec.getDocument()))
- logTarget=os.path.abspath(
- os.path.join(logDirectory,logSpec.getDocument()))
-
+ logSource = os.path.abspath(
+ os.path.join(xdocWorkDir, logSpec.getDocument()))
+ logTarget = os.path.abspath(
+ os.path.join(logDirectory, logSpec.getDocument()))
+
# Do the transfer..
- success=True
+ success = True
try:
- log.debug('Copy %s to %s' % ( logSource, logTarget))
- copyfile(logSource,logTarget)
- except:
- log.error('--- Failed to sync buildLog work->log', exc_info=1)
- success=False
-
+ log.debug('Copy %s to %s' % (logSource, logTarget))
+ copyfile(logSource, logTarget)
+ except:
+ log.error('--- Failed to sync buildLog work->log', exc_info = 1)
+ success = False
+
return success
-
- #####################################################################
+
+ #####################################################################
#
# Workspace Pieces
- #
+ #
def documentRunDetails(self):
-
+
#
# ----------------------------------------------------------------------
#
# Index.xml
- #
- spec=self.resolver.getFileSpec(self.run)
-
- document=XDocDocument('Gump Run',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
-
- definitionSection=document.createSection('Run Details')
-
+ #
+ spec = self.resolver.getFileSpec(self.run)
+
+ document = XDocDocument('Gump Run',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
+
+ definitionSection = document.createSection('Run Details')
+
if not self.gumpSet.isFull():
self.documentPartial(definitionSection)
- definitionTable=definitionSection.createTable()
+ definitionTable = definitionSection.createTable()
definitionTable.createEntry('Gump Run GUID', self.run.getRunGuid())
- definitionTable.createEntry('Gump Run (Hex) GUID', self.run.getRunHexGuid())
+ definitionTable.createEntry('Gump Run (Hex) GUID',
+ self.run.getRunHexGuid())
definitionTable.createEntry('Gump Version', setting.VERSION)
-
+
# RSS|Atom|RDF
- self.documentXMLLinks(document, definitionTable, depth=getDepthForObject(self.workspace))
-
- #rdfUrl=self.resolver.getUrl(self.workspace,'gump','.rdf')
- #rdfArea.createFork('http://www.feedvalidator.org/check.cgi?url=' + rdfUrl) \
- # .createIcon(self.resolver.getImageUrl('valid-rdf.png'), alt='[Valid Atom]') #, title='Validate my Atom feed', width='88', height='31')
-
- self.documentSummary(document,self.workspace.getProjectSummary())
-
- dtSection=definitionSection.createSection('Dates/Times')
- dtTable=dtSection.createTable()
+ self.documentXMLLinks(document, definitionTable,
+ depth = getDepthForObject(self.workspace))
+
+ #rdfUrl = self.resolver.getUrl(self.workspace, 'gump', '.rdf')
+ #rdfArea.createFork('http://www.feedvalidator.org/check.cgi?url=' + \
+ # rdfUrl)\
+ # .createIcon(self.resolver\
+ # .getImageUrl('valid-rdf.png'),
+ # alt='[Valid Atom]')
+ #, title='Validate my Atom feed',
+ #width='88', height='31')
+
+ self.documentSummary(document, self.workspace.getProjectSummary())
+
+ dtSection = definitionSection.createSection('Dates/Times')
+ dtTable = dtSection.createTable()
dtTable.createEntry('@@DATE@@', default.date_s)
- dtTable.createEntry('Start Date/Time (UTC)', self.run.getStart().getUtc())
+ dtTable.createEntry('Start Date/Time (UTC)',
+ self.run.getStart().getUtc())
dtTable.createEntry('End Date/Time (UTC)', self.run.getEnd().getUtc())
dtTable.createEntry('Timezone', self.run.getEnvironment().getTimezone())
dtTable.createEntry('Start Date/Time', self.run.getStart().getLocal())
dtTable.createEntry('End Date/Time', self.run.getEnd().getLocal())
dtTable.createEntry('Elapsed Time', self.run.getElapsedTimeString())
- pythonSection=definitionSection.createSection('Python Information')
- pythonTable=pythonSection.createTable()
+ pythonSection = definitionSection.createSection('Python Information')
+ pythonTable = pythonSection.createTable()
pythonTable.createEntry('Python', str(sys.version))
- pythonTable.createEntry('Operating System (Name)', str(os.name))
- tracked=inspectGarbageCollection()
+ pythonTable.createEntry('Operating System (Name)', str(os.name))
+ tracked = inspectGarbageCollection()
if tracked:
- pythonTable.createEntry('Garbage Collector Tracked', tracked)
-
- javaSection=definitionSection.createSection('Java Information')
- javaTable=javaSection.createTable()
- javaTable.createEntry('Java Command', self.run.getEnvironment().javaCommand)
- javaproperties=self.run.getEnvironment().getJavaProperties()
+ pythonTable.createEntry('Garbage Collector Tracked', tracked)
+
+ javaSection = definitionSection.createSection('Java Information')
+ javaTable = javaSection.createTable()
+ javaTable.createEntry('Java Command',
+ self.run.getEnvironment().javaCommand)
+ javaproperties = self.run.getEnvironment().getJavaProperties()
if javaproperties:
- for name in ['java.vendor', 'java.version', 'os.name', 'os.arch', 'os.version']:
+ for name in ['java.vendor', 'java.version', 'os.name', 'os.arch',
+ 'os.version']:
if name in javaproperties:
- javaTable.createEntry(name, javaproperties[name])
-
- self.documentAnnotations(document,self.run)
-
-
+ javaTable.createEntry(name, javaproperties[name])
+
+ self.documentAnnotations(document, self.run)
+
+
#
# RunOptions
- #
- options=self.run.getOptions()
-
- optSection=document.createSection('Gump Run Options')
+ #
+ options = self.run.getOptions()
+
+ optSection = document.createSection('Gump Run Options')
optSection.createParagraph(
- """The options selected for this Gump run.""")
-
- #self.documentAnnotations(document,options)
-
- optTable=optSection.createTable(['Name','Value'])
- opts=0
-
- descs={ 'Build':'Perform Build',
- 'XDocs':'Generate XDOCS',
- 'Statistics':'Update Statistics (to database)',
- 'Verbose':'Verbose Run',
- 'Cache':'Cache metadata (don\'t go to remote source)',
- 'Text':'Text Output',
- 'Official':'Official Run (e.g. nag notifies, etc.)',
- 'Results':'Generate Results' }
-
+ """The options selected for this Gump run.""")
+
+ #self.documentAnnotations(document, options)
+
+ optTable = optSection.createTable(['Name', 'Value'])
+ opts = 0
+
+ descs = { 'Build':'Perform Build',
+ 'XDocs':'Generate XDOCS',
+ 'Statistics':'Update Statistics (to database)',
+ 'Verbose':'Verbose Run',
+ 'Cache':'Cache metadata (don\'t go to remote source)',
+ 'Text':'Text Output',
+ 'Official':'Official Run (e.g. nag notifies, etc.)',
+ 'Results':'Generate Results' }
+
# iterate over this suites properties
- for (name,value) in getBeanAttributes(options).items():
- desc=name
+ for (name, value) in getBeanAttributes(options).items():
+ desc = name
if descs.has_key(name):
- desc = descs[name] + ' (' + name + ')'
- optTable.createEntry(desc,value)
- opts+=1
-
- if not opts: optTable.createEntry('None')
-
+ desc = descs[name] + ' (' + name + ')'
+ optTable.createEntry(desc, value)
+ opts += 1
+
+ if not opts:
+ optTable.createEntry('None')
+
#
# Environment
#
- environment=self.run.getEnvironment()
-
- envSection=document.createSection('Gump Environment')
+ environment = self.run.getEnvironment()
+
+ envSection = document.createSection('Gump Environment')
envSection.createParagraph(
- """The environment that this Gump run was within.""")
-
- propertiesSection=envSection.createSection('Properties')
- envTable=propertiesSection.createTable(['Name/Description','Value'])
- envs=0
+ """The environment that this Gump run was within.""")
+
+ propertiesSection = envSection.createSection('Properties')
+ envTable = propertiesSection.createTable(['Name/Description', 'Value'])
+ envs = 0
# iterate over this suites properties
- for (name,value) in getBeanAttributes(environment).items():
- envTable.createEntry(name,str(value))
- envs+=1
- if not envs: envTable.createEntry('None')
-
-
- self.documentAnnotations(document,environment)
- #self.documentFileList(document,environment,'Environment-level Files')
- self.documentWorkList(document,environment,'Environment-level Work')
-
- document.serialize()
- document=None
-
- def documentXMLLinks(self, document=None, table=None, rdf=True, depth=0):
+ for (name, value) in getBeanAttributes(environment).items():
+ envTable.createEntry(name, str(value))
+ envs += 1
+ if not envs:
+ envTable.createEntry('None')
+
+ self.documentAnnotations(document, environment)
+ #self.documentFileList(document, environment, 'Environment-level Files')
+ self.documentWorkList(document, environment, 'Environment-level Work')
+
+ document.serialize()
+ document = None
+
+ def documentXMLLinks(self, document = None, table = None, rdf = True,
+ depth = 0):
"""
-
+
Show RSS|Atom|RDF.
-
+
"""
if not table:
- table=document.createTable(['XML Description','Links'])
-
- rssSyndRow=table.createRow()
+ table = document.createTable(['XML Description', 'Links'])
+
+ rssSyndRow = table.createRow()
rssSyndRow.createData().createStrong('RSS Syndication')
- rssArea=rssSyndRow.createData()
- rssArea.createFork('rss.xml','RSS')
- rssUrl=self.resolver.getUrl(self.workspace,'rss','.xml')
- rssArea.createFork('http://www.feedvalidator.org/check.cgi?url=' + rssUrl) \
- .createIcon(self.resolver.getImageUrl('valid-rss.png',depth), alt='[Valid RSS]') #, title='Validate my RSS feed', width='88', height='31')
-
- atomSyndRow=table.createRow()
+ rssArea = rssSyndRow.createData()
+ rssArea.createFork('rss.xml', 'RSS')
+ rssUrl = self.resolver.getUrl(self.workspace, 'rss', '.xml')
+ rssArea.createFork('http://www.feedvalidator.org/check.cgi?url=' + \
+ rssUrl) \
+ .createIcon(self.resolver\
+ .getImageUrl('valid-rss.png',
+ depth),
+ alt = '[Valid RSS]')
+ #, title = 'Validate my RSS feed', width = '88', height = '31')
+
+ atomSyndRow = table.createRow()
atomSyndRow.createData().createStrong('Atom Syndication')
- atomArea=atomSyndRow.createData()
- atomArea.createFork('atom.xml','Atom')
- atomUrl=self.resolver.getUrl(self.workspace,'atom','.xml')
- atomArea.createFork('http://www.feedvalidator.org/check.cgi?url=' + atomUrl) \
- .createIcon(self.resolver.getImageUrl('valid-atom.png',depth), alt='[Valid Atom]') #, title='Validate my Atom feed', width='88', height='31')
-
+ atomArea = atomSyndRow.createData()
+ atomArea.createFork('atom.xml', 'Atom')
+ atomUrl = self.resolver.getUrl(self.workspace, 'atom', '.xml')
+ atomArea.createFork('http://www.feedvalidator.org/check.cgi?url=' + \
+ atomUrl) \
+ .createIcon(self.resolver\
+ .getImageUrl('valid-atom.png',
+ depth),
+ alt = '[Valid Atom]')
+ #, title = 'Validate my Atom feed', width = '88', height = '31')
+
if rdf:
- rdfRow=table.createRow()
+ rdfRow = table.createRow()
rdfRow.createData().createStrong('RDF Metadata')
- rdfArea=rdfRow.createData()
- rdfArea.createFork('gump.actor.rdf','RDF')
-
- def documentPartial(self,node):
- notice=node.createWarning()
-
- notice.createText("""This output does not represent the complete workspace,
- but part of it.
+ rdfArea = rdfRow.createData()
+ rdfArea.createFork('gump.actor.rdf', 'RDF')
+
+ def documentPartial(self, node):
+ notice = node.createWarning()
+
+ notice.createText(
+ """This output does not represent the complete workspace,
+ but part of it.
Only projects, and their dependents, matching this regular expression """)
- notice.createStrong(self.gumpSet.projectexpression)
- notice.createBreak()
- notice.createBreak()
- notice.createStrong('Requested Projects: ')
- notice.createBreak()
- notice.createBreak()
- for project in self.gumpSet.projects:
- notice.createText(project.name)
- notice.createText(' ')
-
+ notice.createStrong(self.gumpSet.projectexpression)
+ notice.createBreak()
+ notice.createBreak()
+ notice.createStrong('Requested Projects: ')
+ notice.createBreak()
+ notice.createBreak()
+ for project in self.gumpSet.projects:
+ notice.createText(project.name)
+ notice.createText(' ')
+
def documentEverythingElse(self):
-
+
self.documentRepositories()
self.documentServers()
self.documentTrackers()
-
+
self.documentBuildLog()
self.documentNotesLog()
self.documentDiffsLog()
-
+
self.documentProjects()
self.documentModules()
-
+
self.documentPackages()
-
+
#
# Document individual repositories
#
- for repo in self.workspace.getRepositories():
- if not self.gumpSet.inRepositories(repo): continue
+ for repo in self.workspace.getRepositories():
+ if not self.gumpSet.inRepositories(repo):
+ continue
self.documentRepository(repo)
-
+
#
# Document individual servers
#
- for server in self.workspace.getServers():
+ for server in self.workspace.getServers():
self.documentServer(server)
-
+
# Document individual trackers
- for tracker in self.workspace.getTrackers():
+ for tracker in self.workspace.getTrackers():
self.documentTracker(tracker)
-
+
# Document individual modules
- for module in self.gumpSet.getCompletedModules():
+ for module in self.gumpSet.getCompletedModules():
self.documentModule(module)
-
+
# Document workspace 'Text'
- spec=self.resolver.getFileSpec(self.workspace, 'context')
- document=XDocDocument('Context',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
- stream=StringIO.StringIO()
- texter=TextDocumenter(self.run,stream)
+ spec = self.resolver.getFileSpec(self.workspace, 'context')
+ document = XDocDocument('Context',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
+ stream = StringIO.StringIO()
+ texter = TextDocumenter(self.run, stream)
texter.document()
stream.seek(0)
document.createSource(stream.read())
stream.close()
document.serialize()
-
+
if not self.workspace.private:
- # Document the workspace XML
- spec=self.resolver.getFileSpec(self.workspace, 'workspace_defn')
- document=XDocDocument('Definition',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
- stream=StringIO.StringIO()
+ # Document the workspace XML
+ spec = self.resolver.getFileSpec(self.workspace, 'workspace_defn')
+ document = XDocDocument('Definition',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
+ stream = StringIO.StringIO()
try:
- self.workspace.dom.writexml(stream,indent=' ',newl='\n')
+ self.workspace.dom.writexml(stream, indent = ' ', newl = '\n')
except Exception, details:
- stream.write('Failed to XML serialize the data. ' + str(details))
+ stream.write('Failed to XML serialize the data. ' \
+ + str(details))
stream.seek(0)
document.createSource(stream.read())
stream.close()
- document.serialize()
-
- #####################################################################
+ document.serialize()
+
+ #####################################################################
+ #
+ # Workspace
#
- # Workspace
- #
def documentWorkspace(self):
-
-
+
+
#
# ----------------------------------------------------------------------
#
# Index.xml
#
-
- spec=self.resolver.getFileSpec(self.workspace,)
- document=XDocDocument('Workspace',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
-
- definitionSection=document.createSection('Workspace Definition')
-
- definitionTable=definitionSection.createTable()
- definitionTable.createEntry('Workspace Name',
- self.workspace.getName())
+
+ spec = self.resolver.getFileSpec(self.workspace)
+ document = XDocDocument('Workspace',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
+
+ definitionSection = document.createSection('Workspace Definition')
+
+ definitionTable = definitionSection.createTable()
+ definitionTable.createEntry('Workspace Name',
+ self.workspace.getName())
if self.workspace.hasDomChild('description'):
- definitionTable.createEntry('Description',
- self.workspace.getDomChildValue('description'))
- if self.workspace.hasDomChild('version'):
- definitionTable.createEntry('Workspace Version',
+ definitionTable.createEntry('Description',
+ self.workspace\
+ .getDomChildValue('description'))
+ if self.workspace.hasDomChild('version'):
+ definitionTable.createEntry('Workspace Version',
self.workspace.getDomAttributeValue('version'))
if not self.workspace.hasDomAttribute('version') \
or not self.workspace.getDomAttributeValue('version') \
- == setting.WS_VERSION:
- definitionTable.createEntry('Gump Preferred Workspace Version',
+ == setting.WS_VERSION:
+ definitionTable.createEntry('Gump Preferred Workspace Version',
setting.WS_VERSION)
definitionTable.createEntry('@@DATE@@', default.date_s)
- definitionTable.createEntry('Start Date/Time (UTC)', self.run.getStart().getUtc())
- definitionTable.createEntry('Start Date/Time', self.run.getStart().getLocal())
- definitionTable.createEntry('Timezone', self.run.getEnvironment().getTimezone())
-
-
- rssSyndRow=definitionTable.createRow()
+ definitionTable.createEntry('Start Date/Time (UTC)',
+ self.run.getStart().getUtc())
+ definitionTable.createEntry('Start Date/Time',
+ self.run.getStart().getLocal())
+ definitionTable.createEntry('Timezone',
+ self.run.getEnvironment().getTimezone())
+
+
+ rssSyndRow = definitionTable.createRow()
rssSyndRow.createData('Syndication')
- rssSyndRow.createData().createFork('rss.xml','RSS')
- atomSyndRow=definitionTable.createRow()
+ rssSyndRow.createData().createFork('rss.xml', 'RSS')
+ atomSyndRow = definitionTable.createRow()
atomSyndRow.createData('Syndication')
- atomSyndRow.createData().createFork('atom.xml','Atom')
-
- textRow=definitionTable.createRow()
+ atomSyndRow.createData().createFork('atom.xml', 'Atom')
+
+ textRow = definitionTable.createRow()
textRow.createData('Workspace Documentation')
- textRow.createData().createLink('context.html','Text')
-
- if not self.workspace.private:
- syndRow=definitionTable.createRow()
+ textRow.createData().createLink('context.html', 'Text')
+
+ if not self.workspace.private:
+ syndRow = definitionTable.createRow()
syndRow.createData('Definition')
- syndRow.createData().createLink('workspace_defn.html','XML')
-
- self.documentAnnotations(document,self.workspace)
- #self.documentXML(document,self.workspace)
-
- detailsSection=document.createSection('Details')
-
- detailsTable=detailsSection.createTable()
- detailsTable.createEntry("State : ",
- self.workspace.getStateDescription())
+ syndRow.createData().createLink('workspace_defn.html', 'XML')
+
+ self.documentAnnotations(document, self.workspace)
+ #self.documentXML(document, self.workspace)
+
+ detailsSection = document.createSection('Details')
+
+ detailsTable = detailsSection.createTable()
+ detailsTable.createEntry("State : ",
+ self.workspace.getStateDescription())
e = self.workspace.getElapsedTimeString()
- if e : detailsTable.createEntry("Elapsed Time : ", e)
- detailsTable.createEntry("Base Directory : ", self.workspace.getBaseDirectory())
- detailsTable.createEntry("Temporary Directory : ", self.workspace.tmpdir)
+ if e:
+ detailsTable.createEntry("Elapsed Time : ", e)
+ detailsTable.createEntry("Base Directory : ",
+ self.workspace.getBaseDirectory())
+ detailsTable.createEntry("Temporary Directory : ",
+ self.workspace.tmpdir)
#if self.workspace.scratchdir:
- # detailsTable.createEntry("Scratch Directory : ", self.workspace.scratchdir))
+ # detailsTable.createEntry("Scratch Directory : ",
+ # self.workspace.scratchdir))
# :TODO: We have duplicate dirs? tmp = scratch?
- detailsTable.createEntry("Log Directory : ", self.workspace.logdir)
- detailsTable.createEntry("Outputs Repository : ", self.workspace.repodir)
+ detailsTable.createEntry("Log Directory : ",
+ self.workspace.logdir)
+ detailsTable.createEntry("Outputs Repository : ",
+ self.workspace.repodir)
detailsTable.createEntry("CVS Directory : ", self.workspace.cvsdir)
detailsTable.createEntry("Package Directory : ", self.workspace.pkgdir)
if not self.workspace.private:
- detailsTable.createEntry("E-mail Server: ", self.workspace.mailserver)
+ detailsTable.createEntry("E-mail Server: ",
+ self.workspace.mailserver)
detailsTable.createEntry("E-mail Port: ", self.workspace.mailport)
- detailsTable.createEntry("List Address: ", self.workspace.administrator)
- detailsTable.createEntry("E-mail Address: ", self.workspace.email)
+ detailsTable.createEntry("List Address: ",
+ self.workspace.administrator)
+ detailsTable.createEntry("E-mail Address: ", self.workspace.email)
detailsTable.createEntry("Prefix: ", self.workspace.prefix)
detailsTable.createEntry("Signature: ", self.workspace.signature)
-
- self.documentStats(document,self.workspace)
- self.documentProperties(detailsSection, self.workspace, 'Workspace Properties')
-
+
+ self.documentStats(document, self.workspace)
+ self.documentProperties(detailsSection, self.workspace,
+ 'Workspace Properties')
+
# Does this self.workspace send notification (nag) mails?
- detailsTable.createEntry("Send Notification E-mails: ", `self.workspace.isNotify()`)
-
- detailsTable.createEntry("Multi-threading: ", `self.workspace.isMultithreading()`)
+ detailsTable.createEntry("Send Notification E-mails: ",
+ `self.workspace.isNotify()`)
+
+ detailsTable.createEntry("Multi-threading: ",
+ `self.workspace.isMultithreading()`)
if self.workspace.isMultithreading():
- detailsTable.createEntry("Updater Threads: ", `self.workspace.getUpdaters()`)
- detailsTable.createEntry("Builder Threads: ", `self.workspace.getBuilders()`)
-
- #document.createRaw('<p><strong>Context Tree:</strong> <link href=\'workspace.html\'>workspace</link></p>')
- # x.write('<p><strong>Workspace Config:</strong> <link href=\'xml.txt\'>XML</link></p>')
- # x.write('<p><strong>RSS :</strong> <link href=\'index.rss\'>News Feed</link></p>')
-
- self.documentFileList(document,self.workspace,'Workspace-level Files')
- self.documentWorkList(document,self.workspace,'Workspace-level Work')
-
- document.serialize()
- document=None
-
-
- def documentRepositories(self):
-
+ detailsTable.createEntry("Updater Threads: ",
+ `self.workspace.getUpdaters()`)
+ detailsTable.createEntry("Builder Threads: ",
+ `self.workspace.getBuilders()`)
+
+ #document.createRaw('<p><strong>Context Tree:</strong> ' + \
+ # '<link href=\'workspace.html\'>workspace' + \
+ # '</link></p>')
+ #x.write('<p><strong>Workspace Config:</strong> ' + \
+ # '<link href=\'xml.txt\'>XML</link></p>')
+ #x.write('<p><strong>RSS :</strong> <link href=\'index.rss\'>' + \
+ # 'News Feed</link></p>')
+
+ self.documentFileList(document, self.workspace, 'Workspace-level Files')
+ self.documentWorkList(document, self.workspace, 'Workspace-level Work')
+
+ document.serialize()
+ document = None
+
+
+ def documentRepositories(self):
+
#
# ----------------------------------------------------------------------
#
# Repositories.xml
#
- spec=self.resolver.getFileSpec(self.workspace, 'repositories')
- document=XDocDocument( 'All Repositories',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
-
-
- reposSection=document.createSection('All Repositories')
- reposTable=reposSection.createTable(['Name'])
-
+ spec = self.resolver.getFileSpec(self.workspace, 'repositories')
+ document = XDocDocument('All Repositories',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
+
+
+ reposSection = document.createSection('All Repositories')
+ reposTable = reposSection.createTable(['Name'])
+
# Pretty sorting...
- sortedRepositoryList=createOrderedList(self.gumpSet.getRepositories())
-
- rcount=0
+ sortedRepositoryList = createOrderedList(self.gumpSet.getRepositories())
+
+ rcount = 0
for repo in sortedRepositoryList:
- if not self.gumpSet.inRepositories(repo): continue
-
- rcount+=1
-
- repoRow=reposTable.createRow()
+ if not self.gumpSet.inRepositories(repo):
+ continue
+
+ rcount += 1
+
+ repoRow = reposTable.createRow()
repoRow.createComment(repo.getName())
-
- self.insertLink( repo, self.workspace, repoRow.createData())
-
- if not rcount: reposTable.createLine('None')
-
- document.serialize()
- document=None
-
- def documentServers(self):
-
+
+ self.insertLink(repo, self.workspace, repoRow.createData())
+
+ if not rcount:
+ reposTable.createLine('None')
+
+ document.serialize()
+ document = None
+
+ def documentServers(self):
+
#
# ----------------------------------------------------------------------
#
# Servers.xml
#
- spec=self.resolver.getFileSpec(self.workspace, 'servers')
- document=XDocDocument( 'All Servers',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
-
- serversSection=document.createSection('All Servers')
- serversTable=serversSection.createTable(['Name','Status','Notes','Results','Start (Local)','Start (UTC)','End (UTC)','Offset (from UTC)'])
-
- sortedServerList=createOrderedList(self.workspace.getServers())
-
- scount=0
+ spec = self.resolver.getFileSpec(self.workspace, 'servers')
+ document = XDocDocument('All Servers',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
+
+ serversSection = document.createSection('All Servers')
+ serversTable = serversSection.createTable(['Name', 'Status', 'Notes',
+ 'Results', 'Start (Local)',
+ 'Start (UTC)', 'End (UTC)',
+ 'Offset (from UTC)'])
+
+ sortedServerList = createOrderedList(self.workspace.getServers())
+
+ scount = 0
for server in sortedServerList:
-
- scount+=1
-
- serverRow=serversTable.createRow()
+
+ scount += 1
+
+ serverRow = serversTable.createRow()
serverRow.createComment(server.getName())
-
- self.insertLink( server, self.workspace, serverRow.createData())
-
- if server.isUp():
+
+ self.insertLink(server, self.workspace, serverRow.createData())
+
+ if server.isUp():
serverRow.createData('Up')
else:
- serverRow.createData().createStrong('Down')
-
+ serverRow.createData().createStrong('Down')
+
if server.hasNote():
serverRow.createData(server.getNote())
else:
serverRow.createData('')
-
+
if server.hasResultsUrl():
- serverRow.createData().createFork( \
- server.getResultsUrl(), \
- 'Results')
+ serverRow.createData().createFork(server.getResultsUrl(),
+ 'Results')
else:
serverRow.createData('Not Available')
-
+
if server.hasResults():
serverRow.createData(server.getResults().getStart().getLocal())
serverRow.createData(server.getResults().getEnd().getLocal())
@@ -688,1716 +734,1913 @@
serverRow.createData('N/A')
serverRow.createData('N/A')
serverRow.createData('N/A')
-
-
- if not scount: serversTable.createLine('None')
-
+
+
+ if not scount:
+ serversTable.createLine('None')
+
document.serialize()
-
- def documentTrackers(self):
+
+ def documentTrackers(self):
#
# ----------------------------------------------------------------------
#
# Trackers.xml
#
- spec=self.resolver.getFileSpec(self.workspace, 'trackers')
- document=XDocDocument( 'All Trackers',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
-
- trackersSection=document.createSection('All Trackers')
- trackersTable=trackersSection.createTable(['Name'])
-
- sortedTrackerList=createOrderedList(self.workspace.getTrackers())
-
- scount=0
+ spec = self.resolver.getFileSpec(self.workspace, 'trackers')
+ document = XDocDocument('All Trackers',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
+
+ trackersSection = document.createSection('All Trackers')
+ trackersTable = trackersSection.createTable(['Name'])
+
+ sortedTrackerList = createOrderedList(self.workspace.getTrackers())
+
+ scount = 0
for tracker in sortedTrackerList:
-
- scount+=1
-
- trackerRow=trackersTable.createRow()
+
+ scount += 1
+
+ trackerRow = trackersTable.createRow()
trackerRow.createComment(tracker.getName())
-
- self.insertLink( tracker, self.workspace, trackerRow.createData())
-
- if not scount: trackersTable.createLine('None')
-
+
+ self.insertLink(tracker, self.workspace, trackerRow.createData())
+
+ if not scount:
+ trackersTable.createLine('None')
+
document.serialize()
-
- def documentBuildLog(self,realTime=False):
+
+ def documentBuildLog(self, realTime = False):
#
# buildLog.xml -- Modules/Projects in build order
#
- spec=self.resolver.getFileSpec(self.workspace, 'buildLog')
- document=XDocDocument('Gump Build Log',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
-
- if realTime:
-
+ spec = self.resolver.getFileSpec(self.workspace, 'buildLog')
+ document = XDocDocument('Gump Build Log',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
+
+ if realTime:
+
# Work done...
modules = len(self.gumpSet.getCompletedModules())
projects = len(self.gumpSet.getCompletedProjects())
-
- document.createWarning("""This Gump run is currently in progress.
+
+ document.createWarning(
+ """This Gump run is currently in progress.
It started at %s. As of this moment (%s), %s modules have been updated, and %s projects built.""" \
- % (self.run.getStart().getLocal(), time.strftime('%H:%M:%S'), modules, projects ))
-
- #document.createNote("""Only projects with significant information
- #(e.g a recent change of state, a failure, etc.) are listed at runtime.""")
-
+ % (self.run.getStart().getLocal(),
+ time.strftime('%H:%M:%S'), modules, projects ))
+
+# document.createNote(
+# """Only projects with significant information
+# (e.g a recent change of state, a failure, etc.) are listed at runtime.""")
+
else:
- document.createNote("""This Gump run is complete.
- It started at %s and ended at %s."""
- % ( self.run.getStart().getLocal(),
+ document.createNote("""This Gump run is complete.
+ It started at %s and ended at %s."""
+ % (self.run.getStart().getLocal(),
self.run.getEnd().getLocal()))
-
+
if not self.gumpSet.isFull():
- self.documentPartial(document)
-
- if not realTime:
- self.documentSummary(document, self.workspace.getProjectSummary())
-
- if not realTime:
+ self.documentPartial(document)
+
+ if not realTime:
+ self.documentSummary(document, self.workspace.getProjectSummary())
+
+ if not realTime:
#
# Modules...
- #
- modulesSection=document.createSection('Modules (in update order)')
- modulesTable=modulesSection.createTable(['Index','Updated','Name','State','Duration\nin state','Last Modified','Notes'])
- mcount=0
- for module in self.gumpSet.getCompletedModules():
-
- mcount+=1
-
- moduleRow=modulesTable.createRow()
- moduleRow.createComment(module.getName())
-
- self.setStyleFromState(moduleRow,module.getStatePair())
-
- moduleRow.createData(module.getPositionIndex())
-
+ #
+ modulesSection = document.createSection('Modules (in update order)')
+ modulesTable = modulesSection.createTable(['Index', 'Updated',
+ 'Name', 'State',
+ 'Duration\nin state',
+ 'Last Modified',
+ 'Notes'])
+ mcount = 0
+ for module in self.gumpSet.getCompletedModules():
+
+ mcount += 1
+
+ moduleRow = modulesTable.createRow()
+ moduleRow.createComment(module.getName())
+
+ self.setStyleFromState(moduleRow, module.getStatePair())
+
+ moduleRow.createData(module.getPositionIndex())
+
if module.hasStart():
- startData=moduleRow.createData(module.getStart().getLocal())
- else:
- startData=moduleRow.createData('-')
-
- self.setStyleFromState(startData,module.getStatePair())
-
- self.insertLink(module,self.workspace,moduleRow.createData())
- self.insertStateIcon(module,self.workspace,moduleRow.createData())
- moduleRow.createData(module.getStats().sequenceInState)
- moduleRow.createData( \
- getGeneralSinceDescription( \
+ startData = moduleRow.createData(module.getStart()\
+ .getLocal())
+ else:
+ startData = moduleRow.createData('-')
+
+ self.setStyleFromState(startData, module.getStatePair())
+
+ self.insertLink(module, self.workspace, moduleRow.createData())
+ self.insertStateIcon(module, self.workspace,
+ moduleRow.createData())
+ moduleRow.createData(module.getStats().sequenceInState)
+ moduleRow.createData(
+ getGeneralSinceDescription(
module.getStats().getLastModified()))
-
- notes=''
+
+ notes = ''
if module.isVerbose():
- if notes: notes += ' '
+ if notes:
+ notes += ' '
notes += 'Verbose'
if module.isDebug():
- if notes: notes += ' '
- notes += 'Debug'
- moduleRow.createData(notes)
-
- if not mcount: modulesTable.createLine('None')
-
+ if notes:
+ notes += ' '
+ notes += 'Debug'
+ moduleRow.createData(notes)
+
+ if not mcount:
+ modulesTable.createLine('None')
+
#
# Projects...
#
- projectsSection=document.createSection('Projects (in build order)')
- projectsTable=projectsSection.createTable(['Index','Time','Name','State','Duration\nin state','Last Modified','Notes'])
- pcount=0
+ projectsSection = document.createSection('Projects (in build order)')
+ projectsTable = projectsSection.createTable(['Index', 'Time', 'Name',
+ 'State',
+ 'Duration\nin state',
+ 'Last Modified', 'Notes'])
+ pcount = 0
for project in self.gumpSet.getCompletedProjects():
-
+
# Hack for bad data.
- if not project.inModule(): continue
-
+ if not project.inModule():
+ continue
+
#if realTime and \
- # (project.getState()==STATE_FAILED or \
- # ((project.getState()<>STATE_PREREQ_FAILED) and \
- # (project.getStats().sequenceInState < INSIGNIFICANT_DURATION))):
+ # (project.getState()==STATE_FAILED or \
+ # ((project.getState()<>STATE_PREREQ_FAILED) and \
+ # (project.getStats().sequenceInState \
+ # < INSIGNIFICANT_DURATION))):
# continue
-
- pcount+=1
-
- projectRow=projectsTable.createRow()
- projectRow.createComment(project.getName())
-
- self.setStyleFromState(projectRow,project.getStatePair())
-
- projectRow.createData(project.getPositionIndex())
-
+
+ pcount += 1
+
+ projectRow = projectsTable.createRow()
+ projectRow.createComment(project.getName())
+
+ self.setStyleFromState(projectRow, project.getStatePair())
+
+ projectRow.createData(project.getPositionIndex())
+
if project.hasStart():
- projectRow.createData(project.getStart().getLocal())
+ projectRow.createData(project.getStart().getLocal())
else:
- projectRow.createData('-')
-
- self.insertLink(project,self.workspace,projectRow.createData())
- self.insertStateIcon(project,self.workspace,projectRow.createData())
- projectRow.createData(project.getStats().sequenceInState)
- projectRow.createData( \
- getGeneralSinceDescription( \
+ projectRow.createData('-')
+
+ self.insertLink(project, self.workspace, projectRow.createData())
+ self.insertStateIcon(project, self.workspace,
+ projectRow.createData())
+ projectRow.createData(project.getStats().sequenceInState)
+ projectRow.createData(getGeneralSinceDescription(
project.getModule().getStats().getLastModified()))
-
- notes=''
+
+ notes = ''
if project.isVerbose():
- if notes: notes += ' '
+ if notes:
+ notes += ' '
notes += 'Verbose'
if project.isDebug():
- if notes: notes += ' '
- notes += 'Debug'
- projectRow.createData(notes)
-
- if not pcount: projectsTable.createLine('None')
-
- document.serialize()
- document=None
-
- def documentNotesLog(self):
+ if notes:
+ notes += ' '
+ notes += 'Debug'
+ projectRow.createData(notes)
+
+ if not pcount:
+ projectsTable.createLine('None')
+
+ document.serialize()
+ document = None
+
+ def documentNotesLog(self):
#
# ----------------------------------------------------------------------
#
# notesLog.xml -- Notes log
#
- spec=self.resolver.getFileSpec(self.workspace, 'notesLog')
- document=XDocDocument('Annotations',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
-
- notesSection=document.createSection('Negative Annotations')
+ spec = self.resolver.getFileSpec(self.workspace, 'notesLog')
+ document = XDocDocument('Annotations',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
+
+ notesSection = document.createSection('Negative Annotations')
notesSection.createParagraph(
"""This page displays entities with errors and/or warning annotations.""")
-
- ncount=0
- for module in self.gumpSet.getCompletedModules():
-
- moduleSection=None
-
- if module.containsNasties():
- moduleSection=document.createSection('Module : ' + module.getName())
+
+ ncount = 0
+ for module in self.gumpSet.getCompletedModules():
+
+ moduleSection = None
+
+ if module.containsNasties():
+ moduleSection = document.createSection('Module : ' \
+ + module.getName())
# Link to the module
- self.insertLink(module,self.workspace,moduleSection.createParagraph())
-
+ self.insertLink(module, self.workspace,
+ moduleSection.createParagraph())
+
# Display the module annotations
- self.documentAnnotations(moduleSection,module,1)
-
+ self.documentAnnotations(moduleSection, module, 1)
+
for project in module.getProjects():
- if not self.gumpSet.inProjectSequence(project): continue
- if not project.containsNasties(): continue
-
- if not moduleSection:
- moduleSection=document.createSection('Module : ' + module.getName())
+ if not self.gumpSet.inProjectSequence(project):
+ continue
+ if not project.containsNasties():
+ continue
+
+ if not moduleSection:
+ moduleSection = document.createSection('Module : ' + \
+ module.getName())
+
+ projectSection = moduleSection.createSection('Project : ' + \
+ project\
+ .getName())
- projectSection=moduleSection.createSection('Project : ' + project.getName())
-
# Link to the project
- self.insertLink(project,self.workspace,projectSection.createParagraph())
-
+ self.insertLink(project, self.workspace,
+ projectSection.createParagraph())
+
# Display the annotations
- self.documentAnnotations(projectSection,project,1)
-
- ncount+=1
-
- if not ncount: notesSection.createParagraph('None.')
-
- document.serialize()
-
- def documentDiffsLog(self):
-
+ self.documentAnnotations(projectSection, project, 1)
+
+ ncount += 1
+
+ if not ncount:
+ notesSection.createParagraph('None.')
+
+ document.serialize()
+
+ def documentDiffsLog(self):
+
#
# ----------------------------------------------------------------------
#
# diffsLog.xml -- Server Differences log
#
- spec=self.resolver.getFileSpec(self.workspace, 'diffsLog')
- document=XDocDocument('Server Differences',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
-
- diffsSection=document.createSection('Server Differences')
- diffsSection.createParagraph(
+ spec = self.resolver.getFileSpec(self.workspace, 'diffsLog')
+ document = XDocDocument('Server Differences',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
+
+ diffsSection = document.createSection('Server Differences')
+ diffsSection.createParagraph(\
"""This page displays entities with different states on different servers.""")
-
- dcount=0
- for module in self.gumpSet.getCompletedModules():
-
- moduleSection=None
+
+ dcount = 0
+ for module in self.gumpSet.getCompletedModules():
+
+ moduleSection = None
if module.hasServerResults() \
- and module.getServerResults().hasDifferences() \
+ and module.getServerResults().hasDifferences() \
and module.getServerResults().containsFailure() :
- moduleSection=document.createSection('Module : ' + module.getName())
+ moduleSection = document.createSection('Module : ' + \
+ module.getName())
# Link to the module
- self.insertLink(module,self.workspace,moduleSection.createParagraph())
-
+ self.insertLink(module, self.workspace,
+ moduleSection.createParagraph())
+
# Display the module server links
- self.documentServerLinks(moduleSection,module,getDepthForObject(self.workspace))
-
+ self.documentServerLinks(moduleSection, module,
+ getDepthForObject(self.workspace))
+
for project in module.getProjects():
- if not self.gumpSet.inProjectSequence(project): continue
- if not project.hasServerResults(): continue
- if not project.getServerResults().hasDifferences(): continue
- if not project.getServerResults().containsFailure(): continue
-
- if not moduleSection:
- moduleSection=document.createSection('Module : ' + module.getName())
+ if not self.gumpSet.inProjectSequence(project) \
+ or not project.hasServerResults() \
+ or not project.getServerResults().hasDifferences() \
+ or not project.getServerResults().containsFailure():
+ continue
+
+ if not moduleSection:
+ moduleSection = document.createSection('Module : ' + \
+ module.getName())
+
+ projectSection = moduleSection.createSection('Project : ' + \
+ project\
+ .getName())
- projectSection=moduleSection.createSection('Project : ' + project.getName())
-
# Link to the project
- self.insertLink(project,self.workspace,projectSection.createParagraph())
-
+ self.insertLink(project, self.workspace,
+ projectSection.createParagraph())
+
# Display the project server links
- self.documentServerLinks(projectSection,project,getDepthForObject(self.workspace))
-
- dcount+=1
-
- if not dcount: diffsSection.createParagraph('None.')
-
- document.serialize()
-
- def documentProjects(self):
-
- sortedProjectList=createOrderedList(self.gumpSet.getProjectSequence())
-
+ self.documentServerLinks(projectSection, project,
+ getDepthForObject(self.workspace))
+
+ dcount += 1
+
+ if not dcount:
+ diffsSection.createParagraph('None.')
+
+ document.serialize()
+
+ def documentProjects(self):
+
+ sortedProjectList = createOrderedList(self.gumpSet.getProjectSequence())
+
#
# ----------------------------------------------------------------------
#
# project_todos.xml -- Projects w/ issues in build order
#
- spec=self.resolver.getFileSpec(self.workspace, 'project_todos')
- document=XDocDocument('Projects with issues',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
+ spec = self.resolver.getFileSpec(self.workspace, 'project_todos')
+ document = XDocDocument('Projects with issues',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
self.documentSummary(document, self.workspace.getProjectSummary())
-
- totalAffected=0
-
- projectsSection=document.createSection('Projects with issues...')
- projectsSection.createParagraph("""These are the project that need 'fixing'.
-This page helps Gumpmeisters (and others) locate the main areas to focus attention.""")
- projectsTable=projectsSection.createTable(['Name',
- 'Dependees','Affected',
- 'Project State','Duration\nin state'])
- pcount=0
-
- depOrder=createOrderedList(sortedProjectList,compareProjectsByFullDependeeCount)
-
+
+ totalAffected = 0
+
+ projectsSection = document.createSection('Projects with issues...')
+ projectsSection.createParagraph(\
+ """These are the project that need 'fixing'.
+This page helps Gumpmeisters (and others) locate the main areas to focus attention.""")
+ projectsTable = projectsSection.createTable(['Name',
+ 'Dependees', 'Affected',
+ 'Project State',
+ 'Duration\nin state'])
+ pcount = 0
+
+ depOrder = createOrderedList(sortedProjectList,
+ compareProjectsByFullDependeeCount)
+
for project in depOrder:
# Hack for bad data
- if not project.inModule(): continue
-
- if not self.gumpSet.inProjectSequence(project): continue
-
- if not project.getState()==STATE_FAILED:
- continue
-
- pcount+=1
-
- #
+ if not project.inModule():
+ continue
+
+ if not self.gumpSet.inProjectSequence(project):
+ continue
+
+ if not project.getState() == STATE_FAILED:
+ continue
+
+ pcount += 1
+
+ #
# Determine the number of projects this module (or its projects)
# cause not to be run.
#
- affected=project.countAffectedProjects()
-
+ affected = project.countAffectedProjects()
+
totalAffected += affected
-
-
- projectRow=projectsTable.createRow()
+
+
+ projectRow = projectsTable.createRow()
projectRow.createComment(project.getName())
-
- self.insertLink(project,self.workspace,projectRow.createData())
-
- projectRow.createData( project.getFullDependeeCount())
+
+ self.insertLink(project, self.workspace, projectRow.createData())
+
+ projectRow.createData(project.getFullDependeeCount())
projectRow.createData(affected)
-
- self.insertStateIcon(project,self.workspace,projectRow.createData())
-
+
+ self.insertStateIcon(project, self.workspace,
+ projectRow.createData())
+
# How long been like this
- seq=stats=project.getStats().sequenceInState
+ seq = project.getStats().sequenceInState
projectRow.createData(seq)
-
- if not pcount:
- projectsTable.createLine('None')
+
+ if not pcount:
+ projectsTable.createLine('None')
else:
projectsSection.createParagraph(
'Total Affected Projects: ' + str(totalAffected))
-
+
document.serialize()
-
+
#
# ----------------------------------------------------------------------
#
# project_fixes.xml -- Projects w/ fixes in build order
#
- spec=self.resolver.getFileSpec(self.workspace, 'project_fixes')
- document=XDocDocument('Project Fixes',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
+ spec = self.resolver.getFileSpec(self.workspace, 'project_fixes')
+ document = XDocDocument('Project Fixes',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
self.documentSummary(document, self.workspace.getProjectSummary())
-
- projectsSection=document.createSection('Projects recently fixed...')
- projectsSection.createParagraph("""These are the projects that were 'fixed' (state changed to success from failed) within %s runs.
+
+ projectsSection = document.createSection('Projects recently fixed...')
+ projectsSection.createParagraph(\
+ """These are the projects that were 'fixed' (state changed to success from failed) within %s runs.
This page helps Gumpmeisters (and others) observe community progress.
- """ % INSIGNIFICANT_DURATION)
-
- projectsTable=projectsSection.createTable(['Name', \
- 'Dependees','Project State','Duration\nin state'])
- pcount=0
+ """ % INSIGNIFICANT_DURATION)
+
+ projectsTable = projectsSection.createTable(['Name', 'Dependees',
+ 'Project State',
+ 'Duration\nin state'])
+ pcount = 0
for project in sortedProjectList:
# Hack for bad data
- if not project.inModule(): continue
+ if not project.inModule():
+ continue
# Filter
- if not self.gumpSet.inProjectSequence(project): continue
-
- if not project.getState()==STATE_SUCCESS or \
- not project.getStats().previousState==STATE_FAILED or \
+ if not self.gumpSet.inProjectSequence(project):
+ continue
+
+ if not project.getState() == STATE_SUCCESS or \
+ not project.getStats().previousState == STATE_FAILED or \
not project.getStats().sequenceInState < INSIGNIFICANT_DURATION:
continue
-
- pcount+=1
-
- projectRow=projectsTable.createRow()
+
+ pcount += 1
+
+ projectRow = projectsTable.createRow()
projectRow.createComment(project.getName())
-
- self.insertLink(project,self.workspace,projectRow.createData())
-
- projectRow.createData( project.getFullDependeeCount())
-
- self.insertStateIcon(project,self.workspace,projectRow.createData())
-
+
+ self.insertLink(project, self.workspace, projectRow.createData())
+
+ projectRow.createData(project.getFullDependeeCount())
+
+ self.insertStateIcon(project, self.workspace,
+ projectRow.createData())
+
# How long been like this
- seq=stats=project.getStats().sequenceInState
+ seq = project.getStats().sequenceInState
projectRow.createData(seq)
-
- if not pcount:
- projectsTable.createLine('None')
-
+
+ if not pcount:
+ projectsTable.createLine('None')
+
document.serialize()
-
+
#
# ----------------------------------------------------------------------
#
# project_prereqs.xml -- Projects w/ prereqs in build order
#
- spec=self.resolver.getFileSpec(self.workspace, 'project_prereqs')
- document=XDocDocument('Project Prerequisite Failures',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
+ spec = self.resolver.getFileSpec(self.workspace, 'project_prereqs')
+ document = XDocDocument('Project Prerequisite Failures',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
self.documentSummary(document, self.workspace.getProjectSummary())
-
- projectsSection=document.createSection('Projects recently fixed...')
- projectsSection.createParagraph("""These are the projects that depend upon others being fixed before they can be built.""")
-
- projectsTable=projectsSection.createTable(['Name', \
- 'Depends','Not-Built Depends','Project State','Duration\nin state'])
- pcount=0
+
+ projectsSection = document.createSection('Projects recently fixed...')
+ projectsSection.createParagraph(\
+ """These are the projects that depend upon others being fixed before they can be built.""")
+
+ projectsTable = projectsSection.createTable(['Name', 'Depends',
+ 'Not-Built Depends',
+ 'Project State',
+ 'Duration\nin state'])
+ pcount = 0
for project in sortedProjectList:
# Hack for bad data
- if not project.inModule(): continue
- # Filter
- if not self.gumpSet.inProjectSequence(project): continue
-
- if not project.getState()==STATE_PREREQ_FAILED:
- continue
-
- pcount+=1
-
- projectRow=projectsTable.createRow()
+ if not project.inModule():
+ continue
+ # Filter
+ if not self.gumpSet.inProjectSequence(project):
+ continue
+
+ if not project.getState() == STATE_PREREQ_FAILED:
+ continue
+
+ pcount += 1
+
+ projectRow = projectsTable.createRow()
projectRow.createComment(project.getName())
-
- self.insertLink(project,self.workspace,projectRow.createData())
-
+
+ self.insertLink(project, self.workspace, projectRow.createData())
+
projectRow.createData(project.getFullDependencyCount())
-
+
# Count unbuilt dependencies
- unbuilt=0
+ unbuilt = 0
for dep in project.getFullDependencyProjectList():
if not dep.isSuccess():
- unbuilt+=1
+ unbuilt += 1
projectRow.createData(unbuilt)
-
- self.insertStateIcon(project,self.workspace,projectRow.createData())
-
+
+ self.insertStateIcon(project, self.workspace,
+ projectRow.createData())
+
# How long been like this
- seq=stats=project.getStats().sequenceInState
+ seq = project.getStats().sequenceInState
projectRow.createData(seq)
-
- if not pcount:
- projectsTable.createLine('None')
-
- document.serialize()
-
- def documentModules(self):
-
+
+ if not pcount:
+ projectsTable.createLine('None')
+
+ document.serialize()
+
+ def documentModules(self):
+
#
# ----------------------------------------------------------------------
#
# module_todos.xml
#
- spec=self.resolver.getFileSpec(self.workspace, 'module_todos')
- document=XDocDocument('Modules with issues',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
-
- modulesSection=document.createSection('Modules with TODOs')
- modulesSection.createParagraph("""These are the modules that need 'fixing', or contained projects that need fixing.
-This page helps Gumpmeisters (and others) locate the main areas to focus attention.""")
- modulesTable=modulesSection.createTable(['Name','Duration\nin state','Module State', \
- 'Project State(s)','Elapsed'])
-
- mcount=0
- for module in self.gumpSet.getCompletedModules():
-
+ spec = self.resolver.getFileSpec(self.workspace, 'module_todos')
+ document = XDocDocument('Modules with issues',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
+
+ modulesSection = document.createSection('Modules with TODOs')
+ modulesSection.createParagraph(\
+ """These are the modules that need 'fixing', or contained projects that need fixing.
+This page helps Gumpmeisters (and others) locate the main areas to focus attention.""")
+ modulesTable = modulesSection.createTable(['Name', 'Duration\nin state',
+ 'Module State',
+ 'Project State(s)',
+ 'Elapsed'])
+
+ mcount = 0
+ for module in self.gumpSet.getCompletedModules():
+
#
# Determine if there are todos, otherwise continue
#
- todos=0
+ todos = 0
for pair in module.aggregateStates():
- if pair.state==STATE_FAILED:
- todos=1
- if not todos: continue
+ if pair.state == STATE_FAILED:
+ todos = 1
+ if not todos:
+ continue
# Shown something...
- mcount+=1
-
+ mcount += 1
+
# Determine longest sequence in this (failed) state...
# for any of the projects
- seq=0
+ seq = 0
for project in module.getProjects():
- if project.getState()==STATE_FAILED:
- stats=project.getStats()
- if stats.sequenceInState > seq: seq = stats.sequenceInState
-
+ if project.getState() == STATE_FAILED:
+ stats = project.getStats()
+ if stats.sequenceInState > seq:
+ seq = stats.sequenceInState
+
# Determine the number of projects this module (or its projects)
# cause not to be run.
-
+
# Display
- moduleRow=modulesTable.createRow()
- moduleRow.createComment(module.getName())
- self.insertLink(module,self.workspace,moduleRow.createData())
-
+ moduleRow = modulesTable.createRow()
+ moduleRow.createComment(module.getName())
+ self.insertLink(module, self.workspace, moduleRow.createData())
+
moduleRow.createData(seq)
-
- self.insertStateIcon(module,self.workspace,moduleRow.createData())
- self.insertStateIcons(module,self.workspace,moduleRow.createData())
-
- moduleRow.createData(secsToElapsedTimeString(module.getElapsedSecs()))
-
- if not mcount: modulesTable.createLine('None')
-
+
+ self.insertStateIcon(module, self.workspace, moduleRow.createData())
+ self.insertStateIcons(module, self.workspace,
+ moduleRow.createData())
+
+ moduleRow.createData(secsToElapsedTimeString(module\
+ .getElapsedSecs()))
+
+ if not mcount:
+ modulesTable.createLine('None')
+
document.serialize()
-
-
+
+
#
# ----------------------------------------------------------------------
#
# module_fixes.xml
#
- spec=self.resolver.getFileSpec(self.workspace, 'module_fixes')
- document=XDocDocument('Modules with fixes',
- spec.getFile() ,
- self.config,
- spec.getRootPath())
-
- modulesSection=document.createSection('Modules recently fixed')
- modulesSection.createParagraph("""These are the modules that were 'fixed' (state changed to success), or contained projects that were fixed, within %s runs.
+ spec = self.resolver.getFileSpec(self.workspace, 'module_fixes')
+ document = XDocDocument('Modules with fixes',
+ spec.getFile(),
+ self.config,
+ spec.getRootPath())
+
+ modulesSection = document.createSection('Modules recently fixed')
+ modulesSection.createParagraph(\
+ """These are the modules that were 'fixed' (state changed to success), or contained projects that were fixed, within %s runs.
This page helps Gumpmeisters (and others) observe community progress.
- """ % INSIGNIFICANT_DURATION)
-
- modulesTable=modulesSection.createTable(['Name','Duration\nin state','Module State', \
- 'Project State(s)','Elapsed'])
-
- mcount=0
- for module in self.gumpSet.getCompletedModules():
-
+ """ % INSIGNIFICANT_DURATION)
+
+ modulesTable = modulesSection.createTable(['Name', 'Duration\nin state',
+ 'Module State',
+ 'Project State(s)',
+ 'Elapsed'])
+
+ mcount = 0
+ for module in self.gumpSet.getCompletedModules():
+
#
# Determine if there are mcount, otherwise continue
#
- mcount=0
+ mcount = 0
for pair in module.aggregateStates():
if pair.state == STATE_SUCCESS \
- and module.getStats().sequenceInState < INSIGNIFICANT_DURATION:
- mcount=1
-
- if not mcount: continue
-
+ and module.getStats().sequenceInState < \
+ INSIGNIFICANT_DURATION:
+ mcount = 1
+
+ if not mcount:
+ continue
+
# Shown something...
- mcount+=1
-
+ mcount += 1
+
[... 4246 lines stripped ...]