diff --git a/backend/services/controller/internal/db/device.go b/backend/services/controller/internal/db/device.go index eeba31e..5af07df 100644 --- a/backend/services/controller/internal/db/device.go +++ b/backend/services/controller/internal/db/device.go @@ -38,7 +38,6 @@ type Device struct { Websockets Status } -// TODO: don't change device status of other MTP func (d *Database) CreateDevice(device Device) error { var result bson.M var deviceExistent Device diff --git a/backend/services/mqtt/.env b/backend/services/mtp/adapter/.env similarity index 100% rename from backend/services/mqtt/.env rename to backend/services/mtp/adapter/.env diff --git a/backend/services/mtp/adapter/.env.local b/backend/services/mtp/adapter/.env.local new file mode 100644 index 0000000..81b4f64 --- /dev/null +++ b/backend/services/mtp/adapter/.env.local @@ -0,0 +1 @@ +MONGO_URI="mongodb://172.16.235.2:27017" \ No newline at end of file diff --git a/backend/services/mtp/adapter/README.md b/backend/services/mtp/adapter/README.md new file mode 100644 index 0000000..ceeb185 --- /dev/null +++ b/backend/services/mtp/adapter/README.md @@ -0,0 +1,2 @@ +- Abstracts all other mtps existence +- Saves devices info and status \ No newline at end of file diff --git a/backend/services/mtp/adapter/cmd/adapter/main.go b/backend/services/mtp/adapter/cmd/adapter/main.go new file mode 100644 index 0000000..2d12da7 --- /dev/null +++ b/backend/services/mtp/adapter/cmd/adapter/main.go @@ -0,0 +1,33 @@ +package main + +import ( + "log" + "os" + "os/signal" + "syscall" + + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/config" + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/db" + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/events" + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/events/handler" + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/nats" +) + +func main() { + done := make(chan os.Signal, 1) + signal.Notify(done, syscall.SIGINT, syscall.SIGTERM) + + c := config.NewConfig() + + js, nc := nats.StartNatsClient(c.Nats) + + db := db.NewDatabase(c.Mongo.Ctx, c.Mongo.Uri) + + handler := handler.NewHandler(nc, js, db, c.ControllerId) + + events.StartEventsListener(c.Nats.Ctx, js, handler) + + <-done + + log.Println("mtp adapter is shutting down...") +} diff --git a/backend/services/mtp/adapter/go.mod b/backend/services/mtp/adapter/go.mod new file mode 100644 index 0000000..06d3f3a --- /dev/null +++ b/backend/services/mtp/adapter/go.mod @@ -0,0 +1,27 @@ +module github.com/OktopUSP/oktopus/backend/services/mtp/adapter + +go 1.22.0 + +require ( + github.com/google/uuid v1.6.0 + github.com/joho/godotenv v1.5.1 + github.com/nats-io/nats.go v1.33.1 + go.mongodb.org/mongo-driver v1.14.0 + google.golang.org/protobuf v1.32.0 +) + +require ( + github.com/golang/snappy v0.0.1 // indirect + github.com/klauspost/compress v1.17.2 // indirect + github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe // indirect + github.com/nats-io/nkeys v0.4.7 // indirect + github.com/nats-io/nuid v1.0.1 // indirect + github.com/xdg-go/pbkdf2 v1.0.0 // indirect + github.com/xdg-go/scram v1.1.2 // indirect + github.com/xdg-go/stringprep v1.0.4 // indirect + github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d // indirect + golang.org/x/crypto v0.18.0 // indirect + golang.org/x/sync v0.1.0 // indirect + golang.org/x/sys v0.16.0 // indirect + golang.org/x/text v0.14.0 // indirect +) diff --git a/backend/services/mtp/adapter/go.sum b/backend/services/mtp/adapter/go.sum new file mode 100644 index 0000000..d87f2fe --- /dev/null +++ b/backend/services/mtp/adapter/go.sum @@ -0,0 +1,66 @@ +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4= +github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= +github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= +github.com/klauspost/compress v1.17.2 h1:RlWWUY/Dr4fL8qk9YG7DTZ7PDgME2V4csBXA8L/ixi4= +github.com/klauspost/compress v1.17.2/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= +github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe h1:iruDEfMl2E6fbMZ9s0scYfZQ84/6SPL6zC8ACM2oIL0= +github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc= +github.com/nats-io/nats.go v1.33.1 h1:8TxLZZ/seeEfR97qV0/Bl939tpDnt2Z2fK3HkPypj70= +github.com/nats-io/nats.go v1.33.1/go.mod h1:Ubdu4Nh9exXdSz0RVWRFBbRfrbSxOYd26oF0wkWclB8= +github.com/nats-io/nkeys v0.4.7 h1:RwNJbbIdYCoClSDNY7QVKZlyb/wfT6ugvFCiKy6vDvI= +github.com/nats-io/nkeys v0.4.7/go.mod h1:kqXRgRDPlGy7nGaEDMuYzmiJCIAAWDK0IMBtDmGD0nc= +github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw= +github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= +github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= +github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI= +github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY= +github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4= +github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8= +github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM= +github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d h1:splanxYIlg+5LfHAM6xpdFEAYOk8iySO56hMFq6uLyA= +github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +go.mongodb.org/mongo-driver v1.14.0 h1:P98w8egYRjYe3XDjxhYJagTokP/H6HzlsnojRgZRd80= +go.mongodb.org/mongo-driver v1.14.0/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc= +golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU= +golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I= +google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= diff --git a/backend/services/mtp/adapter/internal/config/config.go b/backend/services/mtp/adapter/internal/config/config.go new file mode 100644 index 0000000..5173dd8 --- /dev/null +++ b/backend/services/mtp/adapter/internal/config/config.go @@ -0,0 +1,107 @@ +package config + +import ( + "context" + "flag" + "log" + "os" + "strconv" + + "github.com/joho/godotenv" +) + +const LOCAL_ENV = ".env.local" + +type Nats struct { + Url string + Name string + VerifyCertificates bool + Ctx context.Context +} + +type Mongo struct { + Uri string + Ctx context.Context +} + +type Config struct { + Nats Nats + Mongo Mongo + ControllerId string +} + +func NewConfig() *Config { + + loadEnvVariables() + log.SetFlags(log.LstdFlags | log.Lshortfile) + + natsUrl := flag.String("nats_url", lookupEnvOrString("NATS_URL", "nats://localhost:4222"), "url for nats server") + natsName := flag.String("nats_name", lookupEnvOrString("NATS_NAME", "adapter"), "name for nats client") + natsVerifyCertificates := flag.Bool("nats_verify_certificates", lookupEnvOrBool("NATS_VERIFY_CERTIFICATES", false), "verify validity of certificates from nats server") + mongoUri := flag.String("mongo_uri", lookupEnvOrString("MONGO_URI", "mongodb://localhost:27017"), "uri for mongodb server") + controllerId := flag.String("controller_id", lookupEnvOrString("CONTROLLER_ID", "oktopusController"), "usp controller endpoint id") + flHelp := flag.Bool("help", false, "Help") + + /* + App variables priority: + 1º - Flag through command line. + 2º - Env variables. + 3º - Default flag value. + */ + + flag.Parse() + + if *flHelp { + flag.Usage() + os.Exit(0) + } + + ctx := context.TODO() + + return &Config{ + Nats: Nats{ + Url: *natsUrl, + Name: *natsName, + VerifyCertificates: *natsVerifyCertificates, + Ctx: ctx, + }, + Mongo: Mongo{ + Uri: *mongoUri, + Ctx: ctx, + }, + ControllerId: *controllerId, + } +} + +func loadEnvVariables() { + err := godotenv.Load() + + if _, err := os.Stat(LOCAL_ENV); err == nil { + _ = godotenv.Overload(LOCAL_ENV) + log.Printf("Loaded variables from '%s'", LOCAL_ENV) + } + + if err != nil { + log.Println("Error to load environment variables:", err) + } else { + log.Println("Loaded variables from '.env'") + } +} + +func lookupEnvOrString(key string, defaultVal string) string { + if val, _ := os.LookupEnv(key); val != "" { + return val + } + return defaultVal +} + +func lookupEnvOrBool(key string, defaultVal bool) bool { + if val, _ := os.LookupEnv(key); val != "" { + v, err := strconv.ParseBool(val) + if err != nil { + log.Fatalf("LookupEnvOrBool[%s]: %v", key, err) + } + return v + } + return defaultVal +} diff --git a/backend/services/mtp/adapter/internal/db/db.go b/backend/services/mtp/adapter/internal/db/db.go new file mode 100644 index 0000000..3c51550 --- /dev/null +++ b/backend/services/mtp/adapter/internal/db/db.go @@ -0,0 +1,57 @@ +package db + +import ( + "context" + "log" + "sync" + + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/mongo" + "go.mongodb.org/mongo-driver/mongo/options" +) + +type Database struct { + client *mongo.Client + devices *mongo.Collection + ctx context.Context + m *sync.Mutex +} + +func NewDatabase(ctx context.Context, mongoUri string) Database { + var db Database + + clientOptions := options.Client().ApplyURI(mongoUri) + client, err := mongo.Connect(ctx, clientOptions) + if err != nil { + log.Fatal(err) + } + db.client = client + + log.Println("Trying to ping Mongo database...") + err = client.Ping(ctx, nil) + if err != nil { + log.Fatal("Couldn't connect to MongoDB --> ", err) + } + + log.Println("Connected to MongoDB-->", mongoUri) + + devices := client.Database("adapter").Collection("devices") + createIndexes(ctx, devices) + + db.devices = devices + db.ctx = ctx + db.m = &sync.Mutex{} + + return db +} + +func createIndexes(ctx context.Context, devices *mongo.Collection) { + indexField := bson.M{"sn": 1} + _, err := devices.Indexes().CreateOne(ctx, mongo.IndexModel{ + Keys: indexField, + Options: options.Index().SetUnique(true), + }) + if err != nil { + log.Println("ERROR to create index in database:", err) + } +} diff --git a/backend/services/mtp/adapter/internal/db/device.go b/backend/services/mtp/adapter/internal/db/device.go new file mode 100644 index 0000000..5af07df --- /dev/null +++ b/backend/services/mtp/adapter/internal/db/device.go @@ -0,0 +1,148 @@ +package db + +import ( + "log" + + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/mongo" + "go.mongodb.org/mongo-driver/mongo/options" +) + +type MTP int32 + +const ( + UNDEFINED MTP = iota + MQTT + STOMP + WEBSOCKETS +) + +type Status uint8 + +const ( + Offline Status = iota + Associating + Online +) + +type Device struct { + SN string + Model string + Customer string + Vendor string + Version string + ProductClass string + Status Status + Mqtt Status + Stomp Status + Websockets Status +} + +func (d *Database) CreateDevice(device Device) error { + var result bson.M + var deviceExistent Device + + d.m.Lock() + defer d.m.Unlock() + + /* ------------------ Do not overwrite status of other mtp ------------------ */ + err := d.devices.FindOne(d.ctx, bson.D{{"sn", device.SN}}, nil).Decode(&deviceExistent) + if err == nil { + if deviceExistent.Mqtt == Online { + device.Mqtt = Online + } + if deviceExistent.Stomp == Online { + device.Stomp = Online + } + if deviceExistent.Websockets == Online { + device.Websockets = Online + } + } else { + if err != nil && err != mongo.ErrNoDocuments { + log.Println(err) + return err + } + } + /* -------------------------------------------------------------------------- */ + + callback := func(sessCtx mongo.SessionContext) (interface{}, error) { + // Important: You must pass sessCtx as the Context parameter to the operations for them to be executed in the + // transaction. + opts := options.FindOneAndReplace().SetUpsert(true) + + err = d.devices.FindOneAndReplace(d.ctx, bson.D{{"sn", device.SN}}, device, opts).Decode(&result) + if err != nil { + if err == mongo.ErrNoDocuments { + log.Printf("New device %s added to database", device.SN) + return nil, nil + } + return nil, err + } + log.Printf("Device %s already existed, and got replaced for new info", device.SN) + return nil, nil + } + + session, err := d.client.StartSession() + if err != nil { + return err + } + defer session.EndSession(d.ctx) + + _, err = session.WithTransaction(d.ctx, callback) + if err != nil { + return err + } + return err +} +func (d *Database) RetrieveDevices(filter bson.A) ([]Device, error) { + cursor, err := d.devices.Aggregate(d.ctx, filter) + + var results []Device + + for cursor.Next(d.ctx) { + var device Device + + err := cursor.Decode(&device) + if err != nil { + log.Println("Error to decode device info fields") + continue + } + + results = append(results, device) + } + + return results, err +} + +func (d *Database) RetrieveDevice(sn string) (Device, error) { + var result Device + //TODO: filter devices by user ownership + err := d.devices.FindOne(d.ctx, bson.D{{"sn", sn}}, nil).Decode(&result) + if err != nil { + log.Println(err) + } + return result, err +} + +func (d *Database) RetrieveDevicesCount(filter bson.M) (int64, error) { + count, err := d.devices.CountDocuments(d.ctx, filter) + return count, err +} + +func (d *Database) DeleteDevice() { + +} + +func (m MTP) String() string { + switch m { + case UNDEFINED: + return "unknown" + case MQTT: + return "mqtt" + case STOMP: + return "stomp" + case WEBSOCKETS: + return "websockets" + } + return "unknown" +} diff --git a/backend/services/mtp/adapter/internal/db/info.go b/backend/services/mtp/adapter/internal/db/info.go new file mode 100644 index 0000000..a72e150 --- /dev/null +++ b/backend/services/mtp/adapter/internal/db/info.go @@ -0,0 +1,97 @@ +package db + +import ( + "log" + + "go.mongodb.org/mongo-driver/bson" +) + +type VendorsCount struct { + Vendor string `bson:"_id" json:"vendor"` + Count int `bson:"count" json:"count"` +} + +type ProductClassCount struct { + ProductClass string `bson:"_id" json:"productClass"` + Count int `bson:"count" json:"count"` +} + +type StatusCount struct { + Status int `bson:"_id" json:"status"` + Count int `bson:"count" json:"count"` +} + +func (d *Database) RetrieveVendorsInfo() ([]VendorsCount, error) { + var results []VendorsCount + cursor, err := d.devices.Aggregate(d.ctx, []bson.M{ + { + "$group": bson.M{ + "_id": "$vendor", + "count": bson.M{"$sum": 1}, + }, + }, + }) + if err != nil { + log.Println(err) + return nil, err + } + defer cursor.Close(d.ctx) + if err := cursor.All(d.ctx, &results); err != nil { + log.Println(err) + return nil, err + } + // for _, result := range results { + // log.Println(result) + // } + return results, nil +} + +func (d *Database) RetrieveStatusInfo() ([]StatusCount, error) { + var results []StatusCount + cursor, err := d.devices.Aggregate(d.ctx, []bson.M{ + { + "$group": bson.M{ + "_id": "$status", + "count": bson.M{"$sum": 1}, + }, + }, + }) + if err != nil { + log.Println(err) + return nil, err + } + defer cursor.Close(d.ctx) + if err := cursor.All(d.ctx, &results); err != nil { + log.Println(err) + return nil, err + } + // for _, result := range results { + // log.Println(result) + // } + return results, nil +} + +func (d *Database) RetrieveProductsClassInfo() ([]ProductClassCount, error) { + var results []ProductClassCount + cursor, err := d.devices.Aggregate(d.ctx, []bson.M{ + { + "$group": bson.M{ + "_id": "$productclass", + "count": bson.M{"$sum": 1}, + }, + }, + }) + if err != nil { + log.Println(err) + return nil, err + } + defer cursor.Close(d.ctx) + if err := cursor.All(d.ctx, &results); err != nil { + log.Println(err) + return nil, err + } + // for _, result := range results { + // log.Println(result) + // } + return results, nil +} diff --git a/backend/services/mtp/adapter/internal/db/status.go b/backend/services/mtp/adapter/internal/db/status.go new file mode 100644 index 0000000..cff6bdf --- /dev/null +++ b/backend/services/mtp/adapter/internal/db/status.go @@ -0,0 +1,69 @@ +package db + +import ( + "log" + + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/bson/primitive" + "go.mongodb.org/mongo-driver/mongo" +) + +func (d *Database) UpdateStatus(sn string, status Status, mtp MTP) error { + var result Device + + d.m.Lock() + defer d.m.Unlock() + err := d.devices.FindOne(d.ctx, bson.D{{"sn", sn}}, nil).Decode(&result) + if err != nil { + log.Println(err) + } + + //TODO: abolish this logic, find another approach, microservices design maybe? + /* + In case the device status is online, we must check if the mtp + changing is going to affect the global status. In case it does, + we must update the global status accordingly. + */ + + /* + mix the existent device status to the updated one + */ + switch mtp { + case MQTT: + result.Mqtt = status + case STOMP: + result.Stomp = status + case WEBSOCKETS: + result.Websockets = status + } + + /* + check if the global status needs update + */ + var globalStatus primitive.E + if result.Mqtt == Offline && result.Stomp == Offline && result.Websockets == Offline { + globalStatus = primitive.E{"status", Offline} + } + if result.Mqtt == Online || result.Stomp == Online || result.Websockets == Online { + globalStatus = primitive.E{"status", Online} + } + + _, err = d.devices.UpdateOne(d.ctx, bson.D{{"sn", sn}}, bson.D{ + { + "$set", bson.D{ + {mtp.String(), status}, + globalStatus, + }, + }, + }) + + if err != nil { + if err == mongo.ErrNoDocuments { + log.Printf("Device %s is not mapped into database", sn) + return nil + } + log.Println(err) + } + log.Printf("%s is now offline.", sn) + return err +} diff --git a/backend/services/mtp/adapter/internal/events/events.go b/backend/services/mtp/adapter/internal/events/events.go new file mode 100644 index 0000000..993a90b --- /dev/null +++ b/backend/services/mtp/adapter/internal/events/events.go @@ -0,0 +1,61 @@ +package events + +import ( + "context" + "log" + "strings" + + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/events/handler" + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/nats" + "github.com/nats-io/nats.go/jetstream" +) + +func StartEventsListener(ctx context.Context, js jetstream.JetStream, h handler.Handler) { + + events := []string{ + nats.MQTT_STREAM_NAME, + nats.WS_STREAM_NAME, + nats.STOMP_STREAM_NAME, + nats.LORA_STREAM_NAME, + nats.OPC_STREAM_NAME, + } + + for _, event := range events { + go func() { + consumer, err := js.Consumer(ctx, event, event) + if err != nil { + log.Fatalf("Failed to get consumer: %v", err) + } + messages, err := consumer.Messages() + if err != nil { + log.Fatalf("Failed to get consumer messages: %v", err) + } + defer messages.Stop() + for { + msg, err := messages.Next() + if err != nil { + log.Println("Error to get next message:", err) + continue + } + + data := msg.Data() + + log.Printf("Received message, subject: %s", msg.Subject()) + + subject := strings.Split(msg.Subject(), ".") + msgType := subject[len(subject)-1] + device := subject[len(subject)-2] + + switch msgType { + case "status": + h.HandleDeviceStatus(device, msg.Subject(), data) + case "info": + h.HandleDeviceInfo(device, msg.Subject(), data, event) + default: + //ignoreMsg(msg.Subject(), "status", msg.Data()) + } + msg.Ack() + } + }() + } +} diff --git a/backend/services/mtp/adapter/internal/events/handler/handler.go b/backend/services/mtp/adapter/internal/events/handler/handler.go new file mode 100644 index 0000000..f657d74 --- /dev/null +++ b/backend/services/mtp/adapter/internal/events/handler/handler.go @@ -0,0 +1,30 @@ +package handler + +import ( + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/db" + "github.com/nats-io/nats.go" + "github.com/nats-io/nats.go/jetstream" +) + +const ( + ONLINE = iota + OFFLINE +) + +const NATS_SUBJ_PREFIX = "mqtt-adapter.usp.v1." + +type Handler struct { + nc *nats.Conn + js jetstream.JetStream + db db.Database + cid string +} + +func NewHandler(nc *nats.Conn, js jetstream.JetStream, d db.Database, cid string) Handler { + return Handler{ + nc: nc, + js: js, + db: d, + cid: cid, + } +} diff --git a/backend/services/mtp/adapter/internal/events/handler/info.go b/backend/services/mtp/adapter/internal/events/handler/info.go new file mode 100644 index 0000000..753c62a --- /dev/null +++ b/backend/services/mtp/adapter/internal/events/handler/info.go @@ -0,0 +1,68 @@ +package handler + +import ( + "log" + + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/db" + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/nats" + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/usp/usp_msg" + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/usp/usp_record" + "google.golang.org/protobuf/proto" +) + +func (h *Handler) HandleDeviceInfo(device, subject string, data []byte, mtp string) { + log.Printf("Device %s info", device) + deviceInfo := parseDeviceInfoMsg(device, subject, data, getMtp(mtp)) + err := h.db.CreateDevice(deviceInfo) + if err != nil { + log.Printf("Failed to create device: %v", err) + } +} + +func getMtp(mtp string) db.MTP { + switch mtp { + case nats.MQTT_STREAM_NAME: + return db.MQTT + case nats.WS_STREAM_NAME: + return db.WEBSOCKETS + case nats.STOMP_STREAM_NAME: + return db.STOMP + default: + return db.MTP(0) + } +} + +func parseDeviceInfoMsg(sn, subject string, data []byte, mtp db.MTP) db.Device { + var record usp_record.Record + var message usp_msg.Msg + + err := proto.Unmarshal(data, &record) + if err != nil { + log.Fatal(err) + } + err = proto.Unmarshal(record.GetNoSessionContext().Payload, &message) + if err != nil { + log.Fatal(err) + } + + var device db.Device + msg := message.Body.MsgBody.(*usp_msg.Body_Response).Response.GetGetResp() + + device.Vendor = msg.ReqPathResults[0].ResolvedPathResults[0].ResultParams["Manufacturer"] + device.Model = msg.ReqPathResults[1].ResolvedPathResults[0].ResultParams["ModelName"] + device.Version = msg.ReqPathResults[2].ResolvedPathResults[0].ResultParams["SoftwareVersion"] + device.ProductClass = msg.ReqPathResults[4].ResolvedPathResults[0].ResultParams["ProductClass"] + device.SN = sn + switch db.MTP(mtp) { + case db.MQTT: + device.Mqtt = db.Online + case db.WEBSOCKETS: + device.Websockets = db.Online + case db.STOMP: + device.Stomp = db.Online + } + + device.Status = db.Online + + return device +} diff --git a/backend/services/mtp/adapter/internal/events/handler/status.go b/backend/services/mtp/adapter/internal/events/handler/status.go new file mode 100644 index 0000000..7de2f33 --- /dev/null +++ b/backend/services/mtp/adapter/internal/events/handler/status.go @@ -0,0 +1,69 @@ +package handler + +import ( + "log" + "strconv" + + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/db" + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/usp" + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/usp/usp_msg" + "google.golang.org/protobuf/proto" +) + +func (h *Handler) HandleDeviceStatus(device, subject string, data []byte) { + payload, err := strconv.Atoi(string(data)) + if err != nil { + log.Printf("Status subject payload message error %q", err) + } + + switch payload { + case ONLINE: + h.deviceOnline(device) + case OFFLINE: + h.deviceOffline(device) + default: + ignoreMsg(subject, "status", data) + } +} + +func (h *Handler) deviceOnline(device string) { + + log.Printf("Device %s is online", device) + + msg := usp.NewGetMsg(usp_msg.Get{ + ParamPaths: []string{ + "Device.DeviceInfo.Manufacturer", + "Device.DeviceInfo.ModelName", + "Device.DeviceInfo.SoftwareVersion", + "Device.DeviceInfo.SerialNumber", + "Device.DeviceInfo.ProductClass", + }, + MaxDepth: 1, + }) + + payload, _ := proto.Marshal(&msg) + record := usp.NewUspRecord(payload, device, h.cid) + + tr369Message, err := proto.Marshal(&record) + if err != nil { + log.Fatalln("Failed to encode tr369 record:", err) + } + + err = h.nc.Publish(NATS_SUBJ_PREFIX+device+".info", tr369Message) + if err != nil { + log.Printf("Failed to publish online device message: %v", err) + } +} + +func (h *Handler) deviceOffline(device string) { + log.Printf("Device %s is offline", device) + + err := h.db.UpdateStatus(device, db.Offline, db.MQTT) + if err != nil { + log.Fatal(err) + } +} + +func ignoreMsg(subject, ctx string, data []byte) { + log.Printf("Unknown message of %s received, subject: %s, payload: %s. Ignored...", ctx, subject, string(data)) +} diff --git a/backend/services/mtp/adapter/internal/nats/nats.go b/backend/services/mtp/adapter/internal/nats/nats.go new file mode 100644 index 0000000..ebef52c --- /dev/null +++ b/backend/services/mtp/adapter/internal/nats/nats.go @@ -0,0 +1,132 @@ +package nats + +import ( + "context" + "errors" + "log" + "time" + + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/config" + "github.com/nats-io/nats.go" + "github.com/nats-io/nats.go/jetstream" +) + +const ( + MQTT_ADAPTER_STREAM_NAME = "mqtt-adapter" + MQTT_STREAM_NAME = "mqtt" + WS_STREAM_NAME = "ws" + STOMP_STREAM_NAME = "stomp" + LORA_STREAM_NAME = "lora" + OPC_STREAM_NAME = "opc" +) + +func StartNatsClient(c config.Nats) (jetstream.JetStream, *nats.Conn) { + + var ( + nc *nats.Conn + err error + ) + + opts := defineOptions(c) + + for { + nc, err = nats.Connect(c.Url, opts...) + if err != nil { + time.Sleep(5 * time.Second) + continue + } + break + } + log.Printf("Successfully connected to NATS server %s", c.Url) + + js, err := jetstream.New(nc) + if err != nil { + log.Fatalf("Failed to create JetStream client: %v", err) + } + + streams := defineStreams() + err = createStreams(c.Ctx, js, streams) + if err != nil { + log.Fatalf("Failed to create Consumer: %v", err) + } + + consumers := defineConsumers() + err = createConsumers(c.Ctx, js, consumers) + if err != nil { + log.Fatalf("Failed to create Consumer: %v", err) + } + + return js, nc +} + +func createStreams(ctx context.Context, js jetstream.JetStream, streams []string) error { + for _, stream := range streams { + _, err := js.CreateOrUpdateStream(ctx, jetstream.StreamConfig{ + Name: stream, + Description: "Stream for " + stream + " messages", + Subjects: []string{stream + ".>"}, + Retention: jetstream.InterestPolicy, + }) + if err != nil { + return errors.New(err.Error() + " | consumer:" + stream) + } + } + return nil +} + +func createConsumers(ctx context.Context, js jetstream.JetStream, consumers []string) error { + for _, consumer := range consumers { + _, err := js.CreateOrUpdateConsumer(ctx, consumer, jetstream.ConsumerConfig{ + Name: consumer, + Description: "Consumer for " + consumer + " messages", + AckPolicy: jetstream.AckExplicitPolicy, + Durable: consumer, + }) + if err != nil { + return err + } + } + return nil +} + +func defineStreams() []string { + return []string{ + MQTT_STREAM_NAME, + WS_STREAM_NAME, + STOMP_STREAM_NAME, + LORA_STREAM_NAME, + OPC_STREAM_NAME, + } +} + +func defineConsumers() []string { + return []string{ + MQTT_STREAM_NAME, + WS_STREAM_NAME, + STOMP_STREAM_NAME, + LORA_STREAM_NAME, + OPC_STREAM_NAME, + } +} + +func defineOptions(c config.Nats) []nats.Option { + var opts []nats.Option + + opts = append(opts, nats.Name(c.Name)) + opts = append(opts, nats.MaxReconnects(-1)) + opts = append(opts, nats.ReconnectWait(5*time.Second)) + opts = append(opts, nats.DisconnectErrHandler(func(nc *nats.Conn, err error) { + log.Printf("Got disconnected! Reason: %q\n", err) + })) + opts = append(opts, nats.ReconnectHandler(func(nc *nats.Conn) { + log.Printf("Got reconnected to %v!\n", nc.ConnectedUrl()) + })) + opts = append(opts, nats.ClosedHandler(func(nc *nats.Conn) { + log.Printf("Connection closed. Reason: %q\n", nc.LastError()) + })) + if c.VerifyCertificates { + opts = append(opts, nats.RootCAs()) + } + + return opts +} diff --git a/backend/services/mtp/adapter/internal/usp/usp.go b/backend/services/mtp/adapter/internal/usp/usp.go new file mode 100644 index 0000000..7c84254 --- /dev/null +++ b/backend/services/mtp/adapter/internal/usp/usp.go @@ -0,0 +1,149 @@ +package usp + +import ( + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/usp/usp_msg" + "github.com/OktopUSP/oktopus/backend/services/mtp/adapter/internal/usp/usp_record" + "github.com/google/uuid" +) + +const VERSION = "1.0" + +func NewUspRecord(p []byte, toId, fromId string) usp_record.Record { + return usp_record.Record{ + Version: VERSION, + ToId: toId, + FromId: fromId, + PayloadSecurity: usp_record.Record_PLAINTEXT, + RecordType: &usp_record.Record_NoSessionContext{ + NoSessionContext: &usp_record.NoSessionContextRecord{ + Payload: p, + }, + }, + } +} + +func NewCreateMsg(createStuff usp_msg.Add) usp_msg.Msg { + return usp_msg.Msg{ + Header: &usp_msg.Header{ + MsgId: uuid.NewString(), + MsgType: usp_msg.Header_ADD, + }, + Body: &usp_msg.Body{ + MsgBody: &usp_msg.Body_Request{ + Request: &usp_msg.Request{ + ReqType: &usp_msg.Request_Add{ + Add: &createStuff, + }, + }, + }, + }, + } +} + +func NewGetMsg(getStuff usp_msg.Get) usp_msg.Msg { + return usp_msg.Msg{ + Header: &usp_msg.Header{ + MsgId: uuid.NewString(), + MsgType: usp_msg.Header_GET, + }, + Body: &usp_msg.Body{ + MsgBody: &usp_msg.Body_Request{ + Request: &usp_msg.Request{ + ReqType: &usp_msg.Request_Get{ + Get: &getStuff, + }, + }, + }, + }, + } +} + +func NewDelMsg(getStuff usp_msg.Delete) usp_msg.Msg { + return usp_msg.Msg{ + Header: &usp_msg.Header{ + MsgId: uuid.NewString(), + MsgType: usp_msg.Header_DELETE, + }, + Body: &usp_msg.Body{ + MsgBody: &usp_msg.Body_Request{ + Request: &usp_msg.Request{ + ReqType: &usp_msg.Request_Delete{ + Delete: &getStuff, + }, + }, + }, + }, + } +} + +func NewSetMsg(updateStuff usp_msg.Set) usp_msg.Msg { + return usp_msg.Msg{ + Header: &usp_msg.Header{ + MsgId: uuid.NewString(), + MsgType: usp_msg.Header_SET, + }, + Body: &usp_msg.Body{ + MsgBody: &usp_msg.Body_Request{ + Request: &usp_msg.Request{ + ReqType: &usp_msg.Request_Set{ + Set: &updateStuff, + }, + }, + }, + }, + } +} + +func NewGetSupportedParametersMsg(getStuff usp_msg.GetSupportedDM) usp_msg.Msg { + return usp_msg.Msg{ + Header: &usp_msg.Header{ + MsgId: uuid.NewString(), + MsgType: usp_msg.Header_GET_SUPPORTED_DM, + }, + Body: &usp_msg.Body{ + MsgBody: &usp_msg.Body_Request{ + Request: &usp_msg.Request{ + ReqType: &usp_msg.Request_GetSupportedDm{ + GetSupportedDm: &getStuff, + }, + }, + }, + }, + } +} + +func NewGetParametersInstancesMsg(getStuff usp_msg.GetInstances) usp_msg.Msg { + return usp_msg.Msg{ + Header: &usp_msg.Header{ + MsgId: uuid.NewString(), + MsgType: usp_msg.Header_GET_INSTANCES, + }, + Body: &usp_msg.Body{ + MsgBody: &usp_msg.Body_Request{ + Request: &usp_msg.Request{ + ReqType: &usp_msg.Request_GetInstances{ + GetInstances: &getStuff, + }, + }, + }, + }, + } +} + +func NewOperateMsg(getStuff usp_msg.Operate) usp_msg.Msg { + return usp_msg.Msg{ + Header: &usp_msg.Header{ + MsgId: uuid.NewString(), + MsgType: usp_msg.Header_OPERATE, + }, + Body: &usp_msg.Body{ + MsgBody: &usp_msg.Body_Request{ + Request: &usp_msg.Request{ + ReqType: &usp_msg.Request_Operate{ + Operate: &getStuff, + }, + }, + }, + }, + } +} diff --git a/backend/services/ws/internal/usp_message/usp-msg-1-2.pb.go b/backend/services/mtp/adapter/internal/usp/usp_msg/usp-msg-1-2.pb.go similarity index 100% rename from backend/services/ws/internal/usp_message/usp-msg-1-2.pb.go rename to backend/services/mtp/adapter/internal/usp/usp_msg/usp-msg-1-2.pb.go diff --git a/backend/services/ws/internal/usp_message/usp-msg-1-2.proto b/backend/services/mtp/adapter/internal/usp/usp_msg/usp-msg-1-2.proto similarity index 100% rename from backend/services/ws/internal/usp_message/usp-msg-1-2.proto rename to backend/services/mtp/adapter/internal/usp/usp_msg/usp-msg-1-2.proto diff --git a/backend/services/ws/internal/usp_record/usp-record-1-2.pb.go b/backend/services/mtp/adapter/internal/usp/usp_record/usp-record-1-2.pb.go similarity index 100% rename from backend/services/ws/internal/usp_record/usp-record-1-2.pb.go rename to backend/services/mtp/adapter/internal/usp/usp_record/usp-record-1-2.pb.go diff --git a/backend/services/ws/internal/usp_record/usp-record-1-2.proto b/backend/services/mtp/adapter/internal/usp/usp_record/usp-record-1-2.proto similarity index 100% rename from backend/services/ws/internal/usp_record/usp-record-1-2.proto rename to backend/services/mtp/adapter/internal/usp/usp_record/usp-record-1-2.proto diff --git a/backend/services/mtp/mqtt-adapter/README.md b/backend/services/mtp/mqtt-adapter/README.md new file mode 100644 index 0000000..9ab3b63 --- /dev/null +++ b/backend/services/mtp/mqtt-adapter/README.md @@ -0,0 +1 @@ +- acts as a bridge between mqtt server and controller \ No newline at end of file diff --git a/backend/services/mtp/mqtt-adapter/cmd/mqtt-adapter/main.go b/backend/services/mtp/mqtt-adapter/cmd/mqtt-adapter/main.go new file mode 100644 index 0000000..961d48e --- /dev/null +++ b/backend/services/mtp/mqtt-adapter/cmd/mqtt-adapter/main.go @@ -0,0 +1,29 @@ +package main + +import ( + "log" + "os" + "os/signal" + "syscall" + + "github.com/OktopUSP/oktopus/backend/services/mqtt-adapter/internal/bridge" + "github.com/OktopUSP/oktopus/backend/services/mqtt-adapter/internal/config" + "github.com/OktopUSP/oktopus/backend/services/mqtt-adapter/internal/nats" +) + +func main() { + + done := make(chan os.Signal, 1) + signal.Notify(done, syscall.SIGINT, syscall.SIGTERM) + + c := config.NewConfig() + + _, publisher, subscriber := nats.StartNatsClient(c.Nats) + + bridge := bridge.NewBridge(publisher, subscriber, c.Mqtt.Ctx, c.Mqtt) + bridge.StartBridge() + + <-done + + log.Println("mqtt adapter is shutting down...") +} diff --git a/backend/services/mtp/mqtt-adapter/go.mod b/backend/services/mtp/mqtt-adapter/go.mod new file mode 100644 index 0000000..5e4de8a --- /dev/null +++ b/backend/services/mtp/mqtt-adapter/go.mod @@ -0,0 +1,18 @@ +module github.com/OktopUSP/oktopus/backend/services/mqtt-adapter + +go 1.22.0 + +require ( + github.com/eclipse/paho.golang v0.21.0 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/gorilla/websocket v1.5.1 // indirect + github.com/joho/godotenv v1.5.1 // indirect + github.com/klauspost/compress v1.17.7 // indirect + github.com/nats-io/nats.go v1.33.1 // indirect + github.com/nats-io/nkeys v0.4.7 // indirect + github.com/nats-io/nuid v1.0.1 // indirect + golang.org/x/crypto v0.20.0 // indirect + golang.org/x/net v0.21.0 // indirect + golang.org/x/sys v0.17.0 // indirect + golang.org/x/text v0.14.0 // indirect +) diff --git a/backend/services/mtp/mqtt-adapter/go.sum b/backend/services/mtp/mqtt-adapter/go.sum new file mode 100644 index 0000000..806aca2 --- /dev/null +++ b/backend/services/mtp/mqtt-adapter/go.sum @@ -0,0 +1,24 @@ +github.com/eclipse/paho.golang v0.21.0 h1:cxxEReu+iFbA5RrHfRGxJOh8tXZKDywuehneoeBeyn8= +github.com/eclipse/paho.golang v0.21.0/go.mod h1:GHF6vy7SvDbDHBguaUpfuBkEB5G6j0zKxMG4gbh6QRQ= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY= +github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= +github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= +github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= +github.com/klauspost/compress v1.17.7 h1:ehO88t2UGzQK66LMdE8tibEd1ErmzZjNEqWkjLAKQQg= +github.com/klauspost/compress v1.17.7/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= +github.com/nats-io/nats.go v1.33.1 h1:8TxLZZ/seeEfR97qV0/Bl939tpDnt2Z2fK3HkPypj70= +github.com/nats-io/nats.go v1.33.1/go.mod h1:Ubdu4Nh9exXdSz0RVWRFBbRfrbSxOYd26oF0wkWclB8= +github.com/nats-io/nkeys v0.4.7 h1:RwNJbbIdYCoClSDNY7QVKZlyb/wfT6ugvFCiKy6vDvI= +github.com/nats-io/nkeys v0.4.7/go.mod h1:kqXRgRDPlGy7nGaEDMuYzmiJCIAAWDK0IMBtDmGD0nc= +github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw= +github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= +golang.org/x/crypto v0.20.0 h1:jmAMJJZXr5KiCw05dfYK9QnqaqKLYXijU23lsEdcQqg= +golang.org/x/crypto v0.20.0/go.mod h1:Xwo95rrVNIoSMx9wa1JroENMToLWn3RNVrTBpLHgZPQ= +golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4= +golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= +golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y= +golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= diff --git a/backend/services/mtp/mqtt-adapter/internal/bridge/bridge.go b/backend/services/mtp/mqtt-adapter/internal/bridge/bridge.go new file mode 100644 index 0000000..60dae36 --- /dev/null +++ b/backend/services/mtp/mqtt-adapter/internal/bridge/bridge.go @@ -0,0 +1,196 @@ +package bridge + +import ( + "context" + "log" + "net/url" + "strings" + "time" + + "github.com/OktopUSP/oktopus/backend/services/mqtt-adapter/internal/config" + "github.com/eclipse/paho.golang/autopaho" + "github.com/eclipse/paho.golang/paho" + "github.com/google/uuid" + "github.com/nats-io/nats.go" +) + +const ( + ONLINE = iota + OFFLINE +) + +const NATS_MQTT_SUBJECT_PREFIX = "mqtt.usp.v1." +const NATS_MQTT_ADAPTER_SUBJECT_PREFIX = "mqtt-adapter.usp.v1.*." +const MQTT_TOPIC_PREFIX = "oktopus/usp/" + +type ( + Publisher func(string, []byte) error + Subscriber func(string, func(*nats.Msg)) error +) + +type Bridge struct { + Pub Publisher + Sub Subscriber + Mqtt config.Mqtt + Ctx context.Context +} + +func NewBridge(p Publisher, s Subscriber, ctx context.Context, m config.Mqtt) *Bridge { + return &Bridge{ + Pub: p, + Sub: s, + Mqtt: m, + Ctx: ctx, + } +} + +func (b *Bridge) StartBridge() { + + broker, _ := url.Parse(b.Mqtt.Url) + + status := make(chan *paho.Publish) + controller := make(chan *paho.Publish) + apiMsg := make(chan *paho.Publish) + + go b.mqttMessageHandler(status, controller, apiMsg) + + pahoClientConfig := buildClientConfig(status, controller, apiMsg, b.Mqtt.ClientId) + + autopahoClientConfig := autopaho.ClientConfig{ + BrokerUrls: []*url.URL{ + broker, + }, + KeepAlive: 30, + ConnectRetryDelay: 5 * time.Second, + ConnectTimeout: 5 * time.Second, + OnConnectionUp: func(cm *autopaho.ConnectionManager, connAck *paho.Connack) { + log.Printf("Connected to MQTT broker--> %s", b.Mqtt.Url) + subscribe(b.Mqtt.Ctx, b.Mqtt.Qos, cm) + }, + OnConnectError: func(err error) { + log.Printf("Error while attempting connection: %s\n", err) + }, + ClientConfig: *pahoClientConfig, + } + + if b.Mqtt.Username != "" && b.Mqtt.Password != "" { + autopahoClientConfig.SetUsernamePassword(b.Mqtt.Username, []byte(b.Mqtt.Password)) + } + + log.Println("MQTT client id:", pahoClientConfig.ClientID) + log.Println("MQTT username:", b.Mqtt.Username) + log.Println("MQTT password:", b.Mqtt.Password) + + cm, err := autopaho.NewConnection(b.Ctx, autopahoClientConfig) + if err != nil { + log.Fatalln(err) + } + + b.natsMessageHandler(cm) +} + +func (b *Bridge) natsMessageHandler(cm *autopaho.ConnectionManager) { + b.Sub(NATS_MQTT_ADAPTER_SUBJECT_PREFIX+"info", func(m *nats.Msg) { + + log.Printf("Received message on info subject") + cm.Publish(b.Ctx, &paho.Publish{ + QoS: byte(b.Mqtt.Qos), + Topic: MQTT_TOPIC_PREFIX + "v1/agent/" + getDeviceFromSubject(m.Subject), + Payload: m.Data, + Properties: &paho.PublishProperties{ + ResponseTopic: "oktopus/usp/v1/controller/" + getDeviceFromSubject(m.Subject), + }, + }) + }) +} + +func getDeviceFromSubject(subject string) string { + paths := strings.Split(subject, ".") + device := paths[len(paths)-2] + return device +} + +func (b *Bridge) mqttMessageHandler(status, controller, apiMsg chan *paho.Publish) { + for { + select { + case d := <-status: + b.Pub(NATS_MQTT_SUBJECT_PREFIX+getDeviceFromTopic(d.Topic)+".status", d.Payload) + case c := <-controller: + b.Pub(NATS_MQTT_SUBJECT_PREFIX+getDeviceFromTopic(c.Topic)+".info", c.Payload) + case a := <-apiMsg: + b.Pub(NATS_MQTT_SUBJECT_PREFIX+getDeviceFromTopic(a.Topic)+".api", a.Payload) + } + } +} + +func getDeviceFromTopic(topic string) string { + paths := strings.Split(topic, "/") + device := paths[len(paths)-1] + return device +} + +func subscribe(ctx context.Context, qos int, c *autopaho.ConnectionManager) { + if _, err := c.Subscribe(ctx, &paho.Subscribe{ + Subscriptions: []paho.SubscribeOptions{ + { + Topic: MQTT_TOPIC_PREFIX + "+/api/+", + QoS: byte(qos), + }, + { + Topic: MQTT_TOPIC_PREFIX + "+/controller/+", + QoS: byte(qos), + }, + { + Topic: MQTT_TOPIC_PREFIX + "+/status/+", + QoS: byte(qos), + }, + }, + }); err != nil { + log.Fatalln(err) + } + + log.Printf("Subscribed to %s", MQTT_TOPIC_PREFIX+"+/controller/+") + log.Printf("Subscribed to %s", MQTT_TOPIC_PREFIX+"+/status/+") + log.Printf("Subscribed to %s", MQTT_TOPIC_PREFIX+"+/api/+") +} + +func buildClientConfig(status, controller, apiMsg chan *paho.Publish, id string) *paho.ClientConfig { + log.Println("Starting new MQTT client") + singleHandler := paho.NewSingleHandlerRouter(func(p *paho.Publish) { + + if strings.Contains(p.Topic, "status") { + status <- p + } else if strings.Contains(p.Topic, "controller") { + controller <- p + } else if strings.Contains(p.Topic, "api") { + apiMsg <- p + } else { + log.Println("No handler for topic: ", p.Topic) + } + + }) + + clientConfig := paho.ClientConfig{} + + clientConfig = paho.ClientConfig{ + Router: singleHandler, + OnServerDisconnect: func(d *paho.Disconnect) { + if d.Properties != nil { + log.Printf("Requested disconnect: %s\n , properties reason: %s\n", clientConfig.ClientID, d.Properties.ReasonString) + } else { + log.Printf("Requested disconnect; %s reason code: %d\n", clientConfig.ClientID, d.ReasonCode) + } + }, + OnClientError: func(err error) { + log.Println(err) + }, + } + + if id != "" { + clientConfig.ClientID = id + } else { + clientConfig.ClientID = uuid.NewString() + } + + return &clientConfig +} diff --git a/backend/services/mtp/mqtt-adapter/internal/config/config.go b/backend/services/mtp/mqtt-adapter/internal/config/config.go new file mode 100644 index 0000000..8d2c832 --- /dev/null +++ b/backend/services/mtp/mqtt-adapter/internal/config/config.go @@ -0,0 +1,127 @@ +package config + +import ( + "context" + "flag" + "log" + "os" + "strconv" + + "github.com/joho/godotenv" +) + +const LOCAL_ENV = ".env.local" + +type Nats struct { + Url string + Name string + VerifyCertificates bool + Ctx context.Context +} + +type Mqtt struct { + Url string + ClientId string + Username string + Password string + Qos int + Ctx context.Context +} + +type Config struct { + Nats Nats + Mqtt Mqtt +} + +func NewConfig() *Config { + + loadEnvVariables() + log.SetFlags(log.LstdFlags | log.Lshortfile) + + natsUrl := flag.String("nats_url", lookupEnvOrString("NATS_URL", "nats://localhost:4222"), "url for nats server") + natsName := flag.String("nats_name", lookupEnvOrString("NATS_NAME", "mqtt-adapter"), "name for nats client") + natsVerifyCertificates := flag.Bool("nats_verify_certificates", lookupEnvOrBool("NATS_VERIFY_CERTIFICATES", false), "verify validity of certificates from nats server") + mqttUrl := flag.String("mqtt_url", lookupEnvOrString("MQTT_URL", "tcp://localhost:1883"), "url for mqtt server") + mqttClientId := flag.String("mqtt_client_id", lookupEnvOrString("MQTT_CLIENT_ID", "mqtt-adapter"), "client id for mqtt") + mqttUsername := flag.String("mqtt_username", lookupEnvOrString("MQTT_USERNAME", ""), "username for mqtt") + mqttPassword := flag.String("mqtt_password", lookupEnvOrString("MQTT_PASSWORD", ""), "password for mqtt") + mqttQos := flag.Int("mqtt_qos", lookupEnvOrInt("MQTT_QOS", 1), "quality of service for mqtt") + flHelp := flag.Bool("help", false, "Help") + + /* + App variables priority: + 1º - Flag through command line. + 2º - Env variables. + 3º - Default flag value. + */ + + flag.Parse() + + if *flHelp { + flag.Usage() + os.Exit(0) + } + + ctx := context.TODO() + + return &Config{ + Nats: Nats{ + Url: *natsUrl, + Name: *natsName, + VerifyCertificates: *natsVerifyCertificates, + Ctx: ctx, + }, + Mqtt: Mqtt{ + Url: *mqttUrl, + ClientId: *mqttClientId, + Username: *mqttUsername, + Password: *mqttPassword, + Ctx: ctx, + Qos: *mqttQos, + }, + } +} + +func loadEnvVariables() { + err := godotenv.Load() + + if _, err := os.Stat(LOCAL_ENV); err == nil { + _ = godotenv.Overload(LOCAL_ENV) + log.Printf("Loaded variables from '%s'", LOCAL_ENV) + } + + if err != nil { + log.Println("Error to load environment variables:", err) + } else { + log.Println("Loaded variables from '.env'") + } +} + +func lookupEnvOrString(key string, defaultVal string) string { + if val, _ := os.LookupEnv(key); val != "" { + return val + } + return defaultVal +} + +func lookupEnvOrInt(key string, defaultVal int) int { + if val, _ := os.LookupEnv(key); val != "" { + v, err := strconv.Atoi(val) + if err != nil { + log.Fatalf("LookupEnvOrInt[%s]: %v", key, err) + } + return v + } + return defaultVal +} + +func lookupEnvOrBool(key string, defaultVal bool) bool { + if val, _ := os.LookupEnv(key); val != "" { + v, err := strconv.ParseBool(val) + if err != nil { + log.Fatalf("LookupEnvOrBool[%s]: %v", key, err) + } + return v + } + return defaultVal +} diff --git a/backend/services/mtp/mqtt-adapter/internal/nats/nats.go b/backend/services/mtp/mqtt-adapter/internal/nats/nats.go new file mode 100644 index 0000000..e9692cf --- /dev/null +++ b/backend/services/mtp/mqtt-adapter/internal/nats/nats.go @@ -0,0 +1,92 @@ +package nats + +import ( + "log" + "time" + + "github.com/nats-io/nats.go" + "github.com/nats-io/nats.go/jetstream" + + "github.com/OktopUSP/oktopus/backend/services/mqtt-adapter/internal/config" +) + +const ( + STREAM_NAME = "mqtt" +) + +func StartNatsClient(c config.Nats) ( + *nats.Conn, + func(string, []byte) error, + func(string, func(*nats.Msg)) error, +) { + + var ( + nc *nats.Conn + err error + ) + + opts := defineOptions(c) + + for { + nc, err = nats.Connect(c.Url, opts...) + if err != nil { + time.Sleep(5 * time.Second) + continue + } + break + } + log.Printf("Successfully connected to NATS server %s", c.Url) + + js, err := jetstream.New(nc) + if err != nil { + log.Fatalf("Failed to create JetStream client: %v", err) + } + + nc.Subscribe("opa.123.dae", func(m *nats.Msg) { + log.Printf("Received message on subject %s: %s", m.Subject, string(m.Data)) + }) + + return nc, publisher(js), subscriber(nc) +} + +func subscriber(nc *nats.Conn) func(string, func(*nats.Msg)) error { + return func(subject string, handler func(*nats.Msg)) error { + _, err := nc.Subscribe(subject, handler) + if err != nil { + log.Printf("error to subscribe to subject %s error: %q", subject, err) + } + return err + } +} + +func publisher(js jetstream.JetStream) func(string, []byte) error { + return func(subject string, payload []byte) error { + _, err := js.PublishAsync(subject, payload) + if err != nil { + log.Printf("error to send jetstream message: %q", err) + } + return err + } +} + +func defineOptions(c config.Nats) []nats.Option { + var opts []nats.Option + + opts = append(opts, nats.Name(c.Name)) + opts = append(opts, nats.MaxReconnects(-1)) + opts = append(opts, nats.ReconnectWait(5*time.Second)) + opts = append(opts, nats.DisconnectErrHandler(func(nc *nats.Conn, err error) { + log.Printf("Got disconnected! Reason: %q\n", err) + })) + opts = append(opts, nats.ReconnectHandler(func(nc *nats.Conn) { + log.Printf("Got reconnected to %v!\n", nc.ConnectedUrl()) + })) + opts = append(opts, nats.ClosedHandler(func(nc *nats.Conn) { + log.Printf("Connection closed. Reason: %q\n", nc.LastError()) + })) + if c.VerifyCertificates { + opts = append(opts, nats.RootCAs()) + } + + return opts +} diff --git a/backend/services/mtp/mqtt/.env b/backend/services/mtp/mqtt/.env new file mode 100644 index 0000000..e69de29 diff --git a/backend/services/mqtt/.gitignore b/backend/services/mtp/mqtt/.gitignore similarity index 100% rename from backend/services/mqtt/.gitignore rename to backend/services/mtp/mqtt/.gitignore diff --git a/backend/services/mqtt/README.md b/backend/services/mtp/mqtt/README.md similarity index 100% rename from backend/services/mqtt/README.md rename to backend/services/mtp/mqtt/README.md diff --git a/backend/services/mqtt/go.mod b/backend/services/mtp/mqtt/go.mod similarity index 100% rename from backend/services/mqtt/go.mod rename to backend/services/mtp/mqtt/go.mod diff --git a/backend/services/mqtt/go.sum b/backend/services/mtp/mqtt/go.sum similarity index 100% rename from backend/services/mqtt/go.sum rename to backend/services/mtp/mqtt/go.sum diff --git a/backend/services/mqtt/internal/config/config.go b/backend/services/mtp/mqtt/internal/config/config.go similarity index 100% rename from backend/services/mqtt/internal/config/config.go rename to backend/services/mtp/mqtt/internal/config/config.go diff --git a/backend/services/mqtt/internal/listeners/http/http.go b/backend/services/mtp/mqtt/internal/listeners/http/http.go similarity index 100% rename from backend/services/mqtt/internal/listeners/http/http.go rename to backend/services/mtp/mqtt/internal/listeners/http/http.go diff --git a/backend/services/mqtt/internal/listeners/listeners.go b/backend/services/mtp/mqtt/internal/listeners/listeners.go similarity index 100% rename from backend/services/mqtt/internal/listeners/listeners.go rename to backend/services/mtp/mqtt/internal/listeners/listeners.go diff --git a/backend/services/mqtt/internal/listeners/mqtt/hook.go b/backend/services/mtp/mqtt/internal/listeners/mqtt/hook.go similarity index 83% rename from backend/services/mqtt/internal/listeners/mqtt/hook.go rename to backend/services/mtp/mqtt/internal/listeners/mqtt/hook.go index db6373e..aa5eef6 100644 --- a/backend/services/mqtt/internal/listeners/mqtt/hook.go +++ b/backend/services/mtp/mqtt/internal/listeners/mqtt/hook.go @@ -42,7 +42,7 @@ func (h *MyHook) OnDisconnect(cl *mqtt.Client, err error, expire bool) { } if clUser != "" { - err := server.Publish("oktopus/v1/status/"+clUser, []byte("1"), false, 1) + err := server.Publish("oktopus/usp/v1/status/"+clUser, []byte("1"), false, 1) if err != nil { log.Println("server publish error: ", err) } @@ -51,7 +51,7 @@ func (h *MyHook) OnDisconnect(cl *mqtt.Client, err error, expire bool) { func (h *MyHook) OnSubscribed(cl *mqtt.Client, pk packets.Packet, reasonCodes []byte) { //Verifies if it's a device who is subscribed - if strings.Contains(pk.Filters[0].Filter, "oktopus/v1/agent") { + if strings.Contains(pk.Filters[0].Filter, "oktopus/usp/v1/agent") { var clUser string if len(cl.Properties.Props.User) > 0 { @@ -61,12 +61,12 @@ func (h *MyHook) OnSubscribed(cl *mqtt.Client, pk packets.Packet, reasonCodes [] if clUser != "" { cl.Properties.Will = mqtt.Will{ Qos: 1, - TopicName: "oktopus/v1/status/" + clUser, + TopicName: "oktopus/usp/v1/status/" + clUser, Payload: []byte("1"), Retain: false, } log.Println("new device:", clUser) - err := server.Publish("oktopus/v1/status/"+clUser, []byte("0"), false, 1) + err := server.Publish("oktopus/usp/v1/status/"+clUser, []byte("0"), false, 1) if err != nil { log.Println("server publish error: ", err) } @@ -81,7 +81,7 @@ func (h *MyHook) OnPacketEncode(cl *mqtt.Client, pk packets.Packet) packets.Pack clUser = cl.Properties.Props.User[0].Val } if pk.FixedHeader.Type == packets.Connack { - pk.Properties.User = []packets.UserProperty{{Key: "subscribe-topic", Val: "oktopus/v1/agent/" + clUser}} + pk.Properties.User = []packets.UserProperty{{Key: "subscribe-topic", Val: "oktopus/usp/v1/agent/" + clUser}} } return pk diff --git a/backend/services/mqtt/internal/listeners/mqtt/mqtt.go b/backend/services/mtp/mqtt/internal/listeners/mqtt/mqtt.go similarity index 91% rename from backend/services/mqtt/internal/listeners/mqtt/mqtt.go rename to backend/services/mtp/mqtt/internal/listeners/mqtt/mqtt.go index 84a460f..9deb164 100644 --- a/backend/services/mqtt/internal/listeners/mqtt/mqtt.go +++ b/backend/services/mtp/mqtt/internal/listeners/mqtt/mqtt.go @@ -35,18 +35,20 @@ type Redis struct { RedisPassword string } -func (m *Mqtt) Start(server *mqtt.Server) { +func (m *Mqtt) Start(mqttServer *mqtt.Server) { - defineSeverLog(server, m.LogLevel) - defineServerAuth(server, m.AuthFile) + defineSeverLog(mqttServer, m.LogLevel) + defineServerAuth(mqttServer, m.AuthFile) + + server = mqttServer var tlsConfig *listeners.Config if m.Tls { tlsConfig = defineServerTls(m.Fullchain, m.Privkey) } - createListener(server, m.Port, tlsConfig) - addHooks(server, m.Redis) + createListener(mqttServer, m.Port, tlsConfig) + addHooks(mqttServer, m.Redis) } func addHooks(server *mqtt.Server, redisConf Redis) { diff --git a/backend/services/mqtt/internal/listeners/ws/ws.go b/backend/services/mtp/mqtt/internal/listeners/ws/ws.go similarity index 100% rename from backend/services/mqtt/internal/listeners/ws/ws.go rename to backend/services/mtp/mqtt/internal/listeners/ws/ws.go diff --git a/backend/services/mtp/mqtt/mqtt b/backend/services/mtp/mqtt/mqtt new file mode 100755 index 0000000..c231c69 Binary files /dev/null and b/backend/services/mtp/mqtt/mqtt differ diff --git a/backend/services/stomp/.env b/backend/services/mtp/stomp/.env similarity index 100% rename from backend/services/stomp/.env rename to backend/services/mtp/stomp/.env diff --git a/backend/services/stomp/.gitignore b/backend/services/mtp/stomp/.gitignore similarity index 100% rename from backend/services/stomp/.gitignore rename to backend/services/mtp/stomp/.gitignore diff --git a/backend/services/stomp/AUTHORS.md b/backend/services/mtp/stomp/AUTHORS.md similarity index 100% rename from backend/services/stomp/AUTHORS.md rename to backend/services/mtp/stomp/AUTHORS.md diff --git a/backend/services/stomp/LICENSE.txt b/backend/services/mtp/stomp/LICENSE.txt similarity index 100% rename from backend/services/stomp/LICENSE.txt rename to backend/services/mtp/stomp/LICENSE.txt diff --git a/backend/services/stomp/README.md b/backend/services/mtp/stomp/README.md similarity index 100% rename from backend/services/stomp/README.md rename to backend/services/mtp/stomp/README.md diff --git a/backend/services/stomp/ack.go b/backend/services/mtp/stomp/ack.go similarity index 100% rename from backend/services/stomp/ack.go rename to backend/services/mtp/stomp/ack.go diff --git a/backend/services/stomp/breaking_changes.md b/backend/services/mtp/stomp/breaking_changes.md similarity index 100% rename from backend/services/stomp/breaking_changes.md rename to backend/services/mtp/stomp/breaking_changes.md diff --git a/backend/services/stomp/cmd/main.go b/backend/services/mtp/stomp/cmd/main.go similarity index 100% rename from backend/services/stomp/cmd/main.go rename to backend/services/mtp/stomp/cmd/main.go diff --git a/backend/services/stomp/conn.go b/backend/services/mtp/stomp/conn.go similarity index 100% rename from backend/services/stomp/conn.go rename to backend/services/mtp/stomp/conn.go diff --git a/backend/services/stomp/conn_options.go b/backend/services/mtp/stomp/conn_options.go similarity index 100% rename from backend/services/stomp/conn_options.go rename to backend/services/mtp/stomp/conn_options.go diff --git a/backend/services/stomp/conn_test.go b/backend/services/mtp/stomp/conn_test.go similarity index 100% rename from backend/services/stomp/conn_test.go rename to backend/services/mtp/stomp/conn_test.go diff --git a/backend/services/stomp/errors.go b/backend/services/mtp/stomp/errors.go similarity index 100% rename from backend/services/stomp/errors.go rename to backend/services/mtp/stomp/errors.go diff --git a/backend/services/stomp/example_test.go b/backend/services/mtp/stomp/example_test.go similarity index 100% rename from backend/services/stomp/example_test.go rename to backend/services/mtp/stomp/example_test.go diff --git a/backend/services/stomp/examples/client_test/main.go b/backend/services/mtp/stomp/examples/client_test/main.go similarity index 100% rename from backend/services/stomp/examples/client_test/main.go rename to backend/services/mtp/stomp/examples/client_test/main.go diff --git a/backend/services/stomp/frame/ack.go b/backend/services/mtp/stomp/frame/ack.go similarity index 100% rename from backend/services/stomp/frame/ack.go rename to backend/services/mtp/stomp/frame/ack.go diff --git a/backend/services/stomp/frame/command.go b/backend/services/mtp/stomp/frame/command.go similarity index 100% rename from backend/services/stomp/frame/command.go rename to backend/services/mtp/stomp/frame/command.go diff --git a/backend/services/stomp/frame/encode.go b/backend/services/mtp/stomp/frame/encode.go similarity index 100% rename from backend/services/stomp/frame/encode.go rename to backend/services/mtp/stomp/frame/encode.go diff --git a/backend/services/stomp/frame/encode_test.go b/backend/services/mtp/stomp/frame/encode_test.go similarity index 100% rename from backend/services/stomp/frame/encode_test.go rename to backend/services/mtp/stomp/frame/encode_test.go diff --git a/backend/services/stomp/frame/errors.go b/backend/services/mtp/stomp/frame/errors.go similarity index 100% rename from backend/services/stomp/frame/errors.go rename to backend/services/mtp/stomp/frame/errors.go diff --git a/backend/services/stomp/frame/frame.go b/backend/services/mtp/stomp/frame/frame.go similarity index 100% rename from backend/services/stomp/frame/frame.go rename to backend/services/mtp/stomp/frame/frame.go diff --git a/backend/services/stomp/frame/frame_test.go b/backend/services/mtp/stomp/frame/frame_test.go similarity index 100% rename from backend/services/stomp/frame/frame_test.go rename to backend/services/mtp/stomp/frame/frame_test.go diff --git a/backend/services/stomp/frame/header.go b/backend/services/mtp/stomp/frame/header.go similarity index 100% rename from backend/services/stomp/frame/header.go rename to backend/services/mtp/stomp/frame/header.go diff --git a/backend/services/stomp/frame/header_test.go b/backend/services/mtp/stomp/frame/header_test.go similarity index 100% rename from backend/services/stomp/frame/header_test.go rename to backend/services/mtp/stomp/frame/header_test.go diff --git a/backend/services/stomp/frame/heartbeat.go b/backend/services/mtp/stomp/frame/heartbeat.go similarity index 100% rename from backend/services/stomp/frame/heartbeat.go rename to backend/services/mtp/stomp/frame/heartbeat.go diff --git a/backend/services/stomp/frame/heartbeat_test.go b/backend/services/mtp/stomp/frame/heartbeat_test.go similarity index 100% rename from backend/services/stomp/frame/heartbeat_test.go rename to backend/services/mtp/stomp/frame/heartbeat_test.go diff --git a/backend/services/stomp/frame/reader.go b/backend/services/mtp/stomp/frame/reader.go similarity index 100% rename from backend/services/stomp/frame/reader.go rename to backend/services/mtp/stomp/frame/reader.go diff --git a/backend/services/stomp/frame/reader_test.go b/backend/services/mtp/stomp/frame/reader_test.go similarity index 100% rename from backend/services/stomp/frame/reader_test.go rename to backend/services/mtp/stomp/frame/reader_test.go diff --git a/backend/services/stomp/frame/writer.go b/backend/services/mtp/stomp/frame/writer.go similarity index 100% rename from backend/services/stomp/frame/writer.go rename to backend/services/mtp/stomp/frame/writer.go diff --git a/backend/services/stomp/frame/writer_test.go b/backend/services/mtp/stomp/frame/writer_test.go similarity index 100% rename from backend/services/stomp/frame/writer_test.go rename to backend/services/mtp/stomp/frame/writer_test.go diff --git a/backend/services/stomp/go.mod b/backend/services/mtp/stomp/go.mod similarity index 100% rename from backend/services/stomp/go.mod rename to backend/services/mtp/stomp/go.mod diff --git a/backend/services/stomp/go.sum b/backend/services/mtp/stomp/go.sum similarity index 100% rename from backend/services/stomp/go.sum rename to backend/services/mtp/stomp/go.sum diff --git a/backend/services/stomp/id.go b/backend/services/mtp/stomp/id.go similarity index 100% rename from backend/services/stomp/id.go rename to backend/services/mtp/stomp/id.go diff --git a/backend/services/stomp/id_test.go b/backend/services/mtp/stomp/id_test.go similarity index 100% rename from backend/services/stomp/id_test.go rename to backend/services/mtp/stomp/id_test.go diff --git a/backend/services/stomp/internal/log/stdlogger.go b/backend/services/mtp/stomp/internal/log/stdlogger.go similarity index 100% rename from backend/services/stomp/internal/log/stdlogger.go rename to backend/services/mtp/stomp/internal/log/stdlogger.go diff --git a/backend/services/stomp/logger.go b/backend/services/mtp/stomp/logger.go similarity index 100% rename from backend/services/stomp/logger.go rename to backend/services/mtp/stomp/logger.go diff --git a/backend/services/stomp/message.go b/backend/services/mtp/stomp/message.go similarity index 100% rename from backend/services/stomp/message.go rename to backend/services/mtp/stomp/message.go diff --git a/backend/services/stomp/send_options.go b/backend/services/mtp/stomp/send_options.go similarity index 100% rename from backend/services/stomp/send_options.go rename to backend/services/mtp/stomp/send_options.go diff --git a/backend/services/stomp/server/client/channel_test.go b/backend/services/mtp/stomp/server/client/channel_test.go similarity index 100% rename from backend/services/stomp/server/client/channel_test.go rename to backend/services/mtp/stomp/server/client/channel_test.go diff --git a/backend/services/stomp/server/client/client.go b/backend/services/mtp/stomp/server/client/client.go similarity index 100% rename from backend/services/stomp/server/client/client.go rename to backend/services/mtp/stomp/server/client/client.go diff --git a/backend/services/stomp/server/client/client_test.go b/backend/services/mtp/stomp/server/client/client_test.go similarity index 100% rename from backend/services/stomp/server/client/client_test.go rename to backend/services/mtp/stomp/server/client/client_test.go diff --git a/backend/services/stomp/server/client/config.go b/backend/services/mtp/stomp/server/client/config.go similarity index 100% rename from backend/services/stomp/server/client/config.go rename to backend/services/mtp/stomp/server/client/config.go diff --git a/backend/services/stomp/server/client/conn.go b/backend/services/mtp/stomp/server/client/conn.go similarity index 100% rename from backend/services/stomp/server/client/conn.go rename to backend/services/mtp/stomp/server/client/conn.go diff --git a/backend/services/stomp/server/client/errors.go b/backend/services/mtp/stomp/server/client/errors.go similarity index 100% rename from backend/services/stomp/server/client/errors.go rename to backend/services/mtp/stomp/server/client/errors.go diff --git a/backend/services/stomp/server/client/frame.go b/backend/services/mtp/stomp/server/client/frame.go similarity index 100% rename from backend/services/stomp/server/client/frame.go rename to backend/services/mtp/stomp/server/client/frame.go diff --git a/backend/services/stomp/server/client/frame_test.go b/backend/services/mtp/stomp/server/client/frame_test.go similarity index 100% rename from backend/services/stomp/server/client/frame_test.go rename to backend/services/mtp/stomp/server/client/frame_test.go diff --git a/backend/services/stomp/server/client/request.go b/backend/services/mtp/stomp/server/client/request.go similarity index 100% rename from backend/services/stomp/server/client/request.go rename to backend/services/mtp/stomp/server/client/request.go diff --git a/backend/services/stomp/server/client/subscription.go b/backend/services/mtp/stomp/server/client/subscription.go similarity index 100% rename from backend/services/stomp/server/client/subscription.go rename to backend/services/mtp/stomp/server/client/subscription.go diff --git a/backend/services/stomp/server/client/subscription_list.go b/backend/services/mtp/stomp/server/client/subscription_list.go similarity index 100% rename from backend/services/stomp/server/client/subscription_list.go rename to backend/services/mtp/stomp/server/client/subscription_list.go diff --git a/backend/services/stomp/server/client/subscription_list_test.go b/backend/services/mtp/stomp/server/client/subscription_list_test.go similarity index 100% rename from backend/services/stomp/server/client/subscription_list_test.go rename to backend/services/mtp/stomp/server/client/subscription_list_test.go diff --git a/backend/services/stomp/server/client/tx_store.go b/backend/services/mtp/stomp/server/client/tx_store.go similarity index 100% rename from backend/services/stomp/server/client/tx_store.go rename to backend/services/mtp/stomp/server/client/tx_store.go diff --git a/backend/services/stomp/server/client/tx_store_test.go b/backend/services/mtp/stomp/server/client/tx_store_test.go similarity index 100% rename from backend/services/stomp/server/client/tx_store_test.go rename to backend/services/mtp/stomp/server/client/tx_store_test.go diff --git a/backend/services/stomp/server/client/util.go b/backend/services/mtp/stomp/server/client/util.go similarity index 100% rename from backend/services/stomp/server/client/util.go rename to backend/services/mtp/stomp/server/client/util.go diff --git a/backend/services/stomp/server/client/util_test.go b/backend/services/mtp/stomp/server/client/util_test.go similarity index 100% rename from backend/services/stomp/server/client/util_test.go rename to backend/services/mtp/stomp/server/client/util_test.go diff --git a/backend/services/stomp/server/processor.go b/backend/services/mtp/stomp/server/processor.go similarity index 100% rename from backend/services/stomp/server/processor.go rename to backend/services/mtp/stomp/server/processor.go diff --git a/backend/services/stomp/server/queue/manager.go b/backend/services/mtp/stomp/server/queue/manager.go similarity index 100% rename from backend/services/stomp/server/queue/manager.go rename to backend/services/mtp/stomp/server/queue/manager.go diff --git a/backend/services/stomp/server/queue/manager_test.go b/backend/services/mtp/stomp/server/queue/manager_test.go similarity index 100% rename from backend/services/stomp/server/queue/manager_test.go rename to backend/services/mtp/stomp/server/queue/manager_test.go diff --git a/backend/services/stomp/server/queue/memory_queue.go b/backend/services/mtp/stomp/server/queue/memory_queue.go similarity index 100% rename from backend/services/stomp/server/queue/memory_queue.go rename to backend/services/mtp/stomp/server/queue/memory_queue.go diff --git a/backend/services/stomp/server/queue/memory_queue_test.go b/backend/services/mtp/stomp/server/queue/memory_queue_test.go similarity index 100% rename from backend/services/stomp/server/queue/memory_queue_test.go rename to backend/services/mtp/stomp/server/queue/memory_queue_test.go diff --git a/backend/services/stomp/server/queue/queue.go b/backend/services/mtp/stomp/server/queue/queue.go similarity index 100% rename from backend/services/stomp/server/queue/queue.go rename to backend/services/mtp/stomp/server/queue/queue.go diff --git a/backend/services/stomp/server/queue/queue_test.go b/backend/services/mtp/stomp/server/queue/queue_test.go similarity index 100% rename from backend/services/stomp/server/queue/queue_test.go rename to backend/services/mtp/stomp/server/queue/queue_test.go diff --git a/backend/services/stomp/server/queue/storage.go b/backend/services/mtp/stomp/server/queue/storage.go similarity index 100% rename from backend/services/stomp/server/queue/storage.go rename to backend/services/mtp/stomp/server/queue/storage.go diff --git a/backend/services/stomp/server/queue_storage.go b/backend/services/mtp/stomp/server/queue_storage.go similarity index 100% rename from backend/services/stomp/server/queue_storage.go rename to backend/services/mtp/stomp/server/queue_storage.go diff --git a/backend/services/stomp/server/server.go b/backend/services/mtp/stomp/server/server.go similarity index 100% rename from backend/services/stomp/server/server.go rename to backend/services/mtp/stomp/server/server.go diff --git a/backend/services/stomp/server/server_test.go b/backend/services/mtp/stomp/server/server_test.go similarity index 100% rename from backend/services/stomp/server/server_test.go rename to backend/services/mtp/stomp/server/server_test.go diff --git a/backend/services/stomp/server/topic/manager.go b/backend/services/mtp/stomp/server/topic/manager.go similarity index 100% rename from backend/services/stomp/server/topic/manager.go rename to backend/services/mtp/stomp/server/topic/manager.go diff --git a/backend/services/stomp/server/topic/manager_test.go b/backend/services/mtp/stomp/server/topic/manager_test.go similarity index 100% rename from backend/services/stomp/server/topic/manager_test.go rename to backend/services/mtp/stomp/server/topic/manager_test.go diff --git a/backend/services/stomp/server/topic/subscription.go b/backend/services/mtp/stomp/server/topic/subscription.go similarity index 100% rename from backend/services/stomp/server/topic/subscription.go rename to backend/services/mtp/stomp/server/topic/subscription.go diff --git a/backend/services/stomp/server/topic/testing_test.go b/backend/services/mtp/stomp/server/topic/testing_test.go similarity index 100% rename from backend/services/stomp/server/topic/testing_test.go rename to backend/services/mtp/stomp/server/topic/testing_test.go diff --git a/backend/services/stomp/server/topic/topic.go b/backend/services/mtp/stomp/server/topic/topic.go similarity index 100% rename from backend/services/stomp/server/topic/topic.go rename to backend/services/mtp/stomp/server/topic/topic.go diff --git a/backend/services/stomp/server/topic/topic_test.go b/backend/services/mtp/stomp/server/topic/topic_test.go similarity index 100% rename from backend/services/stomp/server/topic/topic_test.go rename to backend/services/mtp/stomp/server/topic/topic_test.go diff --git a/backend/services/stomp/stomp.go b/backend/services/mtp/stomp/stomp.go similarity index 100% rename from backend/services/stomp/stomp.go rename to backend/services/mtp/stomp/stomp.go diff --git a/backend/services/stomp/stomp_test.go b/backend/services/mtp/stomp/stomp_test.go similarity index 100% rename from backend/services/stomp/stomp_test.go rename to backend/services/mtp/stomp/stomp_test.go diff --git a/backend/services/stomp/stompd/main.go b/backend/services/mtp/stomp/stompd/main.go similarity index 100% rename from backend/services/stomp/stompd/main.go rename to backend/services/mtp/stomp/stompd/main.go diff --git a/backend/services/stomp/stompd/signals.go b/backend/services/mtp/stomp/stompd/signals.go similarity index 100% rename from backend/services/stomp/stompd/signals.go rename to backend/services/mtp/stomp/stompd/signals.go diff --git a/backend/services/stomp/stompd/signals_unix.go b/backend/services/mtp/stomp/stompd/signals_unix.go similarity index 100% rename from backend/services/stomp/stompd/signals_unix.go rename to backend/services/mtp/stomp/stompd/signals_unix.go diff --git a/backend/services/stomp/stompd/signals_windows.go b/backend/services/mtp/stomp/stompd/signals_windows.go similarity index 100% rename from backend/services/stomp/stompd/signals_windows.go rename to backend/services/mtp/stomp/stompd/signals_windows.go diff --git a/backend/services/stomp/stompd/stompd b/backend/services/mtp/stomp/stompd/stompd similarity index 100% rename from backend/services/stomp/stompd/stompd rename to backend/services/mtp/stomp/stompd/stompd diff --git a/backend/services/stomp/subscribe_options.go b/backend/services/mtp/stomp/subscribe_options.go similarity index 100% rename from backend/services/stomp/subscribe_options.go rename to backend/services/mtp/stomp/subscribe_options.go diff --git a/backend/services/stomp/subscription.go b/backend/services/mtp/stomp/subscription.go similarity index 100% rename from backend/services/stomp/subscription.go rename to backend/services/mtp/stomp/subscription.go diff --git a/backend/services/stomp/testutil/fake_conn.go b/backend/services/mtp/stomp/testutil/fake_conn.go similarity index 100% rename from backend/services/stomp/testutil/fake_conn.go rename to backend/services/mtp/stomp/testutil/fake_conn.go diff --git a/backend/services/stomp/testutil/fake_conn_test.go b/backend/services/mtp/stomp/testutil/fake_conn_test.go similarity index 100% rename from backend/services/stomp/testutil/fake_conn_test.go rename to backend/services/mtp/stomp/testutil/fake_conn_test.go diff --git a/backend/services/stomp/testutil/mock_logger.go b/backend/services/mtp/stomp/testutil/mock_logger.go similarity index 100% rename from backend/services/stomp/testutil/mock_logger.go rename to backend/services/mtp/stomp/testutil/mock_logger.go diff --git a/backend/services/stomp/testutil/testutil.go b/backend/services/mtp/stomp/testutil/testutil.go similarity index 100% rename from backend/services/stomp/testutil/testutil.go rename to backend/services/mtp/stomp/testutil/testutil.go diff --git a/backend/services/stomp/transaction.go b/backend/services/mtp/stomp/transaction.go similarity index 100% rename from backend/services/stomp/transaction.go rename to backend/services/mtp/stomp/transaction.go diff --git a/backend/services/stomp/validator.go b/backend/services/mtp/stomp/validator.go similarity index 100% rename from backend/services/stomp/validator.go rename to backend/services/mtp/stomp/validator.go diff --git a/backend/services/stomp/version.go b/backend/services/mtp/stomp/version.go similarity index 100% rename from backend/services/stomp/version.go rename to backend/services/mtp/stomp/version.go diff --git a/backend/services/stomp/version_test.go b/backend/services/mtp/stomp/version_test.go similarity index 100% rename from backend/services/stomp/version_test.go rename to backend/services/mtp/stomp/version_test.go diff --git a/backend/services/ws/.env b/backend/services/mtp/ws/.env similarity index 100% rename from backend/services/ws/.env rename to backend/services/mtp/ws/.env diff --git a/backend/services/ws/.gitignore b/backend/services/mtp/ws/.gitignore similarity index 100% rename from backend/services/ws/.gitignore rename to backend/services/mtp/ws/.gitignore diff --git a/backend/services/ws/cmd/main.go b/backend/services/mtp/ws/cmd/main.go similarity index 100% rename from backend/services/ws/cmd/main.go rename to backend/services/mtp/ws/cmd/main.go diff --git a/backend/services/ws/go.mod b/backend/services/mtp/ws/go.mod similarity index 100% rename from backend/services/ws/go.mod rename to backend/services/mtp/ws/go.mod diff --git a/backend/services/ws/go.sum b/backend/services/mtp/ws/go.sum similarity index 100% rename from backend/services/ws/go.sum rename to backend/services/mtp/ws/go.sum diff --git a/backend/services/ws/internal/config/config.go b/backend/services/mtp/ws/internal/config/config.go similarity index 100% rename from backend/services/ws/internal/config/config.go rename to backend/services/mtp/ws/internal/config/config.go diff --git a/backend/services/mtp/ws/internal/usp_message/usp-msg-1-2.pb.go b/backend/services/mtp/ws/internal/usp_message/usp-msg-1-2.pb.go new file mode 100755 index 0000000..e63ed42 --- /dev/null +++ b/backend/services/mtp/ws/internal/usp_message/usp-msg-1-2.pb.go @@ -0,0 +1,6606 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.1 +// protoc v3.21.12 +// source: usp-msg-1-2.proto + +//************************************************************************** +// TR-369 USP Message Protocol Buffer Schema +// +// Copyright (c) 2017-2018, Broadband Forum +// +// The undersigned members have elected to grant the copyright to +// their contributed material used in this software: +// Copyright (c) 2017-2018 ARRIS Enterprises, LLC. +// +// Redistribution and use in source and binary forms, with or +// without modification, are permitted provided that the following +// conditions are met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials +// provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products +// derived from this software without specific prior written +// permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +// CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// The above license is used as a license under copyright only. +// Please reference the Forum IPR Policy for patent licensing terms +// . +// +// Any moral rights which are necessary to exercise under the above +// license grant are also deemed granted under this license. +// +// | Version | Name | Date | +// | TR-369 1.0.0 | User Services Platform | APR, 2018 | +// | TR-369 1.0.1 | User Services Platform | JUN, 2018 | +// | TR-369 1.0.2 | User Services Platform | OCT, 2018 | +// | TR-369 1.1 | User Services Platform | SEP, 2019 | +// +// BBF software release registry: http://www.broadband-forum.org/software +//************************************************************************** + +package usp_msg + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Header_MsgType int32 + +const ( + Header_ERROR Header_MsgType = 0 + Header_GET Header_MsgType = 1 + Header_GET_RESP Header_MsgType = 2 + Header_NOTIFY Header_MsgType = 3 + Header_SET Header_MsgType = 4 + Header_SET_RESP Header_MsgType = 5 + Header_OPERATE Header_MsgType = 6 + Header_OPERATE_RESP Header_MsgType = 7 + Header_ADD Header_MsgType = 8 + Header_ADD_RESP Header_MsgType = 9 + Header_DELETE Header_MsgType = 10 + Header_DELETE_RESP Header_MsgType = 11 + Header_GET_SUPPORTED_DM Header_MsgType = 12 + Header_GET_SUPPORTED_DM_RESP Header_MsgType = 13 + Header_GET_INSTANCES Header_MsgType = 14 + Header_GET_INSTANCES_RESP Header_MsgType = 15 + Header_NOTIFY_RESP Header_MsgType = 16 + Header_GET_SUPPORTED_PROTO Header_MsgType = 17 + Header_GET_SUPPORTED_PROTO_RESP Header_MsgType = 18 +) + +// Enum value maps for Header_MsgType. +var ( + Header_MsgType_name = map[int32]string{ + 0: "ERROR", + 1: "GET", + 2: "GET_RESP", + 3: "NOTIFY", + 4: "SET", + 5: "SET_RESP", + 6: "OPERATE", + 7: "OPERATE_RESP", + 8: "ADD", + 9: "ADD_RESP", + 10: "DELETE", + 11: "DELETE_RESP", + 12: "GET_SUPPORTED_DM", + 13: "GET_SUPPORTED_DM_RESP", + 14: "GET_INSTANCES", + 15: "GET_INSTANCES_RESP", + 16: "NOTIFY_RESP", + 17: "GET_SUPPORTED_PROTO", + 18: "GET_SUPPORTED_PROTO_RESP", + } + Header_MsgType_value = map[string]int32{ + "ERROR": 0, + "GET": 1, + "GET_RESP": 2, + "NOTIFY": 3, + "SET": 4, + "SET_RESP": 5, + "OPERATE": 6, + "OPERATE_RESP": 7, + "ADD": 8, + "ADD_RESP": 9, + "DELETE": 10, + "DELETE_RESP": 11, + "GET_SUPPORTED_DM": 12, + "GET_SUPPORTED_DM_RESP": 13, + "GET_INSTANCES": 14, + "GET_INSTANCES_RESP": 15, + "NOTIFY_RESP": 16, + "GET_SUPPORTED_PROTO": 17, + "GET_SUPPORTED_PROTO_RESP": 18, + } +) + +func (x Header_MsgType) Enum() *Header_MsgType { + p := new(Header_MsgType) + *p = x + return p +} + +func (x Header_MsgType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Header_MsgType) Descriptor() protoreflect.EnumDescriptor { + return file_usp_msg_1_2_proto_enumTypes[0].Descriptor() +} + +func (Header_MsgType) Type() protoreflect.EnumType { + return &file_usp_msg_1_2_proto_enumTypes[0] +} + +func (x Header_MsgType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Header_MsgType.Descriptor instead. +func (Header_MsgType) EnumDescriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{1, 0} +} + +type GetSupportedDMResp_ParamAccessType int32 + +const ( + GetSupportedDMResp_PARAM_READ_ONLY GetSupportedDMResp_ParamAccessType = 0 + GetSupportedDMResp_PARAM_READ_WRITE GetSupportedDMResp_ParamAccessType = 1 + GetSupportedDMResp_PARAM_WRITE_ONLY GetSupportedDMResp_ParamAccessType = 2 +) + +// Enum value maps for GetSupportedDMResp_ParamAccessType. +var ( + GetSupportedDMResp_ParamAccessType_name = map[int32]string{ + 0: "PARAM_READ_ONLY", + 1: "PARAM_READ_WRITE", + 2: "PARAM_WRITE_ONLY", + } + GetSupportedDMResp_ParamAccessType_value = map[string]int32{ + "PARAM_READ_ONLY": 0, + "PARAM_READ_WRITE": 1, + "PARAM_WRITE_ONLY": 2, + } +) + +func (x GetSupportedDMResp_ParamAccessType) Enum() *GetSupportedDMResp_ParamAccessType { + p := new(GetSupportedDMResp_ParamAccessType) + *p = x + return p +} + +func (x GetSupportedDMResp_ParamAccessType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (GetSupportedDMResp_ParamAccessType) Descriptor() protoreflect.EnumDescriptor { + return file_usp_msg_1_2_proto_enumTypes[1].Descriptor() +} + +func (GetSupportedDMResp_ParamAccessType) Type() protoreflect.EnumType { + return &file_usp_msg_1_2_proto_enumTypes[1] +} + +func (x GetSupportedDMResp_ParamAccessType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use GetSupportedDMResp_ParamAccessType.Descriptor instead. +func (GetSupportedDMResp_ParamAccessType) EnumDescriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{9, 0} +} + +type GetSupportedDMResp_ObjAccessType int32 + +const ( + GetSupportedDMResp_OBJ_READ_ONLY GetSupportedDMResp_ObjAccessType = 0 + GetSupportedDMResp_OBJ_ADD_DELETE GetSupportedDMResp_ObjAccessType = 1 + GetSupportedDMResp_OBJ_ADD_ONLY GetSupportedDMResp_ObjAccessType = 2 + GetSupportedDMResp_OBJ_DELETE_ONLY GetSupportedDMResp_ObjAccessType = 3 +) + +// Enum value maps for GetSupportedDMResp_ObjAccessType. +var ( + GetSupportedDMResp_ObjAccessType_name = map[int32]string{ + 0: "OBJ_READ_ONLY", + 1: "OBJ_ADD_DELETE", + 2: "OBJ_ADD_ONLY", + 3: "OBJ_DELETE_ONLY", + } + GetSupportedDMResp_ObjAccessType_value = map[string]int32{ + "OBJ_READ_ONLY": 0, + "OBJ_ADD_DELETE": 1, + "OBJ_ADD_ONLY": 2, + "OBJ_DELETE_ONLY": 3, + } +) + +func (x GetSupportedDMResp_ObjAccessType) Enum() *GetSupportedDMResp_ObjAccessType { + p := new(GetSupportedDMResp_ObjAccessType) + *p = x + return p +} + +func (x GetSupportedDMResp_ObjAccessType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (GetSupportedDMResp_ObjAccessType) Descriptor() protoreflect.EnumDescriptor { + return file_usp_msg_1_2_proto_enumTypes[2].Descriptor() +} + +func (GetSupportedDMResp_ObjAccessType) Type() protoreflect.EnumType { + return &file_usp_msg_1_2_proto_enumTypes[2] +} + +func (x GetSupportedDMResp_ObjAccessType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use GetSupportedDMResp_ObjAccessType.Descriptor instead. +func (GetSupportedDMResp_ObjAccessType) EnumDescriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{9, 1} +} + +type GetSupportedDMResp_ParamValueType int32 + +const ( + GetSupportedDMResp_PARAM_UNKNOWN GetSupportedDMResp_ParamValueType = 0 + GetSupportedDMResp_PARAM_BASE_64 GetSupportedDMResp_ParamValueType = 1 + GetSupportedDMResp_PARAM_BOOLEAN GetSupportedDMResp_ParamValueType = 2 + GetSupportedDMResp_PARAM_DATE_TIME GetSupportedDMResp_ParamValueType = 3 + GetSupportedDMResp_PARAM_DECIMAL GetSupportedDMResp_ParamValueType = 4 + GetSupportedDMResp_PARAM_HEX_BINARY GetSupportedDMResp_ParamValueType = 5 + GetSupportedDMResp_PARAM_INT GetSupportedDMResp_ParamValueType = 6 + GetSupportedDMResp_PARAM_LONG GetSupportedDMResp_ParamValueType = 7 + GetSupportedDMResp_PARAM_STRING GetSupportedDMResp_ParamValueType = 8 + GetSupportedDMResp_PARAM_UNSIGNED_INT GetSupportedDMResp_ParamValueType = 9 + GetSupportedDMResp_PARAM_UNSIGNED_LONG GetSupportedDMResp_ParamValueType = 10 +) + +// Enum value maps for GetSupportedDMResp_ParamValueType. +var ( + GetSupportedDMResp_ParamValueType_name = map[int32]string{ + 0: "PARAM_UNKNOWN", + 1: "PARAM_BASE_64", + 2: "PARAM_BOOLEAN", + 3: "PARAM_DATE_TIME", + 4: "PARAM_DECIMAL", + 5: "PARAM_HEX_BINARY", + 6: "PARAM_INT", + 7: "PARAM_LONG", + 8: "PARAM_STRING", + 9: "PARAM_UNSIGNED_INT", + 10: "PARAM_UNSIGNED_LONG", + } + GetSupportedDMResp_ParamValueType_value = map[string]int32{ + "PARAM_UNKNOWN": 0, + "PARAM_BASE_64": 1, + "PARAM_BOOLEAN": 2, + "PARAM_DATE_TIME": 3, + "PARAM_DECIMAL": 4, + "PARAM_HEX_BINARY": 5, + "PARAM_INT": 6, + "PARAM_LONG": 7, + "PARAM_STRING": 8, + "PARAM_UNSIGNED_INT": 9, + "PARAM_UNSIGNED_LONG": 10, + } +) + +func (x GetSupportedDMResp_ParamValueType) Enum() *GetSupportedDMResp_ParamValueType { + p := new(GetSupportedDMResp_ParamValueType) + *p = x + return p +} + +func (x GetSupportedDMResp_ParamValueType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (GetSupportedDMResp_ParamValueType) Descriptor() protoreflect.EnumDescriptor { + return file_usp_msg_1_2_proto_enumTypes[3].Descriptor() +} + +func (GetSupportedDMResp_ParamValueType) Type() protoreflect.EnumType { + return &file_usp_msg_1_2_proto_enumTypes[3] +} + +func (x GetSupportedDMResp_ParamValueType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use GetSupportedDMResp_ParamValueType.Descriptor instead. +func (GetSupportedDMResp_ParamValueType) EnumDescriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{9, 2} +} + +type GetSupportedDMResp_ValueChangeType int32 + +const ( + GetSupportedDMResp_VALUE_CHANGE_UNKNOWN GetSupportedDMResp_ValueChangeType = 0 + GetSupportedDMResp_VALUE_CHANGE_ALLOWED GetSupportedDMResp_ValueChangeType = 1 + GetSupportedDMResp_VALUE_CHANGE_WILL_IGNORE GetSupportedDMResp_ValueChangeType = 2 +) + +// Enum value maps for GetSupportedDMResp_ValueChangeType. +var ( + GetSupportedDMResp_ValueChangeType_name = map[int32]string{ + 0: "VALUE_CHANGE_UNKNOWN", + 1: "VALUE_CHANGE_ALLOWED", + 2: "VALUE_CHANGE_WILL_IGNORE", + } + GetSupportedDMResp_ValueChangeType_value = map[string]int32{ + "VALUE_CHANGE_UNKNOWN": 0, + "VALUE_CHANGE_ALLOWED": 1, + "VALUE_CHANGE_WILL_IGNORE": 2, + } +) + +func (x GetSupportedDMResp_ValueChangeType) Enum() *GetSupportedDMResp_ValueChangeType { + p := new(GetSupportedDMResp_ValueChangeType) + *p = x + return p +} + +func (x GetSupportedDMResp_ValueChangeType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (GetSupportedDMResp_ValueChangeType) Descriptor() protoreflect.EnumDescriptor { + return file_usp_msg_1_2_proto_enumTypes[4].Descriptor() +} + +func (GetSupportedDMResp_ValueChangeType) Type() protoreflect.EnumType { + return &file_usp_msg_1_2_proto_enumTypes[4] +} + +func (x GetSupportedDMResp_ValueChangeType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use GetSupportedDMResp_ValueChangeType.Descriptor instead. +func (GetSupportedDMResp_ValueChangeType) EnumDescriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{9, 3} +} + +type GetSupportedDMResp_CmdType int32 + +const ( + GetSupportedDMResp_CMD_UNKNOWN GetSupportedDMResp_CmdType = 0 + GetSupportedDMResp_CMD_SYNC GetSupportedDMResp_CmdType = 1 + GetSupportedDMResp_CMD_ASYNC GetSupportedDMResp_CmdType = 2 +) + +// Enum value maps for GetSupportedDMResp_CmdType. +var ( + GetSupportedDMResp_CmdType_name = map[int32]string{ + 0: "CMD_UNKNOWN", + 1: "CMD_SYNC", + 2: "CMD_ASYNC", + } + GetSupportedDMResp_CmdType_value = map[string]int32{ + "CMD_UNKNOWN": 0, + "CMD_SYNC": 1, + "CMD_ASYNC": 2, + } +) + +func (x GetSupportedDMResp_CmdType) Enum() *GetSupportedDMResp_CmdType { + p := new(GetSupportedDMResp_CmdType) + *p = x + return p +} + +func (x GetSupportedDMResp_CmdType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (GetSupportedDMResp_CmdType) Descriptor() protoreflect.EnumDescriptor { + return file_usp_msg_1_2_proto_enumTypes[5].Descriptor() +} + +func (GetSupportedDMResp_CmdType) Type() protoreflect.EnumType { + return &file_usp_msg_1_2_proto_enumTypes[5] +} + +func (x GetSupportedDMResp_CmdType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use GetSupportedDMResp_CmdType.Descriptor instead. +func (GetSupportedDMResp_CmdType) EnumDescriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{9, 4} +} + +type Msg struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Header *Header `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` // Make required in the protocol + Body *Body `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` // Make required in the protocol +} + +func (x *Msg) Reset() { + *x = Msg{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Msg) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Msg) ProtoMessage() {} + +func (x *Msg) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Msg.ProtoReflect.Descriptor instead. +func (*Msg) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{0} +} + +func (x *Msg) GetHeader() *Header { + if x != nil { + return x.Header + } + return nil +} + +func (x *Msg) GetBody() *Body { + if x != nil { + return x.Body + } + return nil +} + +type Header struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + MsgId string `protobuf:"bytes,1,opt,name=msg_id,json=msgId,proto3" json:"msg_id,omitempty"` // Make required in the protocol + MsgType Header_MsgType `protobuf:"varint,2,opt,name=msg_type,json=msgType,proto3,enum=usp.Header_MsgType" json:"msg_type,omitempty"` // Make required in the protocol +} + +func (x *Header) Reset() { + *x = Header{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Header) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Header) ProtoMessage() {} + +func (x *Header) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Header.ProtoReflect.Descriptor instead. +func (*Header) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{1} +} + +func (x *Header) GetMsgId() string { + if x != nil { + return x.MsgId + } + return "" +} + +func (x *Header) GetMsgType() Header_MsgType { + if x != nil { + return x.MsgType + } + return Header_ERROR +} + +type Body struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to MsgBody: + // + // *Body_Request + // *Body_Response + // *Body_Error + MsgBody isBody_MsgBody `protobuf_oneof:"msg_body"` +} + +func (x *Body) Reset() { + *x = Body{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Body) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Body) ProtoMessage() {} + +func (x *Body) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Body.ProtoReflect.Descriptor instead. +func (*Body) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{2} +} + +func (m *Body) GetMsgBody() isBody_MsgBody { + if m != nil { + return m.MsgBody + } + return nil +} + +func (x *Body) GetRequest() *Request { + if x, ok := x.GetMsgBody().(*Body_Request); ok { + return x.Request + } + return nil +} + +func (x *Body) GetResponse() *Response { + if x, ok := x.GetMsgBody().(*Body_Response); ok { + return x.Response + } + return nil +} + +func (x *Body) GetError() *Error { + if x, ok := x.GetMsgBody().(*Body_Error); ok { + return x.Error + } + return nil +} + +type isBody_MsgBody interface { + isBody_MsgBody() +} + +type Body_Request struct { + Request *Request `protobuf:"bytes,1,opt,name=request,proto3,oneof"` +} + +type Body_Response struct { + Response *Response `protobuf:"bytes,2,opt,name=response,proto3,oneof"` +} + +type Body_Error struct { + Error *Error `protobuf:"bytes,3,opt,name=error,proto3,oneof"` +} + +func (*Body_Request) isBody_MsgBody() {} + +func (*Body_Response) isBody_MsgBody() {} + +func (*Body_Error) isBody_MsgBody() {} + +type Request struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to ReqType: + // + // *Request_Get + // *Request_GetSupportedDm + // *Request_GetInstances + // *Request_Set + // *Request_Add + // *Request_Delete + // *Request_Operate + // *Request_Notify + // *Request_GetSupportedProtocol + ReqType isRequest_ReqType `protobuf_oneof:"req_type"` +} + +func (x *Request) Reset() { + *x = Request{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Request) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Request) ProtoMessage() {} + +func (x *Request) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Request.ProtoReflect.Descriptor instead. +func (*Request) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{3} +} + +func (m *Request) GetReqType() isRequest_ReqType { + if m != nil { + return m.ReqType + } + return nil +} + +func (x *Request) GetGet() *Get { + if x, ok := x.GetReqType().(*Request_Get); ok { + return x.Get + } + return nil +} + +func (x *Request) GetGetSupportedDm() *GetSupportedDM { + if x, ok := x.GetReqType().(*Request_GetSupportedDm); ok { + return x.GetSupportedDm + } + return nil +} + +func (x *Request) GetGetInstances() *GetInstances { + if x, ok := x.GetReqType().(*Request_GetInstances); ok { + return x.GetInstances + } + return nil +} + +func (x *Request) GetSet() *Set { + if x, ok := x.GetReqType().(*Request_Set); ok { + return x.Set + } + return nil +} + +func (x *Request) GetAdd() *Add { + if x, ok := x.GetReqType().(*Request_Add); ok { + return x.Add + } + return nil +} + +func (x *Request) GetDelete() *Delete { + if x, ok := x.GetReqType().(*Request_Delete); ok { + return x.Delete + } + return nil +} + +func (x *Request) GetOperate() *Operate { + if x, ok := x.GetReqType().(*Request_Operate); ok { + return x.Operate + } + return nil +} + +func (x *Request) GetNotify() *Notify { + if x, ok := x.GetReqType().(*Request_Notify); ok { + return x.Notify + } + return nil +} + +func (x *Request) GetGetSupportedProtocol() *GetSupportedProtocol { + if x, ok := x.GetReqType().(*Request_GetSupportedProtocol); ok { + return x.GetSupportedProtocol + } + return nil +} + +type isRequest_ReqType interface { + isRequest_ReqType() +} + +type Request_Get struct { + Get *Get `protobuf:"bytes,1,opt,name=get,proto3,oneof"` +} + +type Request_GetSupportedDm struct { + GetSupportedDm *GetSupportedDM `protobuf:"bytes,2,opt,name=get_supported_dm,json=getSupportedDm,proto3,oneof"` +} + +type Request_GetInstances struct { + GetInstances *GetInstances `protobuf:"bytes,3,opt,name=get_instances,json=getInstances,proto3,oneof"` +} + +type Request_Set struct { + Set *Set `protobuf:"bytes,4,opt,name=set,proto3,oneof"` +} + +type Request_Add struct { + Add *Add `protobuf:"bytes,5,opt,name=add,proto3,oneof"` +} + +type Request_Delete struct { + Delete *Delete `protobuf:"bytes,6,opt,name=delete,proto3,oneof"` +} + +type Request_Operate struct { + Operate *Operate `protobuf:"bytes,7,opt,name=operate,proto3,oneof"` +} + +type Request_Notify struct { + Notify *Notify `protobuf:"bytes,8,opt,name=notify,proto3,oneof"` +} + +type Request_GetSupportedProtocol struct { + GetSupportedProtocol *GetSupportedProtocol `protobuf:"bytes,9,opt,name=get_supported_protocol,json=getSupportedProtocol,proto3,oneof"` +} + +func (*Request_Get) isRequest_ReqType() {} + +func (*Request_GetSupportedDm) isRequest_ReqType() {} + +func (*Request_GetInstances) isRequest_ReqType() {} + +func (*Request_Set) isRequest_ReqType() {} + +func (*Request_Add) isRequest_ReqType() {} + +func (*Request_Delete) isRequest_ReqType() {} + +func (*Request_Operate) isRequest_ReqType() {} + +func (*Request_Notify) isRequest_ReqType() {} + +func (*Request_GetSupportedProtocol) isRequest_ReqType() {} + +type Response struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to RespType: + // + // *Response_GetResp + // *Response_GetSupportedDmResp + // *Response_GetInstancesResp + // *Response_SetResp + // *Response_AddResp + // *Response_DeleteResp + // *Response_OperateResp + // *Response_NotifyResp + // *Response_GetSupportedProtocolResp + RespType isResponse_RespType `protobuf_oneof:"resp_type"` +} + +func (x *Response) Reset() { + *x = Response{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Response) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Response) ProtoMessage() {} + +func (x *Response) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Response.ProtoReflect.Descriptor instead. +func (*Response) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{4} +} + +func (m *Response) GetRespType() isResponse_RespType { + if m != nil { + return m.RespType + } + return nil +} + +func (x *Response) GetGetResp() *GetResp { + if x, ok := x.GetRespType().(*Response_GetResp); ok { + return x.GetResp + } + return nil +} + +func (x *Response) GetGetSupportedDmResp() *GetSupportedDMResp { + if x, ok := x.GetRespType().(*Response_GetSupportedDmResp); ok { + return x.GetSupportedDmResp + } + return nil +} + +func (x *Response) GetGetInstancesResp() *GetInstancesResp { + if x, ok := x.GetRespType().(*Response_GetInstancesResp); ok { + return x.GetInstancesResp + } + return nil +} + +func (x *Response) GetSetResp() *SetResp { + if x, ok := x.GetRespType().(*Response_SetResp); ok { + return x.SetResp + } + return nil +} + +func (x *Response) GetAddResp() *AddResp { + if x, ok := x.GetRespType().(*Response_AddResp); ok { + return x.AddResp + } + return nil +} + +func (x *Response) GetDeleteResp() *DeleteResp { + if x, ok := x.GetRespType().(*Response_DeleteResp); ok { + return x.DeleteResp + } + return nil +} + +func (x *Response) GetOperateResp() *OperateResp { + if x, ok := x.GetRespType().(*Response_OperateResp); ok { + return x.OperateResp + } + return nil +} + +func (x *Response) GetNotifyResp() *NotifyResp { + if x, ok := x.GetRespType().(*Response_NotifyResp); ok { + return x.NotifyResp + } + return nil +} + +func (x *Response) GetGetSupportedProtocolResp() *GetSupportedProtocolResp { + if x, ok := x.GetRespType().(*Response_GetSupportedProtocolResp); ok { + return x.GetSupportedProtocolResp + } + return nil +} + +type isResponse_RespType interface { + isResponse_RespType() +} + +type Response_GetResp struct { + GetResp *GetResp `protobuf:"bytes,1,opt,name=get_resp,json=getResp,proto3,oneof"` +} + +type Response_GetSupportedDmResp struct { + GetSupportedDmResp *GetSupportedDMResp `protobuf:"bytes,2,opt,name=get_supported_dm_resp,json=getSupportedDmResp,proto3,oneof"` +} + +type Response_GetInstancesResp struct { + GetInstancesResp *GetInstancesResp `protobuf:"bytes,3,opt,name=get_instances_resp,json=getInstancesResp,proto3,oneof"` +} + +type Response_SetResp struct { + SetResp *SetResp `protobuf:"bytes,4,opt,name=set_resp,json=setResp,proto3,oneof"` +} + +type Response_AddResp struct { + AddResp *AddResp `protobuf:"bytes,5,opt,name=add_resp,json=addResp,proto3,oneof"` +} + +type Response_DeleteResp struct { + DeleteResp *DeleteResp `protobuf:"bytes,6,opt,name=delete_resp,json=deleteResp,proto3,oneof"` +} + +type Response_OperateResp struct { + OperateResp *OperateResp `protobuf:"bytes,7,opt,name=operate_resp,json=operateResp,proto3,oneof"` +} + +type Response_NotifyResp struct { + NotifyResp *NotifyResp `protobuf:"bytes,8,opt,name=notify_resp,json=notifyResp,proto3,oneof"` +} + +type Response_GetSupportedProtocolResp struct { + GetSupportedProtocolResp *GetSupportedProtocolResp `protobuf:"bytes,9,opt,name=get_supported_protocol_resp,json=getSupportedProtocolResp,proto3,oneof"` +} + +func (*Response_GetResp) isResponse_RespType() {} + +func (*Response_GetSupportedDmResp) isResponse_RespType() {} + +func (*Response_GetInstancesResp) isResponse_RespType() {} + +func (*Response_SetResp) isResponse_RespType() {} + +func (*Response_AddResp) isResponse_RespType() {} + +func (*Response_DeleteResp) isResponse_RespType() {} + +func (*Response_OperateResp) isResponse_RespType() {} + +func (*Response_NotifyResp) isResponse_RespType() {} + +func (*Response_GetSupportedProtocolResp) isResponse_RespType() {} + +type Error struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ErrCode uint32 `protobuf:"fixed32,1,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,2,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` + ParamErrs []*Error_ParamError `protobuf:"bytes,3,rep,name=param_errs,json=paramErrs,proto3" json:"param_errs,omitempty"` +} + +func (x *Error) Reset() { + *x = Error{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Error) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Error) ProtoMessage() {} + +func (x *Error) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Error.ProtoReflect.Descriptor instead. +func (*Error) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{5} +} + +func (x *Error) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *Error) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +func (x *Error) GetParamErrs() []*Error_ParamError { + if x != nil { + return x.ParamErrs + } + return nil +} + +type Get struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ParamPaths []string `protobuf:"bytes,1,rep,name=param_paths,json=paramPaths,proto3" json:"param_paths,omitempty"` + MaxDepth uint32 `protobuf:"fixed32,2,opt,name=max_depth,json=maxDepth,proto3" json:"max_depth,omitempty"` +} + +func (x *Get) Reset() { + *x = Get{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Get) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Get) ProtoMessage() {} + +func (x *Get) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Get.ProtoReflect.Descriptor instead. +func (*Get) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{6} +} + +func (x *Get) GetParamPaths() []string { + if x != nil { + return x.ParamPaths + } + return nil +} + +func (x *Get) GetMaxDepth() uint32 { + if x != nil { + return x.MaxDepth + } + return 0 +} + +type GetResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ReqPathResults []*GetResp_RequestedPathResult `protobuf:"bytes,1,rep,name=req_path_results,json=reqPathResults,proto3" json:"req_path_results,omitempty"` +} + +func (x *GetResp) Reset() { + *x = GetResp{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetResp) ProtoMessage() {} + +func (x *GetResp) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetResp.ProtoReflect.Descriptor instead. +func (*GetResp) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{7} +} + +func (x *GetResp) GetReqPathResults() []*GetResp_RequestedPathResult { + if x != nil { + return x.ReqPathResults + } + return nil +} + +type GetSupportedDM struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ObjPaths []string `protobuf:"bytes,1,rep,name=obj_paths,json=objPaths,proto3" json:"obj_paths,omitempty"` + FirstLevelOnly bool `protobuf:"varint,2,opt,name=first_level_only,json=firstLevelOnly,proto3" json:"first_level_only,omitempty"` + ReturnCommands bool `protobuf:"varint,3,opt,name=return_commands,json=returnCommands,proto3" json:"return_commands,omitempty"` + ReturnEvents bool `protobuf:"varint,4,opt,name=return_events,json=returnEvents,proto3" json:"return_events,omitempty"` + ReturnParams bool `protobuf:"varint,5,opt,name=return_params,json=returnParams,proto3" json:"return_params,omitempty"` +} + +func (x *GetSupportedDM) Reset() { + *x = GetSupportedDM{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSupportedDM) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSupportedDM) ProtoMessage() {} + +func (x *GetSupportedDM) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSupportedDM.ProtoReflect.Descriptor instead. +func (*GetSupportedDM) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{8} +} + +func (x *GetSupportedDM) GetObjPaths() []string { + if x != nil { + return x.ObjPaths + } + return nil +} + +func (x *GetSupportedDM) GetFirstLevelOnly() bool { + if x != nil { + return x.FirstLevelOnly + } + return false +} + +func (x *GetSupportedDM) GetReturnCommands() bool { + if x != nil { + return x.ReturnCommands + } + return false +} + +func (x *GetSupportedDM) GetReturnEvents() bool { + if x != nil { + return x.ReturnEvents + } + return false +} + +func (x *GetSupportedDM) GetReturnParams() bool { + if x != nil { + return x.ReturnParams + } + return false +} + +type GetSupportedDMResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ReqObjResults []*GetSupportedDMResp_RequestedObjectResult `protobuf:"bytes,1,rep,name=req_obj_results,json=reqObjResults,proto3" json:"req_obj_results,omitempty"` +} + +func (x *GetSupportedDMResp) Reset() { + *x = GetSupportedDMResp{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSupportedDMResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSupportedDMResp) ProtoMessage() {} + +func (x *GetSupportedDMResp) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSupportedDMResp.ProtoReflect.Descriptor instead. +func (*GetSupportedDMResp) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{9} +} + +func (x *GetSupportedDMResp) GetReqObjResults() []*GetSupportedDMResp_RequestedObjectResult { + if x != nil { + return x.ReqObjResults + } + return nil +} + +type GetInstances struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ObjPaths []string `protobuf:"bytes,1,rep,name=obj_paths,json=objPaths,proto3" json:"obj_paths,omitempty"` + FirstLevelOnly bool `protobuf:"varint,2,opt,name=first_level_only,json=firstLevelOnly,proto3" json:"first_level_only,omitempty"` +} + +func (x *GetInstances) Reset() { + *x = GetInstances{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetInstances) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetInstances) ProtoMessage() {} + +func (x *GetInstances) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetInstances.ProtoReflect.Descriptor instead. +func (*GetInstances) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{10} +} + +func (x *GetInstances) GetObjPaths() []string { + if x != nil { + return x.ObjPaths + } + return nil +} + +func (x *GetInstances) GetFirstLevelOnly() bool { + if x != nil { + return x.FirstLevelOnly + } + return false +} + +type GetInstancesResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ReqPathResults []*GetInstancesResp_RequestedPathResult `protobuf:"bytes,1,rep,name=req_path_results,json=reqPathResults,proto3" json:"req_path_results,omitempty"` +} + +func (x *GetInstancesResp) Reset() { + *x = GetInstancesResp{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetInstancesResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetInstancesResp) ProtoMessage() {} + +func (x *GetInstancesResp) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetInstancesResp.ProtoReflect.Descriptor instead. +func (*GetInstancesResp) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{11} +} + +func (x *GetInstancesResp) GetReqPathResults() []*GetInstancesResp_RequestedPathResult { + if x != nil { + return x.ReqPathResults + } + return nil +} + +type GetSupportedProtocol struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ControllerSupportedProtocolVersions string `protobuf:"bytes,1,opt,name=controller_supported_protocol_versions,json=controllerSupportedProtocolVersions,proto3" json:"controller_supported_protocol_versions,omitempty"` +} + +func (x *GetSupportedProtocol) Reset() { + *x = GetSupportedProtocol{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSupportedProtocol) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSupportedProtocol) ProtoMessage() {} + +func (x *GetSupportedProtocol) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSupportedProtocol.ProtoReflect.Descriptor instead. +func (*GetSupportedProtocol) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{12} +} + +func (x *GetSupportedProtocol) GetControllerSupportedProtocolVersions() string { + if x != nil { + return x.ControllerSupportedProtocolVersions + } + return "" +} + +type GetSupportedProtocolResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AgentSupportedProtocolVersions string `protobuf:"bytes,1,opt,name=agent_supported_protocol_versions,json=agentSupportedProtocolVersions,proto3" json:"agent_supported_protocol_versions,omitempty"` +} + +func (x *GetSupportedProtocolResp) Reset() { + *x = GetSupportedProtocolResp{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSupportedProtocolResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSupportedProtocolResp) ProtoMessage() {} + +func (x *GetSupportedProtocolResp) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSupportedProtocolResp.ProtoReflect.Descriptor instead. +func (*GetSupportedProtocolResp) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{13} +} + +func (x *GetSupportedProtocolResp) GetAgentSupportedProtocolVersions() string { + if x != nil { + return x.AgentSupportedProtocolVersions + } + return "" +} + +type Add struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AllowPartial bool `protobuf:"varint,1,opt,name=allow_partial,json=allowPartial,proto3" json:"allow_partial,omitempty"` + CreateObjs []*Add_CreateObject `protobuf:"bytes,2,rep,name=create_objs,json=createObjs,proto3" json:"create_objs,omitempty"` +} + +func (x *Add) Reset() { + *x = Add{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Add) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Add) ProtoMessage() {} + +func (x *Add) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Add.ProtoReflect.Descriptor instead. +func (*Add) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{14} +} + +func (x *Add) GetAllowPartial() bool { + if x != nil { + return x.AllowPartial + } + return false +} + +func (x *Add) GetCreateObjs() []*Add_CreateObject { + if x != nil { + return x.CreateObjs + } + return nil +} + +type AddResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CreatedObjResults []*AddResp_CreatedObjectResult `protobuf:"bytes,1,rep,name=created_obj_results,json=createdObjResults,proto3" json:"created_obj_results,omitempty"` +} + +func (x *AddResp) Reset() { + *x = AddResp{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddResp) ProtoMessage() {} + +func (x *AddResp) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AddResp.ProtoReflect.Descriptor instead. +func (*AddResp) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{15} +} + +func (x *AddResp) GetCreatedObjResults() []*AddResp_CreatedObjectResult { + if x != nil { + return x.CreatedObjResults + } + return nil +} + +type Delete struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AllowPartial bool `protobuf:"varint,1,opt,name=allow_partial,json=allowPartial,proto3" json:"allow_partial,omitempty"` + ObjPaths []string `protobuf:"bytes,2,rep,name=obj_paths,json=objPaths,proto3" json:"obj_paths,omitempty"` +} + +func (x *Delete) Reset() { + *x = Delete{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Delete) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Delete) ProtoMessage() {} + +func (x *Delete) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Delete.ProtoReflect.Descriptor instead. +func (*Delete) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{16} +} + +func (x *Delete) GetAllowPartial() bool { + if x != nil { + return x.AllowPartial + } + return false +} + +func (x *Delete) GetObjPaths() []string { + if x != nil { + return x.ObjPaths + } + return nil +} + +type DeleteResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + DeletedObjResults []*DeleteResp_DeletedObjectResult `protobuf:"bytes,1,rep,name=deleted_obj_results,json=deletedObjResults,proto3" json:"deleted_obj_results,omitempty"` +} + +func (x *DeleteResp) Reset() { + *x = DeleteResp{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteResp) ProtoMessage() {} + +func (x *DeleteResp) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteResp.ProtoReflect.Descriptor instead. +func (*DeleteResp) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{17} +} + +func (x *DeleteResp) GetDeletedObjResults() []*DeleteResp_DeletedObjectResult { + if x != nil { + return x.DeletedObjResults + } + return nil +} + +type Set struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AllowPartial bool `protobuf:"varint,1,opt,name=allow_partial,json=allowPartial,proto3" json:"allow_partial,omitempty"` + UpdateObjs []*Set_UpdateObject `protobuf:"bytes,2,rep,name=update_objs,json=updateObjs,proto3" json:"update_objs,omitempty"` +} + +func (x *Set) Reset() { + *x = Set{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Set) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Set) ProtoMessage() {} + +func (x *Set) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Set.ProtoReflect.Descriptor instead. +func (*Set) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{18} +} + +func (x *Set) GetAllowPartial() bool { + if x != nil { + return x.AllowPartial + } + return false +} + +func (x *Set) GetUpdateObjs() []*Set_UpdateObject { + if x != nil { + return x.UpdateObjs + } + return nil +} + +type SetResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UpdatedObjResults []*SetResp_UpdatedObjectResult `protobuf:"bytes,1,rep,name=updated_obj_results,json=updatedObjResults,proto3" json:"updated_obj_results,omitempty"` +} + +func (x *SetResp) Reset() { + *x = SetResp{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetResp) ProtoMessage() {} + +func (x *SetResp) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetResp.ProtoReflect.Descriptor instead. +func (*SetResp) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{19} +} + +func (x *SetResp) GetUpdatedObjResults() []*SetResp_UpdatedObjectResult { + if x != nil { + return x.UpdatedObjResults + } + return nil +} + +type Operate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Command string `protobuf:"bytes,1,opt,name=command,proto3" json:"command,omitempty"` + CommandKey string `protobuf:"bytes,2,opt,name=command_key,json=commandKey,proto3" json:"command_key,omitempty"` + SendResp bool `protobuf:"varint,3,opt,name=send_resp,json=sendResp,proto3" json:"send_resp,omitempty"` + InputArgs map[string]string `protobuf:"bytes,4,rep,name=input_args,json=inputArgs,proto3" json:"input_args,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *Operate) Reset() { + *x = Operate{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Operate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Operate) ProtoMessage() {} + +func (x *Operate) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Operate.ProtoReflect.Descriptor instead. +func (*Operate) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{20} +} + +func (x *Operate) GetCommand() string { + if x != nil { + return x.Command + } + return "" +} + +func (x *Operate) GetCommandKey() string { + if x != nil { + return x.CommandKey + } + return "" +} + +func (x *Operate) GetSendResp() bool { + if x != nil { + return x.SendResp + } + return false +} + +func (x *Operate) GetInputArgs() map[string]string { + if x != nil { + return x.InputArgs + } + return nil +} + +type OperateResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OperationResults []*OperateResp_OperationResult `protobuf:"bytes,1,rep,name=operation_results,json=operationResults,proto3" json:"operation_results,omitempty"` +} + +func (x *OperateResp) Reset() { + *x = OperateResp{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OperateResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OperateResp) ProtoMessage() {} + +func (x *OperateResp) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OperateResp.ProtoReflect.Descriptor instead. +func (*OperateResp) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{21} +} + +func (x *OperateResp) GetOperationResults() []*OperateResp_OperationResult { + if x != nil { + return x.OperationResults + } + return nil +} + +type Notify struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SubscriptionId string `protobuf:"bytes,1,opt,name=subscription_id,json=subscriptionId,proto3" json:"subscription_id,omitempty"` + SendResp bool `protobuf:"varint,2,opt,name=send_resp,json=sendResp,proto3" json:"send_resp,omitempty"` + // Types that are assignable to Notification: + // + // *Notify_Event_ + // *Notify_ValueChange_ + // *Notify_ObjCreation + // *Notify_ObjDeletion + // *Notify_OperComplete + // *Notify_OnBoardReq + Notification isNotify_Notification `protobuf_oneof:"notification"` +} + +func (x *Notify) Reset() { + *x = Notify{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Notify) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Notify) ProtoMessage() {} + +func (x *Notify) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[22] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Notify.ProtoReflect.Descriptor instead. +func (*Notify) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{22} +} + +func (x *Notify) GetSubscriptionId() string { + if x != nil { + return x.SubscriptionId + } + return "" +} + +func (x *Notify) GetSendResp() bool { + if x != nil { + return x.SendResp + } + return false +} + +func (m *Notify) GetNotification() isNotify_Notification { + if m != nil { + return m.Notification + } + return nil +} + +func (x *Notify) GetEvent() *Notify_Event { + if x, ok := x.GetNotification().(*Notify_Event_); ok { + return x.Event + } + return nil +} + +func (x *Notify) GetValueChange() *Notify_ValueChange { + if x, ok := x.GetNotification().(*Notify_ValueChange_); ok { + return x.ValueChange + } + return nil +} + +func (x *Notify) GetObjCreation() *Notify_ObjectCreation { + if x, ok := x.GetNotification().(*Notify_ObjCreation); ok { + return x.ObjCreation + } + return nil +} + +func (x *Notify) GetObjDeletion() *Notify_ObjectDeletion { + if x, ok := x.GetNotification().(*Notify_ObjDeletion); ok { + return x.ObjDeletion + } + return nil +} + +func (x *Notify) GetOperComplete() *Notify_OperationComplete { + if x, ok := x.GetNotification().(*Notify_OperComplete); ok { + return x.OperComplete + } + return nil +} + +func (x *Notify) GetOnBoardReq() *Notify_OnBoardRequest { + if x, ok := x.GetNotification().(*Notify_OnBoardReq); ok { + return x.OnBoardReq + } + return nil +} + +type isNotify_Notification interface { + isNotify_Notification() +} + +type Notify_Event_ struct { + Event *Notify_Event `protobuf:"bytes,3,opt,name=event,proto3,oneof"` +} + +type Notify_ValueChange_ struct { + ValueChange *Notify_ValueChange `protobuf:"bytes,4,opt,name=value_change,json=valueChange,proto3,oneof"` +} + +type Notify_ObjCreation struct { + ObjCreation *Notify_ObjectCreation `protobuf:"bytes,5,opt,name=obj_creation,json=objCreation,proto3,oneof"` +} + +type Notify_ObjDeletion struct { + ObjDeletion *Notify_ObjectDeletion `protobuf:"bytes,6,opt,name=obj_deletion,json=objDeletion,proto3,oneof"` +} + +type Notify_OperComplete struct { + OperComplete *Notify_OperationComplete `protobuf:"bytes,7,opt,name=oper_complete,json=operComplete,proto3,oneof"` +} + +type Notify_OnBoardReq struct { + OnBoardReq *Notify_OnBoardRequest `protobuf:"bytes,8,opt,name=on_board_req,json=onBoardReq,proto3,oneof"` +} + +func (*Notify_Event_) isNotify_Notification() {} + +func (*Notify_ValueChange_) isNotify_Notification() {} + +func (*Notify_ObjCreation) isNotify_Notification() {} + +func (*Notify_ObjDeletion) isNotify_Notification() {} + +func (*Notify_OperComplete) isNotify_Notification() {} + +func (*Notify_OnBoardReq) isNotify_Notification() {} + +type NotifyResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SubscriptionId string `protobuf:"bytes,1,opt,name=subscription_id,json=subscriptionId,proto3" json:"subscription_id,omitempty"` +} + +func (x *NotifyResp) Reset() { + *x = NotifyResp{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NotifyResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NotifyResp) ProtoMessage() {} + +func (x *NotifyResp) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[23] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NotifyResp.ProtoReflect.Descriptor instead. +func (*NotifyResp) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{23} +} + +func (x *NotifyResp) GetSubscriptionId() string { + if x != nil { + return x.SubscriptionId + } + return "" +} + +type Error_ParamError struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ParamPath string `protobuf:"bytes,1,opt,name=param_path,json=paramPath,proto3" json:"param_path,omitempty"` + ErrCode uint32 `protobuf:"fixed32,2,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,3,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` +} + +func (x *Error_ParamError) Reset() { + *x = Error_ParamError{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Error_ParamError) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Error_ParamError) ProtoMessage() {} + +func (x *Error_ParamError) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[24] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Error_ParamError.ProtoReflect.Descriptor instead. +func (*Error_ParamError) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{5, 0} +} + +func (x *Error_ParamError) GetParamPath() string { + if x != nil { + return x.ParamPath + } + return "" +} + +func (x *Error_ParamError) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *Error_ParamError) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +type GetResp_RequestedPathResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RequestedPath string `protobuf:"bytes,1,opt,name=requested_path,json=requestedPath,proto3" json:"requested_path,omitempty"` + ErrCode uint32 `protobuf:"fixed32,2,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,3,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` + ResolvedPathResults []*GetResp_ResolvedPathResult `protobuf:"bytes,4,rep,name=resolved_path_results,json=resolvedPathResults,proto3" json:"resolved_path_results,omitempty"` +} + +func (x *GetResp_RequestedPathResult) Reset() { + *x = GetResp_RequestedPathResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetResp_RequestedPathResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetResp_RequestedPathResult) ProtoMessage() {} + +func (x *GetResp_RequestedPathResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[25] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetResp_RequestedPathResult.ProtoReflect.Descriptor instead. +func (*GetResp_RequestedPathResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{7, 0} +} + +func (x *GetResp_RequestedPathResult) GetRequestedPath() string { + if x != nil { + return x.RequestedPath + } + return "" +} + +func (x *GetResp_RequestedPathResult) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *GetResp_RequestedPathResult) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +func (x *GetResp_RequestedPathResult) GetResolvedPathResults() []*GetResp_ResolvedPathResult { + if x != nil { + return x.ResolvedPathResults + } + return nil +} + +type GetResp_ResolvedPathResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ResolvedPath string `protobuf:"bytes,1,opt,name=resolved_path,json=resolvedPath,proto3" json:"resolved_path,omitempty"` + ResultParams map[string]string `protobuf:"bytes,2,rep,name=result_params,json=resultParams,proto3" json:"result_params,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *GetResp_ResolvedPathResult) Reset() { + *x = GetResp_ResolvedPathResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetResp_ResolvedPathResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetResp_ResolvedPathResult) ProtoMessage() {} + +func (x *GetResp_ResolvedPathResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[26] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetResp_ResolvedPathResult.ProtoReflect.Descriptor instead. +func (*GetResp_ResolvedPathResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{7, 1} +} + +func (x *GetResp_ResolvedPathResult) GetResolvedPath() string { + if x != nil { + return x.ResolvedPath + } + return "" +} + +func (x *GetResp_ResolvedPathResult) GetResultParams() map[string]string { + if x != nil { + return x.ResultParams + } + return nil +} + +type GetSupportedDMResp_RequestedObjectResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ReqObjPath string `protobuf:"bytes,1,opt,name=req_obj_path,json=reqObjPath,proto3" json:"req_obj_path,omitempty"` + ErrCode uint32 `protobuf:"fixed32,2,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,3,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` + DataModelInstUri string `protobuf:"bytes,4,opt,name=data_model_inst_uri,json=dataModelInstUri,proto3" json:"data_model_inst_uri,omitempty"` + SupportedObjs []*GetSupportedDMResp_SupportedObjectResult `protobuf:"bytes,5,rep,name=supported_objs,json=supportedObjs,proto3" json:"supported_objs,omitempty"` +} + +func (x *GetSupportedDMResp_RequestedObjectResult) Reset() { + *x = GetSupportedDMResp_RequestedObjectResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSupportedDMResp_RequestedObjectResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSupportedDMResp_RequestedObjectResult) ProtoMessage() {} + +func (x *GetSupportedDMResp_RequestedObjectResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[28] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSupportedDMResp_RequestedObjectResult.ProtoReflect.Descriptor instead. +func (*GetSupportedDMResp_RequestedObjectResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{9, 0} +} + +func (x *GetSupportedDMResp_RequestedObjectResult) GetReqObjPath() string { + if x != nil { + return x.ReqObjPath + } + return "" +} + +func (x *GetSupportedDMResp_RequestedObjectResult) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *GetSupportedDMResp_RequestedObjectResult) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +func (x *GetSupportedDMResp_RequestedObjectResult) GetDataModelInstUri() string { + if x != nil { + return x.DataModelInstUri + } + return "" +} + +func (x *GetSupportedDMResp_RequestedObjectResult) GetSupportedObjs() []*GetSupportedDMResp_SupportedObjectResult { + if x != nil { + return x.SupportedObjs + } + return nil +} + +type GetSupportedDMResp_SupportedObjectResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SupportedObjPath string `protobuf:"bytes,1,opt,name=supported_obj_path,json=supportedObjPath,proto3" json:"supported_obj_path,omitempty"` + Access GetSupportedDMResp_ObjAccessType `protobuf:"varint,2,opt,name=access,proto3,enum=usp.GetSupportedDMResp_ObjAccessType" json:"access,omitempty"` + IsMultiInstance bool `protobuf:"varint,3,opt,name=is_multi_instance,json=isMultiInstance,proto3" json:"is_multi_instance,omitempty"` + SupportedCommands []*GetSupportedDMResp_SupportedCommandResult `protobuf:"bytes,4,rep,name=supported_commands,json=supportedCommands,proto3" json:"supported_commands,omitempty"` + SupportedEvents []*GetSupportedDMResp_SupportedEventResult `protobuf:"bytes,5,rep,name=supported_events,json=supportedEvents,proto3" json:"supported_events,omitempty"` + SupportedParams []*GetSupportedDMResp_SupportedParamResult `protobuf:"bytes,6,rep,name=supported_params,json=supportedParams,proto3" json:"supported_params,omitempty"` + DivergentPaths []string `protobuf:"bytes,7,rep,name=divergent_paths,json=divergentPaths,proto3" json:"divergent_paths,omitempty"` +} + +func (x *GetSupportedDMResp_SupportedObjectResult) Reset() { + *x = GetSupportedDMResp_SupportedObjectResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSupportedDMResp_SupportedObjectResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSupportedDMResp_SupportedObjectResult) ProtoMessage() {} + +func (x *GetSupportedDMResp_SupportedObjectResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[29] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSupportedDMResp_SupportedObjectResult.ProtoReflect.Descriptor instead. +func (*GetSupportedDMResp_SupportedObjectResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{9, 1} +} + +func (x *GetSupportedDMResp_SupportedObjectResult) GetSupportedObjPath() string { + if x != nil { + return x.SupportedObjPath + } + return "" +} + +func (x *GetSupportedDMResp_SupportedObjectResult) GetAccess() GetSupportedDMResp_ObjAccessType { + if x != nil { + return x.Access + } + return GetSupportedDMResp_OBJ_READ_ONLY +} + +func (x *GetSupportedDMResp_SupportedObjectResult) GetIsMultiInstance() bool { + if x != nil { + return x.IsMultiInstance + } + return false +} + +func (x *GetSupportedDMResp_SupportedObjectResult) GetSupportedCommands() []*GetSupportedDMResp_SupportedCommandResult { + if x != nil { + return x.SupportedCommands + } + return nil +} + +func (x *GetSupportedDMResp_SupportedObjectResult) GetSupportedEvents() []*GetSupportedDMResp_SupportedEventResult { + if x != nil { + return x.SupportedEvents + } + return nil +} + +func (x *GetSupportedDMResp_SupportedObjectResult) GetSupportedParams() []*GetSupportedDMResp_SupportedParamResult { + if x != nil { + return x.SupportedParams + } + return nil +} + +func (x *GetSupportedDMResp_SupportedObjectResult) GetDivergentPaths() []string { + if x != nil { + return x.DivergentPaths + } + return nil +} + +type GetSupportedDMResp_SupportedParamResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ParamName string `protobuf:"bytes,1,opt,name=param_name,json=paramName,proto3" json:"param_name,omitempty"` + Access GetSupportedDMResp_ParamAccessType `protobuf:"varint,2,opt,name=access,proto3,enum=usp.GetSupportedDMResp_ParamAccessType" json:"access,omitempty"` + ValueType GetSupportedDMResp_ParamValueType `protobuf:"varint,3,opt,name=value_type,json=valueType,proto3,enum=usp.GetSupportedDMResp_ParamValueType" json:"value_type,omitempty"` + ValueChange GetSupportedDMResp_ValueChangeType `protobuf:"varint,4,opt,name=value_change,json=valueChange,proto3,enum=usp.GetSupportedDMResp_ValueChangeType" json:"value_change,omitempty"` +} + +func (x *GetSupportedDMResp_SupportedParamResult) Reset() { + *x = GetSupportedDMResp_SupportedParamResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSupportedDMResp_SupportedParamResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSupportedDMResp_SupportedParamResult) ProtoMessage() {} + +func (x *GetSupportedDMResp_SupportedParamResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[30] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSupportedDMResp_SupportedParamResult.ProtoReflect.Descriptor instead. +func (*GetSupportedDMResp_SupportedParamResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{9, 2} +} + +func (x *GetSupportedDMResp_SupportedParamResult) GetParamName() string { + if x != nil { + return x.ParamName + } + return "" +} + +func (x *GetSupportedDMResp_SupportedParamResult) GetAccess() GetSupportedDMResp_ParamAccessType { + if x != nil { + return x.Access + } + return GetSupportedDMResp_PARAM_READ_ONLY +} + +func (x *GetSupportedDMResp_SupportedParamResult) GetValueType() GetSupportedDMResp_ParamValueType { + if x != nil { + return x.ValueType + } + return GetSupportedDMResp_PARAM_UNKNOWN +} + +func (x *GetSupportedDMResp_SupportedParamResult) GetValueChange() GetSupportedDMResp_ValueChangeType { + if x != nil { + return x.ValueChange + } + return GetSupportedDMResp_VALUE_CHANGE_UNKNOWN +} + +type GetSupportedDMResp_SupportedCommandResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommandName string `protobuf:"bytes,1,opt,name=command_name,json=commandName,proto3" json:"command_name,omitempty"` + InputArgNames []string `protobuf:"bytes,2,rep,name=input_arg_names,json=inputArgNames,proto3" json:"input_arg_names,omitempty"` + OutputArgNames []string `protobuf:"bytes,3,rep,name=output_arg_names,json=outputArgNames,proto3" json:"output_arg_names,omitempty"` + CommandType GetSupportedDMResp_CmdType `protobuf:"varint,4,opt,name=command_type,json=commandType,proto3,enum=usp.GetSupportedDMResp_CmdType" json:"command_type,omitempty"` +} + +func (x *GetSupportedDMResp_SupportedCommandResult) Reset() { + *x = GetSupportedDMResp_SupportedCommandResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSupportedDMResp_SupportedCommandResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSupportedDMResp_SupportedCommandResult) ProtoMessage() {} + +func (x *GetSupportedDMResp_SupportedCommandResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[31] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSupportedDMResp_SupportedCommandResult.ProtoReflect.Descriptor instead. +func (*GetSupportedDMResp_SupportedCommandResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{9, 3} +} + +func (x *GetSupportedDMResp_SupportedCommandResult) GetCommandName() string { + if x != nil { + return x.CommandName + } + return "" +} + +func (x *GetSupportedDMResp_SupportedCommandResult) GetInputArgNames() []string { + if x != nil { + return x.InputArgNames + } + return nil +} + +func (x *GetSupportedDMResp_SupportedCommandResult) GetOutputArgNames() []string { + if x != nil { + return x.OutputArgNames + } + return nil +} + +func (x *GetSupportedDMResp_SupportedCommandResult) GetCommandType() GetSupportedDMResp_CmdType { + if x != nil { + return x.CommandType + } + return GetSupportedDMResp_CMD_UNKNOWN +} + +type GetSupportedDMResp_SupportedEventResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + EventName string `protobuf:"bytes,1,opt,name=event_name,json=eventName,proto3" json:"event_name,omitempty"` + ArgNames []string `protobuf:"bytes,2,rep,name=arg_names,json=argNames,proto3" json:"arg_names,omitempty"` +} + +func (x *GetSupportedDMResp_SupportedEventResult) Reset() { + *x = GetSupportedDMResp_SupportedEventResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSupportedDMResp_SupportedEventResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSupportedDMResp_SupportedEventResult) ProtoMessage() {} + +func (x *GetSupportedDMResp_SupportedEventResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[32] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSupportedDMResp_SupportedEventResult.ProtoReflect.Descriptor instead. +func (*GetSupportedDMResp_SupportedEventResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{9, 4} +} + +func (x *GetSupportedDMResp_SupportedEventResult) GetEventName() string { + if x != nil { + return x.EventName + } + return "" +} + +func (x *GetSupportedDMResp_SupportedEventResult) GetArgNames() []string { + if x != nil { + return x.ArgNames + } + return nil +} + +type GetInstancesResp_RequestedPathResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RequestedPath string `protobuf:"bytes,1,opt,name=requested_path,json=requestedPath,proto3" json:"requested_path,omitempty"` + ErrCode uint32 `protobuf:"fixed32,2,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,3,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` + CurrInsts []*GetInstancesResp_CurrInstance `protobuf:"bytes,4,rep,name=curr_insts,json=currInsts,proto3" json:"curr_insts,omitempty"` +} + +func (x *GetInstancesResp_RequestedPathResult) Reset() { + *x = GetInstancesResp_RequestedPathResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetInstancesResp_RequestedPathResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetInstancesResp_RequestedPathResult) ProtoMessage() {} + +func (x *GetInstancesResp_RequestedPathResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[33] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetInstancesResp_RequestedPathResult.ProtoReflect.Descriptor instead. +func (*GetInstancesResp_RequestedPathResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{11, 0} +} + +func (x *GetInstancesResp_RequestedPathResult) GetRequestedPath() string { + if x != nil { + return x.RequestedPath + } + return "" +} + +func (x *GetInstancesResp_RequestedPathResult) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *GetInstancesResp_RequestedPathResult) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +func (x *GetInstancesResp_RequestedPathResult) GetCurrInsts() []*GetInstancesResp_CurrInstance { + if x != nil { + return x.CurrInsts + } + return nil +} + +type GetInstancesResp_CurrInstance struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + InstantiatedObjPath string `protobuf:"bytes,1,opt,name=instantiated_obj_path,json=instantiatedObjPath,proto3" json:"instantiated_obj_path,omitempty"` + UniqueKeys map[string]string `protobuf:"bytes,2,rep,name=unique_keys,json=uniqueKeys,proto3" json:"unique_keys,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *GetInstancesResp_CurrInstance) Reset() { + *x = GetInstancesResp_CurrInstance{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetInstancesResp_CurrInstance) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetInstancesResp_CurrInstance) ProtoMessage() {} + +func (x *GetInstancesResp_CurrInstance) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[34] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetInstancesResp_CurrInstance.ProtoReflect.Descriptor instead. +func (*GetInstancesResp_CurrInstance) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{11, 1} +} + +func (x *GetInstancesResp_CurrInstance) GetInstantiatedObjPath() string { + if x != nil { + return x.InstantiatedObjPath + } + return "" +} + +func (x *GetInstancesResp_CurrInstance) GetUniqueKeys() map[string]string { + if x != nil { + return x.UniqueKeys + } + return nil +} + +type Add_CreateObject struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ObjPath string `protobuf:"bytes,1,opt,name=obj_path,json=objPath,proto3" json:"obj_path,omitempty"` + ParamSettings []*Add_CreateParamSetting `protobuf:"bytes,2,rep,name=param_settings,json=paramSettings,proto3" json:"param_settings,omitempty"` +} + +func (x *Add_CreateObject) Reset() { + *x = Add_CreateObject{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Add_CreateObject) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Add_CreateObject) ProtoMessage() {} + +func (x *Add_CreateObject) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[36] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Add_CreateObject.ProtoReflect.Descriptor instead. +func (*Add_CreateObject) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{14, 0} +} + +func (x *Add_CreateObject) GetObjPath() string { + if x != nil { + return x.ObjPath + } + return "" +} + +func (x *Add_CreateObject) GetParamSettings() []*Add_CreateParamSetting { + if x != nil { + return x.ParamSettings + } + return nil +} + +type Add_CreateParamSetting struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Param string `protobuf:"bytes,1,opt,name=param,proto3" json:"param,omitempty"` + Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + Required bool `protobuf:"varint,3,opt,name=required,proto3" json:"required,omitempty"` +} + +func (x *Add_CreateParamSetting) Reset() { + *x = Add_CreateParamSetting{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Add_CreateParamSetting) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Add_CreateParamSetting) ProtoMessage() {} + +func (x *Add_CreateParamSetting) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[37] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Add_CreateParamSetting.ProtoReflect.Descriptor instead. +func (*Add_CreateParamSetting) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{14, 1} +} + +func (x *Add_CreateParamSetting) GetParam() string { + if x != nil { + return x.Param + } + return "" +} + +func (x *Add_CreateParamSetting) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +func (x *Add_CreateParamSetting) GetRequired() bool { + if x != nil { + return x.Required + } + return false +} + +type AddResp_CreatedObjectResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RequestedPath string `protobuf:"bytes,1,opt,name=requested_path,json=requestedPath,proto3" json:"requested_path,omitempty"` + OperStatus *AddResp_CreatedObjectResult_OperationStatus `protobuf:"bytes,2,opt,name=oper_status,json=operStatus,proto3" json:"oper_status,omitempty"` +} + +func (x *AddResp_CreatedObjectResult) Reset() { + *x = AddResp_CreatedObjectResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddResp_CreatedObjectResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddResp_CreatedObjectResult) ProtoMessage() {} + +func (x *AddResp_CreatedObjectResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[38] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AddResp_CreatedObjectResult.ProtoReflect.Descriptor instead. +func (*AddResp_CreatedObjectResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{15, 0} +} + +func (x *AddResp_CreatedObjectResult) GetRequestedPath() string { + if x != nil { + return x.RequestedPath + } + return "" +} + +func (x *AddResp_CreatedObjectResult) GetOperStatus() *AddResp_CreatedObjectResult_OperationStatus { + if x != nil { + return x.OperStatus + } + return nil +} + +type AddResp_ParameterError struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Param string `protobuf:"bytes,1,opt,name=param,proto3" json:"param,omitempty"` + ErrCode uint32 `protobuf:"fixed32,2,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,3,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` +} + +func (x *AddResp_ParameterError) Reset() { + *x = AddResp_ParameterError{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddResp_ParameterError) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddResp_ParameterError) ProtoMessage() {} + +func (x *AddResp_ParameterError) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[39] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AddResp_ParameterError.ProtoReflect.Descriptor instead. +func (*AddResp_ParameterError) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{15, 1} +} + +func (x *AddResp_ParameterError) GetParam() string { + if x != nil { + return x.Param + } + return "" +} + +func (x *AddResp_ParameterError) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *AddResp_ParameterError) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +type AddResp_CreatedObjectResult_OperationStatus struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to OperStatus: + // + // *AddResp_CreatedObjectResult_OperationStatus_OperFailure + // *AddResp_CreatedObjectResult_OperationStatus_OperSuccess + OperStatus isAddResp_CreatedObjectResult_OperationStatus_OperStatus `protobuf_oneof:"oper_status"` +} + +func (x *AddResp_CreatedObjectResult_OperationStatus) Reset() { + *x = AddResp_CreatedObjectResult_OperationStatus{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddResp_CreatedObjectResult_OperationStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddResp_CreatedObjectResult_OperationStatus) ProtoMessage() {} + +func (x *AddResp_CreatedObjectResult_OperationStatus) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[40] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AddResp_CreatedObjectResult_OperationStatus.ProtoReflect.Descriptor instead. +func (*AddResp_CreatedObjectResult_OperationStatus) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{15, 0, 0} +} + +func (m *AddResp_CreatedObjectResult_OperationStatus) GetOperStatus() isAddResp_CreatedObjectResult_OperationStatus_OperStatus { + if m != nil { + return m.OperStatus + } + return nil +} + +func (x *AddResp_CreatedObjectResult_OperationStatus) GetOperFailure() *AddResp_CreatedObjectResult_OperationStatus_OperationFailure { + if x, ok := x.GetOperStatus().(*AddResp_CreatedObjectResult_OperationStatus_OperFailure); ok { + return x.OperFailure + } + return nil +} + +func (x *AddResp_CreatedObjectResult_OperationStatus) GetOperSuccess() *AddResp_CreatedObjectResult_OperationStatus_OperationSuccess { + if x, ok := x.GetOperStatus().(*AddResp_CreatedObjectResult_OperationStatus_OperSuccess); ok { + return x.OperSuccess + } + return nil +} + +type isAddResp_CreatedObjectResult_OperationStatus_OperStatus interface { + isAddResp_CreatedObjectResult_OperationStatus_OperStatus() +} + +type AddResp_CreatedObjectResult_OperationStatus_OperFailure struct { + OperFailure *AddResp_CreatedObjectResult_OperationStatus_OperationFailure `protobuf:"bytes,1,opt,name=oper_failure,json=operFailure,proto3,oneof"` +} + +type AddResp_CreatedObjectResult_OperationStatus_OperSuccess struct { + OperSuccess *AddResp_CreatedObjectResult_OperationStatus_OperationSuccess `protobuf:"bytes,2,opt,name=oper_success,json=operSuccess,proto3,oneof"` +} + +func (*AddResp_CreatedObjectResult_OperationStatus_OperFailure) isAddResp_CreatedObjectResult_OperationStatus_OperStatus() { +} + +func (*AddResp_CreatedObjectResult_OperationStatus_OperSuccess) isAddResp_CreatedObjectResult_OperationStatus_OperStatus() { +} + +type AddResp_CreatedObjectResult_OperationStatus_OperationFailure struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ErrCode uint32 `protobuf:"fixed32,1,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,2,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` +} + +func (x *AddResp_CreatedObjectResult_OperationStatus_OperationFailure) Reset() { + *x = AddResp_CreatedObjectResult_OperationStatus_OperationFailure{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[41] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddResp_CreatedObjectResult_OperationStatus_OperationFailure) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddResp_CreatedObjectResult_OperationStatus_OperationFailure) ProtoMessage() {} + +func (x *AddResp_CreatedObjectResult_OperationStatus_OperationFailure) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[41] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AddResp_CreatedObjectResult_OperationStatus_OperationFailure.ProtoReflect.Descriptor instead. +func (*AddResp_CreatedObjectResult_OperationStatus_OperationFailure) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{15, 0, 0, 0} +} + +func (x *AddResp_CreatedObjectResult_OperationStatus_OperationFailure) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *AddResp_CreatedObjectResult_OperationStatus_OperationFailure) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +type AddResp_CreatedObjectResult_OperationStatus_OperationSuccess struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + InstantiatedPath string `protobuf:"bytes,1,opt,name=instantiated_path,json=instantiatedPath,proto3" json:"instantiated_path,omitempty"` + ParamErrs []*AddResp_ParameterError `protobuf:"bytes,2,rep,name=param_errs,json=paramErrs,proto3" json:"param_errs,omitempty"` + UniqueKeys map[string]string `protobuf:"bytes,3,rep,name=unique_keys,json=uniqueKeys,proto3" json:"unique_keys,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *AddResp_CreatedObjectResult_OperationStatus_OperationSuccess) Reset() { + *x = AddResp_CreatedObjectResult_OperationStatus_OperationSuccess{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[42] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddResp_CreatedObjectResult_OperationStatus_OperationSuccess) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddResp_CreatedObjectResult_OperationStatus_OperationSuccess) ProtoMessage() {} + +func (x *AddResp_CreatedObjectResult_OperationStatus_OperationSuccess) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[42] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AddResp_CreatedObjectResult_OperationStatus_OperationSuccess.ProtoReflect.Descriptor instead. +func (*AddResp_CreatedObjectResult_OperationStatus_OperationSuccess) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{15, 0, 0, 1} +} + +func (x *AddResp_CreatedObjectResult_OperationStatus_OperationSuccess) GetInstantiatedPath() string { + if x != nil { + return x.InstantiatedPath + } + return "" +} + +func (x *AddResp_CreatedObjectResult_OperationStatus_OperationSuccess) GetParamErrs() []*AddResp_ParameterError { + if x != nil { + return x.ParamErrs + } + return nil +} + +func (x *AddResp_CreatedObjectResult_OperationStatus_OperationSuccess) GetUniqueKeys() map[string]string { + if x != nil { + return x.UniqueKeys + } + return nil +} + +type DeleteResp_DeletedObjectResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RequestedPath string `protobuf:"bytes,1,opt,name=requested_path,json=requestedPath,proto3" json:"requested_path,omitempty"` + OperStatus *DeleteResp_DeletedObjectResult_OperationStatus `protobuf:"bytes,2,opt,name=oper_status,json=operStatus,proto3" json:"oper_status,omitempty"` +} + +func (x *DeleteResp_DeletedObjectResult) Reset() { + *x = DeleteResp_DeletedObjectResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[44] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteResp_DeletedObjectResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteResp_DeletedObjectResult) ProtoMessage() {} + +func (x *DeleteResp_DeletedObjectResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[44] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteResp_DeletedObjectResult.ProtoReflect.Descriptor instead. +func (*DeleteResp_DeletedObjectResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{17, 0} +} + +func (x *DeleteResp_DeletedObjectResult) GetRequestedPath() string { + if x != nil { + return x.RequestedPath + } + return "" +} + +func (x *DeleteResp_DeletedObjectResult) GetOperStatus() *DeleteResp_DeletedObjectResult_OperationStatus { + if x != nil { + return x.OperStatus + } + return nil +} + +type DeleteResp_UnaffectedPathError struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UnaffectedPath string `protobuf:"bytes,1,opt,name=unaffected_path,json=unaffectedPath,proto3" json:"unaffected_path,omitempty"` + ErrCode uint32 `protobuf:"fixed32,2,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,3,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` +} + +func (x *DeleteResp_UnaffectedPathError) Reset() { + *x = DeleteResp_UnaffectedPathError{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[45] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteResp_UnaffectedPathError) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteResp_UnaffectedPathError) ProtoMessage() {} + +func (x *DeleteResp_UnaffectedPathError) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[45] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteResp_UnaffectedPathError.ProtoReflect.Descriptor instead. +func (*DeleteResp_UnaffectedPathError) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{17, 1} +} + +func (x *DeleteResp_UnaffectedPathError) GetUnaffectedPath() string { + if x != nil { + return x.UnaffectedPath + } + return "" +} + +func (x *DeleteResp_UnaffectedPathError) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *DeleteResp_UnaffectedPathError) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +type DeleteResp_DeletedObjectResult_OperationStatus struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to OperStatus: + // + // *DeleteResp_DeletedObjectResult_OperationStatus_OperFailure + // *DeleteResp_DeletedObjectResult_OperationStatus_OperSuccess + OperStatus isDeleteResp_DeletedObjectResult_OperationStatus_OperStatus `protobuf_oneof:"oper_status"` +} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus) Reset() { + *x = DeleteResp_DeletedObjectResult_OperationStatus{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[46] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteResp_DeletedObjectResult_OperationStatus) ProtoMessage() {} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[46] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteResp_DeletedObjectResult_OperationStatus.ProtoReflect.Descriptor instead. +func (*DeleteResp_DeletedObjectResult_OperationStatus) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{17, 0, 0} +} + +func (m *DeleteResp_DeletedObjectResult_OperationStatus) GetOperStatus() isDeleteResp_DeletedObjectResult_OperationStatus_OperStatus { + if m != nil { + return m.OperStatus + } + return nil +} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus) GetOperFailure() *DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure { + if x, ok := x.GetOperStatus().(*DeleteResp_DeletedObjectResult_OperationStatus_OperFailure); ok { + return x.OperFailure + } + return nil +} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus) GetOperSuccess() *DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess { + if x, ok := x.GetOperStatus().(*DeleteResp_DeletedObjectResult_OperationStatus_OperSuccess); ok { + return x.OperSuccess + } + return nil +} + +type isDeleteResp_DeletedObjectResult_OperationStatus_OperStatus interface { + isDeleteResp_DeletedObjectResult_OperationStatus_OperStatus() +} + +type DeleteResp_DeletedObjectResult_OperationStatus_OperFailure struct { + OperFailure *DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure `protobuf:"bytes,1,opt,name=oper_failure,json=operFailure,proto3,oneof"` +} + +type DeleteResp_DeletedObjectResult_OperationStatus_OperSuccess struct { + OperSuccess *DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess `protobuf:"bytes,2,opt,name=oper_success,json=operSuccess,proto3,oneof"` +} + +func (*DeleteResp_DeletedObjectResult_OperationStatus_OperFailure) isDeleteResp_DeletedObjectResult_OperationStatus_OperStatus() { +} + +func (*DeleteResp_DeletedObjectResult_OperationStatus_OperSuccess) isDeleteResp_DeletedObjectResult_OperationStatus_OperStatus() { +} + +type DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ErrCode uint32 `protobuf:"fixed32,1,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,2,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` +} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure) Reset() { + *x = DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[47] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure) ProtoMessage() {} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[47] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure.ProtoReflect.Descriptor instead. +func (*DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{17, 0, 0, 0} +} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +type DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AffectedPaths []string `protobuf:"bytes,1,rep,name=affected_paths,json=affectedPaths,proto3" json:"affected_paths,omitempty"` + UnaffectedPathErrs []*DeleteResp_UnaffectedPathError `protobuf:"bytes,2,rep,name=unaffected_path_errs,json=unaffectedPathErrs,proto3" json:"unaffected_path_errs,omitempty"` +} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess) Reset() { + *x = DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[48] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess) ProtoMessage() {} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[48] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess.ProtoReflect.Descriptor instead. +func (*DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{17, 0, 0, 1} +} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess) GetAffectedPaths() []string { + if x != nil { + return x.AffectedPaths + } + return nil +} + +func (x *DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess) GetUnaffectedPathErrs() []*DeleteResp_UnaffectedPathError { + if x != nil { + return x.UnaffectedPathErrs + } + return nil +} + +type Set_UpdateObject struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ObjPath string `protobuf:"bytes,1,opt,name=obj_path,json=objPath,proto3" json:"obj_path,omitempty"` + ParamSettings []*Set_UpdateParamSetting `protobuf:"bytes,2,rep,name=param_settings,json=paramSettings,proto3" json:"param_settings,omitempty"` +} + +func (x *Set_UpdateObject) Reset() { + *x = Set_UpdateObject{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[49] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Set_UpdateObject) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Set_UpdateObject) ProtoMessage() {} + +func (x *Set_UpdateObject) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[49] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Set_UpdateObject.ProtoReflect.Descriptor instead. +func (*Set_UpdateObject) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{18, 0} +} + +func (x *Set_UpdateObject) GetObjPath() string { + if x != nil { + return x.ObjPath + } + return "" +} + +func (x *Set_UpdateObject) GetParamSettings() []*Set_UpdateParamSetting { + if x != nil { + return x.ParamSettings + } + return nil +} + +type Set_UpdateParamSetting struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Param string `protobuf:"bytes,1,opt,name=param,proto3" json:"param,omitempty"` + Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + Required bool `protobuf:"varint,3,opt,name=required,proto3" json:"required,omitempty"` +} + +func (x *Set_UpdateParamSetting) Reset() { + *x = Set_UpdateParamSetting{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[50] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Set_UpdateParamSetting) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Set_UpdateParamSetting) ProtoMessage() {} + +func (x *Set_UpdateParamSetting) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[50] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Set_UpdateParamSetting.ProtoReflect.Descriptor instead. +func (*Set_UpdateParamSetting) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{18, 1} +} + +func (x *Set_UpdateParamSetting) GetParam() string { + if x != nil { + return x.Param + } + return "" +} + +func (x *Set_UpdateParamSetting) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +func (x *Set_UpdateParamSetting) GetRequired() bool { + if x != nil { + return x.Required + } + return false +} + +type SetResp_UpdatedObjectResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RequestedPath string `protobuf:"bytes,1,opt,name=requested_path,json=requestedPath,proto3" json:"requested_path,omitempty"` + OperStatus *SetResp_UpdatedObjectResult_OperationStatus `protobuf:"bytes,2,opt,name=oper_status,json=operStatus,proto3" json:"oper_status,omitempty"` +} + +func (x *SetResp_UpdatedObjectResult) Reset() { + *x = SetResp_UpdatedObjectResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[51] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetResp_UpdatedObjectResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetResp_UpdatedObjectResult) ProtoMessage() {} + +func (x *SetResp_UpdatedObjectResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[51] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetResp_UpdatedObjectResult.ProtoReflect.Descriptor instead. +func (*SetResp_UpdatedObjectResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{19, 0} +} + +func (x *SetResp_UpdatedObjectResult) GetRequestedPath() string { + if x != nil { + return x.RequestedPath + } + return "" +} + +func (x *SetResp_UpdatedObjectResult) GetOperStatus() *SetResp_UpdatedObjectResult_OperationStatus { + if x != nil { + return x.OperStatus + } + return nil +} + +type SetResp_UpdatedInstanceFailure struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AffectedPath string `protobuf:"bytes,1,opt,name=affected_path,json=affectedPath,proto3" json:"affected_path,omitempty"` + ParamErrs []*SetResp_ParameterError `protobuf:"bytes,2,rep,name=param_errs,json=paramErrs,proto3" json:"param_errs,omitempty"` +} + +func (x *SetResp_UpdatedInstanceFailure) Reset() { + *x = SetResp_UpdatedInstanceFailure{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[52] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetResp_UpdatedInstanceFailure) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetResp_UpdatedInstanceFailure) ProtoMessage() {} + +func (x *SetResp_UpdatedInstanceFailure) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[52] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetResp_UpdatedInstanceFailure.ProtoReflect.Descriptor instead. +func (*SetResp_UpdatedInstanceFailure) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{19, 1} +} + +func (x *SetResp_UpdatedInstanceFailure) GetAffectedPath() string { + if x != nil { + return x.AffectedPath + } + return "" +} + +func (x *SetResp_UpdatedInstanceFailure) GetParamErrs() []*SetResp_ParameterError { + if x != nil { + return x.ParamErrs + } + return nil +} + +type SetResp_UpdatedInstanceResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AffectedPath string `protobuf:"bytes,1,opt,name=affected_path,json=affectedPath,proto3" json:"affected_path,omitempty"` + ParamErrs []*SetResp_ParameterError `protobuf:"bytes,2,rep,name=param_errs,json=paramErrs,proto3" json:"param_errs,omitempty"` + UpdatedParams map[string]string `protobuf:"bytes,3,rep,name=updated_params,json=updatedParams,proto3" json:"updated_params,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *SetResp_UpdatedInstanceResult) Reset() { + *x = SetResp_UpdatedInstanceResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[53] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetResp_UpdatedInstanceResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetResp_UpdatedInstanceResult) ProtoMessage() {} + +func (x *SetResp_UpdatedInstanceResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[53] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetResp_UpdatedInstanceResult.ProtoReflect.Descriptor instead. +func (*SetResp_UpdatedInstanceResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{19, 2} +} + +func (x *SetResp_UpdatedInstanceResult) GetAffectedPath() string { + if x != nil { + return x.AffectedPath + } + return "" +} + +func (x *SetResp_UpdatedInstanceResult) GetParamErrs() []*SetResp_ParameterError { + if x != nil { + return x.ParamErrs + } + return nil +} + +func (x *SetResp_UpdatedInstanceResult) GetUpdatedParams() map[string]string { + if x != nil { + return x.UpdatedParams + } + return nil +} + +type SetResp_ParameterError struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Param string `protobuf:"bytes,1,opt,name=param,proto3" json:"param,omitempty"` + ErrCode uint32 `protobuf:"fixed32,2,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,3,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` +} + +func (x *SetResp_ParameterError) Reset() { + *x = SetResp_ParameterError{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[54] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetResp_ParameterError) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetResp_ParameterError) ProtoMessage() {} + +func (x *SetResp_ParameterError) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[54] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetResp_ParameterError.ProtoReflect.Descriptor instead. +func (*SetResp_ParameterError) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{19, 3} +} + +func (x *SetResp_ParameterError) GetParam() string { + if x != nil { + return x.Param + } + return "" +} + +func (x *SetResp_ParameterError) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *SetResp_ParameterError) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +type SetResp_UpdatedObjectResult_OperationStatus struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to OperStatus: + // + // *SetResp_UpdatedObjectResult_OperationStatus_OperFailure + // *SetResp_UpdatedObjectResult_OperationStatus_OperSuccess + OperStatus isSetResp_UpdatedObjectResult_OperationStatus_OperStatus `protobuf_oneof:"oper_status"` +} + +func (x *SetResp_UpdatedObjectResult_OperationStatus) Reset() { + *x = SetResp_UpdatedObjectResult_OperationStatus{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[55] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetResp_UpdatedObjectResult_OperationStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetResp_UpdatedObjectResult_OperationStatus) ProtoMessage() {} + +func (x *SetResp_UpdatedObjectResult_OperationStatus) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[55] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetResp_UpdatedObjectResult_OperationStatus.ProtoReflect.Descriptor instead. +func (*SetResp_UpdatedObjectResult_OperationStatus) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{19, 0, 0} +} + +func (m *SetResp_UpdatedObjectResult_OperationStatus) GetOperStatus() isSetResp_UpdatedObjectResult_OperationStatus_OperStatus { + if m != nil { + return m.OperStatus + } + return nil +} + +func (x *SetResp_UpdatedObjectResult_OperationStatus) GetOperFailure() *SetResp_UpdatedObjectResult_OperationStatus_OperationFailure { + if x, ok := x.GetOperStatus().(*SetResp_UpdatedObjectResult_OperationStatus_OperFailure); ok { + return x.OperFailure + } + return nil +} + +func (x *SetResp_UpdatedObjectResult_OperationStatus) GetOperSuccess() *SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess { + if x, ok := x.GetOperStatus().(*SetResp_UpdatedObjectResult_OperationStatus_OperSuccess); ok { + return x.OperSuccess + } + return nil +} + +type isSetResp_UpdatedObjectResult_OperationStatus_OperStatus interface { + isSetResp_UpdatedObjectResult_OperationStatus_OperStatus() +} + +type SetResp_UpdatedObjectResult_OperationStatus_OperFailure struct { + OperFailure *SetResp_UpdatedObjectResult_OperationStatus_OperationFailure `protobuf:"bytes,1,opt,name=oper_failure,json=operFailure,proto3,oneof"` +} + +type SetResp_UpdatedObjectResult_OperationStatus_OperSuccess struct { + OperSuccess *SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess `protobuf:"bytes,2,opt,name=oper_success,json=operSuccess,proto3,oneof"` +} + +func (*SetResp_UpdatedObjectResult_OperationStatus_OperFailure) isSetResp_UpdatedObjectResult_OperationStatus_OperStatus() { +} + +func (*SetResp_UpdatedObjectResult_OperationStatus_OperSuccess) isSetResp_UpdatedObjectResult_OperationStatus_OperStatus() { +} + +type SetResp_UpdatedObjectResult_OperationStatus_OperationFailure struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ErrCode uint32 `protobuf:"fixed32,1,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,2,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` + UpdatedInstFailures []*SetResp_UpdatedInstanceFailure `protobuf:"bytes,3,rep,name=updated_inst_failures,json=updatedInstFailures,proto3" json:"updated_inst_failures,omitempty"` +} + +func (x *SetResp_UpdatedObjectResult_OperationStatus_OperationFailure) Reset() { + *x = SetResp_UpdatedObjectResult_OperationStatus_OperationFailure{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[56] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetResp_UpdatedObjectResult_OperationStatus_OperationFailure) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetResp_UpdatedObjectResult_OperationStatus_OperationFailure) ProtoMessage() {} + +func (x *SetResp_UpdatedObjectResult_OperationStatus_OperationFailure) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[56] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetResp_UpdatedObjectResult_OperationStatus_OperationFailure.ProtoReflect.Descriptor instead. +func (*SetResp_UpdatedObjectResult_OperationStatus_OperationFailure) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{19, 0, 0, 0} +} + +func (x *SetResp_UpdatedObjectResult_OperationStatus_OperationFailure) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *SetResp_UpdatedObjectResult_OperationStatus_OperationFailure) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +func (x *SetResp_UpdatedObjectResult_OperationStatus_OperationFailure) GetUpdatedInstFailures() []*SetResp_UpdatedInstanceFailure { + if x != nil { + return x.UpdatedInstFailures + } + return nil +} + +type SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UpdatedInstResults []*SetResp_UpdatedInstanceResult `protobuf:"bytes,1,rep,name=updated_inst_results,json=updatedInstResults,proto3" json:"updated_inst_results,omitempty"` +} + +func (x *SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess) Reset() { + *x = SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[57] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess) ProtoMessage() {} + +func (x *SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[57] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess.ProtoReflect.Descriptor instead. +func (*SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{19, 0, 0, 1} +} + +func (x *SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess) GetUpdatedInstResults() []*SetResp_UpdatedInstanceResult { + if x != nil { + return x.UpdatedInstResults + } + return nil +} + +type OperateResp_OperationResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ExecutedCommand string `protobuf:"bytes,1,opt,name=executed_command,json=executedCommand,proto3" json:"executed_command,omitempty"` + // Types that are assignable to OperationResp: + // + // *OperateResp_OperationResult_ReqObjPath + // *OperateResp_OperationResult_ReqOutputArgs + // *OperateResp_OperationResult_CmdFailure + OperationResp isOperateResp_OperationResult_OperationResp `protobuf_oneof:"operation_resp"` +} + +func (x *OperateResp_OperationResult) Reset() { + *x = OperateResp_OperationResult{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[60] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OperateResp_OperationResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OperateResp_OperationResult) ProtoMessage() {} + +func (x *OperateResp_OperationResult) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[60] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OperateResp_OperationResult.ProtoReflect.Descriptor instead. +func (*OperateResp_OperationResult) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{21, 0} +} + +func (x *OperateResp_OperationResult) GetExecutedCommand() string { + if x != nil { + return x.ExecutedCommand + } + return "" +} + +func (m *OperateResp_OperationResult) GetOperationResp() isOperateResp_OperationResult_OperationResp { + if m != nil { + return m.OperationResp + } + return nil +} + +func (x *OperateResp_OperationResult) GetReqObjPath() string { + if x, ok := x.GetOperationResp().(*OperateResp_OperationResult_ReqObjPath); ok { + return x.ReqObjPath + } + return "" +} + +func (x *OperateResp_OperationResult) GetReqOutputArgs() *OperateResp_OperationResult_OutputArgs { + if x, ok := x.GetOperationResp().(*OperateResp_OperationResult_ReqOutputArgs); ok { + return x.ReqOutputArgs + } + return nil +} + +func (x *OperateResp_OperationResult) GetCmdFailure() *OperateResp_OperationResult_CommandFailure { + if x, ok := x.GetOperationResp().(*OperateResp_OperationResult_CmdFailure); ok { + return x.CmdFailure + } + return nil +} + +type isOperateResp_OperationResult_OperationResp interface { + isOperateResp_OperationResult_OperationResp() +} + +type OperateResp_OperationResult_ReqObjPath struct { + ReqObjPath string `protobuf:"bytes,2,opt,name=req_obj_path,json=reqObjPath,proto3,oneof"` +} + +type OperateResp_OperationResult_ReqOutputArgs struct { + ReqOutputArgs *OperateResp_OperationResult_OutputArgs `protobuf:"bytes,3,opt,name=req_output_args,json=reqOutputArgs,proto3,oneof"` +} + +type OperateResp_OperationResult_CmdFailure struct { + CmdFailure *OperateResp_OperationResult_CommandFailure `protobuf:"bytes,4,opt,name=cmd_failure,json=cmdFailure,proto3,oneof"` +} + +func (*OperateResp_OperationResult_ReqObjPath) isOperateResp_OperationResult_OperationResp() {} + +func (*OperateResp_OperationResult_ReqOutputArgs) isOperateResp_OperationResult_OperationResp() {} + +func (*OperateResp_OperationResult_CmdFailure) isOperateResp_OperationResult_OperationResp() {} + +type OperateResp_OperationResult_OutputArgs struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OutputArgs map[string]string `protobuf:"bytes,1,rep,name=output_args,json=outputArgs,proto3" json:"output_args,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *OperateResp_OperationResult_OutputArgs) Reset() { + *x = OperateResp_OperationResult_OutputArgs{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[61] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OperateResp_OperationResult_OutputArgs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OperateResp_OperationResult_OutputArgs) ProtoMessage() {} + +func (x *OperateResp_OperationResult_OutputArgs) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[61] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OperateResp_OperationResult_OutputArgs.ProtoReflect.Descriptor instead. +func (*OperateResp_OperationResult_OutputArgs) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{21, 0, 0} +} + +func (x *OperateResp_OperationResult_OutputArgs) GetOutputArgs() map[string]string { + if x != nil { + return x.OutputArgs + } + return nil +} + +type OperateResp_OperationResult_CommandFailure struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ErrCode uint32 `protobuf:"fixed32,1,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,2,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` +} + +func (x *OperateResp_OperationResult_CommandFailure) Reset() { + *x = OperateResp_OperationResult_CommandFailure{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[62] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OperateResp_OperationResult_CommandFailure) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OperateResp_OperationResult_CommandFailure) ProtoMessage() {} + +func (x *OperateResp_OperationResult_CommandFailure) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[62] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OperateResp_OperationResult_CommandFailure.ProtoReflect.Descriptor instead. +func (*OperateResp_OperationResult_CommandFailure) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{21, 0, 1} +} + +func (x *OperateResp_OperationResult_CommandFailure) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *OperateResp_OperationResult_CommandFailure) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +type Notify_Event struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ObjPath string `protobuf:"bytes,1,opt,name=obj_path,json=objPath,proto3" json:"obj_path,omitempty"` + EventName string `protobuf:"bytes,2,opt,name=event_name,json=eventName,proto3" json:"event_name,omitempty"` + Params map[string]string `protobuf:"bytes,3,rep,name=params,proto3" json:"params,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *Notify_Event) Reset() { + *x = Notify_Event{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[64] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Notify_Event) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Notify_Event) ProtoMessage() {} + +func (x *Notify_Event) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[64] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Notify_Event.ProtoReflect.Descriptor instead. +func (*Notify_Event) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{22, 0} +} + +func (x *Notify_Event) GetObjPath() string { + if x != nil { + return x.ObjPath + } + return "" +} + +func (x *Notify_Event) GetEventName() string { + if x != nil { + return x.EventName + } + return "" +} + +func (x *Notify_Event) GetParams() map[string]string { + if x != nil { + return x.Params + } + return nil +} + +type Notify_ValueChange struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ParamPath string `protobuf:"bytes,1,opt,name=param_path,json=paramPath,proto3" json:"param_path,omitempty"` + ParamValue string `protobuf:"bytes,2,opt,name=param_value,json=paramValue,proto3" json:"param_value,omitempty"` +} + +func (x *Notify_ValueChange) Reset() { + *x = Notify_ValueChange{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[65] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Notify_ValueChange) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Notify_ValueChange) ProtoMessage() {} + +func (x *Notify_ValueChange) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[65] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Notify_ValueChange.ProtoReflect.Descriptor instead. +func (*Notify_ValueChange) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{22, 1} +} + +func (x *Notify_ValueChange) GetParamPath() string { + if x != nil { + return x.ParamPath + } + return "" +} + +func (x *Notify_ValueChange) GetParamValue() string { + if x != nil { + return x.ParamValue + } + return "" +} + +type Notify_ObjectCreation struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ObjPath string `protobuf:"bytes,1,opt,name=obj_path,json=objPath,proto3" json:"obj_path,omitempty"` + UniqueKeys map[string]string `protobuf:"bytes,2,rep,name=unique_keys,json=uniqueKeys,proto3" json:"unique_keys,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *Notify_ObjectCreation) Reset() { + *x = Notify_ObjectCreation{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[66] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Notify_ObjectCreation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Notify_ObjectCreation) ProtoMessage() {} + +func (x *Notify_ObjectCreation) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[66] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Notify_ObjectCreation.ProtoReflect.Descriptor instead. +func (*Notify_ObjectCreation) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{22, 2} +} + +func (x *Notify_ObjectCreation) GetObjPath() string { + if x != nil { + return x.ObjPath + } + return "" +} + +func (x *Notify_ObjectCreation) GetUniqueKeys() map[string]string { + if x != nil { + return x.UniqueKeys + } + return nil +} + +type Notify_ObjectDeletion struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ObjPath string `protobuf:"bytes,1,opt,name=obj_path,json=objPath,proto3" json:"obj_path,omitempty"` +} + +func (x *Notify_ObjectDeletion) Reset() { + *x = Notify_ObjectDeletion{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[67] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Notify_ObjectDeletion) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Notify_ObjectDeletion) ProtoMessage() {} + +func (x *Notify_ObjectDeletion) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[67] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Notify_ObjectDeletion.ProtoReflect.Descriptor instead. +func (*Notify_ObjectDeletion) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{22, 3} +} + +func (x *Notify_ObjectDeletion) GetObjPath() string { + if x != nil { + return x.ObjPath + } + return "" +} + +type Notify_OperationComplete struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ObjPath string `protobuf:"bytes,1,opt,name=obj_path,json=objPath,proto3" json:"obj_path,omitempty"` + CommandName string `protobuf:"bytes,2,opt,name=command_name,json=commandName,proto3" json:"command_name,omitempty"` + CommandKey string `protobuf:"bytes,3,opt,name=command_key,json=commandKey,proto3" json:"command_key,omitempty"` + // Types that are assignable to OperationResp: + // + // *Notify_OperationComplete_ReqOutputArgs + // *Notify_OperationComplete_CmdFailure + OperationResp isNotify_OperationComplete_OperationResp `protobuf_oneof:"operation_resp"` +} + +func (x *Notify_OperationComplete) Reset() { + *x = Notify_OperationComplete{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[68] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Notify_OperationComplete) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Notify_OperationComplete) ProtoMessage() {} + +func (x *Notify_OperationComplete) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[68] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Notify_OperationComplete.ProtoReflect.Descriptor instead. +func (*Notify_OperationComplete) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{22, 4} +} + +func (x *Notify_OperationComplete) GetObjPath() string { + if x != nil { + return x.ObjPath + } + return "" +} + +func (x *Notify_OperationComplete) GetCommandName() string { + if x != nil { + return x.CommandName + } + return "" +} + +func (x *Notify_OperationComplete) GetCommandKey() string { + if x != nil { + return x.CommandKey + } + return "" +} + +func (m *Notify_OperationComplete) GetOperationResp() isNotify_OperationComplete_OperationResp { + if m != nil { + return m.OperationResp + } + return nil +} + +func (x *Notify_OperationComplete) GetReqOutputArgs() *Notify_OperationComplete_OutputArgs { + if x, ok := x.GetOperationResp().(*Notify_OperationComplete_ReqOutputArgs); ok { + return x.ReqOutputArgs + } + return nil +} + +func (x *Notify_OperationComplete) GetCmdFailure() *Notify_OperationComplete_CommandFailure { + if x, ok := x.GetOperationResp().(*Notify_OperationComplete_CmdFailure); ok { + return x.CmdFailure + } + return nil +} + +type isNotify_OperationComplete_OperationResp interface { + isNotify_OperationComplete_OperationResp() +} + +type Notify_OperationComplete_ReqOutputArgs struct { + ReqOutputArgs *Notify_OperationComplete_OutputArgs `protobuf:"bytes,4,opt,name=req_output_args,json=reqOutputArgs,proto3,oneof"` +} + +type Notify_OperationComplete_CmdFailure struct { + CmdFailure *Notify_OperationComplete_CommandFailure `protobuf:"bytes,5,opt,name=cmd_failure,json=cmdFailure,proto3,oneof"` +} + +func (*Notify_OperationComplete_ReqOutputArgs) isNotify_OperationComplete_OperationResp() {} + +func (*Notify_OperationComplete_CmdFailure) isNotify_OperationComplete_OperationResp() {} + +type Notify_OnBoardRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Oui string `protobuf:"bytes,1,opt,name=oui,proto3" json:"oui,omitempty"` + ProductClass string `protobuf:"bytes,2,opt,name=product_class,json=productClass,proto3" json:"product_class,omitempty"` + SerialNumber string `protobuf:"bytes,3,opt,name=serial_number,json=serialNumber,proto3" json:"serial_number,omitempty"` + AgentSupportedProtocolVersions string `protobuf:"bytes,4,opt,name=agent_supported_protocol_versions,json=agentSupportedProtocolVersions,proto3" json:"agent_supported_protocol_versions,omitempty"` +} + +func (x *Notify_OnBoardRequest) Reset() { + *x = Notify_OnBoardRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[69] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Notify_OnBoardRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Notify_OnBoardRequest) ProtoMessage() {} + +func (x *Notify_OnBoardRequest) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[69] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Notify_OnBoardRequest.ProtoReflect.Descriptor instead. +func (*Notify_OnBoardRequest) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{22, 5} +} + +func (x *Notify_OnBoardRequest) GetOui() string { + if x != nil { + return x.Oui + } + return "" +} + +func (x *Notify_OnBoardRequest) GetProductClass() string { + if x != nil { + return x.ProductClass + } + return "" +} + +func (x *Notify_OnBoardRequest) GetSerialNumber() string { + if x != nil { + return x.SerialNumber + } + return "" +} + +func (x *Notify_OnBoardRequest) GetAgentSupportedProtocolVersions() string { + if x != nil { + return x.AgentSupportedProtocolVersions + } + return "" +} + +type Notify_OperationComplete_OutputArgs struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OutputArgs map[string]string `protobuf:"bytes,1,rep,name=output_args,json=outputArgs,proto3" json:"output_args,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *Notify_OperationComplete_OutputArgs) Reset() { + *x = Notify_OperationComplete_OutputArgs{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[72] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Notify_OperationComplete_OutputArgs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Notify_OperationComplete_OutputArgs) ProtoMessage() {} + +func (x *Notify_OperationComplete_OutputArgs) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[72] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Notify_OperationComplete_OutputArgs.ProtoReflect.Descriptor instead. +func (*Notify_OperationComplete_OutputArgs) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{22, 4, 0} +} + +func (x *Notify_OperationComplete_OutputArgs) GetOutputArgs() map[string]string { + if x != nil { + return x.OutputArgs + } + return nil +} + +type Notify_OperationComplete_CommandFailure struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ErrCode uint32 `protobuf:"fixed32,1,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"` + ErrMsg string `protobuf:"bytes,2,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"` +} + +func (x *Notify_OperationComplete_CommandFailure) Reset() { + *x = Notify_OperationComplete_CommandFailure{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_msg_1_2_proto_msgTypes[73] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Notify_OperationComplete_CommandFailure) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Notify_OperationComplete_CommandFailure) ProtoMessage() {} + +func (x *Notify_OperationComplete_CommandFailure) ProtoReflect() protoreflect.Message { + mi := &file_usp_msg_1_2_proto_msgTypes[73] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Notify_OperationComplete_CommandFailure.ProtoReflect.Descriptor instead. +func (*Notify_OperationComplete_CommandFailure) Descriptor() ([]byte, []int) { + return file_usp_msg_1_2_proto_rawDescGZIP(), []int{22, 4, 1} +} + +func (x *Notify_OperationComplete_CommandFailure) GetErrCode() uint32 { + if x != nil { + return x.ErrCode + } + return 0 +} + +func (x *Notify_OperationComplete_CommandFailure) GetErrMsg() string { + if x != nil { + return x.ErrMsg + } + return "" +} + +var File_usp_msg_1_2_proto protoreflect.FileDescriptor + +var file_usp_msg_1_2_proto_rawDesc = []byte{ + 0x0a, 0x11, 0x75, 0x73, 0x70, 0x2d, 0x6d, 0x73, 0x67, 0x2d, 0x31, 0x2d, 0x32, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x75, 0x73, 0x70, 0x22, 0x49, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, + 0x23, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x0b, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x06, 0x68, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x12, 0x1d, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x42, 0x6f, 0x64, 0x79, 0x52, 0x04, 0x62, + 0x6f, 0x64, 0x79, 0x22, 0x97, 0x03, 0x0a, 0x06, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x15, + 0x0a, 0x06, 0x6d, 0x73, 0x67, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x6d, 0x73, 0x67, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x08, 0x6d, 0x73, 0x67, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x48, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x2e, 0x4d, 0x73, 0x67, 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, 0x6d, 0x73, + 0x67, 0x54, 0x79, 0x70, 0x65, 0x22, 0xc5, 0x02, 0x0a, 0x07, 0x4d, 0x73, 0x67, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x09, 0x0a, 0x05, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, + 0x47, 0x45, 0x54, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, + 0x50, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x4e, 0x4f, 0x54, 0x49, 0x46, 0x59, 0x10, 0x03, 0x12, + 0x07, 0x0a, 0x03, 0x53, 0x45, 0x54, 0x10, 0x04, 0x12, 0x0c, 0x0a, 0x08, 0x53, 0x45, 0x54, 0x5f, + 0x52, 0x45, 0x53, 0x50, 0x10, 0x05, 0x12, 0x0b, 0x0a, 0x07, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, + 0x45, 0x10, 0x06, 0x12, 0x10, 0x0a, 0x0c, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x45, 0x5f, 0x52, + 0x45, 0x53, 0x50, 0x10, 0x07, 0x12, 0x07, 0x0a, 0x03, 0x41, 0x44, 0x44, 0x10, 0x08, 0x12, 0x0c, + 0x0a, 0x08, 0x41, 0x44, 0x44, 0x5f, 0x52, 0x45, 0x53, 0x50, 0x10, 0x09, 0x12, 0x0a, 0x0a, 0x06, + 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x0a, 0x12, 0x0f, 0x0a, 0x0b, 0x44, 0x45, 0x4c, 0x45, + 0x54, 0x45, 0x5f, 0x52, 0x45, 0x53, 0x50, 0x10, 0x0b, 0x12, 0x14, 0x0a, 0x10, 0x47, 0x45, 0x54, + 0x5f, 0x53, 0x55, 0x50, 0x50, 0x4f, 0x52, 0x54, 0x45, 0x44, 0x5f, 0x44, 0x4d, 0x10, 0x0c, 0x12, + 0x19, 0x0a, 0x15, 0x47, 0x45, 0x54, 0x5f, 0x53, 0x55, 0x50, 0x50, 0x4f, 0x52, 0x54, 0x45, 0x44, + 0x5f, 0x44, 0x4d, 0x5f, 0x52, 0x45, 0x53, 0x50, 0x10, 0x0d, 0x12, 0x11, 0x0a, 0x0d, 0x47, 0x45, + 0x54, 0x5f, 0x49, 0x4e, 0x53, 0x54, 0x41, 0x4e, 0x43, 0x45, 0x53, 0x10, 0x0e, 0x12, 0x16, 0x0a, + 0x12, 0x47, 0x45, 0x54, 0x5f, 0x49, 0x4e, 0x53, 0x54, 0x41, 0x4e, 0x43, 0x45, 0x53, 0x5f, 0x52, + 0x45, 0x53, 0x50, 0x10, 0x0f, 0x12, 0x0f, 0x0a, 0x0b, 0x4e, 0x4f, 0x54, 0x49, 0x46, 0x59, 0x5f, + 0x52, 0x45, 0x53, 0x50, 0x10, 0x10, 0x12, 0x17, 0x0a, 0x13, 0x47, 0x45, 0x54, 0x5f, 0x53, 0x55, + 0x50, 0x50, 0x4f, 0x52, 0x54, 0x45, 0x44, 0x5f, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x10, 0x11, 0x12, + 0x1c, 0x0a, 0x18, 0x47, 0x45, 0x54, 0x5f, 0x53, 0x55, 0x50, 0x50, 0x4f, 0x52, 0x54, 0x45, 0x44, + 0x5f, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x5f, 0x52, 0x45, 0x53, 0x50, 0x10, 0x12, 0x22, 0x8d, 0x01, + 0x0a, 0x04, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x28, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x00, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x2b, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x48, 0x00, 0x52, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x22, 0x0a, + 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x75, + 0x73, 0x70, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, + 0x72, 0x42, 0x0a, 0x0a, 0x08, 0x6d, 0x73, 0x67, 0x5f, 0x62, 0x6f, 0x64, 0x79, 0x22, 0xb5, 0x03, + 0x0a, 0x07, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x03, 0x67, 0x65, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x08, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, + 0x48, 0x00, 0x52, 0x03, 0x67, 0x65, 0x74, 0x12, 0x3f, 0x0a, 0x10, 0x67, 0x65, 0x74, 0x5f, 0x73, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x64, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x13, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, + 0x72, 0x74, 0x65, 0x64, 0x44, 0x4d, 0x48, 0x00, 0x52, 0x0e, 0x67, 0x65, 0x74, 0x53, 0x75, 0x70, + 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x44, 0x6d, 0x12, 0x38, 0x0a, 0x0d, 0x67, 0x65, 0x74, 0x5f, + 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x11, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, + 0x65, 0x73, 0x48, 0x00, 0x52, 0x0c, 0x67, 0x65, 0x74, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, + 0x65, 0x73, 0x12, 0x1c, 0x0a, 0x03, 0x73, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x08, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x53, 0x65, 0x74, 0x48, 0x00, 0x52, 0x03, 0x73, 0x65, 0x74, + 0x12, 0x1c, 0x0a, 0x03, 0x61, 0x64, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x08, 0x2e, + 0x75, 0x73, 0x70, 0x2e, 0x41, 0x64, 0x64, 0x48, 0x00, 0x52, 0x03, 0x61, 0x64, 0x64, 0x12, 0x25, + 0x0a, 0x06, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, + 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x48, 0x00, 0x52, 0x06, 0x64, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x28, 0x0a, 0x07, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x07, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x12, + 0x25, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x0b, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x48, 0x00, 0x52, 0x06, + 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x12, 0x51, 0x0a, 0x16, 0x67, 0x65, 0x74, 0x5f, 0x73, 0x75, + 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, + 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, + 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, + 0x6c, 0x48, 0x00, 0x52, 0x14, 0x67, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x42, 0x0a, 0x0a, 0x08, 0x72, 0x65, 0x71, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0xac, 0x04, 0x0a, 0x08, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x29, 0x0a, 0x08, 0x67, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x48, 0x00, 0x52, 0x07, 0x67, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x4c, 0x0a, + 0x15, 0x67, 0x65, 0x74, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x64, + 0x6d, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x75, + 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x44, + 0x4d, 0x52, 0x65, 0x73, 0x70, 0x48, 0x00, 0x52, 0x12, 0x67, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, + 0x6f, 0x72, 0x74, 0x65, 0x64, 0x44, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x12, 0x45, 0x0a, 0x12, 0x67, + 0x65, 0x74, 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x5f, 0x72, 0x65, 0x73, + 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, + 0x74, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x48, 0x00, + 0x52, 0x10, 0x67, 0x65, 0x74, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x12, 0x29, 0x0a, 0x08, 0x73, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x48, 0x00, 0x52, 0x07, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x29, 0x0a, + 0x08, 0x61, 0x64, 0x64, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x0c, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x41, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x48, 0x00, 0x52, + 0x07, 0x61, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x12, 0x32, 0x0a, 0x0b, 0x64, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, + 0x75, 0x73, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x48, 0x00, + 0x52, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x35, 0x0a, 0x0c, + 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x12, 0x32, 0x0a, 0x0b, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x5f, 0x72, 0x65, + 0x73, 0x70, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4e, + 0x6f, 0x74, 0x69, 0x66, 0x79, 0x52, 0x65, 0x73, 0x70, 0x48, 0x00, 0x52, 0x0a, 0x6e, 0x6f, 0x74, + 0x69, 0x66, 0x79, 0x52, 0x65, 0x73, 0x70, 0x12, 0x5e, 0x0a, 0x1b, 0x67, 0x65, 0x74, 0x5f, 0x73, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, + 0x6c, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x75, + 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x48, 0x00, 0x52, 0x18, 0x67, + 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x63, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x42, 0x0b, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x70, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x22, 0xd2, 0x01, 0x0a, 0x05, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x19, + 0x0a, 0x08, 0x65, 0x72, 0x72, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x07, + 0x52, 0x07, 0x65, 0x72, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x65, 0x72, 0x72, + 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x72, 0x72, 0x4d, + 0x73, 0x67, 0x12, 0x34, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x5f, 0x65, 0x72, 0x72, 0x73, + 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x45, 0x72, 0x72, + 0x6f, 0x72, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x09, 0x70, + 0x61, 0x72, 0x61, 0x6d, 0x45, 0x72, 0x72, 0x73, 0x1a, 0x5f, 0x0a, 0x0a, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x5f, + 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x61, 0x72, 0x61, + 0x6d, 0x50, 0x61, 0x74, 0x68, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x72, 0x72, 0x5f, 0x63, 0x6f, 0x64, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x07, 0x65, 0x72, 0x72, 0x43, 0x6f, 0x64, 0x65, + 0x12, 0x17, 0x0a, 0x07, 0x65, 0x72, 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x65, 0x72, 0x72, 0x4d, 0x73, 0x67, 0x22, 0x43, 0x0a, 0x03, 0x47, 0x65, 0x74, + 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, + 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x70, 0x74, 0x68, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x07, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x44, 0x65, 0x70, 0x74, 0x68, 0x22, 0xf2, + 0x03, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x4a, 0x0a, 0x10, 0x72, 0x65, + 0x71, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, + 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x0e, 0x72, 0x65, 0x71, 0x50, 0x61, 0x74, 0x68, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x1a, 0xc5, 0x01, 0x0a, 0x13, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x25, + 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x74, 0x68, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, + 0x64, 0x50, 0x61, 0x74, 0x68, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x72, 0x72, 0x5f, 0x63, 0x6f, 0x64, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x07, 0x65, 0x72, 0x72, 0x43, 0x6f, 0x64, 0x65, + 0x12, 0x17, 0x0a, 0x07, 0x65, 0x72, 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x65, 0x72, 0x72, 0x4d, 0x73, 0x67, 0x12, 0x53, 0x0a, 0x15, 0x72, 0x65, 0x73, + 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, + 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x50, + 0x61, 0x74, 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x13, 0x72, 0x65, 0x73, 0x6f, 0x6c, + 0x76, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x1a, 0xd2, + 0x01, 0x0a, 0x12, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, + 0x64, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, + 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x12, 0x56, 0x0a, 0x0d, 0x72, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x31, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x2e, + 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x52, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x1a, 0x3f, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0xca, 0x01, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, + 0x72, 0x74, 0x65, 0x64, 0x44, 0x4d, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x62, 0x6a, 0x5f, 0x70, 0x61, + 0x74, 0x68, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x62, 0x6a, 0x50, 0x61, + 0x74, 0x68, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x66, 0x69, 0x72, 0x73, 0x74, 0x5f, 0x6c, 0x65, 0x76, + 0x65, 0x6c, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x66, + 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x27, 0x0a, + 0x0f, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x73, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x43, 0x6f, + 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, + 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6e, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, + 0x22, 0xbe, 0x0f, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x44, 0x4d, 0x52, 0x65, 0x73, 0x70, 0x12, 0x55, 0x0a, 0x0f, 0x72, 0x65, 0x71, 0x5f, 0x6f, + 0x62, 0x6a, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x2d, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, + 0x74, 0x65, 0x64, 0x44, 0x4d, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, + 0x0d, 0x72, 0x65, 0x71, 0x4f, 0x62, 0x6a, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x1a, 0xf2, + 0x01, 0x0a, 0x15, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x20, 0x0a, 0x0c, 0x72, 0x65, 0x71, 0x5f, + 0x6f, 0x62, 0x6a, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, + 0x72, 0x65, 0x71, 0x4f, 0x62, 0x6a, 0x50, 0x61, 0x74, 0x68, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x72, + 0x72, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x07, 0x65, 0x72, + 0x72, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x65, 0x72, 0x72, 0x5f, 0x6d, 0x73, 0x67, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x72, 0x72, 0x4d, 0x73, 0x67, 0x12, 0x2d, + 0x0a, 0x13, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x6e, 0x73, + 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x64, 0x61, 0x74, + 0x61, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x6e, 0x73, 0x74, 0x55, 0x72, 0x69, 0x12, 0x54, 0x0a, + 0x0e, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x73, 0x18, + 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x53, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x44, 0x4d, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x53, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x52, 0x0d, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x4f, + 0x62, 0x6a, 0x73, 0x1a, 0xea, 0x03, 0x0a, 0x15, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x2c, 0x0a, + 0x12, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x5f, 0x70, + 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x73, 0x75, 0x70, 0x70, 0x6f, + 0x72, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x50, 0x61, 0x74, 0x68, 0x12, 0x3d, 0x0a, 0x06, 0x61, + 0x63, 0x63, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x75, 0x73, + 0x70, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x44, 0x4d, + 0x52, 0x65, 0x73, 0x70, 0x2e, 0x4f, 0x62, 0x6a, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x54, 0x79, + 0x70, 0x65, 0x52, 0x06, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x69, 0x73, + 0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x69, 0x73, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x49, 0x6e, + 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x5d, 0x0a, 0x12, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, + 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x18, 0x04, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, + 0x6f, 0x72, 0x74, 0x65, 0x64, 0x44, 0x4d, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x53, 0x75, 0x70, 0x70, + 0x6f, 0x72, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x52, 0x11, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x6d, + 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x12, 0x57, 0x0a, 0x10, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, + 0x65, 0x64, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x2c, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, + 0x65, 0x64, 0x44, 0x4d, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, + 0x65, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x0f, 0x73, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x57, + 0x0a, 0x10, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, + 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x44, 0x4d, 0x52, 0x65, 0x73, + 0x70, 0x2e, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, + 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x0f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x69, 0x76, 0x65, 0x72, + 0x67, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x0e, 0x64, 0x69, 0x76, 0x65, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x50, 0x61, 0x74, 0x68, 0x73, + 0x1a, 0x89, 0x02, 0x0a, 0x14, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x50, 0x61, + 0x72, 0x61, 0x6d, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x61, 0x72, + 0x61, 0x6d, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, + 0x61, 0x72, 0x61, 0x6d, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x3f, 0x0a, 0x06, 0x61, 0x63, 0x63, 0x65, + 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, + 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x44, 0x4d, 0x52, 0x65, 0x73, + 0x70, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x06, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x12, 0x45, 0x0a, 0x0a, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, + 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, + 0x44, 0x4d, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x4a, 0x0a, 0x0c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, + 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x44, 0x4d, 0x52, 0x65, 0x73, 0x70, 0x2e, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x0b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x1a, 0xd1, 0x01, 0x0a, + 0x16, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, + 0x64, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6d, 0x6d, 0x61, + 0x6e, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, + 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x69, 0x6e, + 0x70, 0x75, 0x74, 0x5f, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x0d, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x4e, 0x61, 0x6d, + 0x65, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x61, 0x72, 0x67, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x42, 0x0a, 0x0c, + 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, + 0x6f, 0x72, 0x74, 0x65, 0x64, 0x44, 0x4d, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x43, 0x6d, 0x64, 0x54, + 0x79, 0x70, 0x65, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x54, 0x79, 0x70, 0x65, + 0x1a, 0x52, 0x0a, 0x14, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x65, 0x76, + 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x72, 0x67, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x61, 0x72, 0x67, 0x4e, + 0x61, 0x6d, 0x65, 0x73, 0x22, 0x52, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x41, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x54, 0x79, 0x70, 0x65, 0x12, 0x13, 0x0a, 0x0f, 0x50, 0x41, 0x52, 0x41, 0x4d, + 0x5f, 0x52, 0x45, 0x41, 0x44, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, + 0x50, 0x41, 0x52, 0x41, 0x4d, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x5f, 0x57, 0x52, 0x49, 0x54, 0x45, + 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10, 0x50, 0x41, 0x52, 0x41, 0x4d, 0x5f, 0x57, 0x52, 0x49, 0x54, + 0x45, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x02, 0x22, 0x5d, 0x0a, 0x0d, 0x4f, 0x62, 0x6a, 0x41, + 0x63, 0x63, 0x65, 0x73, 0x73, 0x54, 0x79, 0x70, 0x65, 0x12, 0x11, 0x0a, 0x0d, 0x4f, 0x42, 0x4a, + 0x5f, 0x52, 0x45, 0x41, 0x44, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, + 0x4f, 0x42, 0x4a, 0x5f, 0x41, 0x44, 0x44, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x01, + 0x12, 0x10, 0x0a, 0x0c, 0x4f, 0x42, 0x4a, 0x5f, 0x41, 0x44, 0x44, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, + 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x4f, 0x42, 0x4a, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, + 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x03, 0x22, 0xe9, 0x01, 0x0a, 0x0e, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x41, + 0x52, 0x41, 0x4d, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x11, 0x0a, + 0x0d, 0x50, 0x41, 0x52, 0x41, 0x4d, 0x5f, 0x42, 0x41, 0x53, 0x45, 0x5f, 0x36, 0x34, 0x10, 0x01, + 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x41, 0x52, 0x41, 0x4d, 0x5f, 0x42, 0x4f, 0x4f, 0x4c, 0x45, 0x41, + 0x4e, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x50, 0x41, 0x52, 0x41, 0x4d, 0x5f, 0x44, 0x41, 0x54, + 0x45, 0x5f, 0x54, 0x49, 0x4d, 0x45, 0x10, 0x03, 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x41, 0x52, 0x41, + 0x4d, 0x5f, 0x44, 0x45, 0x43, 0x49, 0x4d, 0x41, 0x4c, 0x10, 0x04, 0x12, 0x14, 0x0a, 0x10, 0x50, + 0x41, 0x52, 0x41, 0x4d, 0x5f, 0x48, 0x45, 0x58, 0x5f, 0x42, 0x49, 0x4e, 0x41, 0x52, 0x59, 0x10, + 0x05, 0x12, 0x0d, 0x0a, 0x09, 0x50, 0x41, 0x52, 0x41, 0x4d, 0x5f, 0x49, 0x4e, 0x54, 0x10, 0x06, + 0x12, 0x0e, 0x0a, 0x0a, 0x50, 0x41, 0x52, 0x41, 0x4d, 0x5f, 0x4c, 0x4f, 0x4e, 0x47, 0x10, 0x07, + 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x41, 0x52, 0x41, 0x4d, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, + 0x10, 0x08, 0x12, 0x16, 0x0a, 0x12, 0x50, 0x41, 0x52, 0x41, 0x4d, 0x5f, 0x55, 0x4e, 0x53, 0x49, + 0x47, 0x4e, 0x45, 0x44, 0x5f, 0x49, 0x4e, 0x54, 0x10, 0x09, 0x12, 0x17, 0x0a, 0x13, 0x50, 0x41, + 0x52, 0x41, 0x4d, 0x5f, 0x55, 0x4e, 0x53, 0x49, 0x47, 0x4e, 0x45, 0x44, 0x5f, 0x4c, 0x4f, 0x4e, + 0x47, 0x10, 0x0a, 0x22, 0x63, 0x0a, 0x0f, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x43, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x14, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, + 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, + 0x12, 0x18, 0x0a, 0x14, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, + 0x5f, 0x41, 0x4c, 0x4c, 0x4f, 0x57, 0x45, 0x44, 0x10, 0x01, 0x12, 0x1c, 0x0a, 0x18, 0x56, 0x41, + 0x4c, 0x55, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, 0x5f, 0x57, 0x49, 0x4c, 0x4c, 0x5f, + 0x49, 0x47, 0x4e, 0x4f, 0x52, 0x45, 0x10, 0x02, 0x22, 0x37, 0x0a, 0x07, 0x43, 0x6d, 0x64, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x43, 0x4d, 0x44, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, + 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0c, 0x0a, 0x08, 0x43, 0x4d, 0x44, 0x5f, 0x53, 0x59, 0x4e, 0x43, + 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x43, 0x4d, 0x44, 0x5f, 0x41, 0x53, 0x59, 0x4e, 0x43, 0x10, + 0x02, 0x22, 0x55, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, + 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x62, 0x6a, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x62, 0x6a, 0x50, 0x61, 0x74, 0x68, 0x73, 0x12, 0x28, + 0x0a, 0x10, 0x66, 0x69, 0x72, 0x73, 0x74, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x5f, 0x6f, 0x6e, + 0x6c, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, + 0x65, 0x76, 0x65, 0x6c, 0x4f, 0x6e, 0x6c, 0x79, 0x22, 0xf6, 0x03, 0x0a, 0x10, 0x47, 0x65, 0x74, + 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x12, 0x53, 0x0a, + 0x10, 0x72, 0x65, 0x71, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, + 0x74, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x52, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x52, 0x0e, 0x72, 0x65, 0x71, 0x50, 0x61, 0x74, 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x73, 0x1a, 0xb3, 0x01, 0x0a, 0x13, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x50, 0x61, 0x74, 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, + 0x68, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x72, 0x72, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x07, 0x52, 0x07, 0x65, 0x72, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x17, 0x0a, 0x07, + 0x65, 0x72, 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, + 0x72, 0x72, 0x4d, 0x73, 0x67, 0x12, 0x41, 0x0a, 0x0a, 0x63, 0x75, 0x72, 0x72, 0x5f, 0x69, 0x6e, + 0x73, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x75, 0x73, 0x70, 0x2e, + 0x47, 0x65, 0x74, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x2e, 0x43, 0x75, 0x72, 0x72, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x09, 0x63, + 0x75, 0x72, 0x72, 0x49, 0x6e, 0x73, 0x74, 0x73, 0x1a, 0xd6, 0x01, 0x0a, 0x0c, 0x43, 0x75, 0x72, + 0x72, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x69, 0x6e, 0x73, + 0x74, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x5f, 0x70, 0x61, + 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, + 0x74, 0x69, 0x61, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x50, 0x61, 0x74, 0x68, 0x12, 0x53, 0x0a, + 0x0b, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x73, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x49, 0x6e, + 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x4b, 0x65, 0x79, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x4b, 0x65, + 0x79, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x4b, 0x65, 0x79, 0x73, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, + 0x01, 0x22, 0x6b, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12, 0x53, 0x0a, 0x26, 0x63, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x23, 0x63, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x65, + 0x0a, 0x18, 0x47, 0x65, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x12, 0x49, 0x0a, 0x21, 0x61, 0x67, + 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x53, 0x75, 0x70, 0x70, + 0x6f, 0x72, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xaf, 0x02, 0x0a, 0x03, 0x41, 0x64, 0x64, 0x12, 0x23, 0x0a, + 0x0d, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, + 0x61, 0x6c, 0x12, 0x36, 0x0a, 0x0b, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x5f, 0x6f, 0x62, 0x6a, + 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x41, 0x64, + 0x64, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x0a, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x73, 0x1a, 0x6d, 0x0a, 0x0c, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x62, + 0x6a, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x62, + 0x6a, 0x50, 0x61, 0x74, 0x68, 0x12, 0x42, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x5f, 0x73, + 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, + 0x75, 0x73, 0x70, 0x2e, 0x41, 0x64, 0x64, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x61, + 0x72, 0x61, 0x6d, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x0d, 0x70, 0x61, 0x72, 0x61, + 0x6d, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x1a, 0x5c, 0x0a, 0x12, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x12, + 0x14, 0x0a, 0x05, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x70, 0x61, 0x72, 0x61, 0x6d, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, + 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, + 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0xb5, 0x07, 0x0a, 0x07, 0x41, 0x64, 0x64, 0x52, + 0x65, 0x73, 0x70, 0x12, 0x50, 0x0a, 0x13, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6f, + 0x62, 0x6a, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x20, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x41, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x52, 0x11, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x52, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x73, 0x1a, 0xfb, 0x05, 0x0a, 0x13, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x25, 0x0a, + 0x0e, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x50, 0x61, 0x74, 0x68, 0x12, 0x51, 0x0a, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x75, 0x73, 0x70, 0x2e, + 0x41, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0a, 0x6f, 0x70, 0x65, + 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1a, 0xe9, 0x04, 0x0a, 0x0f, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x66, 0x0a, 0x0c, 0x6f, + 0x70, 0x65, 0x72, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x41, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x41, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x2e, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, + 0x6c, 0x75, 0x72, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x46, 0x61, 0x69, 0x6c, + 0x75, 0x72, 0x65, 0x12, 0x66, 0x0a, 0x0c, 0x6f, 0x70, 0x65, 0x72, 0x5f, 0x73, 0x75, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x75, 0x73, 0x70, 0x2e, + 0x41, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x48, 0x00, 0x52, 0x0b, + 0x6f, 0x70, 0x65, 0x72, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x1a, 0x46, 0x0a, 0x10, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x12, + 0x19, 0x0a, 0x08, 0x65, 0x72, 0x72, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x07, 0x52, 0x07, 0x65, 0x72, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x65, 0x72, + 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x72, 0x72, + 0x4d, 0x73, 0x67, 0x1a, 0xae, 0x02, 0x0a, 0x10, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x6e, 0x73, 0x74, + 0x61, 0x6e, 0x74, 0x69, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x10, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x74, 0x65, + 0x64, 0x50, 0x61, 0x74, 0x68, 0x12, 0x3a, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x5f, 0x65, + 0x72, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x75, 0x73, 0x70, 0x2e, + 0x41, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, + 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x09, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x45, 0x72, 0x72, + 0x73, 0x12, 0x72, 0x0a, 0x0b, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x73, + 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x51, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x41, 0x64, 0x64, + 0x52, 0x65, 0x73, 0x70, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x2e, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, + 0x4b, 0x65, 0x79, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x75, 0x6e, 0x69, 0x71, 0x75, + 0x65, 0x4b, 0x65, 0x79, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x4b, + 0x65, 0x79, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3a, 0x02, 0x38, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x1a, 0x5a, 0x0a, 0x0e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x12, 0x19, 0x0a, 0x08, 0x65, + 0x72, 0x72, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x07, 0x65, + 0x72, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x65, 0x72, 0x72, 0x5f, 0x6d, 0x73, + 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x72, 0x72, 0x4d, 0x73, 0x67, 0x22, + 0x4a, 0x0a, 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x6c, 0x6c, + 0x6f, 0x77, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0c, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x1b, + 0x0a, 0x09, 0x6f, 0x62, 0x6a, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x08, 0x6f, 0x62, 0x6a, 0x50, 0x61, 0x74, 0x68, 0x73, 0x22, 0xbe, 0x06, 0x0a, 0x0a, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x53, 0x0a, 0x13, 0x64, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, + 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x11, 0x64, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x1a, + 0xe6, 0x04, 0x0a, 0x13, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, + 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0d, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x12, 0x54, + 0x0a, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0a, 0x6f, 0x70, 0x65, 0x72, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x1a, 0xd1, 0x03, 0x0a, 0x0f, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x69, 0x0a, 0x0c, 0x6f, 0x70, 0x65, 0x72, + 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x44, + 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x2e, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, + 0x6c, 0x75, 0x72, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x46, 0x61, 0x69, 0x6c, + 0x75, 0x72, 0x65, 0x12, 0x69, 0x0a, 0x0c, 0x6f, 0x70, 0x65, 0x72, 0x5f, 0x73, 0x75, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x75, 0x73, 0x70, 0x2e, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x48, + 0x00, 0x52, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x1a, 0x46, + 0x0a, 0x10, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, + 0x72, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x72, 0x72, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x07, 0x52, 0x07, 0x65, 0x72, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x17, 0x0a, + 0x07, 0x65, 0x72, 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x65, 0x72, 0x72, 0x4d, 0x73, 0x67, 0x1a, 0x90, 0x01, 0x0a, 0x10, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x61, + 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x0d, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, + 0x68, 0x73, 0x12, 0x55, 0x0a, 0x14, 0x75, 0x6e, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, + 0x5f, 0x70, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x72, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x23, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x2e, 0x55, 0x6e, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x12, 0x75, 0x6e, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, + 0x64, 0x50, 0x61, 0x74, 0x68, 0x45, 0x72, 0x72, 0x73, 0x42, 0x0d, 0x0a, 0x0b, 0x6f, 0x70, 0x65, + 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1a, 0x72, 0x0a, 0x13, 0x55, 0x6e, 0x61, 0x66, + 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, + 0x27, 0x0a, 0x0f, 0x75, 0x6e, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x61, + 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x75, 0x6e, 0x61, 0x66, 0x66, 0x65, + 0x63, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x72, 0x72, 0x5f, + 0x63, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x07, 0x65, 0x72, 0x72, 0x43, + 0x6f, 0x64, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x65, 0x72, 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x72, 0x72, 0x4d, 0x73, 0x67, 0x22, 0xaf, 0x02, 0x0a, + 0x03, 0x53, 0x65, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x70, 0x61, + 0x72, 0x74, 0x69, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x61, 0x6c, 0x6c, + 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x36, 0x0a, 0x0b, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x5f, 0x6f, 0x62, 0x6a, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, + 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x53, 0x65, 0x74, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4f, 0x62, 0x6a, + 0x73, 0x1a, 0x6d, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, + 0x74, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x62, 0x6a, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x62, 0x6a, 0x50, 0x61, 0x74, 0x68, 0x12, 0x42, 0x0a, 0x0e, + 0x70, 0x61, 0x72, 0x61, 0x6d, 0x5f, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x53, 0x65, 0x74, 0x2e, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, + 0x67, 0x52, 0x0d, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, + 0x1a, 0x5c, 0x0a, 0x12, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x53, + 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x12, 0x14, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0xde, + 0x09, 0x0a, 0x07, 0x53, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x50, 0x0a, 0x13, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x53, 0x65, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x11, 0x75, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x1a, 0x8e, 0x05, 0x0a, + 0x13, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, + 0x64, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x12, 0x51, 0x0a, 0x0b, 0x6f, + 0x70, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x30, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x52, 0x0a, 0x6f, 0x70, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1a, 0xfc, + 0x03, 0x0a, 0x0f, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x12, 0x66, 0x0a, 0x0c, 0x6f, 0x70, 0x65, 0x72, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, + 0x72, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x53, + 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x4f, 0x62, + 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x6f, + 0x70, 0x65, 0x72, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x12, 0x66, 0x0a, 0x0c, 0x6f, 0x70, + 0x65, 0x72, 0x5f, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x41, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x75, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x53, 0x75, 0x63, 0x63, 0x65, + 0x73, 0x73, 0x1a, 0x9f, 0x01, 0x0a, 0x10, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x72, 0x72, 0x5f, 0x63, + 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x07, 0x52, 0x07, 0x65, 0x72, 0x72, 0x43, 0x6f, + 0x64, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x65, 0x72, 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x72, 0x72, 0x4d, 0x73, 0x67, 0x12, 0x57, 0x0a, 0x15, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x5f, 0x66, 0x61, 0x69, 0x6c, + 0x75, 0x72, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x75, 0x73, 0x70, + 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, + 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, + 0x13, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x73, 0x74, 0x46, 0x61, 0x69, 0x6c, + 0x75, 0x72, 0x65, 0x73, 0x1a, 0x68, 0x0a, 0x10, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x12, 0x54, 0x0a, 0x14, 0x75, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x53, 0x65, 0x74, + 0x52, 0x65, 0x73, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x73, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x12, 0x75, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x64, 0x49, 0x6e, 0x73, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x0d, + 0x0a, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1a, 0x79, 0x0a, + 0x16, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, + 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x66, 0x66, 0x65, 0x63, + 0x74, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x12, 0x3a, 0x0a, 0x0a, + 0x70, 0x61, 0x72, 0x61, 0x6d, 0x5f, 0x65, 0x72, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x1b, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x50, + 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x09, 0x70, + 0x61, 0x72, 0x61, 0x6d, 0x45, 0x72, 0x72, 0x73, 0x1a, 0x98, 0x02, 0x0a, 0x15, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x70, + 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x61, 0x66, 0x66, 0x65, 0x63, + 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x12, 0x3a, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x5f, 0x65, 0x72, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x75, 0x73, + 0x70, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, + 0x74, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x09, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x45, + 0x72, 0x72, 0x73, 0x12, 0x5c, 0x0a, 0x0e, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x70, + 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x75, 0x73, + 0x70, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x64, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0d, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, + 0x73, 0x1a, 0x40, 0x0a, 0x12, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x1a, 0x5a, 0x0a, 0x0e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x12, 0x19, 0x0a, 0x08, 0x65, + 0x72, 0x72, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x07, 0x65, + 0x72, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x65, 0x72, 0x72, 0x5f, 0x6d, 0x73, + 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x72, 0x72, 0x4d, 0x73, 0x67, 0x22, + 0xdb, 0x01, 0x0a, 0x07, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, + 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, + 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, + 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, + 0x61, 0x6e, 0x64, 0x4b, 0x65, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x65, 0x6e, 0x64, 0x5f, 0x72, + 0x65, 0x73, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x73, 0x65, 0x6e, 0x64, 0x52, + 0x65, 0x73, 0x70, 0x12, 0x3a, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x61, 0x72, 0x67, + 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x65, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x73, 0x1a, + 0x3c, 0x0a, 0x0e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xee, 0x04, + 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x4d, 0x0a, + 0x11, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x10, 0x6f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x1a, 0x8f, 0x04, 0x0a, + 0x0f, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x12, 0x29, 0x0a, 0x10, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6d, + 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x22, 0x0a, 0x0c, 0x72, + 0x65, 0x71, 0x5f, 0x6f, 0x62, 0x6a, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x48, 0x00, 0x52, 0x0a, 0x72, 0x65, 0x71, 0x4f, 0x62, 0x6a, 0x50, 0x61, 0x74, 0x68, 0x12, + 0x55, 0x0a, 0x0f, 0x72, 0x65, 0x71, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x61, 0x72, + 0x67, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x41, 0x72, 0x67, 0x73, 0x48, 0x00, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x4f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x41, 0x72, 0x67, 0x73, 0x12, 0x52, 0x0a, 0x0b, 0x63, 0x6d, 0x64, 0x5f, 0x66, 0x61, + 0x69, 0x6c, 0x75, 0x72, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x75, 0x73, + 0x70, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x4f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x43, 0x6f, + 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x48, 0x00, 0x52, 0x0a, + 0x63, 0x6d, 0x64, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x1a, 0xa9, 0x01, 0x0a, 0x0a, 0x4f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x73, 0x12, 0x5c, 0x0a, 0x0b, 0x6f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x5f, 0x61, 0x72, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, + 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x73, 0x2e, 0x4f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x41, 0x72, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x6f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x4f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x41, 0x72, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a, 0x0e, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, + 0x64, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x72, 0x72, 0x5f, + 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x07, 0x52, 0x07, 0x65, 0x72, 0x72, 0x43, + 0x6f, 0x64, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x65, 0x72, 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x72, 0x72, 0x4d, 0x73, 0x67, 0x42, 0x10, 0x0a, 0x0e, + 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x22, 0x90, + 0x0d, 0x0a, 0x06, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x75, 0x62, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x65, 0x6e, 0x64, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x73, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x70, 0x12, + 0x29, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, + 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x2e, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x48, 0x00, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x3c, 0x0a, 0x0c, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x17, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x2e, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x3f, 0x0a, 0x0c, 0x6f, 0x62, 0x6a, 0x5f, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x2e, 0x4f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x62, + 0x6a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3f, 0x0a, 0x0c, 0x6f, 0x62, 0x6a, + 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x2e, 0x4f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0b, 0x6f, + 0x62, 0x6a, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x44, 0x0a, 0x0d, 0x6f, 0x70, + 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1d, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x2e, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, + 0x48, 0x00, 0x52, 0x0c, 0x6f, 0x70, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, + 0x12, 0x3e, 0x0a, 0x0c, 0x6f, 0x6e, 0x5f, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x5f, 0x72, 0x65, 0x71, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4e, 0x6f, 0x74, + 0x69, 0x66, 0x79, 0x2e, 0x4f, 0x6e, 0x42, 0x6f, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x42, 0x6f, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, + 0x1a, 0xb3, 0x01, 0x0a, 0x05, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x62, + 0x6a, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x62, + 0x6a, 0x50, 0x61, 0x74, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x65, 0x76, 0x65, 0x6e, 0x74, + 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4e, 0x6f, 0x74, 0x69, 0x66, + 0x79, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x50, + 0x61, 0x72, 0x61, 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x4d, 0x0a, 0x0b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x43, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x5f, 0x70, + 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x50, 0x61, 0x74, 0x68, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x5f, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x1a, 0xb7, 0x01, 0x0a, 0x0e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x62, 0x6a, 0x5f, + 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x62, 0x6a, 0x50, + 0x61, 0x74, 0x68, 0x12, 0x4b, 0x0a, 0x0b, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x5f, 0x6b, 0x65, + 0x79, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x75, 0x73, 0x70, 0x2e, 0x4e, + 0x6f, 0x74, 0x69, 0x66, 0x79, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x4b, 0x65, 0x79, 0x73, + 0x1a, 0x3d, 0x0a, 0x0f, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, + 0x2b, 0x0a, 0x0e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x62, 0x6a, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x62, 0x6a, 0x50, 0x61, 0x74, 0x68, 0x1a, 0x98, 0x04, 0x0a, + 0x11, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, + 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x62, 0x6a, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x62, 0x6a, 0x50, 0x61, 0x74, 0x68, 0x12, 0x21, 0x0a, + 0x0c, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x5f, 0x6b, 0x65, 0x79, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x4b, 0x65, + 0x79, 0x12, 0x52, 0x0a, 0x0f, 0x72, 0x65, 0x71, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, + 0x61, 0x72, 0x67, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x75, 0x73, 0x70, + 0x2e, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x41, 0x72, 0x67, 0x73, 0x48, 0x00, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x4f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x41, 0x72, 0x67, 0x73, 0x12, 0x4f, 0x0a, 0x0b, 0x63, 0x6d, 0x64, 0x5f, 0x66, 0x61, 0x69, + 0x6c, 0x75, 0x72, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x75, 0x73, 0x70, + 0x2e, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, + 0x64, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x63, 0x6d, 0x64, 0x46, + 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x1a, 0xa6, 0x01, 0x0a, 0x0a, 0x4f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x41, 0x72, 0x67, 0x73, 0x12, 0x59, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, + 0x61, 0x72, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x75, 0x73, 0x70, + 0x2e, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x41, 0x72, 0x67, 0x73, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x73, + 0x1a, 0x3d, 0x0a, 0x0f, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, + 0x44, 0x0a, 0x0e, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, + 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x72, 0x72, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x07, 0x52, 0x07, 0x65, 0x72, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x17, 0x0a, 0x07, + 0x65, 0x72, 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, + 0x72, 0x72, 0x4d, 0x73, 0x67, 0x42, 0x10, 0x0a, 0x0e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x1a, 0xb7, 0x01, 0x0a, 0x0e, 0x4f, 0x6e, 0x42, 0x6f, + 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x75, + 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x75, 0x69, 0x12, 0x23, 0x0a, 0x0d, + 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x43, 0x6c, 0x61, 0x73, + 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x5f, 0x6e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, + 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x49, 0x0a, 0x21, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x5f, + 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, + 0x6f, 0x6c, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x1e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x73, 0x42, 0x0e, 0x0a, 0x0c, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0x35, 0x0a, 0x0a, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x52, 0x65, 0x73, 0x70, 0x12, + 0x27, 0x0a, 0x0f, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x42, 0x0b, 0x5a, 0x09, 0x2e, 0x2f, 0x75, 0x73, + 0x70, 0x2d, 0x6d, 0x73, 0x67, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_usp_msg_1_2_proto_rawDescOnce sync.Once + file_usp_msg_1_2_proto_rawDescData = file_usp_msg_1_2_proto_rawDesc +) + +func file_usp_msg_1_2_proto_rawDescGZIP() []byte { + file_usp_msg_1_2_proto_rawDescOnce.Do(func() { + file_usp_msg_1_2_proto_rawDescData = protoimpl.X.CompressGZIP(file_usp_msg_1_2_proto_rawDescData) + }) + return file_usp_msg_1_2_proto_rawDescData +} + +var file_usp_msg_1_2_proto_enumTypes = make([]protoimpl.EnumInfo, 6) +var file_usp_msg_1_2_proto_msgTypes = make([]protoimpl.MessageInfo, 75) +var file_usp_msg_1_2_proto_goTypes = []interface{}{ + (Header_MsgType)(0), // 0: usp.Header.MsgType + (GetSupportedDMResp_ParamAccessType)(0), // 1: usp.GetSupportedDMResp.ParamAccessType + (GetSupportedDMResp_ObjAccessType)(0), // 2: usp.GetSupportedDMResp.ObjAccessType + (GetSupportedDMResp_ParamValueType)(0), // 3: usp.GetSupportedDMResp.ParamValueType + (GetSupportedDMResp_ValueChangeType)(0), // 4: usp.GetSupportedDMResp.ValueChangeType + (GetSupportedDMResp_CmdType)(0), // 5: usp.GetSupportedDMResp.CmdType + (*Msg)(nil), // 6: usp.Msg + (*Header)(nil), // 7: usp.Header + (*Body)(nil), // 8: usp.Body + (*Request)(nil), // 9: usp.Request + (*Response)(nil), // 10: usp.Response + (*Error)(nil), // 11: usp.Error + (*Get)(nil), // 12: usp.Get + (*GetResp)(nil), // 13: usp.GetResp + (*GetSupportedDM)(nil), // 14: usp.GetSupportedDM + (*GetSupportedDMResp)(nil), // 15: usp.GetSupportedDMResp + (*GetInstances)(nil), // 16: usp.GetInstances + (*GetInstancesResp)(nil), // 17: usp.GetInstancesResp + (*GetSupportedProtocol)(nil), // 18: usp.GetSupportedProtocol + (*GetSupportedProtocolResp)(nil), // 19: usp.GetSupportedProtocolResp + (*Add)(nil), // 20: usp.Add + (*AddResp)(nil), // 21: usp.AddResp + (*Delete)(nil), // 22: usp.Delete + (*DeleteResp)(nil), // 23: usp.DeleteResp + (*Set)(nil), // 24: usp.Set + (*SetResp)(nil), // 25: usp.SetResp + (*Operate)(nil), // 26: usp.Operate + (*OperateResp)(nil), // 27: usp.OperateResp + (*Notify)(nil), // 28: usp.Notify + (*NotifyResp)(nil), // 29: usp.NotifyResp + (*Error_ParamError)(nil), // 30: usp.Error.ParamError + (*GetResp_RequestedPathResult)(nil), // 31: usp.GetResp.RequestedPathResult + (*GetResp_ResolvedPathResult)(nil), // 32: usp.GetResp.ResolvedPathResult + nil, // 33: usp.GetResp.ResolvedPathResult.ResultParamsEntry + (*GetSupportedDMResp_RequestedObjectResult)(nil), // 34: usp.GetSupportedDMResp.RequestedObjectResult + (*GetSupportedDMResp_SupportedObjectResult)(nil), // 35: usp.GetSupportedDMResp.SupportedObjectResult + (*GetSupportedDMResp_SupportedParamResult)(nil), // 36: usp.GetSupportedDMResp.SupportedParamResult + (*GetSupportedDMResp_SupportedCommandResult)(nil), // 37: usp.GetSupportedDMResp.SupportedCommandResult + (*GetSupportedDMResp_SupportedEventResult)(nil), // 38: usp.GetSupportedDMResp.SupportedEventResult + (*GetInstancesResp_RequestedPathResult)(nil), // 39: usp.GetInstancesResp.RequestedPathResult + (*GetInstancesResp_CurrInstance)(nil), // 40: usp.GetInstancesResp.CurrInstance + nil, // 41: usp.GetInstancesResp.CurrInstance.UniqueKeysEntry + (*Add_CreateObject)(nil), // 42: usp.Add.CreateObject + (*Add_CreateParamSetting)(nil), // 43: usp.Add.CreateParamSetting + (*AddResp_CreatedObjectResult)(nil), // 44: usp.AddResp.CreatedObjectResult + (*AddResp_ParameterError)(nil), // 45: usp.AddResp.ParameterError + (*AddResp_CreatedObjectResult_OperationStatus)(nil), // 46: usp.AddResp.CreatedObjectResult.OperationStatus + (*AddResp_CreatedObjectResult_OperationStatus_OperationFailure)(nil), // 47: usp.AddResp.CreatedObjectResult.OperationStatus.OperationFailure + (*AddResp_CreatedObjectResult_OperationStatus_OperationSuccess)(nil), // 48: usp.AddResp.CreatedObjectResult.OperationStatus.OperationSuccess + nil, // 49: usp.AddResp.CreatedObjectResult.OperationStatus.OperationSuccess.UniqueKeysEntry + (*DeleteResp_DeletedObjectResult)(nil), // 50: usp.DeleteResp.DeletedObjectResult + (*DeleteResp_UnaffectedPathError)(nil), // 51: usp.DeleteResp.UnaffectedPathError + (*DeleteResp_DeletedObjectResult_OperationStatus)(nil), // 52: usp.DeleteResp.DeletedObjectResult.OperationStatus + (*DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure)(nil), // 53: usp.DeleteResp.DeletedObjectResult.OperationStatus.OperationFailure + (*DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess)(nil), // 54: usp.DeleteResp.DeletedObjectResult.OperationStatus.OperationSuccess + (*Set_UpdateObject)(nil), // 55: usp.Set.UpdateObject + (*Set_UpdateParamSetting)(nil), // 56: usp.Set.UpdateParamSetting + (*SetResp_UpdatedObjectResult)(nil), // 57: usp.SetResp.UpdatedObjectResult + (*SetResp_UpdatedInstanceFailure)(nil), // 58: usp.SetResp.UpdatedInstanceFailure + (*SetResp_UpdatedInstanceResult)(nil), // 59: usp.SetResp.UpdatedInstanceResult + (*SetResp_ParameterError)(nil), // 60: usp.SetResp.ParameterError + (*SetResp_UpdatedObjectResult_OperationStatus)(nil), // 61: usp.SetResp.UpdatedObjectResult.OperationStatus + (*SetResp_UpdatedObjectResult_OperationStatus_OperationFailure)(nil), // 62: usp.SetResp.UpdatedObjectResult.OperationStatus.OperationFailure + (*SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess)(nil), // 63: usp.SetResp.UpdatedObjectResult.OperationStatus.OperationSuccess + nil, // 64: usp.SetResp.UpdatedInstanceResult.UpdatedParamsEntry + nil, // 65: usp.Operate.InputArgsEntry + (*OperateResp_OperationResult)(nil), // 66: usp.OperateResp.OperationResult + (*OperateResp_OperationResult_OutputArgs)(nil), // 67: usp.OperateResp.OperationResult.OutputArgs + (*OperateResp_OperationResult_CommandFailure)(nil), // 68: usp.OperateResp.OperationResult.CommandFailure + nil, // 69: usp.OperateResp.OperationResult.OutputArgs.OutputArgsEntry + (*Notify_Event)(nil), // 70: usp.Notify.Event + (*Notify_ValueChange)(nil), // 71: usp.Notify.ValueChange + (*Notify_ObjectCreation)(nil), // 72: usp.Notify.ObjectCreation + (*Notify_ObjectDeletion)(nil), // 73: usp.Notify.ObjectDeletion + (*Notify_OperationComplete)(nil), // 74: usp.Notify.OperationComplete + (*Notify_OnBoardRequest)(nil), // 75: usp.Notify.OnBoardRequest + nil, // 76: usp.Notify.Event.ParamsEntry + nil, // 77: usp.Notify.ObjectCreation.UniqueKeysEntry + (*Notify_OperationComplete_OutputArgs)(nil), // 78: usp.Notify.OperationComplete.OutputArgs + (*Notify_OperationComplete_CommandFailure)(nil), // 79: usp.Notify.OperationComplete.CommandFailure + nil, // 80: usp.Notify.OperationComplete.OutputArgs.OutputArgsEntry +} +var file_usp_msg_1_2_proto_depIdxs = []int32{ + 7, // 0: usp.Msg.header:type_name -> usp.Header + 8, // 1: usp.Msg.body:type_name -> usp.Body + 0, // 2: usp.Header.msg_type:type_name -> usp.Header.MsgType + 9, // 3: usp.Body.request:type_name -> usp.Request + 10, // 4: usp.Body.response:type_name -> usp.Response + 11, // 5: usp.Body.error:type_name -> usp.Error + 12, // 6: usp.Request.get:type_name -> usp.Get + 14, // 7: usp.Request.get_supported_dm:type_name -> usp.GetSupportedDM + 16, // 8: usp.Request.get_instances:type_name -> usp.GetInstances + 24, // 9: usp.Request.set:type_name -> usp.Set + 20, // 10: usp.Request.add:type_name -> usp.Add + 22, // 11: usp.Request.delete:type_name -> usp.Delete + 26, // 12: usp.Request.operate:type_name -> usp.Operate + 28, // 13: usp.Request.notify:type_name -> usp.Notify + 18, // 14: usp.Request.get_supported_protocol:type_name -> usp.GetSupportedProtocol + 13, // 15: usp.Response.get_resp:type_name -> usp.GetResp + 15, // 16: usp.Response.get_supported_dm_resp:type_name -> usp.GetSupportedDMResp + 17, // 17: usp.Response.get_instances_resp:type_name -> usp.GetInstancesResp + 25, // 18: usp.Response.set_resp:type_name -> usp.SetResp + 21, // 19: usp.Response.add_resp:type_name -> usp.AddResp + 23, // 20: usp.Response.delete_resp:type_name -> usp.DeleteResp + 27, // 21: usp.Response.operate_resp:type_name -> usp.OperateResp + 29, // 22: usp.Response.notify_resp:type_name -> usp.NotifyResp + 19, // 23: usp.Response.get_supported_protocol_resp:type_name -> usp.GetSupportedProtocolResp + 30, // 24: usp.Error.param_errs:type_name -> usp.Error.ParamError + 31, // 25: usp.GetResp.req_path_results:type_name -> usp.GetResp.RequestedPathResult + 34, // 26: usp.GetSupportedDMResp.req_obj_results:type_name -> usp.GetSupportedDMResp.RequestedObjectResult + 39, // 27: usp.GetInstancesResp.req_path_results:type_name -> usp.GetInstancesResp.RequestedPathResult + 42, // 28: usp.Add.create_objs:type_name -> usp.Add.CreateObject + 44, // 29: usp.AddResp.created_obj_results:type_name -> usp.AddResp.CreatedObjectResult + 50, // 30: usp.DeleteResp.deleted_obj_results:type_name -> usp.DeleteResp.DeletedObjectResult + 55, // 31: usp.Set.update_objs:type_name -> usp.Set.UpdateObject + 57, // 32: usp.SetResp.updated_obj_results:type_name -> usp.SetResp.UpdatedObjectResult + 65, // 33: usp.Operate.input_args:type_name -> usp.Operate.InputArgsEntry + 66, // 34: usp.OperateResp.operation_results:type_name -> usp.OperateResp.OperationResult + 70, // 35: usp.Notify.event:type_name -> usp.Notify.Event + 71, // 36: usp.Notify.value_change:type_name -> usp.Notify.ValueChange + 72, // 37: usp.Notify.obj_creation:type_name -> usp.Notify.ObjectCreation + 73, // 38: usp.Notify.obj_deletion:type_name -> usp.Notify.ObjectDeletion + 74, // 39: usp.Notify.oper_complete:type_name -> usp.Notify.OperationComplete + 75, // 40: usp.Notify.on_board_req:type_name -> usp.Notify.OnBoardRequest + 32, // 41: usp.GetResp.RequestedPathResult.resolved_path_results:type_name -> usp.GetResp.ResolvedPathResult + 33, // 42: usp.GetResp.ResolvedPathResult.result_params:type_name -> usp.GetResp.ResolvedPathResult.ResultParamsEntry + 35, // 43: usp.GetSupportedDMResp.RequestedObjectResult.supported_objs:type_name -> usp.GetSupportedDMResp.SupportedObjectResult + 2, // 44: usp.GetSupportedDMResp.SupportedObjectResult.access:type_name -> usp.GetSupportedDMResp.ObjAccessType + 37, // 45: usp.GetSupportedDMResp.SupportedObjectResult.supported_commands:type_name -> usp.GetSupportedDMResp.SupportedCommandResult + 38, // 46: usp.GetSupportedDMResp.SupportedObjectResult.supported_events:type_name -> usp.GetSupportedDMResp.SupportedEventResult + 36, // 47: usp.GetSupportedDMResp.SupportedObjectResult.supported_params:type_name -> usp.GetSupportedDMResp.SupportedParamResult + 1, // 48: usp.GetSupportedDMResp.SupportedParamResult.access:type_name -> usp.GetSupportedDMResp.ParamAccessType + 3, // 49: usp.GetSupportedDMResp.SupportedParamResult.value_type:type_name -> usp.GetSupportedDMResp.ParamValueType + 4, // 50: usp.GetSupportedDMResp.SupportedParamResult.value_change:type_name -> usp.GetSupportedDMResp.ValueChangeType + 5, // 51: usp.GetSupportedDMResp.SupportedCommandResult.command_type:type_name -> usp.GetSupportedDMResp.CmdType + 40, // 52: usp.GetInstancesResp.RequestedPathResult.curr_insts:type_name -> usp.GetInstancesResp.CurrInstance + 41, // 53: usp.GetInstancesResp.CurrInstance.unique_keys:type_name -> usp.GetInstancesResp.CurrInstance.UniqueKeysEntry + 43, // 54: usp.Add.CreateObject.param_settings:type_name -> usp.Add.CreateParamSetting + 46, // 55: usp.AddResp.CreatedObjectResult.oper_status:type_name -> usp.AddResp.CreatedObjectResult.OperationStatus + 47, // 56: usp.AddResp.CreatedObjectResult.OperationStatus.oper_failure:type_name -> usp.AddResp.CreatedObjectResult.OperationStatus.OperationFailure + 48, // 57: usp.AddResp.CreatedObjectResult.OperationStatus.oper_success:type_name -> usp.AddResp.CreatedObjectResult.OperationStatus.OperationSuccess + 45, // 58: usp.AddResp.CreatedObjectResult.OperationStatus.OperationSuccess.param_errs:type_name -> usp.AddResp.ParameterError + 49, // 59: usp.AddResp.CreatedObjectResult.OperationStatus.OperationSuccess.unique_keys:type_name -> usp.AddResp.CreatedObjectResult.OperationStatus.OperationSuccess.UniqueKeysEntry + 52, // 60: usp.DeleteResp.DeletedObjectResult.oper_status:type_name -> usp.DeleteResp.DeletedObjectResult.OperationStatus + 53, // 61: usp.DeleteResp.DeletedObjectResult.OperationStatus.oper_failure:type_name -> usp.DeleteResp.DeletedObjectResult.OperationStatus.OperationFailure + 54, // 62: usp.DeleteResp.DeletedObjectResult.OperationStatus.oper_success:type_name -> usp.DeleteResp.DeletedObjectResult.OperationStatus.OperationSuccess + 51, // 63: usp.DeleteResp.DeletedObjectResult.OperationStatus.OperationSuccess.unaffected_path_errs:type_name -> usp.DeleteResp.UnaffectedPathError + 56, // 64: usp.Set.UpdateObject.param_settings:type_name -> usp.Set.UpdateParamSetting + 61, // 65: usp.SetResp.UpdatedObjectResult.oper_status:type_name -> usp.SetResp.UpdatedObjectResult.OperationStatus + 60, // 66: usp.SetResp.UpdatedInstanceFailure.param_errs:type_name -> usp.SetResp.ParameterError + 60, // 67: usp.SetResp.UpdatedInstanceResult.param_errs:type_name -> usp.SetResp.ParameterError + 64, // 68: usp.SetResp.UpdatedInstanceResult.updated_params:type_name -> usp.SetResp.UpdatedInstanceResult.UpdatedParamsEntry + 62, // 69: usp.SetResp.UpdatedObjectResult.OperationStatus.oper_failure:type_name -> usp.SetResp.UpdatedObjectResult.OperationStatus.OperationFailure + 63, // 70: usp.SetResp.UpdatedObjectResult.OperationStatus.oper_success:type_name -> usp.SetResp.UpdatedObjectResult.OperationStatus.OperationSuccess + 58, // 71: usp.SetResp.UpdatedObjectResult.OperationStatus.OperationFailure.updated_inst_failures:type_name -> usp.SetResp.UpdatedInstanceFailure + 59, // 72: usp.SetResp.UpdatedObjectResult.OperationStatus.OperationSuccess.updated_inst_results:type_name -> usp.SetResp.UpdatedInstanceResult + 67, // 73: usp.OperateResp.OperationResult.req_output_args:type_name -> usp.OperateResp.OperationResult.OutputArgs + 68, // 74: usp.OperateResp.OperationResult.cmd_failure:type_name -> usp.OperateResp.OperationResult.CommandFailure + 69, // 75: usp.OperateResp.OperationResult.OutputArgs.output_args:type_name -> usp.OperateResp.OperationResult.OutputArgs.OutputArgsEntry + 76, // 76: usp.Notify.Event.params:type_name -> usp.Notify.Event.ParamsEntry + 77, // 77: usp.Notify.ObjectCreation.unique_keys:type_name -> usp.Notify.ObjectCreation.UniqueKeysEntry + 78, // 78: usp.Notify.OperationComplete.req_output_args:type_name -> usp.Notify.OperationComplete.OutputArgs + 79, // 79: usp.Notify.OperationComplete.cmd_failure:type_name -> usp.Notify.OperationComplete.CommandFailure + 80, // 80: usp.Notify.OperationComplete.OutputArgs.output_args:type_name -> usp.Notify.OperationComplete.OutputArgs.OutputArgsEntry + 81, // [81:81] is the sub-list for method output_type + 81, // [81:81] is the sub-list for method input_type + 81, // [81:81] is the sub-list for extension type_name + 81, // [81:81] is the sub-list for extension extendee + 0, // [0:81] is the sub-list for field type_name +} + +func init() { file_usp_msg_1_2_proto_init() } +func file_usp_msg_1_2_proto_init() { + if File_usp_msg_1_2_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_usp_msg_1_2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Msg); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Header); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Body); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Request); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Response); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Error); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Get); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSupportedDM); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSupportedDMResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetInstances); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetInstancesResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSupportedProtocol); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSupportedProtocolResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Add); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Delete); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Set); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Operate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OperateResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Notify); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NotifyResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Error_ParamError); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetResp_RequestedPathResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetResp_ResolvedPathResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSupportedDMResp_RequestedObjectResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSupportedDMResp_SupportedObjectResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSupportedDMResp_SupportedParamResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSupportedDMResp_SupportedCommandResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSupportedDMResp_SupportedEventResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetInstancesResp_RequestedPathResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetInstancesResp_CurrInstance); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Add_CreateObject); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Add_CreateParamSetting); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddResp_CreatedObjectResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddResp_ParameterError); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddResp_CreatedObjectResult_OperationStatus); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddResp_CreatedObjectResult_OperationStatus_OperationFailure); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddResp_CreatedObjectResult_OperationStatus_OperationSuccess); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteResp_DeletedObjectResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteResp_UnaffectedPathError); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteResp_DeletedObjectResult_OperationStatus); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteResp_DeletedObjectResult_OperationStatus_OperationFailure); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteResp_DeletedObjectResult_OperationStatus_OperationSuccess); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Set_UpdateObject); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Set_UpdateParamSetting); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetResp_UpdatedObjectResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetResp_UpdatedInstanceFailure); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetResp_UpdatedInstanceResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetResp_ParameterError); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetResp_UpdatedObjectResult_OperationStatus); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetResp_UpdatedObjectResult_OperationStatus_OperationFailure); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetResp_UpdatedObjectResult_OperationStatus_OperationSuccess); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OperateResp_OperationResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OperateResp_OperationResult_OutputArgs); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OperateResp_OperationResult_CommandFailure); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Notify_Event); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Notify_ValueChange); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Notify_ObjectCreation); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Notify_ObjectDeletion); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Notify_OperationComplete); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Notify_OnBoardRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Notify_OperationComplete_OutputArgs); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_msg_1_2_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Notify_OperationComplete_CommandFailure); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_usp_msg_1_2_proto_msgTypes[2].OneofWrappers = []interface{}{ + (*Body_Request)(nil), + (*Body_Response)(nil), + (*Body_Error)(nil), + } + file_usp_msg_1_2_proto_msgTypes[3].OneofWrappers = []interface{}{ + (*Request_Get)(nil), + (*Request_GetSupportedDm)(nil), + (*Request_GetInstances)(nil), + (*Request_Set)(nil), + (*Request_Add)(nil), + (*Request_Delete)(nil), + (*Request_Operate)(nil), + (*Request_Notify)(nil), + (*Request_GetSupportedProtocol)(nil), + } + file_usp_msg_1_2_proto_msgTypes[4].OneofWrappers = []interface{}{ + (*Response_GetResp)(nil), + (*Response_GetSupportedDmResp)(nil), + (*Response_GetInstancesResp)(nil), + (*Response_SetResp)(nil), + (*Response_AddResp)(nil), + (*Response_DeleteResp)(nil), + (*Response_OperateResp)(nil), + (*Response_NotifyResp)(nil), + (*Response_GetSupportedProtocolResp)(nil), + } + file_usp_msg_1_2_proto_msgTypes[22].OneofWrappers = []interface{}{ + (*Notify_Event_)(nil), + (*Notify_ValueChange_)(nil), + (*Notify_ObjCreation)(nil), + (*Notify_ObjDeletion)(nil), + (*Notify_OperComplete)(nil), + (*Notify_OnBoardReq)(nil), + } + file_usp_msg_1_2_proto_msgTypes[40].OneofWrappers = []interface{}{ + (*AddResp_CreatedObjectResult_OperationStatus_OperFailure)(nil), + (*AddResp_CreatedObjectResult_OperationStatus_OperSuccess)(nil), + } + file_usp_msg_1_2_proto_msgTypes[46].OneofWrappers = []interface{}{ + (*DeleteResp_DeletedObjectResult_OperationStatus_OperFailure)(nil), + (*DeleteResp_DeletedObjectResult_OperationStatus_OperSuccess)(nil), + } + file_usp_msg_1_2_proto_msgTypes[55].OneofWrappers = []interface{}{ + (*SetResp_UpdatedObjectResult_OperationStatus_OperFailure)(nil), + (*SetResp_UpdatedObjectResult_OperationStatus_OperSuccess)(nil), + } + file_usp_msg_1_2_proto_msgTypes[60].OneofWrappers = []interface{}{ + (*OperateResp_OperationResult_ReqObjPath)(nil), + (*OperateResp_OperationResult_ReqOutputArgs)(nil), + (*OperateResp_OperationResult_CmdFailure)(nil), + } + file_usp_msg_1_2_proto_msgTypes[68].OneofWrappers = []interface{}{ + (*Notify_OperationComplete_ReqOutputArgs)(nil), + (*Notify_OperationComplete_CmdFailure)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_usp_msg_1_2_proto_rawDesc, + NumEnums: 6, + NumMessages: 75, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_usp_msg_1_2_proto_goTypes, + DependencyIndexes: file_usp_msg_1_2_proto_depIdxs, + EnumInfos: file_usp_msg_1_2_proto_enumTypes, + MessageInfos: file_usp_msg_1_2_proto_msgTypes, + }.Build() + File_usp_msg_1_2_proto = out.File + file_usp_msg_1_2_proto_rawDesc = nil + file_usp_msg_1_2_proto_goTypes = nil + file_usp_msg_1_2_proto_depIdxs = nil +} diff --git a/backend/services/mtp/ws/internal/usp_message/usp-msg-1-2.proto b/backend/services/mtp/ws/internal/usp_message/usp-msg-1-2.proto new file mode 100755 index 0000000..7572e7a --- /dev/null +++ b/backend/services/mtp/ws/internal/usp_message/usp-msg-1-2.proto @@ -0,0 +1,530 @@ +syntax = "proto3"; + +//************************************************************************** +// TR-369 USP Message Protocol Buffer Schema +// +// Copyright (c) 2017-2018, Broadband Forum +// +// The undersigned members have elected to grant the copyright to +// their contributed material used in this software: +// Copyright (c) 2017-2018 ARRIS Enterprises, LLC. +// +// Redistribution and use in source and binary forms, with or +// without modification, are permitted provided that the following +// conditions are met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials +// provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products +// derived from this software without specific prior written +// permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +// CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// The above license is used as a license under copyright only. +// Please reference the Forum IPR Policy for patent licensing terms +// . +// +// Any moral rights which are necessary to exercise under the above +// license grant are also deemed granted under this license. +// +// | Version | Name | Date | +// | TR-369 1.0.0 | User Services Platform | APR, 2018 | +// | TR-369 1.0.1 | User Services Platform | JUN, 2018 | +// | TR-369 1.0.2 | User Services Platform | OCT, 2018 | +// | TR-369 1.1 | User Services Platform | SEP, 2019 | +// +// BBF software release registry: http://www.broadband-forum.org/software +//************************************************************************** + +package usp; + +option go_package="./usp-msg"; + +message Msg { + Header header = 1; // Make required in the protocol + Body body = 2; // Make required in the protocol +} + + +message Header { + string msg_id = 1; // Make required in the protocol + MsgType msg_type = 2; // Make required in the protocol + + enum MsgType { + ERROR = 0; + GET = 1; + GET_RESP = 2; + NOTIFY = 3; + SET = 4; + SET_RESP = 5; + OPERATE = 6; + OPERATE_RESP = 7; + ADD = 8; + ADD_RESP = 9; + DELETE = 10; + DELETE_RESP = 11; + GET_SUPPORTED_DM = 12; + GET_SUPPORTED_DM_RESP = 13; + GET_INSTANCES = 14; + GET_INSTANCES_RESP = 15; + NOTIFY_RESP = 16; + GET_SUPPORTED_PROTO = 17; + GET_SUPPORTED_PROTO_RESP = 18; + } +} + + +message Body { + oneof msg_body { + Request request = 1; + Response response = 2; + Error error = 3; + } +} + + +message Request { + oneof req_type { + Get get = 1; + GetSupportedDM get_supported_dm = 2; + GetInstances get_instances = 3; + Set set = 4; + Add add = 5; + Delete delete = 6; + Operate operate = 7; + Notify notify = 8; + GetSupportedProtocol get_supported_protocol = 9; + } +} + + +message Response { + oneof resp_type { + GetResp get_resp = 1; + GetSupportedDMResp get_supported_dm_resp = 2; + GetInstancesResp get_instances_resp = 3; + SetResp set_resp = 4; + AddResp add_resp = 5; + DeleteResp delete_resp = 6; + OperateResp operate_resp = 7; + NotifyResp notify_resp = 8; + GetSupportedProtocolResp get_supported_protocol_resp = 9; + } +} + + +message Error { + fixed32 err_code = 1; + string err_msg = 2; + repeated ParamError param_errs = 3; + + message ParamError { + string param_path = 1; + fixed32 err_code = 2; + string err_msg = 3; + } +} + + +message Get { + repeated string param_paths = 1; + fixed32 max_depth = 2; +} + +message GetResp { + repeated RequestedPathResult req_path_results = 1; + + message RequestedPathResult { + string requested_path = 1; + fixed32 err_code = 2; + string err_msg = 3; + repeated ResolvedPathResult resolved_path_results = 4; + } + + message ResolvedPathResult { + string resolved_path = 1; + map result_params = 2; + } +} + + + +message GetSupportedDM { + repeated string obj_paths = 1; + bool first_level_only = 2; + bool return_commands = 3; + bool return_events = 4; + bool return_params = 5; +} + +message GetSupportedDMResp { + repeated RequestedObjectResult req_obj_results = 1; + + message RequestedObjectResult { + string req_obj_path = 1; + fixed32 err_code = 2; + string err_msg = 3; + string data_model_inst_uri = 4; + repeated SupportedObjectResult supported_objs = 5; + } + + message SupportedObjectResult { + string supported_obj_path = 1; + ObjAccessType access = 2; + bool is_multi_instance = 3; + repeated SupportedCommandResult supported_commands = 4; + repeated SupportedEventResult supported_events = 5; + repeated SupportedParamResult supported_params = 6; + repeated string divergent_paths = 7; + } + + message SupportedParamResult { + string param_name = 1; + ParamAccessType access = 2; + ParamValueType value_type = 3; + ValueChangeType value_change = 4; + } + + message SupportedCommandResult { + string command_name = 1; + repeated string input_arg_names = 2; + repeated string output_arg_names = 3; + CmdType command_type = 4; + } + + message SupportedEventResult { + string event_name = 1; + repeated string arg_names = 2; + } + + enum ParamAccessType { + PARAM_READ_ONLY = 0; + PARAM_READ_WRITE = 1; + PARAM_WRITE_ONLY = 2; + } + + enum ObjAccessType { + OBJ_READ_ONLY = 0; + OBJ_ADD_DELETE = 1; + OBJ_ADD_ONLY = 2; + OBJ_DELETE_ONLY = 3; + } + + enum ParamValueType { + PARAM_UNKNOWN = 0; + PARAM_BASE_64 = 1; + PARAM_BOOLEAN = 2; + PARAM_DATE_TIME = 3; + PARAM_DECIMAL = 4; + PARAM_HEX_BINARY = 5; + PARAM_INT = 6; + PARAM_LONG = 7; + PARAM_STRING = 8; + PARAM_UNSIGNED_INT = 9; + PARAM_UNSIGNED_LONG = 10; + } + + enum ValueChangeType { + VALUE_CHANGE_UNKNOWN = 0; + VALUE_CHANGE_ALLOWED = 1; + VALUE_CHANGE_WILL_IGNORE = 2; + } + + enum CmdType { + CMD_UNKNOWN = 0; + CMD_SYNC = 1; + CMD_ASYNC = 2; + } +} + + +message GetInstances { + repeated string obj_paths = 1; + bool first_level_only = 2; +} + +message GetInstancesResp { + repeated RequestedPathResult req_path_results = 1; + + message RequestedPathResult { + string requested_path = 1; + fixed32 err_code = 2; + string err_msg = 3; + repeated CurrInstance curr_insts = 4; + } + + + message CurrInstance { + string instantiated_obj_path = 1; + map unique_keys = 2; + } +} + + +message GetSupportedProtocol { + string controller_supported_protocol_versions = 1; +} + +message GetSupportedProtocolResp { + string agent_supported_protocol_versions = 1; +} + + +message Add { + bool allow_partial = 1; + repeated CreateObject create_objs = 2; + + message CreateObject { + string obj_path = 1; + repeated CreateParamSetting param_settings = 2; + } + + message CreateParamSetting { + string param = 1; + string value = 2; + bool required = 3; + } +} + +message AddResp { + repeated CreatedObjectResult created_obj_results = 1; + + message CreatedObjectResult { + string requested_path = 1; + OperationStatus oper_status = 2; + + message OperationStatus { + oneof oper_status { + OperationFailure oper_failure = 1; + OperationSuccess oper_success = 2; + } + + message OperationFailure { + fixed32 err_code = 1; + string err_msg = 2; + } + + message OperationSuccess { + string instantiated_path = 1; + repeated ParameterError param_errs = 2; + map unique_keys = 3; + } + } + } + + message ParameterError { + string param = 1; + fixed32 err_code = 2; + string err_msg = 3; + } +} + + +message Delete { + bool allow_partial = 1; + repeated string obj_paths = 2; +} + +message DeleteResp { + repeated DeletedObjectResult deleted_obj_results = 1; + + message DeletedObjectResult { + string requested_path = 1; + OperationStatus oper_status = 2; + + message OperationStatus { + oneof oper_status { + OperationFailure oper_failure = 1; + OperationSuccess oper_success = 2; + } + + message OperationFailure { + fixed32 err_code = 1; + string err_msg = 2; + } + + message OperationSuccess { + repeated string affected_paths = 1; + repeated UnaffectedPathError unaffected_path_errs = 2; + } + } + } + + message UnaffectedPathError { + string unaffected_path = 1; + fixed32 err_code = 2; + string err_msg = 3; + } +} + + +message Set { + bool allow_partial = 1; + repeated UpdateObject update_objs = 2; + + message UpdateObject { + string obj_path = 1; + repeated UpdateParamSetting param_settings = 2; + } + + message UpdateParamSetting { + string param = 1; + string value = 2; + bool required = 3; + } +} + +message SetResp { + repeated UpdatedObjectResult updated_obj_results = 1; + + message UpdatedObjectResult { + string requested_path = 1; + OperationStatus oper_status = 2; + + message OperationStatus { + oneof oper_status { + OperationFailure oper_failure = 1; + OperationSuccess oper_success = 2; + } + + message OperationFailure { + fixed32 err_code = 1; + string err_msg = 2; + repeated UpdatedInstanceFailure updated_inst_failures = 3; + } + + message OperationSuccess { + repeated UpdatedInstanceResult updated_inst_results = 1; + } + } + } + + message UpdatedInstanceFailure { + string affected_path = 1; + repeated ParameterError param_errs = 2; + } + + message UpdatedInstanceResult { + string affected_path = 1; + repeated ParameterError param_errs = 2; + map updated_params = 3; + } + + message ParameterError { + string param = 1; + fixed32 err_code = 2; + string err_msg = 3; + } +} + +message Operate { + string command = 1; + string command_key = 2; + bool send_resp = 3; + map input_args = 4; +} + +message OperateResp { + repeated OperationResult operation_results = 1; + + message OperationResult { + string executed_command = 1; + oneof operation_resp { + string req_obj_path = 2; + OutputArgs req_output_args = 3; + CommandFailure cmd_failure = 4; + } + + message OutputArgs { + map output_args = 1; + } + + message CommandFailure { + fixed32 err_code = 1; + string err_msg = 2; + } + } +} + +message Notify { + string subscription_id = 1; + bool send_resp = 2; + oneof notification { + Event event = 3; + ValueChange value_change = 4; + ObjectCreation obj_creation = 5; + ObjectDeletion obj_deletion = 6; + OperationComplete oper_complete = 7; + OnBoardRequest on_board_req = 8; + } + + message Event { + string obj_path = 1; + string event_name = 2; + map params = 3; + } + + message ValueChange { + string param_path = 1; + string param_value = 2; + } + + message ObjectCreation { + string obj_path = 1; + map unique_keys = 2; + } + + message ObjectDeletion { + string obj_path = 1; + } + + message OperationComplete { + string obj_path = 1; + string command_name = 2; + string command_key = 3; + oneof operation_resp { + OutputArgs req_output_args = 4; + CommandFailure cmd_failure = 5; + } + + message OutputArgs { + map output_args = 1; + } + + message CommandFailure { + fixed32 err_code = 1; + string err_msg = 2; + } + } + + message OnBoardRequest { + string oui = 1; + string product_class = 2; + string serial_number = 3; + string agent_supported_protocol_versions = 4; + } +} + +message NotifyResp { + string subscription_id = 1; +} diff --git a/backend/services/mtp/ws/internal/usp_record/usp-record-1-2.pb.go b/backend/services/mtp/ws/internal/usp_record/usp-record-1-2.pb.go new file mode 100755 index 0000000..6d3e41b --- /dev/null +++ b/backend/services/mtp/ws/internal/usp_record/usp-record-1-2.pb.go @@ -0,0 +1,1075 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.1 +// protoc v3.21.12 +// source: usp-record-1-2.proto + +//************************************************************************** +// TR-369 USP Record Protocol Buffer Schema +// +// Copyright (c) 2017-2018, Broadband Forum +// +// The undersigned members have elected to grant the copyright to +// their contributed material used in this software: +// Copyright (c) 2017-2018 ARRIS Enterprises, LLC. +// +// Redistribution and use in source and binary forms, with or +// without modification, are permitted provided that the following +// conditions are met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials +// provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products +// derived from this software without specific prior written +// permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +// CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// The above license is used as a license under copyright only. +// Please reference the Forum IPR Policy for patent licensing terms +// . +// +// Any moral rights which are necessary to exercise under the above +// license grant are also deemed granted under this license. +// +// +// | Version | Name | Date | +// | TR-369 1.0.0 | User Services Platform | APR, 2018 | +// | TR-369 1.0.1 | User Services Platform | JUN, 2018 | +// | TR-369 1.0.2 | User Services Platform | OCT, 2018 | +// | TR-369 1.1 | User Services Platform | SEP, 2019 | +// +// BBF software release registry: http://www.broadband-forum.org/software +//************************************************************************** + +package usp_record + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Record_PayloadSecurity int32 + +const ( + Record_PLAINTEXT Record_PayloadSecurity = 0 + Record_TLS12 Record_PayloadSecurity = 1 +) + +// Enum value maps for Record_PayloadSecurity. +var ( + Record_PayloadSecurity_name = map[int32]string{ + 0: "PLAINTEXT", + 1: "TLS12", + } + Record_PayloadSecurity_value = map[string]int32{ + "PLAINTEXT": 0, + "TLS12": 1, + } +) + +func (x Record_PayloadSecurity) Enum() *Record_PayloadSecurity { + p := new(Record_PayloadSecurity) + *p = x + return p +} + +func (x Record_PayloadSecurity) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Record_PayloadSecurity) Descriptor() protoreflect.EnumDescriptor { + return file_usp_record_1_2_proto_enumTypes[0].Descriptor() +} + +func (Record_PayloadSecurity) Type() protoreflect.EnumType { + return &file_usp_record_1_2_proto_enumTypes[0] +} + +func (x Record_PayloadSecurity) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Record_PayloadSecurity.Descriptor instead. +func (Record_PayloadSecurity) EnumDescriptor() ([]byte, []int) { + return file_usp_record_1_2_proto_rawDescGZIP(), []int{0, 0} +} + +type SessionContextRecord_PayloadSARState int32 + +const ( + SessionContextRecord_NONE SessionContextRecord_PayloadSARState = 0 //No segmentation + SessionContextRecord_BEGIN SessionContextRecord_PayloadSARState = 1 //Begin segmentation + SessionContextRecord_INPROCESS SessionContextRecord_PayloadSARState = 2 //Segmentation in process + SessionContextRecord_COMPLETE SessionContextRecord_PayloadSARState = 3 //Segmentation is complete +) + +// Enum value maps for SessionContextRecord_PayloadSARState. +var ( + SessionContextRecord_PayloadSARState_name = map[int32]string{ + 0: "NONE", + 1: "BEGIN", + 2: "INPROCESS", + 3: "COMPLETE", + } + SessionContextRecord_PayloadSARState_value = map[string]int32{ + "NONE": 0, + "BEGIN": 1, + "INPROCESS": 2, + "COMPLETE": 3, + } +) + +func (x SessionContextRecord_PayloadSARState) Enum() *SessionContextRecord_PayloadSARState { + p := new(SessionContextRecord_PayloadSARState) + *p = x + return p +} + +func (x SessionContextRecord_PayloadSARState) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SessionContextRecord_PayloadSARState) Descriptor() protoreflect.EnumDescriptor { + return file_usp_record_1_2_proto_enumTypes[1].Descriptor() +} + +func (SessionContextRecord_PayloadSARState) Type() protoreflect.EnumType { + return &file_usp_record_1_2_proto_enumTypes[1] +} + +func (x SessionContextRecord_PayloadSARState) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SessionContextRecord_PayloadSARState.Descriptor instead. +func (SessionContextRecord_PayloadSARState) EnumDescriptor() ([]byte, []int) { + return file_usp_record_1_2_proto_rawDescGZIP(), []int{2, 0} +} + +type MQTTConnectRecord_MQTTVersion int32 + +const ( + MQTTConnectRecord_V3_1_1 MQTTConnectRecord_MQTTVersion = 0 // Represents MQTT v3.1.1, a.k.a. v4 in the MQTT Spec + MQTTConnectRecord_V5 MQTTConnectRecord_MQTTVersion = 1 +) + +// Enum value maps for MQTTConnectRecord_MQTTVersion. +var ( + MQTTConnectRecord_MQTTVersion_name = map[int32]string{ + 0: "V3_1_1", + 1: "V5", + } + MQTTConnectRecord_MQTTVersion_value = map[string]int32{ + "V3_1_1": 0, + "V5": 1, + } +) + +func (x MQTTConnectRecord_MQTTVersion) Enum() *MQTTConnectRecord_MQTTVersion { + p := new(MQTTConnectRecord_MQTTVersion) + *p = x + return p +} + +func (x MQTTConnectRecord_MQTTVersion) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (MQTTConnectRecord_MQTTVersion) Descriptor() protoreflect.EnumDescriptor { + return file_usp_record_1_2_proto_enumTypes[2].Descriptor() +} + +func (MQTTConnectRecord_MQTTVersion) Type() protoreflect.EnumType { + return &file_usp_record_1_2_proto_enumTypes[2] +} + +func (x MQTTConnectRecord_MQTTVersion) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use MQTTConnectRecord_MQTTVersion.Descriptor instead. +func (MQTTConnectRecord_MQTTVersion) EnumDescriptor() ([]byte, []int) { + return file_usp_record_1_2_proto_rawDescGZIP(), []int{4, 0} +} + +type STOMPConnectRecord_STOMPVersion int32 + +const ( + STOMPConnectRecord_V1_2 STOMPConnectRecord_STOMPVersion = 0 +) + +// Enum value maps for STOMPConnectRecord_STOMPVersion. +var ( + STOMPConnectRecord_STOMPVersion_name = map[int32]string{ + 0: "V1_2", + } + STOMPConnectRecord_STOMPVersion_value = map[string]int32{ + "V1_2": 0, + } +) + +func (x STOMPConnectRecord_STOMPVersion) Enum() *STOMPConnectRecord_STOMPVersion { + p := new(STOMPConnectRecord_STOMPVersion) + *p = x + return p +} + +func (x STOMPConnectRecord_STOMPVersion) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (STOMPConnectRecord_STOMPVersion) Descriptor() protoreflect.EnumDescriptor { + return file_usp_record_1_2_proto_enumTypes[3].Descriptor() +} + +func (STOMPConnectRecord_STOMPVersion) Type() protoreflect.EnumType { + return &file_usp_record_1_2_proto_enumTypes[3] +} + +func (x STOMPConnectRecord_STOMPVersion) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use STOMPConnectRecord_STOMPVersion.Descriptor instead. +func (STOMPConnectRecord_STOMPVersion) EnumDescriptor() ([]byte, []int) { + return file_usp_record_1_2_proto_rawDescGZIP(), []int{5, 0} +} + +type Record struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` + ToId string `protobuf:"bytes,2,opt,name=to_id,json=toId,proto3" json:"to_id,omitempty"` + FromId string `protobuf:"bytes,3,opt,name=from_id,json=fromId,proto3" json:"from_id,omitempty"` + PayloadSecurity Record_PayloadSecurity `protobuf:"varint,4,opt,name=payload_security,json=payloadSecurity,proto3,enum=usp_record.Record_PayloadSecurity" json:"payload_security,omitempty"` + MacSignature []byte `protobuf:"bytes,5,opt,name=mac_signature,json=macSignature,proto3" json:"mac_signature,omitempty"` //MAC or Signature + SenderCert []byte `protobuf:"bytes,6,opt,name=sender_cert,json=senderCert,proto3" json:"sender_cert,omitempty"` + // Types that are assignable to RecordType: + // + // *Record_NoSessionContext + // *Record_SessionContext + // *Record_WebsocketConnect + // *Record_MqttConnect + // *Record_StompConnect + // *Record_Disconnect + RecordType isRecord_RecordType `protobuf_oneof:"record_type"` +} + +func (x *Record) Reset() { + *x = Record{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_record_1_2_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Record) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Record) ProtoMessage() {} + +func (x *Record) ProtoReflect() protoreflect.Message { + mi := &file_usp_record_1_2_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Record.ProtoReflect.Descriptor instead. +func (*Record) Descriptor() ([]byte, []int) { + return file_usp_record_1_2_proto_rawDescGZIP(), []int{0} +} + +func (x *Record) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +func (x *Record) GetToId() string { + if x != nil { + return x.ToId + } + return "" +} + +func (x *Record) GetFromId() string { + if x != nil { + return x.FromId + } + return "" +} + +func (x *Record) GetPayloadSecurity() Record_PayloadSecurity { + if x != nil { + return x.PayloadSecurity + } + return Record_PLAINTEXT +} + +func (x *Record) GetMacSignature() []byte { + if x != nil { + return x.MacSignature + } + return nil +} + +func (x *Record) GetSenderCert() []byte { + if x != nil { + return x.SenderCert + } + return nil +} + +func (m *Record) GetRecordType() isRecord_RecordType { + if m != nil { + return m.RecordType + } + return nil +} + +func (x *Record) GetNoSessionContext() *NoSessionContextRecord { + if x, ok := x.GetRecordType().(*Record_NoSessionContext); ok { + return x.NoSessionContext + } + return nil +} + +func (x *Record) GetSessionContext() *SessionContextRecord { + if x, ok := x.GetRecordType().(*Record_SessionContext); ok { + return x.SessionContext + } + return nil +} + +func (x *Record) GetWebsocketConnect() *WebSocketConnectRecord { + if x, ok := x.GetRecordType().(*Record_WebsocketConnect); ok { + return x.WebsocketConnect + } + return nil +} + +func (x *Record) GetMqttConnect() *MQTTConnectRecord { + if x, ok := x.GetRecordType().(*Record_MqttConnect); ok { + return x.MqttConnect + } + return nil +} + +func (x *Record) GetStompConnect() *STOMPConnectRecord { + if x, ok := x.GetRecordType().(*Record_StompConnect); ok { + return x.StompConnect + } + return nil +} + +func (x *Record) GetDisconnect() *DisconnectRecord { + if x, ok := x.GetRecordType().(*Record_Disconnect); ok { + return x.Disconnect + } + return nil +} + +type isRecord_RecordType interface { + isRecord_RecordType() +} + +type Record_NoSessionContext struct { + NoSessionContext *NoSessionContextRecord `protobuf:"bytes,7,opt,name=no_session_context,json=noSessionContext,proto3,oneof"` +} + +type Record_SessionContext struct { + SessionContext *SessionContextRecord `protobuf:"bytes,8,opt,name=session_context,json=sessionContext,proto3,oneof"` +} + +type Record_WebsocketConnect struct { + WebsocketConnect *WebSocketConnectRecord `protobuf:"bytes,9,opt,name=websocket_connect,json=websocketConnect,proto3,oneof"` +} + +type Record_MqttConnect struct { + MqttConnect *MQTTConnectRecord `protobuf:"bytes,10,opt,name=mqtt_connect,json=mqttConnect,proto3,oneof"` +} + +type Record_StompConnect struct { + StompConnect *STOMPConnectRecord `protobuf:"bytes,11,opt,name=stomp_connect,json=stompConnect,proto3,oneof"` +} + +type Record_Disconnect struct { + Disconnect *DisconnectRecord `protobuf:"bytes,12,opt,name=disconnect,proto3,oneof"` +} + +func (*Record_NoSessionContext) isRecord_RecordType() {} + +func (*Record_SessionContext) isRecord_RecordType() {} + +func (*Record_WebsocketConnect) isRecord_RecordType() {} + +func (*Record_MqttConnect) isRecord_RecordType() {} + +func (*Record_StompConnect) isRecord_RecordType() {} + +func (*Record_Disconnect) isRecord_RecordType() {} + +type NoSessionContextRecord struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"` +} + +func (x *NoSessionContextRecord) Reset() { + *x = NoSessionContextRecord{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_record_1_2_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NoSessionContextRecord) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NoSessionContextRecord) ProtoMessage() {} + +func (x *NoSessionContextRecord) ProtoReflect() protoreflect.Message { + mi := &file_usp_record_1_2_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NoSessionContextRecord.ProtoReflect.Descriptor instead. +func (*NoSessionContextRecord) Descriptor() ([]byte, []int) { + return file_usp_record_1_2_proto_rawDescGZIP(), []int{1} +} + +func (x *NoSessionContextRecord) GetPayload() []byte { + if x != nil { + return x.Payload + } + return nil +} + +type SessionContextRecord struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SessionId uint64 `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"` + SequenceId uint64 `protobuf:"varint,2,opt,name=sequence_id,json=sequenceId,proto3" json:"sequence_id,omitempty"` + ExpectedId uint64 `protobuf:"varint,3,opt,name=expected_id,json=expectedId,proto3" json:"expected_id,omitempty"` + RetransmitId uint64 `protobuf:"varint,4,opt,name=retransmit_id,json=retransmitId,proto3" json:"retransmit_id,omitempty"` + PayloadSarState SessionContextRecord_PayloadSARState `protobuf:"varint,5,opt,name=payload_sar_state,json=payloadSarState,proto3,enum=usp_record.SessionContextRecord_PayloadSARState" json:"payload_sar_state,omitempty"` + PayloadrecSarState SessionContextRecord_PayloadSARState `protobuf:"varint,6,opt,name=payloadrec_sar_state,json=payloadrecSarState,proto3,enum=usp_record.SessionContextRecord_PayloadSARState" json:"payloadrec_sar_state,omitempty"` + Payload [][]byte `protobuf:"bytes,7,rep,name=payload,proto3" json:"payload,omitempty"` +} + +func (x *SessionContextRecord) Reset() { + *x = SessionContextRecord{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_record_1_2_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SessionContextRecord) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SessionContextRecord) ProtoMessage() {} + +func (x *SessionContextRecord) ProtoReflect() protoreflect.Message { + mi := &file_usp_record_1_2_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SessionContextRecord.ProtoReflect.Descriptor instead. +func (*SessionContextRecord) Descriptor() ([]byte, []int) { + return file_usp_record_1_2_proto_rawDescGZIP(), []int{2} +} + +func (x *SessionContextRecord) GetSessionId() uint64 { + if x != nil { + return x.SessionId + } + return 0 +} + +func (x *SessionContextRecord) GetSequenceId() uint64 { + if x != nil { + return x.SequenceId + } + return 0 +} + +func (x *SessionContextRecord) GetExpectedId() uint64 { + if x != nil { + return x.ExpectedId + } + return 0 +} + +func (x *SessionContextRecord) GetRetransmitId() uint64 { + if x != nil { + return x.RetransmitId + } + return 0 +} + +func (x *SessionContextRecord) GetPayloadSarState() SessionContextRecord_PayloadSARState { + if x != nil { + return x.PayloadSarState + } + return SessionContextRecord_NONE +} + +func (x *SessionContextRecord) GetPayloadrecSarState() SessionContextRecord_PayloadSARState { + if x != nil { + return x.PayloadrecSarState + } + return SessionContextRecord_NONE +} + +func (x *SessionContextRecord) GetPayload() [][]byte { + if x != nil { + return x.Payload + } + return nil +} + +type WebSocketConnectRecord struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *WebSocketConnectRecord) Reset() { + *x = WebSocketConnectRecord{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_record_1_2_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WebSocketConnectRecord) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WebSocketConnectRecord) ProtoMessage() {} + +func (x *WebSocketConnectRecord) ProtoReflect() protoreflect.Message { + mi := &file_usp_record_1_2_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WebSocketConnectRecord.ProtoReflect.Descriptor instead. +func (*WebSocketConnectRecord) Descriptor() ([]byte, []int) { + return file_usp_record_1_2_proto_rawDescGZIP(), []int{3} +} + +type MQTTConnectRecord struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Version MQTTConnectRecord_MQTTVersion `protobuf:"varint,1,opt,name=version,proto3,enum=usp_record.MQTTConnectRecord_MQTTVersion" json:"version,omitempty"` + SubscribedTopic string `protobuf:"bytes,2,opt,name=subscribed_topic,json=subscribedTopic,proto3" json:"subscribed_topic,omitempty"` +} + +func (x *MQTTConnectRecord) Reset() { + *x = MQTTConnectRecord{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_record_1_2_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MQTTConnectRecord) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MQTTConnectRecord) ProtoMessage() {} + +func (x *MQTTConnectRecord) ProtoReflect() protoreflect.Message { + mi := &file_usp_record_1_2_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MQTTConnectRecord.ProtoReflect.Descriptor instead. +func (*MQTTConnectRecord) Descriptor() ([]byte, []int) { + return file_usp_record_1_2_proto_rawDescGZIP(), []int{4} +} + +func (x *MQTTConnectRecord) GetVersion() MQTTConnectRecord_MQTTVersion { + if x != nil { + return x.Version + } + return MQTTConnectRecord_V3_1_1 +} + +func (x *MQTTConnectRecord) GetSubscribedTopic() string { + if x != nil { + return x.SubscribedTopic + } + return "" +} + +type STOMPConnectRecord struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Version STOMPConnectRecord_STOMPVersion `protobuf:"varint,1,opt,name=version,proto3,enum=usp_record.STOMPConnectRecord_STOMPVersion" json:"version,omitempty"` + SubscribedDestination string `protobuf:"bytes,2,opt,name=subscribed_destination,json=subscribedDestination,proto3" json:"subscribed_destination,omitempty"` +} + +func (x *STOMPConnectRecord) Reset() { + *x = STOMPConnectRecord{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_record_1_2_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *STOMPConnectRecord) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*STOMPConnectRecord) ProtoMessage() {} + +func (x *STOMPConnectRecord) ProtoReflect() protoreflect.Message { + mi := &file_usp_record_1_2_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use STOMPConnectRecord.ProtoReflect.Descriptor instead. +func (*STOMPConnectRecord) Descriptor() ([]byte, []int) { + return file_usp_record_1_2_proto_rawDescGZIP(), []int{5} +} + +func (x *STOMPConnectRecord) GetVersion() STOMPConnectRecord_STOMPVersion { + if x != nil { + return x.Version + } + return STOMPConnectRecord_V1_2 +} + +func (x *STOMPConnectRecord) GetSubscribedDestination() string { + if x != nil { + return x.SubscribedDestination + } + return "" +} + +type DisconnectRecord struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` + ReasonCode uint32 `protobuf:"fixed32,2,opt,name=reason_code,json=reasonCode,proto3" json:"reason_code,omitempty"` +} + +func (x *DisconnectRecord) Reset() { + *x = DisconnectRecord{} + if protoimpl.UnsafeEnabled { + mi := &file_usp_record_1_2_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DisconnectRecord) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DisconnectRecord) ProtoMessage() {} + +func (x *DisconnectRecord) ProtoReflect() protoreflect.Message { + mi := &file_usp_record_1_2_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DisconnectRecord.ProtoReflect.Descriptor instead. +func (*DisconnectRecord) Descriptor() ([]byte, []int) { + return file_usp_record_1_2_proto_rawDescGZIP(), []int{6} +} + +func (x *DisconnectRecord) GetReason() string { + if x != nil { + return x.Reason + } + return "" +} + +func (x *DisconnectRecord) GetReasonCode() uint32 { + if x != nil { + return x.ReasonCode + } + return 0 +} + +var File_usp_record_1_2_proto protoreflect.FileDescriptor + +var file_usp_record_1_2_proto_rawDesc = []byte{ + 0x0a, 0x14, 0x75, 0x73, 0x70, 0x2d, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x2d, 0x31, 0x2d, 0x32, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0a, 0x75, 0x73, 0x70, 0x5f, 0x72, 0x65, 0x63, 0x6f, + 0x72, 0x64, 0x22, 0xe0, 0x05, 0x0a, 0x06, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, 0x18, 0x0a, + 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x13, 0x0a, 0x05, 0x74, 0x6f, 0x5f, 0x69, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x6f, 0x49, 0x64, 0x12, 0x17, 0x0a, 0x07, + 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, + 0x72, 0x6f, 0x6d, 0x49, 0x64, 0x12, 0x4d, 0x0a, 0x10, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, + 0x5f, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x22, 0x2e, 0x75, 0x73, 0x70, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x2e, 0x52, 0x65, 0x63, + 0x6f, 0x72, 0x64, 0x2e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x63, 0x75, 0x72, + 0x69, 0x74, 0x79, 0x52, 0x0f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x63, 0x75, + 0x72, 0x69, 0x74, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x61, 0x63, 0x5f, 0x73, 0x69, 0x67, 0x6e, + 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x6d, 0x61, 0x63, + 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x65, 0x6e, + 0x64, 0x65, 0x72, 0x5f, 0x63, 0x65, 0x72, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, + 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x43, 0x65, 0x72, 0x74, 0x12, 0x52, 0x0a, 0x12, 0x6e, 0x6f, + 0x5f, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x75, 0x73, 0x70, 0x5f, 0x72, 0x65, 0x63, + 0x6f, 0x72, 0x64, 0x2e, 0x4e, 0x6f, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, + 0x74, 0x65, 0x78, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x48, 0x00, 0x52, 0x10, 0x6e, 0x6f, + 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x4b, + 0x0a, 0x0f, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, + 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x75, 0x73, 0x70, 0x5f, 0x72, 0x65, + 0x63, 0x6f, 0x72, 0x64, 0x2e, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x78, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x48, 0x00, 0x52, 0x0e, 0x73, 0x65, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x51, 0x0a, 0x11, 0x77, + 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x75, 0x73, 0x70, 0x5f, 0x72, 0x65, 0x63, + 0x6f, 0x72, 0x64, 0x2e, 0x57, 0x65, 0x62, 0x53, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x48, 0x00, 0x52, 0x10, 0x77, 0x65, + 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x12, 0x42, + 0x0a, 0x0c, 0x6d, 0x71, 0x74, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x18, 0x0a, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x75, 0x73, 0x70, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, + 0x64, 0x2e, 0x4d, 0x51, 0x54, 0x54, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x52, 0x65, 0x63, + 0x6f, 0x72, 0x64, 0x48, 0x00, 0x52, 0x0b, 0x6d, 0x71, 0x74, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x12, 0x45, 0x0a, 0x0d, 0x73, 0x74, 0x6f, 0x6d, 0x70, 0x5f, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x75, 0x73, 0x70, 0x5f, + 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x2e, 0x53, 0x54, 0x4f, 0x4d, 0x50, 0x43, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x48, 0x00, 0x52, 0x0c, 0x73, 0x74, 0x6f, + 0x6d, 0x70, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x12, 0x3e, 0x0a, 0x0a, 0x64, 0x69, 0x73, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, + 0x75, 0x73, 0x70, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x2e, 0x44, 0x69, 0x73, 0x63, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x48, 0x00, 0x52, 0x0a, 0x64, + 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x22, 0x2b, 0x0a, 0x0f, 0x50, 0x61, 0x79, + 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x12, 0x0d, 0x0a, 0x09, + 0x50, 0x4c, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x58, 0x54, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x54, + 0x4c, 0x53, 0x31, 0x32, 0x10, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0x32, 0x0a, 0x16, 0x4e, 0x6f, 0x53, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, + 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0xbd, 0x03, 0x0a, 0x14, 0x53, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x65, 0x63, 0x6f, + 0x72, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, + 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x69, + 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, + 0x64, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6d, 0x69, + 0x74, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x72, 0x65, 0x74, 0x72, + 0x61, 0x6e, 0x73, 0x6d, 0x69, 0x74, 0x49, 0x64, 0x12, 0x5c, 0x0a, 0x11, 0x70, 0x61, 0x79, 0x6c, + 0x6f, 0x61, 0x64, 0x5f, 0x73, 0x61, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x30, 0x2e, 0x75, 0x73, 0x70, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, + 0x2e, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, + 0x65, 0x63, 0x6f, 0x72, 0x64, 0x2e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x41, 0x52, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x61, + 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x62, 0x0a, 0x14, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, + 0x64, 0x72, 0x65, 0x63, 0x5f, 0x73, 0x61, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x30, 0x2e, 0x75, 0x73, 0x70, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, + 0x64, 0x2e, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, + 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x2e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x41, + 0x52, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x12, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x72, + 0x65, 0x63, 0x53, 0x61, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, + 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x07, 0x70, 0x61, 0x79, + 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x43, 0x0a, 0x0f, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, + 0x41, 0x52, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x4e, 0x4f, 0x4e, 0x45, 0x10, + 0x00, 0x12, 0x09, 0x0a, 0x05, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, + 0x49, 0x4e, 0x50, 0x52, 0x4f, 0x43, 0x45, 0x53, 0x53, 0x10, 0x02, 0x12, 0x0c, 0x0a, 0x08, 0x43, + 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x03, 0x22, 0x18, 0x0a, 0x16, 0x57, 0x65, 0x62, + 0x53, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x52, 0x65, 0x63, + 0x6f, 0x72, 0x64, 0x22, 0xa6, 0x01, 0x0a, 0x11, 0x4d, 0x51, 0x54, 0x54, 0x43, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, 0x43, 0x0a, 0x07, 0x76, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x75, 0x73, 0x70, + 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x2e, 0x4d, 0x51, 0x54, 0x54, 0x43, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x2e, 0x4d, 0x51, 0x54, 0x54, 0x56, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x29, + 0x0a, 0x10, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x70, + 0x69, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, + 0x69, 0x62, 0x65, 0x64, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x22, 0x21, 0x0a, 0x0b, 0x4d, 0x51, 0x54, + 0x54, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x0a, 0x0a, 0x06, 0x56, 0x33, 0x5f, 0x31, + 0x5f, 0x31, 0x10, 0x00, 0x12, 0x06, 0x0a, 0x02, 0x56, 0x35, 0x10, 0x01, 0x22, 0xac, 0x01, 0x0a, + 0x12, 0x53, 0x54, 0x4f, 0x4d, 0x50, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x52, 0x65, 0x63, + 0x6f, 0x72, 0x64, 0x12, 0x45, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x75, 0x73, 0x70, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, + 0x64, 0x2e, 0x53, 0x54, 0x4f, 0x4d, 0x50, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x52, 0x65, + 0x63, 0x6f, 0x72, 0x64, 0x2e, 0x53, 0x54, 0x4f, 0x4d, 0x50, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x35, 0x0a, 0x16, 0x73, 0x75, + 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x5f, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x73, 0x75, 0x62, 0x73, + 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0x18, 0x0a, 0x0c, 0x53, 0x54, 0x4f, 0x4d, 0x50, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x08, 0x0a, 0x04, 0x56, 0x31, 0x5f, 0x32, 0x10, 0x00, 0x22, 0x4b, 0x0a, 0x10, 0x44, + 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, + 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0a, 0x72, 0x65, + 0x61, 0x73, 0x6f, 0x6e, 0x43, 0x6f, 0x64, 0x65, 0x42, 0x0e, 0x5a, 0x0c, 0x2e, 0x2f, 0x75, 0x73, + 0x70, 0x2d, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_usp_record_1_2_proto_rawDescOnce sync.Once + file_usp_record_1_2_proto_rawDescData = file_usp_record_1_2_proto_rawDesc +) + +func file_usp_record_1_2_proto_rawDescGZIP() []byte { + file_usp_record_1_2_proto_rawDescOnce.Do(func() { + file_usp_record_1_2_proto_rawDescData = protoimpl.X.CompressGZIP(file_usp_record_1_2_proto_rawDescData) + }) + return file_usp_record_1_2_proto_rawDescData +} + +var file_usp_record_1_2_proto_enumTypes = make([]protoimpl.EnumInfo, 4) +var file_usp_record_1_2_proto_msgTypes = make([]protoimpl.MessageInfo, 7) +var file_usp_record_1_2_proto_goTypes = []interface{}{ + (Record_PayloadSecurity)(0), // 0: usp_record.Record.PayloadSecurity + (SessionContextRecord_PayloadSARState)(0), // 1: usp_record.SessionContextRecord.PayloadSARState + (MQTTConnectRecord_MQTTVersion)(0), // 2: usp_record.MQTTConnectRecord.MQTTVersion + (STOMPConnectRecord_STOMPVersion)(0), // 3: usp_record.STOMPConnectRecord.STOMPVersion + (*Record)(nil), // 4: usp_record.Record + (*NoSessionContextRecord)(nil), // 5: usp_record.NoSessionContextRecord + (*SessionContextRecord)(nil), // 6: usp_record.SessionContextRecord + (*WebSocketConnectRecord)(nil), // 7: usp_record.WebSocketConnectRecord + (*MQTTConnectRecord)(nil), // 8: usp_record.MQTTConnectRecord + (*STOMPConnectRecord)(nil), // 9: usp_record.STOMPConnectRecord + (*DisconnectRecord)(nil), // 10: usp_record.DisconnectRecord +} +var file_usp_record_1_2_proto_depIdxs = []int32{ + 0, // 0: usp_record.Record.payload_security:type_name -> usp_record.Record.PayloadSecurity + 5, // 1: usp_record.Record.no_session_context:type_name -> usp_record.NoSessionContextRecord + 6, // 2: usp_record.Record.session_context:type_name -> usp_record.SessionContextRecord + 7, // 3: usp_record.Record.websocket_connect:type_name -> usp_record.WebSocketConnectRecord + 8, // 4: usp_record.Record.mqtt_connect:type_name -> usp_record.MQTTConnectRecord + 9, // 5: usp_record.Record.stomp_connect:type_name -> usp_record.STOMPConnectRecord + 10, // 6: usp_record.Record.disconnect:type_name -> usp_record.DisconnectRecord + 1, // 7: usp_record.SessionContextRecord.payload_sar_state:type_name -> usp_record.SessionContextRecord.PayloadSARState + 1, // 8: usp_record.SessionContextRecord.payloadrec_sar_state:type_name -> usp_record.SessionContextRecord.PayloadSARState + 2, // 9: usp_record.MQTTConnectRecord.version:type_name -> usp_record.MQTTConnectRecord.MQTTVersion + 3, // 10: usp_record.STOMPConnectRecord.version:type_name -> usp_record.STOMPConnectRecord.STOMPVersion + 11, // [11:11] is the sub-list for method output_type + 11, // [11:11] is the sub-list for method input_type + 11, // [11:11] is the sub-list for extension type_name + 11, // [11:11] is the sub-list for extension extendee + 0, // [0:11] is the sub-list for field type_name +} + +func init() { file_usp_record_1_2_proto_init() } +func file_usp_record_1_2_proto_init() { + if File_usp_record_1_2_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_usp_record_1_2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Record); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_record_1_2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NoSessionContextRecord); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_record_1_2_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SessionContextRecord); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_record_1_2_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WebSocketConnectRecord); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_record_1_2_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MQTTConnectRecord); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_record_1_2_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*STOMPConnectRecord); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_usp_record_1_2_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DisconnectRecord); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_usp_record_1_2_proto_msgTypes[0].OneofWrappers = []interface{}{ + (*Record_NoSessionContext)(nil), + (*Record_SessionContext)(nil), + (*Record_WebsocketConnect)(nil), + (*Record_MqttConnect)(nil), + (*Record_StompConnect)(nil), + (*Record_Disconnect)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_usp_record_1_2_proto_rawDesc, + NumEnums: 4, + NumMessages: 7, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_usp_record_1_2_proto_goTypes, + DependencyIndexes: file_usp_record_1_2_proto_depIdxs, + EnumInfos: file_usp_record_1_2_proto_enumTypes, + MessageInfos: file_usp_record_1_2_proto_msgTypes, + }.Build() + File_usp_record_1_2_proto = out.File + file_usp_record_1_2_proto_rawDesc = nil + file_usp_record_1_2_proto_goTypes = nil + file_usp_record_1_2_proto_depIdxs = nil +} diff --git a/backend/services/mtp/ws/internal/usp_record/usp-record-1-2.proto b/backend/services/mtp/ws/internal/usp_record/usp-record-1-2.proto new file mode 100755 index 0000000..430ca96 --- /dev/null +++ b/backend/services/mtp/ws/internal/usp_record/usp-record-1-2.proto @@ -0,0 +1,134 @@ +syntax = "proto3"; + +//************************************************************************** +// TR-369 USP Record Protocol Buffer Schema +// +// Copyright (c) 2017-2018, Broadband Forum +// +// The undersigned members have elected to grant the copyright to +// their contributed material used in this software: +// Copyright (c) 2017-2018 ARRIS Enterprises, LLC. +// +// Redistribution and use in source and binary forms, with or +// without modification, are permitted provided that the following +// conditions are met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials +// provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products +// derived from this software without specific prior written +// permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +// CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// The above license is used as a license under copyright only. +// Please reference the Forum IPR Policy for patent licensing terms +// . +// +// Any moral rights which are necessary to exercise under the above +// license grant are also deemed granted under this license. +// +// +// | Version | Name | Date | +// | TR-369 1.0.0 | User Services Platform | APR, 2018 | +// | TR-369 1.0.1 | User Services Platform | JUN, 2018 | +// | TR-369 1.0.2 | User Services Platform | OCT, 2018 | +// | TR-369 1.1 | User Services Platform | SEP, 2019 | +// +// BBF software release registry: http://www.broadband-forum.org/software +//************************************************************************** + +package usp_record; + +option go_package="./usp-record"; + +message Record { + string version = 1; + string to_id = 2; + string from_id = 3; + PayloadSecurity payload_security = 4; + bytes mac_signature = 5; //MAC or Signature + bytes sender_cert = 6; + + oneof record_type { + NoSessionContextRecord no_session_context = 7; + SessionContextRecord session_context = 8; + WebSocketConnectRecord websocket_connect = 9; + MQTTConnectRecord mqtt_connect = 10; + STOMPConnectRecord stomp_connect = 11; + DisconnectRecord disconnect = 12; + } + + enum PayloadSecurity { + PLAINTEXT = 0; + TLS12 = 1; + } +} + +message NoSessionContextRecord { + bytes payload = 2; +} + +message SessionContextRecord { + uint64 session_id = 1; + uint64 sequence_id = 2; + uint64 expected_id = 3; + uint64 retransmit_id = 4; + PayloadSARState payload_sar_state = 5; + PayloadSARState payloadrec_sar_state = 6; + repeated bytes payload = 7; + + enum PayloadSARState { + NONE = 0; //No segmentation + BEGIN = 1; //Begin segmentation + INPROCESS = 2; //Segmentation in process + COMPLETE = 3; //Segmentation is complete + } +} + +message WebSocketConnectRecord { + // An empty message +} + +message MQTTConnectRecord { + MQTTVersion version = 1; + string subscribed_topic = 2; + + enum MQTTVersion { + V3_1_1 = 0; // Represents MQTT v3.1.1, a.k.a. v4 in the MQTT Spec + V5 = 1; + } +} + +message STOMPConnectRecord { + STOMPVersion version = 1; + string subscribed_destination = 2; + + enum STOMPVersion { + V1_2 = 0; + } +} + +message DisconnectRecord { + string reason = 1; + fixed32 reason_code = 2; +} diff --git a/backend/services/ws/internal/ws/handler/client.go b/backend/services/ws/internal/ws/handler/client.go deleted file mode 100644 index bcc0e41..0000000 --- a/backend/services/ws/internal/ws/handler/client.go +++ /dev/null @@ -1,222 +0,0 @@ -package handler - -import ( - "log" - "net/http" - "strings" - "time" - - "github.com/OktopUSP/oktopus/ws/internal/usp_record" - "github.com/gorilla/websocket" - "google.golang.org/protobuf/proto" -) - -const ( - // Time allowed to write a message to the peer. - writeWait = 30 * time.Second - - // Time allowed to read the next pong message from the peer. - pongWait = 10 * time.Second - - // Send pings to peer with this period. Must be less than pongWait. - pingPeriod = (pongWait * 9) / 10 - - // Maximum message size allowed from peer. - //maxMessageSize = 512 - - // Websockets version of the protocol - wsVersion = "13" - - // USP specification version - uspVersion = "v1.usp" -) - -var ( - newline = []byte{'\n'} - space = []byte{' '} - upgrader = websocket.Upgrader{ - ReadBufferSize: 1024, - WriteBufferSize: 1024, - CheckOrigin: func(r *http.Request) bool { return true }, - } -) - -// Client is a middleman between the websocket connection and the hub. -type Client struct { - hub *Hub - - //Websockets client endpoint id, eid follows usp specification - eid string - - // The websocket connection. - conn *websocket.Conn - - // Buffered channel of outbound messages. - send chan message -} - -// readPump pumps messages from the websocket connection to the hub. -// -// The application runs readPump in a per-connection goroutine. The application -// ensures that there is at most one reader on a connection by executing all -// reads from this goroutine. -// cEID = controller endpoint id -func (c *Client) readPump(cEID string) { - defer func() { - c.hub.unregister <- c - c.conn.Close() - }() - //c.conn.SetReadLimit(maxMessageSize) - c.conn.SetReadDeadline(time.Now().Add(pongWait)) - c.conn.SetPongHandler(func(string) error { c.conn.SetReadDeadline(time.Now().Add(pongWait)); return nil }) - for { - _, data, err := c.conn.ReadMessage() - if err != nil { - if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) { - log.Printf("error: %v", err) - } - break - } - message := constructMsg(cEID, c.eid, data) - c.hub.broadcast <- message - } -} - -func constructMsg(eid string, from string, data []byte) message { - if eid == "" { - var record usp_record.Record - err := proto.Unmarshal(data, &record) - if err != nil { - log.Println(err) - } - eid = record.ToId - } - return message{ - eid: eid, - from: from, - data: data, - msgType: websocket.BinaryMessage, - } -} - -// writePump pumps messages from the hub to the websocket connection. -// -// A goroutine running writePump is started for each connection. The -// application ensures that there is at most one writer to a connection by -// executing all writes from this goroutine. -func (c *Client) writePump() { - ticker := time.NewTicker(pingPeriod) - defer func() { - ticker.Stop() - c.conn.Close() - }() - for { - select { - case message, ok := <-c.send: - c.conn.SetWriteDeadline(time.Now().Add(writeWait)) - if !ok { - // The hub closed the channel. - log.Println("The hub closed the channel of", c.eid) - c.conn.WriteMessage(websocket.CloseMessage, []byte{}) - return - } - - w, err := c.conn.NextWriter(message.msgType) - if err != nil { - return - } - w.Write(message.data) - - // Add queued messages to the current websocket message. - n := len(c.send) - for i := 0; i < n; i++ { - w.Write(newline) - send := <-c.send - w.Write(send.data) - } - - if err := w.Close(); err != nil { - return - } - case <-ticker.C: - c.conn.SetWriteDeadline(time.Now().Add(writeWait)) - if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil { - return - } - } - } -} - -// Handle USP Controller events -func ServeController(w http.ResponseWriter, r *http.Request, token, cEID string, authEnable bool) { - if authEnable { - recv_token := r.URL.Query().Get("token") - if recv_token != token { - w.WriteHeader(http.StatusUnauthorized) - w.Write([]byte("Unauthorized")) - return - } - } - - conn, err := upgrader.Upgrade(w, r, nil) - if err != nil { - log.Println(err) - return - } - - client := &Client{hub: hub, eid: cEID, conn: conn, send: make(chan message)} - client.hub.register <- client - - go client.writePump() - go client.readPump("") -} - -// Handle USP Agent events, cEID = controller endpoint id -func ServeAgent(w http.ResponseWriter, r *http.Request, cEID string) { - - //TODO: find out a way to authenticate agents - - header := http.Header{ - "Sec-Websocket-Protocol": {uspVersion}, - "Sec-Websocket-Version": {wsVersion}, - } - - deviceid := extractDeviceId(r.Header) - if deviceid == "" { - w.WriteHeader(http.StatusBadRequest) - log.Println("Device id not found") - w.Write([]byte("Device id not found")) - return - } - - conn, err := upgrader.Upgrade(w, r, header) - if err != nil { - log.Println(err) - return - } - - client := &Client{hub: hub, eid: deviceid, conn: conn, send: make(chan message)} - client.hub.register <- client - - // Allow collection of memory referenced by the caller by doing all work in - // new goroutines. - go client.writePump() - //TODO: get cEID from device message toId record field (must refact nice part of the code for this to be dynamic) - go client.readPump(cEID) -} - -// gets device id from websockets header -func extractDeviceId(header http.Header) string { - - // Header must be like that: bbf-usp-protocol; eid="" is the same ar the record.FromId/record.ToId - // log.Println("Header sec-websocket-extensions:", header.Get("sec-websocket-extensions")) - wsHeaderExtension := header.Get("sec-websocket-extensions") - - // Split the input string by double quotes - deviceid := strings.Split(wsHeaderExtension, "\"") - if len(deviceid) < 2 { - return "" - } - - return deviceid[1] -} diff --git a/backend/services/ws/internal/ws/handler/hub.go b/backend/services/ws/internal/ws/handler/hub.go deleted file mode 100644 index f7f16d8..0000000 --- a/backend/services/ws/internal/ws/handler/hub.go +++ /dev/null @@ -1,128 +0,0 @@ -package handler - -import ( - "encoding/json" - "log" - - "github.com/gorilla/websocket" -) - -// Keeps the content and the destination of a websockets message -type message struct { - // Websockets client endpoint id, eid follows usp specification. - // This field is needed for us to know which agent or controller - // the message is intended to be delivered to. - eid string - data []byte - msgType int - from string -} - -// Hub maintains the set of active clients and broadcasts messages to the -// clients. -type Hub struct { - // Registered clients. - clients map[string]*Client - - // Inbound messages from the clients. - broadcast chan message - - // Register requests from the clients. - register chan *Client - - // Unregister requests from clients. - unregister chan *Client -} - -const ( - OFFLINE = "0" - ONLINE = "1" -) - -type deviceStatus struct { - Eid string - Status string -} - -// Global hub instance -var hub *Hub - -// Controller Endpoint ID -var ceid string - -func InitHandlers(eid string) { - ceid = eid - log.Println("New hub, Controller eid:", ceid) - hub = newHub() - hub.run() -} - -func newHub() *Hub { - return &Hub{ - broadcast: make(chan message), - register: make(chan *Client), - unregister: make(chan *Client), - clients: make(map[string]*Client), - } -} - -func (h *Hub) run() { - for { - select { - case client := <-h.register: - // register new eid - h.clients[client.eid] = client - log.Printf("New client connected: %s", client.eid) - case client := <-h.unregister: - // verify if eid exists - if _, ok := h.clients[client.eid]; ok { - // delete eid from map of connections - delete(h.clients, client.eid) - // close client messages receiving channel - close(client.send) - } - log.Println("Disconnected client", client.eid) - data, _ := json.Marshal(deviceStatus{client.eid, OFFLINE}) - msg := message{ - from: "WS server", - eid: ceid, - data: data, - msgType: websocket.TextMessage, - } - log.Printf("%++v", msg) - //TODO: set this snippet of code as a function to avoid repetition - if c, ok := h.clients[msg.eid]; ok { - select { - // send message to receiver client - case c.send <- msg: - log.Printf("Sent a message %s --> %s", msg.from, msg.eid) - default: - // in case the msg sending fails, close the client connection - // because it means that the client is no longer active - log.Printf("Failed to send a msg to %s, disconnecting client...", msg.eid) - close(c.send) - delete(h.clients, c.eid) - } - } - case message := <-h.broadcast: //TODO: ver a conexão de quem está enviando - log.Println("send message to", message.eid) - // verify if eid exists - if c, ok := h.clients[message.eid]; ok { - select { - // send message to receiver client - case c.send <- message: - log.Printf("Sent a message %s --> %s", message.from, message.eid) - default: - // in case the message sending fails, close the client connection - // because it means that the client is no longer active - log.Printf("Failed to send a message to %s, disconnecting client...", message.eid) - close(c.send) - delete(h.clients, c.eid) - } - } else { - //TODO: create queue for receiver while the client is not online - log.Printf("Message receiver not found: %s", message.eid) - } - } - } -} diff --git a/backend/services/ws/internal/ws/ws.go b/backend/services/ws/internal/ws/ws.go deleted file mode 100644 index 8f62ea1..0000000 --- a/backend/services/ws/internal/ws/ws.go +++ /dev/null @@ -1,42 +0,0 @@ -package ws - -// Websockets server implementation inspired by https://github.com/gorilla/websocket/tree/main/examples/chat - -import ( - "log" - "net/http" - - "github.com/OktopUSP/oktopus/ws/internal/config" - "github.com/OktopUSP/oktopus/ws/internal/ws/handler" - "github.com/gorilla/mux" -) - -// Starts New Websockets Server -func StartNewServer(c config.Config) { - // Initialize handlers of websockets events - go handler.InitHandlers(c.ControllerEID) - - r := mux.NewRouter() - r.HandleFunc("/ws/agent", func(w http.ResponseWriter, r *http.Request) { - handler.ServeAgent(w, r, c.ControllerEID) - }) - r.HandleFunc("/ws/controller", func(w http.ResponseWriter, r *http.Request) { - handler.ServeController(w, r, c.Token, c.ControllerEID, c.Auth) - }) - - go func() { - if c.Tls { - log.Println("Websockets server running with TLS") - err := http.ListenAndServeTLS(c.Port, "cert.pem", "key.pem", r) - if err != nil { - log.Fatal("ListenAndServeTLS: ", err) - } - } else { - log.Println("Websockets server running") - err := http.ListenAndServe(c.Port, r) - if err != nil { - log.Fatal("ListenAndServe: ", err) - } - } - }() -}