Glossary
 |
 |
Click a letter in the glossary index. Or use the Page Down key, the Page Up key, the arrow keys, or the scroll bar to navigate. Please contact us if you know of a relevant term that is not defined in this glossary.
Terminate a transaction in such a way that the values assigned to all protected resources, such as database records, are unchanged from the beginning of the transaction.
(CORBA) An object identifier (OID) that specifies a unique path to a managed object from the root of the OID tree.
Abstract Syntax Notation One (ASN.1)
A formal notation used to define data types and encode data values. A language that describes the data structures that make up an abstract syntax. ITU-T (formerly CCITT) specification X.409 is equivalent to ASN.1. ASN.1 Distinguished Encoding Rules (DER) object identifiers are used in public key interface (PKI) security programming.
A BEA Tuxedo security feature that controls client access to services, objects, and methods by means of lists of clients that are authorized to receive specific services or invoke specific objects and methods. When ACL security is being used, the BEA Tuxedo system checks the appropriate list whenever a client requests a service, to determine whether the client is authorized to access the service.
(CORBA) The object in the security infrastructure of a CORBA application that enforces the checking of authorized access before a request to the target object is delivered.
The processor within the administrative domain of an application at which a client first accesses the system. For a native client, this is the processor on which it is running. For a Workstation client, this is the site at which it contacts the application.
The essential characteristics of transaction processing systems include the following:
See access control list (ACL).
(ATMI) To move a server from the inactive (unavailable) state to the state in which it is up and running (active).
(CORBA) To prepare an object for execution.
(CORBA) The policy that determines the in-memory activation duration for a CORBA object.
See also activate, CORBA object, and policy.
(CORBA) A running instance of an object interface.
See also active object map, client application, CORBA object, object ID (OID), object reference, Portable Object Adapter (POA), and servant.
(CORBA) A table maintained by a POA and the TP Framework that maps the association of object IDs to servants.
See also object ID (OID), Portable Object Adapter (POA), and servant.
A BEA Tuxedo server that is either processing a service request or is available to do so.
See application development environment (ADE).
An application programming interface for writing programs that configure and control a BEA Tuxedo application by setting and changing attribute values in the Management Information Base (MIB). It can be used by both ATMI and CORBA programmers.
That portion of an application that is actively administered at run time by a Bulletin Board Liaison (BBL) process. It does not include workstations or host processors.
The person who installs the BEA Tuxedo system, configures and monitors a BEA Tuxedo application, and updates application information, such as computer names and locations.
A service is advertised when a service table entry exists for it in the BEA Tuxedo bulletin board. When a Domains gateway server is booted, it advertises all the remote services that it is importing from remote domains in the bulletin board of the local domain (that is, the domain on which the gateway server is booted). After a remote service is advertised by a domain gateway server, it remains advertised until either an unadvertise command is issued or a MIB request removes the service.
See application entity qualifier (AEQ).
See application entity title (AET).
A model where a manager communicates with many distributed agents through a system management protocol.
A means of reporting that a managed object is in an abnormal state (that is, a managed object has passed a predefined threshold).
The assignment of various types of programs and record categories for system storage locations, such as main storage or disk storage.
In distributed transaction programming, a session that a transaction obtains by means of an ALLOCATE command.
A remote domain that is used when a primary remote domain is unavailable.
See application programming interface (API).
An interactive Java program that can be run via a Web page displayed by a Java-capable browser. An applet enhances the Web page's display or enables the user to complete a task.
A business program, built around the BEA Tuxedo system, that is defined and controlled by a single BEA Tuxedo configuration file, and that is administered as a single entity. Such an application may comprise one or more clients (local or remote), one or more servers, and one or more machines. At a minimum, a BEA Tuxedo application includes one machine, one server, and one client. Also referred to as a BEA Tuxedo domain.
Multiple BEA Tuxedo applications can communicate with each other through a domain gateway group.
Note: In this context, the term business program is defined as a set of one or more programs that work together. Similarly, in conversation the term application is often used loosely: it may refer to a standalone program or to a set of programs that work together to accomplish a particular business objective.
See TUXCONFIG file and UBBCONFIG file.
The association between a process and a BEA Tuxedo application (domain). A multicontexted process may have associations with multiple BEA Tuxedo domains. It may also have multiple associations with the same domain.
Code that is written by the user, as opposed to system code that is provided by BEA Systems, Inc.
(ATMI) A reference to a particular application association. In the BEA Tuxedo system, an application context is set via an explicit call and is then used implicitly by subsequent ATMI calls. Thus, in an implicit context interface, the terms application context and default context are often used interchangeably.
application context name (ACN)
A set of rules that govern associations between application entities.
application-controlled deactivation
(CORBA) A feature used with the process activation policy to keep an object active in memory until the application explicitly deactivates the object by invoking the TP::deactivateEnable() operation on that object.
application development environment (ADE)
A set of tools (often presented or accessed via a GUI) to help programmers build applications.
A set of software components that make up a distributed transaction processing application on one computer system.
application entity qualifier (AEQ)
The locally unique component of a title that is used to identify an OSI TP application entity.
application entity title (AET)
The globally unique component of the title that is used to identify an OSI TP application entity.
The software that provides the infrastructure that makes it possible for sets of applications or other software components to work together.
A single instance of a user program that performs one or more specific tasks. An AP defines transaction boundaries and accesses resources within those boundaries; it interacts with other system components using interfaces specified in the X/Open Distributed Transaction Processing model. An AP is a single thread of control involved in, at most, one global transaction at any time.
application programming interface (API)
Application-to-Transaction Monitor Interface (ATMI)
The Application-to-Transaction Monitor Interface is the application programming interface to the BEA Tuxedo system. It includes transaction routines, message handling routines, service interface routines, and buffer management routines.
See Abstract Syntax Notation One (ASN.1).
An encryption algorithm that has two keys: a public key and a private key. The public key can be distributed openly while the private key is kept secret. Asymmetric algorithms may be capable of a number of operations, including encryption, digital signatures, and key agreements.
An event that occurs at a time that is unrelated to the time at which another event occurs. The two events are mutually asynchronous. The relationship between the times at which they occur is unpredictable.
Virtual circuits set up to execute independently of each other, that is, asynchronously. An asynchronous connection does not block the processing of working circuits while attempts are being made to reconnect failed circuits. The BRIDGE allows the use of nonfailing network paths by listening and transferring data using multiple network address endpoints.
A process that executes independently of another process. When a request is processed asynchronously, the client application continues to perform other operations while it waits for the service request to be filled.
A request that lets the client do other work while the request is being processed, enhancing parallelism within an application.
See Application-to-Transaction Monitor Interface (ATMI).
A behavior of SNMP agents that operates as follows: When an SNMP agent receives an SNMP set request that contains more than one variable, the agent either sets all requested objects or sets none. This behavior is a requirement of the SNMP standard.
(CORBA) An identifiable association between an object and a value.
When using OMG IDL, that part of an OMG IDL interface that is similar to a public class field or data member. The compiler maps an OMG IDL attribute to accessor and modifier methods in either the C++ or Java programming language. For example, an interface ball might include the attribute color. The idltojava compiler would generate a C++ or Java programming language method to get the color, and, unless the attribute is read-only, would generate a method to set the color. CORBA attributes correspond closely to JavaBeans properties.
See CORBA object and object.
A security mechanism that involves saving a secure, tamper-resistant record of requested system operations, along with the identity of the requesting party.
A manual or computerized means for tracing the transactions affecting the contents of a record.
The process used by the server to verify the identity of an entity, such as a user or a process, before allowing that user or process to join an application. This process relies on the use of passwords and other security mechanisms.
The process of determining which services may be accessed by a particular entity, such as a user or a process, and giving the entity permission to access those services.
A method of creating and installing terminal definitions dynamically (that is, as terminals log on) and deleting them when logging off.
The creation, by a BEA Tuxedo application server, of new threads to handle messages as they are received. The number of new threads that can be created is restricted by a configurable limit.
Features of transaction processing systems that contribute to the smooth, continued systems operation in the presence of failures.
The act of a resource manager in using a log to restore resources to some predetermined state by applying log entries sequentially to the resource until the desired state has been achieved.
The transmission capacity of a computer or communications channel.
See Bulletin Board Liaison (BBL).
A Web-based, graphical user interface for the remote administration of BEA Tuxedo applications (running in either ATMI or CORBA environments). It is delivered as a Java applet that you can download into your Internet browser.
See transaction processing (TP).
(ATMI) Formerly JoltWAS for Servlet.
BEA Tuxedo-WebLogic Connectivity
Formerly JoltWAS for WebLogic. A customized version of BEA Tuxedo-JSE Connectivity for WebLogic.
A BEA Tuxedo domain consists of a BEA Tuxedo application running one or more business applications. A single domain is defined in one configuration file and is administered as a single entity. A domain can be connected to other BEA Tuxedo domains through the Domains feature.
See also domain, TUXCONFIG file, and UBBCONFIG file.
A BEA Tuxedo component that extends the BEA Tuxedo system client/server model to provide transaction interoperability across TP domains. This extension preserves the client/server model and the ATMI interface by making access to services on a remote domain (and service requests from a remote domain) transparent to both the application programmer and user.
A program that performs a task requested of it by a client application.
A robust e-commerce platform from BEA Systems, Inc. for developing and deploying business-critical client/server applications. It handles distributed transaction processing, application messaging, and the full complement of services necessary to build and run enterprise-wide applications.
(CORBA) An application programming interface designed to simplify the implementation of callback objects for CORBA joint client/server applications. The API provides specific methods for defining, starting, stopping, and destroying callbacks objects.
See also application programming interface (API), Callbacks Wrapper object, CORBA callback object, and joint client/server application.
(CORBA) The process of associating a name with an application object or a naming context object. Also used to describe the process of connecting a client application to an application object.
In temporary storage, a control block used by intrapartition transient data to show the VSAM control intervals that have been used and are available. It is updated whenever a control interval or track is assigned to or released from a destination.
The process of combining two or more records into one block.
A synchronous style of message delivery, where a program must wait for an action to complete before the program can proceed. Contrast with nonblocking mode.
Bootstrap environmental object
(CORBA) The object that brings a CORBA application into a BEA Tuxedo domain and provides initial object references to that application. Every CORBA client or server application that interacts with a BEA Tuxedo domain needs a Bootstrap environmental object.
See environmental object, object, object reference, and CORBA domain.
(CORBA) The process of setting up an application to interact with CORBA objects that are located within a BEA Tuxedo domain.
See also Bootstrap environmental object, CORBA object, and CORBA domain.
The BEA Tuxedo system process that maintains virtual circuits to other nodes participating in an application for the purpose of transferring application messages between the nodes.
To send the same message to every node on a network.
A system-level entity whose role is to maintain subscriptions and to cause subscribers' actions to occur when events are posted.
An abstract name for a message type. BEA Tuxedo provides predefined types for message communication: FML, VIEW, STRING, CARRAY, and XML. These buffer types are transparently encoded and decoded across a network of heterogeneous machines. Applications can define additional types.
A collection of shared data structures designed to keep track of a running BEA Tuxedo system application. It contains information about servers, services, clients, and transactions pertaining to a BEA Tuxedo application. The bulletin board is replicated on each logical native (non-foreign) machine in the application.
A BEA Tuxedo administrative process responsible for maintaining a copy of the bulletin board on a particular processor. When the system is running, one BBL process runs continuously on each logical machine in the application.
(CORBA) An application-level component that can be used in combinations that may not be defined ahead of time. A business object is independent of any single application and represents a recognizable, everyday-life entity, such as a document processor. A business object is a self-contained deliverable that has a user interface and a state, and that can cooperate with other separately developed business objects to perform a desired task.
A sequence of eight adjacent bits that are operated on as a unit.
An object-oriented programming language developed at AT&T Bell Laboratories in the early 1980s. C++ is a "hybrid" language based on the non-object-oriented C language.
A subset of memory that contains copies of the frequently accessed parts of a larger memory.
A method that is implemented by application code and that is invoked by system code when needed to perform a specific function. Callback methods are never intended to be invoked directly by application code.
See also application code and metadata interface.
(CORBA) An object implemented to support callbacks on CORBA joint client/server applications using the BEA Wrapper Callbacks API.
See BEA Wrapper Callbacks API, callback method, CORBA callback object, joint client/server application, and object.
A data structure that is an array of characters any of which can be the null character. The interpretation of the array is entirely application dependent.
The Commitment, Concurrency, and Recovery OSI standard.
A digital statement that associates a particular public key with a name or other attributes. The statement is digitally signed by a certificate authority (CA). By trusting that authority to sign only true statements, you can trust that the public key belongs to the person named in the certificate.
See also certificate authority (CA).
A method that provides confident identification of a client by a server through the use of digital certificates. Certificate-based authentication is generally preferred over password-based authentication because it is based on what the user has (the private key) as well as what the user knows (the password that protects the private key).
See authentication and certificate.
A well-known and trusted entity that issues public key certificates. A certificate authority attests to a user's real-world identity, somewhat like a notary public.
A functional unit, controlled by a processor, that handles the transfer of data between the processor and local input/output devices.
In cryptography, a coding system used to create encrypted messages.
An SSL encryption method that includes the key exchange algorithm, the symmetric encryption algorithm, and the secure hash algorithm used to protect the integrity of the communication.
See also Secure Sockets Layer (SSL).
In cryptography, text that is encrypted.
(CORBA) In Java, a type that defines the implementation of a particular kind of object. A class definition defines instances and class variables and methods, and specifies the interfaces and class implementations and the immediate superclass of the class. If the superclass is not explicitly specified, the superclass will implicitly be Object.
See also IDL interface, instance, Java, metadata interface, and object.
A set of client programming tools. These tools can be used in a Java or C++ program or Web page-embeddable Java applet.
(ATMI) A program that performs the following steps:
1. Collects, through a user interface, requests for services from users.
2. Transmits those requests to servers.
3. Receives the servers' responses and passes them to the users.
If a client is located on a machine that is part of the domain to which the target servers belong, then the client is called a native client. If the client is located on a machine that is outside that domain, then the client is called a remote client or a Workstation client. Remote clients communicate with servers through the BEA Tuxedo Workstation component.
(CORBA) Any code that invokes an operation on a distributed object.
See also application, server, and Workstation.
A program, written for use with the BEA Tuxedo software, that requests services from other applications.
Client Data Caching design pattern
(CORBA) The design pattern that provides increased performance for client applications by caching server application data on the machine on which the client application resides, thereby avoiding repeated remote calls to retrieve data.
A BEA Tuxedo feature that enables client programs to carry both usernames and client name values.
A programming model in which application programs are structured as clients or servers to achieve distributed processing. A client program is an application program that requests services to be performed. A server program is an entity that dispatches service routines to satisfy requests from client programs. A service routine is an application program module that performs one or more specific functions on behalf of client programs.
Client/server computing can be configured in a 2-tier or a 3-tier structure. A 2-tier configuration consists of only the client and the server. A 3-tier configuration includes a client, a server, and an intermediate level that acts as a router or a broker.
A software infrastructure in which developers cannot remove and replace software components easily in a plug-and-play fashion.
See Common Management Interface Protocol (CMIP).
A MIB leaf object—that is, a MIB object that does not have any objects below it in the OID tree—which can have zero or more instances. A columnar object represents one column in a table.
See Component Object Model (COM).
(CORBA) A representation of an object that conforms to the Component Object Model (COM) standards, including implementations of all necessary interfaces.
See also Component Object Model (COM), interface, and object.
A style of user interface that allows user interaction by entering commands at a system prompt.
Common Management Interface Protocol (CMIP)
An protocol for network management defined by ISO standards.
Common Object Request Broker Architecture
compact disc-read only memory (CD-ROM)
A disk from which data is read optically by laser and on which the data cannot be modified except under special conditions.
(CORBA) A collection of services that let software components interoperate in a networked environment.
See also COM view, conversation, and object.
The simultaneous execution of more than one function or process.
Pertaining to the occurrence of two or more activities within a given interval of time. Concurrent processes can alternately use shared common resources.
The set of hardware, hardware options, software, and software setup on a computer or on a network.
The name or the number used to reference a particular configuration in a configuration partition. Each configuration set describes the services to be used when the configuration is active.
To customize hardware and software for a computer or for a network.
A half-duplex communication channel between processes.
connection-oriented communication
Communication between two BEA Tuxedo system processes over a connection.
A condition in which shared data is correct and valid.
(CORBA) A pseudo-method that creates an object. In Java, constructors are instance methods with the same name as their class. Java constructors are invoked using the new keyword.
See also class, instance, Java, metadata interface, and object.
Communication characterized by one or more messages exchanged by a requestor and a server such that the server remains dedicated to the communication until the termination of the exchange.
A server that offers services that require a connection to have a conversation with the requester. The conversation follows an application-established protocol. A conversational service must conform to the startup and termination rules of BEA Tuxedo system services.
A service routine that is invoked by means of conversational communication from a client program. When the connection is established and the service is invoked, the client and service exchange data in a manner specific to the application. When the service returns, the connection ends.
(CORBA) Common Object Request Broker Architecture. A multivendor standard published by the Object Management Group for distributed object-oriented computing.
(CORBA) A CORBA object supplied as a parameter in a client application's invocation on a target object. The target object can make invocations on the callback object either during the execution of the target object or at some later time (even after the invocation on the target object has been completed). A callback object might be located inside or outside a BEA Tuxedo domain.
See also client application, CORBA object, and BEA Tuxedo domain.
When using CORBA objects, a file created by the IDL compiler when you compile an application's OMG IDL statements. The client stub contains code that is generated during the client application build process. The client stub maps OMG IDL operation definitions for an object type to the methods in the server application that the BEA Tuxedo domain calls when it invokes a request. The code is used to send the request to the CORBA server application.
When using OMG IDL, a C++ or Java programming language class created by the compiler and used transparently by the client ORB during object invocation. The remote object reference held by the client points to the client stub. This stub is specific to the IDL interface from which it was generated, and contains the information needed for the client to invoke a method on the CORBA object defined in the IDL interface.
See also metadata interface, OMG IDL, skeleton, and BEA Tuxedo domain.
A collection of CORBA or ATMI servers, services, interfaces, machines, and associated resource managers defined by a single UBBCONFIG (ASCII version) or TUXCONFIG (binary version) configuration.
See also TUXCONFIG file and UBBCONFIG file.
CORBA foreign client application
(CORBA) A client application that is implemented on an ORB that is not a product of BEA Systems, Inc.
See ORB.
(CORBA) A set of operations and attributes. A CORBA interface is defined by using OMG IDL statements to create an interface definition. The definition contains operations and attributes that can be used to manipulate an object.
See also attribute, interface, object, OMG IDL, and operation.
CORBA native client application
(CORBA) A client application that invokes operations defined in OMG IDL statements to talk to CORBA server applications. Relative to the CORBA domain to which the server applications belong, a client application is either native (that is, local) or remote. Remote and native client applications are the same. Their requests are handled differently and transparently, depending on whether or not the applications are collocated on a machine that is running in the CORBA domain. CORBA native client applications are always collocated on a machine in the CORBA domain.
See also CORBA domain, CORBA foreign client application, CORBA remote client application, CORBA server application, and OMG IDL.
(CORBA) An entity that complies with the CORBA standard upon which operations are performed. An object is defined by its interface.
See also interface, object, and operation.
(CORBA) Any Object Request Broker (ORB) that complies with the CORBA standard. A CORBA ORB is a communications intermediary between client and server applications that are distributed across a network. The ORB used in BEA Tuxedo applications is a CORBA ORB.
CORBA remote client application
(CORBA) A client application that invokes operations defined in OMG IDL statements to talk to remote CORBA server applications using IIOP. Remote and native client applications are the same. Their requests are handled differently and transparently, depending on whether or not the applications are collocated on a machine that is running in the CORBA domain. CORBA remote client applications are typically not located on a machine that is running in the CORBA domain.
See IIOP, OMG IDL, CORBA domain, CORBA foreign client application, and CORBA native client application.
(CORBA) A program that performs a task requested of it by a client application and that is written to be used with the BEA Tuxedo CORBA software.
(CORBA) Run-time library of default implementations that the CORBA server application build procedure links to the server application executable image. The Transaction Processing (TP) Framework consists of a set of convenience functions that make it easy for you to write code that does the following:
Initializes the server application and executes startup and shutdown routines.
Ties the server application to CORBA domain resources.
Manages objects, bringing them into memory when needed, flushing them from memory when no longer needed, and managing reading and writing of data for persistent objects.
See CORBA domain and CORBA server application.
(CORBA) The adopted OMG Common Facilities. Common Facilities provide horizontal end-user-oriented frameworks that are applicable to most applications, and are defined in OMG IDL.
(CORBA) A set of system services for objects that were developed for the programmer. These services, defined in OMG IDL by the OMG, can be used to create objects, control access to objects, track objects and object references, and control the relationship between types of objects. Programmers can call object service functions instead of writing and calling their own private object service functions.
See also CORBA object, CORBAservices Life Cycle Service, CORBAservices Naming Service, CORBAservices Object Transaction Service (OTS), CORBAservices Security Service, object, object reference, and OMG IDL.
CORBAservices Life Cycle Service
(CORBA) The CORBAservice that defines conventions for creating, deleting, copying, and moving objects.
See also CORBAservices and object.
(CORBA) The CORBAservice that provides the ability to associate a name to an object relative to a naming context.
See also CORBAservices and object.
CORBAservices Object Transaction Service (OTS)
(CORBA) The CORBAservice that provides transaction semantics to ensure the integrity of data in the system.
CORBAservices Security Service
(CORBA) The CORBAservice that defines identification and authentication of principals, authorization and access control, security auditing, security of communication between objects, nonrepudiation, and administration of security information.
See also authentication, authorization, Callbacks Wrapper object, and object.
(CORBA) A public class (or interface) that is a standard member of the Java platform. The intent is that the Java core classes, at a minimum, are available on all operating systems on which the Java platform runs.
See also class, interface, and Java.
Information that describes the security attributes (identity and/or privileges) of a user or other principal. Credentials are claimed through authentication or delegation and are used by access control.
(CORBA) The object that holds the security attributes of a principal. These security attributes include the principal's authenticated or unauthenticated identities. The Credentials object also contains information for establishing security associations. The Credentials object provides methods to obtain the security attributes of the principals it represents.
See also attribute, metadata interface, and object.
The art of protecting information by transforming it (encrypting it) into an unreadable format, called ciphertext. Only those who possess a secret key can decipher (or decrypt) the message into plaintext.
See also ciphertext and plaintext.
The API for the BEA TOP END system.
(ATMI) Clients may initialize to multiple contexts; however, at any given time, in any particular thread, only one of these contexts may be the current context.
(CORBA) A special type of ORB object that is used to communicate between a user application and a specialized built-in service.
See also CORBA ORB, object, SecurityCurrent, and TransactionCurrent.
(ATMI) A Java GUI class that communicates with JoltBeans. The means of communication can be JavaBeans events, methods, or properties offered by JoltBeans.
A system process that runs in the background.
See Direct Access Storage Device (DASD).
A collection of interrelated or independent data items stored together without redundancy to serve one or more applications.
database management system (DBMS)
A program or set of programs that lets users structure and manipulate the data in the tables of a database. A DBMS ensures privacy, recovery, and integrity of data in a multi-user environment.
Data Encryption Standard (DES)
A symmetric key algorithm adopted by the U.S. government in 1976 as a standard encryption-decryption system for unclassified data in the United States. Several types of DES are offered, including DES-CBC and two-key triple-DES.
The ability to request data by a high-level data-management method without concern as to how the data is stored or retrieved.
A set of rules for transforming data of a particular buffer type from one representation into another.
See Distinguished Bulletin Board Liaison (DBBL).
See database management system (DBMS).
See Dynamic Data Exchange (DDE).
The sending and receiving of DDE messages between a client application and a server application.
The conversion of encoded data back to the native format.
The process of restoring encrypted data to its original form.
An algorithm that reverses the work of the encryption algorithm.
The value assumed by a program if a value is not supplied by the user.
A BEA Tuxedo application association that is referenced by subsequent ATMI calls if tpsetctxt() is not called. The default context may differ from thread to thread. This term is often used interchangeably with application context.
deferred synchronous communication
A form of asynchronous communication in which one piece of software can send a message to another piece of software, and then continue to work and retrieve the reply to the message at some later time.
The process of placing an application in a distributed environment and making the application available for use. Deployment can include such tasks as installation, configuration, and administration of various parts of the application.
See Data Encryption Standard (DES).
The document written by the system integrator that explains the overall design of the application or the framework to be built.
A document that encapsulates, in a structured format, solutions to design problems. Design patterns are guides to good design practices.
See also Client Data Caching design pattern and Process-Entity design pattern.
(CORBA) A CORBA client application that operates on a Microsoft desktop platform, such as Windows XP. Desktop client applications use the Component Object Model (COM) and communicate with the BEA Tuxedo domain.
See Component Object Model (COM), conversation, and application.
A process of sending and receiving information.
An electronic file used to identify individuals and resources over networks such as the Internet. A digital certificate securely binds the identity of an individual or resource, as verified by a trusted third party known as a Certificate Authority, to a particular public key. Because no two public keys are ever identical, a public key can be used to identify its owner.
BEA Tuxedo public key security recognizes certificates that comply with X.509 version 3.0.
A digital code, attached to an electronically transmitted message, that uniquely identifies the sender and that can, therefore, be used to authenticate the identity of the sender. When a message is authenticated, verification is provided that: (1) the message is genuine; (2) the message has arrived exactly as it was sent; and (3) the message has come from the stated source.
Digital signatures are especially important for electronic commerce and are a key component of most authentication schemes. The recipient of signed data can use a digital signature to prove to a third party that the signature was, in fact, generated by the signatory. When such proof is provided, the signed data is protected by nonrepudiation: the signatory cannot, at a later time, deny authorship of the signature.
An algorithm that transforms a message of any length to a digital signature in such a way that it is computationally infeasible to (1) find two messages with the same digital signature, (2) produce a message from a given, predetermined digital signature, or (3) find the digital signature of a given message without knowledge of the sender's private key. Typically, a digital signature algorithm is implemented by computing a message digest on the message, then encrypting the message digest with the sender's private key.
An example of a digital signature algorithm is DSA.
See Dynamic Invocation Interface (DII).
Direct Access Storage Device (DASD)
A disk, disk drive, or group of disks or drives on an IBM machine.
Distinguished Bulletin Board Liaison (DBBL)
A BEA Tuxedo administrative process that runs on the MASTER node of the application and communicates with BBLs to coordinate updates to the bulletin board.
(CORBA) A distinguished name (DN) is an entry in the Directory Information Tree (DIT) that uniquely identifies an object in an X.500 directory.
An application that is separated into two or more parts (such as a client and a server) on different computers that communicate through a network.
An application design and implementation strategy that separates an application into units that are executed on different computers and communicate through a network. For example, an application can be separated into three distributed units: a user interface unit, a processing unit, and a storage unit.
(CORBA) An object that can live anywhere on a network. Distributed objects are packaged as independent pieces of code that can be accessed by remote clients via method invocations. The language and compiler used to create distributed objects are totally transparent to the clients. Clients do not need to know where the distributed object resides or what operating system executes on it.
Distributed Program Interface (DPI)
The Distributed Program Interface (DPI) protocol extension to SNMP agents. Permits end-users to dynamically add, delete or replace variables in the local MIB without recompiling the SNMP agent, by creating a subagent that communicates with the agent via the SNMP-DPI protocol.
A transaction involving multiple transaction managers. In a distributed transaction environment, a client application may send requests to several servers resulting in resource updates at multiple resource managers. To complete the transaction, the transaction manager for each participant (client, servers, and resource managers) must be polled to coordinate the commit process for each participant within its domain.
distributed transaction processing (DTP)
A form of processing in which multiple application programs update multiple resources (such as databases) in a coordinated manner. Programs and resources can reside on one or more computers access a network.
See dynamic link library (DLL).
Domain Configuration (DMCONFIG) File
The file that describes the relationship between the local domain (the domain in which the DMCONFIG file resides) and remote domains (any other domains). There is one DMCONFIG file per domain. The DMCONFIG file contains domain information for BEA Tuxedo domains.
A highly asynchronous multitasking server provided by the BEA Tuxedo system to process service requests to and from remote domains. The gateway makes access to services on a remote domain (and service requests from a remote domain) transparent to both the application programmer and the user.
A BEA Tuxedo system component that provides a framework for interoperability among multiple domains. The framework consists of the following:
The restoration of message traffic to a primary remote domain. The TDomain gateway always tries to use the primary domain or the highest-level alternate remote domain defined for a service. When these domains become unavailable (due to circuit failure or other reasons), the gateway transfers message traffic to a lower-priority alternate remote domain, and periodically checks the availability of the primary remote domain and the highest-level alternate remote domain. When possible, the gateway restores message traffic to the primary remote domain or the highest-level remote domain.
See domain gateway and TDomain gateway.
The transfer of message traffic to an alternate remote domain when a primary remote domain fails.
A convention for expressing IP addresses, consisting of a series of four decimal numbers (0-255), separated by periods. Example: 123.205.23.99.
See Distributed Program Interface (DPI).
Digital Signature Algorithm. An algorithm used to generate digital signatures. DSA is defined in US FIPS 186.
See Dynamic Skeleton Interface (DSI).
See distributed transaction processing (DTP).
dual-paired connections outbound IIOP
A type of argument for which a method can allocate or extend the existing storage.
A form of communication available on Microsoft Windows platforms that allows applications to exchange information through a series of messages. Two applications sending and responding to DDE messages are said to have a DDE conversation.
A datatype whose memory size is not known when the code is compiled; a dynamic datatype's memory size is known only when the code is executed.
Dynamic Invocation Interface (DII)
(CORBA) An API that allows a CORBA client to either perform invocations on an object whose signature may be unknown at compile time, or a deferred synchronous invocation. If an object's signature is unknown, the client locates the object and uses the Interface Repository to obtain information about the object's signature and constructs an invocation with the proper parameters. The client can then issue the invocation and receive the response. DII is distinguished from the static invocation interface in which a client performs a synchronous invocation using client stubs. DII also allows a client to issue a request and to not block until the request is completed. The client checks for a response at a later time.
See Dynamic Skeleton Interface (DSI).
A collection of functions grouped into a load module that is dynamically linked with an executable program at run time for a Microsoft Windows application.
Dynamic Skeleton Interface (DSI)
(CORBA) An API that provides a way to deliver requests from an ORB to an object implementation. DSI is used at compile time when the ORB has no knowledge of the object implementation. As the server-side analog to the client-side DII, DSI lets the application programmer examine the parameters of an incoming request to determine a target object and method.
See Dynamic Invocation Interface (DII).
The practice of buying and selling goods and services over the Internet.
The conversion of architecture-specific data into a format that can be transmitted between different architectures, such as XDR encoding.
The process of algorithmically scrambling data to prevent (or hinder) unauthorized disclosure, while still preserving access to the original data by authorized users. To read an encrypted file, a recipient must have access to a secret key or password that enables the recipient to decrypt it. Unencrypted data is called plaintext; encrypted data is referred to as ciphertext.
See ciphertext and plaintext.
An encryption key pair consists of the public key used to encrypt information and a private key used to decipher the information.
(CORBA) Any support object that provides independence from the underlying environment (for example, independence from the operating system). The Bootstrap object is an environmental object.
See also Bootstrap environmental object and object.
A string of specific value that controls a certain attribute of an application. Environment variables are made available to the application as it begins.
An indication to a BEA Tuxedo system process of the occurrence of a particular state or condition, for example, disconnection, transaction request mode, connection request, and so forth.
A BEA Tuxedo system component that monitors the occurrence of defined system and application events and notifies subscribers when an event is detected.
Notification by the BEA Tuxedo system (or by an application) to the Event Broker/Monitor that a defined event has occurred.
A request made to the Event Broker/Monitor to be notified when a specific event is detected.
(CORBA) An event that occurs during program execution that prevents the program from continuing normally (usually an error). C++ supports exceptions with the try, catch, and throw keywords. There are two categories of exceptions: system and user-defined.
In C++, system exceptions inherit from CORBA::System_Exception and user-defined exceptions inherit from CORBA::User_Exception.
The ease with which a system adapts to meet new requirements. Extensibility also includes the ability to add or change a function or data (data type, file format, database schema, or information model) without:
Exterior Gateway Protocol (EGP)
A protocol used to advertise the set of networks that can be reached within an autonomous system. EGP enables this information to be shared with other autonomous systems.
External Data Representation (XDR)
A canonical data format defined by Sun Microsystems and used to transfer data between heterogeneous hardware nodes.
See also CORBA object, object reference, and application.
(CORBA) A feature of the BEA Tuxedo software that permits the routing of requests on a CORBA object reference to a specific server group based on criteria supplied at the time the object reference is created by a factory.
See also factory and object reference.
(CORBA) A CORBA object that locates the factories that an application needs. Both client applications and server applications can use a factory finder. A factory finder object provides an implementation of the CORBAservices COSLifeCycle.FactoryFinder interface, as well as the BEA Tobj.FactoryFinder interface.
See also factory, local factory, object, client application, and server application.
(CORBA) The FactoryFinder configuration file for domains. This file is parsed by the TMFFNAME service when it is started as a Master NameManager. The file contains information used by NameManagers to control the import and the export of object references for factory objects with other domains.
See also domain, factory, and object reference.
Restoration of message traffic to a higher-priority circuit. The BRIDGE process always tries to use the highest-priority circuit defined for the node; when traffic is flowing on a lower-priority circuit, whether due to circuit failure or just non-availability, the BRIDGE periodically checks higher-priority circuits to find one that is usable. When a higher priority circuit becomes available again, the data flow is returned to it. This mechanism is called failback.
(ATMI and CORBA) Seamless transfer of message traffic to a lower-priority circuit on the occasion of the failure of a higher-priority circuit. Some operating system and hardware bundles transparently detect a problem on one network card and replace it with another. When this replacement is done quickly, application-level TCP virtual circuits have no indication that a fault has occurred.
In the BEA Tuxedo system, data flows over the highest available priority circuit. If all network groups have the same priority, data travels over all networks simultaneously. If all circuits at the current priority fail, data is sent over the next lower priority circuit. This is called "failover."
(Jolt) A failure prevention mechanism that works as follows. If the current Jolt Relay Adapter (JRAD) fails to respond to a connection request, the Jolt Relay (JRLY) is enabled to connect to another available JRAD. The Jolt client proves a list of JRLY addresses to which the JRAD attempts connection in a round-robin fashion.
Field Manipulation Language (FML)
(ATMI) A set of C language functions for defining and manipulating storage structures called field buffers. Cooperating processes can send and receive data in fielded buffers.
(Jolt) An interface for maintaining buffers with field/value pairs; specifically, the 16-bit version of this interface.
(ATMI) A file that consists of FML field names and their identifiers. The field table enables users to refer to fields by logical names rather than by system field identifiers.
See Field Manipulation Language (FML).
(ATMI) A buffer of self-describing data items accessed through the field manipulation language API.
A physical connection between a native BEA Tuxedo system node and a foreign node. At least one gateway server must reside on the BEA Tuxedo node.
(CORBA) A client application that is implemented on an ORB that is not a product of BEA Systems, Inc. Although the client is implemented on a Microsoft product, the ORB is provided by BEA Systems, Inc.
See ORB.
A node in the network that does not have access to the configuration's bulletin board, or that cannot execute the full complement of BEA Tuxedo system software.
The ability to send data to a device without having to be concerned with the format in which the data is displayed. The same data may appear in different formats on different devices.
The software environment tailored to the needs of a specific domain. Frameworks include a collection of software components that programmers use to build applications for the domain the framework addresses. Frameworks can contain specialized APIs, services, and tools, which reduce the knowledge a user or programmer needs to accomplish a specific task.
For the BEA Tuxedo system, any communication mechanism between different environments (for example, between native and foreign nodes). A software program that allows dissimilar systems to communicate and exchange information. A gateway normally handles communication between systems and performs all necessary protocol translation such that the end applications communicate transparently.
A collection of processes that provide communication services to and from remote domains. The group consists of the following: GWADM, the gateway administrative server, and a gateway process, for example, GWTDOMAIN.
A server process, resident on a native BEA Tuxedo system node, that communicates with one or more foreign machines.
General Inter-ORB Protocol (GIOP)
(CORBA) A standard for communication between independent CORBA Object Request Broker (ORB) implementations. GIOP was developed by the Object Management Group (OMG). GIOP is an abstract protocol that forms the basis for specific protocols that map the GIOP standard to individual transport layers. For example, IIOP maps the GIOP standard to the TCP/IP transport layer.
See also CORBA ORB and IIOP.
See General Inter-ORB Protocol (GIOP).
The BEA Tuxedo system name for a transaction in which multiple servers or multiple resource manager interfaces are used and that is coordinated as an atomic unit of work. A global transaction may be composed of several local transactions, in each of which a single resource manager is accessed.
See also resource manager (RM).
Global Transaction Identifier (GTRID)
A data structure, the value of which uniquely identifies a global transaction.
graphical user interface (GUI)
A high-level interface that uses windows and menus with graphic symbols instead of typed system commands to provide an interactive environment for a user. The BEA Administration Console, available through the World Wide Web, enables an authorized user to configure and control a BEA Tuxedo application.
A collection of servers or services on a machine, often associated with a resource manager. A group is an administrative unit used for booting, shutting down, and migrating servers and services.
See graphical user interface (GUI).
A request that originates on a remote computer. Handlers are registered in the local BEA Tuxedo bulletin board as client programs.
See also Workstation Handler (WSH).
A database organized in the form of a tree structure that predetermines the access paths to data stored in the database. DL/I, IMS, and SQL/DS are hierarchical database managers.
In a database, a tree of segments beginning with the root and proceeding downward to dependent segment types. No segment type can be dependent on more than one other segment type.
A computer that is attached to a network and provides services other than acting as a communication switch.
The primary or controlling computer in a data communication system.
hypertext markup language (HTML)
The language used for writing pages for the World Wide Web.
See Implementation Configuration File (ICF).
Portions of a file that get expanded by RCS and SNMP Agent utilities to contain file and identification information. If compiled, these strings are placed into object file functions, where the information is made available.
(CORBA) A tool that takes an OMG IDL interface and produces C++ programming language interfaces and classes that represent the mapping from the IDL interface to the C++ programming language.
(CORBA) A declaration in OMG IDL of an interface to a CORBA object. The interface declaration contains IDL operations and attributes. The OMG IDL interface declaration is used to generate stubs and skeletons for BEA Tuxedo CORBA objects.
See also CORBA object, interface, OMG IDL, and skeleton.
(CORBA) One or more objects the client passes to an IDL operation when it invokes the operation. Parameters may be declared as in (passed from client to server), out (passed from server to client), or inout (passed from client to server and then back from server to client).
(CORBA) A tool that takes an OMG IDL interface and produces Java programming language interfaces and classes that represent the mapping from the IDL interface to the Java programming language. The resulting files are .java files.
(CORBA) Internet Inter-ORB Protocol. The standard protocol defined by the CORBA specification for interoperation between Object Request Brokers (ORBs), which was written by the Object Management Group (OMG). The IIOP enables two or more Object Request Brokers (ORBs) to cooperate to deliver requests to an object.
See also CORBA ORB and object.
(CORBA) A BEA Tuxedo system process that handles all IIOP communication between a remote application and target CORBA objects.
See also Jolt Server Handler (JSH) and Workstation Handler (WSH).
(CORBA) A BEA Tuxedo system process that listens for incoming IIOP connections from remote applications. After a connection is established, the Listener hands off the connection to the IIOP Handler.
See also Jolt Server Listener (JSL) and Workstation Listener (WSL).
(CORBA) The feature of the BEA Tuxedo software that enables client applications to communicate with the BEA Tuxedo domain, and the reverse. The IIOP Listener/Handler receives a request from a client application via the IIOP protocol, and then sends that request to the appropriate server application within the BEA Tuxedo domain. It also receives a request from a server application in the BEA Tuxedo domain and sends the request to a server outside the domain.
See also IIOP, client application, domain, and server application.
(Jolt) A process that receives a client request, which is sent using the IIOP, and delivers that request to the appropriate server application.
(CORBA) The method code that you write that satisfies a client application's request on a specific object. The interface defines the operation and is implemented in the method.
See also interface, metadata interface, and object.
Implementation Configuration File (ICF)
(CORBA) A file that describes the implementation attributes of BEA Tuxedo C++ server applications. The ICF file is input to the IDL compiler when generating skeletons for BEA Tuxedo C++ server applications.
See also skeleton and server application.
(CORBA) The file that contains, among other data, method declarations for each operation defined in your OMG IDL statements. You need to implement the method with your business logic. When you build the server application, you provide this implementation file to the BEA Tuxedo build procedure.
See also implementation code, metadata interface, OMG IDL, operation, and server application.
A server that is not currently available to process requests.
A connection to the local gateway that is initiated by a domain gateway on a remote domain.
A software design technique in which a piece of code contains only the information it needs to do its job.
A common underlying computing base. The infrastructure is a set of components (fundamental services) that support another higher-level set of components in a given system. The higher-level components are typically more directly associated with providing the specific function of the overall system.
(CORBA) When using CORBA objects, the NamingContext object returned by a call to the method orb.resolve_initial_references("NameService"). It is an object reference to the CosNaming Service registered with the ORB. The initial naming context can be used to create other NamingContext objects.
(CORBA) A particular realization of an abstraction or template, such as a class of objects or a computer process.
(CORBA) To create an instance by defining one particular variation of an object within a class, giving it a name and locating the object in some physical place.
Facilities that provide access to the attributes of managed resources, to retrieve or modify values of these attributes. Access to managed resources used by agents to respond to management requests.
The ability of applications to share information or to process independently by requesting services and satisfying service requests. In a well-integrated system, all of the parts have a purpose, and the parts combine effectively to achieve the purpose of the overall system.
A description of how the clients and servers in a distributed application or application framework work with each other.
Pertaining to an application in which each entry entails a response from a system or program, as in an inquiry system or airline reservation system. An interactive system may also be conversational, implying a continuous dialog between the user and the system.
A system facility that controls how different users see and work with the system by means of user profiles. When signing on, the interactive interface makes available those parts of the system authorized by the profile. The interactive interface has sets of selection and data entry panels through which users communicate with the system.
(CORBA) An online database that contains the definitions of the interfaces that determine the CORBA contracts between client and server applications.
See conversation and IDL interface.
A mechanism that allows customization of a system's text messages and data formats into an application's language and format of choice.
International Standards Organization (ISO)
An international organization whose membership includes standards and research groups from various nations. ISO establishes standards for computer network communications and many other technologies.
The world's largest network, the Internet is based on the TCP/IP protocol suite and is universally accessible.
Internet Inter-ORB Protocol (IIOP)
Internet Protocol Address (IP address)
A numeric value that uniquely identifies a node in a TCP/IP network. IP addresses are usually expressed in dotted decimal notation, a series of four decimal numbers (0-255), separated by periods. Example: 123.205.23.99.
The ability to exchange requests between entities.
Interoperable Object Reference (IOR)
(CORBA) The entity that associates a collection of tagged profiles with object references. An ORB must create an IOR (from an object reference) whenever an object reference is passed across ORBs.
See also CORBA ORB and object reference.
A set of internal company or group-specific networks protected by firewalls and connected by IP routers. An intranet appears to its users as a single network.
(CORBA) The process of performing a method call on a distributed object, with or without knowledge of the object's location on the network. CORBA Static invocation, which uses a client stub for the invocation and a server skeleton for the service being invoked, is used when the interface of the object is known at compile time. CORBA Dynamic invocation must be used if the interface is not known at compile time.
See also CORBA callback object and skeleton.
(CORBA) The security policy that controls whether a client application may invoke a method on the target object as specified in the request.