Configuration API¶

The configuration API is used by the Middleware API to store and read its settings. By managing the settings of the middleware through this configuration API one can create different applications that behave consistently and inherit the same settings. For example a command line client or a GUI program can read and write their settings through this API. In addition, the configuration API offers an extensibility framework, by which applications can add their specific settings which will be managed in the same way as the middleware settings. The settings are loaded and saved from/to persistent storage using a backend; a backend is provided which has a simple text file format.

The settings can be managed by API calls. The middleware settings have appropriate defaults so that it can function properly with a minimum amount of changes.

Architecture¶

Configuration API consists of the low-level classes that can be used for storing and retrieving configuration objects. Moreover, it allows the creation of a higher level API for accessing configuration items. The SIP SIMPLE settings are defined using this API, however application-specific settings can also make use of it in order to define a consistent view of all the settings, by either extending the settings objects defined in the middleware or creating new settings objects.

The module sipsimple.configuration contains the main classes of the configuration API. These are:

• ConfigurationManager
• SettingsObject
• SettingsGroup
• Setting
• SettingsObjectExtension

In addition, the exceptions which make up this package are:

• ConfigurationError (base class for all other configuration errors)
• ObjectNotFoundError

The package sipsimple.configuration.backend contains the abstract interface for configuration backends, as well as concrete implementations of backends. This package is explained in more detail in Configuration Backend API.

ConfigurationManager¶

The central entity is the ConfigurationManager, which is used for storing and retrieving settings. Within the ConfigurationManager, settings can be represented in a hierarchical structure, where the root the of tree is the configuration document. This structure is represented using a dictionary, defined recursively as:

• the keys of the dictionary are unicode objects
• the values of the dictionary can be:
  • the None object (this represents a default value)
  • unicode objects
  • lists of unicode objects
  • dictionaries using this specification
    An item in the dictionary with an unicode object or a list as the value is a single setting: the name of the item is the name of the setting. An item with a dictionary as the value is a group of settings: the name of the item is the name of the group. This dictionary representation is stored to a persistent storage and loaded using the configuration backend as explained in Configuration Backend API. Any backend which is able to store and load such data can be used. A simple text file backend and a volatile memory backend are provided. After configuration data is loaded from the backend, it is saved on the ConfigurationManager and can be managed using its methods; in order to save the data using the backend provided, the save method needs to be called; any calls to update or delete will not ask the backend to store the data as well.

The ConfigurationManager class is a singleton to allow any part of the code to access it without the need to pass references. However, its start method needs to be called before it can be used. Once this is done, objects can be added, retrieved or deleted from the underlying storage; if using the SIPApplication class, its start method takes care of this passing as the backend the one it receives as an argument. The methods of ConfigurationManager are:

__init__(self)
References to the ConfigurationManager instance can be obtained anytime without passing any arguments. However, it needs the manager needs to be started in order to be used, otherwise all methods will raise a RuntimeError.
start(self)
The start method allows the ConfigurationManager instance to use the backend specified in SIPApplication complying to the Storage API for accessing the underlying storage. See Configuration Backend API for information on what the required interface for the passed object is. Raises a ConfigurationBackendError if the backend cannot load the configuration data from persistent storage.
update(self, group, name, data)
The partial data which must be a dictionary as formerly defined corresponding to an object having the specified name under the specified group. If group is None, the object will be saved top-level (its name will the a top-level key in the data dictionary). Note that changes will not be written to the underlying storage until the save method is called.
delete(self, group, name)
If an object stored as name exists in group, then it will be deleted. If group is None, then the top-level object identified by name will be deleted.
get(self, group, name)
Retrieves the object stored with name in group, if it exists. Otherwise, the method will raise an ObjectNotFoundError. If group is None, the top-level object identified by name will be retrieved.
get_names(self, group)
Returns a list with all the names of the objects in group. Returns an empty list if the group does not exist.
save(self)
Flushes the changes made to the configuration to the backend. This method must be called to ensure that all changes have been written to persistent storage. Raises a ConfigurationBackendError if the backend cannot store the data to persistent storage.

SettingsObject¶

A SettingsObject is used to represent a hierarchy of settings, which are managed via the ConfigurationManager. There are two types of SettingsObject:

• SettingsObjects without an ID, i.e. there should be only one instance of this SettingsObject in an application. When a subclass fo SettingsObject lacks a __id__ attribute, that is, it doesn't have an ID it is automatically a Singleton. This also means that the object cannot be deleted. An example of such a SettingsObject is SIPSimpleSettings. These SettingsObjects are useful to represent global settings.
• SettingsObjects with an associated id. The instances are not necessarily persistent. New ones can be created and existing ones can be deleted. An example of such a SettingsObject is the Account. These SettingsObjects are useful to represent settings which apply to entities identifiable by a string id. The ID can be changed, which means these objects cannot be Singletons.

SettingsObjects can belong to a group, depending on whether the __group__ attribute was specified. If it wasn't, the data will be saved top-level using the id of the SettingsObject; otherwise, the data will be saved under the group specified using the id. It is recommended that SettingsObjects with instances per id be saved in a group, although this is not enforced. For example, the Account instances are saved in a group named Accounts.

When a SettingsObject is instantiated its contained settings are loaded from the configuration storage. If it is the first time a SettingsObject is created, the default values for the settings will apply. The SettingsObject will only be copied to storage when its save method is called. If a SetttingsObject is deleted (by calling its delete method) it can no longer be saved, al subsequent calls to save will do nothing.

Defining a global SettingsObject¶

In order to define a global SettingsObject, the __id__ attribute must be defined on the class, while the __group__ attribute can be defined. The __id__ must not be used in any other SettingsObject which is stored in the same group (or globally if the __group__ attribute is missing). An example of defining a global SettingsObject:

from sipsimple.configuration import SettingsObject

class SIPSimpleSettings(SettingsObject):
    __group__ = 'Global'
    __id__ = 'SIPSimple'

The __init__ method must not accept any other argument except self. It will be called each time the settings are loaded from the storage, not only the first time the object is created.

Defining a per-id SettingsObject¶

In order to define a per-id SettingsObject, the __group__ attribute should be defined on the class, while the __id__ attribute must be left to None. When instantiating the resulting class, exactly one argument must be given, which represents the string id. Each class defined as a per-id SettingsObject should be allocated a different group from all the other SettingsObjects (including global ones), otherwise the keys under which the SettingsObjects are stored could overlap. An example of defining a per-id SettingsObject:

from sipsimple.configuration import SettingsObject

class Account(SettingsObject):
    __group__ = 'Accounts'
    def __init__(self, id):
        """Do something each time the Account is loaded""" 

The __init__ method must accept exactly one argument except self. It will be called each time the object is loaded from the storage, in addition to the first time the object is created. This allows the SettingsObject to be more than a simple collection of settings.

methods¶

save(self)
If the contained Settings of this SettingsObject have changed, the object will be saved to the persistent storage. A CFGSettingsObjectDidChange notification will be issued which contains the modified settings. If the save fails, a CFGManagerSaveFailed notification is issued in addition.
delete(self)
This method can only be called on per-id SettingsObjects. It will delete the object from the persistent storage. All references to this SettingsObject must be removed.

notifications¶

CFGManagerSaveFailed
This notification is sent when the save or delete method of a SettingsObject fail to save the data in the configuration manager storage backend. Attributes:

modified:

A dict instance which maps settings keys in their fully qualified form (attribute names seperated by '.', relative to the SettingsObject) to a ModifiedValue instance; the ModifiedValue instance contains two attributes: old and new which are set to the old and the new Setting's value respectively. If the object was never saved before, it will be None.

exception:

The exception object that was raised while attempting to save the data in the configuration manager.

operation:

Attempted opperation, one of 'save' or 'delete'.

timestamp:

A datetime.datetime object representing the moment the notification was sent.

CFGSettingsObjectDidChange
This notification is sent when the save method of a SettingsObject is called and some settings were previously changed. It will not be sent the first time save is called in an object. Attributes:

modified:

A dict instance which maps settings keys in their fully qualified form (attribute names seperated by '.', relative to the SettingsObject) to a ModifiedValue instance; the ModifiedValue instance contains two attributes: old and new which are set to the old and the new Setting's value respectively.

timestamp:

A datetime.datetime object representing the moment the notification was sent.

CFGSettingsObjectWasCreated
This notification is sent after a SettingsObject representing a configuration entity was saved for the first time. This notification will not be sent for global SettingsObject objects because they are never created, they always exist. Attributes:

timestamp:

A datetime.datetime object representing the moment the notification was sent.

CFGSettingsObjectWasActivated
For global SettingsObject objects this notification is sent after the single object instance is created. For dynamic ID SettingsObject objects, this notification is sent when the object has been loaded from the configuration manager (if the object existed) or the first time save is called on a new object. Attributes:

timestamp:

A datetime.datetime object representing the moment the notification was sent.

CFGSettingsObjectWasDeleted
This notification is sent after a SettingsObject has been deleted. Attributes:

timestamp:

A datetime.datetime object representing the moment the notification was sent.

Setting¶

The Setting descriptor is used to describe a setting in SettingsObjects. The following methods are part of the public API of it:
__init__(self, type, default=None, nillable=False)
Create a new Setting descriptor which represents a setting in all instances of a SettingsObject. The default value must be specified if the setting is not nillable. The type will be applied to the values which are set to this descriptor if the value is not already an instance of the type; it is not applied to the default value.

An example of using a setting:

from sipsimple import __version__
from sipsimple.configuration import Setting, SettingsObject

class SIPSimpleSettings(SettingsObject):
    __group__ = 'Global'
    __id__ = 'SIPSimple'

    user_agent = Setting(type=str, default='sipsimple %s' % __version__)

When a setting value is read from the configuration backend, the type is used to reconstruct the value from a unicode object, a list of unicode objects, or a dictionary containing unicode keys and values with any of these three types. Several built-in types are recognised and are handled automatically:

• bool: the unicode strings u'yes', u'true', {{{u'on' and u'1' are considered to have the value True, while u'no', u'false', u'off' and u'0' are considered to have the value False; the comparison is done case insensitively; all other strings are considered invalid.
• int, long and basestring: the type is called using the value as an argument.
  All other types are instantiated using an un-pickling like mechanism. The __new__ method is called without any arguments and __setstate__ is called on the object returned by __new__ using the value as the sole argument.

Saving a setting value is done similarly, according to type. The builtin types which are handled are the same:

• bool: the unicode objects u'true' and u'false are used depending on the value.
• int, long and basestring: unicode is called with the value as the sole argument.
  For all other types, the __getstate__ method is called which should return an appropriate value.

SettingsGroup¶

A SettingsGroup allows settings to be structured hierarchically. Subclasses of SettingsGroup are containers for Settings and other SettingsGroups just as SettingsObjects are. In addition, the subclasses of SettingsGroup are descriptors and can be used as such to assign a SettingsGroup as a child of another SettingsGroup or a SettingsObject. An example usage containing Setting, SettingsGroup and SettingsObject:

from sipsimple import __version__
from sipsimple.configuration import Setting, SettingsGroup, SettingsObject

class TLSSettings(SettingsGroup):
    verify_server = Setting(type=bool, default=False)

class SIPSimpleSettings(SettingsObject):
    __group__ = 'Global'
    __id__ = 'SIPSimple'

    user_agent = Setting(type=str, default='sipsimple %s' % __version__)

    tls = TLSSettings

SettingsObjectExtension¶

The SettingsObjectExtension allows an application to add or customize the settings of the middleware according to its needs. In order to add or replace settings/settings groups defined in another SettingsObject, SettingsObjectExtension can be subclassed and the register_extension class method of the original SettingsObject can be called passing the SettingObjectExtension subclass as the sole argument. In order to add/replace settings in a group of settings, the original SettingsGroup can be subclassed. Example:

from sipsimple import __version__
from sipsimple.configuration import Setting, SettingsGroup, SettingsObject, SettingsObjectExtension

class TLSSettings(SettingsGroup):
    verify_server = Setting(type=bool, default=False)

class SIPSimpleSettings(SettingsObject):
    __group__ = 'Global'
    __id__ = 'SIPSimple'

    user_agent = Setting(type=str, default='sipsimple %s' % __version__)

    tls = TLSSettings

class TLSSettingsExtension(TLSSettings):
    verify_client = Setting(type=bool, default=True)

class SIPSimpleSettingsExtension(SettingsObjectExtension):
    default_account = Setting(type=str, default=None, nillable=True)

    tls = TLSSettingsExtension

SIPSimpleSettings.register_extension(SIPSimpleSettingsExtension)

Backend API¶

The backend API provides a way to use the configuration framework consistently, while using any system for storing the data persistently. The ConfigurationManager makes use of a backend whenever it needs to write/read something to the persistent storage. The backend only needs to know how to handle data in the dictionary format explained in Configuration Manager. In order to use a specific backend, it is given to the ConfigurationManager in its start method.

The interface sipsimple.configuration.backend.IBackend describes the backend:
load()
Load the configuration data using whatever means employed by the backend implementation and return a dictionary conforming to the definition in Configuration Manager.
save(data)
Given a dictionary conforming to the definition in this interface, save the data using whatever means employed by the backend implementation.

FileBackend¶

A concrete implementation of the IBackend interface resides in sipsimple.configuration.backend.file.FileBackend. The methods different from the ones in IBackend are:

__init__(self, filename, encoding='utf-8')
Create a new FileBackend which uses the specified filename for loading and storing the data to; the data is written using the specified encoding, defaulting to UTF-8.

This object saves the data using a simple text file format with the following syntax:

• SettingGroups, SettingsObjects or Groups of SettingsObjects are represented by their name (or id in the case of SettingsObjects) followed by a colon (*:*). These containers can contain other such containers or simple settings. Their children need to be indented more that the container itself. The indentation need not be consistent.
  

   Accounts:
      user@domain:
        display_name = User
        tls:
          certificate =
  

• Simple settings are represented by a name followed by an equals sign and the value; whitespace anywhere in between is ignored. The different values are represented in the following way:
  • None is represented by the absence of a value.
    

        setting =
    

  • Unicode objects are represented by a simple string (which can be quoted to include leading and trailing whitespace by either single or double quotes) and can have the following espace sequances: \' *, *\", \n, \r. The unicode characters are encoded using the encoding specified in the constructor.
    

        setting1 = value
        setting2 = value with spaces
        setting3 = "  value with leading and trailing spaces  " 
        setting4 = value with a line feed\n
    

  • Lists are represented by unicode strings as described above separated by commas (*,*). Any not-quoted whitespace around the comma is ignored.
    

        setting = a, b  , c
    

  • Complex settings can be represented just like a group:
    

        complex_setting:
          field1 = value
          field2 = 123
    

MemoryBackend¶

A concrete implementation of the IBackend interface resides in sipsimple.configuration.backend.memory.MemoryBackend.

Middleware Settings¶

These are the current settings, kept in the modules sipsimple.configuration.settings and sipsimple.account. The main classes used to access the settings are Account, BonjourAccount and SIPSimpleSettings. All settings can be accessed as simple attributes. The types of attributes is described for each setting below. When setting the value of an attribute, if it's not of the required type, it will be given to the specified type as the only argument. The modified settings are not saved to the persistent storage until the save method is called on the main object. Once this is done, a CFGSettingsObjectDidChange notification is sent, the data of which is explained in SettingsObject Notifications.

Only a nillable setting can be assigned the value None, even if the type of the setting would otherwise accept None as an argument. The settings as described below are not nillable, unless specified explicitely. To reset the value of a setting, the special object sipsimple.configuration.DefaultValue can be assigned to it. If a default value is not explicitely specified below, it defaults to None. Note that a non-nillable setting cannot have the default value of None.

General¶

SIP SIMPLE settings:
             +-- default_account = user@example.com
SIP SIMPLE --|-- user_agent = sipsimple 0.16.2
             |-- audio
             |-- chat
             |-- desktop_sharing
             |-- file_transfer
             |-- logs
             |-- rtp
             |-- sip
             |-- sounds
             +-- tls

        +-- alert_device = system_default
audio --|-- input_device = system_default                   
        |-- output_device = system_default
        |-- sample_rate = 44100
        |-- silent = False
        +-- tail_length = 0

       +
chat --|
       +

                  +
desktop_sharing --|
                  +

                +
file_transfer --|
                +

logs --|-- pjsip_level = 5

      +-- audio_codec_list = AudioCodecList(['G722', 'PCMU', 'GSM', 'speex', 'PCMA'])
rtp --|-- port_range = PortRange(start=50000, end=50500)
      +-- timeout = 30

      +-- invite_timeout = 90
sip --|-- tcp_port = 0
      |-- tls_port = 0
      |-- transport_list = SIPTransportList(['tls', 'tcp', 'udp'])
      +-- udp_port = 0

      +-- ca_list = None
tls --|-- protocol = TLSv1
      +-- timeout = 3000

The sipsimple.configuration.settings.SIPSimpleSettings class is a singleton can be instantiated and used anywhere after the ConfigurationManager has been started.

The settings are explained below:

SIPSimpleSettings.default_account (type=str, default='bonjour@local', nillable=True)

A string, which contains the id of the default Account. This setting is managed by the AccountManager and should not be changed manually. See AccountManager for more information.

SIPSimpleSettings.user_agent (type=str, default='sipsimple VERSION')

This setting will be used to set the value of the User-Agent header in outgoing SIP requests and of the Server header in all SIP responses.

Audio¶

SIPSimpleSettings.audio.alert_device (type=AudioOutputDevice, default='system_default', nillable=True)

The name of the alert device, which can be used for alerting the user. If it is set to 'system_default', one will be selected automatically by the operating system; if it is set to None, a dummy device will be used which will discard any audio data. This device is not used by the middleware but is provided for consistency.

SIPSimpleSettings.audio.input_device (type=AudioInputDevice, default='system_default', nillable=True)

The name of the audio device, which will be used for input (recording). If it is set to 'system_default', one will be selected automatically by the operating system; if it is set to None, a dummy device will be used which doesn't record anything.

SIPSimpleSettings.audio.output_device (type=AudioOutputDevice, default='system_default', nillable=True)

The name of the audio device, which will be used for output (playback). If it is set to 'system_default'}}, one will be selected automatically by the operating system; if it is set to {{{None, a dummy device will be used which will discard any audio data.

SIPSimpleSettings.audio.tail_length (type=NonNegativeInteger, default=200)

This setting is used as a parameter for the audio echo cancellation algorithm. It's value is a non-negative integer which represents milliseconds. It specifies the length of the echo cancellation filter.

SIPSimpleSettings.audio.sample_rate (type=SampleRate, default=44100)

This is the sample rate at which the audio system runs, in Hz. All playback and recording will be done at this rate. If an audio codec has a smaller or larger sample rate, it will be resampled to this value (if possible). Example values include 8000, 32000, 44100 etc.

SIPSimpleSettings.audio.silent (type=bool, default=False)

If this setting is set to True, no audio notifications will be played on the alert device (the volume of the alert device will be set to 0).

Chat¶

Empty section for future use.

Desktop Sharing¶

Empty section for future use.

File Transfer¶

Empty section for future use.

Logs¶

SIPSimpleSettings.logs.pjsip_level (type=NonNegativeInteger, default=5)

This setting controls the amount of log messages generated by the PJSIP core. It must be set to a non-negative integer.

RTP¶

SIPSimpleSettings.rtp.port_range (type=PortRange, default=PortRange(50000, 50500))

This setting controls the port range from which ports used by RTP transport will be assigned. The values of the ports need to be in the range 1-65535; the start port must not be larger than the end port.

SIPSimpleSettings.rtp.audio_codec_list (type=AudioCodecLis}t}}, default={{{AudioCodecList(('G722', 'speex', 'PCMU', 'PCMA')))

This setting is used to specify the preferred audio codecs, which should be used for audio calls. It must contain only strings, which represent the supported codecs (speex, G722, PCMA, PCMU, iLBC and GSM), in the order in which they are preferred. This setting can be overridden per account.

SIPSimpleSettings.rtp.timeout (type=NonNegativeInteger}t}}, default={{{30)))

This setting is used to specify the time after which a notification is raised should no RTP be received from the other end. It can be used by an application to decide to terminate the session or print an alert.

SIP¶

SIPSimpleSettings.sip.invite_timeout (type=NonNegativeInteger, default=90)

This setting is used to terminate an outgoing session request in progress that does not receive a final answer before this internal in seconds is reached.

SIPSimpleSettings.sip.udp_port (type=Port, default=0)

This is the port on which the Engine will bind and for for sending and receiving UDP packets. It is an integer in the range 0-65535. If it is set to 0, it will be allocated automatically.

SIPSimpleSettings.sip.tcp_port (type=Port, default=0)

This is the port on which the Engine will listen for TCP connections. It is an integer in the range 0-65535. If it is set to 0, it will be allocated automatically.

SIPSimpleSettings.sip.tls_port (type=Port, default=0)

This is the port on which the Engine will listen for TLS connections. It is an integer in the range 0-65535. If it is set to 0, it will be allocated automatically. The port must be different than the port used for TCP connections.

SIPSimpleSettings.sip.transport_list (type=SIPTransportList, default=SIPTransportList(('tls', 'tcp', 'udp')))

This setting's value is a tuple, which can only contain the strings 'tls', 'tcp' and 'udp'. It has a double purpose:

• Only the transports specified here are used to SIP requests associated with normal accounts.
• The order of the transports specified in this tuple represent the preferred order in which transports should be used. This applies to all SIP requests.

TLS¶

SIPSimpleSettings.tls.ca_list (type=Path, default=None, nillable=True)

The settings points to a file which contains the CA certificates. In can be None, in which case no CAs are available. It is interpreted as an absolute path, with a leading _~_ expanded to the home directory of the current user. In order to access the full path to the CA file, the normalized attribute on the setting can be used:

  SIPSimpleSettings().tls.ca_list.normalized

SIPSimpleSettings.tls.protocol (type=TLSProtocol, default='TLSv1')

This setting sets the version of the TLS protocol which will be used. It is a string and must be one of 'TLSv1'.

SIPSimpleSettings.tls.timeout (type=NonNegativeInteger, default=3000)

This is the timeout for negotiating TLS connections, in milliseconds. It must be an non-negative integer.

Account¶

Account user@example.com:
          +-- display_name = Example User
account --|-- enabled = True
          |-- auth
          |-- dialog_event
          |-- message_summary
          |-- msrp
          |-- nat_traversal
          |-- presence
          |-- rtp
          |-- sip
          |-- tls
          +-- xcap

       +-- password = xyz
auth --|-- username = None
       +

               +-- enabled = True
dialog_event --|
               +

                  +-- enabled = True
message_summary --|-- voicemail_uri = None
                  +

       +-- connection_model = relay
msrp --|-- transport = tls
       +

                +-- msrp_relay = None
nat_traversal --|-- stun_server_list = None
                |-- use_ice = False
                |-- use_msrp_relay_for_inbound = True
                +-- use_msrp_relay_for_outbound = False

           +-- enabled = True
presence --|-- use_rls = True
           +

      +-- audio_codec_list = None
rtp --|-- inband_dtmf = False
      |-- srtp_encryption = optional
      +-- use_srtp_without_tls = False

      +-- always_use_my_proxy = False
sip --|-- outbound_proxy = SIPProxyAddress('sip.example.com', port=5060, transport='udp')
      |-- publish_interval = 3600
      |-- register = True
      |-- register_interval = 3600
      +-- subscribe_interval = 3600

      +-- certificate = tls/user@example.com.crt
tls --|-- verify_server = False
      +

       +-- enabled = True
xcap --|-- xcap_root = None
       +

The Account object is used to represent a normal SIP account registered at a SIP provider. It is uniquely identifiable by it's SIP ID, in the form user@domain. There is exactly one instance of Account per ID, which means that an Account can be accessed by instantianting it anywhere. However, this is not the recommended way of accessing accounts, since it can lead to creating new accounts. The recommended way is by using the AccountManager. Information about the roles of Account, apart from being a collection of settings, is explained in the Middleware API.

The settings that can be accessed on an Account are described below:

Account.id (type=SIPAddress)

Its type is a subclass of str, so it can be used as a normal string, however it also has two attributes username and domain which point to the specific parts of the SIP address.

Account.display_name (type=unicode, default=None, nillable=True)

The contents of this setting will be sent as part of the From header when sending SIP requests, the From CPIM header and other similar information.

Account.enabled (type=bool, default=False)

If this setting is set to True, the Account will automatically activate and can be used in other parts of the middleware. More about this is described in Account.

Auth¶

Account.auth.username (type=str, default=None, nillable=True)

The username used for authentication if it is different from the one in the SIP ID of the account. If it is None or an empty string, the account SIP ID username will be used instead.

Account.auth.password (type=str, default='')

The password, which will be used with this account for authentication.

Dialog Event¶

Account.dialog_event.enabled (type=bool, default=True)

If this setting is set to True, the Account will subscribe to the dialog event as specified by RFC4235.

MSRP¶

Account.msrp.transport (type=MSRPTransport, default='tls')

MSRP can use either TLS or TCP and this setting controls which one should be used for normal accounts.

Account.msrp.connection_model (type=MSRPConnectionModel, default='relay')

Whether relay or acm connection models shall be used for NAT traversal purposes.

Message Summary¶

Account.message_summary.enabled (type=bool, default=True)

If this setting is set to True, the Account will subscribe to the message-summary event, as specified by RFC3842.

Account.message_summary.voicemail_uri (type=str, default=None, nillable=True)

This is the SIP URI where the Subscribe is sent and where the user can call to listen to the voicemail messages.

NAT Traversal¶

Account.nat_traversal.use_ice (type=bool, default=False)

If this setting is set to True, ICE will be used for finding media candidates for communication over NAT-ed networks.

Account.nat_traversal.stun_server_list (type=StunServerAddressList, default=None, nillable=True)

This setting used for NAT traversal can be used to specify the addresses of the STUN servers used for detecting server reflexive candidates in the context of ICE. The value of the setting is a tuple of objects of type StunServerAddress. If None, the servers will be looked up in the DNS (SRV record _stun._udp.domain).

Account.nat_traversal.msrp_relay (type=MSRPRelayAddress, default=None, nillable=True)

This setting can be used to specify a MSRP relay for use in MSRP connections. If it is set to None. If None, the servers will be looked up in the DNS (SRV record _msrps._tcp.domain).

Account.nat_traversal.use_msrp_relay_for_inbound (type=bool, default=True)

If this setting is set to True, the MSRP relay will be used for all incoming MSRP connections.

Account.nat_traversal.use_msrp_relay_for_outbound (type=bool, default=False)

If this setting is set to True, the MSRP relay will be used for all outgoing MSRP connections.

Presence¶

Account.presence.enabled (type=bool, default=True)

If this setting is set to True, the Account will publish its presence state and subscribe to presence and presence.winfo Event packages.

Account.presence.use_rls (type=bool, default=False)

If this setting is set to True, the Account will store its Buddy Lists in rls-services XCAP document and send a single Subscribe for the presence event to the RLS services address to obtain the presence information for its buddies. If it is set to False, it will subscribe to each buddy individually.

RTP¶

Account.rtp.audio_codecs (type=AudioCodecList, default=None, nillable=True)

This setting is used to specify the preferred audio codecs, which should be used for audio calls of this account. It must be a tuple containing only strings, which represent the supported codecs (speex, g722, g711, ilbc and gsm), in the order in which they are preferred, or None if the codec_list from the general rtp settings is to be used.

Account.audio.srtp_encryption (type=SRTPEncryption, default='optional')

The value of this setting specifies how the account requires the calls to be encrypted using SRTP. It can be one of the values 'disabled', 'optional' or 'mandatory'.

Account.audio.use_srtp_without_tls (type=bool, default=False)

If this setting is set to True, SRTP could be used even if the SIP signaling used to control the call is not over TLS.

SIP¶

Account.sip.always_use_my_proxy (type=bool, default=False)

If this setting is set to True and the outbound proxy is not set, the signalling for outbound requests going to foreign domains will be sent to the account proxy instead of sending it to the foreign proxy.

Account.sip.outbound_proxy (type=SIPProxyAddress, default=None, nillable=True)

This setting specifies whether to send all SIP requests when creating a new SIP dialog to a specific proxy. If this setting is set to None, then an RFC3263 lookup will be done based on the domain part of the SIP request URI.

Account.sip.register (type=bool, default=True)

If this setting is set to True, the Account will automatically register when it is active. More about this is described in Account.

Account.sip.publish_interval (type=NonNegativeInteger, default=3600)

This setting controls the number of seconds used for the Expire header when publishing events. It must be a non-negative integer.

Account.sip.subscribe_interval (type=NonNegativeInteger, default=3600)

This setting controls the number of seconds used for the Expire header when subscribing to events. It must be a non-negative integer.

Account.registration.interval (type=NonNegativeInteger, default=600)

This setting controls the number of seconds used for the Expire header when registering. It must be a non-negative integer.

TLS¶

Account.tls.certificate (type=Path, default=None, nillable=True)

The path to the file that contains the certificate and its private key used to authenticate on TLS connections. It is interpreted as an absolute path, with a leading _~_ expanded to the home directory of the current user. In order to access the full path to the TLS certificate, the normalized attribute on the setting can be used:

  account.tls.certificate.normalized

Account.tls.verify_server (type=bool, default=False)

If this setting is set to True, the middleware will verify the server's certificate when connecting via TLS.

XCAP¶

Account.xcap.enabled (type=bool, default=True)

If this setting is set to True, The use of XCAP root set below will be activated.

Account.xcap.xcap_root (type=XCAPRoot, default=None, nillable=True)

The XCAP root is required for accessing documents via the XCAP protocol. It must be a URL with either the http or https schemes.

BonjourAccount¶

Account bonjour@local:
          +-- display_name = Bonjour User
account --|-- enabled = False
          |-- msrp
          |-- rtp
          |-- sip
          +-- tls

       +-- transport = tcp
msrp --|
       +

      +-- audio_codec_list = None
rtp --|-- inband_dtmf = False
      |-- srtp_encryption = optional
      +-- use_srtp_without_tls = False

      +-- transport_list = SIPTransportList(['udp'])
sip --|
      +

      +-- certificate = tls/bonjour@local.crt
tls --|-- verify_server = False
      +

The BonjourAccount is a singleton object as there can only be one bonjour account on a system. A bonjour account is used in P2P mode and does not interact with any server. Similar to the Account, it is used both as a complex object, which contains the required behavior for bonjour, as well as a container for the settings which apply to it.

The settings of the BonjourAccount are described below:

BonjourAccount.id (type=SIPAddress)

This is not a setting, as it is the static string 'bonjour@local' which represents the id of the BonjourAccount.

BonjourAccount.enabled (type=bool, default=True)

If this setting is set to True, the account will be used. More information about this is in BonjourAccount.

BonjourAccount.display_name (type=unicode, default=None, nillable=True)

The contents of this setting will be sent as part of the From header when sending SIP requests.

MSRP¶

SIPSimpleSettings.msrp.transport (type=MSRPTransport, default='tcp')

MSRP can use either TLS or TCP and this setting controls which one should be used for the bonjour account.

RTP¶

BonjourAccount.rtp.audio_codec_list (type=AudioCodecList, default=('speex', 'g722', 'g711', 'ilbc', 'gsm'))

This setting is used to specify the preferred audio codecs, which should be used for audio calls of this account. It must be a tuple containing only strings, which represent the supported codecs (speex, g722, g711, ilbc and gsm), in the order in which they are preferred.

BonjourAccount.rtp.srtp_encryption (type=SRTPEncryption, default='optional')

The value of this setting specifies how the account requires the calls to be encrypted using SRTP. It can be one of the values 'disabled', 'optional' or 'mandatory'.

BonjourAccount.rtp.use_srtp_without_tls (type=bool, default=False)

If this setting is set to True, SRTP could be used even if the SIP signaling used to control the call is not over TLS.

TLS¶

BonjourAccount.tls.certificate (type=Path, default=None, nillable=True)

The path to the file that contains the certificate and its private key used to authenticate on TLS connections. It is interpreted as an absolute path, with a leading _~_ expanded to the home directory of the current user. In order to access the full path to the certificate file, the normalized attribute on the setting can be used:

  BonjourAccount().tls.ca_list.normalized

BonjourAccount.tls.verify_server (type=bool, default=False)

If this setting is set to True, the middleware will verify the server's certificate when connecting via TLS.

SIPClients Settings¶

The SIPClients scripts use the Configuration API to extend the settings in the middleware with some application-specific settings. The following sections list these additional settings in order to provide an example for the kind of settings which, being application specific, do not find their place in the middleware and should be added by the application.

General¶

SIPSimpleSettings.user_data_directory (type=AbsolutePath, default='~/.sipclient)

This is the directory, which will be used by default for storing the SIP SIMPLE data. The relative paths are calculated on runtime based on this setting, which means that if this setting is changed, all relative paths will point inside the new directory. It is a string, which must be an absolute path.

SIPSimpleSettings.resources_directory (type=AbsolutePath, default=None)

This is the directory, which will be used by default for storing the sound files played for various notifications.

Audio¶

SIPSimpleSettings.audio.directory (type=DataPath, default=DataPath('history'))

This directory will be used to store recorded audio conversations. Under this directory, a subdirectory per account with the id of the account as the name will be created. If it is set to relative path, it is taken relative to SIPSimpleSettings.user_data_directory; otherwise it is interpreted as an absolute path. In order to access the full path to the history directory, the value attribute on the setting can be used:

  SIPSimpleSettings().audio.directory.value

File Transfer¶

SIPSimpleSettings.file_transfer.directory (type=DataPath, default=DataPath('file_transfers'))

This directory is used to store the files obtained via MSRP file transfer. If it is set to relative path, it is taken relative to SIPSimpleSettings.user_data_directory; otherwise it is interpreted as an absolute path. In order to access the full path to the history directory, the value attribute on the setting can be used:

  SIPSimpleSettings().file_transfer.directory.value

Logs¶

SIPSimpleSettings.logs.directory (type=DataPath, default=DataPath('logs'))

This is the directory where the logs create by the SIP SIMPLE middleware will be stored. If it is set to relative path, it is taken relative to SIPSimpleSettings.user_data_directory; otherwise it is interpreted as an absolute path. In order to access the full path to the history directory, the value attribute on the setting can be used:

  SIPSimpleSettings().logs.directory.value

SIPSimpleSettings.logs.trace_sip (type=bool, default=False)

If this setting is set to True, the SIP packets will be written to a log file named 'sip_trace.txt', inside the directory pointed by SIPSimpleSettings.logging.directory.

SIPSimpleSettings.logs.trace_pjsip (type=bool, default=False)

If this setting is set to True, the PJSIP log messages will be written to a log file named 'pjsip_trace.txt', inside the directory pointed by SIPSimpleSettings.logging.directory.

SIPSimpleSettings.logs.trace_msrp (type=bool, default=False)

If this setting is set to True, the MSRP packets will be written to a log file named 'msrp_trace.txt', inside the directory pointed by SIPSimpleSettings.logging.directory.

SIPSimpleSettings.logs.trace_xcap (type=bool, default=False)

If this setting is set to True, the XCAP packets will be written to a log file named 'xcap_trace.txt', inside the directory pointed by SIPSimpleSettings.logging.directory.

Sounds¶

SIPSimpleSettings.sounds.audio_inbound (type=AbsolutePath, default=None, nillable=True)

This setting should point to a wav file, which will be played when a SIP session request is received. If it is set to None, no sound will be played.

SIPSimpleSettings.sounds.audio_outbound (type=AbsolutePath, default=None, nillable=True)

This setting should point to a wav file, which will be used as ringtone during an outgoing SIP session request as a response to a 180 Ringing. If it is set to None, no sound will be played.

SIPSimpleSettings.sounds.file_sent (type=AbsolutePath, default=None, nillable=True)

This setting should point to a wav file, which will be played when an outgoing file transfer is finished. If it is set to None, no sound will be played.

SIPSimpleSettings.sounds.file_received (type=AbsolutePath, default=None, nillable=True)

This setting should point to a wav file, which will be played when an incoming file transfer is finished. If it is set to None, no sound will be played.

SIPSimpleSettings.sounds.message_sent (type=AbsolutePath, default=None, nillable=True)

This setting is a string representing an absolute path to a wav file, which is played when a message is sent in a chat session. If it is set to None, no sound is played.

SIPSimpleSettings.sounds.message_received (type=AbsolutePath, default=None, nillable=True)

This setting is a string representing an absolute path to a wav file, which is played when a message is received in a chat session. If it is set to None, no sound is played.

Account¶

Sounds¶

Account.sounds.audio_inbound (type=AbsolutePath, default=None, nillable=True)

This setting should point to a wav file, which will be used to play the incoming ringtone. If it is set to None, the wav file set in SIPSimpleSettings.sounds.audio_inbound will be used instead.

BonjourAccount¶

Sounds¶

BonjourAccount.sounds.audio_inbound (type=AbsolutePath, default=None, nillable=True)

This setting should point to a wav file which will be used as the incoming ringtone. If it is set to None, the wav file set in SIPSimpleSettings.sounds.audio_inbound will be used instead.