blob: b5f404ce5f992f9fff89384c86e9d79ca2d9bd93 [file] [log] [blame]
// Copyright 2021 The Chromium 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 cachingservice
import (
"fmt"
"strconv"
"strings"
"github.com/maruel/subcommands"
"go.chromium.org/luci/auth/client/authcli"
"go.chromium.org/luci/common/cli"
"go.chromium.org/luci/grpc/prpc"
"infra/cmd/shivas/cmdhelp"
"infra/cmd/shivas/site"
"infra/cmd/shivas/utils"
"infra/cmdsupport/cmdlib"
ufspb "infra/unifiedfleet/api/v1/models"
ufsAPI "infra/unifiedfleet/api/v1/rpc"
ufsUtil "infra/unifiedfleet/app/util"
)
// defaultCachingServicePort is the default port for the CachingService.
const defaultCachingServicePort = 8082
// AddCachingServiceCmd add CachingService to the system.
var AddCachingServiceCmd = &subcommands.Command{
UsageLine: "cachingservice",
ShortDesc: "Add CachingService",
LongDesc: cmdhelp.AddCachingServiceLongDesc,
CommandRun: func() subcommands.CommandRun {
c := &addCachingService{}
c.authFlags.Register(&c.Flags, site.DefaultAuthOptions)
c.envFlags.Register(&c.Flags)
c.commonFlags.Register(&c.Flags)
c.Flags.StringVar(&c.newSpecsFile, "f", "", cmdhelp.CachingServiceFileText)
c.Flags.StringVar(&c.name, "name", "", "name of the CachingService")
c.Flags.IntVar(&c.port, "port", defaultCachingServicePort, "port number of the CachingService")
c.Flags.Var(utils.CSVString(&c.subnets), "subnets", "comma separated subnet list which this CachingService serves/supports")
c.Flags.StringVar(&c.primary, "primary", "", "primary node ip of the CachingService")
c.Flags.StringVar(&c.secondary, "secondary", "", "secondary node ip of the CachingService")
c.Flags.StringVar(&c.state, "state", "", cmdhelp.StateHelp)
c.Flags.StringVar(&c.description, "desc", "", "description for the CachingService")
return c
},
}
type addCachingService struct {
subcommands.CommandRunBase
authFlags authcli.Flags
envFlags site.EnvFlags
commonFlags site.CommonFlags
newSpecsFile string
name string
port int
subnets []string
primary string
secondary string
state string
description string
}
var mcsvFields = []string{
"name",
"port",
"subnets",
"primary",
"secondary",
"state",
"desc",
}
func (c *addCachingService) Run(a subcommands.Application, args []string, env subcommands.Env) int {
if err := c.innerRun(a, args, env); err != nil {
cmdlib.PrintError(a, err)
return 1
}
return 0
}
func (c *addCachingService) innerRun(a subcommands.Application, args []string, env subcommands.Env) error {
if err := c.validateArgs(); err != nil {
return err
}
ctx := cli.GetContext(a, c, env)
ctx = utils.SetupContext(ctx, ufsUtil.OSNamespace)
hc, err := cmdlib.NewHTTPClient(ctx, &c.authFlags)
if err != nil {
return err
}
e := c.envFlags.Env()
if c.commonFlags.Verbose() {
fmt.Printf("Using UFS service %s\n", e.UnifiedFleetService)
}
ic := ufsAPI.NewFleetPRPCClient(&prpc.Client{
C: hc,
Host: e.UnifiedFleetService,
Options: site.DefaultPRPCOptions,
})
var cs ufspb.CachingService
var cachingServices []*ufspb.CachingService
if c.newSpecsFile != "" {
if utils.IsCSVFile(c.newSpecsFile) {
cachingServices, err = c.parseMCSV()
if err != nil {
return err
}
} else {
if err = utils.ParseJSONFile(c.newSpecsFile, &cs); err != nil {
return err
}
}
} else {
c.parseArgs(&cs)
}
if len(cachingServices) == 0 {
cachingServices = append(cachingServices, &cs)
}
for _, r := range cachingServices {
res, err := ic.CreateCachingService(ctx, &ufsAPI.CreateCachingServiceRequest{
CachingService: r,
CachingServiceId: r.GetName(),
})
if err != nil {
fmt.Printf("Failed to add CachingService %s. %s\n", r.GetName(), err)
continue
}
res.Name = ufsUtil.RemovePrefix(res.Name)
utils.PrintProtoJSON(res, !utils.NoEmitMode(false))
fmt.Printf("Successfully added the CachingService %s\n", res.Name)
}
return nil
}
func (c *addCachingService) parseArgs(cs *ufspb.CachingService) {
cs.Name = c.name
cs.Port = int32(c.port)
cs.ServingSubnets = c.subnets
cs.PrimaryNode = c.primary
cs.SecondaryNode = c.secondary
cs.State = ufsUtil.ToUFSState(c.state)
cs.Description = c.description
}
func (c *addCachingService) validateArgs() error {
if c.newSpecsFile != "" {
if c.name != "" {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\nThe file mode is specified. '-name' cannot be specified at the same time.")
}
if c.port != defaultCachingServicePort {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\nThe file mode is specified. '-port' cannot be specified at the same time.")
}
if len(c.subnets) != 0 {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\nThe file mode is specified. '-subnets' cannot be specified at the same time.")
}
if c.primary != "" {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\nThe file mode is specified. '-primary' cannot be specified at the same time.")
}
if c.secondary != "" {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\nThe file mode is specified. '-secondary' cannot be specified at the same time.")
}
if c.state != "" {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\nThe file mode is specified. '-state' cannot be specified at the same time.")
}
if c.description != "" {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\nThe file mode is specified. '-description' cannot be specified at the same time.")
}
}
if c.newSpecsFile == "" {
if c.name == "" {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\n'-name' is required, no mode ('-f') is specified.")
}
if !ufsAPI.HostnameRegex.MatchString(c.name) {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\n'-name' must be a hostname or ipv4 address.")
}
if len(c.subnets) == 0 {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\n'-subnets' is required.")
}
if !ufsAPI.HostnameRegex.MatchString(c.primary) {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\n'-primary' must be a hostname or ipv4 address.")
}
if !ufsAPI.HostnameRegex.MatchString(c.secondary) {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\n'-secondary' must be a hostname or ipv4 address.")
}
if c.state != "" && !ufsUtil.IsUFSState(ufsUtil.RemoveStatePrefix(c.state)) {
return cmdlib.NewQuietUsageError(c.Flags, "Wrong usage!!\n%s is not a valid state name, please check help info for '-state'.", c.state)
}
}
return nil
}
// parseMCSV parses the MCSV file and returns CachingService requests.
func (c *addCachingService) parseMCSV() ([]*ufspb.CachingService, error) {
records, err := utils.ParseMCSVFile(c.newSpecsFile)
if err != nil {
return nil, err
}
var cachingServices []*ufspb.CachingService
for i, rec := range records {
// if i is 0, determine whether this is a header.
if i == 0 && utils.LooksLikeHeader(rec) {
if err := utils.ValidateSameStringArray(mcsvFields, rec); err != nil {
return nil, err
}
continue
}
cs := &ufspb.CachingService{}
for i := range mcsvFields {
name := mcsvFields[i]
value := rec[i]
switch name {
case "name":
if !ufsAPI.HostnameRegex.MatchString(value) {
return nil, fmt.Errorf("Error in line %d.\nFailed to parse name(must be a hostname or ipv4 address) %s", i, value)
}
cs.Name = value
case "port":
port, err := strconv.ParseInt(value, 10, 32)
if err != nil {
return nil, fmt.Errorf("Error in line %d.\nFailed to parse port %s", i, value)
}
cs.Port = int32(port)
case "subnets":
cs.ServingSubnets = strings.Fields(value)
case "primary":
if !ufsAPI.HostnameRegex.MatchString(value) {
return nil, fmt.Errorf("Error in line %d.\nFailed to parse primary(must be a hostname or ipv4 address) %s", i, value)
}
cs.PrimaryNode = value
case "secondary":
if !ufsAPI.HostnameRegex.MatchString(value) {
return nil, fmt.Errorf("Error in line %d.\nFailed to parse secondary(must be a hostname or ipv4 address) %s", i, value)
}
cs.SecondaryNode = value
case "state":
if !ufsUtil.IsUFSState(ufsUtil.RemoveStatePrefix(value)) {
return nil, fmt.Errorf("Error in line %d.\n%s is not a valid state name. %s", i, value, cmdhelp.StateFilterHelpText)
}
cs.State = ufsUtil.ToUFSState(value)
case "desc":
cs.Description = value
default:
return nil, fmt.Errorf("Error in line %d.\nUnknown field: %s", i, name)
}
}
cachingServices = append(cachingServices, cs)
}
return cachingServices, nil
}