Emc Corporation

Dell Products Inc.

Emc IP Holding Company LLC

Emc Coropration

Ruben Michel

Tao Kai Lam

Ilya Liubovich

Stanislav Sosnovsky

Victoria Dubrovsky

Eitan Bachmat

Richard Francis Cormier

David W DesRoches

Avinoam Zakai

Yuval Ofek

Ohad Zeliger

Shai Bar-Nefy

Satish Suryanarayan

Ron Arnan

Vitaly Rozenman

Yoav Raz

Moshe Schreiber

Avigail Matalon

Musik Schreiber

Dan Lottero

One or more aspects of the present disclosure relate to providing a worker archive with access to a coordinating archive. In embodiments, a worker archive is provided access to one or more components in a main coordinating archive. In addition, an incoming protocol communication is processed using a subject component from the main coordinating archive using the worker archive.

Providing a worker EAR with access to a coordinating EAR

An example methodology includes, by a server, establishing a request-response communication connection with one or more clients, wherein each request-response communication connection is initiated by the one or more clients, and upgrading the request-response communication connection to a bidirectional connection. The method also includes, by the server, determining a message to send to the one or more connected clients, creating an identifier (ID) for each message to be sent, wherein the ID is unique to each of the one or more connected clients, and broadcasting the message with respective IDs on the bidirectional connection to the one or more connected clients. The server can receive a response message that includes the ID included with the broadcast message from the one or more connected clients, wherein the response message from a connected client is sent on the bidirectional connection between the server and the connected client.

Reverse request-response message exchange

One or more aspects of the present disclosure relate to disabling executable instructions from a network message. In embodiments, a message can be received at a server. In addition, one or more executable instructions can be disabled from the message. Further, the message with the disabled one or more executable instructions can be processed.

Disabling executable instructions from a network message

One or more aspects of the present disclosure relate to tunneling messages corresponding to a first protocol through a second protocol. In embodiments, a communication engine can be provided to a client. The communication engine can intercept a first communication message directed to a server on a client. For example, the first communication message can correspond to the first protocol. Additionally, the first communication message can be converted into a second communication message corresponding to a second protocol. Further, a persistent second protocol communication session can be initiated between the client and server by transmitting the second protocol message. In embodiments, the first protocol can correspond to a Hypertext Transfer Protocol Secure (HTTPS), and the second protocol can correspond to a WebSocket protocol.

Tunneling a first protocol communication message through a second protocol communication channel

A storage system query mechanism and corresponding techniques for implementing queries are provided. In one exemplary method, queries are processed by providing a server-side meta-model for creating queries on the server; and providing a client-side meta-model for creating queries on the client, wherein the client and the server are based on different programming languages and wherein the queries created on the client are translated from a language of the client into a language of the server for processing by the server. The query results are optionally converted to data transfer objects for presentation on the client. In an exemplary query service method, at least one base meta-model is provided having a plurality of base classes and a domain-specific injection point; and at least one domain-specific meta-model is received and injected into the base meta-model at the domain-specific injection point.

Storage system query mechanism and techniques

A storage system query mechanism and corresponding techniques for implementing queries are provided. In an exemplary method, control path data in a storage array is processed by obtaining an object model (OM) data object comprising retrieved control path data upon an initial user request; storing the OM data object in a cache using one or more fa&#xe7;ade data classes; employing a refresh service to listen to refresh events that impact a validity of the OM data object, wherein the OM data object is evicted from the cache when the validity of the OM data object is impacted by one of the refresh events; and delivering the OM data object from the cache upon a subsequent user request if the OM data object remains in the cache at a time of the subsequent user request.

A storage system query mechanism and corresponding techniques for implementing queries are provided. Queries can be created on a client and server, where the client and the server are based on different programming languages, by providing a server-side meta-model and client-side meta-model. A base meta-model is provided having a plurality of base classes and a domain-specific injection point to allow domain specific meta-models to be injected into the base meta-model. Domain-specific query executors can be employed to process a query. Techniques are also provided for caching control path data in a storage array using one or more fa&#xe7;ade data classes and a refresh service to listen to refresh events that impact a validity of the cached data objects. Applications can optionally register domain specific query executors, object model providers and/or class loaders. Query results can be presented on a client device by providing a declarative data grid component as part of a graphical user interface.

A method, apparatus and computer program product for using correlated stack traces to determine faults in client/server software is presented. Client/server software is executed. A client call stack is maintained on the client and a server call stack is maintained on the server. When an unexpected occurrence is detected while running the client/server software then the client call stack is collected, as is the server call stack. The client call stack and the server call stack are correlated to produce a correlated call stack and the correlated call stack is provided to a user.

Using correlated stack traces to determine faults in client/server software

A system uses generative aspect oriented programming to propagating context between components in a component server, the system produces code that, when executed, implicitly propagates authenticating context between a client component and an invoked component which the client component invokes in a component server. The system generates a function that allows the specification of a timeout between the client component and the invoked component that the client component invokes in the component server. The timeout function receives a user-defined timeout value to be applied for interface invocations between the client component and the invoked component. The system further generates a function declaration that, upon execution, discloses a target component identity between a client component and an invoked component that the client component invokes in the component server. The target component identity specifies a specific identity of a target computer system to which an interface invocation between the client component and the invoked component is directed.

Methods and apparatus providing a categorical approach to aspect-oriented programming

A system produces a component framework that insulates components from an underlying communication infrastructure by receiving a component descriptor that specifies fundamental properties of a component and receiving a definition of remotable interfaces associated with the component. A generation tool emits a component framework that includes: i) a coInterface interface that exposes the component's remotable interfaces; ii) a coFactories interface that declares factories for component operation; iii) a template for a coClass class, the coClass class operable to receive developer programmed functionality; and iv) a coBridge class that extends the coClass class and functions as a morphism from an IDL-defined component to an object model based, middleware-independent component.

Categorical approach for implementing a software component development architecture

A code generator generates component controllers by receiving, as input, an identity of a component and identities of dependent components of the component and applying a categorical-based generator that applies at least one morphism to generate at least one component controller to manage both collocated and remote access to the dependent components of the component in a strongly typed manner. Application of the categorical based generator includes generating at least one service-component controller for controlling service components that, during operation, are instantiated upon component server initialization to provide services to other components during component server operation and generating at least one session-component controller for controlling session components instantiated, utilized for services during a session, and terminated as needed by other components.

Methods and apparatus providing a categorical approach to strongly typed component management

A system provides a generation tool that emits a method declaration in a coFactory, and further emits the method's definition in a coBridge. Locating a naming service is delegated to a server infrastructure, and names of the sought after interface and the required component are further emitted. The generative approach disclosed assures a proper type of a downcast. Errors are handled by throwing an exception if either the component or its interface is absent. The coClass implements the coFactories, and a developer of a component can access other component by simply invoking a method within the coClass, which is implemented in a coBridge.

System and methods for generating a software component interface

A software build framework includes and architecture to identify software components including sets of classes, or objects, and categorizes the objects into layers in the component. A set of build rules identifies allowable dependencies between the component layers among the same and other components in the system, as well as external entities such as off the shelf (OTS) and third party vendor products outside the development control. The build mechanism enumerates a set of dependencies for each of the components, and an enforcer analyzes the dependencies to identify dependencies in violation of the rules. The enforcer separates the compile time and runtime inheritance paths to detect indirect monolithic inheritance. In this manner, dependency rules define an efficient and optimal architecture which lends itself well to modifications, timely builds and deliverable releases, and enforces the dependency rules at compile time so as to avoid generating an obsolete or suspect build.

System and methods for defining a software build

A system provides categorical mapping of valuetypes by receiving, as input, a valuetype within an object model specification. The system applies a categorical-based generator that applies at least one morphism to the object model specification. Application of the categorical-based generator generates an interface that exposes the valuetype in an interface object model and generates an implementation of the interface that exposes the valuetype in a middleware implementation object model. The interface and its implementation seamlessly support valuetype properties including inheritance, null values, native casting and arbitrary graph communication.

Methods and apparatus for providing a categorical approach to valuetype bridge support

Conventional development architectures for software system development employ varied invocation and triggering mechanisms for various objects and processes, such as services. Integrating new services tends to impose substantial changes in multiple code objects, requires retroactive testing, and increases the risk of failure. A services architecture in which users of a service seamlessly employ a respective service using only the objects, classes, and entities germane to the service usage provides interprocess module and service entity invocation. Extraneous definitions and functions, such as housekeeping relating to activation and passivation, location (module or component) of the service, and memory allocation, are removed from the user view. The architecture provides for automatic activation in the event components for providing the service have been passivated. Invocation requests are mapped across modules to the appropriate service entities. In this manner, the services architecture provides a seamless user view of the service by handling extraneous functions and allowing the service user to focus on the subscriber rather than the service implementation detail.

Growing community of inventors

Hopkinton, MA, United States of America

Ruben Michel