def import_key_pair_from_string(self, name, key_material):
key_pair = KeyPair(name=name,
public_key=key_material,
fingerprint='fingerprint',
private_key='private_key',
driver=self)
return key_pair
def _to_key_pair(self, data):
key_pair = KeyPair(name=data['name'],
fingerprint=data['fingerprint'],
public_key=data.get('value', None),
private_key=data.get('privatekey', None),
driver=self, extra={'id': data['id']})
return key_pair
def _to_key_pair(self, data):
try:
pubkey = data['ssh_pub_key']
except KeyError:
pubkey = None
return KeyPair(data['name'], public_key=pubkey, fingerprint=None,
driver=self, private_key=None, extra={'id': data['id']})
def _to_key_pair(self, data):
extra = {'id': data['id']}
return KeyPair(name=data['name'],
fingerprint=data['fingerprint'],
public_key=data['public_key'],
private_key=None,
driver=self,
extra=extra)
def _to_key_pair(self, elem):
key_pair = KeyPair(name=elem['label'],
public_key=elem['key'],
fingerprint=elem['fingerprint'],
private_key=elem.get('private', None),
driver=self,
extra={'id': elem['id']})
return key_pair
def get_key_pair(self, name):
try:
key_material = self.key_pairs[name]
except KeyError:
raise KeyPairDoesNotExistError(name, self)
return KeyPair(name, key_material,
get_key_fingerprint(parse_openssh_pubkey(key_material)),
self)
def _to_key_pair(self, data):
extra = {'created_at': data['created_at'],
'updated_at': data['updated_at']}
return KeyPair(name=data['id'],
fingerprint=None,
public_key=data['key'],
private_key=None,
driver=self,
extra=extra)
def import_key_pair_from_string(self, name, key_material):
key_pair = KeyPair(
name=name,
public_key=key_material,
fingerprint="fingerprint",
private_key="private_key",
driver=self,
)
return key_pair
def _to_key_pair(self, key_pair):
private_key = ""
if "PrivateKey" in key_pair:
private_key = key_pair["PrivateKey"]
return KeyPair(name=key_pair["KeypairName"],
public_key="",
private_key=private_key,
fingerprint=key_pair["KeypairFingerprint"],
driver=self)
def _to_key_pair(self, data):
extra = {"id": data["id"]}
return KeyPair(
name=data["name"],
fingerprint=data["fingerprint"],
public_key=data["public_key"],
private_key=None,
driver=self,
extra=extra,
)
def _to_key_pair(self, elem):
key_pair = KeyPair(
name=elem["label"],
public_key=elem["key"],
fingerprint=elem["fingerprint"],
private_key=elem.get("private", None),
driver=self,
extra={"id": elem["id"]},
)
return key_pair
def _to_key_pair(self, data):
key_pair = KeyPair(
name=data["name"],
fingerprint=data["fingerprint"],
public_key=data.get("value", None),
private_key=data.get("privatekey", None),
driver=self,
extra={"id": data["id"]},
)
return key_pair
def _ssh_public_key_to_key_pair(self, ssh_public_key, name=None):
key_type, key_content, key_name = self._parse_ssh_public_key(ssh_public_key)
public_key_name = name if name else key_name
public_key = '{} {} {}'.format(key_type, key_content, public_key_name)
return KeyPair(name=public_key_name,
public_key=public_key,
fingerprint=None,
driver=self,
extra={'public_key_type': key_type,
'public_key_content': key_content})
def _to_key_pair(self, data):
extra = {
"created_at": data["created_at"],
"updated_at": data["updated_at"]
}
return KeyPair(
name=data["id"],
fingerprint=None,
public_key=data["key"],
private_key=None,
driver=self,
extra=extra,
)
def list_key_pairs(self):
response = self.connection.request("v1/sshkeys")
key_pairs = []
for kp in response.object:
key_pair = KeyPair(
name=kp["name"],
public_key=kp["key"],
fingerprint=get_pubkey_openssh_fingerprint(kp["key"]),
driver=self,
extra=dict(id=kp["id"]),
)
key_pairs.append(key_pair)
return key_pairs
def _to_key(self, data, name=None, sshkey=None):
extra = {'uuid': data['object_uuid'], 'labels': data.get('labels', [])}
name = data.get('name', name)
sshkey = data.get('sshkey', sshkey)
key = KeyPair(name=name,
fingerprint=data['object_uuid'],
public_key=sshkey,
private_key=None,
extra=extra,
driver=self.connection.driver)
return key
def list_key_pairs(self):
"""
List all the available SSH keys.
:return: Available SSH keys.
:rtype: ``list`` of :class:`KeyPair`
"""
response = self.connection.request('/users/%s' % (self._get_user_id()),
region='account')
keys = response.object['user']['ssh_public_keys']
return [KeyPair(name=' '.join(key['key'].split(' ')[2:]),
public_key=' '.join(key['key'].split(' ')[:2]),
fingerprint=key['fingerprint'],
driver=self) for key in keys]
def __init__(self): # pylint: disable=W0231
self._TEST_SIZE = NodeSize(
id="test_id",
name="test_size",
ram=4096,
disk=10240,
bandwidth=100000,
price=0,
driver=self,
)
self._TEST_NODE = Node(
id="test_id",
name="test_node",
state=NodeState.RUNNING,
public_ips=["1.2.3.4"],
private_ips=["2.3.4.5"],
driver=self,
size=self._TEST_SIZE,
extra={"ex_key": "ex_value"},
)
self._TEST_LOCATION = NodeLocation(id="test_location",
name="location1",
country="Australia",
driver=self)
self._TEST_VOLUME = StorageVolume(
id="vol1",
name="vol_name",
size=40960,
driver=self,
state=StorageVolumeState.AVAILABLE,
extra={"ex_key": "ex_value"},
)
self._TEST_VOLUME_SNAPSHOT = VolumeSnapshot(id="snap1",
size=80960,
driver=self)
self._TEST_IMAGE = NodeImage(
id="image1",
name="test_image",
extra={"ex_key": "ex_value"},
driver=self,
)
self._TEST_KEY_PAIR = KeyPair(
name="test_key",
fingerprint="abc123",
public_key="pub123",
private_key="priv123",
driver=self,
extra={"ex_key": "ex_value"},
)
def _to_key(self, data, name=None, sshkey=None):
extra = {"uuid": data["object_uuid"], "labels": data.get("labels", [])}
name = data.get("name", name)
sshkey = data.get("sshkey", sshkey)
key = KeyPair(
name=name,
fingerprint=data["object_uuid"],
public_key=sshkey,
private_key=None,
extra=extra,
driver=self.connection.driver,
)
return key
def import_key_pair_from_string(self, name, key_material):
"""
Import a new public key from string.
:param name: Key pair name.
:type name: ``str``
:param key_material: Public key material.
:type key_material: ``str``
:return: Imported key pair object.
:rtype: :class:`KeyPair`
"""
new_key = KeyPair(name=name,
public_key=' '.join(key_material.split(' ')[:2]),
fingerprint=None,
driver=self)
keys = [key for key in self.list_key_pairs() if not key.name == name]
keys.append(new_key)
return self._save_keys(keys)
def __init__(self): # pylint: disable=W0231
self._TEST_SIZE = NodeSize(id='test_id',
name='test_size',
ram=4096,
disk=10240,
bandwidth=100000,
price=0,
driver=self)
self._TEST_NODE = Node(id='test_id',
name='test_node',
state=NodeState.RUNNING,
public_ips=['1.2.3.4'],
private_ips=['2.3.4.5'],
driver=self,
size=self._TEST_SIZE,
extra={'ex_key': 'ex_value'})
self._TEST_LOCATION = NodeLocation(id='test_location',
name='location1',
country='Australia',
driver=self)
self._TEST_VOLUME = StorageVolume(
id='vol1',
name='vol_name',
size=40960,
driver=self,
state=StorageVolumeState.AVAILABLE,
extra={'ex_key': 'ex_value'})
self._TEST_VOLUME_SNAPSHOT = VolumeSnapshot(id='snap1',
size=80960,
driver=self)
self._TEST_IMAGE = NodeImage(id='image1',
name='test_image',
extra={'ex_key': 'ex_value'},
driver=self)
self._TEST_KEY_PAIR = KeyPair(name='test_key',
fingerprint='abc123',
public_key='pub123',
private_key='priv123',
driver=self,
extra={'ex_key': 'ex_value'})
def key_pair(self):
"""key pair object used for authentication. If None, then a akey_pair can be generated"""
if self._key_pair is None:
# generate a key
key = RSAKey.generate(2048)
fingerprint = key.get_fingerprint()
# construct the public key
public_key_base64 = key.get_base64()
public_key = f'ssh-rsa {public_key_base64} {self.user}'
# construct the private key
private_key_fout = StringIO()
key.write_private_key(private_key_fout)
private_key = private_key_fout.getvalue()
self._key_pair = KeyPair(f'key-pair-{self.name}',
public_key=public_key,
fingerprint=fingerprint,
driver=self.driver,
private_key=private_key)
return self._key_pair
def create_key_pair(self, name: str, public_key: str) -> KeyPair:
payload = {
"key": public_key,
"name": name,
}
data = json.dumps(payload)
headers = {"Content-Type": "application/json"}
response = self.connection.request(
"v1/sshkeys",
method="POST",
headers=headers,
data=data,
)
kp = response.object
key = kp.pop("key")
key_pair = KeyPair(
name=kp.pop("name"),
public_key=key,
fingerprint=get_pubkey_openssh_fingerprint(key),
driver=self,
extra=kp,
)
return key_pair
def create_key_pair(self, name, ssh_key_pub):
if name in self._key_pairs:
raise Exception("Key pair '%s' already exists" % (name,))
self._key_pairs[name] = k = KeyPair(name, "XXXX", "XXXX", self)
return k
def destroy_keypair(self, driver, keypair_name):
keypair = KeyPair(keypair_name, None, None, None)
driver.delete_key_pair(keypair)
logger.info('Keypair \'%s\' destroyed', keypair.name)
def _delete_keypair(self, kp_name):
kp = KeyPair(name=kp_name, public_key=None, fingerprint=None,
driver=self.libcloud_driver)
return self.libcloud_driver.delete_key_pair(kp)
def _delete_keypair(self, kp_name):
kp = KeyPair(name=kp_name, public_key=None, fingerprint=None,
driver=self._thread_local.driver)
return self._thread_local.driver.delete_key_pair(kp)