System Properties

This document discusses the system properties that the mBS uses to collect system information in a platform independent way.

Contents:

Setting and Getting System Properties
- Setting System Properties
  - Prior to Framework Startup
  - At Framework Runtime
- Getting System Properties
Properties for Framework Startup and Shutdown
Properties for Specifying Base URLs
System Bundle Properties
Bundle Related Properties
Storage Properties
Security Properties
Properties for Certificate Management and Signature Verification
Resolving Information Properties
Input and Output Properties
Resource Manager Properties
Event Manager Properties
Tracer Properties
Framework Measurement Properties
Fault Manager Properties
Transaction Manager Properties
OS and Processor Aliases
Properties for Control of the Number of Bundles, Services and Listeners
Properties Holding Product Information
Debug Properties

Setting and Getting System Properties

System properties can be classified in four categories:

System properties of the Java interpreter
The interpreter of a Java virtual machine uses conventional system properties, which are usually listed in the documentation of the VM. Such interpreter property is the java.class.path, which wraps the environment classpath. See the Java Language Specification for further details.
System properties defined by the OSGi Framework Specification
The OSGi Framework Specification in its "Environment Properties" section defines properties for the general features of the framework environment, such as language, vendor, version, operating system, and processor.
System properties of the mBS framework
The mBS framework uses properties to tune its boot and runtime behavior. You set them before you start the framework. The framework properties are subject of this document.
System properties of the mBS bundles
The bundles of the mBS also define system properties to configure parameters important for their operation. Usually, when a bundle's system property is modified, the bundle should be restarted in order to take in the change.

Setting System Properties

Prior to Framework Startup

The following methods for setting system properties are convenient for setting system properties both for the framework and active bundles. In addition, the state of system properties will survive framework restarts.

In the default.prs file for the used virtual machine, for example located in the bin/vms/<vm_name> directory. This file can also be placed in lib/serverXxx.jar which contains the framework of mBS.
In this case, system properties are placed in new lines without any prefixes. For example:
mbs.output = remote mbs.output.remote.host = 192.168.244.18 mbs.output.remote.port = 2020

The properties in the default.prs file are with highest priority, that is, they overwrite the ones specified in another manner.
You can provide system properties to the framework from another file, specified through the mbs.prs.name system property in the framework's starting script.
Note: The text file holding the system properties for the framework should not end with a comment ("//").

In a Config class, in whose

public static void load()

method the necessary system properties should be loaded and initialized. Then, the Config class must be included in the system classpath.

This approach is convenient for devices, which do not have a file system. Using this approach will speed up the startup as the framework will load system properties in binary format.

import java.util.Hashtable;

public class Config {
             
  static final String[] PROPERTIES = {
    "mbs.boot.bootfile", "boot.ini",
    "mbs.bundles.base", "../../../bundles/",
    "my.property", "myvalue"
  };
             
  public static void load() {
    Hashtable systemProps = System.getProperties(); 
    for (int i = 0; i < Config.PROPERTIES.length; i+=2) {
      String propertyName = Config.PROPERTIES[i];
      String value = Config.PROPERTIES[i+1]; 
      if (propertyName != null && propertyName.trim().length() > 0) {
        systemProps.put(propertyName.trim(), value.trim());
        System.out.println("Setting system property " + propertyName 
                           + " with value " + value + ".");
      }
    }
  } 
}

Listing 1: Setting system properties with a Config class.

Straight in the server or serverconn executable script dedicated to the current virtual machine. When you run the script, the concerned module reads the property value and settles it in its operation process. For example if the Sun's JDK is used:
java -Dmbs.output=remote -Dmbs.output.remote.host=192.168.244.18 -Dmbs.output.remote.port=2020 . . .

At Framework Runtime

This approach is convenient for system properties of bundles. If the bundle whose system properties you have set is already started, restart it to apply the changes.

In the framework's text console (command prompt or Telnet) by invoking the set command.
set mbs.output=remote
set mbs.output.remote.host = 192.168.244.18
set mbs.output.remote.port = 2020
In the mConsole's System Properties dialog loaded through the Bundles -> Server Properties menu option. For more help, see the "Managing System Properties" section of the mConsole description.

Getting System Properties

You can view system properties by using:

The set command by only specifying the property name. For example:
set mbs.output
The System Properties dialog from the mConsole, which is loaded by the Bundles -> Server Properties menu command.

Properties for Framework Startup and Shutdown

You may use the properties below to modify the boot process of the mBedded Server framework - to specify your own boot INI file with bundles to load at startup; and to specify the name of the file holding system properties to set for the framework.

System Property	Default Value	Description
`mbs.boot.disableProcessing`	false	If true, disables the use of the Boot module at framework startup.
`mbs.boot.bootfile`	boot.ini	Sets the path to the boot INI file, containing instructions for installing specific bundles at framework startup. If the path is relative, it should start from the directory the framework will be launched from.
`mbs.boot.always`	false	Specifies if the framework should always call the Boot module nevertheless there may be a ready storage to load installed bundles from.
`mbs.boot.extension`	-	Sets the name of the boot extension class implementing the `com.prosyst.mbs.framework.boot.Boot` interface.
`mbs.prs.name`	default.prs	Specifies the name of the file to load system properties from. It can be the name of a resource file from server.jar, or a file from the file system. This property can take three possible values: default.prs - the properties' file in the bin/vms/<vm_name> directory which contains the system properties for usual framework startup and operation. defaultconn.prs - the properties' file in the bin/vms/<vm_name> directory which contains the system properties necessary to launch the Connector Version of the framework. <custom> - a properties' file developed by the framework administrator.
`mbs.startlevel`	5	Indicates the active start level of the framework. Only bundles with start levels less or equal to the active level are started.
`mbs.applicationBundleStartLevel`	-	Sets the minimum start level for application bundles. If the property is not specified, the minimum start level for application bundles is the maximum start level from the boot INI incremented with 1 (<boot_ini_max_level>+1). That is, all bundles installed from the boot INI are considered as system bundles, and all bundles installed afterwards are considered as application bundles.
`mbs.startup.delay`	0	Specifies the time in milliseconds the framework should wait before startup.
`mbs.watchdog`	true	Turns on/off the watchdog feature of the framework.
`mbs.server.jar`	-	Specifies the JAR file containing the framework implementation. Used by the Framework Loader.
`mbs.exit.novmshutdown`	false	If true, disables terminating the JVM process (i.e. `System.exit()` will not be called) when stopping framework.

Properties for Specifying Base URLs

Base URLs are set as bases for specifying various relative URLs, such as the directory where core mBS bundles are located, the main directory with executable scripts, etc.

System Property	Default Value	Description
`mbs.exec.base`	../../pscripts/	The base directory of executable scripts. It is recommended that this property ends with "/".
`mbs.domain.base`	..	The location of the directory holding the domain.crp file. This is the certificate file that contains the serial number of the ProSyst mBS product. By default, this property points to the parent folder of the server starting script, i.e. bin/vms. The framework archive (lib/server.jar) can also contain this file so that it is read as a resource from the JAR. If there is a resource "domain.crp" in the server.jar, then the certificate file is loaded from this source, otherwise the framework looks for it in the domain base location (`mbs.domain.base`).
`mbs.bundles.base`	../../../bundles	Specifies bundle base URL. When installing a bundle, whose location is not an absolute URL or an absolute path, then the location is considered relative to the `mbs.bundles.base` directory. This property is ignored if the bundle location is preceded by "/". Note: The bundle base URL should contain a communication protocol identifier, such as http://. For the local file system this is file:///. If the bundle base URL points to a remote machine, access to that URL must be provided. For example, if an HTTP URL is assigned, it should be registered as a resource in an HTTP server running on the target machine.
`mbs.urlbase`	-	Specifies the base location it is allowed to install bundles from. For example: If this property is set to https://, to be able install to a bundle its location must start with https://.

System Bundle Properties

You can preliminary specify the main properties of the System Bundle. See the OSGi Framework Specification for more information about the role of the System Bundle.

Property	Description
`mbs.activator`	Optional list of class names of the additional activators to the system bundle. Their `start` and `stop` methods are invoked when the framework starts and stops. For example, if you want the init activities (such as registration of service) of the Log Bundle activator to be performed at framework startup, this property value must be `com.prosyst.mbs.impl.service.log.LogActivator`.
`mbs.syspackages`	Optional list of packages that will be loaded by the framework's parent class loader and should be exported by the System Bundle. This property should also contain the public packages of those bundles whose activators are included in the list of the `mbs.activator` property. This property has the same format for packages as the Export-Package manifest header.
`mbs.config`	Optional list of service configurations that will be created by the system bundle. Specify this property if you add a new functionality to system bundle (through the `mbs.activator` system property) which needs configuration management. The syntax of this list is the same as for the Config manifest header, as it is described in the Config Bundle. The use of this property brings the following requirements to you: The XML files specified with this property should be accessible through the `java.lang.ClassLoader.getSystemResource(String)` method. To be processed, the `org.osgi.service.cm.ManagedService` service associated with the specified service PID through this property should be registered by the system bundle. To have configuration management requested through this property, the system bundle must export the `org.osgi.service.cm package` and must be only one to do it.
`mbs.factoryconfig`	Optional list of service factory configurations that will be created by the system bundle. Specify this property if you add a new functionality to system bundle (through the `mbs.activator` system property) which needs configuration management. The syntax of this list is the same as for the FactoryConfig manifest header, as it is described in the Config Bundle. The use of this property brings the following requirements to you: The XML files specified with this property should be accessible through the `java.lang.ClassLoader.getSystemResource(String)` method. To be processed, the `org.osgi.service.cm.ManagedServiceFactory` service associated with the specified service factory PID through this property should be registered by the system bundle. To have configuration management requested through this property, the system bundle must export the `org.osgi.service.cm package` and must be only one to do it.

Note: If you add functionality to the System Bundle, to have it work properly make sure that all added packages are included in the system classpath and/or in the System Bundle.

Bundle Related Properties

The mBS framework supports properties to tune some aspects of bundle management.

System Property	Default Value	Description
`mbs.bundles.resolve`	false	If this property is true, the framework will always try to resolve the bundle after installation.
`mbs.bundles.cacheHeaders`	-	A list of comma-separated manifest headers, which the framework will keep in its cache for faster checking if a bundle has a specific header through the Framework Access service. This property should not contain more than 32 headers.
`mbs.bundles.getStateSimple`	false	If this property is true, when called the `Bundle`'s `getState` method will try to resolve the relevant bundle.
`mbs.bundles.osgilazy`	false	If this property is true, the framework will support Equinox lazy initialization.
`mbs.loader.type`	-	The type of bundle loaders to use for a specific platform. If this property is not set, a default type will be used. The property can have the following values: jxe22 - for J9 2.2. Allows working with JXE archives. tao - for Tao VM . Allows working with Tao native archives in the Standard Version of the framework. custom - for a custom bundle loader. Allows working with a custom implementation of `com.prosyst.mbs. framework.classloader. ClassProvider`.
`mbs.loader.class`	com.prosyst.mbs. impl.framework. DefaultClassProvider	The bundle loader class, implementing `com.prosyst.mbs. impl.framework.ClassProvider`, that will be used for loading bundle classes. The property takes effect only if `mbs.loader.type` is set to custom.
`mbs.loader.setsigners`	true	If true, on defining a new bundle class the `setSigners` method of the corresponding bundle loader will be called. This property is recommended to be true for JDK1.1 and Jeode, and false for CEE-J and J9.
`mbs.loader.r3`	false	If true, a fix in class loading compatible with release 3 of the OSGi Service Platform specification will be enabled.
`mbs.loader.r4`	false	If true, a fix in class loading compatible with release 4 of the OSGi Service Platform specifications will be enabled.
`mbs.manifest.osname.ignoreSpaces`	true	When true, the framework ignores the spaces in the `os.name` system property value, used for loading bundle native libraries appropriate for the runtime environment. For example, "windows 2000" will be considered as "windows2000".
`mbs.update`	eager	Specifies the update mode of the framework. The property can be eager or lazy. The property can be changed at runtime and the change will have effect the next time a bundle is installed or updated.
`mbs.customFrameworkLoader`	false	If true, the framewok will use a special class loader, called the Framework Loader, for managing the framework in case an extension bundle is installed.
`mbs.noFwRestart`	false	If true, the framework process will not be restarted when a bootclasspath extension bundle is installed or updated.
`mbs.core.timeout`	30000	Provides the timeout in milliseconds for a bundle to start or stop.

Storage Properties

This section lists the system properties that can be used to adjust the parameters of framework storage.

Property	Default Value	Description
`mbs.storage.allowroot`	com.prosyst.fsbrowser; com.prosyst.httpfsbrowser	Contains a list of symbolic names, separated with semi-colons, of the bundles which are allowed to access the root directory of the framework storage.
`mbs.storage.delete`	false	Removes or preserves the storage directory at startup. If set to true, the storage folder is deleted.
`mbs.storage.delete.subarchives`	false	If true, makes the framework delete all sub archives included in the bundle classpath from the bundle JAR after they are extracted. Enabling this function can significantly reduce the size of the framework storage. Note: This property is not valid when using the standard server.jar. To make it work, server.jar should be recompiled using the JMM Java Preprocessor option deflate. As the framework source files are not included in the installation, the recompiled server.jar is available only upon request to ProSyst.
`mbs.storage.grbnotsave`	false	Specifies if the list with files to be deleted from the storage should be saved after every modification (adding or removing a file).
`mbs.storage.root`	storage	The name of the root storage folder.
`mbs.storage.inflater`	-	Defines what ZIP implementation will be used to decompress JAR files. There are two possibilities: To use the inflater in the `java.util.zip` package, set the property to `com.prosyst.mbs. impl.services. przip.jzip.InflaterImpl`. To use the ProSyst pure Java inflater, set the property to `com.prosyst.mbs. impl.services. przip.pzip.InflaterImpl`. When there is no value set for this property, the framework works with the `java.util.zip` inflater. Note: This property works for the Standard Version of the framework and the Connector version of the framework using storage on top of java.io with Connector support only if server.jar and serverconn.jar, respectively, are re-compiled with the JMM Java Preprocessor option przip. As the framework source files are not included in the installation, the recompiled server.jar is available only upon request to ProSyst.
`mbs.storage.trustedRoot`	../../../	Specifies the directory which the framework will consider as trusted storage root - the checksums of the installed bundles stored outside this directory will be compared on each framework restart, and those whose checksums do not match will be uninstalled. In addition, all extension bundles must be installed in this storage so that they are loaded in the framework. The property value should end with a path separator ("/").
`mbs.storage.zip.jdk13`	true	If true, fixes some ZIP problems in most of the JDK 1.1/PersonalJava/JDK 1.2 compliant JVMs, like Perc, PJEE, CEE-J, Sun JDK 1.1, etc.
`mbs.storage.zipoutputstream`	-	Defines what ZIP implementation to use when writing data in archives. The property has two possible values: `com.prosyst.mbs. impl.services. przip.jzip. ZipOutputStreamImpl` - for the archive writer based on the`java.util.zip` package; `com.prosyst.mbs. impl.services.przip.pzip. ZipOutputStreamImpl` - for the ProSyst archive writer in pure Java. Note: This property works for the Standard Version of the framework and the Connector version of the framework using storage on top of java.io with Connector support only if server.jar and serverconn.jar, respectively, are re-compiled with the JMM Java Preprocessor option przip. As the framework source files are not included in the installation, the recompiled server.jar is available only upon request to ProSyst.
`mbs.update.keep`	false	Specifies whether the data files in the framework storage should be kept, when a bundle is updated, or not. If this property has no value, then as a default value false is considered.
`mbs.keepmf`	true	Turns on the framework cache of bundles' manifests. Otherwise, they are read from the JARs every time `Bundle.getHeaders` is called.
`mbs.storage.impl`	com.prosyst.mbs. impl.framework. module.storage. file.StorageImpl	Specifies which storage implementation should be used to save framework data. This property can be: For storage on top of java.io and storage on top of java.io with Connector support - `com.prosyst.mbs.impl. framework.module. storage.file.StorageImpl` For storage on top of MMFS with Connector support - `com.prosyst.mbs.impl. framework.module. storage.mm.StorageImpl`
`mbs.storage.url`	-	If set, this property specifies a URL from where a built storage can be taken. Depending on the storage implementation (set with the `mbs.storage.impl` system property), this property should point to: Valid ZIP file for storage on top of java.io and storage on top of java.io with Connector support. Valid storage.mbs file for storage on top of MMFS. storage.mbs is a built storage in a special MMFS format.
`mbs.storage.native`	jdk12	Specifies how to store native libraries in the storage directory. The value of this property can be jdk11 or jdk12. If it is jdk12, native libraries are placed in separate sub-directories within the data directories allocated for each installed bundle in the framework storage. In detail, the native libraries of a bundle are saved into <storage_root>/data/<bundle_id>/<bundle_vesion>/native. Use jdk12 when you have 1.2 compatible VM (you have the `findLibrary` method in a class loader). If it is jdk11, native libraries are stored in the native subfolder of the framework storage. A path to this folder is automatically added in the environment. Use jdk11 when you have 1.1 compatible VM. In this case, the path is set to the <storage_root>/native folder so the `loadLibrary` method can work correctly.
`mbs.storage.nativedir`	`.`	Specifies the directory to which native libraries are extracted from bundle JARs. This property is vital when the jdk11 native mode is used and there is no `PATH` environment variable, which is the case with WinCE.
`mbs.storage.keepgarbage`	false	Turns on/off keeping storage garbage at framework startup.
`mbs.storage.norename`	false	Specifies if the flat RAM file system the flash manager will operate on does not support renaming.
`mbs.storage.ramroot`	-	Indicates the root directory of the temporary RAM storage, in which the flash manager will transfer files from the flash persistent storage.
`mbs.storage.forbiddenChars`	':', '*', '?', '\"', '<', '>', '\|'	Defines the comma-separated set of characters forbidden for file names in the operating system. If some of these characters is encountered in a bundle location, it is replaced with the ^ symbol in the storage.
`mbs.storage.maxFileName`	-	The maximum number of characters that a bundle JAR file can have in the framework storage. This property should have value less than 48 for the QNX operating system.
`mbs.storage.flashmgr.flatram`	false	Indicates if the RAM file system, used with the framework flash manager, is "flat".
`mbs.storage.flashmgr.replace`	false	Specifies if when a temporary file is scheduled twice for flush in the queue of the flash manager, the second instance will replace the first one (the flush operation is not executed yet). The default is false – which means that the file will not be replaced and thus will be synchronized twice.
`mbs.storage.mm.type`	file	Specifies the type of the memory model file system (MMFS) used for storing framework data when using the Connector Version of the framework. It can be: file - Stored data is kept in a single file, referred to as `java.io.RandomAccessFile`, on the external memory of the framework device (hard disk or flash). ram - framework and bundle related data are stored in RAM memory <custom_type> - framework and bundle related data are stored using memory models developed by third parties. In this case the file system components found in `org.osgi.service.io` and `javax.microedition.io` should be implemented.
`mbs.storage.mm.nativelibs`	true	Enables working with native libraries if the current storage implementation is `com.prosyst.mbs.impl.framework. module.storage.mm.StorageImpl`. Use this property only if the framework device has file system.
`mbs.storage.mm.cluster.count`	3995	Specifies the number of data clusters to segment an MMFS into.
`mbs.storage.mm.cluster.size`	1024	Specifies the size in bytes of each cluster an MMFS is segmented into.
`mbs.storage.mm.changes.save`	1	Specifies the number of changes in the MMFS, after which the system information will be automatically saved (in case MMFS over RAM is not used).
`mbs.storage.mm.file.name`	storage.mbs	Specifies the name of the file, which keeps system information about the framework storage when MMFS is used. It is recommended to change this property for Jbed to Vfat0/storage.mbs or to Ram/storage.mbs.

Security Properties

This section lists the system properties that you can use to tune framework security.

Property	Default Value	Description
`mbs.sm`	false	Turns on (when true) and off (when false) the ProSyst Security Manager (see "Framework Architecture").
`mbs.security`	-	Activates the security in the framework. This property has three possible values: none - Security is off. For VMs that do not support the JDK 1.2 or PersonalJava security model, the property must have this value. jdk12 - Security that implements the JDK 1.2 security model is on. Has meaning only if the ProSyst Security Manager is active (`mbs.sm` is equal to true) custom - Custom Security module should be used, whose implementation is specified with the `mbs.security.class` system property. Has meaning only if the ProSyst Security Manager is active (`mbs.sm` is equal to true) If the jdk12 security models is on, you should specify a policy file. For example in the server executable script: `java -Djava.security.policy=current.policy`
`mbs.security.class`	-	Contains the class name of a custom Security module. Has meaning only if `mbs.security` is not specified or is equal to none.
`mbs.security.checkthreads`	false	Allows/forbids a bundle to access the thread groups of other bundles. This property is useful when the framework works without its security (mbs.security=none) and with resource management (mbs.resman.enabled=true). If the property is true, then access to other bundles' thread groups is not allowed. If security is on, the ProSyst Security Manager always checks if a bundle has the right to access the thread group of another bundle regardless of this property value.
`mbs.security.fileaccess`	false	Turns on/off automatic assignment of ExclusiveFilePermissions to bundles for writing data outside the persistent storage.
`mbs.disableLocalPermissions`	false	If true, disables the anlysis and processing of bundle local permissions.
`jeode.security`	false	Turns on security optimizations, specific for the Jeode virtual machine, and should be set when using security with this virtual machine.

Properties for Certificate Management and Signature Verification

Property	Default Value	Description
`mbs.certificates`	true	If true, enables the availability of the Certificate Manager as well as of all features of the framework related to certificate management and to signed bundle JAR files.
`mbs.certificates.impl`	default	Specifies the Certificate Manager implementation. Can have two possible values: default - Stands for the default Certificate Manager, implemented in the framework. <cert_mngr_class> - Stands for the class name of a custom Certificate Manager. The class must implement the `com.prosyst.mbs.framework. certcertmanager.CertificateManager` interface.
`mbs.certificates.boot.enableDigests`	false	If true, enables verifying entry digests in installed signed bundles at framework startup.
`mbs.certificates.delayedCheckJarEntriesDigests`	false	If true, enables verifying entry digests in installed signed bundles only when there is a need for a relevant entry.
`mbs.keystore.class`	com.prosyst.mbs. impl.framework.module. certmanager.certstorage. DefaultCertificateKeyStoreImpl	Specifies the implementation class of the certificate storage used by the Certificate Manager. Possible values are: `com.prosyst.mbs. impl.framework.module. certmanager.certstorage. DefaultCertificateKeyStoreImpl` `com.prosyst.mbs. impl.framework.module. certmanager.certstorage. FolderCertificateStorageImpl`

Resolving Information Properties

Property	Default Value	Description
`mbs.resolveinfo.file`	resolve.inf	Specifies the name of the file to keep system resolving information.
`mbs.resolveinfo.useappfile`	true	Turns on/off the separate processing of resolving information of system bundles and of application bundles.
`mbs.appresolveinfo.file`	appresolve.inf	Specifies the name of the file to keep application resolving information.

Input and Output Properties

By using the output properties, you can redirect the system output to a remote machine.

Property	Default Value	Description
`mbs.output`	default	Specifies the location to redirect framework output. This property has three possible values: default or missing value - The framework output is mapped to the standard system output of the local device. file - The framework output is recorded in a file on the server host machine. This file is called console.txt and is placed in bin/vms/<vm_name> folder, where <vm_name> stands for the folder that corresponds to the currently used JVM for the ProSyst mBS. For more details, refer to the Directory Structure chapter. Note: On a platform running the WinCE operating system or the Tao virtual machine, console.txt is saved in the main directory of the file system. remote - The framework input and output are mapped to the system input and output of a remote machine. To use properly this option, you should specify `mbs.output.remote.host` and `mbs.output.remote.port` as specified below. Tip: You can load and use the Remote Console tool that displays the server output onto a remote machine. This tool receives the output stream from the framework device.
`mbs.output.charscount`	80	Specifies the maximum number of symbols that a line in the standard output can have.
`mbs.output.remote.host`	127.0.0.1 (the IP address of the local machine)	Defines the IP address of the remote machine to forward the framework output to.
`mbs.output.remote.port`	2000	Specifies the port of the remote machine to redirect the command output to.
`mbs.output.remote.autoFlush`	false	If true and the `mbs.output` system property is equal to remote, that is, the standard output is sent to a remote location, the output stream will be automatically flushed after each write operation.
`mbs.output.remote.reconnectTimeout`	20000	Specifies the timeout in milliseconds for reconnection to the remote output destination. Has meaning only if `mbs.output` is equal to remote.
`mbs.output.remote.useLocalIn`	false	If true, the framework will read both the remote input and the system input. This is useful in case problems appear in receiving the remote input.
`mbs.output.file.autoflush`	true	If true and `mbs.ouput` is equal to file, that is, the standard output is written to a file, the framework is automatically flush the stream after each write operation.

Resource Manager Properties

This section describes the system properties that affect the resource manager of the framework.

Property	Default Value	Description
`mbs.resman.class`	com.prosyst.mbs. impl.framework.module. resman.ResourceManagerImpl.	Declares the resource manager implementation class. For JDK 1.3, JDK 1.4, and CVM 1.0 and JVMs compliant with these JVMs this class is `com.prosyst.mbs.impl. framework.module.resman. ResourceManagerImpl`. For JDK 1.5 and CVM 1.1 and JVMs compliant with these JVMs this class is `com.prosyst.mbs.impl. framework.module.resman.jdkv15. ResourceManagerImpl`. For J9 2.x this class is `com.prosyst.mbs.impl. framework.module.resman.j9v2. J9ResourceManager`.
`mbs.resman.enabled`	false	Turns on and off the resource management of the framework.
`mbs.resman.DefBundleThreads`	10	Specifies the maximum number of active threads a bundle can create, if there is not a requirement XML or this file does not contain an entry for bundle threads.
`mbs.resman.MaxBundleThreads`	100	Indicates the maximum number of active threads a bundle can create regardless of what is specified in the bundle requirement XML.
`mbs.resman.maxThreads`	1000	Specifies the maximum number of active threads in all bundles and framework at one time.
`mbs.resman.DefDataStorageSpace`	204800	Specifies the size in bytes of the data space allocation per bundle.
`mbs.resman.MaxDataStorageSpace`	409600	Specifies the maximum size in bytes of the data space allocated per bundle regardless of what the bundle requirement XML contains.
`mbs.resman.DefBundleSockets`	10	Specifies the default number of sockets that a bundle can open.
`mbs.resman.MaxBundleSockets`	15	Specifies the maximum number of open sockets that a bundle can have at one time regardless of what is indicated in the requirement XML.
`mbs.resman.maxSockets`	1000	Indicates the maximum number of sockets open in all bundles and framework at one time.
`mbs.resman.j9.newspacesize`	100000	Specifies the default size in bytes of the NewSpace segment of a bundle's memory space.
`mbs.resman.j9.oldspacesize`	100000	Specifies the default size in bytes of the OldSpace segment of a bundle's memory space.
`mbs.resman.j9.maxspacesize`	200000	Specifies the upper limit in bytes for the size of a memory space.
`mbs.threads.fix`	false	On Tao and CEE-J VMs must be set to true in order to use some VM-specific techniques related to resource management.

Event Manager Properties

You can set the priority of the event delivering thread and define the timeout to wait for a listener to receive and process a framework-related event.

Property	Default Value	Description
`mbs.events.queue.size`	50	Specifies the size of the queue with events.
`mbs.core.timeout`	30000	Specifies the timeout in milliseconds after which a listener is considered hanging.
`mbs.events.priority`	`Thread.NORM_PRIORITY`(5)	Specifies the priority of the thread for event delivering.

Tracer Properties

The system property related to the Tracer framework module enable the configuration of the Tracer implementation as well as of the used transport. There are other properties for setting some additional parameters of the Tracer operation.

Property	Default Value	Description
`mbs.tracer.impl`	-	Specifies the Tracer implementation class. This property must be set to activate the Tracer. The property can have the following values: default - Messages are sent with the default implementation of the Tracer module. <custom_tracer> - Messages are sent with the specified custom Tracer class. It must implement `org.osgi.framework.ServiceFactory` providing `com.prosyst. mbs.framework.tracer.TraceService` instances as described in Framework Architecture.
`mbs.tracer.transport`	tcp	Specifies the transport that will be used for the connection to the client. This property can have the following values: com.prosyst.mbs.impl.framework.module.tracer.TCPLogger - The Tracer will send messages over TCP/IP. This tracer transport implementation opens a socket and accepts a single client on it. The `mbs.tracer.tcp.port` system property defines the port on which the socket will be open. <custom_tracer_transport> - The Tracer will send messages through the specified custom transport class, which must implement `com.prosyst. mbs.framework.tracer.TraceRemoteLogger`.
`mbs.tracer.tcp.port`	55000	Specifies the port allocated for sending Tracer-enabled messages over TCP/IP.
`mbs.tracer.waitclient`	false	Indicates if the framework will be blocked until a client is accepted. Setting this property to true can prevent from losing tracer logs generated before the client connects to the framework.
`mbs.tracer.asynchmsgcount`	100	Specifies the size of the queue for asynchronous messages to accumulate before sending the messages to the client.

Framework Measurement Properties

Note: These properties should be specified in the framework starting script or in the command line as the framework loads the Framework Measurement module before reading the content of the default.prs properties file.

Property	Default Value	Description
`mbs.measurements.class`	`com.prosyst. mbs.impl. framework.module. measurement. DefaultFrameworkMeasurementImpl`	Specifies the class of the Framework Measurement module: Default implementation - `com.prosyst. mbs.impl. framework.module. measurement. DefaultFrameworkMeasurementImpl` Native implementation - `com.prosyst. mbs.impl. framework.module. measurement. NativeFrameworkMeasurementImpl`
`mbs.measurements.full`	false	Turns on logging of detailed measurement information in the standard output.
`mbs.measurements.intermediate`	false	Turns on logging of measurement information of medium level in the standard output.
`mbs.measurements.simple`	false	Turns on logging only of basic measurement information in the standard output.
Common properties for specifying parameters of triggered measurement
`mbs.measurements.heapMemory`	false	Turns on triggering of heap memory measurement.
`mbs.measurements.memory`	false	Enables triggering of heap, process and flash memory measurement.
`mbs.measurements.threads`	false	Enables triggering of threads count measurement.
Native Measurement properties for specifying parameters of triggered measurement
`mbs.measurements.flashMemory`	false	Turns on triggering of consumed flash memory measurement.
`mbs.measurements. flashMemory.hierarchicalView`	false	Enables triggered flash memory measurement with reports for each subfolder in the main storage folder hierarchy.
`mbs.measurements.processMemory`	false	Turns on triggered measurement of the memory consumed by the framework process.
Native Measurement properties for manner of logging of measurement information
`mbs.measurements.triger.log.display`	false	If true, the results of triggered measurement(s) will be displayed in the native environment.
`mbs.measurements.impl.debug`	false	Turns on logging of debug information in the standard output about the operation of the Native Framework Measurement.
`mbs.measurements.impl.stricterrors`	false	If true, the Native Framework Measurement will throw an exception if it receives an illegal measurement argument (measurement log, or triggering event type or module).
`mbs.measurements.impl.logOnConsole`	false	Turns on printing logged measurement information in the standard output.
Properties for Periodic Measurement
`mbs.measurements.period`	10	Specifies the period in minutes to trigger memory measurements.

Fault Manager Properties

Property	Default Value	Description
`mbs.fm.class`	-	Contains the name of the class implementing the framework's Fault Manager.
Properties for the default implementation of the Fault Manager
`mbs.faultmanager.file`	fasult.fm	Specifies the name of the file where fault messages will be stored.
`mbs.faultmanager.records`	20	Specifies the maximum number of fault records to be saved in the faults file. If this number is exceeded, the oldest records are deleted.
`mbs.faultmanager.nodate`	false	Indicates if dates should be included in fault records.

Transaction Manager Properties

Property	Description
`mbs.tm.class`	Specifies the implementation class of the Transaction Manager module. Default implementation is com.prosyst.mbs.impl.framework.module.transaction.TransactionManagerImpl and should be set in order to have the default transaction support available in the framework.

OS and Processor Aliases

Via system properties you can specify aliases for the OS and the processor of the environment on which the framework runs. They can be used for OS or processor checks of Bundle-NativeCode clauses in addition to the commercial OS and processor names, specified in the clause.

The system properties for OS and processor aliases are:

Property	Description
`os.aliases`	Specifies the frequently used aliases for the operating system running the framework. Recommended OS alias values are described in the Writing Bundles document.
`processor.aliases`	Specifies the frequently used aliases for the processor of the runtime environment. Recommended processor alias values are described in the Writing Bundles document.

Properties for Control of the Number of Bundles, Services and Listeners

You can tune the number of bundles, services and listeners in the framework at one time.

Property	Default Value	Description
`mbs.bundle.count`	-	Specifies the maximum number of bundles in the framework. By default there is no limit.
`mbs.service.count`	-	Specifies the maximum number of services in the framework. By default there is no limit.
`mbs.listener.count`	-	Specifies the maximum number of bundle, framework and service listeners in the framework. By default there is no limit.

Properties Holding Product Information

The following read-ony system properties carry information about the mBS product .

Property	Default Value	Description
`mbs.product.version`	6.0	Contains the version of mBS.
`mbs.framework.build.version`	141	Contains the build number of mBS framework.

Debug Properties

You can start the framework with preliminary defined levels of received debug information as well as with specific type of debug turned on.

Property Default Value Description

mbs.debug

Switches on the debug levels of the framework. A level is associated with a module of the framework (see "Framework Architecture"). The possible values are as follows:

0	No debug
1	Debug of Framework core
2	Debug of Package Manager
3	Debug of Service Manager
4	Debug of Event Manager
5	Debug of Bundle Manager
6	Debug of class loading in the used Class Provider
7	Debug of Storage
8	Debug of loading the boot INI
9	Debug of available URL Handlers
10	Basic debug of security
11	Intermediate debug of security
12	Full debug of security
13	Debug of Resource Manager
14	Debug of start levels menagament
15	Debug of Framework Access service
16	Debug of Fault Manager
17	Debug of Certificate Manager

You may specify more than one debug level as value to this property. In this case, use the following syntax:
mbs.debug=m[;n]
where m and n are debug levels.

mbs.log.errorlevel false If this property is true, the framework will log and print all debug and error information regardless of the other debug settings. Setting this property to true is useful during development for easier tracking of problematic situations.

mbs.log.usedispatcher false If this property true, the framework will print log information in a non-blocking way through the log dispatcher.

mbs.security.debug false If this property is true, the framework will print detailed debug information about the security operations it is performing.

Getting Started