swim rust

O Swim Rust SDK contém estrutura de software para criar aplicativos com estado com estado que podem ser interagidos por meio de APIs de streaming multiplexado. Ele é construído no topo do tempo de execução assíncrono de Tokio e é necessário um tempo de execução do Tokio para qualquer aplicação de natação.

Cada aplicativo consiste em algum número de agentes com estado, cada um dos quais é executado como uma tarefa de tokio separado e pode ser abordado individualmente por um URI. Um agente pode ter estado público e privado, que pode ser mantido apenas na memória ou, opcionalmente, em armazenamento persistente. O estado público do agente consiste em várias faixas, análogas a um campo em um registro. Existem vários tipos de faixas que, por exemplo, faixas contendo valores únicos e aqueles que contêm um mapa de pares de valor-chave.

O estado de qualquer pista pode ser observado estabelecendo um link para ele (de outra instância do agente ou de um cliente dedicado). Um link estabelecido levará todas as atualizações ao estado dessa pista para o assinante e também permitirá que o assinante solicite alterações ao estado (para os tipos de pista que suportam isso). Os links operam em uma conexão de soquete da Web e são multiplexados, o que significa que os links para várias faixas no mesmo host podem compartilhar uma única conexão de soquete da Web.

Site | Guia do desenvolvedor | DOCs da API do servidor | Docs da API do cliente

Guias de uso

Implementando agentes de natação em ferrugem

Construindo um aplicativo de servidor de natação

Documentação de referência

Exemplos

O exemplo a seguir executa um servidor de Swimos que hospeda uma rota de agente único, onde cada instância do agente possui uma pista única, chamada lane . Cada vez que são feitas alterações na pista, ela será impressa no console pelo servidor.

[ 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 exemplo, se um cliente de natação enviar uma atualização, com o valor 5 , para o agente no URI /examples/name da Lane lane , uma instância de ExampleAgent , usando ExampleLifecycle , será iniciada pelo servidor. O valor da pista será definido como 5 e o seguinte será impresso no console:

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

Vários aplicativos de exemplo estão disponíveis no diretório ExempliP_Apps, que demonstram recursos individuais, bem como aplicativos mais abrangentes.

Desenvolvimento

Veja o Guia de Desenvolvimento.

Licença

Este projeto está licenciado sob a licença Apache 2.0.