def remove_all_droplets(): manager = digitalocean.Manager(token=token) my_droplets = manager.get_all_droplets() for droplet in my_droplets: if droplet.name in droplets_to_remove: droplet.destroy() print(f"Droplet {droplet.name} destroyed")
def setUp(self): super(TestBaseAPI, self).setUp() self.manager = digitalocean.Manager(token=self.token) self.user_agent = "{0}/{1} {2}/{3}".format('python-digitalocean', digitalocean.__version__, requests.__name__, requests.__version__)
def build_context(args): context = args if 'token' not in context: context['token'] = os.environ.get('DO_TOKEN') manager = digitalocean.Manager(token=context['token']) my_droplets = manager.get_all_droplets() mydrop = [_ for _ in my_droplets if _.ip_address == get_ip_address()][0] context['droplet_id'] = mydrop.id context['droplet'] = mydrop context['volume_name'] = mydrop.name + '-volume' context['volume_directory'] = '/mnt/' + context['volume_name'] context['volume'] = digitalocean.Volume( token= context['token'], name= context['volume_name'], region= context['droplet_region'], size_gigabytes= context['volume_size_gbs'] ) context['user'] = os.environ.get('USER') if 'sudo_password' not in context: context['sudo_password'] = os.environ.get('SUDO') return context
def up(): manager = digitalocean.Manager(token=token) keys = manager.get_all_sshkeys() for name in ubuntu: droplet = digitalocean.Droplet( token=token, name=name, region="sfo2", image="ubuntu-18-04-x64", size_slug="s-2vcpu-2gb", ssh_keys=keys, backups=False, ) droplet.create() for name in centos: droplet = digitalocean.Droplet( token=token, name=name, region="sfo2", image="centos-7-x64", size_slug="s-2vcpu-2gb", ssh_keys=keys, backups=False, ) droplet.create()
def build_context(args): ''' This creates a dictionary of variables we'll be using throughout the script. args are from parse_args ''' context = args currentdate = datetime.datetime.now().strftime("%Y-%m-%d") currentyear = datetime.datetime.now().strftime("%Y") currentmonth = datetime.datetime.now().strftime("%m") input_filename = os.path.basename(context['s3_input']) output_base = context['filebase'] + '__' + currentdate + '__' + \ input_filename.replace('.csv', '.json') # digital ocean if not context['token']: context['token'] = os.environ.get('DO_TOKEN') manager = digitalocean.Manager(token=context['token']) my_droplets = manager.get_all_droplets() vols = manager.get_all_volumes() mydrop = [_ for _ in my_droplets if _.ip_address == get_ip_address()][0] context['droplet'] = mydrop context['droplet_id'] = mydrop.id context['droplet_region'] = mydrop.region['slug'] context['volume_name'] = mydrop.name + '-volume' context['volume_directory'] = '/mnt/' + context['volume_name'] # AWS s3 if 's3://' not in context['s3_input']: raise "Improperly formatted -s3 or --s3-input flag" context['input'] = download_from_s3(context['s3_input'], new_dir='pylogs/') context['auth'] = 'pylogs/{}__{}__tokens.json'.format( mydrop.id, currentdate) context['s3_bucket'] = s3.get_bucket(context['s3_input']) context['s3_key'] = context['s3_input'].split('input/')[0] context['s3_path'] = os.path.join(context['s3_key'], 'output/user_friends/', currentyear, currentmonth, output_base + '.bz2') context['s3_log'] = os.path.join('s3://' + context['s3_bucket'], 'logs', output_base.replace('.json', '.log')) context['s3_log_done'] = os.path.join(context['s3_key'], 'logs/user_friends/', currentyear, currentmonth, output_base.replace('.json', '.log')) context['s3_auth'] = os.path.join('s3://' + context['s3_bucket'], 'tokens/used', os.path.basename(context['auth'])) # local stuff context['user'] = os.environ.get('USER') if not context['sudo_password']: context['sudo_password'] = os.environ.get('SUDO') context['output'] = os.path.join(context['volume_directory'], output_base) context['log'] = os.path.join(context['volume_directory'], output_base.replace('.json', '.log')) return context
def create(confg): # Create manager with token. manager = digitalocean.Manager(token=TOKEN) # Create droplet droplet = create_droplet(manager=manager, name=config.name) logger.success('droplet status: {}', get_droplet_status(droplet))
def weights(config): manager = digitalocean.Manager(token=TOKEN) droplets = manager.get_all_droplets(tag_name=[TAG]) if config.names == None: config.names = [droplet.name for droplet in droplets] meta = bittensor.metagraph.Metagraph() console = Console() meta.load() meta.sync() meta.save() for name in config.names: wallet = bittensor.wallet.Wallet(name=TAG, hotkey=name) if wallet.has_hotkey: try: uid_i = meta.hotkeys.index(wallet.hotkey.public_key) weights = meta.W[uid_i, :] # Chain weights column. chain_weight_cols_vals = ['[blue]{}[/blue]: '.format(name)] for uid_j, weight in enumerate(weights.tolist()): if weight != 0: chain_weight_cols_vals.append( '[bold white frame]{} [dim green frame]{:.3}'. format(uid_j, weight)) chain_weight_columns = Columns(chain_weight_cols_vals, equal=True, expand=True) console.print(chain_weight_columns) except Exception as e: logger.exception(e)
def spinupServer(token, ssh_key, verbose): # DO NOT RUN WITHOUT MY PERMISSION, THIS IS A PAID SERVICE, always close server when done # ask DigitalOcean.com to provision a server (d for droplet) snaps = digitalocean.Manager(token = pytoken).get_my_images() d = digitalocean.Droplet(token=pytoken, name='test'+token, region= 'nyc3', image= "ubuntu-16-04-x64", #Ubuntu 16.04.1 x64 #manager = digitalocean.Manager(token = pytoken) #manager.get_all_images() size_slug='1gb', ssh_keys = [ssh_key.id], backups=True) d.create() while True: d.load() if d.ip_address!=None: print("Bucking up and starting engines...") sys.stdout.flush() break while True: if "completed" in str(d.get_actions()[0].status): break if len(snaps) != 0: d.rebuild(int(snaps[0].id)) return d
def test(jsFilePath='app.js', pyFilePath='seleniumTest.py', py2FilePath='test2.parth', verbose = True, name = '', key = ''): # ssh key get -- the key will work with the local files, do /not/ make new ones (aka, no ssh-keygen) ssh_key = digitalocean.Manager(token = pytoken).get_all_sshkeys()[0] # there should only be one # provision server then set it up and run code t0 = time.time() d = spinupServer("AJS", ssh_key, verbose) out, errors, ip = runSetup(d.ip_address, ssh_key, jsFilePath, pyFilePath, py2FilePath, verbose, name, key) '''try: raw_input('To close server press ENTER') except: input('To close server press ENTER')''' timeAJS = time.time()-t0 # input('press enter, ip = '+str(ip)) # destroy server and print operating cost (usually negligible) # playing with snapshots, this works in creating one called test # d.power_off() # d.take_snapshot("test") # d.power_on() #print(d.get_snapshots()) #sys.stdout.flush() closeServer(d) # print('$'+str(round(.03*timeAJS/60/60,2))) # how much cash you owe me return {'out': out, 'errors': errors}
def _create_droplet(public_key, world_name=''): key_name = 'hungcat-mc-ctl-' + public_key[-7:] droplet_name = 'minecraft-{}'.format(world_name) manager = digitalocean.Manager(token=DIGITALOCEAN_API_TOKEN) all_droplets = manager.get_all_droplets() existing_droplets = filter(lambda droplet: droplet.name == droplet_name, all_droplets) minecraft_droplet = None if len(existing_droplets) == 0: keys = manager.get_all_sshkeys() if len(filter(lambda k: k.name == key_name, keys)) == 0: key = digitalocean.SSHKey(token=DIGITALOCEAN_API_TOKEN, name=key_name, public_key=public_key) key.create() keys.append(key) droplet = digitalocean.Droplet(token=DIGITALOCEAN_API_TOKEN, name=droplet_name, region= DIGITALOCEAN_REGION_SLUG if DIGITALOCEAN_REGION_SLUG is not None else 'sgp1', image='docker-18-04', size_slug='2gb', ssh_keys=keys, backups=False) droplet.create() minecraft_droplet = manager.get_droplet(droplet.id) else: minecraft_droplet = existing_droplets[0] return minecraft_droplet
def create_droplet(domain): manager = digitalocean.Manager(token=token) key = manager.get_ssh_key(sshkey) droplet = digitalocean.Droplet( token=token, name=domain, region='ams2', # Amsterdam 2 image=os.environ['DIGITALOCEAN_DEFAULT_IMAGE'], slug='centos7-2gb-1468403002394', size_slug='2gb', backups=False, ssh_keys=[key]) droplet.create() actions = droplet.get_actions() status = '' while True: for action in actions: action.load() # Once it shows complete, droplet is up and running status = action.status print('Droplet creating status .. ' + status) if status == 'completed': break if status == 'completed': break else: time.sleep(2) return droplet
def _create_droplet(public_key): key_name = 'minecraft-lambda-function-' + public_key[-7:] manager = digitalocean.Manager(token=DIGITALOCEAN_API_TOKEN) all_droplets = manager.get_all_droplets() existing_droplets = filter(lambda droplet: droplet.name == "minecraft", all_droplets) minecraft_droplet = None if len(existing_droplets) == 0: keys = manager.get_all_sshkeys() if len(filter(lambda k: k.name == key_name, keys)) == 0: key = digitalocean.SSHKey(token=DIGITALOCEAN_API_TOKEN, name=key_name, public_key=public_key) key.create() keys.append(key) droplet = digitalocean.Droplet( token=DIGITALOCEAN_API_TOKEN, name="minecraft", region=DIGITALOCEAN_REGION_SLUG if DIGITALOCEAN_REGION_SLUG is not None else "sgp1", image="docker-18-04", size_slug="2gb", ssh_keys=keys, backups=False) droplet.create() minecraft_droplet = manager.get_droplet(droplet.id) else: minecraft_droplet = existing_droplets[0] return minecraft_droplet
def __init__(self): super().__init__() self.token = self.config['do']['token'] self.manager = digitalocean.Manager(token=self.token) self.tag = 'PhD' self._base_output_dir = self.get_base_output_dir() self._ssh_connections = {}
def show_droplets(token, tag=None): manager = digitalocean.Manager(token=token) my_droplets = manager.get_all_droplets(tag_name=tag) for droplet in my_droplets: print('Droplet id: {}'.format(droplet.id)) print('Droplet name: {}'.format(droplet.name)) print('Droplet ip: {}'.format(droplet.ip_address))
def __init__(self,droplet_name,tag_name,api_key): self.api_key = api_key self.manager = digitalocean.Manager(token=self.api_key) self.droplet_tag_name = [] self.droplet_name=droplet_name self.tag = tag_name self.droplet_tag_name.append(tag_name)
def create_do_droplet(config): status={"command":"create_do_droplet","status":False,"message":"FALSE","droplet":None} # Time it takes to build a Droplet time_to_build = 80 manager = digitalocean.Manager(token=config['token']) droplet = digitalocean.Droplet(token=config['token'], name=config['name'], region=config['region'], image=config['image'], size_slug=config['size'], backups=config['backups'], ipv6=config['ipv6'], ssh_keys=config['ssh_keys'], tags=config['tags'] ) try: droplet.create() except digitalocean.DataReadError as e: status['message']=e return status except digitalocean.Error as e: status['message']=e return status # Sleep for time_to_build time.sleep(time_to_build) newDroplet = manager.get_droplet(droplet.id) status['status']=True status['message']="Droplet Created" status['droplet']=newDroplet return status
def upload_world(): manager = digitalocean.Manager(token=DIGITALOCEAN_API_TOKEN) all_droplets = manager.get_all_droplets() droplet = filter(lambda droplet: droplet.name == "minecraft", all_droplets)[0] private_key = _get_ssh_private_key() client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) _ssh_connect(client, hostname=droplet.ip_address, username="******", pkey=private_key) commands = [ "cd /root", "docker cp minecraft:/data/world ./", "apt install -y zip", "zip -r world.zip world" ] _exec_commands(client, commands) sftp = client.open_sftp() sftp.get("/root/world.zip", "/tmp/world.zip") s3 = boto3.resource("s3") bucket = s3.Bucket(S3_BUCKET_NAME) obj = bucket.Object("world.zip") obj.put(Body=open("/tmp/world.zip", "rb")) obj.Acl().put(ACL="public-read") bucket_location = boto3.client("s3").get_bucket_location(Bucket=S3_BUCKET_NAME)["LocationConstraint"] world_path = "https://s3-%s.amazonaws.com/%s/world.zip" % (bucket_location, S3_BUCKET_NAME) message = ":rocket: Uploaded world.zip: " + world_path return message
def list_do_ssh_keys(): manager = digitalocean.Manager(token=my_token) ssh_keys = manager.get_all_sshkeys() print "" for key in ssh_keys: print "ssh key: ", key print ""
def droplet_with_name(name: str): manager = digitalocean.Manager(token=TOKEN) droplets = manager.get_all_droplets(tag_name=[TAG]) for droplet in droplets: if droplet.name == name: return droplet return None
def __init__(self, digitalocean_token, github_personal_access_token, snapshot_name, floating_ip): self.digitalocean_token = digitalocean_token self.snapshot_name = snapshot_name self.floating_ip = floating_ip self.github_personal_access_token = github_personal_access_token self.manager = digitalocean.Manager(token=self.digitalocean_token) # 1. Determine if an existing Droplet is running. # If so, we'll need to cleanup and shut it down once the new stack is up. self.old_droplet = self.getRunningDroplet() # 2. Create a new droplet using our stack's standard config self.new_droplet = self.createDroplet() # 3. Poll Digital Ocean until the droplet has started up successfully self.waitForDropletToBootUp(self.new_droplet) # 4. Poll until our Dockerised stack inside the droplet has started up succesfully self.waitForDockerStackToStartUp(self.new_droplet) # 5. Switch our Floating IP to the new droplet self.switchFloatingIP(self.new_droplet) # 6. Cleanup and destroy our old droplet # self.old_droplet = [d for d in self.manager.get_all_droplets() if d.name.startswith("scremsong-stack-foobar")][0] if self.old_droplet is not None: self.shutdownOldDroplet(self.old_droplet)
def droplets(): manager = digitalocean.Manager(token=token) droplets = manager.get_all_droplets() for droplet in droplets: print(droplet.ip_address) print(droplet.name) print("\n")
def __init__(self): if len(sys.argv) != 2: digitalOceanManager.printUsage() else: # init do-API self.manager = digitalocean.Manager(token=token.get("API_KEY")) # check if at least one droplet is running self.dropletRunning = self.__countDropletsWithPrefix( self.prefix) > 0 if sys.argv[1] == "start": if self.dropletRunning: print("Droplet is already running, no need to start it") else: self.startServer() elif sys.argv[1] == "stop": if not self.dropletRunning: print("Droplet isn't running, can't be stopped") else: self.stopServer() else: digitalOceanManager.printUsage() pass
def get_droplet_count(self): manager = digitalocean.Manager(token=self.ocean_dependency.token) number = 0 my_droplets = manager.get_all_droplets() for droplet in my_droplets: number += 1 return number
async def stream_status(message): try: manager = digio.Manager(token=config.digital_ocean_api_key()) droplet, statuses = DropletApi.check_single_droplet_status( manager, config.default_tag_name()) status_names = ",".join([s.status for s in statuses]) default_stream_key = config.default_stream_key() use_stream_key_line = default_stream_key is not "{stream key}" stream_key_line = "" if use_stream_key_line: stream_key_line = "stream key for publishing is '{}'\n".format( default_stream_key) await client.send_message(message.channel, "droplet {0} exists at ip {1}, \n" \ "stream publish url is rtmp://{1}:1935/publish?publish_key={{publish key}}\n" \ "{5}" \ "stream play url is rtmp://{1}:1935/live/{4}?play_key={3}\n" \ "droplet's last status(es) are {2}" .format(droplet.name, droplet.ip_address, status_names, config.stream_play_key(), default_stream_key, stream_key_line)) except MissingDropletException: await client.send_message( message.channel, "Stream is currently off, turn it on first! (!turn on stream)") pass
def get_digital_data(file_object): manager = digitalocean.Manager(token=DIGITAL_OCEAN_TOKEN) my_droplets = manager.get_all_droplets() context = {} context['droplet_details'] = [] for droplet in my_droplets: details = {} details['features'] = droplet.networks details['memory'] = droplet.memory details['created_at'] = droplet.created_at details['region'] = droplet.region details['size'] = droplet.size details['total_space'] = droplet.disk details['total_size'] = droplet.size context['droplet_details'].append(details) context['file_size'] = file_object.size best_droplet, best_droplet_index = get_best_droplet( my_droplets, size_in_mb(file_object.size)) context['best_droplet'] = best_droplet context['best_droplet_index'] = best_droplet_index return context
def get_do_manager(access_token): """ Helper function for initializing `digitalocean.Manager` instance :param access_token: Digital Ocean access token :type access_token: str :returns: Digital Ocean manager instance :rtype: digitalocean.Manager :raises click.ClickException: when the token isn't passed or is incorrect """ token = access_token or os.getenv(DO_ACCESS_TOKEN_ENV) if not token: raise click.ClickException( "You need to either pass your Digital Ocean access token explicitly ('-t ...') " "or set is as an environment variable ('export {DO_ACCESS_TOKEN_ENV}=...')." .format(DO_ACCESS_TOKEN_ENV=DO_ACCESS_TOKEN_ENV, )) try: manager = digitalocean.Manager(token=token) manager.get_account() # To make sure we're authenticated except digitalocean.Error as e: raise click.ClickException( "We were unable to connect to your Digital Ocean account: '{}'". format(e)) return manager
def down(): manager = digitalocean.Manager(token=token) my_droplets = manager.get_all_droplets() for droplet in my_droplets: if droplet.name in names: print('destroying droplet:{}'.format(droplet.name)) droplet.destroy()
def get_droplet_status(droplet_id, project_id): manager = digitalocean.Manager(token=DO_TOKEN) droplet = manager.get_droplet(id) if droplet.status == 'active': pass else: get_droplet_status.delay(droplet_id, project_id, countdown=60)
def __init__(self, access_token): """Initialize the Digital Ocean connection.""" import digitalocean self._access_token = access_token self.data = None self.manager = digitalocean.Manager(token=self._access_token)
def call_cron_droplet_update(self): token = self._token() if token is False: return False manager = digitalocean.Manager(token=token) droplet_list = manager.get_all_droplets() self._sincro_droplet(droplet_list)