// PutGTMPoolStatus modify status of wideip pool
func PutGTMPoolStatus(host string, poolmodify *ModifyPoolStatus) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Scheme = common.Protocol
u.Path = path.Join(u.Path, common.Gtmpoolsuri)
u.Path = path.Join(u.Path, fmt.Sprintf("/~%s~%s", gtmPartition, poolmodify.Name))
var poolstatus interface{}
switch poolmodify.Status {
case true:
{
poolstatus = EnablePoolStatus{Enabled: true}
}
case false:
{
poolstatus = DisablePoolStatus{Disabled: true}
}
}
r, err := backend.Request(common.PUT, u.String(), &poolstatus)
if err != nil {
return nil, err
}
return r, nil
}
// PutLTMPoolMember modify status of pool member
func PutLTMPoolMember(host, poolname, member, status string) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, fmt.Sprintf("pool/~%s~%s/members/~%s~%s", ltmPartition, poolname, ltmPartition, member))
memberstatus := ModifyPoolMemberStatus{}
switch status {
case "enabled":
{
memberstatus = ModifyPoolMemberStatus{State: "user-up", Session: "user-enabled"}
}
case "disabled":
{
memberstatus = ModifyPoolMemberStatus{State: "user-up", Session: "user-disabled"}
}
case "offline":
{
memberstatus = ModifyPoolMemberStatus{State: "user-down", Session: "user-disabled"}
}
}
r, err := backend.Request(common.PUT, u.String(), &memberstatus)
if err != nil {
return nil, err
}
return r, nil
}
// ShowLTMDevice returns information
// of loadbalancer devices
func ShowLTMDevice(inputURL string) (*backend.Response, *Devices, *errors.Error) {
// Declaration LTM Device
ltmdevice := new(Devices)
deviceURL := util.ReplaceLTMUritoDeviceURI(inputURL)
fmt.Println(deviceURL)
res, err := backend.Request(common.GET, deviceURL, <mdevice)
if err != nil {
return nil, nil, err
}
return res, ltmdevice, nil
}
// PostLTMDataGroup creates a new datagroup
func PostLTMDataGroup(host, direction string, json *CreateDataGroup) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, common.Dg, direction)
r, err := backend.Request(common.POST, u.String(), &json)
if err != nil {
return nil, err
}
return r, nil
}
// PostLTMSSLCert create a new ssl certificate
func PostLTMSSLCert(host string, json interface{}) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, "cert")
r, err := backend.Request(common.POST, u.String(), &json)
if err != nil {
return nil, err
}
return r, nil
}
// DeleteLTMDataGroup deletes a specific datagroup
func DeleteLTMDataGroup(host, direction, datagroupname string) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, common.Dg, direction, "/", datagroupname)
r, err := backend.Request(common.DELETE, u.String(), nil)
if err != nil {
return nil, err
}
return r, nil
}
// PostLTMPoolMember add member to a pool
func PostLTMPoolMember(host, poolname string, json *CreatePoolMember) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, fmt.Sprintf("pool/~%s~%s/members", ltmPartition, poolname))
r, err := backend.Request(common.POST, u.String(), &json)
if err != nil {
return nil, err
}
return r, nil
}
// PostLTMPool create a new pool
func PostLTMPool(host string, json *CreatePool) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, "pool")
r, err := backend.Request(common.POST, u.String(), &json)
if err != nil {
return nil, err
}
return r, nil
}
// DeleteLTMPoolMember delete pool member
func DeleteLTMPoolMember(host, poolname, poolmember string) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, fmt.Sprintf("pool/~%s~%s/members/~%s~%s", ltmPartition, poolname, ltmPartition, poolmember))
r, err := backend.Request(common.DELETE, u.String(), nil)
if err != nil {
return nil, err
}
return r, nil
}
// ShowLTMFWRules shows firewall profile
func ShowLTMFWRules(host, vserver string) (*backend.Response, *FirewallRules, *errors.Error) {
fwrules := new(FirewallRules)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, fmt.Sprintf("virtual/~%s~%s/fw-rules", ltmPartition, vserver))
res, err := backend.Request(common.GET, u.String(), &fwrules)
if err != nil {
return nil, nil, err
}
return res, fwrules, nil
}
// ShowLTMAddressListName returns a specific address list on LB
func ShowLTMAddressListName(host, address string) (*backend.Response, *AddressList, *errors.Error) {
addresslist := new(AddressList)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, address)
res, err := backend.Request(common.GET, u.String(), addresslist)
if err != nil {
return nil, nil, err
}
return res, addresslist, nil
}
// ShowLTMIRules shows iRules
func ShowLTMIRules(host string) (*backend.Response, *IRules, *errors.Error) {
iRs := new(IRules)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, "rule")
res, err := backend.Request(common.GET, u.String(), &iRs)
if err != nil {
return nil, nil, err
}
return res, iRs, nil
}
// ShowLTMIRule shows a specific iRule
func ShowLTMIRule(host, iRuleName string) (*backend.Response, *IRule, *errors.Error) {
iR := new(IRule)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, fmt.Sprintf("rule/~%s~%s", ltmPartition, iRuleName))
res, err := backend.Request(common.GET, u.String(), &iR)
if err != nil {
return nil, nil, err
}
return res, iR, nil
}
// ShowLTMPools show all declared pools
func ShowLTMPools(host string) (*backend.Response, *Pools, *errors.Error) {
// Declaration LTM Pools
ltmpools := new(Pools)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, "pool")
res, err := backend.Request(common.GET, u.String(), <mpools)
if err != nil {
return nil, nil, err
}
return res, ltmpools, nil
}
// ShowLTMPool show specific pool
func ShowLTMPool(host, pool string) (*backend.Response, *Pool, *errors.Error) {
// Declaration LTM Pool
ltmpool := new(Pool)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, fmt.Sprintf("pool/~%s~%s", ltmPartition, pool))
res, err := backend.Request(common.GET, u.String(), <mpool)
if err != nil {
return nil, nil, err
}
return res, ltmpool, nil
}
// ShowLTMDataGroup lists all datagroups on a loadbalancer
func ShowLTMDataGroup(host, source string) (*backend.Response, *DataGroups, *errors.Error) {
// Declaration LTM DataGroup
ltmdatagroup := new(DataGroups)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, common.Dg, source)
res, err := backend.Request(common.GET, u.String(), ltmdatagroup)
if err != nil {
return nil, nil, err
}
return res, ltmdatagroup, nil
}
// ShowLTMVirtualServer show all virtual server
func ShowLTMVirtualServer(host string) (*backend.Response, *VirtualServers, *errors.Error) {
// Declaration LTM virtual server
ltmvirtualserver := new(VirtualServers)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, "virtual")
res, err := backend.Request(common.GET, u.String(), ltmvirtualserver)
if err != nil {
return nil, nil, err
}
return res, ltmvirtualserver, nil
}
// ShowGTMIRule shows a specific iRule
func ShowGTMIRule(host, iRuleName string) (*backend.Response, *IRule, *errors.Error) {
iR := new(IRule)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Scheme = common.Protocol
u.Path = path.Join(u.Path, common.Gtmirulesuri, fmt.Sprintf("/%s", iRuleName))
res, err := backend.Request(common.GET, u.String(), &iR)
if err != nil {
return nil, nil, err
}
return res, iR, nil
}
// ShowLTMProfile show profiles from a virtual server
func ShowLTMProfile(host, vserver string) (*backend.Response, *Profiles, *errors.Error) {
// Declaration LTM Profile
ltmprofile := new(Profiles)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, fmt.Sprintf("virtual/~%s~%s/profiles", ltmPartition, vserver))
res, err := backend.Request(common.GET, u.String(), <mprofile)
if err != nil {
return nil, nil, err
}
return res, ltmprofile, nil
}
// DeleteGTMWip deletes a pool on a trafficmanager
func DeleteGTMWip(host, wideip string) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Scheme = common.Protocol
u.Path = path.Join(u.Path, common.Gtmwipsuri)
u.Path = path.Join(u.Path, fmt.Sprintf("/~%s~%s", gtmPartition, wideip))
r, err := backend.Request(common.DELETE, u.String(), nil)
if err != nil {
return nil, err
}
return r, nil
}
// ShowGTMWip list a specific wide ip on a trafficmanager
func ShowGTMWip(host, wideip string) (*backend.Response, *Wip, *errors.Error) {
gtmwip := new(Wip)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Scheme = common.Protocol
u.Path = path.Join(u.Path, common.Gtmwipsuri, "/", wideip)
res, err := backend.Request(common.GET, u.String(), >mwip)
if err != nil {
return nil, nil, err
}
return res, gtmwip, nil
}
// ShowLTMDeviceName returns information
// of a specific loadbalancer device
func ShowLTMDeviceName(host, inputURL string, ltmDeviceNames map[string]string) (*backend.Response, *Device, *errors.Error) {
// Declaration LTM Device Name
value := ltmDeviceNames[host]
ltmdevicename := new(Device)
u := new(url.URL)
u.Scheme = common.Protocol
u.Path = path.Join(host, common.DeviceURI, value)
devicenameURL := u.String()
res, err := backend.Request(common.GET, devicenameURL, <mdevicename)
if err != nil {
return nil, nil, err
}
return res, ltmdevicename, nil
}
// ShowGTMPools shows all declared pools on gtm
func ShowGTMPools(host string) (*backend.Response, *Pools, *errors.Error) {
gtmpools := new(Pools)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Scheme = common.Protocol
u.Path = path.Join(u.Path, common.Gtmpoolsuri)
res, err := backend.Request(common.GET, u.String(), >mpools)
if err != nil {
return nil, nil, err
}
return res, gtmpools, nil
}
// ShowLTMDataGroupName lists a specific datagroup on a loadbalancer
func ShowLTMDataGroupName(host, direction, datagroupname string) (*backend.Response, *DataGroup, *errors.Error) {
// Declaration LTM DataGroup by Name
ltmdatagroupname := new(DataGroup)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, common.Dg, direction, "/", datagroupname)
res, err := backend.Request(common.GET, u.String(), ltmdatagroupname)
if err != nil {
return nil, nil, err
}
return res, ltmdatagroupname, nil
}
// DeleteGTMPoolMember delete pool member on a trafficmanager
func DeleteGTMPoolMember(host, pool string, poolmember *RemovePoolMember) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Scheme = common.Protocol
u.Path = path.Join(u.Path, common.Gtmpoolsuri)
u.Path = path.Join(u.Path, fmt.Sprintf("/%s/members/~%s~%s:~%s~%s", pool, gtmPartition,
poolmember.Loadbalancer, ltmPartition, poolmember.Name))
r, err := backend.Request(common.DELETE, u.String(), nil)
if err != nil {
return nil, err
}
return r, nil
}
//ShowGTMPoolMembers shows members on a specific pool
func ShowGTMPoolMembers(host, pool string) (*backend.Response, *PoolMembers, *errors.Error) {
// Declaration GTM Pool Member
gtmpoolmembers := new(PoolMembers)
u, errParse := url.Parse(host)
if errParse != nil {
return nil, nil, &errors.ErrorCodeBadRequestParse
}
u.Scheme = common.Protocol
u.Path = path.Join(u.Path, common.Gtmpoolsuri, fmt.Sprintf("/~%s~%s/members", gtmPartition, pool))
res, err := backend.Request(common.GET, u.String(), >mpoolmembers)
if err != nil {
return nil, nil, err
}
return res, gtmpoolmembers, nil
}
// PatchLTMWhiteAddresses to whitelist ips
// Due not overwriting address list
// its necessary to get all entries first
func PatchLTMWhiteAddresses(host string, whiteIP *CreateAddresses) (*backend.Response, *errors.Error) {
_, white, err := ShowLTMAddressListName(host, common.WhiteList)
if err != nil {
return nil, err
}
// first slices are compared to order loops
// if white list has already white ips it will skip
// append(...) is doing a delete item of the slice
// see https://github.com/golang/go/wiki/SliceTricks
if len(white.Addresses) < len(whiteIP.Addresses) {
for i := range white.Addresses {
for j := range whiteIP.Addresses {
if whiteIP.Addresses[j] == white.Addresses[i] {
whiteIP.Addresses = append(whiteIP.Addresses[:j], whiteIP.Addresses[j+1:]...)
break
}
}
}
} else {
for i := range whiteIP.Addresses {
for j := range white.Addresses {
if whiteIP.Addresses[i] == white.Addresses[j] {
whiteIP.Addresses = append(whiteIP.Addresses[:i], whiteIP.Addresses[i+1:]...)
break
}
}
}
}
for i := range white.Addresses {
whiteIP.Addresses = append(whiteIP.Addresses, white.Addresses[i])
}
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, common.WhiteList)
r, err := backend.Request(common.PATCH, u.String(), &whiteIP)
if err != nil {
return nil, err
}
return r, nil
}
// PostGTMWip creates a new wide ip on a trafficmanager
func PostGTMWip(host string, json *CreateWip) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Scheme = common.Protocol
u.Path = path.Join(u.Path, common.Gtmwipsuri)
if !(len(json.Poollbmode) > 0) {
json.Poollbmode = "global-availability"
}
r, err := backend.Request(common.POST, u.String(), &json)
if err != nil {
return nil, err
}
return r, nil
}
//PostGTMPoolMember adds new members to an existing pool on a trafficmanager
func PostGTMPoolMember(host string, pool string, json *CreatePoolMember) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Scheme = common.Protocol
u.Path = path.Join(u.Path, common.Gtmpoolsuri, pool, common.MembersURI)
json.Partition = gtmPartition
json.Subpath = fmt.Sprintf("%s:/%s", json.Loadbalancer, gtmPartition)
json.Fullpath = fmt.Sprintf("/%s/%s:/%s/%s", gtmPartition, json.Loadbalancer, ltmPartition, json.Name)
json.Loadbalancer = ""
r, err := backend.Request(common.POST, u.String(), &json)
fmt.Println(json)
if err != nil {
return nil, err
}
return r, nil
}
// PatchLTMDataGroupItem keeps all records in a datagroup and add new records
// F5 API use PATCH and PUT in the same way. Overwriting all records, which is bad if you want to add items
// in existing list. It gets all records first an append the new records from client.
func PatchLTMDataGroupItem(host, direction, datagroup string, json *CreateDataGroupItem) (*backend.Response, *errors.Error) {
u, errParse := url.Parse(host)
if errParse != nil {
return nil, &errors.ErrorCodeBadRequestParse
}
u.Path = path.Join(u.Path, common.Dg, direction, "/", datagroup)
_, data, err := ShowLTMDataGroupName(host, direction, datagroup)
if err != nil {
return nil, err
}
for _, v := range data.Records {
json.Records = append(json.Records, v)
}
r, err := backend.Request(common.PATCH, u.String(), &json)
if err != nil {
return nil, err
}
return r, nil
}