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="******"