Using jhove2 for policy assessment of files
This presentation is the property of its rightful owner.
Sponsored Links
1 / 83

Using JHOVE2 for Policy Assessment of Files PowerPoint PPT Presentation


  • 47 Views
  • Uploaded on
  • Presentation posted in: General

Using JHOVE2 for Policy Assessment of Files. Richard Anderson Code4LibCon Preconference 2/7/2011 http://code4lib.org/conference/2011/schedule#preconf 13:30-16:30 : Persimmon Room. Agenda 13:30-16:30. What is JHOVE2 ? Characterization of digital objects Validation vs Assessment

Download Presentation

Using JHOVE2 for Policy Assessment of Files

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Using jhove2 for policy assessment of files

Using JHOVE2 for Policy Assessment of Files

Richard Anderson

Code4LibCon Preconference

2/7/2011

http://code4lib.org/conference/2011/schedule#preconf

13:30-16:30 : Persimmon Room


Agenda 13 30 16 30

Agenda 13:30-16:30

What is JHOVE2 ?

Characterization of digital objects

Validation vs Assessment

Examples of JHOVE2 output

Source Units, Modules, Reportable Properties

Implementation of Assessment

Configuration of Assessment Rules


Jhove2 is

JHOVE2 is …

… a project to develop a next-generation open source framework and application for format-aware characterization

… a collaborative undertaking of the California Digital Library (CDL), Portico, and Stanford University

… a two year grant from the Library of Congress as part of its National Digital Information Infrastructure Preservation Program (NDIIPP)


What so what

“What? So what?”

Determining the presumptive format of a digital object based on suggestive extrinsic hints and intrinsic signatures

Reporting the intrinsic properties of an object significant for classification, analysis, and planning

Characterization is the automated determination of the intrinsic and extrinsic properties of a formatted object

  • Identification

  • Feature extraction

  • Validation

  • Assessment


What s new in jhove2

What's new in JHOVE2?

Je ne sais quoi !

Processing of multi-file objects as well as embedded objects inside files

Recursive processing of containers objects

Plug-in Format Modules

Buffered I/O

Internationalized output

Clean APIs and modern design patterns


Api design idioms

API design idioms

Separation of concerns

Annotation and Reflection

confluence.ucop.edu/display/JHOVE2Info/Background+Papers

Inversion of Control (IOC) / Dependency Injection

Martin Fowler

martinfowler.com/articles/injection.html

Spring Framework

www.springsource.org/


Project home

Project Home

Domain name

  • http://jhove2.org/

    Code Repository

  • https://bitbucket.org/jhove2/main/wiki/Home

    • Public Wiki/Documentation

    • Browse/Clone Source Code

    • Download Release Packages

    • Changeset History

    • Issue Tracking

      Mailing lists

  • [email protected]

  • [email protected]


Jhove2 documentation

JHOVE2 Documentation

Complete documentation

  • User’s guide

  • Architectural overview

  • Module specifications

  • Programmer’s guide


Agenda 13 30 16 301

Agenda 13:30-16:30

What is JHOVE2 ?

Characterization of digital objects

Validation vs Assessment

Examples of JHOVE2 output

Source Units, Modules, Reportable Properties

Implementation of Assessment

Configuration of Assessment Rules


Using jhove2 for policy assessment of files

Characterization


Validation vs assessment

Validation vs. Assessment

Validation is the determination of the level of conformance to the normative requirements of a format’s authoritative specification

  • To the extent that there is community consensus on these requirements, validation is an objective determination – Hard coded in JHOVE2 Modules

    Assessment is the determination of the level of acceptability for a specific purpose on the basis of locally-defined policy rules

  • Since these rules are locally configurable, assessment is a subjective determination – Scripted via config files


Format specifications

Format Specifications


Validation vs assessment1

Validation vs. Assessment

Validation is the determination of the level of conformance to the normative requirements of a format’s authoritative specification

  • To the extent that there is community consensus on these requirements, validation is an objective determination – Hard coded in JHOVE2 Modules

    Assessment is the determination of the level of acceptability for a specific purpose on the basis of locally-defined policy rules

  • Since these rules are locally configurable, assessment is a subjective determination – Scripted via config files


Putting it another way

Putting it another way …

Assessment is the evaluation of

a source unit'sreportable properties

against a set of

policy-based rules


Using jhove2 for policy assessment of files

Assessment is the evaluation ofa source unit's

File  (UTF-8)

File with embedded ByteStream(s) (TIFF with ICC profile)

Aggregate (Directory, ZIP )

ClumpSource (ShapeFile)

reportable properties

against a set of

policy-based rules


Using jhove2 for policy assessment of files

Assessment is the evaluation ofa source unit's reportable properties

Format Identification

Features

Validity

against a set of

policy-based rules


Using jhove2 for policy assessment of files

Assessment is the evaluation ofa source unit's

reportable properties

against a set of

policy-based rules

Is the item acceptable?

Is there a preservation risk?

What level of preservation service?

Should we flag object for future action?


Practical applications of assessment

Practical Applications of Assessment

Ingest workflows

Migration workflows

Digitization workflows

Publishing workflows


Agenda 13 30 16 302

Agenda 13:30-16:30

What is JHOVE2 ?

Characterization of digital objects

Validation vs Assessment

Examples of JHOVE2 output

Source Units, Modules, Reportable Properties

Implementation of Assessment

Configuration of Assessment Rules


Running jhove

Running JHOVE

jhove2.sh –d Text –o outfile.txt myfile.xml

Display format choices are: Text (default), JSON, and XML.

File argument can be any of:

  • Filename

  • Directory name

  • URL

  • Set of space-delimited filepaths

    http://bitbucket.org/jhove2/main/wiki/documents/JHOVE2-Users-Guide.pdf


Jhove2 output options

JHOVE2 Output options

  • Input File

    • xml-schemaLocation-cannot-resolve.xml

  • Text

    • text-output.txt

  • XML

    • xml-output.xml

  • JSON

    • json-output.txt


Jhove2 output

JHOVE2 Output

FileSource:

Path: E:\samples\xml\schema-sample.xml

Size (byte): 9516

LastModified: 2010-10-12T11:55:29-06:00

SourceName: schema-sample.xml

StartingOffset (byte): 0


Format identification

Format Identification

PresumptiveFormats:

PresumptiveFormat {FormatIdentification}:

NativeIdentifier {I8R}:

Namespace: PUID

Value: fmt/101  PRONOM Identifier

JHOVE2Identifier {I8R}:

Namespace: JHOVE2

Value: http://jhove2.org/terms/format/xml

...


Pronom format registry

PRONOM Format Registry

http://www.nationalarchives.gov.uk/PRONOM/Format/proFormatSearch.aspx?status=detailReport&id=638

NameExtensible Markup Language

Version1.0

Other namesXML (1.0)

IdentifiersPUID: fmt/101

Apple Uniform Type Identifier: public.xml

MIME: text/xml

ClassificationText (Mark-up)

DescriptionThe Extensible Markup Language (XML) is a general purpose markup language for creating other, special purpose, markup languages, and is a simplified subset of SGML. …


Agent used for identification

Agent used for Identification

Module {DROIDIdentifier}:

SignatureFile: …/DROID_SignatureFile_V20.xml

Version: 2.0.0

ReleaseDate: 2010-09-10

WrappedProduct:

Name: DROID

Version: 4.0.0

ReleaseDate: 2009-07-23

...


Droid

DROID

http://sourceforge.net/projects/droid/

DROID (Digital Record Object Identification) is an automatic file format identification tool. It is the first in a planned series of tools developed by The National Archives under the umbrella of its PRONOM technical registry service


Xml module

XML Module

Module {XmlModule}:

SaxParser:

Parser: org.apache.xerces.parsers.SAXParser

XmlDeclaration:

Version:1.0

Encoding: UTF-8

Standalone: no

RootElement:

Name: mets

Namespace: http://www.loc.gov/METS/


Xml module namespaces

XML Module (namespaces)

NamespaceInformation:

NamespaceCount: 2

Namespaces:

Namespace:

URI: http://www.loc.gov/METS/

Declarations:

Prefix: [default]

SchemaLocations:

SchemaLocation:

Location: http://www.loc.gov/standards/mets/version15/mets.xsd

Namespace:

URI: http://www.loc.gov/mix/v10

Declarations:

Prefix: mix


Xml module cont

XML Module (cont)

ValidationResults:

ParserWarnings {ValidationMessageList}:

ValidationMessageCount: 0

ParserErrors {ValidationMessageList}:

ValidationMessageCount: 0

FatalParserErrors {ValidationMessageList}:

ValidationMessageCount: 0

isWellFormed: true

isValid: true


Format modules from jhove2 team

ICC color profile

JPEG 2000

PDF

SGML

Shapefile

TIFF

UTF-8

WAVE

XML

Zip

Format Modules from JHOVE2 Team

JHOVE2 can identify (by DROID) many more formats than it can validate (by modules)


Other module development

Other Module Development

3rd party development activities

  • NetCDF and GRIB modules (Wegener Institute)

  • Integration with DuraCloud (DuraSpace)

  • ARC module (Bibliothèque nationale de France)

  • WARC, JPEG, GIF modules (CDL, hopefully ;-)

    Possible development efforts

  • Additional format modules

  • Configuration GUIs

  • JHOVE2-as-a-service

  • Integration with DAITTS, DSpace, Fedora, FITS, etc.

    Suggestions, volunteers and funders welcome


Assessmentmodule

AssessmentModule

Module {AssessmentModule}:

AssessmentResultSets:

AssessmentResultSet:

RuleSetName: XmlRuleSet

RuleSetDescription: RuleSet for Xml Module

ObjectFilter: org.jhove2.module.format.xml.XmlModule

BooleanResult: true

AssessmentResults:

AssessmentResult:

RuleName: XmlValidityRule

RuleDescription: Is the XML file acceptable?

BooleanResult: true

NarrativeResult: Acceptable


Agenda 13 30 16 303

Agenda 13:30-16:30

What is JHOVE2 ?

Characterization of digital objects

Validation vs Assessment

Examples of JHOVE2 output

Source Units, Modules, Reportable Properties

Implementation of Assessment

Configuration of Assessment Rules


Jhove2 abstractions

JHOVE2 Abstractions

  • Source Unit

  • Module

  • Reportable

  • Reportable Property

  • Message


Source unit

Source Unit

A formatted object about which characterization information can be meaningfully reported

  • Unitary

    • Filee.g. UTF-8 text file

    • File inside of a containere.g. TIFF inside a Zip

    • Byte stream inside a filee.g. ICC inside a TIFF

  • Aggregate

    • Directory

    • Directory inside of a container

    • Clumpe.g. Shapefile

    • File sete.g. command line arguments

      For purposes of characterization, directories, file sets, and clumps are considered format types


Source interface java

Source Interface (Java)

public Set<FormatIdentification> getPresumptiveFormats() {

return presumptiveFormatIdentifications;

}

public List<Module> getModules() {

return this.modules;

}

public List<Source> getChildSources() {

return this.children;

}


Format module

Format Module

  • implements Parser

  • implements Validator

  • Implements Reportable

  • Imports org.jhove2.annotation.ReportableProperty

    public long parse(JHOVE2 jhove2, Source source, Input input) {

    // extract features and

    //fill in the reportable properties fields

    . . .

    }


Reportables

Reportables

A Reportable is a named set of properties

Reportables correspond to Java classes

Including classes for sources and modules

Also define reportables for the major conceptual structures inherent to a format

JPEG 2000: Box

TIFF:IFH, IFD, IFD entry (“tag”)

UTF-8:Character stream, character

WAVE:Chunk


Reportable interface

Reportable Interface

package org.jhove2.core

public interface Reportable {

public I8R getReportableIdentifier();

public String getReportableName();

public void setReportableName(String name);

}

public abstract class AbstractReportable

implements Reportable

{

protected I8R reportableIdentifier;

protected String reportableName;

}

A reportable class implements the Reportable marker interface


Reportableproperties

ReportableProperties

A ReportableProperty is a named, typed value

  • org.jhove2.annotation.ReportableProperty

  • Unique formal identifier

  • Data type

    • Scalar or collection

    • Java types, JHOVE2 primitive types, or JHOVE2 reportables

  • Typed value

  • Description of correct semantic interpretation

  • Properties correspond to fields


Reportableproperty annotation

ReportableProperty Annotation

Each reportable property is represented by a field and accessor and mutator methods

The accessor method must be marked with the @ReportableProperty annotation

public class MyReportable

implements Reportable

{

protected String myProperty;

@ReportableProperty(order=1, desc=“description”, ref=“reference”)

public String getMyProperty() {

return this.myProperty;

}

public void setMyProperty(String property) {

this.myProperty = property;

}

}


Wave reportable properties

Wave Reportable Properties

chunks[ ]  

formatChunkNotBeforeDataChunkMessage

missingRequiredFormatChunkMessage

missingRequiredDataChunkMessage

missingRequiredFactChunkMessage

isValid

childChunks[ ]

hasPadByte

identifier

isValid

size


Utf 8 reportable properties

UTF-8 Reportable Properties

byteOrderMark

c0Characters

c1Characters

codeBlocks

eOLMarkers

invalidCharacters[ ]   

isValid

numCharacters

numLines

numNonCharacters

c0Control

c1Control

codeBlock

codePoint

codePointOutOfRange

coverage

invalidByteValues

isByteOrderMark

isC0Control

isC1Control

isNonCharacter

isValid

size


Using jhove2 for policy assessment of files

XML Reportable Properties


Fields for the reportable properties

Fields for the reportable properties

protected StringsaxParser = "org.apache.xerces.parsers.SAXParser";

protected XmlDeclarationxmlDeclaration = new XmlDeclaration();

protected StringxmlRootElementName;

protected List<XmlDTD>xmlDTDs;

protected HashMap<String,XmlNamespace>xmlNamespaceMap;

protected List<XmlNotation>xmlNotations;

protected List<String>xmlCharacterReferences;

protected List<XmlEntity>xmlEntitys;

protected List<XmlProcessingInstruction>xmlProcessingInstructions;

protected List<String>xmlComments;

protected XmlValidationResultsxmlValidationResults ;

protected booleanwellFormed ;


Getter methods for reportable properties

Getter methods for reportable properties

import org.jhove2.annotation.ReportableProperty;

@ReportableProperty(order = 1, value = "Java class used to parse the XML")

public String getSaxParser() {

return saxParser;

}

@ReportableProperty(order = 2, value = "XML Declaration data")

public XmlDeclaration getXmlDeclaration() {

return xmlDeclaration;

}

@ReportableProperty(order = 3, value = "Name of the document's root element")

public String getXmlRootElementName() {

return xmlRootElementName;

}


Messages

Messages

if (position == start && ch.isByteOrderMark()) {

Object [] messageParms= new Object [] {position};

this.bomMessage = new Message(

Severity.INFO,

Context.OBJECT,

"org.jhove2.module.format.utf8.UTF8Module.bomMessage",

messageParms);

}


Messages1

Messages

Messages are reportable properties

Unique identifier

info:jhove2/message/…

Context

ProcessCondition arising from the process of characterization

ObjectCondition arising in the object being characterized

Severity

Error

Warning

Info

Internationalizable


Agenda 13 30 16 304

Agenda 13:30-16:30

What is JHOVE2 ?

Characterization of digital objects

Validation vs Assessment

Examples of JHOVE2 output

Source Units, Modules, Reportable Properties

Implementation of Assessment

Configuration of Assessment Rules

http://code4lib.org/conference/2011/schedule#preconf


Assessment rules

Assessment rules

Assertions (logical expressions) based on

Presence/absence of a property

Constraints on property values

Combinations of properties/values


Predicate logic

Predicate Logic

  • Rules use a construct whose basic structure looks like this:

    If

    (condition)

    Then

    (consequent)

    Else

    (alternative)

    http://en.wikipedia.org/wiki/Conditional_(programming)


Condition

Condition

A condition is defined by a universal or existential qualifier

“for all”

 “for any”

¬“not any”

and an arbitrary set of predicates

  • {ALL_OFF | ANY_OF | NONE_OF}

    • (predicate)

    • (predicate)

    • ...

  • http://www.csm.ornl.gov/~sheldon/ds/sec1.6.html


  • Predicate

    Predicate

    Each predicate is a string containing a boolean expression

    xmlDeclaration.standalone == 'yes'

    These assertions take the form:

    propertyrelationvalue

    Supported relational operators include:

    • == !=<>=<=>

    • contains

    • exists ( != null)


    Xml assessment rule

    XML Assessment rule

    • If ANY_OF

    • validity == true ;

    • (validity == undetermined) and

    • (wellFormed == true)

    • Then

    • Acceptable

    • Else

    • Not acceptable

    • End If


    Jpeg 2000 assessment rule

    JPEG 2000 Assessment Rule

    • If ALL_OF

    • validity == true;

    • exists(colourBox);

    • exists(resolutionBox.capture)

    • Then

    • Acceptable

    • Else

    • Not acceptable

    • End If


    Wave assessment rule

    Wave Assessment rule

    • If ALL_OF

    • validity == true ;

    • exists(broadcastWaveExtensionChunk) ;

    • waveFormatChunk.nSamplesPerSec == 96000 ;

    • waveFormatChunk.nBitsPerSample == 24

    • Then

    • Acceptable

    • Else

    • Not acceptable

    • End If


    Tiff assessment rule

    TIFF Assessment rule

    • If ANY_OF

    • validity == true ;

    • ((ifd.messages contains

    • ‘offsetNotByteAligned’) or

    • (ifd.messages contains

    • ‘dateNotWellFormed’))

    • Then

    • Acceptable

    • Else

    • Not acceptable

    • End If


    Rules engines

    Rules Engines

    • JSR 94: JavaTM Rule Engine API
http://jcp.org/en/jsr/detail?id=94

    • Rule Engines Overview
http://jadex-rules.informatik.uni-hamburg.de/xwiki/bin/view/Resources/Rule+Engines

    • Top 10 Java Business Rule Engines
http://blog.taragana.com/index.php/archive/top-10-java-business-rule-engines/

    • Introduction to Drools
http://www.intltechventures.com/presentations/2008-01-26-Introduction-to-Drools.pdf


    Expression languages

    Expression Languages

    Predicates (conditions) are evaluated using an domain-specific language that supports scripted examination of Java objects

    MVEL (MVFLEX Expression Language)http://mvel.codehaus.org/

    OGNL (Object-Graph Navigation Language)

    http://www.opensymphony.com/ognl

    Groovyhttp://groovy.codehaus.org/

    Open Source Expression Languages in Javahttp://java-source.net/open-source/expression-languages

    http://www.java-opensource.com/open-source/expression-languages.html


    Assessment module at work

    Assessment Module at work

    publicvoid assess(JHOVE2 jhove2, Source source)

    throws JHOVE2Exception {

    /* Assess the source unit. */

    this.configInfo = jhove2.getConfigInfo();

    List<Module> modules = source.getModules();

    for (Module module : modules) {

    assessObject(module);

    this.getModuleAccessor().persistModule(this);

    }

    assessObject(source);

    this.getModuleAccessor().persistModule(this);

    }


    Assessobject method

    AssessObject Method

    privatevoid assessObject(Object assessedObject)

    throws JHOVE2Exception {

    String objectFilter = assessedObject.getClass().getName();

    List<RuleSet> ruleSetList = getRuleSetFactory()

    .getRuleSetList(objectFilter);

    if (ruleSetList != null) {

    for (RuleSet ruleSet : ruleSetList) {

    if (ruleSet.isEnabled()) {

    AssessmentResultSet resultSet =

    new AssessmentResultSet();

    assessmentResultSets.add(resultSet);

    resultSet.setRuleSet(ruleSet);

    resultSet.fireAllRules(assessedObject);

    }

    }

    }


    Fire off the rules

    Fire Off the Rules

    publicvoidfireAllRules(Object assessedObject) {

    /* Evaluate each Rule */

    for (AssessmentResult result : getAssessmentResults()) {

    result.fireRule(assessedObject);

    }

    protectedvoidfireRule(Object assessedObject) {

    /* Evaluate each of the Rule's predicates */

    for (String predicate : rule.getPredicates()) {

    Boolean predicateTruth;

    predicateTruth= MVEL.evalToBoolean(

    predicate, assessedObject);

    getPredicateEvaluations().put(

    predicate, predicateTruth);

    }


    Using jhove2 for policy assessment of files

    Sequence Diagram


    Identification

    Identification


    Feature extraction

    Feature extraction


    Using jhove2 for policy assessment of files

    Assessmemt


    Agenda 13 30 16 305

    Agenda 13:30-16:30

    What is JHOVE2 ?

    Characterization of digital objects

    Validation vs Assessment

    Examples of JHOVE2 output

    Source Units, Modules, Reportable Properties

    Implementation of Assessment

    Configuration of Assessment Rules


    Assessment configuration

    Assessment Configuration

    Lists of properties for a Module can be generated using the ReportableInstanceTraverser utility

    USAGE: java -cp CLASSPATH org.jhove2.app.util.traverser.ReportableInstanceTraverser

    fully-qualified-class-name

    output-file-path

    {optional boolean should-recurse(default true)}

    wave-property-list.txt

    tiff-module-properties.txt


    Assessment configuration1

    Assessment Configuration

    Rules are configured using ARules utility

    Utility developed by CDL to create rule set in XML

    Future plans: a GUI

    ARules output is a Spring configfle


    Arules configuration

    ARules configuration

    ruleset XmlRuleSet enabled org.jhove2.module.format.xml.XmlModule

    desc Ruleset for XML module

    rule XmlStandaloneRule enabled

    desc Does XML Declaration specify standalone status?

    cons Is Standalone

    alt Is Not Standalone

    quant all

    pred xmlDeclaration.standalone == "yes"

    rule XmlAcceptableRule enabled

    DescIs the XML status acceptable?

    cons Acceptable

    alt Not Acceptable

    quant any

    pred valid.name() == "True"

    pred (valid.name() == "Undetermined") && (wellFormed.name() == "True")


    Ruleset spring bean

    RuleSet Spring Bean

    <!-- RuleSet bean for the XmlModule -->

    <bean id="XmlRuleSet" class="org.jhove2.module.assess.RuleSet" scope="singleton"> <property name="name" value="XmlRuleSet"/> <property name="description"

    value="RuleSet for Xml Module"/> <property name="objectFilter"

    value="org.jhove2.module.format.xml.XmlModule"/> <property name="rules"> <list value-type="org.jhove2.module.assess.Rule"><ref local="XmlStandaloneRule"/><ref local="XmlValidityRule"/> </list></property><property name="enabled" value="true"/>

    </bean>


    Rule spring bean

    Rule Spring Bean

    <!-- Rule bean for evaluating validity value -->

    <bean id="XmlValidityRule"

    class="org.jhove2.module.assess.Rule" scope="singleton"> <property name="name" value="XmlValidityRule"/> <property name="description"

    value="Is the XML validity status acceptable?"/><property name="consequent" value="Acceptable"/> <property name="alternative" value="Not Acceptable"/> <property name="quantifier" value="ANY_OF"/><property name="predicates"> <list value-type="java.lang.String"><value><![CDATA[ valid.toString() == 'true']]</value><value><![CDATA[ (valid.toString() == 'undetermined') && (wellFormed.toString() == 'true') ]]></value> </list></property><property name="enabled" value="true"/>

    </bean>


    Spring config files

    Spring Config Files

    config

    └───spring

    └───module

    ├───aggrefy

    │ jhove2-aggrefy-config.xml

    ├───assess

    │ jhove2-assess-config.xml

    │ jhove2-ruleset-xml-config.xml

    ├───digest

    │ jhove2-digest-config.xml

    ├───display

    │ jhove2-display-config.xml

    ├───identify

    │ jhove2-display-config.xml


    Assessment output

    Assessment Output

    Results stored as new characterization properties

    Rule evaluation output includes

    • Rule's name and brief description

    • Boolean value of the condition that was evaluated

    • Text value of the consequent of alternative

    • Details of the predicate evaluation results


    Assessment output example

    Assessment Output Example

    Module {AssessmentModule}:

    AssessmentResultSets:

    AssessmentResultSet:

    RuleSetName: XmlRuleSet

    RuleSetDescription: Ruleset for XML module

    ObjectFilter: org.jhove2.module.format.xml.XmlModule

    BooleanResult: false

    AssessmentResults:

    AssessmentResult:

    RuleName:XmlStandaloneRule

    RuleDescription: Does XML Declaration specify standalone status?

    BooleanResult: false

    NarrativeResult: Is Not Standalone

    AssessmentDetails: ALL_OF { xmlDeclaration.standalone == "yes" => false; }

    AssessmentResult:

    RuleName: XmlAcceptableRule

    RuleDescription: Is the XML status acceptable?

    BooleanResult: true

    NarrativeResult: Acceptable

    AssessmentDetails: ANY_OF { valid.name() == "True" => true;(valid.name( )

    == "Undetermined") && (wellFormed.name() == "True") => false; }


    Actionable outcomes

    Actionable Outcomes?

    • Assessment outcome is informational data

    • Surrounding workflows may utilize assessment results to guide control mechanism

    • JHOVE2 provides API, but does not initiate actions


    Assessment enhancements

    Assessment Enhancements

    • Assessment Config file editing

      • Make it easier for a non-programmer to edit

      • Editing should be bullet-proofed if possible

    • GUI User interface

      • Presents a GUI treeview that lists reportable properties in a navigable hierarchy.

    • Sanity checking

      • Pre-test config files to ensure compatability

        • Command-line invocation of the sanity checker

        • Run check whenever installed modules have been changed

      • Also have robust reporting in case property is missing


    Jhove2 community

    JHOVE2 Community

    Wiki

    • http://jhove2.org/

    • https://bitbucket.org/jhove2/main/wiki/Modules

      Mailing lists

    • [email protected]

    • [email protected]


  • Login