async with AsyncExitStack() as stack:
            scope[self.context_name] = stack

    on('build', function(req) { req.httpRequest.headers['X-Minio-Extract'] = 'true'; }).
    on('httpData', function(chunk) { file.write(chunk); }).
    on('httpDone', function() { file.end(); }).

    server.send(message3)
    clientListener.assertTextMessage(message3)

    // Empty client to server message.
    val message4 = ""
    client.send(message4)
    serverListener.assertTextMessage(message4)

    // Server to client message that shares context with message1.
    val message5 = message1 + message1
    server.send(message5)
    clientListener.assertTextMessage(message5)

This is normally called a **webhook**.

## Webhooks steps { #webhooks-steps }

The process normally is that **you define** in your code what is the message that you will send, the **body of the request**.

You also define in some way at which **moments** your app will send those requests or events.

# ----------------------------------------------------------
#                                                      Mail
#                                                     ------
# Does it send mock mail? (true: no send actually, logging only)
mail.send.mock = false

# SMTP server settings for main: host:port
mail.smtp.server.main.host.and.port = localhost:25

# The prefix of subject to show test environment or not

    }

    /**
     * Get preferred send size
     *
     * @return preferred send size in bytes
     */
    public int getPreferredSendSize() {
        return preferredSendSize;
    }

    /**
     * Set preferred send size
     *
     * @param preferredSendSize preferred send size in bytes
     */
    public void setPreferredSendSize(int preferredSendSize) {

        Smb2CreateResponse createResp;
        try {
            createResp = th.send(create);
        } catch (final SmbException e) {
            final Smb2CreateResponse cr = create.getResponse();
            if (cr != null && cr.isReceived() && cr.getStatus() == NtStatus.NT_STATUS_SUCCESS) {
                try {
                    th.send(new Smb2CloseRequest(th.getConfig(), cr.getFileId()));

    }
    
    /**
     * Establish RDMA connection
     */
    public abstract void connect() throws IOException;
    
    /**
     * Send data using RDMA
     */
    public abstract void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException;
    
    /**
     * Receive data using RDMA  
     */
    public abstract ByteBuffer receive(int timeout) throws IOException;

                    }
                } else {
                    logger.warn("Failed to send {} to {}. HTTP Status is {}. {}", body, url, response.getHttpStatusCode(),
                            response.getContentAsString());
                }
            } catch (final IOException e) {
                logger.warn("Failed to send {} to {}.", body, url, e);
            }
        }));
    }

    /**

	maps.Copy(ntargets, list.targets)
	return ntargets
}

// Send - sends events to targets identified by target IDs.
func (list *TargetList) Send(event Event, id TargetID) (*http.Response, error) {
	list.RLock()
	target, ok := list.targets[id]
	list.RUnlock()
	if ok {
		return target.Send(event)
	}
	return nil, ErrARNNotFound{}
}

// Stats returns stats for targets.