Microsoft Technology Licensing, LLC

Richard Douglas Hill

Craig Andrew Critchley

Krishnan Srinivasan

Rodney Thomas Limprecht

Shy Cohen

Uday Sooryakant Hegde

Gueorgui Chkodrov

Stefan R Batres

Alexander A Mitchell

Craig Henry Wittenberg

Satish Ramchandra Thatte

Tihomir Tsvetkov Tarnavski

Rebecca Ann Norlander

David Owen Driver

Pramod Gurunath

Mitchell G Morris

David E Langworthy

Alan Geller

Hany E Ramadan

Edward K Y Jung

Paul J Leach

Jan Stephen Gray

Kenneth David Wolf

Robert George Atkinson

Antony S Williams

Stephen James Millet

James M Lyon

Anthony Dean Andrews

Mario C Goertzel

Alexander Dadiomov

Shannon J Chan

Michael Marucheck

Gopal Krishna R Kakivaya

Richard Dievendorff

Tom Corbett

Eric Wendell Johnson

Alexander A Armanasu

Michael Thomas Dice

Scott G Robinson

Nicholas Alexander Allen

Christopher G Kaler

Erik B Christensen

John Anthony Taylor

Christopher Wellington Brumme

Giovanni Moises Della-Libera

David Wortendyke

Michael Joseph Toutonghi

James Ernest Johnson

Tirunelveli R Vishwanath

Lance Olson

Edmund Samuel Victor Pinto

Umesh Madan

Michael James Coulson

Stefan Harrington Pharies

John David Doty

Vijay Gajjala

Elliot Lee Waingold

Matthew Thomas Tavis

Geary L Eppley

Tomasz Janczuk

Michael Steven Vernal

David Edwin Levin

Stephen T Swartz

Max A Feingold

Bharat Shah

Natasha Harish Jethanandani

Douglas M Purdy

Gregory C Johnson

Siddhartha Puri

Saurab Nog

Aaron Stern

Jesus Ruiz-Scougall

Anastasios Kasiolas

Douglas A Walter

Kapil Gupta

Vipul A Modi

Ryan Thomas Sturgell

Dean A Wells

Scott Christopher Seely

Jonathan T Wheeler

Margaret J Lye

Evgeny Osovetsky

Dave Dopson

Mansoor Mohsin

Alexander Martin DeJarnatt

Mohammad Makarechian

Sowmyanarayanan K Srinivasan

Erin Honeycutt

Chaitanya Dutt Upadhyay

Yaniv Pessach

Mauro Ottaviani

Uday S Hedge

Yasser Shohoud

Alfred M Lee, Iv

Kirill Gavrylyuk

Eugene Shvets

Gregoire Guetat

Anand Rjagopalan

Mohamed-Hany Essam Ramadan

Serge Sverdlov

Embodiments described herein allow a service component author to write service components without having to handle incoming messages being received at any time. This may be facilitated by a message dispatch engine that dispatches messages from the incoming message queue only when the destination service component has indicated that it is ready to receive the message having that context. If the service component is not yet ready for the message, the message dispatch component may lock the message at least until the destination service component indicates that it is now ready to receive the message. Until that time, the message dispatch engine may ignore the locked message when finding messages to dispatch.

Queued message dispatch

The present invention extends to methods, systems, and computer program products for domain controller safety-features and cloning. Embodiments include cloning virtual domain controllers. Cloning permits virtual domain controllers to be rapidly deployed by copying/cloning the entire operating system state of an existing virtual domain controller. Other embodiments provide safety features protecting domain controllers running within virtual machines from introducing distributed corruption into a directory services data system. Protection is facilitated by detecting when a hypervisor or Virtual Machine Manager ('VMM') uses features that cause a virtual machine to be rolled back in time outside of an operating system's awareness. In response to detecting a feature that causes rollback, safeties can be implemented to compensate for otherwise divergent state and prevent the introduction of duplicate unique identifiers.

Domain controller safety-features and cloning

The present invention extends to methods, systems, and computer program products for configuring assurances within distributed messaging systems. A defined set of message log and cursor components are configurably activatable and deactivatable to compose a variety of different capture assurances, transfer assurances, and delivery assurances within a distributed messaging system. A composition of a capture assurance, a transfer assurance, and a delivery assurance can provide an end-to-end assurance for a messaging system. End-to-end assurances can include one of best effort, at-most-once, at-least-once, and exactly once and can include one of: durable or non-durable. Using a defined set of activatable and deactivatable message log and cursor components facilities more efficient transitions between desired assurances. In some embodiments, a composition of a capture assurance, a transfer assurance, and a delivery assurance provides durable exactly-once message delivery.

Distributed messaging system with configurable assurances

The present invention extends to methods, systems, and computer program products for durable exactly once message delivery at scale. A message capture system uses a synchronous capture channel and transactions to provide durable exactly once message capture. Messages are sent from the message capture system to a message delivery system over a network using an at least once transfer protocol. The message delivery system implements a durable at most once messaging behavior, the combination of which results in durable exactly once transfer of messages from the message capture system to the message delivery system. The message delivery system uses a synchronous delivery channel and transactions to provide durable exactly once message delivery. Cursors maintaining message consumer state are collocated with message consumers, freeing up message log resources to process increased volumes of messages, such as, for example, in a queued or pub/sub environment.

Durable exactly once message delivery at scale

The present invention extends to methods, systems, and computer program products for distributed aggregation on an overlay network. Embodiments of the invention utilize tiers of nodes that are cascaded in a layered system. Each tier reduces the size of data by orders of magnitude through pre-aggregation. Thus, high volume streams of messages can be reduced to lower volume streams at large scales, such as, for example, the Internet. No central coordination is used; thus there is no central point of failure or bottleneck. When a node fails, other nodes in the same tier as the failing node automatically take over the responsibilities of the failed node.

Distributed aggregation on an overlay network

Methods, systems, and computer program products that provide for a runtime messaging infrastructure, which abstracts send and receive operations for exchanging messages with partner endpoint. The messaging infrastructure improves availability and scalability of a message application by improving on the availability and scalability of the underlying message transports. In particular, availability and scalability are improved by linking the message application at runtime with any number of the message transports, without the message application specifying a transport at development time. The message infrastructure receives instructions from the message application specifying end-to-end delivery assurances. The infrastructure uses transports in order to fulfill the specified delivery assurance, and creates a link between the message application and transports for use in exchanging messages. Session state storage can be maintained in a pluggable store, which could be, for example, a durable database store or an application memory store.

Availability and scalability in a messaging system in a manner transparent to the application

The present invention extends to methods, systems, and computer program products for maintaining message state at a cursor. A message consumer requests messages from a cursor. The cursor can maintain state information for the message consumers separately from a message log that stores messages. Any of a variety of message delivery assurances can be used when delivering a message to a message consumer.

Message state maintenance at a cursor

The present invention extends to methods, systems, and computer program products for maintaining message state at a message log. Messages are accumulated at a message log in accordance with a message retention policy. Any of a variety of message capture assurances can be used when capturing a message from a message producer within a message log. A message becomes visible to message consumers after the outcome of writing the message is known (either failure or success). Messages are requested using (e.g., monotonically increasing) sequence numbers. Messages are also dropped from the message log in accordance with the message retention policy.

Message state maintenance at a message log

The present invention monitors the receipt of messages between two endpoints on established sequence session in accordance with a Reliable Messaging protocol for Web Services (RM-WS protocol). The messages received may be application or infrastructure messages (e.g., acknowledgement messages in accordance with the RM-WS protocol). Further, the present invention defines a time period known as the inactivity timeout, which is an upper limit to the time that may pass without receiving a message (either application or infrastructure) on the sequence session. Based on this inactivity timeout period, the present invention calculates time periods for sending idempotent infrastructure messages in accordance with the RM-WS protocol for verifying and maintaining connection liveliness.

Verifying and maintaining connection liveliness in a reliable messaging for web services environment

The present invention provides for flow and congestion control mechanisms in accordance with a Reliable Message protocol for Web Services (RM-WS). For flow control, one endpoint informs another endpoint of its available buffer size by including buffer size information in response messages. The response messages, typically RM-WS infrastructure messages, are then used to determine an upper limit on the number of messages that can be sent to the acceptor in order to prevent resending messages due to buffer overrun. In the case of congestion control, embodiments provide for increasing the number of in-flight messages until a failure point is found. The last successful rate below the failure point is the closest known point to the optimum point. Example embodiments then reset and try again raising the rate back to the last known good point and fine tuning from there using an algorithm that asymptotes the optimum rate.

Efficient transfer of messages using reliable messaging protocols for web services

A single programming model is provided for accessing a plurality of distinct message transports while developing one or more applications for message delivery between two endpoints. The programming model allows for independently configurable assurances and features for transporting the messages. The configurable assurances may be selected from at least once delivery, at most once message delivery, in order message delivery, and message time to live. The independently chosen features may include a session state storage, an extension of time to live, and transacted message buffering.

Message delivery with configurable assurances and features between two endpoints

The present invention extends to methods, systems, and computer program products for using subqueues to enhance local message processing. Messages include queue IDs comprised of a parent portion and a suffix portion. The parent portion identifies a parent queue and the suffix portion identifies a subqueue of the parent queue. Message are logically moved between queues by changing suffix values, such as, for example, between subqueues, between the parent queue and a subqueue, and between a subqueue and the parent queue. Applications can examine messages and route messages to specified subqueues based on message content (including message bodies and headers). Suffix values can be changed in place (e.g., while the message remains physically stored in the queue) so as to preserve message sender identity and to avoid prematurely acknowledging delivery (i.e., no return ACK is generated).

Using subqueues to enhance local message processing

The present invention extends to methods, systems, and computer program products for failed message error recovery using application specific error queues. An application message, a reference to a receive queue that corresponds to a receiving application, and a reference to an application specific error queue specific to a sending application are received from the sending application. The application message is enqueued in a transmission queue. Transfer of the application message to the receive queue is attempted. It is detected that the application message was not delivered to the receiving application due to an error. The application message is moved from the transmission queue to the application specific error queue. The application message and appropriate error information is returned from the application specific error queue to the sending application.

Failed message error recovery using application specific error queues

The present invention extends to methods, systems, and computer program products for reliably and securely transferring queued application messages. Application messages are (e.g.,. binary or text) encoded and then encapsulated in transfer messages, enqueue messages, and dequeue responses such that composable protocol elements used in application messages can be reused in the transfer messages, enqueue messages, and dequeue responses. Transfer message headers are encoded and then encapsulated along with encoded application messages such that composable protocol elements used in transfer headers and application messages can be reused in the store and forward messages. Application messages, transfer messages, enqueue messages, dequeue responses, and store and forward messages can all be configured in accordance with the same messaging protocol, such as, for example, Simple Object Access Protocol. Since encapsulated elements are encoded, the encapsulated elements do not interfere with configuration of wrapping messages.

Reliably transferring queued application messages

Growing community of inventors

Kirkland, WA, United States of America

Richard Douglas Hill