InTheForest/moby
1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2026-01-11 18:51:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove deprecated pkg/parsers

Browse Source 
- `ParseKeyValueOpt` was deprecated in 5b18a7914c
  and moved to the graphdriver package.
- `ParseUintListMaximum` and `ParseUintList` were deprecated in commit
  064cdf475c after they were moved internal
  to pkg/sysinfo in 2282279180.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
This commit is contained in:
Sebastiaan van Stijn
2025-06-16 16:21:22 +02:00
parent 04618dfc0b
commit 1f0e9077e4
2 changed files with 0 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
pkg/parsers/parsers.go
View File

@@ -1,106 +0,0 @@
// Package parsers provides helper functions to parse and validate different type
// of string. It can be hosts, unix addresses, tcp addresses, filters, kernel
// operating system versions.
package parsers
import (
"fmt"
"strconv"
"strings"
)
// ParseKeyValueOpt parses and validates the specified string as a key/value
// pair (key=value).
//
// Deprecated: use [strings.Cut] instead. This utility was only used internally, and will be removed in the next release.
func ParseKeyValueOpt(opt string) (key string, value string, _ error) {
k, v, ok := strings.Cut(opt, "=")
if !ok {
return "", "", fmt.Errorf("unable to parse key/value option: %s", opt)
}
return strings.TrimSpace(k), strings.TrimSpace(v), nil
}
// ParseUintListMaximum parses and validates the specified string as the value
// found in some cgroup file (e.g. `cpuset.cpus`, `cpuset.mems`), which could be
// one of the formats below. Note that duplicates are actually allowed in the
// input string. It returns a `map[int]bool` with available elements from `val`
// set to `true`. Values larger than `maximum` cause an error if max is non zero,
// in order to stop the map becoming excessively large.
// Supported formats:
//
// 7
// 1-6
// 0,3-4,7,8-10
// 0-0,0,1-7
// 03,1-3 <- this is gonna get parsed as [1,2,3]
// 3,2,1
// 0-2,3,1
//
// Deprecated: ParseUintListMaximum was only used internally and will be removed in the next release.
func ParseUintListMaximum(val string, maximum int) (map[int]bool, error) {
return parseUintList(val, maximum)
}
// ParseUintList parses and validates the specified string as the value
// found in some cgroup file (e.g. `cpuset.cpus`, `cpuset.mems`), which could be
// one of the formats below. Note that duplicates are actually allowed in the
// input string. It returns a `map[int]bool` with available elements from `val`
// set to `true`.
// Supported formats:
//
// 7
// 1-6
// 0,3-4,7,8-10
// 0-0,0,1-7
// 03,1-3 <- this is gonna get parsed as [1,2,3]
// 3,2,1
// 0-2,3,1
//
// Deprecated: ParseUintList was only used internally and will be removed in the next release.
func ParseUintList(val string) (map[int]bool, error) {
return parseUintList(val, 0)
}
func parseUintList(val string, maximum int) (map[int]bool, error) {
if val == "" {
return map[int]bool{}, nil
}
availableInts := make(map[int]bool)
split := strings.Split(val, ",")
errInvalidFormat := fmt.Errorf("invalid format: %s", val)
for _, r := range split {
if !strings.Contains(r, "-") {
v, err := strconv.Atoi(r)
if err != nil {
return nil, errInvalidFormat
}
if maximum != 0 && v > maximum {
return nil, fmt.Errorf("value of out range, maximum is %d", maximum)
}
availableInts[v] = true
} else {
minS, maxS, _ := strings.Cut(r, "-")
minAvailable, err := strconv.Atoi(minS)
if err != nil {
return nil, errInvalidFormat
}
maxAvailable, err := strconv.Atoi(maxS)
if err != nil {
return nil, errInvalidFormat
}
if maxAvailable < minAvailable {
return nil, errInvalidFormat
}
if maximum != 0 && maxAvailable > maximum {
return nil, fmt.Errorf("value of out range, maximum is %d", maximum)
}
for i := minAvailable; i <= maxAvailable; i++ {
availableInts[i] = true
}
}
}
return availableInts, nil
}

56
pkg/parsers/parsers_test.go
View File

@@ -1,56 +0,0 @@
package parsers
import (
"reflect"
"testing"
)
func TestParseUintList(t *testing.T) {
valids := map[string]map[int]bool{
"": {},
"7": {7: true},
"1-6": {1: true, 2: true, 3: true, 4: true, 5: true, 6: true},
"0-7": {0: true, 1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true},
"0,3-4,7,8-10": {0: true, 3: true, 4: true, 7: true, 8: true, 9: true, 10: true},
"0-0,0,1-4": {0: true, 1: true, 2: true, 3: true, 4: true},
"03,1-3": {1: true, 2: true, 3: true},
"3,2,1": {1: true, 2: true, 3: true},
"0-2,3,1": {0: true, 1: true, 2: true, 3: true},
}
for k, v := range valids {
out, err := parseUintList(k, 0)
if err != nil {
t.Fatalf("Expected not to fail, got %v", err)
}
if !reflect.DeepEqual(out, v) {
t.Fatalf("Expected %v, got %v", v, out)
}
}
invalids := []string{
"this",
"1--",
"1-10,,10",
"10-1",
"-1",
"-1,0",
}
for _, v := range invalids {
if out, err := parseUintList(v, 0); err == nil {
t.Fatalf("Expected failure with %s but got %v", v, out)
}
}
}
func TestParseUintListMaximumLimits(t *testing.T) {
v := "10,1000"
if _, err := parseUintList(v, 0); err != nil {
t.Fatalf("Expected not to fail, got %v", err)
}
if _, err := parseUintList(v, 1000); err != nil {
t.Fatalf("Expected not to fail, got %v", err)
}
if out, err := parseUintList(v, 100); err == nil {
t.Fatalf("Expected failure with %s but got %v", v, out)
}
}