def cli(env, identifier, network, speed): """Manage NIC settings.""" mgr = SoftLayer.HardwareManager(env.client) hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware') mgr.change_port_speed(hw_id, network == 'public', int(speed))
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network, tag): """List hardware servers.""" manager = SoftLayer.HardwareManager(env.client) servers = manager.list_hardware(hostname=hostname, domain=domain, cpus=cpu, memory=memory, datacenter=datacenter, nic_speed=network, tags=tag) table = formatting.Table([ 'id', 'hostname', 'primary_ip', 'backend_ip', 'datacenter', 'action', ]) table.sortby = sortby or 'hostname' for server in servers: table.add_row([ utils.lookup(server, 'id'), utils.lookup(server, 'hostname') or formatting.blank(), utils.lookup(server, 'primaryIpAddress') or formatting.blank(), utils.lookup(server, 'primaryBackendIpAddress') or formatting.blank(), utils.lookup(server, 'datacenter', 'name') or formatting.blank(), formatting.active_txn(server), ]) return table
def cli(env, identifier, domain, userfile, tag, hostname, userdata): """Edit hardware details.""" if userdata and userfile: raise exceptions.ArgumentError( '[-u | --userdata] not allowed with [-F | --userfile]') data = { 'hostname': hostname, 'domain': domain, } if userdata: data['userdata'] = userdata elif userfile: with open(userfile, 'r') as userfile_obj: data['userdata'] = userfile_obj.read() if tag: data['tags'] = ','.join(tag) mgr = SoftLayer.HardwareManager(env.client) hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware') if not mgr.edit(hw_id, **data): raise exceptions.CLIAbort("Failed to update hardware")
def get_physical_servers(self): '''Get all the hardware instances''' hw = SoftLayer.HardwareManager(self.client) instances = hw.list_hardware() for instance in instances: self.process_instance(instance, 'hardware')
def cli(env, identifier, start_date, end_date, summary_period, quite_summary): """Bandwidth data over date range. Bandwidth is listed in GB Using just a date might get you times off by 1 hour, use T00:01 to get just the specific days data Timezones can also be included with the YYYY-MM-DDTHH:mm:ss.00000-HH:mm format. Due to some rounding and date alignment details, results here might be slightly different than results in the control portal. Example:: slcli hw bandwidth 1234 -s 2019-05-01T00:01 -e 2019-05-02T00:00:01.00000-12:00 """ hardware = SoftLayer.HardwareManager(env.client) hardware_id = helpers.resolve_id(hardware.resolve_ids, identifier, 'hardware') data = hardware.get_bandwidth_data(hardware_id, start_date, end_date, None, summary_period) title = "Bandwidth Report: %s - %s" % (start_date, end_date) table, sum_table = create_bandwidth_table(data, summary_period, title) env.fout(sum_table) if not quite_summary: env.fout(table)
def on_get(self, req, resp): client = req.env['sl_client'] hardware = SoftLayer.HardwareManager(client) nodes = [] hw_items = set([ 'id', 'hostname', 'domain', 'hardwareStatus', 'globalIdentifier', 'fullyQualifiedDomainName', 'processorPhysicalCoreAmount', 'memoryCapacity', 'primaryBackendIpAddress', 'primaryIpAddress', 'datacenter', ]) server_items = set([ 'activeTransaction[id, transactionStatus[friendlyName,name]]', ]) mask = ('[mask[%s],' ' mask(SoftLayer_Hardware_Server)[%s]]' % (','.join(hw_items), ','.join(server_items))) for hw in hardware.list_hardware(mask=mask): nodes.append({ "uuid": hw['id'], "instance_uuid": hw['id'], # Get the actual power state of every device??? N+1 alert! # "power_state": '', "provision_state": hw['hardwareStatus']['status'], }) resp.body = {'nodes': nodes}
def cli(env, identifier, memory, network, drive_controller, public_bandwidth, add_disk, resize_disk, test): """Upgrade a Hardware Server.""" mgr = SoftLayer.HardwareManager(env.client) if not any([memory, network, drive_controller, public_bandwidth, add_disk, resize_disk]): raise exceptions.ArgumentError("Must provide " " [--memory], [--network], [--drive-controller], [--public-bandwidth]," "[--add-disk] or [--resize-disk]") hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'Hardware') if not test: if not (env.skip_confirmations or formatting.confirm( "This action will incur charges on your account. Continue?")): raise exceptions.CLIAbort('Aborted') disk_list = list() if add_disk: for guest_disk in add_disk: disks = {'description': 'add_disk', 'capacity': guest_disk[0], 'number': guest_disk[1]} disk_list.append(disks) if resize_disk: for guest_disk in resize_disk: disks = {'description': 'resize_disk', 'capacity': guest_disk[0], 'number': guest_disk[1]} disk_list.append(disks) if not mgr.upgrade(hw_id, memory=memory, nic_speed=network, drive_controller=drive_controller, public_bandwidth=public_bandwidth, disk=disk_list, test=test): raise exceptions.CLIAbort('Hardware Server Upgrade Failed') env.fout('Successfully Upgraded.')
def cli(env, title, subject_id, body, hardware_identifier, virtual_identifier, priority): """Create a support ticket.""" ticket_mgr = SoftLayer.TicketManager(env.client) if body is None: body = click.edit('\n\n' + ticket.TEMPLATE_MSG) created_ticket = ticket_mgr.create_ticket(title=title, body=body, subject=subject_id, priority=priority) if hardware_identifier: hardware_mgr = SoftLayer.HardwareManager(env.client) hardware_id = helpers.resolve_id(hardware_mgr.resolve_ids, hardware_identifier, 'hardware') ticket_mgr.attach_hardware(created_ticket['id'], hardware_id) if virtual_identifier: vs_mgr = SoftLayer.VSManager(env.client) vs_id = helpers.resolve_id(vs_mgr.resolve_ids, virtual_identifier, 'VS') ticket_mgr.attach_virtual_server(created_ticket['id'], vs_id) env.fout(ticket.get_ticket_results(ticket_mgr, False, created_ticket['id']))
def execute(self, args): data = {} if args['--userdata'] and args['--userfile']: raise exceptions.ArgumentError( '[-u | --userdata] not allowed with [-F | --userfile]') if args['--userfile']: if not os.path.exists(args['--userfile']): raise exceptions.ArgumentError( 'File does not exist [-u | --userfile] = %s' % args['--userfile']) if args.get('--userdata'): data['userdata'] = args['--userdata'] elif args.get('--userfile'): with open(args['--userfile'], 'r') as userfile: data['userdata'] = userfile.read() data['hostname'] = args.get('--hostname') data['domain'] = args.get('--domain') mgr = SoftLayer.HardwareManager(self.client) hw_id = helpers.resolve_id(mgr.resolve_ids, args.get('<identifier>'), 'hardware') if not mgr.edit(hw_id, **data): raise exceptions.CLIAbort("Failed to update hardware")
def cli(env, identifier): """Get details for a hardware monitors device.""" hardware = SoftLayer.HardwareManager(env.client) table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' monitoring = hardware.get_hardware(identifier) table.add_row(['Domain', monitoring.get('fullyQualifiedDomainName')]) table.add_row(['Public Ip', monitoring.get('primaryIpAddress')]) table.add_row(['Private Ip', monitoring.get('primaryBackendIpAddress')]) table.add_row(['Location', monitoring['datacenter']['longName']]) monitoring_table = formatting.Table( ['Id', 'IpAddress', 'Status', 'Type', 'Notify']) for monitor in monitoring['networkMonitors']: monitoring_table.add_row([ monitor.get('id'), monitor.get('ipAddress'), monitor.get('status'), monitor['queryType']['name'], monitor['responseAction']['actionDescription'] ]) table.add_row(['Devices monitors', monitoring_table]) env.fout(table)
def cli(env, identifier): """Get billing for a hardware device.""" hardware = SoftLayer.HardwareManager(env.client) hardware_id = helpers.resolve_id(hardware.resolve_ids, identifier, 'hardware') result = hardware.get_hardware(hardware_id) table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['Id', identifier]) table.add_row( ['Billing Item Id', utils.lookup(result, 'billingItem', 'id')]) table.add_row( ['Recurring Fee', utils.lookup(result, 'billingItem', 'recurringFee')]) table.add_row([ 'Total', utils.lookup(result, 'billingItem', 'nextInvoiceTotalRecurringAmount') ]) table.add_row([ 'Provision Date', utils.lookup(result, 'billingItem', 'provisionDate') ]) price_table = formatting.Table(['Item', 'Recurring Price']) for item in utils.lookup(result, 'billingItem', 'children') or []: price_table.add_row( [item['description'], item['nextInvoiceTotalRecurringAmount']]) table.add_row(['prices', price_table]) env.fout(table)
def cli(env, **args): """Order/create a dedicated server.""" template.update_with_template_args(args, list_args=['disk', 'key']) mgr = SoftLayer.HardwareManager(env.client) ds_options = mgr.get_dedicated_server_create_options(args['chassis']) order = _process_args(env, args, ds_options) # Do not create hardware server with --test or --export do_create = not (args['export'] or args['test']) output = None if args.get('test'): result = mgr.verify_order(**order) table = formatting.Table(['Item', 'cost']) table.align['Item'] = 'r' table.align['cost'] = 'r' total = 0.0 for price in result['prices']: total += float(price.get('recurringFee', 0.0)) rate = "%.2f" % float(price['recurringFee']) table.add_row([price['item']['description'], rate]) table.add_row(['Total monthly cost', "%.2f" % total]) output = [] output.append(table) output.append( formatting.FormattedItem( '', ' -- ! Prices reflected here are retail and do not ' 'take account level discounts and are not guaranteed.')) if args['export']: export_file = args.pop('export') template.export_to_template(export_file, args, exclude=['wait', 'test']) return 'Successfully exported options to a template file.' if do_create: if env.skip_confirmations or formatting.confirm( "This action will incur charges on your account. " "Continue?"): result = mgr.place_order(**order) table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['id', result['orderId']]) table.add_row(['created', result['orderDate']]) output = table else: raise exceptions.CLIAbort('Aborting dedicated server order.') return output
def cli(env, identifier, enable): """Toggle the IPMI interface on and off""" mgr = SoftLayer.HardwareManager(env.client) hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware') result = env.client['Hardware_Server'].toggleManagementInterface(enable, id=hw_id) env.fout(result)
def get_physical_servers(self): '''Get all the hardware instances''' hw = SoftLayer.HardwareManager(self.client) mask = "mask[%s]" % ','.join(itertools.chain(self.common_items, self.hw_items)) instances = hw.list_hardware(mask=mask) for instance in instances: self.process_instance(instance, 'hardware')
def execute(self, args): public = args['public'] mgr = SoftLayer.HardwareManager(self.client) hw_id = helpers.resolve_id(mgr.resolve_ids, args.get('<identifier>'), 'hardware') mgr.change_port_speed(hw_id, public, args['--speed'])
def cli(env, identifier): """List virtual server credentials.""" hardware = SoftLayer.HardwareManager(env.client) result = hardware.get_hardware(identifier) table = formatting.Table(['username', 'password']) for item in result['operatingSystem']['passwords']: table.add_row([item['username'], item['password']]) return table
def cli(env, identifier, username_storage): """Authorize File or Block Storage to a Hardware Server.""" hardware = SoftLayer.HardwareManager(env.client) hardware_id = helpers.resolve_id(hardware.resolve_ids, identifier, 'hardware') if not hardware.authorize_storage(hardware_id, username_storage): raise exceptions.CLIAbort('Authorize Storage Failed') env.fout('Successfully Storage Added.')
def cli(env, identifier, discrete): """Retrieve a server’s hardware state via its internal sensors.""" mgr = SoftLayer.HardwareManager(env.client) sensors = mgr.get_sensors(identifier) temperature_table = formatting.Table(["Sensor", "Status", "Reading", "Min", "Max"], title='Temperature (c)') volts_table = formatting.Table(["Sensor", "Status", "Reading", "Min", "Max"], title='Volts') watts_table = formatting.Table(["Sensor", "Status", "Reading"], title='Watts') rpm_table = formatting.Table(["Sensor", "Status", "Reading", "Min"], title='RPM') discrete_table = formatting.Table(["Sensor", "Status", "Reading"], title='Discrete') for sensor in sensors: if sensor.get('sensorUnits') == 'degrees C': temperature_table.add_row([sensor.get('sensorId'), sensor.get('status'), sensor.get('sensorReading'), sensor.get('upperNonCritical'), sensor.get('upperCritical')]) if sensor.get('sensorUnits') == 'volts': volts_table.add_row([sensor.get('sensorId'), sensor.get('status'), sensor.get('sensorReading'), sensor.get('lowerNonCritical'), sensor.get('lowerCritical')]) if sensor.get('sensorUnits') == 'Watts': watts_table.add_row([sensor.get('sensorId'), sensor.get('status'), sensor.get('sensorReading')]) if sensor.get('sensorUnits') == 'RPM': rpm_table.add_row([sensor.get('sensorId'), sensor.get('status'), sensor.get('sensorReading'), sensor.get('lowerCritical')]) if sensor.get('sensorUnits') == 'discrete': discrete_table.add_row([sensor.get('sensorId'), sensor.get('status'), sensor.get('sensorReading')]) env.fout(temperature_table) env.fout(rpm_table) env.fout(volts_table) env.fout(watts_table) if discrete: env.fout(discrete_table)
def execute(self, args): mgr = SoftLayer.HardwareManager(self.client) hw_id = helpers.resolve_id(mgr.resolve_ids, args.get('<identifier>'), 'hardware') if args['--really'] or formatting.confirm('This will power off the ' 'server with id %s ' 'Continue?' % hw_id): self.client['Hardware_Server'].powerOff(id=hw_id) else: raise exceptions.CLIAbort('Aborted.')
def cli(env, identifier, immediate, comment, reason): """Cancel a dedicated server.""" mgr = SoftLayer.HardwareManager(env.client) hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware') if not (env.skip_confirmations or formatting.no_going_back(hw_id)): raise exceptions.CLIAbort('Aborted') mgr.cancel_hardware(hw_id, reason, comment, immediate)
def execute(self, args): table = formatting.Table(['Code', 'Reason']) table.align['Code'] = 'r' table.align['Reason'] = 'l' mgr = SoftLayer.HardwareManager(self.client) for code, reason in mgr.get_cancellation_reasons().items(): table.add_row([code, reason]) return table
def cli(env, identifier, wait): """Check if a server is ready.""" compute = SoftLayer.HardwareManager(env.client) compute_id = helpers.resolve_id(compute.resolve_ids, identifier, 'hardware') ready = compute.wait_for_ready(compute_id, wait) if ready: env.fout("READY") else: raise exceptions.CLIAbort("Server %s not ready" % compute_id)
def cli(env, identifier): """Update server firmware.""" mgr = SoftLayer.HardwareManager(env.client) hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware') if not (env.skip_confirmations or formatting.confirm( 'This will power off the server with id %s and ' 'update device firmware. Continue?' % hw_id)): raise exceptions.CLIAbort('Aborted.') mgr.update_firmware(hw_id)
def connect(self, access, authentication_data, region): ''' TBD ''' try: _status = 100 _fmsg = "An error has occurred, but no error message was captured" _username, _api_key, _api_type = authentication_data.split('-') if access.lower().count("private"): self.slconn = SoftLayer.create_client_from_env (username = _username.strip(), \ api_key= _api_key.strip(), \ endpoint_url = SoftLayer.API_PRIVATE_ENDPOINT) else: self.slconn = SoftLayer.create_client_from_env (username = _username.strip(), \ api_key= _api_key.strip(), \ endpoint_url = SoftLayer.API_PUBLIC_ENDPOINT) _resp = self.slconn.call('Account', 'getObject') _datacenters = SoftLayer.VSManager( self.slconn).get_create_options()['datacenters'] for _dcitem in _datacenters: if region == _dcitem['template']['datacenter']['name']: _region = _dcitem['template']['datacenter']['name'] _msg = "Selected region is " + str(region) + " (" + _region + ")" if _api_type.lower().count("baremetal"): self.nodeman = SoftLayer.HardwareManager(self.slconn) else: self.nodeman = SoftLayer.VSManager(self.slconn) self.sshman = SoftLayer.SshKeyManager(self.slconn) self.imageman = SoftLayer.ImageManager(self.slconn) _status = 0 except Exception as msg: _fmsg = str(msg) _status = 23 finally: if _status: _msg = self.get_description() + " connection failure: " + _fmsg cberr(_msg) raise CldOpsException(_msg, _status) else: _msg = self.get_description() + " connection successful." cbdebug(_msg) return _status, _msg, _region
def power_off(env, identifier): """Power off an active server.""" mgr = SoftLayer.HardwareManager(env.client) hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware') if env.skip_confirmations or formatting.confirm('This will power off the ' 'server with id %s ' 'Continue?' % hw_id): env.client['Hardware_Server'].powerOff(id=hw_id) else: raise exceptions.CLIAbort('Aborted.')
def cli(env, identifier): """List virtual server credentials.""" manager = SoftLayer.HardwareManager(env.client) hardware_id = helpers.resolve_id(manager.resolve_ids, identifier, 'hardware') instance = manager.get_hardware(hardware_id) table = formatting.Table(['username', 'password']) for item in instance['operatingSystem']['passwords']: table.add_row([item['username'], item['password']]) env.fout(table)
def power_cycle(env, identifier): """Power cycle a server.""" mgr = SoftLayer.HardwareManager(env.client) hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware') if not (env.skip_confirmations or formatting.confirm('This will power off the server with id %s. ' 'Continue?' % hw_id)): raise exceptions.CLIAbort('Aborted.') env.client['Hardware_Server'].powerCycle(id=hw_id)
def rescue(env, identifier): """Reboot server into a rescue image.""" mgr = SoftLayer.HardwareManager(env.client) hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware') if not (env.skip_confirmations or formatting.confirm( "This action will reboot this server. Continue?")): raise exceptions.CLIAbort('Aborted') env.client['Hardware_Server'].bootToRescueLayer(id=hw_id)
def execute(self, args): table = formatting.Table(['Code', 'Chassis']) table.align['Code'] = 'r' table.align['Chassis'] = 'l' mgr = SoftLayer.HardwareManager(self.client) chassis = mgr.get_available_dedicated_server_packages() for chassis in chassis: table.add_row([chassis[0], chassis[1]]) return table
def execute(self, args): server = SoftLayer.HardwareManager(self.client) server_id = helpers.resolve_id(server.resolve_ids, args.get('<identifier>'), 'hardware') if args['--really'] or formatting.confirm( "This action will reboot this server. " "Continue?"): server.rescue(server_id) else: raise exceptions.CLIAbort('Aborted')