Diameter Server Output

Introduction

The Diameter protocol is an authentication, authorization, and accounting protocol for computer networks that evolved from and replaces the RADIUS protocol that preceded it.

The TIBCO StreamBase® Server Output Adapter for Diameter is used to push Diameter tuple messages from the EventFlow to the Diameter socket connections. The adapter only accepts Diameter messages that this adapter is set up to receive. Multiple output adapters can be used on the same configuration to reduce the number of ports on each adapter and to help to organize the application. The application commands property on the property page is used to determine which messages from the Diameter dictionary are to be received into the adapter from the EventFlow.

Diameter Server Routing

If there are multiple connections to a server for an origin-host and the input tuple of the Diameter Server Output Adapters socket identifier is null then the adapter will pick the first connection that matches the origin-host, if no connection is found then origin-realm will be used to find a connection. If no match is found for socket identifier, origin-host, or origin-realm then the message is not sent and a write error is output on the status port.

Adapter Properties

This section describes the properties you can set for this adapter, using the various tabs of the Properties view in StreamBase Studio.

General Tab

Name: Use this required field to specify or change the name of this instance of this component, which must be unique in the current EventFlow module. The name must contain only alphabetic characters, numbers, and underscores, and no hyphens or other special characters. The first character must be alphabetic or an underscore.

Adapter: A read-only field that shows the formal name of the adapter.

Start with application: If this field is set to Yes (default) or to a module parameter that evaluates to true, this instance of this adapter starts as part of the JVM engine that runs this EventFlow fragment. If this field is set to No or to a module parameter that evaluates to false, the adapter instance is loaded with the engine, but does not start until you send an epadmin container resume command (or its sbadmin equivalent), or until you start the component with StreamBase Manager.

Enable Error Output Port: Select this check box to add an Error Port to this component. In the EventFlow canvas, the Error Port shows as a red output port, always the last port for the component. See Using Error Ports to learn about Error Ports.

Description: Optionally enter text to briefly describe the component's purpose and function. In the EventFlow Editor canvas, you can see the description by pressing Ctrl while the component's tooltip is displayed.

Operator Properties Tab

Property Type Description
Diameter Configuration Edit Button Shortcut to the StreamBase Configuration File Editor, used for adapter configuration or converting an existing application's adapter-configurations.xml file to HOCON format.
Adapter Configuration Drop-down list The adapter configuration from the configuration file to use with this adapter.
Output Filled Tuple check box Output Adapter Only. If enabled the input tuple will be filled with header information and output after writing to the connection.
Application Commands string This is the list of Application and Command codes that this adapter instance will expose on its ports. The format of this field is ApplicationName|CommandCode,ApplicationName|CommandCode with each set of application and command being separated by a comma and each application and CommandCode being separated by a | character. Each application and command code set produces a tuple on the adapters output port with the generated schema, based on the dictionary for the command required. Any dash characters in the names will be replaced by underscores in the tuples field name.
Handle Errors check box If enabled the operator will handle diameter error messages. When enabled, a field named Error is added to the output tuple. If an error occurs the applicationId will be Base and the commandCode will be Error and the Error field will be populated.

Concurrency Tab

Use the Concurrency tab to specify parallel regions for this instance of this component, or multiplicity options, or both. The Concurrency tab settings are described in Concurrency Options, and dispatch styles are described in Dispatch Styles.

Caution

Concurrency settings are not suitable for every application, and using these settings requires a thorough analysis of your application. For details, see Execution Order and Concurrency, which includes important guidelines for using the concurrency options.

Diameter Input Ports

Diameter Input Static Fields

The schema for the input port is partially static fields created by the adapter and partially dynamically created based on the dictionary provided. The static part of the message must contain the following fields.

Field Name Field Type Description
applicationId string The application ID of this Diameter message.
commandCode string The command code of this Diameter message.
*Error Tuple This field is only available when the Handle Errors adapter property is checked. This tuple contains all information required to handle an error; the structure is defined in the Diameter Error Fields section.

Diameter Input Error Fields

If Handle Errors is enabled, an Error field is added to the tuple and its schema is defined below. This field is used if the applicationId is set to Base and the commandCode is set to Error.

Field Name Field Type Description
socketIdentifier string This is a unique identifier for each client socket connection. This field is required for the output adapter when sending a Diameter message. The controller adapter will also output this value as part of the info field of a connection status message.
receiveType string This field is currently ignored and provided for parity with other generated field definitions.
sendType string This MUST be set to answer.
receivedTime timestamp This field is for information purposes only. It does not need to be set to send a message and is ignored.
receivedTimeNanoSeconds long This field is for information purposes only. It does not need to be set to send a message and is ignored.
latencyNanoSeconds long This field is for information purposes only. It does not need to be set to send a message and is ignored.
answerMessage tuple The messages schema is well defined by the adapter. The sendType must be set to answer and the values in this tuple are used when creating the outbound Diameter error message.
answerMessage.header.version int The version of the Diameter application.
answerMessage.header.length int The length of the Diameter message. If this value should be set to 0 if creating a new error message to send.
answerMessage.header.request boolean This value must be false if creating a new error message to send.
answerMessage.header.proxiable boolean A Boolean flag that determines if this message is proxiable. This value should be set to the same value as the request message that caused the error to be generated.
answerMessage.header.error boolean This value must be set to true.
answerMessage.header.retransmitted boolean A Boolean flag that determines if this message was retransmitted.
answerMessage.header.commandCode int The command code of the Diameter message that caused the error.
answerMessage.header.applicationId long The application ID of the Diameter message that caused the error.
answerMessage.header.hopByHop int This field is used to match the requests with their answers as the same value in the request is used in the response. This value is automatically filled in when sending a message.
answerMessage.header.endToEnd int This field is used to detect duplicate messages along with the combination of the Origin-Host AVP. This value is automatically filled in when sending a message.
answerMessage.answerMessage.Origin_Host string The origin host
answerMessage.answerMessage.Origin_Realm string The origin realm
answerMessage.answerMessage.Result_Code long The result code to send
answerMessage.answerMessage.Error_Messsage string The optional human readable error message to give context to the result code
answerMessage.answerMessage.Error_Reporting_Host string The optional error reporting host
answerMessage.answerMessage.Session_Id string The session id
answerMessage.answerMessage.Failed_AVP list The list of AVP values that caused this error or null if none
answerMessage.answerMessage.Failed_AVP.code int The AVP code
answerMessage.answerMessage.Failed_AVP.vendorId int The AVP vendor id
answerMessage.answerMessage.Failed_AVP.data blob The AVPs data if any. If not supplied the length value is used and null values written to the length.
answerMessage.answerMessage.Failed_AVP.length length The AVPs data length. If data is not null then its length is used. If data is null then this value is used to write length number of null bytes. If this value is null then the system attempts to find the code in the dictionary and use its data type length. If the code cannot be found then a length of 0 is used.

Diameter Input Dynamic Fields

The schema for the input ports are partially static fields created by the adapter and partially dynamically created based on the dictionary provided. The following explains the fields that the adapter creates for each application and command code specified. Not all fields are required to be filled out to send a Diameter message. The required fields will vary depending on the message based on the dictionary file selected and its requirements. The field socketIdentifier and sendType must have a value of request or answer. If this is a request message then the requestMessage.header.applicationId and requestMessage.header.commandCode must be set, which determine the Diameter message type to send.

Field Name Field Type Description
socketIdentifier string This is a unique identifier for each client socket connection. This field is required for the output adapter when sending a Diameter message. The controller adapter will also output this value as the object field of a connection status message.
receiveType string This field will be one of two values: answer or request, and will be filled out by the adapter when a message is received from the Diameter connection. If the value is answer that means the Diameter message is an answer to a request that had been previously sent. If the value is request that means this is a request message. This value should be blank when starting a new request and sending a tuple into an output adapter. If this value is not blank it is ignored.
sendType string This field will be one of two values: answer or request. This value should be set by your EventFlow application to tell the output adapter how to handle sending this message. If the value is request the output adapter uses the requestMessage field as the value to send; if the value is answer the output adapter uses the answerMessage field as the value to send.
receivedTime timestamp This field is for information purposes only. It does not need to be set to send a message, and is ignored.
receivedTimeNanoSeconds long This field is for information purposes only. It does not need to be set to send a message, and is ignored.
latencyNanoSeconds long This field is for information purposes only. It does not need to be set to send a message, and is ignored.
requestMessage tuple This field is dynamically created for each message type that this adapter is set up to handle. The messages schema is created by using the dictionary file provided. Although this message is dynamically created, a standard Diameter header is also provided. If the sendType is set to request then the values in this tuple are used when creating the outbound Diameter message.
requestMessage.header.version int The version of the Diameter application. This value is automatically filled in when sending a message based on the adapter configuration.
requestMessage.header.length int The length of the Diameter message. This value is automatically filled in when sending a message.
requestMessage.header.request boolean This value is automatically filled in when sending a message.
requestMessage.header.proxiable boolean A Boolean flag which determines whether this message is proxiable.
requestMessage.header.error boolean This value is automatically filled in when sending a message.
requestMessage.header.retransmitted boolean A Boolean flag that determines if this message was retransmitted.
requestMessage.header.commandCode int The command code of this Diameter message. This value is required when sending a request message.
requestMessage.header.applicationId long The application ID of this Diameter message. This value is required when sending a request message.
requestMessage.header.hopByHop int This field is used to match the requests with their answers, as the same value in the request is used in the response. This value is automatically filled in when sending a message.
requestMessage.header.endToEnd int This field is used to detect duplicate messages along with the combination of the Origin-Host AVP. This value is automatically filled in when sending a message.
answerMessage tuple This field is dynamically created for each message type that this adapter is set up to handle. The messages schema is created by using the dictionary file provided. Although this message is dynamically created, a standard Diameter header is also provided. If the sendType is set to answer then the values in this tuple are used when creating the outbound Diameter message.
answerMessage.header.version int The version of the Diameter application. This value is automatically filled in when sending a message based on the adapter configuration.
answerMessage.header.length int The length of the Diameter message. This value is automatically filled in when sending a message.
answerMessage.header.request boolean This value is automatically filled in when sending a message.
answerMessage.header.proxiable boolean A Boolean flag that determines if this message is proxiable.
answerMessage.header.error boolean This value is automatically filled in when sending a message.
answerMessage.header.retransmitted boolean A Boolean flag that determines if this message was retransmitted.
answerMessage.header.commandCode int The command code of this Diameter message. This value is required to send a request message.
answerMessage.header.applicationId long The application ID of this Diameter message. This value is required when sending a request message.
answerMessage.header.hopByHop int This field is used to match the requests with their answers as the same value in the request is used in the response. This value is automatically filled in when sending a message.
answerMessage.header.endToEnd int This field is used to detect duplicate messages along with the combination of the Origin-Host AVP. This value is automatically filled in when sending a message.

Message Handling

This section describes how messages are handled if they are not exposed to the EventFlow application, by specifying the application and command on one of the configured adapters.

Handled Messages

The following lists the Diameter message types that are handled internally if they are not exposed to the EventFlow application

  • CER - Capabilities-Exchange-Request

  • CEA - Capabilities-Exchange-Answer

  • DWR - Device-Watchdog-Request

  • DWA - Device-Watchdog-Answer

  • DPR - Disconnect-Peer-Request

  • DPA - Disconnect-Peer-Answer

Unhandled Messages

There are two types of unhandled messages: those that are part of the dictionary but not exposed to the EventFlow application, and those messages that are not in the provided dictionary files.

If a Diameter message is received but cannot be found in the dictionary file, then a status and log error message will be output with the error. The client is subsequently disconnected.

If a Diameter message is received and found in the dictionary but no adapter is set up to handle the message, an INFO warning is displayed in the logs that states the application and command code that was received and not handled.

Shared Adapter Configuration

The shared adapter configuration for the Diameter adapters is located in HOCON.

Example Shared Adapter Configuration HOCON

name = "Diameter.conf"
type = "com.tibco.ep.streambase.configuration.adapter"
version = "1.0.0"
configuration = {

// An adapter group type defines a collection of EventFlow adapter configurations, 
// indexed by adapter type.
  AdapterGroup = {

// A collection of EventFlow adapter configurations, indexed by adapter type. 
// This object is required and must contain at least one configuration.
    adapters = {

// The root section for an EventFlow adapter configuration.
      DiameterAdapters = {

// Section list. This array is optional and has no default value.
        sections = [ 

// A configuration for an EventFlow adapter named section.
          {

// Section name. The value does not have to be unique; that 
// is, you can have multiple sections with the same name
// in the same array of sections. This property is required.
        name = "DiameterAdapter"

// Section for setting adapter properties. All values must be strings. This object 
// is optional and has no default value.
          settings = {
            dictionary = "TestDictionary.json"
            host = ""
            id = "DiameterSectionedMessagesServer"
            originHost = "127.0.0.1"
            originRealm = "tibco.com"
            productName = "Streambase"
              }
                }

// A configuration for an EventFlow adapter named section.
                    {

// Section name. The value does not have to be unique; that is, 
// you can have multiple sections with the same name
// in the same array of sections. This property is required.
                      name = "DiameterAdapter"

// Section for setting adapter properties. All values must be strings. This object 
// is optional and has no default value.
                        settings = {
                          dictionary = "TestDictionary.json"
                          host = "127.0.0.1"
                          id = "DiameterSectionedMessagesClient"
                          originHost = "127.0.0.1"
                          originRealm = "tibco.com"
                          productName = "Streambase"
            }
          }
        ]
      }
    }
  }
}

Shared Adapter Configuration Options

Property Type Default Description
id string   This is the name that will link the adapters together and is displayed in the drop-down list on each adapter's property configuration.
dictionary string   This is the Diameter dictionary file name that will be used for composing and parsing Diameter messages.
host string   For the server, this is the host it will accept connections on; leave blank for all, and for the client this is the host to connect to.
port int 3868 For the server, this is the port the server listens on; if 0, a random port is selected; for the client, this is the port the client will create the outbound connection to.
networkProtocol string TCP Valid values are TCP and SCTP and determines the underlying network protocol to use.
startServerAtStartup boolean true Only valid for server adapters. If set to true, the server creates a listener at the startup of the application. If set to false, then the control port must be used to start the server listener.
connectAtStartup boolean true Only valid for client adapters. If set to true, the client attempts to connect to the server at startup of the application; if set to false then you must use the control port to establish a connection.
noDelay boolean false If set to true, the connection option no delay is set on the sockets.
enableAutomaticReconnect boolean true Only valid for client adapters. If set to true, the adapter will attempt to reconnect to the server if for any reason the connection is lost or is not initially established.
reconnectTimeoutMS int 5000 Only valid for client adapters. This value is the number of milliseconds to wait between a disconnect or invalid connection attempt and when a new connection attempt should be started.
maxReconnectAttempts int 10 Only valid for client adapters. This value is the maximum number of reconnect attempts that should be made before giving up trying to connect to the server. The number of reconnect attempts is reset after a valid connection is made. A value of 0 means unlimited connection attempts.
maxDeviceWatchDogRequests int 3 The maximum number of device watch dog request messages to send before disconnecting.
watchDogTimeoutMS int 3000 The amount of time (in milliseconds) before the watch dog times out and sends a watchdog request.
originHost string 127.0.0.1 The origin host to use with the connection.
originRealm string my.realm The origin realm to use with the connection.
productName string StreamBase The product name to use with the connection.
firmwareVersion int 210 The firmware to use with the connection.
readBufferSize int 102400 The number of bytes for each sockets circular read buffer.
writeBufferSize int 102400 The number of bytes for each sockets circular write buffer.
socketReceiveBufferSize int -1 This value directly sets the SO_RCVBUF size. If this option is missing or less than 0 it will be ignored and the default for your system is used.
socketSendBufferSize int -1 This value directly sets the SO_SNDBUF size. If this option is missing or less than 0 it will be ignored and the default for your system is used.
connectTimeoutMS int -1 This value sets the connection timeout in milliseconds. If this option is missing or less than 0 it will be ignored and the default for your system is used.
writeSpinCount int -1 The write spin count is used to control how many times the underlying socket.write(...) is called per write operation. If this option is missing or less than 0 it will be ignored and the default for your system is used.
writeBufferWaterMarkHigh int -1 If the number of bytes queued in the write buffer exceeds the high water mark, the channel will pause writing until it falls before the low water mark. If this option or writeBufferWaterMarkLow is missing or less than 0 it will be ignored and the default for your system is used.
writeBufferWaterMarkLow int -1 If the number of bytes queued in the write buffer exceeds the high water mark and then dropped down below the low water mark, the channel will start writing again. If this option or writeBufferWaterMarkHigh is missing or less than 0 it will be ignored and the default for your system is used.
enableConnectionEventLogging boolean false If enabled, verbose connection events are output at the debug log level such as READ, WRITE, and CONNECT. If the adapters log level is currently set to trace then detailed information is output for events with data such as READ and WRITE.
secureCommunicationConfig string   The name of the SecureCommunicationServerProfile (used in the Diameter Server Input adapter) or SecureCommunicationClientProfile (used in the Diameter Client Input adapter) HOCON configuration to use when setting up an SSL connection. If this value is missing or empty, no SSL is enabled for connections.
useSelfSignedCert boolean false This option is only available when a name is given for the secureCommunicationConfig setting. When enabled, it ignores all security settings and instead generates and uses a self-signed certificate. This option only affects a Diameter server. WARNING! Use this option for testing purposes only.
useInsecureTrustManager boolean false This option is only available when a name is given for the secureCommunicationConfig setting. When enabled it ignores all security settings and instead uses a insecure trust manager which will allow all certificates. This option only affects a Diameter client. WARNING! Use this option for testing purposes only.
rateControlType string NONE Valid values are NONE, SHED, and THROTTLE and will determine the rate control type to use. Using THROTTLE causes the system to only hand n number of requests per second and will slow down the connection to that target rate. Using SHED causes messages that go above the target rate to be discarded with a failure message returned to the send.
tps int 1000 The maximum number of tuples per second the system will handle per Origin Host.
overallTPS int 5000 The maximum number of tuples per second the system will handle overall.
rateControlResultCode int 3004 Only used when the rateControlType is set to SHED. This value is used as the Result Code of the reject message.
rateControlAVP string   Only used when the rateControlType is set to SHED. This value is used as the FailedAVP of the reject message. The format of this string is a comma-separated list of code and vendorIds with vendorId being optional; code and vendorId are joined with a pipe character. For example: code|vendorId,code|vendorId,code,code
outputRawBinaryInTraceLog boolean false This option will output all messages sent and received to the log in raw binary format when the log level is set to trace and this option is set to true. WARNING! Use this option for testing purposes only.

Diameter Dictionary

This section describes Diameter dictionaries and how they are used with the adapters to parse and compose Diameter messages.

Dictionary files are in JSON format and are cumulative in that you can include more dictionary files inside of other dictionary files to keep them organized and less complex.

Base Dictionary

StreamBase includes a Diameter sample that comes with a BaseDictionary.json file. TIBCO recommends using the file as the base for your Diameter projects. This base dictionary includes all the required information for the Diameter adapters to perform the most basic Diameter protocol functions. The sample also includes a TestDictionary.json that shows the most basic dictionary files, including the base dictionary, to get the adapters up and running.

Dictionary Schema

The following shows the schema to which each dictionary must conform:

{
   "$schema":"http://json-schema.org/draft-04/schema#",
   "type":"object",
   "properties":{
      "includeDictionary":{
        "type":"array",
         "items":{
            "type":"object",
            "properties":{
               "file":{
                  "type":"string"
               }
            },
            "required":[
               "file"
            ]
         }       
      },
      "settings":{
        "type":"object",
        "properties":{
           "enumAsString":{
              "type":"boolean"
           },
           "applicationAndCommandAsString":{
              "type":"boolean"
           }
        }        
      },
      "vendors":{
         "type":"array",
         "items":{
            "type":"object",
            "properties":{
               "name":{
                  "type":"string"
               },
               "id":{
                  "type":"string"
               },
               "code":{
                  "type":"integer"
               }
            },
            "required":[
               "name",
               "id",
               "code"
            ]
         }
      },
      "dataTypes":{
         "type":"array",
         "items":{
            "type":"object",
            "properties":{
               "dataType":{
                  "type":"string"
               },
               "parentDataType":{
                  "type":"string"
               }
            },
            "required":[
               "dataType"
            ]
         }
      },
      "avps":{
         "type":"array",
         "items":{
            "type":"object",
            "properties":{
               "name":{
                  "type":"string"
               },
               "code":{
                  "type":"integer"
               },
               "vendorId":{
                  "type":"string"
               },
               "must":{
                  "type":"array",
                  "items":{
                     "enum":[
                        "M",
                        "V",
                        null
                     ]
                  }
               },
               "must-not":{
                  "type":"array",
                  "items":{
                     "enum":[
                        "M",
                        "V",
                        null
                     ]
                  }
               },
               "type":{
                  "type":"object",
                  "properties":{
                     "dataType":{
                        "type":"string"
                     },
                     "enum":{
                        "type":[
                           "array",
                           "object"
                        ],
                        "items":{
                           "type":"object",
                           "properties":{
                              "value":{
                                 "type":"integer"
                              },
                              "name":{
                                 "type":"string"
                              }
                           },
                           "required":[
                              "name"
                           ]
                        }
                     }
                  },
                  "required":[
                     "dataType"
                  ]
               },
               "grouped":{
                  "type":"array",
                  "items":{
                     "type":"object",
                     "properties":{
                        "name":{
                           "type":"string"
                        },
                        "min":{
                           "type":"integer"
                        },
                        "max":{
                           "type":"integer"
                        }
                     }
                  }
               }
            },
            "required":[
               "name",
               "code"
            ]
         }
      },
      "applications":{
         "type":"array",
         "items":{
            "type":"object",
            "properties":{
               "applicationId":{
                  "type":"integer"
               },
               "name":{
                  "type":"string"
               },
               "commands":{
                  "type":"array",
                  "items":{
                     "type":"object",
                     "properties":{
                        "name":{
                           "type":"string"
                        },
                        "code":{
                           "type":"integer"
                        },
                        "proxiable": {
                            "type":"boolean"
                        },
                        "request":{
                           "type":"array",
                           "items":{
                              "type":"object",
                              "properties":{
                                 "name":{
                                    "type":"string"
                                 },
                                 "min":{
                                    "type":"integer"
                                 },
                                 "max":{
                                    "type":"integer"
                                 },
                                 "vendorId":{
                                    "type":"string"
                                 },
                                 "index":{
                                    "type":"integer"
                                 },
                                 "hidden":{
                                    "type":"boolean"
                                 }
                              },
                              "required":[
                                 "name",
                                 "min"
                              ]
                           }
                        },
                        "answer":{
                           "type":"array",
                           "items":{
                              "type":"object",
                              "properties":{
                                 "name":{
                                    "type":"string"
                                 },
                                 "min":{
                                    "type":"integer"
                                 },
                                 "max":{
                                    "type":"integer"
                                 },
                                 "vendorId":{
                                    "type":"string"
                                 },
                                 "index":{
                                    "type":"integer"
                                 },
                                 "hidden":{
                                    "type":"boolean"
                                 }
                              },
                              "required":[
                                 "name",
                                 "min"
                              ]
                           }
                        }
                     },
                     "required":[
                        "name",
                        "code",
                        "proxiable",
                        "request",
                        "answer"
                     ]
                  }
               }
            },
            "required":[
               "commands",
               "applicationId"
            ]
         }
      }
   },
   "required":[
      "vendors",
      "dataTypes",
      "avps",
      "applications"
   ]
}

Dictionary Layout

The following are the major categories of the dictionary file and an overview of their usage.

includeDictionary

The includeDictionary section is an array of files that allows one dictionary file to include another dictionary file. This enables you to organize your dictionaries into logical application or vendor groups and combine them into a single dictionary.

  • file — The relative path to the linked dictionary file to include.

settings

The settings section allows dictionary related settings to be set.

  • enumAsString — The enumAsString setting is a true/false flag that determines if the string values of the enumerations in the dictionary should be used in EventFlow instead of the integer values. If set to true, the schemas produced by parsing the dictionary files will input/output a string value for all enum fields and require that any input fields match one of the enum values listed.

  • applicationAndCommandAsString — The applicationAndCommandAsString setting is a true/false flag that determines if the applicationId and commandCode fields of the request and answer message headers should be treated as string or numeric fields. If this value is true, the input and outputs of the adapters will consider the applicationId and commandCode to be string fields and match them to the dictionary name values. All messages read from the Diameter connection are translated to the correct string values, and all tuples are converted to the correct numeric values for the outbound Diameter messages.

vendors

The vendors section allows you to add vendor names and codes that will be used later in avp's and application commands.

  • name — The human-readable name of the vendor.

  • code — The code of the vendor to use with vendorId fields in other sections, for linking.

  • id — The ID of the vendor to send with Diameter messages.

dataTypes

The dataTypes section allows you to add any extended data types that are not already specified by the base dictionary.

  • dataType - The name of the data type which will be used when creating AVPs.

  • parentDataType - The parent data type which must eventually link back to one of the base underlying data types (OctetString, OctetStringBinary, OctetStringBase64, Integer32, Integer64, Unsigned32, Unsigned64, Float32, Float64).

    • OctetStringBinary will produce a blob field and the data from the diameter packet will be direct output to event flow as a binary payload

    • OctetStringBase64 will produce a string field and the data from the diameter packet will be Base64 encoded into event flow and Base64 decoded before sending.

avps

The avps (attribute value pairs) section allows you to add any AVPs that are not currently present in the base dictionary. These AVPs can be self-referenced to form nested structures. The AVPs are used in the application commands as the fields for each request and answer command.

  • name — The AVP name that is used later in the application commands to link AVPs to commands.

    code — The AVP code that is sent and used in the Diameter message.

    vendorId — (Optional) The vendor associated with this AVP; use the code of one of the vendors in the vendor section.

    must — An array of Diameter values to specify how this AVP will operate, value available:

    • M — In the must case it means the AVP must appear in the Diameter message or the message will be rejected.

    • V — In the must case it means the vendorId must have a value.

    must-not — An array of Diameter values to specify how this AVP will operate, value available:

    • M — In the must-not case it means the AVP must NOT appear in the Diameter message or the message will be rejected.

    • V — In the must-not case it means the vendorId must NOT appear in the Diameter message or the message will be rejected.

    type — The data type of this AVP which must correspond to one of the base or extended data types. If this field is missing then the grouped field must exist.

    grouped — An array of nested AVP values.

    • name — The name of the AVP to include.

    • min — (Optional) The minimum number of times this value must appear.

    • max — (Optional) The maximum number of times this value must appear.

applications

The applications section allows you to add any applications and commands that are not currently present in the base dictionary. The applications section is the main building block for creating a Diameter application and is comprised of multiple commands. Each command in turn has a request and answer message that is created from one or many AVPs listed in the AVP section.

  • applicationId — The application ID used when sending Diameter messages. This value is also used during the capabilities exchange.

  • name — The human-readable name of this application to use in the adapter properties.

  • commands — The array of commands associated with this application.

    • name — The name of the command, and is used in the adapter properties.

    • code — The code of the command used to create the Diameter message.

    • proxiable — A flag to specify if this command is proxiable.

    • request/answer — An array of AVP values which make up the request/answer commands.

      • name — The name of the AVP to include.

      • min — (Optional) The minimum number of times this value must appear.

      • max — (Optional) The maximum number of times this value must appear.

      • vendorId — (Optional) The vendor associated with this AVP; use the code of one of the vendors in the vendor section.

      • index — (Optional) The index of this AVP value is the order of the AVP values.

      • hidden — (Optional) If hidden is true, the AVP value will be parsed from messages but is ignored in the StreamBase application and does not appear in the generated schema. This value cannot be true if the min value present and is greater than 0.