114 lines
3.1 KiB
Go
114 lines
3.1 KiB
Go
package cli
|
|
|
|
import (
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/qdm12/gluetun/internal/constants"
|
|
"github.com/qdm12/gluetun/internal/constants/providers"
|
|
"github.com/qdm12/gluetun/internal/storage"
|
|
"golang.org/x/text/cases"
|
|
"golang.org/x/text/language"
|
|
)
|
|
|
|
var (
|
|
ErrProviderUnspecified = errors.New("VPN provider to format was not specified")
|
|
ErrMultipleProvidersToFormat = errors.New("more than one VPN provider to format were specified")
|
|
)
|
|
|
|
func addProviderFlag(flagSet *flag.FlagSet, providerToFormat map[string]*bool,
|
|
provider string, titleCaser cases.Caser,
|
|
) {
|
|
boolPtr, ok := providerToFormat[provider]
|
|
if !ok {
|
|
panic(fmt.Sprintf("unknown provider in format map: %s", provider))
|
|
}
|
|
flagSet.BoolVar(boolPtr, provider, false, "Format "+titleCaser.String(provider)+" servers")
|
|
}
|
|
|
|
func (c *CLI) FormatServers(args []string) error {
|
|
var format, output string
|
|
allProviders := providers.All()
|
|
allProviderFlags := make([]string, len(allProviders))
|
|
for i, provider := range allProviders {
|
|
allProviderFlags[i] = strings.ReplaceAll(provider, " ", "-")
|
|
}
|
|
|
|
providersToFormat := make(map[string]*bool, len(allProviders))
|
|
for _, provider := range allProviderFlags {
|
|
providersToFormat[provider] = new(bool)
|
|
}
|
|
flagSet := flag.NewFlagSet("format-servers", flag.ExitOnError)
|
|
flagSet.StringVar(&format, "format", "markdown", "Format to use which can be: 'markdown' or 'json'")
|
|
flagSet.StringVar(&output, "output", "/dev/stdout", "Output file to write the formatted data to")
|
|
titleCaser := cases.Title(language.English)
|
|
for _, provider := range allProviderFlags {
|
|
addProviderFlag(flagSet, providersToFormat, provider, titleCaser)
|
|
}
|
|
if err := flagSet.Parse(args); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Note the format is validated by storage.Format
|
|
|
|
// Verify only one provider is set to be formatted.
|
|
var providers []string
|
|
for provider, formatPtr := range providersToFormat {
|
|
if *formatPtr {
|
|
providers = append(providers, provider)
|
|
}
|
|
}
|
|
switch len(providers) {
|
|
case 0:
|
|
return fmt.Errorf("%w", ErrProviderUnspecified)
|
|
case 1:
|
|
default:
|
|
return fmt.Errorf("%w: %d specified: %s",
|
|
ErrMultipleProvidersToFormat, len(providers),
|
|
strings.Join(providers, ", "))
|
|
}
|
|
|
|
var providerToFormat string
|
|
for _, providerToFormat = range allProviders {
|
|
if strings.ReplaceAll(providerToFormat, " ", "-") == providers[0] {
|
|
break
|
|
}
|
|
}
|
|
|
|
logger := newNoopLogger()
|
|
storage, err := storage.New(logger, constants.ServersData)
|
|
if err != nil {
|
|
return fmt.Errorf("creating servers storage: %w", err)
|
|
}
|
|
|
|
formatted, err := storage.Format(providerToFormat, format)
|
|
if err != nil {
|
|
return fmt.Errorf("formatting servers: %w", err)
|
|
}
|
|
|
|
output = filepath.Clean(output)
|
|
const permission = fs.FileMode(0o644)
|
|
file, err := os.OpenFile(output, os.O_TRUNC|os.O_WRONLY|os.O_CREATE, permission)
|
|
if err != nil {
|
|
return fmt.Errorf("opening output file: %w", err)
|
|
}
|
|
|
|
_, err = fmt.Fprint(file, formatted)
|
|
if err != nil {
|
|
_ = file.Close()
|
|
return fmt.Errorf("writing to output file: %w", err)
|
|
}
|
|
|
|
err = file.Close()
|
|
if err != nil {
|
|
return fmt.Errorf("closing output file: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|