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 test_update_volumes_data(self):
droplet_response = self.load_from_file('droplets/single.json')
volume_response = self.load_from_file('volumes/single.json')
url_droplet =self.base_url + "droplets/12345"
url_volume = self.base_url + "volumes/506f78a4-e098-11e5-ad9f-000f53306ae1"
responses.add(responses.GET,
url_droplet,
body=droplet_response,
status=200,
content_type='application/json')
responses.add(responses.GET,
url_volume,
body=volume_response,
status=200,
content_type='application/json')
droplet = digitalocean.Droplet(id='12345', token=self.token)
d = droplet.load()
d.update_volumes_data()
self.assert_get_url_equal(responses.calls[0].request.url, url_droplet)
self.assert_get_url_equal(responses.calls[1].request.url, url_volume)
self.assertEqual(len(d.volumes), 1)
self.assertEqual(d.volumes[0].id, '506f78a4-e098-11e5-ad9f-000f53306ae1')
self.assertEqual(d.volumes[0].name, 'example')
self.assertEqual(d.volumes[0].region['slug'], 'nyc1')
def create_droplet(self,
droplet,
backend_region_id=None,
backend_image_id=None,
backend_size_id=None,
ssh_key_uuid=None):
if ssh_key_uuid:
ssh_key = SshPublicKey.objects.get(uuid=ssh_key_uuid)
backend_ssh_key = self.get_or_create_ssh_key(ssh_key)
droplet.key_name = ssh_key.name
droplet.key_fingerprint = ssh_key.fingerprint
backend_droplet = digitalocean.Droplet(
token=self.manager.token,
name=droplet.name,
user_data=droplet.user_data,
region=backend_region_id,
image=backend_image_id,
size_slug=backend_size_id,
ssh_keys=[backend_ssh_key.id] if ssh_key_uuid else [])
backend_droplet.create()
action_id = backend_droplet.action_ids[-1]
droplet.backend_id = backend_droplet.id
droplet.save()
return action_id
def create_droplet(my_token, template_id, username, tags, user_data):
# type: (str, str, str, List[str], str) -> str
droplet = digitalocean.Droplet(token=my_token,
name='{0}.zulipdev.org'.format(username),
region='nyc3',
image=template_id,
size_slug='2gb',
user_data=user_data,
tags=tags,
backups=False)
print("Initiating droplet creation...")
droplet.create()
incomplete = True
while incomplete:
actions = droplet.get_actions()
for action in actions:
action.load()
print("...[{0}]: {1}".format(action.type, action.status))
if action.type == 'create' and action.status == 'completed':
incomplete = False
break
if incomplete:
time.sleep(15)
print("...droplet created!")
droplet.load()
print("...ip address for new droplet is: {0}.".format(droplet.ip_address))
return droplet.ip_address
def create_from_snapshot(self, snapshot):
account_keys = self.manager.get_all_sshkeys()
config_keys = self.config.get("ssh_keys")
if config_keys:
keys = [
key.id for key in account_keys if key.public_key in config_keys
]
else:
keys = [key.id for key in account_keys]
my_droplets = self.manager.get_all_droplets()
for drop in my_droplets:
assert drop.name != self.name, "Droplet already exists"
new_droplet = digitalocean.Droplet(
name=self.name,
size=self.config.get("size", "s-1vcpu-1gb"),
image=snapshot.id,
region=self.config.get("region", "nyc3"),
ssh_keys=keys,
monitoring=True,
token=self.token,
tags=[self.name],
)
print(f"Creating droplet from snapshot {snapshot.id}")
new_droplet.create()
self.droplet = new_droplet
def droplet_create_from_latest_snapshot(manager, api_key, image_base_name,
size_slug, region):
my_droplet = get_curr_droplet(manager, image_base_name)
if my_droplet is None:
valheim_snap = get_newest_snap(manager, image_base_name)
assert valheim_snap, (
f'could not find snapshot matching {image_base_name}')
print(f'No droplet running, creating one '
f'from snapshot {valheim_snap.name}')
my_droplet = digitalocean.Droplet(token=api_key,
name=valheim_snap.name,
region=region,
image=valheim_snap.id,
size_slug=size_slug,
backups=False,
monitoring=True,
ssh_keys=manager.get_all_sshkeys())
my_droplet.create()
# this function is a generator of status messages, and will
# raise an error if it exceeds the maximum wait time.
for status_msg in wait_for_active_droplet(my_droplet):
print(status_msg)
else:
print(f'Droplet already exists at {my_droplet.ip_address}')
for status_msg in wait_for_active_droplet(my_droplet):
print(status_msg)
print('Droplet is ready, you can now start the valheim server.')
def test_load(self):
data = self.load_from_file('droplets/single.json')
responses.add(responses.GET,
self.base_url + "droplets/12345",
body=data,
status=200,
content_type='application/json')
droplet = digitalocean.Droplet(id='12345', token=self.token)
d = droplet.load()
self.assertEqual(responses.calls[0].request.url,
self.base_url + "droplets/12345")
self.assertEqual(d.id, 12345)
self.assertEqual(d.name, "example.com")
self.assertEqual(d.memory, 512)
self.assertEqual(d.vcpus, 1)
self.assertEqual(d.disk, 20)
self.assertEqual(d.backups, False)
self.assertEqual(d.ipv6, True)
self.assertEqual(d.private_networking, False)
self.assertEqual(d.region['slug'], "nyc3")
self.assertEqual(d.status, "active")
self.assertEqual(d.image['slug'], "ubuntu-14-04-x64")
self.assertEqual(d.size_slug, '512mb')
self.assertEqual(d.created_at, "2014-11-14T16:36:31Z")
self.assertEqual(d.ip_address, "104.131.186.241")
self.assertEqual(d.ip_v6_address,
"2604:A880:0800:0010:0000:0000:031D:2001")
self.assertEqual(d.kernel['id'], 2233)
self.assertEqual(d.features, ["ipv6", "virtio"])
self.assertEqual(d.tags, [])
def create_droplet(domain):
droplet = digitalocean.Droplet(
token=token,
name=domain,
region='nyc3', # New York 3
image=os.environ['DIGITALOCEAN_DEFAULT_IMAGE'],
size_slug='512mb', # 512MB
backups=False
)
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(self, name, wait=False):
# Check volumes exist
volumes = self.get_data_volumes(name)
if not volumes:
raise RuntimeError("No volumes exist for host %s" % name)
dconf = self.hosts[name]
print "Creating droplet %s (region %s)" % (name, dconf['region'])
droplet = digitalocean.Droplet(
token = self.token,
name = name,
region = dconf['region'],
size_slug = dconf['size'],
image = dconf['image'],
ssh_keys = self.ssh_keys,
backups = False,
ipv6 = False,
private_networking = False,
user_data = self.cloud_config(name),
)
droplet.create()
done = False
while not done:
actions = droplet.get_actions()
for action in actions:
# can we use action.wait()?
action.load()
# Once it shows complete, droplet is up and running
print " ...%s" % action.status
done = action.status == "completed"
self.attach_data_volumes(droplet)
print "Host %s ip address %s" % \
(name, self.get_ip_addr(name)) # Side-effect: cache IP
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, 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 test_create_no_keys(self):
data = self.load_from_file('droplet_actions/create.json')
responses.add(responses.POST, self.base_url + "droplets",
body=data,
status=202,
content_type='application/json')
droplet = digitalocean.Droplet(name="example.com",
size_slug="512mb",
image="ubuntu-14-04-x64",
region="nyc3",
backups=True,
ipv6=True,
private_networking=True,
user_data="Some user data.",
token=self.token)
droplet.create()
self.assert_url_query_equal(responses.calls[0].request.url,
self.base_url + "droplets")
self.maxDiff = None
self.assertEqual(
json.loads(responses.calls[0].request.body),
{u"name": u"example.com", u"region": u"nyc3",
u"user_data": u"Some user data.", u"ipv6": True,
u"private_networking": True, u"backups": True,
u"image": u"ubuntu-14-04-x64", u"size": u"512mb", u"ssh_keys": []})
self.assertEqual(droplet.id, 3164494)
self.assertEqual(droplet.action_ids, [36805096])
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 create_droplet(self):
if frappe.db.count(
"Deployer Instance") + 1 > self.deployer_config.max_instances:
self.set_pull_request_status(
"Maximum number of concurrently active instances reached",
"error")
self.destroy_instance(error=True)
return
self.instance_name = '-'.join([
self.application_being_tested, "PR",
str(self.pull_request_number), self.instance_requested_by
])
self.get_manager()
self.droplet = digitalocean.Droplet(
token=get_decrypted_password("Deployer Config",
self.deployer_config.name,
"do_token"),
name=self.instance_name,
size=self.parameters.get('droplet_size'),
region="blr1",
ssh_keys=self.manager.get_all_sshkeys(),
image=self.deployer_config.snapshot_id)
self.droplet.create()
while True:
action = self.droplet.get_actions()[0]
if (action.type, action.status) == ('create', 'completed'):
break
sleep(10)
self.droplet = self.manager.get_droplet(self.droplet.id)
self.instance_url = self.droplet.ip_address
self.droplet_id = self.droplet.id
self.is_active = True
self.instance_created_at = frappe.utils.now()
self.save(ignore_permissions=True)
return True
def restore_droplet(snapshot,
keys,
api_key,
region='nyc1',
size_slug='2gb',
name='starbound-server',
backups=False):
print "Pushing snapshot {} to a fresh droplet".format(snapshot)
droplet = digitalocean.Droplet(token=api_key,
name=name,
ssh_keys=keys,
region=region,
image=snapshot,
size_slug=size_slug,
backups=backups)
# Create the Droplet and wait for it to complete
droplet.create()
action = digitalocean.Action(id=droplet.action_ids[0],
token=droplet.token,
droplet_id=droplet.id)
action.load()
action.wait()
created = droplet.load()
print "Droplet Created at {}".format(droplet.ip_address)
def getDroplets(self, hosts):
retValue = {}
droplets = self.manager.get_all_droplets()
for h, v in hosts.items():
if hosts[h]['enabled']:
for droplet in droplets:
if droplet.name == h:
retValue[droplet.name] = droplet
if h not in retValue:
for curkey in self.manager.get_all_sshkeys():
if curkey.name == v['sshkey']:
sshkey = curkey
continue
droplet = digitalocean.Droplet(
token=self.apikey,
name=h,
region=v['region'],
image=v['image'],
size_slug=v['size_slug'],
ssh_keys=[sshkey],
monitoring=True,
backups=False,
)
retValue[h] = droplet
return retValue
def create_droplet(self):
if self.checking_droplet() is True:
self.ip_address = self.fetching_ip_address()
self.start_installation()
else:
self.keys = self.manager.get_all_sshkeys()
print("Creating the droplet")
try:
droplet = digitalocean.Droplet(token=self.api_key,
name=self.droplet_name,
region='nyc1', # New York 2
image='centos-7-x64', # Ubuntu 14.04 x64
size_slug='512mb',
ssh_keys=self.keys,# 512MB
backups=False,
tags=self.droplet_tag_name
)
droplet.create()
time.sleep(30)
print("----Droplet Created--------")
print('Ip_address of ' + self.droplet_name + ' Tag name is ' + self.tag + ' ' + self.fetching_ip_address())
self.droplet_tag_name.clear()
self.ip_address=self.fetching_ip_address()
print("-------Droplet Created---------")
time.sleep(4)
logging.info("Starting installation")
#self.start_installation()
self.start_installation()
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 create_droplet(branch, githash):
user_data = open(startup_script).read()
# use all keys registered at digitalocean
keys = get_manager().get_all_sshkeys()
setenvs = []
for var, value in read_environemnt().items():
assert var.replace('_', '').isalnum()
export = '{var}=$(cat <<-{eof}\n{value}\n{eof}\n)'.format(
value=value, var=var, eof=uuid4().hex)
setenvs.append(export)
user_data = expand_config_vars(
user_data, {
'GITHASH': githash,
'BRANCH': branch,
'SETENVS': ' '.join(setenvs),
'STARTUP': read_startup()
})
droplet = digitalocean.Droplet(
token=config['DIGITAL_OCEAN_TOKEN'],
name='{}{}--{}'.format(NAME_PREFIX, githash, branch),
region='fra1',
image='docker-20-04',
size_slug='s-2vcpu-4gb',
user_data=user_data,
ssh_keys=keys, # Automatic conversion
backups=False)
droplet.create()
return droplet
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 create_vpn(self, args):
keys = self.manager.get_all_sshkeys()
vpn_name = "vpn-{0}".format(self.date)
self.vpn_user_data = self.generate_user_data(
args.gmail_user, args.gmail_user_password,
args.gmail_notify_email_list)
vpn = digitalocean.Droplet(
token=self.token,
tags=[vpn_name],
region=args.do_region,
name=vpn_name,
size_slug=args.do_size,
image="ubuntu-18-04-x64",
ssh_keys=keys,
backups=False,
ipv6=True,
user_data=self.vpn_user_data,
private_networking=False,
)
vpn.create()
print("Created VPN: {0}. Please wait for email.".format(vpn_name))
def do_newfromimage(self, image_id):
if self.manager:
if len(image_id) > 1:
sizes = self.manager.get_all_sizes()
for i, j in enumerate(sizes):
print("{0} - {1}, per month: ${2}".format(
i, j.slug.upper(), j.price_monthly))
print(colored("X - Exit", "red"))
response = input("Choice:")
if response.upper() == "X":
print_log("Cancelled.", "info")
try:
image = self.manager.get_image(image_id)
import random
droplet = digitalocean.Droplet(
token=self.uniqueKey,
name=image.name,
region=random.choice(image.regions),
image=image.id,
size_slug=sizes[int(response)].slug)
droplet.create()
print_log("Droplet creation initiated successfully!",
"success")
except DataReadError as err:
print_log(err, "error")
else:
print_log("Please enter a image id!", "error")
else:
print_log("Login first!", "error")
def resurrect(self, size=1, image=None, ssh_keys=None):
version = self.next_version_number()
tag = api.Tag(token=self.token, name=self.name)
tag.create() # create tag if not already created
result = []
for _ in range(0, size):
server = api.Droplet(token=self.token,
name=f"{self.name}{version}",
region='ams3',
size='s-1vcpu-1gb',
private_networking=True,
ipv6=True,
backups=False,
ssh_keys=ssh_keys or settings.DO_SSH_KEYS,
image=image or settings.DO_OBJECT_IMAGE
# tags=[tag],
)
r = server.create()
if r or r is None:
tag.add_droplets([str(server.id)])
result.append((server, r))
version = version + 1
return result
async def create_vm(self):
self.droplet = digitalocean.Droplet(
token=self.config.get("token"),
name=self.name,
region=self.region,
image=self.image,
size_slug=self.size,
backups=False,
user_data=self.cluster.render_cloud_init(
image=self.docker_image,
command=self.command,
gpu_instance=self.gpu_instance,
bootstrap=self.bootstrap,
env_vars=self.env_vars,
),
)
await self.cluster.call_async(self.droplet.create)
for action in self.droplet.get_actions():
while action.status != "completed":
action.load()
await asyncio.sleep(0.1)
while self.droplet.ip_address is None:
await self.cluster.call_async(self.droplet.load)
await asyncio.sleep(0.1)
self.cluster._log(f"Created droplet {self.name}")
return self.droplet.ip_address
def make_droplet(name, region, image, size, backups=0, ssh_key=0):
token = get_token()
key_list = []
if backups == 0:
backups = False
elif backups == 1:
backups = True
else:
backups == False
if int(ssh_key) != 0:
key_list.append(int(ssh_key))
try:
droplet = digitalocean.Droplet(token=token,
name=name,
region=region,
image=image,
size=size,
backups=backups,
ssh_keys=key_list)
droplet.create()
droplet = get_droplet(str(droplet).split(" ")[0])
return droplet
except Exception as e:
message = "Failed to create droplet, DO API responded: %s" % str(
e.args)
create_log(message, 3)
def startServer(self):
print("starting..")
# get latest snapshot, with given prefix
snapshot = self.__fetchSnapshot(self.prefix)
keys = self.manager.get_all_sshkeys()
#print(self.manager.get_all_regions())
# create droplet based on it
droplet = digitalocean.Droplet(
token=self.manager.token,
name=self.prefix + "DROPLET-" + self.__getTimeString(),
region='fra1', # Frankfurt
# https://www.digitalocean.com/community/questions/create-droplet-from-snapshot-by-rest-api
image=snapshot.id, # current latest snapshot
size_slug='s-2vcpu-4gb', # 1GB RAM, 1 vCPU
ssh_keys=keys, # Automatic conversion
backups=False)
droplet.create()
# delete snapshot
snapshot.destroy()
pass
def createServer():
print "Creating a new remote server in %s..." % (region)
keys = manager.get_all_sshkeys()
droplet = digitalocean.Droplet(token=apiToken,
name='vpnServer',
region=region,
image='ubuntu-16-04-x64',
size_slug='512mb',
ssh_keys=keys,
backups=False)
droplet.create()
actions = droplet.get_actions()
print droplet
print droplet.name
print droplet.ip_address
setup = False
print actions
for action in actions:
setUp = action.wait()
if setUp:
droplet.load()
ip_address = droplet.ip_address
print "Remote server was created. IP Address: " + ip_address
return ip_address
else:
print "Remote server could not be created."
return 0
def create_srv(team_name, cloud_config="", is_admin=False, max_retries=3, current_try=1):
keys = manager.get_all_sshkeys()
droplet = digitalocean.Droplet(
token=token,
name=f"{team_name}-{random.choice(words)}",
image=random.choice(possible_images),
region=DEF_REGION,
size_slug='512mb',
user_data=cloud_config,
backups=BACKUPS_ENABLED,
keys=keys if is_admin else []
)
droplet.create()
actions = droplet.get_actions()
active = False
while not active:
for action in actions:
action.load()
if action.status == "completed":
active = True
time.sleep(2)
if rkn_logic.is_it_blocked(droplet.ip_address):
droplet.destroy()
if current_try <= max_retries:
return create_srv(team_name, current_try=current_try + 1)
raise RecursionError('Max retries reached')
return droplet
def create_droplet(my_token: str, template_id: str, name: str, tags: List[str],
user_data: str) -> str:
droplet = digitalocean.Droplet(
token=my_token,
name=name,
region="nyc3",
image=template_id,
size_slug="s-1vcpu-2gb",
user_data=user_data,
tags=tags,
backups=False,
)
print("Initiating droplet creation...")
droplet.create()
incomplete = True
while incomplete:
actions = droplet.get_actions()
for action in actions:
action.load()
print(f"...[{action.type}]: {action.status}")
if action.type == "create" and action.status == "completed":
incomplete = False
break
if incomplete:
time.sleep(15)
print("...droplet created!")
droplet.load()
print(f"...ip address for new droplet is: {droplet.ip_address}.")
return droplet.ip_address
def drip(self, name, do_region, do_image_slug, do_size_slug,
do_ssh_key_names):
# FIXME: this should propably work like _manipulate_dns, recreating droplets when they exist
droplet = digitalocean.Droplet(
token=self.do_token,
name=name,
region=do_region,
image=do_image_slug,
size_slug=do_size_slug,
backups=False,
ipv6=True,
private_networking=True,
ssh_keys=self._get_ssh_keys_by_names(do_ssh_key_names))
self._logger.info('droplet %s: creating...', name)
droplet.create()
self._logger.info('droplet %s: id: %s', name, droplet.id)
while not (droplet.ip_address and droplet.ip_v6_address):
time.sleep(1)
self._logger.info('droplet %s: waiting for ip addresses', name)
droplet.load()
self._logger.info('droplet %s: ips: %s, %s, %s', name,
droplet.ip_address, droplet.ip_v6_address,
droplet.private_ip_address.lower())
return droplet
