def __validateModules(self):
self.__validatePrerequisites(self._STAGE_validateModules)
for mr in self.__moduleRecords:
ns = mr.namespace()
for base_uid in mr.dependsOnExternal():
xmr = ns.lookupModuleRecordByUID(base_uid)
if xmr is None:
raise pyxb.NamespaceArchiveError(
'Module %s depends on external module %s, not available in archive path'
% (mr.generationUID(), base_uid))
if not xmr.isIncorporated():
_log.info('Need to incorporate data from %s', xmr)
else:
_log.info('Have required base data %s', xmr)
for origin in mr.origins():
for (cat, names) in six.iteritems(origin.categoryMembers()):
if not (cat in ns.categories()):
continue
cross_objects = names.intersection(
six.iterkeys(ns.categoryMap(cat)))
if 0 < len(cross_objects):
raise pyxb.NamespaceArchiveError(
'Archive %s namespace %s module %s origin %s archive/active conflict on category %s: %s'
% (self.__archivePath, ns, mr, origin, cat,
" ".join(cross_objects)))
_log.info('%s no conflicts on %d names', cat, len(names))
def _readToStage(self, stage):
if self.__stage is None:
raise pyxb.NamespaceArchiveError(
'Attempt to read from invalid archive %s' % (self, ))
try:
while self.__stage < stage:
if self.__stage < self._STAGE_uid:
self.__unpickler = self.__createUnpickler()
self.__stage = self._STAGE_uid
continue
if self.__stage < self._STAGE_readModules:
assert self.__unpickler is not None
self.__readModules(self.__unpickler)
self.__stage = self._STAGE_readModules
continue
if self.__stage < self._STAGE_validateModules:
self.__validateModules()
self.__stage = self._STAGE_validateModules
continue
if self.__stage < self._STAGE_readComponents:
assert self.__unpickler is not None
self.__stage = self._STAGE_readComponents
self.__readComponentSet(self.__unpickler)
self.__unpickler = None
continue
raise pyxb.LogicError('Too many stages (at %s, want %s)' %
(self.__stage, stage))
except:
self.__stage = None
self.__unpickler = None
raise
def __readModules(self, unpickler):
mrs = unpickler.load()
assert isinstance(
mrs, set), 'Expected set got %s from %s' % (type(mrs),
self.archivePath())
if self.__moduleRecords is None:
for mr in mrs.copy():
mr2 = mr.namespace().lookupModuleRecordByUID(
mr.generationUID())
if mr2 is not None:
mr2._setFromOther(mr, self)
mrs.remove(mr)
self.__moduleRecords = set()
assert 0 == len(self.__namespaces)
for mr in mrs:
mr._setArchive(self)
ns = mr.namespace()
ns.addModuleRecord(mr)
self.__namespaces.add(ns)
self.__moduleRecords.add(mr)
else:
# Verify the archive still has what was in it when we created this.
for mr in mrs:
mr2 = mr.namespace().lookupModuleRecordByUID(
mr.generationUID())
if not (mr2 in self.__moduleRecords):
raise pyxb.NamespaceArchiveError(
'Lost module record %s %s from %s' %
(mr.namespace(), mr.generationUID(),
self.archivePath()))
def __validatePrerequisites (self, stage):
from pyxb.namespace import builtin
prereq_uids = self._unsatisfiedModulePrerequisites()
for uid in prereq_uids:
if builtin.BuiltInObjectUID == uid:
continue
depends_on = self.__NamespaceArchives.get(uid)
if depends_on is None:
raise pyxb.NamespaceArchiveError('%s: archive depends on unavailable archive %s' % (self.archivePath(), uid))
depends_on._readToStage(stage)
def __createUnpickler (self):
unpickler = pickle.Unpickler(open(self.__archivePath, 'rb'))
fmt = unpickler.load()
if self.__PickleFormat != fmt:
raise pyxb.NamespaceArchiveError('Archive format is %s, require %s' % (fmt, self.__PickleFormat))
self.__generationUID = unpickler.load()
return unpickler
def __validatePrerequisites(self, stage):
import builtin
prereq_uids = self._unsatisfiedModulePrerequisites()
#print '%s depends on %d prerequisites' % (self, len(prereq_uids))
for uid in prereq_uids:
if builtin.BuiltInObjectUID == uid:
continue
depends_on = self.__NamespaceArchives.get(uid)
if depends_on is None:
raise pyxb.NamespaceArchiveError(
'%s: archive depends on unavailable archive %s' %
(self.archivePath(), uid))
#print '%s stage %s depends on %s at %s going to %s' % (self, self._stage(), depends_on, depends_on._stage(), stage)
depends_on._readToStage(stage)
def add(self, namespace):
"""Add the given namespace to the set that is to be stored in this archive."""
if namespace.isAbsentNamespace():
raise pyxb.NamespaceArchiveError('Cannot archive absent namespace')
self.__namespaces.add(namespace)
