ACID
The basic transaction properties of atomicity, consistency, isolation, and durability.
ActiveX
A set of technologies that enables software components to interact with one another in a networked environment, regardless of the language in which they were created. ActiveX is built on the Component Object Model (COM).
Apartment thread
A thread used to execute calls to objects of components configured for apartment-model threading. Each object "lives in an apartment" (thread) for the life of the object. All calls to that object execute on the apartment thread. This threading model is used, for example, for component implementations that keep object state in thread-local storage (TLS). A component's objects can be distributed over one or more apartments. See also main thread.
Atomicity
A feature of a transaction that indicates that either all actions of the transaction happen or none happen.
Authentication level for calls
The level of authentication for clients calling the package. This ranges from the default for the Windows NT Server Authentication service, which is Connect, to authenticating the entire packet, including the data; the sender's identity and signature are encrypted for maximum security.
Automatic transaction
A transaction created by Microsoft Transaction Server for an object and based on the component's transaction attribute.
Base client
A client that runs outside the Microsoft Transaction Server run-time environment but that instantiates Microsoft Transaction Server objects.
Base process
An application process in which a base client executes. A base client runs outside the Microsoft Transaction Server run-time environment, but instantiates Microsoft Transaction Server objects.
Business rule
The combination of validation edits, logon verifications, database lookups, policies, and algorithmic transformations that constitute an enterprise's way of doing business. Also known as business logic.
Caller
A client that invokes a method of an object. An object's caller isn't necessarily the object's creator. For example, client A could create object X and pass this reference to client B, and then client B could use that reference to call a method of object X. In this case, client A is the creator, client B is the caller. See also creator.
Catalog
The Microsoft Transaction Server data store that maintains configuration information for components, packages, and roles. You can administer the catalog by using the Microsoft Transaction Server Explorer.
Class
A type that defines interfaces of a particular type of object. A class defines the properties of the object and the methods used to control the object's behavior.
Class factory
An object that implements the IClassFactory interface, which allows it to create objects of a specific class.
Class ID (CLSID)
A universally unique identifier (UUID) that identifies a COM component. Each COM component has its CLSID in the Windows Registry, so it can be loaded by other applications.
Client/server
A distributed application model in which client applications request services from a server application. A server can have many clients at the same time, and a client can request data from multiple servers. An application can be both a client and a server.
Component
A discrete unit of code built on ActiveX technologies that delivers a well-specified set of services through well-specified interfaces. Components provide the objects that clients request at run time.
COM (Component Object Model)
An open architecture for cross-platform development of client/server applications based on object-oriented technology. Clients have access to an object through interfaces implemented on the object. COM is language neutral, so any language that produces ActiveX components can also produce COM applications.
Concurrency
The appearance of simultaneous execution of processes or transactions by interleaving the execution of multiple pieces of work.
Constructor
In C++ and Java, a special initialization function called automatically when an instance of a class is declared. This function prevents errors that result from the use of uninitialized objects. The constructor has the same name as the class itself and can't return a value.
Context
State that is implicitly associated with a given Microsoft Transaction Server object. Context contains information about the object's execution environment, such as the identity of the object's creator and, optionally, the transaction encompassing the work of the object. An object's context is similar in concept to the process context that an operating system maintains for an executing program. The Microsoft Transaction Server run-time environment manages a context for each object.
Creator
A client that creates an object provided by a component (using CreateObject, CoCreateInstance, or the CreateInstance method). When a client creates an object, it is given an object reference that can be used to call the methods of that object. See also caller.
Data source name (DSN)
The name that applications use to request a connection to an ODBC data source.
Deadlock
A situation in which two or more threads are permanently blocked (waiting), with each thread waiting for a resource exclusively held by one of the other threads that is blocked. For example, if thread A locks record 1 and waits to lock record 2, while thread B has locked record 2 and waits to lock record 1, the two threads are deadlocked.
Declarative security
Security that is configured using Microsoft Transaction Server Explorer. You can control access to packages, components, and interfaces by defining roles. Roles determine which users are allowed to invoke interfaces in a component. See also programmatic security.
Direct caller
The identity of the process (base client or server process) calling into the current server process.
Distributed COM (DCOM)
DCOM is an object protocol that enables ActiveX components to communicate directly with each other across a network. DCOM is language neutral, so any language that produces ActiveX components can also produce DCOM applications.
Distributed Transaction Coordinator (MS DTC)
A transaction manager that coordinates transactions that span multiple resource managers. Work can be committed as an atomic transaction even if it spans multiple resource managers, potentially on separate computers.
Dynamic-link library (DLL)
A file that contains one or more functions that are compiled, linked, and stored separately from the processes that use them. The operating system maps the DLLs into the address space of the calling process when the process is starting or while it's running.
Domain
In Windows NT, a collection of computers defined by the administrator of a Windows NT server network that share a common directory database. A domain provides access to the centralized user accounts and group accounts maintained by the domain administrator. Each domain has a unique name.
Failfast
A policy of Microsoft Transaction Server that aids fault containment. When the Transaction Server encounters an unexpected internal error condition, it immediately terminates the process and logs messages to the Windows NT event log for details about the failure.
Fault tolerance
The ability of a system to recover from an error, a failure, or a change in environmental conditions (such as loss of power). True fault tolerance provides for fully automatic recovery without disruption of user tasks or files, in contrast to manual means of recovery, such as restoring data loss with backup files.
Group
A name that identifies a set of one or more Windows NT user accounts.
In-doubt transaction
A transaction that has been prepared but hasn't received a decision to commit or abort because the server coordinating the transaction is unavailable.
In-process component
A component that runs in a client's process space. This is typically a dynamic-link library (DLL).
Instance
An object of a particular component class. Each instance has its own private data elements or member variables. A component instance is synonymous with object.
Interactive logon user
The current user on a Windows Transaction Server computer.
Interface
A group of logically related operations or methods that provides access to a component object.
Isolation
A characteristic whereby two transactions running in parallel produce the illusion that there is no concurrency. It appears that the system runs one transaction at a time.
Just-in-time activation
The ability for a Microsoft Transaction Server object to be activated only as needed for executing requests from its client. Objects can be deactivated even while clients hold references to them, allowing otherwise idle server resources to be used more productively.
Load balancing
Distribution of the processing load among several servers carrying out network tasks to increase overall network performance.
Main thread
A single thread used to run all objects of components marked as "single thread." See also apartment thread.
Marshaling
The process of packaging and sending interface method parameters across thread or process boundaries.
Method
A procedure (function) that acts on an object.
Microsoft Distributed Transaction Coordinator (MS DTC)
A transaction manager that coordinates transactions that span multiple resource managers. Work can be committed as an atomic transaction even if it spans multiple resource managers, on separate computers.
Microsoft Transaction Server component
A COM component that executes in the Microsoft Transaction Server run-time environment. A Transaction Server component must be a dynamic-link library (DLL), implement a class factory to create objects, and describe all of the component's interfaces in a type library for standard marshaling.
Microsoft Transaction Server Explorer
An application to configure and manage Microsoft Transaction Server components within a distributed computer network.
Object
A run-time instance of a COM component. An object is created by a component's class factory. Object is synonymous with instance.
ODBC resource dispenser
A resource dispenser that manages pools of database connections for Microsoft Transaction Server components that use the standard ODBC programming interfaces.
Open Database Connectivity (ODBC)
A standard programming language interface used to connect to a variety of data sources.
Out-of-process component
A component that runs in a separate process space from its client. The Microsoft Transaction Server enables components implemented as DLLs to be used out-of-process from the client, by loading the components into surrogate server processes.
Package
A set of components that perform related application functions. All components in a package run together in the same Microsoft Transaction Server server process. A package is a trust boundary that defines when security credentials are verified. It's also a deployment unit for a set of components. You can create packages with the Transaction Server Explorer.
Package file
A file that contains information about the components and roles of a package. A package file is created using the package export function of the Transaction Server Explorer. When you create a prebuilt package, the associated component files (DLLs, type libraries, and proxy-stub DLLs, if implemented) are copied to the same directory in which the package file was created.
Pooling
A performance optimization based on using collections of preallocated resources, such as objects or database connections. Pooling results in more efficient resource allocation.
Prebuilt package
A package file that contains information about the components and roles of a package. A package file is created using the package export function of the Transaction Server Explorer. When you create a prebuilt package, the associated component files (DLLs, type libraries, and proxy-stub DLLs, if implemented) are copied to the same directory where the package file was created.
Programmatic identifier (progID)
A name that identifies a COM component. For example, a programmatic ID could be Bank.MoveMoney.
Programmatic security
Procedural logic provided by a component to determine if a client is authorized to perform the requested operation. See also declarative security.
Proxy
An interface-specific object that provides the parameter marshaling and communication required for a client to call an application object that is running in a different execution environment, such as on a different thread or in another process. The proxy is located with the client and communicates with a corresponding stub located with the application object being called.
Remote procedure call (RPC)
A standard that allows one process to make calls to functions executed in another process. The process can be on the same computer or on a different computer in the network.
Resource dispenser
A service that provides the synchronization and management of nondurable resources within a process, providing for simple and efficient sharing by Microsoft Transaction Server objects. For example, the ODBC resource dispenser manages pools of database connections.
Resource manager
A system service that manages durable data. Server applications use resource managers to maintain the durable state of the application, such as the record of inventory on hand, pending orders, and accounts receivable. The resource managers work in cooperation with the transaction manager to provide the application with a guarantee of atomicity and isolation (using the two-phase commit protocol). Microsoft SQL Server is an example of a resource manager.
Role
A symbolic name that defines a class of users for a set of components. Each role defines which users are allowed to invoke interfaces on a component.
Semaphore
A locking mechanism used inside resource managers or resource dispensers. Semaphores have no symbolic names, only shared and exclusive mode access, no deadlock detection, and no automatic release or commit.
Server process
A process that hosts Microsoft Transaction Server components. A Microsoft Transaction Server component can be loaded into a surrogate server process, either on the client computer (local) or on another computer (remote). It can also be loaded into a client application process (in-process).
Shared property
A variable available to all objects in the same server process by way of the Shared Property Manager. The value of the property can be any type that can be represented by a variant.
Stateful object
An object that holds private state accumulated from the execution of one or more client calls.
Stub
An interface-specific object that provides the parameter marshaling and communication required for an application object to receive calls from a client running in a different execution environment, such as on a different thread or in another process. The stub is located with the application object and communicates with a corresponding proxy located with the client that calls it.
Thread
The basic entity to which the operating system allocates CPU time. A thread can execute any part of the application code, including a part currently being executed by another thread. All threads of a process share the virtual address space, global variables, and operating-system resources of the process.
Trace message
A message that includes the current status of various Microsoft Transaction Server activities, such as startup and shutdown. Trace Messages include current trace messages issued by the Microsoft Distributed Transaction Coordinator (MS DTC). Tracing allows you to view the current status of various MS DTC activities, such as startup and shutdown, and to trace potential problems by viewing additional debugging information. You can specify the level of tracing.
Transaction
A unit of work that is done as an atomic operation—that is, the operation succeeds or fails as a whole.
Transaction context
An object used to allow a client to dynamically include one or more objects in one transaction.
Transaction list
Displays the current transactions in which this computer participates, including transactions whose status is in doubt and transactions that have timed out. You can monitor the status of a transaction and manually resolve a transaction.
Transaction manager
A system service responsible for coordinating the outcome of transactions to achieve atomicity. The transaction manager ensures that the resource managers reach a consistent decision on whether the transaction should commit or abort.
Transaction Server object
A COM object that executes in the Microsoft Transaction Server run-time environment and follows the Transaction Server programming and deployment model.
Two-phase commit
A protocol that ensures that transactions that apply to more than one server are completed on all servers or none at all. Two-phase commit is coordinated by the transaction manager and supported by resource managers.
Type library (.tlb)
A file containing standard descriptions of data types, modules, and interfaces that can be used to fully expose objects with ActiveX technology.
User name
The name that identifies a Windows NT user account.