WO1998055921A1 - System and method relating to generic handling of data - Google Patents
System and method relating to generic handling of data Download PDFInfo
- Publication number
- WO1998055921A1 WO1998055921A1 PCT/SE1998/001060 SE9801060W WO9855921A1 WO 1998055921 A1 WO1998055921 A1 WO 1998055921A1 SE 9801060 W SE9801060 W SE 9801060W WO 9855921 A1 WO9855921 A1 WO 9855921A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- data
- handling
- call
- function
- internal
- Prior art date
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
Definitions
- the present invention relates to a system for providing communication between a number of data handling arrangements of which at least a number are arranged in different hierarchical layers.
- the invention also relates to a communication block which is re-usable, i.e. which can be used on different levels in a system and which enables the use of a generic component having the same interface towards all kinds of functionalities.
- the invention also relates to a method of sending messages between data handling systems and/or function handling means and a method for generic handling of data in a configurable number of data handling arrangements each of which containing a configurable number of function handling means.
- CONFIRMATION COPY interfaces in separate parts and to have a common structure holding these parts.
- the distributed databases of today and the need of flexible interfaces towards them often provide solutions in which the same kind of components are re-used in another part of the system, i.e. the "global" system. Examples thereon are e.g. discussed in 'Microsoft Corporation, OLE 2 Programmers Reference Vol. 1 and 2', Microsoft Press 1994 and Object Management Group "The Common Object Request Broker: Architecture and Specification" .
- US-A-5 327 529 shows how data is connected to separate subfunctions .
- WO 95/11560 shows an application programming interface system for heterogeneous connectivity and universal and generic interfacing for distributed applications and processors.
- the object of the system relates to a number of applications which should cooperate, but does not provide an interface to something for which the protocol is not exactly known.
- This document does not disclose a continuously evolving interface. Distribution components of similar kinds are used in order to ensure that applications having these components are able to communicate with each other and they are not intended for, and do also not provide for, an interface which is flexible per se.
- the definition data that is given has a very strict syntax adapted to the particular application.
- An interface which can be almost completely completed without the knowledge about the demanded services, is also needed. Particularly it shall be enough to configure towards a specific underlying produc . Furthermore products are needed for which the functionality can be enhanced step by step as the technology and the markets develop.
- the interface upwards has to be stable; particularly it has to be backwards compatible also when underlying interfaces are changed. Furthermore it is desirable that an operator is enabled to define the presentation of underlying interfaces. In general terms this is achieved through simple components transforming data, which components are flexibly controllable.
- the components reuse overlying common functionality to control the translation of data and for fetching information about how to provide the translation.
- data is handled generically, so that regardless of complexity and of differences between data, all data is handled in one and the same manner.
- the protocols that are used for transfer of data both support a generic handling of data and structuring and classification of data.
- a separation is done between definition data that is used to define the interface and its behavior and information data which is the data that is sent and modified during operation of the system.
- a generic handling of information data enables the provision of generic components having a uniform interface, independently of the exact manner in which functions are performed. Since information data consequently is handled in a generic manner, the structured protocols that are used enable the creation of flexible and re-usable building blocks which as such contain intelligence to use the appropriate parts of the information data that it receives and together with definition data use said information data for different functionalities.
- Definition data is structured according to common guidelines following the division in components and building blocks. The structuration of definition data in a number of ways is similar to the structuration of information data transmitted using some protocol .
- definition data is always arranged separately and it is never introduced into the components .
- simple generic building blocks for communication are used on many different locations within the architecture, and therefore the system can be distributed in different ways on underlying hardware.
- a hierarchical distribution mechanism is used which is controlled in a flexible manner and the re-usable building blocks can be combined in different ways.
- a building block here relates to a complete functionality, mostly comprising a plurality of components, a component here e.g. comprising a C++ class and possibly some subclasses.
- each data handling arrangements comprises interfacing means and handling means.
- the interfacing means includes converting means for translating incoming messages to internal messages (calls) comprising an internal call object and a number of result objects.
- At least a number of the data handling arrangements comprise (s) a number of function handling means and the interfacing means further comprise (s) distributing means for distributing call objects to the appropriate function handling means.
- a call object is sent from one function handling means to another in a consecutive way as an internal standard call object and each function handling means provides at least one result object upon handling the call object.
- Internal (standard) call objects are converted to internal communication messages for sending between data handling arrangements.
- Providing a result object means that a result object is generated, or, alternatively a result object from an underlying function handling means is just modified or controlled before it is sent on.
- the invention is based on an object oriented framework using inheritance and the possibility of calling specialized object without knowing anything but the common properties of a superior object.
- call methods In order to provide an interface between re-usable building blocks which mainly is uniform, merely a few number of call methods are used through which a call and a result object are exchanged.
- a simple protocol is used to define information data e.g. as a name and ASCII -string and it is arranged on top of a high level (basic) carrier service such as a remote procedure call (RPC) , X.25, Telnet etc.
- RPC remote procedure call
- At least one data handling arrangement receives messages from external systems which in converting means are translated to internal communication messages or standard call objects.
- incoming messages are ASCII messages based on a carrier protocol such as for example HTTP, RPC, Telnet etc.
- At least one (second) data handling arrangement is arranged to receive messages from another
- an internal communication message sent between data handling arrangement comprises an ASCII data string using the RPC protocol.
- the HTTP protocol is used.
- at least one data handling arrangement comprises sending means for sending a call object (as a call operation) to an application system, e.g. a service management application system (SMAS) .
- SMAS service management application system
- the sending means then comprises executing means for translating the internal call object to a message having a format receivable by the application system.
- each data handling arrangement and/or each function handling means at least one result object is provided when an internal call object is processed and said result objects are sent to the preceding data handling arrangements/function handling means.
- Particularly all information data i.e. internal call objects or internal communication messages, are handled generically and separately from definition data used for defining the interface, its behavior and the relevant functions.
- the definition data is stored in setup files, tables or as text files in any appropriate manner.
- at least one data handling arrangement or at least one function handling means apply load sharing, i.e.
- load sharing can be applied on different levels either on the data handling arrangement level or on the level of function handling means.
- a number of data handling arrangements are arranged in parallell .
- the interfacing means forms a single access point for external client systems as well as for each data handling arrangement .
- the interfacing means particularly comprises a parallell distributor for executing incoming calls in parallell and a handler switch.
- the interface means may also include protocol converting means for converting different protocols to an internal communication message before the convertion to an internal standard call object is done in the converting means.
- the converting means of the interfacing means particularly converts incoming messages to an internal call object at least comprising the mandatory parameters: object, action and key-fields and advantageously also a number of optional parameters for information (call information) .
- the handling means of a data handling arrangement comprises a call object handler which receives internal call objects from the handler switch of the interfacing means and which distributes the internal call objects to service agent managers provided for processing the calls in service agent processes. Particularly routing tables and/or text files are used for giving distribution (definition) information.
- a new function handling means is introduced, (or a data handling arrangement) an additional service agent is introduced and a service agent manager has to be created and configured for handling the service agent.
- Each service agent process particularly comprises a function call handler for analyzing incoming internal call objects to determine the relevant action and for creating call objects to be sent to serving means of the application system (s) .
- At least one data handling arrangement comprises an adapting part including one adapter for each type of application system (or each version of one and the same application system) .
- the adapters internal call objects are received and converted to the type of message receivable by the intended application system (version) .
- At least one data handling arrangement comprises a number of function handling means such as for example one or more of a log handling means in which received call objects are logged, for example together with date and time stamp, transaction handling means in which a unique transaction identification is added to the call object, router handling means for routing the call object for example depending on physical location address and/or functionality, conversion handling means replacing one identification by another different identification, authority handling means for checking user access to data requested in a call object, validating means for checking data sent in a call object etc.
- One or more data handling arrangements may comprise/be provided with one or more of said function handling means and/or a number of other function handling means defined or not yet defined, e.g. in the future developed function handling means. The same applies for "lower level" function handling means or subfunction handling means.
- a data handling arrangement is thus also provided for messages incoming from a client system or from another data handling arrangement.
- a data handling arrangement includes interfacing means, handling means and sending means.
- the interfacing means form a single access point for incoming messages.
- the interfacing means further comprises converting means for translating incoming messages to internal standard call objects which call objects each at least comprise an object field, an operation field and key-fields.
- the interfacing means comprises distributing means for distributing call objects to said handling means.
- the handling means comprises a number of processing means for processing call objects, at least one result object being provided when an operation is performed.
- Each of said processing means comprises function handling means and when an operation has been performed in a function handling means, a result object is returned to the preceding function handling means (or a preceding data handling arrangement) .
- a method which relates to the sending of a message from a client system to an application system through a number of data handling arrangements.
- the method comprises the steps of: - receiving an message in interfacing means of said data handling arrangement , - converting the message to an internal standard call object and a number of result objects,
- FIG 1 schematically illustrates the inventive concept in common terms
- FIG 2 schematically illustrates different functional layers (function handling means) getting definition data for flexible controlling
- FIG 3A schematically illustrates a managing system managing a number of application systems
- FIG 3B schematically illustrates a service agent framework
- FIG 4 schematically illustrates a first embodiment of a data handling arrangement handling different application systems
- FIG 5 illustrates the interfacing means of the data handling arrangement of Fig 4
- FIG 6 illustrates the handling means of the data handling arrangement as illustrated in Fig 5
- FIG 7 schematically illustrates a service agent process
- FIG 8 schematically illustrates authority handling means
- FIG 9 schematically illustrates routing handling means
- FIG 10 schematically illustrates access handling means
- FIG 11 is an example of an adapter
- FIG 12 illustrates an embodiment comprising three data handling arrangements
- FIG 13 is a flow diagram for sending a message via two data handling arrangements to an application system.
- first generic communication handling means (converting means) 15 converts an internal call object to a generic internal standard communication message 1 which is sent to second generic communication handling means (converting means) 11 of a data handling arrangement 10, in which the internal communication message is converted to an internal standard call object.
- the internal call object is received in distributing means and the call object is routed via function handling means routing table 12 to specific logic function handling means 13A;13B;13C using definition data 120 in a separate definition file or a table.
- a result object is returned (not shown) and internal standard call objects are sent to another data handling arrangement via first and second generic communication function handling means 14,21 (blocks) (in which it is converted to/from an internal communication message) .
- the second data handling arrangement 20 is for example a generic service adapter in which a similar procedure as above is performed using definition data 220 in table function handling means 22 for sending an internal communication message to specific logic function handling means 23A;23B;23C etc.
- Fig 1 illustrates one way of implementing a distribution mechanism.
- the distribution functionality is implemented e.g. by two or three independent function handling means, each having a separate set of definition data, c.f. the function handling means distributor and router in Fig 12; a function handling means rearranger (not shown) may also be implemented between the distributor and the router of Fig 12.
- the distribution mechanism is controlled by definition data providing information about which underlying data handling arrangement/function handling means is to be the receiver of a particular messages.
- the definition data can be in the form of "simple" data, but it may also contain more or less advanced programming. Particularly a complete specific logic containing data and intelligence can be exchanged completely in one step.
- Fig 2 illustrates how different functional layers fetch definition data for flexible controlling by a controlling arrangement 40.
- a function handling means 41,42,43 is created and these function handling means have an external interface which is uniform, comprising the reception of a call object and a response in the form of a result object.
- the different function handling means are security handling means 41, validating handling means 42 and execution handling means 43.
- Definition data for each function handling means (security model 410, validation model 420, config. validation 430) are kept separately and independently.
- function handling means which is implemented as an interface to C++ classes
- a security function handling means the interface of which is the class security which only contains the method handle (call object, result object)
- function handling block validator the interface of which is the class validator having the methods: - validate (call object, result object) - handle (call object, result object) .
- Both these function handling means have an important internal functionality and a considerable internal structure even if they from the outside seem to be two very simple objects only supporting a few possible methods.
- Fig 3A very schematically illustrates service providers and a managing system CC BS managing a number of application systems SMAS, SOG etc.
- the service providers form the sales service/customer view.
- the external (managing) system or the client system is here supposed to be a customer care and a billing system (CC BS) or a customer administration system including a subscriber database and a billing database.
- a message is sent by interfacing means (not explicitly illustrated) as an enhanced customer administration interface object, here called a CAI+ message.
- a CAI+ message is a textbased message comprising a number of CAI+ objects followed by an action.
- a CAI+ object is an object name followed by data or a number of object names followed by data.
- the message can be sent to a number of different application systems such as a service management application system SMAS of different versions (e.g. service data point SDP and service control point SCP) using a man machine interface MMI and an INM protocol (a TCP/IP based, binary format protocol) respectively.
- a service management application system SMAS of different versions e.g. service data point SDP and service control point SCP
- MMI man machine interface
- INM protocol a TCP/IP based, binary format protocol
- CMISE Common Management Information Service
- SOG Service Order Gateway
- GSA Generic Service Adapter
- CAI Generic Service Adapter
- a SOG is a device providing an information interface towards a customer administration system for a mobile communication system.
- a GSA service agent framework is a product hiding different subsystems in the service provisioning area for the client. As illustrated in the figure there exists a number of different subsystems having different representation of the subscription data.
- a service can have its provision data distributed in different subsystems such as GSA-SCP and GSA-SDP servers etc.
- GSA Generic Service Adapater
- SMAS Service Creation Environment
- SMS Service Management System
- SMAS includes functions for creating new IN services and updating existing ones. It further provides functions for installation of services into the network elements, and operations to connect subscribers and subscriber specific data to the services. Statistics on service usage can be retrieved from the network and presented to the SMAS user.
- GSA provides an environment for development of machine-machine commuication interfaces or man-machine interfaces for provisioning of services managed by SMAS.
- the connection between communication messages or UI (User Interface) fields and corresponding IN objects is handled in GSA by a service configuration file.
- GSA interfaces can be developed which provides a service implementation independent view of IN services.
- chey must be moved to the operational Service Management and Provisioning system also includes a GSA installation.
- GSA does not have any extra support for storing information about the subscribers or subscriptions. Thus, its completely transparent towards SMAS. For each SMAS service or SDP application, a service configuration file is created. Logic handling relations between SMAS services or SDP applications are handled outside GSA.
- Fig 3B schematically illustrates a (GSA) Service Agent Framework.
- the interfacing means comprises a parallell distributor and a handler switch for distributing/routing call objects. This is further described under reference to Figs 4 and 5.
- Adapters are used for sending a message to different application systems or different versions of application systems, such as e.g. GSA 2.1- SDP, GSA2.2-SDP, GSA-SCP; SOG, GSA-SAF-CUSTOM and SQL (Standard Query Language) -server.
- the relevant interfaces to be used are also indicated in Fig 3B.
- the given application systems/versions are only given for exemplifying reasons.
- a standard service agent is provided for reading "simple" forms of definition data; e.g. a message can be divided into a number of parts etc., using a configuration file.
- a customer service agent For more advanced or specifique tasks a customer service agent is provided through which the customer can provide for definition data (e.g. programs) to handle specifique or advanced tasks etc.
- definition data e.g. programs
- the data handling arrangement 50 as referred to above, c.f. Fig 4, comprises an interface part 51 which will be further described under reference to Fig 5.
- the interface function handling means forms a single access point for the client system (s) . Different communication interfaces can be offered.
- the data handling arrangement further comprises function handling means called handling means 52 which takes care of the actual message (call) processing in so called service agents.
- a call object comprises ASCII coded data, comprising a number of CAI+ objects followed by a number of actions (generally more objects than actions) .
- a service agent is called which then invokes its logic to execute the request.
- a service agent is an object created to support service provisioning operations and it does not exist in the system itself. The service agent is what is provided when a configuration is made at site. For the configuration a number of operations are defined which effect the service agent object in a standardized way. The operations are create, set, delete and get. Other operations can however be implemented within the framework e.g. by customer programming .
- Each message from a client system can result in multiple messages to other subsystems or application systems via adapters in adapting means 53, which also are included in the data handling arrangement 50 as illustrated in Fig 4.
- adapting means 53 which also are included in the data handling arrangement 50 as illustrated in Fig 4.
- Not every data handling arrangement includes an adapter part since some data handling arrangements may only communicate with other data handling arrangements and not with application systems or subsystems.
- the adapter part 53 then takes care of all specific handling including addressing, routing, adaption of messages, communication protocols and different versions of subsystems or different application systems.
- the adapting part 53 also includes a General Service Agent Functionality (SAF) part including a number of servers, of which some examples are shown in Fig 4, e.g. a lock server, a transaction server, setup/validation serving means etc.
- SAF General Service Agent Functionality
- the handling means 52 will be further described under reference to Fig 6 and the adapting means 53 will be further described with reference to Fig 11 in which a specific adapter is illustrated for exemplifying reasons.
- Fig 5 the interfacing means 51 according to a first embodiment is illustrated.
- Messages are incoming from one or more client systems e.g. via a customer administration interface CAI, some other interface or as an internal communication message (for example from another data handling arrangement) .
- the interface part i.e. the interfacing means 51, includes a parallell distributor 501 which is able to execute incoming calls in parallell.
- the parallell distributor 501 has one port or access point for all calling clients (and adapters) .
- the interface format from the parallell distributor is HTTP (or RPC) .
- a call object 100 is the standard internal interface between different handlers and objects.
- the internal standard call objects 100 are used as arguments between internal interfaces and they contain the field information.
- the internal call object 100 is sent for example via HTTP or RPC.
- the interface part thus comprises converting means for translating an input message sent via RPC or HTTP to a call object 100.
- the call object 100 comprises a number of parameters of which the parameters object, action and key-fields are mandatory. However, there are also optional parameters with information.
- "Object” defines the service feature object to be managed and "action” defines the operation.
- Key-field parameters are defined in a validation profile for the "object”.
- TransID is an optional parameter set by the calling system and it is not modified but used for identification of the call in logs.
- the result of the operation (action) is sent back with a result object .
- An example of a call object comprising three CAI+ objects and two actions may be as as follows:
- the protocol converting means adapting messages acts a server for the client system. Internally the converting means may act as a client. Examples of converters are CAI-CAI+converters and RPC-HTTP converters.
- the converting means may also comprise a CAI to Telnet protocol converter and a RPC to HTTP protocol converter. A multithreaded (builds applications with multiple threads) RPC server converting from RCP format to HTTP format can also be provided.
- the converting means may also in a particular embodiment route a HTTP message to two different URL addresses (w.w.w. addresses) such that if a first URL address is not available, the next address will be called instead. From the interfacing means 51, via the parallell distributor 501, or separate switching means, the call objects 100 are transferred to the handling means 52.
- a call object 100 i.e. an internal standard call object
- the call object is received in a call handler 502 which creates and adds a unique TransID, e.g. a GSA_TransID to the call object.
- the call handler sends the call object 100 to the relevant service agent manager 503A via a routing functionality.
- Routing information i.e. definition data
- a table not shown
- Which service agent manager that is chosen depends on the call object. In a particular embodiment there is one standard service agent and a number of customized service agents.
- a service agent manager 503A, 503B, 503C acts as a manager for a number of service agent processes 503A X , ... , 503A 5 , 503B ! , ... , 503C 5 .
- Each service agent manager 503A, 503B,503C can only handle one type of service agents.
- the service agent manager can be configured for the number of processes to be running.
- the manager includes a functionality of error reporting if a service agent fails.
- the service agent manager includes a functionality for supervision of load and resource utilization etc.
- Fig 7 illustrates the reception of a call object in a service agent process 503A.
- the service agent process is written in JavaTM of Sun Microsystems and the process is started/restarted and stopped from its call handler 502.
- the service agent process comprises a function call handler 504A, also denoted a message handler, which is a central object in the service agent framework.
- the function call handler 504A- L analyses incoming messages (call objects) 100 to decide which actions are to be performed.
- the function call handler 504A ] creates a number of call objects which are sent to other servers via adapters which will be more thoroughly described below.
- the function call handler 504A X comprises a number of function handling means, in this particular case a lock handler, a log, an authority handler, a message validation handler in addition to the call object handler (handle messages) itself.
- function handling means in this particular case a lock handler, a log, an authority handler, a message validation handler in addition to the call object handler (handle messages) itself.
- this merely constitutes one particular embodiment and fewer as well as more function handling means can be provided, and of course the invention is not limited to include these particular function handling means but a wide variety of other alternatives are possible.
- the illustrated function handling means will be more thoroughly discussed below. Since working with messages or call objects in parallell from clients has to be done in a controlled manner, a lock handler is provided. Therefore locks are introduced per managed object (call object) identity and the call objects are identified by the key fields contained in the object.
- the lock handler checks if an object is locked, and if not, the call object will be introduced into a lock
- Definition data SETUP FILE 522, PROGRAM CODE 523 as well as lock server 514 etc. is kept externally.
- the lock handling function unlocks the call object by deleting it from the lock server 514.
- the number of locked objects in parallell is low, for example less than 50.
- the lock handling functionality is configurable so as to be possible to switch on/switch off.
- the function call handler also contains a transaction handler.
- a transaction ID is then created for each call object. The identity is used to identify the call in logs etc. and it is added as one parameter in the call object.
- the handler can use a transID- in outgoing calls with an extra extension per call and for example two extra digits for outgoing calls.
- Transaction ID handling is performed using a transaction server 515.
- Input call objects as well as result objects are both logged in an event log server 519.
- the authority handler handles authority profiles. Different users are connected to the profiles which describe what operations a user is allowed to do for different call objects.
- the authority handler deals with access control to different objects.
- the authority handler as such is not essential and can be switched off which means that all access requests are granted.
- the authority handler is able to retrieve which key-parameters that belong to a particular call object which means that the authority handler must have access to the setup-files (text files or tables) .
- the authority handler reads all setup-files which are present by calling a setup/validation server 516 in order to be able to conclude which parameters of the call objects that are considered as key parameters for the different call objects.
- the access control is handled by an authority server 517 which is called by the authority handler.
- the authority server either returns "grant access” or “deny access” depending on if a call object matches an existing authority profile in the authority database or not . This is illustrated in Fig. 8.
- the authority handler in one embodiment works within the function call handler although it is not necessary and access to the authority server 517 is provided with object identifier parameters, user identity and action.
- the message validation handler validates input call objects and checks mandatory parameters and parameter limitations by calling setup/validation server 516. Of course also other validation requirements can be implemented by a program code in the function call handler which alternatively can be done by the client.
- the handling means also includes a standard message handler for rearranging messages (handle messages in the figure) which is the core functionality of the standard service agent handler (cf. Fig 4) . It creates messages (call objects) , calls an adapter to send the call object (if the data handling arrangement includes adapters which however is the case in the shown embodiment) , analyses the result, determines the next action to be done and provides/creates a result object to be sent back to the calling client. For simple tasks "single transaction" can be used for example applying best effort which means that the transaction will continue with remaining messages even if the previous failed. In an alternative embodiment atomic synchronization is used, which means that if the transaction is not successful for all objects, the whole transaction will be undone.
- each input message or a call object has fields named "object” and "action” .
- This combination points out the call objects to be sent to the underlying servers.
- a batch of messages or call objects are written in the setup file per action and the batch is then executed by the handler after preprocessing.
- free programming of service agents is provided for. This is particularly advantageous for cases when the tasks to be performed are complex or when the standard operations are not sufficient .
- the service agent programs are in an advantageous embodiment written as JavaTM objects.
- the handle message code is the only code that needs to be written for each new service agent. When programming is applicable a program name is given in the file.
- the actual object i.e.
- a send handler 526 is also provided which includes a number of function handling means such as lock handler, transaction, log and send (in this particular case) .
- the send handler hides a number of functions to the function call handler or the message handler which the latter is not to be concerned with.
- This function handling means functions substantially in the same manner as the function handling means of the function call handler as discussed above.
- a routing table is used for routing a call object to different server subsystems.
- Internal standard call objects uses routing (e.g. RPC based) without adaptation. If however adaptation is required, this is implemented in adapters for the particular service subsystem or the particular application system (version) .
- Connection pool and routing function 525 is an object combining open connections for the transaction. The routing function is involved when a new connection is created.
- a setup file i.e. definition data
- the setup file also specifies operation mode, single transaction or programming. If programming is applicable, a program name is also given in the file as discussed above.
- the service agent process also includes a result handler 527 which in turn also comprises a number of function handling means; in this particular case translate message, reset connections, reset call and result store and return result.
- the result object created by the handler is to be returned to the client system. This can be done in different ways. Before the result object is sent back, all data in the call and result store 524 are deleted for the transaction.
- Connections in the connection pool 525 are also closed. This is done in order to make the service agent process ready to execute the next call object in a subsequent transaction.
- the call and result store 524 a collection of calls and results for the actual transaction are stored. The store is provided with a copy of each call object and result objects and all outgoing call objects are stored together with the transaction sub-identification which is the outgoing call object number.
- each outgoing CAI+object is on the same format whereas the objects are modified in the adapters, if so required by the receiving system.
- the definition data included in the database DB 518 among others comprises locked objects, authority profiles and routing tables etc.
- setup file 522 and program code 523 is always kept separate from the information data, e.g. the call objects.
- Fig 9 call object server routing is schematically illustrated for various servers (GSA1SCP, GSA2SCP, GSA1SDP, SOG-AD) of service management application systems indicating the RPC-hostname and the RPC-ports to be used.
- the adapters here adapt the call objects to messages receivable by the application systems.
- An Application Programming Interface (API) of a Generic Service Adapter for RPC communication is e.g. used for sending.
- API Application Programming Interface
- the granting of access procedure via the authority server 517 is schematically illustrated.
- the database 518 includes an object table 518A and an access table 518B. From the call object, the object type and the key parameters are used to retrieve the call object ID.
- the user ID, the action and the object ID select a distinct row in the access table and if the row exist, the access is granted. Otherwise the access is denied.
- the section between the call and the database relates to the storing procedure.
- the underlined parameters are the keys for the respective table.
- the data handling arrangement as illustrated in Fig 4 includes an adapter part 53 since the data handling arrangement communicates with application systems 6A,6B.
- a so called GSA-SCP 53A adapter is illustrated which is a generic service adapter-service control point adapter relating to the SCP version of a SMAS.
- GSA-SCP 53A GSA-SDP 53B and SOG 53C adapters are illustrated.
- other adapters can also be provided such as for example SQL adapters.
- the adapters support call objects based on RPC (or HTTP) but also other alternatives are possible as discussed earlier in the application.
- the adapter 53A is called by the handler, i.e. the function call handler (message handler) 504A- L .
- the handler 504A- L has specified the parameters to be sent and the adapter 53A adapts them for the actual server (here GSA-SCP) and then sends a call object to the GSA-SCP subsystem.
- the adapter also converts the returned result object to a CAI+ format before it is returned to the call handler.
- an adapter internally can be implemented in a number of different ways depending on the supported system.
- new adapters can be added without requiring any modification of the service agent framework product .
- the adapters are developed as separate server processes. In this way development and testing gets easier and do not depend on one another.
- the GSA-SCP adapter 53A here comprises a parallell distributor 531 for load sharing purposes and the . call object is sent to the adapter itself which includes a routing table 532.
- Load sharing relates to an advantageous implementation of the invention which however is not necessary.
- resource sharing is provided so that the message can be sent to a free subsystem.
- the adapter converts a call object to a GSA-SCP server message.
- the adapter is multithreaded in order to cooperate with multiple GSA-RPC servers.
- a GSA-SCP server using the RPC-protocol is single threaded, the server only executes one request at the time.
- multiple servers are running in one and the same application system (SMAS) .
- a resource pool 533 for distribution to different servers within the same application system is then needed.
- an algorithm is needed and a central data area is provided for the algorithm data.
- the algorithm is executed by multiple GSA adapters simultaneously and for indication of the number of the respective GSA servers and their addresses, a parameter list is provided.
- a routing table as illustrated in Fig 11 can be used.
- an SCP specified in an incoming call object can be replaced by the actual SCP name as used in the application system (SMAS) .
- SMAS application system
- GSA-SDP server adapter which converts incoming call objects to GSA-SDP server messages using RPC. Similar to the adapter illustrated in Fig 11, a routing table is provided. However, this adapter does not have to be multithreaded since no SDP requests are executed in parallell.
- a SOG adapter (service order gateway) can be provided for converting call objects to CAI messages for a Telnet based SOG. Also this adapter comprises a routing table.
- the first data handling arrangement 60 comprises three function handling means, namely distributor 61, router 62 and communication 63A,63B.
- the definition data relating to the distributor 61 is separately arranged in a table 610 showing which types of services e.g. Virtual Call Center, (VCC) , Virtual Private Network (VPN) , Universal Personal Telecommunications (UPT) that are to be distributed to which physical locations, e.g. SMAS_A1 , SMAS_A2, SMAS_A3; Al , A2 , A3 e.g. being different towns.
- VCC Virtual Call Center
- VPN Virtual Private Network
- UPT Universal Personal Telecommunications
- the communication function handling means 63A, 63B provides for a conversion of an internal call object to an internal communication message as discussed under reference e.g. to Fig 1.
- the second data handling arrangement 70 also comprises a number of function handling means 71 , 72 , 73 , 74A, 74B.
- the communication function handling means 71 provides for conversion of an incoming communication message to an internal call object.
- the definition data of the distributor is provided in a table 720 giving the handler process to which a given service object (e.g. subscriber, VCC queue, VCC prompt; i.e. different CAI+ objects) is to be distributed.
- the router definition data is kept in a table 730 indicating which computer ports (addresses) given handler processes are to be routed to.
- the communication function handling means 74A, 74B provides a conversion as discussed above.
- the first data handling arrangement 60 can distribute a message to different physical locations depending on which type of service is addressed.
- the second data handling arrangement 70 distributes to different processes depending on which object that should be modified and the third data handling arrangement 80 executes the modification.
- a reuse of exactly the same function handling means can be achieved between the first and the second data handling arrangement since the distributor and router function handling means are exactly the same but the definition data make them serve different purposes.
- a flow diagram is illustrated in which a message incoming from an external system is received in a first data handling arrangement 90A.
- the flow diagram both illustrates the sending of call objects (i.e. internal standard call objects) between function handling means within a data handling arrangement and the sending of objects or messages as internal communication messages between data handling arrangements or from a data handling arrangement to an application system 90C (adapted if needed) . It should however be clear that this merely relates to one particular implementation of the inventive concept.
- the first data handling arrangement 90A comprises a number of function handling means here a receiver 91A, a log 92A, a transaction handler 93A, a lock handler 94A, a router 95A and a sender 96A.
- a message is received from an external system, in the receiver 91A, which for example can receive ASCII messages based on some kind of carrier protocol such as HTTP, RPC, Telnet.
- the receiver 91A includes translating means for translating the incoming message to an internal standard call object.
- the internal standard call object is sent to the log 92A in which it is logged together with a date and a time stamp.
- the receiver 91A on processing the object, provides a (empty) result object which is returned to the external system.
- the log 92A in turn provides or generates or provides a result object which is returned to the receiver 91A.
- the call object is sent to the transaction handler 93A in which a transaction ID is added to the call object. Also the transaction handler 93A generates/provides a result object which is returned to the log 92A.
- the call object is then sent to the lock handler 94A, the functioning of which has been described earlier in the application which also provides a result object etc.
- the call object is routed depending on for example the physical location e.g. for purposes of load sharing and call objects are generated and can be sent to three systems.
- the sender 96A includes translating means for translating an internal standard call object to an internal communication message, and the internal communication message, for example an ASCII data string sent using the RPC protocol, is sent to the second data handling arrangement 90B, which also comprises a number of function handling means, here receiver 91B, authority handling means 92B, converting means 93B, validating means 94B, executing means 95B.
- the receiver function handling means 91B the internal communication message is converted to an internal standard call object and a result object is provided which is sent back to the first data handling arrangement 90A.
- the standard call object is sent to the authority handling means 92B in which a check is done to see if the user is allowed to use the data that as requested in the call object.
- the result of the operation is returned to the receiver 91B.
- conversion handling means (converter) 93B a data conversion is performed. An example thereon is the replacement of one identificator by another. Again a result object is provided, which is returned to the authority handling means 92B.
- validating means 94B the data contained in the call object is checked, for example the length of data string of the call object is checked. Again a result object is returned.
- the execution handling means 95B performs the actual method call towards the underlying subsystem, i.e. the application system. An example thereon is a call of C++ class method that sets data in database. An adapted message is then provided to the application system 90C which may comprise a database interface library of a relational database.
- the system coordinates and modifies messages towards the data handling arrangements, in order to provide a simple one point of entry interface for simple messages that are transformed to a larger more complex set of messages.
Abstract
Description
Claims
Priority Applications (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
EP98928751A EP0986782A1 (en) | 1997-06-04 | 1998-06-03 | System and method relating to generic handling of data |
CA002292665A CA2292665A1 (en) | 1997-06-04 | 1998-06-03 | System and method relating to generic handling of data |
AU80469/98A AU740953B2 (en) | 1997-06-04 | 1998-06-03 | System and method relating to generic handling of data |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
SE9702113A SE9702113L (en) | 1997-06-04 | 1997-06-04 | Systems and procedures related to generic data management |
SE9702113-3 | 1997-06-04 |
Publications (1)
Publication Number | Publication Date |
---|---|
WO1998055921A1 true WO1998055921A1 (en) | 1998-12-10 |
Family
ID=20407230
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/SE1998/001060 WO1998055921A1 (en) | 1997-06-04 | 1998-06-03 | System and method relating to generic handling of data |
Country Status (6)
Country | Link |
---|---|
EP (1) | EP0986782A1 (en) |
CN (1) | CN1265203A (en) |
AU (1) | AU740953B2 (en) |
CA (1) | CA2292665A1 (en) |
SE (1) | SE9702113L (en) |
WO (1) | WO1998055921A1 (en) |
Families Citing this family (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6934948B2 (en) * | 2001-01-22 | 2005-08-23 | International Business Machines Corporation | System and method for grouping diverse operations |
Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0456249A2 (en) * | 1990-05-10 | 1991-11-13 | Hewlett-Packard Company | System for integrating application programs in a heterogeneous network enviroment |
WO1997008616A1 (en) * | 1995-08-29 | 1997-03-06 | Bell Communications Research, Inc. | System and method for parsing and building data signals |
-
1997
- 1997-06-04 SE SE9702113A patent/SE9702113L/en not_active Application Discontinuation
-
1998
- 1998-06-03 WO PCT/SE1998/001060 patent/WO1998055921A1/en active IP Right Grant
- 1998-06-03 EP EP98928751A patent/EP0986782A1/en not_active Ceased
- 1998-06-03 CA CA002292665A patent/CA2292665A1/en not_active Abandoned
- 1998-06-03 CN CN 98807639 patent/CN1265203A/en active Pending
- 1998-06-03 AU AU80469/98A patent/AU740953B2/en not_active Ceased
Patent Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0456249A2 (en) * | 1990-05-10 | 1991-11-13 | Hewlett-Packard Company | System for integrating application programs in a heterogeneous network enviroment |
WO1997008616A1 (en) * | 1995-08-29 | 1997-03-06 | Bell Communications Research, Inc. | System and method for parsing and building data signals |
Also Published As
Publication number | Publication date |
---|---|
SE9702113L (en) | 1998-12-05 |
SE9702113D0 (en) | 1997-06-04 |
AU8046998A (en) | 1998-12-21 |
CN1265203A (en) | 2000-08-30 |
EP0986782A1 (en) | 2000-03-22 |
AU740953B2 (en) | 2001-11-15 |
CA2292665A1 (en) | 1998-12-10 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US6182153B1 (en) | Object-oriented programming interface for developing and running network management applications on a network communication infrastructure | |
US8010973B2 (en) | Class loader for managing a network | |
US5218697A (en) | Method and system for networking computers having varying file architectures | |
US20020085696A1 (en) | Methods and apparatus for call service processing | |
JP2002522932A (en) | Method and system for intelligent distributed network architecture | |
MXPA01003975A (en) | Method and apparatus for providing real-time call processing services in an intelligent network. | |
US6499059B1 (en) | Method of controlling a network element using a service profile and apparatus of the same | |
CA2249780A1 (en) | Bean-based management system | |
CA2249487A1 (en) | Remote object access | |
CN104615489B (en) | A kind of implementation method of multinode data interaction | |
CN101795206B (en) | Method and device for realizing SNMP agent on distributed equipment | |
WO2002067502A1 (en) | Method and system for providing a network service using service scripts | |
US6788939B2 (en) | Service deployment architecture | |
Alliance | Service-based architecture in 5G | |
WO1997007621A1 (en) | Parallel execution of requests in osi agents | |
AU740953B2 (en) | System and method relating to generic handling of data | |
US6282202B1 (en) | Method for internal communication in a telecommunications system | |
US5966713A (en) | Method for determining the contents of a restoration log | |
US6370136B1 (en) | Dialing plan arrangement for expandable telecommunications system | |
KR100270915B1 (en) | Metwork management platform and method | |
Yoda et al. | Object oriented TMN based operations systems development platform | |
AU718930B2 (en) | Procedure for supporting the generation of an object in a computer system | |
Pavlou | The OSIMIS TMN Platform: Support for Multiple Technology Integrated Management Systems | |
KR100417850B1 (en) | Integration system of wireless network and the internet | |
Bredereke | Requirements specification and design of a simplified telephone network by functional documentation |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
WWE | Wipo information: entry into national phase |
Ref document number: 98807639.X Country of ref document: CN |
|
AK | Designated states |
Kind code of ref document: A1 Designated state(s): AL AM AT AU AZ BA BB BG BR BY CA CH CN CU CZ DE DK EE ES FI GB GE GH GM GW HU ID IL IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT UA UG US UZ VN YU ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A1 Designated state(s): GH GM KE LS MW SD SZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN ML MR NE SN TD TG |
|
DFPE | Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101) | ||
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
ENP | Entry into the national phase |
Ref document number: 2292665 Country of ref document: CA Ref document number: 2292665 Country of ref document: CA Kind code of ref document: A |
|
WWE | Wipo information: entry into national phase |
Ref document number: 1998928751 Country of ref document: EP |
|
WWE | Wipo information: entry into national phase |
Ref document number: 80469/98 Country of ref document: AU |
|
NENP | Non-entry into the national phase |
Ref document number: 1999502265 Country of ref document: JP |
|
WWP | Wipo information: published in national office |
Ref document number: 1998928751 Country of ref document: EP |
|
REG | Reference to national code |
Ref country code: DE Ref legal event code: 8642 |
|
WWG | Wipo information: grant in national office |
Ref document number: 80469/98 Country of ref document: AU |