US20070198705A1 - System and method for integrating resources in a network - Google Patents

Abstract

A method for integrating a resource in a network includes receiving at a first adapter a command associated with a function to be performed by a resource. The method also includes receiving a first script associated with the command, and interpreting the first script to produce one or more first byte codes. The method further includes causing a second adapter to receive a second script. The second adapter is operable to interpret the second script into one or more second byte codes. In addition, the method includes executing the one or more first byte codes, and invoking execution of the one or more second byte codes at the second adapter. The execution of the byte codes at the first and second adapters is operable to invoke the function in and facilitate communication with the resource.

Description

PRIORITY CLAIM
• This patent application is a Continuation of U.S. patent application Ser. No. 10/226863, filed Aug. 23, 2002, entitled System and Method for Integrating Resources in a Network, the contents of which are incorporated herein by reference.
TECHNICAL FIELD
• This disclosure relates generally to the field of computer systems, and more particularly to a system, a method, and a program product for integrating resources in a network.
BACKGROUND
• Integration adapters typically allow a new product to be installed in and work with existing or legacy computing systems. Each adapter typically allows the new product to communicate using the appropriate protocols and formats supported by a particular computing system. In general, providing more adapters typically increases the number of computing systems that the new product can work with, which also increases the number of potential customers for the new product. An integration adapter is often created by a skilled programmer who follows the software development cycle. The software development cycle typically includes steps for designing a software program, writing software code, compiling the code, building an executable program, deploying the executable program, and testing or debugging the executable program. This often can be a time consuming task.
BRIEF DESCRIPTION OF THE DRAWINGS
• For a more complete understanding of this disclosure, reference is now made to the following descriptions, taken in conjunction with the accompanying drawings, in which:
• FIG. 1 illustrates an example system for integrating a resource in a network;
• FIG. 2 illustrates an example data flow for integrating a resource in a network;
• FIG. 3 illustrates another example data flow for integrating a resource in a network;
• FIG. 4 illustrates an example method for integrating a resource at a first adapter;
• FIG. 5 illustrates an example method for integrating a resource at a second adapter;
• FIG. 6 illustrates another example method for integrating a resource at a first adapter;
• FIG. 7 illustrates another example method for integrating a resource at a second adapter; and
• FIG. 8 illustrates an example method for persisting scripts in a database.
DETAILED DESCRIPTION OF EXAMPLE EMBODIMENTS
• FIG. 1 illustrates anexample system100 for integrating a resource in a network. In the illustrated embodiment,system100 includesservers102, agateway104,resources106, anetwork108, andclients110. Other embodiments ofsystem100 may be used without departing from the scope of this disclosure.
• In one aspect of operation,server102 and/orgateway104 includeadapter modules124,126, which help to integrate aresource106 intosystem100. Theresource106 may be a computing system or a device.Adapter modules124,126 integrate theresource106 by collectively executing scripts, which define the function or functions to be performed byserver102 and/orgateway104.Adapter modules124,126 can also transfer or marshal data between the executing scripts. The executing scripts causeserver102 and/orgateway104 to behave as an adapter. For example, the scripts may act to translate data so thatserver102 can communicate with theresource106, even when they use different protocols and formats.Adapter module124 could also individually execute script to provide a service insystem100. For example, the script may causeserver102 to analyze data for a specific condition and invoke the execution of another script if the condition is met.
• In the illustrated embodiment,server102 is coupled tonetwork108.Server102 could also be coupled togateway104. In this specification, the term “couple” refers to any direct or indirect communication between two or more components, whether or not those components are in physical contact with one another. Also, the term “communication” refers to communication between physically separate components or between components within a single physical unit.Server102 performs one or more functions to integrate aresource106 insystem100.Server102 may include any hardware, software, firmware, or combination thereof operable to perform integration functions insystem100.
• Gateway104 is coupled toserver102 and to aresource106. Gateway104 facilitates access to theresource106. For example,gateway104 may communicate withserver102 and exchange information withresource106. Gateway104 may comprise any hardware, software, firmware, or combination thereof operable to provide access to a device or system being integrated. The use ofgateway104 may or may not be required to access aresource106 insystem100. As shown inFIG. 1, agateway104 could be used to integrate someresources106 but notother resources106.
• Resource106 represents a computing device or system being integrated intosystem100 byserver102 and/orgateway104.Resource106 may represent any suitable system or device. In the illustrated example,resource106 represents a database information system or an enterprise resource planning (ERP) system. Other suitable resources, such as transaction processing systems, could also be used and integrated intosystem100.
• Network108 is coupled toserver102 and clients110. Network108 facilitates communication between components ofsystem100. For example,network108 may communicate Internet Protocol (IP) packets, frame relay frames, Asynchronous Transfer Mode (ATM) cells, or other suitable information between network addresses.Network108 may include one or more local area networks (LANs), metropolitan area networks (MANs), wide area networks (WANs), all or a portion of a global network such as the Internet, or any other communication system or systems at one or more locations.
• Client110 is coupled tonetwork108.Client110 may perform any of a variety of functions insystem100. For example,client110 may communicate withserver102 and submit a request to perform a function inresource106.Server102 and/orgateway104 act as an adapter so that the requested function can be invoked and performed in theresource106.Client110accesses server102 using abrowser112, aclient application114, or in any other suitable manner.Client110 may include any hardware, software, firmware, or combination thereof operable to communicate withserver102.
• In the illustrated example,server102 includes aprocessor116 and amemory118.Processor116 executes instructions and manipulates data to perform the operations ofserver102. AlthoughFIG. 1 illustrates asingle processor116 inserver102,multiple processors116 may be used according to particular needs.Memory118 stores and facilitates retrieval of information used byprocessor116 to perform the functions ofserver102.Memory118 may, for example, store instructions to be performed byprocessor116 and data used byprocessor116.Memory118 may include any hardware, software, firmware, or combination thereof operable to store and facilitate retrieval of information.
• In the illustrated example,server102 comprises a JAVA 2 Platform Enterprise Edition (J2EE™) server. In this example embodiment,server102 includes one ormore Enterprise JAVABEANS120.Server102 may also include one or more JAVASERVER Pages (JSP™)servlets122.FIG. 1 illustrates only example embodiments ofserver102, andserver102 could represent any other suitable platform. For example, other protocols that support the use of JAVA objects or other objects can be used insystem100.
• JAVABEANS120 represent JAVA applications that implement business or other logic insystem100. Any type of logic may be implemented inJAVABEANS120 to perform any suitable function. For example, the logic implemented inJAVABEANS120 may allow a user using aclient110 to order products from different vendors. In this example,JAVABEANS120 may submit product orders to theresources106, which represent the vendors' order processing systems. The logic implemented inJAVABEANS120 may also allow auser using client110 to track shipments being handled by various shipping carriers. In that case,JAVABEANS120 may retrieve information about specific shipments from theresources106, which represent the carriers' tracking systems. Other oradditional JAVABEANS120 could be used insystem100.
• JAVABEANS120 can be invoked directly from aclient110 usingclient application114.JAVABEANS120 could also be invoked from aclient110 using abrowser112, whereserver102 uses one ormore JSP servlets122 to generate web pages that can be displayed to a user atclient110. The user may then invoke a function ofserver102, such as by initiating execution of aJAVABEAN120, using the web page.
• To facilitate integration of aresource106 intosystem100,server102 includes anadapter module124, andserver102 orgateway104 includes anadapter module126.
• Adapter modules124,126 may each receive one or more scripts, such as by retrieving scripts stored in adatabase128. The scripts identify the actions to be performed byadapter modules124,126. In particular, the scripts identify howadapter modules124,126 operate in order to integrate aresource106 withserver102.Adapter modules124,126 compile or interpret the scripts into byte codes and execute the byte codes.Adapter modules124,126 may further communicate with one another and exchange information during the execution of the scripts. By executing the scripts and exchanging information,adapter modules124,126 may allow information, such as function invocations and status messages, to be communicated betweenserver102 andresource106.Adapter module124 could also individually execute a script to perform a function inserver102, such as analyzing data.Adapter modules124,126 may each comprise any hardware, software, firmware, or combination thereof operable to execute scripts.
• In one embodiment,adapter modules124,126 represent JAVA applications that run on or under one or more JAVA Virtual Machines (JVM™). In a particular embodiment,adapter module124 executes in a (J2EE™) container, andadapter module126 is not contained in a (J2EE™) container. In this embodiment,adapter module124 may communicate withadapter module126 using at least one of the Remote Method Invocation (RMI), JAVA Messaging Service (JMS™), and JAVA Data Base Connection (JDBC™) mechanisms. Becauseadapter module124 may only be able to communicate using a mechanism defined in the (J2EE™) standard,adapter module124 may be unable to communicate directly with theresource106 being integrated.Adapter module126 can communicate using any or all of the (J2EE™) mechanisms, plus any other communication mechanism suitable for communicating with aresource106 being integrated. Becauseadapter module126 may not be limited to communicating using a (J2EE™) mechanism,adapter module126 may communicate with theresource106 being integrated.Adapter modules124,126 may also communicate with one another using a (J2EE™) mechanism and exchange information so that theresource106 is integrated intosystem100.
• As a particular example,resource106 may represent a directory-based file system. In the (J2EE™) environment, the RMI, JMS, and JDBC mechanisms may not support a facility that allowsserver102 to access files on the directory.Adapter modules124,126 execute scripts to allowserver102 to read information from or write information to a file in the directory. For example,adapter module126 may not be restricted to communicating using (J2EE™) mechanisms, soadapter module126 could access files on the directory.Adapter module124 could communicate withadapter module126 and informadapter module126 of what information should be read from or written toresource106. If writing information to the directory,adapter module124 could communicate the information toadapter module126 using one or more of the (J2EE™) communication mechanisms. Similarly, if reading information from the directory,adapter module126 could make the information available toadapter module124 using one or more of the (J2EE™) communication mechanisms.
• AlthoughFIG. 1 illustrates one example of asystem100 for integrating a resource in a network, various changes may be made tosystem100. For example, whileFIG. 1 illustrates the use of a (J2EE™)server102, other suitable servers may be used.
• FIG. 2 illustrates anexample data flow200 for integrating a resource in a network. WhileFIG. 2 assumes that aserver202 and agateway204 are collectively used to integrate aresource206, the functionality described with respect togateway204 could be implemented inserver202.
• InFIG. 2,server202 includes anadapter module224, andgateway204 includes anadapter module226.Server202 could represent any suitable computing device, such as a (J2EE™) server, andgateway204 could represent any suitable gateway device.
• In this example,gateway204 has access to ascript directory228.Script directory228 may include any hardware, software, firmware, or combination thereof operable to store and facilitate retrieval of information. Also,script directory228 may use any of a variety of data structures, arrangements, or compilations to store and facilitate retrieval of the information.
• In the illustrated example,script directory228stores scripts250,252.Scripts250,252 represent scripts that can be compiled/interpreted and executed byadapter modules224,226.Scripts250,252 may represent source Jython or Python scripts, a script library, a JAVA class, or any other suitable structure containing one or more scripts. Thescripts250,252 facilitate integration of and communication with aresource206, such as by converting data from a protocol used byserver202 to a protocol used byresource206.Script250 could represent a script executed byadapter module224, andscript252 could represent a script executed byadapter module226.
• Adapter modules224,226 could represent any suitable element for compiling/interpreting and executing scripts. In one embodiment,adapter module224 may represent a JAVABEANS component that conforms to JAVA container boundaries, whileadapter module226 is not contained in a JAVA container. In this embodiment, eachadapter module224,226 is associated with one or more JAVABEAN properties. In a particular embodiment, the properties of anadapter module224,226 identify the location ofscript directory228 and thescript250,252 associated with thatadapter224,226.
• In one aspect of operation,adapter module224 may execute ascript250 to provide a service. For example,adapter module224 may receive a request to perform a function, such as by receiving a command from anEnterprise JAVABEAN120 ofFIG. 1 to analyze data and determine if a condition is satisfied.Adapter module224 communicates amessage260 toadapter module226, which instructsadapter module226 to retrievescript250 fromdirectory228.Adapter module226 retrieves script250 (represented as data flow262) and communicatesscript250 to adapter module224 (represented as data flow264).Adapter module224 receives, compiles or interprets, and executesscript250. Thescript250 causesadapter module224 to analyze the data and determine if the condition is satisfied.
• In another aspect of operation,adapter modules224,226 may executescripts250,252 to act as an adapter. For example,adapter module224 may receive a request to provide adapter functionality, such as by receiving a command from anEnterprise JAVABEAN120 to invoke a function inresource206.Adapter module224 communicatesmessage260 toadapter module226, causingadapter module226 to retrieve and providescript250 toadapter module224.Adapter module224 also communicates amessage266 toadapter module226.Message266 instructsadapter module226 to retrieve script252 (represented as data flow268) and compile/interpretscript252.Server202 can executescript250, and the execution ofscript250 may generate amessage270 that invokes the execution ofscript252 ingateway204.Server202 andgateway204 can also marshal or transfer data between the executingscripts250,252 (represented as data flows272). By executing thescripts250,252 and exchanging data,server202 andgateway204 may act as an integration adapter and facilitate communication betweenserver202 andresource206.
• Themessages260,266,270 that causeadapter module226 to retrievescripts250,252 may represent any suitable type of instruction. For example,messages260,266,270 could represent RMI calls, JMS messages, or other suitable messages.
• In a particular embodiment,message260 represents a RMI import command,message266 represents a RMI proxy import command, andmessage270 represents a RMI proxy invocation command. A proxy import makes the properties, functions, and classes ofscript252 available for use byscript250. A proxy invocation command invokes thescript252 that was previously imported by a proxy command. In addition,server202 andgateway204 can marshal data between one another in the form of properties, function/method arguments, return values, or other suitable information.
• In addition todirectory228,server202 could also have access to ascript cache274.Cache274 stores binary (compiled) versions ofscripts250,252. In one embodiment, amarker278 associated with the binary version of ascript250,252 is compared with amarker280 associated with thescript250,252. As an example, themarkers278,280 may represent date-time stamps. If themarkers278,280 are the same,server202 orgateway204 may use the binary version of thescript250,252. Otherwise,server202 orgateway204 retrieves and compiles/interprets thescript250,252. Caching binary versions ofscripts250,252 may help to speed the operation ofserver202 andgateway204 by reducing the need to compile or interpretscripts250,252 each time they are used.
• In another embodiment,cache274 may be used in place ofdirectory228. For example,cache274 could be used whenscripts250,252 are being developed.Cache274 would store the latest versions ofscripts250,252 in binary form. After development is complete, the binary forms ofscripts250,252 can be made available, while thesource scripts250,252 are not. This could help to protect thesource scripts250,252 from being modified after development is complete.
• The use ofscripts250,252 may help to simplify the development of an adapter forresource206. For example, rather than requiring that an adapter be developed in a complex programming environment by an experienced programmer,scripts250,252 could be written in a scripting language such as Jython or Python using atext editor282. Thescripts250,252 could also be developed using a shorter development cycle. For example, a developer could design, write, and test/debug thescripts250,252 without the need to perform the other steps of the software development cycle.
• AlthoughFIG. 2 illustrates one example of adata flow200 for integrating a resource in a network, various changes may be made toFIG. 2. For example,gateway204 could be coupled to any number ofresources206. Also, any suitable type ofmessages260,264,266,270 could be used. In addition,scripts250,252 indirectory228 need not includemarkers280, andcache274 need not be included.
• FIG. 3 illustrates anotherexample data flow300 for integrating a resource in a network. WhileFIG. 3 assumes that aserver302 and agateway304 are collectively used to integrate aresource306, the functionality described with respect togateway304 could be implemented inserver302.
• InFIG. 3,server302 includes anadapter module324, andgateway304 includes anadapter module326.Server302 andgateway304 may be the same as or similar toserver202 andgateway204 ofFIG. 2. In this example,server302 has access to ascript repository328, which storesscripts350,352.
• In one aspect of operation,adapter module324 may execute ascript350 to provide a service. In this embodiment,adapter module324 may retrieve script350 from repository328 (represented as data flow360).Adapter module324 then compiles or interprets and executesscript350. Thescript350 causesadapter module324 to perform the function and provide the service.
• In another aspect of operation,adapter modules324,326 may executescripts350,352 to act as an adapter.Adapter module324 retrieves and compiles/interpretsscript350.Adapter module324 also retrievesscript352 from repository328 (represented as data flow362) and communicates thescript352 toadapter module326 usingmessage364.Message364 may, for example, represent a RMI proxy import command.Adapter module326 can then compile/interpretscript352.Adapter module324 executesscript350, and duringexecution adapter module324 communicatesmessage366 to invoke the execution ofscript352 ingateway304.Server302 andgateway304 can also marshal or transfer data between one another (represented as data flows368).
• In addition to or in place ofrepository328,server302 could have access to ascript cache374.Cache374 stores binary versions ofscripts350,352.Server302 may usemarkers378,380 in the same or similar manner as described with respect toserver202 ofFIG. 2.
• AlthoughFIG. 3 illustrates another example of adata flow300 for integrating a resource in a network, various changes may be made toFIG. 3. For example,gateway304 could be coupled to any number ofresources306. Also, any suitable type ofmessages364,366 could be used. In addition,scripts350,352 inrepository328 need not includemarkers380, andcache374 need not be included.
• FIG. 4 illustrates anexample method400 for integrating a resource at a first adapter.Method400 may be described with respect toserver202 ofFIG. 2.Method400 could also be used by another device or devices in another system.
• Server202 receives a request to perform a function atstep402. This may include, for example,adapter module224 receiving a command from an Enterprise JAVABEAN or another component. The request could include a command to perform a particular service, a command to act as an adapter for aresource206, or other suitable request.
• Server202 communicates a request for afirst script250 to agateway204 atstep404. This may include, for example,adapter module224 communicating a RMI import command toadapter module226 ingateway204.Server202 receives thefirst script250 fromgateway204 atstep406. This may include, for example,adapter module226 retrieving thescript250 fromdirectory228 and communicating thescript250 toadapter module224.Server202 compiles/interprets thefirst script250 atstep408. This may include, for example,adapter module224 interpreting aJython script250 into JAVA byte codes.
• If the request received atstep402 represents a request for a service,server202 invokes the compiled/interpretedscript250 atstep412. This may include, for example,adapter module224 executing the JAVA byte codes generated atstep408. Otherwise, the request represents a request to act as an adapter.Server202 instructsgateway204 to retrieve and compile/interpret asecond script252 atstep414. This may include, for example,adapter module224 communicating a proxy import command toadapter module226. This may also includeadapter module226 retrieving thesecond script252 fromdirectory228 and compiling/interpreting thescript252.Server202 invokes thefirst script250 atstep416. The execution of thefirst script250 invokes execution of thesecond script252 ingateway204 atstep418. This may include, for example,adapter module224 communicating a proxy invocation command toadapter module226. At this point, the executingscripts250,252 may exchange information to act as an adapter to integrate aresource206.
• AlthoughFIG. 4 illustrates one example of amethod400 for integrating a resource at a first adapter, various changes may be made toFIG. 4. For example, whileFIG. 4 assumes that aserver202 and agateway204 are collectively used to integrate aresource206, the functionality described with respect togateway204 could be implemented inserver202.
• FIG. 5 illustrates anexample method500 for integrating a resource at a second adapter.Method500 may be described with respect togateway204 ofFIG. 2.Method500 could also be used by another device or devices in another system.
• Gateway204 receives a request for afirst script250 atstep502. This may include, for example,adapter module226 receiving an import command fromadapter module224 inserver202.Gateway204 retrieves thefirst script250 atstep504. This may include, for example,adapter module226 accessingdirectory228 and retrieving thescript250 fromdirectory228.Gateway204 communicates thefirst script250 toserver202 atstep506. This may include, for example,adapter module226 communicating thescript250 toadapter module224 ofserver202.
• If thescript250 is being used byserver202 to perform a service,method500 ends.Server202 may provide the service without further interactions withgateway204.
• Otherwise,server202 andgateway204 may act as an adapter.Gateway204 receives an instruction to retrieve asecond script252 atstep510. This may include, for example,adapter module226 receiving a proxy import command fromadapter module224.Gateway204 retrieves thesecond script252 atstep512. This may include, for example,adapter module226 accessingdirectory228 and retrieving thescript252 fromdirectory228.Gateway204 compiles/interprets thesecond script252 atstep514. This may include, for example,adapter module226 interpreting aJython script252 into JAVA byte codes.Gateway204 receives an instruction to invoke thesecond script252 atstep516. This may include, for example,adapter module226 receiving a proxy invocation command fromadapter module224.Gateway204 invokes thesecond script252 atstep518. This may include, for example,adapter module226 executing the JAVA byte codes generated atstep514. At this point, the executingscripts250,252 may exchange information to act as an adapter to integrate aresource206.
• AlthoughFIG. 5 illustrates one example of amethod500 for integrating a resource at a second adapter, various changes may be made toFIG. 5. For example, whileFIG. 5 assumes that aserver202 and agateway204 are collectively used to integrate aresource206, the functionality described with respect togateway204 could be implemented inserver202.
• FIG. 6 illustrates anotherexample method600 for integrating a resource at a first adapter.Method600 may be described with respect toserver302 ofFIG. 3.Method600 could also be used by another device or devices in another system.
• Server302 receives a request to perform a function atstep602, such as a request from an Enterprise JAVABEAN or other component.Server302 retrieves thefirst script350 atstep604. This may include, for example,adapter module324 retrieving thefirst script350 from ascript repository328.Server302 compiles/interprets thefirst script350 atstep606.
• If the request received atstep602 represents a request for a service atstep608,server302 invokes the compiled/interpretedscript350 atstep610. Otherwise, the request may represent a request to act as an adapter.Server302 retrieves asecond script352 atstep612. This may include, for example,adapter module324 retrieving thesecond script352 fromrepository328.Server302 communicates thesecond script352 togateway304 atstep614. This may include, for example,adapter module324 communicating thesecond script352 toadapter module326 using a proxy import command. This may also includeadapter module326 compiling/interpreting the second script354.Server302 invokes thefirst script350 atstep616. The execution of thefirst script350 invokes execution of thesecond script352 ingateway304 atstep618. This may include, for example,adapter module324 communicating a proxy invocation command toadapter module326. At this point, the executingscripts350,352 may exchange information to act as an adapter to integrate aresource306.
• AlthoughFIG. 6 illustrates another example of amethod600 for integrating a resource at a first adapter, various changes may be made toFIG. 6. For example, whileFIG. 6 assumes that aserver302 and agateway304 are collectively used to integrate aresource306, the functionality described with respect togateway304 could be implemented inserver302.
• FIG. 7 illustrates anotherexample method700 for integrating a resource at a second adapter.Method700 may be described with respect togateway304 ofFIG. 3.Method700 could also be used by another device or devices in another system.
• Gateway304 receives asecond script352 fromserver302 atstep702. This may include, for example,adapter module326 receiving thesecond script352 fromadapter module324.Gateway304 compiles/interprets thesecond script352 atstep704. This may include, for example,adapter module326 interpreting aJython script352 into JAVA byte codes.Gateway304 receives an instruction to invoke thesecond script352 atstep706.Gateway304 invokes thesecond script352 atstep708. This may include, for example,adapter module326 executing the JAVA byte codes generated atstep704. At this point,adapter module326 may be executingscript352, andadapter module324 inserver302 may be executingscript350. The executingscripts350,352 may exchange information to act as an adapter to integrate aresource306.
• AlthoughFIG. 7 illustrates another example of amethod700 for integrating a resource at a second adapter, various changes may be made toFIG. 7. For example, whileFIG. 7 assumes that aserver302 and agateway304 are collectively used to integrate aresource306, the functionality described with respect togateway304 could be implemented inserver302.
• FIG. 8 illustrates anexample method800 for persisting scripts in a database.Method800 may be described with respect toserver202 ofFIG. 2.Method800 could also be used by another device or devices in another system. For example,method800 could be used byserver302 to persist scripts in a database.
• Server202 compares a current script to a previously compiled or interpreted script atstep802. This may include, for example,adapter module224 comparing amarker278 associated with the binary version of ascript250 with amarker280 associated with the source version of thescript250.Server202 determines whether the compared scripts match atstep804. This may include, for example,adapter module224 determining whether themarkers278,280 contain the same date-time stamp.
• If themarkers278,280 match, the current script may not have changed since that script was compiled/interpreted earlier.Server202 may retrieve the binary version of the script atstep806. This may include, for example,adapter module224 retrieving the binary version of thescript250 from acache274. At this point,server202 may use and process the binary version of thescript250.
• If themarkers278,280 do not match atstep804, the current script has changed since that script was compiled/interpreted.Server202 compiles/interprets the newer script atstep808. This may include, for example,adapter module224 generating JAVA byte codes.Server202 stores the binary version of the newer script atstep810. This may include, for example,adapter module224 replacing the older binary version ofscript250 incache274 with the newer binary version generated atstep808. At this point,cache274 contains an updated version of thescript250.
• While this disclosure has been described in terms of certain embodiments and generally associated methods, alterations and permutations of the embodiments and methods will be apparent to those skilled in the art. Accordingly, the above description of example embodiments does not define or constrain this disclosure. Other changes, substitutions, and alterations are also possible without departing from the spirit and scope of this disclosure, as defined by the following claims.

Claims (10)

1-41. (canceled)

42. A method for integrating a resource in a network, comprising:

a first adaptor of a resource integration system receiving from a requesting entity a command associated with a function to be performed by a resource communicatively coupled to the resource integration system;

the first adaptor generating a first set of byte codes responsive to receiving the command;

a second adapter of the resource integration system generating a second set of byte codes;

the first adaptor invoking execution of the first set of byte codes; and

the first adaptor invoking execution of the second set of byte codes at the second adapter, the execution of the first and second sets of byte codes at the first and second adapters operable to invoke the function in the resource.

43. The method ofclaim 42, wherein the first adaptor generating the first set of bytes codes includes:

the first adaptor retrieving a first script from a storage resource of the resource integration system; and

the first adaptor interpreting the first script to generate the first set of byte codes.

44. The method ofclaim 43, wherein the second adaptor generating the second set of byte codes includes the second adaptor retrieving a second script from the storage resource and interpreting the second script.

45. A system for integrating a resource in a network, comprising:

at least one processor having access to a storage resource and operable to communicate to a first adapter of a resource integration system, the first adapter operable to:

receive from a requesting entity a command associated with a function to be performed by a resource communicatively coupled to the resource integration system;

receive a first script from the storage resource;

cause a second adapter of the resource integration system to receive a second script from the storage resource; and

execute the first script, wherein the execution of the first script invokes execution of the second script by the second adapter, the execution of the first and second scripts at the first and second adapters operable to invoke the function in the resource.

46. The system ofclaim 45, wherein the first adaptor is configured to interpret the first script to generate a first set of byte codes and the second adapter is configured to interpret the second script to generate a second set of bytes codes.

47. The system ofclaim 46, wherein executing the first script comprises executing the first set of bytes codes and wherein executing the second script comprises executing the second set of bytes codes.

48. A system for integrating a resource in a network, comprising:

executable instructions stored on a computer readable medium; and

the instructions operable, when executed, to cause a first adaptor of a resource integration system to:

receive from a requesting entity a command associated with a function to be performed by a resource communicatively coupled to a resource integration system;

receive from one of (a) storage resource and (b) a second adaptor of the resource integration system a first script associated with the command;

execute the first script; and

invoke execution of a second script at the second adapter, the execution of the first and second scripts operable to invoke the function in the resource.

49. A system for integrating a resource in a network, comprising:

a storage resource operable to store a first script and a second script;

a first adapter of a resource integration system operable to receive a command associated with a function to be performed by a resource communicatively coupled to the resource integration system, receive the first script from the storage resource, and execute the first script;

a second adapter of the resource integration system operable to receive the second script from the storage resource, and execute the second script in response to the execution of the first script; and

wherein the execution of the first and second scripts is operable to invoke the function in the resource.

50. The system ofclaim 49, wherein executing the first script includes interpreting the first script to generate a first set of byte codes and executing the first set of byte codes and further executing the second script includes interpreting the second script to generate a second set of byte codes and executing the second set of byte codes.

Images