mirror of
https://github.com/yunionio/cloudpods.git
synced 2026-06-23 22:48:06 +08:00
268 lines
8.7 KiB
Go
268 lines
8.7 KiB
Go
// Copyright 2019 Yunion
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package shell
|
|
|
|
import (
|
|
"yunion.io/x/jsonutils"
|
|
|
|
"yunion.io/x/onecloud/pkg/mcclient"
|
|
"yunion.io/x/onecloud/pkg/mcclient/modules"
|
|
"yunion.io/x/onecloud/pkg/mcclient/options"
|
|
)
|
|
|
|
func init() {
|
|
type ElasticipListOptions struct {
|
|
Region string `help:"List eips in cloudregion"`
|
|
|
|
Usable *bool `help:"List all zones that is usable"`
|
|
UsableEipForAssociateType string `help:"With associate id filter which eip can associate"`
|
|
UsableEipForAssociateId string `help:"With associate type filter which eip can associate"`
|
|
|
|
options.BaseListOptions
|
|
}
|
|
R(&ElasticipListOptions{}, "eip-list", "List elastic IPs", func(s *mcclient.ClientSession, opts *ElasticipListOptions) error {
|
|
params, err := options.ListStructToParams(opts)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
results, err := modules.Elasticips.List(s, params)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printList(results, modules.Elasticips.GetColumns(s))
|
|
return nil
|
|
})
|
|
|
|
type EipCreateOptions struct {
|
|
MANAGER string `help:"cloud provider"`
|
|
REGION string `help:"cloud region in which EIP is allocated"`
|
|
NAME string `help:"name of the EIP"`
|
|
Bandwidth int `help:"Bandwidth in Mbps"`
|
|
Ip string `help:"IP address of the EIP"`
|
|
Network string `help:"Network of the EIP"`
|
|
ChargeType string `help:"bandwidth charge type" choices:"traffic|bandwidth"`
|
|
}
|
|
R(&EipCreateOptions{}, "eip-create", "Create an EIP", func(s *mcclient.ClientSession, args *EipCreateOptions) error {
|
|
params := jsonutils.NewDict()
|
|
params.Add(jsonutils.NewString(args.MANAGER), "manager")
|
|
params.Add(jsonutils.NewString(args.REGION), "region")
|
|
params.Add(jsonutils.NewString(args.NAME), "name")
|
|
if args.Bandwidth != 0 {
|
|
params.Add(jsonutils.NewInt(int64(args.Bandwidth)), "bandwidth")
|
|
}
|
|
|
|
if len(args.ChargeType) > 0 {
|
|
params.Add(jsonutils.NewString(args.ChargeType), "charge_type")
|
|
}
|
|
|
|
if len(args.Network) > 0 {
|
|
params.Add(jsonutils.NewString(args.Network), "network")
|
|
}
|
|
|
|
if len(args.Ip) > 0 {
|
|
params.Add(jsonutils.NewString(args.Ip), "ip")
|
|
}
|
|
|
|
result, err := modules.Elasticips.Create(s, params)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printObject(result)
|
|
return nil
|
|
})
|
|
|
|
type EipDeleteOptions struct {
|
|
ID string `help:"ID or name of EIP"`
|
|
}
|
|
R(&EipDeleteOptions{}, "eip-delete", "Delete an EIP", func(s *mcclient.ClientSession, args *EipDeleteOptions) error {
|
|
result, err := modules.Elasticips.Delete(s, args.ID, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printObject(result)
|
|
return nil
|
|
})
|
|
|
|
type EipUpdateOptions struct {
|
|
ID string `help:"ID or name of EIP"`
|
|
Name string `help:"New name of EIP"`
|
|
Desc string `help:"New description of EIP"`
|
|
|
|
EnableAutoDellocate bool `help:"enable automatically dellocate when dissociate from instance"`
|
|
DisableAutoDellocate bool `help:"disable automatically dellocate when dissociate from instance"`
|
|
}
|
|
R(&EipUpdateOptions{}, "eip-update", "Update EIP properties", func(s *mcclient.ClientSession, args *EipUpdateOptions) error {
|
|
params := jsonutils.NewDict()
|
|
if len(args.Name) > 0 {
|
|
params.Add(jsonutils.NewString(args.Name), "name")
|
|
}
|
|
if len(args.Desc) > 0 {
|
|
params.Add(jsonutils.NewString(args.Desc), "description")
|
|
}
|
|
if args.EnableAutoDellocate {
|
|
params.Add(jsonutils.JSONTrue, "auto_dellocate")
|
|
} else if args.DisableAutoDellocate {
|
|
params.Add(jsonutils.JSONFalse, "auto_dellocate")
|
|
}
|
|
result, err := modules.Elasticips.Update(s, args.ID, params)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printObject(result)
|
|
return nil
|
|
})
|
|
|
|
type EipAssociateOptions struct {
|
|
ID string `help:"ID or name of EIP"`
|
|
INSTANCEID string `help:"ID of instance the eip associated with"`
|
|
InstanceType string `default:"server" help:"Instance type that the eip associated with, default is server" choices:"server"`
|
|
}
|
|
R(&EipAssociateOptions{}, "eip-associate", "Associate an EIP to an instance", func(s *mcclient.ClientSession, args *EipAssociateOptions) error {
|
|
params := jsonutils.NewDict()
|
|
params.Add(jsonutils.NewString(args.InstanceType), "instance_type")
|
|
params.Add(jsonutils.NewString(args.INSTANCEID), "instance_id")
|
|
result, err := modules.Elasticips.PerformAction(s, args.ID, "associate", params)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printObject(result)
|
|
return nil
|
|
})
|
|
|
|
type EipDissociateOptions struct {
|
|
ID string `help:"ID or name of EIP"`
|
|
AutoDelete bool `help:"automatically delete the dissociate EIP" json:"auto_delete,omitfalse"`
|
|
}
|
|
R(&EipDissociateOptions{}, "eip-dissociate", "Dissociate an EIP from an instance", func(s *mcclient.ClientSession, args *EipDissociateOptions) error {
|
|
params, err := options.StructToParams(args)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
result, err := modules.Elasticips.PerformAction(s, args.ID, "dissociate", params)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printObject(result)
|
|
return nil
|
|
})
|
|
|
|
type EipSingleOptions struct {
|
|
ID string `help:"ID or name of EIP"`
|
|
}
|
|
R(&EipSingleOptions{}, "eip-sync", "Synchronize status of an EIP", func(s *mcclient.ClientSession, args *EipSingleOptions) error {
|
|
result, err := modules.Elasticips.PerformAction(s, args.ID, "sync", nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printObject(result)
|
|
return nil
|
|
})
|
|
|
|
R(&EipSingleOptions{}, "eip-syncstatus", "Synchronize status of an EIP", func(s *mcclient.ClientSession, args *EipSingleOptions) error {
|
|
result, err := modules.Elasticips.PerformAction(s, args.ID, "syncstatus", nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printObject(result)
|
|
return nil
|
|
})
|
|
|
|
type ServerCreateEipOptions struct {
|
|
ID string `help:"server ID or name"`
|
|
BW int `help:"EIP bandwidth in Mbps"`
|
|
ChargeType string `help:"bandwidth charge type" choices:"traffic|bandwidth"`
|
|
}
|
|
R(&ServerCreateEipOptions{}, "server-create-eip", "allocate an EIP and associate EIP to server", func(s *mcclient.ClientSession, args *ServerCreateEipOptions) error {
|
|
params := jsonutils.NewDict()
|
|
params.Add(jsonutils.NewInt(int64(args.BW)), "bandwidth")
|
|
|
|
if len(args.ChargeType) > 0 {
|
|
params.Add(jsonutils.NewString(args.ChargeType), "charge_type")
|
|
}
|
|
|
|
result, err := modules.Servers.PerformAction(s, args.ID, "create-eip", params)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printObject(result)
|
|
return nil
|
|
})
|
|
|
|
type EipShowOptions struct {
|
|
ID string `help:"ID or name of EIP"`
|
|
}
|
|
R(&EipShowOptions{}, "eip-show", "show details of an EIP", func(s *mcclient.ClientSession, args *EipShowOptions) error {
|
|
result, err := modules.Elasticips.Get(s, args.ID, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printObject(result)
|
|
return nil
|
|
})
|
|
|
|
type EipChangeBandwidthOptions struct {
|
|
ID string `help:"ID or name of the EIP"`
|
|
BW int `help:"new bandwidth of EIP"`
|
|
}
|
|
R(&EipChangeBandwidthOptions{}, "eip-change-bandwidth", "Change maximal bandwidth of EIP", func(s *mcclient.ClientSession, args *EipChangeBandwidthOptions) error {
|
|
params := jsonutils.NewDict()
|
|
params.Add(jsonutils.NewInt(int64(args.BW)), "bandwidth")
|
|
result, err := modules.Elasticips.PerformAction(s, args.ID, "change-bandwidth", params)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printObject(result)
|
|
return nil
|
|
})
|
|
|
|
type EipPurgeOptions struct {
|
|
ID string `help:"ID or name of EIP"`
|
|
}
|
|
R(&EipPurgeOptions{}, "eip-purge", "Purge EIP db records", func(s *mcclient.ClientSession, args *EipPurgeOptions) error {
|
|
result, err := modules.Elasticips.PerformAction(s, args.ID, "purge", nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printObject(result)
|
|
return nil
|
|
})
|
|
|
|
type EipChangeOwnerOptions struct {
|
|
ID string `help:"EIP to change owner"`
|
|
PROJECT string `help:"Project ID or change"`
|
|
RawId bool `help:"User raw ID, instead of name"`
|
|
}
|
|
R(&EipChangeOwnerOptions{}, "eip-change-owner", "Change owner porject of a eip", func(s *mcclient.ClientSession, opts *EipChangeOwnerOptions) error {
|
|
params := jsonutils.NewDict()
|
|
if opts.RawId {
|
|
projid, err := modules.Projects.GetId(s, opts.PROJECT, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
params.Add(jsonutils.NewString(projid), "tenant")
|
|
params.Add(jsonutils.JSONTrue, "raw_id")
|
|
} else {
|
|
params.Add(jsonutils.NewString(opts.PROJECT), "tenant")
|
|
}
|
|
srv, err := modules.Elasticips.PerformAction(s, opts.ID, "change-owner", params)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
printObject(srv)
|
|
return nil
|
|
})
|
|
|
|
}
|