AspenTech Inmation Backup

Overview

AspenTech Inmation stores all information relating to the models, namespaces and object configuration in the image files. It is possible to restore the full system using these files themselves or a system backup.

Three image files are created for each AspenTech Inmation running service (Core, Connector, Server etc.) with different functions and file suffixes in the img folder under the AspenTech\inmation.root directory. It is sufficient to recover only the system image files for the Core service (either the Central Core or a Local Core), as the configuration of a connected Server, Connector, or other distributed service is also stored (as primary) in the Core configuration.

The image files are described in Table 1:

Table 1. Image file types
Image File Type File suffix Description

Image file

*.inimg

The image file contains all the data regarding the system configuration including model trees and object configurations. A backup of the image file should be created regularly to provide data security in the event of any hardware failure or system corruption. Note: the image file does not contain historical data for objects, only configuration data.

Fingerprint file

*.infp

The fingerprint file contains other contextual data needed by the image. When restoring the system from the image file, it is necessary to also have a copy of the fingerprint file.

Image (last known good image)

*.inlkg

The “last known good” image file is a snapshot of the system image in its last known good state. This file can be used to restore the system if the main image file is corrupted or doesn’t work properly.

Backups by Component

Master Core

Back up the Master Core’s image files, either automatically or manually, as described on this page.

Local Core, Interface, Connector, Relay

These do not need to be backed up. Backing up local cores is optional but might be convenient for some recovery scenarios. Other component configurations are implicit in the stored configuration of the Central and Local Core.

Service image files

The most important image files are the Core image files. The Core image stores all the system data for all services from the last time they were connected and can create the appropriate Connector or Server image file in the appropriate locations on restart of the services. The Connector and Server image files are important if there is disruption between the Core and Connector/Server communication, as configuration changes for disconnected remote services will not be recorded in the Core image. If disruption is expected, it is prudent to maintain image backups for remote components as well as the Core image. For disaster recovery purposes, it is assumed there will not be enough disruption between Core and dependent components to warrant individual service component backup.

Note that in a Master-Local Core system, the Master Core image file contains ALL of the configuration for the complete distributed system (Connectors, Servers, Relays, Local Cores, Local Connectors, Local Servers). Therefore, it is possible to recover any system component from the latest Master service image file, assuming the Master has maintained connection to all components.

Persistency database files

Dynamic property values of objects under components are persisted to database files in the AspenTech\inmation.root\work directory. This allows for the last dynamic value to be read back after service restart following an unexpected shutdown. The persistency database files should also be regularly backed up if you do not wish to lose any dynamic property values. Each component has its own persistency database file called dynprop.db stored in the db folder of the appropriate component folder in the work directory. For example the persistency database file for the Core component can be found at AspenTech\inmation.root\work\core\db\. The frequency at which dynamic values of an object are persisted to the database file is configured under Archive Options of the object, using the Persistency Mode property.

Creating image backups

Manual

Backups of image files can be created manually by simply making copies of the image files to a new location.

syslib.dumpimg (IaC)

As part of the IaC functionality, each Core has a Core Logic entry for Backup that schedules the Lua-based backup for the AspenTech Inmation files every 24 hours (at 02:00 UTC). The backups are postfixed with the (numeric) day of the week to persist a 7 day rolling backup in the AspenTech\inmation.root backup directory (e.g. D:\AspenTech\inmation.root.P\backup).

During IaC installation, this script is called:

local DEP = require 'esi-deploy'
-- ... set other variables ...
DEP:INIT_BACKUP_LOGIC({
	ioPath = coreLogicPath,
	diskPath = diskFolder,
	retentionMode = DEP.BackupRetentionMode.WEEKLY
})

This creates a Scheduler Item called Backup Schedule, which runs the script of the Action Item Run Backup Task:

local triggerValue = syslib.getvalue("trigger")
if triggerValue == true then
	syslib.sleep(5000)
	local DAT = require "esi-datetime"
	-- <filenameLOC>

	syslib.dumpimage("<filePath>" .. filename)
	return "ok"
else
	local selfValue, selfQ, selfT = syslib.getvalue(syslib.getselfpath())
	if selfValue == nil then
		return "ok, waiting for initial execution", 0, syslib.currenttime()
	else
		return selfValue, selfQ, selfT
	end
end

<filePath> is replaced with the actual value of the parameter diskPath when INIT_BACKUP_LOGIC was called.

The line of code <filenameLOC> depends on the retention mode:

local filename = "backup" .. DAT:WEEKDAY(syslib.now()) -- weekly retention
local filename = "backup" -- daily retention

syslib.backup IMAGE Files

Image backups can also be made using the Lua interface by using the internal syslib.backup library (library is called at the beginning of the script using the require command). The IMAGE() backup function will create backups of the image file, the fingerprint file and the persistency database file (containing persisted dynamic property values for the component). The function requires a valid path, including a name for the image dump file, to create backup files. The IMAGE function is called using the Lua : notation. For example:

local backup = require('syslib.Backup')
backup:IMAGE("D:/backups/core_backup_img")

This will create an image, fingerprint and persistency file in the D:/backups directory. These will be named:

core_backup_img.inimgdump
core_backup_img.infpdump
core_backup_img.dbdump

These commands are designed to create backups of the Core’s image and fingerprint files, so the scripts should be run in a Core context i.e. by objects directly beneath the Core. If the script is run at the Connector level (or context), then the Connector image, fingerprint and persistency database backups will be created.

If the filename already exists, it will be overwritten by the Lua command with the image files. If no filename is provided, then an error message will be displayed alerting you to enter a filename as well as a directory path. If the directory path is not valid, an error message will also be returned.

To restore these image dump files, follow the steps in Restore, remembering to rename the image and fingerprint files appropriately (e.g. to core.inimg and core.infp).

The Backup script should be configured to run periodically to take a regular backup of the image files, and the script can be easily adapted to include, for example, the date or day of the week so that multiple images are maintained.