def order(env, **args): """Creates a LB. Protocols supported are TCP, HTTP, and HTTPS.""" mgr = SoftLayer.LoadBalancerManager(env.client) network = SoftLayer.NetworkManager(env.client) datacenter = network.get_datacenter(datacenter=args.get('datacenter')) if datacenter: location = {'id': datacenter[0]['id']} else: raise exceptions.CLIHalt('Datacenter {} was not found'.format(datacenter)) name = args.get('name') description = args.get('label', None) backend = args.get('backend') frontend = args.get('frontend') protocols = [ { "backendPort": backend.get('port'), "backendProtocol": backend.get('protocol'), "frontendPort": frontend.get('port'), "frontendProtocol": frontend.get('protocol'), "loadBalancingMethod": args.get('method'), "maxConn": 1000 } ] # remove verify=True to place the order receipt = mgr.order_lbaas(location, name, description, protocols, args.get('subnet'), public=args.get('public'), verify=args.get('verify')) table = parse_receipt(receipt) env.fout(table)
def cli(env): """List active load balancers.""" mgr = SoftLayer.LoadBalancerManager(env.client) load_balancers = mgr.get_local_lbs() table = formatting.Table([ 'ID', 'VIP Address', 'Location', 'SSL Offload', 'Connections/second', 'Type' ]) table.align['Connections/second'] = 'r' for load_balancer in load_balancers: ssl_support = 'Not Supported' if load_balancer['sslEnabledFlag']: if load_balancer['sslActiveFlag']: ssl_support = 'On' else: ssl_support = 'Off' lb_type = 'Standard' if load_balancer['dedicatedFlag']: lb_type = 'Dedicated' elif load_balancer['highAvailabilityFlag']: lb_type = 'HA' table.add_row([ 'local:%s' % load_balancer['id'], load_balancer['ipAddress']['ipAddress'], load_balancer['loadBalancerHardware'][0]['datacenter']['name'], ssl_support, load_balancer['connectionLimit'], lb_type ]) env.fout(table)
def cli(env, identifier): """Get Netscaler details.""" mgr = SoftLayer.LoadBalancerManager(env.client) this_lb = mgr.get_adc(identifier) table = netscaler_table(this_lb) env.fout(table)
def cli(env, identifier, enabled, port, weight, healthcheck_type, ip_address): """Edit the properties of a service group.""" mgr = SoftLayer.LoadBalancerManager(env.client) loadbal_id, service_id = loadbal.parse_id(identifier) # check if any input is provided if not any([ip_address, enabled, weight, port, healthcheck_type]): raise exceptions.CLIAbort( 'At least one property is required to be changed!') # check if the IP is valid ip_address_id = None if ip_address: ip_service = env.client['Network_Subnet_IpAddress'] ip_record = ip_service.getByIpAddress(ip_address) ip_address_id = ip_record['id'] mgr.edit_service(loadbal_id, service_id, ip_address_id=ip_address_id, enabled=enabled, port=port, weight=weight, hc_type=healthcheck_type) env.fout('Load balancer service %s is being modified!' % identifier)
def add(env, identifier, **args): """Adds a listener to the identifier LB""" mgr = SoftLayer.LoadBalancerManager(env.client) uuid, _ = mgr.get_lbaas_uuid_id(identifier) new_listener = { 'backendPort': args.get('backport'), 'backendProtocol': args.get('backprotocol') if args.get('backprotocol') else args.get('frontprotocol'), 'frontendPort': args.get('frontport'), 'frontendProtocol': args.get('frontprotocol'), 'loadBalancingMethod': args.get('method'), 'maxConn': args.get('connections', None), 'sessionType': args.get('sticky'), 'tlsCertificateId': args.get('sslcert') } try: mgr.add_lb_listener(uuid, new_listener) click.secho("Success", fg='green') except SoftLayerAPIError as exception: click.secho("ERROR: {}".format(exception.faultString), fg='red')
def l7pool_add(env, identifier, **args): """Adds a new l7 pool -S is in colon deliminated format to make grouping IP:port:weight a bit easier. """ mgr = SoftLayer.LoadBalancerManager(env.client) uuid, _ = mgr.get_lbaas_uuid_id(identifier) pool_main = { 'name': args.get('name'), 'loadBalancingAlgorithm': args.get('method'), 'protocol': args.get('protocol') } pool_members = list(args.get('server')) pool_health = { 'interval': args.get('healthinterval'), 'timeout': args.get('healthtimeout'), 'maxRetries': args.get('healthretry'), 'urlPath': args.get('healthpath') } pool_sticky = {'type': args.get('sticky')} try: mgr.add_lb_l7_pool(uuid, pool_main, pool_members, pool_health, pool_sticky) click.secho("Success", fg='green') except SoftLayerAPIError as exception: click.secho("ERROR: {}".format(exception.faultString), fg='red')
def add(env, identifier, private, member, weight): """Add a new LBaaS members.""" mgr = SoftLayer.LoadBalancerManager(env.client) uuid, _ = mgr.get_lbaas_uuid_id(identifier) # Get a server ID to add to_add = {"weight": weight} if private: to_add['privateIpAddress'] = member else: to_add['publicIpAddress'] = member try: mgr.add_lb_member(uuid, to_add) click.secho("Member {} added".format(member), fg='green') except SoftLayerAPIError as exception: if 'publicIpAddress must be a string' in exception.faultString: click.secho( "This LB requires a Public IP address for its members and none was supplied", fg='red') elif 'privateIpAddress must be a string' in exception.faultString: click.secho( "This LB requires a Private IP address for its members and none was supplied", fg='red') click.secho("ERROR: {}".format(exception.faultString), fg='red')
def edit(env, identifier, listener, **args): """Updates a listener's configuration. LISTENER should be a UUID, and can be found from `slcli lb detail <IDENTIFIER>` """ mgr = SoftLayer.LoadBalancerManager(env.client) uuid, _ = mgr.get_lbaas_uuid_id(identifier) new_listener = {'listenerUuid': listener} arg_to_option = { 'frontprotocol': 'frontendProtocol', 'backprotocol': 'backendProtocol', 'frontport': 'frontendPort', 'backport': 'backendPort', 'method': 'loadBalancingMethod', 'connections': 'maxConn', 'sticky': 'sessionType', 'sslcert': 'tlsCertificateId' } for arg in args: if args[arg]: new_listener[arg_to_option[arg]] = args[arg] try: mgr.add_lb_listener(uuid, new_listener) click.secho("Success", fg='green') except SoftLayerAPIError as exception: click.secho("ERROR: {}".format(exception.faultString), fg='red')
def execute(self, args): mgr = SoftLayer.LoadBalancerManager(self.client) input_id = args.get('<identifier>') key_value = get_ids(input_id) loadbal_id = int(key_value[0]) service_id = int(key_value[1]) # check if any input is provided if not (args['--ip'] or args['--enabled'] or args['--weight'] or args['--port'] or args['--hc_type']): return 'At least one property is required to be changed!' # check if the IP is valid ip_address_id = None if args['--ip']: ip_address = mgr.get_ip_address(args['--ip']) if not ip_address: return 'Provided IP address is not valid!' else: ip_address_id = ip_address['id'] mgr.edit_service(loadbal_id, service_id, ip_address_id=ip_address_id, enabled=args.get('--enabled'), port=args.get('--port'), weight=args.get('--weight'), hc_type=args.get('--hc_type')) return 'Load balancer service %s is being modified!' % input_id
def order(env, **args): """Creates a LB. Protocols supported are TCP, HTTP, and HTTPS.""" mgr = SoftLayer.LoadBalancerManager(env.client) location = args.get('datacenter') name = args.get('name') description = args.get('label', None) backend = args.get('backend') frontend = args.get('frontend') protocols = [{ "backendPort": backend.get('port'), "backendProtocol": backend.get('protocol'), "frontendPort": frontend.get('port'), "frontendProtocol": frontend.get('protocol'), "loadBalancingMethod": args.get('method'), "maxConn": 1000 }] # remove verify=True to place the order receipt = mgr.order_lbaas(location, name, description, protocols, args.get('subnet'), public=args.get('public'), verify=args.get('verify')) table = parse_receipt(receipt) env.fout(table)
def delete_loadbalancers(resources, client): if 'loadbalancers' not in resources: return lbmgr = SoftLayer.LoadBalancerManager(client) for lb, lbinfo in resources['loadbalancers'].iteritems(): print("deleting loadbalancer {}: {}".format( lb, lbmgr.cancel_lb(lbinfo['id'])))
def cli(env, identifier): """Reset connections on a certain service group.""" mgr = SoftLayer.LoadBalancerManager(env.client) loadbal_id, group_id = loadbal.parse_id(identifier) mgr.reset_service_group(loadbal_id, group_id) return 'Load balancer service group connections are being reset!'
def cli(env, billing_id, datacenter): """Adds a load balancer given the id returned from create-options.""" mgr = SoftLayer.LoadBalancerManager(env.client) if not formatting.confirm("This action will incur charges on your " "account. Continue?"): raise exceptions.CLIAbort('Aborted.') mgr.add_local_lb(billing_id, datacenter=datacenter) env.fout("Load balancer is being created!")
def execute(self, args): mgr = SoftLayer.LoadBalancerManager(self.client) input_id = args.get('<identifier>') key_value = get_ids(input_id) loadbal_id = int(key_value[0]) group_id = int(key_value[1]) mgr.reset_service_group(loadbal_id, group_id) return 'Load balancer service group connections are being reset!'
def execute(self, args): mgr = SoftLayer.LoadBalancerManager(self.client) input_id = args.get('<identifier>') key_value = get_ids(input_id) loadbal_id = int(key_value[1]) load_balancer = mgr.get_local_lb(loadbal_id) return get_local_lb_table(load_balancer)
def cli(env, identifier): """Get Load Balancer as a Service details.""" mgr = SoftLayer.LoadBalancerManager(env.client) _, lbid = mgr.get_lbaas_uuid_id(identifier) this_lb = mgr.get_lb(lbid) if this_lb.get('previousErrorText'): print(this_lb.get('previousErrorText')) table = lbaas_table(this_lb) env.fout(table)
def cli(env): """List active Netscaler devices.""" mgr = SoftLayer.LoadBalancerManager(env.client) netscalers = mgr.get_adcs() if netscalers: adc_table = generate_netscaler_table(netscalers) env.fout(adc_table) else: env.fout("No Netscalers")
def execute(self, args): mgr = SoftLayer.LoadBalancerManager(self.client) input_id = helpers.resolve_id(mgr.resolve_ids, args.get('<identifier>'), 'load_balancer') if not formatting.confirm("This action will incur charges on your " "account. Continue?"): raise exceptions.CLIAbort('Aborted.') mgr.add_local_lb(input_id, datacenter=args['--datacenter']) return "Load balancer is being created!"
def l7pool_del(env, identifier): """Deletes the identified pool Identifier is L7Pool Id. NOT the UUID """ mgr = SoftLayer.LoadBalancerManager(env.client) try: mgr.del_lb_l7_pool(identifier) click.secho("Success", fg='green') except SoftLayerAPIError as exception: click.secho("ERROR: {}".format(exception.faultString), fg='red')
def policies(env, protocol_id): """List policies of the front-end protocol (listener).""" mgr = SoftLayer.LoadBalancerManager(env.client) if protocol_id: l7policies = mgr.get_l7policies(protocol_id) table = generate_l7policies_table(l7policies, protocol_id) else: l7policies = mgr.get_all_l7policies() table = l7policies_table(l7policies) env.fout(table)
def cli(env): """List active Load Balancer as a Service devices.""" mgr = SoftLayer.LoadBalancerManager(env.client) lbaas = mgr.get_lbaas() if lbaas: lbaas_table = generate_lbaas_table(lbaas) env.fout(lbaas_table) else: env.fout("No LBaaS devices found")
def execute(self, args): mgr = SoftLayer.LoadBalancerManager(self.client) routing_types = mgr.get_routing_types() table = formatting.KeyValueTable(['ID', 'Name']) table.align['ID'] = 'l' table.align['Name'] = 'l' table.sortby = 'ID' for routing_type in routing_types: table.add_row([routing_type['id'], routing_type['name']]) return table
def cancel(env, identifier): """Cancels a LBaaS instance""" mgr = SoftLayer.LoadBalancerManager(env.client) uuid, _ = mgr.get_lbaas_uuid_id(identifier) try: mgr.cancel_lbaas(uuid) click.secho("LB {} canceled succesfully.".format(identifier), fg='green') except SoftLayerAPIError as exception: click.secho("ERROR: {}".format(exception.faultString), fg='red')
def cli(env): """List routing types.""" mgr = SoftLayer.LoadBalancerManager(env.client) routing_methods = mgr.get_routing_methods() table = formatting.KeyValueTable(['ID', 'Name']) table.align['ID'] = 'l' table.align['Name'] = 'l' table.sortby = 'ID' for routing_method in routing_methods: table.add_row([routing_method['id'], routing_method['name']]) env.fout(table)
def execute(self, args): mgr = SoftLayer.LoadBalancerManager(self.client) input_id = args.get('<identifier>') key_value = get_ids(input_id) group_id = int(key_value[1]) if args['--really'] or formatting.confirm("This action will cancel a " "service group. Continue?"): mgr.delete_service_group(group_id) return 'Service group %s is being deleted!' % input_id else: raise exceptions.CLIAbort('Aborted.')
def execute(self, args): mgr = SoftLayer.LoadBalancerManager(self.client) input_id = args.get('<identifier>') key_value = get_ids(input_id) loadbal_id = int(key_value[1]) if args['--really'] or formatting.confirm("This action will cancel a " "load balancer. Continue?"): mgr.cancel_lb(loadbal_id) return 'Load Balancer with id %s is being cancelled!' % input_id else: raise exceptions.CLIAbort('Aborted.')
def cli(env, identifier): """Deletes an existing load balancer service.""" mgr = SoftLayer.LoadBalancerManager(env.client) _, service_id = loadbal.parse_id(identifier) if not (env.skip_confirmations or formatting.confirm( "This action will cancel a service from your " "load balancer. Continue?")): raise exceptions.CLIAbort('Aborted.') mgr.delete_service(service_id) return 'Load balancer service %s is being cancelled!' % service_id
def delete(env, identifier, listener): """Removes the listener from identified LBaaS instance LISTENER should be a UUID, and can be found from `slcli lb detail <IDENTIFIER>` """ mgr = SoftLayer.LoadBalancerManager(env.client) uuid, _ = mgr.get_lbaas_uuid_id(identifier) try: mgr.remove_lb_listener(uuid, listener) click.secho("Success", fg='green') except SoftLayerAPIError as exception: click.secho("ERROR: {}".format(exception.faultString), fg='red')
def cli(env, identifier): """Toggle the status of an existing load balancer service.""" mgr = SoftLayer.LoadBalancerManager(env.client) _, service_id = loadbal.parse_id(identifier) if not (env.skip_confirmations or formatting.confirm("This action will toggle the status on the " "service. Continue?")): raise exceptions.CLIAbort('Aborted.') mgr.toggle_service_status(service_id) return 'Load balancer service %s status updated!' % identifier
def cli(env, identifier): """Deletes an existing load balancer service group.""" mgr = SoftLayer.LoadBalancerManager(env.client) _, group_id = loadbal.parse_id(identifier) if not (env.skip_confirmations or formatting.confirm("This action will cancel a service group. " "Continue?")): raise exceptions.CLIAbort('Aborted.') mgr.delete_service_group(group_id) env.fout('Service group %s is being deleted!' % identifier)