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)
