Understanding Open Server
With Customer Success Stories
Open Server is a toolkit for designing and implementing any kind of server application. The versatility that makes Open Server so powerful can make conceptualizing its uses difficult.
This white paper demystifies Open Server capabilities by outlining the technology and presenting customer success stories that illustrate the concepts. The success stories are selected from a large pool of submissions by users from many companies that describe innovative Open Server solutions.
After reading this paper, you will be able to envision the wide range of problems Open Server solves and you will understand why Open Server is the optimal server solution in the Sybase heterogeneous distributed-computing environment.
SYBASE, the SYBASE logo, APT-FORMS, Data Workbench, DBA Companion, Deft, GainExposure, GainInsight, Gain Momentum, SQL Debug, SQL Solutions, SQR, Transact-SQL, and VQL are registered trademarks of Sybase, Inc. Adaptable Windowing Environment, ADA Workbench, Application Manager, Applications from Models, APT-Build, APT-Edit, APT-Execute, APT-Library, APT-Translator, APT Workbench, Backup Server, Build Momentum, Camelot, Client/Server Architecture for the Online Enterprise, Client/Server for the Real World, Configurator, Connection Manager, CT-Library, Database Analyzer, DBA Companion Application Manager, DBA Companion Resource Manager, DB-Library, Deft Analyst, Deft Designer, Deft Educational, Deft Professional, Deft Trial, Developers Workbench, Easy SQR, Embedded SQL, Enterprise Builder, Enterprise Client/Server, Enterprise CONNECT, Enterprise Manager, Enterprise Meta Server, Enterprise Modeler, Enterprise Momentum, Enterprise SQL Server Manager, Gain, Gain Interplay, Gateway Manager, Intermedia Server, Maintenance Express, MAP, MethodSet, Movedb, Navigation Server, Navigation Server Manager, Net-Gateway, Net-Library, Object Momentum, OmniSQL Access Module, OmniCONNECT, OmniSQL Server, OmniSQL Toolkit, Open Client, Open Client/Server Interfaces, Open Gateway, Open Server, Open Solutions, Partnerships That Work, PC APT-Execute, PC DB-Net, PC Net Library, PostDoc, Replication Server, Replication Server Manager, Report-Execute, Report Workbench, Resource Manager, RW-Display Lib, RW-Library, Secure SQL Server, Secure SQL Toolset, SKILS, SQL Code Checker, SQL Edit, SQL Edit/TPU, SQL Server, SQL Server/CFT, SQL Server/DBM, SQL Server Manager, SQL Server Monitor, SQL Station, SQL Toolset, SQR Developers Kit, SQR Execute, SQR Toolkit, SQR Workbench, STEP, SYBASE Client/Server Interfaces, SYBASE Gateways, SYBASE Intermedia, Sybase Momentum, SYBASE SQL Lifecycle, Sybase Synergy Program, SYBASE Virtual Server Architecture, SYBASE User Workbench, SyBooks, System 10, Tabular Data Stream, The Enterprise Client/Server Company, The Online Information Center, and XA-Library are trademarks of Sybase, Inc. All other company and product names used herein may be the trademarks or registered trademarks of their respective companies.
Use, duplication, or disclosure by the government is subject to the restrictions set forth in subparagraph (c)(1)(ii) of DFARS 52.227-7013 for the DOD and as set forth in FAR 52.227-19(a)-(d) for civilian agencies. Sybase, Inc., 6475 Christie Avenue, Emeryville, CA 94608.
The client/server model is an increasingly popular way to implement distributed computing. It divides processing into client applications and server applications that cooperate to accomplish tasks for the application as a whole.
Client applications make requests for service; for example, a client application might request data from a database server. Another client might send a request to an environmental control server to lower the temperature in a room. Server applications receive requests and respond by returning data or other information to client applications, or by taking some action. For example, a database server returns tabular data and information to client applications and an electronic mail server directs incoming mail to its final destination.
The following figure depicts a common client/server interaction. In this example, the client application makes a request and delivers it to the server. The server application receives the request and processes it. The server then takes action and/or returns a result to the client. The client receives the result (if a result was returned) and process it.
Sybase is an industry leader in supplying database systems to the business, educational, and scientific communities. The foundation of the Sybase product line is a powerful and versatile client/server toolkit for distributed database systems designed to fully integrate user applications, SQL and non-SQL data sources, and application services regardless of hardware platform, operating system, or data format. At the heart of this toolkit, SYBASE Open Server is the engine that gives application programmers the flexibility to create solutions for an enormous range of distributed computing problems.
Sybase is the only software company that opens the door to the client/server communication path on the server side. Many companies offer the developer a client-side application programming interface (API), but Sybase's Open Server uniquely offers a server-side API.
The implication is that you can develop a custom server for any application or data source. Sybase offers Open Server as an integrated part of its distributed client/server product line, which includes SYBASE Open Client, a client API that you can use to access any client tool or application. The figure on the next page illustrates these ideas.
Creating a server application is a challenging development task. Not only must the server software meet client requirements, but it must perform many operating system responsibilities such as threading, network communication, and memory management.
Open Server is a highly-configurable server toolkit that greatly simplifies the design and implementation of server applications in the enterprise client/server environment.
The Open Server toolkit supplies a server infrastructure and the building blocks to create custom servers. Open Server reduces the server developer's job to one of designing software that meets client requirements while Open Server handles all the intricacies of lower- level processing. It offers a set of API functions through which the developer accesses a rich set of server features.
Open Server's ability to be any kind of server in any kind of client/server topology obviously is extremely valuable in and of itself. In addition to its ability to solve an enormous variety of server problems, Open Server can be the key component in making enterprise-wide client/server implementation possible at all.
Open Server also allows you to reuse the enterprise client/server infrastructure. For example, consider an enterprise with tens of thousands of workstations, each equipped with Open Client and a connection to the enterprise network. It is highly advantages to re- use the communication path for every service that each workstation requires rather than create new communication paths as each new service is added.
Open Server provides a mechanism for making all the workstations as standard and efficient as possible and delivers the ability to re-use the communication path in the enterprise client/server computing environment.
Typically, companies achieve client/server computing incrementally, starting out with a departmental implementation and expanding the model to an enterprise-wide scale over time. Ultimately, the goal is to make all applications work within the client/server model. The problem then becomes one of infrastructure. What infrastructure can you standardize on to make the client/server model successful in the overall enterprise?
One of the essential considerations in choosing a client/server infrastructure to support the enterprise is how well the infrastructure can integrate existing applications and data sources. If some applications or data reside on mainframe computers, and many do, choosing an infrastructure can be tricky.
Open Server runs on the mainframe and works conveniently as a tool for integrating the mainframe into the client/server model.
Client/server solutions provided by many vendors assume that companies will downsize from mainframes to minicomputers, workstations, and personal computers. This approach makes sense in many cases; however, there are many other companies for which mainframe applications continue to meet needs well. These companies would rather find a way to extend mainframe applications and provide access to legacy data within a client/server environment than to spend time and money converting all mainframe applications and migrating data to the smaller computer systems. The sentiment is, "why fix what isn't broken?"
Open Server offers enormous benefits by helping to build a client/server infrastructure that accommodates data and applications from a range of different sources. Many customers have adapted their mainframe applications to use the Open Server API thereby integrating legacy applications and data source into the client/server environment.
London Life Insurance Company of Canada is one example of a company that used Sybase and Open Server to integrate their enterprise systems and speed application development. London Life wanted to retain the mainframe for very high volume transaction processing and for primary data warehousing. They were able to use Sybase technology as a highly-critical mainframe link by combining Open Server for CICS, Net Gateway, and OmniSQL.
Sybase's open client/server infrastructure allowed London Life to provide easy mainframe access for diverse platforms, including DOS, Windows/NT, and the DEC environment.
London Life's director of information resource management, John Thompson, says "Our SYBASE system will eventually allow virtually any type of computer to access the mainframe and other networked resources¯that's a pretty powerful facility."
Sybase is the only major database vendor that offers a full compliment of products for implementing and maintaining enterprise-wide client/server solutions. Sybase uses its own architecture to build new products quickly to meet market needs. Rather than re-inventing or re-building the underlying communications infrastructure every time it builds a new product, Sybase uses its published Open Server and Open Client APIs in the same way that Sybase customers do. For example, Replication Server, OmniCONNECT, Net-Gateway, DirectCONNECT, Navigation Server, Backup Server, Audit Server, and SQL Monitor are SYBASE System 10 products built with Open Server.
Figure 3 illustrates the relationship between some of the products in the integrated Sybase product environment. The list below describes them.
It is possible to put together an enterprise-wide client/server infrastructure with similar components by mixing and matching from various vendors. For example, a company can acquire the peer- to-peer middleware pipe, a UNIX TP monitor, a database, various ODBC drivers, a set of system management tools, and gateways to the different data sources, all from different vendors.
By the time the enterprise-wide client/server infrastructure is set up, the company will be working with six to ten vendors. The IS staff will have to learn eight or nine different technologies that were not designed and tested as an integrated unit and there will undoubtedly be support issues.
On the other hand, companies that choose the SYBASE enterprise- wide client/server infrastructure, work with one vendor and acquire a suite of products built on a common architectural framework engineered and tested to work in harmony. The IS staff in charge of the Sybase enterprise-wide client/server implementation needs only to learn Open Client Client-Library, Transact SQL, and the Open Server API. Once they understand those three technologies, they have most of the knowledge they need to leverage the entire Sybase mechanism.
When developers design and implement software using a component model, they create self-contained software blocks or components, each with a specific function. A component can be replaced by another that has the same specifications without rewriting or changing surrounding components. This component model for software design also results in the ability to re-use components.
Three-tier architecture, based on the component model, is emerging as a popular design solution for large or complex server applications that run under some type of middleware such as a transaction processing monitor or an object-oriented environment. Because it is based on the component model, the three-tier architecture allows the flexibility and freedom to replace components without affecting the rest of the system.
Sybase is the only database company that makes it easy to implement an independent application in the middle tier of a three- tier software architecture. Figure 4 illustrates the topology using Sybase products.
The functionality of each tier is as follows:
Three-tier architecture gives the application complete independence with respect to both the front-end tool and the back-end datastore and makes it easy to extend database functionality. Many MIS developers find the three-tier construct imperative.
In environments that do not support a three-tier topology, developers must integrate business rules, for example, either in the front-end tool or the back-end datastore. Business rules can be integrated with the back-end datastore by programming them in stored procedures or a trigger, a special kind of stored procedure that automatically executes whenever data is inserted, updated, or deleted in the columns with which the trigger is associated. Programming business rules in triggers results in dependence on the datastore.
This section provides a context for understanding Open Server architecture and describes the components that make up the Open Server toolkit.
Open Server infrastructure is based on SQL Server architecture. As Figure 5 suggests, Open Server has the same input/output strategy, kernel functionality, and network components as SQL Server. SQL Server contains additional functionality for query processing (SQL processing and storing and receiving data) and transaction management. Both Open Server and SQL Server provide access to their functionality through API function calls.
Open Server's Server-Library interface is the only API designed to parallel the Open Client architecture and feature set and to take advantage of the full suite of Sybase products.
Open Server architecture is based on the ISO/OSI Reference Model of functional layering.
Figure 6 shows the makeup of the Open Server toolkit, which includes server-customization components, Open Server components, and network components.
Sybase provides software for all of the components shown in gray. It also possesses the capability to process event handlers and registered procedures (developed by the application programmer) that customize the server so it fulfills specific client requirements.
The rest of this section outlines the Open Server toolkit components.
Event handlers and registered procedures are Open Server building blocks for customizing servers to meet the needs of specific clients. These are the only components for which the server developer is responsible. Figure 7 highlights the server-customization components.
Generally, a server application does not perform any autonomous work. Most of the time, it responds to various events¯occurrences that prompt a server to take action. When the client application has a request, it can trigger an event. The Open Server kernel uses the event mechanism as well. For example, when a client connects to an Open Server, it generates a CONNECT event. When a client logs off, the Open Server kernel raises a DISCONNECT event.
The Open Server event model allows Open Server programmers to install custom routines, or event handlers, that run when a specific Open Server event occurs. Open Server provides the mechanism by which handler routines are triggered when events occur.
The event model encourages the developer to write modular programs because each event must be specifically handled by a separate routine. These routines can then be easily replaced or re- used as necessary.
Instead of requiring that the front-end application pass the same block of SQL commands to the server over and over again, that block may be stored and reused. Registered procedures stored on the Open Server are the mechanisms that provide this capability. (Stored procedures are the SQL Server counterpart to registered procedures.)
Both registered and stored procedures are good methods for promoting portability because only one version of the procedure is accessible to all users. Registered and stored procedures improve database performance because the procedure is right where it is needed and can be run there. They help with network performance because clients send only a single command to the server rather than the entire procedure.
Registered procedures are C-language procedures installed by the Open Server application programmer. A client application registers the procedure with Open Server and later invokes it by issuing a remote procedure call (RPC) to Open Server.
Traditionally, RPCs are a SQL Server capability related to both stored procedures and triggers. RPCs are used to execute stored procedures, and they are SQL Server's primary method of creating a distributed database system.
Open Server components include the kernel, Server-Library, and the Internal SYBASE Libraries. Figure 8 highlights the Open Server components.
The Open Server core kernel functionality is modeled directly from the SQL Server kernel. It incorporates threads, notification, internationalization, error logging, and debugging.
- Threads. Open Server is a single process, multithreaded system that ultimately provides better performance because it makes more efficient use of system resources. Servers must be able to handle multiple client requests simultaneously. A fully loaded server can have hundreds of clients connected at the same time, yet must run as a single operating-system process. To manage multiple clients, Open Server implements each client as a separate "thread of control" on the same process. Each thread has a private data space in which Open Server stores the state of that particular client connection.
- Notification Procedures. Situations commonly arise in which a client application needs to know when a particular event occurs. For instance, an investment application might need to know when a stock reaches a specified price so it can place an order to sell. Applications can learn of events by polling a central database server for changes in status, but the resulting large number of client queries can be a significant strain on the server. It is more practical for the server to simply notify interested clients when there is a change in status. Open Server offers notification procedures, which are much more preferable than polling.
Client applications can use notification procedures to notify applications of changes with the Open Server application, communicate between clients in a cooperative processing environment, synchronize communication between Open Client applications and Open Server applications.
- Internationalization. Open Server provides support for international applications by allowing the application to localize. A localized application typically generates error messages in a local language and character set, uses local datetime formats, and uses a specific character set and collating sequence (also called "sort order") when converting or comparing strings. Open Server applications can support localized clients. A localized client uses the language, datetime formats, and character set of its choice. These may differ from the Open Server application's language, datetime formats, and character set.
- Error Logging. Open Server's default response to errors is to write error messages to the log file. An application can tailor this response by installing an error handling routine. Typically, an error handler detects the type and severity of an error, and takes a specific action based on these values. For example, an application might want to send particular errors to a client, while writing others to a log file.
- Debugging. Open Server implements debug trace flags. When developing applications, it is very important to integrate these trace flags as much as possible. The two types of trace flags are those which the program can activate, and those available with predefined registered procedures designed for debugging.
Server-Library routines are a toolset for designing Open Server applications that take advantage of the features of distributed client/server architecture. The use of Server-Library defines an application as an Open Server application. Open Server applications can access data stored in foreign database management systems, trigger external events, and respond to Open Client applications.
Internal SYBASE libraries include SYBASE CS-Library and utilities that both clients and servers can use, such as internationalization routines and shared internal routines. The internal SYBASE libraries also include bulk copy routines, which are used as a tool for high- speed data transfer between a database table and program variables.
CS-Library is a collection of utility routines that support datatype conversion, arithmetic operations, character set conversion, datetime operations, sort order operations, and localized error messages.
Open Server's network protocol architecture provides highly effective cross-platform communication. In a homogeneous computing environment, communication between nodes might not be a problem, but when hardware architectures differ from one node to the next, network architecture becomes a very complicated issue.
Open Server connectivity between different platforms is already worked out, so application programmers need only be concerned with application software and not the system-level intricacies of the network protocol.
Figure 9 highlights the network components.
The generic APIs layer performs implementation-specific work and defines private interfaces that allow access to transport services and to the Net-Library drivers.
The Net-Library Interface is an API that provides a generalized solution to network I/O while supporting a variety of operating systems and network topologies, protocols, and vendors.
The Net-Library Drivers implement mapping between the Net- Library Interface
