def test_server_prepare_post_body_optional_attributes(self):
server = Server(
core_number=2,
memory_amount=1024,
hostname='my.example.com',
zone=ZONE.Chicago,
storage_devices=[
Storage(
os='Ubuntu 14.04',
size=10
)
],
vnc_password='******',
password_delivery='email',
login_user=login_user_block('upclouduser', ['this-is-a-SSH-key']),
avoid_host='12345678'
)
body = server.prepare_post_body()
assert body['server']['title'] == 'my.example.com'
assert body['server']['core_number'] == 2
assert body['server']['memory_amount'] == 1024
assert body['server']['hostname'] == server.title
assert body['server']['zone'] == 'us-chi1'
assert body['server']['vnc_password'] == 'my-passwd'
assert body['server']['password_delivery'] == 'email'
assert body['server']['login_user'] == {
'username': '******',
'create_password': '******',
'ssh_keys': {
'ssh_key': ['this-is-a-SSH-key']
}
}
assert body['server']['avoid_host'] == '12345678'
def create_server(self, module):
"""Create a server from module.params. Filters out unwanted attributes."""
# filter out 'filter_keys' and those who equal None from items to get server's attributes for POST request
items = module.params.items()
filter_keys = set(['state', 'api_user', 'api_passwd', 'user', 'ssh_keys'])
server_dict = dict((key,value) for key, value in items if key not in filter_keys and value is not None)
if module.params.get('ssh_keys'):
login_user = upcloud_api.login_user_block(
username=module.params.get('user'),
ssh_keys=module.params['ssh_keys'],
create_password=False
)
server_dict['login_user'] = login_user
return self.manager.create_server(server_dict)
def create_server(self, module):
"""Create a server from module.params. Filters out unwanted attributes."""
# filter out 'filter_keys' and those who equal None from items to get server's attributes for POST request
items = list(module.params.items())
filter_keys = set(['state', 'api_user', 'api_passwd', 'user', 'ssh_keys'])
server_dict = dict((key,value) for key, value in items if key not in filter_keys and value is not None)
if module.params.get('ssh_keys'):
login_user = upcloud_api.login_user_block(
username=module.params.get('user'),
ssh_keys=module.params['ssh_keys'],
create_password=False
)
server_dict['login_user'] = login_user
return self.manager.create_server(server_dict)
def do_command(self):
loaded_ssh_key = self._load_ssh_keyfile(self.ssh_key)
user_block = upcloud_api.login_user_block(username=self.login_user,
ssh_keys=[loaded_ssh_key],
create_password=False)
server = upcloud_api.Server(
plan=self.plan,
hostname=self.hostname,
zone=self.zone,
storage_devices=[upcloud_api.Storage(os=self.os, size=10)],
login_user=user_block)
created_server = self._sdk_call(
lambda: self._manager.create_server(server))
if self.ensure_started:
self._sdk_call(lambda: created_server.ensure_started())
self._output = {'uuid': created_server.uuid}
def create_server(self, module_params):
"""Create a server from module parameters. Filters out unwanted attributes."""
# filter out 'filter_keys' and those who equal None from items to get
# server's attributes for POST request
items = module_params.items()
filter_keys = set(
["state", "api_user", "api_passwd", "user", "ssh_keys"])
server_dict = dict((key, value) for key, value in items
if key not in filter_keys and value is not None)
if module_params.get("ssh_keys"):
login_user = upcloud_api.login_user_block(
username=module_params.get("user"),
ssh_keys=module_params["ssh_keys"],
create_password=False,
)
server_dict["login_user"] = login_user
return self.manager.create_server(server_dict)
def collect_server_params(self, module):
items = module.params.items()
filter_keys = set(['state', 'api_user', 'api_passwd', 'user', 'ssh_keys', 'ip_address'])
server_dict = dict((key,value) for key, value in items if key not in filter_keys and value is not None)
if module.params.get('ssh_keys'):
login_user = upcloud_api.login_user_block(
username=module.params.get('user'),
ssh_keys=module.params['ssh_keys'],
create_password=False
)
server_dict['login_user'] = login_user
# Convert all booleans to strings for Upcloud API
for item in server_dict:
if server_dict[item] == True:
server_dict[item] = 'on'
elif server_dict[item] == False:
server_dict[item] = 'off'
return server_dict
def collect_server_params(self, module):
items = module.params.items()
filter_keys = set([
'state', 'api_user', 'api_passwd', 'user', 'ssh_keys', 'ip_address'
])
server_dict = dict((key, value) for key, value in items
if key not in filter_keys and value is not None)
if module.params.get('ssh_keys'):
login_user = upcloud_api.login_user_block(
username=module.params.get('user'),
ssh_keys=module.params['ssh_keys'],
create_password=False)
server_dict['login_user'] = login_user
# Convert all booleans to strings for Upcloud API
for item in server_dict:
if server_dict[item] == True:
server_dict[item] = 'on'
elif server_dict[item] == False:
server_dict[item] = 'off'
return server_dict
def test_server_prepare_post_body_optional_attributes(self):
server1 = Server(
core_number=2,
memory_amount=1024,
hostname='my.example.com',
zone='us-chi1',
storage_devices=[
Storage(
os='01000000-0000-4000-8000-000030200200',
size=10
)
],
vnc_password='******',
password_delivery='email',
login_user=login_user_block('upclouduser', ['this-is-a-SSH-key']),
avoid_host='12345678',
user_data='https://my.script.com/some_script.py',
ip_addresses = [
IPAddress(family='IPv4', access='public'),
IPAddress(family='IPv6', access='public')
]
)
server2_dict = {
'core_number':2,
'memory_amount':1024,
'hostname':'my.example.com',
'zone': 'us-chi1',
'storage_devices':[
{'os': '01000000-0000-4000-8000-000030200200', 'size': 10}
],
'vnc_password': '******',
'password_delivery': 'email',
'login_user': login_user_block('upclouduser', ['this-is-a-SSH-key']),
'avoid_host': '12345678',
'user_data': 'https://my.script.com/some_script.py',
'ip_addresses': [
{'family':'IPv4', 'access':'public'},
{'family':'IPv6', 'access':'public'}
]
}
server2 = Server._create_server_obj(server2_dict, cloud_manager=self)
body1 = server1.prepare_post_body()
body2 = server2.prepare_post_body()
for body in [body1, body2]:
assert body['server']['title'] == 'my.example.com'
assert body['server']['core_number'] == 2
assert body['server']['memory_amount'] == 1024
assert body['server']['hostname'] == server1.title
assert body['server']['zone'] == 'us-chi1'
assert body['server']['vnc_password'] == 'my-passwd'
assert body['server']['password_delivery'] == 'email'
assert body['server']['login_user'] == {
'username': '******',
'create_password': '******',
'ssh_keys': {
'ssh_key': ['this-is-a-SSH-key']
}
}
assert body['server']['avoid_host'] == '12345678'
assert body['server']['user_data'] == 'https://my.script.com/some_script.py'
assert body['server']['ip_addresses'] == {
'ip_address': [
{'family': 'IPv4', 'access': 'public'},
{'family': 'IPv6', 'access': 'public'}
]
}
import requests
import upcloud_api
from upcloud_api import Server, Storage, ZONE, login_user_block
manager = upcloud_api.CloudManager('darnellapi', 'Master1960#')
manager.authenticate()
noofservers = 3
login_user = login_user_block(
username='******',
ssh_keys=['ssh-rsa AAAAB3NzaC1yc2EAA[...]ptshi44x [email protected]'],
create_password=False
)
for inc in range(0, noofservers):
server_config = Server(
title='Server'+str(inc),
plan='1xCPU-1GB',
hostname='server'+str(inc)+'.darnell.com',
zone=ZONE.Chicago,
storage_devices=[
Storage(os='CentOS 6.5', size=25),
],
login_user=login_user,
user_data='/createproxy.sh'
)
manager.create_server(server_config)
print("end of loop")
# Connect to UpCloud
manager = up.CloudManager(upcloud_user, upcloud_password)
manager.authenticate()
print('Connected to UpCloud API as user "{0}"'.format(upcloud_user))
res = subprocess.run(
'cat {0}'.format(ssh_key_filepath),
shell=True,
stdout=subprocess.PIPE,
text=True,
)
ssh_key_value = res.stdout.strip()
rtmp_user_desc = up.login_user_block(
username='******',
ssh_keys=[ssh_key_value],
create_password=False,
)
rtmp_server_desc = up.Server(
core_number=upcloud_cores, # CPU cores
memory_amount=upcloud_ram, # RAM in MB
zone=upcloud_region,
title='Multiservice RTMP Broadcaster',
# UpCloud strangely requires that every server have a qualified domain
# name. (?!) Using a totaly made up name here.
hostname='multiservice-rtmp-server.com',
storage_devices=[
up.Storage(os='Ubuntu 18.04', size=upcloud_disk),
],
login_user=rtmp_user_desc, # user and ssh-keys
def create(vm_):
'''
Create a single Upcloud VM.
'''
name = vm_['name']
try:
# Check for required profile parameters before sending any API calls.
if vm_['profile'] and config.is_profile_configured(
__opts__,
__active_provider_name__ or 'upcloud',
vm_['profile'],
vm_=vm_) is False:
return False
except AttributeError:
pass
if _validate_name(name) is False:
return False
__utils__['cloud.fire_event'](
'event',
'starting create',
'salt/cloud/{0}/creating'.format(name),
args=_filter_event('creating', vm_,
['name', 'profile', 'provider', 'driver']),
sock_dir=__opts__['sock_dir'],
transport=__opts__['transport'])
log.info('Creating Cloud VM {0}'.format(name))
root_login_user = login_user_block(username='******',
ssh_keys=[get_pub_key(vm_)],
create_password=False)
server_kwargs = {}
manager = _get_manager(vm_)
location = vm_.get('location')
## TO-DO: Add support for cloning
image = vm_.get('image', DEFAULT_IMAGE)
extra_storage = vm_.get('extra_storage', [])
storage = [
# Primary, holds the operating system
Storage(uuid=image)
] + [Storage(size=s) for s in extra_storage]
size_dict = _parse_size(vm_.get('size', DEFAULT_SIZE))
server_kwargs.update(size_dict)
# Let's take care of any network configuration
ip_addresses = vm_.get('ip_addresses', [])
control_from_inside = vm_.get('control_from_inside', False)
server_kwargs['zone'] = location
server_kwargs['hostname'] = vm_.get('hostname', name)
server_kwargs['storage_devices'] = storage
server_kwargs['ip_addresses'] = ip_addresses
report_data = copy.deepcopy(server_kwargs)
report_data['storage_devices'] = extra_storage
server_obj = Server(**server_kwargs)
__utils__['cloud.fire_event'](
'event',
'requesting instance',
'salt/cloud/{0}/requesting'.format(name),
args=_filter_event('requesting', report_data,
['name', 'profile', 'provider', 'driver']),
sock_dir=__opts__['sock_dir'],
transport=__opts__['transport'])
log.debug('vm_kwargs: {0}'.format(server_kwargs))
create_server_result = manager.create_server(server_obj)
log.info('create_server_result: {0}'.format(create_server_result.__dict__))
# Let's create some information worth logging out from this
if create_server_result is not None and isinstance(
create_server_result, Server) and create_server_result.populated:
# Keep this around, we are going to need it soon enough
new_server_info = create_server_result.to_dict()
log.debug('create_server_result/new_server_info: {0}', new_server_info)
# Will need this soon enough
username = create_server_result.username
password = create_server_result.password
control_ip = _select_control_ip(create_server_result.ip_addresses,
control_from_inside)
if control_ip is None:
log.error(
"Could not use any of the addresses in {0} for ssh control".
format(new_server_info['ip_addresses']))
return False
vm_['ssh_host'] = control_ip.address
vm_['password'] = password
vm_['ssh_username'] = username
ret = __utils__['cloud.bootstrap'](vm_, __opts__)
ret.update(new_server_info)
# TO-DO: insert code here to attach volumes, and other configuration steps.
#
# check salt/cloud/clouds/mazure.py for inspiration
__utils__['cloud.fire_event']('event',
'created instance',
'salt/cloud/{0}/created'.format(
vm_['name']),
args=_filter_event(
**{
'name': vm_['name'],
'profile': vm_['profile'],
'provider': vm_['driver'],
}),
sock_dir=__opts__['sock_dir'],
transport=__opts__['transport'])
return ret
else:
log.error("Could not create Upcloud server, error: {0}".format(
str(create_server_result)))
return False
def init_key(self):
super().init_key()
self.login_user = login_user_block(username=self.config.get(
'remote', 'user'),
ssh_keys=[self.public_key],
create_password=False)
#!/usr/bin/env python3
#
# Create a new instance at UpCloud.
#
# pip3 install --user upcloud-api
# chmod 600 upcloud_create_server.py
import upcloud_api
from upcloud_api import Server, Storage, ZONE, login_user_block
# EDIT
manager = upcloud_api.CloudManager('USERNAME', 'PASSWORD')
user_viktor = login_user_block(
username='******',
ssh_keys=['ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBJnaM2JLvO4DWkmmSXys+jn0KhTRVkCfAAhv/1Pszs0DJTheQgOR9e3ThNCgR7CxIqZ5kXrZ+BIDtDs5IGrg9IA= szv-ecdsa'],
create_password=False
)
new_server_config = Server(
hostname='upcloud.keszul.tk',
zone=ZONE.Frankfurt,
plan='2xCPU-2GB',
storage_devices=[
Storage(os='Debian 8.0', size=50)
],
login_user=user_viktor,
# Docker + pip
user_data='https://github.com/szepeviktor/debian-server-tools/raw/master/upcloud-init.sh'
)
#!/usr/bin/env python3
#
# Create a new instance at UpCloud.
#
# pip3 install --user upcloud-api
# chmod 0700 ./upcloud_create_server.py
from upcloud_api import CloudManager, Server, Storage, ZONE, login_user_block
# EDIT here
manager = CloudManager('USERNAME', 'PASSWORD')
user_viktor = login_user_block(
username='******',
ssh_keys=['ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBJnaM2JLvO4DWkmmSXys+jn0KhTRVkCfAAhv/1Pszs0DJTheQgOR9e3ThNCgR7CxIqZ5kXrZ+BIDtDs5IGrg9IA= szv-ecdsa'],
create_password=False
)
new_server_config = Server(
hostname='upcloud.keszul.tk',
zone=ZONE.Frankfurt,
plan='2xCPU-4GB',
storage_devices=[
Storage(os='Debian 9.0', size=80)
],
login_user=user_viktor,
# Docker + pip
user_data='https://github.com/szepeviktor/debian-server-tools/raw/master/upcloud-init.sh'
)
