Language and interface for unified network service creation, provision and deployment

Abstract

A services definition language for seamlessly creating and maintaining services over a network service reduces deployment time, cost, and maintenance, and increases reliability. An executable element generator is operable to process module scripts, such as an XML (Extensible Markup Language) script, recognized across the execution environment. Each module script describes a network element, service, or subscription. A plurality of available services are defined, in which each of the available services corresponds to one or more of the module scripts. A script processor interprets the module script and provides it to executable element generators conversant in the script language, which process the module scripts via a GUI to produce executable objects. A service provisioning engine is operable to execute the executable objects for providing the corresponding service via the network.

Description

NOTICE OF COPYRIGHT

[0002] A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.

BACKGROUND OF THE INVENTION

[0003] In a network system, services are provided to users via network interconnections from a service provider. Such services include data, voice, video, and others, and are typically implemented and/or initiated via an interconnection from a network node operated by the service provider to customer premises equipment (CPE) operable to receive the service. Customer premises equipment may include, for example, PCs, TVs, wired and wireless phones, mass storage devices, or other network elements operable to be interconnected over the network. Service provisioning in this manner includes identifying the service to be provided, identifying the CPE, or network node, to receive the service, and determining the manner in which the service is to be delivered to the end-user.

[0004] One method of providing services to an end user includes so-called hybrid fiber coax (HFC) networks. Physically extending the network into the home of each user would be cumbersome, however many homes are already interconnected by coaxial cables employed for carrying legacy cable television signals. Such HFC networks employ a high speed networking device, such as an optical networking unit (ONU), at a point which is capable of accessing 500-1000 end user homes via the existing coax cable plant. Tapping into the tree-and-branch topology of the legacy coax network allows high speed ONUs to be installed only once for every 500-1000 homes, rather than in every home. This approach allows the high-speed optical network to be employed for much of the physical distance, and employs the existing legacy coax for the so-called “last mile” run to individual users. By employing frequencies on the coax typically above the frequency already employed for cable TV, HFC networks utilize unused bandwidth to overcome the “last mile” problem and provide services to users efficiently and economically.

[0005] Service provisioning, therefore, typically involves identifying a number of network nodes and instructions, for example machine instructions for configuring a particular hardware element, concerned with providing a particular service, and directing the nodes by transmitting appropriate instructions to which the nodes are responsive. In order for the service to be properly provisioned, concerned nodes must be accurately identified and the proper instructions transmitted accordingly. Often, however, there are many different types of nodes on such a network, each responsive to a different set of instructions. Further, each service typically requires a specific corresponding set of instructions to be transmitted. Still further, new services and new nodes are frequently added or upgraded, requiring additional instructions or modification of existing instructions, in order to provision the service.

[0006] In a typical prior art service provisioning system, multiple sets of instructions are maintained for each of the various services, and for each of the hardware types which may be invoked in providing the service. Each provision of the service requires identifying a set of the concerned instructions, often called an adaptor, and performing an aggregation, such as a compilation or interpretation, of the set of instructions concerned with the particular instantiation, thereby resulting in a specific build of the service. Frequently, multiple builds are maintained to correspond to different customer sites and different services which are to be provided to that site. However, maintaining multiple builds and multiple adaptors raises maintenance and development issues. Such adaptors are often written in a low level language specific to a particular platform. In a non-monolithic system, i.e. a system having many platforms, a different adaptor may be required for each supported platform. The need for multiple adaptors can result in increased deployment time and increased cost as custom adaptors and builds are deployed to adapt to new or upgraded services and hardware to be provisioned.

[0007] Attempts have been made to provide a common denominator to nodes which run on different platforms, or operating systems, each of which has a particular set of instructions to which it is responsive. The Extensible Markup Language (XML) is a generic syntax promoted by the World Wide Web Consortium (W3C, Massachusetts Institute of Technology, Laboratory for Computer Science, Cambridge, Mass.) intended to be recognized, interpreted, and executed across many platforms. While XML may prove useful toward deploying the same instantiation of a service across nodes of different platforms, custom adaptors must still be deployed when variables other than operating system platforms are introduced. Such variables include new hardware devices such as switches, routers and bridges, new CPE units, new revisions to existing services, and addition of new services altogether. Each of these occurrences requires a custom adaptor to be developed and employed to provision the service.

SUMMARY OF THE INVENTION

[0008] In a network services delivery environment, service deployment time, cost and maintenance are reduced, and reliability increased, by a system for provisioning services over a network which includes an executable element generator operable to process module scripts recognized across an execution environment, and generate corresponding executable objects. A plurality of services are defined, in which each of the services corresponds to one or more of the module scripts. The services are provided via a network in communication with, and operable to provide the services to, each of a plurality of users. A service provisioning engine (SPE) is operable to execute the executable objects for providing the corresponding service via the network. The SPE reads the scripts and associated parameters from a common repository such as a knowledge base, and provides or initiates the service by transmitting information signals, via the network, to one or more customer premises equipment units, such as PCs, televisions, and telephones at the customers site.

[0009] The network as employed herein therefore defines an execution environment. Network elements such as hardware devices are deployed and interconnected by the network. The network elements are configured by configuration parameters for the particular network element. The configuration parameters coordinate the network element for a particular service, such as assigning ports and buffers within a device. Services such as voice, video, and data are defined and employ the network elements through manipulation of element parameters of the network elements concerned with providing the service, for example, bit rate or QOS (Quality of Service). Each of the services, further, is implemented by instantiations of service plans, each service plan enumerating service parameters for identifying variables and aspects associated with the particular instantiation of the service, such as price and duration.

[0010] Each of the executable element generators employed in the service provisioning system is operable to process executable scripts, such as an XML compliant file, for a particular network entity, such as network elements, services, and service plans. In a particular embodiment there are at least three types of executable element generators. A module builder is operable to define the configuration parameters corresponding to each of the network elements. A network pre-provisioning manager (NPP) is operable to define the element parameters corresponding to each of the services. A service creation manager (SCM) is operable to define service plans for deploying an instantiation of the service. Each of the executable element generators is preferably a graphical user interface (GUI) directed to seamlessly guiding an operator through computing an executable script which includes the desired parameters for the concerned network entity.

[0011] In another particular embodiment, another executable element generator is employed. A service provisioning manager (SPM) defines attributes corresponding to an instantiation, or subscription, of a service for a particular user. In this embodiment, the executable scripts are defined first as module scripts indicative of attributes concerning the element, service, or subscription. The executable element generators receive the module scripts via a script processor conversant in a service definition language, such as an XML compliant language, operable to allow the executable element generators to associate values with the attributes, or parameters, in the module script. The module scripts, once processed by the executable element generators, comprise executable scripts which are customized, or deployed by having values associated with attributes therein, and are stored in the knowledge base as executable objects. The executable objects need not necessarily conform to the service definition form of the module scripts, as they have been processed into form where it may be known and utilized by other applications in the network services operating system (NSOS).

[0012] The system further includes a knowledge base, which may be for example an LDAP (lightweight directory access protocol) directory, for storing the executable scripts and related parameters. The service provisioning engine accesses the knowledge base via an indicator, and provisions the service by reading the executable scripts and associated parameters, and deploying the service at the particular user's CPE via the network.

[0013] The network as defined herein includes an access network, a metro area network, and a wide area network. The service provisioning engine employs at least the access network in provisioning the service, the access network including a hybrid fiber-coax network which may also be employed for providing non-provisioned, or legacy, signals to a user.

[0014] In this manner, executable scripts, or module scripts, such as XML compliant files, are processed by the executable element generator, and recognized by the service provisioning engine. Further, since the scripts are XML compliant, they are capable of being recognized by each of the network elements with which the service provisioning engine communicates. The use of the executable element generators allows the executable scripts to be selectively regenerated on demand to correspond to changes in the network elements, services, or service plans, without redesigning or manually recoding adaptor routines to correspond to the new network elements, services, or service plans. In alternate embodiments, other forms of executable script files may be employed to accommodate various deployment and compatibility issues. The system therefore provides a rapidly customizable and configurable service provisioning implementation.

BRIEF DESCRIPTION OF THE DRAWINGS

[0015] The foregoing and other objects, features and advantages of the invention will be apparent from the following more particular description of preferred embodiments of the invention, as illustrated in the accompanying drawings in which like reference characters refer to the same parts throughout the different views. The drawings are not necessarily to scale, emphasis instead being placed upon illustrating the principles of the invention.

[0016] FIG. 1 is a context diagram of the present invention;

[0017] FIG. 2 shows the local broadband access networks of FIG. 1;

[0018] FIG. 3 shows a block diagram of a service provisioning system;

[0019] FIG. 4 shows the service provisioning system of FIG. 3 in greater detail;

[0020] FIGS. 5 a -5d show flowcharts of service provisioning as defined by the present invention;

[0021] FIG. 6 shows a data flow of module scripts employed in creating and provisioning services;

[0022] FIG. 7 shows a three tier model of the architecture of the network services operating system (NSOS);

[0023] FIG. 8 shows different layers within the NSOS responsive to the module scripts;

[0024] FIG. 9 shows multiple executable scripts invoked in provisioning service plans;

[0025] FIG. 10 shows a layer diagram of the execution environment employed by the present invention; and

[0026] FIG. 11 shows an example of processing of a code fragment of a module script of the present invention.

DETAILED DESCRIPTION OF THE INVENTION

[0027] A description of preferred embodiments of the invention follows.

[0028] A hybrid fiber-coax network is employed for provisioning services to users. Services are provided through a service provisioning system via a network as described below. FIG. 1 shows a context diagram of the present invention. Referring to FIG. 1, a plurality of services 10 are available for provisioning to users 14a-14c via a network 12. The users 14a-14c are shown as exemplary. A plurality 14a-14n of users can be supported. The network 12 may include a public access network such as the Internet and other networks described further below. The services include video 10a, such as pay-per-view, video on demand, and digital cable; IP telephony 10b, such as voice-over-IP (VIP) and digital telephones; Internet access via a web browser 10c, and Virtual Private Networks (VPN) 10d. Other services can be similarly provisioned.

[0029] FIG. 2 shows the network 12 in more detail. Referring to FIG. 2, the network 12 includes a plurality of local broadband access networks (LBANs) 16, interconnected across a metro area network 18. Each of the LBANs 16 includes at least a portion of a hybrid fiber-coax (HFC) network connected to individual users 14n generally. The metro area network is typically a public access network such as the Internet, and may be connected to other metro area networks via a wide area network (WAN, not shown). As indicated above, the use of an LBAN 16 allows services to be provisioned (provided) directly to the end users 14n using existing coax cables comprising the coax part of the HFC network. The metro area network 18 provides a high bandwidth connection from the network 12 to the LBAN 16 via an optical or other node serving each LBAN 16. In a typical embodiment, services are provisioned from a service delivery center (not shown), operated by the service provider, via the LBAN 16 in conjunction with the network 12.

[0030] In a particular embodiment, the LBAN is a Narad Broadband Access Network (NBAN) provided by Narad Networks Inc., of Westford, Mass., assignee of the present application, and as described in copending U.S. patent application Ser. No. 09/952,482, filed Sep. 13, 2001, entitled “Network Architecture for Intelligent Network Elements,” (Attorney Docket No. 3070.1000-003), incorporated herein by reference. As disclosed above, each LBAN serves approximately 500-1000 homes from a high speed optical unit such as an optical network distribution switch, employing the LBAN for the “last mile” connection from the high-speed trunk provided by the optical unit to the user via the legacy coax network.

[0031] FIG. 3 shows a block diagram of the service provisioning system. Referring to FIG. 3, an executable element generator 20 is connected to a service provisioning engine 22. The executable element generator 20 generates executable scripts which are interpreted by the service provisioning engine 22. The executable element generator 20 is typically driven by a graphical user interface (GUI) invoked by a human operator. A knowledge base 24 stores the executable scripts and associated parameters. The service provisioning engine 22 is in communication with the LBAN 16, either directly or via other portions of the network 12 (FIG. 1), and provides the service via the LBAN 16. A user 14′ receives the service via one or more units of customer premises equipment (CPE) 26 also connected to the LBAN. CPEs 26 include PCs, telephones, TVs, and other devices adapted to be connected to the LBAN 16. The executable element generator 20 generates executable scripts directing the service provisioning engine 22 how to provide a particular service. In a particular embodiment, the executable scripts are XML compliant scripts. As described above, XML is a generic, platform independent syntax which may be interpreted by multiple platforms. The executable scripts as defined herein are therefore applicable to a plurality of platforms which recognize the XML language. In alternate embodiments, other script or language formats may be employed. The service provisioning engine 22 reads the executable scripts and may read associated executable scripts and parameters from the knowledge base 24. The service is then provisioned, or provided to the user, via the LBAN 16, typically by sending messages to the CPE 26 and other network elements concerned with providing the service.

[0032] FIG. 4 shows the service provisioning system of FIG. 3 in more detail. Before describing FIG. 4, some background on service provisioning may prove beneficial. Services are provided in the form of network transmissions and interactions which are selectively enabled for users who have subscribed to the service. The services as employed in the present system are an enumerated collection of network-based operations and/or transmissions initiated by a service provider, typically on a revenue-generating fee-for-services basis. An example is video-on demand transmitted from the service provider to the user's CPE 26. A service is typically, but not necessarily, associated with one or more provisioning objects for providing the service. A provisioning object may be, for example, a router operable to provide QOS based throughput sufficient for video-on-demand. Each provisioning object associated with a service has configuration parameters which are used to configure the provisioning object for providing the service according to the requirements of the service provider. Configuration parameters are directed to a particular hardware provisioning object for provisioning a particular service, such as assigning ports and buffers within a device.

[0033] Similarly, each service also has element parameters which direct the provisioning object in providing the service. The element parameters direct the provisioning object how to provide at least a portion of the service. For example, service parameters for a video-on-demand service may direct a router to deliver at a QOS level of guaranteed variable bit rate real-time.

[0034] Additionally, each service has one or more service plans. A service plan is an instantiation of a service offered by a particular service provider. For example, a video-on-demand service provider may have one service plan providing ten movies a month and another service plan providing twenty movies a month.

[0035] Referring to FIG. 4, the executable element generators include a module builder 20 for initially generating the executable scripts. The executable element generators, or script processors which consume the executable scripts and generate provisioning parameters include a network pre-provisioning (NPP) manager 23, a service plan administrator (SPA) 25, and a service provisioning manager 28 (SPM). The module builder 20 is a graphical user interface which generates executable scripts indicative of provisioning parameters for a particular provisioning object, such as network elements, services, and service plans. This tool allows a vendor to describe a provisioning object as it relates to the system in the syntax employed by the executable scripts. The module builder 20 can be employed, for example, by a vendor manufacturing hardware to be interconnected over the LBAN, such as a router manufacturer for routing video-on-demand or a laptop manufacturer on which the video-on-demand is to be received. The executable script is then stored in the knowledge base 24 along with an indicator so that it may be employed by the script processors to provide the service 10, (FIG. 1).

[0036] The NPP 23 manager allows a service provider to process executable scripts including defining configuration parameters corresponding to a particular network element. The configuration parameters allow the service provider to configure the network element provisioning object for a service, and would be invoked by the service provider, such as a network operator, to whom the network element was supplied. The NPP 23 receives an executable script generated by the module builder 20 for each network element concerned with providing the service. The NPP 23 then allows a network engineer at the service provider to configure the network element by defining the element parameters.

[0037] The SPA 25 allows a service provider to process executable scripts including element parameters corresponding to a particular service 10 (FIG. 1). The element parameters allow the service provider to direct the provisioning object how to perform the service, and would be invoked by the service provider to which the provisioning object was supplied. The SPA 25 receives an executable script generated by the module builder 20 for each provisioning object concerned with providing the service. The SPA 25 then allows a network engineer at the service provider to describe their service as it relates to a provisioning object in the syntax of the executable script. In the example above, the SPA 25 would be employed by the video-on-demand service provider to generate a script to direct the router and the laptop accordingly, for example to transmit and receive at a particular number of bits per second or frames per second. Other exemplary element parameters include maximum frame error rate, retry timeout and rate, port number (application type), and TCP/IP error recovery variables such as the slow start window and fast retransmit.

[0038] A service provisioning manager (SPM) 28 allows generation of an executable script defining a particular instantiation of a service (10, FIG. 2), or service plan, to be defined. Service parameters are defined within each of the service plans via the GUI of the SPM 28. The SPM defines an instantiation of the service in terms of service parameters, including variables specific to a particular user, such as price, duration, billing options, and others. In the above example, a particular service plan might specify that the video-on-demand service provides a movie for a 24 hour period, or, for example, a service plan applicable to subscribers in Westford, Mass. which encompasses knowledge of the local cable provider's coax network. The SPM 25, therefore, allows an operator to process executable scripts for specifying service parameters corresponding to each service plan.

[0039] The three types of script processors NPP 23, SPA 25, and SPM 28 each receive, or consume the executable scripts from the module builder. Each script processor processes the scripts to define provisioning parameters for a provisioning object. Each script processor is operable to receive service provisioning input from a particular type of client, and defines a particular type of provisioning parameters such that the service provisioning engine 22 may receive the provisioning parameters and direct the corresponding provisioning object accordingly. Specifically, the NPP 23 defines configuration parameters applicable to network elements, and would typically be invoked by a network operator (NOP) responsible for maintaining the network elements in running order. The SPA 25 defines element parameters applicable to services, and would be invoked by a service provider to set up a service. The SPM 28 defines service parameters applicable to a service plan, and would be invoked by a telephone operator or web interface responsive to an end user request for a specific service to be provisioned, described further below.

[0040] Each of the provisioning parameters from the executable scripts is written to the knowledge base 24 for later retrieval by the service provisioning engine 22. An indicator corresponding to the service and the service provider is also written so that the executable scripts may be indexed and retrieved. In a particular embodiment, the knowledge base is an LDAP directory.

[0041] The service provisioning manager 28 initiates provisioning of a service in response to a request from a user 14. By employing the executable script or scripts corresponding to a service 10 (FIG. 1), a user may select from among available service plans and relevant service parameters associated with the plan. The service provisioning manager 28 employs both an operator interface 30 and a web-based interface 32. The operator interface 30 is staffed by a human operator who initiates the service in response to a telephone call, email, hardcopy mail, or other indirect request, and is ideal for a user unfamiliar with GUIs. Such an interface may be employed at a service delivery center comprising the service provider's servers and equipment. The web-based interface 32 may be accessed directly by a user who enters information specifying the service plan and service parameters desired, along with other pertinent personal and billing information.

[0042] The service provisioning manager 28 then directs the service provisioning engine 22 to provide the service to the CPE 26 of the user via the LBAN 16. The service provisioning engine 22 retrieves the applicable provisioning parameters resulting from the processing of the executable scripts, including the service parameters, the element parameters, and the configuration parameters from the knowledge base 24. In this manner, a general purpose service provisioning system is established which can provision a plurality of services for a plurality of users across multiple platforms supporting XML compliant files by employing the executable element generator to generate executable scripts concerned with provisioning the services.

[0043] FIGS. 5 a -5d show flowcharts of a particular embodiment of the service provisioning system. Referring to FIG. 5a, a flowchart of the operation of the module builder 20 is shown. A network element is defined which is to be employed in providing one or more services, as depicted at step 100. An executable script file corresponding to the network element is opened, as described at step 102. The device parameters or settings concerned with providing one or more services are identified, as shown at step 104. For each device parameter, the operator determines a configuration parameter setting or value for the device parameter, as depicted at step 106. An entry having the configuration parameter indicative of the determined parameter setting is written to the executable script, as disclosed at step 108. A check is performed to determine if there are more device parameters for this network element, as shown at step 110. If there are more device parameters, control reverts to step 106. If there are no more device parameters for this network element, an identifier for the executable script is computed, as disclosed at step 112. The executable script is then stored in the knowledge base 24 (FIG. 4) along with the identifier, as depicted at step 114.

[0044] FIG. 5 b shows a flowchart of network pre-provisioning (NPP). Referring to FIG. 5b, a service is selected for pre-provisioning, as disclosed at step 120. An executable script file corresponding to the service is opened, as described at step 122. The executable script generated by the module builder for any network elements concerned with provisioning the service are fetched from the knowledge base (FIG. 4), as shown at step 124. For each network element concerned with provisioning the service, element settings for the network element are determined, as depicted at step 126. For each element setting, the operator determines the element parameter for the element setting, as depicted at step 128. An entry having the element parameter corresponding to the element setting is written to the executable script, as disclosed at step 130. A check is performed to determine if there are any more element settings for the current network element, as shown at step 132. If there are, control reverts to step 128. If there are no more element settings for the current network element, a check is performed to see if there are any more network elements concerned with provisioning this service, as depicted at step 134. If there are, control reverts to step 126, otherwise an identifier for the service and the corresponding executable script are computed, as disclosed at step 136. The executable script and the corresponding identifier are then written to the knowledge base, as shown at step 138.

[0045] FIG. 5 c shows a flowchart of the service provisioning manager 28 (SPM). Referring to FIG. 5c, a service is selected for instantiation, as shown at step 140. An executable script file corresponding to this instantiation, or service plan, is opened, as depicted at step 142. Executable scripts created by the NPP module for this service are fetched from the knowledge base, as shown at step 144. For each NPP script associated with this service, service variables are identified, as shown at step 146. An operator determines the proper service parameter for this service variable depending on the service plan desired, as shown at step 148. An entry having the service parameter is written to the executable script, as depicted at step 150. Other service parameters not specific to the NPP executable script may be entered as well. A check is performed to determine if there are more service parameters corresponding to this NPP executable script, as disclosed at step 152. If there are, control reverts to step 148, otherwise a check is performed to determine if there are any more NPP executable scripts for this service plan, as shown at step 154. If there are more NPP executable scripts, then control reverts to step 146, otherwise, an identifier for this service plan is computed, as shown at step 156. The executable script and the identifier are then written to the knowledge base, as depicted at step 158.

[0046] FIG. 5 d shows a flowchart of the service provisioning flow comprising the flow shown in FIGS. 5a-5c. Referring to FIG. 5d and FIG. 4, a service provider identifies a service 10 (FIG. 1) for provisioning via the LBAN 16, as depicted at step 200. A hardware vendor is identified to develop or provide a network element for providing the service, as shown at step 202. An executable script corresponding to the network element is developed by the vendor employing the module builder 20, including the sequence shown in FIG. 5a, as disclosed at step 204. A check is performed to determine if there are additional network elements concerned with providing the service, as shown at step 206. If there are additional network elements, control reverts to step 202. Otherwise an NPP 23 script corresponding to the service is developed, including the sequence shown in FIG. 5b, as disclosed at step 208. The service provisioning manager 28 is then invoked to develop an executable script corresponding to service plans corresponding to the service, as described in FIG. 5c and depicted at step 210. Executable scripts for providing an instantiation of the service are now stored in the knowledge base from each of steps 204, 208 and 210, as shown at step 212. A user requests an instantiation of the service by accessing the service provisioning manager 28, as disclosed at step 214. As indicated above, the service provisioning manager 28 may be accessed directly via the web or indirectly via a human operator at the service operations center. The service provisioning manager 28 receives the user request, and invokes the service provisioning engine 22 to provision the service, as depicted at step 216. The service provisioning engine 22 then retrieves the executable scripts corresponding to the service from the knowledge base, as shown at step 218. The network elements concerned with provisioning the service are then identified and configured by the service provisioning engine 22 by executing the executable scripts generated by the module builder 20, as described at step 220. If required, executable scripts concerning the service generated by the NPP are executed, as shown at step 222, to initialize the network elements. The executable scripts comprising the service plan are then executed to provision the service, as described at step 224. The LBAN is accessed to determine the CPE of the target user of the provisioned service, as disclosed at step 226, and the service provisioned by accessing the CPE at the user site. In this manner, services are scalably and dynamically provisioned for each user over the LBAN by employing the executable scripts concerned with providing the service.

[0047] In another particular embodiment, shown in FIG. 6, a script engine 70 is employed between the module builder and the executable element generators. The script engine 70 is conversant in a service definition language common to the executable element generators and to the module builder, and generates module scripts 72 in the script definition language. The script definition language may be based on a known metalanguage such as XML to provide compatibility and facilitate external interfaces, described further below.

[0048] The module scripts employ the constructs of the script definition language. In a particular embodiment, the script definition language provides a hierarchical rule structure as described below with respect to the DTD in TABLE IV. The script definition language includes elements, behaviors, classes, flows, and tasks. A user interface (UI), which is typically a graphical user interface (GUI) is also employed to present and collect information from the user, such as an MSO (Multi-Service Operator).

[0049] A group of low-level programming elements is used to describe standard low-level programming concepts such as variable assignment, data structures, comparison, string concatenation, branching, looping, splits, joins, suspends, resumes, transaction demarcation, and error handling. The language includes support for arrays, keyed tables, and a wide variety of scalar types.

[0050] Using the behavior element, one can define the functionality of a network/service element and a service in the syntax of the language. Each behavior consists of zero or more properties and a set of actions. For example, an MSO can define the functionality of a VLAN switch to be employed by a service using this behavior construct. Further, the MSO can add actions to this behavior such as provisioning the VLAN as part of behavior definition.

[0051] Classes are used to model concrete network/service elements and the services entities like service plans, subscriptions, etc. Each class comprises of list of properties, actions and a list of behaviors that the class implements, and also specifies flow binding for each action. For example, using this class element, a switch vendor may model a particular switch to define its properties, actions and the behaviors. Once a behavior or behaviors are attached to a service element, the service element can be used as part of the MSO's service flows.

[0052] Though the language specification includes a broad set of core tasks to perform database operations, file manipulation, object manipulation and protocol signaling, it may also be employed to define a new set of tasks that can be used as part of the flows. Using the task construct, user can define an interface to access java task code. For example, using this task element, a network element vendor can develop a custom java task to provision a VLAN on their VLAN switch.

[0053] The XSML flow construct can be used for describing complex object oriented workflows with user interactions. The tasks, UI resources and low-level programming concepts are held together by a set of elements that define a sequence of states in a flow. Each state in a flow can: a) execute a task, behavioral action or another flow; b) present and collect information from the user; c) perform testing and branching based on evaluation of a conditional expression; and d) evaluate assignment variable expressions. These flows can be bound to the class actions or class behavioral actions so that when an action of a class or behavior is invoked, the corresponding bound flow is triggered and executed.

[0054] The module scripts 72 are invoked by the executable element generators 23, 25, and 28 to generate executable objects 78, which are adapted for operations similar to the executable scripts as described above. The executable element generators 23, 25, and 28 receive the module scripts 72 via a script engine 70. FIG. 6 shows a data flow of the script engine 70 and module scripts employed in creating and provisioning services. Referring to FIG. 6, the module builder 20 generates module scripts 72 corresponding to each of the network entities: elements, services, and subscriptions. Once generated by the module builder 20, the module scripts are stored in the knowledge base 24 for subsequent retrieval.

[0055] Each of the module scripts 72 is adapted to be processed by the script engine 70 according to a set of script rules 74, or document type definition (DTD), described further below. The scripts are processed by the script engine 70, and the processed script 76 is received by a respective one of the executable element generators 23, 25, or 28, depending on the network entity to which the script corresponds. Multiple module scripts may be received and processed by the executable element generators 23, 25, 28, and used to produce an executable object, shown by arrow 78, which is also stored in the knowledge base 24.

[0056] As indicated above, each of the three types of executable element generators 23, 25, and 28 receives a particular type of module script. The Network Pre-provisioning manager 23 (NPP) processes module scripts corresponding to network elements, generally hardware boxes such as switches and routers. The Service Plan Administrator 25 (SPA) processes module scripts corresponding to services to be offered, such as mobile phone and video-on-demand. The Service Provisioning Manager (SPM) 28 processes module scripts corresponding to subscriptions, which are instantiations of a service associated with a particular user, or subscriber, on a fee for services basis. The executable element generators 23, 25 and 28 gather values for predetermined attributes in the module script, typically via a graphical user interface (GUI). The executable element generators 23, 25 and 28 also identify and resolve interfaces specified in the module scripts between network entities.

[0057] Each of the executable element generators generates an executable object, which is directed to updating and maintaining the element, service, or subscription in the NSOS. Maintaining includes updating signaling stacks, topology information, adaptors, and other systems within the NSOS, shown further below with respect to FIG. 8. Accordingly, the executable element generators typically process multiple module scripts, as a service generally relies upon at least several network elements, each corresponding to a module script, and similarly, a subscription may reference multiple services. The executable objects are executed by the service provisioning engine 22, which interacts with the LBAN 16 to provision and deliver the service.

[0058] The module builder 20, therefore, generates module scripts 72 which may be stored and manipulated by the executable element generators in creation and management of a service. Since a module script is specific to a particular network entity, the network entities, such as elements, services, and subscriptions, concerned with providing a particular instance of a service to a user may be seamlessly and rapidly identified and provisioned appropriately to deliver the service to the user and bill the user accordingly. Further, in alternate embodiments, a module script 72 may be generated by an external entity rather than the module builder. This arrangement allows a third party vendor to supply a network entity and provide a manually built module script to allow integration with the NSOS framework described above.

[0059] FIG. 7 shows a three tier model of a particular embodiment the architecture of the network services operating system (NSOS) as it employs the system disclosed herein. The presentation layer 81 includes the executable element generators 23, 25, and 28, and communicates with the server layer via an enterprise javebeans (EJB) interface. The server layer represents the service provisioning engine 22 executing the NSOS kernel and the script engine 70. The service provisioning engine 22 is also in communication with a script logic repository 82, including service and element specific instructions referenced in the module scripts. An HTTP (HTML—Hypertext Markup Language) interface allows communication with web-based clients 80 via the module scripts or HTTP. An SNMP (Simple Network Management Protocol) interface facilitates network interconnections to network entities (devices) and external system 84. The knowledge base 24 provides a repository for the module scripts 72 , executable objects 78, and associated systems, described below.

[0060] FIG. 8 shows different layers and systems within the NSOS responsive to the module scripts 72 similar to FIG. 7. The knowledge base 24 contains the unified knowledge repository. The element layer 86 concerns network elements, such as switches and routers, particularly with regard to topology 88. The services layer 89 is concerned with the service provided by the elements, and includes the systems 90a-90f as shown.

[0061] FIG. 9 shows the multiple executable scripts invoked in provisioning a particular service plan. As indicated above, each of the executable element generators generates a particular type of executable script. In the examples given, the executable scripts are directed to network elements, services, and service plans. Multiple executable scripts may be invoked for provisioning a particular service, for example the same router, a network element, may be invoked to deliver services to multiple users. Accordingly, the same executable script may be invoked for a plurality of service instantiations. Referring to FIG. 9, a plurality of users 14a′-14d′ are each being provisioned. Each of users 14a′-14d′ is being provisioned for a service which invokes executable scripts as indicated by the dotted lines 52a-52d, respectively. User 14a′ is provisioned for a service which invokes executable script 50a for a service plan, executable script 50c for the service, and executable script 50g for a network element, as shown by the dotted line 52a. Similarly, user 14b′ is provisioned for service plan denoted by executable script 50b, but for the same service and hence employing executable scripts 50c and 50g as well. User 14c′ is provisioned using executable scripts 50c, 50f, and 50g, and user 14d′ is provisioned using executable scripts 50d, 50f, and 50g, as indicated by dotted lines 52c and 52d, respectively.

[0062] FIG. 10 shows a layer diagram of the execution environment employed by the present invention. Referring to FIG. 10, a top layer 51 includes the GUI presentations and input requests, including point-and-click inputs and free-form text entries. A human operator invoking the executable element generator 20 (FIG. 4) supplies inputs to the GUI depending on the service and the desired executable script. A second layer 53 contains the application logic. This layer drives the GUI to conditionally request input from the GUI which ensures that all required input needed to generate the desired executable script is entered. A third layer 54 includes the services and element infrastructure. This layer 54 includes data and processing concerned with specific network elements, services, and service plans to enable access to particular entities, such as to the knowledge base 24 (FIG. 4) using the identifier. A core tasks layer 56 allows knowledge base and object manipulation, such as storing and fetching from the knowledge base 24 based on the identifier. A runtime elements layer 58 coordinates runtime tasks and objects, such as initiating and terminating runtime objects, coordinating message passing and semaphores between objects, and generally providing the runtime environment for generating the executable scripts. A base layer 60 includes the underlying XML grammar, syntax and logic rules to which the executable entity is conformant. Since XML is recognized by a plurality of platforms, it is a common denominator by which the executable entities are related, such that the service provisioning as described herein is implemented in a platform independent manner.

[0063] FIG. 11 shows an example of a module script to be executed by the service provisioning engine 22 (FIG. 4). Referring to FIG. 8, a module script processed by the SPM and corresponding to a service plan for the video-on-demand example above is shown. The module script identifies the service as “rentmovie,” corresponding to the video-on-demand service described above at line 301. A service provisioning operation is specified at line 302. Line 303 identifies the particular SUBScriber Network Identifier (SUBSNID) identifies the user and associated CPE. Line 304 specifies the bit rate for this transmission to be sufficient for real time video. Line 305 indicates that the QOS is QOS level 3, which corresponds to, for example, VBR-RT (variable bit rate real-time) for supporting video. Line 306 specifies the duration that the bit rate is to be supported. The syntax paragraph is terminated at line 307, and a billing paragraph begins, as shown by line 308. This transaction is identified as a one-time transaction, such as a pay-per-view instance. The subscriber is again identified at line 309, and the title and price of the movie identified at lines 310 and 311, respectively. The paragraph is terminated at line 312, and the executable script terminated at line 313. Note that this example is intended as illustrative, and that many module scripts, each processed by different executable element generators, are likely to be invoked in the provisioning of a particular service.

[0064] The module scripts are each directed at a corresponding executable element generator 23, 25, and 28 as described above. Tables I-III show code fragments corresponding to each of the types of module scripts NPP 23, SPA 25, and SPM 38, respectively, processed by the corresponding executable element generators. Further, the script rules of the script definition language, also called a DTD, are shown in Table IV.

TABLE I
FOLLOWS
<?xml version=“1.0”?>
<module name=“xsml.narad.nban” version=“1.0”>
<description>
This module defines narad NBAN class.
</description>
<database>
<tables>
<table name=“nban” >
<columns>
<column name=“nban_id” type=“integer” />
<column name=“intf_ip_addr” type=“string” size=“15” />
<column name=“intf_net_mask” type=“string” size=“15” />
</columns>
<indices>
<index name=“nban_idx1” >
<index-column name=“nban_id” />
</index>
<index name=“nban_idx2” >
<index-column name=“intf_ip_addr” />
<index-column name=“intf_net_mask” />
</index>
</indices>
</table>
</tables>
</database>
<classes>
<class name=“NBAN”>
<class-behaviors>
<class-behavior property-name=“ent” >
<behavior-ref behavior-name=“entity”
module-name=“xsml.core” />
</class-behavior>
<class-behavior property-name=“se”>
<behavior-ref behavior-name=“service_element”
module-name=“xsml.core.element” />
<class-behavior-actions>
<class-behavior-action name=“add” scope=“class” >
<ui display-name=“Add NBAN” />
<flow-ref flow-name=“AddNBAN” />
</class-behavior-action>
<class-behavior-action name=“modify” scope=“instance” >
<ui display-name=“Modify NBAN” />
<flow-ref flow-name=“ModifyNBAN” />
</class-behavior-action>
<class-behavior-action name=“delete” scope=“instance” >
<ui display-name=“Delete NBAN” />
<flow-ref flow-name=“DeleteObject”
module-name=“xsml.core.db” />
</class-behavior-action>
</class-behavior-actions>
</class-behavior>
</class-behaviors>
<description>
This class represents a Narad Broadband Access Network (NBAN).
</description>
<parent>
<class-ref class-name=“Network” />
</parent>
<properties>
<property name=“nban_id” type=“integer” access=“read-write”/>
<property name=“intf_ip_addr” type=“string” access=“read-write”/>
<property name=“intf_net_mask” type=“string” access=“read-write”/>
</properties>
<persistence>
<database-map table-name=“nban” >
<column-map column-name=“nban_id”
property-name=“nban_id” />
<column-map column-name=“intf_ip_addr”
property-name=“intf_ip_addr” />
<column-map column-name=“intf_net_mask”
property-name=“intf_net_mask” />
</database-map>
</persistence>
</class>
</classes>
<flows>
<flow name=“AddNBAN” start-state=“get-inputs” >
<description>
This flow creates a NBAN object in the database by adding
the records to all the required tables.
</description>
<inputs>
<param name=“parent_oid” type=“long” />
</inputs>
<outputs>
<param name=“object” type=“var-bucket” />
</outputs>
<states>
<ui-state name=“get-inputs” next-state=“create-nban-id”
title=“Add NBAN” header=“NBAN Details” >
<ui-ref ui-name=“NameIPAddrNetMaskScreen” />
<output-map>
<set-var name=“nban.ent.name” >
<output-ref name=“name.value” />
</set-var>
<set-var name=“nban.intf_ip_addr” >
<output-ref name=“ipAddr.value” />
</set-var>
<set-var name=“nban.intf_net_mask” >
<output-ref name=“mask.value” />
</set-var>
</output-map>
</ui-state>
<!-- Add a task here to create the nban id. Till then
hard code it. -->
<expr-state name=“create-nban-id” next-state=“store-nban” >
<statements>
<assign name=“nban.nban_id”>
<integer>9</integer>
</assign>
</statements>
</expr-state>
<task-state name=“store-nban” next-state=“endstate” >
<task-ref task-name=“AddObject” module-name=“xsml.core.db” />
<input-map>
<set-param name=“object_instance” >
<var-ref name=“nban” />
</set-param>
<set-param name=“class_name” >
<string>NBAN</string>
</set-param>
<set-param name=“module_name” >
<string>xsml.narad.core</string>
</set-param>
<set-param name=“parent_oid” >
<var-ref name=“parent_oid” />
</set-param>
</input-map>
<output-map>
<set-var name=“nban” >
<output-ref name=“object_instance” />
</set-var>
</output-map>
</task-state>
<end-state name=“endstate” >
<flow-output-map>
<set-param name=“object” >
<var-ref name=“nban” />
</set-param>
</flow-output-map>
</end-state>
</states>
</flow>
</flows>
<ui-screens>
<ui-screen name=“NameIPAddrNetMaskScreen”
title=“Specify Name, IP Address and Mask”
header=“Specify Name, IP Address and Mask” >
<description>Enter Name, IP Address and Network Mask</description>
<inputs>
<param name=“maskLb.value” type=“string”/>
<param name=“mask.value” type=“string”/>
<param name=“ipAddr.value” type=“string”/>
<param name=“nameLb.value” type=“string”/>
<param name=“ipAddrLb.value” type=“string”/>
<param name=“name.value” type=“string”/>
</inputs>
<outputs>
<param name=“mask.value” type=“string”/>
<param name=“ipAddr.value” type=“string”/>
<param name=“name.value” type=“string”/>
</outputs>
<definition>
<bsh-screen>
<![CDATA[
//---------------------------------------------
// This is generated automatically -- Please do not edit
// This file is generated using XSML UI Builder
//
// @author: SLoke
// @version: $Id: NaradCore.xsml,v 1.9 2002/07/18 20:12:35 yellanks Exp $
//---------------------------------------------
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.table.*;
import javax.swing.tree.*;
import com.naradnet.util.gui.*;
import com.naradnet.util.events.OutputListener;
import com.naradnet.util.events.OutputEvent;
import com.naradnet.xsml.common.*;
import java.util.*;
//Parameters: Title (String), Header (String)
BshNDialog NameIPAddrNetMaskScreen(String title, String header)
{
//INITIALIZE SCREEN COMPONENTS HERE
initScreen( )
{
javax.swing.JPanel holder=new javax.swing.Jpanel( );
holder.setLayout(newGridLayout(0,1,5,5));
javax.swing.JPanel JPanel_1 = new javax.swing.JPanel( );
JPanel_1.setLocation(new Point(21,77));
Jpanel_1.setSize(new Dimension(310,150));
JPanel_1.setPreferredSize(newDimension(310,150));
JPanel_1.setName(“JPanel_1”);
holder.add(JPanel_1);
JPanel_1.setLayout(new NBorderLayout(5,5));
javax.swing.JPanel Jpanel_4 = new javax.swing.Jpanel( );
JPanel_4.setLocation(new Point(10,10));
JPanel_4.setSize(new Dimension(290,100));
Jpanel_4.setPreferredSize(new Dimension(100,25));
Jpanel_4.setName(“JPanel_4”);
JPanel_1.add(“Center”,JPanel_4);
JPanel_4.setLayout(new GridBagLayout( ));
name.setLocation(new Point(97,−6));
name.setSize(new Dimension(181,36));
name.setPreferredSize(newDimension(100,21));
name.setName(“name”);
((GridBagLayout)Jpanel_4.getLayout( )).setConstraints(name,new
GridBagConstraints(1,0,1,1,1.0,0.0,10,2,new Insets(2,0,2,2),0,0));
Jpanel_4.add(name);
name.setFont(newFont(“serif”,0,12));
ipAddr.setLocation(new Point(97,39));
ipAddr.setSize(new Dimension(125,21));
ipAddr.setPreferredSize(newDimension(125,21));
ipAddr.setName(“ipAddr”);
((GridBagLayout)JPanel_4.getLayout( )).setConstraints(ipAddr,new
GridBagConstraints(1,1,1,1,1.0,0.0,17,0,new Insets(0,0,2,0),0,0));
JPanel_4.add(ipAddr);
mask.setLocation(newPoint(97,77));
mask.setSize(newDimension(125,21));
mask.setPreferredSize(new Dimension(125,21));
mask.setName(“mask”);
((GridBagLayout)Jpanel_4.getLayout( )).setConstraints(mask,new
GridBagConstraints(1,2,1,1,1.0,0.0,17,0,new Insets(0,0,2,0),0,0));
JPanel_4.add(mask);
javax.swing.JLabel nameLb = new javax.swing.Jlabel( );
nameLb.setLocation(newPoint(10,−6));
nameLb.setSize(new Dimension(87,36));
nameLb.setPreferredSize(newDimension(100,25));
nameLb.setName(“nameLb”);
nameLb.setText(“Name:”);
((GridBagLayout)JPanel_4.getLayout( )).setConstraints(nameLb,new
GridBagConstraints(0,0,1,1,0.0,0.0,17,2,new Insets(2,0,2,0),0,0));
JPanel_4.add(nameLb);
javax.swing.JLabel ipAddrLb = new javax.swing.Jlabel( );
ipAddrLb.setLocation(new Point(10,32));
ipAddrLb.setSize(new Dimension(87,36));
ipAddrLb.setPreferredSize(new Dimension(100,25));
ipAddrLb.setName(“ipAddrLb”);
ipAddrLb.setText(“IP Address:”);
((GridBagLayout)JPanel_4.getLayout( )).setConstraints(ipAddrLb,new
GridBagConstraints(0,1,1,1,0.0,0.0,17,2,new Insets(0,0,2,0),0,0));
JPanel_4.add(ipAddrLb);
javax.swing.JLabel maskLb = new javax.swing.Jlabel( );
maskLb.setLocation(newPoint(10,70));
maskLb.setSize(new Dimension(87,36));
maskLb.setPreferredSize(new Dimension(100,25));
maskLb.setName(“maskLb”);
maskLb.setText(“Mask:”);
((GridBagLayout)JPanel_4.getLayout( )).setConstraints(maskLb,new
GridBagConstraints(0,2,1,1,0.0,0.0,17,2,new Insets(0,0,2,0),0,0));
JPanel_4.add(maskLb);
javax.swing.JPanel JPanel_6 = new javax.swing.Jpanel( );
JPanel_6.setLocation(new Point(10,115));
JPanel_6.setSize(new Dimension(290,25));
JPanel_6.setPreferredSize(newDimension(100,25));
JPanel_6.setName(“JPanel_6”);
JPanel_1.add(“South”,JPanel_6);
JPanel_6.setLayout(new FlowLayout(1,5,1));
okBtn.setLocation(new Point(42,11));
okBtn.setSize(new Dimension(100,25));
okBtn.setPreferredSize(new Dimension(100,25));
okBtn.setName(“okBtn”);
okBtn.setText(“OK”);
Jpanel_6.add(okBtn);
okBtn.setLabel(“OK”);
okBtn.setActionCommand(“OK”);
cancelBtn.setLocation(new Point(147,11));
cancelBtn.setSize(new Dimension(100,25));
cancelBtn.setPreferredSize(new Dimension(100,25));
cancelBtn.setName(“cancelBtn”);
cancelBtn.setText(“Cancel”);
JPanel_6.add(cancelBtn);
cancelBtn.setLabel(“Cancel”);
cancelBtn.setActionCommand(“Cancel”);
nd.setContentPane(holder);
Dimension gsize = holder.getPreferredSize( );
nd.setSize(gsize.width,gsize.height+30);
//REGISTER BUTTON LISTENERS
okBtn.addActionListener( this );
cancelBtn.addActionListener( this );
}
//BUTTON ACTIONS HERE
actionPerformed(event)
{
String cmd=event.getActionCommand( );
VarBucket outData=new VarBucket( );
//CREATE EVENT LAZILY AND SHIP IT!
boolean
cancel=(cmd.equalsIgnoreCase(“Cancel”)||cmd.equalsIgnoreCase(“Abort”));
OutputEvent oe=new OutputEvent(cmd, outData, cancel);
nd.fireOutputChanged(oe);
}
//VARIABLE DECLARATIONS HERE
com.naradnet.util.gui.NIPAddress mask = new
com.naradnet.util.gui.NTPAddress( );
javax.swing.JTextField name = new javax.swing.JtextField( );
com.naradnet.util.gui.DynamicNaradButton okBtn = new
com.naradnet.util.gui.DynamicNaradButton( );
com.naradnet.util.gui.NIP Address ipAddr = new
com.naradnet.util.gui.NIPAddress( );
com.naradnet.util.gui.DynamicNaradButton cancelBtn = new
com.naradnet.util.gui.DynamicNaradButton( );
//INSTANTIATION HAPPENS HERE
BshNDialog nd=new BshNDialog(title,header);
InitScreen( );
return nd;
}
]]>
</bsh-screen>
</definition>
</ui-screen>
</ui-screens>
</module>
END TABLE I

[0065]

TABLE II
FOLLOWS
<?xml version=“1.0”?>
<module name=“xsml.narad.svc.vlan” version=“1.0”>
<description>
This module defines the VLAN service behaviors and classes.
</description>
<!--
<database>
<tables>
<table name=“subscription_vlan” >
<columns>
<column name=“vlan_id” type=“integer” />
</columns>
</table>
</tables>
</database>
-->
<classes>
<class name=“VLAN Attributes”
<description>
This class holds VLAN Tag information.
</description>
<properties>
<property name=“vlan_id” type=“long” access=“create-only” />
<property name=“network_id” type=“long” access=“create-only” />
<property name=“owner_id” type=“long” access=“create-only” />
<property name=“owner_type” type=“integer” access=“create-only” />
<property name=“service_type” type=“integer” access=“create-only” />
<property name=“vlan_tag” type=“integer” access=“read-write” />
</properties>
<persistence>
<database-map table-name=“vlan_pool” >
<column-map property-name=“vlan_id” column-name=“vlan_id” />
<column-map property-name=“network_id”
column-name=“network_id” />
<column-map property-name=“owner_id” column-name=“owner_id” />
<column-map property-name=“owner_type”
column-name=“owner_type” />
<column-map property-name=“service_type”
column-name=“svc_type” />
<column-map property-name=“vlan_tag”
column-name=“vlan_tag” />
</database-map>
</persistence>
</class>
<class name=“VLAN Subscription”>
<description>
This class holds mapping between subscription and vlan
</description>
<properties>
<property name=“vlan_id” type=“long” access=“create-only” />
<property name=“subscription_id” type=“long” access=“create-only” />
</properties>
<persistence>
<database-map table-name=“vlan_subscription” >
<column-map property-name=“vlan_id” column-name=“vlan_id” />
<column-map property-name=“subscription_id”
column-name=“subscription_id” />
</database-map>
</persistence>
</class>
<class name=“oia vlan service” display-name=“OIA VLAN Service”>
<description>
This class represents an Open Internet Access service based on
VLAN.
</description>
<class-behaviors>
<class-behavior property-name=“ent” >
<behavior-ref behavior-name=“entity”
module-name=“xsml.core” />
</class-behavior>
<class-behavior property-name=“svc” >
<behavior-ref behavior-name=“service”
module-name=“xsml.core.service” />
<class-behavior-actions>
<class-behavior-action name=“create plan” >
<ui display-name=“Create New Plan” />
<flow-ref flow-name=“CreateServicePlan” />
</class-behavior-action>
<class-behavior-action name=“deploy plan” >
<ui display-name=“Deploy Plan” />
<flow-ref flow-name=“DeployServicePlan”
module-name=“xsml.core.service” />
</class-behavior-action>
<class-behavior-action name=“activate plan” >
<ui display-name=“Activate Plan” />
<flow-ref flow-name“activate plan”
module-name=“xsml.core.service” />
</class-behavior-action>
<class-behavior-action name=“verify plan” >
<ui display-name=“Verify Plan” />
<flow-ref flow-name=“verify plan”
module-name=“xsml.core.service” />
</class-behavior-action>
<class-behavior-action name=“create subscription” >
<flow-ref flow-name=“create vlan subscription” />
</class-behavior-action>
</class-behavior-actions>
</class-behavior>
<class-behavior property-name=“oiasvc” >
<behavior-ref behavior-name=“OIA Service”
module-name=“xsml.service.oia” />
</class-behavior>
</class-behaviors>
</class>
<!--
<class name=“oia vlan subscription”>
<description>
This class represents an Open Internet Access subscription
based on VLAN.
</description>
<class-behaviors>
<class-behavior property-name=“ent” >
<behavior-ref behavior-name=“entity”
module-name=“xsml.core” />
</class-behavior>
<class-behavior property-name=“subsn” >
<behavior-ref behavior-name=“subscription”
module-name=“xsml.core.service” />
<class-behavior-actions>
<class-behavior-action name=“modify subscription” >
<ui display-name=“Modify” />
<flow-ref flow-name=“modify subscription” />
</class-behavior-action>
<class-behavior-action name=“delete subscription” >
<ui display-name=“Delete” />
<flow-ref flow-name“ delete subscription” />
</class-behavior-action>
</class-behavior-actions>
</class-behavior>
</class-behaviors>
<properties>
<property name=“vlan_id” type=“integer” access=“read-write”/>
</properties>
<persistence>
<database-map table-name=“subscription_vlan” >
<column-map column-name=“vlan_id”
property-name=“vlan_id” />
</database-map>
</persistence>
</class>
-->
</classes>
<flows>
<flow name=“CreateServicePlan” start-state=“get-common-inputs” >
<description>
This flow creates a new OIA VLAN Service plan.
</description>
<outputs>
<param name=“service_plan” type=“var-bucket” >
<class-ref class-name=“oia vlan service”
module-name=“xsml.narad.svc.vlan” />
</param>
</outputs>
<states>
<subflow-state name=“get-common-inputs”
next-state=“get-oia-svc-inputs” >
<flow-ref flow-name=“GetCommonSvcInputs”
module-name=“xsml.core.service” />
<output-map>
<set-var name=“plan.ent.name” >
<output-ref name=“name” />
</set-var>
<set-var name=“plan.svc.description” >
<output-ref name=“description” />
</set-var>
<set-var name=“plan.svc.start_date” >
<output-ref name=“start_date” />
</set-var>
<set-var name=“plan.svc.end_date” >
<output-ref name=“end_date” />
</set-var>
<set-var name=“plan.svc.price_plan_id” >
<output-ref name=“price_plan_id” />
</set-var>
</output-map>
</subflow-state>
<subflow-state name=“get-oia-svc-inputs”
next-state=“set-status” >
<flow-ref flow-name=“GetOIAServiceDetails”
module-name=“xsml.service.oia” />
<output-map>
<set-var name=“plan.oiasvc.qos” >
<output-ref name=“qos” />
</set-var>
<set-var name=“plan.oiasvc.bandwidth” >
<output-ref name=“bandwidth” />
</set-var>
<set-var name=“plan.oiasvc.provider_id” >
<output-ref name=“provider_id” />
</set-var>
</output-map>
</subflow-state>
<expr-state name=“set-status” next-state=“store-plan” >
<statements>
<assign name=“plan.svc.status” >
<global-ref name=“ActiveState”
module-name=“xsml.core.service” />
</assign>
</statements>
</expr-state>
<task-state name=“store-plan” next-state=“endstate” >
<task-ref task-name=“AddObject” module-name=“xsml.core.db” />
<input-map>
<set-param name=“object_instance” >
<var-ref name=“plan” />
</set-param>
<set-param name=“class_name” >
<string>oia vlan service</string>
</set-param>
<set-param name=“module_name” >
<string>xsml.narad.svc.vlan</string>
</set-param>
</input-map>
<output-map>
<set-var name=“service_plan” >
<output-ref name=“object_instance” />
</set-var>
</output-map>
</task-state>
<end-state name=“endstate” >
<flow-output-map>
<set-param name=“service_plan” >
<var-ref name=“service_plan” />
</set-param>
</flow-output-map>
</end-state>
</states>
</flow>
<flow name=“create vlan subscription” start-state=“fetch-plans” >
<description>
This is a generic flow for creating a subscription.
</description>
<inputs>
<param name=“subscriber_id” type=“long” />
</inputs>
<outputs>
<param name=“subscription” type=“var-bucket” />
</outputs>
<states>
<task-state name=“fetch-plans” next-state=“select-plan”>
<task-ref module-name=“xsml.core.db”
task-name=“ListAllObjectsWithBehaviorProperties” />
<input-map>
<set-param name=“module_name”>
<string>xsml.narad.svc.vlan</string>
</set-param>
<set-param name=“class name”>
<string>oia vlan service</string>
</set-param>
</input-map>
<output-map>
<set-var name=“service_plans_list”>
<output-ref name=“object_list”/>
</set-var>
</output-map>
</task-state>
<ui-state name=“select-plan”
next-state=“fetch-subscriber-sites” >
<ui-ref ui-name=“selplan” module-name=“xsml.core.service”/>
<input-map>
<set-param name=“planTable.items”>
<var-ref name=“service_plans_list” />
</set-param>
<set-param name=“planTable.columns”>
<list>
<string>Plan Name</string>
<string>QOS</string>
<string>Bandwidth</string>
<string>Service Provider Id</string>
<string>Price Plan Id</string>
</list>
</set-param>
<set-param name=“planTable.props”>
<list>
<string>ent.name</string>
<string>oiasvc.qos</string>
<string>oiasvc.bandwidth</string>
<string>oiasvc.provider_id</string>
<string>svc.price_plan_id</string>
</list>
</set-param>
</input-map>
<output-map>
<set-var name=“selected_plan”>
<output-ref name=“planTable.value” />
</set-var>
</output-map>
</ui-state>
<task-state name=“fetch-subscriber-sites”
next-state=“select-sites”>
<task-ref task-name=“ListSubscriberSitesCoveredByPlan”
module-name=“xsml.narad.svc.core” />
<input-map>
<set-param name=“subscriber_id”>
<var-ref name=“subscriber_id”/>
</set-param>
<set-param name=“service_plan_id”>
<var-ref name=“selected_plan.oid”/>
</set-param>
</input-map>
<output-map>
<set-var name=“site_list”>
<output-ref name=“site_list”/>
</set-var>
</output-map>
</task-state>
<ui-state name=“select-sites”
next-state=“get-selected-site-objects” >
<ui-ref ui-name=“SiteSel” module-name=“xsml.narad.svc.core”/>
<input-map>
<set-param name=“fromList.items”>
<var-ref name=“site_list” >
<extract>
<extract-property name=“site_name”/>
</extract>
</var-ref>
</set-param>
</input-map>
<output-map>
<set-var name=“subscription.name”>
<output-ref name=“subscrNameTf.value” />
</set-var>
<set-var name=“subscription.comments”>
<output-ref name=“commentsTf.value” />
</set-var>
<set-var name=“selected_sites_names”>
<output-ref name=“toList.value”/>
</set-var>
</output-map>
</ui-state>
<task-state name=“get-selected-site-objects”
next-state=“create-and-set-subscription-sites”>
<task-ref task-name=“FilterObjectList”
module-name=“xsml.core.listutil” />
<input-map>
<set-param name=“object_list”>
<var-ref name=“site_list”/>
</set-param>
<set-param name=“input_property_name”>
<string>site_name</string>
</set-param>
<set-param name=“input_property_value_list”>
<var-ref name=“selected_sites_names”/>
</set-param>
</input-map>
<output-map>
<set-var name=“selected_sites”>
<output-ref name=“filtered_object_list”/>
</set-var>
</output-map>
</task-state>
<subflow-state name=“create-and-set-subscription-sites”
next-state=“fetch-vlan-attrs”>
<flow-ref flow-name=“CreateSubscriptionSites”
module-name=“xsml.narad.svc.core”/>
<input-map>
<set-param name=“site_list”>
<var-ref name=“selected_sites”/>
</set-param>
</input-map>
<output-map>
<set-var name=“subscription.subscription_sites”>
<output-ref name=“subscription_sites”/>
</set-var>
</output-map>
</subflow-state>
<task-state name=“fetch-vlan-attrs”
next-state=“set-subscription-properties”>
<task-ref task-name=“ListObjectsByCondition”
module-name=“xsml.core.db” />
<input-map>
<set-param name=“class_name”>
<string>VLAN Attributes</string>
</set-param>
<set-param name=“module_name”>
<string>xsml.narad.svc.vlan</string>
</set-param>
<set-param name=“condition”>
<string>network_id=$network_id AND
owner_id=$service_provider_id</string>
</set-param>
<set-param name=“condition_inputs”>
<var-bucket>
<var-property name=“network_id”>
<var-ref name=“selected_sites”>
<extract>
<extract-property name=“network_id”/>
<list-index>
<integer>0</integer>
</list-index>
</extract>
</var-ref>
</var-property>
<var-property name=“service_provider_id”>
<var-ref name=“selected_plan.oiasvc.provider_id”/>
</var-property>
</var-bucket>
</set-param>
</input-map>
<output-map>
<set-var name=“subscription.service_dep_attr”>
<output-ref name=“object_list”>
<extract>
<list-index><integer>0</integer></list-index>
</extract>
</output-ref>
</set-var>
</output-map>
</task-state>
<expr-state name=“set-subscription-properties”
next-state=“resolve-sam-servers”>
<statements>
<assign name=“subscription.subscriber_id”>
<var-ref name=“subscriber_id”/>
</assign>
<assign name=“subscription.service_plan_id”>
<var-ref name=“selected_plan.oid”/>
</assign>
<assign name=“subscription.service_type”>
<integer>3</integer>
</assign>
<assign name=“subscription.service_method”>
<integer>2</integer>
</assign>
<assign name=“subscription.status”>
<integer>0</integer>
</assign>
<assign name=“subscription.start_date”>
<long>0</long>
</assign>
<assign name=“subscription.is_meshed”>
<boolean>false</boolean>
</assign>
</statements>
</expr-state>
<task-state name=“resolve-sam-servers”
next-state=“reserve-vlan-resources”>
<task-ref task-name=“ResolveSAMServers”
module-name=“xsml.narad.svc.core” />
<input-map>
<set-param name=“subscription”>
<var-ref name=“subscription”/>
</set-param>
</input-map>
</task-state>
<task-state name=“reserve-vlan-resources”
next-state=“commit-resources”>
<task-ref task-name=“ReserveVLANResources”
module-name=“xsml.narad.svc.core” />
<input-map>
<set-param name=“subscription”>
<var-ref name=“subscription”/>
</set-param>
</input-map>
</task-state>
<task-state name=“commit-resources”
next-state=“store-subscription”>
<task-ref task-name=“CommitResources”
module-name=“xsml.narad.svc.core”/>
<input-map>
<set-param name=“subscription”>
<var-ref name=“subscription”/>
</set-param>
</input-map>
</task-state>
<task-state name=“store-subscription”
next-state=“end-subscription”>
<task-ref task-name=“StoreSubscription”
module-name=“xsml.narad.svc.core” />
<input-map>
<set-param name=“subscription”>
<var-ref name=“subscription”/>
</set-param>
</input-map>
</task-state>
<end-state name=“end-subscription”>
<flow-output-map>
<set-param name=“subscription” >
<var-ref name=“subscription” />
</set-param>
</flow-output-map>
</end-state>
</states>
</flow>
</flows>
</module>
END TABLE II

[0066]

TABLE III
FOLLOWS
<?xml version=“1.0”?>
<module name=“xsml.narad.svc.core” version=“1.0”>
<description>
This module describes the core service classes and behaviors that are
specific to Narad networks' services. It also defines Tasks and flows
specific to Narad Services.
</description>
<classes>
<class name=“Site”>
<description>
This class represents Site in that are used by the Narad Services
</description>
<properties>
<property name=“site_id” type=“long” access=“create-only” />
<property name=“subscriber_id” type=“long” access=“create-only” />
<property name=“site_name” type=“string” access=“read-write” />
<property name=“mac_address” type=“string” access=“read-write” />
<property name=“port_number” type=“string” access=“read-write” />
<property name=“public_ip_address” type=“string”
access=“read-write” />
<property name=“public_ip_mask” type=“string”
access=“read-write” />
<property name=“street” type=“string” access=“read-write” />
<property name=“city” type=“string” access=“read-write” />
<property name=“zipcode” type=“string” access=“read-write” />
<property name=“country” type=“string” access=“read-write” />
<property name=“status” type=“integer” access=“read-write” />
<property name=“network_id” type=“long” access=“create-only” />
</properties>
<persistence>
<database-map table-name=“site” >
<column-map property-name=“site_id” column-name=“site_id” />
<column-map property-name=“subscriber_id”
column-name=“sub_id” />
<column-map property-name=“site name” column-name=“site_name” />
<column-map property-name=“mac_address”
column-name=“mac_address” />
<column-map property-name=“port_number”
column-name=“port number” />
<column-map property-name=“public_ip_address”
column-name=“public_ip_address” />
<column-map property-name=“public_ip_mask”
column-name=“public_ip_mask” />
<column-map property-name=“street” column-name=“ street” />
<column-map property-name=“city” column-name=“city” />
<column-map property-name=“zipcode” column-name=“zipcode” />
<column-map property-name=“country” column-name=“country” />
<column-map property-name=“status” column-name=“status” />
<column-map property-name=“network_id”
column-name=“network_id” />
</database-map>
</persistence>
</class>
<class name=“ServiceClassifier”>
<description>
This class holds one classifier used in the service subscription.
</description>
<properties>
<property name=“classifier id” type=“long” access=“create-only” />
<property name=“site_id” type=“long” access=“create-only” />
<property name=“subscription_id” type=“long” access=“create-only” />
<property name=“src_mac_address” type=“string”
access=“read-write” />
<property name=“src_ip_address” type=“string”
access=“read-write” />
<property name=“src_port” type=“integer” access=“read-write” />
<property name=“dst_ip_address” type=“string”
access=“read-write” />
<property name=“dst_ip_address” type=“string”
access=“read-write” />
<property name=“dst_port” type=“integer” access=“read-write” />
</properties>
<persistence>
<database-map table-name=“site_svc_classifier” >
<column-map property-name=“classifier_id”
column-name=“classifier_id” />
<column-map property-name=“site_id” column-name=“site_id” />
<column-map property-name=“subscription_id”
column-name=“subsn_id” />
<column-map property-name=“src_mac_address”
column-name=“srcmac” />
<column-map property-name=“src_ip address”
column-name=“srcip” />
<column-map property-name=“src_port” column-name=“srcport” />
<column-map property-name=“dst_mac_address”
column-name=“dstmac” />
<column-map property-name=“dst_ip_address”
column-name=“dstip” />
<column-map property-name=“dst_port” column-name=“dstport” />
</database-map>
</persistence>
</class>
<class name=“SubscriptionSite”>
<description>
This class holds Service subscription information for one site
</description>
<properties>
<property name=“site_id” type=“long” access=“create-only” />
<property name=“subscription_id” type=“long” access=“create-only” />
<property name=“if_index” type=“integer” access=“create-only” />
<property name=“all_devices” type=“boolean” access=“read-write” />
<property name=“classifiers” type=“list” access=“read-write” />
<property name=“end_devices” type=“list” access=“read-write” />
<property name=“config_status” type=“integer” access=“read-write” />
</properties>
<persistence>
<database-map table-name=“subscription_site” >
<column-map property-name=“site_id” column-name=“site_id” />
<column-map property-name=“subscription_id”
column-name=“subscription_id” />
<column-map property-name=“if_index” column-name=“if_index” />
<column-map property-name=“all_devices”
column-name=“all_devices” />
<column-map property-name=“config_status”
column-name=“config_status” />
</database-map>
</persistence>
</class>
<class name=“Subscription”>
<description>
This class holds Service subscription information
</description>
<properties>
<property name=“subscription_id” type=“long” access=“create-only” />
<property name=“subscriber_id” type=“long” access=“create-only” />
<property name=“name” type=“string” access=“read-write” />
<property name=“service_plan_id” type=“long” access=“read-write” />
<property name=“service_type” type=“integer” access=“read-write” />
<property name=“service_method” type=“integer”
access=“read-write” />
<property name=“comments” type=“string” access=“read-write” />
<property name=“status” type=“integer” access=“read-write” />
<property name=“start_date” type=“long” access=“read-write” />
<property name=“is_meshed” type=“boolean” access=“read-write” />
<property name=“subscription_sites” type=“list”
access=“read-write” />
<property name=“service_dep_attrs” type=“var-bucket”
access=“read-write” />
</properties>
<persistence>
<database-map table-name=“subscription” >
<column-map property-name=“ subscription_id”
column-name=“subscription_id” />
<column-map property-name=“subscriber_id”
column-name=“sub_id” />
<column-map property-name=“name”
column-name=“subscription_name” />
<column-map property-name=“service_plan_id”
column-name=“service_id” />
<column-map property-name=“service_type”
column-name=“service_type” />
<column-map property-name=“service_method”
column-name=“service_method” />
<column-map property-name=“comments” column-name=“comments”
/>
<column-map property-name=“status” column-name=“status” />
<column-map property-name=“start_date”
column-name=“start_date” />
<column-map property-name=“is_meshed” column-name=“is_mesh” />
</database-map>
</persistence>
</class>
</classes>
<tasks>
<task name=“ListSubscriberSitesCoveredByPlan”>
<description>
This task returns the list site objects that can be serverd
by given plan with plan id belonging to given subscriber's
id.
</description>
<java-class name=“com.naradnet.xsml.tasks.NaradServiceTasks”
method=“listSitesByPlanId” />
<inputs>
<param name=“subscriber_id” type=“long” />
<param name=“service_plan_id” type=“long” />
</inputs>
<outputs>
<param name=“site_list” type=“list” />
</outputs>
</task>
<task name=“StoreSubscription”>
<description>
This stores Subscription object that is specific to narad.
</description>
<java-class name=“com.naradnet.xsml.tasks.NaradServiceTasks”
method=“storeSubscription” />
<inputs>
<param name=“subscription” type=“class”>
<class-ref class-name=“Subscription” />
</param>
</inputs>
<outputs>
<param name=“subscription” type=“class”>
<class-ref class-name=“Subscription” />
</param>
</outputs>
</task>
<task name=“ResolveSAMServers”>
<description>
This tasks resolves all the NARAD SAM Servers involved in
the subscription and stores them in the subscription site
objects of the given subscription
</description>
<java-class name=“com.naradnet.xsml.tasks.NaradServiceTasks”
method=“resolveSAMServers” />
<inputs>
<param name=“subscription” type=“class”>
<class-ref class-name=“Subscription” />
</param>
</inputs>
<outputs>
<param name=“subscription” type=“class”>
<class-ref class-name=“Subscription” />
</param>
</outputs>
</task>
<task name=“ReserveVLANResources”>
<description>
This tasks reserves VLAN Resources
</description>
<java-class name=“com.naradnet.xsml.tasks.NaradServiceTasks”
method=“reserveVlanResources” />
<inputs>
<param name=“subscription” type=“class”>
<class-ref class-name=“Subscription” />
</param>
</inputs>
<outputs>
<param name=“subscription” type=“class”>
<class-ref class-name=“Subscription” />
</param>
</outputs>
</task>
<task name=“CommitResources”>
<description>
This tasks commits resources
</description>
<java-class name=“com.naradnet.xsml.tasks.NaradServiceTasks”
method=“commitResources” />
<inputs>
<param name=“subscription” type=“class”>
<class-ref class-name=“Subscription” />
</param>
</inputs>
<outputs>
<param name=“subscription” type=“class”>
<class-ref class-name=“Subscription” />
</param>
</outputs>
</task>
</tasks>
<flows>
<flow name=“CreateSubscriptionSites” start-state=“start-state”>
<inputs>
<param name=“site_list” type=“list”/>
</inputs>
<outputs>
<param name=“subscription_sites” type=“list”/>
</outputs>
<states>
<task-state name=“start-state” next-state=“set-all-devices-flag”>
<task-ref task-name=“CreateVarBucketList”
module-name=“xsml.core.listutil” />
<input-map>
<set-param name=“value_list”>
<var-ref name=“site_list”>
<extract>
<extract-property name=“site_id”/>
</extract>
</var-ref>
</set-param>
<set-param name=“property_name”>
<string>site_id</string>
</set-param>
<set-param name=“class_name”>
<string>SubscriptionSite</string>
</set-param>
<set-param name=“module_name”>
<string>xsml.narad.svc.core</string>
</set-param>
</input-map>
<output-map>
<set-var name=“subscription_sites”>
<output-ref name=“varbucket_list”/>
</set-var>
</output-map>
</task-state>
<task-state name=“set-all-devices-flag” next-state=“end-state”>
<task-ref task-name=“AddPropertyToVarBucketList”
module-name=“xsml.core.listutil” />
<input-map>
<set-param name=“varbucket_list”>
<var-ref name=“subscription_sites”/>
</set-param>
<set-param name=“property_name”>
<string>all devices</string>
</set-param>
<set-param name=“property_value”>
<boolean>true</boolean>
</set-param>
</input-map>
<output-map>
<set-var name=“subscription_sites”>
<output-ref name=“varbucket_list”/>
</set-var>
</output-map>
</task-state>
<end-state name=“end-state”>
<flow-output-map>
<set-param name=“subscription_sites” >
<var-ref name=“subscription_sites” />
</set-param>
</flow-output-map>
</end-state>
</states>
</flow>
</flows>
<ui-screens>
<ui-screen name=“SiteSel” title=“Select Site(s)” header=“Select A Site”>
<description>This Screen Helps Selecting Subscriber Site(s) That Participate In
The Subscription</description>
<inputs>
<param name=“fromList.items” type=“list”/>
<param name=“fromList.value” type=“list”/>
<param name=“toList.items” type=“list”/>
<param name=“toList.value” type=“list”/>
<param name=“commentsTf.value” type=“string”/>
<param name=“subscrNameTf.value” type=“string”/>
</inputs>
<outputs>
<param name=“toList.value” type=“list”/>
<param name=“commentsTf.value” type=“string”/>
<param name=“subscrNameTf.value” type=“string”/>
</outputs>
<definition>
<bsh-screen>
<![CDATA[
//--------------------------------------------
// This is generated automatically -- Please do not edit
// This file is generated using XSML UI Builder
//
// @author: SLoke
// ©version: $Id: NaradServiceCore.xsml,v 1.3 2002/07/16 19:01:38 kotagirs
Exp $
//--------------------------------------------
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.table.*;
import javax.swing.tree.*;
import com.naradnet.util.gui.*;
import com.naradnet.util.events.OutputListener;
import com.naradnet.util.events.OutputEvent;
import com.naradnet.xsml.common.*;
import java.util.*;
//Parameters: Title (String), Header (String)
BshNDialog SiteSel(String title, String header)
{
//INITIALIZE SCREEN COMPONENTS HERE
initScreen( )
{
javax.swing.JPanel holder=new javax.swing.Jpanel( );
holder.setLayout(new GridLayout(0,1,5,5));
javax.swing.JPanel panel = new javax.swing.Jpanel( );
panel.setLocation(new Point(5,21));
panel.setSize(new Dimension(453,331));
panel.setPreferredSize(new Dimension(453,331));
panel.setName(“panel”);
holder.add(panel);
panel.setLayout(new GridBagLayout( ));
javax.swing.JPanel JPanel_3 = new javax.swing.Jpanel( );
Jpanel_3.setLocation(new Point(12,168));
JPanel_3.setSize(new Dimension(164,83));
Jpanel_3.setPreferredSize(new Dimension(109,148));
JPanel_3.setName(“JPanel_3 ”);
((GridBagLayout)panel.getLayout( )).setConstraints(JPanel_3,new
GridBagConstraints(0,4,1,1,0.0,1.0,10,1,new Insets(0,2,2,2),0,0));
panel.add(JPanel_3);
JPanel_3.setLayout(new GridLayout(0,1,5,5));
javax.swing.JScrollPane JScrollPane_7 = new
javax.swing.JScrollPane( );
JscrollPane_7.setLocation(new Point(10,10));
JScrollPane_7.setSize(newDimension(144,63));
JScrollPane_7.setPreferredSize(newDimension(89,128));
JScrollPane_7.setName(“JScrollPane_7”);
JPanel_3.add(JScrollPane_7);
fromList.setLocation(new Point(0,0));
fromList.setSize(newDimension(122,41));
fromList.setName(“fromList”);
JScrollPane_7.getViewport( ).add(fromList);
javax.swing.JPanel JPanel_4 = new javax.swing.Jpanel( );
JPanel_4.setLocation(new Point(l78,168));
JPanel_4.setSize(newDimension(107,83));
JPanel_4.setPreferredSize(new Dimension(93,185));
JPanel_4.setName(“JPanel_4”);
((GridBagLayout)panel.getLayout( )).setConstraints(JPanel_4,new
GridBagConstraints(1,4,1,1,0.0,1.0,10,1,new Insets(0,0,2,0),0,0));
panel.add(JPanel_4);
JPanel_4.setLayout(newGridBagLayout( ));
addOne.setLocation(new Point(11,−34));
addOne.setSize(new Dimension(85,37));
addOne.setPreferredSize(new Dimension(71,37));
addOne.setName(“addOne”);
addOne.setText(“Add>”);
((GridBagLayout)JPanel_4.getLayout( )).setConstraints(addOne,new
GridBagConstraints(0,0,1,1,1.0,0.0,10,2,new Insets(5,1,1,1),0,0));
JPanel_4.add(addOne);
addOne.setLabel(“Add>”);
addOne.setActionCommand(“Add”);
addOne.setEnabled(false);
delOne.setLocation(new Point(11,4));
delOne.setSize(new Dimension(85,37));
delOne.setPreferredSize(new Dimension(71,37));
delOne.setName(“delOne”);
delOne.setText(“<Delete”);
((GridBagLayout)JPanel_4.getLayout( )).setConstraints(delOne,new
GridBagConstraints(0,1,1,1,1.0,0.0,10,2,new Insets(0,1,1,1),0,0));
JPanel_4.add(delOne);
delOne.setLabel(“<Delete”);
delOne.setActionCommand(“Delete”);
delOne.setEnabled(false);
addAll.setLocation(new Point(11,42));
addAll.setSize(new Dimension(85,37));
addAll.setPreferredSize(new Dimension(57,37));
addAll.setName(“addAll”);
addAll.setText(“Add>>”);
((GridBagLayout)JPanel_4.getLayout( )).setConstraints(addAll,new
GridBagConstraints(0,2,1,1,1.0,0.0,10,2,new Insets(0,1,1,1),0,0));
JPanel_4.add(addAll);
addAll.setLabel(“Add>>”);
addAll.setActionCommand(“Add>>”);
addAll.setEnabled(false);
delAll.setLocation(new Point(11,80));
delAll.setSize(newDimension(85,37));
delAll.setPreferredSize(new Dimension(71,37));
delAll.setName(“delAll”);
delAll.setText(“<<Delete”);
((GridBagLayout)JPanel_4.getLayout( )).setConstraints(delAll,new
GridBagConstraints(0,3,1,1,1.0,0.0,10,2,new Insets(0,1,5,1),0,0));
JPanel_4.add(delAll);
delAll.setLabel(“<<Delete”);
delAll.setActionCommand(“Del All”);
delAll.setEnabled(false);
javax.swing.JPanel JPanel_6 = new javax.swing.JPanel( );
JPanel_6.setLocation(new Point(12,261));
Jpanel_6.setSize(new Dimension(429,59));
Jpanel_6.setPreferredSize(new Dimension(370,20));
Jpanel_6.setName(“JPanel_6”);
((GridBagLayout)panel.getLayout( )).setConstraints(JPanel_6,new
GridBagConstraints(0,5,0,1,1.0,0.0010,10,1,new Insets(8,2,2,2),0,0));
panel.add(JPanel_6);
JPanel_6.setLayout(new FlowLayout(1,10,1));
okBtn.setLocation(new Point(109,11));
okBtn.setSize(newDimension(100,25));
okBtn.setPreferredSize(newDimension(100,25));
okBtn.setName(“okBtn”);
okBtn.setText(“Finish”);
JPanel_6.add(okBtn);
okBtn.setLabel(“Finish”);
okBtn.setActionCommand(“OK”);
cancel.setLocation(new Point(219,11));
cancel.setSize(new Dimension(100,25));
cancel.setPreferredSize(new Dimension(100,25));
cancel.setName(“cancel”);
cancel.setText(“Cancel”);
JPanel_6.add(cancel);
cancel.setLabel(“Cancel”);
cancel.setActionCommand(“Cancel”);
javax.swing.JPanel JPanel_5 = new javax.swing.JPanel( );
JPanel_5.setLocation(newPoint(287,168));
Jpanel_5.setSize(new Dimension(154,83));
Jpanel_5.setPreferredSize(new Dimension(121,151));
JPanel_5.setName(“JPanel_5”);
((GridBagLayout)panel.getLayout( )).setConstraints(JPanel_5,new
GridBagConstraints(2,4,1,1,0.0,1.0,10,1,new Insets(0,2,2,2),0,0));
panel.add(JPanel_5);
JPanel_5.setLayout(new GridLayout(0,1,0,0));
javax.swing.JScrollPane JScrollPane_15 = new
javax.swing.JscrollPane( );
JScrollPane_15.setLocation(new Point(10,10));
JscrollPane_15.setSize(new Dimension(134,63));
JScrollPane_15.setPreferredSize(newDimension(100,25));
JscrollPane_15.setName(“JscrollPane_15”);
JPanel_5.add(JScrollPane_15);
toList.setLocation(new Point(0,0));
toList.setSize(new Dimension(112,41));
toList.setName(“toList”);
JscrollPane_15.getViewport( ).add(toList);
javax.swing.JLabel fromLb = new javax.swing.Jlabel( );
fromLb.setLocation(new Point(12,132));
fromLb.setSize(new Dimension(164,36));
fromLb.setPreferredSize(new Dimension(126,37));
fromLb.setName(“fromLb”);
fromLb.setText(“Subscriber Sites”);
((GridBagLayout)panel.getLayout( )).setConstraints(fromLb,new
GridBagConstraints(0,3,1,1,1.0,0.0,10,1,new Insets(0,2,0,2),0,0));
panel.add(fromLb);
fromLb.setHorizontalAlignment(0);
javax.swing.JLabel toLb = new javax.swing.Jlabel( );
toLb.setLocation(newPoint(287,132));
toLb.setSize(new Dimension(154,36));
toLb.setPreferredSize(new Dimension(99,37));
toLb.setName(“toLb”);
toLb.setText(“Selected Sites”);
((GridBagLayout)panel.getLayout( )).setConstraints(toLb,new
GridBagConstraints(2,3,1,1,0.0,0.0,1 0,1,new Insets(0,2,0,2),0,0));
panel.add(toLb);
toLb.setHorizontalAlignment(0);
javax.swing.JLabel headLb = new javax.swing.JLabel( );
headLb.setLocation(new Point(12,96));
headLb.setSize(new Dimension(429,36));
headLb.setPreferredSize(new Dimension(358,37));
headLb.setName(“headLb”);
headLb.setText(“Select Sites That Participate In This Service”);
((GridBagLayout)panel.getLayout( )).setConstraints(headLb,new
GridBagConstraints(0,2,3,1,1.0,0.0,10,1,new Insets(10,2,0,2),0,0));
panel.add(headLb);
headLb.setHorizontal Alignment(0);
javax.swing.JLabel JLabel_28 = new javax.swing.JLabel( );
JLabel_28.setLocation(newPoint(12,10));
JLabel_28.setSize(new Dimension(164,36));
JLabel_28.setPreferredSize(new Dimension(100,25));
JLabel_28.setName(“JLabel_28”);
JLabel_28.setText(“ServiceName:”);
((GridBagLayout)panel.getLayout( )).setConstraints(JLabel_28,new
GridBagConstraints(0,0,1,1,0.0,0.0,10,1,new Insets(0,2,2,2),0,0));
panel.add(JLabel_28);
subscrNameTf.setLocation(new Point(178,10));
subscrNameTf.setSize(new Dimension(263,36));
subscrNameTf.setPreferredSize(new Dimension(100,25));
subscrNameTf.setName(“subscrNameTf”);
((GridBagLayout)panel.getLayout( )).setConstraints(subscrNameTf,new
GridBagConstraints(1,0,2,1,1.0,0.0,10,1,new Insets(0,0,2,2),0,0));
panel.add(subscrNameTf);
javax.swing.JLabel JLabel_30 = new javax.swing.JLabel( );
JLabel_30.setLocation(newPoint(12,48));
Jlabel_30.setSize(new Dimension(164,36));
Jlabel_30.setPreferredSize(new Dimension(100,25));
Jlabel_30.setName(”JLabel_30“);
JLabel_30.setText(“Comments:”);
((GridBagLayout)panel.getLayout( )).setConstraints(JLabel_30,new
GridBagConstraints(0,1,1,1,0.0,0.0,10,1,new Insets(0,2,2,2),0,0));
panel.add(JLabel_30);
commentsTf.setLocation(new Point(178,48));
commentsTf.setSize(new Dimension(263,36));
commentsTf.setPreferredSize(new Dimension(100,25));
commentsTf.setName(“commentsTf”);
((GridBagLayout)panel.getLayout( )).setConstraints(commentsTf,new
GridBagConstraints(1,1,2,1,1.0,0.0,10,1,new Insets(0,0,2,2),0,0));
panel.add(commentsTf);
nd.setContentPane(holder);
Dimension gsize = holder.getPreferredSize( );
nd.setSize(gsize.width,gsize.height+30);
//REGISTER BUTTON LISTENERS
okBtn.addActionListener( this );
cancel.addActionListener( this );
fromList_valueChanged = new ListSelectionListener( ) {
valueChanged(event) {
if( fromList.getSelectedIndex( ) >=0 )
{
addOne.setEnabled(true);
addAll.setEnabled(false);
}
int[] indices = fromList.getSelectedIndices( );
if( indices != null && indices.length > 1 )
{
addOne.setEnabled(false);
addAll.setEnabled(true);
}
}
invoke(method,args) {}
};
fromList.addListSelectionListener(fromList_valueChanged);
addOne_actionPerformed = new ActionListener( ) {
actionPerformed(event) {
Object element = fromList.getSelectedValue( );
fromList.getModel( ).removeElement(element);
addOne.setEnabled(false);
if( !(toList.getModel( ) instanceof DefaultListModel) )
toList.setModel(newDefaultListModel( ));
toList.getModel( ).addElement(element);
}
invoke(method,args){}
};
addOne.addActionListener(addOne_actionPerformed);
delOne_actionPerformed = new ActionListener( ) {
actionPerformed(event) {
Object element = toList.getSelectedValue( );
toList.getModel( ).removeElement(element);
delOne.setEnabled(false);
fromList.getModel( ).addElement(element);
}
invoke(method,args){}
};
delOne.addActionListener(delOne_actionPerformed);
addAll_actionPerformed = new ActionListener( ) {
actionPerformed(event) {
Object[] elements = fromList.getSelectedValues( );
if( !(toList.getModel( ) instanceof DefaultListModel) )
toList.setModel(newDefaultListModel( ));
for(int i=0; i<elements.length; i++)
{
fromList.GetModel( ).removeElement(elements[i]);
toList.getModel( ).addElement(elements[i]);
}
addAll.setEnabled(false);
}
invoke(method,args){}
};
addAll.addActionListener(addAll_actionPerformed);
delAll_actionPerformed = new ActionListener( ) {
actionPerformed(event) {
Object[] elements = toList.getSelectedValues( );
for(int i=0; i<elements.length; i++)
{
toList.GetModel( ).removeElement(elements[i]);
fromList.getModel( ).addElement(elements[i]);
}
delAll.setEnabled(false);
}
invoke(method,args){}
};
delAll.addActionListener(delAll_actionPerformed);
okBtn_actionPerformed = new ActionListener( ) {
actionPerformed(event) {
if( toList.getModel( ) instanceof DefaultListModel )
{
int len=toList.getModel( ).size( );
if( len <= 0 ) return;
toList.setSelectionInterval(0, len−1);
}
}
invoke(method,args){}
};
okBtn.addActionListener(okBtn_actionPerformed);
toList_valueChanged = new ListSelectionListener( ) {
valueChanged(event) {
int index = toList.getSelectedIndex( );
if( index >= 0 )
{
delOne.setEnabled(true);
del All.setEnabled(false);
// delete this item from the fromList if for some reason left
over!
Object elem = toList.getSelectedValue( );
fromList.getModel( ).removeElement(elem);
}
int[] indices = toList.getSelectedlndices( );
if( indices != null && indices.length > 1 )
{
delOne.setEnabled(false);
delAll.setEnabled(true);
// delete these items from the fromList if for some reason left
over!
Object[] elems = toList.getSelectedValues( );
for(int i=0; i<elems.length; i++)
{
fromList.getModel( ).removeElement(elems[i]);
}
}
}
invoke(method,args) { }
};
toList.addListSelectionListener(toList valueChanged);
}
//BUTTON ACTIONS HERE
actionPerformed(event)
{
String cmd=event.getActionCommand( );
VarBucket outData=new VarBucket( );
//CREATE EVENT LAZILY AND SHIP IT!
boolean
cancel=(cmd.equalsIgnoreCase(“Cancel”)||cmd.equalsIgnoreCase(“Abort”));
OutputEvent oe=new OutputEvent(cmd, outData, cancel);
nd.fireOutputChanged(oe);
}
//VARIABLE DECLARATIONS HERE
javax.swing.JList fromList = new javax.swing.JList( );
com.naradnet.util.gui.DynamicNaradButton delOne = new
com.naradnet.util.gui.DynamicNaradButton( );
javax.swing.JTextField subscrNameTf = new javax.swing.JTextField( )
com.naradnet.util.gui.DynamicNaradButton addOne = new
com.naradnet.util.gui.DynamicNaradButton( );
com.naradnet.util.gui.DynamicNaradButton delAll = new
com.naradnet.util.gui.DynamicNaradButton( );
com.naradnet.util.gui.DynamicNaradButton okBtn = new
com.naradnet.util.gui.DynamicNaradButton( );
javax.swing.JTextField commentsTf = new javax.swing.JtextField( );
javax.swing.JList toList = new javax.swing.Jlist( );
com.naradnet.util.gui.DynamicNaradButton addAll = new
com.naradnet.util.gui.DynamicNaradButton( );
com.naradnet.util.gui.DynamicNaradButton cancel = new
com.naradnet.util.gui.DynamicNaradButton( );
//INSTANTIATION HAPPENS HERE
BshNDialog nd=new BshNDialog(title,header);
InitScreen( );
return nd;
}
]]>
</bsh-screen>
</definition>
</ui-screen>
</ui-screens>
</module>
END TABLE III

[0067]

TABLE IV
FOLLOWS
<!ENTITY % xsml-common SYSTEM “xsml-common.mod” >
<!ENTITY % xsml-db SYSTEM “xsml-db.mod” >
<!ENTITY % xsml-expr SYSTEM “xsml-expr.mod” >
<!ENTITY % xsml-globals SYSTEM “xsml-globals.mod” >
<!ENTITY % xsml-actions SYSTEM “xsml-actions.mod” >
<!ENTITY % xsml-behaviors SYSTEM “xsml-behaviors.mod” >
<!ENTITY % xsml-classes SYSTEM “xsml-classes.mod” >
<!ENTITY % xsml-flows SYSTEM “xsml-flows.mod” >
<!ENTITY % xsml-tasks SYSTEM “xsml-tasks.mod” >
<!ENTITY % xsml-relationships SYSTEM “xsml-relationships.mod” >
<!ENTITY % xsml-ui SYSTEM “xsml-ui.mod” >
<!--
Copyright(c) 2002 Narad Networks, Inc.
Version: $Id: xsml-common.mod,v 1.6 2002/07/09 18:01:13 kotagirs Exp $
-->
<!-- Common elements or entity-definitions -->
<!ENTITY % PROPERTY-TYPE “(string|integer|long|double|date|list|
	var-bucket|opaque|boolean|class)” >
<!ENTITY % BOOLEAN	“(true|false|yes|no)” >
<!ENTITY % CONST-EXPR	“string|integer|long|double|list|
	var-bucket|boolean” >
<!ENTITY % VAR-EXPR	“var-ref|global-ref” >
<!ENTITY % OUTPUT-EXPR	“output-ref” >
<!ENTITY % NAME-ATTR	“name NMTOKEN #REQUIRED” >
<!ENTITY % DISPLAY-NAME-ATTR	“display-name NMTOKEN #IMPLIED”
>
<!ENTITY % NEXT-STATE-ATTR	“next-state NMTOKEN #IMPLIED” >
<!ENTITY % STATE-ATTRS	“% NAME-ATTR;
% NEXT-STATE-ATTR;” >
<!-- Description tag -->
<!ELEMENT description ( #CDATA ) >
<!-- Properties of a behavior/class -->
<!ELEMENT properties property+>
<!-- Property definition -->
<!ELEMENT property class-ref?>
<!ATTLIST property
	% NAME-ATTR;
	type % PROPERTY-TYPE;	“string”
	access (read-only|read-write|create-only) “read-write”
	min NMTOKEN	#IMPLIED
	max NMTOKEN	#IMPLIED
	default CDATA	#IMPLIED
	mandatory %BOOLEAN; “false”
>
<!-- Each input or output parameter -->
<!ELEMENT param class-ref?>
<!ATTLIST param
	% NAME-ATTR;
	type %PROPERTY-TYPE; “string”
>
<!-- Inputs to a flow or task -->
<!ELEMENT inputs param+>
<!-- Outputs from a flow or task -->
<!ELEMENT outputs param+>
<!-- Go-to statement used in the statement blocks or on-failure conditions -->
<!ELEMENT goto EMPTY >
<!ATTLIST goto
	state	NMTOKEN	#REQUIRED
>
<!-- Defines the persistence description of a class or behavior -->
<!ELEMENT persistence (database-map)>
<!--
Copyright(c) 2002 Narad Networks, Inc.
Version: $Id: xsml-db.mod,v 1.2 2002/03/27 15:48:31 kotagirs Exp $
-->
<!-- Database definition.
Tables, Indexes and other database objects can be defined using this schema. Other
database objects could be specified as CDATA which will be directly run in the database
which could create these objects in the database. These objects could be sequences,
stored procedures, triggers, views etc.
-->
<!-- Column types supported -->
<!ENTITY % COLUMN-TYPE “(string|integer|double|boolean)” >
<!-- Database definition -->
<!ELEMENT database tables?, other-db-objects? >
<!-- Tables in the database -->
<!ELEMENT tables table+ >
<!-- Table definition -->
<!ELEMENT table columns, indices?>
<!ATTLIST table
	%NAME-ATTR;
>
<!-- Columns in a table -->
<!ELEMENT columns column+ >
<!-- Column definition -->
<!ELEMENT column EMPTY >
<!ATTLIST column
	%NAME-ATTR;
	type	%COLUMN-TYPE; #REQUIRED
	size	NMTOKEN #REQUIRED
	mandatory %BOOLEAN;	“false”
>
<!-- Indexes on the table -->
<!ELEMENT indices index+ >
<!-- Index definition -->
<!ELEMENT index index-column+ >
<!ATTLIST index
	%NAME-ATTR;
	unique %BOOLEAN;	“false”
>
<!-- Columns in the index -->
<!ELEMENT index-column EMPTY >
<!ATTLIST index-column
	%NAME-ATTR;
>
<!-- Other database object creation commands. These objects could be
sequences, stored procedures, triggers, views etc.
-->
<!ELEMENT other-db-objects (#CDATA) >
<!-- Describes the mapping between the database table column and a property
of a class or behavior
-->
<!ELEMENT database-map column-map+>
<!ATTLIST database-map
	table-name	NMTOKEN#REQUIRED
>
<!ELEMENT column-map EMPTY>
<!ATTLIST column-map
	colunm-name NMTOKEN #REQUIRED
	property-name	NKTOKEN #REQUIRED
<!--
Copyright(c) 2002 Narad Networks, Inc.
Version: $Id: xsml-expr.mod,v 1.8 2002/07/02 14:32:23 yellanks Exp $
-->
<!-- This module contains the syntax for the expressions that can be
used in XSML.
-->
<!ENTITY %LOGICAL-EXPR “( equals | not-equals | exists |
	not-exists | and | or )”
>
<!-- Constant values of various types supported -->
<!ELEMENT string (#CDATA) >
<!ELEMENT integer (#NMTOKEN) >
<!ELEMENT long (#NMTOKEN) >
<!ELEMENT boolean %BOOLEAN; >
<!ELEMENT double (#NMTOKEN) >
<!ELEMENT date (#CDATA) >
<!ATTLIST date
	format NMTOKEN #IMPLIED
>
<!-- List of values. The list could be heterogeneous or homogeneous i.e.,
all the elements of the list could be of one type or of different types.
For a homogeneous list, the item-type should be specified
-->
<!ELEMENT list (%CONST-EXPR;|%VAR-EXPR;)+ >
<!ATTLIST list
	item-type %PROPERTY-TYPE; #IMPLIED
>
<!-- Var Bucket used to represent a class/behavior. The class or behavior
name is specified as the type-name and its module is specified as the
module-name. The bucket contains the name value pairs for the properties
of the class/behavior.
-->
<!ELEMENT var-bucket (class-ref|behavior-ref)?, var-property+ >
<!-- Var Property to be used as part of a Var Bucket -->
<!ELEMENT var-property (%CONST-EXPR;|% VAR-EXPR;) >
<!ATTLIST var-property
	%NAME-ATTR;
>
<!ELEMENT var-ref extract? >
<!ATTLIST var-ref
	%NAME-ATTR;
>
<!-- reference to a variable in the output from the execution of a state -->
<!ELEMENT output-ref extract? >
<!ATTLIST output-ref
	%NAME-ATTR;
>
<!-- reference to global variables -->
<!ELEMENT global-ref extract? >
<!ATTLIST global-ref
	%NAME-ATTR;
	module-name NMTOKEN #IMPLIED
>
<!-- Extract expression can be applied to following two types of compound
variables.
	1. var-bucket
	2. list of simple data types or var-buckets.
Using Extract on var-buckets:
By using extract operation, you can extract one or more properties
from a var-bucket variable. If more than one extract-property is specfied,
the evaluation of the extract expression will create a new var bucket for
holding the specified properties. match-property and index are not
applicable for var-buckets.
Using Extract on lists:
By using extract, you can perform the following on lists:
	1. extract a particular element with a given index from the list
	2. extract a particular element whose property value matches the
	given match-property value
	3. You can extract one or more from the element found through 1 and 2.
	4. You can extract one or more properties from all the elements in the
	list and prepare a new list.
	Note: 2, 3 and 4 can be applied to only list of var-buckets.
-->
<!ELEMENT extract ( (extract-property+, (match-property | list-index)?) |
	(extract-property*, (match-property | list-index)) ) >
<!ELEMENT extract-property EMPTY>
<!ATTLIST extract-property
	%NAME-ATTR;
>
<!ELEMENT match-property ( %CONST-EXPR; | % VAR-EXPR; ) >
<!ATTLIST match-property
	%NAME-ATTR;
>
<!ELEMENT list-index (integer| %VAR-EXPR;) >
<!-- Assignment operation -->
<!ELEMENT assign ( %CONST-EXPR; | %VAR-EXPR; ) >
<!ATTLIST assign
	%NAME-ATTR;
>
<!-- A block of statements -->
<!ENTITY %STMT-BLOCK “( ( assign | if)*, goto? )” >
<!ELEMENT statements ( assign+ ) >
<!-- The Condition Statement. (if (condition)-then-else) -->
<!ELEMENT if ( condition, then, else? ) >
<!ELEMENT equals ( (%CONST-EXPR; | %VAR-EXPR;),
	(%CONST-EXPR; | %VAR-EXPR;) ) >
<!ELEMENT not-equals ( (%CONST-EXPR; | %VAR-EXPR;),
	(% CONST-EXPR; | % VAR-EXPR;) ) >
<!ELEMENT exists ( var-ref ) >
<!ELEMENT not-exists ( var-ref) >
<!ELEMENT and %LOGICAL-EXPR;+ >
<!ELEMENT or %LOGICLAL-EXPR;+ >
<!ELEMENT condition %LOGICAL-EXPR; >
<!ELEMENT then ( %STMT-BLOCK; ) >
<!ELEMENT else ( %STMT-BLOCK; ) >
<!--
Copyright(c) 2002 Narad Networks, Inc.
Version: $Id: xsml-globals.mod,v 1.2 2002/02/13 15:24:15 yellanks Exp $
-->
<!-- Global Definitions that can be used in any XSML module. -->
<!ELEMENT globals define+ >
<!-- Definition of a constant -->
<!ELEMENT define %CONST-EXPR; >
<!ATTLIST define
	%NAME-ATTR;
>
<!--
Copyright(c) 2002 Narad Networks, Inc.
Version: $Id: xsml-actions.mod,v 1.5 2002/07/17 18:30:29 kotagirs Exp $
-->
<!ENTITY %ACTION-SCOPE “scope (class|instance)”>
<!-- Behavior Actions
-->
<!ELEMENT actions action+ >
<!ELEMENT action ( inputs?, outputs? ) >
<!ATTLIST action
	%NAME-ATTR;
	%ACTION-SCOPE; “instance”
>
<!-- Class actions.
-->
<!ELEMENT class-actions class-action+ >
<!ELEMENT class-action ( flow-ref?, ui? ) >
<!ATTLIST class-action
	%NAME-ATTR;
	%ACTION-SCOPE; “instance”
>
<!-- Class Behavior actions.
-->
<!ELEMENT class-behavior-actions class-behavior-action+ >
<!ELEMENT class-behavior-action ( flow-ref?, ui? ) >
<!ATTLIST class-behavior-action
	%NAME-ATTR;
	%ACTION-SCOPE; “instance”
>
<!-- Relationship actions.
-->
<!ELEMENT relationship-actions relationship-action+ >
<!ELEMENT relationship-action ( flow-ref?, ui?, dnd-action? ) >
<!ATTLIST relationship-action
	%NAME-ATTR;
	%ACTION-SCOPE; “instance”
>
<!-- Reference to a action in a behavior/class in a module -->
<!ELEMENT action-ref (  ( behavior-ref, class-ref ) |
	( behavior-ref, class-id-map ) |
	( behavior-ref, object-id-map ) |
	( class-ref, object-id-map ) ) >
<!ATTLIST action-ref
	action-name NMTOKEN #REQUIRED
>
<!-- User Interface specific elements -->
<!ELEMENT ui EMPTY >
<!ATTLIST ui
	display-name NMTOKEN #REQUIRED
>
<!-- Specifies the action is a drop and drop action for the relationship -->
<!ELEMENT dnd-action EMPTY >
<!--
Copyright(c) 2002 Narad Networks, Inc.
Version: $Id: xsml-behaviors.mod,v 1.2 2002/03/27 15:48:24 kotagirs Exp $
-->
<!-- Behavior Definition
Classes can implement the behaviors by providing the implementations to
the actions specified in the behavior.
Behaviors can be definied with just the properties or with actions or
with both. A behavior with just the properties and no actions behaves
like a c-struct.
-->
<!ELEMENT behaviors behavior+>
<!ELEMENT behavior ( description?, properties?, actions?, persistence? ) >
<!ATTLIST behavior
	%NAME-ATTR;
>
<!-- Reference to a behavior in a module -->
<!ELEMENT behavior-ref EMPTY>
<!ATTLIST behavior-ref
	behavior-name NMTOKEN #REQUIRED
	module-name NMTOKEN #IMPLIED
>
<!--
Copyright(c) 2002 Narad Networks, Inc.
Version: $Id: xsml-classes.mod,v 1.6 2002/07/09 18:01:13 kotagirs Exp $
-->
<!-- Class Definition
Concrete implementations of element/service objects. Classes can
implement behaviors from other modules.
-->
<!ELEMENT classes class+>
<!ELEMENT class ( description?, class-behaviors?, properties?, class-actions?, \
	parent?, persistence? ) >
<!ATTLIST class
	%NAME-ATTR;
	%DISPLAY-NAME-ATTR;
>
<!-- Behaviors that the class implements are defined as class-behaviors -->
<!ELEMENT class-behaviors class-behavior+ >
<!ELEMENT class-behavior behavior-ref, class-behavior-actions?>
<!ATTLIST class-behavior
	property-name NMTOKEN #REQUIRED
>
<!-- Parent class reference. If there is no parent, the object will belong
to the root ( the MSO ) -->
<!ELEMENT parent class-ref>
<!-- Reference to a class in a module -->
<!ELEMENT class-ref EMPTY>
<!ATTLIST class-ref
	class-name NMTOKEN #REQUIRED
	module-name NMTOKEN #IMPLIED
>
<!--
Copyright(c) 2002 Narad Networks, Inc.
Version: $Id: xsml-flows.mod,v 1.10 2002/07/17 00:02:32 kotagirs Exp $
-->
<!-- Flow definitions -->
<!ELEMENT flows flow+>
<!ELEMENT flow ( description?, inputs?, outputs?,
	(task-state|subflow-state|action-state|ui-state
	expr-state|event-state|parallel-state|end-state|
	condition-state)+ ) >
<!ATTLIST flow
	%NAME-ATTR;
	start-state	NMTOKEN	#REQUIRED
>
<!--State in which a task is executed. -->
<!ELEMENT task-state ( description?, task-ref, input-map?, output-map?, on-failure? )
>
<!ATTLIST task-state
	%STATE-ATTRS;
>
<!-- State in which another flow is executed as a sub-flow. -->
<!ELEMENT subflow-state ( description?, flow-ref, input-map?, output-map?,
on-failure? ) >
<!ATTLIST subflow-state
	%STATE-ATTRS;
>
<!-- State in which an action on a specific object is executed. Actions of
a behavior that the object's class is implementing can also be invoked
here.
-->
<!ELEMENT action-state ( description?, action-ref, input-map?, output-map?,
on-failure? ) >
<!ATTLIST action-state
	%STATE-ATTRS;
>
<!-- State in which a user interface is displayed on the client and the
state ends only when the dialog box is closed. The title and header
attributes if specified will override the values set in the screen
definition.
-->
<!ELEMENT ui-state ( description?, ui-ref, input-map?, output-map?, on-failure? ) >
<!ATTLIST ui-state
	%STATE-ATTRS;
	title	NMTOKEN #IMPLIED
	header	NMTOKEN #IMPLIED
>
<!-- State in which a block of xsml statements can be executed -->
<!ELEMENT expr-state ( description?, statements ) >
<!ATTLIST expr-state
	%STATE-ATTRS;
>
<!-- State in which a block of xsml statements can be executed -->
<!ELEMENT condition-state ( description?, condition, ( goto|raise-error ) ) >
<!ATTLIST condition-state
	%STATE-ATTRS;
>
<!-- statement to raise the error -->
<!ELEMENT raise-error EMPTY>
<!ATTLIST raise-error
	message CDATA #REQUIRED
>
<!-- Event State TO BE DEFINED. This is intended as state where the flow
would wait for the event to occur. Another entity would generate this
event which would trigger this flow to be resumed.
-->
<!ELEMENT event-state ( description? ) >
<!ATTLIST event-state
	%STATE-ATTRS;
>
<!-- Parallel state allows you to execute multiple flows in parallel
-->
<!ELEMENT parallel-state ( description?, subflow-state+ ) >
<!ATTLIST parallel-state
	%STATE-ATTRS;
	type	(and|or)	“and”
>
<!-- All flows has to end with end-state. In this state, one should prepare
the flow output from the local variables and constant expressions.
-->
<!ELEMENT end-state flow-output-map>
<!ATTLIST end-state
>
<!-- Reference to a flow in a module -->
<!ELEMENT flow-ref EMPTY>
<!ATTLIST flow-ref
	flow-name	NMTOKEN	#REQUIRED
	module-name	NMTOKEN	#IMPLIED
>
<!-- Mapping of values to input and output parameters of a task/state -->
<!ELEMENT set-param ( %CONST-EXPR; | %VAR-EXPR; ) >
<!ATTLIST set-param
	%NAME-ATTR;
>
<!ELEMENT set-var ( %CONST-EXPR; | %VAR-EXPR; | %OUTPUT-EXPR; ) >
<!ATTLIST set-var
	%NAME-ATTR;
>
<!-- Input map for a task/state execution -->
<!ELEMENT input-map ( set-param+ ) >
<!-- Output map from a task/state execution -->
<!ELEMENT output-map ( set-var+ ) >
<!-- Flow Output map to create flow output to return from end-state of flow -->
<!ELEMENT flow-output-map ( set-param+ ) >
<!ELEMENT object-id-map ( var-ref ) >
<!ELEMENT class-id-map ( var-ref) >
<!-- On Failure condition for a task/state execution -->
<!ELEMENT on-failure ( return | goto | continue | rollback ) >
<!-- Return to the client with the given result ( success/fail ) -->
<!ELEMENT return EMPTY >
<!ATTLIST return
	result ( failure ) “failure”
>
<!-- Rollback till the start of the flow and return failure -->
<!ELEMENT rollback EMPTY >
<!-- continues with next state as it is defined in the state attributes list -->
<!ELEMENT continue EMPTY >
<!--
Copyright(c) 2002 Narad Networks, Inc.
Version: $Id: xsml-tasks.mod,v 1.1 2002/01/31 20:08:57 yellanks Exp $
-->
<!-- Task Definitions -->
<!ELEMENT tasks ( task+ ) >
<!ELEMENT task ( description?, (Java-class | ejb-class ), \
	inputs?, outputs? ) >
<!ATTLIST task
	%NAME-ATTR;
>
<!-- Reference to a task in a module -->
<!ELEMENT task-ref EMPTY>
<!ATTLIST task-ref
	task-name	NMTOKEN	#REQUIRED
	module-name	NMTOKEN	#IMPLIED
>
<!-- If the task is implemented as a plain java class, the details of the
class should to be provided.
-->
<!ELEMENT java-class EMPTY >
<!ATTLIST java-class
	%NAME-ATTR;
	method	NMTOKEN #REQUIRED
	rollback-method	NMTOKEN #IMPLIED
>
<!-- If the task is implemented as a session bean (ejb), the details of the
bean should to be provided.
-->
<!ELEMENT ejb-class EMPTY >
<!ATTLIST ejb-class
	jndi-name	NMTOKEN #REQUIRED
	home-class	NMTOKEN #REQUIRED
	remote-intf	NMTOKEN #REQUIRED
	method	NMTOKEN #REQUIRED
	rollback-method	NMTOKEN #IMPLIED
>
<!--
Copyright(c) 2002 Narad Networks, Inc.
Version: $Id: xsml-relationships.mod,v 1.3 2002/07/09 18:01:13 kotagirs Exp $
-->
<!-- Relationships Definition
Relationships define the different types of relationships between
xsml classes.
-->
<!-- Relationships between classes -->
<!ELEMENT relationships relationship+>
<!ELEMENT relationship class-ref, class-ref, relationship-actions>
<!ATTLIST relationship
	type	(1to1|1toN|Nto1|MtoN)	“1to1”
	%NAME-ATTR;
	%DISPLAY-NAME-ATTR;
>
<!-- Reference to a relationship in a module -->
<!ELEMENT relationship-ref EMPTY>
<!ATTLIST relationship-ref
	relationship-name	NMTOKEN	#REQUIRED
	module-name	NMTOKEN	#IMPLIED
>
<!--
Copyright(c) 2002 Narad Networks, Inc.
Defines ui-screens element.
Version: $Id: xsml-ui.mod,v 1.3 2002/06/13 15:37:09 yellanks Exp $
-->
<!-- Task Definitions -->
<!ELEMENT ui-screens ( ui-screen+ ) >
<!ELEMENT ui-screen ( description?, inputs?, outputs, definition ) >
<!ATTLIST ui-screen
	%NAME-ATTR;
	title	NMTOKEN #REQUIRED
	header	NMTOKEN #REQUIRED
>
<!ELEMENT definition ANY>
<!-- Reference to a ui resource in a module -->
<!ELEMENT ui-ref EMPTY>
<!ATTLIST ui-ref
	ui-name	NMTOKEN	#REQUIRED
	module-name	NMTOKEN	#IMPLIED
>
% xsml-common;
% xsml-db;
% xsml-expr;
% xsml-globals;
% xsml-actions;
% xsml-behaviors;
% xsml-classes;
% xsml-flows;
% xsml-tasks;
% xsml-relationships;
% xsml-ui;
<!--Module. This is the top of the tree. -->
<!ELEMENT module (globals?, database?, behaviors?, classes?,
	flows?, tasks?, relationships?, ui-screens?)>
<!ATTLIST module
	%NAME-ATTR;
>
END TABLE IV

[0068] Those skilled in the art should readily appreciate that the applications and programs for module script processing as defined herein are deliverable to a computer in many forms, including but not limited to a) information permanently stored on non-writeable storage media such as ROM devices, b) information alterably stored on writeable storage media such as floppy disks, magnetic tapes, CDs, RAM devices, and other magnetic and optical media, or c) information conveyed to a computer through communication media, for example using baseband signaling or broadband signaling techniques, as in an electronic network such as the Internet or telephone modem lines. The operations and methods may be implemented in a software entity executable by a processor or as a set of instructions embedded in a carrier wave. Alternatively, the operations and methods may be embodied in whole or in part using hardware components, such as Application Specific Integrated Circuits (ASICs), state machines, controllers or other hardware components or devices, or a combination of hardware, software, and firmware components.

[0069] While this invention has been particularly shown and described with references to preferred embodiments thereof, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the scope of the invention encompassed by the appended claims. Accordingly, the present invention is not intended to be limited except by the following claims.

Claims

1. A method of providing services via a services operating system comprising: providing a module builder operable to generate module scripts, the module scripts indicative of a service entity; providing a script engine, the script engine operable to process the module scripts to identify attributes of the corresponding service entity; providing at least one executable element generator, the executable element generator responsive to the script engine; generating, via the executable element generator, executable objects corresponding to the service entity by assigning values to the attributes; storing the executable objects in a knowledge base; and deploying the executable objects for providing services.

2. The method of claim 1 wherein the service entities further comprise network elements, network services, and network subscriptions.

3. The method of claim 1 wherein each of the module scripts corresponds to a particular one of a network element, a network service, and a network subscription.

4. The method of claim 1 wherein generating the module scripts further comprises generating metalanguage files.

5. The method of claim 1 wherein assigning values to the attributes further comprises gathering data from a user interface.

6. The method of claim 1 wherein providing an executable element generator further comprises providing at least one of a network pre-provisioning manager (NPP), a service plan administrator (SPA), and a service provisioning manager (SPM).

7. The method of claim 1 wherein providing an executable element generator comprises providing an network pre-provisioning manager responsive to module scripts corresponding to network elements.

8. The method of claim 1 wherein providing executable element generator further comprises providing a service plan administrator responsive to module scripts corresponding to network services.

9. The method of claim 1 wherein providing the executable element generator further comprises providing a service provisioning manager responsive to module scripts corresponding to network subscriptions.

10. A system for providing services via a services operating system comprising: a module builder operable to generate module scripts, the module scripts indicative of a service entity; a script engine operable to process the module scripts to identify attributes of the corresponding service entity; at least one executable element generator, the executable element generator responsive to the script engine; a plurality of executable objects, each executable object corresponding to at least one service entity, the executable objects generated by the executable element generator by assigning values to the attributes; a knowledge base operable to store the executable objects; and a service provisioning engine operable to access the knowledge base to deploy the executable objects for providing services.

11. The system of claim 10 wherein the service entities further comprise network elements, network services, and network subscriptions.

12. The system of claim 10 wherein the module scripts are adapted to correspond to a particular one of a network element, a network service, and a network subscription.

13. The system of claim 10 wherein the module scripts further comprise metalanguage files.

14. The system of claim 10 wherein the executable element generators are further operable to assign values to the attributes via gathering data from a user interface.

15. The system of claim 10 wherein the executable element generators further comprise a network pre-provisioning manager (NPP), a service plan administrator (SPA), and a service provisioning manager (SPM).

16. The system of claim 15 wherein the network pre-provisioning manager (NPP) is responsive to module scripts corresponding to the network elements.

17. The system of claim 15 wherein the service plan administrator (SPA) is responsive to module scripts corresponding to the network services.

18. The system of claim 15 wherein the service provisioning manager (SPM) is responsive to module scripts corresponding to the network subscriptions.

19. A method of creating and managing services in a HFC network comprising: identifying a plurality of network services available via the network; identifying a plurality of network elements operable to deliver the network services; defining, for each of the identified network elements, an element module indicative of attributes of the particular element; defining, for each of the identified services, a service module indicative of attributes of the particular service; and deploying, via an executable element generator, an executable object corresponding to each of the element modules and service modules by assigning values to attributes.

20. The method of claim 19 further comprising: storing the executable objects in a common knowledge base; identifying a service for instantiation; and executing the executable objects corresponding to the identified service via a service provisioning engine to provide an instantiation of the service.

21. The method of claim 20 wherein identifying the service for instantiation further comprises: receiving a request for instantiation at a service provisioning manager in communication with the common knowledge base; aggregating the executable objects from the common knowledge base corresponding to the requested service; and executing the aggregated executable objects.

22. The method of claim 19 wherein each of the service modules and each of the element modules is a template of attributes adapted to receive values.

23. The method of claim 19 wherein the executable element generator is a network pre-provisioning manager and deploying further comprises defining values for each of the attributes in the element module.

24. The method of claim 19 wherein the executable element generator is a service plan administrator (SPA) and deploying further comprises defining values for each of the attributes in the service module.

25. The method of claim 21 wherein aggregating the executable objects further comprises integrating the identified executable object into a combined executable element.

26. The method of claim 25 where executing the executable objects further comprises indexing a logic repository to reference service and element specific instructions in response to the executable element.

27. The method of claim 19 wherein assigning the values to attributes further comprises referencing a predetermined list of values and selectively determining a subset of the values as a result of parsing the module.

28. The method of claim 19 wherein deploying the executable objects corresponding to service modules further comprises identifying element modules corresponding to a particular service module, and associating the identified element modules with the particular service module via the executable element.

29. The method of claim 19 wherein the service modules and the element modules are indicative of a metalanguage.

30. The method of claim 19 wherein the executable objects correspond to a metalanguage.

31. The method of claim 30 wherein the metalanguage is XML.

32. The method of claim 19 wherein the service modules and the element modules are module scripts.

33. A method of enabling services via a network comprising: identifying a plurality of entities available via the network; defining a module for each of the identified entities, the module indicative of characteristics of the entity; customizing, via a user interface, each of the modules by associating characteristics with values to generate an executable element; and aggregating the executable objects in a knowledge base.

34. The method of claim 33 further comprising instantiating a service by receiving a request to instantiate a particular service at a service provisioning manager; identifying the executable objects corresponding the requested service; and executing, via an executable element generator, the identified executable objects.

35. The method of claim 33 wherein the entities further comprise network elements and network services.

36. A system for creating and managing services in an HFC network comprising: a plurality of network services available via the network; a plurality of network elements operable to deliver the network services; at least one element module, each element module corresponding to a particular network element and indicative of attributes of the particular element; at least one service module, each service module corresponding to a particular network service and indicative of attributes of the particular service; and an executable element generator operable to deploy an executable object corresponding to each of the element modules and service modules by assigning values to attributes.

37. The system of claim 36 further comprising a common knowledge base operable to store the executable objects; and a service provisioning engine operable to execute the executable objects corresponding to an identified service to provide an instantiation of the service.

38. The system of claim 36 further comprising: a service provisioning manager in communication with the common knowledge base and operable to receive a request for instantiation; the service provisioning manger operable to aggregate the element modules and service modules corresponding to the requested service to generate an aggregated executable object.

39. The system of claim 36 wherein each of the service modules and each of the element modules is a template of attributes adapted to receive values.

40. The system of claim 46 wherein the executable element generator is a network pre-provisioning manager (NPP) and deploying further comprises defining values for each of the attributes in the element module.

41. The system of claim 36 wherein the executable element generator is a service plan administrator (SPA) and deploying further comprises defining values for each of the attributes in the service module.

42. The system of claim 36 further comprising a predetermined list of attributes wherein the executable element generators are further operable to assign values to attributes by referencing the predetermined list of values and selectively determining a subset of the attributes as a result of parsing the module.

43. The system of claim 36 wherein the element modules and the service modules are indicative of a metalanguage.

44. The system of claim 36 wherein the executable objects correspond to a metalanguage.

45. The system of claim 44 wherein the metalanguage is XML.

46. The system of claim 36 wherein the attributes further comprise behavior, capability, and operating variables.