actix / actix: framework d'acteur pour Rust.

Actix est un framework d'acteurs Rust.

Plate-forme État de la construction
Linux
macOS état de construction
les fenêtres état de construction

Caractéristiques

  • Acteurs Async / Sync.
  • Communication d'acteur dans un contexte local / thread.
  • Utilise Futures pour la gestion des messages asynchrones.
  • Prise en charge HTTP1 / HTTP2 (actix-web)
  • Supervision des acteurs.
  • Messages dactylographiés (Non Tout type).

Usage

Utiliser actix, ajoutez ceci à votre Cargo.toml:

[[dépendances]
actix = "0.10.0-alpha.3"

Initialiser Actix

Pour utiliser actix, vous devez d'abord créer un Système.

fn principale() {
    laisser système = actix::Système::Nouveau("tester");

    système.courir();
}

Actix utilise la boucle d'événements tokio.
Système :: new () crée une nouvelle boucle d'événements et démarre le Système acteur.
system.run () démarre la boucle d'événement tokio et se terminera une fois Système acteur
reçoit le SystemExit message.

Créons un acteur simple.

Mettre en œuvre un acteur

Afin de définir un acteur, vous devez définir une structure et la faire implémenter
les Acteur trait.

utilisation actix::{Acteur, Addr, Arbiter, Context, System};

struct MyActor;

impl Acteur pour MyActor {
    type Le contexte = Contexte <Soi>;

    fn commencé(&mut soi, ctx: &mut Soi::Le contexte) {
        println!("Je suis vivant!");
        Système::actuel().Arrêtez(); // <- système d'arrêt
    }
}

fn principale() {
    laisser système = Système::Nouveau("tester");

    laisser adr = MyActor.début();

    système.courir();
}

L'apparition d'un nouvel acteur se fait via le début et créer Méthodes de
l'acteur
trait. Il fournit plusieurs façons différentes de créer des acteurs, pour plus de détails, consultez la documentation.
Vous pouvez mettre en œuvre commencé, arrêt et arrêté méthodes du trait Acteur.
commencé est appelé quand l'acteur commence et arrêt quand l'acteur a terminé.
Consultez la documentation de l'API
pour plus d'informations sur le cycle de vie des acteurs.

Gérer les messages

Un acteur communique avec un autre acteur en envoyant des messages. Dans actix tous les messages
sont tapés. Définissons un simple Somme message avec deux utiliser paramètres,
et un acteur qui acceptera ce message et retournera la somme de ces deux nombres.
Ici, nous utilisons l'actix-rt comme moyen de démarrer notre Système
et conduire notre principal Futur afin que nous puissions facilement .attendre pour les messages envoyés au Acteur.

utilisation actix::prélude::*;

// c'est notre message
#[derive(Message)]
#[rtype(résultat=[rtype(result="utiliser")] // nous devons définir le type de réponse pour le message `Sum`
struct Somme(utiliser, utiliser);

// Définition de l'acteur
struct Summator;

impl Acteur pour Summator {
    type Le contexte = Contexte <Soi>;
}

// maintenant nous devons définir `MessageHandler` pour le message` Sum`.
impl Gestionnaire pour Summator {
    type Résultat = utiliser; // <- Type de réponse au message

    fn manipuler(&mut soi, msg: somme, ctx: &mut Contexte <Soi>) -> Soi::Résultat {
        msg.0 + msg.1
    }
}

#[actix_rt::main] // <- démarre le système et bloque jusqu'à la résolution future
asynchrone fn principale() {
    laisser adr = Summator.début();
    laisser res = adr.envoyer(Somme(dix, 5)).attendre; // <- envoyer un message et obtenir le futur pour le résultat

    rencontre res {
        D'accord(résultat) => println!("SOMME: {}", résultat),
        _ => println!("La communication avec l'acteur a échoué"),
    }
}

Toutes les communications avec les acteurs passent par un Adr objet. Vous pouvez do_send un message
sans attendre de réponse, ou envoyer un acteur avec un message spécifique. le Message
trait définit le type de résultat pour un message.

État de l'acteur et abonnement pour des messages spécifiques

Vous avez peut-être remarqué que les méthodes de Acteur et Gestionnaire les traits acceptent & mut auto, alors tu es
bienvenue pour stocker quoi que ce soit dans un acteur et le faire muter chaque fois que nécessaire.

Les objets d'adresse nécessitent un type d'acteur, mais si nous voulons simplement envoyer un message spécifique à
un acteur qui peut gérer le message, nous pouvons utiliser le Bénéficiaire interface. Créons
un nouvel acteur qui utilise Bénéficiaire.

utilisation actix::prélude::*;
utilisation std::temps::Durée;

#[derive(Message)]
#[rtype(résultat=[rtype(result="()")]
struct Ping {
    pub identifiant: utiliser,
}

// Définition de l'acteur
struct Jeu {
    compteur: utiliser,
    Nom: Chaîne,
    addr: Destinataire<Ping>,
}

impl Acteur pour Jeu {
    type Le contexte = Contexte;
}

// gestionnaire de message simple pour le message Ping
impl Gestionnaire pour Jeu {
    type Résultat = ();

    fn manipuler(&mut soi, msg: Ping, ctx: &mut Contexte <Soi>) {
        soi.compteur + = 1;

        si soi.compteur > dix {
            Système::actuel().Arrêtez();
        } autre {
            println!("[{0}] Ping reçu {1} ", soi.name, msg.id);

            // attendez 100 nanos
            ctx.run_later(Durée::Nouveau(0, 100), bouge toi |acte, _| {
                act.addr.do_send(Ping {id: msg.id + 1 });
            });
        }
    }
}

fn principale() {
    laisser système = Système::Nouveau("tester");

    // Pour obtenir un objet Recipient, nous devons utiliser une méthode de générateur différente
    // qui permettra de reporter la création d'acteur
    laisser adr = Jeu::créer(|ctx| {
        // maintenant nous pouvons obtenir l'adresse du premier acteur et créer le deuxième acteur
        laisser adr = ctx.adresse();
        laisser addr2 = Jeu {
            compteur: 0,
            Nom: Chaîne::de("Jeu 2"),
            adr: adr.bénéficiaire(),
        }
        .début();

        // commençons les pings
        addr2.do_send(Ping {id: dix });

        // maintenant nous pouvons enfin créer le premier acteur
        Jeu {
            compteur: 0,
            Nom: Chaîne::de("Jeu 1"),
            adr: addr2.bénéficiaire(),
        }
    });

    système.courir();
}

exemple de chat

Il y a un
exemple de chat
qui fournit un exemple de base de service client / serveur réseau.

fectl

Vous pouvez envisager de vérifier l'utilitaire fectl. Il est écrit
avec actix et montre comment créer une application réseau avec des interactions relativement complexes.

Contribuant

Toutes les contributions sont les bienvenues, si vous avez une demande de fonctionnalité, n'hésitez pas à ouvrir un problème!

Licence

Ce projet est autorisé sous l'un ou l'autre des

à votre choix.

Code de conduite

La contribution à la caisse actix est organisée selon les termes du
Contributor Covenant, le mainteneur d'actix, @ fafhrd91, promet de
intervenir pour faire respecter ce code de conduite.