## 1.1 Purpose

This SRS defines the functional and nonfunctional requirements for the System Administration Module of an Integrated Library System (ILS). Developed for the King County Library System (KCLS), the requirements are intended to support a large, urban, multi-branch, centralized library system and are broadly applicable to similar enterprises. The module is intended to replace and enhance current administration capabilities found in commercially available ILSes and to add new functionality, presupposing the data structures and core functionality of a full-fledged ILS.

The purpose of the System Administration Module is to provide centralized configuration and operational control of the ILS, including:
- Configuring features and processes for managing branches, patrons, collections, and circulation
- Monitoring, troubleshooting, and controlling server, database, application, services, ports, and API performance
- Managing user and group accounts and privileges
- Managing server and client software installation, upgrades, and updates
- Accessing and managing configuration files and log files, backups, and recovery
- Supporting dashboards, consoles, scheduling, reporting, and business rules (e.g., loan, requesting, and suppression rules)
- Ensuring secure protocols and patron data protection

## 1.2 Scope

This SRS specifies the System Administration Module of an Integrated Library System (ILS) for the King County Library System and other large, urban, multi-branch, centralized library systems. The module replaces and enhances the administration capabilities of commercially available ILSes and adds new functionality. It presupposes a full-fledged ILS and focuses on management activities rather than data structures or detailed user interfaces.

Products to be produced:
- System Administration Module (enterprise ILS component)
- Administrative consoles and dashboards: Server Console, System Performance Dashboard, Application Dashboard, Client Management Console, Circulation Dashboard, Configuration File Console, Log-file Dashboard, Job Scheduling Console
- Administrative tools: Query Tool, Report Templates/Generator, MARC Import/Export utilities, Record Set management

What the software will do:
- Configure ILS features and processes for branches, patrons, collections, and circulation
- Monitor, troubleshoot, and control servers, databases, applications, services, ports, and APIs (including SNMP-based monitoring, alerting, and thresholds)
- Manage user and group accounts, roles, and privileges; provide auditability through individual logins
- Manage server and client software installation, upgrades, and updates; centralize client configuration and updates
- Provide access to and management of configuration and log files; support dashboards for status and performance
- Schedule, sequence, and administer automated jobs (reports, imports/exports, maintenance) with appropriate permissions
- Define and enforce business rules (suppression/visibility, requesting/holds, loan rules, data validation)
- Support data recovery and continuity (live incremental/full backups, rollback/undo, server clustering)
- Enforce security (secure protocols such as SFTP/SSL/SSH; patron data security; privilege administration)
- Provide queries and reports with fine-grained permissions and multiple output formats; printer support
- Support maintenance operations (MARC bibliographic/authority import/export; record sets; staff and patron account setup; keyboard macros/shortcuts)

Application, benefits, objectives, and goals:
- Application: Centralized administration of an enterprise-level ILS serving approximately 50 locations, ~20 million circulations, and annual acquisition/processing of 500,000+ items
- Benefits: Centralized control, real-time operational insight, improved reliability and recoverability, stronger security and compliance, scalable client management, and efficient reporting
- Objectives/goals: Enable live, minimally disruptive operations (e.g., searches/reports during open hours), provide comprehensive administration visibility and control, and support iterative improvement of functions; deliver a development/training environment with migration to production

Consistency with higher-level specifications:
- Part of an enterprise-level Library Automation System and consistent with existing and planned modules (Acquisitions and Serials Management, Circulation, Cataloging, and OPAC/web services)
- Relies on and interacts with ILS data structures and external vendor interfaces via published APIs and standard-format data exchanges (e.g., USMARC21, EDIFACT)

### 1.3.1 Product perspective

The System Administration Module is a core component of an enterprise-level Integrated Library System (ILS) used by a large, centralized, multi-branch public library system. It manages and configures ILS features and processes; monitors and controls servers, databases, services, ports, and APIs; manages user and group accounts and privileges; manages software installation and updates; and supports backups and recovery. It relies on and interacts with other ILS modules (e.g., Acquisitions, Cataloging, Circulation) and with the patron-facing Online Public Access Catalog (OPAC). It also interfaces with vendor services through published APIs and standard data file exchanges.

Major elements and interconnections (textual):
- Enterprise ILS: Acquisitions, Cataloging, Circulation, OPAC.
- System Administration Module: configuration, monitoring, security, maintenance, reporting.
- Relational database backend with SQL and ODBC access.
- Server and client environments: Linux/Solaris servers; web browser or Windows-compatible client access.
- External services and protocols: SNMP, SMTP, SFTP/SSL/SSH, SIP2/NCIP2, USMARC21, EDIFACT, OCLC.
- Backup and recovery infrastructure; clustering/failover.

#### System interfaces
- ILS core modules (Acquisitions, Cataloging, Circulation)
  - Functionality enabled: creation and modification of business rules (loan rules, requesting rules, suppression/visibility), MARC authority/bibliographic import/export, record sets for batch operations, data validation, concurrent record access and lock administration.
  - Interface description: shared relational database and ILS-internal interfaces; real-time processing and record locking behaviors are enforced across modules. [Further interface specification: N/A]
- OPAC (patron interface)
  - Functionality enabled: enforcement of visibility (suppression) rules and request (hold) rules affecting public display and hold placement.
  - Interface description: ILS-internal interface for patron discovery and transactions. [N/A]
- Self-service and external circulation endpoints
  - Functionality enabled: simultaneous access to patron and item records; real-time circulation updates and holds via SIP2/NCIP2 and similar protocols and APIs.
  - Interface description: SIP2/NCIP2-based messaging. [Message content/format references: N/A]
- Vendor and partner systems (e.g., OCLC; vendor websites)
  - Functionality enabled: MARC authority/bibliographic import/export; order/invoice or related exchanges via standard file formats; scheduled imports/exports; SFTP transfers.
  - Interface description: published APIs and automated transfer of standard-format data files (e.g., USMARC21, EDIFACT) over secure protocols (SFTP/SSL/SSH). [Detailed specs: N/A]
- Monitoring and alerting systems
  - Functionality enabled: SNMP-based monitoring of system resources; configurable thresholds; alerts via dashboards, email, and text messages.
  - Interface description: SNMP; email/text delivery channels. [N/A]
- Backup and high availability systems
  - Functionality enabled: live incremental/full backups; integration with third-party backup software (e.g., EMC NetWorker); server clustering for failover.
  - Interface description: vendor backup interfaces; cluster management. [N/A]

#### User interfaces
- Access modalities: web browser or Windows-compatible client; accessible with screen-reading and screen-magnification software.
- Administrative consoles and dashboards: system performance dashboard; server console (software/server start/stop/restart); application dashboard (backups, reboots, upgrades, version, transaction queues, log sizes, record counts, database utilization); client management console; configuration file console; log-file dashboard; job scheduling console; circulation dashboard.
- Documentation and help: web-based, indexed, function-organized, searchable documentation; online hierarchical and cross-linked HTML help.
- Printing and output: definition and selection of receipt, standard, label, and forms printers; options to display, print, email, FTP, or save to files (CSV, Excel, customizable formats); selection and ordering of record fields when printing.

#### Hardware interfaces
- Server platform: Linux or Solaris server.
- Client workstations: Windows-compatible clients; remote session management (view/manage/kill client sessions).
- Printers: support for receipt, standard, label, and forms printers; all Windows printers supported.
- System interfaces and ports: monitoring of system interfaces and ports via SNMP.
- Configuration characteristics, device-specific protocols, and port counts: [N/A]

#### Software interfaces
For required software products and standards:
- Relational database backend (SQL/ODBC-capable)
  - Name: [N/A]; Mnemonic: [N/A]; Specification number: [N/A]; Version: [N/A]; Source: [N/A]
  - Purpose: fully relational backend; SQL queries against any table; ODBC access; full data accessibility.
  - Interface: SQL queries; ODBC data source. [Detailed message/format: N/A]
- Operating systems
  - Name: Linux or Solaris; Mnemonic: [N/A]; Specification number: [N/A]; Version: [N/A]; Source: [N/A]
  - Purpose: server operating environment.
  - Interface: standard OS services; shell access (including root). [N/A]
- Web browsers
  - Name: Microsoft Internet Explorer (v6.0+), Mozilla Firefox (v2.0+); Mnemonic: [N/A]; Specification number: [N/A]; Version: as noted; Source: [N/A]
  - Purpose: browser-based administrative access.
  - Interface: standards-compliant HTML. [N/A]
- Backup software
  - Name: EMC NetWorker (example); Mnemonic: [N/A]; Specification number: [N/A]; Version: [N/A]; Source: [N/A]
  - Purpose: live incremental/full backups of data and transaction logs.
  - Interface: vendor backup integration. [N/A]
- Monitoring
  - Name: SNMP; Mnemonic: [N/A]; Specification number: [N/A]; Version: [N/A]; Source: [N/A]
  - Purpose: system resource monitoring and alerting.
  - Interface: SNMP-managed objects/events. [N/A]
- Secure transport and access
  - Name: SFTP (active/passive per vendor), SSL, SSH; Mnemonic: [N/A]; Specification number: [N/A]; Version: [N/A]; Source: [N/A]
  - Purpose: secure file transfer and remote access.
  - Interface: protocol-standard sessions. [N/A]
- Email
  - Name: SMTP; Mnemonic: [N/A]; Specification number: [N/A]; Version: [N/A]; Source: [N/A]
  - Purpose: email transport for notifications/alerts.
  - Interface: SMTP configuration and message delivery. [N/A]
- Library interoperability standards
  - Name: SIP2, NCIP2, USMARC21, EDIFACT, OCLC; Mnemonic: [N/A]; Specification number: [N/A]; Version: [N/A]; Source: [N/A]
  - Purpose: self-service/device integration; bibliographic/authority data exchange; vendor data exchange.
  - Interface: protocol/file-format compliant messages and files. [N/A]
- Remote client management
  - Name: VNC, Remote Desktop; Mnemonic: [N/A]; Specification number: [N/A]; Version: [N/A]; Source: [N/A]
  - Purpose: client software management and support.
  - Interface: remote session/control. [N/A]

#### Communications interfaces
- Network protocols and services: SNMP for monitoring; SMTP for email transport; SFTP (active/passive) for file transfer; SSL and SSH for secure communications; SIP2/NCIP2 for circulation device integration; FTP and email output for report/print delivery; ODBC for database connectivity.
- Specific local network, addressing, and protocol versions: [N/A]

#### Memory constraints
- [N/A]

#### Operations
- Modes: centralized system administration serving multiple locations; both interactive and unattended operations.
- Interactive operations: real-time processing; simultaneous access and updates to patron and item records; dashboards and consoles for monitoring and administration; configuration and rule management; client session management.
- Unattended operations: scheduled tasks/jobs (maintenance, reports, imports/exports, software updates) with sequencing and administrative oversight; alerts via dashboards/email/text.
- Data processing support: query tool with field selection, expressions, Boolean operators; report templates and permissions; customizable report layouts and outputs.
- Backup and recovery: live incremental and full backups; integration with third-party backup software; data change logging with undo/revision control (ideally); server clustering for failover.

#### Site adaptation requirements
- Configuration of business rules: loan rules, requesting rules, and suppression/visibility rules tailored by patron/item types, statuses, locations, and override permissions.
- Account templates: configurable templates and granular privileges for staff and patron account creation; role/privilege-based access control for individuals and groups.
- Email settings: editable email configuration with common settings (masquerading, log retention, bounce management).
- Client configuration: server-based client configuration files with import/export; centrally managed client software installation and streaming updates; workstation independence of accounts.
- Printers and output: definition of printer types and output options (print to server file, FTP, email, or printer); field selection and ordering for printed outputs.
- Environments: development and training environments with migration of configurations to production.
- Localization/branch adaptation and scaling parameters: [N/A]

#### Interfaces with services
- Vendor websites and services: integration via published APIs and automated transfer of standard-format data files (e.g., USMARC21, EDIFACT); OCLC interaction for MARC import/export.
- Messaging and notification services: SMTP-based email delivery; text messaging for alerts. [Service providers: N/A]
- Secure transfer and remote access services: SFTP (active/passive), SSL, SSH; remote client management via VNC and Remote Desktop.
- Cloud/SaaS specifics: [N/A]

### 1.3.2 Product functions

The System Administration Module provides centralized configuration, operations control, security, data administration, automation, and reporting for an enterprise Integrated Library System. Major functions include:

- Configure ILS operations and business rules
  - Configure system features supporting branches, patrons, collections, and circulation.
  - Create and modify business rules: loan rules (check-out, due dates, renewals), requesting rules (hold eligibility and overrides), and visibility/suppression rules for authority, bibliographic, order, and item records.
  - Define data rules: default values, validation, formatting, and required fields for any field.
  - Configure email transport and policies (SMTP, masquerading, retention, bounce management).

- Manage identities, roles, and access
  - Create and manage individual and shared staff accounts with role/privilege-based access; support user-level preferences and audit trail.
  - Provision patron accounts using templates with validation and configurable defaults.
  - Control fine-grained permissions for modules, reports, configuration files, database tables/fields, and consoles.
  - Enforce patron data security and secure transfer protocols (SFTP, SSL, SSH); manage record locks, view lock origins, and set unlock thresholds.

- Operate and monitor the platform
  - Monitor servers, databases, applications, services, interfaces, and ports via SNMP with configurable thresholds and alerts (dashboards, email, text).
  - Use performance and status dashboards (system performance, application status, circulation KPIs).
  - Start, stop, and restart software and servers; access root shell; identify and manage runaway processes.
  - Access configuration and log files without downtime; enable/disable logs and set retention.

- Administer data and records
  - Operate on a fully relational SQL database with direct query and ODBC access; support real-time processing and concurrent field/record sharing with conflict prompts.
  - Import/export MARC bibliographic and authority records (single or batch), including overlay; manage batches as selection lists.
  - Create and manage record sets for batch updates, query scoping, and controlled deletion with logging and undo.

- Schedule and automate jobs
  - Schedule and sequence maintenance tasks, reports, imports/exports, and software updates; modify or cancel jobs prior to start.
  - Manage staff-scheduled jobs from a central console with administrative oversight.

- Ensure backup, recovery, and resilience
  - Perform live incremental and full backups of data and transaction logs; integrate with third-party backup tools.
  - Log data changes and support undo/revision control; cluster servers for failover.

- Provide queries, reporting, and output
  - Design queries over all record types with picklists, regular expressions, and Boolean operators; administer table/field access for staff.
  - Create report templates and control report execution permissions; customize layout and appearance.
  - Output to screen, printer, email, file (CSV, Excel, and customizable formats); produce record number summaries.
  - Support multiple printer types (receipt, standard, label, forms) and flexible print/output options (file, ftp, email, printer) with field order control.

- Manage clients and deployment
  - Centrally install and stream updates to client software; target specific clients; manage clients via VNC and Remote Desktop.
  - Maintain server-based client configurations with import/export; keep staff/group accounts independent from workstations.
  - Use a client management console to view active clients and terminate sessions.

- Use administrative consoles and dashboards
  - Configure custom dashboards and grant access to users/groups.
  - Access dedicated consoles: configuration files, log files, server control, system performance, application status, client management, circulation metrics, and job scheduling.

- Enhance administrative productivity
  - Provide centrally managed, permissioned keyboard macros and shortcuts assignable to keys or text strings.

Illustrative use cases and scenarios:
- A circulation manager adjusts loan and requesting rules so patrons cannot place holds on on-order CDs while allowing holds on other on-order items; selected staff can override specific criteria.
- A system administrator receives an alert for high CPU load, identifies a runaway process from the performance dashboard, and terminates it; later reviews related log entries without stopping the system.
- Nightly MARC batches are imported, overlaying short records; results are reviewed via a selection list, and a report is emailed upon job completion.
- After an item record is mistakenly deleted, staff use revision/undo to restore it; record locks are monitored and stale locks are released from the lock administration console.
- IT pushes a client software update to selected branch PCs, verifies successful sessions, and terminates stale sessions from the client management console.
- A branch lead runs a circulation dashboard filtered to their location and executes a pre-approved report template, exporting results to Excel.

### 1.3.3 User characteristics

The System Administration Module serves multiple user groups whose characteristics influence usability and access.

- System Administrators
  - Characteristics: Staff responsible for managing servers, databases, applications, services, ports, and APIs related to the ILS.
  - Technical expertise: Advanced, including use of administrative consoles/dashboards, monitoring tools (e.g., SNMP), secure protocols (e.g., SSH/SSL/SFTP), configuration and log file access, backups, clustering, and client management.
  - Account model: Full visibility and control over user privileges; use of roles/privileges; may require root shell access.

- Library Staff
  - Characteristics: Managers, librarians, library technicians, library assistants, and pages involved in designing and providing Library services.
  - Technical expertise: Varies by role; staff may receive granular permissions to create/modify accounts, run queries and reports, and schedule/manage jobs.
  - Account model: Supports individual and shared staff login accounts with role-based access; individual logins enable user-level preferences and audit trails.

- Managers, Library Managers, and Library Directors
  - Characteristics: Management staff who oversee Library processes; Cluster and Site Managers who provide input to service design and implementation; Executive Team members who plan and direct services and priorities.
  - Technical expertise: Organizational and operational focus; access controlled through roles/privileges.

- Patrons (indirect/affected users)
  - Characteristics: Customers of the Library, with or without a library card, on-site or remote, using print, media, or electronic resources.
  - Technical scope: Limited access to selected data fields as permitted; not intended administrators of the module.

Cross-cutting characteristics influencing usability and access:
- Accessibility: The module must be accessible with screen-reading software, screen-magnification software, and other assistive programs.
- Client access: Users access the module via a web browser (Microsoft Internet Explorer v6.0+ and Mozilla Firefox v2.0+) or a Windows-compatible client.
- Security and permissions: Fine-grained, role-based privileges govern visibility and actions across user groups; accounts are independent from workstations.

Educational level: [N/A]
Prior domain experience: Library staff and managers are involved in designing and providing Library services; further details [N/A].
Disabilities: Users may rely on assistive technologies as noted above.

### 1.3.4 Limitations

- Regulatory requirements and policies:
  - HTML output must be standards-compliant.
  - An online, hierarchical, cross-linked HTML help system must describe all system functions.

- Hardware limitations:
  - Operates on a Linux or Solaris server.
  - Accessible via web browser or a Windows-compatible client; if web-based, must support Microsoft Internet Explorer 6.0+ and Mozilla Firefox 2.0+.
  - Printing limited to Windows-supported printers; four printer types must be definable (receipt, standard, label, forms).

- Interfaces to other applications:
  - Interfaces with vendor websites via published APIs and/or automated transfer of standard-format data files (e.g., USMARC21, EDIFACT).
  - Interacts with the OPAC.
  - Supports SIP2/NCIP2 and similar protocols/APIs for record access/updates across staff and patron-facing systems.
  - Supports MARC bibliographic/authority import/export, including to/from OCLC.
  - Supports SNMP for system monitoring.
  - Supports SMTP for email transport; administrative email configuration required.
  - Database must be accessible as an ODBC source; SQL queries must be allowed against any table.

- Parallel operation:
  - Concurrent access/updates to patron and item records by multiple staff and patrons, including self-check and OPAC, with conflict prompts.
  - Record lock visibility and administrative unlocking with configurable lock-duration thresholds.
  - Server clustering for failover capability.

- Audit functions:
  - Data changes (e.g., deletions) must be logged; undo/revision control is required.
  - Full access to log files; logs viewable without downtime; enable/disable with configurable retention; centralized log dashboard.
  - Individual logins enable user-level audit trails.

- Control functions:
  - Fine-grained user/group/role-based privileges; full administrative visibility and control of privileges.
  - Administrative consoles/dashboards for system monitoring and management, including server startup/shutdown, performance/process views, application status, client session management (incl. kill), job scheduling/review/management, configuration file access, and email configuration.
  - Centralized, controllable client software installation and updates.

- Higher-order language requirements:
  - [N/A]

- Signal handshake protocols (e.g., XON-XOFF, ACK-NACK):
  - [N/A]

- Quality requirements (e.g., reliability):
  - Live incremental and full backups of data and transaction logs; support for third-party backup software.
  - Data rollback/undo and revision control.
  - Server clustering for failover; system monitoring with configurable alerts (dashboards, email, text).
  - Real-time processing (e.g., up-to-date pull lists; support for live shelf reading/weeding).
  - Must support a high-volume environment (approximately 50 locations, 20 million circulations/year, 500,000 items/year) with searches/reports processed during open hours without disrupting other functions.

- Criticality of the application:
  - [N/A]

- Safety and security considerations:
  - Patron data must be secure in all transfers.
  - Supports secure protocols: SFTP (active and passive modes configurable per vendor), SSL, and SSH.

- Physical/mental considerations:
  - Accessible with screen-reading software, screen-magnification software, and other assistive technologies.

- Limitations sourced from other systems (including real-time requirements through interfaces):
  - Relies on the data structures and functionality of an enterprise-level Library Automation System, including Acquisitions and Cataloging modules; interacts with the OPAC.
  - Interfaces with external vendors via published APIs and standardized file exchanges (e.g., USMARC21, EDIFACT).
  - Real-time and concurrent operation requirements apply across integrated interfaces (e.g., SIP2/NCIP2, self-check, OPAC).

## 1.4 Definitions

- System Administration Module: The component of the Integrated Library System that configures and supports features and processes for managing library branches, patrons, collections, and circulation transactions; monitors, troubleshoots, and controls servers, databases, applications, services, ports, and APIs; manages user/group accounts and privileges; manages software installation, upgrades, and updates; and supports backup of databases, configuration files, and log files.

- Integrated Library System (ILS): An enterprise-level Library Automation System that includes multiple modules (e.g., Acquisitions and Serials Management, Circulation, Cataloging) and a patron interface.

- Online Public Access Catalog (OPAC): The patron interface to the ILS.

- Patron: A customer of the library system, with or without a library card, using print, media, or electronic resources on-site or remotely.

- Staff: Managers, librarians, library technicians, library assistants, and library pages involved in designing and providing library services.

- System Administrators: Staff responsible for managing servers, databases, applications, services, ports, and APIs related to the ILS.

- Managers: Management staff who oversee library processes.

- Library Managers: Cluster and Site Managers who provide input to the design and implementation of library services.

- Library Directors: Members of the Library Executive Team who plan and direct library services and priorities.

- Roles: Access-control constructs used to grant accounts the ability to access specific modules and functions.

- Privileges: Fine-grained permissions used to allow or restrict specific actions or data access (e.g., running particular reports, performing overrides).

- Security Groups: Groups used to manage user rights and privileges for individuals, workgroups, or other staff groupings.

- Business Rules: Configurable restrictions governing system actions (e.g., preventing deletion of checked-out item records or bibliographic records with existing holds).

- Rules of Suppression: Customizable visibility rules that determine whether authority, bibliographic, order, and item records are viewable by patrons and/or staff in staff and public interfaces, with scoping to specific workgroups or locations.

- Requesting Rules: Rules that determine whether a patron can place a hold on an item, based on criteria such as patron type, number of current holds, account balance, item type/status, owning location, and other factors; may permit staff overrides.

- Loan Rules: Rules that allow or disallow checkout, calculate loan periods, and determine renewal limits based on criteria such as patron type, number of items checked out, account balance, item type/status, owning location, and checkout location schedule; may permit staff overrides.

- Data Validation: Configuration of default values, required status, and automatic formatting for fields in records.

- Record Set: A managed set of records that can be imported/exported in batch, used as the basis for batch field updates, used to scope queries, and used for batch deletion with review, error logging, and undo.

- Record Lock: The condition indicating a record is in use; the system identifies where, by whom, and when the lock was placed, and provides administrative controls to list, time-limit, and unlock records.

- Dashboard: A configurable administrative display showing current and historical data (e.g., system performance, record activity, circulation key performance indicators) with role-based access.

- Console: A focused administrative interface for managing a specific area (e.g., server management, client sessions, configuration files, job scheduling).

- Job (Scheduled Task): Any scheduled operation such as maintenance tasks, reports, imports/exports, or software updates, which can be sequenced, modified, or canceled prior to start.

- Real-Time Processing: System behavior in which data and lists (e.g., pull lists) are up to date at the time of viewing or printing, supporting live operational activities (e.g., shelf reading, weeding).

- Record Types: The categories of records maintained or accessed by the system, including patron, bibliographic, item, authority, order, invoice, and hold/request records.

# 2 References

## Compliance

- Title: MARC 21 Format for Bibliographic Data; MARC 21 Format for Authority Data
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: Library of Congress
  - Source: https://www.loc.gov/marc/

- Title: UN/EDIFACT (Electronic Data Interchange for Administration, Commerce and Transport)
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: UN/CEFACT (United Nations Centre for Trade Facilitation and Electronic Business)
  - Source: https://unece.org/trade/uncefact/unedifact

- Title: Standard Interchange Protocol (SIP), Version 2
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: [N/A]
  - Source: [N/A]

- Title: ANSI/NISO Z39.83 – Circulation Interchange Protocol (NCIP), Version 2
  - Report number: ANSI/NISO Z39.83
  - Date: [N/A]
  - Publishing organization: NISO (National Information Standards Organization)
  - Source: https://www.niso.org/standards-committees/ncip

- Title: Simple Network Management Protocol (SNMP)
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: IETF (Internet Engineering Task Force)
  - Source: https://www.rfc-editor.org/

- Title: Simple Mail Transfer Protocol (SMTP)
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: IETF (Internet Engineering Task Force)
  - Source: https://www.rfc-editor.org/

- Title: Secure Shell (SSH) Protocol
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: IETF (Internet Engineering Task Force)
  - Source: https://www.rfc-editor.org/

- Title: Secure Sockets Layer (SSL)
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: [N/A]
  - Source: [N/A]

- Title: Open Database Connectivity (ODBC)
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: Microsoft
  - Source: https://learn.microsoft.com/sql/odbc/

- Title: HTML Specification (Standards-Compliant HTML)
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: W3C (World Wide Web Consortium)
  - Source: https://www.w3.org/TR/html/

## Guidance

- Title: Microsoft Internet Explorer 6 Documentation
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: Microsoft
  - Source: https://learn.microsoft.com/ [N/A for specific IE6 documentation page]

- Title: Mozilla Firefox 2 Documentation
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: Mozilla
  - Source: https://support.mozilla.org/ [N/A for specific Firefox 2 documentation page]

- Title: EMC NetWorker Product Documentation
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: Dell EMC
  - Source: https://www.dell.com/support/ [N/A for specific NetWorker documentation page]

- Title: VNC (Virtual Network Computing) Documentation
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: [N/A]
  - Source: [N/A]

- Title: Microsoft Remote Desktop Services Documentation
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: Microsoft
  - Source: https://learn.microsoft.com/windows-server/remote/remote-desktop-services/

- Title: King County Library System – Acquisitions and Serials Management Module Specification
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: King County Library System
  - Source: [N/A]

- Title: King County Library System – Circulation Module Specification
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: King County Library System
  - Source: [N/A]

- Title: King County Library System – Cataloging Module Specification
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: King County Library System
  - Source: [N/A]

- Title: King County Library System – OPAC and Web Services Requirements (in development)
  - Report number: [N/A]
  - Date: [N/A]
  - Publishing organization: King County Library System
  - Source: [N/A]

## 3.1 Functions

This section summarizes the fundamental system-administration functions of the Integrated Library System (ILS) and how inputs are accepted and processed to generate outputs.

Sub-functions and fundamental actions
- System monitoring and consoles
  - Collect and expose system and application telemetry via SNMP and internal instrumentation, including disk/CPU/memory/processes/interfaces/ports, job queues, backups, reboots, software versions, and record counts (REQ-6501, REQ-2467, REQ-2464).
  - Evaluate metrics against configurable alert thresholds and deliver alerts via dashboards, email, and text to unlimited recipients (REQ-6501).
  - Surface and manage processes and sessions, including identification of runaway processes and ability to manage/kill client sessions (REQ-2467, REQ-2430).
  - Provide administrative consoles for server/app startup/shutdown/restart, and centralized access to configuration and log files (REQ-2466, REQ-6517, REQ-2433, REQ-2479, REQ-2474, REQ-2470).
  - Provide configurable dashboards (system, circulation, job scheduling) with role-based access (REQ-6520, REQ-6503, REQ-6521).
  - Configure email transport and support SMTP (REQ-6515, REQ-6516).
- Business rules and validation
  - Enforce business-rule–based restrictions on actions such as delete, request/hold placement, and checkout/renewal based on patron/item attributes, statuses, location codes, account balances, and other criteria (REQ-2445, REQ-5190, REQ-5057).
  - Support visibility/suppression rules for authority/bibliographic/order/item records across staff/patron interfaces (REQ-5278).
  - Provide field-level defaults, validation, formatting, and required indicators (REQ-5328).
  - Allow staff with appropriate roles to override specific criteria where permitted by rules (REQ-5190, REQ-5057).
- Data recovery and continuity
  - Execute live incremental and full backups of data and transaction logs, including support for third-party backup tools (REQ-6502).
  - Log data changes and provide undo and revision-control–style rollback where available (REQ-6505).
  - Support server clustering for failover (REQ-2462).
- Security and access control
  - Protect patron data in transit; support secure protocols SFTP (active/passive), SSL, SSH (REQ-6510, REQ-6511).
  - Provide full visibility and control of user privileges; support individual and shared staff accounts with roles/privileges (REQ-6509, REQ-2492).
- Maintenance and configuration
  - Import/export MARC bibliographic and authority records in batch or singly; overlay existing records; maintain imported batches as selection lists (REQ-1716).
  - Manage record sets for batch updates, scoping queries, and controlled deletions with error logging and undo (REQ-6518).
  - Create patron and staff accounts via dedicated interfaces with configurable templates, defaults, validation, and granular privileges (REQ-2419, REQ-2420).
  - Schedule maintenance tasks, reports, data exports; sequence jobs (start B after A finishes); manage others’ scheduled jobs with appropriate permissions (REQ-6507, REQ-6508, REQ-6521).
  - Create and centrally manage macros/shortcuts; import/export and permission-restrict their use/editing (REQ-2220).
- Client management
  - Centrally manage client installation and streaming updates; target specific clients; manage via VNC/Remote Desktop; keep accounts independent of workstations; maintain server-based client configs with import/export (REQ-6504, REQ-6514, REQ-6519).
- Queries and reporting
  - Provide user-friendly query design across all record types with field selection, picklists, regex options, Boolean operators; administrators control table/field access (REQ-5624).
  - Create and run report templates; enforce fine-grained report permissions (REQ-5607, REQ-5617).
  - Customize report layout/appearance; display/print/email/save to CSV/Excel and other formats (REQ-2197).
  - Produce record-number reports by record type; control access at user/group level (REQ-2465).
  - Support multiple print outputs (server file, FTP, email, printer), selectable printer types, and field/order control where applicable (REQ-2439, REQ-2441).

a) Validity checks on inputs
- Field-level validation, defaulting, formatting, and required flags for any field (REQ-5328).
- Business-rule validations for holds/requests, checkout/renewal, and record deletion based on patron/item attributes, statuses, location codes, account balances, and other criteria (REQ-5190, REQ-5057, REQ-2445).
- Visibility/suppression checks to determine whether records are viewable by staff/patrons (REQ-5278).
- Role/privilege checks for access to modules, dashboards, configuration/log files, job scheduling, report/query execution, and overrides (REQ-2492, REQ-6509, REQ-6517, REQ-5617, REQ-5624).
- Protocol and transport configuration checks for secure communications (SFTP/SSL/SSH) and email settings (REQ-6511, REQ-6515).

b) Exact sequence of operations
- Jobs can be explicitly sequenced (“start job B when job A finishes”) (REQ-6507).
- [N/A] for additional exact operational sequences not otherwise specified.

c) Responses to abnormal situations
- Overflow
  - [N/A]
- Communication facilities
  - [N/A]
- Hardware faults and failures
  - Clustered servers provide failover capability (REQ-2462).
- Error handling and recovery
  - Monitoring identifies runaway processes; administrators can intervene via consoles (REQ-2467, REQ-2466).
  - Record lock administration lists sustained-use/locked records and allows unlocking (REQ-7302, REQ-6513).
  - Data changes are logged with undo/revision control to support rollback (REQ-6505).
  - Live incremental/full backups support restore operations; log files can be reviewed without stopping the system (REQ-6502, REQ-2474).
  - Alerts are generated when configurable thresholds are exceeded; multiple delivery channels are supported (REQ-6501).

d) Effect of parameters
- Alert thresholds determine when and how alerts are emitted and to whom (REQ-6501).
- Suppression, requesting, and loan rules’ parameters (e.g., patron type, item type/status, owning/checkout location, account balance, current counts, open/closed schedules) determine visibility, holdability, checkout/renewal eligibility, and due dates; override flags enable staff exceptions (REQ-5278, REQ-5190, REQ-5057).
- Field validation settings (default/required/format) govern input acceptance at data-entry time (REQ-5328).
- Permissions/roles govern access to modules, data, dashboards, reports/queries, config/log files, job scheduling, and client/session controls (REQ-2492, REQ-6509, REQ-6517, REQ-5617, REQ-2430).
- Log retention thresholds and email configuration parameters (masquerading, bounce management) affect logging persistence and email behavior (REQ-2474, REQ-6515).
- Job schedules and dependencies affect execution timing and ordering (REQ-6507).
- Printer type/selection and print field/order choices affect output format and content (REQ-2441, REQ-2439).

e) Relationship of outputs to inputs
- Business rules
  - Inputs: patron attributes, item attributes/statuses, location codes, balances, current counts, schedules (REQ-5190, REQ-5057).
  - Outputs: permit/deny hold placement; permit/deny checkout/renewal; compute due dates; indicate whether staff override is allowed (REQ-5190, REQ-5057).
- Visibility/suppression
  - Inputs: record type and configured suppression scopes (REQ-5278).
  - Outputs: record visibility to staff/patrons by interface and location (REQ-5278).
- Monitoring/alerts and dashboards
  - Inputs: system/application metrics and thresholds (REQ-6501, REQ-2464).
  - Outputs: dashboards, status indicators, and alerts via dashboard/email/text (REQ-6501, REQ-2467).
- Query/reporting
  - Inputs: selected tables/fields, criteria, expressions, templates, and permissions (REQ-5624, REQ-5607, REQ-5617).
  - Outputs: on-screen reports and files (CSV/Excel/custom) and print/email/FTP/server-file outputs (REQ-2197, REQ-2439).
- MARC import/export and record sets
  - Inputs: MARC records/batches, overlay settings; record set definitions (REQ-1716, REQ-6518).
  - Outputs: imported/overlaid records; batch field updates; scoped queries; controlled deletions with error logs and undo (REQ-6518).
- Client management
  - Inputs: update targets, packages, and server-based configurations (REQ-6504, REQ-6519).
  - Outputs: updated client installations/configurations and managed sessions (REQ-2430, REQ-6504).
- Input/output sequences
  - [N/A]
- Formulas for input to output conversion
  - [N/A]

## 3.2 Performance requirements

- Capacity (static)
  - The system shall support a large, multi-branch environment with up to 50 locations.
  - The system shall sustain at least 20,000,000 circulation transactions per year.
  - The system shall sustain the annual purchasing and processing of at least 500,000 items.
  - The system shall handle authority, bibliographic, order, item, invoice, hold/request, patron, configuration, and log records; maximum record counts per type: [N/A].
  - Number of terminals/workstations to be supported concurrently: [N/A].
  - Number of simultaneous users/sessions (staff, patrons, self-checks, SIP2/NCIP2, OPAC): [N/A].

- Concurrency and real-time behavior (dynamic)
  - The system shall provide real-time processing such that operational lists (e.g., pull lists) and live shelf-reading/weeding views reflect current data at time of viewing or printing.
  - The system shall allow simultaneous access and update of patron and item records by multiple staff and patrons via staff terminals, self-check stations, SIP2/NCIP2 and similar protocols/APIs, and OPAC. Maximum concurrent updates/readers: [N/A].
  - Record locking thresholds (lock duration) shall be configurable and administrators shall be able to view and release locks. Lock acquisition and timeout limits: [N/A].

- Throughput and responsiveness (dynamic)
  - Searches and reports shall be processable during open hours without disrupting other system functions. Specific response-time and throughput targets for normal and peak workloads: [N/A].
  - Query and reporting tools shall operate across all record types. Minimum/maximum dataset sizes per run and completion time targets (normal/peak): [N/A].

- Background operations and availability (dynamic)
  - Log files shall be viewable without stopping the system (no operational downtime required for log review).
  - Incremental and full backups shall be performed live (no operational downtime required for backup). Backup throughput, backup window, recovery time objective (RTO), and recovery point objective (RPO): [N/A].
  - The system shall support server clustering for failover capability. Target failover time, RTO, and RPO: [N/A].

- Monitoring, alerts, and notifications (dynamic)
  - Monitoring alerts shall be generated based on configurable thresholds for system resources and delivered via dashboards, email, and text messages. Alert delivery latency and throughput: [N/A].

- Output and printing performance (dynamic)
  - The system shall support printing to receipt, standard, label, and forms printers and output to file/FTP/email without disrupting other functions. Maximum print job size and output latency: [N/A].

## 3.3 Usability requirements

The following usability and quality-in-use requirements and objectives are derived from the original SRS. They address effectiveness, efficiency, satisfaction, accessibility, and avoidance of harm within the contexts of use for patrons, staff, system administrators, and managers in a large, multi-branch library system.

- Contexts of use
  - The system is used by diverse user classes (patrons; staff including librarians, technicians, assistants, pages; system administrators; managers and directors) across a large, multi-branch environment with centralized system administration. (1.5; 1.6 OE-1)

- Effectiveness
  - The query tool provides a user-friendly interface enabling staff to design queries against all record types using selectable fields, picklists, regular expressions from a drop-down, and Boolean operators. (REQ-5624)
  - The system supports field and record sharing with prompts warning users when a record has changed since it was displayed, enabling correct conflict resolution during simultaneous access. (REQ-5323)
  - Record lock management allows staff to identify where a patron or item record is in use; administrators can list and unlock sustained-use/locked records and set lock duration thresholds. (REQ-6513, REQ-7302)
  - Business rules restrict harmful actions (e.g., deleting checked-out items or bibs with holds), and requesting/loan rules control transaction eligibility with staff override capabilities where appropriate. (REQ-2445, REQ-5190, REQ-5057)
  - Data quality is supported through configurable default values, validation, automatic formatting, and required-field settings for any field. (REQ-5328)
  - Record sets support batch updates, scoped queries, safe deletion with pre-review and error logging, and undo of deletions. (REQ-6518)

- Efficiency
  - Keyboard macros and shortcuts are supported (administrator- and user-programmable), centrally managed, importable/exportable, and controllable via permissions to reduce task time. (REQ-2220)
  - Report templates created by administrators can be reused and adapted by staff, reducing effort to produce routine outputs. (REQ-5607)
  - Printing and output are streamlined: users can select printers by type (receipt, standard, label, forms), print to file/FTP/email/printer, and select and order fields when printing. (REQ-2441, REQ-2439)
  - Dashboards provide at-a-glance status with visual indicators and identification of runaway processes; custom dashboards can be created and shared; circulation KPIs can be scoped by branch or systemwide. (REQ-2467, REQ-6520, REQ-6503)
  - Job scheduling and its console support review, sequencing, modification, cancellation, and delegated permissions, reducing administrative overhead. (REQ-6521, REQ-6507, REQ-6508)
  - Client usability is enhanced by workstation-independent accounts, server-based client configurations, and centrally managed client software updates (including remote session management). (REQ-6514, REQ-6519, REQ-6504, REQ-2430)

- Satisfaction and learnability
  - The system provides online, hierarchical, cross-linked help in HTML describing and illustrating all functions. (UD-3)
  - System documentation is web-based, indexed, organized by function, easily searchable, library-specific, and version-specific; upgrades include written guidelines and feature change lists. (REQ-2428, REQ-2431)

- Accessibility and compatibility
  - The system is accessible with screen readers, screen magnifiers, and other assistive technologies. (OE-5)
  - The system is accessible via a web browser or a Windows-compatible client; if browser-based, it supports specified browser versions. (OE-3, OE-4)

- Avoidance of harm (safety, security, and error recovery in use)
  - Patron data is secure in all transfers; secure protocols (SFTP active/passive, SSL, SSH) are supported. (REQ-6510, REQ-6511)
  - Visibility/suppression rules govern whether records are viewable by patrons and staff, preventing unintended disclosure. (REQ-5278)
  - Fine-grained report and account privileges give administrators control over access, reducing the risk of misuse. (REQ-5617, REQ-6509)
  - Prompts on concurrent updates and administrative controls for locked records reduce the risk of data loss or overwrite. (REQ-5323, REQ-7302)
  - Data rollback with logged changes and revision control (ideally) provides recovery from user errors. (REQ-6505)
  - Live backups without stopping the system support continuity of service during open hours, reducing disruption risk. (REQ-6502; 1.6 OE-1)

- Output and presentation quality
  - Users can fully customize report layout/appearance and output to display, print, email, CSV, Excel, and customizable formats. (REQ-2197)

- Quantitative usability targets
  - Effectiveness metrics: [N/A]
  - Efficiency metrics: [N/A]
  - Satisfaction metrics: [N/A]

## 3.5 Logical database requirements

- a) Types of information used by various functions
  - Patron accounts and related attributes (account setup; requesting and loan eligibility).
  - Staff accounts, groups/roles, and privileges (individual and shared logins; permissions; audit trail).
  - Bibliographic records (MARC) and Authority records (MARC), including overlay of existing records via import/export.
  - Item records (including status, type, owning location code).
  - Holds/Requests placed by patrons on items.
  - Circulation transactions (check-outs, check-ins, renewals) used for dashboards and loan rule evaluation.
  - Orders and Invoices (record types reported and counted).
  - Record sets (for batch updates, scoping queries, batch deletion, import/export).
  - Report templates and ad hoc query definitions (administrator-defined and staff-usable).
  - Scheduled jobs (tasks, reports, imports/exports; sequencing and management).
  - Record lock metadata (record identifier, location, user, timestamp).
  - Printer definitions (receipt, standard, label, forms).
  - Client configuration profiles (server-based configurations).
  - Email configuration settings (e.g., masquerading, bounce management, log retention).

- b) Frequency of use
  - Real-time processing for creation, update, and retrieval of records and transactions.
  - Simultaneous access and updates by multiple staff, patrons, and external interfaces (SIP2/NCIP2, OPAC).
  - Queries and reports run on demand and via scheduled jobs during open hours without disrupting other system functions.
  - [N/A] (No explicit periodicity for individual entities beyond the above.)

- c) Accessing capabilities
  - Fully relational, SQL-based database; ability to run SQL queries against any table; accessible as an ODBC source.
  - User-friendly query tool supporting field selection, picklists, regular expressions, and full Boolean operators; administrators control staff access to tables and fields.
  - MARC bibliographic/authority import and export (single and batch), including overlays.
  - Record sets import/export; use as scopes for queries and basis for batch field updates and deletions.
  - Report output to display, print, email, or save (CSV, Excel, and customizable formats).
  - Scheduled execution of tasks, reports, imports, exports; jobs can be sequenced and managed.
  - External/system access through published protocols/APIs (e.g., SIP2/NCIP2) for concurrent field/record sharing.

- d) Data entities and their relationships
  - Bibliographic 1—N Item (items exemplify bibliographic records).
  - Patron 1—N Hold/Request N—1 Item (patrons place holds on items).
  - Patron 1—N CirculationTransaction N—1 Item (check-outs/returns).
  - Staff/User N—M Group/Role → Privilege (roles/groups grant privileges; governs module, data, and function access).
  - Suppression rules apply visibility constraints to Authority, Bibliographic, Order, and Item records for staff vs. OPAC.
  - Loan rules and Requesting rules evaluate Patron and Item attributes (e.g., types, counts, balances, statuses, location codes) and checkout location schedules; certain criteria are overridable by staff with specific roles.
  - RecordLock references a target record (of any type), user, location, and timestamp.
  - RecordSet contains members drawn from supported record types and can drive batch operations.
  - ReportTemplate targets specific record types/fields and may be run by staff with appropriate permissions.
  - ScheduledJob references a task (report/import/export) with owner and execution state.
  - PrinterDefinition and ClientConfiguration are referenced during output and client sessions.

- e) Integrity constraints
  - Field-level controls: default values, data validation, automatic formatting, and required fields, applicable to any field.
  - Business-rule restrictions: prevent deletion of items in checked-out status; prevent deletion of bibliographic records with existing holds.
  - Concurrency controls: simultaneous access with change detection prompts; record locking with configurable lock-duration thresholds; administrative ability to unlock records.
  - Import/overlay controls: MARC imports may overlay existing short or full bibliographic records.
  - Batch safety: batch deletions via record sets require pre-deletion review, error logging, and “undo” for one or more deletions.
  - Data recovery: logged data changes with “undo” functionality; revision control is desirable.

- f) Security
  - Role/group-based access control for individuals, workgroups, and arbitrary staff groups; administrative visibility/control of user privileges.
  - Differentiated visibility: staff (per privileges) can view all patron/item fields; patrons can access only selected fields.
  - Suppression rules govern whether authority, bibliographic, order, and item records are visible to staff and/or OPAC.
  - Fine-grained permissions for running specific reports and ad hoc queries; administrators control table/field access in the query tool.
  - Patron data is secure in all transfers; secure protocols supported for data movement (SFTP—active/passive, SSL, SSH).
  - Individual logins support an audit trail tied to user actions.

- g) Data retention requirements
  - Log files: enable/disable logging with configurable retention thresholds; email-related log retention configurable.
  - Backups: live incremental and full backups of data and transaction logs; supports third-party backup software. [N/A] (No specified backup retention periods.)
  - Revision/undo: data-change logging to support rollback/revision control. [N/A] (No specified retention period for versions/undo logs.)
  - Records: [N/A] (No explicit retention or purging policies beyond reporting counts of deleted/purged records.)

## 3.6 Design constraints

- Platform and client environment
  - Server must run on Linux or Solaris.
  - System must be accessible via a web browser or a Windows-compatible client.
  - If browser-based, must support Microsoft Internet Explorer (v6.0 and later) and Mozilla Firefox (v2.0 and later).

- Accessibility
  - Must be accessible with screen-reading software, screen-magnification software, and other assistive technologies.

- Database and data access
  - Must use a fully relational, SQL-based database backend.
  - Database must be accessible as an ODBC source, and all data tables and storage must be fully accessible.

- Web and documentation standards
  - Must produce standards-compliant HTML.
  - Online help and documentation must be web-based HTML.

- Security and transport protocols
  - Patron data must be secure in all transfers to and from the system.
  - Must support secure protocols including SFTP, SSL, and SSH; SFTP must support active and passive modes, configurable per vendor.
  - Must support SMTP for email transport.

- Monitoring and management standards
  - Must provide full support for SNMP for monitoring system resources.

- Interoperability and data exchange standards
  - Must support MARC bibliographic and authority record import/export (single and batch), including interoperability with vendors such as OCLC.
  - Must support exchange of standard-format data files such as USMARC21 and EDIFACT via published APIs and/or automated transfers.
  - Must interoperate with SIP2/NCIP2 and similar protocols and APIs.

- Access control model
  - User rights and privileges must be controlled via security groups and/or roles, enabling granular access for individuals and staff groups.

- Operational and deployment constraints
  - Must provide a development and training environment with the ability to migrate configurations to production.
  - Staff and group accounts must be independent from specific workstations.
  - All Windows printers must be supported, including receipt, standard, label, and forms printers.

- Administrative access
  - Must provide access to the root shell.
  - Must provide full access to configuration and log files, with configurable logging and retention.

- Organizational constraint
  - System administration processes are consolidated at a central location and must serve multiple branches.

## 3.7 Software system attributes

### Reliability
- Data integrity controls, including data validation, required fields, and default values for any field (REQ-5328).
- Business rules enforce consistent operations (e.g., disallow deletion of checked-out items or bibs with holds) (REQ-2445).
- Concurrent record access with prompts when a record has changed since display to prevent inconsistent updates (REQ-5323).
- Record lock identification and administration to detect and resolve sustained locks (REQ-6513, REQ-7302).
- Change logging with undo/data rollback; revision control is desirable (REQ-6505).
- Comprehensive, configurable log files that can be reviewed without stopping the system; enable/disable and retention thresholds supported (REQ-2474).
- Use of a fully relational, SQL-based database with full table accessibility and ODBC access (REQ-6512).

### Availability
- Live incremental and full backups of data and transaction logs; supports third‑party backup software (e.g., EMC NetWorker) (REQ-6502).
- Server clustering for failover capability (REQ-2462).
- System monitoring via SNMP with configurable thresholds and multi‑channel alerts (dashboard, email, text) to unlimited recipients (REQ-6501).
- Operational dashboards and consoles for performance, applications, clients, jobs, and logs to detect and remediate issues quickly (REQ-2467, REQ-2464, REQ-2430, REQ-6521, REQ-2433).
- Administrative utilities for software/server shutdown and restart (REQ-2466).
- Logs viewable without stopping the system (REQ-2474).
- Real-time processing to keep operational views current (e.g., pull lists up to date) (REQ-5615).
- Desirable ability to run searches and reports during open hours without disrupting other functions (OE-1).

### Security
- Patron data is secure in all transfers to and from the system (REQ-6510).
- Secure protocol support: SFTP (active/passive per vendor), SSL, SSH (REQ-6511).
- Role- and privilege-based access control; individual and shared staff accounts; granular visibility and control of user privileges (CO-4, REQ-2492, REQ-6509).
- Record visibility/suppression rules controlling staff/patron access in staff and public interfaces (REQ-5278).
- Read/write permissions on configuration files assignable by user/group (REQ-6517).
- Logging and auditability via configurable log files and data change logs/undo (REQ-2474, REQ-6505).
- Security details aligned to example subareas:
  1) Cryptographic techniques: SSL/SSH/SFTP for data in transit (REQ-6511).
  2) Log/history data sets: system and change logs with retention controls (REQ-2474, REQ-6505).
  3) Functional separation across modules: [N/A]
  4) Restricted communications between program areas: [N/A]
  5) Data integrity checks for critical variables: data validation and business rules (REQ-5328, REQ-2445).
  6) Data privacy: patron data secure in transfer; visibility controls via suppression rules and role-based permissions (REQ-6510, REQ-5278, CO-4, REQ-6509).

### Maintainability
- Standards-compliant HTML output (CO-2) and fully relational database backend (CO-1).
- Dedicated development and training environments with migration to production (CO-3).
- Web-based, indexed, searchable documentation specific to the deployed version (REQ-2428); upgrade/update guidelines listing new/changed/removed features (REQ-2431).
- Centralized administrative consoles/dashboards for configuration, monitoring, performance, jobs, logs, applications, and clients (REQ-6517, REQ-6501, REQ-2467, REQ-6521, REQ-2433, REQ-2464, REQ-2430).
- Central management of client software installation and updates; ability to target specific clients; support for VNC and Remote Desktop (REQ-6504).
- Server-based, exportable/importable client configurations (REQ-6519).
- Job scheduling with sequencing and administrative oversight (REQ-6507, REQ-6508).
- Keyboard macros/shortcuts centrally managed with import/export and permission controls (REQ-2220).
- Record sets to support batch operations, scoped queries, auditable deletions with error logs and undo (REQ-6518).
- Access to configuration files, log files, and root shell for administrative maintenance (REQ-2479, REQ-2474, REQ-2470).

### Portability
- Operating system: server runs on Linux or Solaris (OE-2).
- Client access: web browser (Internet Explorer v6.0+ and Mozilla Firefox v2.0+) or Windows-compatible client (OE-3, OE-4).
- Standards-compliant HTML output (CO-2).
- Database accessibility via ODBC (REQ-6512).
- SMTP support for email transport (REQ-6516).
- Accounts independent from workstations; client installs not tied to a specific location (REQ-6514).
- Sub-attributes:
  1) Percentage of elements with host-dependent code: [N/A]
  2) Percentage of code that is host dependent: [N/A]
  3) Use of a proven portable language: [N/A]
  4) Use of a particular compiler or language subset: [N/A]
  5) Use of a particular operating system: Linux or Solaris (OE-2)

## 3.8 Supporting information

The following items provide contextual information to aid interpretation of this SRS. Unless an item below is explicitly captured as a numbered requirement in Section 3 (e.g., “Req ID: 1716”), these items are informative and are not themselves requirements.

- Sample input/output formats
  - Input/import and interfaces (requirements-backed):
    - MARC bibliographic and authority records import/export (Req ID: 1716).
    - Standard-format data files exchanged with vendors, e.g., USMARC21, EDIFACT (Assumptions/Dependencies DE-2; Req ID: 1716).
    - Real-time and batch interactions via SIP2/NCIP2 and similar protocols/APIs for circulation and OPAC interactions (Req IDs: 5323; Assumptions/Dependencies DE-3).
    - Secure transfer protocols for data exchange: SFTP (active/passive), SSL, SSH (Req ID: 6511).
    - ODBC/SQL access to a fully relational database (Req ID: 6512).
  - Output/export and presentation (requirements-backed):
    - Reports to CSV and Excel, and customizable formats; display, print, email, or save (Req ID: 2197).
    - MARC record export (Req ID: 1716).
    - Printing to file on server, FTP, email, or printer; control of printed field order when applicable (Req ID: 2439).
    - Standards-compliant HTML for system-generated pages and online help (Constraints CO-2; UD-3).

- Cost analysis studies and user survey results
  - [N/A]

- Supporting or background information
  - Intended deployment scale: large, centralized, multi-branch library system (approximately 50 locations; ~20 million circulations; >500,000 items processed per year) with a preference for non-disruptive in-hours processing (OE-1).
  - Operating environment and access: Linux or Solaris server; access via web browser (Internet Explorer 6.0+ and Firefox 2.0+) or Windows-compatible client; compatible with assistive technologies (OE-2, OE-3, OE-4, OE-5).
  - Flowcharts referenced in this SRS describe current practices and are provided for context only; they are not prescriptive (Document Conventions 1.4).
  - Centralized administration is assumed; the module is part of an enterprise ILS and relies on Acquisitions, Cataloging, and OPAC components; it interfaces with vendor sites via APIs and/or standard file transfers (AS-1, AS-2, DE-1, DE-2, DE-3).
  - Documentation expectations: developer-provided data specifications, high-level process descriptions, and integrated, searchable online help (UD-1, UD-2, UD-3).
  - Audience and collaboration model: readable by non-technical stakeholders and sufficiently specific for developers; iterative, prototype-oriented development with end-user review is assumed (1.3 Intended Audience).

- Problems to be solved by the software
  - Provide centralized configuration and administration of an enterprise ILS for a large, multi-branch library system, including:
    - Configuration of features and processes for branches, patrons, collections, and circulation.
    - Monitoring, troubleshooting, and control of servers, databases, applications, services, ports, and APIs; dashboards and alerts for performance and health.
    - Management of user/group accounts, roles/privileges, and client software installation/upgrades.
    - Data protection: backups, rollback/revision control, clustering/failover.
    - Enforcement and administration of business rules (loan, requesting, suppression, validation).
    - Secure data exchange and patron data protection.
    - Querying and reporting with templates, permissions, and multiple output formats.
    - Support for concurrent record access and record lock management.
    - Scheduling and management of maintenance jobs and data workflows.

- Special packaging and media instructions (security, export, initial loading)
  - [N/A]

Normative status of this information
- Normative (part of the requirements): any item explicitly specified by a numbered requirement (e.g., Req IDs in Section 3), constraints (CO-1..), operating environment items (OE-1..), and user documentation items (UD-1..).
- Informative (not a requirement): background notes such as descriptive context, flowchart references, audience and collaboration assumptions, and any items marked [N/A].

## 4.1 Functions

### Systems: General (Reqs: 6512, 5615, 5323, 6513, 2492, 2428, 2431, 2479, 2474, 2470)
- Verification methods: inspection, analysis, demonstration, test.
- Inputs and validity checks:
  - Database connectivity parameters; verify SQL access and ODBC configuration accept only valid credentials (6512).
  - Concurrent user/session credentials and roles; validate role-based access and audit logging for individual vs. shared accounts (2492).
  - Paths/permissions for configuration and log files; verify user/group permissions (2479, 2474).
  - [N/A] for 2428, 2431, 2470 (documentation/guidelines/shell access have no input fields).
- Sequence of operations:
  - Execute SQL queries via native client and ODBC; verify end-to-end access (6512).
  - Perform check-in/check-out and list generation while observing real-time updates to pull lists and shelf tools (5615).
  - Simultaneously edit patron/item records from multiple clients; observe locking prompts and conflict resolution (5323).
  - Create, observe, and clear record locks; identify lock origin and timestamps (6513).
  - Review documentation delivery and version alignment; review upgrade guideline content and sequence (2428, 2431).
  - Enable/disable logs and adjust retention; observe without stopping system (2474).
- Responses to abnormal situations:
  - Overflow: [N/A].
  - Communication facilities: disconnect ODBC/network mid-transaction; verify graceful error reporting and no data corruption (6512, 5615, 5323).
  - Hardware faults/failures: kill client sessions; verify server stability and ability to identify/kill sessions via tools where applicable (2430 reference for later dashboards; [N/A] here).
  - Error handling and recovery: induce concurrent update conflicts; verify prompts and reasonable application of changes (5323); attempt to access restricted files and verify access denied with logged event (2479, 2474).
- Effect of parameters:
  - Role/privilege assignments change visibility and functional access (2492).
  - Log retention thresholds alter file lifecycle (2474).
  - Real-time options and cache parameters affect list freshness (5615).
- Relationship of outputs to inputs:
  - Input/output sequences: query submission → DB response via SQL/ODBC (6512); concurrent edit → prompt → save/rollback (5323, 6513).
  - Formulas for input to output conversion: [N/A].

### Systems: Consoles and Dashboards (Reqs: 6520, 6501, 7302, 2467, 2466, 2464, 2430, 6503, 6517, 2433, 6521, 6515, 6516)
- Verification methods: inspection, demonstration, test.
- Inputs and validity checks:
  - Dashboard definitions, widget selections, and sharing targets; validate user/group authorization (6520).
  - SNMP targets, thresholds, recipients, and channels; validate ranges and formats (6501).
  - Record lock thresholds and unlock selections; validate scope and permissions (7302).
  - Server/app control commands (start/stop/restart); validate authorized use only (2466).
  - SMTP host/port/auth and email config presets; validate syntax and credentials (6515, 6516).
  - Job schedules, dependencies, and cancellations; validate cron-like expressions and dependency graphs (6521).
- Sequence of operations:
  - Create dashboards → assign access → view live/historical metrics (6520).
  - Configure monitoring thresholds → trigger alert conditions → deliver alerts via dashboard/email/text (6501).
  - List locked records → unlock selection → verify state cleared (7302).
  - View process list and indicators → identify runaway processes (2467).
  - Execute server/app control actions with confirmation and status updates (2466).
  - View application metrics: backups, reboots, version, queues, log sizes, record counts, DB utilization (2464).
  - List clients and terminate sessions (2430).
  - View circulation KPIs scoped by branch/system (6503).
  - Access configuration files via single console with per-file permissions (6517); locate/log files via dashboard (2433).
  - Schedule/modify/cancel jobs; enforce dependencies (6521).
- Responses to abnormal situations:
  - Overflow: [N/A].
  - Communication facilities: simulate SNMP/SMTP outages; verify alerts/logging and retry/backoff where applicable (6501, 6516).
  - Hardware faults/failures: simulate process crash; verify detection and alerting (2467); reject unavailable server controls with clear errors (2466).
  - Error handling and recovery: invalid unlock attempts are blocked and logged (7302); invalid schedule/cron rejected with message (6521); invalid SMTP settings blocked with diagnostic (6515, 6516).
- Effect of parameters:
  - Thresholds alter alert generation (6501).
  - Scope filters alter KPI views (6503).
  - Permissions alter visibility and actions on consoles (6520, 6517, 2430).
- Relationship of outputs to inputs:
  - Input/output sequences: configure → monitor → alert; schedule → queue → execute → result (6501, 6521).
  - Formulas for input to output conversion: [N/A].

### Systems: Business Rules (Reqs: 2445, 5278, 5190, 5057, 5328)
- Verification methods: analysis, test, inspection.
- Inputs and validity checks:
  - Rule definitions for suppression, requesting, and loan rules; validate allowed fields, operators, and values (5278, 5190, 5057).
  - Default/required/format/validation attributes for fields (5328).
  - Deletion attempts against restricted states (2445).
- Sequence of operations:
  - Evaluate rules on actions: delete, check-out, renewal, hold placement; confirm evaluation order and overrides (2445, 5190, 5057).
  - Apply validation/defaults on create/edit forms (5328).
- Responses to abnormal situations:
  - Overflow: [N/A].
  - Communication facilities: [N/A].
  - Hardware faults/failures: [N/A].
  - Error handling and recovery: rule conflicts produce deterministic resolution and user-visible messages; disallowed actions are prevented and logged; staff override paths honored only where configured (2445, 5190, 5057).
- Effect of parameters:
  - Changing patron/item types, balances, statuses, owning/check-out location codes, open/closed schedules modifies permit/deny outcomes (5190, 5057).
  - Rule scoping to workgroups affects visibility (5278).
  - Field default/required/format settings alter form behavior (5328).
- Relationship of outputs to inputs:
  - Input/output sequences: submit action → rule evaluation → allow/deny → optional override → commit/abort.
  - Formulas for input to output conversion:
    - Due date = checkout timestamp + loan period adjusted by open/closed schedule (5057).
    - [N/A] for other explicit formulas.

### Systems: Data Recovery (Reqs: 6502, 6505, 2462)
- Verification methods: test, demonstration, analysis.
- Inputs and validity checks:
  - Backup job configuration (full/incremental, targets, schedules, third-party software integration) (6502).
  - Rollback/undo selection and scope; revision retrieval where available (6505).
  - Cluster membership and failover roles (2462).
- Sequence of operations:
  - Run live backups during system operation; verify data and logs are captured without service disruption; validate restore (6502).
  - Perform deletes/updates → execute undo → verify prior state restored; review revision history if present (6505).
  - Simulate node failure → verify automatic failover and continuity (2462).
- Responses to abnormal situations:
  - Overflow: test log growth under load and retention handling (6502).
  - Communication facilities: network interruption during backup; verify resume/retry or safe failure and reporting (6502).
  - Hardware faults/failures: node failure triggers failover (2462); corrupted backup media detected and reported during restore (6502).
  - Error handling and recovery: failed rollbacks report cause and leave system consistent; partial restores report and abort safely (6505, 6502).
- Effect of parameters:
  - Backup type and schedule affect window and artifacts (6502).
  - Cluster configuration affects failover behavior (2462).
- Relationship of outputs to inputs:
  - Input/output sequences: schedule → snapshot/log copy → verify → restore test (6502).
  - Formulas for input to output conversion: [N/A].

### Systems: Security (Reqs: 6510, 6509, 6511)
- Verification methods: inspection, analysis, test.
- Inputs and validity checks:
  - Secure transport settings for SFTP/SSL/SSH (6511); verify cipher/protocol selections.
  - Privilege assignments and visibility controls (6509).
  - Patron data transfer scenarios (uploads/downloads/exports) (6510).
- Sequence of operations:
  - Establish secure connections; transfer representative patron data; verify encryption in transit (6510, 6511).
  - Modify privileges; observe resultant access changes (6509).
- Responses to abnormal situations:
  - Overflow: [N/A].
  - Communication facilities: downgrade/invalid TLS handshake; verify refusal and logging (6511).
  - Hardware faults/failures: [N/A].
  - Error handling and recovery: unauthorized access attempts denied and logged; SFTP active/passive mode mismatches handled per vendor config (6511).
- Effect of parameters:
  - Role changes alter visibility/control (6509).
  - SFTP active/passive mode selection affects connectivity (6511).
- Relationship of outputs to inputs:
  - Input/output sequences: request → authenticate → authorize → perform action → audit (6509, 6511).
  - Formulas for input to output conversion: [N/A].

### Systems: Maintenance (Reqs: 1716, 6518, 2420, 2419, 6507, 6508, 2220)
- Verification methods: test, inspection, demonstration.
- Inputs and validity checks:
  - MARC import/export batch definitions, field selections, overlay options, vendor targets (1716).
  - Record set definitions; import/export members; batch update selection (6518).
  - Account templates and privilege granularity for staff/patron creation; required/validated fields (2420, 2419).
  - Job definitions, sequences, and permissions (6507, 6508).
  - Macro/shortcut definitions, scopes, and permissions (2220).
- Sequence of operations:
  - Import MARC (single/batch) → optional overlay → verify records; export with selected fields to vendors (1716).
  - Create record sets → run batch field updates → delete with preview/logging/undo (6518).
  - Create accounts via templates → verify defaults, validations, and privilege scoping (2420, 2419).
  - Schedule jobs, including “start B after A” dependencies; modify/cancel prior to start; admin view/manage others’ jobs (6507, 6508).
  - Define macros/shortcuts → deploy centrally → import/export to users; enforce permissions (2220).
- Responses to abnormal situations:
  - Overflow: large batch imports/exports handled without failure; log truncation policies verified (1716, 6518).
  - Communication facilities: vendor transfers fail; verify retry/failure logs (1716).
  - Hardware faults/failures: job interruption mid-execution yields clear status and safe resume/re-run (6507).
  - Error handling and recovery: invalid MARC rejected with diagnostics; batch updates produce error logs and support undo (1716, 6518); unauthorized job scheduling/actions blocked and logged (6508).
- Effect of parameters:
  - Overlay and field selection options alter import/export outcomes (1716).
  - Record set scopes limit operations (6518).
  - Template configurations alter defaulted/required fields (2420, 2419).
  - Permissions constrain job and macro capabilities (6508, 2220).
- Relationship of outputs to inputs:
  - Input/output sequences: define → validate → execute → review logs/results.
  - Formulas for input to output conversion: [N/A].

### Systems: Client Management (Reqs: 6514, 6504, 6519)
- Verification methods: test, demonstration, inspection.
- Inputs and validity checks:
  - Account authentication independent of workstation identity; client installation not tied to location (6514).
  - Target client lists and update packages; remote management tool settings (6504).
  - Server-based client configuration export/import selections (6519).
- Sequence of operations:
  - Login from multiple workstations to verify independence (6514).
  - Push updates to selected clients; manage via VNC/Remote Desktop; verify streaming updates (6504).
  - Export/import configurations; apply to clients (6519).
- Responses to abnormal situations:
  - Overflow: [N/A].
  - Communication facilities: network loss during update; verify rollback/retry/reporting (6504).
  - Hardware faults/failures: client crash during update; verify safe state and recovery (6504).
  - Error handling and recovery: reject invalid configuration packages; log failures (6519).
- Effect of parameters:
  - Client selection scoping controls rollout (6504).
  - Server-based configurations govern client behavior (6519).
- Relationship of outputs to inputs:
  - Input/output sequences: select → deploy → apply → confirm (6504, 6519).
  - Formulas for input to output conversion: [N/A].

### Systems: Queries and Reports (Reqs: 2197, 5624, 5607, 5617, 2465, 2441, 2439)
- Verification methods: test, inspection, analysis.
- Inputs and validity checks:
  - Query field selections, value picklists, regex choices, Boolean operators; table/field access controls (5624).
  - Report template definitions and availability to staff (5607).
  - Permissions to run reports/ad hoc queries on specific data sets (5617).
  - Report formatting/output target selection (CSV, Excel, custom), and printer selection (receipt/standard/label/forms) with Windows printer enumeration (2197, 2441).
  - Print-to-file/FTP/email/printer options; field selection and order (2439).
  - Record number report access controls (2465).
- Sequence of operations:
  - Build queries → execute → view results; enforce access controls (5624, 5617).
  - Use templates → run/modify → distribute outputs (5607, 2197).
  - Generate record number report with counts and deletions/purges (2465).
  - Select printer/output; print or deliver via FTP/email (2441, 2439).
- Responses to abnormal situations:
  - Overflow: large result sets paginated or exported without failure; printing large jobs handled or queued (2197, 2439).
  - Communication facilities: FTP/email delivery failures logged with clear errors and no data loss (2439).
  - Hardware faults/failures: printer offline → clear error surfaced and job recoverable/re-routable (2441).
  - Error handling and recovery: invalid query syntax or unauthorized field/table usage blocked with diagnostics; insufficient permissions prevent execution (5624, 5617).
- Effect of parameters:
  - Template selection affects default layouts; user modifications affect appearance (5607, 2197).
  - Printer type selection affects formatting (2441).
  - Field selection/order affect printed/exported output (2439).
- Relationship of outputs to inputs:
  - Input/output sequences: define query/report → validate → execute → render/print/export.
  - Formulas for input to output conversion: [N/A].

## 4.2 Performance requirements

This section defines the planned approaches to verify performance requirements in parallel with the performance-related items specified in the Requirements. Verification will use analysis, inspection, demonstration, and test (functional, load, stress, and soak) in representative environments. Instrumentation will include system and application logs, SNMP-based monitoring, and the administrative dashboards provided by the system (e.g., system performance dashboard and application dashboard).

General metrics to be captured across tests:
- Transaction latency (mean, 95th/99th percentile), throughput, and error rate
- Resource utilization (CPU, memory, disk I/O, network I/O), process health, and queue depths
- Lock/contension statistics (rate, duration, timeouts)
- Evidence of service disruption (timeouts, failed requests, forced logouts)
- Impact of background jobs (backups, reports, imports/exports) on interactive workload

Verification by requirement:

- OE-1 Operating environment capacity and continuity
  - Methods: Capacity sizing analysis; load and soak tests simulating 50 locations and annual workloads consistent with 20 million circulations and processing of 500,000 items; concurrent search and report execution during “open hours.”
  - Evidence: Measured throughput and latency for circulation, search, and account operations; resource headroom during sustained load; absence of service disruption while searches/reports run.
  - Acceptance: Numeric thresholds [N/A]; demonstrate stable operation without functional disruption during concurrent operations.

- REQ-5615 Real-time processing
  - Methods: End-to-end latency tests for exemplar workflows (e.g., pull lists currency at view/print time; live shelf reading/weeding correctness) under nominal and peak concurrent activity.
  - Evidence: Event-to-visibility latency distributions; correctness of displayed lists versus current database state.
  - Acceptance: Maximum/percentile latency targets [N/A]; no stale results at time of viewing/printing.

- REQ-5323 Field and record sharing (simultaneous access)
  - Methods: Concurrency tests with mixed clients (staff workstations, self-checks via SIP2/NCIP2, OPAC) simultaneously reading/updating patron and item records; induced update conflicts.
  - Evidence: Successful concurrent operations; presence and correctness of conflict prompts; lock wait times; absence of deadlocks and lost updates.
  - Acceptance: Supported concurrent user count and lock-wait thresholds [N/A]; zero data loss; graceful conflict handling.

- OE-1 Searches and reports during open hours without disruption; REQ-5624 Query tool; REQ-2197 Report format/output; REQ-2465 Record number report
  - Methods: Execute large ad hoc and templated queries/reports (display, print, email, save to CSV/Excel) while sustaining representative circulation and patron activity; include worst-case filters and joins.
  - Evidence: Report/query completion times; impact on interactive transaction latency; system responsiveness on dashboards.
  - Acceptance: Performance targets for completion times and latency impact [N/A]; no unplanned service degradation or timeouts.

- REQ-6502 System backup (live incremental and full)
  - Methods: Run incremental and full backups (including via third-party software such as EMC NetWorker) during simulated open hours at normal and peak workloads.
  - Evidence: Backup success logs; transaction success rate and latency during backup windows; resource utilization; absence of service interruption.
  - Acceptance: Allowed performance impact and downtime limits [N/A]; backups complete successfully without disrupting interactive operations.

- REQ-1716 MARC import/export (batch) performance
  - Methods: Batch import/export tests of bibliographic and authority records (single and large batches), including overlay scenarios and OCLC interactions where applicable.
  - Evidence: Records-per-second throughput; error/reject rates; verification of overlays; no adverse impact on concurrent interactive activity.
  - Acceptance: Throughput and error-rate thresholds [N/A]; completed batches with accurate results.

- REQ-6518 Record sets (batch operations)
  - Methods: Execute batch field updates, scoped queries, deletions with pre-review, error logging, and undo on large record sets while system is under load.
  - Evidence: Operation completion times; correctness (logs, sampling); undo success; system responsiveness.
  - Acceptance: Duration and impact thresholds [N/A]; zero unintended data modification; successful undo where invoked.

- Cross-cutting instrumentation and observability (supports verification above; REQ-2467 System performance dashboard; REQ-6501 System monitoring)
  - Methods: Configure dashboards and SNMP to collect time-synchronized metrics and alerts; set alert thresholds to capture anomalies during tests.
  - Evidence: Time series of key metrics; alert logs; correlation of workload to performance behavior.
  - Acceptance: Monitoring coverage adequate to diagnose performance issues; alert delivery verified; numeric alert thresholds for acceptance [N/A].

Notes:
- Where the original SRS does not define numeric limits (e.g., explicit user counts, latency/throughput targets), acceptance thresholds are marked [N/A]. In such cases, verification will produce measured baselines and evidence of non-disruption under specified mixed workloads to support stakeholder acceptance.

## 4.3 Usability requirements

The following verification activities qualify the usability and quality-in-use aspects of the System Administration Module. Each item aligns with a usability-related requirement from the SRS. Where measurable effectiveness, efficiency, satisfaction, or harm-avoidance criteria are not specified in the SRS, this is noted as [N/A].

- OE-5 Accessibility (access via assistive technologies)
  - Methods: Assistive-technology compatibility testing using screen-reading software, screen-magnification software, and other assistive programs; confirm end-to-end operability of core administrative workflows with these tools.
  - Criteria: [N/A]

- UD-3 Online help system (hierarchical, cross-linked HTML help describing all functions)
  - Methods: Inspection of help content and structure; verify hierarchy, cross-linking, HTML delivery, and coverage of all system functions with illustrative content.
  - Criteria: [N/A]

- Req 2428 System documentation (library- and version-specific; web-based, indexed, organized by function, searchable)
  - Methods: Document review; verify version tagging, library-specific content, indexing, functional organization, and search results for representative queries.
  - Criteria: [N/A]

- Req 2467 System performance dashboard (visual status indicators; identify runaway processes)
  - Methods: UI inspection and demonstration; confirm presence and meaning of visual indicators (e.g., green/red lights) and display of required process attributes; trigger and observe identification of a runaway process in a controlled environment.
  - Criteria: [N/A]

- Req 5624 Query tool (user-friendly interface with field selection, picklists, regex, Boolean; admin-controlled access)
  - Methods: Task-based usability test and demonstration; construct queries using field selection, picklists, regex from drop-down, and Boolean operators; verify administrator control of table/field access.
  - Criteria: [N/A]

- Req 5607 Report templates (admin-created templates usable/modifiable by staff)
  - Methods: Role-based demonstration; create a template as admin; run as-is and with modifications as staff.
  - Criteria: [N/A]

- Req 2197 Report format and output (custom layout; display/print/email/save to CSV/Excel/custom formats)
  - Methods: Functional demonstration; configure custom layouts; export to each specified format; display, print, and email sample reports.
  - Criteria: [N/A]

- Req 2441 Printer support (define/select receipt, standard, label, forms printers; support all Windows printers)
  - Methods: Configuration and print-path tests across the four printer types with representative Windows printers; verify selection and output integrity.
  - Criteria: [N/A]

- Req 2439 Multiple print output options (print to server file, FTP, email, or printer; select and order fields)
  - Methods: End-to-end output tests for each channel (file/FTP/email/printer); verify field selection and ordering in output.
  - Criteria: [N/A]

- Req 2220 Keyboard macros and shortcuts (admin/user-programmable; shortcut keys; centralized management; import/export; permission restrictions)
  - Methods: Create and assign macros/shortcuts; import/export between users; verify central server management and permission-based usage/editing restrictions.
  - Criteria: [N/A]

- Req 6503 Circulation dashboard (KPIs with branch/systemwide scoping)
  - Methods: UI demonstration; validate display of specified KPIs and scope toggling between single-branch and systemwide views.
  - Criteria: [N/A]

- Req 6520 Dashboard configuration (custom dashboards; access control to selected users/groups)
  - Methods: Create dashboards with selected widgets; assign and verify access for specific users/groups.
  - Criteria: [N/A]

- Req 2433 Log-file dashboard and Req 2474 Log file access (locate/view logs; enable/disable; retention settings; review without stopping system)
  - Methods: Demonstration and configuration inspection; locate and view logs, toggle logging, adjust retention thresholds, and review logs during live operation.
  - Criteria: [N/A]

- Req 6517 Configuration file console (single console; per-file read/write permissions)
  - Methods: UI inspection; open/edit configuration files; verify permission enforcement by user/group.
  - Criteria: [N/A]

- Req 6521 Job scheduling console; Req 6507 Job scheduling; Req 6508 Job scheduling: management (single interface; sequence jobs; modify/cancel; admin visibility/control of staff-scheduled jobs)
  - Methods: Schedule, sequence, modify, and cancel jobs via the console; verify administrative visibility and control over staff-scheduled jobs.
  - Criteria: [N/A]

- Req 2430 Client management console (list clients; names/IPs; manage/kill sessions)
  - Methods: UI demonstration; verify client enumeration (name/IP) and ability to terminate sessions.
  - Criteria: [N/A]

- Req 6515 Email configuration and Req 6516 SMTP support (quick menu of common settings; SMTP transport)
  - Methods: Configuration inspection; adjust common settings (e.g., masquerading, log retention, bounce handling) via quick menu; send test messages via SMTP.
  - Criteria: [N/A]

- Req 5323 Field and record sharing (simultaneous access; prompts when a record changed since display)
  - Methods: Multi-user concurrency test; have two users edit the same record and verify presence and clarity of change/conflict prompts before committing.
  - Criteria: [N/A]

- Req 6513 Record lock management and Req 7302 Record lock administration (identify lock location/user/time; list sustained locks; unlock from console)
  - Methods: Lock records intentionally; verify display of lock metadata; list long-held locks; unlock selected records from the administration console.
  - Criteria: [N/A]

## 4.5 Logical database requirements

This section defines the planned verification approaches for the logical database requirements, organized to parallel the information items a)–g).

a) Types of information used by various functions
- Scope from SRS:
  - Record types and related artifacts: authority, bibliographic, item, patron, order, invoice, hold/request (UD-1; REQ-1716, REQ-2465, REQ-6518).
  - Administrative data and artifacts: configuration files and log files (REQ-2479, REQ-2474, REQ-6517), scheduled jobs (REQ-6507, REQ-6508, REQ-6521).
- Verification methods:
  - Documentation inspection: Verify existence and completeness of data specifications for all record types (UD-1).
  - Functional tests:
    - MARC import/export of bibliographic and authority records, including overlay behavior (REQ-1716).
    - Record set creation, import/export, and batch operations on sets (REQ-6518).
    - Record number reports across record types (REQ-2465).
  - Cross-module rule execution: Exercise requesting, loan, and suppression rules reading necessary fields (REQ-5190, REQ-5057, REQ-5278).
- Evidence: Approved data specification set, import/export logs and samples, executed report outputs showing record counts, executed rule results.

b) Frequency of use
- Scope from SRS:
  - Real-time processing expectations (REQ-5615).
  - Simultaneous access to patron and item records across staff/self-check/SIP2/NCIP2 interfaces (REQ-5323).
  - Record lock visibility/administration (REQ-6513, REQ-7302).
  - Scale context: 50 locations; high annual circulations (OE-1).
- Verification methods:
  - Concurrency testing: Simulate simultaneous updates and reads across staff clients, self-check, and SIP2/NCIP2 endpoints; verify conflict handling and prompts (REQ-5323).
  - Lock contention testing: Hold records, verify lock discovery, timeout/threshold behavior, and administrative unlock (REQ-6513, REQ-7302).
  - Load testing: Execute mixed read/write workloads at volumes aligned with OE-1; confirm real-time data freshness in representative functions (e.g., pull lists, shelf reading) (REQ-5615).
- Evidence: Load/concurrency test plans and results, lock audit listings, timing and freshness metrics.
- Explicit quantitative frequencies: [N/A]

c) Accessing capabilities
- Scope from SRS:
  - Fully relational SQL database; run SQL against any table; ODBC access; full table accessibility (REQ-6512).
  - Query tool with field selection, regex, and Boolean operators; administrator control of table/field access (REQ-5624).
  - Report generation and export formats (REQ-2197); report permissioning (REQ-5617).
- Verification methods:
  - Connectivity tests: Establish ODBC connectivity; execute representative SQL on each table (REQ-6512).
  - Functional query tests: Build and run queries using UI features (picklists, regex, Boolean), and verify administrator-imposed access limits (REQ-5624).
  - Reporting tests: Generate customizable layouts; export to CSV/Excel; verify permission-scoped access to data/report execution (REQ-2197, REQ-5617).
- Evidence: ODBC connection logs, executed SQL samples, screenshots/outputs from query and report runs, permission matrices and test results.

d) Data entities and their relationships
- Scope from SRS:
  - Entities: authority, bibliographic, item, patron, order, invoice, hold/request (UD-1; REQ-1716, REQ-2465).
  - Relationship expectations implied by business rules (e.g., items linked to bibliographic records; holds linked to bibliographic/item and patron) (REQ-2445, REQ-5190, REQ-5057).
- Verification methods:
  - Schema review: Compare delivered schema to provided data specifications for entities and expected relationships (UD-1).
  - Referential integrity tests:
    - Attempt prohibited deletes (e.g., delete checked-out items; delete bibliographic records with outstanding holds) and confirm enforcement (REQ-2445).
    - Validate foreign keys via targeted queries showing child/parent counts across key relationships.
- Evidence: Approved schema review checklist, executed constraint tests with results, sample ER review notes.
- Complete ER model details: [N/A]

e) Integrity constraints
- Scope from SRS:
  - Business rule enforcement for delete restrictions (REQ-2445).
  - Requesting, loan, and suppression rules for operational constraints and overrides (REQ-5190, REQ-5057, REQ-5278).
  - Field-level defaults, validation, formatting, required status (REQ-5328).
  - Record sharing with conflict prompts; record lock management (REQ-5323, REQ-6513, REQ-7302).
  - Data rollback/undo; revision control if provided (REQ-6505).
- Verification methods:
  - Rule testing: Execute positive/negative cases for requesting/loan/suppression rules, including staff override pathways (REQ-5190, REQ-5057, REQ-5278).
  - Validation testing: Create/update records to verify defaults, required fields, and formatting enforcement (REQ-5328).
  - Concurrency/conflict testing: Simulate concurrent edits; verify change prompts, lock visibility, and administrative unlock (REQ-5323, REQ-6513, REQ-7302).
  - Rollback testing: Perform deletes/updates and validate undo and, if available, revision history (REQ-6505).
- Evidence: Test case matrix and results, audit/log entries, screenshots of enforced constraints and overrides.

f) Security
- Scope from SRS:
  - Patron data secure in transit (REQ-6510).
  - Secure protocols SFTP/SSL/SSH with active/passive SFTP as configured (REQ-6511).
  - Role/privilege controls for users, reports, and configuration files (REQ-2492, REQ-6509, REQ-5617, REQ-6517).
  - Visibility controls via suppression rules (REQ-5278).
- Verification methods:
  - Transport security validation: Packet inspection to confirm encryption on patron data flows; protocol negotiation checks for SSL/TLS and SFTP modes (REQ-6510, REQ-6511).
  - Access control testing: Verify least-privilege access to tables/fields, reports, and configuration files; test role-based elevation and auditability (REQ-2492, REQ-6509, REQ-5617, REQ-6517).
  - Visibility testing: Confirm that suppression rules hide/show records appropriately in staff and OPAC contexts (REQ-5278).
- Evidence: Security test reports, protocol capture excerpts, access control test logs, visibility test outcomes.

g) Data retention requirements
- Scope from SRS:
  - Log file retention thresholds; enable/disable; viewable without stopping system (REQ-2474).
  - Backup/restore for data and transaction logs; support for third-party tools (REQ-6502).
  - Rollback/undo for data changes (REQ-6505).
  - Record deletion/purge reporting (REQ-2465).
  - Job scheduling for maintenance tasks (REQ-6507, REQ-6508, REQ-6521).
- Verification methods:
  - Log retention tests: Configure retention thresholds; generate logs to rollover; verify availability during runtime and correct purging (REQ-2474).
  - Backup and restore drills: Execute full and incremental backups; perform representative restores using supported tooling (REQ-6502).
  - Retention/purge evidence: Use record number reports before/after purge operations; verify audit entries and ability to rollback where specified (REQ-2465, REQ-6505).
  - Scheduling tests: Schedule, sequence, run, modify, and cancel retention-related jobs; verify administrative visibility and control (REQ-6507, REQ-6508, REQ-6521).
- Evidence: Backup/restore logs, retention configuration snapshots, purge reports, job execution histories.
- Explicit business data retention periods/policies: [N/A]

## 4.6 Design constraints

- CO-1: Fully relational, SQL-based database back-end
  - Methods: architecture/design review of DB selection and documentation; schema inspection to confirm relational modeling; execution of representative SQL queries (read/write) against all core tables; verification of ODBC data source exposure and successful connection from a Windows client; confirmation that all data tables are accessible as specified.
  - Evidence: review report, query logs/screenshots, ODBC connectivity test results, table access matrix.

- CO-2: Standards-compliant HTML output
  - Methods: automated validation of representative UI pages and help content using a W3C HTML validator; static analysis for prohibited/nonstandard tags/attributes; cross-browser spot checks focused on standards conformance (rendering equivalence) for pages generated by the system.
  - Evidence: validator reports (no errors of blocking severity), review checklist, screenshots from sampled pages.

- CO-3: Separate development and training environments with migratable configurations to production
  - Methods: environment audit to confirm distinct dev/training/prod instances; witnessed end-to-end migration exercise of representative configurations (export from dev/training, import/apply to a production-like environment); post-migration parity check of settings; rollback drill to verify recovery capability if migration fails.
  - Evidence: environment inventory, migration procedure and logs, pre/post configuration comparisons, rollback test report.

- CO-4: Access control via security groups/roles for individuals, workgroups, and arbitrary staff groups
  - Methods: security model review to confirm role/group constructs; administrative UI/API tests to assign privileges at individual, workgroup, and arbitrary staff group levels; positive/negative access tests to verify allowed/denied module access aligns with assigned roles; attempt privilege changes to confirm only authorized administrators can modify role assignments.
  - Evidence: role/permission configuration snapshots, test user matrices with results, administrative action logs.

## 4.7 Software system attributes

### Reliability — verification
- Concurrency control and conflict handling
  - Related requirements: 5323 (field and record sharing), 6513 (record lock management), 7302 (record lock administration)
  - Method: test and demonstration with concurrent patron/staff sessions updating the same records; administer locks via console; attempt unlocks
  - Acceptance criteria: conflict prompts appear when records change after display; current locks are listed with location/user/timestamp; authorized staff can unlock one/many records; no data corruption observed

- Real-time processing behavior
  - Related requirements: 5615 (real-time processing)
  - Method: test by generating check-in/out, pull lists, and shelf-reading/weeding operations while observing views/prints
  - Acceptance criteria: lists and views reflect current data at time of viewing/printing; latency threshold: [N/A]

- Backup integrity (live incremental/full) and restore
  - Related requirements: 6502 (system backup), 2464 (application dashboard)
  - Method: test and analysis by running live incremental and full backups (including with a third-party tool, e.g., EMC NetWorker), then perform restore to a test instance
  - Acceptance criteria: backup jobs complete; application remains operational during backup; successful restore yields complete and consistent data; performance impact threshold: [N/A]

- Data rollback / revision control
  - Related requirements: 6505 (data rollback)
  - Method: test by creating, updating, and deleting records, then invoking “undo”/rollback; verify revision history if present
  - Acceptance criteria: pre-change state restored for each tested operation; revision history maintained if implemented; scope/limits of rollback: [N/A]

- Failover capability
  - Related requirements: 2462 (server clustering)
  - Method: fault-injection test by simulating node/process failure
  - Acceptance criteria: clustered node(s) assume service without manual data repair; switchover time objective: [N/A]

- Monitoring, logging, and alerting
  - Related requirements: 6501 (system monitoring/SNMP), 2467 (system performance dashboard), 2474 (log file access), 2433 (log-file dashboard)
  - Method: test by configuring thresholds, inducing CPU/memory/disk events; verify dashboard indicators; verify alerts via dashboard/email/text; view logs while system is running; adjust log retention
  - Acceptance criteria: alerts are generated and delivered over configured channels; dashboards reflect current status; logs are viewable without stopping system; log retention is configurable; maximum recipients tested: [N/A]

- Configuration management accessibility
  - Related requirements: 2479 (configuration file access), 6517 (configuration file console)
  - Method: inspection and test by locating and editing configuration via the single console; assign per-file permissions
  - Acceptance criteria: authorized users can read/write designated configuration files; unauthorized users cannot; change takes effect per product design (restart/hot-reload as applicable)

- Quantitative reliability targets (e.g., MTBF): [N/A]

### Availability — verification
- Controlled restart and recovery operations
  - Related requirements: 2466 (server console), 2464 (application dashboard)
  - Method: demonstration by performing software/server shutdown and restart using provided utilities; review dashboard history (last backups/reboots/upgrades)
  - Acceptance criteria: shutdown/restart utilities execute successfully; dashboard reflects most recent events; state integrity preserved

- Scheduled operations management
  - Related requirements: 6521 (job scheduling console), 6507 (job scheduling), 6508 (job scheduling: management)
  - Method: test by creating, sequencing (“start B after A”), modifying, and cancelling jobs; verify that admin can view/manage jobs scheduled by others
  - Acceptance criteria: jobs execute per schedule/sequence; modifications and cancellations honored when made prior to start; admin visibility/control of others’ jobs works

- Operations during maintenance
  - Related requirements: 6502 (live backups), 6504 (client software updates), OE-1 (non-disruptive processing desirable)
  - Method: test by running backups and targeted client updates under representative load; monitor service continuity
  - Acceptance criteria: no service outage observed during tested maintenance windows; quantitative availability level/RTO/RPO: [N/A]

- Target availability percentage: [N/A]

### Security — verification
- Secure transport protocols
  - Related requirements: 6511 (secure protocol support), 6510 (patron data security)
  - Method: test and analysis by configuring SFTP (active/passive per vendor), SSL/TLS, SSH; verify with network capture/endpoint configuration
  - Acceptance criteria: all tested data transfers occur over encrypted channels; SFTP active/passive modes function as configured per vendor; required algorithms/cipher strengths: [N/A]

- Role- and privilege-based access control
  - Related requirements: CO-4 (roles), 6509 (user account privileges), 2492 (individual/shared staff logins), 6517 (configuration file console permissions)
  - Method: test by creating roles/privileges, assigning to individual and shared accounts; attempt access to restricted modules/files; verify admin visibility/control of privileges
  - Acceptance criteria: access restricted per role; admins can view and change user/group privileges; per-file read/write permissions enforced; auditability for individual logins present per product capability

- Patron and staff data visibility
  - Related requirements: 5323 (field/record sharing), 5278 (suppression rules)
  - Method: test by attempting to view/update records as patron and staff with varying privileges; configure suppression rules and observe visibility in staff and OPAC interfaces
  - Acceptance criteria: patrons see only allowed fields; staff visibility aligns with privileges; suppression rules enforce configured visibility scopes

- Logging and audit controls
  - Related requirements: 2474 (log file access), 2433 (log-file dashboard), 2492 (audit trail for individual logins)
  - Method: test by performing privileged operations and reviewing logs; set and verify retention thresholds; view logs without stopping system
  - Acceptance criteria: actions are logged with sufficient context (user, time, action); retention can be configured; logs accessible during operation

- Email configuration security
  - Related requirements: 6515 (email configuration), 6516 (SMTP support)
  - Method: inspection and test by configuring SMTP and common settings (masquerading, log retention, bounce handling); send test messages/alerts
  - Acceptance criteria: email transport works via SMTP; configured settings persist and are effective

- Data at rest protection; integrity checks for critical variables; enforced module separation; restricted inter-module communications; specified cryptographic algorithms/strengths: [N/A]

### Maintainability — verification
- Product and user documentation
  - Related requirements: 2428 (system documentation), 2431 (upgrade guidelines), UD-1, UD-2, UD-3 (user documentation/help)
  - Method: inspection
  - Acceptance criteria: web-based, indexed, searchable documentation specific to deployed version; upgrade notes list new/changed/removed features; data specifications and high-level process descriptions provided; online hierarchical cross-linked help available

- Environment separation and migration
  - Related requirements: CO-3 (development/training environment and migration)
  - Method: demonstration by configuring features in non-production and migrating to production
  - Acceptance criteria: configurations migrate successfully to production with no functional loss

- Configuration and log manageability
  - Related requirements: 2479 (configuration file access), 6517 (configuration file console), 2474 (log file access), 2433 (log-file dashboard)
  - Method: inspection and test by locating/editing configs via single console, setting permissions; viewing logs and adjusting retention
  - Acceptance criteria: centralized access to configs/logs; permissions enforced; logs viewable during operation; retention configurable

- Client lifecycle management
  - Related requirements: 6504 (client software updates), 6519 (client configurations), 6514 (accounts independent from workstation), 2430 (client management console)
  - Method: test by streaming updates to selected clients, importing/exporting configurations, managing/killing client sessions; remote management via VNC/Remote Desktop
  - Acceptance criteria: targeted clients receive updates; configurations are server-based and portable; sessions manageable remotely

- Macros and automation
  - Related requirements: 2220 (keyboard macros and shortcuts)
  - Method: test by creating, importing/exporting, assigning shortcuts, and enforcing permissions
  - Acceptance criteria: macros function as configured; central management and permission restrictions are effective

- Batch record operations
  - Related requirements: 6518 (record sets)
  - Method: test by creating record sets, performing batch field updates, deletions with pre-review, error logging, and undo
  - Acceptance criteria: all listed batch capabilities operate correctly; errors logged; undo reverses deletions

- Modularity/complexity/interface limits for maintainability: [N/A]

### Portability — verification
- Supported operating environments
  - Related requirements: OE-2 (Linux or Solaris server)
  - Method: installation and operational tests on Linux or Solaris
  - Acceptance criteria: full system functionality demonstrated on at least one supported OS; portability to other OS: [N/A]

- Client access and browser compatibility
  - Related requirements: OE-3 (web-browser or Windows-compatible client), OE-4 (IE ≥6.0, Firefox ≥2.0), CO-2 (standards-compliant HTML)
  - Method: test by accessing via specified browsers and Windows-compatible client; validate HTML against standards
  - Acceptance criteria: all functions accessible/rendered; HTML passes standards validation; other browsers/versions: [N/A]

- Database connectivity and openness
  - Related requirements: 6512 (SQL-based database with ODBC; SQL query access)
  - Method: test by connecting via ODBC, enumerating tables, and executing queries
  - Acceptance criteria: ODBC connectivity succeeds; SQL queries executable against any table; full table access available as specified

- Printing and export formats
  - Related requirements: 2441 (printer support), 2439 (print output options), 2197 (report format/output)
  - Method: test by defining printers, printing to server file/FTP/email/printer, and exporting to CSV/Excel; customize report layouts
  - Acceptance criteria: all output modalities succeed; report layout customization works

- Host-dependence metrics (percent host-dependent code; language/compiler subset use; OS neutrality targets): [N/A]

## 5.1 Assumptions and dependencies

- The System Administration Module is part of an enterprise-level Integrated Library System (ILS).
- System Administration processes are centralized at a single location and serve multiple branches/locations.
- The module relies on the data structures and functionality of the enterprise ILS, including Acquisitions and Cataloging modules.
- The module interacts with the patron interface (OPAC).
- The module interfaces with vendor websites and services via published APIs and/or automated exchange of standard-format data files (e.g., USMARC21, EDIFACT).
- The requirements presuppose the general data structures and functionality of a full-fledged ILS.
- The target operating environment will provide Linux or Solaris servers and access via a web browser or a Windows-compatible client; if browser-based, Microsoft Internet Explorer v6.0+ and Mozilla Firefox v2.0+ will be available; assistive technologies (e.g., screen readers, screen magnifiers) will be available.
- The library context is a large, multi-branch system (approximately 50 locations, ~20 million circulations annually, ~500,000 items purchased/processed per year), and searches/reports may run during open hours without disrupting other functions.
- External standards and protocols used by connected systems and devices will be available in the environment, including:
  - MARC bibliographic and authority exchange with vendors such as OCLC.
  - Circulation and self-service device protocols (e.g., SIP2/NCIP2).
  - Email transport via SMTP.
  - Secure transfer and access protocols (e.g., SFTP in active/passive modes, SSL, SSH).
  - System monitoring via SNMP.
- Third-party backup software (e.g., EMC NetWorker) may be employed and will be available if selected.
- Remote client management tools (e.g., VNC, Remote Desktop) are permitted and available in the network environment.
- Development and refinement of data structures and user interfaces will occur through a collaborative, iterative, prototype-oriented process with end-user participation.

## 5.2 Acronyms and abbreviations

- ACQ: [N/A]
- API: Application Programming Interface
- CAP: [N/A]
- CIR: [N/A]
- CPU: [N/A]
- CSV: [N/A]
- EDIFACT: [N/A]
- FTP: [N/A]
- HTML: [N/A]
- ILS: Integrated Library System
- IP: [N/A]
- ITS: [N/A]
- MARC: [N/A]
- MGT: [N/A]
- NCIP2: [N/A]
- ODBC: [N/A]
- OCLC: [N/A]
- OPAC: Online Public Access Catalog
- SIP2: [N/A]
- SFTP: [N/A]
- SNMP: [N/A]
- SQL: [N/A]
- SRS: Software Requirements Specification
- SSH: [N/A]
- SSL: [N/A]
- SMTP: [N/A]
- USMARC21: [N/A]
- VNC: [N/A]