Aayush: weblog

Posts Tagged ‘telecom’

Vote for Rancore Technologies – Red Hat Innovation Awards 2011

Posted by Aayush Bhatnagar on May 2, 2011


Please  vote for Rancore Technologies in the Red Hat Innovation Awards 2011.

Steps:

Click on this link: http://www.redhat.com/summit/awards/

Then click on VOTE NOW.

For reading the entry text for Rancore, scroll to the bottom of the page.

Voting begins May 2nd 8 am Eastern Time and Ends on 4th May 11:59 PM Eastern Time.

This translates to May 2nd 5:30 PM India time till 4th May 9:30 AM India Time.

Thanks

Advertisements

Posted in Uncategorized | Tagged: , , , , , , , , , , , | Leave a Comment »

An alternative for RF Drive Tests- NextGen Smartphone Apps that Integrate with OSS.

Posted by Aayush Bhatnagar on January 1, 2011


Introduction:

Usually in telecom operations, iterative RF coverage audits are common. This is facilitated by drive tests carried out by engineers and technicians who cover the length and breadth of the service areas by road.

These drive tests are an expensive business, both in terms of the costs involved and the human resources needed. Drive test equipment has to be carried physically in vehicles and these vehicles are continuously driven across the service areas of the operator. The results are then post processed manually to identify possible “pain points” for RF coverage.

This practice of drive tests still does not provide the operator with much information on how good/bad indoor coverage is for their customers.

Hence, despite spending a lot of money on drive tests, the biggest pain point of indoor coverage issues still remain unresolved.

With the advent of smart phones and mobile applications, there is a smarter way available for operators to get better RF audit results.

Proposed Solution:

The customer’s smart phone can be used as a RF audit device. A mobile application can run in the background which continuously audits the phone’s signal strength. Whenever the signal strength goes below a configured value, logs are generated at stored in the mobile phone’s internal memory. When the signal is strong again, these logs are pushed to the operator’s OSS/BSS infrastructure for post processing.

Some of the details which can be pushed in the logs can be:

– Latitude and Longitude when the signal went weak.

– Timestamp value when the signal went below the configured limit.

– Latitude and Longitude when the signal became normal again

– Timestamp value when the signal became normal

– Customer’s phone model and operating system details.

By using this solution, the operator can have the same effect as RF drive tests. Moreover, by using this technique the operator can also get information regarding the indoor coverage of the RF signal. The log details can be post processed at the OSS and plotted on a map to identify the problem areas with respect to RF coverage.

Architecture

I discuss here an alternative architecture for RF audits that leverages an application installed on the end-device. This architecture also shows integration with the back-end OSS (NGOSS compliant system) to achieve automation of test results through well defined NGOSS TAM (Telecom Applications Map) software applications.

These TAM applications will be executed by business processes governed by the eTOM model.

The figure above shows the overall architecture needed to implement this architecture. Major touch points between the software application involved are shown in red circles. The explanation of each touchpoint is discussed in this section. Please note, that the architecture above only shows some of the standardized TAM applications which can be leveraged upon for implementing the proposed architecture. If more functionality is needed, more TAM applications may come into the picture.

The major touchpoints are as follows:

Point 1 – This is the interface between the software application on the smartphone and the OSS. This interface can be HTTP or SOAP/XML. The informational logs from the smartphone are fed to the Resource Performance Monitoring TAM application denoted by the TAM Application ID 7.9.1. This TAM application is responsible for performance data collection in near real-time. This application also co-relates events and filters them. Finally, data aggregation is also performed by this application so that it can be fed to the reporting system.

Point 2 – This interface is shared between the resource performance monitoring application and the resource performance analysis application. This application is responsible for performing the root cause analysis of performance degradation based on the information captured by the performance monitoring application. In our case, the degradation refers to the drop in the signal strength.

Point 3 – Based on the performance analysis, this application feeds the data to the performance reporting application where detailed reports are generated periodically and provided to the operator.  These reports can be generated automatically or even by manual intervention. e.g: If the operator wishes to generate a targeted RF report for the New Delhi Circle, a report will be generated on demand.

Point 4 – In case there is frequent degradation of the RF signal in a particular geography, the resource performance analysis application can raise a trouble ticket. The decision to raise a trouble ticket will be governed by a set of pre-configured rules in this application. These trouble tickets are handled by the Service problem reception, monitoring and analysis applications.

Point 5- In case there is a major network outage resulting in the loss of service for many subscribers, the resource performance analysis application can also raise a critical alarm to the Network Management Systems (NMS). These alarms may be escalated to the NoC (Network Operations Center). Based on the seriousness of the fault being reported, an alarm may be escalated to the Network Operations Center using this touch point.

Point 6 – This is the interface between the Resource performance reporting application and the Resource Design/Assign application. Based on the performance reports, there may be design changes required to the RF network. These change requests/enhancements are fed to the resource design application.

Point 7 – This touch point is between the service problem reception, monitoring and analysis applications which process the trouble ticket, perform the root cause analysis of the problem and decide upon the course of action to be taken to tackle the problem.

Point 8- The Service problem correction application is responsible for taking corrective action to the service problem (loss of RF coverage). Problem correction may be automated (configuring the base stations over the EMS), or it may be required to send a field technician to resolve the fault on-site.  This application may provide significant inputs to the Resource Design application to help avoid similar problems in the future.

What this Solution can’t provide:

1. Drive tests are also used for performing competitive analysis amongst operators. This cannot be achieved using this smartphone application technique.

2. This solution requires the end customer to carry a phone which supports installable applications. Hence, rudimentary phones will not be able to participate in this RF audit and a drive test will be necessary in case the bulk of the customer base carries plain phones.

Conclusion:

With the advent of 3G/4G networks, smartphones are available in greater volumes. Hence, 2 yrs down the line they will be with more and more customers. Then this technique will really benefit the operators to drive down costs of RF audits.

Posted in airwaves, BSS, OSS, telecom | Tagged: , , , | 1 Comment »

Telecommunications for Dummies – Telecom Basics and Introduction to BSS.

Posted by Aayush Bhatnagar on September 5, 2010


Introduction

This post is intended to be a crash course for beginners who wish to understand at a “broad level” how Business Support Subsystem components work in a telecom carrier’s network and more importantly how they connect to the telecom network elements over standard protocols.

Hence, the text is more “conversational” in nature rather than completely “technical”.

Elementary examples of simple call setup procedures have also been included, as they are required for a holistic understanding of the entire ecosystem – beginning from a call setup, to its charging, rating and billing.

Background

Telecom operations from the perspective of a carrier are divided into two broad categories: OSS and BSS.

Operations Support Subsystems (OSS) is an aggregation of functions that enable the operator to provision and manage their inventory, customers, services and network elements. Provisioning implies “making an entry or a record” of some resource. This resource may be a customer, a value added service, inventory such as dongles or even a network element such as a call control switch. For example if a new customer is acquired, his entire record has to be saved in the network such as his name, address, phone number allotted etc. This is customer provisioning.

An example of managing an inventory could be as follows.

Dongles procured by the carrier need to be recorded in the inventory management system. Each dongle would undergo a lifecycle.

Eg: When the dongle is first procured, it is recorded to be in stock. When the dongle is dispatched to a retail store, its status is changed in the inventory management system to be “for sale”. When a customer purchases the dongle, its status changes to “sold” and it is linked to the customer’s identity who bought it.

On the other hand, Business Support Subsystems is an aggregation of functions which are used for managing an operator’s day-to-day business characteristics and providing an operator with complete clarity on the performance and management of his diverse lines of businesses.

BSS systems include real-time functions such as charging (post-paid/pre-paid), rating using tariff plans and applying discounts.

BSS also includes some non-real-time components such as launching new marketing campaigns, analyzing the success of individual marketing campaigns through business intelligence reports, partner management (for dealing with 3rd party content providers, other operators, franchisees etc), creating invoices, payment collection, revenue sharing with partners and billing.

This note is more focussed on the BSS components of an operator’s ecosystem.

Before going to the specifics of BSS, it is useful to review a typical call setup procedure for post paid calls as well as for pre paid calls, so that some basic grounding is available regarding the call flows in a typical telecom network:



The above scenario depicts the flow of messages for a pre-paid subscriber. When the subscriber dials out a number, the local office checks whether the subscriber has enough balance in his/her account. Only if the balance is available, does the call proceed further.

Case Study:

NOTE-1: There may be one or more transit exchanges between the originating local office and the terminating local office.

NOTE-2: The messages that flow between the local exchange and the pre-paid platform are in INAP protocol. INAP stands for Intelligent Network Application Part and is the top most layer of the SS7 protocol stack. Both the local office and the service control point (SCP) understand the INAP messages.

NOTE-3: The other levels of the SS7 stack are: MTP1, MTP2, MTP3, SCCP and TCAP. MTP stands for Message Transfer Part. SCCP stands for Signalling Connection Control Part. TCAP stands for Transaction Capability Application Part.

Main steps in charging a pre-paid call in a fixed line network:

  • When a pre-paid subscriber makes a call, it arrives at a local exchange (also called local office in the US).
  • The local exchange looks at the calling number (A-party), and finds that it is a call made by a pre-paid customer. So, it cannot connect the call straight away as it would have done for a post –paid customer.
  • The local exchange has to now talk to a pre-paid platform.
  • The local exchange sends a message to the pre-paid platform informing it of the A-party number and the B-party number.
  • This message is received by a component of the pre-paid platform called the Service Control Point (SCP). SCP is nothing but a software module that understands and receives messages sent by the local exchange.
  • On receiving the message from the local exchange, the SCP communicates with a Rating Engine, which is the second component of the pre-paid platform. The rating engine is the heart of the pre-paid platform. As tariff plans get more complex and more services need to be charged, the rating engine must have flexibility and functionality to meet the business requirements.
  • It contains in its database, the current balance of all the pre-paid customers. Since there are hundreds and thousands of customers served by a single pre-paid platform, the rating engine will contain a large number of customer balance records.
  • The rating engine looks at the A-party number and then queries its database to find out the current balance of the A-party. If the A-party has zero or insufficient balance, then it must inform the SCP that the calling customer has insufficient balance.
  • The SCP in turn will send a message to the local exchange informing it that the calling party has insufficient balance.
  • The local exchange rejects the call.
  • If however, the rating engine finds that the calling party has sufficient balance, then via the SCP, the local exchange is informed that the call can proceed.
  • If the balance of the calling party is zero, then no further analysis is required by the rating engine to reject the call. However it has to check by looking at the B-party number if the balance is sufficient to support the minimum rate of the call pulse.
  • For example: If a local call costs 10 cents per minute and the balance of the A-party is currently 5 cents, then this balance is not sufficient.  If it was an international call, then even 50 cents balance may not be sufficient.
  • Assuming that the balance was sufficient and the pre-paid platform has allowed the call to proceed, then the local exchange will allow the call to proceed and the call will be eventually connected via one or more exchanges to the called subscriber whose phone will ring.
  • If the call is abandoned for any reason like the calling party abandoning the call before it is answered by the B-party, no answer by B-party etc, then the local exchange must again send a message to the SCP informing it that the call has not matured.
  • The rating engine had at the time of allowing the call reserved a certain amount from the subscriber’s balance. For example the amount that would have been reserved depends upon the tariff plan of the customer. To avoid frequent requests for the reservation of amount, the rating engine may be asked to grant a larger chunk of units from the balance.
  • As an example, assume that the calling party had a balance of USD 100 when the call was made. When the message reaches the pre-paid platform, the rating engine on finding that there is enough balance will not only respond to the local exchange about the sufficiency of the balance as described above, but also reserve an amount, say USD 5. Therefore, temporarily the balance reduces to USD 95. It is important to understand that reserving an amount is not equivalent to actually reducing the balance of the calling party. At this time, the reservation only signifies the “intent”, and actual deduction would happen only if the call is successful and usage takes place.
  • When the call is answered, the deduction will happen periodically from the reserved amount of USD 5. How much amount must be deducted and at what periodicity? This has to ultimately depend upon the tariff plan which the calling party has subscribed to. Assuming that the call charges are 50 cents per minute, this reserved amount of USD 5 would be enough for 10 minutes of conversation. This is the validity time.
  • At the time of informing the local exchange that the calling party has sufficient balance and the call can be connected, the validity time is also conveyed by the SCP. Thus, the local exchange knows that if this call matures, it can let the call continue for the first 10 minutes without again contacting the pre-paid platform.
  • If the conversation ends is less than 10 minutes, for example the call duration is just 3 minutes, the local exchange sends a message to the charging platform and only USD 1.5 will be deducted by the pre-paid platform at the end of the call. The remaining USD 3.5 is returned to the account balance of the calling party. His closing balance will now be USD 8.5.
  • Assuming that the conversation exceeded 10 minutes, the local exchange sends another request to reserve more units. This has to be done prior to the expiry of the validity time. The pre-paid platform will reserve another chunk of USD 5 and inform the local exchange accordingly.
  • It may happen that the unit reservation request fails. This will happen when the subscriber has no units left in his balance. In such a scenario, the pre-paid platform will respond with a message that informs the local exchange that the credit limit is reached. The local exchange will then immediately terminate the call.

The architecture for charging a pre-paid call in a mobile network (GSM) is shown below. Note that it is very similar. Only the INAP protocol layer  has been replaced by CAMEL:

NOTE-1: CAMEL stands for Customised Applications for Mobile Enhanced Logic.

NOTE-2: There will be a base station and the base station controller (BSC) before the call reaches the originating MSC. Likewise, there will be a BSC and a BTS on the terminating side.

NOTE-3: There may be one or more transit exchanges between the originating and terminating MSCs. These are called GMSCs (Gateway MSCs) in mobile networks.

NOTE-4: The architecture in a CDMA mobile network will be identical except that CAMEL will be replaced by IS-826 protocol layer.

Details of the SMP and the VMS:

Service Management Point (SMP):

The SMP performs the management functions for the IN platform. For example, all the pre-paid customers must be recorded in the IN platform along with their initial balance. This is typically called the provisioning of customers. This task is performed by the SMP. The SMP will typically have local terminals where operators can do this task through a set of commands called the command line interface (CLI). There may also be a need to periodically delete (de-provision) customers who have left the pre-paid service provided by the operator. It will also be connected to a voucher management system from where commands will flow to the SMP for bulk provisioning of customers so that a large number of customers can be simultaneously provisioned in the pre-paid system.

Voucher Management System:

The Voucher Management System (VMS) allows prepaid subscribers recharge their accounts using pre-paid vouchers, allowing operators to run widely distributed dealer networks efficiently and easily. VMS allows subscribers to add funds to their accounts within the home network or in roaming networks regardless of location, time of day or model of phone. VMS cuts down administrative, bookkeeping and servicing expenses and makes it easy for subscribes to keep track of their account balance without service centres.

Features of a VMS are as follows:

Account recharging via voice services

The Voucher Management System allows subscribers to recharge their accounts from their own telephone as well as from any tone-dial phone.

Account recharging via non-voice services

Subscribers can top up their own accounts, as well as the account of any other subscriber of the same network, by sending an SMS request with a PIN code to a service number. Accounts can also be recharged from a special websites of the carrier.

Account recharging via operator

Subscribers can recharge their accounts via call centre operators.

Distributed system

The prepaid card system allows distributed systems with card roaming to be built, giving your subscribers the ability to recharge their accounts while in roaming.

Blocking

The Voucher Management System can bar a specific telephone number from accessing the service after several consecutive unsuccessful attempts to enter a PIN code from that number, protecting you from fraud.

Advertising

Additional profit can be generated from placing adverts on cards, and can also be a useful marketing tool for the operator, for example to advertise new services.

Card Status

Information about card usage (transactions made) is recorded automatically in the operator’s billing system.

Revisiting Post paid Charging:

Charging for Post-paid subscribers:

For post-paid subscribers, there is no need to check for the balance. The calls are allowed to proceed further, without any messaging to a pre-paid platform, and the call details are captured in the form of a Call Detail Record (CDR) at the end of the call.

These CDRs are used later for billing purposes.

A typical CDR file captures the following information:

–          Calling party number

–          Called party number

–          Call start time

–          Call end time

–          Call duration (End Time – Start Time)

–          Call Identifier

This information is saved in the form of a file in the local exchange or the MSC and is pushed to the Charging System for post processing.

The charging system has a rating engine and a mediation engine.  The rating engine analyzes the CDR files and determines the rate to be applied for each CDR file.  Once this rating is completed, the CDR is known as a rated-CDR. This rated CDR is pushed to the mediation engine. The mediation engine is required because it may receive CDRs from more than one source and the format of the CDRs may be different from each source.

The mediation engine post-processes the rated CDRs from multiple sources and reformats them into a common file. This common file is then pushed to the billing system which generates the itemized bills for each customer based on the CDRs.

A simple procedure for a post-paid subscriber is given below in terms of CDR creation and storage:

We have so far described charging of voice calls. The figure below shows the post-paid charging of a data call in CDMA:

The data call path bifurcates from the PCF – Packet Control Function, which is a logical function of the Base Station Controller as shown above.

The Rating, Mediation engine and billing system are common for data calls as well as voice calls.

The figure below shows the corresponding architecture for charging a Mobile WiMAX data call. The only difference here is, that we have an ASN gateway as the controller for data calls. The AAA is sending charging events on RADIUS protocol.

The AAA (Authorization, Authentication and Accounting) server receives the messages on RADIUS protocol. There may be a dedicated RADIUS to DIAMETER converter in the AAA server, which converts these messages to the DIAMETER protocol and sends them to the charging platform. DIAMETER protocol’s Rf interface is used for post-paid charging while the DIAMETER protocol’s Ro interface is used for pre-paid charging.

Introduction to the Realtime Components of BSS:

We can now discuss the BSS system in more detail. There may be some overlap of information with what is described above.

The figure below shows a “modern” BSS system which works on DIAMETER interfaces and integrates with IMS, Mobile WiMAX and LTE on DIAMETER protocols:

LEGEND:

This is only an architectural representation meant to show some of the major components of a BSS system and to provide a glimpse in to the complexity of a modern BSS platform.

However, we will be discussing conceptually some of the basic components of the BSS system without going into the technical details.

Some of the most important real-time network facing components of a BSS system are:

  1. Charging
  2. Rating
  3. Mediation
  4. Billing, and
  5. Reconciliation

1. Charging

Charging of customers can be done in two ways: pre-paid (online) charging and post-paid (offline) charging. The first step of revenue generation starts with the charging process, where the network elements identify the events which need to be charged. Some examples include – sending a SMS, MMS, dialling a number, downloading content etc.  Network elements such as the local exchange (office), SMSC (Short Message Service Centre) etc generate these “chargeable” events towards the charging platform.

Chargeable events can be conceptualized as “intents” to charge the customer based on his/her actions. At this stage, it is not guaranteed that these events will actually lead to revenue realization. For example, a chargeable event will be generated for a missed call, or a failed call setup. However, as the call never got connected successfully, the customer will not be liable for paying for this event.  However, the operator may change his policy and may charge the customer even for missed calls if needed.

Interfaces for Charging:

Charging platforms support multiple interfaces to receive events. Some of the most common charging interfaces are on RADIUS and DIAMETER protocols. Legacy systems used to charge calls on the IN (Intelligent Network) pre-paid platform. There were also Web Service interfaces used for charging in some legacy systems. Web services work on the HTTP protocol and are described by SOAP protocol (Simple Object Access Protocol).

2. Rate Determination and Rating.

The next logical step after receiving charging events is Rate Determination and Rating.

Once the charging system has received an event, rate calculation takes place for the customer depending upon the current tariff plan in use. The charging system needs to decide the amount of units which need to be consumed for the particular charging event. For post-paid subscribers, these units are determined and attached to a Call Detail Record (CDR). Then this
“rated-CDR” is dumped as a file.

For pre-paid subscribers, the units are determined and compared with the subscriber’s account balance. If the account balance is sufficient, the charging system borrows the required amount of units from the subscriber’s account and prepares to deduct them from the available balance.

Units may have different manifestations. For example, we can represent Units as “money”. We may also represent units in the form of the allowable limit for data download in Megabytes (units measured by volume). Another possibility is to measure units in terms of talk time. In some special cases, the operator may also represent units in terms of the number of free calls offered and the number of free SMS messages allowed.

Before the charging system rates a particular charging event and actually deducts units, there is an intermediary step. This step is to apply discounts if applicable. For example, if the charging event cost the subscriber $1 and the tariff plan of the subscriber offered him with a discount of 50% on all calls, then the rate applicable would only be 50 cents.

At this stage, it is important to understand the relationship between a tariff plan, the components of a tariff plan, offers attached with the tariff plan, rate to be applied based on the offers, and the validity semantics of the offer. These are important inputs to the rating engine. The final rate to be applied is calculated based on the tariff plan, offers and discounts applicable on the base plan and the validity of the offers.

The illustration below explains the relationship between these concepts:

The figure above represents a tariff plan. This plan has four components:

  1. Voice
  2. Messaging
  3. Data
  4. Content.

The voice component applies to the usual calls that the subscriber initiates. The messaging component of this example refers to the SMS messages. The Data component refers to the internet browsing and downloads from websites. Finally, the content component refers to the purchase of premium content such as movies, ringtones and ebooks from an operator’s application store for example.

Each component of this tariff plan has an offer attached to it. In this example, the customer has the first 100 voice calls free, the first 50 SMS messages free, first 10 MB of downloads free and 2 ringtones free.

These offers have validity applicable to them. The first 100 voice calls are free and must be consumed within a month. Similarly, the free SMS offer must be consumed within a month. The same is applicable to the data download offer. However, the 2 ringtones are free as a onetime offer to the customer. The customer may download at the most 2 ringtones for free. For the 3rd ringtone download, normal charges shall apply.

The last concept is that of usage counters. At the top of each month, the free voice call quota is re-initialized to a value of 100. With each call made by the customer, this value of 100 is decremented until it reaches zero. Once the free call quota is zero, normal charges apply to all subsequent calls. Similarly, for messaging the usage quota is set to 50 every month.

Validity can be represented in several forms:

The validity semantics of an offer has to be very flexible. This flexibility determines the business agility of an operator. In the figure above, certain validity options are shown. For example:

  • A particular offer may be valid at the top of each month. This is similar to the voice call free usage counters discussed in the example earlier.
  • In some other scenarios, a certain offer may be valid only on certain days of the week (Monday, Wednesday, and Friday). For example all voice calls are discounted 30% on certain days of the week (weekends for example).
  • Another option is for an offer to be applicable within a time band of a day. For example, the operator may offer discounted call rates at night time (between 11 pm and 5 am) to encourage usage during these lean hours.
  • The fourth option shown above is for an offer to be applicable only on some special days such as Diwali, New Year, and Christmas etc.
  • The validity of an offer can also be confined to a closed user group. For example, all calls made between users belonging to a closed user group will be cheaper as compared to the calls made outside the group.
  • Some offers are valid based on the destination of the called party. For example, there may be a special rate applied when calls are made between New York and Chicago.
  • Usage based validity is a very interesting case. For example, when the usage of a particular customer crosses $30 in a given month, all subsequent calls for that month are offered at a discounted rate of 25%. This is a kind of a “reward” given to high ARPU customers.
  • The last option for validity is “unconditional”. This means that the offer in question will be valid at all times and for all calls.

3. Mediation:

The mediation process is the next logical step after rating. Once the rate is determined as explained in the previous section, it is applied to the CDR file. Now, this rated CDR file is pulled by the mediation engine. The mediation engine can handle CDRs from various sources – The MSC, the local office, the SMSC etc. It converts all these CDR files into a common file format. The file format is chosen so that it is understandable by the billing system. This file is then provided to the billing system for post-processing.

4. Billing:

In the billing process, CDRs are provided by the Mediation engine to the billing system. The billing system processes these CDRs and reads them. The output of this process is the generation of an itemized bill in human readable form by the billing system. As the CDRs which reach the billing system are already rated, the billing system can calculate the final bill for a subscriber and the rate applied for each charging event.

The details of the CDR are presented in the form of a bill which can then be e-mailed or dispatched to the subscriber’s billing address.

These days, some advanced billing systems also provide a feature of billing level discounts. For example, if there is a high paying customer who generates a bill of over USD 100 every month for 6 months consecutively, the billing system can provide this customer with a discount of 10% on his next bill. The billing system may even ask the rating engine to provide this high ARPU customer with a quota for free calls from next month onwards.

Wholesale/Interconnect Billing:

Wholesale billing applications include a variety of capabilities. Traditionally, this area included inter-carrier settlements capabilities and this was later extended to interconnect billing applications. In today’s competitive markets and complex value chains, it has expanded further to include among others Roaming, wholesale operators, and resellers, Mobile Virtual Network Operators, Content Providers and E-Commerce.

There is now an array of applications in the area providing charging, billing, and settlement capabilities on a raw data basis, individual transaction basis and bulk basis across a variety of services and platforms. These applications work across a variety of platforms and support a wide range of services, preferably in one single system.

5. Reconciliation:

Reconciliation is an offline process of sorting out the CDRs of the calls made in a certain period to determine the following information:

  1. How many calls were made to another carrier’s network?
  2. How many calls made to another carrier’s network were local/regional/international?
  3. How many calls from other networks terminated in my network?
  4. How many calls made from a 3rd party network used my network as a transit and they actually terminated in some other network?
  5. Similar details for SMS messages and MMS messages are also post processed.

Based on such information, the operator makes a record of the amount of revenue which has to be shared with other network operators. This revenue sharing takes place because all these operators share a point of interconnect (POI) to each other’s networks and they allow calls to be made from one network to another.

Due to this, the operator arrives at an amount which other operators need to pay him, and an amount which he needs to pay to other operators for providing interconnect services to each other.

This process is known as reconciliation.

Business Perspective and an introduction to the non-realtime components of BSS:

Business teams of a carrier are responsible for designing and planning tariff plans which are later launched in the form of marketing campaigns. Each tariff plan needs to be designed carefully, keeping in mind the inputs obtained from competitive analysis of the tariff plans of other carriers.

The BSS component which manages the marketing campaigns for the carrier is called “Campaign Management”. The success or failure of a particular marketing campaign is gauged by another component known as “Business Intelligence” or BI.

The Business Intelligence engine provides the business teams with clarity on the performance of a particular marketing campaign based on various parameters. An example is provided below:

  • Popularity of a particular marketing campaign (tariff plan) based on market segments such as children, young executives etc.
  • Popularity of a campaign based on the region – Florida, California, New Jersey etc.
  • Popularity of a campaign based on age.
  • Popularity of a campaign based on market segment – High ARPU customers, Customers with traditionally low ARPU, mid ARPU customers, enterprise customers etc.

Some of the other major functions of a BSS system which is critical from the viewpoint of a network carrier are:

Revenue Assurance:

The main revenue assurance application areas are:

  • Detection of data discrepancies – Detection of data discrepancies between systems and data repositories that might affect the ability to generate revenues or increase costs, including,
    • Configuration data – e.g. between Customer Relationship Management systems, inventory and network)
    • Events data – e.g., between the call Switch, Mediation, and billing)
    • Interconnect/partners billing
  • Detection of data integrity and correctness problems, e.g., a switch that rounds incorrectly the durations of the call.
  • Rating and Billing Verification – Verification of the correctness of the application of the rating and billing rules – e.g., is the customer billed according to the correct plan, and is he billed correctly according to the correspondent plan.
  • Investigation of revenue leakages, finding and correcting their root cause to prevent the recurrence of similar leakages
  • Grouping and classification of leakages
  • Equipment and system testing – Proactively test equipment and systems and processes to verify that they provide accurate information- e.g., using test call generation
  • Trouble Reports and Alarms – Generation and tracking of Revenue Assurance Trouble Reports and Alarms
  • Automation of revenue assurance controls and data collection
  • Automation of leakages correction
  • Generation of revenue leakage reports and documentation both for internal needs as well as a support to regulatory compliance activities.

Fraud Management:

Investigating, preventing and responding to activities that indicate fraudulent use of networks or systems.

This is achieved by effective Fraud Management systems coupled with the instrumentation and monitoring that enables potential fraudulent activities to be identified. There are close linkages between fraud identification and anomaly detection.

Eg:

  1. Someone fraudulently tops up the pre paid account from the system backend without using a voucher.
  2. Someone reduces the value of the pos paid bill just before it is processed by the billing system.
  3. Someone deletes the CDRs or reduces the rate on each CDR.

Conclusion:

The domain of BSS is huge and it is not possible to cover all aspects in a single post.

However, this post provided an introduction to some of the important concepts of this area and how the BSS connects to network elements of a telecom system over standard interfaces.

We also discussed some of the most critical concepts of a BSS platform which directly influence the operator’s revenue realization capabilities – such as rating, charging, billing, reconciliation, revenue assurance and fraud management.

If you found this post useful, please feel free to drop comments. If you feel that a certain area was missed out, or if some part of the post was not easily understandable, please let me know.

Posted in 3gpp, billing, BSS, DIAMETER, DIAMETER charging, IMS, mediation, network elements, OSS, post-paid, pre-paid, RADIUS, rating, telecom | Tagged: , , , , , , , , , , , , | 60 Comments »

Creating,building,deploying and testing projects with Mobicents JAIN SLEE 2.x.y Series

Posted by Aayush Bhatnagar on March 10, 2010


Introduction:

Mobicents 2.x.y series of the JAIN SLEE platform is fully compliant to JSR-240 specification. It has been released to the community recently and I have observed frequent queries by the community on creating and deploying JAIN SLEE services on this platform.

Some of the queries are a common concern to many community members.

Therefore, I decided to write this tutorial for providing a step-by-step process for developing and deploying components on the JAIN SLEE 2.x.y series of the Mobicents platform.

This post assumes that you have basic working experience with tools such as Eclipse and Maven and you are using the JAIN SLEE 2.0.0GA binary distribution. For getting JAIN SLEE 2.0.0 GA, please visit this link: JAIN SLEE 2.0.0 GA Download

This post will cover the following topics:

a) Setting up your environment.

b) Installing necessary plugins and software.

c) Developing a JAIN SLEE project using maven archetypes.

d) Launching Maven builds from command line and from eclipse.

e) Deploying and testing your JAIN SLEE services using an IMS client.

Setting up your environment and software installation:


Before you start, you need to set up your environment properly and need to download and install the requisite software. This includes the following steps:

1. Download the Java Development Kit and install it on your machine.

You can get the JDK from this link: JDK Download

Select the appropriate package depending upon your operating system and set the JAVA_HOME environment variable and set the PATH variable properly. Follow the instructions given on the SUN website for the same.

2. Download and install Maven-2 or higher.

All Mobicents components are ‘mavenized’. You need to get Maven 2 or higher and install it on your machine. Please download and install maven and set the required environment variables (M2, M2_HOME and M2_REPO). Also set the PATH correctly.

You can get maven 2 from this link: MAVEN2

3. Download and install Mobicents Maven plugins.

Mobicents provides some plugins for development. Even though these components are for the JAIN SLEE 1.x.y application components at the time of this post, the maven plugins for JAIN SLEE 2.x.y are expected to be released soon for use with the JAIN SLEE 2.x.y series.

You can download and install these plugins from here:

a. Mobicents maven library plugin

b. Mobicents maven DU plugin

4. Install Maven archetypes and configure the Maven archetype catalog

You need to get the archetypes from the link provided:

a. Mobicents maven archetypes

Now the archetype-catalog.xml file needs to be configured to include these installed archetypes. This is done by including their entries in this file. This file should be present in the .m2 directory of  your installation.  An example file is shown below:

<?xml version=”1.0″ encoding=”UTF-8″?>
<archetype-catalog>
<archetypes>
<archetype>
<groupId>org.mobicents.tools.maven.archetype.slee</groupId>
<artifactId>jain-slee-11-service</artifactId>
<version>1.0.0.BETA2-SNAPSHOT</version>
</archetype>
<archetype>
<groupId>org.mobicents.tools.maven.archetype.slee</groupId>
<artifactId>jain-slee-11-library</artifactId>
<version>1.0.0.BETA2-SNAPSHOT</version>
</archetype>
<archetype>
<groupId>org.mobicents.tools.maven.archetype.slee</groupId>
<artifactId>jain-slee-11-ra</artifactId>
<version>1.0.0.BETA2-SNAPSHOT</version>
</archetype>
<archetype>
<groupId>org.mobicents.tools.maven.archetype.slee</groupId>
<artifactId>jain-slee-11-profile</artifactId>
<version>1.0.0.BETA2-SNAPSHOT</version>
</archetype>
</archetypes>
</archetype-catalog>
Please note, that at the time of writing this post, the jain-slee-11-service archetype is not present in the SVN.  It will be committed in the SVN in the future though. You can use the jain-slee-basic-service archetype for Mobicents 1.x.y and edit the descriptors to make it work with the 2.x.y series.

5. Download and install Eclipse Galileo

Please use Eclipse Galileo, as it supports launching MAVEN builds from inside eclipse and you will not need to use the command line interface. Eclipse Galileo can be downloaded from here:

Eclipse Download

Open eclipse and configure your default workbench location. You should see a screen like this for a new installation:

6. Install the m2Eclipse plugin

After downloading eclipse, you need to install the m2eclipse plugin for maven integration with eclipse.

You can use the update site URL given on this link to install this plugin: m2eclipse

Refer to the screenshot on how to do this below.

Go to help —> install new software and then add the update site url as shown below:

7. Download and install Mobicents JAIN SLEE 2.0.0 GA

Download and install the mobicents container from the link given earlier in this post.

8. Download and install a SIP/IMS client

For testing purposes for the sample project explained later in this post, you will need a SIP or IMS client. I have used the Mercuro IMS client for testing. It is freely available here

Creating a basic Mobicents JAIN SLEE project:

1. Create an maven eclipse project:

Create a new maven project in eclipse by going to File —> New —> Other –> Maven Project. The project wizard launched will guide you in the project creation progress as shown in the screenshot below. You can select the archetypes you need for module creation. You may click on the “configure” button to select your archetype-catalog.xml file to see a list of available archetypes.

In this example, we are using the jain-slee-basic-service archetype, as at the time of writing this post the jain-slee-11-archetype is not ready in SVN.

The project modules created will be of the following structure:

|-du
|—src
|—–main
|——-resources
|———services
|-sbb
|—src
|—–main
|——-java
|———…
|——-resources
|———META-INF

If you look in the filesystem, the project parent (root) will have the following content:

It will contain a parent POM file and two modules by the name of “sbb” and “du”

The parent POM file of our example project looks like this:

<project xmlns=”http://maven.apache.org/POM/4.0.0&#8243; xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance&#8221; xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd”&gt;

<modelVersion>4.0.0</modelVersion>

<packaging>pom</packaging>

<artifactId>mobicents-tutorial-parent</artifactId>

<groupId>org.tutorial</groupId>

<version>0.0.1-SNAPSHOT</version>

<modules>

<module>sbb</module>

<module>du</module>

</modules>

<properties>

<!– JBOSS APP SERVER CONFIG RUNNING MOBICENTS –>

<jboss.config>default</jboss.config>

<mobicents.resources.sip11.version>2.0.0.GA</mobicents.resources.sip11.version>

<mobicents.servers.jainslee.version>2.0.0.GA</mobicents.servers.jainslee.version>

</properties>

<dependencyManagement>

<dependencies>

<!–

IMPORTS MOBICENTS JAIN SLEE SERVER

DEPENDENCY MANAGEMENT

–>

<dependency>

<groupId>org.mobicents.servers.jainslee.core</groupId>

<artifactId>mobicents-slee-core</artifactId>

<version>2.0.0-SNAPSHOT</version>

</dependency>

</dependencies>

</dependencyManagement>

<build>

<plugins>

<!– MOBICENTS MAVEN ECLIPSE PLUGIN – use “mvn mobicents:eclipse” to generate eclipse project files –>

<plugin>

<artifactId>maven-eclipse-plugin</artifactId>

<groupId>org.mobicents.tools</groupId>

<version>1.0.0.BETA2</version>

<inherited>false</inherited>

<executions />

</plugin>

<!– JAVA COMPILER CONFIG –>

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-compiler-plugin</artifactId>

<configuration>

<source>1.5</source>

<target>1.5</target>

<debug>true</debug>

</configuration>

</plugin>

<!– JARS MANIFEST FILE SETUP –>

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-jar-plugin</artifactId>

<configuration>

<archive>

<manifest>

<addDefaultSpecificationEntries>

true

</addDefaultSpecificationEntries>

<addDefaultImplementationEntries>

true

</addDefaultImplementationEntries>

</manifest>

</archive>

</configuration>

</plugin>

</plugins>

</build>

<!– JBOSS MAVEN REPOSITORIES –>

<repositories>

<repository>

<id>jboss</id>

<name>JBoss Repository</name>

<url>http://repository.jboss.org/maven2</url&gt;

<snapshots>

<enabled>false</enabled>

</snapshots>

</repository>

<repository>

<id>jboss-snapshots</id>

<name>JBoss Snapshot Repository</name>

<url>http://snapshots.jboss.org/maven2</url&gt;

<releases>

<enabled>false</enabled>

</releases>

<snapshots>

<enabled>true</enabled>

</snapshots>

</repository>

</repositories>

<pluginRepositories>

<pluginRepository>

<id>jboss</id>

<name>JBoss Plugin Repository</name>

<url>http://repository.jboss.org/maven2</url&gt;

<snapshots>

<enabled>false</enabled>

</snapshots>

</pluginRepository>

<pluginRepository>

<id>jboss-snapshots</id>

<name>JBoss Snapshot Plugin Repository</name>

<url>http://snapshots.jboss.org/maven2</url&gt;

<releases>

<enabled>false</enabled>

</releases>

<snapshots>

<enabled>true</enabled>

</snapshots>

</pluginRepository>

</pluginRepositories>

</project>

This POM files lists its two child modules, the JBOSS repository URLs, the configuration of the target JBOSS AS in which we want to deploy our components, the java compiler configurations and the plugins we need for generating the eclipse files for mobicents projects.

The SBB module will have the following content:

It consists of the src folder. Inside this folder we have a hierarchy. The src/main/java folder contains your source code. The src/main/resources folder contains your sbb-jar.xml deployment descriptor file.

The pom file of the SBB module is as follows:

<project xmlns=”http://maven.apache.org/POM/4.0.0&#8243; xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance&#8221; xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd”&gt;

<modelVersion>4.0.0</modelVersion>

<parent>

<artifactId>mobicents-tutorial-parent</artifactId>

<groupId>org.tutorial</groupId>

<version>0.0.1-SNAPSHOT</version>

</parent>

<artifactId>mobicents-tutorial-sbb</artifactId>

<dependencies>

<dependency>

<groupId>org.mobicents.resources</groupId>

<artifactId>sip11-ratype</artifactId>

<version>2.0.0.BETA2</version>

<scope>runtime</scope>

</dependency>

</dependencies>

</project>

The deployable unit module will have the following structure:

It will consist of the src folder just like the sbb module did. Under the src/main/resources/services folder you will have your JAIN SLEE service.xml file.

The pom file looks like this for this module:

<project xmlns=”http://maven.apache.org/POM/4.0.0&#8243; xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance&#8221; xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd”&gt;
<modelVersion>4.0.0</modelVersion>
<packaging>pom</packaging>
<parent>
<artifactId>mobicents-tutorial-parent</artifactId>
<groupId>org.tutorial</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<artifactId>mobicents-tutorial-du</artifactId>
<dependencies>
<dependency>
<artifactId>mobicents-tutorial-sbb</artifactId>
<groupId>${pom.groupId}</groupId>
<version>${pom.version}</version>
</dependency>
</dependencies>

<build>

<plugins>
<plugin>
<groupId>org.mobicents.tools</groupId>
<artifactId>maven-du-plugin</artifactId>
<extensions>true</extensions>
<configuration />
<executions>
<execution>
<phase>install</phase>
<goals>
<goal>create</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-antrun-plugin</artifactId>
<executions>
<execution>
<id>deploy-DU</id>
<phase>install</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<copy overwrite=”true” file=”target/${project.build.finalName}.jar” todir=”${jboss.home}/server/${node}/deploy” />
</tasks>
</configuration>
</execution>
<execution>
<id>undeploy-DU</id>
<phase>clean</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<delete file=”${jboss.home}/server/${node}/deploy/${project.build.finalName}.jar” />
</tasks>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

The project structure is shown below:

2. Populate your SBB code:

Now, we are ready to do some coding. This example contains two event handler methods. The first event handler method is called when the service is first started by the JAIN SLEE container. It is marked as the onServiceStartedEvent (args).

In this event we check whether it is our service that is starting and attach to the service activity if that is the case.

This event is declared in the sbb-jar.xml file as follows:

<event event-direction=”Receive” initial-event=”True”>

<event-name>ServiceStartedEvent</event-name>

<event-type-ref>

<event-type-name>javax.slee.serviceactivity.ServiceStartedEvent</event-type-name>

<event-type-vendor>javax.slee</event-type-vendor>

<event-type-version>1.1</event-type-version>

</event-type-ref>

<initial-event-select variable=”ActivityContext” />

</event>

The source code for this event is generated by the maven plugin.

The second event handler of our project is the onRegisterEvent. This event is supposed to send back a 200 OK for the incoming request on the SIP server transaction activity and then construct and send a MESSAGE to the SIP client on the client transaction activity.

This method is declared in the sbb-jar.xml as follows:

<event event-direction=”Receive” initial-event=”True”>

<event-name>RegisterEvent</event-name>

<event-type-ref>

<event-type-name>javax.sip.message.Request.REGISTER</event-type-name>

<event-type-vendor>net.java.slee</event-type-vendor>

<event-type-version>1.2</event-type-version>

</event-type-ref>

<initial-event-select variable=”ActivityContext” />

</event>

The source code for this method is as follows:

public void onRegisterEvent(RequestEvent event, ActivityContextInterface ac)

{

tracer.info(“REGISTER REQUEST RECEIVED AT MY SBB”);

Request register = event.getRequest();

ServerTransaction st = event.getServerTransaction();

FromHeader from = (FromHeader) register.getHeader(FromHeader.NAME);

ContactHeader contact = (ContactHeader)register.getHeader(ContactHeader.NAME);

tracer.info(“SENDING REPONSE TO THE REGISTER REQUEST”);

try{

st.sendResponse(messageFactory.createResponse(Response.OK, register));

tracer.info(“SENDING AN INSTANT MESSAGE TO THE CLIENT”);

Address fromNameAddress = addressFactory

.createAddress(“sip:mobicents-jain-slee@mobicents.org”);

fromNameAddress.setDisplayName(“Mobicents JAIN SLEE 2.0.0”);

FromHeader fromHeader = headerFactory.createFromHeader(

fromNameAddress, Utils.getInstance().generateTag());

List<ViaHeader> viaHeaders = new ArrayList<ViaHeader>(1);

ListeningPoint listeningPoint = provider.getListeningPoints()[0];

ViaHeader viaHeader = provider.getHeaderFactory()

.createViaHeader(listeningPoint.getIPAddress(),

listeningPoint.getPort(),

listeningPoint.getTransport(), null);

viaHeaders.add(viaHeader);

ContentTypeHeader contentTypeHeader = headerFactory

.createContentTypeHeader(“text”, “plain”);

CSeqHeader cSeqHeader = headerFactory.createCSeqHeader(2L,

Request.MESSAGE);

MaxForwardsHeader maxForwardsHeader = headerFactory

.createMaxForwardsHeader(70);

provider.getNewClientTransaction(messageFactory.createRequest(contact.getAddress().getURI(),

Request.MESSAGE, headerFactory.createCallIdHeader(“mobicents”+System.currentTimeMillis()),

cSeqHeader, fromHeader, headerFactory.createToHeader(from.getAddress(),null),

viaHeaders, maxForwardsHeader, contentTypeHeader, “Welcome to Mobicents JAIN SLEE 2.0 series”))

.sendRequest();

}catch(Exception ex){

ex.printStackTrace();

}

tracer.info(“REQUEST GREETING SENT..”);

}

The other important method of this SBB is the setSbbContext method. This is where we populate the resources being used in the SBB including JAIN SLEE facilities and Resource Adapter factories.

The code for this method looks like this:

/**
* Called when an sbb object is instantied and enters the pooled state.
*/
public void setSbbContext(SbbContext context) {
this.sbbContext = context;
this.tracer = context.getTracer(RootSbb.class.getSimpleName());
try {
sbbEnv = (Context) new InitialContext().lookup(“java:comp/env”);
provider = (SleeSipProvider) sbbEnv.lookup(“slee/resources/jainsip/1.2/provider”);
messageFactory = provider.getMessageFactory();
headerFactory = provider.getHeaderFactory();
addressFactory = provider.getAddressFactory();
tracer.info(“setSbbContext(…)”);
} catch (NamingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

3. Deployment descriptors:

There are two major deployment descriptors: sbb-jar.xml and service.xml

The sbb-jar.xml file looks like the one shown below. It contains the events that the SBB listens to and the SIP resource adapter configuration:

<?xml version=”1.0″?>

<!DOCTYPE sbb-jar PUBLIC “-//Sun Microsystems, Inc.//DTD JAIN SLEE SBB 1.1//EN”

http://java.sun.com/dtd/slee-sbb-jar_1_1.dtd”&gt;

<sbb-jar>

<sbb>

<description />

<sbb-name>mobicents-tutorial SBB</sbb-name>

<sbb-vendor>org.tutorial</sbb-vendor>

<sbb-version>0.0.1-SNAPSHOT</sbb-version>

<sbb-classes>

<sbb-abstract-class reentrant=”False”>

<sbb-abstract-class-name>org.tutorial.mobicents_tutorial.RootSbb</sbb-abstract-class-name>

</sbb-abstract-class>

</sbb-classes>

<event event-direction=”Receive” initial-event=”True”>

<event-name>RegisterEvent</event-name>

<event-type-ref>

<event-type-name>javax.sip.message.Request.REGISTER</event-type-name>

<event-type-vendor>net.java.slee</event-type-vendor>

<event-type-version>1.2</event-type-version>

</event-type-ref>

<initial-event-select variable=”ActivityContext” />

</event>

<event event-direction=”Receive” initial-event=”True”>

<event-name>ServiceStartedEvent</event-name>

<event-type-ref>

<event-type-name>javax.slee.serviceactivity.ServiceStartedEvent</event-type-name>

<event-type-vendor>javax.slee</event-type-vendor>

<event-type-version>1.1</event-type-version>

</event-type-ref>

<initial-event-select variable=”ActivityContext” />

</event>

<resource-adaptor-type-binding>

<resource-adaptor-type-ref>

<resource-adaptor-type-name>

JAIN SIP

</resource-adaptor-type-name>

<resource-adaptor-type-vendor>

javax.sip

</resource-adaptor-type-vendor>

<resource-adaptor-type-version>

1.2

</resource-adaptor-type-version>

</resource-adaptor-type-ref>

<activity-context-interface-factory-name>

slee/resources/jainsip/1.2/acifactory

</activity-context-interface-factory-name>

<resource-adaptor-entity-binding>

<resource-adaptor-object-name>

slee/resources/jainsip/1.2/provider

</resource-adaptor-object-name>

<resource-adaptor-entity-link>

SipRA

</resource-adaptor-entity-link>

</resource-adaptor-entity-binding>

</resource-adaptor-type-binding>

</sbb>

</sbb-jar>

The JAIN SLEE service.xml descriptor looks like the one shown below:

<?xml version=”1.0″ encoding=”utf-8″?>

<!DOCTYPE service-xml PUBLIC “-//Sun Microsystems, Inc.//DTD JAIN SLEE Service 1.1//EN”

http://java.sun.com/dtd/slee-service-xml_1_1.dtd”&gt;

<service-xml>

<service>

<description/>

<service-name>mobicents-tutorial SLEE Service</service-name>

<service-vendor>org.tutorial</service-vendor>

<service-version>1.1</service-version>

<root-sbb>

<description/>

<sbb-name>mobicents-tutorial SBB</sbb-name>

<sbb-vendor>org.tutorial</sbb-vendor>

<sbb-version>0.0.1-SNAPSHOT</sbb-version>

</root-sbb>

<default-priority>0</default-priority>

</service>

</service-xml>

4. Build your code:

For building the project, make sure JBOSS_HOME is set. Then right click on mobicents-tutorial-parent and go to run-as. Now click on maven install.

As a result of this operation, the DU will be compiled and deployed in the JBOSS AS.

Refer to the screenshot below:


5. Deploy your binaries:

If you JBOSS_HOME variable is not set, then the binaries will be copied to the mobicents-tutorial-parent\du\${jboss.home}\server\${node}\deploy directory. You can manually copy and paste this binary to the /deploy directory of JBOSS AS.

6. Test the service:

Use an IMS or a SIP client. I have used Mercuro. Configure 127.0.0.1:5060 as the outbound proxy for the client and then register with Mobicents JAIN SLEE server.

For Mercuro, you will see the result as shown in the screenshot below:


Conclusion:

If you have right tools by your side, then creating projects, developing, deploying and testing your logic can be a smooth process.

If you found this post useful, then please let me know. Your feedback is valuable.


Posted in Eclipse, IMS, IMS UE, jain slee, jslee, maven, Mobicents, sbb, SIP, telecom | Tagged: , , , , , , , , , , , , , , | 40 Comments »