---
title: "IceBox.*"
url: https://docs.zeroc.com/ice/3.8/property-reference/icebox-properties
docs_index: https://docs.zeroc.com/llms.txt
---

> For an index of every page, see [llms.txt](https://docs.zeroc.com/llms.txt).

# IceBox.\*

Parts of this page are for some programming languages only, and name them. For one language's text alone, see [C++](https://docs.zeroc.com/ice/3.8/property-reference/icebox-properties/cpp.md), [C#](https://docs.zeroc.com/ice/3.8/property-reference/icebox-properties/csharp.md), [Java](https://docs.zeroc.com/ice/3.8/property-reference/icebox-properties/java.md), [JavaScript](https://docs.zeroc.com/ice/3.8/property-reference/icebox-properties/js.md), [MATLAB](https://docs.zeroc.com/ice/3.8/property-reference/icebox-properties/matlab.md), [PHP](https://docs.zeroc.com/ice/3.8/property-reference/icebox-properties/php.md), [Python](https://docs.zeroc.com/ice/3.8/property-reference/icebox-properties/python.md), [Ruby](https://docs.zeroc.com/ice/3.8/property-reference/icebox-properties/ruby.md), and [Swift](https://docs.zeroc.com/ice/3.8/property-reference/icebox-properties/swift.md).

## IceBox.InheritProperties

`IceBox.InheritProperties=num`

If `num` is set to a value larger than `0`, each service [inherits the configuration properties](https://docs.zeroc.com/ice/3.8/services/icebox/configuring-icebox-services.md) of the IceBox server's communicator, except the properties whose names start with `IceBox.` or `Ice.Admin.`. Properties set by the service arguments in [IceBox.Service.name](#icebox.service.name) override inherited properties. If not defined, the default value is `0`.

## IceBox.LoadOrder

`IceBox.LoadOrder=names`

Determines the [order](https://docs.zeroc.com/ice/3.8/services/icebox/configuring-icebox-services.md) in which services are loaded. The service manager loads the services in the order they appear in `names`, where each service name is separated by a comma or white space. Each name must have a matching `IceBox.Service.name` property. Any services not mentioned in `names` are loaded afterward, in an undefined order.

## IceBox.PrintServicesReady

`IceBox.PrintServicesReady=token`

If this property is set, the service manager prints "`token` ready" on standard output once initialization of all the services is complete. This is useful for scripts that need to wait until all services are ready to be used.

## IceBox.Service.*name*

`IceBox.Service.name=entry_point [args]`

Defines a [service](https://docs.zeroc.com/ice/3.8/services/icebox/configuring-icebox-services.md) to be loaded during IceBox initialization. The service manager examines the arguments that follow the entry point. An argument of the form `--prefix.key=value`, where `prefix` is one of the [reserved prefixes](https://docs.zeroc.com/ice/3.8/runtime/properties-and-configuration/properties-overview.md) such as `Ice`, or the service `name`, sets a property in the communicator that the service manager passes to the service `start` method; `--Ice.Config=file` loads a configuration file into that communicator. The service manager passes all remaining arguments to the `start` method in the `args` parameter. Whitespace separates the arguments, and any arguments that contain whitespace must be enclosed in quotes.

> **C++**
>
> In C++, `entry_point` has the form `path[,version]:function`.
>
> The `path` and optional `version` components are used to construct the name of a DLL or shared library. If no version is supplied, the version is the empty string. The `function` component is the name of a function with extern C linkage. For example, the entry point `IceStormService,38:createIceStorm` implies a shared library name of `libIceStormService.so.38` on Linux, `libIceStormService.38.dylib` on macOS, and `IceStormService38.dll` on Windows. Furthermore, a Windows debug build of the Ice library appends a `d` to the version (e.g., `IceStormService38d.dll`).
>
> The function must be declared with extern C linkage and have the following signature:
>
> ```cpp
> IceBox::Service* function(const Ice::CommunicatorPtr&);
> ```
>
> Note that the function must return a raw pointer and not a `shared_ptr`. IceBox deallocates the object when it unloads the library. The communicator instance passed to this function is the server's communicator, which is not the same as the communicator passed to the service's `start` method.
>
> The `path` component may optionally contain a relative or absolute path name, indicated by the presence of a path separator (`/` or `\`). In this case, the last component of the path is used to construct the name of the shared library or DLL. Consider this example:
>
> ```config
> IceBox.Service.IceStorm=./IceStormService,38:createIceStorm
> ```
>
> The use of a relative path means the Ice runtime will look in the current working directory for `libIceStormService.so.38` on Linux or `IceStormService38.dll` on Windows.
>
> If the `path` component contains spaces, the entire entry point must be enclosed in quotes:
>
> ```config
> IceBox.Service.IceStorm="C:\Program Files\ZeroC\Ice-Services-3.8.3\bin\IceStormService,38:createIceStorm"
> ```
>
> If the `path` component does not include a leading path name, Ice delegates to the operating system to locate the shared library or DLL, which typically means that the plug-in can reside in any of the directories in your shared library or DLL search path.

> **C#**
>
> In C#, `entry_point` has the form `assembly:class`.
>
> The `assembly` can be a partially or fully qualified assembly name, such as `myplugin,Version=0.0.0.0,Culture=neutral`, or an assembly DLL name such as `myplugin.dll`, and may optionally include a leading relative or absolute path name.
>
> The specified class must implement the `IceBox.Service` interface and provide at least one of the constructors shown in the example below:
>
> ```csharp
> public class MyService : IceBox.Service
> {
>     public MyService(Ice.Communicator serverCommunicator) { ... }
>     public MyService() { ... }
>
>     // ...
> }
> ```
>
> The constructor taking an `Ice.Communicator` argument is invoked if present, otherwise the parameterless constructor is invoked.
>
> If you specify a relative path name in the entry point, the assembly is located relative to the program's current working directory:
>
> ```config
> IceBox.Service.MyService=..\MyService.dll:MyService
> ```
>
> Enclose the assembly's path name in quotes if it contains spaces:
>
> ```config
> IceBox.Service.MyService="C:\Program Files\MyService\MyService.dll:MyServiceClass"
> ```
>
> Finally, if the assembly uses a leading path name, be sure to include the `.dll` extension.

> **Java**
>
> In Java, `entry_point` has the form `[path:]class`.
>
> The `class` component must be the name of a class that implements the `com.zeroc.IceBox.Service` interface and provides at least one of the constructors shown in the example below:
>
> ```java
> public class MyService implements com.zeroc.IceBox.Service {
>     public MyService(com.zeroc.Ice.Communicator serverCommunicator);
>     public MyService();
>
>     // ...
> }
> ```
>
> The constructor taking a `Communicator` argument is invoked if present, otherwise the default constructor is invoked.
>
> If `path` is specified, it may be the path name of a JAR file or class directory, as shown below:
>
> ```config
> IceBox.Service.MyService=MyService.jar:MyService
> IceBox.Service.MyOtherService=/classes:MyOtherService
> ```
>
> If `path` contains spaces, it must be enclosed in quotes:
>
> ```config
> IceBox.Service.MyService="factory classes.jar":MyService
> ```
>
> IceBox uses a single class loader to load all services having the same value for `path`.
>
> If `class` is specified without a path, IceBox attempts to load the class with the current thread's context class loader, then with `Class.forName`, and finally with the system class loader.

> **JavaScript, MATLAB, PHP, Python, Ruby, and Swift**
>
> > **Note**
> >
> > IceBox supports services implemented in C++, C#, and Java. This mapping can call those services remotely.

## IceBox.Trace.ServiceObserver

`IceBox.Trace.ServiceObserver=num`

If `num` is set to a value larger than `0`, the service manager traces the registration and removal of service observers. If not defined, the default value is `0`.

## IceBox.UseSharedCommunicator.*name*

`IceBox.UseSharedCommunicator.name=num`

If `num` is set to a value larger than `0`, the service manager supplies the service `name` with a communicator that might be [shared by other services](https://docs.zeroc.com/ice/3.8/services/icebox/configuring-icebox-services.md). If the [IceBox.InheritProperties](#icebox.inheritproperties) property is also defined, the shared communicator inherits the properties of the IceBox server. If not defined, the default value is `0`.
