Comment puis-je récupérer les messages Protobuf inconnus dans Go ?

Pièges du démarchage des messages Protobuf inconnus

L'incapacité de proto.Unmarshal à gérer les types d'interface{} est un aspect essentiel à comprendre. Sa signature de méthode stipule la transmission d'un argument proto.Message, qui est implémenté par des types de protobuffer concrets.

Relever le défi

Lorsque vous traitez des charges utiles de protobuffer brutes qui manquent de contexte supplémentaire , il est crucial d'avoir au moins quelques informations d'identification (par exemple, une chaîne ou un nombre) à côté de la tranche d'octets. Ces informations peuvent être utilisées pour mapper le message concret spécifique du prototampon. Vous pouvez ensuite utiliser une instruction switch pour instancier le type approprié et le transmettre à Unmarshal :

switch atLeastSomething {
    case "foo":
        message = &mypb.Foo{}
    case "bar":
        message = &mypb.Bar{}
}
_ = proto.Unmarshal(data, message)

Embracing the Unpredictable : décodage de messages complètement inconnus

Dans de rares cas , vous pouvez rencontrer une charge utile de protobuffer complètement inconnue. Le package protowire fournit une solution pour en extraire certaines informations, bien qu'avec des limitations inhérentes. Le contenu de la charge utile peut être récupéré, mais avec une sémantique plus faible.

Détails de mise en œuvre

Voici un analyseur simplifié pour les messages proto inconnus :

func parseUnknown(b []byte) []Field {
    // Data model
    type Field struct {
        Tag Tag
        Val Val
    }
    type Tag struct {
        Num int32
        Type protowire.Type
    }
    type Val struct {
        Payload interface{}
        Length  int
    }
    // Parsing algorithm
    fields := make([]Field, 0)
    for len(b) > 0 {
        n, t, fieldlen := protowire.ConsumeField(b)
        if fieldlen < 1 {
            return nil
        }
        ... // Parsing logic
        fields = append(fields, field)
        b = b[fieldlen:]
    }
    return fields
}

Échantillon d'entrée et de sortie

Avec l'échantillon entrée :

message Foo {
  string a = 1;
  string b = 2;
  Bar bar = 3;
}
message Bar {
  string c = 1;
}
&test.Foo{A: "A", B: "B", Bar: &test.Bar{C: "C"}}

Le résultat sera :

Field{Tag:Tag{Num:1, Type:2}, Val:Val{Payload:[]uint8{0x41}, Length:1}}
Field{Tag:Tag{Num:2, Type:2}, Val:Val{Payload:[]uint8{0x42}, Length:1}}
Field{Tag:Tag{Num:1, Type:2}, Val:Val{Payload:[]uint8{0x43}, Length:1}}
Field{Tag:Tag{Num:3, Type:2}, Val:Val{Payload:[]Field{Field{Tag:Tag{Num:1, Type:2}, Val:Val{Payload:[]uint8{0x43}, Length:1}}}, Length:3}}

Considérations supplémentaires

• Les sous-messages sont analysés et stockés de manière récursive , s'il est valide. Sinon, les octets sont stockés tels quels.
• Les champs répétés ne sont pas explicitement gérés, mais peuvent être déduits des valeurs Tag.Num répétées après l'analyse.
• Les cartes sont censées être sémantiquement équivalentes à paires clé/valeur répétées.
• Une des informations est probablement perdue, ne préservant que l'ensemble valeur.

Alternative : Any et Interface{}

Bien que Any puisse initialement sembler une option appropriée pour les messages inconnus, elle a une structure strictement définie et ne peut pas être utilisé pour décoder des charges utiles inconnues. De plus, protowire n'est pas applicable à Any en raison de sa structure spécifique.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!