group.go - release.projects.madb - Git at Google

 // Copyright 2016 The Vanadium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package main

 import (
 	"fmt"
 	"os"
 	"sort"
 	"strings"

 	"github.com/olekukonko/tablewriter"

 	"v.io/x/lib/cmdline"
 )

 var cmdMadbGroup = &cmdline.Command{
 	Children: []*cmdline.Command{
 		cmdMadbGroupAdd,
 		cmdMadbGroupClearAll,
 		cmdMadbGroupDelete,
 		cmdMadbGroupList,
 		cmdMadbGroupRemove,
 		cmdMadbGroupRename,
 	},
 	Name:             "group",
 	DontInheritFlags: true,
 	Short:            "Manage device groups",
 	Long: `
 Manages device groups, each of which can have one or more device members. The
 device groups can be used for specifying the target devices of other madb
 commands.
 `,
 }

 var cmdMadbGroupAdd = &cmdline.Command{
 	Runner: subCommandRunnerWithFilepath{runMadbGroupAdd, getDefaultConfigFilePath},
 	Name:   "add",
 	Short:  "Add members to a device group",
 	Long: `
 Adds members to a device group. This command also creates the group, if the
 group does not exist yet. The device group can be used when specifying devices
 in any madb commands.

 When creating a new device group with this command, the provided name must not
 conflict with an existing device nickname (see: madb help name set).

 A group can contain another device group, in which case all the members of the
 other group will also be considered as members of the current group.
 `,
 	ArgsName: "<group_name> <member1> [<member2> ...]",
 	ArgsLong: `
 <group_name> is an alpha-numeric string with no special characters or spaces.
 This name must not be an existing device nickname.

 <member> is a member specifier, which can be one of device serial, qualifier,
 device index (e.g., '@1', '@2'), device nickname, or another device group.
 `,
 }

 func runMadbGroupAdd(env *cmdline.Env, args []string, filename string) error {
 	// Check if the arguments are valid.
 	if len(args) < 2 {
 		return env.UsageErrorf("There must be at least two arguments.")
 	}

 	groupName := args[0]
 	if !isValidName(groupName) {
 		return fmt.Errorf("Not a valid group name: %q", groupName)
 	}

 	cfg, err := readConfig(filename)
 	if err != nil {
 		return err
 	}
 	if isDeviceNickname(groupName, cfg) {
 		return fmt.Errorf("The group name %q conflicts with a device nickname.", groupName)
 	}

 	members := removeDuplicates(args[1:])
 	for _, member := range members {
 		if err := isValidDeviceSpecifier(member); err != nil {
 			return fmt.Errorf("Invalid member %q: %v", member, err)
 		}
 	}

 	oldMembers, ok := cfg.Groups[groupName]
 	if !ok {
 		oldMembers = []string{}
 	}

 	cfg.Groups[groupName] = removeDuplicates(append(oldMembers, members...))
 	return writeConfig(cfg, filename)
 }

 var cmdMadbGroupClearAll = &cmdline.Command{
 	Runner: subCommandRunnerWithFilepath{runMadbGroupClearAll, getDefaultConfigFilePath},
 	Name:   "clear-all",
 	Short:  "Clear all the existing device groups",
 	Long: `
 Clears all the existing device groups.
 `,
 }

 func runMadbGroupClearAll(env *cmdline.Env, args []string, filename string) error {
 	cfg, err := readConfig(filename)
 	if err != nil {
 		return err
 	}

 	// Reset the groups
 	cfg.Groups = make(map[string][]string)

 	return writeConfig(cfg, filename)
 }

 var cmdMadbGroupDelete = &cmdline.Command{
 	Runner: subCommandRunnerWithFilepath{runMadbGroupDelete, getDefaultConfigFilePath},
 	Name:   "delete",
 	Short:  "Delete an existing device group",
 	Long: `
 Deletes an existing device group.
 `,
 	ArgsName: "<group_name1> [<group_name2> ...]",
 	ArgsLong: `
 <group_name> the name of an existing device group.
 You can specify more than one group names.
 `,
 }

 func runMadbGroupDelete(env *cmdline.Env, args []string, filename string) error {
 	// Check if the arguments are valid.
 	if len(args) < 1 {
 		return env.UsageErrorf("There must be at least one argument.")
 	}

 	cfg, err := readConfig(filename)
 	if err != nil {
 		return err
 	}
 	for _, groupName := range args {
 		if !isGroupName(groupName, cfg) {
 			return fmt.Errorf("Not an existing group name: %q", groupName)
 		}
 	}

 	// Delete the groups
 	for _, groupName := range args {
 		delete(cfg.Groups, groupName)
 	}

 	return writeConfig(cfg, filename)
 }

 var cmdMadbGroupList = &cmdline.Command{
 	Runner: subCommandRunnerWithFilepath{runMadbGroupList, getDefaultConfigFilePath},
 	Name:   "list",
 	Short:  "List all the existing device groups",
 	Long: `
 Lists the name and members of all the existing device groups.
 `,
 }

 func runMadbGroupList(env *cmdline.Env, args []string, filename string) error {
 	cfg, err := readConfig(filename)
 	if err != nil {
 		return err
 	}

 	tw := tablewriter.NewWriter(os.Stdout)
 	tw.SetHeader([]string{"Group Name", "Members"})
 	tw.SetHeaderAlignment(tablewriter.ALIGN_LEFT)
 	tw.SetAutoFormatHeaders(false)
 	tw.SetAlignment(tablewriter.ALIGN_LEFT)

 	data := make([][]string, 0, len(cfg.Groups))
 	for group, members := range cfg.Groups {
 		data = append(data, []string{group, strings.Join(members, " ")})
 	}

 	sort.Sort(byFirstElement(data))

 	for _, row := range data {
 		tw.Append(row)
 	}
 	tw.Render()

 	return nil
 }

 var cmdMadbGroupRemove = &cmdline.Command{
 	Runner: subCommandRunnerWithFilepath{runMadbGroupRemove, getDefaultConfigFilePath},
 	Name:   "remove",
 	Short:  "Remove members from a device group",
 	Long: `
 Removes members from an existing device group. If there are no remaining members
 after that, the group gets deleted.
 `,
 	ArgsName: "<group_name> <member1> [<member2> ...]",
 	ArgsLong: `
 <group_name> is an alpha-numeric string with no special characters or spaces.
 This name must be an existing device group name.

 <member> is a member specifier, which can be one of device serial, qualifier,
 device index (e.g., '@1', '@2'), device nickname, or another device group.
 `,
 }

 func runMadbGroupRemove(env *cmdline.Env, args []string, filename string) error {
 	// Check if the arguments are valid.
 	if len(args) < 2 {
 		return env.UsageErrorf("There must be at least two arguments.")
 	}

 	groupName := args[0]
 	if !isValidName(groupName) {
 		return fmt.Errorf("Not a valid group name: %q", groupName)
 	}

 	cfg, err := readConfig(filename)
 	if err != nil {
 		return err
 	}
 	if !isGroupName(groupName, cfg) {
 		return fmt.Errorf("Not an existing group name: %q", groupName)
 	}

 	members := removeDuplicates(args[1:])
 	oldMembers := cfg.Groups[groupName]
 	cfg.Groups[groupName] = subtractSlices(oldMembers, members)

 	if len(cfg.Groups[groupName]) == 0 {
 		delete(cfg.Groups, groupName)
 	}

 	return writeConfig(cfg, filename)
 }

 var cmdMadbGroupRename = &cmdline.Command{
 	Runner: subCommandRunnerWithFilepath{runMadbGroupRename, getDefaultConfigFilePath},
 	Name:   "rename",
 	Short:  "Rename an existing device group",
 	Long: `
 Renames an existing device group.
 `,
 	ArgsName: "<old_name> <new_name>",
 	ArgsLong: `
 <old_name> is the name of an existing device group.

 <new_name> is the new name for the existing group.
 This must be an alpha-numeric string with no special characters or spaces,
 and must not conflict with another existing device or group name.
 `,
 }

 func runMadbGroupRename(env *cmdline.Env, args []string, filename string) error {
 	// Check if the arguments are valid.
 	if len(args) != 2 {
 		return env.UsageErrorf("There must be exactly two arguments.")
 	}

 	oldName, newName := args[0], args[1]
 	if !isValidName(oldName) {
 		return fmt.Errorf("Not a valid group name: %q", oldName)
 	}
 	if !isValidName(newName) {
 		return fmt.Errorf("Not a valid group name: %q", newName)
 	}

 	cfg, err := readConfig(filename)
 	if err != nil {
 		return err
 	}
 	if !isGroupName(oldName, cfg) {
 		return fmt.Errorf("Not an existing group name: %q", oldName)
 	}
 	if isNameInUse(newName, cfg) {
 		return fmt.Errorf("The provided name is already in use: %q", newName)
 	}

 	cfg.Groups[newName] = cfg.Groups[oldName]
 	delete(cfg.Groups, oldName)

 	return writeConfig(cfg, filename)
 }

 // removeDuplicates takes a string slice and removes all the duplicates.
 func removeDuplicates(s []string) []string {
 	result := make([]string, 0, len(s))

 	used := map[string]bool{}
 	for _, elem := range s {
 		if !used[elem] {
 			result = append(result, elem)
 			used[elem] = true
 		}
 	}

 	return result
 }

 // subtractSlices takes two slices and returns a new slice formed by removing
 // all the elements in s2 from s1.
 func subtractSlices(s1, s2 []string) []string {
 	result := make([]string, 0, len(s1))

 	m := map[string]bool{}
 	for _, e2 := range s2 {
 		m[e2] = true
 	}

 	for _, e1 := range s1 {
 		if !m[e1] {
 			result = append(result, e1)
 		}
 	}

 	return result
 }

 // expandGroups takes a slice of device specifier tokens and returns a new slice
 // where all the group name tokens are expanded to include all their members.
 // The expansion process is transitive; if a group includes other groups, all
 // the members of the other groups are also included in the returned slice. Each
 // group is processed at most once, in order to avoid infinite loops.
 func expandGroups(tokens []string, cfg *config) []string {
 	expanded := make([]string, 0, len(tokens))

 	queue := make([]string, len(tokens))
 	copy(queue, tokens)

 	visitedGroups := make(map[string]bool)

 	for len(queue) > 0 {
 		// Pop a token from the queue
 		token := queue[0]
 		queue = queue[1:]

 		if isGroupName(token, cfg) {
 			// If this group was already processed before, ignore and proceed
 			// to the next token to avoid infinite loops.
 			if visitedGroups[token] {
 				continue
 			}
 			visitedGroups[token] = true

 			// Otherwise, expand the group and add all the members to the queue.
 			queue = append(queue, cfg.Groups[token]...)
 		} else {
 			expanded = append(expanded, token)
 		}
 	}

 	return expanded
 }
	// Copyright 2016 The Vanadium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package main

	import (
	"fmt"
	"os"
	"sort"
	"strings"

	"github.com/olekukonko/tablewriter"

	"v.io/x/lib/cmdline"
	)

	var cmdMadbGroup = &cmdline.Command{
	Children: []*cmdline.Command{
	cmdMadbGroupAdd,
	cmdMadbGroupClearAll,
	cmdMadbGroupDelete,
	cmdMadbGroupList,
	cmdMadbGroupRemove,
	cmdMadbGroupRename,
	},
	Name: "group",
	DontInheritFlags: true,
	Short: "Manage device groups",
	Long: `
	Manages device groups, each of which can have one or more device members. The
	device groups can be used for specifying the target devices of other madb
	commands.
	`,
	}

	var cmdMadbGroupAdd = &cmdline.Command{
	Runner: subCommandRunnerWithFilepath{runMadbGroupAdd, getDefaultConfigFilePath},
	Name: "add",
	Short: "Add members to a device group",
	Long: `
	Adds members to a device group. This command also creates the group, if the
	group does not exist yet. The device group can be used when specifying devices
	in any madb commands.

	When creating a new device group with this command, the provided name must not
	conflict with an existing device nickname (see: madb help name set).

	A group can contain another device group, in which case all the members of the
	other group will also be considered as members of the current group.
	`,
	ArgsName: "<group_name> <member1> [<member2> ...]",
	ArgsLong: `
	<group_name> is an alpha-numeric string with no special characters or spaces.
	This name must not be an existing device nickname.

	<member> is a member specifier, which can be one of device serial, qualifier,
	device index (e.g., '@1', '@2'), device nickname, or another device group.
	`,
	}

	func runMadbGroupAdd(env *cmdline.Env, args []string, filename string) error {
	// Check if the arguments are valid.
	if len(args) < 2 {
	return env.UsageErrorf("There must be at least two arguments.")
	}

	groupName := args[0]
	if !isValidName(groupName) {
	return fmt.Errorf("Not a valid group name: %q", groupName)
	}

	cfg, err := readConfig(filename)
	if err != nil {
	return err
	}
	if isDeviceNickname(groupName, cfg) {
	return fmt.Errorf("The group name %q conflicts with a device nickname.", groupName)
	}

	members := removeDuplicates(args[1:])
	for _, member := range members {
	if err := isValidDeviceSpecifier(member); err != nil {
	return fmt.Errorf("Invalid member %q: %v", member, err)
	}
	}

	oldMembers, ok := cfg.Groups[groupName]
	if !ok {
	oldMembers = []string{}
	}

	cfg.Groups[groupName] = removeDuplicates(append(oldMembers, members...))
	return writeConfig(cfg, filename)
	}

	var cmdMadbGroupClearAll = &cmdline.Command{
	Runner: subCommandRunnerWithFilepath{runMadbGroupClearAll, getDefaultConfigFilePath},
	Name: "clear-all",
	Short: "Clear all the existing device groups",
	Long: `
	Clears all the existing device groups.
	`,
	}

	func runMadbGroupClearAll(env *cmdline.Env, args []string, filename string) error {
	cfg, err := readConfig(filename)
	if err != nil {
	return err
	}

	// Reset the groups
	cfg.Groups = make(map[string][]string)

	return writeConfig(cfg, filename)
	}

	var cmdMadbGroupDelete = &cmdline.Command{
	Runner: subCommandRunnerWithFilepath{runMadbGroupDelete, getDefaultConfigFilePath},
	Name: "delete",
	Short: "Delete an existing device group",
	Long: `
	Deletes an existing device group.
	`,
	ArgsName: "<group_name1> [<group_name2> ...]",
	ArgsLong: `
	<group_name> the name of an existing device group.
	You can specify more than one group names.
	`,
	}

	func runMadbGroupDelete(env *cmdline.Env, args []string, filename string) error {
	// Check if the arguments are valid.
	if len(args) < 1 {
	return env.UsageErrorf("There must be at least one argument.")
	}

	cfg, err := readConfig(filename)
	if err != nil {
	return err
	}
	for _, groupName := range args {
	if !isGroupName(groupName, cfg) {
	return fmt.Errorf("Not an existing group name: %q", groupName)
	}
	}

	// Delete the groups
	for _, groupName := range args {
	delete(cfg.Groups, groupName)
	}

	return writeConfig(cfg, filename)
	}

	var cmdMadbGroupList = &cmdline.Command{
	Runner: subCommandRunnerWithFilepath{runMadbGroupList, getDefaultConfigFilePath},
	Name: "list",
	Short: "List all the existing device groups",
	Long: `
	Lists the name and members of all the existing device groups.
	`,
	}

	func runMadbGroupList(env *cmdline.Env, args []string, filename string) error {
	cfg, err := readConfig(filename)
	if err != nil {
	return err
	}

	tw := tablewriter.NewWriter(os.Stdout)
	tw.SetHeader([]string{"Group Name", "Members"})
	tw.SetHeaderAlignment(tablewriter.ALIGN_LEFT)
	tw.SetAutoFormatHeaders(false)
	tw.SetAlignment(tablewriter.ALIGN_LEFT)

	data := make([][]string, 0, len(cfg.Groups))
	for group, members := range cfg.Groups {
	data = append(data, []string{group, strings.Join(members, " ")})
	}

	sort.Sort(byFirstElement(data))

	for _, row := range data {
	tw.Append(row)
	}
	tw.Render()

	return nil
	}

	var cmdMadbGroupRemove = &cmdline.Command{
	Runner: subCommandRunnerWithFilepath{runMadbGroupRemove, getDefaultConfigFilePath},
	Name: "remove",
	Short: "Remove members from a device group",
	Long: `
	Removes members from an existing device group. If there are no remaining members
	after that, the group gets deleted.
	`,
	ArgsName: "<group_name> <member1> [<member2> ...]",
	ArgsLong: `
	<group_name> is an alpha-numeric string with no special characters or spaces.
	This name must be an existing device group name.

	<member> is a member specifier, which can be one of device serial, qualifier,
	device index (e.g., '@1', '@2'), device nickname, or another device group.
	`,
	}

	func runMadbGroupRemove(env *cmdline.Env, args []string, filename string) error {
	// Check if the arguments are valid.
	if len(args) < 2 {
	return env.UsageErrorf("There must be at least two arguments.")
	}

	groupName := args[0]
	if !isValidName(groupName) {
	return fmt.Errorf("Not a valid group name: %q", groupName)
	}

	cfg, err := readConfig(filename)
	if err != nil {
	return err
	}
	if !isGroupName(groupName, cfg) {
	return fmt.Errorf("Not an existing group name: %q", groupName)
	}

	members := removeDuplicates(args[1:])
	oldMembers := cfg.Groups[groupName]
	cfg.Groups[groupName] = subtractSlices(oldMembers, members)

	if len(cfg.Groups[groupName]) == 0 {
	delete(cfg.Groups, groupName)
	}

	return writeConfig(cfg, filename)
	}

	var cmdMadbGroupRename = &cmdline.Command{
	Runner: subCommandRunnerWithFilepath{runMadbGroupRename, getDefaultConfigFilePath},
	Name: "rename",
	Short: "Rename an existing device group",
	Long: `
	Renames an existing device group.
	`,
	ArgsName: "<old_name> <new_name>",
	ArgsLong: `
	<old_name> is the name of an existing device group.

	<new_name> is the new name for the existing group.
	This must be an alpha-numeric string with no special characters or spaces,
	and must not conflict with another existing device or group name.
	`,
	}

	func runMadbGroupRename(env *cmdline.Env, args []string, filename string) error {
	// Check if the arguments are valid.
	if len(args) != 2 {
	return env.UsageErrorf("There must be exactly two arguments.")
	}

	oldName, newName := args[0], args[1]
	if !isValidName(oldName) {
	return fmt.Errorf("Not a valid group name: %q", oldName)
	}
	if !isValidName(newName) {
	return fmt.Errorf("Not a valid group name: %q", newName)
	}

	cfg, err := readConfig(filename)
	if err != nil {
	return err
	}
	if !isGroupName(oldName, cfg) {
	return fmt.Errorf("Not an existing group name: %q", oldName)
	}
	if isNameInUse(newName, cfg) {
	return fmt.Errorf("The provided name is already in use: %q", newName)
	}

	cfg.Groups[newName] = cfg.Groups[oldName]
	delete(cfg.Groups, oldName)

	return writeConfig(cfg, filename)
	}

	// removeDuplicates takes a string slice and removes all the duplicates.
	func removeDuplicates(s []string) []string {
	result := make([]string, 0, len(s))

	used := map[string]bool{}
	for _, elem := range s {
	if !used[elem] {
	result = append(result, elem)
	used[elem] = true
	}
	}

	return result
	}

	// subtractSlices takes two slices and returns a new slice formed by removing
	// all the elements in s2 from s1.
	func subtractSlices(s1, s2 []string) []string {
	result := make([]string, 0, len(s1))

	m := map[string]bool{}
	for _, e2 := range s2 {
	m[e2] = true
	}

	for _, e1 := range s1 {
	if !m[e1] {
	result = append(result, e1)
	}
	}

	return result
	}

	// expandGroups takes a slice of device specifier tokens and returns a new slice
	// where all the group name tokens are expanded to include all their members.
	// The expansion process is transitive; if a group includes other groups, all
	// the members of the other groups are also included in the returned slice. Each
	// group is processed at most once, in order to avoid infinite loops.
	func expandGroups(tokens []string, cfg *config) []string {
	expanded := make([]string, 0, len(tokens))

	queue := make([]string, len(tokens))
	copy(queue, tokens)

	visitedGroups := make(map[string]bool)

	for len(queue) > 0 {
	// Pop a token from the queue
	token := queue[0]
	queue = queue[1:]

	if isGroupName(token, cfg) {
	// If this group was already processed before, ignore and proceed
	// to the next token to avoid infinite loops.
	if visitedGroups[token] {
	continue
	}
	visitedGroups[token] = true

	// Otherwise, expand the group and add all the members to the queue.
	queue = append(queue, cfg.Groups[token]...)
	} else {
	expanded = append(expanded, token)
	}
	}

	return expanded
	}