)

// Target is the entity that we will receive
// a single log entry and Send it to the log target
//
//	e.g. Send the log to a http server
type Target interface {
	String() string
	Endpoint() string
	Stats() types.TargetStats
	Init(ctx context.Context) error
	IsOnline(ctx context.Context) bool
	Cancel()
	Send(ctx context.Context, entry any) error
	Type() types.TargetType
}

type targetsList struct {

        content = f"notification for {email}: {message}"
        email_file.write(content)


@app.post("/send-notification/{email}")
async def send_notification(email: str, background_tasks: BackgroundTasks):
    background_tasks.add_task(write_notification, email, message="some notification")

            assertThrows(CIFSException.class, handle::getSessionKey);
        }
    }

    @Nested
    @DisplayName("Send/Receive Fragment Tests")
    class SendReceiveFragmentTests {

        @Test
        @DisplayName("Should send and receive fragment successfully")
        void testDoSendReceiveFragment_Success() throws Exception {

            setTree(c, tree);
            return handle;
        }).when(c).connectHost(any(), anyString());

        // Execute send - should retry after transport error
        try {
            c.send(loc, req, resp, EnumSet.noneOf(RequestParam.class));
        } catch (Exception e) {
            // It's ok if it fails, we just want to verify reset was called
        }

     *
     * Operations larger than this size will use RDMA read/write
     * instead of send/receive.
     *
     * @return threshold in bytes
     */
    int getRdmaReadWriteThreshold();

    /**
     * Get maximum RDMA send size
     *
     * @return max send size in bytes
     */
    int getRdmaMaxSendSize();

    /**
     * Get maximum RDMA receive size
     *

        assertNotNull(capabilities, "Capabilities should not be null");
        assertEquals(1, capabilities.size(), "TCP provider should only support send/receive");
        assertTrue(capabilities.contains(RdmaCapability.RDMA_SEND_RECEIVE), "Should support send/receive");
        assertFalse(capabilities.contains(RdmaCapability.RDMA_READ), "Should not support RDMA read");

---
name: Feature request
about: Suggest an idea
title: ''
labels: enhancement
assignees: ''

---

Start by telling us what problem you’re trying to solve. Often a solution already exists!

     * @throws IOException if an I/O error occurs
     */
    protected abstract Request peekKey() throws IOException;

    /**
     * Sends a request to the remote endpoint.
     *
     * @param request the request to send
     * @throws IOException if an I/O error occurs
     */
    protected abstract void doSend(Request request) throws IOException;

    /**

        // Send FSCTL_QUERY_NETWORK_INTERFACE_INFO
        Smb2IoctlRequest request = new Smb2IoctlRequest();
        request.setCtlCode(FSCTL_QUERY_NETWORK_INTERFACE_INFO);
        request.setFileId(new byte[16]);  // Use session ID
        request.setMaxOutputResponse(65536);
        
        Smb2IoctlResponse response = (Smb2IoctlResponse) session.send(request);
        

            assertEquals("Test IO Exception", thrown.getMessage());
        }
    }

    @Nested
    @DisplayName("Send/Receive Tests")
    class SendReceiveTests {

        @Test
        @DisplayName("Should handle basic send/receive fragment methods")
        void testSendReceiveFragmentMethods() throws IOException {
            // Given: Test handle with configured return values