def test_load_fields(self): """compdesc.load populates id, name, etc. fields""" os.system(''' cat >a.xml <<EOF <?xml version="1.0"?> <component> <id>resolveme</id> <name>Resolve Me</name> <description> I need to be resolved </description> <requires>a</requires> <requires>b</requires> <provides>c</provides> <provides>d</provides> </component> EOF ''') desc = ComponentDescriptor('a.xml') component = desc.load(None) self.assert_equals('resolveme', component.id) self.assert_equals('Resolve Me', component.name) self.assert_equals('\n I need to be resolved\n ', component.description) self.assert_equals(['a', 'b'], component.requires) self.assert_equals(['c', 'd'], component.provides)
def test_load_sub_component_meta(self): """Be sure metadata gets loaded from subcomponents even if the toplevel component has none. """ open('test1.xml', 'w').write('''<?xml version="1.0"?> <component> <contents> <component>test2.xml</component> </contents> </component> ''') open('test2.xml', 'w').write('''<?xml version="1.0"?> <component> <contents> <deb ref="sha-1:aaa"> <meta> <necessity>mandatory</necessity> </meta> </deb> </contents> </component> ''') cache = ShamCache() package = MockPackage('a', '1', deb, 'sha-1:aaa') cache.add(package) desc = ComponentDescriptor('test1.xml') comp = desc.load(cache) assert package in list(comp.iter_packages()) self.assert_equal("mandatory", package[('pdk', 'necessity')])
def test_write_relation(self): os.system(''' cat >a.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <deb> <version>2.0.53</version> <version-lt>2.0.53</version-lt> <version-lt-eq>2.0.53</version-lt-eq> <version-gt>2.0.53</version-gt> <version-gt-eq>2.0.53</version-gt-eq> </deb> <dsc> <version>2.0.53</version> <version-lt>2.0.53</version-lt> </dsc> <rpm> <version>2.0.53-0</version> <version-lt>2.0.53-0</version-lt> </rpm> <srpm> <version>2.0.53-0</version> <version-lt>2.0.53-0</version-lt> </srpm> </contents> </component> EOF cp a.xml b.xml ''') desc = ComponentDescriptor('a.xml') desc.write() self.assert_equals_long(open('b.xml').read(), open('a.xml').read())
def test_load_and_write_cond(self): """compdesc.load returns a component with packages""" os.system(''' cat >a.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <deb> <cond><![CDATA[ apache (>>2) ]]></cond> <deb ref="sha-1:aaa"> <cond>apache</cond> </deb> </deb> </contents> </component> EOF cp a.xml b.xml ''') desc = ComponentDescriptor('a.xml') desc.write() self.assert_equals_long(open('b.xml').read(), open('a.xml').read()) condition = desc.contents[0].reference.condition a = MockPackage('apache', '2-1', deb, 'sha-1:aaa') b = MockPackage('apache', '1.3', deb, 'sha-1:bbb') assert condition.evaluate(a) assert not condition.evaluate(b)
def test_self_reference(self): os.system(''' cat >a.xml <<EOF <component/> ''') desc = ComponentDescriptor('a.xml') ref = desc.get_self_reference() self.assert_equal('a.xml', ref.filename) self.assert_equal(rules.tc, ref.condition.__class__)
def test_load_empty(self): """compdesc.load returns an empty component""" os.system(''' cat >a.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component/> EOF ''') desc = ComponentDescriptor('a.xml') descriptor = desc.load(None) assert isinstance(descriptor, Component)
def test_build_bare_name_rule(self): '''rules like <deb>name</deb> should have name conditions. No metadata should be present. ''' builder = ComponentDescriptor(None) name_element = XML('<deb>some-name</deb>') ref = builder.build_package_ref(name_element) assert not ref.reference.blob_id self.assert_equal('deb', ref.reference.package_type.type_string) self.assert_rule_matches([('pdk', 'name', 'some-name'), ('pdk', 'type', 'deb')], [], [], ref.rule)
def test_load_and_use_star_cond(self): """compdesc.load returns a component with packages""" os.system(''' cat >a.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <dsc> <name>apache</name> <dsc ref="sha-1:ccc"> <name>apache</name> </dsc> <deb ref="sha-1:aaa"> <name>apache</name> </deb> <deb ref="sha-1:bbb"> <name>apache-common</name> </deb> </dsc> <dsc> <cond><![CDATA[ * apache (>=2) ]]></cond> </dsc> <src> <cond><![CDATA[ * apache (>=2) ]]></cond> </src> <bin> <cond><![CDATA[ * apache-common (>=2) ]]></cond> </bin> </contents> </component> EOF cp a.xml b.xml ''') desc = ComponentDescriptor('a.xml') desc.write() self.assert_equals_long(open('b.xml').read(), open('a.xml').read()) condition = desc.contents[1].rule.condition a = MockPackage('apache', '2', deb, 'sha-1:aaa') b = MockPackage('apache-commmon', '2', deb, 'sha-1:bbb') c = MockPackage('apache', '2', dsc, 'sha-1:ccc') a.complement = [c] b.complement = [c] c.complement = [a, b] assert condition.evaluate(a) assert condition.evaluate(b) assert not condition.evaluate(c) src_condition = desc.contents[2].rule.condition assert src_condition.evaluate(a) assert src_condition.evaluate(b) assert not src_condition.evaluate(c)
def test_empty_meta_element(self): open('test.xml', 'w').write('''<?xml version="1.0"?> <component> <meta/> </component> ''') desc = ComponentDescriptor('test.xml') desc.write() expected = '''<?xml version="1.0" encoding="utf-8"?> <component> </component> ''' self.assert_equals_long(expected, open('test.xml').read())
def test_meta_implicit_ref(self): """Check that implicit references in metadata are supported and correctly resolve to references to self. """ open('test.xml', 'w').write('''<?xml version="1.0"?> <component> <meta> <necessity>mandatory</necessity> </meta> </component> ''') desc = ComponentDescriptor('test.xml') comp = desc.load(Cache(os.path.join(self.work_dir, 'cache'))) self.assert_equal('mandatory', comp.meta[('pdk', 'necessity')])
def test_dont_mutate_meta(self): """Make sure the load method does not mutate the meta info in the descriptor. """ open('test.xml', 'w').write('''<?xml version="1.0"?> <component> <meta> <predicate>object</predicate> </meta> <contents> <dsc> <name>a</name> <meta> <c>d</c> </meta> </dsc> <deb ref="sha-1:aaa"> <meta> <necessity>mandatory</necessity> </meta> </deb> </contents> </component> ''') desc = ComponentDescriptor('test.xml') cache = ShamCache() cache.add(MockPackage('a', '1', deb, 'sha-1:aaa')) desc.load(cache) desc.write() expected = '''<?xml version="1.0" encoding="utf-8"?> <component> <meta> <predicate>object</predicate> </meta> <contents> <dsc> <name>a</name> <meta> <c>d</c> </meta> </dsc> <deb ref="sha-1:aaa"> <meta> <necessity>mandatory</necessity> </meta> </deb> </contents> </component> ''' self.assert_equals_long(expected, open('test.xml').read())
def test_conditional_include(self): os.system(''' cat >b.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <deb ref="sha-1:aaa"> <name>apache</name> </deb> <deb ref="sha-1:bbb"> <name>libc6</name> </deb> <deb ref="sha-1:ccc"> <name>ls</name> </deb> </contents> </component> EOF ''') os.system(''' cat >a.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <component> <file>b.xml</file> <limit>apache</limit> <exclude>ls</exclude> </component> </contents> </component> EOF cp a.xml c.xml ''') apache = MockPackage('apache', '1', deb, 'sha-1:aaa', arch='i386') libc = MockPackage('libc6', '1', deb, 'sha-1:bbb', arch='i386') ls = MockPackage('ls', '1', deb, 'sha-1:ccc', arch='i386') cache = ShamCache() cache.add(apache) cache.add(libc) cache.add(ls) desc_a = ComponentDescriptor('a.xml') desc_a.write() self.assert_equals_long(open('c.xml').read(), open('a.xml').read()) component_a = desc_a.load(cache) assert isinstance(component_a, Component) expected = [apache] actual = list(component_a.iter_packages()) self.assert_equal(expected, actual)
def test_bad_comp_ref(self): os.system(''' cat >a.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <component> <limit><![CDATA[ apache ]]></limit> </component> </contents> </component> EOF ''') try: ComponentDescriptor('a.xml').load(ShamCache()) self.fail('should have thrown exception') except InputError: pass os.system(''' cat >a.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <component> <zzz></zzz> <limit><![CDATA[ apache ]]></limit> </component> </contents> </component> EOF ''') try: ComponentDescriptor('a.xml').load(ShamCache()) self.fail('should have thrown exception') except InputError, error: assert '"zzz"' in str(error)
def test_load_component_meta(self): """compdesc.load finds component metadata""" os.system(''' cat >a.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <meta> <necessity>optional</necessity> </meta> </component> EOF ''') desc = ComponentDescriptor('a.xml') component = desc.load(None) self.assert_equals(component.meta['pdk', 'necessity'], 'optional')
def test_is_package_ref(self): builder = ComponentDescriptor(None) deb_rule = Element('deb') udeb_rule = Element('udeb') dsc_rule = Element('dsc') rpm_rule = Element('rpm') srpm_rule = Element('srpm') component_rule = Element('component') assert builder.is_package_ref(deb_rule) assert builder.is_package_ref(udeb_rule) assert builder.is_package_ref(dsc_rule) assert builder.is_package_ref(rpm_rule) assert builder.is_package_ref(srpm_rule) assert not builder.is_package_ref(component_rule)
def test_build_ref(self): builder = ComponentDescriptor(None) element = XML(''' <deb> <name>hello</name> <meta> <ice>cube</ice> </meta> </deb> ''') ref = builder.build_package_ref(element) assert not ref.reference.blob_id self.assert_equal('deb', ref.reference.package_type.type_string) self.assert_rule_matches([('pdk', 'name', 'hello'), ('pdk', 'type', 'deb')], [('pdk', 'ice', 'cube')], [], ref.rule)
def test_occupied_meta_element(self): open('test.xml', 'w').write('''<?xml version="1.0"?> <component> <meta> <key>value</key> </meta> <contents> <deb ref="sha-1:aaa"> <meta> <other-key>other-value</other-key> <link> <vuln>22</vuln> </link> <unlink> <vuln>20</vuln> </unlink> </meta> </deb> </contents> </component> ''') desc = ComponentDescriptor('test.xml') desc.write() expected = '''<?xml version="1.0" encoding="utf-8"?> <component> <meta> <key>value</key> </meta> <contents> <deb ref="sha-1:aaa"> <meta> <other-key>other-value</other-key> <link> <vuln>22</vuln> </link> <unlink> <vuln>20</vuln> </unlink> </meta> </deb> </contents> </component> ''' self.assert_equals_long(expected, open('test.xml').read())
def test_iter_package_refs(self): class MockRef(PackageStanza): def __init__(self, label): condition = rules.ac([('pdk', 'name', 'apache')]) PackageStanza.__init__(self, deb, None, condition, []) self.label = label self.children = [] def __repr__(self): return str(self.label) desc = ComponentDescriptor(None) a = MockRef('a') b = MockRef('b') c = MockRef('c') a.children = [b] desc.contents = [a, c] self.assert_equal([a, c], list(desc.iter_package_refs())) self.assert_equal([a, b, c], list(desc.iter_full_package_refs()))
def test_complement(self): """compdesc.load returns a component with packages""" os.system(''' cat >a.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <deb> <deb ref="sha-1:aaa"/> <deb ref="sha-1:bbb"/> <dsc ref="sha-1:ccc"/> </deb> <dsc> <dsc ref="sha-1:ccc"/> <deb ref="sha-1:aaa"/> <deb ref="sha-1:bbb"/> <deb ref="sha-1:ddd"/> </dsc> </contents> </component> EOF ''') desc = ComponentDescriptor('a.xml') cache = ShamCache(make_copies=True) a = MockPackage('a', '1', deb, 'sha-1:aaa', arch='i386') b = MockPackage('b', '1', deb, 'sha-1:bbb', arch='i386') c = MockPackage('c', '1', dsc, 'sha-1:ccc', arch='any') d = MockPackage('b', '1', deb, 'sha-1:ddd', arch='i386') cache.add(a) cache.add(b) cache.add(c) cache.add(d) component = desc.load(cache) packages = list(component.iter_packages()) self.assert_equal([c], packages[0].complement) self.assert_equal([c], packages[1].complement) self.assert_equal([a, b], packages[2].complement) self.assert_equal([a, b, d], packages[3].complement) self.assert_equal([c], packages[4].complement) self.assert_equal([c], packages[5].complement) self.assert_equal([c], packages[6].complement)
def test_load_file_object(self): """compdesc.load returns a component with packages""" handle = stringio('''<?xml version="1.0" encoding="utf-8"?> <component> <contents> <deb ref="sha-1:aaa"/> </contents> </component> ''') desc = ComponentDescriptor('a.xml', handle) cache = ShamCache() cache.add(MockPackage('a', '1', deb, 'sha-1:aaa')) component = desc.load(cache) assert isinstance(component, Component) self.assert_equal('a.xml', desc.filename) self.assert_equal(1, len(list(component.iter_packages()))) self.assert_equal(1, len(list(component.iter_direct_packages()))) self.assert_equal(['sha-1:aaa'], [p.blob_id for p in component.iter_packages()]) self.assert_equal(0, len(list(component.iter_direct_components()))) self.assert_equal(0, len(list(component.iter_components())))
def test_parse_entity(self): '''Check that we can parse entities at all.''' open('test.xml', 'w').write('''<?xml version="1.0"?> <component> <entities> <some-ent id="can-do"> <a.name>hello</a.name> <b.description>whodo whodo whodo</b.description> </some-ent> </entities> </component> ''') desc = ComponentDescriptor('test.xml') entity1 = desc.entities[('some-ent', 'can-do')] self.assert_equal('hello', entity1[('a', 'name')]) self.assert_equal('whodo whodo whodo', entity1[('b', 'description')]) cache = ShamCache() comp = desc.load(cache) entity2 = comp.entities[('some-ent', 'can-do')] self.assert_equal('hello', entity2[('a', 'name')]) self.assert_equal('whodo whodo whodo', entity2[('b', 'description')])
def test_read_write_and_or(self): os.system(''' cat >a.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <deb> <or> <and> <name>a</name> <arch>b</arch> </and> <name>c</name> </or> <my.some>value</my.some> </deb> </contents> </component> EOF cp a.xml b.xml ''') desc = ComponentDescriptor('a.xml') deb_ref = desc.contents[0] expected = rules.ac([ rules.oc([ rules.ac([ rules.rc(eq, 'pdk', 'name', 'a'), rules.rc(eq, 'pdk', 'arch', 'b') ]), rules.rc(eq, 'pdk', 'name', 'c') ]), rules.rc(eq, 'my', 'some', 'value') ]) expected = PhantomConditionWrapper(expected, deb, None) self.assert_equals_long(expected, deb_ref.reference.condition) desc.write() self.assert_equals_long(open('b.xml').read(), open('a.xml').read())
def test_load(self): """compdesc.load returns a component with packages""" os.system(''' cat >a.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <deb ref="sha-1:aaa"/> </contents> </component> EOF ''') desc = ComponentDescriptor('a.xml') cache = ShamCache() cache.add(MockPackage('a', '1', deb, 'sha-1:aaa')) component = desc.load(cache) assert isinstance(component, Component) self.assert_equal(1, len(list(component.iter_packages()))) self.assert_equal(1, len(list(component.iter_direct_packages()))) self.assert_equal(['sha-1:aaa'], [p.blob_id for p in component.iter_packages()]) self.assert_equal(0, len(list(component.iter_direct_components()))) self.assert_equal(0, len(list(component.iter_components())))
def test_parse_link(self): '''Check that we can parse entities at all.''' open('test.xml', 'w').write('''<?xml version="1.0"?> <component> <contents> <deb ref="sha-1:aaa"> <meta> <pdk.link> <some-meta>can-do</some-meta> </pdk.link> </meta> </deb> </contents> </component> ''') desc = ComponentDescriptor('test.xml') self.assert_equal([('some-meta', 'can-do')], desc.contents[0].links) cache = ShamCache() package = MockPackage('a', '1', deb, 'sha-1:aaa') cache.add(package) comp = desc.load(cache) package = comp.iter_packages().next() self.assert_equals([('some-meta', 'can-do')], package.links)
def test_read_relation_condition(self): os.system(''' cat >a.xml <<EOF <component> <contents> <deb> <version>2.0.53</version> <version-lt>2.0.53</version-lt> <version-lt-eq>2.0.53</version-lt-eq> <version-gt>2.0.53</version-gt> <version-gt-eq>2.0.53</version-gt-eq> </deb> <dsc> <version>2.0.53</version> <version-lt>2.0.53</version-lt> </dsc> <rpm> <version>2.0.53</version> <version-lt>2.0.53</version-lt> </rpm> <srpm> <version>2.0.53</version> <version-lt>2.0.53</version-lt> </srpm> </contents> </component> EOF ''') desc = ComponentDescriptor('a.xml') deb_conditions = desc.contents[0].reference.condition.conditions dv = DebianVersion self.assert_equal(rules.rc(eq, 'pdk', 'version', dv('2.0.53')), deb_conditions[0]) assert isinstance(deb_conditions[0].target, DebianVersion) self.assert_equal(rules.rc(lt, 'pdk', 'version', dv('2.0.53')), deb_conditions[1]) assert isinstance(deb_conditions[1].target, DebianVersion) self.assert_equal(rules.rc(le, 'pdk', 'version', dv('2.0.53')), deb_conditions[2]) assert isinstance(deb_conditions[2].target, DebianVersion) self.assert_equal(rules.rc(gt, 'pdk', 'version', dv('2.0.53')), deb_conditions[3]) assert isinstance(deb_conditions[3].target, DebianVersion) self.assert_equal(rules.rc(ge, 'pdk', 'version', dv('2.0.53')), deb_conditions[4]) assert isinstance(deb_conditions[4].target, DebianVersion) dsc_conditions = desc.contents[1].reference.condition.conditions self.assert_equal(rules.rc(eq, 'pdk', 'version', dv('2.0.53')), dsc_conditions[0]) assert isinstance(dsc_conditions[0].target, DebianVersion) self.assert_equal(rules.rc(lt, 'pdk', 'version', dv('2.0.53')), dsc_conditions[1]) assert isinstance(dsc_conditions[1].target, DebianVersion) def rv(version): return RPMVersion(version_string=version) rpm_conditions = desc.contents[2].reference.condition.conditions self.assert_equal(rules.rc(eq, 'pdk', 'version', rv('2.0.53')), rpm_conditions[0]) assert isinstance(rpm_conditions[0].target, RPMVersion) self.assert_equal(rules.rc(lt, 'pdk', 'version', rv('2.0.53')), rpm_conditions[1]) assert isinstance(rpm_conditions[1].target, RPMVersion) srpm_conditions = desc.contents[3].reference.condition.conditions self.assert_equal(rules.rc(eq, 'pdk', 'version', rv('2.0.53')), srpm_conditions[0]) assert isinstance(srpm_conditions[0].target, RPMVersion) self.assert_equal(rules.rc(lt, 'pdk', 'version', rv('2.0.53')), srpm_conditions[1]) assert isinstance(srpm_conditions[1].target, RPMVersion)
def test_load_multilevel(self): """test loading a component that refers to another""" os.system(''' cat >a.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <deb> <name>libc6</name> <meta> <necessity>mandatory</necessity> </meta> </deb> <deb> <name>apache</name> <meta> <necessity>default</necessity> </meta> </deb> <component>b.xml</component> </contents> </component> EOF ''') os.system(''' cat >b.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <deb> <name>libc6</name> <meta> <necessity>optional</necessity> </meta> </deb> <deb ref="sha-1:aaa"> <name>apache</name> <meta> <necessity>optional</necessity> </meta> </deb> <component>c.xml</component> </contents> </component> EOF ''') os.system(''' cat >c.xml <<EOF <?xml version="1.0" encoding="utf-8"?> <component> <contents> <deb ref="sha-1:bbb"> <name>libc6</name> <meta> <necessity>mandatory</necessity> <some-random-key>42</some-random-key> </meta> </deb> </contents> </component> EOF ''') apache = MockPackage('apache', '1', deb, 'sha-1:aaa') libc = MockPackage('libc6', '1', deb, 'sha-1:bbb') cache = ShamCache() cache.add(apache) cache.add(libc) desc_b = ComponentDescriptor('b.xml') component_b = desc_b.load(cache) assert isinstance(component_b, Component) self.assert_equal('b.xml', desc_b.filename) self.assert_equal('b.xml', component_b.ref) self.assert_equal(2, len(list(component_b.iter_packages()))) self.assert_equal(['sha-1:aaa', 'sha-1:bbb'], [p.blob_id for p in component_b.iter_packages()]) self.assert_equal(1, len(list(component_b.iter_direct_packages()))) self.assert_equal(1, len(list(component_b.iter_direct_components()))) self.assert_equal(1, len(list(component_b.iter_components()))) self.assert_equal('optional', libc['pdk', 'necessity']) self.assert_equal('optional', apache['pdk', 'necessity']) apache = MockPackage('apache', '1', deb, 'sha-1:aaa') libc = MockPackage('libc6', '1', deb, 'sha-1:bbb') cache = ShamCache() cache.add(apache) cache.add(libc) desc_a = ComponentDescriptor('a.xml') component_a = desc_a.load(cache) assert isinstance(component_a, Component) self.assert_equal(2, len(list(component_a.iter_packages()))) self.assert_equal(['sha-1:aaa', 'sha-1:bbb'], [p.blob_id for p in component_a.iter_packages()]) self.assert_equal(0, len(list(component_a.iter_direct_packages()))) self.assert_equal(1, len(list(component_a.iter_direct_components()))) self.assert_equal(2, len(list(component_a.iter_components()))) self.assert_equal('mandatory', libc['pdk', 'necessity']) self.assert_equal('default', apache['pdk', 'necessity']) self.assert_equal('42', libc['pdk', 'some-random-key'])
def test_dont_lose_entities(self): """Make sure the write method handles entities.""" open('test.xml', 'w').write('''<?xml version="1.0"?> <component> <meta> <predicate>object</predicate> </meta> <contents> <dsc> <name>a</name> <meta> <c>d</c> </meta> </dsc> <deb ref="sha-1:aaa"> <meta> <necessity>mandatory</necessity> </meta> </deb> </contents> <entities> <test id="1"> <a>b</a> <c>d</c> <e>f</e> </test> </entities> </component> ''') desc = ComponentDescriptor('test.xml') cache = ShamCache() cache.add(MockPackage('a', '1', deb, 'sha-1:aaa')) desc.load(cache) desc.write() expected = '''<?xml version="1.0" encoding="utf-8"?> <component> <meta> <predicate>object</predicate> </meta> <contents> <dsc> <name>a</name> <meta> <c>d</c> </meta> </dsc> <deb ref="sha-1:aaa"> <meta> <necessity>mandatory</necessity> </meta> </deb> </contents> <entities> <test id="1"> <a>b</a> <c>d</c> <e>f</e> </test> </entities> </component> ''' self.assert_equals_long(expected, open('test.xml').read())
def audit(args): """\\fB%prog\\fP .PP Load the component, and verify that it and it's parts are well-formed. """ ##specialization code starts here def note_problem(fact, prediction, prediction_basis, evidence, evidence_basis): """A mismatch handler for Arbiter Handle the case of a prediction that doesn't pan out by reporting the mismatch to stdout, in a format suitable for: cut -d'|' """ note_problem.called = True fields = fact.get_problem_description(prediction, prediction_basis, evidence, evidence_basis) result = string_together(fields, '|') print result note_problem.called = False my_cache = workspace.current_workspace().cache arbiter = Arbiter(note_problem) for component_name in args.args: def _note_blob_id(blob_id): """Make common predictions and warrants for blob_id. Predict that a blob_id will be in cache Warrant the blob_id will be needed by the component. """ arbiter.predict(InCache(blob_id), True, component_name) # Get the set of packages in the component descriptor = ComponentDescriptor(component_name) component = descriptor.load(my_cache) # predict expected blob_ids and headers for package in component.iter_packages(): _note_blob_id(package.blob_id) arbiter.predict(InCache(package.blob_id + '.header'), True, component_name) for package_tuple in package.extra_files: blob_id = package_tuple[0] _note_blob_id(blob_id) # predict upcoming source packages for package in component.iter_packages(): if package.role == 'binary': fact = HasSource(package.format, package.pdk.sp_name, package.pdk.sp_version.full_version) arbiter.predict(fact, True, component_name) # warrant source packages found for package in component.iter_packages(): if package.role == 'source': fact = HasSource(package.format, package.name, package.version.full_version) arbiter.warrant(fact, True, component_name) # predict upcoming cache checksums # pre-warrant found inodes # note inode -> filename relationships for later found_by_inode = {} for blob_id in my_cache: inode = my_cache.get_inode(blob_id) if blob_id.endswith('.header'): arbiter.warrant(InCache(blob_id), True, 'cache') continue entry = found_by_inode.setdefault(inode, Set([])) entry.add(blob_id) # ? Won't this create repeated predictions? for blob_id in found_by_inode[inode]: arbiter.predict(ChecksumMatches(blob_id), blob_id, 'cache') for inode, blob_ids in found_by_inode.iteritems(): for blob_id in blob_ids: arbiter.warrant(InCache(blob_id), True, 'cache') # warrant cache checksums one_id = tuple(blob_ids)[0] handle = open(my_cache.file_path(one_id)) sha1_digest = sha.new() md5_digest = md5.new() read_size = 8196 while 1: block = handle.read(read_size) if not block: break sha1_digest.update(block) md5_digest.update(block) handle.close() prefixes = [] for blob_id in blob_ids: if blob_id.startswith('sha-1'): prefixes.append('sha-1') arbiter.warrant(ChecksumMatches(blob_id), 'sha-1:' + sha1_digest.hexdigest(), 'cache') elif blob_id.startswith('md5'): prefixes.append('md5') arbiter.warrant(ChecksumMatches(blob_id), 'md5:' + md5_digest.hexdigest(), 'cache') else: # note unknown prefixes arbiter.note_problem(blob_id, ('md5:', 'sha-1:'), 'unknown prefix') prefixes.sort() if prefixes != ['md5', 'sha-1']: digests = (md5_digest.hexdigest(), sha1_digest.hexdigest()) arbiter.note_problem(tuple(blob_ids), digests, 'not hard linked properly') arbiter.note_leftovers() if note_problem.called: raise IntegrityFault, "Audit detected fault(s)"