Log & Error Handling

Journalisation

Casbin utilise le log intégré pour imprimer les journaux sur la console par défaut, comme :

2017/07/15 19:43:56 [Request: alice, data1, read ---> true]

La journalisation n'est pas activée par défaut. Vous pouvez l'activer via Enforcer.EnableLog() ou le dernier paramètre de NewEnforcer().

note

Nous prenons déjà en charge la journalisation du modèle, de la demande d'exécution, du rôle et de la politique en Golang. Vous pouvez définir votre propre journal pour la journalisation de Casbin. Si vous utilisez Python, pycasbin utilise le mécanisme de journalisation Python par défaut. Le package pycasbin fait un appel à logging.getLogger() pour définir le journal. Aucune configuration de journalisation spéciale n'est nécessaire autre que l'initialisation du journal dans l'application parente. Si aucune journalisation n'est initialisée dans l'application parente, vous ne verrez aucun message de journal de pycasbin. En même temps, lorsque vous activez le journal dans pycasbin, il utilisera la configuration de journal par défaut. Pour les autres extensions pycasbin, vous pouvez vous référer à la documentation sur la journalisation Django si vous êtes un utilisateur Django. Pour les autres utilisateurs Python, vous devriez vous référer à la documentation sur la journalisation Python pour configurer le journal.

Utilisez différents journaux pour différents exécuteurs

Chaque exécuteur peut avoir son propre journal pour enregistrer des informations, et il peut être modifié à l'exécution.

Et vous pouvez utiliser un journal approprié via le dernier paramètre de NewEnforcer(). Si vous utilisez cette méthode pour initialiser votre exécuteur, vous n'avez pas besoin d'utiliser le paramètre activé car la priorité du champ activé dans le journal est plus élevée.

// Set a default logger as enforcer e1's logger.
// This operation can also be seen as changing the logger of e1 at runtime.
e1.SetLogger(&Log.DefaultLogger{})

// Set another logger as enforcer e2's logger.
e2.SetLogger(&YouOwnLogger)

// Set your logger when initializing enforcer e3.
e3, _ := casbin.NewEnforcer("examples/rbac_model.conf", a, logger)

Journaux pris en charge

Nous fournissons quelques journaux pour vous aider à enregistrer des informations.

Go

Journal	Auteur	Description
Journal par défaut (intégré)	Casbin	Le journal par défaut utilisant le log de golang.
Journal Zap	Casbin	Utilisation de zap, fournit un journal encodé en json et vous pouvez personnaliser davantage avec votre propre zap-logger.

PHP

Logger	Auteur	Description
psr3-bridge logger	Casbin	Fournit un pont conforme à PSR-3.

Comment écrire un logger

Votre logger devrait implémenter l'interface Logger.

Méthode	Type	Description
EnableLog()	obligatoire	Contrôlez si vous voulez imprimer le message.
IsEnabled()	obligatoire	Affiche le statut activé du logger actuel.
LogModel()	obligatoire	Journalise les informations liées au modèle.
LogEnforce()	obligatoire	Journalise les informations liées à l'application.
LogRole()	obligatoire	Journalise les informations liées au rôle.
LogPolicy()	obligatoire	Journalise les informations liées à la politique.

Vous pouvez passer votre logger personnalisé à Enforcer.SetLogger().

Voici un exemple de comment personnaliser un logger pour Golang :

import (
    "fmt"
    "log"
    "strings"
)

// DefaultLogger is the implementation for a Logger using golang log.
type DefaultLogger struct {
    enabled bool
}

func (l *DefaultLogger) EnableLog(enable bool) {
    l.enabled = enable
}

func (l *DefaultLogger) IsEnabled() bool {
    return l.enabled
}

func (l *DefaultLogger) LogModel(model [][]string) {
    if !l.enabled {
        return
    }
    var str strings.Builder
    str.WriteString("Model: ")
    for _, v := range model {
        str.WriteString(fmt.Sprintf("%v\n", v))
    }

    log.Println(str.String())
}

func (l *DefaultLogger) LogEnforce(matcher string, request []interface{}, result bool, explains [][]string) {
    if !l.enabled {
        return
    }

    var reqStr strings.Builder
    reqStr.WriteString("Request: ")
    for i, rval := range request {
        if i != len(request)-1 {
            reqStr.WriteString(fmt.Sprintf("%v, ", rval))
        } else {
            reqStr.WriteString(fmt.Sprintf("%v", rval))
        }
    }
    reqStr.WriteString(fmt.Sprintf(" ---> %t\n", result))

    reqStr.WriteString("Hit Policy: ")
    for i, pval := range explains {
        if i != len(explains)-1 {
            reqStr.WriteString(fmt.Sprintf("%v, ", pval))
        } else {
            reqStr.WriteString(fmt.Sprintf("%v \n", pval))
        }
    }

    log.Println(reqStr.String())
}

func (l *DefaultLogger) LogPolicy(policy map[string][][]string) {
    if !l.enabled {
        return
    }

    var str strings.Builder
    str.WriteString("Policy: ")
    for k, v := range policy {
        str.WriteString(fmt.Sprintf("%s : %v\n", k, v))
    }

    log.Println(str.String())
}

func (l *DefaultLogger) LogRole(roles []string) {
    if !l.enabled {
        return
    }

    log.Println("Roles: ", roles)
}

Gestion des erreurs

Des erreurs ou des paniques peuvent survenir lorsque vous utilisez Casbin pour des raisons telles que :

1. Syntaxe invalide dans le fichier de modèle (.conf).
2. Syntaxe invalide dans le fichier de politique (.csv).
3. Erreurs personnalisées provenant des adaptateurs de stockage, par exemple, MySQL échoue à se connecter.
4. Bug de Casbin.

Il y a cinq fonctions principales dont vous devez être conscient pour les erreurs ou les paniques :

Fonction	Comportement en cas d'erreur
NewEnforcer()	Renvoie une erreur
LoadModel()	Renvoie une erreur
LoadPolicy()	Renvoie une erreur
SavePolicy()	Renvoie une erreur
Enforce()	Renvoie une erreur

note

NewEnforcer() appelle LoadModel() et LoadPolicy() en interne. Donc, vous n'avez pas à appeler ces deux derniers lors de l'utilisation de NewEnforcer().

Activer et désactiver

L'exécuteur peut être désactivé via la fonction Enforcer.EnableEnforce(). Lorsqu'il est désactivé, Enforcer.Enforce() renverra toujours true. D'autres opérations comme l'ajout ou la suppression de politiques ne sont pas affectées. Voici un exemple :

e := casbin.NewEnforcer("examples/basic_model.conf", "examples/basic_policy.csv")

// Will return false.
// By default, the enforcer is enabled.
e.Enforce("non-authorized-user", "data1", "read")

// Disable the enforcer at runtime.
e.EnableEnforce(false)

// Will return true for any request.
e.Enforce("non-authorized-user", "data1", "read")

// Enable the enforcer again.
e.EnableEnforce(true)

// Will return false.
e.Enforce("non-authorized-user", "data1", "read")