swim rust

Le SDK Swim Rust contient un cadre logiciel pour la création d'applications avec état qui peuvent être interagies via des API de streaming multiplexées. Il est construit au-dessus de l'exécution asynchrone de Tokio et un runtime tokio est requis pour toute application de natation.

Chaque application se compose d'un certain nombre d'agents avec état, chacun fonctionnant comme une tâche Tokio distincte et peut être traité individuellement par un URI. Un agent peut avoir un état public et privé qui peut être détenu uniquement en mémoire ou, éventuellement, dans un stockage persistant. L'état public de l'agent se compose d'un certain nombre de voies, analogues à un domaine dans un dossier. Il existe plusieurs types de voies qui, par exemple, des voies contenant des valeurs uniques et celles contenant une carte des paires de valeurs clés.

L'état de toute voie peut être observé en établissant un lien vers lui (soit à partir d'une autre instance d'agent, soit d'un client dédié). Un lien établi poussera toutes les mises à jour vers l'état de cette voie à l'abonné et permettra également à l'abonné de demander des modifications à l'État (pour les types de voies qui le soutiennent). Les liens fonctionnent sur une connexion en ligne et sont multiplexés, ce qui signifie que les liens vers plusieurs voies sur le même hôte peuvent partager une seule connexion Web-Socket.

Site Web | Guide du développeur | Docs API du serveur | Docs API client

Guides d'utilisation

Implémentation d'agents de natation à la rouille

Construire une application de serveur de natation

Documentation de référence

Exemples

L'exemple d'application suivante exécute un serveur Swimos qui héberge une route d'agent unique où chaque instance d'agent a une voie unique, appelée lane . Chaque fois qu'une modification est apportée à la voie, elle sera imprimée sur la console par le serveur.

[ 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 ) ;
            } )
        } )
    }
}

Par exemple, si un client de natation envoie une mise à jour, avec la valeur 5 , à l'agent de l'URI /examples/name de la lane de voie, une instance d' ExampleAgent , à l'aide ExampleLifecycle , sera lancée par le serveur. La valeur de la voie sera ensuite définie sur 5 et les éléments suivants seront imprimés sur la console:

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

Un certain nombre d'exemples d'applications sont disponibles dans le répertoire Exemple_Apps qui démontrent des fonctionnalités individuelles ainsi que des applications plus complètes.

Développement

Voir le guide de développement.

Licence

Ce projet est concédé sous licence Apache 2.0.