fix: update vendor release/3.9 20240128 (#19366)

Co-authored-by: Qiu Jian <qiujian@yunionyun.com>

Makefile

@@ -285,7 +285,9 @@ dep:
 GOPROXY ?= direct
 
 mod:
-	GOPROXY=$(GOPROXY) GONOSUMDB=yunion.io/x go get -d $(patsubst %,%@master,$(shell GO111MODULE=on go mod edit -print  | sed -n -e 's|.*\(yunion.io/x/[a-z].*\) v.*|\1|p'))
+	GOPROXY=$(GOPROXY) GONOSUMDB=yunion.io/x go get -d yunion.io/x/sqlchemy@v1.1.2
+	GOPROXY=$(GOPROXY) GONOSUMDB=yunion.io/x go get -d yunion.io/x/pkg@v1.10.0
+	GOPROXY=$(GOPROXY) GONOSUMDB=yunion.io/x go get -d $(patsubst %,%@master,$(shell GO111MODULE=on go mod edit -print  | sed -n -e 's|.*\(yunion.io/x/[a-z].*\) v.*|\1|p' | egrep -v '/cloudmux$$|/sqlchemy$$|/pkg$$'))
 	GOPROXY=$(GOPROXY) GONOSUMDB=yunion.io/x go mod tidy
 	GOPROXY=$(GOPROXY) GONOSUMDB=yunion.io/x go mod vendor -v
 

go.mod

@@ -104,16 +104,16 @@ require (
 	moul.io/http2curl/v2 v2.3.0
 	yunion.io/x/log v1.0.1-0.20230411060016-feb3f46ab361
 	yunion.io/x/ovsdb v0.0.0-20230306173834-f164f413a900
-	yunion.io/x/pkg v1.0.1-0.20231012131524-8a175238485b
+	yunion.io/x/pkg v1.10.0
 	yunion.io/x/s3cli v0.0.0-20190917004522-13ac36d8687e
-	yunion.io/x/structarg v0.0.0-20220312084958-9c6c79c7d1c6
+	yunion.io/x/structarg v0.0.0-20231017124457-df4d5009457c
 )
 
 require (
 	github.com/google/uuid v1.3.0
 	yunion.io/x/executor v0.0.0-20230705125604-c5ac3141db32
 	yunion.io/x/jsonutils v1.0.1-0.20230613121553-0f3b41e2ef19
-	yunion.io/x/sqlchemy v1.1.2-0.20231011114043-0d203453d3e2
+	yunion.io/x/sqlchemy v1.1.2
 )
 
 require (

go.sum

@@ -1161,11 +1161,11 @@ yunion.io/x/ovsdb v0.0.0-20230306173834-f164f413a900 h1:Hu/4ERvoWaN6aiFs4h4/yvVB
 yunion.io/x/ovsdb v0.0.0-20230306173834-f164f413a900/go.mod h1:0vLkNEhlmA64HViPBAnSTUMrx5QP1CLsxXmxDKQ80tc=
 yunion.io/x/pkg v0.0.0-20190620104149-945c25821dbf/go.mod h1:t6rEGG2sQ4J7DhFxSZVOTjNd0YO/KlfWQyK1W4tog+E=
 yunion.io/x/pkg v0.0.0-20190628082551-f4033ba2ea30/go.mod h1:t6rEGG2sQ4J7DhFxSZVOTjNd0YO/KlfWQyK1W4tog+E=
-yunion.io/x/pkg v1.0.1-0.20231012131524-8a175238485b h1:0eDqhMiGCPcbYLXRuCprsNCOsj0cQ09swUmGkXatlBk=
-yunion.io/x/pkg v1.0.1-0.20231012131524-8a175238485b/go.mod h1:ksCJVQ+DwKrJ5QBEoU8pzrDFfDaZVAFH/iJ6yQCYxJk=
+yunion.io/x/pkg v1.10.0 h1:A0L/ebGyF3+z+kXGRifnpMaLX1GSOHwNx6ocLR6cKRw=
+yunion.io/x/pkg v1.10.0/go.mod h1:ksCJVQ+DwKrJ5QBEoU8pzrDFfDaZVAFH/iJ6yQCYxJk=
 yunion.io/x/s3cli v0.0.0-20190917004522-13ac36d8687e h1:v+EzIadodSwkdZ/7bremd7J8J50Cise/HCylsOJngmo=
 yunion.io/x/s3cli v0.0.0-20190917004522-13ac36d8687e/go.mod h1:0iFKpOs1y4lbCxeOmq3Xx/0AcQoewVPwj62eRluioEo=
-yunion.io/x/sqlchemy v1.1.2-0.20231011114043-0d203453d3e2 h1:DB6wG9VXsnJGaABcfN89wRjRPCCCuJSsd8xob48BD8Q=
-yunion.io/x/sqlchemy v1.1.2-0.20231011114043-0d203453d3e2/go.mod h1:uuPVZEyEq3sWd5vf9VjGSy6lZzof22X87OEHw9sddJQ=
-yunion.io/x/structarg v0.0.0-20220312084958-9c6c79c7d1c6 h1:WuWXhY3DvhdRTzWCJ/kwt3Ss6KIq7+KqJwb+esvNGwU=
-yunion.io/x/structarg v0.0.0-20220312084958-9c6c79c7d1c6/go.mod h1:EP6NSv2C0zzqBDTKumv8hPWLb3XvgMZDHQRfyuOrQng=
+yunion.io/x/sqlchemy v1.1.2 h1:h44E1ZO3bwiObXZsnCNSTRgXc9xSV86CWINUMs0qDVE=
+yunion.io/x/sqlchemy v1.1.2/go.mod h1:uuPVZEyEq3sWd5vf9VjGSy6lZzof22X87OEHw9sddJQ=
+yunion.io/x/structarg v0.0.0-20231017124457-df4d5009457c h1:QuLab2kSRECZRxo4Lo2KcYn6XjQFDGaZ1+x0pYDVVwQ=
+yunion.io/x/structarg v0.0.0-20231017124457-df4d5009457c/go.mod h1:EP6NSv2C0zzqBDTKumv8hPWLb3XvgMZDHQRfyuOrQng=

vendor/modules.txt

@@ -1449,7 +1449,7 @@ yunion.io/x/log/hooks
 yunion.io/x/ovsdb/cli_util
 yunion.io/x/ovsdb/schema/ovn_nb
 yunion.io/x/ovsdb/types
-# yunion.io/x/pkg v1.0.1-0.20231012131524-8a175238485b
+# yunion.io/x/pkg v1.10.0
 ## explicit; go 1.18
 yunion.io/x/pkg/errors
 yunion.io/x/pkg/gotypes
@@ -1486,14 +1486,14 @@ yunion.io/x/pkg/utils
 # yunion.io/x/s3cli v0.0.0-20190917004522-13ac36d8687e
 ## explicit; go 1.12
 yunion.io/x/s3cli
-# yunion.io/x/sqlchemy v1.1.2-0.20231011114043-0d203453d3e2
+# yunion.io/x/sqlchemy v1.1.2
 ## explicit; go 1.17
 yunion.io/x/sqlchemy
 yunion.io/x/sqlchemy/backends
 yunion.io/x/sqlchemy/backends/clickhouse
 yunion.io/x/sqlchemy/backends/mysql
 yunion.io/x/sqlchemy/backends/sqlite
-# yunion.io/x/structarg v0.0.0-20220312084958-9c6c79c7d1c6
+# yunion.io/x/structarg v0.0.0-20231017124457-df4d5009457c
 ## explicit; go 1.12
 yunion.io/x/structarg
 # github.com/go-logr/logr => github.com/go-logr/logr v0.4.0

vendor/yunion.io/x/pkg/util/netutils/ipv6.go

@@ -0,0 +1,583 @@
+// Copyright 2019 Yunion
+//
+// 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 netutils
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math/rand"
+	"net"
+	"strconv"
+	"strings"
+
+	"yunion.io/x/pkg/errors"
+)
+
+type IPV6Addr [8]uint16
+
+func hex2Number(hexStr string) (uint16, error) {
+	val, err := strconv.ParseInt(hexStr, 16, 64)
+	if err != nil {
+		return 0, errors.Wrap(err, "strconv.ParseInt")
+	}
+	return uint16(val), nil
+}
+
+func normalizeIpv6Addr(addrStr string) ([8]uint16, error) {
+	var addr [8]uint16
+	parts := strings.Split(addrStr, ":")
+	expectPartCnt := 8
+	if len(parts) > 0 && strings.Contains(parts[len(parts)-1], ".") {
+		// 2001:db8:3333:4444:5555:6666:1.2.3.4
+		v4part, err := IP2Number(parts[len(parts)-1])
+		if err != nil {
+			return addr, errors.Wrapf(err, "IP2Number %s", parts[len(parts)-1])
+		}
+		addr[6] = uint16((v4part >> 16) & 0xffff)
+		addr[7] = uint16(v4part & 0xFFFF)
+		expectPartCnt = 6
+		parts = parts[:len(parts)-1]
+	}
+	if len(parts) < expectPartCnt {
+		for i := range parts {
+			parts[i] = strings.TrimSpace(parts[i])
+		}
+		switch len(parts) {
+		case 0, 1:
+			return addr, errors.Wrap(errors.ErrInvalidFormat, addrStr)
+		case 2:
+			if len(parts[0]) == 0 && expectPartCnt == 6 {
+				// ::192.168.0.1
+				return addr, nil
+			} else if len(parts[0]) > 0 && expectPartCnt == 6 {
+				// 3ffe::192.168.0.1
+				var err error
+				addr[0], err = hex2Number(parts[0])
+				if err != nil {
+					return addr, errors.Wrapf(err, "hex2Number %s", addrStr)
+				}
+				return addr, nil
+			} else {
+				return addr, errors.Wrap(errors.ErrInvalidFormat, addrStr)
+			}
+		/*case 3:
+		if len(parts[0]) == 0 && len(parts[1]) == 0 && len(parts[2]) == 0 {
+			// ::
+			return addr, nil
+		} else if len(parts[0]) == 0 && len(parts[2]) > 0 {
+			// ::1, ::1:192.168.0.1
+			for i := 0; i <= 1; i++ {
+				if len(parts[2-i]) == 0 {
+					continue
+				}
+				var err error
+				addr[expectPartCnt-1-i], err = hex2Number(parts[2-i])
+				if err != nil {
+					return addr, errors.Wrapf(err, "hex2Number %s", addrStr)
+				}
+			}
+			return addr, nil
+		} else if len(parts[0]) > 0 && len(parts[2]) == 0 {
+			// 3ffe::
+			for i := 0; i <= 1; i++ {
+				if len(parts[i]) == 0 {
+					continue
+				}
+				var err error
+				addr[i], err = hex2Number(parts[i])
+				if err != nil {
+					return addr, errors.Wrapf(err, "hex2Number %s", addrStr)
+				}
+			}
+			return addr, nil
+		} else {
+			return addr, errors.Wrap(errors.ErrInvalidFormat, addrStr)
+		}*/
+		default:
+			if len(parts) == 3 && len(parts[0]) == 0 && len(parts[1]) == 0 && len(parts[2]) == 0 {
+				return addr, nil
+			} else if len(parts[0]) == 0 {
+				if len(parts[1]) == 0 {
+					// ::1, ::3ffe:3200:1234:1234, ::1234:123.123.123.123
+					for i := 0; i < len(parts)-2; i++ {
+						partIdx := len(parts) - 1 - i
+						addrIdx := expectPartCnt - 1 - i
+						var err error
+						addr[addrIdx], err = hex2Number(parts[partIdx])
+						if err != nil {
+							return addr, errors.Wrapf(err, "hex2Number %s", addrStr)
+						}
+					}
+				} else {
+					return addr, errors.Wrap(errors.ErrInvalidFormat, addrStr)
+				}
+			} else if len(parts[len(parts)-1]) == 0 {
+				// 3ffe::, 3ffe:3200::, 3ffe:3200::123.123.123.123
+				for i := 0; i < len(parts)-1; i++ {
+					if len(parts[i]) == 0 {
+						continue
+					}
+					var err error
+					addr[i], err = hex2Number(parts[i])
+					if err != nil {
+						return addr, errors.Wrapf(err, "hex2Number %s", addrStr)
+					}
+				}
+			} else {
+				addrIdx := 0
+				for i := 0; i < len(parts); i++ {
+					if len(parts[i]) == 0 {
+						addrIdx = expectPartCnt + 1 - len(parts) + i
+						continue
+					}
+					var err error
+					addr[addrIdx], err = hex2Number(parts[i])
+					if err != nil {
+						return addr, errors.Wrapf(err, "hex2Number %s", addrStr)
+					}
+					addrIdx++
+				}
+			}
+		}
+	} else {
+		for i := 0; i < len(parts); i++ {
+			var err error
+			addr[i], err = hex2Number(strings.TrimSpace(parts[i]))
+			if err != nil {
+				return addr, errors.Wrapf(err, "hex2Number %s", addrStr)
+			}
+		}
+	}
+	return addr, nil
+}
+
+func NewIPV6Addr(ipstr string) (IPV6Addr, error) {
+	var addr IPV6Addr
+	if len(ipstr) > 0 {
+		addr8, err := normalizeIpv6Addr(ipstr)
+		if err != nil {
+			return addr, errors.Wrapf(errors.ErrInvalidFormat, "%s %s", ipstr, err.Error())
+		}
+		addr = addr8
+	}
+	return addr, nil
+}
+
+const MaxUint16 = uint16(0xffff)
+
+func (addr IPV6Addr) StepDown() IPV6Addr {
+	naddr := IPV6Addr{}
+	borrow := true
+	for i := 7; i >= 0; i-- {
+		if borrow {
+			if addr[i] > 0 {
+				naddr[i] = addr[i] - 1
+				borrow = false
+			} else {
+				naddr[i] = MaxUint16
+				borrow = true
+			}
+		} else {
+			naddr[i] = addr[i]
+		}
+	}
+	return naddr
+}
+
+func (addr IPV6Addr) StepUp() IPV6Addr {
+	naddr := IPV6Addr{}
+	upshift := true
+	for i := 7; i >= 0; i-- {
+		if upshift {
+			if addr[i] == MaxUint16 {
+				naddr[i] = 0
+				upshift = true
+			} else {
+				naddr[i] = addr[i] + 1
+				upshift = false
+			}
+		} else {
+			naddr[i] = addr[i]
+		}
+	}
+	return naddr
+}
+
+func masklen2Uint16(maskLen uint8) uint16 {
+	return ^(uint16(1<<(16-maskLen)) - 1)
+}
+
+func (addr IPV6Addr) NetAddr(maskLen uint8) IPV6Addr {
+	var naddr IPV6Addr
+	for i := 0; i < 8; i++ {
+		if maskLen >= 16 {
+			naddr[i] = addr[i]
+			maskLen -= 16
+		} else if maskLen > 0 && maskLen < 16 {
+			naddr[i] = addr[i] & masklen2Uint16(maskLen)
+			maskLen = 0
+		} else {
+			naddr[i] = 0
+		}
+	}
+	return naddr
+}
+
+func (addr IPV6Addr) BroadcastAddr(maskLen uint8) IPV6Addr {
+	var naddr IPV6Addr
+	for i := 0; i < 8; i++ {
+		if maskLen >= 16 {
+			naddr[i] = addr[i]
+			maskLen -= 16
+		} else if maskLen > 0 && maskLen < 16 {
+			mask := masklen2Uint16(maskLen)
+			naddr[i] = addr[i] | (MaxUint16 - mask)
+			maskLen = 0
+		} else {
+			naddr[i] = MaxUint16
+		}
+	}
+	return naddr
+}
+
+func (addr IPV6Addr) HostAddr(hostAddr IPV6Addr, maskLen uint8) IPV6Addr {
+	var naddr IPV6Addr
+	for i := 0; i < 8; i++ {
+		if maskLen >= 16 {
+			naddr[i] = addr[i]
+			maskLen -= 16
+		} else if maskLen > 0 && maskLen < 16 {
+			mask := masklen2Uint16(maskLen)
+			naddr[i] = (addr[i] & mask) | (hostAddr[i] & (MaxUint16 - mask))
+			maskLen = 0
+		} else {
+			naddr[i] = hostAddr[i]
+		}
+	}
+	return naddr
+}
+
+func (addr IPV6Addr) String() string {
+	hexStrs := make([]string, 8)
+	for i := 0; i < 8; i++ {
+		hexStrs[i] = fmt.Sprintf("%x", addr[i])
+	}
+
+	maxZeroLen := 0
+	maxZeroStart := -1
+	maxZeroEnd := -1
+	zeroStart := -1
+	zeroEnd := -1
+	for i := 0; i < len(addr); i++ {
+		if addr[i] == 0 {
+			if zeroStart >= 0 {
+				zeroEnd = i
+			} else {
+				zeroStart = i
+				zeroEnd = i
+			}
+		} else {
+			if zeroStart >= 0 {
+				// record the max
+				if zeroEnd-zeroStart+1 > maxZeroLen {
+					maxZeroStart = zeroStart
+					maxZeroEnd = zeroEnd
+					maxZeroLen = maxZeroEnd - maxZeroStart + 1
+				}
+				zeroStart = -1
+				zeroEnd = -1
+			} else {
+				// do nothing
+			}
+		}
+	}
+	if zeroStart >= 0 {
+		if zeroEnd-zeroStart+1 > maxZeroLen {
+			maxZeroStart = zeroStart
+			maxZeroEnd = zeroEnd
+			maxZeroLen = maxZeroEnd - maxZeroStart + 1
+		}
+	}
+	if maxZeroLen > 0 {
+		return strings.Join(hexStrs[:maxZeroStart], ":") + "::" + strings.Join(hexStrs[maxZeroEnd+1:], ":")
+	} else {
+		return strings.Join(hexStrs, ":")
+	}
+}
+
+func (addr IPV6Addr) Lt(addr2 IPV6Addr) bool {
+	for i := 0; i < 8; i++ {
+		if addr[i] < addr2[i] {
+			return true
+		} else if addr[i] > addr2[i] {
+			return false
+		}
+	}
+	return false
+}
+
+func (addr IPV6Addr) Le(addr2 IPV6Addr) bool {
+	for i := 0; i < 8; i++ {
+		if addr[i] < addr2[i] {
+			return true
+		} else if addr[i] > addr2[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func (addr IPV6Addr) Equals(addr2 IPV6Addr) bool {
+	for i := 0; i < 8; i++ {
+		if addr[i] != addr2[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func (addr IPV6Addr) Gt(addr2 IPV6Addr) bool {
+	return !addr.Le(addr2)
+}
+
+func (addr IPV6Addr) Ge(addr2 IPV6Addr) bool {
+	return !addr.Lt(addr2)
+}
+
+type IPV6AddrRange struct {
+	start IPV6Addr
+	end   IPV6Addr
+}
+
+func NewIPV6AddrRange(ip1 IPV6Addr, ip2 IPV6Addr) IPV6AddrRange {
+	ar := IPV6AddrRange{}
+	ar.Set(ip1, ip2)
+	return ar
+}
+
+func (ar *IPV6AddrRange) Set(ip1 IPV6Addr, ip2 IPV6Addr) {
+	if ip1.Lt(ip2) {
+		ar.start = ip1
+		ar.end = ip2
+	} else {
+		ar.start = ip2
+		ar.end = ip1
+	}
+}
+
+// n.IP and n.Mask must be ipv4 type.  n.Mask must be canonical
+func NewIPV6AddrRangeFromIPNet(n *net.IPNet) IPV6AddrRange {
+	pref, err := NewIPV6Prefix(n.String())
+	if err != nil {
+		panic("unexpected IPNet: " + n.String())
+	}
+	return pref.ToIPRange()
+}
+
+func (ar IPV6AddrRange) Contains(ip IPV6Addr) bool {
+	return ip.Ge(ar.start) && ip.Le(ar.end)
+}
+
+func (ar IPV6AddrRange) ContainsRange(ar2 IPV6AddrRange) bool {
+	return ar.start.Le(ar2.start) && ar.end.Ge(ar2.end)
+}
+
+const (
+	borderEqual = 0
+	borderLower = 1
+	borderUpper = 2
+	notBorder   = 3
+)
+
+func randomUint16(min, max uint16) uint16 {
+	return min + uint16(rand.Intn(int(max)+1-int(min)))
+}
+
+func randomNext(min, max uint16, border int) (uint16, int) {
+	var newVal uint16
+	if min == max {
+		newVal = min
+	} else {
+		newVal = randomUint16(min, max)
+		if newVal == min {
+			if border == borderUpper {
+				border = notBorder
+			} else if border == borderEqual {
+				border = borderLower
+			}
+		} else if newVal == max {
+			if border == borderLower {
+				border = notBorder
+			} else if border == borderEqual {
+				border = borderUpper
+			}
+		} else {
+			border = notBorder
+		}
+	}
+	return newVal, border
+}
+
+func (ar IPV6AddrRange) Random() IPV6Addr {
+	var naddr IPV6Addr
+	border := borderEqual
+	for i := 0; i < 8; i++ {
+		switch border {
+		case borderEqual:
+			naddr[i], border = randomNext(ar.start[i], ar.end[i], border)
+		case borderLower:
+			naddr[i], border = randomNext(ar.start[i], MaxUint16, border)
+		case borderUpper:
+			naddr[i], border = randomNext(0, ar.end[i], border)
+		default:
+			// any random
+			naddr[i] = randomUint16(0, MaxUint16)
+		}
+	}
+	return naddr
+}
+
+func (ar IPV6AddrRange) String() string {
+	return fmt.Sprintf("%s-%s", ar.start, ar.end)
+}
+
+func (ar IPV6AddrRange) StartIp() IPV6Addr {
+	return ar.start
+}
+
+func (ar IPV6AddrRange) EndIp() IPV6Addr {
+	return ar.end
+}
+
+func (ar IPV6AddrRange) Merge(ar2 IPV6AddrRange) (*IPV6AddrRange, bool) {
+	if ar.IsOverlap(ar2) || ar.end.StepUp().Equals(ar2.start) || ar2.end.StepUp().Equals(ar.start) {
+		if ar2.start.Lt(ar.start) {
+			ar.start = ar2.start
+		}
+		if ar2.end.Gt(ar.end) {
+			ar.end = ar2.end
+		}
+		return &ar, true
+	}
+	return nil, false
+}
+
+func (ar IPV6AddrRange) IsOverlap(ar2 IPV6AddrRange) bool {
+	if ar.start.Ge(ar2.end) || ar.end.Le(ar2.start) {
+		return false
+	} else {
+		return true
+	}
+}
+
+func (ar IPV6AddrRange) equals(ar2 IPV6AddrRange) bool {
+	return ar.start.Equals(ar2.start) && ar.end.Equals(ar2.end)
+}
+
+type IPV6Prefix struct {
+	Address IPV6Addr
+	MaskLen uint8
+	ipRange IPV6AddrRange
+}
+
+func (pref *IPV6Prefix) String() string {
+	if pref.MaskLen == 128 {
+		return pref.Address.String()
+	} else {
+		return fmt.Sprintf("%s/%d", pref.Address.NetAddr(pref.MaskLen).String(), pref.MaskLen)
+	}
+}
+
+func (pref *IPV6Prefix) Equals(pref1 *IPV6Prefix) bool {
+	if pref1 == nil {
+		return false
+	}
+	return pref.ipRange.equals(pref1.ipRange)
+}
+
+func ParsePrefix6(prefix string) (IPV6Addr, uint8, error) {
+	slash := strings.IndexByte(prefix, '/')
+	if slash > 0 {
+		addr, err := NewIPV6Addr(prefix[:slash])
+		if err != nil {
+			return addr, 0, errors.Wrap(err, "NewIPV6Addr")
+		}
+		maskLen, err := strconv.Atoi(prefix[slash+1:])
+		if err != nil {
+			return addr, 0, ErrInvalidMask // fmt.Errorf("invalid masklen %s", err)
+		}
+		if maskLen < 0 || maskLen > 128 {
+			return addr, 0, ErrOutOfRangeMask // fmt.Errorf("out of range masklen")
+		}
+		return addr.NetAddr(uint8(maskLen)), uint8(maskLen), nil
+	} else {
+		addr, err := NewIPV6Addr(prefix)
+		if err != nil {
+			return addr, 0, errors.Wrap(err, "NewIPV4Addr")
+		}
+		return addr, 128, nil
+	}
+}
+
+func NewIPV6Prefix(prefix string) (IPV6Prefix, error) {
+	addr, maskLen, err := ParsePrefix6(prefix)
+	if err != nil {
+		return IPV6Prefix{}, errors.Wrap(err, "ParsePrefix6")
+	}
+	pref := IPV6Prefix{
+		Address: addr,
+		MaskLen: maskLen,
+	}
+	pref.ipRange = pref.ToIPRange()
+	return pref, nil
+}
+
+func (prefix IPV6Prefix) ToIPRange() IPV6AddrRange {
+	start := prefix.Address.NetAddr(prefix.MaskLen)
+	end := prefix.Address.BroadcastAddr(prefix.MaskLen)
+	return IPV6AddrRange{start: start, end: end}
+}
+
+func (prefix IPV6Prefix) Contains(ip IPV6Addr) bool {
+	return prefix.ipRange.Contains(ip)
+}
+
+func DeriveIPv6AddrFromIPv4AddrMac(ipAddr string, macAddr string, startIp6, endIp6 string, maskLen6 uint8) string {
+	v4, _ := NewIPV4Addr(ipAddr)
+	v4Bytes := v4.ToBytes()
+	mac, _ := ParseMac(macAddr)
+	hostAddr := IPV6Addr{
+		0, 0, 0, 0,
+		binary.BigEndian.Uint16([]byte{v4Bytes[0], v4Bytes[1]}),
+		binary.BigEndian.Uint16([]byte{v4Bytes[2], v4Bytes[3]}),
+		binary.BigEndian.Uint16([]byte{mac[2], mac[3]}),
+		binary.BigEndian.Uint16([]byte{mac[4], mac[5]}),
+	}
+	sAddr6, _ := NewIPV6Addr(startIp6)
+	eAddr6, _ := NewIPV6Addr(endIp6)
+	netAddr6 := sAddr6.NetAddr(maskLen6)
+	i := uint8(64)
+	if maskLen6 > i {
+		i = maskLen6
+	}
+	for i < 128 {
+		addr6 := netAddr6.HostAddr(hostAddr, i)
+		if addr6.Ge(sAddr6) && addr6.Le(eAddr6) {
+			return addr6.String()
+		}
+		i++
+	}
+	return ""
+}

vendor/yunion.io/x/pkg/util/netutils/macutils.go

@@ -0,0 +1,68 @@
+// Copyright 2019 Yunion
+//
+// 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 netutils
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type SMacAddr [6]byte
+
+func ErrMacFormat(macStr string) error {
+	return fmt.Errorf("invalid mac format: %s", macStr)
+}
+
+func ParseMac(macStr string) (SMacAddr, error) {
+	mac := SMacAddr{}
+	macStr = FormatMacAddr(macStr)
+	parts := strings.Split(macStr, ":")
+	if len(parts) != 6 {
+		return mac, ErrMacFormat(macStr)
+	}
+	for i := 0; i < 6; i += 1 {
+		bt, err := strconv.ParseInt(parts[i], 16, 64)
+		if err != nil {
+			return mac, ErrMacFormat(macStr)
+		}
+		mac[i] = byte(bt)
+	}
+	return mac, nil
+}
+
+func (mac SMacAddr) Add(step int) SMacAddr {
+	mac2 := SMacAddr{}
+	leftOver := step
+	for i := 5; i >= 0; i -= 1 {
+		newByte := int(mac[i]) + leftOver
+		res := 0
+		if newByte < 0 {
+			res = ((-newByte) / 0x100) + 1
+			newByte = newByte + res*0x100
+		}
+		mac2[i] = byte(newByte % 0x100)
+		leftOver = newByte/0x100 - res
+	}
+	return mac2
+}
+
+func (mac SMacAddr) String() string {
+	var parts [6]string
+	for i := 0; i < len(parts); i += 1 {
+		parts[i] = fmt.Sprintf("%02x", mac[i])
+	}
+	return strings.Join(parts[:], ":")
+}

vendor/yunion.io/x/pkg/util/netutils/netutils.go

@@ -55,7 +55,7 @@ func IP2Number(ipstr string) (uint32, error) {
 	if len(parts) == 4 {
 		var num uint32
 		for i := 0; i < 4; i += 1 {
-			n, e := strconv.Atoi(parts[i])
+			n, e := strconv.Atoi(strings.TrimSpace(parts[i]))
 			if e != nil {
 				return 0, ErrInvalidNumber // fmt.Errorf("invalid number %s", parts[i])
 			}
@@ -162,10 +162,18 @@ type IPV4AddrRange struct {
 }
 
 func NewIPV4AddrRange(ip1 IPV4Addr, ip2 IPV4Addr) IPV4AddrRange {
+	ar := IPV4AddrRange{}
+	ar.Set(ip1, ip2)
+	return ar
+}
+
+func (ar *IPV4AddrRange) Set(ip1 IPV4Addr, ip2 IPV4Addr) {
 	if ip1 < ip2 {
-		return IPV4AddrRange{start: ip1, end: ip2}
+		ar.start = ip1
+		ar.end = ip2
 	} else {
-		return IPV4AddrRange{start: ip2, end: ip1}
+		ar.start = ip2
+		ar.end = ip1
 	}
 }
 
@@ -417,12 +425,13 @@ const (
 )
 
 var privateIPRanges []IPV4AddrRange
+var customizedPrivateIPRanges []IPV4AddrRange
 var hostLocalIPRange IPV4AddrRange
 var linkLocalIPRange IPV4AddrRange
 var multicastIPRange IPV4AddrRange
 
 func init() {
-	updatePrivateIPRanges(nil)
+	initPrivateIPRanges()
 
 	prefix, _ := NewIPV4Prefix(hostlocalPrefix)
 	hostLocalIPRange = prefix.ToIPRange()
@@ -432,13 +441,15 @@ func init() {
 	multicastIPRange = prefix.ToIPRange()
 }
 
-func updatePrivateIPRanges(prefs []string) {
-	if len(prefs) == 0 {
-		prefs = []string{
-			"10.0.0.0/8",
-			"172.16.0.0/12",
-			"192.168.0.0/16",
-		}
+func initPrivateIPRanges() {
+	// https://zh.wikipedia.org/wiki/%E4%BF%9D%E7%95%99IP%E5%9C%B0%E5%9D%80
+	prefs := []string{
+		"10.0.0.0/8",
+		"100.64.0.0/10",
+		"172.16.0.0/12",
+		"192.0.0.0/24",
+		"198.18.0.0/15",
+		"192.168.0.0/16",
 	}
 	privateIPRanges = make([]IPV4AddrRange, len(prefs))
 	for i, prefix := range prefs {
@@ -451,15 +462,22 @@ func updatePrivateIPRanges(prefs []string) {
 }
 
 func SetPrivatePrefixes(pref []string) {
-	updatePrivateIPRanges(pref)
+	customizedPrivateIPRanges = make([]IPV4AddrRange, 0)
+	for _, prefix := range pref {
+		prefix, err := NewIPV4Prefix(prefix)
+		if err != nil {
+			continue
+		}
+		customizedPrivateIPRanges = append(customizedPrivateIPRanges, prefix.ToIPRange())
+	}
 }
 
 func GetPrivateIPRanges() []IPV4AddrRange {
-	return privateIPRanges
+	return append(privateIPRanges, customizedPrivateIPRanges...)
 }
 
 func IsPrivate(addr IPV4Addr) bool {
-	for _, ipRange := range privateIPRanges {
+	for _, ipRange := range GetPrivateIPRanges() {
 		if ipRange.Contains(addr) {
 			return true
 		}

vendor/yunion.io/x/pkg/util/regutils/regutils.go

@@ -134,6 +134,14 @@ func MatchCIDR(str string) bool {
 	return ip != nil && !strings.Contains(str, ":")
 }
 
+func MatchCIDR6(str string) bool {
+	ip, _, err := net.ParseCIDR(str)
+	if err != nil {
+		return false
+	}
+	return ip != nil && !strings.Contains(str, ".")
+}
+
 func MatchIP6Addr(str string) bool {
 	ip := net.ParseIP(str)
 	return ip != nil && strings.Contains(str, ":")

vendor/yunion.io/x/pkg/utils/misc.go

@@ -546,8 +546,15 @@ func TransSQLAchemyURL(pySQLSrc string) (dialect, ret string, err error) {
 		return dialect, pySQLSrc, nil
 	}
 
-	r := regexp.MustCompile(`[/@:]+`)
-	strs := r.Split(pySQLSrc, -1)
+	lastAtIndex := strings.LastIndex(pySQLSrc, "@")
+	firstPart := pySQLSrc[:lastAtIndex]
+	secondPart := pySQLSrc[lastAtIndex+1:]
+
+	r := regexp.MustCompile(`[/:]+`)
+	firstPartArr := r.Split(firstPart, -1)
+	secondPartArr := r.Split(secondPart, -1)
+
+	strs := append(firstPartArr, secondPartArr...)
 	if len(strs) != 6 {
 		err = fmt.Errorf("Incorrect mysql connection url: %s", pySQLSrc)
 		return

vendor/yunion.io/x/sqlchemy/backends/clickhouse/columninfo.go

@@ -168,7 +168,7 @@ func findSegment(sqlStr string, prefix string) string {
 func trimPartition(partStr string) string {
 	for {
 		partStr = strings.TrimSpace(partStr)
-		if partStr[0] == '(' {
+		if len(partStr) > 0 && partStr[0] == '(' {
 			partStr = partStr[1 : len(partStr)-1]
 		} else {
 			break

vendor/yunion.io/x/sqlchemy/backends/mysql/column.go

@@ -95,7 +95,12 @@ func (c *SBooleanColumn) ConvertFromString(str string) interface{} {
 
 // ConvertFromValue implementation of STristateColumn for IColumnSpec
 func (c *SBooleanColumn) ConvertFromValue(val interface{}) interface{} {
-	bVal := val.(bool)
+	var bVal bool
+	if c.IsPointer() {
+		bVal = *val.(*bool)
+	} else {
+		bVal = val.(bool)
+	}
 	if bVal {
 		return 1
 	}

vendor/yunion.io/x/sqlchemy/reflect.go

@@ -164,20 +164,11 @@ func setValueBySQLString(value reflect.Value, val string) error {
 		if jsonV == jsonutils.JSONNull {
 			return nil
 		}
-		jsonM, err := jsonV.GetMap()
-		if err != nil {
-			return errors.Wrapf(err, "jsonV.GetMap val %s json %s", val, jsonV)
-		}
 		mapValue := reflect.MakeMap(value.Type())
 		value.Set(mapValue)
-		for k, jsonV := range jsonM {
-			elemValue := reflect.New(value.Type().Elem()).Elem()
-			jsonStr, _ := jsonV.GetString()
-			err := setValueBySQLString(elemValue, jsonStr)
-			if err != nil {
-				return errors.Wrapf(err, "TestSetValueBySQLString %s", jsonV.String())
-			}
-			value.SetMapIndex(reflect.ValueOf(k), elemValue)
+		err = jsonV.Unmarshal(mapValue.Interface())
+		if err != nil {
+			return errors.Wrapf(err, "jsonV.Unmarshal")
 		}
 		return nil
 	default:
@@ -208,7 +199,6 @@ func setValueBySQLString(value reflect.Value, val string) error {
 			}
 			value.Set(reflect.Indirect(newVal))
 			return nil
-			// return errors.Wrapf(ErrNotSupported, "not supported type: %s", valueType)
 		}
 	}
 }

vendor/yunion.io/x/structarg/structarg.go

@@ -1008,6 +1008,7 @@ func (this *ArgumentParser) reset() {
 	for _, arg := range this.optArgs {
 		arg.Reset()
 	}
+	this.help = false
 }
 
 func (this *ArgumentParser) ParseArgs(args []string, ignore_unknown bool) error {
@@ -1026,7 +1027,7 @@ func (this *ArgumentParser) ParseArgs2(args []string, ignore_unknown bool, setDe
 		if argStr == "--help" {
 			// shortcut to show help
 			fmt.Println(this.HelpString())
-			os.Exit(1)
+			this.help = true
 			continue
 		}
 		if strings.HasPrefix(argStr, "-") {