class TestImagesClient(object):
def test_get_by_id(self, hetzner_client):
image = hetzner_client.images.get_by_id(1)
assert image.id == 4711
assert image.name == "ubuntu-16.04"
assert image.description == "Ubuntu 16.04 Standard 64 bit"
def test_get_by_name(self, hetzner_client):
image = hetzner_client.images.get_by_name("ubuntu-16.04")
assert image.id == 4711
assert image.name == "ubuntu-16.04"
assert image.description == "Ubuntu 16.04 Standard 64 bit"
def test_get_list(self, hetzner_client):
result = hetzner_client.images.get_list()
images = result.images
assert images[0].id == 4711
assert images[0].name == "ubuntu-16.04"
assert images[0].description == "Ubuntu 16.04 Standard 64 bit"
@pytest.mark.parametrize(
"image",
[Image(id=1), BoundImage(mock.MagicMock(), dict(id=1))])
def test_get_actions_list(self, hetzner_client, image):
result = hetzner_client.images.get_actions_list(image)
actions = result.actions
assert len(actions) == 1
assert actions[0].id == 13
assert actions[0].command == "change_protection"
@pytest.mark.parametrize(
"image",
[Image(id=1), BoundImage(mock.MagicMock(), dict(id=1))])
def test_update(self, hetzner_client, image):
image = hetzner_client.images.update(
image,
description="My new Image description",
type="snapshot",
labels={})
assert image.id == 4711
assert image.description == "My new Image description"
@pytest.mark.parametrize(
"image",
[Image(id=1), BoundImage(mock.MagicMock(), dict(id=1))])
def test_delete(self, hetzner_client, image):
delete_success = hetzner_client.images.delete(image)
assert delete_success is True
@pytest.mark.parametrize(
"image",
[Image(id=1), BoundImage(mock.MagicMock(), dict(id=1))])
def test_change_protection(self, hetzner_client, image):
action = hetzner_client.images.change_protection(image, delete=True)
assert action.id == 13
assert action.command == "change_protection"
def test_create(self, hetzner_client):
response = hetzner_client.servers.create(
"my-server",
server_type=ServerType(name="cx11"),
image=Image(name="ubuntu-16.04"),
ssh_keys=[SSHKey(name="my-ssh-key")],
volumes=[Volume(id=1)],
user_data=
"#cloud-config\\nruncmd:\\n- [touch, /root/cloud-init-worked]\\n",
location=Location(name="nbg1"),
automount=False)
server = response.server
action = response.action
next_actions = response.next_actions
root_password = response.root_password
assert server.id == 42
assert server.volumes == []
assert server.server_type.id == 1
assert server.datacenter.id == 1
assert server.image.id == 4711
assert action.id == 1
assert action.command == "create_server"
assert len(next_actions) == 1
assert next_actions[0].id == 13
assert next_actions[0].command == "start_server"
assert root_password == "YItygq1v3GYjjMomLaKc"
def test_rebuild(self, servers_client, server, generic_action):
servers_client._client.request.return_value = generic_action
action = servers_client.rebuild(server, Image(name="ubuntu-16.04"))
servers_client._client.request.assert_called_with(url="/servers/1/actions/rebuild", method="POST", json={"image": "ubuntu-16.04"})
assert action.id == 1
assert action.progress == 0
def test_create_with_datacenter(self, servers_client, response_create_simple_server):
servers_client._client.request.return_value = response_create_simple_server
response = servers_client.create(
"my-server",
server_type=ServerType(name="cx11"),
image=Image(id=4711),
datacenter=Datacenter(id=1)
)
servers_client._client.request.assert_called_with(
url="/servers",
method="POST",
json={
'name': "my-server",
'server_type': "cx11",
'image': 4711,
'datacenter': 1,
"start_after_create": True
}
)
bound_server = response.server
assert bound_server._client is servers_client
assert bound_server.id == 1
assert bound_server.name == "my-server"
def test_rebuild(self, hetzner_client, bound_server, generic_action):
hetzner_client.request.return_value = generic_action
action = bound_server.rebuild(Image(name="ubuntu-16.04"))
hetzner_client.request.assert_called_with(url="/servers/14/actions/rebuild", method="POST", json={"image": "ubuntu-16.04"})
assert action.id == 1
assert action.progress == 0
def test_create_with_location(self, servers_client,
response_create_simple_server):
servers_client._client.request.return_value = response_create_simple_server
response = servers_client.create("my-server",
server_type=ServerType(name="cx11"),
image=Image(name="ubuntu-20.04"),
location=Location(name="fsn1"))
servers_client._client.request.assert_called_with(
url="/servers",
method="POST",
json={
'name': "my-server",
'server_type': "cx11",
'image': "ubuntu-20.04",
'location': "fsn1",
"start_after_create": True
})
bound_server = response.server
bound_action = response.action
assert bound_server._client is servers_client
assert bound_server.id == 1
assert bound_server.name == "my-server"
assert isinstance(bound_action, BoundAction)
assert bound_action._client == servers_client._client.actions
assert bound_action.id == 1
assert bound_action.command == "create_server"
def _create_instance(self, defn) -> None:
if not self.public_client_key:
(private, public) = create_key_pair(type="ed25519")
self.public_client_key = public
self.private_client_key = private
if not self.public_host_key:
(private, public) = create_key_pair(type="ed25519")
self.public_host_key = public
self.private_host_key = private
location: BoundLocation = self.get_client().locations.get_by_name(
defn.location)
ssh_keys: List[BoundSSHKey] = [
self._create_ssh_key(self.public_client_key)
]
# Ensure host keys get injected into the base OS
user_data = ("#cloud-config\n"
"ssh_keys:\n"
" ed25519_public: {0}\n"
" ed25519_private: |\n"
" {1}").format(
self.public_host_key,
self.private_host_key.replace("\n", "\n "))
self.logger.log_start(
f"creating {defn.server_type} server at {location.description}...")
response = self.get_client().servers.create(
name=defn.server_name,
labels={
**self.get_common_labels(),
**dict(defn.labels)
},
location=location,
server_type=ServerType(defn.server_type),
ssh_keys=ssh_keys,
user_data=user_data,
image=Image(name="ubuntu-20.04"), # for lustration
start_after_create=True,
)
self.state = self.STARTING
self.wait_on_action(response.action)
with self.depl._db:
self.vm_id = response.server.id
self.public_ipv4 = response.server.public_net.ipv4.ip
self.public_ipv6 = response.server.public_net.ipv6.ip
self.server_name = defn.server_name
self.server_type = defn.server_type
self.legacy_if_scheme = defn.server_type.startswith("cx")
self.location = defn.location
self.labels = dict(defn.labels)
self.private_host_key = None
known_hosts.add(self.public_ipv4, self.public_host_key)
self.logger.log_end(f"{self.public_ipv4}")
def test_created_is_datetime(self):
image = Image(id=1, created="2016-01-30T23:50+00:00")
assert image.created == datetime.datetime(2016,
1,
30,
23,
50,
tzinfo=tzoffset(None, 0))
def create_vm(self, vm_name, vm_model, vm_os_image):
"""
Provision a new VM
"""
self.logger.debug(f"Creating VM {vm_name}")
response = self.client.servers.create(
name=vm_name,
server_type=ServerType(vm_model),
ssh_keys=self.client.ssh_keys.get_all(),
image=Image(name=vm_os_image))
response.action.wait_until_finished()
return response.server
async def _create_node(
self,
suffix: str,
servertype: str,
datacenter: str,
image: str,
ip: str,
labels: Union[Dict[str, str], None] = None,
) -> NodeABC:
name = f'{self._prefix:s}-node-{suffix:s}'
self._log.info('Creating node %s ...', name)
_ = self._client.servers.create(
name=name,
server_type=ServerType(name=servertype),
image=Image(name=image),
datacenter=Datacenter(name=datacenter),
ssh_keys=[self._ssh_key],
firewalls=[self._firewall],
labels=labels,
)
self._log.info('Waiting for node %s to become available ...', name)
while True:
server = self._client.servers.get_by_name(name=name)
if server.status == Server.STATUS_RUNNING:
break
await sleep(self._wait)
self._log.info('Attaching network to node %s ...', name)
server.attach_to_network(
network=self._network,
ip=ip,
)
self._log.info('Bootstrapping node %s ...', name)
node = await Node.from_async(
server=server,
client=self._client,
fn_private=self._fn_private,
prefix=self._prefix,
wait=self._wait,
log=self._log,
)
await node.bootstrap() # TODO param?
return node
def createServer(name, image):
#freebsd = snapid="8322744"
#image=Image(type="snapshot", id=snapid)
sysImage = True
if image == "debian":
image_name = "debian-10"
elif image == "centos":
image_name = "centos-8"
elif image == "freebsd":
snap_id = "8322744"
sysImage = False
elif image == "vpn":
snap_id = "9207785"
sysImage = False
elif image == "ubuntu":
image_name = "ubuntu-18.04"
if sysImage:
response = client.servers.create(name=name,
server_type=ServerType("cx11"),
image=Image(name=image_name))
else:
response = client.servers.create(name=name,
server_type=ServerType("cx11"),
image=Image(type="snapshot",
id=snap_id))
server = response.server
serverData = dict()
serverData['id'] = server.id
serverData['ip'] = server.public_net.ipv4.ip
serverData['pwd'] = response.root_password
add_hetzner(name, server.id, server.public_net.ipv4.ip, "cx11",
response.root_password)
return serverData
def deploy_instance(self, name) -> None:
log.info(f"hcloud: Deploying instance with name {name}")
launch_config = self.launch.copy()
labels = launch_config.get("labels", dict())
labels.update({"scalr": self.filter})
params = {
"name": name,
"labels": labels,
"server_type": ServerType(launch_config["server_type"]),
"image": Image(launch_config["image"]),
"ssh_keys": [SSHKey(ssh_key) for ssh_key in launch_config["ssh_keys"]],
"location": Location(launch_config["location"]),
"user_data": launch_config["user_data"],
}
self.hcloud.servers.create(**params)
def create():
with open(data_file, "r") as file:
data = json.load(file)
client = Client(token=data["token"])
response = client.servers.create("win10-OCR",
server_type=ServerType(name="cx41"),
image=Image(id=22859215),
networks=[Network(id=135205)],
location=Location(id=2))
server = response.server
data["server_id"] = f"{server.id}"
with open(data_file, "w") as file:
json.dump(data, file, indent=4)
click.echo("creation complete")
def test_create_with_firewalls(self, servers_client,
response_create_simple_server):
servers_client._client.request.return_value = response_create_simple_server
firewalls = [
Firewall(id=1),
BoundFirewall(mock.MagicMock(), dict(id=2))
]
response = servers_client.create("my-server",
server_type=ServerType(name="cx11"),
image=Image(id=4711),
firewalls=firewalls,
start_after_create=False)
servers_client._client.request.assert_called_with(
url="/servers",
method="POST",
json={
'name': "my-server",
'server_type': "cx11",
'image': 4711,
'firewalls': [{
"firewall": 1
}, {
"firewall": 2
}],
"start_after_create": False
})
bound_server = response.server
bound_action = response.action
next_actions = response.next_actions
root_password = response.root_password
assert root_password == "YItygq1v3GYjjMomLaKc"
assert bound_server._client is servers_client
assert bound_server.id == 1
assert bound_server.name == "my-server"
assert isinstance(bound_action, BoundAction)
assert bound_action._client == servers_client._client.actions
assert bound_action.id == 1
assert bound_action.command == "create_server"
assert next_actions[0].id == 13
async def start(self):
if self.running == False:
print("Starting " + self.name)
response = self.client.servers.create(
self.name,
server_type=ServerType(name=self.servertype),
image=Image(self.snapshot),
location=Location(self.location),
volumes=[Volume(self.volume)])
self.server = response.server
#while self.server.status != Server.STATUS_RUNNING:
# print(self.server.status)
# time.sleep(2)
# serv = self.client.servers.get_by_id(self.server.id)
# self.server = serv
#print("Server is now running")
self.running = True
else:
print(self.name + " is already running")
def __init__(
self,
cluster: str,
config,
env_vars: dict = None,
bootstrap=None,
docker_image: str = None,
image: str = None,
location: str = None,
server_type: str = None,
*args,
**kwargs,
):
super().__init__(*args, **kwargs)
self.cluster = cluster
self.config = config
self.location = location
self.bootstrap = bootstrap
self.env_vars = env_vars
self.client = hcloud.Client(self.config.get("token"))
self.server_type = ServerType(server_type)
self.image = Image(name=image)
self.docker_image = docker_image
def create_node(self):
assert self.ssh_key_id
assert self.ssh_custom_key
response = self.client.servers.create(
name=self.get_rnd_name('node'),
server_type=ServerType('cx51'), image=Image(name='debian-10'),
ssh_keys=[SSHKey(name=self.key_name)]
)
server = response.server
ip = server.public_net.ipv4.ip
logging.info('CREATED %s' % ip)
time.sleep(5)
# warm up
for _ in range(10):
ssh_conn = SSH_Connection(host=ip, user=self.config.get('remote', 'user'),
connect_kwargs=self.ssh_custom_key)
try: ssh_conn.run('whoami', hide=True)
except: time.sleep(5)
else: break
return ip
def create_server(name, verbose=False):
response = client.servers.create(name=name,
server_type=ServerType(name="cx11"),
datacenter=get_data_center(),
image=Image(name="debian-10"),
ssh_keys=[ssh_key])
server = response.server
main_ip = str(response.server.data_model.public_net.ipv4.ip)
if verbose:
print(server)
print("You can login: "******"ssh -oStrictHostKeyChecking=no root@" +
main_ip)
try:
client.floating_ips.unassign(get_floating_ip())
except APIException:
if verbose:
print("No need to unassign")
if verbose:
print("Waiting...")
time.sleep(20)
if verbose:
print("Now assign the ip new")
client.floating_ips.assign(get_floating_ip(), server)
print(main_ip)
from hcloud import Client
from hcloud.images.domain import Image
from hcloud.server_types.domain import ServerType
client = Client(token="{YOUR_API_TOKEN}"
) # Please paste your API token here between the quotes
response = client.servers.create(name="my-server",
server_type=ServerType("cx11"),
image=Image(name="ubuntu-20.04"))
server = response.server
print(server)
print("Root Password" + response.root_password)
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
host_ip = s.getsockname()[0]
s.close()
for part_id in part_ids:
user_data_part = user_data_template
user_data_part = user_data_part.replace("<host_ip>", host_ip)
user_data_part = user_data_part.replace("<part_id>", part_id)
response = client.servers.create(
name=part_id,
server_type=ServerType("cx11"),
image=Image(name="ubuntu-18.04"),
user_data=user_data_part,
ssh_keys=[client.ssh_keys.get_by_name("tmp")])
servers.append(response.server)
exec_parts = ins_parts.values(
part_id=part_id,
server_ip=response.server.public_net.ipv4.ip,
in_progress=1,
time_stamp=datetime.now(),
project_name=project_name,
callback_ip=host_ip)
try:
db_ctx["conn"].execute(exec_parts)
except Exception as e:
print(e)
def test_rebuild(self, hetzner_client, server):
action = hetzner_client.servers.rebuild(server,
Image(name="ubuntu-16.04"))
assert action.id == 13
assert action.command == "rebuild_server"
def test_rebuild(self, bound_server):
action = bound_server.rebuild(Image(name="ubuntu-16.04"))
assert action.id == 13
assert action.command == "rebuild_server"
#Get all the information of the old server
oldServerType = (Server(id=oldServer).id).server_type
oldServerDatacenter = (Server(id=oldServer).id).datacenter
oldServerVolumes = (Server(id=oldServer).id).volumes
oldServerFloatingIP = ((Server(id=oldServer).id).public_net).floating_ips
sshKeys = client.ssh_keys.get_all()
#Find the newest backup
images = client.images.get_all(type="backup")
backupNewestID = 0
for image in images:
infImage = (client.images.get_by_id(image.id))
createdFrom = ((Image(id=infImage).id).created_from).name
if createdFrom == serverName:
idImage = infImage.id
if idImage > backupNewestID:
backupNewestID = idImage
imageNewServer = client.images.get_by_id(backupNewestID)
#detach Volume, unassign IP and change name
for x in range(len(oldServerVolumes)):
oldServerVolumes[x].detach()
client.floating_ips.unassign((oldServerFloatingIP)[0])
try:
oldServer.update(name=serverName + "-OLD")
except:
x = 1
from hcloud import Client
from hcloud.images.domain import Image
from hcloud.server_types.domain import ServerType
# Create a client
client = Client(token="project-token")
# Create 2 servers
# Create 2 servers
response1 = client.servers.create("Server1",
server_type=ServerType(name="cx11"),
image=Image(id=4711))
response2 = client.servers.create("Server2",
server_type=ServerType(name="cx11"),
image=Image(id=4711))
# Get all servers
server1 = response1.server
server2 = response2.server
servers = client.servers.get_all()
assert servers[0].id == server1.id
assert servers[1].id == server2.id
# Create 2 volumes
response1 = client.volumes.create(size=15,
name="Volume1",
location=server1.location)
response2 = client.volumes.create(size=10,
name="Volume2",
def create(self, defn: HcloudDefinition, check, allow_reboot,
allow_recreate):
assert isinstance(defn, HcloudDefinition)
hetzner = defn.config.hcloud
self.token = get_access_token(hetzner)
if self.state not in (MachineState.RESCUE, MachineState.UP) or check:
self.check()
self.set_common_state(defn)
self.upgrade_disk = hetzner.upgradeDisk
# TODO maybe bootstrap can be automated with vncdotool
image_id = self._fetch_image_id(hetzner.image, hetzner.image_selector)
if self.image_id is None:
self.image_id = image_id
elif self.image_id != image_id:
self.warn(
f"image_id changed from {self.image_id} to {image_id} but can't update image of a VM."
)
if self.location is None:
self.location = hetzner.location
elif self.location != hetzner.location:
self.warn(
f"location changed from {self.location} to {hetzner.location} but can't update location of a VM."
)
if self.vm_id is not None and hetzner.serverType != self.server_type:
# TODO Check if server can be upgraded before hitting the Hetzner API
# https://docs.hetzner.cloud/#server-actions-change-the-type-of-a-server
do_upgrade = True
# Only confirm if upgrade_disk is True because then the upgrade can't be undone
if self.upgrade_disk:
do_upgrade = self.depl.logger.confirm(
f"are you sure you want to change Hetzner server {self.name} type from "
+ f"{self.server_type} to {hetzner.serverType}?")
if do_upgrade:
self.log_start("Changing Hetzner server type...")
self._server.shutdown().wait_until_finished()
self.wait_for_down(callback=lambda: self.log_continue("."))
self._server.change_type(
ServerType(name=hetzner.serverType),
upgrade_disk=self.upgrade_disk).wait_until_finished()
self._server.power_on()
self.wait_for_up(callback=lambda: self.log_continue("."))
self.log_end("")
self.server_type = hetzner.serverType
ssh_keys = [
k.name if isinstance(k, ResourceEval) else k
for k in hetzner.sshKeys
]
if self.state != MachineState.MISSING and ssh_keys != self.ssh_keys:
self.logger.warn(
f"SSH keys cannot be changed after the server is created.")
volume_ids = []
filesystems = {}
for volumeopts in hetzner.volumes:
volume = volumeopts.volume
if isinstance(volume, str):
volume_model = self._client.volumes.get_by_name(volume)
volume_name = volume
volume_id = volume_model.id
volume_loc = volume_model.location.name
else:
volume_res = self.depl.get_typed_resource(
volume._name, "hcloud-volume", HcloudVolumeState)
volume_name = volume_res.name
volume_id = volume_res.hcloud_id
assert volume_id is not None
volume_loc = volume_res.location
if volume_loc != self.location:
raise Exception(
f"Volume {volume_name!r} is in a different location from server {self.name!r}"
)
volume_ids.append(volume_id)
if volumeopts.mountPoint is not None:
fs = dict(volumeopts.fileSystem)
fs["device"] = f"/dev/disk/by-id/scsi-0HC_Volume_{volume_id}"
filesystems[volumeopts.mountPoint] = fs
has_priv = self._ssh_private_key is not None
has_pub = self._ssh_public_key is not None
assert has_priv == has_pub
if not has_priv:
self.log("Generating SSH keypair...")
(self._ssh_private_key, self._ssh_public_key) = create_key_pair()
if self.vm_id:
if self.volume_ids != volume_ids:
current = set(self.volume_ids)
new = set(volume_ids)
volumes_client = self._client.volumes
self.log_start("Updating volumes...")
for v in current - new:
volumes_client.detach(Volume(id=v))
self.log_continue(".")
for v in new - current:
volumes_client.attach(
Volume(id=v), self._server,
automount=False).wait_until_finished()
self.log_continue(".")
self.log_end("")
self.volume_ids = volume_ids
else:
self.log_start(
"Creating Hetzner Cloud VM (" +
f"image '{image_id}', type '{hetzner.serverType}', location '{hetzner.location}'"
+ ")...")
response = self._client.servers.create(
name=self.name,
ssh_keys=[SSHKey(name=k) for k in ssh_keys],
volumes=[Volume(id=v) for v in volume_ids],
server_type=ServerType(self.server_type),
image=Image(id=self.image_id),
# Set labels so we can find the instance if nixops crashes before writing vm_id
labels=dict(self._server_labels()),
user_data=None if self._ssh_public_key is None else yaml.dump(
{"public-keys": [self._ssh_public_key]}),
)
self.log_end("")
self.public_ipv4 = response.server.public_net.ipv4.ip
self.log_start("waiting for SSH...")
self.wait_for_up(callback=lambda: self.log_continue("."))
self.log_end("")
with self.depl._db:
self.vm_id = response.server.id
# TODO get state from creation response
self.state = MachineState.STARTING
self.ssh_keys = ssh_keys
self.volume_ids = volume_ids
self._detect_hardware()
self._update_host_keys()
self.filesystems = filesystems
from hcloud import Client
from hcloud.images.domain import Image
from hcloud.server_types.domain import ServerType
client = Client(token="{YOUR_API_TOKEN}") # Please paste your API token here between the quotes
response = client.servers.create(name="my-server", server_type=ServerType("cx11"), image=Image(name="ubuntu-18.04"))
server = response.server
print(server)
print("Root Password" + response.root_password)
from mcstatus import MinecraftServer
load_dotenv()
os.chdir(Path(__file__).parent.absolute())
# Discord config
DISCORD_TOKEN = os.getenv("DISCORD_TOKEN")
ROLE = int(os.getenv("BOT_PRIVILEDGED_ROLE"))
PREFIX = os.getenv("BOT_PREFIX")
discord = commands.Bot(PREFIX)
# Hetzner config
HCLOUD_TOKEN = os.getenv("HCLOUD_TOKEN")
SERVER_NAME = os.getenv("SERVER_NAME")
SERVER_TYPE = ServerType(name=os.getenv("SERVER_TYPE"))
SERVER_IMAGE = Image(name=os.getenv("SERVER_IMAGE"))
hcloud = hcl.Client(HCLOUD_TOKEN)
def get_volume() -> Volume:
return hcloud.volumes.get_by_name(SERVER_NAME)
def requires_role():
"""Short-hand for commands.has_role(ROLE)"""
return commands.has_role(ROLE)
@discord.event
async def on_command_error(ctx, error: commands.CommandError):
if isinstance(error, commands.CheckFailure):
class TestImagesClient(object):
@pytest.fixture()
def images_client(self):
return ImagesClient(client=mock.MagicMock())
def test_get_by_id(self, images_client, image_response):
images_client._client.request.return_value = image_response
image = images_client.get_by_id(1)
images_client._client.request.assert_called_with(url="/images/1",
method="GET")
assert image._client is images_client
assert image.id == 4711
assert image.name == "ubuntu-20.04"
@pytest.mark.parametrize("params", [{
'name': "ubuntu-20.04",
"type": "system",
"sort": "id",
"bound_to": "1",
"label_selector": "k==v",
"page": 1,
"per_page": 10
}, {
'name': ""
}, {}])
def test_get_list(self, images_client, two_images_response, params):
images_client._client.request.return_value = two_images_response
result = images_client.get_list(**params)
images_client._client.request.assert_called_with(url="/images",
method="GET",
params=params)
images = result.images
assert result.meta is None
assert len(images) == 2
images1 = images[0]
images2 = images[1]
assert images1._client is images_client
assert images1.id == 4711
assert images1.name == "ubuntu-20.04"
assert images2._client is images_client
assert images2.id == 4712
assert images2.name == "ubuntu-18.10"
@pytest.mark.parametrize("params", [{
'name': "ubuntu-20.04",
"type": "system",
"sort": "id",
"bound_to": "1",
"label_selector": "k==v",
}, {}])
def test_get_all(self, images_client, two_images_response, params):
images_client._client.request.return_value = two_images_response
images = images_client.get_all(**params)
params.update({"page": 1, "per_page": 50})
images_client._client.request.assert_called_with(url="/images",
method="GET",
params=params)
assert len(images) == 2
images1 = images[0]
images2 = images[1]
assert images1._client is images_client
assert images1.id == 4711
assert images1.name == "ubuntu-20.04"
assert images2._client is images_client
assert images2.id == 4712
assert images2.name == "ubuntu-18.10"
def test_get_by_name(self, images_client, one_images_response):
images_client._client.request.return_value = one_images_response
image = images_client.get_by_name("ubuntu-20.04")
params = {"name": "ubuntu-20.04"}
images_client._client.request.assert_called_with(url="/images",
method="GET",
params=params)
assert image._client is images_client
assert image.id == 4711
assert image.name == "ubuntu-20.04"
@pytest.mark.parametrize(
"image",
[Image(id=1), BoundImage(mock.MagicMock(), dict(id=1))])
def test_get_actions_list(self, images_client, image,
response_get_actions):
images_client._client.request.return_value = response_get_actions
result = images_client.get_actions_list(image)
images_client._client.request.assert_called_with(
url="/images/1/actions", method="GET", params={})
actions = result.actions
assert result.meta is None
assert len(actions) == 1
assert isinstance(actions[0], BoundAction)
assert actions[0]._client == images_client._client.actions
assert actions[0].id == 13
assert actions[0].command == "change_protection"
@pytest.mark.parametrize(
"image",
[Image(id=1), BoundImage(mock.MagicMock(), dict(id=1))])
def test_update(self, images_client, image, response_update_image):
images_client._client.request.return_value = response_update_image
image = images_client.update(image,
description="My new Image description",
type="snapshot",
labels={})
images_client._client.request.assert_called_with(
url="/images/1",
method="PUT",
json={
"description": "My new Image description",
"type": "snapshot",
"labels": {}
})
assert image.id == 4711
assert image.description == "My new Image description"
@pytest.mark.parametrize(
"image",
[Image(id=1), BoundImage(mock.MagicMock(), dict(id=1))])
def test_change_protection(self, images_client, image, generic_action):
images_client._client.request.return_value = generic_action
action = images_client.change_protection(image, True)
images_client._client.request.assert_called_with(
url="/images/1/actions/change_protection",
method="POST",
json={"delete": True})
assert action.id == 1
assert action.progress == 0
@pytest.mark.parametrize(
"image",
[Image(id=1), BoundImage(mock.MagicMock(), dict(id=1))])
def test_delete(self, images_client, image, generic_action):
images_client._client.request.return_value = generic_action
delete_success = images_client.delete(image)
images_client._client.request.assert_called_with(url="/images/1",
method="DELETE")
assert delete_success is True
ssh_pub_key[1])
ssh_key_list.append(k)
if debug:
print(NAME,
args.type,
args.image,
args.datacenter,
ssh_key_names,
ssh_pub_key,
ssh_key_list,
packages,
file=sys.stderr)
response = client.servers.create(name=NAME,
server_type=ServerType(args.type),
image=Image(args.image),
ssh_keys=ssh_key_list,
labels=labels)
server = response.server
IPADDR = server.data_model.public_net.ipv4.ip
print("Machine created: %s" % IPADDR, file=sys.stderr)
server.change_dns_ptr(IPADDR, NAME + '.hcloud.owncloud.com') # needs an FQDN
# CAUTION: keep in sync with ../hcloud_tf/make_machine.sh
script = """
exec 1>&2 # all output goes to stderr.
server_image="%s"
IPADDR="%s"
extra_pkg="%s"
do_login="******"