he

.github/workflows/build-and-test.yaml

@@ -15,7 +15,7 @@ jobs:
       - uses: actions/checkout@v1
         with:
           fetch-depth: 1
-      - uses: actions/setup-go@v1
+      - uses: actions/setup-go@v1.1.2
         with:
           go-version: '1.13'
       - name: prepare GOPATH
@@ -25,19 +25,8 @@ jobs:
           workdir="$HOME/go/src/yunion.io/x"
           mkdir -p "$workdir"
           mv "$HOME/work/pkg/pkg" "$workdir/"
-      - name: go get dependencies
-        shell: bash
-        run: |
-          set -o xtrace
-          workdir="$HOME/go/src/yunion.io/x"
+
           export GOPATH="$HOME/go"
           cd "$workdir/pkg"
           go get -v -t -d ./...
-      - name: run test
-        shell: bash
-        run: |
-          set -o xtrace
-          workdir="$HOME/go/src/yunion.io/x"
-          export GOPATH="$HOME/go"
-          cd "$workdir/pkg"
           go test -v ./...

errors/aggregate.go

@@ -15,7 +15,6 @@
 package errors
 
 import (
-	"errors"
 	"fmt"
 )
 
@@ -78,6 +77,16 @@ func (agg aggregate) Errors() []error {
 	return []error(agg)
 }
 
+func (agg aggregate) Cause() error {
+	if len(agg) == 0 {
+		return nil
+	}
+	if len(agg) == 1 {
+		return Cause(agg[0])
+	}
+	return ErrAggregate
+}
+
 // Matcher is used to match errors.  Returns true if the error matches.
 type Matcher func(error) bool
 
@@ -196,4 +205,4 @@ func AggregateGoroutines(funcs ...func() error) Aggregate {
 }
 
 // ErrPreconditionViolated is returned when the precondition is violated
-var ErrPreconditionViolated = errors.New("precondition is violated")
+// var ErrPreconditionViolated = errors.New("precondition is violated")

errors/aggregate_test.go

@@ -107,6 +107,9 @@ func TestSingularAggregate(t *testing.T) {
 	if s := agg.Errors()[0].Error(); s != "err" {
 		t.Errorf("expected 'err', got %q", s)
 	}
+	if s := Cause(agg).Error(); s != "err" {
+		t.Errorf("Cause(agg) expected 'err', got %q", s)
+	}
 
 	err = agg.(error)
 	if err == nil {
@@ -115,6 +118,9 @@ func TestSingularAggregate(t *testing.T) {
 	if s := err.Error(); s != "err" {
 		t.Errorf("expected 'err', got %q", s)
 	}
+	if s := Cause(err).Error(); s != "err" {
+		t.Errorf("Cause(err) expected 'err', got %q", s)
+	}
 }
 
 func TestPluralAggregate(t *testing.T) {
@@ -135,6 +141,9 @@ func TestPluralAggregate(t *testing.T) {
 	if s := agg.Errors()[0].Error(); s != "abc" {
 		t.Errorf("expected '[abc, 123]', got %q", s)
 	}
+	if s := Cause(agg); s != ErrAggregate {
+		t.Errorf("Cause(agg) expect %q, got %q", ErrAggregate, s)
+	}
 
 	err = agg.(error)
 	if err == nil {
@@ -143,6 +152,9 @@ func TestPluralAggregate(t *testing.T) {
 	if s := err.Error(); s != "[abc, 123]" {
 		t.Errorf("expected '[abc, 123]', got %q", s)
 	}
+	if s := Cause(err); s != ErrAggregate {
+		t.Errorf("Cause(err) expect %q, got %q", ErrAggregate, s)
+	}
 }
 
 func TestFilterOut(t *testing.T) {

errors/consts.go

@@ -0,0 +1,16 @@
+package errors
+
+const (
+	ErrServer       = Error("ServerError")
+	ErrClient       = Error("ClientError")
+	ErrUnclassified = Error("UnclassifiedError")
+
+	ErrNotFound       = Error("NotFoundError")
+	ErrDuplicateId    = Error("DuplicateIdError")
+	ErrInvalidStatus  = Error("InvalidStatusError")
+	ErrTimeout        = Error("TimeoutError")
+	ErrNotImplemented = Error("NotImplementedError")
+	ErrNotSupported   = Error("NotSupportedError")
+
+	ErrAggregate = Error("AggregateError")
+)

gotypes/deepcopy.go

@@ -24,6 +24,13 @@ type IDeepCopy interface {
 
 type DeepCopyFlags uintptr
 
+// DeepCopy copies the passed argument recursively
+//
+// There are a few constraint
+//
+//  - It cannot handle un-exported fields
+//  - It cannot handle circular references.  Doing so will cause runtime stack
+//    overflow panic
 func DeepCopy(v interface{}) interface{} {
 	rv := reflect.ValueOf(v)
 	cpRv := DeepCopyRv(rv)

gotypes/gotypes_test.go

@@ -246,14 +246,29 @@ func TestInCollection(t *testing.T) {
 }
 
 func TestGetInstanceTypeName(t *testing.T) {
-	var a int32
-	t.Logf("%s", GetInstanceTypeName(a))
-
-	type STestStruct struct {
+	{
+		var (
+			a    int32
+			want = "int32"
+		)
+		if got := GetInstanceTypeName(a); got != want {
+			t.Fatalf("want %s, got %s", want, got)
+		}
 	}
 
-	t.Logf("%s", GetInstanceTypeName(STestStruct{}))
-	t.Logf("%s", GetInstanceTypeName(&STestStruct{}))
+	{
+		type STestStruct struct{}
+		var (
+			want = "STestStruct"
+			a    = STestStruct{}
+		)
+		if got := GetInstanceTypeName(a); got != want {
+			t.Fatalf("want %s, got %s", want, got)
+		}
+		if got := GetInstanceTypeName(&a); got != want {
+			t.Fatalf("ptr type name: want %s, got %s", want, got)
+		}
+	}
 }
 
 func TestIsNil(t *testing.T) {

tristate/tristate_test.go

@@ -17,18 +17,15 @@ package tristate
 import "testing"
 
 func TestTriState(t *testing.T) {
-	if True.Bool() {
-		t.Logf("True == true")
-	}
-	if !False.Bool() {
-		t.Logf("False == false")
-	}
-	if !None.Bool() {
-		t.Logf("None == false")
+	assert := func(hold bool, fmtStr string, args ...interface{}) {
+		if !hold {
+			t.Fatalf(fmtStr, args...)
+		}
 	}
+	assert(True.Bool(), "True != true")
+	assert(!False.Bool(), "False != false")
+	assert(!None.Bool(), "None != false")
 
 	var val TriState
-	if val.IsNone() {
-		t.Logf("val is None")
-	}
+	assert(val.IsNone(), "val is None")
 }

util/filterclause/filterclause.go

@@ -46,6 +46,20 @@ func (jfc *SJointFilterClause) GetJointModelName() string {
 	return jfc.JointModel[:len(jfc.JointModel)-1]
 }
 
+func condFunc(field sqlchemy.IQueryField, params []string, cond func(field sqlchemy.IQueryField, val string) sqlchemy.ICondition) sqlchemy.ICondition {
+	if len(params) == 1 {
+		return cond(field, params[0])
+	} else if len(params) > 1 {
+		conds := make([]sqlchemy.ICondition, len(params))
+		for i := range params {
+			conds[i] = cond(field, params[i])
+		}
+		return sqlchemy.OR(conds...)
+	} else {
+		return nil
+	}
+}
+
 func (fc *SFilterClause) QueryCondition(q *sqlchemy.SQuery) sqlchemy.ICondition {
 	field := q.Field(fc.field)
 	if field == nil {
@@ -78,25 +92,17 @@ func (fc *SFilterClause) QueryCondition(q *sqlchemy.SQuery) sqlchemy.ICondition
 			return sqlchemy.LT(field, fc.params[0])
 		}
 	case "like":
-		if len(fc.params) == 1 {
-			return sqlchemy.Like(field, fc.params[0])
-		}
+		return condFunc(field, fc.params, sqlchemy.Like)
 	case "contains":
-		if len(fc.params) == 1 {
-			return sqlchemy.Contains(field, fc.params[0])
-		}
+		return condFunc(field, fc.params, sqlchemy.Contains)
 	case "startswith":
-		if len(fc.params) == 1 {
-			return sqlchemy.Startswith(field, fc.params[0])
-		}
+		return condFunc(field, fc.params, sqlchemy.Startswith)
 	case "endswith":
-		if len(fc.params) == 1 {
-			return sqlchemy.Endswith(field, fc.params[0])
-		}
+		return condFunc(field, fc.params, sqlchemy.Endswith)
 	case "equals":
-		if len(fc.params) == 1 {
-			return sqlchemy.Equals(field, fc.params[0])
-		}
+		return condFunc(field, fc.params, func(f sqlchemy.IQueryField, p string) sqlchemy.ICondition {
+			return sqlchemy.Equals(f, p)
+		})
 	case "notequals":
 		if len(fc.params) == 1 {
 			return sqlchemy.NOT(sqlchemy.Equals(field, fc.params[0]))

util/netutils/errors.go

@@ -15,13 +15,13 @@
 package netutils
 
 import (
-	"github.com/pkg/errors"
+	"yunion.io/x/pkg/errors"
 )
 
 var (
-	ErrInvalidNumber  = errors.New("invalid number")
-	ErrOutOfRange     = errors.New("ip number out of range [0-255]")
-	ErrInvalidIPAddr  = errors.New("invalid ip address")
-	ErrInvalidMask    = errors.New("invalid mask")
-	ErrOutOfRangeMask = errors.New("out of range masklen [0-32]")
+	ErrInvalidNumber  = errors.Error("invalid number")
+	ErrOutOfRange     = errors.Error("ip number out of range [0-255]")
+	ErrInvalidIPAddr  = errors.Error("invalid ip address")
+	ErrInvalidMask    = errors.Error("invalid mask")
+	ErrOutOfRangeMask = errors.Error("out of range masklen [0-32]")
 )

util/netutils/netutils.go

@@ -16,13 +16,13 @@ package netutils
 
 import (
 	"fmt"
+	"math/bits"
 	"math/rand"
 	"net"
 	"strconv"
 	"strings"
 
-	"github.com/pkg/errors"
-
+	"yunion.io/x/pkg/errors"
 	"yunion.io/x/pkg/util/regutils"
 )
 
@@ -206,6 +206,19 @@ func (ar IPV4AddrRange) EndIp() IPV4Addr {
 	return ar.end
 }
 
+func (ar IPV4AddrRange) Merge(ar2 IPV4AddrRange) (*IPV4AddrRange, bool) {
+	if ar.IsOverlap(ar2) || ar.end+1 == ar2.start || ar2.end+1 == ar.start {
+		if ar2.start < ar.start {
+			ar.start = ar2.start
+		}
+		if ar2.end > ar.end {
+			ar.end = ar2.end
+		}
+		return &ar, true
+	}
+	return nil, false
+}
+
 func (ar IPV4AddrRange) IsOverlap(ar2 IPV4AddrRange) bool {
 	if ar.start > ar2.end || ar.end < ar2.start {
 		return false
@@ -308,11 +321,7 @@ func (ar IPV4AddrRange) equals(ar2 IPV4AddrRange) bool {
 }
 
 func Masklen2Mask(maskLen int8) IPV4Addr {
-	var mask uint32 = 0
-	for i := 0; i < int(maskLen); i += 1 {
-		mask |= 1 << uint(31-i)
-	}
-	return IPV4Addr(mask)
+	return IPV4Addr(^(uint32(1<<(32-maskLen)) - 1))
 }
 
 type IPV4Prefix struct {
@@ -337,14 +346,7 @@ func (pref *IPV4Prefix) Equals(pref1 *IPV4Prefix) bool {
 }
 
 func Mask2Len(mask IPV4Addr) int8 {
-	var maskLen int8 = 0
-	for {
-		if (mask & (1 << uint(31-maskLen))) == 0 {
-			break
-		}
-		maskLen += 1
-	}
-	return maskLen
+	return int8(bits.LeadingZeros32(^uint32(mask)))
 }
 
 func ParsePrefix(prefix string) (IPV4Addr, int8, error) {