WO2001037087A2

WO2001037087A2 - Internet component object method

Info

Publication number: WO2001037087A2
Application number: PCT/US2000/031519
Authority: WO
Inventors: Michael Mcdonald
Original assignee: Treev, Inc.
Priority date: 1999-11-19
Filing date: 2000-11-17
Publication date: 2001-05-25
Also published as: AU1615801A; WO2001037087A3

Abstract

An Internet component object method is disclosed. The Internet component object model enables an adapter to run in both the client and server computers and has its logic follow one of two distinct paths of execution depending on whether the adapter is running in a client-server or web environment. If the client workstation is operating in a client-server environment, then the adapter makes a direct call to a service application programming interface (API). If the client workstation is operating in a web environment, then the adapter sends a hypertext transfer protocol (HTTP) request to a web server for remotely accessing a service API.

Description

INTERNET COMPONENT OBJECT METHOD

Background Field of the Invention The present invention relates to adapters (i.e., software components) that expose an interface to an underlying service, and more particularly, to adapters that function in both client-server environments and web environments.

Discussion of the Related Art In the early stages of computing, the expense of computing power dictated a mainframe-controlled environment. As the price of computing fell, powerful desktop computers emerged. These desktop computers were connected together by simple local area networks (LANs). Today, the convergence of ever-cheaper computing with widespread, global connectivity through the Internet has led to the age of network- centric computing. In network-centric computing, each person has the use of many central processing units (CPUs).

The growth of network computing has presented many challenges to the software development process. Software developers must determine how to build software for a rapidly changing network-centric computing environment. Software development, deployment, and maintenance are critical issues that must be addressed in the evolution process. In particular, software developers must account for the current architectural evolution from client-server architectures to three-tier network computing architectures.

Summary of the Invention

The present invention provides an Internet component object method that enables an adapter to operate in either a client-server architecture or three-tier network computing architecture. The adapter includes a service application programming interface class that is instantiated in a client workstation operating in a client-server environment or in a client workstation and web server operating in a web environment. A method in the service application programming interface class enables the computer system in which it was instantiated to determine the type of environment in which the computer system is operative. Based upon this determination, the logic of the adapter will follow one of two distinct paths of execution. If the computer system is operating in a client-server environment, then a direct call is made to a service application programming interface. If the computer system is operating in a web environment, then a hypertext transfer protocol request is sent to a web server to remotely access a service application programming interface. In accordance with this structure, the adapter of the present invention can be run in two physical places (e.g., a client workstation and a web server).

Brief Description of the Drawings FIG. 1 is an architecture diagram of the interaction of adapters in a client-server environment and in a three-tier network-computing environment. FIG. 2 illustrates an adapter architecture according to the present invention.

FIG. 3 is a flowchart of the operation of an adapter architecture in a client-server environment and in a three-tier network-computing environment.

Detailed Description of the Preferred Embodiments In a client-server environment, an adapter that exposes an interface (i.e., a set of properties and methods) to an underlying service is typically implemented as a "heavyweight" component. By definition, a "heavyweight" component is any component that directly makes use of a bulky service (in terms of its code size) such as a database service (e.g., ActiveX Data Objects (ADO), Data Access Objects (DAO), Open Database Connectivity (ODBC), etc.) or a client-server application programming interface (API). "Lightweight" components, on the other hand, have a relatively small memory footprint and indirectly make use of a bulky service by accessing the service remotely via some form of inter-process communication (IPC).

Adapters in a client-server environment are typically implemented to directly make use of an underlying core engine and/or database engine. In this architecture, the client-server adapter communicates directly with the server via Transmission Control Protocol/Internet Protocol (TCP/IP) sockets.

The utilization of this type of adapter outside of a client-server environment poses several problems. In particular, client-server adapters are not well suited for web- based applications that make use of graphical user interface (GUI) controls in a web browser. Having the adapter directly use the underlying core components causes the web-based application to be large due to the number of software components that need to be installed on the machine before the web-based application can run. Furthermore, client-server adapters create problems for network managers who are responsible for security firewall and proxy issues. Most firewalls and proxies allow only a few protocols (such as the hypertext transfer protocol (HTTP)) and ports (e.g., port 80) to be enabled for obvious security reasons. As a direct result, software that incorporates adapters that operate on non-standard ports may be inappropriate for security-sensitive applications. In the present invention, an Internet component object method is defined that enables an adapter to function both in a client-server environment as a traditional "heavyweight" component and in a web environment as a "lightweight" component. This universal adapter greatly increases code re-use and hence the maintainability of the system software. To support both a client-server environment and a web environment, the adapter of the present invention is operative to discover the environment in which it is running. Based upon this environment discovery, the adapter may either (1) make a call directly to the underlying service API or (2) remotely access the service API by issuing an HTTP request to a web server.

FIG. 1 illustrates a general three-tiered computing architecture. Illustrated within the tree-tiered computing architecture of FIG. 1 is the two-tier client-server model and the three-tier network computing architecture (NCA) model. The two-tier client-server model is illustrated by the interaction between client workstation 110 and server 140. In the client-server model, client-server (C/S) application 111, via control component 112 (e.g., OCX controls), calls into adapter component 1 13 A. Adapter component 1 13A makes direct use of underlying service API 1 14A to access core engine/database engine 141 on server 140. The access of core engine/database engine 141 on server 140 by service API component 1 14A is illustrated as communication 115 in FIG. 1.

The NCA model, on the other hand, is illustrated by the interaction between client workstation 120, web server 130, and server 140. In the NCA model, web application 121, via control component 122, calls into adapter component 113B. Adapter component 1 13B makes indirect use of underlying service API 1 14B by issuing an HTTP request to web server component 131. The issuance of HTTP request from adapter 113B to web server component 131 is illustrated as communication 125 in FIG. 1. Web server component 131 dispatches the request to a handler 132 (e.g., Active Server Pages (ASP), Internet Service API (ISAPI) extensions, Common

Gateway Interface (CGI) scripts, or a custom HTTP server), which in turn calls into adapter component 1 13C. Adapter component 113C then makes direct use of underlying service API 114B to access core engine/database engine 141 on server 140. The access of core engine/database engine 141 on server 140 by service API component 1 14B is illustrated as communication 135 in FIG. 1. After the access of core engine/database engine 141, handler 132 delivers the results to client workstation 120 in an HTTP response.

As will be discussed in greater detail below, adapter 1 13 of the present invention can be described as a "split adapter." The term "split adapter" is used to describe the fact that adapter 113 can be run in two physical places (i.e., client workstation 110/120 and web server 130) and that its logic is split into two distinct paths of execution depending on whether adapter 1 13 is running in a client-server environment or in a web environment. More specifically, adapter 1 13 A, 113B, and 1 13C represent separate instantiations of classes defined in adapter 113. FIG. 2 illustrates the internal architecture of adapter 1 13. In FIG. 2, the term

"adapter user" is used to refer to any software component that creates instances of the classes defined in adapter 1 13 and makes use of the properties and methods defined within those classes. Accordingly, adapter user 210 can represent an end-user application, a control, or some other component. Each adapter 1 13 consists of several component classes 220-1 to 220-N whereby each component class 220- 1 to 220-N exposes methods and properties to adapter user 210. Each method or property of component classes 220-1 to 220-N has the potential to call methods or functions in the underlying service API 1 14. In the present invention, all calls to the underlying service API 114 are split out into a separate class named ServiceAPI class 230. Accordingly, each method or property of component classes 220-1 to 220-N has the potential to call methods or functions in ServiceAPI class 230. As will be described below, a method of ServiceAPI class 230 can either make direct use of service API 1 14A or make indirect use of service API 1 14B by sending an HTTP request to web server 130 using, for example, the Microsoft Internet Transfer Control 240. This indirect call to service API 114B is processed by web server component 131 and handler 132. The request is then passed to a separate instance of service API class 230 that is running on web server 130. As noted above, these separate instances of service API class 230 give rise to the term "split adapter."

The flowchart of FIG. 3 illustrates the operation of the adapter architecture of

FIG. 2 in the context of the three-tiered computing architecture of FIG. 1. The flowchart of FIG. 3 begins at step 302 with adapter user 210 making a call into a property or method of component #N class 220-N. In the context of FIG. 1, adapter user 210 can represent either control component 112 on client workstation 1 10 or control component 122 on client workstation 120. If component #N class 220-N requires use of an underlying service, at step 304, it makes a call into a method of ServiceAPI class 230 that is instantiated on either client workstation 110 or client workstation 120. As noted, the method of ServiceAPI class 230 may make direct use of service API 114 or make indirect use of service API 1 14 by sending an HTTP request to web server component 131 using Internet Transfer Control 240.

The choice of action by the method of Service API class 230 is dependent upon a determination of environment type (i.e., client-server environment or web environment) at step 306. If it is determined, at step 306, that adapter 1 13 is operative on client workstation 110 as part of a client-server environment (i.e., adapter 1 13 A), then the method of ServiceAPI class 230 instantiated on client workstation 1 10, at step 308, makes a direct call to underlying service API 1 14A, which then accesses core engines/database engines 141. This communication is illustrated as communication 115 in FIG. 1. The results of the API call are then returned in a communication from server 140 to client workstation 110 (not shown) at step 310.

If it is determined, at step 306, that adapter 113 is operative on client workstation 120 as part of a web environment (i.e., adapter 113B), then the method of ServiceAPI class 230 instantiated at client workstation 120, at step 312, makes an indirect call to underlying service API 1 14B by issuing an HTTP request to web server 130. This HTTP request is illustrated as communication 125 in FIG. 1. At step 314, web server component 131 extracts the parameters from the HTTP request and dispatches it to handler 132. Next, at step 316, handler 132, operating as adapter user 210, makes a call into a property or method of component #N class 220-N. If component #N class 220-N requires use of an underlying service, at step 318, it makes a call into a method of ServiceAPI class 230 that is instantiated on web server 130.

As the method of ServiceAPI class 230 that is operative on web server 130 and the method of ServiceAPI class 230 that is operative on client workstation 120 merely represent separate instantiations, the same determination of the environment type at step 306 is performed at step 320. In the determination process at step 320, however, the primary path of execution is as a client-server environment. Here, it is assumed that web server 130 is the computer that will make a direct call to service API 114B. As it is assumed that web server 130 will not make an indirect call to an underlying service API, the branch of execution as a web server environment is not required. In the branch of execution as a client-server environment, a direct call is made, at step 322, to underlying service API 1 14B, which then accesses core engines/database engines 141. This communication is illustrated as communication 135 in FIG. 1. The results of the API call are then returned, at step 324, in a communication (not shown) from server 140 to web server 130, and subsequently to client workstation 120.

Having described the general adapter process, the Visual Basic code of an adapter example is provided. Consider an example adapter that consists of two classes, Folder and File, which interact with a file system. A Folder object refers to a directory in the file system and a File object refers to an actual data file. The properties of a Folder object might include its name, full path, size, creation date, modification date, last access date, etc. For the purposes of this example, only two properties will be addressed, its name and full path. In addition, the Folder object consists of child items (i.e., subfolders) and it returns from its Childltems property a collection of Folder objects that represent the subfolders contained in the folder. A portion of code from the Folder class might look as follows.

Private m_strName As String 'folder name

Private m_strFullPath As String 'full pathname of the folder

Private Property Get Childltems() As Collection

Set Childltems = g_ServiceAPI.GetChildren(m_strFullPath) End Property

The g ServiceAPI variable is a global which represents a single instance of ServiceAPI class 230. This variable is declared as follows.

Public g_ServiceAPI As New ServiceAPI

The primary portions of the split adapter code are contained in ServiceAPI class 230. The example ServiceAPI method GetChildren is defined as follows.

Line Code

1 Public Function GetChildren(ByVal strFullPath As String) As Collection

2 Dim Items As Collection 3 Dim Folder As Folder

4 Dim SysDrive As Scripting. Drive

5 Dim SysFolder As Scripting. Folder

6 Dim SysSubFolder As Scripting. Folder

7 Dim URL As String 8 Dim Response As Variant

9 Dim ByteArray As TreevUtils.VBByteArray If g_TreevEnv.ServerAddress = "" Then 'Construct a collection of subfolders. Set Items = New Collection If strFullPath = "" Then 'We're at the root, so enumerate the drives on the system. For Each SysDrive In g_FileSystem. Drives Set Folder = New Folder Folder.Name = SysDriveLetter & ":" Folder.FullPath = SysDrive. DriveLetter & ":\" Items.Add Folder Next Else 'We're in a folder, so enumerate its subfolders. Set SysFolder = g_FileSystem.GetFolder(strFullPath) For Each SysSubFolder In SysFolder.SubFolders Set Folder = New Folder Folder.Name = SysFolder.Name Folder.FullPath = SysSubFolder.Path Items.Add Folder Next End If Else 'Issue an HTTP request to the server. URL = "http.7/" & g_TreevEnv.ServerAddress & ":" & _ CStr(g_TreevEnv.TCPPortNumber) & _ "/test.asp?path=" & g_TreevEnv.EncodeURL(strFullPath) Response = frmlnet.Execute(URL, , , , icByteArray)

'Convert the response into a collection of subfolders. Set ByteArray = New TreevUtils.VBByteArray ByteArray. Bytes = Response 40 Call ByteArray.LoadObject(ltems)

41 End If

42 Set GetChildren = Items 43 End Function

In discussing the GetChildren method example, some supporting classes and modules are introduced.

TreevEnvironment Class

As noted, split adapter 1 13 will support applications operating in either a client- server environment or in a web environment. To support this universal behavior, adapter 113 includes a mechanism for determining whether it is (1) running in a client- server environment and needs to make direct calls into the underlying service API 1 14 or (2) running in a web environment and needs to make indirect use of the underlying service API 1 14 via HTTP.

In one embodiment, a TreevEnvironment class is added to adapter component 113. This TreevEnvironment class provides two properties, ServerAddress and TCPPortNumber, which represent the two key attributes required by the web environment: (1) the address of the web server (e.g., www.site.com) and (2) the TCP port number to be used (e.g., 1730). In one embodiment, the default attributes will be a web server address containing an empty string ("") and a TCP port number of 80. An empty web server address serves to indicate that no web server 130 exists and that adapter 113 should make direct calls to the underlying service API 1 14. The two attributes are implemented as static class members (not instance variables) such that any component running in the same process will have access to the same information. At each point where adapter 1 13 needs to make a call to an underlying service API 1 14, it determines whether or not it should make a direct call to the underlying service API 1 14 or should make indirect use of the underlying service API 1 14 via HTTP. In one embodiment, adapter 113 includes the following line of code in a code module (e.g., GLOBALS.BAS).

Public g_TreevEnv As New TreevEnvironment

This line of code instantiates a global instance of the TreevEnvironment class that can be used by adapter 113 to determine the need for a direct call to the underlying service API 1 14 versus an indirect use of the underlying service API 114 via an HTTP request. The environment determination process is effected by executing code similar to the following:

If g_TreevEnv.ServerAddress = "" Then

'Make a direct call to the service API Else 'Issue an HTTP request to the web server

End If

Here, it is assumed that the ServerAddress and TCPPor Number properties will be set to the correct values when web application 121 is started on client workstation 120. Note that client-server application 1 1 1 does not need to set these properties since they have reasonable defaults.

VBByteArray Class

The VBByteArray class will provide the basic means of implementing persistence to byte arrays. It will consist of LoadObject and SaveObject methods to handle the reading and writing of objects to the underlying byte array. It will also consist of a Bytes property which will allow the caller to either get/set the byte array that is to be operated on. In addition, it will implement an interface allowing it handle the reading and writing of any variant type of data. Once an object has been persisted to a byte array, it can be written across any communication channel. Internet Transfer Form (FRMINET.FRM)

This Visual Basic (VB) form contains a single Microsoft Internet Transfer Control and is intended to be used in each and every adapter 113 to provide the basic means to support transfer of data between a client workstation 120 and web server 130 via HTTP.

In the code example provided above, the GetChildren method of ServiceAPI class 230 examines the ServerAddress property (see code line 10) to determine whether to make a direct call to the underlying service API 1 14 or to make an indirect call to the underlying service API 1 14 by issuing an HTTP request to web server 130. In the case of a direct call, the method utilizes a global instance of the Scripting.FileSystemObject class (i.e., g_FileSystem) to enumerate the subfolders of the current path and return a collection of Folder objects (see code lines 1 1-30). In the case of an indirect call, the method issues an HTTP request to web server 130, reads the response into a byte array, and uses the VBByteArray class to load the object represented by this byte array (see code lines 32-40).

As noted above, the GetChildren method of ServiceAPI class 230 exists as a separate instantiation on either client workstation 110, 120 or web server 130. For client workstation 110 operating in a client-server environment, the GetChildren method determines at code line 10 that the ServerAddress property has been set to the default value (i.e., ""). The GetChildren method then proceeds to make a direct call to underlying service API 114 at code lines 1 1-30.

For client workstation 120 operating in a web environment, the GetChildren method determines at code line 10 that the ServerAddress property has been set to the address of web server 130. The GetChildren method then proceeds to make an indirect API call to underlying service API 1 14 at code lines 32-40. This indirect call includes the issuance of an HTTP request at code lines 33-35.

For web server 130 having received an HTTP request from client workstation 120, the GetChildren method determines at code line 10 that the ServerAddress property has been set to the default value (i.e., ""). The GetChildren method then proceeds to make a direct call to underlying service API 114 at code lines 1 1-30. While the invention has been described in detail and with reference to specific embodiments thereof, it will be apparent to one skilled in the art that various changes and modifications can be made therein without departing from the spirit and scope thereof. In particular, it should be noted that while the environment determination process described above has been described using the defined TreevEnvironment class, other methods of determining the operating environment of client workstation 1 10, 120 or web server 130 would be apparent to one of ordinary skill in the relevant art. Thus, it is intended that the present invention cover the modifications and variations of this invention provided they come within the scope of the appended claims and their equivalents.

Claims

What is claimed is:

1. In a computer environment having an adapter that includes a service application programming interface class, a method for calling a service application programming interface, comprising the steps of: (a) invoking a method in a first instance of said service application programming interface class instantiated in a client workstation that performs the steps of:

(i) determining a type of environment in which said client workstation is operative; (ii) if said client workstation is operating in a client-server environment, then making a direct call to a service application programming interface; and

(iii) if said client workstation is operating in a three-tier environment, then sending a request to a server for remotely accessing a service application programming interface; and

(b) invoking a method in a second instance of said service application programming interface class instantiated in said server that makes a call to a service application programming interface.

2. The method of claim 1, wherein step (a)(i) comprises the step of determining if a server address property of an instantiation of an environment class in said client workstation is set to a default value.

3. The method of claim 1, wherein step (a)(iii) comprises the step of sending a hypertext transfer protocol request to a web server.

4. In a computer environment having an adapter that includes a service application programming interface class, a method for calling a service application programming interface, comprising the step of: (a) invoking a method in an instance of said service application programming interface class instantiated in a client workstation that performs the steps of:

(i) determining a type of environment in which said client workstation is operative;

(ii) if said client workstation is operating in a client-server environment, then making a direct call to a service application programming interface; and

(iii) if said client workstation is operating in a three-tier environment, then sending a request to a server for remotely accessing a service application programming interface.

5. The method of claim 4, wherein step (a)(i) comprises the step of determining if a server address property in an instantiation of an environment class in said client workstation is set to a default value.

6. The method of claim 4, wherein step (a)(iii) comprises the step of sending a hypertext transfer protocol request to a web server.

7. The method of claim 5, further comprising the step of invoking a method in a second instance of said service application programming interface class instantiated in said server that performs the steps of:

(i) determining if a server address property in a second instantiation of said environment class in said server is set to a default value; and (ii) if said server address property in said second instantiation is set to said default value, then making a call to a service application programming interface.

8. A computer program product for enabling a processor in a computer system to call a service application programming interface, said computer program product comprising: a computer usable medium having computer readable program code means embodied in said medium for causing a program to execute on the computer system, said computer readable program code means comprising: a first computer readable program code means for enabling the computer system to invoke a method in an instance of a service application programming interface class instantiated in the computer system that performs the steps of:

(a) determining a type of environment in which said computer system is operative;

(b) if said computer system is operating in a client-server environment, then making a direct call to a service application programming interface; and

(c) if said computer system is operating in a three-tier environment, then sending a request to a server for remotely accessing a service application programming interface.

9. The computer program product of claim 8, wherein step (a) comprises the step of determining if a server address property in an instantiation of an environment class in said computer system is set to a default value.

10. The computer program product of claim 8, wherein step (c) comprises the step of sending a hypertext transfer protocol request to a web server.

1 1. A method for calling a service application programming interface, comprising the steps of:

(a) determining a type of environment in which a client workstation is operative;

(b) if said client workstation is operating in a client-server environment, then making a direct call to a service application programming interface;

(c) if the client workstation is operating in a three-tier environment, then sending a request to a server for remotely accessing a service application programming interface.

12. The method of claim 11 , wherein step (a) comprises the step of determining if a server address property is set to a default value.

13. The method of claim 11 , wherein step (c) comprises the step of sending a hypertext transfer protocol request to a web server.

14. A computer program product for enabling a processor in a computer system to call a service application programming interface, said computer program product comprising: a computer usable medium having computer readable program code means embodied in said medium for causing a program to execute on the computer system, said computer readable program code means comprising: a first computer readable program code means for enabling the computer system to determine a type of environment in which the computer system is operative; a second computer readable program code means for enabling the computer system to make a direct call to a service application programming interface if the computer system is operating in a client-server environment; and a third computer readable program code means for enabling the computer system to send a request to a server for remotely accessing a service application programming interface if the computer system is operating in a three-tier environment

15. The computer program product of claim 14, wherein said first computer readable program code means comprises computer readable program code means for determining if a server address property is set to a default value.

16. The computer program product of claim 14, wherein said third computer readable program code means comprises computer readable program code means for sending a hypertext transfer protocol request to a web server.