def loadKey(keyName, keyFile):
keyValue = open(keyFile).read().strip()
sshKey = digitalocean.SSHKey(token=doApiToken)
sshKey.load_by_pub_key(keyValue)
if not sshKey.fingerprint:
print "Creating key: %s" % keyName
sshKey = digitalocean.SSHKey(token=doApiToken,
public_key=keyValue,
name=keyName)
sshKey.create()
else:
print "Key already exists: %s" % keyName
return sshKey
def _create_ssh_keys(manager: digitalocean.Manager) -> List[digitalocean.SSHKey]:
"""
Upload a ssh public key to Digital Ocean, if not already loaded.
If it is already loaded, then just get the id.
:return: List of SSHkey objects.
"""
registered_keys = manager.get_all_sshkeys()
ssh_keys = []
print('Registering SSH keys...')
print('Known keys:')
print('\n'.join([key.name for key in registered_keys]))
key = DIGITAL_OCEAN_PUBLIC_KEY
print(f'Checking key: {key}')
with open(os.path.join(SSH_PATH, f"{key}")) as file:
public_key = file.read().rstrip('\n')
registered = [rkey for rkey in registered_keys if rkey.public_key == public_key]
for rkey in registered_keys:
if rkey.public_key == public_key:
ssh_keys.append(registered[0])
print(
f'SSH key {key} verified already registered as '
f'{registered[0].name}.')
break
else:
key = digitalocean.SSHKey(
name=key,
public_key=public_key,
token=DIGITAL_OCEAN_TOKEN,
)
key.create()
ssh_keys.append(key)
print(f'SSH key {key} has now been registered with name {key.name}')
return ssh_keys
def create_ssh_key(name: str, public_key: str) -> digitalocean.SSHKey:
action_public_ssh_key_object = digitalocean.SSHKey(name=name,
public_key=public_key,
token=manager.token)
set_api_request_retry_limits(action_public_ssh_key_object)
action_public_ssh_key_object.create()
return action_public_ssh_key_object
def push_ssh_key(self, ssh_key):
backend_ssh_key = digitalocean.SSHKey(token=self.manager.token,
name=ssh_key.name,
public_key=ssh_key.public_key)
backend_ssh_key.create()
return backend_ssh_key
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(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 pull_ssh_key(self, name, fingerprint):
backend_ssh_key = digitalocean.SSHKey(
token=self.manager.token, fingerprint=fingerprint, name=name, id=None
)
backend_ssh_key.load()
return backend_ssh_key
def _create_ssh_key(self):
""" Creates a new SSH key """
self._ssh_key = digitalocean.SSHKey(
token=settings.DIGITALOCEAN_API_TOKEN,
name=settings.APP_NAME,
public_key=self.public_key,
)
self._ssh_key.create()
return self._ssh_key
def __add_ssh_key_to_digitalocean(self):
print('Adding public key {} to DigitalOcean'.format(self.keyname))
# check for existing key, and delete
for key in self.manager.get_all_sshkeys():
if key.name == self.keyname:
key.destroy()
key = digitalocean.SSHKey(token=os.getenv('DO_TOKEN'),
name=self.keyname,
public_key=self.pubkey)
key.create()
def create_ssh_key(self, name: str, public_key_content: str) -> str:
ssh_key_data = {
'name': name,
'public_key': public_key_content
}
ssh_key = digitalocean.SSHKey(
token=self.api_token,
**ssh_key_data
)
ssh_key.create()
return ssh_key.id
def _generate_ssh_key(self):
self._print_info('generating ssh key')
self.ssh_key = paramiko.rsakey.RSAKey.generate(2048, str(uuid.uuid4()))
self._print_info('create ssh key on DigitalOcean')
self.digital_ocean_ssh_key = digitalocean.SSHKey(
token=self.token,
name=SSH_KEY_NAME,
public_key='ssh-rsa {key}'.format(
key=str(self.ssh_key.get_base64())))
self.digital_ocean_ssh_key.create()
def add_key(api_token):
data_path = ansible_data.playbook_path()
public_key = open(data_path + '/env/ssh_key.pub').read()
key = digitalocean.SSHKey(token=api_token,
name='VPN-Deployer',
public_key=public_key)
key.create()
with open(data_path + '/env/ssh_key.id', 'w+') as f:
f.write(str(key.id))
return key.id
def get_ssh_key_id(self, key):
"""
Get the DigitalOcean ID for the SSH key. If the SSH key hasn't been
uploaded to DigitalOcean, upload it.
"""
if key.digitalocean_id:
return key.digitalocean_id
else:
new_do_key = digitalocean.SSHKey(token=self._token,
name='minecraftserver',
public_key=key.public_key)
new_do_key.create()
key.digitalocean_id = new_do_key.id
key.save(update_fields=['digitalocean_id'])
return new_do_key.id
def __init__(self, username):
"""
Generate a keypair for the specified username.
username : string
>>> key = SshKeypair('Bob')
>>> key.username == 'Bob' and type(key.pemFilePathnameAsStr) == str and type(key.doSshKey) == digitalocean.SSHKey
True
"""
super(SshKeypair, self).__init__()
self.writeToDisk(passPhrase="")
publicKey = self.publicKeyOpensshAsBytes.decode('utf-8')
self.username = username
self.doSshKey = digitalocean.SSHKey()
self.doSshKey.token = getApiToken()
self.doSshKey.public_key = publicKey
self.doSshKey.name = os.path.basename(self.pemFilePathnameAsStr)
self.doSshKey.create()
def __init__(self, key_name='key'):
tmp_dir = tempfile.TemporaryDirectory()
self._persist_tmp_dir = tmp_dir
tmp_path = Path(tmp_dir.name)
prv_key_path = tmp_path / key_name
self.prv_key_pathstr = prv_key_path.as_posix()
cmd = [
'ssh-keygen', '-t', 'ed25519', '-a', '123', '-f',
self.prv_key_pathstr, '-C', 'VPN', '-N', ''
]
subprocess.check_output(cmd)
pub_key_path = tmp_path / (key_name + '.pub')
pub_key_path.chmod(0o600)
pub_key = pub_key_path.open().read()
pub_do_key = do.SSHKey(token=token, name=key_name, public_key=pub_key)
pub_do_key.create()
self.pub_do_key = pub_do_key
def deploy(
self,
sshkey=None,
region="Amsterdam 3",
image="ubuntu 18.04",
size_slug="s-1vcpu-2gb",
delete=True,
project_name=None,
):
"""
Deploy your Droplet to Digital Ocean
Args
sshkey (string): sshkey name used on digital ocean (if not set it will use the default one which already loaded)
region (string): region name to deploy to
image (string): Image name to be used
size_slug (string): size of the droplet (s-1vcpu-2gb,s-6vcpu-16gb,gd-8vcpu-32gb)
delete (bool): delete the droplet if it is already deployed on digital ocean
project_name (string): project to add this droplet it. If not specified the default project will be used.
"""
project = None
if project_name:
project = self.parent.projects.get_project_exist_remote(project_name)
if not project:
raise j.exceptions.Input("could not find project with name:%s" % project_name)
# Get ssh
if not sshkey:
sshkey_do = self.parent.get_default_sshkey()
if not sshkey_do:
# means we did not find the sshkey on digital ocean yet, need to create
sshkey = self.parent.sshkey
key = digitalocean.SSHKey(
token=self.parent.projects.parent_instance.token, name=sshkey.name, public_key=sshkey.public_key
)
key.create()
sshkey_do = self.parent.get_default_sshkey()
assert sshkey_do
sshkey = sshkey_do.name
if self.parent.droplets.check_droplet_exist_remote(self.do_name):
dr0 = self.parent.droplets.get_droplet_exist_remote(self.do_name)
if delete:
dr0.destroy()
else:
sshcl = j.clients.sshclient.get(name="do_%s" % self.do_name, host=dr0.ip_address, sshkey=sshkey)
return dr0, sshcl
sshkey = self.parent.droplets.parent_instance.get_sshkey(sshkey)
region = self.parent.droplets.parent_instance.get_region(region)
imagedo = self.parent.droplets.parent_instance.get_image(image)
img_slug_or_id = imagedo.slug if imagedo.slug else imagedo.id
droplet = digitalocean.Droplet(
token=self.parent.droplets.parent_instance.token,
name=self.do_name,
region=region.slug,
image=img_slug_or_id,
size_slug=size_slug,
ssh_keys=[sshkey],
backups=False,
)
droplet.create()
if project:
project.assign_resources(["do:droplet:%s" % droplet.id])
def droplet_create(
self,
name="test",
sshkey=None,
region="Amsterdam 3",
image="ubuntu 18.04",
size_slug="s-1vcpu-2gb",
delete=True,
project_name=None,
):
"""
:param name:
:param sshkey:
:param region:
:param image:
:param size_slug: s-1vcpu-2gb,s-6vcpu-16gb,gd-8vcpu-32gb
:param delete:
:param mosh: when mosh will be used to improve ssh experience
:param project_name: project to add this droplet it. If not specified the default project will be used.
:return: droplet,sshclient
"""
project = None
if project_name:
project = self._project_get(project_name)
if not project:
raise j.exceptions.Input("could not find project with name:%s" % project_name)
delete = j.data.types.bool.clean(delete)
sshkey = j.data.types.string.clean(sshkey)
if not sshkey:
sshkey_do = self._sshkey_get_default()
if not sshkey_do:
sshkey_ = j.clients.sshkey.default
# means we did not find the sshkey on digital ocean yet, need to create
key = digitalocean.SSHKey(token=self.token_, name=sshkey_.name, public_key=sshkey_.pubkey)
key.create()
sshkey_do = self._sshkey_get_default()
assert sshkey_do
sshkey = sshkey_do.name
if self.droplet_exists(name):
dr0 = self._droplet_get(name=name)
if delete:
dr0.destroy()
else:
sshcl = j.clients.ssh.get(name="do_%s" % name, addr=dr0.ip_address, sshkey_name=sshkey)
sshcl.save()
return dr0, sshcl
sshkey = self.sshkey_get(sshkey)
region = self.region_get(region)
imagedo = self.image_get(image)
if region.slug not in imagedo.regions:
j.shell()
img_slug_or_id = imagedo.slug if imagedo.slug else imagedo.id
droplet = digitalocean.Droplet(
token=self.token_,
name=name,
region=region.slug,
image=img_slug_or_id,
size_slug=size_slug,
ssh_keys=[sshkey],
backups=False,
)
droplet.create()
# dr = self.get(name=name)
# dr.do_id = droplet.id
self._droplets.append(droplet)
self.reset()
if project:
project.assign_resources(["do:droplet:%s" % droplet.id])
vm = self._vm_get(name)
vm.do_id = droplet.id
self.save()
def actions_wait():
while True:
actions = droplet.get_actions()
if len(actions) == 0:
return
for action in actions:
action.load()
# Once it shows complete, droplet is up and running
print(action.status)
if action.status == "completed":
return
actions_wait()
droplet.load()
sshcl = j.clients.ssh.get(name="do_%s" % name, addr=droplet.ip_address, sshkey_name=sshkey.name)
sshcl.save()
return droplet, sshcl
'Failed to put droplet ' + str(droplet.name) +
' up. Timeout (' + str(timeout) + 'ms).', 'timeout'))
token = env('DEPLOY_API_TOKEN')
if token is None:
raise EnvironmentError(
log.err('Environment variable DEPLOY_API_TOKEN is empty.'))
public_key = env('PUBLIC_KEY')
if public_key is None:
raise EnvironmentError(
log.err('Environment variable PUBLIC_KEY is empty.'))
key_name = env('KEY_NAME', public_key.split()[-1])
ssh_key = digitalocean.SSHKey(token=token).load_by_pub_key(public_key)
if ssh_key is None:
ssh_key = digitalocean.SSHKey(token=token)
ssh_key.name = key_name
ssh_key.public_key = public_key
ssh_key.create()
droplet_name = env('AZK_MID', 'azk-deploy')
droplet_name = env('BOX_NAME', droplet_name)
droplet_region = env('BOX_REGION', 'nyc3')
droplet_image = env('BOX_IMAGE', 'ubuntu-14-04-x64')
droplet_size = env('BOX_SIZE', '1gb')
droplet_backup = True if env('BOX_BACKUP', 'false') == 'true' else None
droplet_private_networking = True if env('BOX_PRIVATE_NETWORKING',
'false') == 'true' else None
