def reboot_server(server_id=LINODE_ID): """ Using the Linode Python Library, reboot the specified server(s) Args: servers: list of ints - The integer ID numbers for servers to reboot Returns: None Raises: ValueError -- if supplied server IDs cannot be changed to integers """ # Make sure server ID is an integer, or is at least convertible to one try: server_id = int(server_id) except ValueError as e: raise e # Connect to Linode client = LinodeClient(LINODE_TOKEN) # Harness my particular server my_server = client.load(Instance, server_id) # Reboot server my_server.reboot()
def reboot_server(): client = LinodeClient(LINODE_TOKEN) # Print out all of the instances on the linode server # for my_linode in client.linode_api4.instances(): # print(f"{linode.label}: {linode.id}") my_server = client.load(Instance, 376715) my_server.reboot()
def __init__(self): self.API_KEY = API_KEY self.client = LinodeClient(API_KEY) self.region = None self.ltype = None self.image = "linode/ubuntu16.04lts" self.stackscript = 68166 self.count = raw_input('How many proxies would you like to make?: ') self.set_region() self.set_type()
def index(): client = LinodeClient('no-token') types = client.linode.types(Type.label.contains("Linode")) regions = client.regions() stackscript = StackScript(client, config.stackscript_id) return render_template('configure.html', types=types, regions=regions, application_name=config.application_name, stackscript=stackscript)
def index(): client = LinodeClient('no-token') types = client.linode.types(Type.label.contains("Linode")) regions = client.regions() stackscript = StackScript(client, config.stackscript_id) return render_template('configure.html', types=types, regions=regions, application_name=config.application_name, stackscript=stackscript )
def get_client(): """ XXX This will get a LinodeClient prepared with an API Token and User-Agent :return: the Linode Client """ return LinodeClient(token=load_token(), user_agent="Cloudify/{}".format(version))
def setUp(self): self.client = LinodeClient('testing', base_url='/') self.get_patch = patch( 'linode_api4.linode_client.requests.Session.get', side_effect=mock_get) self.get_patch.start()
def index(): """ This route renders the main page, where users land when visiting the example site normally. This will present a simple form to deploy a Linode and allow them to submit the forum. """ client = LinodeClient('no-token') types = client.linode.types(Type.label.contains("Linode")) regions = client.regions() stackscript = StackScript(client, config.stackscript_id) return render_template('configure.html', types=types, regions=regions, application_name=config.application_name, stackscript=stackscript )
def test_no_instances_found_with_label_gives_none(default_args, access_token): set_module_args(default_args) module = linode_v4.initialise_module() client = LinodeClient(module.params['access_token']) target = 'linode_api4.linode_client.LinodeGroup.instances' with mock.patch(target, return_value=[]): result = linode_v4.maybe_instance_from_label(module, client) assert result is None
def make_instance(token, type_id, region_id, distribution_id): client = LinodeClient('{}'.format(token)) stackscript = StackScript(client, config.stackscript_id) (linode, password) = client.linode.instance_create(type_id, region_id, group=config.application_name, image=distribution_id, stackscript=stackscript.id) if not linode: raise RuntimeError("it didn't work") return linode, password
def client(self) -> LinodeClient: """Creates a 'client' property that is used to access the Linode API.""" if not self._client: api_token = self.module.params['api_token'] api_version = self.module.params['api_version'] self._client = LinodeClient( api_token, base_url='https://api.linode.com/{0}'.format(api_version), user_agent=COLLECTION_USER_AGENT, ) return self._client
def create_instance(): client = LinodeClient(DEPLOY['api_key']) linode_server, root_password = client.linode.instance_create( 'g6-dedicated-2', 'us-central', image='linode/arch', label=DEPLOY['name'] ) print(crayons.green(f'[+] Created new Linode instance "{linode_server.label}"!')) if DEBUG: print('[!] IP:', linode_server.ipv4[0]) print('[!] RP:', root_password) return (linode_server, linode_server.ipv4[0], root_password)
class NewProxy(): def __init__(self): self.API_KEY = API_KEY self.client = LinodeClient(API_KEY) self.region = None self.ltype = None self.image = "linode/ubuntu16.04lts" self.stackscript = 68166 self.count = raw_input('How many proxies would you like to make?: ') self.set_region() self.set_type() def set_region(self): region_list = self.client.regions() for i in range(len(region_list)): print('{} {}'.format(i, region_list[i])) r = input('Please select an available region: ') self.region = region_list[r] def set_type(self): type_list = self.client.linode.types() for i in range(len(type_list)): print('{} {}'.format(i, type_list[i])) t = input('Please select an available linode type: ') self.ltype = type_list[t] def create_linodes(self): for i in range(int(self.count)): new_linode, password = self.client.linode.instance_create( self.ltype, self.region, image=self.image, stackscript=self.stackscript, stackscript_data={ "squid_user":"******".format(AUTH_USER), "squid_password":"******".format(AUTH_PASS) } ) print('Creating Proxy {}...'.format(new_linode.ipv4[0])) with open('LINODE PROXY LIST.txt', 'a+') as f: f.write('{}:{}:{}:{}\n'.format( new_linode.ipv4[0], 3128, AUTH_USER, AUTH_PASS )) with open('LINODE PROXY PASSWORDS.txt', 'a+') as f: f.write('{} \t{}\n'.format(new_linode.ipv4[0], password))
def linode_client(args, vars, env=environ): try: from linode_api4 import LinodeClient except ImportError: raise AnsibleError(u'could not import linode_api4 module') at = args.get( 'access_token', vars.get('linode_access_token', env.get('LINODE_ACCESS_TOKEN', None))) if at is None: raise AnsibleError(u'could not resolve linode access token') user_agent = 'Ansible-linode_api4/%s' % ansible_version return LinodeClient(at, user_agent=user_agent)
def _build_client(self) -> None: """Build the Linode client.""" api_token = self.get_option('api_token') if api_token is None: try: api_token = os.environ['LINODE_API_TOKEN'] except KeyError: pass if api_token is None: raise AnsibleError(('Could not retrieve Linode API Token ' 'from plugin configuration or environment')) self.client = LinodeClient(api_token, user_agent=COLLECTION_USER_AGENT)
def _build_client(self): """Build the Linode client.""" access_token = self.get_option('access_token') if access_token is None: try: access_token = os.environ['LINODE_ACCESS_TOKEN'] except KeyError: pass if access_token is None: raise AnsibleError(('Could not retrieve Linode access token ' 'from plugin configuration or environment')) self.client = LinodeClient(access_token)
def test_instance_by_label_cannot_authenticate(capfd, access_token, default_args): set_module_args(default_args) module = linode_v4.initialise_module() client = LinodeClient(module.params['access_token']) target = 'linode_api4.linode_client.LinodeGroup.instances' with mock.patch(target, side_effect=LinodeApiError('foo')): with pytest.raises(SystemExit): linode_v4.maybe_instance_from_label(module, client) out, err = capfd.readouterr() results = json.loads(out) assert results['failed'] is True assert 'Unable to query the Linode API' in results['msg']
def main(): agent_label = os.environ['AGENT_NAME'] key = os.getenv("LINODE_API_KEY") if key is None: raise RuntimeError("please specify Linode API key") client = LinodeClient(key) def destroy(linode): linode.delete() #client.linode_delete(LinodeID = linode[u'LINODEID'], skipChecks = 1) linodes = client.linode.instances() #logging.info("linodes: {}".format(linodes)) with closing(ThreadPool(5)) as pool: agent = filter(lambda linode: linode.label == agent_label, linodes) pool.map(destroy, agent) pool.close() pool.join()
def _build_client(self, loader): """Build the Linode client.""" t = Templar(loader=loader) access_token = self.get_option('access_token') if t.is_template(access_token): access_token = t.template(variable=access_token, disable_lookups=False) if access_token is None: try: access_token = os.environ['LINODE_ACCESS_TOKEN'] except KeyError: pass if access_token is None: raise AnsibleError(('Could not retrieve Linode access token ' 'from plugin configuration or environment')) self.client = LinodeClient(access_token)
def _client(): return LinodeClient("{}".format(LINODE_PAT))
from os.path import join, dirname """ Set current working directory to repository root. """ os.chdir(join(dirname(__file__), '..')) """ Load linode API key from dotenv file """ from dotenv import load_dotenv load_dotenv('.env') LINODE_API_KEY = os.environ.get("LINODE_API_KEY") """ Instantiate linode API client with key """ from linode_api4 import LinodeClient # type: ignore client = LinodeClient(LINODE_API_KEY) """ Print available linode types, regions, and images """ # ltypes = client.linode.types() # regions = client.regions() # images = client.images() # for ltype in ltypes: # print(ltype) # for region in regions: # print(region) # for image in images: # print(image) class DesiredLinode:
def reboot_server(): #function to reboot server when it is down client = LinodeClient(LINODE_TOKEN) #connecting to our linode server with token my_server = client.load(Instance, 376715) #opening a particular instance of our server my_server.reboot() logging.info('Attempting to reboot server...')
for ss in stackscripts: if ss.label == basename: stackscript = ss break if not stackscript: print("ERROR: no appropriate stackscript found") exit(1) return (stackscript) # we don't care about sysargv[0], the invoked command name args = parse_args(sys.argv[1:]) config = load_config(args['config_file']) client = LinodeClient(config['api_token']) stackscript = get_stackscript(config['stackscript_label'], client) for vm in config['virtual_machines']: # Instance_create() returns the newly-created Instance object and the root # password that was generated for it. This Instance will boot automatically, # and should be available shortly. try: new_linode, password = client.linode.instance_create( vm['size'], vm['region'], vm['image'], stackscript=stackscript, stackscript_data={ "GIT_REPO": config['git_repo'], "GIT_BRANCH": config['git_branch'],
- name: Reboot a server linode: api_key: 'longStringFromLinodeApi' name: linode-test1 linode_id: "{{ linode_creation.instance.id }}" state: restarted delegate_to: localhost ''' import os import time try: from linode_api4 import LinodeClient LINODE_CLIENT = LinodeClient('') HAS_LINODE = True except ImportError: HAS_LINODE = False from ansible.module_utils.basic import AnsibleModule def randompass(): ''' Generate a long random password that comply to Linode requirements ''' # Linode API currently requires the following: # It must contain at least two of these four character classes: # lower case letters - upper case letters - numbers - punctuation # we play it safe :)
import sys import json from linode_api4 import LinodeClient, Instance client = LinodeClient(sys.argv[1]) ipv4 = [] ipv6 = [] private = [] for instance_id in sys.argv[2:]: instance = client.load(Instance, instance_id) ipv4.append(instance.ips.ipv4.public[0].address) ipv6.append(instance.ips.ipv6.slaac.address) private.append(instance.ips.ipv4.private[0].address) print(json.dumps({'ipv4': ','.join(ipv4), 'ipv6': ','.join(ipv6), 'private': ','.join(private)}))
#!/usr/local/bin/python3 from linode_api4 import LinodeClient, Image import config token = input("Please provide an OAuth Token: ") client = LinodeClient(token) s = client.linode.stackscript_create('Demonstration_Public', '#!/bin/bash', client.images(Image.is_public == True), is_public=True) print("StackScript created, use this ID: {}".format(s.id))
def reboot_server(): client =LinodeClient(LINODE_TOKEN) server=client.load(Instance, <>) server.reboot()
def build_client(module): """Build a LinodeClient.""" return LinodeClient(module.params['access_token'], user_agent=get_user_agent('linode_v4_module'))
def main(): """ Main func for automatic vulnerability scan by Tenable.io of Company GCP and Cloudflare resources :return: none """ parser = argparse.ArgumentParser(description='Provide all arguments for successful Vulnerability scan') parser.add_argument("-all", dest="tg_all", action="store_true", help="Scan All supported infrastructures") parser.add_argument("-cloudflare", dest="tg_cloudflare", action="store_true", help="Scan GCP infrastructure") parser.add_argument("-gcp", dest="tg_gcp", action="store_true", help="Scan Cloudflare infrastructure") parser.add_argument("-aws", dest="tg_aws", action="store_true", help="Scan AWS infrastructures") parser.add_argument("-linode", dest="tg_linode", action="store_true", help="Scan Linode infrastructures") parser.add_argument("-others", dest="tg_others", action="store_true", help="Scan rest of SaaS: DO, Linode, etc") parser.add_argument("-schedule", dest="tg_schedule", action="store_true", help="Schedule scans by Tenable.io") parser.set_defaults(tg_all=False) parser.set_defaults(tg_cloudflare=False) parser.set_defaults(tg_gcp=False) parser.set_defaults(tg_aws=False) parser.set_defaults(tg_linode=False) parser.set_defaults(tg_others=False) parser.set_defaults(tg_schedule=False) args = parser.parse_args() # Create dirs gen.create_dirs() # Set configuration file location main_script_abs = os.path.dirname(os.path.abspath(__file__)) settings_obj = configparser.ConfigParser() settings_obj.read(main_script_abs + '/conf/conf.cfg') # Initiate an instance of TenableIOClient. settings = settings_obj._sections.copy() tenable_client = TenableIOClient(access_key=settings['TENABLE.IO']['access_key'], secret_key=settings['TENABLE.IO']['secret_key']) logger.info('Successfully authenticated to Tenable.io') # Set scheduled scan time scan_time = datetime.now() # Set time delta if you need to launch scanning job right now if not args.tg_schedule: for section in settings.keys(): if 'time_delta' in settings[section].keys(): settings[section]['time_delta'] = 0 # Launch scan jobs in Tenable.io against GCP resources if args.tg_gcp or args.tg_all: # Set GCP credentials environment logger.info('Parsing google credentials and set ENV variables') gcp_api_key_json = settings_obj.get('GCP', 'gcp-api-key-json') # Set Service account env variable and form path to json file os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = main_script_abs + gcp_api_key_json # Configure credentials for Google API authentication credentials = GoogleCredentials.get_application_default() compute = discovery.build('compute', 'v1', credentials=credentials) sql = discovery.build('sqladmin', 'v1beta4', credentials=credentials) logger.info('Successfully authenticated to GCP services') # Get list of all projects via GCP Resource manager resource_client = resource_manager.Client() projects_list = list(resource_client.list_projects()) logger.info('Successfully extracted list GCP projects and public IP addresses') # Retrieve all GCP organization public IP address target_ip_addresses = gcp.get_organization_public_ip(compute, sql, projects_list) # # In case you need to read from local copy of saved projects # target_ip_addresses = gen.read_json_file('json/20181006T104414-gcp_addresses.json') logger.info('Trying to create scan jobs in Tenable.io for all GCP projects') # Launch scan against GCP resources scan_time = tnb.create_tenable_scan(scan_target='TENABLE_GCP_SCAN', client=tenable_client, target=target_ip_addresses, settings=settings, logger=logger, scan_time=scan_time) logger.info('Successfully created scan jobs in Tenable.io') if args.tg_cloudflare or args.tg_all: # Parse CF credentials environment logger.info('Parsing Cloudflare credentials') cf_email = settings_obj.get('CLOUDFLARE', 'cf_email') cf_api_key = settings_obj.get('CLOUDFLARE', 'cf_api_key') # Create Cloudflare connection object cf_client = CloudFlare.CloudFlare(email=cf_email, token=cf_api_key) # Create targets for scanning job target_hostnames = cf.get_cf_website_dns(cf_client=cf_client) # # Test purposes (comment please when test will be finished) # target_hostnames = gen.read_json_file('json/20181005T185623-cf_addresses.json') # scan_time += timedelta(hours=90) cf.create_firewall_access_rule(cf_client=cf_client, settings=settings, zones=target_hostnames) scan_time = tnb.create_tenable_scan(scan_target='TENABLE_CF_SCAN', client=tenable_client, target=target_hostnames, settings=settings, logger=logger, scan_time=scan_time) if args.tg_aws or args.tg_all: # Create Cloudflare connection object target_assets = aws.get_tenables_assets(client=tenable_client) scan_time = tnb.create_tenable_scan(scan_target='TENABLE_AWS_SCAN', client=tenable_client, target=target_assets, settings=settings, logger=logger, scan_time=scan_time) if args.tg_linode or args.tg_all: # Get Linode targets linode_client = LinodeClient(settings['LINODE']['lin_api_key']) linode_targets = lin.get_linode_targets(client=linode_client) scan_time = tnb.create_tenable_scan(scan_target='TENABLE_LINODE_SCAN', client=tenable_client, target=linode_targets, settings=settings, logger=logger, scan_time=scan_time) if args.tg_others or args.tg_all: # Launch scan of Other targets target_assets = others.prepare_other_targets(settings['TENABLE_OTHERS_SCAN']) scan_time = tnb.create_tenable_scan(scan_target='TENABLE_OTHERS_SCAN', client=tenable_client, target=target_assets, settings=settings, logger=logger, scan_time=scan_time) logger.info('Vulnerability scan will be finished at {0}'.format(scan_time.strftime('%Y%m%dT%H%M%S'))) logger.info('######################################## END ########################################')
def reboot_server(): client = LinodeClient(LINODE_TOKEN) my_server = client.load(Instance, 376715) my_server.reboot()
for service in device.services: if service.find_action("GetExternalIPAddress"): external_ips.append( service.GetExternalIPAddress()["NewExternalIPAddress"]) if len(external_ips) < 1: raise Exception("Found no external IP addresses") if len(external_ips) > 1: raise Exception("Found more than one external IP address") external_ip = external_ips[0] # Find our domain and record linode_client = LinodeClient(config["token"]) for domain in linode_client.domains(): if domain.domain != domain_name: continue for record in domain.records: if record.name == subdomain_name: record.target = external_ip record.save() break else: domain.record_create(record_type="A", name=subdomain_name, target=external_ip)
#!/usr/local/bin/python3 from linode_api4 import LinodeClient, Image import config token = input("Please provide an OAuth Token: ") client = LinodeClient(token) s = client.linode.stackscript_create('Demonstration_Public', '#!/bin/bash', client.images(Image.is_public==True), is_public=True) print("StackScript created, use this ID: {}".format(s.id))