From 4af15887a44cbc33f6fe6bab279e78871b477eb4 Mon Sep 17 00:00:00 2001 From: ish Date: Wed, 10 Jul 2024 11:51:32 +0900 Subject: [PATCH 1/4] OpenStack: Fix duplicated search in FindTag() --- .../cloud-driver/drivers/openstack/resources/TagHandler.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/cloud-control-manager/cloud-driver/drivers/openstack/resources/TagHandler.go b/cloud-control-manager/cloud-driver/drivers/openstack/resources/TagHandler.go index f53347a0f..2db21b99d 100644 --- a/cloud-control-manager/cloud-driver/drivers/openstack/resources/TagHandler.go +++ b/cloud-control-manager/cloud-driver/drivers/openstack/resources/TagHandler.go @@ -425,6 +425,7 @@ func (tagHandler *OpenStackTagHandler) FindTag(resType irs.RSType, keyword strin tagInfo := getTagInfo(resType, vpc.Name, vpc.ID, tag, vpc.Tags, keyword) if tagInfo != nil { tagInfos = append(tagInfos, tagInfo) + break } } } @@ -451,6 +452,7 @@ func (tagHandler *OpenStackTagHandler) FindTag(resType irs.RSType, keyword strin tagInfo := getTagInfo(resType, subnet.Name, subnet.ID, tag, subnet.Tags, keyword) if tagInfo != nil { tagInfos = append(tagInfos, tagInfo) + break } } } @@ -487,6 +489,7 @@ func (tagHandler *OpenStackTagHandler) FindTag(resType irs.RSType, keyword strin tagInfo := getTagInfo(resType, sg.Name, sg.ID, tag, tags, keyword) if tagInfo != nil { tagInfos = append(tagInfos, tagInfo) + break } } } @@ -513,6 +516,7 @@ func (tagHandler *OpenStackTagHandler) FindTag(resType irs.RSType, keyword strin tagInfo := getTagInfo(resType, nlb.Name, nlb.ID, tag, nlb.Tags, keyword) if tagInfo != nil { tagInfos = append(tagInfos, tagInfo) + break } } } @@ -537,6 +541,7 @@ func (tagHandler *OpenStackTagHandler) FindTag(resType irs.RSType, keyword strin tagInfo := getTagInfo(resType, vm.Name, vm.ID, tag, *vm.Tags, keyword) if tagInfo != nil { tagInfos = append(tagInfos, tagInfo) + break } } } From 472c37ca8c9d72af9901c9a155da7c4b9d1db7a3 Mon Sep 17 00:00:00 2001 From: ish Date: Wed, 10 Jul 2024 11:55:41 +0900 Subject: [PATCH 2/4] OpenStack: Fix resource type showing as all when requested resType is all --- .../drivers/openstack/resources/TagHandler.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/cloud-control-manager/cloud-driver/drivers/openstack/resources/TagHandler.go b/cloud-control-manager/cloud-driver/drivers/openstack/resources/TagHandler.go index 2db21b99d..310da89ee 100644 --- a/cloud-control-manager/cloud-driver/drivers/openstack/resources/TagHandler.go +++ b/cloud-control-manager/cloud-driver/drivers/openstack/resources/TagHandler.go @@ -422,7 +422,7 @@ func (tagHandler *OpenStackTagHandler) FindTag(resType irs.RSType, keyword strin } for _, vpc := range vpcList { for _, tag := range vpc.Tags { - tagInfo := getTagInfo(resType, vpc.Name, vpc.ID, tag, vpc.Tags, keyword) + tagInfo := getTagInfo(irs.VPC, vpc.Name, vpc.ID, tag, vpc.Tags, keyword) if tagInfo != nil { tagInfos = append(tagInfos, tagInfo) break @@ -449,7 +449,7 @@ func (tagHandler *OpenStackTagHandler) FindTag(resType irs.RSType, keyword strin } for _, subnet := range ss { for _, tag := range subnet.Tags { - tagInfo := getTagInfo(resType, subnet.Name, subnet.ID, tag, subnet.Tags, keyword) + tagInfo := getTagInfo(irs.SUBNET, subnet.Name, subnet.ID, tag, subnet.Tags, keyword) if tagInfo != nil { tagInfos = append(tagInfos, tagInfo) break @@ -486,7 +486,7 @@ func (tagHandler *OpenStackTagHandler) FindTag(resType irs.RSType, keyword strin } for _, tag := range tags { - tagInfo := getTagInfo(resType, sg.Name, sg.ID, tag, tags, keyword) + tagInfo := getTagInfo(irs.SG, sg.Name, sg.ID, tag, tags, keyword) if tagInfo != nil { tagInfos = append(tagInfos, tagInfo) break @@ -513,7 +513,7 @@ func (tagHandler *OpenStackTagHandler) FindTag(resType irs.RSType, keyword strin } for _, nlb := range nlbs { for _, tag := range nlb.Tags { - tagInfo := getTagInfo(resType, nlb.Name, nlb.ID, tag, nlb.Tags, keyword) + tagInfo := getTagInfo(irs.NLB, nlb.Name, nlb.ID, tag, nlb.Tags, keyword) if tagInfo != nil { tagInfos = append(tagInfos, tagInfo) break @@ -538,7 +538,7 @@ func (tagHandler *OpenStackTagHandler) FindTag(resType irs.RSType, keyword strin for _, vm := range vms { if vm.Tags != nil { for _, tag := range *vm.Tags { - tagInfo := getTagInfo(resType, vm.Name, vm.ID, tag, *vm.Tags, keyword) + tagInfo := getTagInfo(irs.VM, vm.Name, vm.ID, tag, *vm.Tags, keyword) if tagInfo != nil { tagInfos = append(tagInfos, tagInfo) break From d3fbc84c3679bacf56f2f744cf22353e0210e51b Mon Sep 17 00:00:00 2001 From: ish Date: Wed, 10 Jul 2024 14:13:27 +0900 Subject: [PATCH 3/4] OpenStack: Enable TagHandler capability --- .../cloud-driver/drivers/openstack/OpenStackDriver.go | 1 + 1 file changed, 1 insertion(+) diff --git a/cloud-control-manager/cloud-driver/drivers/openstack/OpenStackDriver.go b/cloud-control-manager/cloud-driver/drivers/openstack/OpenStackDriver.go index 892bf9a53..87b0f6e29 100644 --- a/cloud-control-manager/cloud-driver/drivers/openstack/OpenStackDriver.go +++ b/cloud-control-manager/cloud-driver/drivers/openstack/OpenStackDriver.go @@ -46,6 +46,7 @@ func (OpenStackDriver) GetDriverCapability() idrv.DriverCapabilityInfo { drvCapabilityInfo.MyImageHandler = true drvCapabilityInfo.RegionZoneHandler = true drvCapabilityInfo.PriceInfoHandler = false + drvCapabilityInfo.TagHandler = true return drvCapabilityInfo } From 1e84512c47c2691d737721ea0e3404f22529deaa Mon Sep 17 00:00:00 2001 From: ish Date: Wed, 10 Jul 2024 19:40:55 +0900 Subject: [PATCH 4/4] OpenStack: Add tagging feature for supported resources --- .../connect/OpenStack_CloudConnection.go | 35 ++++- .../drivers/openstack/main/Test_Resources.go | 57 +++++++- .../openstack/main/conf/config.yaml.sample | 19 ++- .../resources/CommonOpenStackFunc.go | 22 +++ .../drivers/openstack/resources/NLBHandler.go | 14 +- .../openstack/resources/SecurityHandler.go | 76 +++++++++-- .../drivers/openstack/resources/VMHandler.go | 49 ++++++- .../drivers/openstack/resources/VPCHandler.go | 125 +++++++++++++----- 8 files changed, 335 insertions(+), 62 deletions(-) diff --git a/cloud-control-manager/cloud-driver/drivers/openstack/connect/OpenStack_CloudConnection.go b/cloud-control-manager/cloud-driver/drivers/openstack/connect/OpenStack_CloudConnection.go index a8ab8bddf..101a6550a 100644 --- a/cloud-control-manager/cloud-driver/drivers/openstack/connect/OpenStack_CloudConnection.go +++ b/cloud-control-manager/cloud-driver/drivers/openstack/connect/OpenStack_CloudConnection.go @@ -50,13 +50,25 @@ func (cloudConn *OpenStackCloudConnection) CreateImageHandler() (irs.ImageHandle func (cloudConn *OpenStackCloudConnection) CreateVPCHandler() (irs.VPCHandler, error) { cblogger.Info("OpenStack Cloud Driver: called CreateVPCHandler()!") - vpcHandler := osrs.OpenStackVPCHandler{Client: cloudConn.NetworkClient, VMClient: cloudConn.ComputeClient} + vpcHandler := osrs.OpenStackVPCHandler{ + CredentialInfo: cloudConn.CredentialInfo, + IdentityClient: cloudConn.IdentityClient, + ComputeClient: cloudConn.ComputeClient, + NetworkClient: cloudConn.NetworkClient, + NLBClient: cloudConn.NLBClient, + } return &vpcHandler, nil } func (cloudConn OpenStackCloudConnection) CreateSecurityHandler() (irs.SecurityHandler, error) { cblogger.Info("OpenStack Cloud Driver: called CreateSecurityHandler()!") - securityHandler := osrs.OpenStackSecurityHandler{Client: cloudConn.ComputeClient, NetworkClient: cloudConn.NetworkClient} + securityHandler := osrs.OpenStackSecurityHandler{ + CredentialInfo: cloudConn.CredentialInfo, + IdentityClient: cloudConn.IdentityClient, + ComputeClient: cloudConn.ComputeClient, + NetworkClient: cloudConn.NetworkClient, + NLBClient: cloudConn.NLBClient, + } return &securityHandler, nil } @@ -68,7 +80,15 @@ func (cloudConn *OpenStackCloudConnection) CreateKeyPairHandler() (irs.KeyPairHa func (cloudConn *OpenStackCloudConnection) CreateVMHandler() (irs.VMHandler, error) { cblogger.Info("OpenStack Cloud Driver: called CreateVMHandler()!") - vmHandler := osrs.OpenStackVMHandler{Region: cloudConn.Region, ComputeClient: cloudConn.ComputeClient, NetworkClient: cloudConn.NetworkClient, VolumeClient: cloudConn.Volume3Client} + vmHandler := osrs.OpenStackVMHandler{ + Region: cloudConn.Region, + CredentialInfo: cloudConn.CredentialInfo, + IdentityClient: cloudConn.IdentityClient, + ComputeClient: cloudConn.ComputeClient, + NetworkClient: cloudConn.NetworkClient, + NLBClient: cloudConn.NLBClient, + VolumeClient: cloudConn.Volume3Client, + } if vmHandler.VolumeClient == nil { vmHandler.VolumeClient = cloudConn.Volume2Client } @@ -83,7 +103,14 @@ func (cloudConn *OpenStackCloudConnection) CreateVMSpecHandler() (irs.VMSpecHand func (cloudConn *OpenStackCloudConnection) CreateNLBHandler() (irs.NLBHandler, error) { cblogger.Info("OpenStack Cloud Driver: called CreateNLBHandler()!") - nlbHandler := osrs.OpenStackNLBHandler{CredentialInfo: cloudConn.CredentialInfo, Region: cloudConn.Region, VMClient: cloudConn.ComputeClient, NetworkClient: cloudConn.NetworkClient, NLBClient: cloudConn.NLBClient} + nlbHandler := osrs.OpenStackNLBHandler{ + CredentialInfo: cloudConn.CredentialInfo, + Region: cloudConn.Region, + IdentityClient: cloudConn.IdentityClient, + ComputeClient: cloudConn.ComputeClient, + NetworkClient: cloudConn.NetworkClient, + NLBClient: cloudConn.NLBClient, + } return &nlbHandler, nil } diff --git a/cloud-control-manager/cloud-driver/drivers/openstack/main/Test_Resources.go b/cloud-control-manager/cloud-driver/drivers/openstack/main/Test_Resources.go index 77ccba819..14eb6c632 100644 --- a/cloud-control-manager/cloud-driver/drivers/openstack/main/Test_Resources.go +++ b/cloud-control-manager/cloud-driver/drivers/openstack/main/Test_Resources.go @@ -335,10 +335,18 @@ Loop: fmt.Println("Finish GetSecurity()") case 3: fmt.Println("Start CreateSecurity() ...") + var tags []irs.KeyValue + for _, tag := range config.Openstack.Resources.Security.Tags { + tags = append(tags, irs.KeyValue{ + Key: tag.Key, + Value: tag.Value, + }) + } reqInfo := irs.SecurityReqInfo{ IId: securityIId, SecurityRules: &securityRulesInfos, VpcIID: targetVPCIId, + TagList: tags, } security, err := securityHandler.CreateSecurity(reqInfo) if err != nil { @@ -403,19 +411,35 @@ func testVPCHandler(config Config) { subnetLists := config.Openstack.Resources.VPC.Subnets var subnetInfoList []irs.SubnetInfo for _, sb := range subnetLists { + var tags []irs.KeyValue + for _, tag := range sb.Tags { + tags = append(tags, irs.KeyValue{ + Key: tag.Key, + Value: tag.Value, + }) + } info := irs.SubnetInfo{ IId: irs.IID{ NameId: sb.NameId, }, IPv4_CIDR: sb.IPv4CIDR, + TagList: tags, } subnetInfoList = append(subnetInfoList, info) } + var tags []irs.KeyValue + for _, tag := range config.Openstack.Resources.VPC.Tags { + tags = append(tags, irs.KeyValue{ + Key: tag.Key, + Value: tag.Value, + }) + } VPCReqInfo := irs.VPCReqInfo{ IId: vpcIID, IPv4_CIDR: config.Openstack.Resources.VPC.IPv4CIDR, SubnetInfoList: subnetInfoList, + TagList: tags, } addSubnet := config.Openstack.Resources.VPC.AddSubnet addSubnetInfo := irs.SubnetInfo{ @@ -546,6 +570,13 @@ func testVMHandler(config Config) { if config.Openstack.Resources.Vm.ImageType == "MyImage" { imageType = irs.MyImage } + var tags []irs.KeyValue + for _, tag := range config.Openstack.Resources.Vm.Tags { + tags = append(tags, irs.KeyValue{ + Key: tag.Key, + Value: tag.Value, + }) + } vmReqInfo := irs.VMReqInfo{ IId: irs.IID{ NameId: config.Openstack.Resources.Vm.IID.NameId, @@ -565,13 +596,15 @@ func testVMHandler(config Config) { }, VMSpecName: config.Openstack.Resources.Vm.VmSpecName, KeyPairIID: irs.IID{ - NameId: config.Openstack.Resources.Vm.KeyPairIID.NameId, + NameId: config.Openstack.Resources.Vm.KeyPairIID.NameId, + SystemId: config.Openstack.Resources.Vm.KeyPairIID.SystemId, }, RootDiskSize: config.Openstack.Resources.Vm.RootDiskSize, RootDiskType: config.Openstack.Resources.Vm.RootDiskType, SecurityGroupIIDs: SecurityGroupIIDs, VMUserId: config.Openstack.Resources.Vm.VMUserId, VMUserPasswd: config.Openstack.Resources.Vm.VMUserPasswd, + TagList: tags, } Loop: @@ -780,6 +813,9 @@ func testNLBHandler(config Config) { Timeout: 4, Threshold: 3, }, + TagList: []irs.KeyValue{ + {Key: "nlb-tag-key", Value: "nlb-tag-value"}, + }, } updateListener := irs.ListenerInfo{ Protocol: "TCP", @@ -1552,6 +1588,10 @@ type Config struct { CIDR string `yaml:"CIDR"` Direction string `yaml:"Direction"` } `yaml:"removeRules"` + Tags []struct { + Key string `yaml:"key"` + Value string `yaml:"value"` + } `yaml:"tags"` } `yaml:"security"` KeyPair struct { NameId string `yaml:"nameId"` @@ -1568,11 +1608,19 @@ type Config struct { Subnets []struct { NameId string `yaml:"nameId"` IPv4CIDR string `yaml:"ipv4CIDR"` + Tags []struct { + Key string `yaml:"key"` + Value string `yaml:"value"` + } `yaml:"tags"` } `yaml:"subnets"` AddSubnet struct { NameId string `yaml:"nameId"` IPv4CIDR string `yaml:"ipv4CIDR"` } `yaml:"addSubnet"` + Tags []struct { + Key string `yaml:"key"` + Value string `yaml:"value"` + } `yaml:"tags"` } `yaml:"vpc"` Vm struct { IID struct { @@ -1586,7 +1634,8 @@ type Config struct { ImageType string `yaml:"ImageType"` VmSpecName string `yaml:"VmSpecName"` KeyPairIID struct { - NameId string `yaml:"nameId"` + NameId string `yaml:"nameId"` + SystemId string `yaml:"systemId"` } `yaml:"KeyPairIID"` VpcIID struct { NameId string `yaml:"nameId"` @@ -1604,6 +1653,10 @@ type Config struct { RootDiskType string `yaml:"RootDiskType"` VMUserId string `yaml:"VMUserId"` VMUserPasswd string `yaml:"VMUserPasswd"` + Tags []struct { + Key string `yaml:"key"` + Value string `yaml:"value"` + } `yaml:"tags"` } `yaml:"vm"` } `yaml:"resources"` } `yaml:"openstack"` diff --git a/cloud-control-manager/cloud-driver/drivers/openstack/main/conf/config.yaml.sample b/cloud-control-manager/cloud-driver/drivers/openstack/main/conf/config.yaml.sample index 80e20a7a3..ec5791eaf 100644 --- a/cloud-control-manager/cloud-driver/drivers/openstack/main/conf/config.yaml.sample +++ b/cloud-control-manager/cloud-driver/drivers/openstack/main/conf/config.yaml.sample @@ -1,6 +1,6 @@ openstack: identity_endpoint: TBD - project_id: TBD + project_id: TBD domain_name: TBD username: TBD password: TBD @@ -33,6 +33,9 @@ openstack: IPProtocol: "tcp" CIDR: "0.0.0.0/0" Direction: "inbound" + tags: + - key: sg-tag-key + value: sg-tag-value keyPair: nameId: mcb-test-key systemId: @@ -40,17 +43,26 @@ openstack: nameId: m1.small systemId: vpc: - nameId: mcb-test-vpc + nameId: nlb-tester-vpc systemId: ipv4CIDR: 180.0.0.0/16 subnets: - nameId: mcb-test-vpc-subnet1 ipv4CIDR: 180.0.40.0/24 + tags: + - key: subnet1-tag-key + value: subnet1-tag-value - nameId: mcb-test-vpc-subnet2 ipv4CIDR: 180.0.30.0/24 + tags: + - key: subnet2-tag-key + value: subnet2-tag-value addSubnet: nameId: mcb-test-vpc-subnet3 ipv4CIDR: 180.0.50.0/24 + tags: + - key: vpc-tag-key + value: vpc-tag-value vm: IID: nameId: mcb-test-vm @@ -71,3 +83,6 @@ openstack: SecurityGroupIIDs: - nameId: mcb-test-security systemId: + tags: + - key: vm-tag-key + value: vm-tag-value diff --git a/cloud-control-manager/cloud-driver/drivers/openstack/resources/CommonOpenStackFunc.go b/cloud-control-manager/cloud-driver/drivers/openstack/resources/CommonOpenStackFunc.go index 5605104f6..1aa022737 100644 --- a/cloud-control-manager/cloud-driver/drivers/openstack/resources/CommonOpenStackFunc.go +++ b/cloud-control-manager/cloud-driver/drivers/openstack/resources/CommonOpenStackFunc.go @@ -174,3 +174,25 @@ func CheckIIDValidation(IId irs.IID) bool { } return true } + +func tagsToKeyValue(tagString string) irs.KeyValue { + split := strings.Split(tagString, "=") + + if len(split) == 2 { + return irs.KeyValue{ + Key: split[0], + Value: split[1], + } + } + + return irs.KeyValue{} +} + +func returnTaggingError(errTags []irs.KeyValue, originalErrMsg string) error { + errMsg := "TaggingError: " + for _, tag := range errTags { + errMsg = errMsg + "{" + tag.Key + ", " + tag.Value + "}, " + } + + return errors.New(errMsg[:len(errMsg)-2] + ": " + originalErrMsg) +} diff --git a/cloud-control-manager/cloud-driver/drivers/openstack/resources/NLBHandler.go b/cloud-control-manager/cloud-driver/drivers/openstack/resources/NLBHandler.go index 676d5e4aa..018a85def 100644 --- a/cloud-control-manager/cloud-driver/drivers/openstack/resources/NLBHandler.go +++ b/cloud-control-manager/cloud-driver/drivers/openstack/resources/NLBHandler.go @@ -26,7 +26,8 @@ import ( type OpenStackNLBHandler struct { CredentialInfo idrv.CredentialInfo Region idrv.RegionInfo - VMClient *gophercloud.ServiceClient + IdentityClient *gophercloud.ServiceClient + ComputeClient *gophercloud.ServiceClient NetworkClient *gophercloud.ServiceClient NLBClient *gophercloud.ServiceClient } @@ -781,6 +782,12 @@ func (nlbHandler *OpenStackNLBHandler) ChangeHealthCheckerInfo(nlbIID irs.IID, h } func (nlbHandler *OpenStackNLBHandler) setterNLB(rawNLB loadbalancers.LoadBalancer) (irs.NLBInfo, error) { + var tags []irs.KeyValue + + for _, tag := range rawNLB.Tags { + tags = append(tags, tagsToKeyValue(tag)) + } + nlbInfo := irs.NLBInfo{ IId: irs.IID{ NameId: rawNLB.Name, @@ -789,6 +796,7 @@ func (nlbHandler *OpenStackNLBHandler) setterNLB(rawNLB loadbalancers.LoadBalanc Scope: string(NLBRegionType), Type: string(NLBPublicType), CreatedTime: rawNLB.CreatedAt, + TagList: tags, } vpcIId, err := nlbHandler.getVPCIID(rawNLB) if err == nil { @@ -867,7 +875,7 @@ func (nlbHandler *OpenStackNLBHandler) getRawVMByName(name string) (*servers.Ser opts := servers.ListOpts{ Name: name, } - pager, err := servers.List(nlbHandler.VMClient, opts).AllPages() + pager, err := servers.List(nlbHandler.ComputeClient, opts).AllPages() if err != nil { return nil, err } @@ -882,7 +890,7 @@ func (nlbHandler *OpenStackNLBHandler) getRawVMByIP(ip string) (*servers.Server, opts := servers.ListOpts{ IP: ip, } - pager, err := servers.List(nlbHandler.VMClient, opts).AllPages() + pager, err := servers.List(nlbHandler.ComputeClient, opts).AllPages() if err != nil { return nil, err } diff --git a/cloud-control-manager/cloud-driver/drivers/openstack/resources/SecurityHandler.go b/cloud-control-manager/cloud-driver/drivers/openstack/resources/SecurityHandler.go index 8d037ffbb..4b025185b 100644 --- a/cloud-control-manager/cloud-driver/drivers/openstack/resources/SecurityHandler.go +++ b/cloud-control-manager/cloud-driver/drivers/openstack/resources/SecurityHandler.go @@ -4,6 +4,8 @@ import ( "encoding/json" "errors" "fmt" + idrv "github.com/cloud-barista/cb-spider/cloud-control-manager/cloud-driver/interfaces" + networkTags "github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/attributestags" "net" "strconv" "strings" @@ -24,16 +26,31 @@ const ( ) type OpenStackSecurityHandler struct { - Client *gophercloud.ServiceClient - NetworkClient *gophercloud.ServiceClient + CredentialInfo idrv.CredentialInfo + IdentityClient *gophercloud.ServiceClient + ComputeClient *gophercloud.ServiceClient + NetworkClient *gophercloud.ServiceClient + NLBClient *gophercloud.ServiceClient } func (securityHandler *OpenStackSecurityHandler) setterSeg(secGroup secgroups.SecurityGroup) *irs.SecurityInfo { + var tags []irs.KeyValue + + tagStrings, err := networkTags.List(securityHandler.NetworkClient, "security-groups", secGroup.ID).Extract() + if err != nil { + cblogger.Error(err) + } + + for _, tag := range tagStrings { + tags = append(tags, tagsToKeyValue(tag)) + } + secInfo := &irs.SecurityInfo{ IId: irs.IID{ NameId: secGroup.Name, SystemId: secGroup.ID, }, + TagList: tags, } listOpts := rules.ListOpts{ @@ -61,7 +78,7 @@ func (securityHandler *OpenStackSecurityHandler) setterSeg(secGroup secgroups.Se func (securityHandler *OpenStackSecurityHandler) CreateSecurity(securityReqInfo irs.SecurityReqInfo) (createdSG irs.SecurityInfo, creteErr error) { // log HisCall - hiscallInfo := GetCallLogScheme(securityHandler.Client.IdentityEndpoint, call.SECURITYGROUP, securityReqInfo.IId.NameId, "CreateSecurity()") + hiscallInfo := GetCallLogScheme(securityHandler.ComputeClient.IdentityEndpoint, call.SECURITYGROUP, securityReqInfo.IId.NameId, "CreateSecurity()") // Check SecurityGroup Exists secGroupList, err := securityHandler.ListSecurity() @@ -87,7 +104,7 @@ func (securityHandler *OpenStackSecurityHandler) CreateSecurity(securityReqInfo } start := call.Start() - group, err := secgroups.Create(securityHandler.Client, createOpts).Extract() + group, err := secgroups.Create(securityHandler.ComputeClient, createOpts).Extract() if err != nil { createErr := errors.New(fmt.Sprintf("Failed to Create Security. err = %s", err.Error())) cblogger.Error(createErr.Error()) @@ -97,7 +114,7 @@ func (securityHandler *OpenStackSecurityHandler) CreateSecurity(securityReqInfo defer func() { if creteErr != nil { - secgroups.Delete(securityHandler.Client, group.ID) + secgroups.Delete(securityHandler.ComputeClient, group.ID) } }() @@ -136,6 +153,29 @@ func (securityHandler *OpenStackSecurityHandler) CreateSecurity(securityReqInfo } } + // Tagging + tagHandler := OpenStackTagHandler{ + CredentialInfo: securityHandler.CredentialInfo, + IdentityClient: securityHandler.IdentityClient, + ComputeClient: securityHandler.ComputeClient, + NetworkClient: securityHandler.NetworkClient, + NLBClient: securityHandler.NLBClient, + } + + var errTags []irs.KeyValue + var errMsg string + for _, tag := range securityReqInfo.TagList { + _, err = tagHandler.AddTag(irs.SG, irs.IID{SystemId: group.ID}, tag) + if err != nil { + cblogger.Error(err) + errTags = append(errTags, tag) + errMsg += err.Error() + ", " + } + } + if len(errTags) > 0 { + return irs.SecurityInfo{}, returnTaggingError(errTags, errMsg[:len(errMsg)-2]) + } + // 생성된 SecurityGroup 정보 리턴 securityInfo, err := securityHandler.GetSecurity(irs.IID{SystemId: group.ID}) if err != nil { @@ -150,11 +190,11 @@ func (securityHandler *OpenStackSecurityHandler) CreateSecurity(securityReqInfo func (securityHandler *OpenStackSecurityHandler) ListSecurity() ([]*irs.SecurityInfo, error) { // log HisCall - hiscallInfo := GetCallLogScheme(securityHandler.Client.IdentityEndpoint, call.SECURITYGROUP, SecurityGroup, "ListSecurity()") + hiscallInfo := GetCallLogScheme(securityHandler.ComputeClient.IdentityEndpoint, call.SECURITYGROUP, SecurityGroup, "ListSecurity()") // 보안그룹 목록 조회 start := call.Start() - pager, err := secgroups.List(securityHandler.Client).AllPages() + pager, err := secgroups.List(securityHandler.ComputeClient).AllPages() if err != nil { getErr := errors.New(fmt.Sprintf("Failed to List Security. err = %s", err.Error())) cblogger.Error(getErr.Error()) @@ -182,7 +222,7 @@ func (securityHandler *OpenStackSecurityHandler) ListSecurity() ([]*irs.Security func (securityHandler *OpenStackSecurityHandler) GetSecurity(securityIID irs.IID) (irs.SecurityInfo, error) { // log HisCall - hiscallInfo := GetCallLogScheme(securityHandler.Client.IdentityEndpoint, call.SECURITYGROUP, securityIID.NameId, "GetSecurity()") + hiscallInfo := GetCallLogScheme(securityHandler.ComputeClient.IdentityEndpoint, call.SECURITYGROUP, securityIID.NameId, "GetSecurity()") start := call.Start() securityGroup, err := securityHandler.getRawSecurity(securityIID) @@ -200,10 +240,18 @@ func (securityHandler *OpenStackSecurityHandler) GetSecurity(securityIID irs.IID func (securityHandler *OpenStackSecurityHandler) DeleteSecurity(securityIID irs.IID) (bool, error) { // log HisCall - hiscallInfo := GetCallLogScheme(securityHandler.Client.IdentityEndpoint, call.SECURITYGROUP, securityIID.NameId, "DeleteSecurity()") + hiscallInfo := GetCallLogScheme(securityHandler.ComputeClient.IdentityEndpoint, call.SECURITYGROUP, securityIID.NameId, "DeleteSecurity()") start := call.Start() - result := secgroups.Delete(securityHandler.Client, securityIID.SystemId) + securityGroup, err := securityHandler.getRawSecurity(securityIID) + if err != nil { + getErr := errors.New(fmt.Sprintf("Failed to Delete Security. err = %s", err.Error())) + cblogger.Error(getErr.Error()) + LoggingError(hiscallInfo, getErr) + return false, getErr + } + + result := secgroups.Delete(securityHandler.ComputeClient, securityGroup.ID) if result.Err != nil { delErr := errors.New(fmt.Sprintf("Failed to Delete Security. err = %s", result.Err.Error())) cblogger.Error(delErr.Error()) @@ -215,7 +263,7 @@ func (securityHandler *OpenStackSecurityHandler) DeleteSecurity(securityIID irs. } func (securityHandler *OpenStackSecurityHandler) AddRules(sgIID irs.IID, securityRules *[]irs.SecurityRuleInfo) (irs.SecurityInfo, error) { - hiscallInfo := GetCallLogScheme(securityHandler.Client.IdentityEndpoint, call.SECURITYGROUP, sgIID.NameId, "AddRules()") + hiscallInfo := GetCallLogScheme(securityHandler.ComputeClient.IdentityEndpoint, call.SECURITYGROUP, sgIID.NameId, "AddRules()") start := call.Start() securityGroup, err := securityHandler.getRawSecurity(sgIID) @@ -280,7 +328,7 @@ func (securityHandler *OpenStackSecurityHandler) AddRules(sgIID irs.IID, securit } func (securityHandler *OpenStackSecurityHandler) RemoveRules(sgIID irs.IID, securityRules *[]irs.SecurityRuleInfo) (bool, error) { - hiscallInfo := GetCallLogScheme(securityHandler.Client.IdentityEndpoint, call.SECURITYGROUP, sgIID.NameId, "AddRules()") + hiscallInfo := GetCallLogScheme(securityHandler.ComputeClient.IdentityEndpoint, call.SECURITYGROUP, sgIID.NameId, "AddRules()") start := call.Start() rawseg, err := securityHandler.getRawSecurity(sgIID) @@ -520,9 +568,9 @@ func (securityHandler *OpenStackSecurityHandler) getRawSecurity(securityIID irs. return nil, errors.New("invalid IID") } if securityIID.SystemId != "" { - return secgroups.Get(securityHandler.Client, securityIID.SystemId).Extract() + return secgroups.Get(securityHandler.ComputeClient, securityIID.SystemId).Extract() } else { - pager, err := secgroups.List(securityHandler.Client).AllPages() + pager, err := secgroups.List(securityHandler.ComputeClient).AllPages() if err != nil { return nil, err } diff --git a/cloud-control-manager/cloud-driver/drivers/openstack/resources/VMHandler.go b/cloud-control-manager/cloud-driver/drivers/openstack/resources/VMHandler.go index 7c1dcc449..9d550b011 100644 --- a/cloud-control-manager/cloud-driver/drivers/openstack/resources/VMHandler.go +++ b/cloud-control-manager/cloud-driver/drivers/openstack/resources/VMHandler.go @@ -44,10 +44,13 @@ const ( ) type OpenStackVMHandler struct { - Region idrv.RegionInfo - ComputeClient *gophercloud.ServiceClient - NetworkClient *gophercloud.ServiceClient - VolumeClient *gophercloud.ServiceClient + Region idrv.RegionInfo + CredentialInfo idrv.CredentialInfo + IdentityClient *gophercloud.ServiceClient + ComputeClient *gophercloud.ServiceClient + NetworkClient *gophercloud.ServiceClient + NLBClient *gophercloud.ServiceClient + VolumeClient *gophercloud.ServiceClient } func (vmHandler *OpenStackVMHandler) StartVM(vmReqInfo irs.VMReqInfo) (startvm irs.VMInfo, createErr error) { @@ -115,8 +118,8 @@ func (vmHandler *OpenStackVMHandler) StartVM(vmReqInfo irs.VMReqInfo) (startvm i // Private IP 할당 서브넷 매핑 // Private IP 할당 서브넷 매핑 - vpc 및 서브넷 확인 vpcHandler := OpenStackVPCHandler{ - Client: vmHandler.NetworkClient, - VMClient: vmHandler.ComputeClient, + NetworkClient: vmHandler.NetworkClient, + ComputeClient: vmHandler.ComputeClient, } rawVpc, err := vpcHandler.getRawVPC(vmReqInfo.VpcIID) if err != nil { @@ -155,7 +158,7 @@ func (vmHandler *OpenStackVMHandler) StartVM(vmReqInfo irs.VMReqInfo) (startvm i } // SecurityGroup 준비 segHandler := OpenStackSecurityHandler{ - Client: vmHandler.ComputeClient, + ComputeClient: vmHandler.ComputeClient, NetworkClient: vmHandler.NetworkClient, } @@ -299,6 +302,30 @@ func (vmHandler *OpenStackVMHandler) StartVM(vmReqInfo irs.VMReqInfo) (startvm i return irs.VMInfo{}, createErr } } + + // Tagging + tagHandler := OpenStackTagHandler{ + CredentialInfo: vpcHandler.CredentialInfo, + IdentityClient: vpcHandler.IdentityClient, + ComputeClient: vpcHandler.ComputeClient, + NetworkClient: vpcHandler.NetworkClient, + NLBClient: vpcHandler.NLBClient, + } + + var errTags []irs.KeyValue + var errMsg string + for _, tag := range vmReqInfo.TagList { + _, err = tagHandler.AddTag(irs.VM, irs.IID{SystemId: server.ID}, tag) + if err != nil { + cblogger.Error(err) + errTags = append(errTags, tag) + errMsg += err.Error() + ", " + } + } + if len(errTags) > 0 { + return irs.VMInfo{}, returnTaggingError(errTags, errMsg[:len(errMsg)-2]) + } + serverInfo = vmHandler.mappingServerInfo(*serverResult) password, err := getPassword(*serverResult) if err == nil { @@ -570,6 +597,13 @@ func getVmStatus(vmStatus string) irs.VMStatus { } func (vmHandler *OpenStackVMHandler) mappingServerInfo(server servers.Server) irs.VMInfo { + var tags []irs.KeyValue + + if server.Tags != nil { + for _, tag := range *server.Tags { + tags = append(tags, tagsToKeyValue(tag)) + } + } // Get Default VM Info vmInfo := irs.VMInfo{ @@ -587,6 +621,7 @@ func (vmHandler *OpenStackVMHandler) mappingServerInfo(server servers.Server) ir NetworkInterface: server.HostID, KeyValueList: nil, SecurityGroupIIds: nil, + TagList: tags, } OSType, err := getOSTypeByServer(server) if err == nil { diff --git a/cloud-control-manager/cloud-driver/drivers/openstack/resources/VPCHandler.go b/cloud-control-manager/cloud-driver/drivers/openstack/resources/VPCHandler.go index 9f70afc4d..957e70473 100644 --- a/cloud-control-manager/cloud-driver/drivers/openstack/resources/VPCHandler.go +++ b/cloud-control-manager/cloud-driver/drivers/openstack/resources/VPCHandler.go @@ -3,6 +3,7 @@ package resources import ( "errors" "fmt" + idrv "github.com/cloud-barista/cb-spider/cloud-control-manager/cloud-driver/interfaces" "github.com/gophercloud/gophercloud" "github.com/gophercloud/gophercloud/openstack/compute/v2/servers" "github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/external" @@ -19,8 +20,11 @@ const ( ) type OpenStackVPCHandler struct { - Client *gophercloud.ServiceClient - VMClient *gophercloud.ServiceClient + CredentialInfo idrv.CredentialInfo + IdentityClient *gophercloud.ServiceClient + ComputeClient *gophercloud.ServiceClient + NetworkClient *gophercloud.ServiceClient + NLBClient *gophercloud.ServiceClient } type NetworkWithExt struct { @@ -29,6 +33,11 @@ type NetworkWithExt struct { } func (vpcHandler *OpenStackVPCHandler) setterVPC(nvpc NetworkWithExt) *irs.VPCInfo { + var tags []irs.KeyValue + + for _, tag := range nvpc.Tags { + tags = append(tags, tagsToKeyValue(tag)) + } // VPC 정보 맵핑 vpcInfo := irs.VPCInfo{ @@ -36,6 +45,7 @@ func (vpcHandler *OpenStackVPCHandler) setterVPC(nvpc NetworkWithExt) *irs.VPCIn NameId: nvpc.Name, SystemId: nvpc.ID, }, + TagList: tags, } var External string if nvpc.External == true { @@ -65,24 +75,31 @@ func (vpcHandler *OpenStackVPCHandler) setterVPC(nvpc NetworkWithExt) *irs.VPCIn } func (vpcHandler *OpenStackVPCHandler) setterSubnet(subnet subnets.Subnet) *irs.SubnetInfo { + var tags []irs.KeyValue + + for _, tag := range subnet.Tags { + tags = append(tags, tagsToKeyValue(tag)) + } + subnetInfo := irs.SubnetInfo{ IId: irs.IID{ NameId: subnet.Name, SystemId: subnet.ID, }, IPv4_CIDR: subnet.CIDR, + TagList: tags, } return &subnetInfo } func (vpcHandler *OpenStackVPCHandler) CreateVPC(vpcReqInfo irs.VPCReqInfo) (createdVPC irs.VPCInfo, createErr error) { // log HisCall - hiscallInfo := GetCallLogScheme(vpcHandler.Client.IdentityEndpoint, call.VPCSUBNET, vpcReqInfo.IId.NameId, "CreateVPC()") + hiscallInfo := GetCallLogScheme(vpcHandler.NetworkClient.IdentityEndpoint, call.VPCSUBNET, vpcReqInfo.IId.NameId, "CreateVPC()") start := call.Start() // Check VPC Exists listOpts := networks.ListOpts{Name: vpcReqInfo.IId.NameId} - page, err := networks.List(vpcHandler.Client, listOpts).AllPages() + page, err := networks.List(vpcHandler.NetworkClient, listOpts).AllPages() if err != nil { createErr := errors.New(fmt.Sprintf("Failed to Create VPC err = %s", err.Error())) cblogger.Error(createErr.Error()) @@ -108,7 +125,7 @@ func (vpcHandler *OpenStackVPCHandler) CreateVPC(vpcReqInfo irs.VPCReqInfo) (cre Name: vpcReqInfo.IId.NameId, } - vpc, err := networks.Create(vpcHandler.Client, createOpts).Extract() + vpc, err := networks.Create(vpcHandler.NetworkClient, createOpts).Extract() if err != nil { createErr := errors.New(fmt.Sprintf("Failed to Create VPC with name %s err=%s and Finished to rollback deleting", vpcReqInfo.IId.NameId, err.Error())) cblogger.Error(createErr.Error()) @@ -152,6 +169,29 @@ func (vpcHandler *OpenStackVPCHandler) CreateVPC(vpcReqInfo irs.VPCReqInfo) (cre } } + // Tagging + tagHandler := OpenStackTagHandler{ + CredentialInfo: vpcHandler.CredentialInfo, + IdentityClient: vpcHandler.IdentityClient, + ComputeClient: vpcHandler.ComputeClient, + NetworkClient: vpcHandler.NetworkClient, + NLBClient: vpcHandler.NLBClient, + } + + var errTags []irs.KeyValue + var errMsg string + for _, tag := range vpcReqInfo.TagList { + _, err = tagHandler.AddTag(irs.VPC, irs.IID{SystemId: vpc.ID}, tag) + if err != nil { + cblogger.Error(err) + errTags = append(errTags, tag) + errMsg += err.Error() + ", " + } + } + if len(errTags) > 0 { + return irs.VPCInfo{}, returnTaggingError(errTags, errMsg[:len(errMsg)-2]) + } + vpcInfo, err := vpcHandler.GetVPC(irs.IID{SystemId: vpc.ID}) if err != nil { createErr := errors.New(fmt.Sprintf("Failed to Create VPC err = %s", err.Error())) @@ -178,14 +218,14 @@ func (vpcHandler *OpenStackVPCHandler) CreateVPC(vpcReqInfo irs.VPCReqInfo) (cre } func (vpcHandler *OpenStackVPCHandler) ListVPC() ([]*irs.VPCInfo, error) { // log HisCall - hiscallInfo := GetCallLogScheme(vpcHandler.Client.IdentityEndpoint, call.VPCSUBNET, VPC, "ListVPC()") + hiscallInfo := GetCallLogScheme(vpcHandler.NetworkClient.IdentityEndpoint, call.VPCSUBNET, VPC, "ListVPC()") listOpts := external.ListOptsExt{ ListOptsBuilder: networks.ListOpts{}, } start := call.Start() - page, err := networks.List(vpcHandler.Client, listOpts).AllPages() + page, err := networks.List(vpcHandler.NetworkClient, listOpts).AllPages() if err != nil { getErr := errors.New(fmt.Sprintf("Failed to List VPC err = %s", err.Error())) cblogger.Error(getErr.Error()) @@ -214,7 +254,7 @@ func (vpcHandler *OpenStackVPCHandler) ListVPC() ([]*irs.VPCInfo, error) { func (vpcHandler *OpenStackVPCHandler) GetVPC(vpcIID irs.IID) (irs.VPCInfo, error) { // log HisCall - hiscallInfo := GetCallLogScheme(vpcHandler.Client.IdentityEndpoint, call.VPCSUBNET, vpcIID.NameId, "GetVPC()") + hiscallInfo := GetCallLogScheme(vpcHandler.NetworkClient.IdentityEndpoint, call.VPCSUBNET, vpcIID.NameId, "GetVPC()") //var vpc NetworkWithExt start := call.Start() vpc, err := vpcHandler.getRawVPC(vpcIID) @@ -231,7 +271,7 @@ func (vpcHandler *OpenStackVPCHandler) GetVPC(vpcIID irs.IID) (irs.VPCInfo, erro func (vpcHandler *OpenStackVPCHandler) DeleteVPC(vpcIID irs.IID) (bool, error) { // log HisCall - hiscallInfo := GetCallLogScheme(vpcHandler.Client.IdentityEndpoint, call.VPCSUBNET, vpcIID.NameId, "DeleteVPC()") + hiscallInfo := GetCallLogScheme(vpcHandler.NetworkClient.IdentityEndpoint, call.VPCSUBNET, vpcIID.NameId, "DeleteVPC()") start := call.Start() err := vpcHandler.vpcCleaner(vpcIID) @@ -254,17 +294,42 @@ func (vpcHandler *OpenStackVPCHandler) CreateSubnet(vpcId string, reqSubnetInfo IPVersion: gophercloud.IPv4, DNSNameservers: []string{DNSNameservers}, } - subnet, err := subnets.Create(vpcHandler.Client, subnetCreateOpts).Extract() + subnet, err := subnets.Create(vpcHandler.NetworkClient, subnetCreateOpts).Extract() if err != nil { cblogger.Error("Failed to Create Subnet with name %s, err=%s", reqSubnetInfo.IId.NameId, err) return irs.SubnetInfo{}, err } + + // Tagging + tagHandler := OpenStackTagHandler{ + CredentialInfo: vpcHandler.CredentialInfo, + IdentityClient: vpcHandler.IdentityClient, + ComputeClient: vpcHandler.ComputeClient, + NetworkClient: vpcHandler.NetworkClient, + NLBClient: vpcHandler.NLBClient, + } + + var errTags []irs.KeyValue + var errMsg string + for _, tag := range reqSubnetInfo.TagList { + _, err = tagHandler.AddTag(irs.SUBNET, irs.IID{SystemId: subnet.ID}, tag) + if err != nil { + cblogger.Error(err) + errTags = append(errTags, tag) + errMsg += err.Error() + ", " + } + } + if len(errTags) > 0 { + return irs.SubnetInfo{}, returnTaggingError(errTags, errMsg[:len(errMsg)-2]) + } + subnetInfo := vpcHandler.setterSubnet(*subnet) + return *subnetInfo, nil } func (vpcHandler *OpenStackVPCHandler) GetSubnet(subnetIId irs.IID) (irs.SubnetInfo, error) { - subnet, err := subnets.Get(vpcHandler.Client, subnetIId.SystemId).Extract() + subnet, err := subnets.Get(vpcHandler.NetworkClient, subnetIId.SystemId).Extract() if err != nil { cblogger.Error("Failed to Get Subnet with Id %s, err=%s", subnetIId.SystemId, err) return irs.SubnetInfo{}, nil @@ -274,7 +339,7 @@ func (vpcHandler *OpenStackVPCHandler) GetSubnet(subnetIId irs.IID) (irs.SubnetI } func (vpcHandler *OpenStackVPCHandler) DeleteSubnet(subnetIId irs.IID) (bool, error) { - err := subnets.Delete(vpcHandler.Client, subnetIId.SystemId).ExtractErr() + err := subnets.Delete(vpcHandler.NetworkClient, subnetIId.SystemId).ExtractErr() if err != nil { cblogger.Error("Failed to Delete Subnet with Id %s, err=%s", subnetIId.SystemId, err) return false, err @@ -283,7 +348,7 @@ func (vpcHandler *OpenStackVPCHandler) DeleteSubnet(subnetIId irs.IID) (bool, er } func (vpcHandler *OpenStackVPCHandler) CreateRouter(vpcName string) (*string, error) { - externVPCId, _ := GetPublicVPCInfo(vpcHandler.Client, "ID") + externVPCId, _ := GetPublicVPCInfo(vpcHandler.NetworkClient, "ID") routerName := vpcName AdminStateUp := true createOpts := routers.CreateOpts{ @@ -295,7 +360,7 @@ func (vpcHandler *OpenStackVPCHandler) CreateRouter(vpcName string) (*string, er } // Create Router - router, err := routers.Create(vpcHandler.Client, createOpts).Extract() + router, err := routers.Create(vpcHandler.NetworkClient, createOpts).Extract() if err != nil { return nil, err } @@ -306,7 +371,7 @@ func (vpcHandler *OpenStackVPCHandler) GetRouter(vpcName string) (*string, error // Get Router Info routerName := vpcName listOpts := routers.ListOpts{Name: routerName} - page, err := routers.List(vpcHandler.Client, listOpts).AllPages() + page, err := routers.List(vpcHandler.NetworkClient, listOpts).AllPages() if err != nil { cblogger.Error("Failed to Get Router List, err=%s", err) return nil, err @@ -338,7 +403,7 @@ func (vpcHandler *OpenStackVPCHandler) DeleteRouter(vpcName string) (bool, error return false, err } // Delete Router - err = routers.Delete(vpcHandler.Client, *routerId).ExtractErr() + err = routers.Delete(vpcHandler.NetworkClient, *routerId).ExtractErr() if err != nil { cblogger.Error("Failed to Delete Router with Id %s, err=%s", routerId) return false, err @@ -352,7 +417,7 @@ func (vpcHandler *OpenStackVPCHandler) AddInterface(subnetId string, routerId st } // Add Interface - _, err := routers.AddInterface(vpcHandler.Client, routerId, createOpts).Extract() + _, err := routers.AddInterface(vpcHandler.NetworkClient, routerId, createOpts).Extract() if err != nil { return false, err } @@ -365,7 +430,7 @@ func (vpcHandler *OpenStackVPCHandler) DeleteInterface(subnetId string, routerId } // Delete Interface - _, err := routers.RemoveInterface(vpcHandler.Client, routerId, deleteOpts).Extract() + _, err := routers.RemoveInterface(vpcHandler.NetworkClient, routerId, deleteOpts).Extract() if err != nil { return false, err } @@ -374,7 +439,7 @@ func (vpcHandler *OpenStackVPCHandler) DeleteInterface(subnetId string, routerId func (vpcHandler *OpenStackVPCHandler) AddSubnet(vpcIID irs.IID, subnetInfo irs.SubnetInfo) (irs.VPCInfo, error) { // log HisCall - hiscallInfo := GetCallLogScheme(vpcHandler.Client.IdentityEndpoint, call.VPCSUBNET, subnetInfo.IId.NameId, "AddSubnet()") + hiscallInfo := GetCallLogScheme(vpcHandler.NetworkClient.IdentityEndpoint, call.VPCSUBNET, subnetInfo.IId.NameId, "AddSubnet()") subnetCreateOpts := subnets.CreateOpts{ NetworkID: vpcIID.SystemId, @@ -385,7 +450,7 @@ func (vpcHandler *OpenStackVPCHandler) AddSubnet(vpcIID irs.IID, subnetInfo irs. } start := call.Start() - _, err := subnets.Create(vpcHandler.Client, subnetCreateOpts).Extract() + _, err := subnets.Create(vpcHandler.NetworkClient, subnetCreateOpts).Extract() if err != nil { addSubnetErr := errors.New(fmt.Sprintf("Failed to Add Subnet err = %s", err.Error())) cblogger.Error(addSubnetErr.Error()) @@ -406,10 +471,10 @@ func (vpcHandler *OpenStackVPCHandler) AddSubnet(vpcIID irs.IID, subnetInfo irs. func (vpcHandler *OpenStackVPCHandler) RemoveSubnet(vpcIID irs.IID, subnetIID irs.IID) (bool, error) { // log HisCall - hiscallInfo := GetCallLogScheme(vpcHandler.Client.IdentityEndpoint, call.VPCSUBNET, subnetIID.NameId, "RemoveSubnet()") + hiscallInfo := GetCallLogScheme(vpcHandler.NetworkClient.IdentityEndpoint, call.VPCSUBNET, subnetIID.NameId, "RemoveSubnet()") start := call.Start() - err := subnets.Delete(vpcHandler.Client, subnetIID.SystemId).ExtractErr() + err := subnets.Delete(vpcHandler.NetworkClient, subnetIID.SystemId).ExtractErr() if err != nil { delErr := errors.New(fmt.Sprintf("Failed to Remove Subnet err = %s", err.Error())) cblogger.Error(delErr.Error()) @@ -424,7 +489,7 @@ func (vpcHandler *OpenStackVPCHandler) RemoveSubnet(vpcIID irs.IID, subnetIID ir func (vpcHandler *OpenStackVPCHandler) getRawRouter(vpcName string) (router routers.Router, err error) { routerName := vpcName listOpts := routers.ListOpts{Name: routerName} - page, err := routers.List(vpcHandler.Client, listOpts).AllPages() + page, err := routers.List(vpcHandler.NetworkClient, listOpts).AllPages() if err != nil { cblogger.Error("Failed to Get Router List, err=%s", err) return routers.Router{}, err @@ -448,7 +513,7 @@ func (vpcHandler *OpenStackVPCHandler) vpcCleaner(vpcIId irs.IID) error { if err != nil { return err } - pager, err := servers.List(vpcHandler.VMClient, nil).AllPages() + pager, err := servers.List(vpcHandler.ComputeClient, nil).AllPages() if err != nil { return err } @@ -465,7 +530,7 @@ func (vpcHandler *OpenStackVPCHandler) vpcCleaner(vpcIId irs.IID) error { } } listOpts := routers.ListOpts{Name: vpc.IId.NameId} - page, err := routers.List(vpcHandler.Client, listOpts).AllPages() + page, err := routers.List(vpcHandler.NetworkClient, listOpts).AllPages() if err != nil { return err } @@ -475,7 +540,7 @@ func (vpcHandler *OpenStackVPCHandler) vpcCleaner(vpcIId irs.IID) error { } if len(routerList) == 0 { // Not Exist Route Only VPC Delete - err = networks.Delete(vpcHandler.Client, vpc.IId.SystemId).ExtractErr() + err = networks.Delete(vpcHandler.NetworkClient, vpc.IId.SystemId).ExtractErr() if err != nil { return err } @@ -487,11 +552,11 @@ func (vpcHandler *OpenStackVPCHandler) vpcCleaner(vpcIId irs.IID) error { for _, subnet := range vpc.SubnetInfoList { vpcHandler.DeleteInterface(subnet.IId.SystemId, router.ID) } - err = routers.Delete(vpcHandler.Client, router.ID).ExtractErr() + err = routers.Delete(vpcHandler.NetworkClient, router.ID).ExtractErr() if err != nil { return err } - err = networks.Delete(vpcHandler.Client, vpc.IId.SystemId).ExtractErr() + err = networks.Delete(vpcHandler.NetworkClient, vpc.IId.SystemId).ExtractErr() if err != nil { return err } @@ -511,7 +576,7 @@ func (vpcHandler *OpenStackVPCHandler) getRawVPC(vpcIID irs.IID) (*NetworkWithEx Name: vpcIID.NameId, }, } - page, err := networks.List(vpcHandler.Client, listOpts).AllPages() + page, err := networks.List(vpcHandler.NetworkClient, listOpts).AllPages() if err != nil { return nil, err } @@ -529,7 +594,7 @@ func (vpcHandler *OpenStackVPCHandler) getRawVPC(vpcIID irs.IID) (*NetworkWithEx } return nil, errors.New("not found vpc") } else { - err := networks.Get(vpcHandler.Client, vpcIID.SystemId).ExtractInto(&vpc) + err := networks.Get(vpcHandler.NetworkClient, vpcIID.SystemId).ExtractInto(&vpc) if err != nil { return nil, err }