swim rust

El SDK de Swim Rust contiene un marco de software para construir aplicaciones con estado que se pueden interactuar a través de API de transmisión multiplexadas. Está construido sobre el tiempo de ejecución asíncrono de Tokio y se requiere un tiempo de ejecución de Tokio para cualquier aplicación de natación.

Cada aplicación consta de un número de agentes con estado, cada uno de los cuales se ejecuta como una tarea de Tokio separada y puede ser abordada individualmente por un URI. Un agente puede tener un estado público y privado que se puede mantener únicamente en la memoria o, opcionalmente, en el almacenamiento persistente. El estado público del agente consiste en una serie de carriles, análogos a un campo en un registro. Hay múltiples tipos de carriles que, por ejemplo, los carriles que contienen valores únicos y aquellos que contienen un mapa de pares de valor clave.

El estado de cualquier carril se puede observar estableciendo un enlace a él (ya sea desde otra instancia de agente o un cliente dedicado). Un enlace establecido impulsará todas las actualizaciones al estado de ese carril al suscriptor y también permitirá que el suscriptor solicite cambios al estado (para los tipos de carril que lo respalden). Los enlaces funcionan a través de una conexión al socket web y se multiplexan, lo que significa que los enlaces a múltiples carriles en el mismo host pueden compartir una sola conexión de socket.

Sitio web | Guía de desarrolladores | Servidor API Docs | Documentos de API del cliente

Guías de uso

Implementación de agentes de natación en óxido

Construyendo una aplicación de servidor de natación

Documentación de referencia

Ejemplos

La siguiente aplicación de ejemplo ejecuta un servidor SWIMOS que aloja una ruta de un solo agente donde cada instancia de agente tiene un solo carril, llamado lane . Cada vez que se realiza un cambio en el carril, el servidor imprimirá en la consola en la consola.

[ dependencies ]
swimos = { version = " 0.1.1 " , features = [ " server " , " agent " ] }

 use swimos :: {
    agent :: {
        agent_lifecycle :: HandlerContext ,
        agent_model :: AgentModel ,
        event_handler :: { EventHandler , HandlerActionExt } ,
        lanes :: ValueLane ,
        lifecycle , AgentLaneModel ,
    } ,
    route :: RoutePattern ,
    server :: { until_termination , Server , ServerBuilder } ,
} ;

# [ tokio :: main ]
pub async fn main ( ) -> Result < ( ) , Box < dyn std :: error :: Error > > {
    // An agent route consists of the agent definition and a lifecycle.
    let model = AgentModel :: new ( ExampleAgent :: default , ExampleLifecycle . into_lifecycle ( ) ) ;

    let server = ServerBuilder :: with_plane_name ( "Example Plane" )
        . set_bind_addr ( "127.0.0.1:8080" . parse ( ) ? ) // Bind the server to this address.
        . add_route ( RoutePattern :: parse_str ( "/examples/{id}" ) ? , model ) // Register the agent we have defined.
        . build ( )
        . await ? ;

    // Run the server until we terminate it with Ctrl-C.
    let ( task , handle ) = server . run ( ) ;
    let ( ctrl_c_result , server_result ) = tokio :: join! ( until_termination ( handle , None ) , task ) ;

    ctrl_c_result? ;
    server_result? ;
    Ok ( ( ) )
}

// Deriving the `AgentLaneModel` trait makes this type into an agent.
# [ derive ( AgentLaneModel ) ]
struct ExampleAgent {
    lane : ValueLane < i32 > ,
}

// Any agent type can have any number of lifecycles defined for it. A lifecycle describes
// how the agent will react to events that occur as it executes.
# [ derive ( Default , Clone , Copy ) ]
struct ExampleLifecycle ;

// The `lifecycle` macro creates an method called `into_lifecycle` for the type, using the
// annotated event handlers methods in the block.
# [ lifecycle ( ExampleAgent ) ]
impl ExampleLifecycle {
    # [ on_event ( lane ) ]
    fn lane_event (
        & self ,
        context : HandlerContext < ExampleAgent > ,
        value : & i32 ,
    ) -> impl EventHandler < ExampleAgent > {
        let n = * value ;
        context . get_agent_uri ( ) . and_then ( move |uri| {
            context . effect ( move || {
                println ! ( "Received value: {} for 'lane' on agent at URI: {}." , n , uri ) ;
            } )
        } )
    }
}

Por ejemplo, si un cliente de natación envía una actualización, con el valor 5 , al agente en el URI /examples/name para el lane del carril, el servidor iniciará una instancia de ExampleAgent , utilizando ExampleLifecycle . El valor del carril se establecerá en 5 y el siguiente se imprimirá en la consola:

 Received value: 5 for 'lane' on agent at URI: /examples/name.

Hay varias aplicaciones de ejemplo disponibles en el directorio Ejemplo_Apps que demuestra características individuales, así como aplicaciones más completas.

Desarrollo

Consulte la Guía de desarrollo.

Licencia

Este proyecto tiene licencia bajo la licencia Apache 2.0.