implement ippool

1. support vlan ippool management
2. support calico ippool management

Signed-off-by: Duan Jiong <djduanjiong@gmail.com>

pkg/simple/client/network/ippool/calico/client/clientset/versioned/clientset.go

@@ -0,0 +1,97 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package versioned
+
+import (
+	"fmt"
+
+	discovery "k8s.io/client-go/discovery"
+	rest "k8s.io/client-go/rest"
+	flowcontrol "k8s.io/client-go/util/flowcontrol"
+	crdcalicov3 "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3"
+)
+
+type Interface interface {
+	Discovery() discovery.DiscoveryInterface
+	CrdCalicov3() crdcalicov3.CrdCalicov3Interface
+}
+
+// Clientset contains the clients for groups. Each group has exactly one
+// version included in a Clientset.
+type Clientset struct {
+	*discovery.DiscoveryClient
+	crdCalicov3 *crdcalicov3.CrdCalicov3Client
+}
+
+// CrdCalicov3 retrieves the CrdCalicov3Client
+func (c *Clientset) CrdCalicov3() crdcalicov3.CrdCalicov3Interface {
+	return c.crdCalicov3
+}
+
+// Discovery retrieves the DiscoveryClient
+func (c *Clientset) Discovery() discovery.DiscoveryInterface {
+	if c == nil {
+		return nil
+	}
+	return c.DiscoveryClient
+}
+
+// NewForConfig creates a new Clientset for the given config.
+// If config's RateLimiter is not set and QPS and Burst are acceptable,
+// NewForConfig will generate a rate-limiter in configShallowCopy.
+func NewForConfig(c *rest.Config) (*Clientset, error) {
+	configShallowCopy := *c
+	if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 {
+		if configShallowCopy.Burst <= 0 {
+			return nil, fmt.Errorf("Burst is required to be greater than 0 when RateLimiter is not set and QPS is set to greater than 0")
+		}
+		configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst)
+	}
+	var cs Clientset
+	var err error
+	cs.crdCalicov3, err = crdcalicov3.NewForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
+
+	cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
+	return &cs, nil
+}
+
+// NewForConfigOrDie creates a new Clientset for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *Clientset {
+	var cs Clientset
+	cs.crdCalicov3 = crdcalicov3.NewForConfigOrDie(c)
+
+	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
+	return &cs
+}
+
+// New creates a new Clientset for the given RESTClient.
+func New(c rest.Interface) *Clientset {
+	var cs Clientset
+	cs.crdCalicov3 = crdcalicov3.New(c)
+
+	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
+	return &cs
+}

pkg/simple/client/network/ippool/calico/client/clientset/versioned/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// This package has the automatically generated clientset.
+package versioned

pkg/simple/client/network/ippool/calico/client/clientset/versioned/fake/clientset_generated.go

@@ -0,0 +1,82 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/discovery"
+	fakediscovery "k8s.io/client-go/discovery/fake"
+	"k8s.io/client-go/testing"
+	clientset "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned"
+	crdcalicov3 "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3"
+	fakecrdcalicov3 "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3/fake"
+)
+
+// NewSimpleClientset returns a clientset that will respond with the provided objects.
+// It's backed by a very simple object tracker that processes creates, updates and deletions as-is,
+// without applying any validations and/or defaults. It shouldn't be considered a replacement
+// for a real clientset and is mostly useful in simple unit tests.
+func NewSimpleClientset(objects ...runtime.Object) *Clientset {
+	o := testing.NewObjectTracker(scheme, codecs.UniversalDecoder())
+	for _, obj := range objects {
+		if err := o.Add(obj); err != nil {
+			panic(err)
+		}
+	}
+
+	cs := &Clientset{tracker: o}
+	cs.discovery = &fakediscovery.FakeDiscovery{Fake: &cs.Fake}
+	cs.AddReactor("*", "*", testing.ObjectReaction(o))
+	cs.AddWatchReactor("*", func(action testing.Action) (handled bool, ret watch.Interface, err error) {
+		gvr := action.GetResource()
+		ns := action.GetNamespace()
+		watch, err := o.Watch(gvr, ns)
+		if err != nil {
+			return false, nil, err
+		}
+		return true, watch, nil
+	})
+
+	return cs
+}
+
+// Clientset implements clientset.Interface. Meant to be embedded into a
+// struct to get a default implementation. This makes faking out just the method
+// you want to test easier.
+type Clientset struct {
+	testing.Fake
+	discovery *fakediscovery.FakeDiscovery
+	tracker   testing.ObjectTracker
+}
+
+func (c *Clientset) Discovery() discovery.DiscoveryInterface {
+	return c.discovery
+}
+
+func (c *Clientset) Tracker() testing.ObjectTracker {
+	return c.tracker
+}
+
+var _ clientset.Interface = &Clientset{}
+
+// CrdCalicov3 retrieves the CrdCalicov3Client
+func (c *Clientset) CrdCalicov3() crdcalicov3.CrdCalicov3Interface {
+	return &fakecrdcalicov3.FakeCrdCalicov3{Fake: &c.Fake}
+}

pkg/simple/client/network/ippool/calico/client/clientset/versioned/fake/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// This package has the automatically generated fake clientset.
+package fake

pkg/simple/client/network/ippool/calico/client/clientset/versioned/fake/register.go

@@ -0,0 +1,56 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+	crdcalicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+)
+
+var scheme = runtime.NewScheme()
+var codecs = serializer.NewCodecFactory(scheme)
+var parameterCodec = runtime.NewParameterCodec(scheme)
+var localSchemeBuilder = runtime.SchemeBuilder{
+	crdcalicov3.AddToScheme,
+}
+
+// AddToScheme adds all types of this clientset into the given scheme. This allows composition
+// of clientsets, like in:
+//
+//   import (
+//     "k8s.io/client-go/kubernetes"
+//     clientsetscheme "k8s.io/client-go/kubernetes/scheme"
+//     aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme"
+//   )
+//
+//   kclientset, _ := kubernetes.NewForConfig(c)
+//   _ = aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme)
+//
+// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types
+// correctly.
+var AddToScheme = localSchemeBuilder.AddToScheme
+
+func init() {
+	v1.AddToGroupVersion(scheme, schema.GroupVersion{Version: "v1"})
+	utilruntime.Must(AddToScheme(scheme))
+}

pkg/simple/client/network/ippool/calico/client/clientset/versioned/scheme/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// This package contains the scheme of the automatically generated clientset.
+package scheme

pkg/simple/client/network/ippool/calico/client/clientset/versioned/scheme/register.go

@@ -0,0 +1,56 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package scheme
+
+import (
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+	crdcalicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+)
+
+var Scheme = runtime.NewScheme()
+var Codecs = serializer.NewCodecFactory(Scheme)
+var ParameterCodec = runtime.NewParameterCodec(Scheme)
+var localSchemeBuilder = runtime.SchemeBuilder{
+	crdcalicov3.AddToScheme,
+}
+
+// AddToScheme adds all types of this clientset into the given scheme. This allows composition
+// of clientsets, like in:
+//
+//   import (
+//     "k8s.io/client-go/kubernetes"
+//     clientsetscheme "k8s.io/client-go/kubernetes/scheme"
+//     aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme"
+//   )
+//
+//   kclientset, _ := kubernetes.NewForConfig(c)
+//   _ = aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme)
+//
+// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types
+// correctly.
+var AddToScheme = localSchemeBuilder.AddToScheme
+
+func init() {
+	v1.AddToGroupVersion(Scheme, schema.GroupVersion{Version: "v1"})
+	utilruntime.Must(AddToScheme(Scheme))
+}

pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3/blockaffinity.go

@@ -0,0 +1,164 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package calicov3
+
+import (
+	"time"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	rest "k8s.io/client-go/rest"
+	calicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+	scheme "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned/scheme"
+)
+
+// BlockAffinitiesGetter has a method to return a BlockAffinityInterface.
+// A group's client should implement this interface.
+type BlockAffinitiesGetter interface {
+	BlockAffinities() BlockAffinityInterface
+}
+
+// BlockAffinityInterface has methods to work with BlockAffinity resources.
+type BlockAffinityInterface interface {
+	Create(*calicov3.BlockAffinity) (*calicov3.BlockAffinity, error)
+	Update(*calicov3.BlockAffinity) (*calicov3.BlockAffinity, error)
+	Delete(name string, options *v1.DeleteOptions) error
+	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
+	Get(name string, options v1.GetOptions) (*calicov3.BlockAffinity, error)
+	List(opts v1.ListOptions) (*calicov3.BlockAffinityList, error)
+	Watch(opts v1.ListOptions) (watch.Interface, error)
+	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *calicov3.BlockAffinity, err error)
+	BlockAffinityExpansion
+}
+
+// blockAffinities implements BlockAffinityInterface
+type blockAffinities struct {
+	client rest.Interface
+}
+
+// newBlockAffinities returns a BlockAffinities
+func newBlockAffinities(c *CrdCalicov3Client) *blockAffinities {
+	return &blockAffinities{
+		client: c.RESTClient(),
+	}
+}
+
+// Get takes name of the blockAffinity, and returns the corresponding blockAffinity object, and an error if there is any.
+func (c *blockAffinities) Get(name string, options v1.GetOptions) (result *calicov3.BlockAffinity, err error) {
+	result = &calicov3.BlockAffinity{}
+	err = c.client.Get().
+		Resource("blockaffinities").
+		Name(name).
+		VersionedParams(&options, scheme.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of BlockAffinities that match those selectors.
+func (c *blockAffinities) List(opts v1.ListOptions) (result *calicov3.BlockAffinityList, err error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	result = &calicov3.BlockAffinityList{}
+	err = c.client.Get().
+		Resource("blockaffinities").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested blockAffinities.
+func (c *blockAffinities) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	opts.Watch = true
+	return c.client.Get().
+		Resource("blockaffinities").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Watch()
+}
+
+// Create takes the representation of a blockAffinity and creates it.  Returns the server's representation of the blockAffinity, and an error, if there is any.
+func (c *blockAffinities) Create(blockAffinity *calicov3.BlockAffinity) (result *calicov3.BlockAffinity, err error) {
+	result = &calicov3.BlockAffinity{}
+	err = c.client.Post().
+		Resource("blockaffinities").
+		Body(blockAffinity).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a blockAffinity and updates it. Returns the server's representation of the blockAffinity, and an error, if there is any.
+func (c *blockAffinities) Update(blockAffinity *calicov3.BlockAffinity) (result *calicov3.BlockAffinity, err error) {
+	result = &calicov3.BlockAffinity{}
+	err = c.client.Put().
+		Resource("blockaffinities").
+		Name(blockAffinity.Name).
+		Body(blockAffinity).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the blockAffinity and deletes it. Returns an error if one occurs.
+func (c *blockAffinities) Delete(name string, options *v1.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("blockaffinities").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *blockAffinities) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	var timeout time.Duration
+	if listOptions.TimeoutSeconds != nil {
+		timeout = time.Duration(*listOptions.TimeoutSeconds) * time.Second
+	}
+	return c.client.Delete().
+		Resource("blockaffinities").
+		VersionedParams(&listOptions, scheme.ParameterCodec).
+		Timeout(timeout).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Patch applies the patch and returns the patched blockAffinity.
+func (c *blockAffinities) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *calicov3.BlockAffinity, err error) {
+	result = &calicov3.BlockAffinity{}
+	err = c.client.Patch(pt).
+		Resource("blockaffinities").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// This package has the automatically generated typed clients.
+package calicov3

pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3/fake/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// Package fake has the automatically generated clients.
+package fake

pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3/fake/fake_blockaffinity.go

@@ -0,0 +1,120 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+	calicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+)
+
+// FakeBlockAffinities implements BlockAffinityInterface
+type FakeBlockAffinities struct {
+	Fake *FakeCrdCalicov3
+}
+
+var blockaffinitiesResource = schema.GroupVersionResource{Group: "crd.projectcalico.org", Version: "calicov3", Resource: "blockaffinities"}
+
+var blockaffinitiesKind = schema.GroupVersionKind{Group: "crd.projectcalico.org", Version: "calicov3", Kind: "BlockAffinity"}
+
+// Get takes name of the blockAffinity, and returns the corresponding blockAffinity object, and an error if there is any.
+func (c *FakeBlockAffinities) Get(name string, options v1.GetOptions) (result *calicov3.BlockAffinity, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(blockaffinitiesResource, name), &calicov3.BlockAffinity{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*calicov3.BlockAffinity), err
+}
+
+// List takes label and field selectors, and returns the list of BlockAffinities that match those selectors.
+func (c *FakeBlockAffinities) List(opts v1.ListOptions) (result *calicov3.BlockAffinityList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(blockaffinitiesResource, blockaffinitiesKind, opts), &calicov3.BlockAffinityList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &calicov3.BlockAffinityList{ListMeta: obj.(*calicov3.BlockAffinityList).ListMeta}
+	for _, item := range obj.(*calicov3.BlockAffinityList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested blockAffinities.
+func (c *FakeBlockAffinities) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(blockaffinitiesResource, opts))
+}
+
+// Create takes the representation of a blockAffinity and creates it.  Returns the server's representation of the blockAffinity, and an error, if there is any.
+func (c *FakeBlockAffinities) Create(blockAffinity *calicov3.BlockAffinity) (result *calicov3.BlockAffinity, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(blockaffinitiesResource, blockAffinity), &calicov3.BlockAffinity{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*calicov3.BlockAffinity), err
+}
+
+// Update takes the representation of a blockAffinity and updates it. Returns the server's representation of the blockAffinity, and an error, if there is any.
+func (c *FakeBlockAffinities) Update(blockAffinity *calicov3.BlockAffinity) (result *calicov3.BlockAffinity, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(blockaffinitiesResource, blockAffinity), &calicov3.BlockAffinity{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*calicov3.BlockAffinity), err
+}
+
+// Delete takes name of the blockAffinity and deletes it. Returns an error if one occurs.
+func (c *FakeBlockAffinities) Delete(name string, options *v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(blockaffinitiesResource, name), &calicov3.BlockAffinity{})
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeBlockAffinities) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(blockaffinitiesResource, listOptions)
+
+	_, err := c.Fake.Invokes(action, &calicov3.BlockAffinityList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched blockAffinity.
+func (c *FakeBlockAffinities) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *calicov3.BlockAffinity, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(blockaffinitiesResource, name, pt, data, subresources...), &calicov3.BlockAffinity{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*calicov3.BlockAffinity), err
+}

pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3/fake/fake_ipamblock.go

@@ -0,0 +1,120 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+	calicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+)
+
+// FakeIPAMBlocks implements IPAMBlockInterface
+type FakeIPAMBlocks struct {
+	Fake *FakeCrdCalicov3
+}
+
+var ipamblocksResource = schema.GroupVersionResource{Group: "crd.projectcalico.org", Version: "calicov3", Resource: "ipamblocks"}
+
+var ipamblocksKind = schema.GroupVersionKind{Group: "crd.projectcalico.org", Version: "calicov3", Kind: "IPAMBlock"}
+
+// Get takes name of the iPAMBlock, and returns the corresponding iPAMBlock object, and an error if there is any.
+func (c *FakeIPAMBlocks) Get(name string, options v1.GetOptions) (result *calicov3.IPAMBlock, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(ipamblocksResource, name), &calicov3.IPAMBlock{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*calicov3.IPAMBlock), err
+}
+
+// List takes label and field selectors, and returns the list of IPAMBlocks that match those selectors.
+func (c *FakeIPAMBlocks) List(opts v1.ListOptions) (result *calicov3.IPAMBlockList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(ipamblocksResource, ipamblocksKind, opts), &calicov3.IPAMBlockList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &calicov3.IPAMBlockList{ListMeta: obj.(*calicov3.IPAMBlockList).ListMeta}
+	for _, item := range obj.(*calicov3.IPAMBlockList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested iPAMBlocks.
+func (c *FakeIPAMBlocks) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(ipamblocksResource, opts))
+}
+
+// Create takes the representation of a iPAMBlock and creates it.  Returns the server's representation of the iPAMBlock, and an error, if there is any.
+func (c *FakeIPAMBlocks) Create(iPAMBlock *calicov3.IPAMBlock) (result *calicov3.IPAMBlock, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(ipamblocksResource, iPAMBlock), &calicov3.IPAMBlock{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*calicov3.IPAMBlock), err
+}
+
+// Update takes the representation of a iPAMBlock and updates it. Returns the server's representation of the iPAMBlock, and an error, if there is any.
+func (c *FakeIPAMBlocks) Update(iPAMBlock *calicov3.IPAMBlock) (result *calicov3.IPAMBlock, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(ipamblocksResource, iPAMBlock), &calicov3.IPAMBlock{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*calicov3.IPAMBlock), err
+}
+
+// Delete takes name of the iPAMBlock and deletes it. Returns an error if one occurs.
+func (c *FakeIPAMBlocks) Delete(name string, options *v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(ipamblocksResource, name), &calicov3.IPAMBlock{})
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeIPAMBlocks) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(ipamblocksResource, listOptions)
+
+	_, err := c.Fake.Invokes(action, &calicov3.IPAMBlockList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched iPAMBlock.
+func (c *FakeIPAMBlocks) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *calicov3.IPAMBlock, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(ipamblocksResource, name, pt, data, subresources...), &calicov3.IPAMBlock{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*calicov3.IPAMBlock), err
+}

pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3/fake/fake_ippool.go

@@ -0,0 +1,120 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+	calicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+)
+
+// FakeIPPools implements IPPoolInterface
+type FakeIPPools struct {
+	Fake *FakeCrdCalicov3
+}
+
+var ippoolsResource = schema.GroupVersionResource{Group: "crd.projectcalico.org", Version: "calicov3", Resource: "ippools"}
+
+var ippoolsKind = schema.GroupVersionKind{Group: "crd.projectcalico.org", Version: "calicov3", Kind: "IPPool"}
+
+// Get takes name of the iPPool, and returns the corresponding iPPool object, and an error if there is any.
+func (c *FakeIPPools) Get(name string, options v1.GetOptions) (result *calicov3.IPPool, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(ippoolsResource, name), &calicov3.IPPool{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*calicov3.IPPool), err
+}
+
+// List takes label and field selectors, and returns the list of IPPools that match those selectors.
+func (c *FakeIPPools) List(opts v1.ListOptions) (result *calicov3.IPPoolList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(ippoolsResource, ippoolsKind, opts), &calicov3.IPPoolList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &calicov3.IPPoolList{ListMeta: obj.(*calicov3.IPPoolList).ListMeta}
+	for _, item := range obj.(*calicov3.IPPoolList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested iPPools.
+func (c *FakeIPPools) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(ippoolsResource, opts))
+}
+
+// Create takes the representation of a iPPool and creates it.  Returns the server's representation of the iPPool, and an error, if there is any.
+func (c *FakeIPPools) Create(iPPool *calicov3.IPPool) (result *calicov3.IPPool, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(ippoolsResource, iPPool), &calicov3.IPPool{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*calicov3.IPPool), err
+}
+
+// Update takes the representation of a iPPool and updates it. Returns the server's representation of the iPPool, and an error, if there is any.
+func (c *FakeIPPools) Update(iPPool *calicov3.IPPool) (result *calicov3.IPPool, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(ippoolsResource, iPPool), &calicov3.IPPool{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*calicov3.IPPool), err
+}
+
+// Delete takes name of the iPPool and deletes it. Returns an error if one occurs.
+func (c *FakeIPPools) Delete(name string, options *v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(ippoolsResource, name), &calicov3.IPPool{})
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeIPPools) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(ippoolsResource, listOptions)
+
+	_, err := c.Fake.Invokes(action, &calicov3.IPPoolList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched iPPool.
+func (c *FakeIPPools) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *calicov3.IPPool, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(ippoolsResource, name, pt, data, subresources...), &calicov3.IPPool{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*calicov3.IPPool), err
+}

pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3/fake/fake_network_client.go

@@ -0,0 +1,48 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	rest "k8s.io/client-go/rest"
+	testing "k8s.io/client-go/testing"
+	calicov3 "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3"
+)
+
+type FakeCrdCalicov3 struct {
+	*testing.Fake
+}
+
+func (c *FakeCrdCalicov3) BlockAffinities() calicov3.BlockAffinityInterface {
+	return &FakeBlockAffinities{c}
+}
+
+func (c *FakeCrdCalicov3) IPAMBlocks() calicov3.IPAMBlockInterface {
+	return &FakeIPAMBlocks{c}
+}
+
+func (c *FakeCrdCalicov3) IPPools() calicov3.IPPoolInterface {
+	return &FakeIPPools{c}
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeCrdCalicov3) RESTClient() rest.Interface {
+	var ret *rest.RESTClient
+	return ret
+}

pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3/generated_expansion.go

@@ -0,0 +1,25 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package calicov3
+
+type BlockAffinityExpansion interface{}
+
+type IPAMBlockExpansion interface{}
+
+type IPPoolExpansion interface{}

pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3/ipamblock.go

@@ -0,0 +1,164 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package calicov3
+
+import (
+	"time"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	rest "k8s.io/client-go/rest"
+	calicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+	scheme "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned/scheme"
+)
+
+// IPAMBlocksGetter has a method to return a IPAMBlockInterface.
+// A group's client should implement this interface.
+type IPAMBlocksGetter interface {
+	IPAMBlocks() IPAMBlockInterface
+}
+
+// IPAMBlockInterface has methods to work with IPAMBlock resources.
+type IPAMBlockInterface interface {
+	Create(*calicov3.IPAMBlock) (*calicov3.IPAMBlock, error)
+	Update(*calicov3.IPAMBlock) (*calicov3.IPAMBlock, error)
+	Delete(name string, options *v1.DeleteOptions) error
+	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
+	Get(name string, options v1.GetOptions) (*calicov3.IPAMBlock, error)
+	List(opts v1.ListOptions) (*calicov3.IPAMBlockList, error)
+	Watch(opts v1.ListOptions) (watch.Interface, error)
+	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *calicov3.IPAMBlock, err error)
+	IPAMBlockExpansion
+}
+
+// iPAMBlocks implements IPAMBlockInterface
+type iPAMBlocks struct {
+	client rest.Interface
+}
+
+// newIPAMBlocks returns a IPAMBlocks
+func newIPAMBlocks(c *CrdCalicov3Client) *iPAMBlocks {
+	return &iPAMBlocks{
+		client: c.RESTClient(),
+	}
+}
+
+// Get takes name of the iPAMBlock, and returns the corresponding iPAMBlock object, and an error if there is any.
+func (c *iPAMBlocks) Get(name string, options v1.GetOptions) (result *calicov3.IPAMBlock, err error) {
+	result = &calicov3.IPAMBlock{}
+	err = c.client.Get().
+		Resource("ipamblocks").
+		Name(name).
+		VersionedParams(&options, scheme.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of IPAMBlocks that match those selectors.
+func (c *iPAMBlocks) List(opts v1.ListOptions) (result *calicov3.IPAMBlockList, err error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	result = &calicov3.IPAMBlockList{}
+	err = c.client.Get().
+		Resource("ipamblocks").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested iPAMBlocks.
+func (c *iPAMBlocks) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	opts.Watch = true
+	return c.client.Get().
+		Resource("ipamblocks").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Watch()
+}
+
+// Create takes the representation of a iPAMBlock and creates it.  Returns the server's representation of the iPAMBlock, and an error, if there is any.
+func (c *iPAMBlocks) Create(iPAMBlock *calicov3.IPAMBlock) (result *calicov3.IPAMBlock, err error) {
+	result = &calicov3.IPAMBlock{}
+	err = c.client.Post().
+		Resource("ipamblocks").
+		Body(iPAMBlock).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a iPAMBlock and updates it. Returns the server's representation of the iPAMBlock, and an error, if there is any.
+func (c *iPAMBlocks) Update(iPAMBlock *calicov3.IPAMBlock) (result *calicov3.IPAMBlock, err error) {
+	result = &calicov3.IPAMBlock{}
+	err = c.client.Put().
+		Resource("ipamblocks").
+		Name(iPAMBlock.Name).
+		Body(iPAMBlock).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the iPAMBlock and deletes it. Returns an error if one occurs.
+func (c *iPAMBlocks) Delete(name string, options *v1.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("ipamblocks").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *iPAMBlocks) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	var timeout time.Duration
+	if listOptions.TimeoutSeconds != nil {
+		timeout = time.Duration(*listOptions.TimeoutSeconds) * time.Second
+	}
+	return c.client.Delete().
+		Resource("ipamblocks").
+		VersionedParams(&listOptions, scheme.ParameterCodec).
+		Timeout(timeout).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Patch applies the patch and returns the patched iPAMBlock.
+func (c *iPAMBlocks) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *calicov3.IPAMBlock, err error) {
+	result = &calicov3.IPAMBlock{}
+	err = c.client.Patch(pt).
+		Resource("ipamblocks").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3/ippool.go

@@ -0,0 +1,164 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package calicov3
+
+import (
+	"time"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	rest "k8s.io/client-go/rest"
+	calicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+	scheme "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned/scheme"
+)
+
+// IPPoolsGetter has a method to return a IPPoolInterface.
+// A group's client should implement this interface.
+type IPPoolsGetter interface {
+	IPPools() IPPoolInterface
+}
+
+// IPPoolInterface has methods to work with IPPool resources.
+type IPPoolInterface interface {
+	Create(*calicov3.IPPool) (*calicov3.IPPool, error)
+	Update(*calicov3.IPPool) (*calicov3.IPPool, error)
+	Delete(name string, options *v1.DeleteOptions) error
+	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
+	Get(name string, options v1.GetOptions) (*calicov3.IPPool, error)
+	List(opts v1.ListOptions) (*calicov3.IPPoolList, error)
+	Watch(opts v1.ListOptions) (watch.Interface, error)
+	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *calicov3.IPPool, err error)
+	IPPoolExpansion
+}
+
+// iPPools implements IPPoolInterface
+type iPPools struct {
+	client rest.Interface
+}
+
+// newIPPools returns a IPPools
+func newIPPools(c *CrdCalicov3Client) *iPPools {
+	return &iPPools{
+		client: c.RESTClient(),
+	}
+}
+
+// Get takes name of the iPPool, and returns the corresponding iPPool object, and an error if there is any.
+func (c *iPPools) Get(name string, options v1.GetOptions) (result *calicov3.IPPool, err error) {
+	result = &calicov3.IPPool{}
+	err = c.client.Get().
+		Resource("ippools").
+		Name(name).
+		VersionedParams(&options, scheme.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of IPPools that match those selectors.
+func (c *iPPools) List(opts v1.ListOptions) (result *calicov3.IPPoolList, err error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	result = &calicov3.IPPoolList{}
+	err = c.client.Get().
+		Resource("ippools").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested iPPools.
+func (c *iPPools) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	opts.Watch = true
+	return c.client.Get().
+		Resource("ippools").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Watch()
+}
+
+// Create takes the representation of a iPPool and creates it.  Returns the server's representation of the iPPool, and an error, if there is any.
+func (c *iPPools) Create(iPPool *calicov3.IPPool) (result *calicov3.IPPool, err error) {
+	result = &calicov3.IPPool{}
+	err = c.client.Post().
+		Resource("ippools").
+		Body(iPPool).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a iPPool and updates it. Returns the server's representation of the iPPool, and an error, if there is any.
+func (c *iPPools) Update(iPPool *calicov3.IPPool) (result *calicov3.IPPool, err error) {
+	result = &calicov3.IPPool{}
+	err = c.client.Put().
+		Resource("ippools").
+		Name(iPPool.Name).
+		Body(iPPool).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the iPPool and deletes it. Returns an error if one occurs.
+func (c *iPPools) Delete(name string, options *v1.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("ippools").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *iPPools) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	var timeout time.Duration
+	if listOptions.TimeoutSeconds != nil {
+		timeout = time.Duration(*listOptions.TimeoutSeconds) * time.Second
+	}
+	return c.client.Delete().
+		Resource("ippools").
+		VersionedParams(&listOptions, scheme.ParameterCodec).
+		Timeout(timeout).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Patch applies the patch and returns the patched iPPool.
+func (c *iPPools) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *calicov3.IPPool, err error) {
+	result = &calicov3.IPPool{}
+	err = c.client.Patch(pt).
+		Resource("ippools").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

pkg/simple/client/network/ippool/calico/client/clientset/versioned/typed/network/calicov3/network_client.go

@@ -0,0 +1,99 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package calicov3
+
+import (
+	rest "k8s.io/client-go/rest"
+	calicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+	"kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned/scheme"
+)
+
+type CrdCalicov3Interface interface {
+	RESTClient() rest.Interface
+	BlockAffinitiesGetter
+	IPAMBlocksGetter
+	IPPoolsGetter
+}
+
+// CrdCalicov3Client is used to interact with features provided by the crd.projectcalico.org group.
+type CrdCalicov3Client struct {
+	restClient rest.Interface
+}
+
+func (c *CrdCalicov3Client) BlockAffinities() BlockAffinityInterface {
+	return newBlockAffinities(c)
+}
+
+func (c *CrdCalicov3Client) IPAMBlocks() IPAMBlockInterface {
+	return newIPAMBlocks(c)
+}
+
+func (c *CrdCalicov3Client) IPPools() IPPoolInterface {
+	return newIPPools(c)
+}
+
+// NewForConfig creates a new CrdCalicov3Client for the given config.
+func NewForConfig(c *rest.Config) (*CrdCalicov3Client, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := rest.RESTClientFor(&config)
+	if err != nil {
+		return nil, err
+	}
+	return &CrdCalicov3Client{client}, nil
+}
+
+// NewForConfigOrDie creates a new CrdCalicov3Client for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *CrdCalicov3Client {
+	client, err := NewForConfig(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+}
+
+// New creates a new CrdCalicov3Client for the given RESTClient.
+func New(c rest.Interface) *CrdCalicov3Client {
+	return &CrdCalicov3Client{c}
+}
+
+func setConfigDefaults(config *rest.Config) error {
+	gv := calicov3.SchemeGroupVersion
+	config.GroupVersion = &gv
+	config.APIPath = "/apis"
+	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+
+	if config.UserAgent == "" {
+		config.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+
+	return nil
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *CrdCalicov3Client) RESTClient() rest.Interface {
+	if c == nil {
+		return nil
+	}
+	return c.restClient
+}

pkg/simple/client/network/ippool/calico/client/informers/externalversions/factory.go

@@ -0,0 +1,180 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package externalversions
+
+import (
+	reflect "reflect"
+	sync "sync"
+	time "time"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	cache "k8s.io/client-go/tools/cache"
+	versioned "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned"
+	internalinterfaces "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/informers/externalversions/internalinterfaces"
+	network "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/informers/externalversions/network"
+)
+
+// SharedInformerOption defines the functional option type for SharedInformerFactory.
+type SharedInformerOption func(*sharedInformerFactory) *sharedInformerFactory
+
+type sharedInformerFactory struct {
+	client           versioned.Interface
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	lock             sync.Mutex
+	defaultResync    time.Duration
+	customResync     map[reflect.Type]time.Duration
+
+	informers map[reflect.Type]cache.SharedIndexInformer
+	// startedInformers is used for tracking which informers have been started.
+	// This allows Start() to be called multiple times safely.
+	startedInformers map[reflect.Type]bool
+}
+
+// WithCustomResyncConfig sets a custom resync period for the specified informer types.
+func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption {
+	return func(factory *sharedInformerFactory) *sharedInformerFactory {
+		for k, v := range resyncConfig {
+			factory.customResync[reflect.TypeOf(k)] = v
+		}
+		return factory
+	}
+}
+
+// WithTweakListOptions sets a custom filter on all listers of the configured SharedInformerFactory.
+func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption {
+	return func(factory *sharedInformerFactory) *sharedInformerFactory {
+		factory.tweakListOptions = tweakListOptions
+		return factory
+	}
+}
+
+// WithNamespace limits the SharedInformerFactory to the specified namespace.
+func WithNamespace(namespace string) SharedInformerOption {
+	return func(factory *sharedInformerFactory) *sharedInformerFactory {
+		factory.namespace = namespace
+		return factory
+	}
+}
+
+// NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces.
+func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory {
+	return NewSharedInformerFactoryWithOptions(client, defaultResync)
+}
+
+// NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory.
+// Listers obtained via this SharedInformerFactory will be subject to the same filters
+// as specified here.
+// Deprecated: Please use NewSharedInformerFactoryWithOptions instead
+func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory {
+	return NewSharedInformerFactoryWithOptions(client, defaultResync, WithNamespace(namespace), WithTweakListOptions(tweakListOptions))
+}
+
+// NewSharedInformerFactoryWithOptions constructs a new instance of a SharedInformerFactory with additional options.
+func NewSharedInformerFactoryWithOptions(client versioned.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory {
+	factory := &sharedInformerFactory{
+		client:           client,
+		namespace:        v1.NamespaceAll,
+		defaultResync:    defaultResync,
+		informers:        make(map[reflect.Type]cache.SharedIndexInformer),
+		startedInformers: make(map[reflect.Type]bool),
+		customResync:     make(map[reflect.Type]time.Duration),
+	}
+
+	// Apply all options
+	for _, opt := range options {
+		factory = opt(factory)
+	}
+
+	return factory
+}
+
+// Start initializes all requested informers.
+func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	for informerType, informer := range f.informers {
+		if !f.startedInformers[informerType] {
+			go informer.Run(stopCh)
+			f.startedInformers[informerType] = true
+		}
+	}
+}
+
+// WaitForCacheSync waits for all started informers' cache were synced.
+func (f *sharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool {
+	informers := func() map[reflect.Type]cache.SharedIndexInformer {
+		f.lock.Lock()
+		defer f.lock.Unlock()
+
+		informers := map[reflect.Type]cache.SharedIndexInformer{}
+		for informerType, informer := range f.informers {
+			if f.startedInformers[informerType] {
+				informers[informerType] = informer
+			}
+		}
+		return informers
+	}()
+
+	res := map[reflect.Type]bool{}
+	for informType, informer := range informers {
+		res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced)
+	}
+	return res
+}
+
+// InternalInformerFor returns the SharedIndexInformer for obj using an internal
+// client.
+func (f *sharedInformerFactory) InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	informerType := reflect.TypeOf(obj)
+	informer, exists := f.informers[informerType]
+	if exists {
+		return informer
+	}
+
+	resyncPeriod, exists := f.customResync[informerType]
+	if !exists {
+		resyncPeriod = f.defaultResync
+	}
+
+	informer = newFunc(f.client, resyncPeriod)
+	f.informers[informerType] = informer
+
+	return informer
+}
+
+// SharedInformerFactory provides shared informers for resources in all known
+// API group versions.
+type SharedInformerFactory interface {
+	internalinterfaces.SharedInformerFactory
+	ForResource(resource schema.GroupVersionResource) (GenericInformer, error)
+	WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool
+
+	Crd() network.Interface
+}
+
+func (f *sharedInformerFactory) Crd() network.Interface {
+	return network.New(f, f.namespace, f.tweakListOptions)
+}

pkg/simple/client/network/ippool/calico/client/informers/externalversions/generic.go

@@ -0,0 +1,66 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package externalversions
+
+import (
+	"fmt"
+
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	cache "k8s.io/client-go/tools/cache"
+	calicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+)
+
+// GenericInformer is type of SharedIndexInformer which will locate and delegate to other
+// sharedInformers based on type
+type GenericInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() cache.GenericLister
+}
+
+type genericInformer struct {
+	informer cache.SharedIndexInformer
+	resource schema.GroupResource
+}
+
+// Informer returns the SharedIndexInformer.
+func (f *genericInformer) Informer() cache.SharedIndexInformer {
+	return f.informer
+}
+
+// Lister returns the GenericLister.
+func (f *genericInformer) Lister() cache.GenericLister {
+	return cache.NewGenericLister(f.Informer().GetIndexer(), f.resource)
+}
+
+// ForResource gives generic access to a shared informer of the matching type
+// TODO extend this to unknown resources with a client pool
+func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) {
+	switch resource {
+	// Group=crd.projectcalico.org, Version=calicov3
+	case calicov3.SchemeGroupVersion.WithResource("blockaffinities"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Crd().Calicov3().BlockAffinities().Informer()}, nil
+	case calicov3.SchemeGroupVersion.WithResource("ipamblocks"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Crd().Calicov3().IPAMBlocks().Informer()}, nil
+	case calicov3.SchemeGroupVersion.WithResource("ippools"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Crd().Calicov3().IPPools().Informer()}, nil
+
+	}
+
+	return nil, fmt.Errorf("no informer found for %v", resource)
+}

pkg/simple/client/network/ippool/calico/client/informers/externalversions/internalinterfaces/factory_interfaces.go

@@ -0,0 +1,40 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package internalinterfaces
+
+import (
+	time "time"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	cache "k8s.io/client-go/tools/cache"
+	versioned "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned"
+)
+
+// NewInformerFunc takes versioned.Interface and time.Duration to return a SharedIndexInformer.
+type NewInformerFunc func(versioned.Interface, time.Duration) cache.SharedIndexInformer
+
+// SharedInformerFactory a small interface to allow for adding an informer without an import cycle
+type SharedInformerFactory interface {
+	Start(stopCh <-chan struct{})
+	InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer
+}
+
+// TweakListOptionsFunc is a function that transforms a v1.ListOptions.
+type TweakListOptionsFunc func(*v1.ListOptions)

pkg/simple/client/network/ippool/calico/client/informers/externalversions/network/calicov3/blockaffinity.go

@@ -0,0 +1,88 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package calicov3
+
+import (
+	time "time"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	watch "k8s.io/apimachinery/pkg/watch"
+	cache "k8s.io/client-go/tools/cache"
+	networkcalicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+	versioned "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned"
+	internalinterfaces "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/informers/externalversions/internalinterfaces"
+	calicov3 "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/listers/network/calicov3"
+)
+
+// BlockAffinityInformer provides access to a shared informer and lister for
+// BlockAffinities.
+type BlockAffinityInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() calicov3.BlockAffinityLister
+}
+
+type blockAffinityInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// NewBlockAffinityInformer constructs a new informer for BlockAffinity type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewBlockAffinityInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredBlockAffinityInformer(client, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredBlockAffinityInformer constructs a new informer for BlockAffinity type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewFilteredBlockAffinityInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
+	return cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.CrdCalicov3().BlockAffinities().List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.CrdCalicov3().BlockAffinities().Watch(options)
+			},
+		},
+		&networkcalicov3.BlockAffinity{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *blockAffinityInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredBlockAffinityInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *blockAffinityInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&networkcalicov3.BlockAffinity{}, f.defaultInformer)
+}
+
+func (f *blockAffinityInformer) Lister() calicov3.BlockAffinityLister {
+	return calicov3.NewBlockAffinityLister(f.Informer().GetIndexer())
+}

pkg/simple/client/network/ippool/calico/client/informers/externalversions/network/calicov3/interface.go

@@ -0,0 +1,59 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package calicov3
+
+import (
+	internalinterfaces "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// BlockAffinities returns a BlockAffinityInformer.
+	BlockAffinities() BlockAffinityInformer
+	// IPAMBlocks returns a IPAMBlockInformer.
+	IPAMBlocks() IPAMBlockInformer
+	// IPPools returns a IPPoolInformer.
+	IPPools() IPPoolInformer
+}
+
+type version struct {
+	factory          internalinterfaces.SharedInformerFactory
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
+	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
+}
+
+// BlockAffinities returns a BlockAffinityInformer.
+func (v *version) BlockAffinities() BlockAffinityInformer {
+	return &blockAffinityInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
+}
+
+// IPAMBlocks returns a IPAMBlockInformer.
+func (v *version) IPAMBlocks() IPAMBlockInformer {
+	return &iPAMBlockInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
+}
+
+// IPPools returns a IPPoolInformer.
+func (v *version) IPPools() IPPoolInformer {
+	return &iPPoolInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
+}

pkg/simple/client/network/ippool/calico/client/informers/externalversions/network/calicov3/ipamblock.go

@@ -0,0 +1,88 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package calicov3
+
+import (
+	time "time"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	watch "k8s.io/apimachinery/pkg/watch"
+	cache "k8s.io/client-go/tools/cache"
+	networkcalicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+	versioned "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned"
+	internalinterfaces "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/informers/externalversions/internalinterfaces"
+	calicov3 "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/listers/network/calicov3"
+)
+
+// IPAMBlockInformer provides access to a shared informer and lister for
+// IPAMBlocks.
+type IPAMBlockInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() calicov3.IPAMBlockLister
+}
+
+type iPAMBlockInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// NewIPAMBlockInformer constructs a new informer for IPAMBlock type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewIPAMBlockInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredIPAMBlockInformer(client, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredIPAMBlockInformer constructs a new informer for IPAMBlock type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewFilteredIPAMBlockInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
+	return cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.CrdCalicov3().IPAMBlocks().List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.CrdCalicov3().IPAMBlocks().Watch(options)
+			},
+		},
+		&networkcalicov3.IPAMBlock{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *iPAMBlockInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredIPAMBlockInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *iPAMBlockInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&networkcalicov3.IPAMBlock{}, f.defaultInformer)
+}
+
+func (f *iPAMBlockInformer) Lister() calicov3.IPAMBlockLister {
+	return calicov3.NewIPAMBlockLister(f.Informer().GetIndexer())
+}

pkg/simple/client/network/ippool/calico/client/informers/externalversions/network/calicov3/ippool.go

@@ -0,0 +1,88 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package calicov3
+
+import (
+	time "time"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	watch "k8s.io/apimachinery/pkg/watch"
+	cache "k8s.io/client-go/tools/cache"
+	networkcalicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+	versioned "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned"
+	internalinterfaces "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/informers/externalversions/internalinterfaces"
+	calicov3 "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/listers/network/calicov3"
+)
+
+// IPPoolInformer provides access to a shared informer and lister for
+// IPPools.
+type IPPoolInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() calicov3.IPPoolLister
+}
+
+type iPPoolInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// NewIPPoolInformer constructs a new informer for IPPool type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewIPPoolInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredIPPoolInformer(client, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredIPPoolInformer constructs a new informer for IPPool type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewFilteredIPPoolInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
+	return cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.CrdCalicov3().IPPools().List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.CrdCalicov3().IPPools().Watch(options)
+			},
+		},
+		&networkcalicov3.IPPool{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *iPPoolInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredIPPoolInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *iPPoolInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&networkcalicov3.IPPool{}, f.defaultInformer)
+}
+
+func (f *iPPoolInformer) Lister() calicov3.IPPoolLister {
+	return calicov3.NewIPPoolLister(f.Informer().GetIndexer())
+}

pkg/simple/client/network/ippool/calico/client/informers/externalversions/network/interface.go

@@ -0,0 +1,46 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package network
+
+import (
+	internalinterfaces "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/informers/externalversions/internalinterfaces"
+	calicov3 "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/informers/externalversions/network/calicov3"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// Calicov3 provides access to shared informers for resources in Calicov3.
+	Calicov3() calicov3.Interface
+}
+
+type group struct {
+	factory          internalinterfaces.SharedInformerFactory
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
+	return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
+}
+
+// Calicov3 returns a new calicov3.Interface.
+func (g *group) Calicov3() calicov3.Interface {
+	return calicov3.New(g.factory, g.namespace, g.tweakListOptions)
+}

pkg/simple/client/network/ippool/calico/client/listers/network/calicov3/blockaffinity.go

@@ -0,0 +1,65 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by lister-gen. DO NOT EDIT.
+
+package calicov3
+
+import (
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/client-go/tools/cache"
+	calicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+)
+
+// BlockAffinityLister helps list BlockAffinities.
+type BlockAffinityLister interface {
+	// List lists all BlockAffinities in the indexer.
+	List(selector labels.Selector) (ret []*calicov3.BlockAffinity, err error)
+	// Get retrieves the BlockAffinity from the index for a given name.
+	Get(name string) (*calicov3.BlockAffinity, error)
+	BlockAffinityListerExpansion
+}
+
+// blockAffinityLister implements the BlockAffinityLister interface.
+type blockAffinityLister struct {
+	indexer cache.Indexer
+}
+
+// NewBlockAffinityLister returns a new BlockAffinityLister.
+func NewBlockAffinityLister(indexer cache.Indexer) BlockAffinityLister {
+	return &blockAffinityLister{indexer: indexer}
+}
+
+// List lists all BlockAffinities in the indexer.
+func (s *blockAffinityLister) List(selector labels.Selector) (ret []*calicov3.BlockAffinity, err error) {
+	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
+		ret = append(ret, m.(*calicov3.BlockAffinity))
+	})
+	return ret, err
+}
+
+// Get retrieves the BlockAffinity from the index for a given name.
+func (s *blockAffinityLister) Get(name string) (*calicov3.BlockAffinity, error) {
+	obj, exists, err := s.indexer.GetByKey(name)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(calicov3.Resource("blockaffinity"), name)
+	}
+	return obj.(*calicov3.BlockAffinity), nil
+}

pkg/simple/client/network/ippool/calico/client/listers/network/calicov3/expansion_generated.go

@@ -0,0 +1,31 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by lister-gen. DO NOT EDIT.
+
+package calicov3
+
+// BlockAffinityListerExpansion allows custom methods to be added to
+// BlockAffinityLister.
+type BlockAffinityListerExpansion interface{}
+
+// IPAMBlockListerExpansion allows custom methods to be added to
+// IPAMBlockLister.
+type IPAMBlockListerExpansion interface{}
+
+// IPPoolListerExpansion allows custom methods to be added to
+// IPPoolLister.
+type IPPoolListerExpansion interface{}

pkg/simple/client/network/ippool/calico/client/listers/network/calicov3/ipamblock.go

@@ -0,0 +1,65 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by lister-gen. DO NOT EDIT.
+
+package calicov3
+
+import (
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/client-go/tools/cache"
+	calicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+)
+
+// IPAMBlockLister helps list IPAMBlocks.
+type IPAMBlockLister interface {
+	// List lists all IPAMBlocks in the indexer.
+	List(selector labels.Selector) (ret []*calicov3.IPAMBlock, err error)
+	// Get retrieves the IPAMBlock from the index for a given name.
+	Get(name string) (*calicov3.IPAMBlock, error)
+	IPAMBlockListerExpansion
+}
+
+// iPAMBlockLister implements the IPAMBlockLister interface.
+type iPAMBlockLister struct {
+	indexer cache.Indexer
+}
+
+// NewIPAMBlockLister returns a new IPAMBlockLister.
+func NewIPAMBlockLister(indexer cache.Indexer) IPAMBlockLister {
+	return &iPAMBlockLister{indexer: indexer}
+}
+
+// List lists all IPAMBlocks in the indexer.
+func (s *iPAMBlockLister) List(selector labels.Selector) (ret []*calicov3.IPAMBlock, err error) {
+	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
+		ret = append(ret, m.(*calicov3.IPAMBlock))
+	})
+	return ret, err
+}
+
+// Get retrieves the IPAMBlock from the index for a given name.
+func (s *iPAMBlockLister) Get(name string) (*calicov3.IPAMBlock, error) {
+	obj, exists, err := s.indexer.GetByKey(name)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(calicov3.Resource("ipamblock"), name)
+	}
+	return obj.(*calicov3.IPAMBlock), nil
+}

pkg/simple/client/network/ippool/calico/client/listers/network/calicov3/ippool.go

@@ -0,0 +1,65 @@
+/*
+Copyright 2020 The KubeSphere Authors.
+
+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.
+*/
+
+// Code generated by lister-gen. DO NOT EDIT.
+
+package calicov3
+
+import (
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/client-go/tools/cache"
+	calicov3 "kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+)
+
+// IPPoolLister helps list IPPools.
+type IPPoolLister interface {
+	// List lists all IPPools in the indexer.
+	List(selector labels.Selector) (ret []*calicov3.IPPool, err error)
+	// Get retrieves the IPPool from the index for a given name.
+	Get(name string) (*calicov3.IPPool, error)
+	IPPoolListerExpansion
+}
+
+// iPPoolLister implements the IPPoolLister interface.
+type iPPoolLister struct {
+	indexer cache.Indexer
+}
+
+// NewIPPoolLister returns a new IPPoolLister.
+func NewIPPoolLister(indexer cache.Indexer) IPPoolLister {
+	return &iPPoolLister{indexer: indexer}
+}
+
+// List lists all IPPools in the indexer.
+func (s *iPPoolLister) List(selector labels.Selector) (ret []*calicov3.IPPool, err error) {
+	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
+		ret = append(ret, m.(*calicov3.IPPool))
+	})
+	return ret, err
+}
+
+// Get retrieves the IPPool from the index for a given name.
+func (s *iPPoolLister) Get(name string) (*calicov3.IPPool, error) {
+	obj, exists, err := s.indexer.GetByKey(name)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(calicov3.Resource("ippool"), name)
+	}
+	return obj.(*calicov3.IPPool), nil
+}

pkg/simple/client/network/ippool/calico/options.go

@@ -0,0 +1,23 @@
+/*
+Copyright 2020 The KubeSphere authors.
+
+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 calico
+
+type Options struct {
+	IPIPMode    string `json:"ipipMode,omityempty" yaml:"ipipMode,omityempty"`
+	VXLANMode   string `json:"vxlanMode,omityempty" yaml:"vxlanMode,omityempty"`
+	NATOutgoing bool   `json:"natOutgoing,omitempty" yaml:"natOutgoing,omityempty"`
+}

pkg/simple/client/network/ippool/calico/provider.go

@@ -0,0 +1,415 @@
+/*
+Copyright 2020 KubeSphere Authors
+
+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 calico
+
+import (
+	"errors"
+	"fmt"
+
+	v3 "github.com/projectcalico/libcalico-go/lib/apis/v3"
+	"github.com/projectcalico/libcalico-go/lib/backend/model"
+	cnet "github.com/projectcalico/libcalico-go/lib/net"
+	k8serrors "k8s.io/apimachinery/pkg/api/errors"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/client-go/util/workqueue"
+	"k8s.io/klog"
+	"kubesphere.io/kubesphere/pkg/apis/network/calicov3"
+	"kubesphere.io/kubesphere/pkg/apis/network/v1alpha1"
+	kubesphereclient "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
+	"kubesphere.io/kubesphere/pkg/client/clientset/versioned/scheme"
+	"kubesphere.io/kubesphere/pkg/simple/client/k8s"
+	calicoset "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned"
+	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
+)
+
+const (
+	CalicoNamespaceAnnotationIPPoolV4 = "cni.projectcalico.org/ipv4pools"
+	CalicoNamespaceAnnotationIPPoolV6 = "cni.projectcalico.org/ipv6pools"
+	CalicoPodAnnotationIPAddr         = "cni.projectcalico.org/ipAddrs"
+)
+
+var (
+	ErrBlockInuse = errors.New("ipamblock in using")
+)
+
+type provider struct {
+	client   calicoset.Interface
+	ksclient kubesphereclient.Interface
+	options  Options
+}
+
+func (c provider) CreateIPPool(pool *v1alpha1.IPPool) error {
+	calicoPool := &calicov3.IPPool{
+		TypeMeta: v1.TypeMeta{},
+		ObjectMeta: v1.ObjectMeta{
+			Name: pool.Name,
+		},
+		Spec: v3.IPPoolSpec{
+			CIDR:         pool.Spec.CIDR,
+			Disabled:     pool.Spec.Disabled,
+			NodeSelector: "all()",
+			VXLANMode:    v3.VXLANMode(c.options.VXLANMode),
+			IPIPMode:     v3.IPIPMode(c.options.IPIPMode),
+			NATOutgoing:  c.options.NATOutgoing,
+		},
+	}
+
+	err := controllerutil.SetControllerReference(pool, calicoPool, scheme.Scheme)
+	if err != nil {
+		klog.Warningf("cannot set reference for calico ippool %s, err=%v", pool.Name, err)
+	}
+
+	_, err = c.client.CrdCalicov3().IPPools().Create(calicoPool)
+	if k8serrors.IsAlreadyExists(err) {
+		return nil
+	}
+
+	return err
+}
+
+func (c provider) UpdateIPPool(pool *v1alpha1.IPPool) error {
+	return nil
+}
+
+func (c provider) GetIPPoolStats(pool *v1alpha1.IPPool) (*v1alpha1.IPPool, error) {
+	stats := &v1alpha1.IPPool{}
+
+	calicoPool, err := c.client.CrdCalicov3().IPPools().Get(pool.Name, v1.GetOptions{})
+	if err != nil {
+		return nil, err
+	}
+
+	blocks, err := c.listBlocks(calicoPool)
+	if err != nil {
+		return nil, err
+	}
+
+	stats.Status.Capacity = pool.NumAddresses()
+	stats.Status.Reserved = 0
+	stats.Status.Unallocated = 0
+	stats.Status.Synced = true
+	stats.Status.Allocations = 0
+
+	if len(blocks) <= 0 {
+		stats.Status.Unallocated = pool.NumAddresses()
+		stats.Status.Allocations = 0
+		return stats, nil
+	}
+
+	for _, block := range blocks {
+		stats.Status.Allocations += block.NumAddresses() - block.NumFreeAddresses() - block.NumReservedAddresses()
+		stats.Status.Reserved += block.NumReservedAddresses()
+	}
+
+	stats.Status.Unallocated = stats.Status.Capacity - stats.Status.Allocations - stats.Status.Reserved
+
+	return stats, nil
+}
+
+func setBlockAffiDeletion(c calicoset.Interface, blockAffi *calicov3.BlockAffinity) error {
+	if blockAffi.Spec.State == string(model.StatePendingDeletion) {
+		return nil
+	}
+
+	blockAffi.Spec.State = string(model.StatePendingDeletion)
+	_, err := c.CrdCalicov3().BlockAffinities().Update(blockAffi)
+	return err
+}
+
+func deleteBlockAffi(c calicoset.Interface, blockAffi *calicov3.BlockAffinity) error {
+	trueStr := fmt.Sprintf("%t", true)
+	if blockAffi.Spec.Deleted != trueStr {
+		blockAffi.Spec.Deleted = trueStr
+		_, err := c.CrdCalicov3().BlockAffinities().Update(blockAffi)
+		if err != nil {
+			return err
+		}
+	}
+
+	err := c.CrdCalicov3().BlockAffinities().Delete(blockAffi.Name, &v1.DeleteOptions{})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c provider) doBlockAffis(pool *calicov3.IPPool, do func(calicoset.Interface, *calicov3.BlockAffinity) error) error {
+	_, cidrNet, _ := cnet.ParseCIDR(pool.Spec.CIDR)
+
+	blockAffis, err := c.client.CrdCalicov3().BlockAffinities().List(v1.ListOptions{})
+	if err != nil {
+		return err
+	}
+
+	for _, blockAffi := range blockAffis.Items {
+		_, blockCIDR, _ := cnet.ParseCIDR(blockAffi.Spec.CIDR)
+		if !cidrNet.IsNetOverlap(blockCIDR.IPNet) {
+			continue
+		}
+
+		err = do(c.client, &blockAffi)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c provider) listBlocks(pool *calicov3.IPPool) ([]calicov3.IPAMBlock, error) {
+	_, cidrNet, _ := cnet.ParseCIDR(pool.Spec.CIDR)
+
+	blocks, err := c.client.CrdCalicov3().IPAMBlocks().List(v1.ListOptions{})
+	if err != nil {
+		return nil, err
+	}
+
+	var result []calicov3.IPAMBlock
+	for _, block := range blocks.Items {
+		_, blockCIDR, _ := cnet.ParseCIDR(block.Spec.CIDR)
+		if !cidrNet.IsNetOverlap(blockCIDR.IPNet) {
+			continue
+		}
+		result = append(result, block)
+	}
+
+	return result, nil
+}
+
+func (c provider) doBlocks(pool *calicov3.IPPool, do func(calicoset.Interface, *calicov3.IPAMBlock) error) error {
+	blocks, err := c.listBlocks(pool)
+	if err != nil {
+		return err
+	}
+
+	for _, block := range blocks {
+		err = do(c.client, &block)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func deleteBlock(c calicoset.Interface, block *calicov3.IPAMBlock) error {
+	if block.Empty() {
+		if !block.Spec.Deleted {
+			block.Spec.Deleted = true
+			_, err := c.CrdCalicov3().IPAMBlocks().Update(block)
+			if err != nil {
+				return err
+			}
+		}
+	} else {
+		return ErrBlockInuse
+	}
+	err := c.CrdCalicov3().IPAMBlocks().Delete(block.Name, &v1.DeleteOptions{})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c provider) DeleteIPPool(pool *v1alpha1.IPPool) (bool, error) {
+	// Deleting a pool requires a little care because of existing endpoints
+	// using IP addresses allocated in the pool.  We do the deletion in
+	// the following steps:
+	// -  disable the pool so no more IPs are assigned from it
+	// -  remove all affinities associated with the pool
+	// -  delete the pool
+
+	// Get the pool so that we can find the CIDR associated with it.
+	calicoPool, err := c.client.CrdCalicov3().IPPools().Get(pool.Name, v1.GetOptions{})
+	if err != nil {
+		return false, err
+	}
+
+	// If the pool is active, set the disabled flag to ensure we stop allocating from this pool.
+	if !calicoPool.Spec.Disabled {
+		calicoPool.Spec.Disabled = true
+
+		calicoPool, err = c.client.CrdCalicov3().IPPools().Update(calicoPool)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	//If the address pool is being used, we return, avoiding deletions that cause other problems.
+	stat, err := c.GetIPPoolStats(pool)
+	if err != nil {
+		return false, err
+	}
+	if stat.Status.Allocations > 0 {
+		return false, nil
+	}
+
+	//set blockaffi to pendingdelete
+	err = c.doBlockAffis(calicoPool, setBlockAffiDeletion)
+	if err != nil {
+		return false, err
+	}
+
+	//delete block
+	err = c.doBlocks(calicoPool, deleteBlock)
+	if err != nil {
+		if errors.Is(err, ErrBlockInuse) {
+			return false, nil
+		}
+		return false, err
+	}
+
+	//delete blockaffi
+	err = c.doBlockAffis(calicoPool, deleteBlockAffi)
+	if err != nil {
+		return false, err
+	}
+
+	//delete calico ippool
+	err = c.client.CrdCalicov3().IPPools().Delete(calicoPool.Name, &v1.DeleteOptions{})
+	if err != nil {
+		return false, err
+	}
+
+	//Congratulations, the ippool has been completely cleared.
+	return true, nil
+}
+
+//Synchronizing address pools at boot time
+func (c provider) syncIPPools() error {
+	calicoPools, err := c.client.CrdCalicov3().IPPools().List(v1.ListOptions{})
+	if err != nil {
+		klog.V(4).Infof("syncIPPools: cannot list calico ippools, err=%v", err)
+		return err
+	}
+
+	pools, err := c.ksclient.NetworkV1alpha1().IPPools().List(v1.ListOptions{})
+	if err != nil {
+		klog.V(4).Infof("syncIPPools: cannot list kubesphere ippools, err=%v", err)
+		return err
+	}
+
+	existPools := map[string]bool{}
+	for _, pool := range pools.Items {
+		existPools[pool.Name] = true
+	}
+
+	for _, calicoPool := range calicoPools.Items {
+		if _, ok := existPools[calicoPool.Name]; !ok {
+			pool := &v1alpha1.IPPool{
+				TypeMeta: v1.TypeMeta{},
+				ObjectMeta: v1.ObjectMeta{
+					Name: calicoPool.Name,
+				},
+				Spec: v1alpha1.IPPoolSpec{
+					Type:      v1alpha1.Calico,
+					CIDR:      calicoPool.Spec.CIDR,
+					Disabled:  calicoPool.Spec.Disabled,
+					BlockSize: calicoPool.Spec.BlockSize,
+				},
+				Status: v1alpha1.IPPoolStatus{},
+			}
+
+			_, err = c.ksclient.NetworkV1alpha1().IPPools().Create(pool)
+			if err != nil {
+				klog.V(4).Infof("syncIPPools: cannot create kubesphere ippools, err=%v", err)
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (c provider) SyncStatus(stopCh <-chan struct{}, q workqueue.RateLimitingInterface) error {
+	blockWatch, err := c.client.CrdCalicov3().IPAMBlocks().Watch(v1.ListOptions{})
+	if err != nil {
+		return err
+	}
+
+	ch := blockWatch.ResultChan()
+	defer blockWatch.Stop()
+
+	for {
+		select {
+		case <-stopCh:
+			return nil
+		case event, ok := <-ch:
+			if !ok {
+				// End of results.
+				return fmt.Errorf("calico ipamblock watch closed")
+			}
+
+			if event.Type == watch.Added || event.Type == watch.Deleted || event.Type == watch.Modified {
+				block := event.Object.(*calicov3.IPAMBlock)
+				_, blockCIDR, _ := cnet.ParseCIDR(block.Spec.CIDR)
+
+				if block.Labels[v1alpha1.IPPoolNameLabel] != "" {
+					q.Add(block.Labels[v1alpha1.IPPoolNameLabel])
+					continue
+				}
+
+				pools, err := c.ksclient.NetworkV1alpha1().IPPools().List(v1.ListOptions{})
+				if err != nil {
+					continue
+				}
+
+				for _, pool := range pools.Items {
+					_, poolCIDR, _ := cnet.ParseCIDR(pool.Spec.CIDR)
+					if poolCIDR.IsNetOverlap(blockCIDR.IPNet) {
+						q.Add(pool.Name)
+
+						block.Labels = map[string]string{
+							v1alpha1.IPPoolNameLabel: pool.Name,
+						}
+						c.client.CrdCalicov3().IPAMBlocks().Update(block)
+						break
+					}
+				}
+			}
+		}
+	}
+}
+
+func NewProvider(ksclient kubesphereclient.Interface, options Options, k8sOptions *k8s.KubernetesOptions) provider {
+	config, err := clientcmd.BuildConfigFromFlags("", k8sOptions.KubeConfig)
+	if err != nil {
+		klog.Fatalf("failed to build k8s config , err=%v", err)
+	}
+	config.QPS = k8sOptions.QPS
+	config.Burst = k8sOptions.Burst
+	client, err := calicoset.NewForConfig(config)
+	if err != nil {
+		klog.Fatalf("failed to new calico client , err=%v", err)
+	}
+
+	p := provider{
+		client:   client,
+		ksclient: ksclient,
+		options:  options,
+	}
+
+	if err := p.syncIPPools(); err != nil {
+		klog.Fatalf("failed to sync calico ippool to kubesphere ippool, err=%v", err)
+	}
+
+	return p
+}

pkg/simple/client/network/ippool/calico/provider_test.go

@@ -0,0 +1,72 @@
+/*
+Copyright 2020 The KubeSphere authors.
+
+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 calico
+
+import (
+	"flag"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/klog"
+	"kubesphere.io/kubesphere/pkg/apis/network/v1alpha1"
+	ksfake "kubesphere.io/kubesphere/pkg/client/clientset/versioned/fake"
+	calicofake "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico/client/clientset/versioned/fake"
+	"testing"
+)
+
+func TestCalicoIPPoolSuit(t *testing.T) {
+	klog.InitFlags(nil)
+	flag.Set("logtostderr", "true")
+	flag.Set("v", "4")
+	flag.Parse()
+	klog.SetOutput(GinkgoWriter)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Calico IPPool Suite")
+}
+
+var _ = Describe("test calico ippool", func() {
+	pool := &v1alpha1.IPPool{
+		TypeMeta: v1.TypeMeta{},
+		ObjectMeta: v1.ObjectMeta{
+			Name: "testippool",
+		},
+		Spec: v1alpha1.IPPoolSpec{
+			Type:      v1alpha1.Calico,
+			CIDR:      "192.168.0.0/16",
+			BlockSize: 24,
+		},
+		Status: v1alpha1.IPPoolStatus{},
+	}
+
+	ksclient := ksfake.NewSimpleClientset(pool)
+	client := calicofake.NewSimpleClientset()
+
+	p := provider{
+		options: Options{
+			IPIPMode:    "Always",
+			VXLANMode:   "Never",
+			NATOutgoing: true,
+		},
+		client:   client,
+		ksclient: ksclient,
+	}
+
+	It("test create calico ippool", func() {
+		err := p.CreateIPPool(pool)
+		Expect(err).ShouldNot(HaveOccurred())
+	})
+})

pkg/simple/client/network/ippool/ipam/interface.go

@@ -0,0 +1,47 @@
+/*
+Copyright 2020 KubeSphere Authors
+
+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 ipam
+
+import (
+	"github.com/containernetworking/cni/pkg/types/current"
+	"kubesphere.io/kubesphere/pkg/apis/network/v1alpha1"
+)
+
+// ipam.Interface has methods to perform IP address management.
+type Interface interface {
+	// AutoAssign automatically assigns one or more IP addresses as specified by the
+	// provided AutoAssignArgs.  AutoAssign returns the list of the assigned IPv4 addresses,
+	// and the list of the assigned IPv6 addresses in IPNet format.
+	// The returned IPNet represents the allocation block from which the IP was allocated,
+	// which is useful for dataplanes that need to know the subnet (such as Windows).
+	//
+	// In case of error, returns the IPs allocated so far along with the error.
+	AutoAssign(args AutoAssignArgs) (*current.Result, error)
+
+	// ReleaseByHandle releases all IP addresses that have been assigned
+	// using the provided handle.  Returns an error if no addresses
+	// are assigned with the given handle.
+	ReleaseByHandle(handleID string) error
+
+	GetUtilization(args GetUtilizationArgs) ([]*PoolUtilization, error)
+}
+
+// Interface used to access the enabled IPPools.
+type PoolAccessorInterface interface {
+	// Returns a list of all pools sorted in alphanumeric name order.
+	getAllPools() ([]v1alpha1.IPPool, error)
+}

pkg/simple/client/network/ippool/ipam/ipam.go

@@ -0,0 +1,626 @@
+/*
+Copyright 2020 KubeSphere Authors
+
+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 ipam
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+	"net"
+
+	cnitypes "github.com/containernetworking/cni/pkg/types"
+	"github.com/containernetworking/cni/pkg/types/current"
+	"github.com/davecgh/go-spew/spew"
+	cnet "github.com/projectcalico/libcalico-go/lib/net"
+	"github.com/projectcalico/libcalico-go/lib/set"
+	k8serrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/klog"
+	"kubesphere.io/kubesphere/pkg/apis/network/v1alpha1"
+	kubesphere "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
+	"kubesphere.io/kubesphere/pkg/client/clientset/versioned/scheme"
+	"kubesphere.io/kubesphere/pkg/simple/client/network/utils"
+	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
+)
+
+const (
+	// Number of retries when we have an error writing data to etcd.
+	datastoreRetries = 10
+)
+
+var (
+	ErrNoQualifiedPool  = errors.New("cannot find a qualified ippool")
+	ErrNoFreeBlocks     = errors.New("no free blocks in ippool")
+	ErrMaxRetry         = errors.New("Max retries hit - excessive concurrent IPAM requests")
+	ErrUnknowIPPoolType = errors.New("unknow ippool type")
+)
+
+func (c IPAMClient) getAllPools() ([]v1alpha1.IPPool, error) {
+	pools, err := c.client.NetworkV1alpha1().IPPools().List(metav1.ListOptions{
+		LabelSelector: labels.SelectorFromSet(labels.Set{
+			v1alpha1.IPPoolTypeLabel: c.typeStr,
+		}).String(),
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return pools.Items, nil
+}
+
+// NewIPAMClient returns a new IPAMClient, which implements Interface.
+func NewIPAMClient(client kubesphere.Interface, typeStr string) IPAMClient {
+	return IPAMClient{
+		typeStr: typeStr,
+		client:  client,
+	}
+}
+
+// IPAMClient implements Interface
+type IPAMClient struct {
+	typeStr string
+	client  kubesphere.Interface
+}
+
+// AutoAssign automatically assigns one or more IP addresses as specified by the
+// provided AutoAssignArgs.  AutoAssign returns the list of the assigned IPv4 addresses,
+// and the list of the assigned IPv6 addresses.
+//
+// In case of error, returns the IPs allocated so far along with the error.
+func (c IPAMClient) AutoAssign(args AutoAssignArgs) (*current.Result, error) {
+	var (
+		result current.Result
+		err    error
+		ip     *cnet.IPNet
+		pool   *v1alpha1.IPPool
+	)
+
+	for i := 0; i < datastoreRetries; i++ {
+		pool, err = c.client.NetworkV1alpha1().IPPools().Get(args.Pool, metav1.GetOptions{})
+		if err != nil {
+			return nil, ErrNoQualifiedPool
+		}
+
+		if pool.Disabled() {
+			klog.Infof("provided ippool %s should be enabled", pool.Name)
+			return nil, ErrNoQualifiedPool
+		}
+
+		if pool.TypeInvalid() {
+			return nil, ErrUnknowIPPoolType
+		}
+
+		ip, err = c.autoAssign(args.HandleID, args.Attrs, pool)
+		if err != nil {
+			if errors.Is(err, ErrNoFreeBlocks) {
+				return nil, err
+			}
+			continue
+		}
+		break
+	}
+
+	if err != nil {
+		klog.Infof("AutoAssign: args=%s, err=%v", spew.Sdump(args), err)
+		return nil, ErrMaxRetry
+	}
+
+	version := 4
+	if ip.IP.To4() == nil {
+		version = 6
+	}
+
+	result.IPs = append(result.IPs, &current.IPConfig{
+		Version: fmt.Sprintf("%d", version),
+		Address: net.IPNet{IP: ip.IP, Mask: ip.Mask},
+		Gateway: net.ParseIP(pool.Spec.Gateway),
+	})
+
+	for _, route := range pool.Spec.Routes {
+		_, dst, _ := net.ParseCIDR(route.Dst)
+		result.Routes = append(result.Routes, &cnitypes.Route{
+			Dst: *dst,
+			GW:  net.ParseIP(route.GW),
+		})
+	}
+	result.DNS.Domain = pool.Spec.DNS.Domain
+	result.DNS.Options = pool.Spec.DNS.Options
+	result.DNS.Nameservers = pool.Spec.DNS.Nameservers
+	result.DNS.Search = pool.Spec.DNS.Search
+
+	poolType := pool.Spec.Type
+	switch poolType {
+	case v1alpha1.VLAN:
+		result.Interfaces = append(result.Interfaces, &current.Interface{
+			Mac: utils.EthRandomAddr(ip.IP),
+		})
+	}
+
+	return &result, nil
+}
+
+//findOrClaimBlock find an address block with free space, and if it doesn't exist, create it.
+func (c IPAMClient) findOrClaimBlock(pool *v1alpha1.IPPool, minFreeIps int) (*v1alpha1.IPAMBlock, error) {
+	remainingBlocks, err := c.ListBlocks(pool.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	// First, we try to find a block from one of the existing blocks.
+	for len(remainingBlocks) > 0 {
+		// Pop first cidr.
+		block := remainingBlocks[0]
+		remainingBlocks = remainingBlocks[1:]
+
+		// Pull out the block.
+		if block.NumFreeAddresses() >= minFreeIps {
+			return &block, nil
+		} else {
+			continue
+		}
+	}
+
+	//Second, create unused Address Blocks
+	b, err := c.findUnclaimedBlock(pool)
+	if err != nil {
+		return nil, err
+	}
+	controllerutil.SetControllerReference(pool, b, scheme.Scheme)
+	b, err = c.client.NetworkV1alpha1().IPAMBlocks().Create(b)
+	if err != nil {
+		if k8serrors.IsAlreadyExists(err) {
+			b, err = c.queryBlock(b.BlockName())
+		}
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if b.NumFreeAddresses() >= minFreeIps {
+		return b, nil
+	} else {
+		errString := fmt.Sprintf("Block '%s' has %d free ips which is less than %d ips required.", b.BlockName(), b.NumFreeAddresses(), minFreeIps)
+		return nil, errors.New(errString)
+	}
+}
+
+func (c IPAMClient) autoAssign(handleID string, attrs map[string]string, requestedPool *v1alpha1.IPPool) (*cnet.IPNet, error) {
+	var (
+		result *cnet.IPNet
+	)
+
+	b, err := c.findOrClaimBlock(requestedPool, 1)
+	if err != nil {
+		return result, err
+	}
+
+	for i := 0; i < datastoreRetries; i++ {
+		result, err = c.assignFromExistingBlock(b, handleID, attrs)
+		if err != nil {
+			if k8serrors.IsConflict(err) {
+				b, err = c.queryBlock(b.Name)
+				if err != nil {
+					return nil, err
+				}
+
+				// Block b is in sync with datastore. Retry assigning IP.
+				continue
+			}
+			return nil, err
+		}
+		return result, nil
+	}
+
+	return nil, ErrMaxRetry
+}
+
+func (c IPAMClient) assignFromExistingBlock(block *v1alpha1.IPAMBlock, handleID string, attrs map[string]string) (*cnet.IPNet, error) {
+	ips := block.AutoAssign(1, handleID, attrs)
+	if len(ips) == 0 {
+		return nil, fmt.Errorf("block %s has no availabe IP", block.BlockName())
+	}
+
+	err := c.incrementHandle(handleID, block, 1)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = c.client.NetworkV1alpha1().IPAMBlocks().Update(block)
+	if err != nil {
+		if err := c.decrementHandle(handleID, block, 1); err != nil {
+			klog.Errorf("Failed to decrement handle %s", handleID)
+		}
+		return nil, err
+	}
+
+	return &ips[0], nil
+}
+
+// ReleaseByHandle releases all IP addresses that have been assigned
+// using the provided handle.
+func (c IPAMClient) ReleaseByHandle(handleID string) error {
+	handle, err := c.queryHandle(handleID)
+	if err != nil {
+		if k8serrors.IsNotFound(err) {
+			return nil
+		}
+		return err
+	}
+
+	for blockStr, _ := range handle.Spec.Block {
+		blockName := v1alpha1.ConvertToBlockName(blockStr)
+		if err := c.releaseByHandle(handleID, blockName); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c IPAMClient) releaseByHandle(handleID string, blockName string) error {
+	for i := 0; i < datastoreRetries; i++ {
+		block, err := c.queryBlock(blockName)
+		if err != nil {
+			if k8serrors.IsNotFound(err) {
+				// Block doesn't exist, so all addresses are already
+				// unallocated.  This can happen when a handle is
+				// overestimating the number of assigned addresses.
+				return nil
+			} else {
+				return err
+			}
+		}
+
+		num := block.ReleaseByHandle(handleID)
+		if num == 0 {
+			// Block has no addresses with this handle, so
+			// all addresses are already unallocated.
+			return nil
+		}
+
+		if block.Empty() {
+			if err = c.DeleteBlock(block); err != nil {
+				if k8serrors.IsConflict(err) {
+					// Update conflict - retry.
+					continue
+				} else if !k8serrors.IsNotFound(err) {
+					return err
+				}
+			}
+		} else {
+			// Compare and swap the AllocationBlock using the original
+			// KVPair read from before.  No need to update the Value since we
+			// have been directly manipulating the value referenced by the KVPair.
+			_, err = c.client.NetworkV1alpha1().IPAMBlocks().Update(block)
+			if err != nil {
+				if k8serrors.IsConflict(err) {
+					// Comparison failed - retry.
+					continue
+				} else {
+					// Something else - return the error.
+					return err
+				}
+			}
+		}
+
+		if err = c.decrementHandle(handleID, block, num); err != nil {
+			klog.Errorf("Failed to decrement handle %s, err=%s", handleID, err)
+		}
+
+		return nil
+	}
+	return ErrMaxRetry
+}
+
+func (c IPAMClient) incrementHandle(handleID string, block *v1alpha1.IPAMBlock, num int) error {
+	for i := 0; i < datastoreRetries; i++ {
+		create := false
+		handle, err := c.queryHandle(handleID)
+		if err != nil {
+			if k8serrors.IsNotFound(err) {
+				// Handle doesn't exist - create it.
+				handle = &v1alpha1.IPAMHandle{
+					ObjectMeta: v1.ObjectMeta{
+						Name: handleID,
+					},
+					Spec: v1alpha1.IPAMHandleSpec{
+						HandleID: handleID,
+						Block:    map[string]int{},
+					},
+				}
+				create = true
+			} else {
+				// Unexpected error reading handle.
+				return err
+			}
+		}
+
+		// Increment the handle for this block.
+		handle.IncrementBlock(block, num)
+
+		if create {
+			_, err = c.client.NetworkV1alpha1().IPAMHandles().Create(handle)
+		} else {
+			_, err = c.client.NetworkV1alpha1().IPAMHandles().Update(handle)
+		}
+		if err != nil {
+			if k8serrors.IsAlreadyExists(err) || k8serrors.IsConflict(err) {
+				continue
+			}
+			return err
+		}
+
+		return nil
+	}
+
+	return ErrMaxRetry
+}
+
+func (c IPAMClient) decrementHandle(handleID string, block *v1alpha1.IPAMBlock, num int) error {
+	for i := 0; i < datastoreRetries; i++ {
+		handle, err := c.queryHandle(handleID)
+		if err != nil {
+			return err
+		}
+
+		_, err = handle.DecrementBlock(block, num)
+		if err != nil {
+			klog.Errorf("decrementHandle: %v", err)
+			return err
+		}
+
+		// Update / Delete as appropriate.  Since we have been manipulating the
+		// data in the KVPair, just pass this straight back to the client.
+		if handle.Empty() {
+			if err = c.deleteHandle(handle); err != nil {
+				if k8serrors.IsConflict(err) {
+					// Update conflict - retry.
+					continue
+				} else if !k8serrors.IsNotFound(err) {
+					return err
+				}
+			}
+		} else {
+			if _, err = c.client.NetworkV1alpha1().IPAMHandles().Update(handle); err != nil {
+				if k8serrors.IsConflict(err) {
+					// Update conflict - retry.
+					continue
+				}
+				return err
+			}
+		}
+
+		return nil
+	}
+
+	return ErrMaxRetry
+}
+
+// GetUtilization returns IP utilization info for the specified pools, or for all pools.
+func (c IPAMClient) GetUtilization(args GetUtilizationArgs) ([]*PoolUtilization, error) {
+	var usage []*PoolUtilization
+
+	// Read all pools.
+	allPools, err := c.getAllPools()
+	if err != nil {
+		return nil, err
+	}
+
+	// Identify the ones we want and create a PoolUtilization for each of those.
+	wantAllPools := len(args.Pools) == 0
+	wantedPools := set.FromArray(args.Pools)
+	for _, pool := range allPools {
+		if wantAllPools || wantedPools.Contains(pool.Name) {
+			cap := pool.NumAddresses()
+			reserved := pool.NumReservedAddresses()
+			usage = append(usage, &PoolUtilization{
+				Name:        pool.Name,
+				Capacity:    cap,
+				Reserved:    reserved,
+				Allocate:    0,
+				Unallocated: cap - reserved,
+			})
+		}
+	}
+
+	// Find which pool this block belongs to.
+	for _, poolUse := range usage {
+		blocks, err := c.ListBlocks(poolUse.Name)
+		if err != nil {
+			return nil, err
+		}
+
+		if len(blocks) <= 0 {
+			continue
+		} else {
+			poolUse.Reserved = 0
+			poolUse.Allocate = 0
+		}
+
+		for _, block := range blocks {
+			poolUse.Allocate += block.NumAddresses() - block.NumFreeAddresses() - block.NumReservedAddresses()
+			poolUse.Reserved += block.NumReservedAddresses()
+		}
+
+		poolUse.Unallocated = poolUse.Capacity - poolUse.Allocate - poolUse.Reserved
+	}
+
+	return usage, nil
+}
+
+// findUnclaimedBlock finds a block cidr which does not yet exist within the given list of pools. The provided pools
+// should already be sanitized and only include existing, enabled pools. Note that the block may become claimed
+// between receiving the cidr from this function and attempting to claim the corresponding block as this function
+// does not reserve the returned IPNet.
+func (c IPAMClient) findUnclaimedBlock(pool *v1alpha1.IPPool) (*v1alpha1.IPAMBlock, error) {
+	var result *v1alpha1.IPAMBlock
+
+	// List blocks up front to reduce number of queries.
+	// We will try to write the block later to prevent races.
+	existingBlocks, err := c.ListBlocks(pool.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	/// Build a map for faster lookups.
+	exists := map[string]bool{}
+	for _, e := range existingBlocks {
+		exists[fmt.Sprintf("%s", e.Spec.CIDR)] = true
+	}
+
+	// Iterate through pools to find a new block.
+	_, cidr, _ := cnet.ParseCIDR(pool.Spec.CIDR)
+	poolType := pool.Spec.Type
+	switch poolType {
+	case v1alpha1.VLAN:
+		if _, ok := exists[cidr.String()]; !ok {
+			var reservedAttr *v1alpha1.ReservedAttr
+			if pool.Spec.RangeStart != "" && pool.Spec.RangeEnd != "" {
+				reservedAttr = &v1alpha1.ReservedAttr{
+					StartOfBlock: pool.StartReservedAddressed(),
+					EndOfBlock:   pool.EndReservedAddressed(),
+					Handle:       v1alpha1.ReservedHandle,
+					Note:         v1alpha1.ReservedNote,
+				}
+			}
+			result = v1alpha1.NewBlock(pool, *cidr, reservedAttr)
+		}
+	default:
+		blocks := blockGenerator(pool)
+		for subnet := blocks(); subnet != nil; subnet = blocks() {
+			// Check if a block already exists for this subnet.
+			if _, ok := exists[fmt.Sprintf("%s", subnet.String())]; !ok {
+				result = v1alpha1.NewBlock(pool, *subnet, nil)
+				break
+			}
+		}
+	}
+
+	if result != nil {
+		return result, nil
+	} else {
+		return nil, ErrNoFreeBlocks
+	}
+}
+
+func (c IPAMClient) ListBlocks(pool string) ([]v1alpha1.IPAMBlock, error) {
+	blocks, err := c.client.NetworkV1alpha1().IPAMBlocks().List(metav1.ListOptions{
+		LabelSelector: labels.SelectorFromSet(labels.Set{
+			v1alpha1.IPPoolNameLabel: pool,
+		}).String(),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return blocks.Items, nil
+}
+
+// DeleteBlock deletes the given block.
+func (c IPAMClient) DeleteBlock(b *v1alpha1.IPAMBlock) error {
+	if !b.IsDeleted() {
+		b.MarkDeleted()
+		_, err := c.client.NetworkV1alpha1().IPAMBlocks().Update(b)
+		if err != nil {
+			return err
+		}
+	}
+	return c.client.NetworkV1alpha1().IPAMBlocks().Delete(b.Name, nil)
+}
+
+func (c IPAMClient) queryBlock(blockName string) (*v1alpha1.IPAMBlock, error) {
+	block, err := c.client.NetworkV1alpha1().IPAMBlocks().Get(blockName, metav1.GetOptions{})
+	if err != nil {
+		return nil, err
+	}
+
+	if block.IsDeleted() {
+		err := c.DeleteBlock(block)
+		if err != nil {
+			return nil, err
+		}
+
+		return nil, k8serrors.NewNotFound(v1alpha1.Resource(v1alpha1.ResourcePluralIPAMBlock), blockName)
+	}
+
+	return block, nil
+}
+
+// queryHandle gets a handle for the given handleID key.
+func (c IPAMClient) queryHandle(handleID string) (*v1alpha1.IPAMHandle, error) {
+	handle, err := c.client.NetworkV1alpha1().IPAMHandles().Get(handleID, metav1.GetOptions{})
+	if err != nil {
+		return nil, err
+	}
+
+	if handle.IsDeleted() {
+		err := c.deleteHandle(handle)
+		if err != nil {
+			return nil, err
+		}
+
+		return nil, k8serrors.NewNotFound(v1alpha1.Resource(v1alpha1.ResourcePluralIPAMHandle), handleID)
+	}
+
+	return handle, nil
+}
+
+// deleteHandle deletes the given handle.
+func (c IPAMClient) deleteHandle(h *v1alpha1.IPAMHandle) error {
+	if !h.IsDeleted() {
+		h.MarkDeleted()
+		_, err := c.client.NetworkV1alpha1().IPAMHandles().Update(h)
+		if err != nil {
+			return err
+		}
+	}
+	return c.client.NetworkV1alpha1().IPAMHandles().Delete(h.Name, nil)
+}
+
+// Generator to get list of block CIDRs which
+// fall within the given cidr. The passed in pool
+// must contain the passed in block cidr.
+// Returns nil when no more blocks can be generated.
+func blockGenerator(pool *v1alpha1.IPPool) func() *cnet.IPNet {
+	tmp, cidr, _ := cnet.ParseCIDR(pool.Spec.CIDR)
+	ip := *tmp
+
+	var blockMask net.IPMask
+	if ip.Version() == 4 {
+		blockMask = net.CIDRMask(pool.Spec.BlockSize, 32)
+	} else {
+		blockMask = net.CIDRMask(pool.Spec.BlockSize, 128)
+	}
+
+	ones, size := blockMask.Size()
+	blockSize := new(big.Int).Exp(big.NewInt(2), big.NewInt(int64(size-ones)), nil)
+
+	return func() *cnet.IPNet {
+		returnIP := ip
+
+		if cidr.Contains(ip.IP) {
+			ipnet := net.IPNet{IP: returnIP.IP, Mask: blockMask}
+			cidr := cnet.IPNet{IPNet: ipnet}
+			ip = cnet.IncrementIP(ip, blockSize)
+			return &cidr
+		} else {
+			return nil
+		}
+	}
+}

pkg/simple/client/network/ippool/ipam/ipam_test.go

@@ -0,0 +1,139 @@
+/*
+Copyright 2020 KubeSphere Authors
+
+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 ipam
+
+import (
+	"flag"
+	"fmt"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/klog"
+	"kubesphere.io/kubesphere/pkg/apis/network/v1alpha1"
+	ksfake "kubesphere.io/kubesphere/pkg/client/clientset/versioned/fake"
+	"testing"
+)
+
+func TestIPAM_blockGenerator(t *testing.T) {
+	pool := &v1alpha1.IPPool{
+		ObjectMeta: v1.ObjectMeta{
+			Name: "testippool",
+		},
+		Spec: v1alpha1.IPPoolSpec{
+			Type:       v1alpha1.VLAN,
+			CIDR:       "192.168.0.0/24",
+			RangeEnd:   "192.168.0.250",
+			RangeStart: "192.168.0.10",
+			BlockSize:  25,
+		},
+	}
+	blocks := blockGenerator(pool)
+	for subnet := blocks(); subnet != nil; subnet = blocks() {
+		if subnet.String() != "192.168.0.0/25" && subnet.String() != "192.168.0.128/25" {
+			t.FailNow()
+		}
+	}
+}
+
+func TestIPAMSuit(t *testing.T) {
+	klog.InitFlags(nil)
+	flag.Set("logtostderr", "true")
+	flag.Set("v", "4")
+	flag.Parse()
+	klog.SetOutput(GinkgoWriter)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "IPAM Test Suite")
+}
+
+const (
+	vlanIPPoolName = "testippool"
+)
+
+var (
+	vlanIPPool = &v1alpha1.IPPool{
+		TypeMeta: v1.TypeMeta{},
+		ObjectMeta: v1.ObjectMeta{
+			Name: vlanIPPoolName,
+		},
+		Spec: v1alpha1.IPPoolSpec{
+			Type: v1alpha1.VLAN,
+			CIDR: "192.168.0.0/24",
+		},
+		Status: v1alpha1.IPPoolStatus{},
+	}
+)
+
+func newVLANIPAMClient() IPAMClient {
+	vlanIPPool.Labels = map[string]string{
+		v1alpha1.IPPoolTypeLabel: vlanIPPool.Spec.Type,
+		v1alpha1.IPPoolNameLabel: vlanIPPool.Name,
+		v1alpha1.IPPoolIDLabel:   fmt.Sprintf("%d", vlanIPPool.ID()),
+	}
+	return IPAMClient{
+		typeStr: v1alpha1.VLAN,
+		client:  ksfake.NewSimpleClientset(vlanIPPool),
+	}
+}
+
+func TestIpamClient_GetAllPools(t *testing.T) {
+	c := newVLANIPAMClient()
+	pools, _ := c.getAllPools()
+	if len(pools) != 1 {
+		t.FailNow()
+	}
+}
+
+var _ = Describe("test vlan ippool", func() {
+	It("test get all vlan ippool", func() {
+		c := newVLANIPAMClient()
+		pools, _ := c.getAllPools()
+		Expect(len(pools)).To(Equal(1))
+	})
+
+	It("test get pool utilization", func() {
+		c := newVLANIPAMClient()
+		stats, _ := c.GetUtilization(GetUtilizationArgs{Pools: []string{vlanIPPoolName}})
+		Expect(len(stats)).To(Equal(1))
+		Expect(stats[0].Unallocated).To(Equal(256))
+	})
+
+	It("test auto assign/unassign ip", func() {
+		c := newVLANIPAMClient()
+		result, _ := c.AutoAssign(AutoAssignArgs{
+			HandleID: "testhandle",
+			Pool:     vlanIPPoolName,
+		})
+		Expect(len(result.IPs)).To(Equal(1))
+		stats, _ := c.GetUtilization(GetUtilizationArgs{Pools: []string{vlanIPPoolName}})
+		Expect(stats[0].Unallocated).To(Equal(255))
+
+		blocks, _ := c.client.NetworkV1alpha1().IPAMBlocks().List(v1.ListOptions{})
+		Expect(len(blocks.Items)).To(Equal(1))
+		Expect(blocks.Items[0].BlockName()).To(Equal(fmt.Sprintf("%d-%s", vlanIPPool.ID(), "192-168-0-0-24")))
+
+		handles, _ := c.client.NetworkV1alpha1().IPAMHandles().List(v1.ListOptions{})
+		Expect(len(handles.Items)).To(Equal(1))
+		Expect(handles.Items[0].Name).To(Equal("testhandle"))
+
+		Expect(c.ReleaseByHandle("testhandle")).ShouldNot(HaveOccurred())
+		blocks, _ = c.client.NetworkV1alpha1().IPAMBlocks().List(v1.ListOptions{})
+		Expect(len(blocks.Items)).To(Equal(0))
+
+		handles, _ = c.client.NetworkV1alpha1().IPAMHandles().List(v1.ListOptions{})
+		Expect(len(handles.Items)).To(Equal(0))
+	})
+})

pkg/simple/client/network/ippool/ipam/ipam_types.go

@@ -0,0 +1,51 @@
+/*
+Copyright 2020 KubeSphere Authors
+
+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 ipam
+
+// AutoAssignArgs defines the set of arguments for assigning one or more
+// IP addresses.
+type AutoAssignArgs struct {
+	HandleID string
+
+	// A key/value mapping of metadata to store with the allocations.
+	Attrs map[string]string
+
+	Pool string
+}
+
+// GetUtilizationArgs defines the set of arguments for requesting IP utilization.
+type GetUtilizationArgs struct {
+	// If specified, the pools whose utilization should be reported.  Each string here
+	// can be a pool name or CIDR.  If not specified, this defaults to all pools.
+	Pools []string
+}
+
+// PoolUtilization reports IP utilization for a single IP pool.
+type PoolUtilization struct {
+	// This pool's name.
+	Name string
+
+	// Number of possible IPs in this block.
+	Capacity int
+
+	// Number of available IPs in this block.
+	Unallocated int
+
+	Allocate int
+
+	Reserved int
+}

pkg/simple/client/network/ippool/options.go

@@ -0,0 +1,23 @@
+/*
+Copyright 2020 The KubeSphere authors.
+
+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 ippool
+
+import "kubesphere.io/kubesphere/pkg/simple/client/network/ippool/calico"
+
+type Options struct {
+	Calico *calico.Options `json:"calico,omityempty" yaml:"calico,omityempty"`
+}

pkg/simple/client/network/ippool/provider.go

@@ -0,0 +1,98 @@
+/*
+Copyright 2020 The KubeSphere authors.
+
+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 ippool
+
+import (
+	"k8s.io/client-go/util/workqueue"
+	networkv1alpha1 "kubesphere.io/kubesphere/pkg/apis/network/v1alpha1"
+	kubesphereclient "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
+	"kubesphere.io/kubesphere/pkg/simple/client/network/ippool/ipam"
+)
+
+type Provider interface {
+	// canDelete indicates whether the address pool is being used or not.
+	DeleteIPPool(pool *networkv1alpha1.IPPool) (canDelete bool, err error)
+	CreateIPPool(pool *networkv1alpha1.IPPool) error
+	UpdateIPPool(pool *networkv1alpha1.IPPool) error
+	GetIPPoolStats(pool *networkv1alpha1.IPPool) (*networkv1alpha1.IPPool, error)
+	SyncStatus(stopCh <-chan struct{}, q workqueue.RateLimitingInterface) error
+}
+
+type provider struct {
+	kubesphereClient kubesphereclient.Interface
+	ipamclient       ipam.IPAMClient
+}
+
+func (p provider) DeleteIPPool(pool *networkv1alpha1.IPPool) (bool, error) {
+	blocks, err := p.ipamclient.ListBlocks(pool.Name)
+	if err != nil {
+		return false, err
+	}
+
+	for _, block := range blocks {
+		if block.Empty() {
+			if err = p.ipamclient.DeleteBlock(&block); err != nil {
+				return false, err
+			}
+		} else {
+			return false, nil
+		}
+	}
+
+	return true, nil
+}
+
+func (p provider) CreateIPPool(pool *networkv1alpha1.IPPool) error {
+	return nil
+}
+
+func (p provider) UpdateIPPool(pool *networkv1alpha1.IPPool) error {
+	return nil
+}
+
+func (p provider) SyncStatus(stopCh <-chan struct{}, q workqueue.RateLimitingInterface) error {
+	return nil
+}
+
+func (p provider) GetIPPoolStats(pool *networkv1alpha1.IPPool) (*networkv1alpha1.IPPool, error) {
+	stats, err := p.ipamclient.GetUtilization(ipam.GetUtilizationArgs{
+		Pools: []string{pool.Name},
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	stat := stats[0]
+	return &networkv1alpha1.IPPool{
+		Status: networkv1alpha1.IPPoolStatus{
+			Allocations: stat.Allocate,
+			Unallocated: stat.Unallocated,
+			Reserved:    stat.Reserved,
+			Capacity:    stat.Capacity,
+			Synced:      true,
+		},
+	}, nil
+}
+
+func NewProvider(clientset kubesphereclient.Interface, options Options) provider {
+	vlanProvider := provider{
+		kubesphereClient: clientset,
+		ipamclient:       ipam.NewIPAMClient(clientset, networkv1alpha1.VLAN),
+	}
+
+	return vlanProvider
+}

pkg/simple/client/network/ippool/provider_test.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2020 The KubeSphere authors.
+
+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 ippool
+
+import (
+	"testing"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"kubesphere.io/kubesphere/pkg/apis/network/v1alpha1"
+	fakeks "kubesphere.io/kubesphere/pkg/client/clientset/versioned/fake"
+	"kubesphere.io/kubesphere/pkg/simple/client/network/ippool/ipam"
+)
+
+func testNewProvider() provider {
+	return NewProvider(fakeks.NewSimpleClientset(), Options{})
+}
+
+func TestProvider_GetIPPoolStats(t *testing.T) {
+	p := testNewProvider()
+
+	pool := v1alpha1.IPPool{
+		TypeMeta: v1.TypeMeta{},
+		ObjectMeta: v1.ObjectMeta{
+			Name: "testippool",
+			Labels: map[string]string{
+				v1alpha1.IPPoolTypeLabel: v1alpha1.VLAN,
+			},
+		},
+		Spec: v1alpha1.IPPoolSpec{
+			Type: v1alpha1.VLAN,
+			CIDR: "192.168.0.0/24",
+		},
+		Status: v1alpha1.IPPoolStatus{},
+	}
+
+	_, err := p.kubesphereClient.NetworkV1alpha1().IPPools().Create(&pool)
+	if err != nil {
+		t.FailNow()
+	}
+
+	p.ipamclient.AutoAssign(ipam.AutoAssignArgs{
+		HandleID: "testhandle",
+		Attrs:    nil,
+		Pool:     "testippool",
+	})
+	stat, err := p.GetIPPoolStats(&pool)
+	if err != nil {
+		t.FailNow()
+	}
+	if stat.Status.Unallocated != pool.NumAddresses()-1 || stat.Status.Reserved != 0 ||
+		stat.Status.Capacity != pool.NumAddresses() || stat.Status.Allocations != 1 {
+		t.FailNow()
+	}
+}

pkg/simple/client/network/options.go

@@ -16,24 +16,33 @@ limitations under the License.
 
 package network
 
-import "github.com/spf13/pflag"
+import (
+	"github.com/spf13/pflag"
+	"kubesphere.io/kubesphere/pkg/simple/client/network/ippool"
+)
 
 type NSNPOptions struct {
 	AllowedIngressNamespaces []string `json:"allowedIngressNamespaces,omitempty" yaml:"allowedIngressNamespaces,omitempty"`
 }
 
 type Options struct {
-	EnableNetworkPolicy bool        `json:"enableNetworkPolicy,omitempty" yaml:"enableNetworkPolicy"`
-	NSNPOptions         NSNPOptions `json:"nsnpOptions,omitempty" yaml:"nsnpOptions,omitempty"`
+	EnableNetworkPolicy bool           `json:"enableNetworkPolicy,omitempty" yaml:"enableNetworkPolicy"`
+	NSNPOptions         NSNPOptions    `json:"nsnpOptions,omitempty" yaml:"nsnpOptions,omitempty"`
+	EnableIPPool        bool           `json:"enableIPPool,omitempty" yaml:"enableIPPool"`
+	IPPoolOptions       ippool.Options `json:"ippoolOptions,omitempty" yaml:"ippoolOptions,omitempty"`
 }
 
 // NewNetworkOptions returns a `zero` instance
 func NewNetworkOptions() *Options {
 	return &Options{
 		EnableNetworkPolicy: false,
+		EnableIPPool:        false,
 		NSNPOptions: NSNPOptions{
 			AllowedIngressNamespaces: []string{},
 		},
+		IPPoolOptions: ippool.Options{
+			Calico: nil,
+		},
 	}
 }
 
@@ -44,10 +53,14 @@ func (s *Options) Validate() []error {
 
 func (s *Options) ApplyTo(options *Options) {
 	options.EnableNetworkPolicy = s.EnableNetworkPolicy
+	options.EnableIPPool = s.EnableIPPool
 	options.NSNPOptions = s.NSNPOptions
+	options.IPPoolOptions = s.IPPoolOptions
 }
 
 func (s *Options) AddFlags(fs *pflag.FlagSet, c *Options) {
 	fs.BoolVar(&s.EnableNetworkPolicy, "enable-network-policy", c.EnableNetworkPolicy,
 		"This field instructs KubeSphere to enable network policy or not.")
+	fs.BoolVar(&s.EnableIPPool, "enable-ippool", c.EnableIPPool,
+		"This field instructs KubeSphere to enable ippool or not.")
 }

pkg/simple/client/network/utils/utils.go

@@ -0,0 +1,37 @@
+/*
+Copyright 2020 The KubeSphere authors.
+
+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 utils
+
+import (
+	"fmt"
+	"math/rand"
+	"net"
+)
+
+func EthRandomAddr(ip net.IP) string {
+	buf := make([]byte, 2)
+	rand.Read(buf)
+
+	// Clear multicast bit
+	buf[0] &= 0xfe
+	// Set the local bit
+	buf[0] |= 2
+
+	//TODO support ipv6
+	buf = append(buf, []byte(ip)...)
+	return fmt.Sprintf("%02x:%02x:%02x:%02x:%02x:%02x", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5])
+}