OSS and BSS

All fixed and mobile telecommunications service providers have physical equipment with embedded software that enable them to offer services. Beyond this embedded network software, there are two other kinds of software that are critical to a service provider's day-to-day business: business support systems and operations support systems.

BSS (Business Support System) software applications are used by operations, customer care, and other functional groups to manage business operations focusing on external business such as billing, rating, sales management, customer-service management and customer databases.

OSS (Operations Support System) software applications allow operations and IT personnel to administer the operational processes focusing on the network and services, including service quality monitoring, network and server performance, logical and physical resources management (also referred to as element and network management), and provisioning.

OSS and BSS are the foundation of a service provider's business. They enable telecom service providers to manage their networks, their business and their customer relations. Furthermore, they are a key part of the Service Delivery Environment (SDE), enabling service providers to deploy advanced IMS, IPTV, Web or "blended" services to their customers.

“This SqlTransaction has completed; it is no longer usable.”

Look for possible areas where the transaction is being committed twice (or rolled back twice, or rolled back and committed, etc.). Does the .Net code commit the transaction after the SP has already committed it? Does the .Net code roll it back on encountering an error, then attempt to roll it back again in a catch (or finally) clause?

It's possible an error condition was never being hit on the old server, and thus the faulty "double rollback" code was never hit. Maybe now you have a situation where there is some configuration error on the new server, and now the faulty code is getting hit via exception handling.

The following example creates a SqlConnection and a SqlTransaction. It also demonstrates how to use the BeginTransaction, Commit, and Rollback methods. The transaction is rolled back on any error. Try/Catch error handling is used to handle any errors when attempting to commit or roll back the transaction.

private static void ExecuteSqlTransaction(string connectionString)
{
    using (SqlConnection connection = new SqlConnection(connectionString))
    {
        connection.Open();

        SqlCommand command = connection.CreateCommand();
        SqlTransaction transaction;

        // Start a local transaction.
        transaction = connection.BeginTransaction("SampleTransaction");

        // Must assign both transaction object and connection 
        // to Command object for a pending local transaction
        command.Connection = connection;
        command.Transaction = transaction;

        try
        {
            command.CommandText =
            "Insert into Region (RegionID, RegionDescription) VALUES (100, 'Description')";
            command.ExecuteNonQuery();
            command.CommandText =
            "Insert into Region (RegionID, RegionDescription) VALUES (101, 'Description')";
            command.ExecuteNonQuery();

            // Attempt to commit the transaction.
            transaction.Commit();
            Console.WriteLine("Both records are written to database.");
        }
        catch (Exception ex)
        {
            Console.WriteLine("Commit Exception Type: {0}", ex.GetType());
            Console.WriteLine("  Message: {0}", ex.Message);

            // Attempt to roll back the transaction. 
            try
            {
                transaction.Rollback();
            }
            catch (Exception ex2)
            {
                // This catch block will handle any errors that may have occurred 
                // on the server that would cause the rollback to fail, such as 
                // a closed connection.
                Console.WriteLine("Rollback Exception Type: {0}", ex2.GetType());
                Console.WriteLine("  Message: {0}", ex2.Message);
            }
        }
    }
}