blob: f95177e946cafc6ff61a9055c3f88276e68b7d9f [file] [log] [blame]
/*
* Portions copyright 2019-present Open Networking Foundation
* Original copyright 2019-present Ciena Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package commands
import (
"context"
"fmt"
"github.com/fullstorydev/grpcurl"
flags "github.com/jessevdk/go-flags"
"github.com/jhump/protoreflect/dynamic"
"google.golang.org/grpc"
"sort"
"strings"
"time"
)
const (
DEFAULT_CREATE_FORMAT = "table{{ .Id }}\t{{ .Message }}"
DEFAULT_DELETE_FORMAT = "table{{ .Id }}\t{{ .Message }}"
DEFAULT_UPDATE_FORMAT = "table{{ .Id }}\t{{ .Message }}"
DEFAULT_SYNC_FORMAT = "table{{ .Id }}\t{{ .Message }}"
)
type ModelNameString string
type ModelList struct {
ListOutputOptions
ShowHidden bool `long:"showhidden" description:"Show hidden fields in default output"`
ShowFeedback bool `long:"showfeedback" description:"Show feedback fields in default output"`
ShowBookkeeping bool `long:"showbookkeeping" description:"Show bookkeeping fields in default output"`
Filter string `short:"f" long:"filter" description:"Comma-separated list of filters"`
State string `short:"s" long:"state" description:"Filter model state [DEFAULT | ALL | DIRTY | DELETED | DIRTYPOL | DELETEDPOL]"`
Args struct {
ModelName ModelNameString
} `positional-args:"yes" required:"yes"`
}
type ModelUpdate struct {
OutputOptions
Unbuffered bool `short:"u" long:"unbuffered" description:"Do not buffer console output and suppress default output processor"`
Filter string `short:"f" long:"filter" description:"Comma-separated list of filters"`
SetFields string `long:"set-field" description:"Comma-separated list of field=value to set"`
SetJSON string `long:"set-json" description:"JSON dictionary to use for settings fields"`
Sync bool `long:"sync" description:"Synchronize before returning"`
SyncTimeout time.Duration `long:"synctimeout" default:"600s" description:"Timeout for --sync option"`
Args struct {
ModelName ModelNameString
} `positional-args:"yes" required:"yes"`
IDArgs struct {
ID []int32
} `positional-args:"yes" required:"no"`
}
type ModelDelete struct {
OutputOptions
Unbuffered bool `short:"u" long:"unbuffered" description:"Do not buffer console output and suppress default output processor"`
Filter string `short:"f" long:"filter" description:"Comma-separated list of filters"`
All bool `short:"a" long:"all" description:"Operate on all models"`
Args struct {
ModelName ModelNameString
} `positional-args:"yes" required:"yes"`
IDArgs struct {
ID []int32
} `positional-args:"yes" required:"no"`
}
type ModelCreate struct {
OutputOptions
Unbuffered bool `short:"u" long:"unbuffered" description:"Do not buffer console output"`
SetFields string `long:"set-field" description:"Comma-separated list of field=value to set"`
SetJSON string `long:"set-json" description:"JSON dictionary to use for settings fields"`
Sync bool `long:"sync" description:"Synchronize before returning"`
SyncTimeout time.Duration `long:"synctimeout" default:"600s" description:"Timeout for --sync option"`
Args struct {
ModelName ModelNameString
} `positional-args:"yes" required:"yes"`
}
type ModelSync struct {
OutputOptions
Unbuffered bool `short:"u" long:"unbuffered" description:"Do not buffer console output and suppress default output processor"`
Filter string `short:"f" long:"filter" description:"Comma-separated list of filters"`
SyncTimeout time.Duration `long:"synctimeout" default:"600s" description:"Timeout for synchronization"`
All bool `short:"a" long:"all" description:"Operate on all models"`
Args struct {
ModelName ModelNameString
} `positional-args:"yes" required:"yes"`
IDArgs struct {
ID []int32
} `positional-args:"yes" required:"no"`
}
type ModelSetDirty struct {
OutputOptions
Unbuffered bool `short:"u" long:"unbuffered" description:"Do not buffer console output and suppress default output processor"`
Filter string `short:"f" long:"filter" description:"Comma-separated list of filters"`
All bool `short:"a" long:"all" description:"Operate on all models"`
Args struct {
ModelName ModelNameString
} `positional-args:"yes" required:"yes"`
IDArgs struct {
ID []int32
} `positional-args:"yes" required:"no"`
}
type ModelOpts struct {
List ModelList `command:"list"`
Update ModelUpdate `command:"update"`
Delete ModelDelete `command:"delete"`
Create ModelCreate `command:"create"`
Sync ModelSync `command:"sync"`
SetDirty ModelSetDirty `command:"setdirty"`
}
type ModelStatusOutputRow struct {
Id interface{} `json:"id"`
Message string `json:"message"`
}
type ModelStatusOutput struct {
Rows []ModelStatusOutputRow
Unbuffered bool
}
var modelOpts = ModelOpts{}
func RegisterModelCommands(parser *flags.Parser) {
parser.AddCommand("model", "model commands", "Commands to query and manipulate XOS models", &modelOpts)
}
// Initialize ModelStatusOutput structure, creating a row for each model that will be output
func InitModelStatusOutput(unbuffered bool, count int) ModelStatusOutput {
return ModelStatusOutput{Rows: make([]ModelStatusOutputRow, count), Unbuffered: unbuffered}
}
// Update model status output row for the model
// If unbuffered is set then we will output directly to the console. Regardless of the unbuffered
// setting, we always update the row, as callers may check that row for status.
// Args:
// output - ModelStatusOutput struct to update
// i - index of row to update
// id - id of model, <nil> if no model exists
// status - status text to set if there is no error
// errror - if non-nil, then apply error text instead of status text
// final - true if successful status should be reported, false if successful status is yet to come
func UpdateModelStatusOutput(output *ModelStatusOutput, i int, id interface{}, status string, err error, final bool) {
if err != nil {
if output.Unbuffered {
fmt.Printf("%v: %s\n", id, HumanReadableError(err))
}
output.Rows[i] = ModelStatusOutputRow{Id: id, Message: HumanReadableError(err)}
} else {
if output.Unbuffered && final {
fmt.Println(id)
}
output.Rows[i] = ModelStatusOutputRow{Id: id, Message: status}
}
}
// Convert a user-supplied state filter argument to the appropriate enum name
func GetFilterKind(kindArg string) (string, error) {
kindMap := map[string]string{
"default": FILTER_DEFAULT,
"all": FILTER_ALL,
"dirty": FILTER_DIRTY,
"deleted": FILTER_DELETED,
"dirtypol": FILTER_DIRTYPOL,
"deletedpo": FILTER_DELETEDPOL,
}
// If no arg then use default
if kindArg == "" {
return kindMap["default"], nil
}
val, ok := kindMap[strings.ToLower(kindArg)]
if !ok {
return "", fmt.Errorf("Failed to understand model state %s", kindArg)
}
return val, nil
}
// Common processing for commands that take a modelname and a list of ids or a filter
func GetIDList(conn *grpc.ClientConn, descriptor grpcurl.DescriptorSource, modelName string, ids []int32, filter string, all bool) ([]int32, error) {
err := CheckModelName(descriptor, modelName)
if err != nil {
return nil, err
}
// we require exactly one of ID, --filter, or --all
exclusiveCount := 0
if len(ids) > 0 {
exclusiveCount++
}
if filter != "" {
exclusiveCount++
}
if all {
exclusiveCount++
}
if (exclusiveCount == 0) || (exclusiveCount > 1) {
return nil, fmt.Errorf("Use either an ID, --filter, or --all to specify which models to operate on")
}
queries, err := CommaSeparatedQueryToMap(filter, true)
if err != nil {
return nil, err
}
if len(ids) > 0 {
// do nothing
} else {
models, err := ListOrFilterModels(context.Background(), conn, descriptor, modelName, FILTER_DEFAULT, queries)
if err != nil {
return nil, err
}
ids = make([]int32, len(models))
for i, model := range models {
ids[i] = model.GetFieldByName("id").(int32)
}
if len(ids) == 0 {
return nil, fmt.Errorf("Filter matches no objects")
} else if len(ids) > 1 {
if !Confirmf("Filter matches %d objects. Continue [y/n] ? ", len(models)) {
return nil, fmt.Errorf("Aborted by user")
}
}
}
return ids, nil
}
func (options *ModelList) Execute(args []string) error {
conn, descriptor, err := InitReflectionClient()
if err != nil {
return err
}
defer conn.Close()
err = CheckModelName(descriptor, string(options.Args.ModelName))
if err != nil {
return err
}
filterKind, err := GetFilterKind(options.State)
if err != nil {
return err
}
queries, err := CommaSeparatedQueryToMap(options.Filter, true)
if err != nil {
return err
}
models, err := ListOrFilterModels(context.Background(), conn, descriptor, string(options.Args.ModelName), filterKind, queries)
if err != nil {
return err
}
var field_names []string
data := make([]map[string]interface{}, len(models))
for i, val := range models {
data[i] = make(map[string]interface{})
for _, field_desc := range val.GetKnownFields() {
field_name := field_desc.GetName()
isGuiHidden := strings.Contains(field_desc.GetFieldOptions().String(), "1005:1")
isFeedback := strings.Contains(field_desc.GetFieldOptions().String(), "1006:1")
isBookkeeping := strings.Contains(field_desc.GetFieldOptions().String(), "1007:1")
if isGuiHidden && (!options.ShowHidden) {
continue
}
if isFeedback && (!options.ShowFeedback) {
continue
}
if isBookkeeping && (!options.ShowBookkeeping) {
continue
}
if field_desc.IsRepeated() {
continue
}
data[i][field_name] = val.GetFieldByName(field_name)
// Every row has the same set of known field names, so it suffices to use the names
// from the first row.
if i == 0 {
field_names = append(field_names, field_name)
}
}
}
// Sort field names, making sure "id" appears first
sort.SliceStable(field_names, func(i, j int) bool {
if field_names[i] == "id" {
return true
} else if field_names[j] == "id" {
return false
} else {
return (field_names[i] < field_names[j])
}
})
var default_format strings.Builder
default_format.WriteString("table")
for i, field_name := range field_names {
if i == 0 {
fmt.Fprintf(&default_format, "{{ .%s }}", field_name)
} else {
fmt.Fprintf(&default_format, "\t{{ .%s }}", field_name)
}
}
FormatAndGenerateListOutput(&options.ListOutputOptions, default_format.String(), "{{.id}}", data)
return nil
}
func (options *ModelUpdate) Execute(args []string) error {
conn, descriptor, err := InitReflectionClient()
if err != nil {
return err
}
defer conn.Close()
err = CheckModelName(descriptor, string(options.Args.ModelName))
if err != nil {
return err
}
if (len(options.IDArgs.ID) == 0 && len(options.Filter) == 0) ||
(len(options.IDArgs.ID) != 0 && len(options.Filter) != 0) {
return fmt.Errorf("Use either an ID or a --filter to specify which models to update")
}
queries, err := CommaSeparatedQueryToMap(options.Filter, true)
if err != nil {
return err
}
updates, err := CommaSeparatedQueryToMap(options.SetFields, true)
if err != nil {
return err
}
modelName := string(options.Args.ModelName)
var models []*dynamic.Message
if len(options.IDArgs.ID) > 0 {
models = make([]*dynamic.Message, len(options.IDArgs.ID))
for i, id := range options.IDArgs.ID {
models[i], err = GetModel(context.Background(), conn, descriptor, modelName, id)
if err != nil {
return err
}
}
} else {
models, err = ListOrFilterModels(context.Background(), conn, descriptor, modelName, FILTER_DEFAULT, queries)
if err != nil {
return err
}
}
if len(models) == 0 {
return fmt.Errorf("Filter matches no objects")
} else if len(models) > 1 {
if !Confirmf("Filter matches %d objects. Continue [y/n] ? ", len(models)) {
return fmt.Errorf("Aborted by user")
}
}
fields := make(map[string]interface{})
if len(options.SetJSON) > 0 {
fields["_json"] = []byte(options.SetJSON)
}
for fieldName, value := range updates {
value = value[1:]
proto_value, err := TypeConvert(descriptor, modelName, fieldName, value)
if err != nil {
return err
}
fields[fieldName] = proto_value
}
modelStatusOutput := InitModelStatusOutput(options.Unbuffered, len(models))
for i, model := range models {
id := model.GetFieldByName("id").(int32)
fields["id"] = id
err := UpdateModel(conn, descriptor, modelName, fields)
UpdateModelStatusOutput(&modelStatusOutput, i, id, "Updated", err, !options.Sync)
}
if options.Sync {
ctx, cancel := context.WithTimeout(context.Background(), options.SyncTimeout)
defer cancel()
for i, model := range models {
id := model.GetFieldByName("id").(int32)
if modelStatusOutput.Rows[i].Message == "Updated" {
conditional_printf(!options.Quiet, "Wait for sync: %d ", id)
conn, _, err = GetModelWithRetry(ctx, conn, descriptor, modelName, id, GM_UNTIL_ENACTED|Ternary_uint32(options.Quiet, GM_QUIET, 0))
conditional_printf(!options.Quiet, "\n")
UpdateModelStatusOutput(&modelStatusOutput, i, id, "Enacted", err, true)
}
}
}
if !options.Unbuffered {
FormatAndGenerateOutput(&options.OutputOptions, DEFAULT_UPDATE_FORMAT, DEFAULT_UPDATE_FORMAT, modelStatusOutput.Rows)
}
return nil
}
func (options *ModelDelete) Execute(args []string) error {
conn, descriptor, err := InitReflectionClient()
if err != nil {
return err
}
defer conn.Close()
modelName := string(options.Args.ModelName)
ids, err := GetIDList(conn, descriptor, modelName, options.IDArgs.ID, options.Filter, options.All)
if err != nil {
return err
}
modelStatusOutput := InitModelStatusOutput(options.Unbuffered, len(ids))
for i, id := range ids {
err = DeleteModel(conn, descriptor, modelName, id)
UpdateModelStatusOutput(&modelStatusOutput, i, id, "Deleted", err, true)
}
if !options.Unbuffered {
FormatAndGenerateOutput(&options.OutputOptions, DEFAULT_DELETE_FORMAT, DEFAULT_DELETE_FORMAT, modelStatusOutput.Rows)
}
return nil
}
func (options *ModelCreate) Execute(args []string) error {
conn, descriptor, err := InitReflectionClient()
if err != nil {
return err
}
defer conn.Close()
err = CheckModelName(descriptor, string(options.Args.ModelName))
if err != nil {
return err
}
updates, err := CommaSeparatedQueryToMap(options.SetFields, true)
if err != nil {
return err
}
modelName := string(options.Args.ModelName)
fields := make(map[string]interface{})
if len(options.SetJSON) > 0 {
fields["_json"] = []byte(options.SetJSON)
}
for fieldName, value := range updates {
value = value[1:]
proto_value, err := TypeConvert(descriptor, modelName, fieldName, value)
if err != nil {
return err
}
fields[fieldName] = proto_value
}
modelStatusOutput := InitModelStatusOutput(options.Unbuffered, 1)
err = CreateModel(conn, descriptor, modelName, fields)
UpdateModelStatusOutput(&modelStatusOutput, 0, fields["id"], "Created", err, !options.Sync)
if options.Sync {
ctx, cancel := context.WithTimeout(context.Background(), options.SyncTimeout)
defer cancel()
if modelStatusOutput.Rows[0].Message == "Created" {
id := fields["id"].(int32)
conditional_printf(!options.Quiet, "Wait for sync: %d ", id)
conn, _, err = GetModelWithRetry(ctx, conn, descriptor, modelName, id, GM_UNTIL_ENACTED|Ternary_uint32(options.Quiet, GM_QUIET, 0))
conditional_printf(!options.Quiet, "\n")
UpdateModelStatusOutput(&modelStatusOutput, 0, id, "Enacted", err, true)
}
}
if !options.Unbuffered {
FormatAndGenerateOutput(&options.OutputOptions, DEFAULT_CREATE_FORMAT, DEFAULT_CREATE_FORMAT, modelStatusOutput.Rows)
}
return nil
}
func (options *ModelSync) Execute(args []string) error {
conn, descriptor, err := InitReflectionClient()
if err != nil {
return err
}
defer conn.Close()
modelName := string(options.Args.ModelName)
ids, err := GetIDList(conn, descriptor, modelName, options.IDArgs.ID, options.Filter, options.All)
if err != nil {
return err
}
ctx, cancel := context.WithTimeout(context.Background(), options.SyncTimeout)
defer cancel()
modelStatusOutput := InitModelStatusOutput(options.Unbuffered, len(ids))
for i, id := range ids {
conditional_printf(!options.Quiet, "Wait for sync: %d ", id)
conn, _, err = GetModelWithRetry(ctx, conn, descriptor, modelName, id, GM_UNTIL_ENACTED|Ternary_uint32(options.Quiet, GM_QUIET, 0))
conditional_printf(!options.Quiet, "\n")
UpdateModelStatusOutput(&modelStatusOutput, i, id, "Enacted", err, true)
}
if !options.Unbuffered {
FormatAndGenerateOutput(&options.OutputOptions, DEFAULT_SYNC_FORMAT, DEFAULT_SYNC_FORMAT, modelStatusOutput.Rows)
}
return nil
}
func (options *ModelSetDirty) Execute(args []string) error {
conn, descriptor, err := InitReflectionClient()
if err != nil {
return err
}
defer conn.Close()
modelName := string(options.Args.ModelName)
ids, err := GetIDList(conn, descriptor, modelName, options.IDArgs.ID, options.Filter, options.All)
if err != nil {
return err
}
modelStatusOutput := InitModelStatusOutput(options.Unbuffered, len(ids))
for i, id := range ids {
updateMap := map[string]interface{}{"id": id}
err := UpdateModel(conn, descriptor, modelName, updateMap)
UpdateModelStatusOutput(&modelStatusOutput, i, id, "Dirtied", err, true)
}
if !options.Unbuffered {
FormatAndGenerateOutput(&options.OutputOptions, DEFAULT_SYNC_FORMAT, DEFAULT_SYNC_FORMAT, modelStatusOutput.Rows)
}
return nil
}
func (modelName *ModelNameString) Complete(match string) []flags.Completion {
conn, descriptor, err := InitReflectionClient()
if err != nil {
return nil
}
defer conn.Close()
models, err := GetModelNames(descriptor)
if err != nil {
return nil
}
list := make([]flags.Completion, 0)
for k := range models {
if strings.HasPrefix(k, match) {
list = append(list, flags.Completion{Item: k})
}
}
return list
}