Configuration Settings

Engine's configuration system is in transition. Prior to the 2015 release, configuration settings were defined as constants in the code itself, and could only be set in a configuration file or via a callback to custom code provided to set them.

2015 introduced the ability to configure settings for a tenant, package, or registration. The listing of settings below will note the most specific level at which a particular setting may be configured.

Note: "special", "base", and "system" all indicate a setting that must be set system-wide, for all tenants. The difference between them is the possible methods of initializing the setting. If you are just setting them in your configuration file, you don't have to think about this difference.

System-level settings can be configured via a settings file in Engine. Your Engine delivery includes a template for this file.

• For .NET, the configuration file (SCORMEngineSettings.config) should be referenced by your web.config file.
• for Java, the configuration file (SCORMEngineSettings.properties) should be placed in your web server's classpath.

For each of tenant, course, and registration, Engine supplies a /configuration resource in the API, as per the API documentation.

To make use of /configuration, you will need to supply a setting ID. See below for a list of setting IDs configurable via the API.

API Configuration Example

One of the most common default Engine behaviors that is overridden is SCO launch type.

Here are examples of requests that could be used to set this at each of tenant, course, and registration in the default tenant with a course ID of "RusticiGolf" and registration ID "RusticiGolf-JoeLearner":

• tenant: /default/configuration/PlayerScoLaunchType
• course: /default/courses/RusticiGolf/configuration/PlayerScoLaunchType
• registration: /default/registrations/RusticiGolf-JoeLearner/configuration/PlayerScoLaunchType

In each case, the body of the PUT request would look something like this:

{"value":"FRAMESET"}

Required Configuration Settings

In order for Engine to run, you must fill out a small number of configuration settings. First, there are a few URL-based settings that you will need to fill out with the web path you configure on your server. We recommend searching the configuration template for instances of "/ScormEngineInterface" and replacing it with the web path, starting with ScormEngineUrl.

Apart from the URL settings, there are a few others that will need to be provided manually:

• DataPersistenceEngine: The type of database server you are using to support Engine. Acceptable values are provided in the configuration settings template.
• SystemDatabaseConnectionString: The connection string to use to connect to your system database. (If your application uses a separate database for Engine's system and tenant schemas, you will need to set a connection string to use for the tenant tables instead in TenantDatabaseConnectionString. Tenancy is further described elsewhere in this manual.)
  • In .NET installations, you can set this to ${connectionStrings.connectionStringName}, which will be replaced at runtime with the associated connection string from the .NET connectionStrings web.config section (in this case the connection string with the name connectionStringName).
• RedirectOnExitUrl: This is a URL setting, but it is unlikely you will want to keep the provided default. The value of the setting should probably be a URL to a user dashboard page on your LMS.
• ApiBasicSystemAccounts: A set of basic auth "accounts" specifying different API users for the system. The setting takes the form of username:password[:role] (the role is optional). At this moment, the only valid role is root. For more information about API authentication, see: API Authentication
• WebPathToContentRoot: The web path (URL) to the directory that is hosting the course files. If you're hosting the content on the same domain as Engine, then you can exclude the domain in your URL (i.e. "/path/to/content/root").

If you're importing courses into Engine via zip files, then you will also need to specify the following settings. If you're only importing courses by passing the path to the manifest file, then you do not need to set them.

• FilePathToUploadedZippedPackage: The folder on your filesystem where Engine can store the zip files of your packages while they are being imported. This setting should be a writable directory, and it is preferably one that is not exposed by your web server. Keep in mind that Engine does not automatically delete anything from this folder, so if storage space becomes a concern, you may need to periodically delete the older files. At the same time, be careful not to delete any newly created files, as they may still be in use by Engine's import process.
• FilePathToContentRoot: The path to the folder on your filesystem where Engine will keep the contents of the imported packages. When Engine unzips an imported course, it will save the unpacked files into this folder. This folder must be hosted at the web address specified by WebPathToContentRoot.

FilePathToContentRoot and WebPathToContentRoot are good examples of settings that might be set on a per-tenant basis. That can be done via the API or with the special tenant syntax.

Finally, there are two necessary settings if you want to use xAPI:

• SystemHomepageUrl: This should be an absolute URL to the homepage of your service/LMS. This setting is used to identify actors within the context of your application, including the "system"-level actor sometimes used as an Asserter.
• xAPIFilesPath: xAPI requires the filesystem to store certain kinds of data (viz., large documents and statement attachments). This setting should point to some writeable directory on your filesystem where Engine can store these files.

Replacement

Some settings are likely to have finer grained requirements but might not be set via the API, such as RedirectOnExitUrl. This presents a possible use case for a special ${RegistrationId} replacement token available in Engine. So, for example, if you set RedirectOnExitUrl, which would look like this in SCORMEngineSettings.config:

<add key="RedirectOnExitUrl" value="http://example.org/lms?registrationId=${RegistrationId}" />

then your app would have the registration ID available to it when Engine redirected on exit.

It is also possible to do replacement based on ${TenantName}, see below.

Special Tenant Syntax

Many configuration settings can be specified on a per-tenant basis. When getting a tenant-specific configuration setting, Engine will check for the setting prefixed by the lower-case tenant name and a dot. If found, the value of that entry will be used; if not, the value of the non-prefixed setting will be used.

For example, your LMS might have 5 tenants: AcmeCo, BusinessPlus, MaximumProfit, MoneyCorp, and SolutionsInc. If the first three use connection string database=a;password=secret; and the last two use connection string database=b;password=secret, then you can include the following two entries in your configuration file:

<add key="DataPersistenceEngine" value="sqlserver"/>
<add key="SystemDatabaseConnectionString" value="database=system;password=secret;"/>
<add key="TenantDatabaseConnectionString" value="database=a;password=secret;"/>
<add key="moneycorp.TenantDatabaseConnectionString" value="database=b;password=secret;"/>
<add key="solutionsinc.TenantDatabaseConnectionString" value="database=b;password=secret;"/>

Alternatively, you may use the ${TenantName} token for settings which you want to vary by tenant, but the only difference is the tenant name. For example, you could keep each tenant's content under a different path:

<add key="WebPathToContentRoot" value="/courses/${TenantName}">
<add key="FilePathToContentRoot" value="C:\inetpub\wwwroot\courses\${TenantName}"/>

These examples use the .NET configuration file format, but the principle still holds for Java-style configuration.

File Stores

The following configuration settings may be set either to a directory, or to a file store configuration.

• xAPIFilesPath
• FilePathToContentRoot
• FilePathToUploadedZippedPackage

File store configurations are for storing files using systems like Amazon S3 that are impractical to mount as a filesystem. Any implementation of RusticiSoftware.ScormContentPlayer.Logic.DataAccess.FileStorage.IStreamingFileStore can be used, and Engine ships with built-in support for S3. The syntax for setting up a file store is: Full.Class.Name|Assembly.Name, stringArg1, stringArg2, etc. Each argument specified will be passed in order to the constructor for the specified class.

On Java |Assembly.Name should be omitted.

To use Engine's S3 support, specify the class: RusticiSoftware.ScormContentPlayer.Logic.DataAccess.FileStorage.S3StreamingFileStore, and the following parameters:

• AWS Key
• AWS Secret
• AWS region
• bucket
• prefix

For Example:

RusticiSoftware.ScormContentPlayer.Logic.DataAccess.FileStorage.S3StreamingFileStore|RusticiSoftware.ScormEngine, AWS_key, AWS_secret, us-east-1, rustici-tests,bsctest-content/${TenantId}/

Note:

• ${TenantId} is included in the prefix. This is crucial for multi-tenant installations. Engine does not examine the parameters passed in to verify a unique store is set up for each tenant, it's up to you to make sure a unique file store location is established for each tenant.
• When content is stored on something like S3, cross-domain restrictions still apply, so a proxy solution (such as CloudFront) is needed.

Content Authentication (CloudFront support)

Engine supports adding content authorization cookies via ContentAuthCookieFactory. We provide an implementation for use with Amazon CloudFront. To use Engine's CloudFront support, specify the class 'RusticiSoftware.ScormContentPlayer.Logic.Utilities.CloudFrontCookieFactory`, and the following parameters:

• path to private key .pem file
• key pair id
• seconds for which authorization is valid

Example for CloudFront authorization cookies that will expire in 8 hours:

RusticiSoftware.ScormContentPlayer.Logic.Utilities.CloudFrontCookieFactory, /fullpath/to/privatekey.pem, keyPairId, 480

Note:

• When using content authorization cookies, ideally CourseDirectoryNamingMethod should be set to ApiCourseId and all content would be imported via the API. If not, most content will work properly but Engine will be unable to calculate the appropriate path for multi-AU AICC content (and authorization cookies will not be set for such content).
• Cross-domain cookies cannot be set. So even if other cross domain issues are solved, the content must be served from the same domain as Engine.

Player (Course) Settings

We've been implementing learning standards for more than a decade. So we know where the specifications are vague, incomplete, and/or frustrating. And we've worked hard to design Engine to work around those moments as much as possible. This is why player settings (previously called package properties) exist.

Player Settings are settings associated with each course imported into Engine that give you fine-grained control over specific conformance-related and interface behaviors.

Caution for Upgraders: It's best not to mix the "Package Property Editor" (PPE) with the new configuration system settings mentioned above. Setting the associated configuration setting, even at the system level, will override any such value set in the PPE.

Settings

Each setting is defined as follows:

SettingIdentifier (level [, default: defaultValue])

description of setting

The level is the most specific level at which the setting may be configured. Settings may always be configured at a lower (less specific) level, If a setting is configured at multiple levels, the most specific level will be used.

From less specific to most, the levels are:

• system (including base and special)
• tenant
• package
• registration

If you aren't sure if you should be changing a particular setting or not, or what you should set it to, please go ahead and ask us. This is not a complete listing of the available configuration settings, though it does include everything we expect new customers might want to change. We will continue to improve this listing as we move settings over to using the new system.

Xapi Settings

xAPIEnabled (system, default: true)

xAPIMaxRequestSizeInBytes (system, default: 5242880)

The maximum number of bytes to accept in an xAPI request before returning an error. The default is 5 mebibytes.

xAPIObjectStoreRepairs (system)

Some customers who upgraded to Engine 2015.1 from earlier versions of Engine and were using xAPI may experience bugs arising from the keys in the upgraded object store not matching the scheme used in 2015.1 and later. Setting this allows customers to fix this issue by automatically searching for certain objects based on the location they would have had in 2014. The valid choices here are UriHashCase and DocumentHashCase. Both options should be enabled for Java customers with this problem; only UriHashCase is necessary for .NET customers. In both cases, be sure to consult with Engine support before enabling, so we can confirm this problem applies to you.

xAPIEnablePublicEndpoint (system, default: false)

If set, allows unauthenticated access to a public xAPI endpoint.

Lrs Settings

SystemHomepageUrl (tenant)

The absolute URL of the canonical, permanent, homepage for this system. Ideally this really is the homepage a user would use to access the system, but this must be canonical and permanent: that is, it is a single URL the system can be identified by. This setting is required for xAPI, in order to create actor objects for users in the system. It is also used to construct activity IDs during SCORM to xAPI conversion.

xAPIFilesPath (tenant, default: RusticiSoftware.ScormContentPlayer.Logic.DataAccess.FileStorage.NullStreamingFileStore)

The root path or file store (see file stores) where xAPI Files (attachments and large documents) will be stored.

HashContentFilesForActivityId (tenant, default: true)

Specifies whether or not non-xAPI content files should be hashed to generate an activity ID during import. If true, then all of the files in the content directory are hashed to generate the activity ID. If false, then only the manifest file is hashed.

xAPIValidations (tenant, default: AttachmentContentTransferEncoding, SignatureContentType, NoUnexpectedParameters, IdenticalDocumentsCanConflict, StatementSchemaValidation, NewDocumentsRequireETag)

xAPI validations that are required to pass the conformance test (and indeed to conform to xAPI), but were not present in prior releases of Engine. These should be left on if possible, but are provided as a setting to enable non-conforming requests to work if needed.

xAPIPostProcessContextParameters (tenant, default: top , left , content_token , width , content_endpoint , height, Content-Length)

Only relevant if TinCanPostProcessContext is overriden, or as a way to consume extraneous parameters so they are not flagged as 'unexpected'. Comma-delimited, case sensitive list of xAPI parameters to pass to the TinCanPostProcessContext integration method requestParameters collection. This is needed because xAPI requires us to consider any unexpected parameters an error, so if an integration uses parameters from the xAPI call it needs to declare that usage. The default value contains extra parameters the combination of the Engine player and the TinCan launch process recomendation typically cause to be sent.

EnableExistingActivityIdParserWarnings (tenant, default: true)

When enabled (default), parser warnings will be generated during import of packages with activities that are either already mapped to a package, or recorderd in the LRS.

xAPIMaxDocumentSizeForDatabaseInBytes (tenant, default: 64000)

Setting that determines the max number of bytes to put into a DB for a document before trying to store the document in a file store. Unfortunately, documents stored in the database must be kept entirely in memory, and so it is advantageous to put larger documents in the filestore, which supports streaming (low memory usage).

LrsAuth Settings

LrsAuthCallbackMaxCacheSize (tenant, default: 500)

The number of cache entries at which to obliterate the auth callback cache to prevent excessive memory usage.

LrsAuthCallbackUrl (tenant)

Call back URL that will provide basic auth authorization. Will convert username:password@hostname to basic authentication if provided.

LrsAuthCacheSecondsSuccess (tenant, default: 1800)

The default amount of time to cache a successful LRS auth callback. Can be overridden via auth callback response for each individual request if necessary

LrsAuthCacheSecondsFailure (tenant, default: 60)

The default amount of time to cache an unsuccessful LRS auth callback. This value acts as a timeout that will prevent multiple quick requests (eg, DoS) to the callback page should there be an issue connecting or getting a response.

xAPIBasicAccounts (tenant)

A set of xAPI accounts can be optionally specified. To use one of these accounts, the same username and password must be sent over HTTP basic auth to the xAPI endpoint. These should be separated by newlines, and must be of the form username:password:role. The roles are as follows:
* user : typical, default permissions, allowing the account to assert any statement, and read only those statements they have asserted or play some role in
* read-only : allowed to read all statements and state documents, but not write anything
* write-only : allowed to write any statement or xAPI document, but not read anything
* root : allowed to read and write any statement or xAPI document

Api Settings

ApiAlternateIdDelimiter (system, default: ~)

A delimiter that may be used instead of | when passing External IDs to API calls, since | can be a problem in URL paths.

ApiRoot (system, default: /api/)

The root path (under the main application path) for the API (before the API version).

NancyConsolePassword (system)

Password for the Nancy Diagnostic Console (/ScormEngineInterface/_Nancy). Leave blank to disable. (.NET only)

ApiImportResultsPostBackUrl (tenant)

Specifies a URL to which to post import results, will convert username:password@hostname to basic authentication if provided.

ApiPostbackProcessorSleepSeconds (system, default: 300)

How long to sleep between checking for postback tasks to retry (note: the first try is always immediate, either by being synchronous or by triggering an async check of the queue.)

ApiResultLimit (system, default: 100)

Maximum number of items to return in a list at once.

ApiResultLimitSinceNotSpecified (system, default: 10)

Maximum number of items to return in a list at once when the 'since' parameter is available and not used. The only reason since is not a required parameter is to make testing the API easy, and long lists are not required for that.

ApiDoNotCheckAuthentication (base, default: false)

For use when API authentication will be handled by a proxy or other software outside of Engine. All API calls will be allowed, IsAllowed() will not be called.

ApiBasicSystemAccounts (system)

A set of basic auth "accounts" comprising different API users for the system. The setting takes the form of `username:password[:role]` (the role is optional). At this moment, the only valid role is `root`.

ApiBasicTenantAccounts (tenant)

A set of basic auth "accounts" comprising different API users for a particular tenant. The setting takes the form of `username:password[:role]`, where the role is optional. At this moment, the only valid role is `tenant`.

ApiTokenSecret (tenant)

Secret used to sign tokens generated by the API, currently used in signed launch links. If the string starts with '0x' the remainder will be interpreted as hexidecimal.

ApiTokenPostbackValidHours (tenant, default: 24)

Number of hours the token used to authenticate SCORM runtime postbacks (when using signed launch links) is valid.

ApiUseSignedLaunchLinks (tenant)

If enabled, launch links generated by the API will be signed, and only signed launch links will be accepted by the player (so launch links must be generated via the API).

ImportLinkLocation (system, default: defaultui/import)

The path to the import page used when you have generated an import URL to POST to.

DefaultImportRedirectLocation (system, default: defaultui/defaultredirect)

Default redirect URL to redirect to after import via `defaultui\import` page if none was supplied.

ApiConfigurationSystemTenantName (base)

Tenant name to use with the API to allow configuring system settings via `/{tenant}/configuration` (by using the 'system tenant'). Note: to avoid confusion, this tenant can not be used anywhere else.

ApiRollup Settings

ApiRollupRegistrationPostBackUrl (registration)

Specifies a URL to which to post activity and status data within an interval in which dirty data is available or as soon as possible when the course is completed.

ApiRollupRegistrationSynchronous (registration, default: true)

The initial attempt to post registration data will occur synchronously as the course is being completed.

ApiRollupRegistrationAuthType (registration, default: httpbasic)

Indicates how to authorize against the given postbackurl, can be 'form' or 'httpbasic'. If form authentication, the username and password for authentication are submitted as form fields 'username' and 'password', and the registration data as the form field 'data'. If httpbasic authentication is used, the username and password are placed in the standard Authorization HTTP header, and the registration data is the body of the message. This field is set to 'httpbasic' by default.

ApiRollupRegistrationAuthUser (registration)

User name to use when posting registration data.

ApiRollupRegistrationAuthPassword (registration)

Password to use when posting registration data.

ApiRollupRegistrationFormat (registration, default: activity)

Level of detail in the information that provided when posting registration data. It may be one of three values: 'course' (course summary), 'activity' (activity summary, or 'full' (full detail), and is set to 'activity' by default. The information will be posted as JSON, using the schemas for the registration /progress or /progress/detail resources depending on the format selected, with an additional wrapper specifying the registration ID.

ApiPostbackTimeoutSeconds (tenant, default: 10)

Timeout in seconds for API rollup registration postback.

ApiRollupRegistrationDuringSession (registration, default: true)

Should rollup registration postbacks be sent during a learning session, instead of waiting for the learner to exit?.

Database Settings

SystemDatabaseEnabled (base, default: true)

Should the system database be used? Note: if disabled, features that use system wide queues such as PENS and xAPI pipes will not work. Multiple tenants per DB are not supported without a system database. This setting must be set as desired upon initial installation of Engine, changing it on a existing system is likely to result in data loss.

SystemDatabaseConnectionString (base)

The connection string to use when connecting to the system schema

DatabaseSchema (base)

The DBMS-level schema to use when connecting to the database. At this moment, it is not possible to specify different tenant and system DBMS schemas.

TenantDatabaseConnectionString (tenant) (default: SystemDatabaseConnectionString)

The connection string to use when connecting to the tenant schema

DataPersistenceEngine (base)

A string (`sqlserver`, `mysql`, `postgresql`, or `oracle`) corresponding to the DBMS flavor in use.

DatabaseTimeoutSeconds (base, default: 60)

The timeout (in seconds) to set on database operations. This setting applies only to .NET.

DatabaseRetryCount (base, default: 3)

The number of retries we should attempt an database action when contending for shared locks.

MaxPersistableStringLength (base, default: 2500000)

The maximum string length (in characters) to allow through to the database.

TenantIdLength (base, default: 2)

The length, in bytes, of the tenancy field in the database

Upsert Settings

MaxRowsPerDatabaseUpsert (system, default: 1)

The maximum number of rows we should send in a single datbase upsert (merge) statement. Set to 0 for no limit.

MaxParametersPerDatabaseUpsert (system, default: 2100)

The maximum number of parameters to include in a single database upsert/merge statement. Set to 0 for no limit. The default of 2100 is based on limits inherent to SqlServer.

AttemptInsertBeforeUpsert (system, default: false)

If true, attempt to use inserts before upserts. This can result in a signficant performance gain in systems where inserts would generally be expected to succeed, such as the Engine upgrade tool.

Tenancy Settings

TenancyEnabled (system, default: true)

AllowedTenantNames (system)

A comma- and/or whitespace-delimited string enumerating all valid tenant names that, if given, prevents tenants with names not contained therein from being created. Note that this setting does not prevent previously-created tenants from being accessed; this setting only restricts what new tenants can be created.

AllowedTenantNameRegex (system)

A regular expression matching only allowed tenant names that, if given, restricts tenant creation to only those names that match. This setting uses the .NET reguandlar expression language (even on Java). If AllowedTenantNames is also given, it will be checked first, and only names not matched there will be validated against this regex. Note that this setting does not prevent previously-created tenants from being accessed; this setting only restricts what new tenants can be created.

ProxiedRequests Settings

ForwardedHost (system)

The original (before proxying) value of the "Host" header field in Engine requests (i.e. the targeted host of a request at its origin). As with the "Host" HTTP header, this value may come with a port number appended.

ForwardedProtocol (system)

The original (before proxying) protocl used to send requests to Engine. If the Engine server is behind an SSL Offloading proxy, this value will likely be HTTPS.

ExternalIdSerialization Settings

EnableExternalIdEncryption (system)

If enabled, external IDs will be encrypted after serialization and decrypted before deserialization. Requires either that IntegrationEncryptionPassword is set or that the Encrypt and Decrypt methods of the integration be overridden.

IntegrationEncryptionPassword (system)

If EnableExternalIdEncryption is set to true (and the default Encrypt/Decrypt implementations are used), this setting gives the secret key used for external ID encryption.

Misc Settings

ValidateManifestsUsingXsd (tenant, default: true)

Whether to additionally validate manifests using an XML parser as well as the ScormEngine validation

DefaultCommCommitFrequency (system, default: 10000)

WebPathToContentRoot (tenant)

A web path (URL) pointing to the directory that is hosting your course content. If you're hosting the content on the same domain as Engine, then you can exclude the domain in your URL (i.e. "/path/to/content/root").

WebPathToContentRootHistory (tenant)

A list of historical values used for WebPathToContentRoot, which allows the launch links of packages uploaded when these historical values were in effect to be updated so as to reflect the current value. These entries are not required to be in historical order.

ContentAuthCookieFactory (tenant)

For generating cookies to allow access to content. Definition for an 'ICookieAuthFactory' implementation. Format: 'full.class.name|assembly.name, constuctorarg1, arg2, arg3' (assembly name is not needed for Java, or where class is in RusticiSoftware.ScormEngine). Engine provides an implementation for Amazon CloudFront. Example for CloudFront authentication cookies that will expire in 8 hours: 'RusticiSoftware.ScormContentPlayer.Logic.Utilities.CloudFrontCookieFactory, /fullpath/to/privatekey.pem, keyPairId, 480'

UserCountReportEnabled (system)

UserCountReportDaysBetweenReports (system, default: 30)

How many days to wait before reporting a user count after the last time user count was reported.

UserCountReportCustomerId (system, default: unknown)

A unique Engine customer identifier provided by Rustici Software.

UserCountReportTargetUrl (system, default: https://cloud.scorm.com/engineUserCount)

Where will the user count report be sent?

UserCountReportMaxOffsetMS (system, default: 3600000)

The maximum number of MS to offset the time to send the next report by (actual amount is a random number up to this value). It should not be necessary to change this value except for testing.

UserCountReportContractPeriodEndDate (system, default: 12/31/2015)

In order to ensure taking a user count as soon as possible at the end of each contract period, note the end of the contract period

UserCountReportLookBackDays (system, default: 365)

How long is the contract period (and therefore the range to report usage for).

SimpleQueueRetryInitialDelaySeconds (system, default: 600)

How long to mark tasks as ineligible for processing when picking them up. This time will be doubled after each retry.

SimpleQueueMaxTries (system, default: 8)

How many times to attempt a queued item before giving up. Note that the last retry will have a delay of 2^n * SimpleQueueRetryInitialDelaySeconds

ApiPostbackProcessorMaxBatchSize (system, default: 10)

Maximum number of rollup registration tasks to dequeue for processing at once.

FilePathToContentRoot (tenant)

The path to the directory or file store (see file stores) where uploaded and unzipped files should be placed.

FilePathToUploadedZippedPackage (tenant)

The path or file store (see file stores) where uploaded zip files should be placed. In a future release this may be used to allow different Engine instances to receive an upload and process the import, but for now there is no reason this shouldn't just be set to a temporary directory on the local file system.

RedirectOnExitUrl (registration)

The URL the application should redirect to when the learner exits a course

UseModernPlayer (registration, default: true)

If true (default), uses modern player. If false, uses legacy player. Regardless of this configuration setting, either can be overridden by the `player` query string parameter (`player=legacy` or `player=modern`)

DefaultModernPlayerTheme (registration, default: default)

The modern player theme to use unless otherwise specified in the launch URL.

WhenToRestartRegistration (registration, default: WHEN_EXISTING_REG_IS_COMPLETE_AND_NEWER_PACKAGE_VERSION_EXISTS)

Determines whether or not to restart a registration when launching it.

AllowedRequests (system)

Comma delimited whitelist of non-API request types that are allowed (see documentation for SecureMethod enum for valid entries). Leaving this blank allows all requests.

AiccSessionPerLaunch (system, default: false)

If true, the AICC session ID will be created for each launch, and only valid until that launch session has terminated. Otherwise sessions will be precreated for a registration and valid as long as that registraiton exists.

UpdateRunTimeDataLockExpireSeconds (system, default: 10)

How many seconds to lock the registration for when updating SCORM runtime data. Specifying 0 disables registration locking.

UpdateRunTimeDataLockWaitSeconds (system, default: 11)

How long to wait for a lock on the registration when updating SCORM runtime data.

CourseDirectoryNamingMethod (tenant, default: UploadName)

For import via the API, determines whether to use the file name of zip being uploaded (UploadName) or the API course ID + version (ApiCourseId) when naming the directory imported courses are to be placed in.

ManifestDirPathAcceptedRegex (system)

This regex will be used to check the manifestDirPath in a preview launch. If the manifestDirPath matches this regex, then the manifest will be downloaded and validated. Otherwise preview launch will throw an exception. By default this setting is empty, meaning that nothing will be accepted and preview launch will always throw an exception.

ConfigurationCache Settings

ConfigurationCacheMaxEntries (base, default: 2000)

The number of cache entries at which to clear the configuration cache to prevent excessive memory usage. This includes an entry for each tenant and package referenced. (Registration specific configuration items are not cached.) Set to 0 to disable caching.

ConfigurationCacheSeconds (base, default: 60)

The number of seconds before cached configuration settings expire. Note that for multi web server installations, it may take up to this long for setting changes to be applied, except for registration settings that are not cached. Setting to zero will disable time-based expiration, but the cache will still clear itself if it reaches a size of ConfigurationCacheMaxEntries.

ConcurrentLaunch Settings

ConcurrentLaunchDetectionEnabled (registration, default: true)

Enable or disable concurrent launch detection.

ConcurrentLaunchDetectionHistoryRows (registration, default: 5)

The number of launch history entries to load when detecting concurrent launches.

LaunchHistoryExpiration Settings

ShouldExpireLaunchHistory (tenant, default: false)

If true, purge old launch history entries when adding new ones. This can potentially save a lot of DBMS storage space.

ExpireLaunchHistoryAfterDays (tenant, default: 30)

The minimum number of days that should pass before purging a launch history entry.

xApiStatementPipe Settings

xAPIStatementPipeEnabled (system, default: false)

If true, enable the statement pipe feature.

xAPIStatementPipeSleepTimeMilliseconds (system, default: 10000)

When no pipes are ready to be processed, the statement pipe thread will sleep for this many milliseconds.

xAPIStatementPipeCooldownMilliseconds (system, default: 60000)

The minimum amount of time, in milliseconds, that the statement pipe thread will wait to poll an endpoint for new statements after running out of new statements.

xAPIStatementPipeMaxBackoffHours (system, default: 24)

When piping statements, we may encounter an error when calling the API of either LRS. If we do, we retry after a set amount of time, that doubles with each successive failure. This value sets a maximum amount of time (in hours) we will wait between retries. If 0 is given, there is no maximum.

xAPIStatementPipeBatchSize (system, default: 500)

The maximum number of statements that we will send at a time when using the statement pipe feature.

xAPIStatementPipeWebTimeoutMilliseconds (system, default: 10000)

The timeout, in milliseconds, we will use when sending GET and POST requests to the LRSes involved in a statement pipe. This number is set fairly high by default to accomodate batches involving many attachments.

xAPIStatementPipeLockTimeSeconds (system, default: 600)

The amount of time, in seconds, a given machine can lock a statement pipe for exclusive use. This value should encompass the 'clock drift' between machines and any delays due to possible slow connections or failed timeouts.

Player Settings

PlayerShowFinishButton (registration, default: UNDEFINED)

Specifies whether the interface should show a button that allows the learner to return to the LMS

PlayerShowCloseItem (registration, default: UNDEFINED)

Specifies whether the interface should show a button that allows the learner to exit the SCO

PlayerShowHelp (registration, default: UNDEFINED)

Specifies whether the interface should show a help button

PlayerShowProgressBar (registration, default: UNDEFINED)

Specifies whether the interface should show a progress bar

PlayerUseMeasureProgressBar (registration, default: UNDEFINED)

Specifies whether the interface should determine progress bar progress using Measure Rollup or individual SCO completion.

PlayerShowCourseStructure (registration, default: UNDEFINED)

Specifies whether the interface should show the course outline to the learner

PlayerCourseStructureStartsOpen (registration, default: UNDEFINED)

Specifies whether the interface should show the course outline when the course loads or if it should initially be collaspsed and hidden. Only valid if ShowCourseStructure is true.

UseLegacyMobileFramesetBehavior (registration, default: true)

Determines how to handle mobile launches. When set to true, then Engine will use the old behavior (where forceFrameset is needed to do a frameset launch, and SuppressNavbarWhenForcedFrameset is needed to hide the navbar). When set to false, mobile launches will be treated the same way as desktop launches.

PlayerShowNavBar (registration, default: UNDEFINED)

Specifies whether the interface should show the navigation bar containing buttons like Prev, Next, Exit, etc

PlayerShowTitleBar (registration, default: UNDEFINED)

Specifies whether the interface should show the title bar containing the name of the package being delivered

PlayerEnableFlowNav (registration, default: UNDEFINED)

Specifies whether the interface should allow the learner to use Previous and Next navigation elements to go through the course

PlayerEnableChoiceNav (registration, default: UNDEFINED)

Specifies whether the interface should allow the learner to choose specific parts to the course to take in any order from the course outline

PlayerDesiredWidth (registration)

The number of pixels in width the course would like to have available, if possible, during delivery.

PlayerDesiredHeight (registration)

The number of pixels in height the course would like to have available, if possible, during delivery.

PlayerDesiredFullScreen (registration, default: UNDEFINED)

Specifies that the course is best experienced when it occupies the full screen.

PlayerRequiredWidth (registration)

The number of pixels in width the course must occupy to function correctly.

PlayerRequiredHeight (registration)

The number of pixels in height the course must occupy to function correctly.

PlayerRequiredFullScreen (registration, default: UNDEFINED)

Specifies that the course must be experienced in full screen mode to function correctly.

PlayerCourseStructureWidth (registration)

Specifies the default width in pixels for the course outline when shown.

PlayerScoLaunchType (registration)

Specifies how the individual parts of the course should be launched

PlayerLaunchType (registration)

Specifies how the player as a whole should be launched for this course.

PlayerIntermediateScoSatisfiedNormalExitAction (registration)

The navigation behavior the SCP should display when a SCO that has been satisfied in the middle of a course exits with an exit type of normal.

PlayerIntermediateScoSatisfiedSuspendExitAction (registration)

The navigation behavior the SCP should display when a SCO that has been satisfied in the middle of a course exits with an exit type of suspend.

PlayerIntermediateScoSatisfiedTimeoutExitAction (registration)

The navigation behavior the SCP should display when a SCO that has been satisfied in the middle of a course exits with an exit type of timeout.

PlayerIntermediateScoSatisfiedLogoutExitAction (registration)

The navigation behavior the SCP should display when a SCO that has been satisfied in the middle of a course exits with an exit type of logout.

PlayerIntermediateScoNotSatisfiedNormalExitAction (registration)

The navigation behavior the SCP should display when a SCO in the middle of a course that has not been satisfied exits with an exit type of normal.

PlayerIntermediateScoNotSatisfiedSuspendExitAction (registration)

The navigation behavior the SCP should display when a SCO that has not been satisfied in the middle of a course exits with an exit type of suspend.

PlayerIntermediateScoNotSatisfiedTimeoutExitAction (registration)

The navigation behavior the SCP should display when a SCO that has not been satisfied in the middle of a course exits with an exit type of timeout.

PlayerIntermediateScoNotSatisfiedLogoutExitAction (registration)

The navigation behavior the SCP should display when a SCO that has not been satisfied in the middle of a course exits with an exit type of logout.

PlayerFinalScoCourseSatisfiedNormalExitAction (registration)

The navigation behavior the SCP should display when a SCO at the end of the course that has been satisfied exits with an exit type of normal.

PlayerFinalScoCourseSatisfiedSuspendExitAction (registration)

The navigation behavior the SCP should display when a SCO at the end of the course that has been satisfied exits with an exit type of suspend.

PlayerFinalScoCourseSatisfiedTimeoutExitAction (registration)

The navigation behavior the SCP should display when a SCO at the end of the course that has been satisfied exits with an exit type of timeout.

PlayerFinalScoCourseSatisfiedLogoutExitAction (registration)

The navigation behavior the SCP should display when a SCO at the end of the course that has been satisfied exits with an exit type of logout.

PlayerFinalScoCourseNotSatisfiedNormalExitAction (registration)

The navigation behavior the SCP should display when a SCO at the end of the course that has not been satisfied exits with an exit type of normal.

PlayerFinalScoCourseNotSatisfiedSuspendExitAction (registration)

The navigation behavior the SCP should display when a SCO at the end of the course that has not been satisfied exits with an exit type of suspend.

PlayerFinalScoCourseNotSatisfiedTimeoutExitAction (registration)

The navigation behavior the SCP should display when a SCO at the end of the course that has not been satisfied exits with an exit type of timeout.

PlayerFinalScoCourseNotSatisfiedLogoutExitAction (registration)

The navigation behavior the SCP should display when a SCO at the end of the course that has not been satisfied exits with an exit type of logout.

PlayerPreventRightClick (registration, default: UNDEFINED)

Specifies whether the player should allow the learner to right click within its frames. This setting can add a small measure of security to the application by making it harder to view the source.

PlayerPreventWindowResize (registration, default: UNDEFINED)

Specifies whether the player should allow the learner to resize its windows.

PlayerIsAvailableOffline (registration, default: UNDEFINED)

Specifies whether the package is available to take offline -- used by the default implementation of GetOfflineCatalog()

PlayerStatusDisplayPreference (registration)

Specifies how the player should display the completion and success status of individual SCOs.

PlayerScoreRollupModeValue (registration)

Specifies how the player should rollup scores from individual SCOs to aggregations in SCORM 1.2

PlayerScoreRollupModeNumberOfScoringObjects (registration)

Specifies how the player should rollup scores from individual SCOs to aggregations in SCORM 1.2

PlayerStatusRollupModeValue (registration)

Specifies how the player should rollup completion status from individual SCOs to aggregations in SCORM 1.2

PlayerStatusRollupModeThresholdScore (registration)

Specifies how the player should rollup completion status from individual SCOs to aggregations in SCORM 1.2

PlayerApplyRollupStatusToSuccess (registration, default: UNDEFINED)

Specifies whether the success status should be updated based on the rudimentary status rollup rules.

PlayerFirstScoIsPretest (registration, default: UNDEFINED)

Specifies whether the first SCO in the course should be considered a pretest. If true and the first SCO is passed, the rest of the course will be marked as completed.

PlayerWrapScoWindowWithApi (registration, default: UNDEFINED)

When a SCO is launched in a new window, this specifies whether the window should be wrapped with a shell window containing a copy of the SCORM API. This setting allows content with errors in the use of its API finder algorithm to still be delivered in a new window. Essentially, this mimics the structure of the ADL Test Suite.

PlayerFinishCausesImmediateCommit (registration, default: UNDEFINED)

This setting forces data to be sent to the server immediately upon the call of LMSFinish or Terminate by the SCO. Can be useful for SCOs that are not completing because of timing issues related to window closing.

PlayerDebugControlAudit (registration, default: true)

Should the debugger capture control data at the audit level

PlayerDebugControlDetailed (registration, default: true)

Should the debugger capture control data at the detailed level

PlayerDebugRteAudit (registration, default: true)

Should the debugger capture RunTime data at the audit level

PlayerDebugRteDetailed (registration, default: true)

Should the debugger capture RunTime data at the detailed level

PlayerDebugSequencingAudit (registration, default: true)

Should the debugger capture Sequencing data at the audit level

PlayerDebugSequencingDetailed (registration, default: true)

Should the debugger capture Sequencing data at the detailed level

PlayerDebugSequencingSimple (registration, default: true)

Capture sequencing debugging information in a more human readable fashion than the very technical Audit or Detailed level

PlayerDebugLookAheadAudit (registration, default: true)

Should the debugger capture LookAhead Sequencing data at the audit level

PlayerDebugLookAheadDetailed (registration)

Should the debugger capture LookAhead Sequencing data at the detailed level (use care when setting this to true, it can have a noticable performance impact)

PlayerDebugIncludeTimestamps (registration, default: true)

Should debug information include timestamps and measurements of how long individual functions are taking for performance monitoring

PlayerCaptureHistory (registration, default: UNDEFINED)

Specifies if the course should return attempt information to the server

PlayerCaptureHistoryDetailed (registration, default: UNDEFINED)

Specifies if the course should return detailed attempt information to the server

PlayerCommMaxFailedSubmissions (registration)

Specifies the maximum number of times the client to server communication can fail before the system stops trying and the learner is notified that there is an error.

PlayerCommCommitFrequency (registration)

The frequency (in milliseconds) with which the application will check for dirty data and try to send it to the server.

PlayerInvalidMenuItemAction (registration)

Specifies the method of disabling items in the course outline which for which a request would not succeed.

PlayerAlwaysFlowToFirstSco (registration, default: UNDEFINED)

Should the SCP always launch the first SCO when the course is launched regardless of sequencing rules.

PlayerLogoutCausesPlayerExit (registration, default: UNDEFINED)

Should the SCP allow a cmi.exit request of logout to exit the entire player

PlayerResetRunTimeData (registration)

Should the SCP always persist runtime data when the exit type is suspend, or should this be left up to the sequencer?

PlayerOfflineSynchMode (registration)

Determines the way offline data is synchronized with the main LMS. This property is only applicable for use with the Rustici Software Offline Player (RSOP)

PlayerValidateInteractionResponses (registration, default: UNDEFINED)

SCORM has a well-defined set of interaction types it will accept. This option in

PlayerLookaheadSequencerMode (registration)

Determines how the Lookahead Sequencer should function on the client side. The Lookahead Sequencer is used intelligently enable/disable activities and controls within the Scorm Content Player based on possible future paths.

PlayerScoreOverridesStatus (registration, default: UNDEFINED)

Determines whether or not the status derived from a score should override the actual status.

PlayerAllowCompleteStatusChange (registration, default: UNDEFINED)

Determines whether or not the lesson status can be modified once it has been set to complete. Applies to SCORM 1.2.

PlayerScaleRawScore (registration, default: UNDEFINED)

In SCORM 2004 content, if a SCO sets a raw score but not a scaled score, should the raw score count as the normative score for the SCO?

PlayerRollupEmptySetToUnknown (registration, default: UNDEFINED)

In SCORM 2004, determines whether a set of child activities in an unknown state rollup to "unknown" or "complete/satisfied"

PlayerReturnToLmsAction (registration)

Defines what happens when a user click "Return To LMS"

PlayerUseQuickLookaheadSequencer (registration, default: UNDEFINED)

In SCORM 2004 4th Edition and later, determines whether or not to use the Quick Lookahead Sequencer

PlayerForceDisableRootChoice (registration, default: UNDEFINED)

Disables the Root menu item Choice option. This is to prevent new attempts being initiated on the course.

PlayerRollupRuntimeAtScoUnload (registration, default: UNDEFINED)

Initiates rollup and transfer of runtime data at ScoUnload for all SCOs.

PlayerForceObjectiveCompletionSetByContent (registration, default: UNDEFINED)

Override the manifest settings for "Objective Set By Content" and "Completion Set By Content" with true values.

PlayerInvokeRollupAtSuspendAll (registration, default: UNDEFINED)

Initiates rollup when SuspendAll is invoked.

PlayerCompletionStatOfFailedSuccessStat (registration)

Specifies the Completion Status value to apply in the case of a Failed Success Status. Only applied if set to "completed" or "incomplete"

PlayerSatisfiedCausesCompletion (registration, default: UNDEFINED)

Determines whether or not activity Satisfaction will set completion

PlayerMakeStudentPrefsGlobalToCourse (registration, default: UNDEFINED)

When a student makes a preference (audio volume, etc) the preference should be applied to all SCOs

PlayerLaunchCompletedRegsAsNoCredit (registration, default: UNDEFINED)

Determines whether an AICC or SCORM 1.2 registrations goes into "no credit" mode upon completion

PlayerSuspendDataMaxLength (registration)

Maximum suspend data length in bytes.

PlayerTimeLimit (registration)

Time limit of the course in minutes, 0 for unlimited (no time limit)

PlayerIsCompletionTracked (registration, default: UNDEFINED)

Does this course package actually report completion in a meaningful way?

PlayerIsSatisfactionTracked (registration, default: UNDEFINED)

Does this course package actually report satisfaction (pass/fail) in a meaningful way?

PlayerIsScoreTracked (registration, default: UNDEFINED)

Does this course package actually report its score in a meaningful way?

PlayerIsIncompleteScoreMeaningful (registration, default: UNDEFINED)

If the course is incomplete, is the score still meaningful?

PlayerIsIncompleteSatisfactionMeaningful (registration, default: UNDEFINED)

If the course is incomplete, is its satisfaction (pass/fail) still meaningful?

PlayerInternetExplorerCompatibilityMode (registration)

The Internet Explorer Compatibility Mode to launch this content in. This determines which X-UA-Compatible meta tag should be used, if any, by the player's frameset pages in which content can be held within a child frame.

PromptOnPlayerClose (registration, default: false)

Constant value used by the default integration implementation that represents the key used in the configuration repository to specify whether the SCORM Player should prompt the user for confirmation before unloading due to the browser window being closed

SuppressNavbarWhenForcedFrameset (registration, default: false)

When enabled, prevents the navbar from showing for requests with the forceFrameset parameter

MaxPersistRuntimeDataAttempts (registration, default: 1)

Maximum number of attempts to save course runtime data.

RedirectOnRefreshUrl (registration)

Optional URL the application should redirect to when the learner refreshes the deliver page, which otherwise may result in a the content being re-launched. This can happen when the user deliberately refreshes the page, or uses the back button (except in IE where the back button just shows the existing page from cache and does not reload from the server, or re-run scripts)
Re-launch is a problem if the content was not suspended, as a new attempt will be generated which will not have all the details from the prior attempt (the prior attempt will still be shown in history).  So even though the user may have completed the initial attempt, they may appear to be incomplete.
This is an unusual problem, and frequently re-launching after a refresh is the best choice, so for now we only recommend assinging a value to this property if you have run into the problem described above.  The redirect page should minimally make it clear to the user how to get back into the content.

RedirectLaunchPageOnExit (registration)

When using any 'New Window' variant for PlayerLaunchType, if this setting is enabled, automatically returns the launch page to the LMS when the player window closes. This setting has no effect if the player launch type is frameset.

SupplementalQueryStringParametersForAllActivities (registration)

Specifies parameter names that, when appended to the launch url, will be forwarded to all content activity pages.