swim rust

Das Swim Rust SDK enthält Software -Framework zum Erstellen staatlicher Anwendungen, die mit Multiplex -Streaming -APIs interagiert werden können. Es ist auf der Tokio Asynchronous -Laufzeit aufgebaut und für jede Schwimmanwendung ist eine Tokio -Laufzeit erforderlich.

Jede Anwendung besteht aus einer Reihe staatlicher Agenten, von denen jede als separate Tokio -Aufgabe ausgeführt wird und von einem URI einzeln behandelt werden kann. Ein Agent hat möglicherweise sowohl öffentlichen als auch privaten Staaten, der entweder ausschließlich im Speicher oder optional im anhaltenden Speicherplatz gehalten werden kann. Der öffentliche Zustand des Agenten besteht aus einer Reihe von Gassen, die in einem Datensatz analog zu einem Feld sind. Es gibt mehrere Arten von Gassen, die beispielsweise Fahrspuren mit einzelnen Werten und solchen enthalten, die eine Karte von Schlüsselwertpaaren enthalten.

Der Zustand jeder Fahrspur kann beobachtet werden, indem eine Verbindung dazu hergestellt wird (entweder von einer anderen Agenteninstanz oder einem speziellen Kunden). Ein etablierter Link wird alle Aktualisierungen des Standes dieser Spur zum Abonnenten übertragen und es dem Abonnenten auch ermöglichen, Änderungen am Staat anzufordern (für Spur -Arten, die dies unterstützen). Die Links arbeiten über eine Web-Socket-Verbindung und werden multiplexiert, was bedeutet, dass Links zu mehreren Fahrspuren auf demselben Host eine einzelne Websocket-Verbindung freigeben können.

Website | Entwicklerleitfaden | Server -API -Dokumente | Client -API -Dokumente

Nutzungsführer

Implementierung von Schwimmagenten in Rost

Erstellen einer Schwimmserveranwendung

Referenzdokumentation

Beispiele

In der folgenden Beispielanwendung wird ein Swimos -Server ausgeführt, auf dem eine einzige Agentenroute gehostet wird, auf der jede Agenteninstanz eine einzelne Spur namens lane hat. Jedes Mal, wenn eine Änderung an der Spur vorgenommen wird, wird sie vom Server auf der Konsole gedruckt.

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

Wenn beispielsweise ein Swim -Client ein Update mit dem Wert 5 an den Agenten an den URI /examples/name für die Lane lane sendet, wird eine Instanz von ExampleAgent unter Verwendung von ExampleLifecycle vom Server gestartet. Der Wert der Fahrspur wird dann auf 5 gesetzt und das Folgende wird auf der Konsole gedruckt:

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

Eine Reihe von Beispielanwendungen sind im Verzeichnis example_apps verfügbar, das individuelle Funktionen sowie umfassendere Anwendungen zeigt.

Entwicklung

Siehe den Entwicklungsleitfaden.

Lizenz

Dieses Projekt ist unter der Apache 2.0 -Lizenz lizenziert.