Abstract: Methods, apparatuses, and systems for managing a network with a non-system class loader via remote method invocation are described. A method includes transferring the Java remote method invocation (RMI) call to a network element in order to obtain a version of the management software associated with the network element. The method further includes determining if a requested class to be loaded by a class loader based on the RMI call belongs to a system namespace or a non-system namespace. The method further includes obtaining a byte code associated with the requested class from a class hash with a class name key if the requested class belongs to the non-system namespace. The method further includes loading the requested class and associated byte code to a Java virtual machine with a non-system class loader if the requested class belongs to the non-system namespace.

Abstract: A method and apparatus for using a microcontainer as a Plain-Old-Java-Object (POJO) based kernel in an application server. In one embodiment, the method includes dynamically construct deployed objects of a deployment from aspects. The method further includes providing a runtime infrastructure by dynamically constructing kernel objects of an application server from the aspects to execute the deployed objects.

Abstract: A communications services network platform has a multi-layered software architecture residing on a host computer. The network platform connects to a communications network and includes a call processing stack, a link layer, and a service support subsystem. The call processing stack implements call processing by processing events associated with a communication path through the communications network and has an application layer, representing each active call being processed by the call processing stack, and a resource layer, including software abstractions of physical resources located outside the host computer. The link layer manages a communications link between physically connected physical resources and the call processing stack. The service support subsystem executes services requested by the call processing stack. The platform manages and controls communications events associated with the communication path to complete a request for services between nodes on the communication network.

Abstract: Described herein is an implementation for exposing an “execution context” to a logical execution flow of procedures as it executes. An “execution context” is a set of data and/or sub-procedures that might be useful at some point during a logical execution flow (to manage and control the execution flow and provide additional services to the execution flow) of computer-executable instructions though the often complex, intertwined, and interconnected conglomeration of procedures of software product(s).

Abstract: An RFID event tracking and management system provides a standardized approach that can be utilized by various industry verticals. A series of industry-specific data models can be built upon a common data model using an object-oriented database and relational mapping tool. Using the industry-specific data models, an object-oriented database is generated that can be used by all vertical applications that sit on top of the database. The data models can be defined using a data model service, such that query and capture interfaces can interact with the respective data model. Such an approach allows the data models to be dynamic, which is desirable as a single static data model is not appropriate for all industries.

Abstract: A computer method and system provides on-demand transformation between objects of a source programming model and corresponding objects in a target programming model. For different source objects in the source programming model, the invention creates respective target objects. For every created target object, the invention system and method create a respective proxy object. Where a source object has multiple features, the proxy object triggers transformation of a feature only upon access of that feature and the corresponding target object. The present invention operates transparently to a client. Thus, clients do not have to call transform on the feature (children and references) of the source object before accessing any feature of the target object.

Abstract: According to one aspect of the present invention, a system is provided to support a web-based application. The system comprising a set of server-side objects managed by an object manager (OM), the set of server-side objects including a global session object providing access to a repository, a server-side business object, and server-side business components contained in the server-side business object. The system further comprises a set of browser-side objects running on a browser, the set of browser-side objects including a browser-side application object that exists throughout a user-session to manage other browser-side objects. The system also comprises a remote procedure call (RPC) mechanism and a notification mechanism to facilitate communication and synchronization between the browser-side objects and the server-side objects.

Abstract: A clustered enterprise distributed processing system. The distributed processing system includes a first and a second computer coupled to a communication medium. The first computer includes a virtual machine (JVM) and kernel software layer for transferring messages, including a remote virtual machine (RJVM). The second computer includes a JVM and a kernel software layer having a RJVM. Messages are passed from a RJVM to the JVM in one computer to the JVM and RJVM in the second computer. Messages may be forwarded through an intermediate server or rerouted after a network reconfiguration. Each computer includes a Smart stub having a replica handler, including a load balancing software component and a failover software component. Each computer includes a duplicated service naming tree for storing a pool of Smart stubs at a node.

Abstract: An apparatus and method provide for providing services using an attribute. In one example, the attribute may hide complexity of an underlying infrastructure and may call methods in the infrastructure to locate partner services. Any number of partner services may include a policy in which a pre-existing instance of a partner service may be used to perform desired services. Alternatively, an instance of a service may be created. In another example, a manifest in a partner list entry may be used for identifying a set of services at a node.

Abstract: A database system providing stored procedures as web services is described. In one embodiment, for example, in a database system, a method of the present invention is described for providing a stored procedure as a Web service, the method comprises steps of: predefining a stored procedure to be invoked upon receiving a client request for a particular Web service; receiving an incoming request from a particular client for the particular Web service; in response to the incoming request, identifying the stored procedure that is predefined for the particular Web service; executing the identified stored procedure for generating a result set; and returning the result set back to the particular client.

Abstract: Currently lacking are effective and accurate tools to help petroleum traders and logistics personnel to make better decisions, collaborate in real-time and negotiate deals in a private and secure environment. The present invention addresses this and other needs in the industry. In particular, the present invention provides automated workflow management for a series of workflow tasks by mapping the workflow tasks to a collaborative workflow process comprising: roles, users, business processes and computer executable activities. A workflow object is received that supplies information used to set particular attributes of the roles, the users, the business activities and the computer executable activities of the collaborative workflow process. Information and data objects are shared electronically among the users performing certain of the roles. At least one of the activities is automatically executed, such that the workflow is automatically managed.

Abstract: A method of converting ERP data in a database managed by an ERP application and accessed through an ERP API and ERP Message Agent API (MAAPI) to strongly typed data in Java objects includes steps of reading, parsing, creating, and populating. A XML file containing the definition of the Java objects and their attributes or HyperText Markup Language (HTML) statements which specifies presentation format is read. Each of the declarations and HTML statements are parsed to identify definitions of objects and their attributes. The respective objects are created with their attributes. The objects are populated with data from the ERP data.

Abstract: Systems, methods, and software for managing information retention using uniform retention rules is disclosed. Particularly, the disclosure relates to identifying data to be archived and assigning, inter alia, a destruction date to the identified data. Data for archival are identified using one or more defined retention rules. The retention rules identify the data for archival by one or more properties of the data. Once identified, retention information is applied to the identified data.

Abstract: The cache control unit 15 of the mobile terminal 10 receives an access request for an instance of an object that specifies data to which applications 13 refers, and in the case that an instance of the object does not exist, creates an instance of the object and a counter. In addition, an instance of a reference setting class is created, the reference that refers to the instance of the requested object is set and the result is returned to the application 13, and the counter is incremented by 1. In the case that a release notification for the instance of the reference setting class is received, the counter is decremented by 1, and when the counter has reached 0, the instance of the object is released.

Abstract: Methods and systems for instrumenting a COM object are disclosed. A request from a client for creating a COM object is intercepted and a wrapper object corresponding to the requested COM object is generated. The wrapper object implements a universal interface with a plurality of virtual functions each indexed by a number corresponding to an index number of a method associated with an interface of the requested COM object.

Abstract: An operating system architecture is based on a service model in which active entities (services) are containers for objects having a number of interfaces specified through a contract language that is a subset of the language in which the service is coded. Services may reside in the same address space or may reside in separate address spaces, without changing the programming model or compiled binaries. The location of a service is independent of the location of the service's clients and of services the service calls.

Abstract: Methods and systems for enabling arbitrary components to control communications, such as data transfers, without having or requiring prior knowledge of each other. The system includes a component that creates controller objects for a communication, such as a data transfer involving several components. Further, the component associates the controller objects with a communication session object of the data transfer, such as a data transfer session object. One or more of the components involved in the data transfer obtain the controller objects through the data transfer session object and execute source-specific instructions included in the obtained controller objects to generate user interfaces. The user interfaces enable the components to control aspects of the communication, such as the data transfer.

Abstract: A system and method for generating business content portable across multiple software applications is described. In one embodiment, a universal object model (UOM) is employed to art as an abstraction layer between business content and the application used to create the business content. The UOM generates portable business content from objects and operations uncovered by a descriptive language such as extendable mark-up language (XML). The UOM objects and/or properties are mapped to an application object model (AOM) which is capable of extending the properties and/or operations of the original business application. The portable business content is mapped from the AOM to another application in accordance to the applications application programming interface (API). The business content created by the UOM may be configured for other applications without rewriting the business content by modifying the AOM.

Abstract: A computer implemented method/system of creating and managing one or more interceptors. The method comprises the steps of intrinsically chaining the interceptors, and storing state information, in at least one of the chained interceptors, directed to a reference to the next interceptor. A server computer in a client-sever environment that includes a processor configured to generate one or more interceptors and to intrinsically chain the interceptors, and a memory associated with at least one of the chained interceptors and configured to store state information directed to a reference to the next interceptor thereof. The method/system, in various embodiments, includes dissimilar interceptors, callbacks, and flyweight pattern weighting.

Abstract: Plug-in configurable middleware is provided for managing distributed applications. The middleware includes at least one core runtime engine configured as a plurality of concurrent instantiations on one or more hosts within a distributed architecture. These hosts can represent separate nodes or a single node within the architecture. Each core runtime engine instance provides the minimum amount of functionality required to support plug-in architecture, that is to support the instantiation of one or more plug-ins within that core runtime engine instance. Each core runtime engine instance is in communication with other concurrent core runtime engine instances and can share the functionality of plug-in instances with the other core runtime engine instances, for example through the use of proxies. A plurality of personalities representing pre-defined functions is defined and one of more of these personalities is associated with each core runtime engine instance.

Abstract: In accordance with one embodiment of the present invention applications are configured with custom modules. A deployment descriptor of an application includes a definition for a new container type and modules of the new container type. A deployment system reads the deployment descriptor and implements the modules of the new container type. The new containers are then available to assist in the deployment of the application.

Abstract: Systems and methods for enabling a Meta Object Facility (MOF) compliant service for a metadata resource. The systems and methods employ a connector adapted to receive metadata from the metadata resource via a resource-specific application programming interface, and a metamodel repository storing one or more MOF models. The systems and methods further employ a persistence interface between the connector and metamodel repository. The persistence interface is configured to instantiate at least one MOF compliant service for the connector based on one of the MOF models in the metamodel repository.

Abstract: A virtual machine (e.g. the Java Virtual Machine (JVM)) may include extensions for compiling objects (e.g. Java Objects) into data representation language (e.g. XML) representations of the objects, and for decompiling representations of objects into objects. The virtual machine may supply an API to the compilation/decompilation extensions. The compiler/decompiler API may accept an object as input, and output a data representation language representation of the object and all its referenced objects (the object graph) in a data stream. In addition, the compiler/decompiler API may accept a data stream, which includes a representation of the object and all its referenced objects (the object graph), and output the object (and all the objects in its object graph). In one embodiment, an intermediary format may be used to represent a data representation language document and may be dynamically processed to generate a class instance from the data representation language document.

Abstract: System and method for bridging between inter-object communication interfaces, such as RMI and IIOP, may include in one embodiment a bridge mechanism that maintains a cache of reference objects. The key used for hashing in the cache may be based on the object identifier (OID) of the reference objects. In one embodiment, the integer value of the OID is generated and then converted to a string for use in caching the object. In one embodiment, objects are not marked for deletion from the cache until a client calls a remove method. In one embodiment, object references in the cache include a reference to an exported object. In one embodiment, unexport of the exported object is performed by a post-invoke mechanism of the bridge mechanism after the remove method has completed.

Abstract: A system and method for providing composite applications for software-based systems that uses a built-in application model having at least one general purpose object type, and providing dynamic late-binding of object implementations through an object typing system decoupled from pre-run time program code, using persistently stored objects. The application model may require that program objects in a conformant application be instances of a predefined active object type, or optionally instances of a predefined reactive object type. The application model enables integration of applications into composite applications, and further integration of composite applications into subsequently defined systems. The run-time object typing system for persistently stored objects is independent of the class typing system that is defined at compile-time or link-time, and enables convenient and practical modifications during development, deployment and maintenance of composite applications.

Abstract: A user-driven, service-oriented application model, in which conformant applications implement and process instances of two program object types. Components in conformant applications consist of objects having built-in behaviors that are common across different applications. Each application object is either an instance of a predefined active object type, or an instance of a predefined reactive object type. Active objects are associated with individual users of their application, are allowed to activate services, and encapsulate all their inputs and outputs within a bounded space. Reactive objects are instantiated or processed by services, and, in one embodiment, each one is owned by an individual active object at any given point in time. During operation of the disclosed system, services activated by active objects route reactive objects to active objects. An active object assumes ownership of a received reactive object upon receipt.

Abstract: To provide a component processing system and a component processing method in which components used by a plurality of applications are centrally managed, thereby enabling efficient response to changes in the components. Component environment definition information that shows locations of components used by the individual applications is composed of a component location definition information that defines the locations of the components, a component use definition information that defines the components to be used; and an application location definition information that includes an information designating the component use definition information corresponding to the individual applications. In response to a request from the application, a component managing unit in a framework requests a middleware to acquire the location of the component to be used by this application, and the middleware reads the component environment definition information to respond to the component managing unit.

Abstract: A method and system thereof for identifying records are described. Records on a node are distinguished from other records on the node by assigning each record a unique local identifier. When a record is moved from one node to another node, a unique global identifier is assigned to the record. A translation technique is employed to map the local identifier to the global identifier (and vice versa).

Abstract: The invention relates to a method of automatically managing associations in a distributed environment between components requesting services and components providing services, comprising the following steps: dynamically discovering required services by means of a distributed service discovery protocol, advertising services provided by means of a distributed service discovery protocol, and producing a connection between a component requesting services and a component providing services. According to the invention, for at least one of said components, said requested services and/or said provided services are declared in a declaration file associated with the component that is analyzed when starting that component on a platform forming part of the distributed environment. Application to home automation networks and small office automation networks.

Abstract: A computer implemented method/system of creating and managing one or more interceptors. The method comprises the steps of intrinsically chaining the interceptors, and storing state information, in at least one of the chained interceptors, directed to a reference to the next interceptor. A server computer in a client-sever environment that includes a processor configured to generate one or more interceptors and to intrinsically chain the interceptors, and a memory associated with at least one of the chained interceptors and configured to store state information directed to a reference to the next interceptor thereof. The method/system, in various embodiments, includes dissimilar interceptors, callbacks, and flyweight pattern weighting.

Abstract: Techniques are provided for individual data objects in an enterprise computing system, where the individual data objects represent unique assets of a family of assets. The individual data objects are used in addition to business partner master data, and also in some cases in addition to generic product master data. The individual data objects are configurable such that attributes for an individual data object change over the lifetime of the unique asset to which the individual data object pertains. Techniques for modeling the lifecycle of an individual object family are described. Techniques also are provided for an integration framework that integrates a software application with an individual object that is used or altered by the software application.

Abstract: An instrumentation system performs operations such as profiling an application and partitioning and distributing units of the application using different versions of metadata describing the application. Performing an operation on an executing application generates overhead. Detailed metadata used in operations such as profiling create unnecessary overhead during other operations. By removing metadata detail unnecessary for a particular operation, an instrumentation system using reduced metadata generates less overhead for that particular operation. Different instrumentation packages include different versions of metadata for performing operations on the application.

Abstract: Systems and methods that interact with an enterprise clipboard are described. One example system embodiment includes logic to acquire an object item and logic to acquire information about the object item. The information may be metadata and/or contextual information. The example system embodiment includes logic to create a context associated with the object item. The example system embodiment includes logic to selectively provide to an enterprise clipboard the object item along with information about the object item so that the receiver of the object item and the information about the object item does not receive just data.

Abstract: A technique for determining whether a server host supports the functions in a command sent by a client host. The client host formulates a command including a command object that contains parameter objects. The parameter objects, which represent the functions, are serialized, e.g., using the Java serialization command, and communicated to the server host. The server host attempts to deserialize the parameter objects. If it is successful, it is concluded that the server host supports the functions represented by the parameter objects. Or, it is concluded that the server host is incompatible with the functions represented by one or more parameter objects that cannot be deserialized. The server host may be a storage server, and the functions may be storage-related, such as a copy type to be performed.

Abstract: Described are methods, apparatus and computer programs for determining run-time dependencies between logical components of a data processing environment. Components of the data processing environment are monitored by monitoring agents accessing run-time activity data via APIs of the managed system. A dependency generator identifies correlations between the run-time activity of the monitored components. For synchronous monitored systems, the dependency generator calculates an activity period for monitored components and determines which component's activity periods contain the activity periods of other components. Containment is used as an indicator of a likely dependency relationship, and a weighting is computed for each dependency relationship based on the consistency of containment.

Abstract: A computer implemented method that may include receiving an object manager request within an object oriented model, wherein said model comprises a first object manager comprising a first data format and a second object manager comprising a second data format different than the first data format and wherein the request is from the first object manager for information regarding a managed object managed by the second object manager. The method may also include intercepting the object manager request with a proxy provider able to communicate with the second object manager. The method may also include generating with the proxy provider a proxy request for information to the second object manager regarding the managed object managed by the second object manager.

Abstract: A method and a corresponding system for use in a resource management infrastructure conforming to the WMI architecture are proposed. The WMI architecture includes a framework, known as CIM Object Manager (or CIMOM), which exploits WMI providers of dynamic services for the managed objects; in the WMI architecture, the CIM providers must be implemented as Common Object Model (COM) objects and must comply with a specific WMI provider interface (named “IWbemServices”). The invention discloses a method for integrating non-compliant providers, for example written in the Java language, into the WMI infrastructure. For this purpose, a bridge provider is associated with each managed object that is supported by the Java providers. The bridge provider identifies the Java provider that must be invoked to fulfill a particular request (based on a specific CIM qualifier); the parameters of the request are converted into Java types, and a corresponding method is called on an intermediate Java object.

Abstract: A method of generating code that permits client access to a business process orchestration running on a server as a web service using the Simple Object Access Protocol (SOAP). Business process orchestrations in XLANG are converted to a web service implementation description from which the Web services code is generated. During runtime, when a SOAP request message comes into the server, it is passed to the target web method. The message is then passed to a Web services adapter that submits the request for further processing by the backend system. The response is forwarded to the Web services adapter, which returns the response as a SOAP response message to the client.

Abstract: A method and system is provided for managing resource groups in a computer system having an automatic availability capability. In one embodiment, a method is provided which may be performed in a computer system comprising a plurality of resources, a monitor for monitoring at least some of the plurality of resources, an agent to configure resource groups, each resource group specifying a group of resources to be monitored by the monitor, and a graphical user interface (GUI) that communicates with the monitor and provides an interface for a user to monitor a resource group. The method comprises: (A) providing, via the GUI, customized presentations to the user for monitoring resource groups of different types so that the GUI provides different presentations to the user in monitoring different types of resource groups.

Abstract: A client connected to a communication network performs an access request to an object. An application server performs an application by an actual object according to the client request. An object pool connected to the client and the application server pools a proxy object corresponding to the actual object and holds the actual object management information. The application server notifies the object pool of an event according to the status change of the application. The object pool automatically updates the actual object management information according to the notification of the event from the application server.

Abstract: A method for dispatching steps of an application running on an application server which can be accessed from client terminals. Users select user interaction elements on client terminals, and the interactions are transmitted to the application server executing a main part of an application, which creates output that contains the next set of possible user interactions. Calling application steps can be addressed and invoked by other application steps in order to reuse software components necessary for processing said other application steps. Nesting programming commands used to call another application step are arbitrarily nested and serve as a called sub-routine within the calling application step. Values are returned to the calling application step, and nesting paths of called application steps are discarded in case a user switches to another application.

Abstract: A computerized method for managing objects created in a directory service of a distributed computing environment, including a component for backing up and restoring a single or plurality of directory service objects, a component for delegating security privileges to permit access to directory service objects, a component for retrieving data in policy storage format and representing the data in human-readable form, a component having a graphical user interface including a display capable of searching and reporting policy storage data in human readable form, a component capable of replicating a single or plurality of directory service objects across the domain tree boundaries of the directory service, a component for analyzing the effect a particular setting will have on a particular target represented as a directory service object before the setting is added to the directory service.

Abstract: This disclosure involves dynamic business object properties for Enterprise Service Architecture (ESA) or other Service Oriented Architecture (SOA) architectures. For example, a method for dynamically modifying an interface in a SOA can comprise receiving a request for an interface associated with a business object, where the interface includes a plurality of fields configured to receive information from a client. The method can further identify current values of one or more attributes associated with the business object and dynamically modify at least one of the fields of the interface based, at least in part, on one or more of the current values.

Abstract: Under the present invention, a configurable dictionary is provided. The configurable dictionary includes a set of objects that identify: (1) attribute conditions of the computer system to be checked; (2) associated locations within the computer system for checking the attribute conditions; and (3) actions to be taken based on results of the checks for the computer system. The health of the computer system is checked by processing the set of objects in the configurable dictionary. Specifically, the attribute conditions identified in the configurable dictionary are checked at their associated locations, and any necessary action are implemented.

Abstract: In one aspect, there is provided a computer-implemented method. The method may include mapping, using a metamodel, one or more WSDL (Web Service Descriptor Language) statements associated with a web service to one or more metamodel objects. The one or more metamodel objects are used to generate a client proxy. The client proxy handles calls from a client application to the web service to enable the client application to call the web service without regard to the one or more WSDL statements. Related systems, apparatus, methods, and/or articles are also described.

Abstract: The disclosure includes a system and method for providing a business logic framework. In some implementations, a method includes identifying an event associated with business logic of an application framework. The application framework is associated with method framework logic and the business logic. One or more business objects are identified in accordance with the business logic. The business logic is executed using the identified one or more business objects independent of the method framework logic.

Abstract: A method includes receiving at least one of a widget or a reference to a widget, where the widget can be at least one of a static data object, a media object, or a software object. At least a portion of a widget container, which is a procedural software framework containing a service module associated with the widget and the widget, is generated. The service module can be a pre-defined function associated with the widget container before the widget container is generated. The widget container can be configured to be executed at a widget-container processing device in response to a reference to the widget container being accessed from a processor-readable vehicle.

Abstract: A data processing method includes declaring a server semantic object that specifies an operation independent of implementation. The server semantic object is delivered to a set of clients in different hardware environments. Each hardware environment stores a client semantic object specifying processing operations that implement the operation associated with the server semantic object for the hardware environment. The server semantic object is combined with each client semantic object in each hardware environment to produce server semantic object data at each client. The server semantic object data is presented at each client in accordance with a common protocol observed by each client.

Abstract: The structuring library of the invention is based on components for developing man-machine interfaces for command and control information systems comprising computer hardware, an operating system, and an execution environment for the development platform, and this library comprises, between the execution environment and the specific man-machine interface application, a technical layer grouping together an arrangement of non-specialized technical components in the application domain of said systems, each dedicated to an elementary task, their assembly providing the nonfunctional services to the application, and an application domain layer grouping together an arrangement of software components of the application domain, their assembly providing the functional services to the application, the whole serving as a basis for the MMI application considered.

Abstract: A method and system for processing a remote function call. According to one embodiment, an application receives from a local software component a request to execute an external software component, and makes one or more calls to a communications interface based on the received request, the communications interface including a standard set of routines for executing remote function calls.