def rebuild(self, server, image): # type: (servers.domain.Server, Image) -> actions.domainAction """Rebuilds a server overwriting its disk with the content of an image, thereby destroying all data on the target server. :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>` :param image: :class:`BoundImage <hcloud.images.client.BoundImage>` or :class:`Image <hcloud.servers.domain.Image>` :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = { "image": image.id_or_name } response = self._client.request(url="/servers/{server_id}/actions/rebuild".format(server_id=server.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def attach_iso(self, server, iso): # type: (servers.domain.Server, Iso) -> actions.domainAction """Attaches an ISO to a server. :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>` :param iso: :class:`BoundIso <hcloud.isos.client.BoundIso>` or :class:`Server <hcloud.isos.domain.Iso>` :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = { "iso": iso.id_or_name } response = self._client.request(url="/servers/{server_id}/actions/attach_iso".format(server_id=server.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def reset_password(self, server): # type: (servers.domain.Server) -> ResetPasswordResponse """ Resets the root password. Only works for Linux systems that are running the qemu guest agent. :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>` :return: :class:`ResetPasswordResponse <hcloud.servers.domain.ResetPasswordResponse>` """ response = self._client.request( url="/servers/{server_id}/actions/reset_password".format( server_id=server.id), method="POST") return ResetPasswordResponse(action=BoundAction( self._client.actions, response['action']), root_password=response['root_password'])
def disable_public_interface(self, load_balancer): # type: (Union[LoadBalancer, BoundLoadBalancer]) -> BoundAction """ Disables the public interface of a Load Balancer. :param load_balancer: :class:` <hcloud.load_balancers.client.BoundLoadBalancer>` or :class:`LoadBalancer <hcloud.load_balancers.domain.LoadBalancer>` :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ response = self._client.request( url="/load_balancers/{load_balancer_id}/actions/disable_public_interface".format( load_balancer_id=load_balancer.id), method="POST") return BoundAction(self._client.actions, response['action'])
def create( self, type, # type: str description=None, # type: Optional[str] labels=None, # type: Optional[str] home_location=None, # type: Optional[Location] server=None, # type: Optional[Server] name=None, # type: Optinal[str] ): # type: (...) -> CreateFloatingIPResponse """Creates a new Floating IP assigned to a server. :param type: str Floating IP type Choices: ipv4, ipv6 :param description: str (optional) :param labels: Dict[str, str] (optional) User-defined labels (key-value pairs) :param home_location: :class:`BoundLocation <hcloud.locations.client.BoundLocation>` or :class:`Location <hcloud.locations.domain.Location>` ( Home location (routing is optimized for that location). Only optional if server argument is passed. :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>` Server to assign the Floating IP to :param name: str (optional) :return: :class:`CreateFloatingIPResponse <hcloud.floating_ips.domain.CreateFloatingIPResponse>` """ data = {'type': type} if description is not None: data['description'] = description if labels is not None: data['labels'] = labels if home_location is not None: data['home_location'] = home_location.id_or_name if server is not None: data['server'] = server.id if name is not None: data['name'] = name response = self._client.request(url="/floating_ips", json=data, method="POST") action = None if response.get('action') is not None: action = BoundAction(self._client.actions, response['action']) result = CreateFloatingIPResponse(floating_ip=BoundFloatingIP( self, response['floating_ip']), action=action) return result
def change_algorithm(self, load_balancer, algorithm): # type: (Union[LoadBalancer, BoundLoadBalancer], Optional[bool]) -> BoundAction """Changes the algorithm used by the Load Balancer :param load_balancer: :class:` <hcloud.load_balancers.client.BoundLoadBalancer>` or :class:`LoadBalancer <hcloud.load_balancers.domain.LoadBalancer>` :param algorithm: :class:`LoadBalancerAlgorithm <hcloud.load_balancers.domain.LoadBalancerAlgorithm>` The LoadBalancerSubnet you want to add to the Load Balancer :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = {"type": algorithm.type} response = self._client.request( url="/load_balancers/{load_balancer_id}/actions/change_algorithm".format(load_balancer_id=load_balancer.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def update_service(self, load_balancer, service): # type: (Union[LoadBalancer, BoundLoadBalancer], LoadBalancerService) -> List[BoundAction] """Updates a service of an Load Balancer. :param load_balancer: :class:`BoundLoadBalancer <hcloud.load_balancers.client.BoundLoadBalancer>` or :class:`LoadBalancer <hcloud.load_balancers.domain.LoadBalancer>` :param service: :class:`LoadBalancerService <hcloud.load_balancers.domain.LoadBalancerService>` The LoadBalancerService with updated values within for the Load Balancer :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = self.get_service_parameters(service) response = self._client.request( url="/load_balancers/{load_balancer_id}/actions/update_service".format( load_balancer_id=load_balancer.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def resize(self, volume, size): # type: (Union[Volume, BoundVolume], int) -> BoundAction """Changes the size of a volume. Note that downsizing a volume is not possible. :param volume: :class:`BoundVolume <hcloud.volumes.client.BoundVolume>` or :class:`Volume <hcloud.volumes.domain.Volume>` :param size: int New volume size in GB (must be greater than current size) :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = self._client.request( url="/volumes/{volume_id}/actions/resize".format( volume_id=volume.id), json={'size': size}, method="POST") return BoundAction(self._client.actions, data['action'])
def change_protection(self, image, delete=None): # type: (Image, Optional[bool], Optional[bool]) -> BoundAction """Changes the protection configuration of the image. Can only be used on snapshots. :param image: :class:`BoundImage <hcloud.images.client.BoundImage>` or :class:`Image <hcloud.images.domain.Image>` :param delete: bool If true, prevents the snapshot from being deleted :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = {} if delete is not None: data.update({"delete": delete}) response = self._client.request(url="/images/{image_id}/actions/change_protection".format(image_id=image.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def assign(self, floating_ip, server): # type: (FloatingIP, Server) -> BoundAction """Assigns a Floating IP to a server. :param floating_ip: :class:`BoundFloatingIP <hcloud.floating_ips.client.BoundFloatingIP>` or :class:`FloatingIP <hcloud.floating_ips.domain.FloatingIP>` :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>` Server the Floating IP shall be assigned to :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ response = self._client.request( url="/floating_ips/{floating_ip_id}/actions/assign".format( floating_ip_id=floating_ip.id), method="POST", json={"server": server.id}) return BoundAction(self._client.actions, response['action'])
def request_console(self, server): # type: (servers.domain.Server) -> RequestConsoleResponse """Requests credentials for remote access via vnc over websocket to keyboard, monitor, and mouse for a server. :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>` :return: :class:`RequestConsoleResponse <hcloud.servers.domain.RequestConsoleResponse>` """ response = self._client.request( url="/servers/{server_id}/actions/request_console".format( server_id=server.id), method="POST") return RequestConsoleResponse(action=BoundAction( self._client.actions, response['action']), wss_url=response['wss_url'], password=response['password'])
def attach(self, volume, server, automount=None): # type: (Union[Volume, BoundVolume], Union[Server, BoundServer], Optional[bool]) -> BoundAction """Attaches a volume to a server. Works only if the server is in the same location as the volume. :param volume: :class:`BoundVolume <hcloud.volumes.client.BoundVolume>` or :class:`Volume <hcloud.volumes.domain.Volume>` :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>` :param automount: boolean :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = {'server': server.id} if automount is not None: data["automount"] = automount data = self._client.request(url="/volumes/{volume_id}/actions/attach".format(volume_id=volume.id), json=data, method="POST") return BoundAction(self._client.actions, data['action'])
def detach_from_network(self, load_balancer, network): # type: (Union[LoadBalancer, BoundLoadBalancer], Union[Network,BoundNetwork]) -> BoundAction """Detaches a Load Balancer from a Network. :param load_balancer: :class:` <hcloud.load_balancers.client.BoundLoadBalancer>` or :class:`LoadBalancer <hcloud.load_balancers.domain.LoadBalancer>` :param network: :class:`BoundNetwork <hcloud.networks.client.BoundNetwork>` or :class:`Network <hcloud.networks.domain.Network>` :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = { "network": network.id, } response = self._client.request( url="/load_balancers/{load_balancer_id}/actions/detach_from_network".format( load_balancer_id=load_balancer.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def delete_service(self, load_balancer, service): # type: (Union[LoadBalancer, BoundLoadBalancer], LoadBalancerService) -> List[BoundAction] """Deletes a service from a Load Balancer. :param load_balancer: :class:`BoundLoadBalancer <hcloud.load_balancers.client.BoundLoadBalancer>` or :class:`LoadBalancer <hcloud.load_balancers.domain.LoadBalancer>` :param service: :class:`LoadBalancerService <hcloud.load_balancers.domain.LoadBalancerService>` The LoadBalancerService you want to delete from the Load Balancer :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = { "listen_port": service.listen_port, } response = self._client.request( url="/load_balancers/{load_balancer_id}/actions/delete_service".format(load_balancer_id=load_balancer.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def create( self, name, # type: str rules=None, # type: Optional[List[FirewallRule]] labels=None, # type: Optional[str] resources=None, # type: Optional[List[FirewallResource]] ): # type: (...) -> CreateFirewallResponse """Creates a new Firewall. :param name: str Firewall Name :param rules: List[:class:`FirewallRule <hcloud.firewalls.domain.FirewallRule>`] (optional) :param labels: Dict[str, str] (optional) User-defined labels (key-value pairs) :param resources: List[:class:`FirewallResource <hcloud.firewalls.domain.FirewallResource>`] (optional) :return: :class:`CreateFirewallResponse <hcloud.firewalls.domain.CreateFirewallResponse>` """ data = {'name': name} if labels is not None: data['labels'] = labels if rules is not None: data.update({"rules": []}) for rule in rules: data['rules'].append(rule.to_payload()) if resources is not None: data.update({"apply_to": []}) for resource in resources: data['apply_to'].append(resource.to_payload()) response = self._client.request(url="/firewalls", json=data, method="POST") actions = [] if response.get('actions') is not None: actions = [ BoundAction(self._client.actions, _) for _ in response['actions'] ] result = CreateFirewallResponse(firewall=BoundFirewall( self, response['firewall']), actions=actions) return result
def change_alias_ips(self, server, network, alias_ips): # type: (Union[Server,BoundServer], Union[Network,BoundNetwork], List[str]) -> BoundAction """Changes the alias IPs of an already attached network. :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>` :param network: :class:`BoundNetwork <hcloud.networks.client.BoundNetwork>` or :class:`Network <hcloud.networks.domain.Network>` :param alias_ips: List[str] New alias IPs to set for this server. :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = {"network": network.id, "alias_ips": alias_ips} response = self._client.request( url="/servers/{server_id}/actions/change_alias_ips".format( server_id=server.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def set_rules(self, firewall, rules): # type: (Firewall, List[FirewallRule]) -> List[BoundAction] """Sets the rules of a Firewall. All existing rules will be overwritten. Pass an empty rules array to remove all rules. :param firewall: :class:`BoundFirewall <hcloud.firewalls.client.BoundFirewall>` or :class:`Firewall <hcloud.firewalls.domain.Firewall>` :param rules: List[:class:`FirewallRule <hcloud.firewalls.domain.FirewallRule>`] :return: List[:class:`BoundAction <hcloud.actions.client.BoundAction>`] """ data = { "rules": [] } for rule in rules: data['rules'].append(rule.to_payload()) response = self._client.request( url="/firewalls/{firewall_id}/actions/set_rules".format(firewall_id=firewall.id), method="POST", json=data) return [BoundAction(self._client.actions, _) for _ in response['actions']]
def detach_from_network(self, server, network): # type: (Union[Server,BoundServer], Union[Network,BoundNetwork]) -> BoundAction """Detaches a server from a network. :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>` :param network: :class:`BoundNetwork <hcloud.networks.client.BoundNetwork>` or :class:`Network <hcloud.networks.domain.Network>` :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = { "network": network.id, } response = self._client.request( url="/servers/{server_id}/actions/detach_from_network".format( server_id=server.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def remove_from_resources(self, firewall, resources): # type: (Firewall, List[FirewallResource]) -> List[BoundAction] """Removes one Firewall from multiple resources. :param firewall: :class:`BoundFirewall <hcloud.firewalls.client.BoundFirewall>` or :class:`Firewall <hcloud.firewalls.domain.Firewall>` :param rules: List[:class:`FirewallResource <hcloud.firewalls.domain.FirewallResource>`] :return: List[:class:`BoundAction <hcloud.actions.client.BoundAction>`] """ data = { "remove_from": [] } for resource in resources: data['remove_from'].append(resource.to_payload()) response = self._client.request( url="/firewalls/{firewall_id}/actions/remove_from_resources".format(firewall_id=firewall.id), method="POST", json=data) return [BoundAction(self._client.actions, _) for _ in response['actions']]
def change_protection(self, volume, delete=None): # type: (Union[Volume, BoundVolume], Optional[bool]) -> BoundAction """Changes the protection configuration of a volume. :param volume: :class:`BoundVolume <hcloud.volumes.client.BoundVolume>` or :class:`Volume <hcloud.volumes.domain.Volume>` :param delete: boolean If True, prevents the volume from being deleted :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = {} # type: Dict[str, Any] if delete is not None: data.update({"delete": delete}) response = self._client.request( url="/volumes/{volume_id}/actions/change_protection".format(volume_id=volume.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def change_type(self, load_balancer, load_balancer_type): # type: ([LoadBalancer, BoundLoadBalancer], [LoadBalancerType, BoundLoadBalancerType]) ->BoundAction """Changes the type of a Load Balancer. :param load_balancer: :class:`BoundLoadBalancer <hcloud.load_balancers.client.BoundLoadBalancer>` or :class:`LoadBalancer <hcloud.load_balancers.domain.LoadBalancer>` :param load_balancer_type: :class:`BoundLoadBalancerType <hcloud.load_balancer_types.client.BoundLoadBalancerType>` or :class:`LoadBalancerType <hcloud.load_balancer_types.domain.LoadBalancerType>` Load Balancer type the Load Balancer should migrate to :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = { "load_balancer_type": load_balancer_type.id_or_name, } response = self._client.request( url="/load_balancers/{load_balancer_id}/actions/change_type". format(load_balancer_id=load_balancer.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def change_protection(self, load_balancer, delete=None): # type: (Union[LoadBalancer, BoundLoadBalancer], Optional[bool]) -> BoundAction """Changes the protection configuration of a Load Balancer. :param load_balancer: :class:` <hcloud.load_balancers.client.BoundLoadBalancer>` or :class:`LoadBalancer <hcloud.load_balancers.domain.LoadBalancer>` :param delete: boolean If True, prevents the Load Balancer from being deleted :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = {} if delete is not None: data.update({"delete": delete}) response = self._client.request( url="/load_balancers/{load_balancer_id}/actions/change_protection".format( load_balancer_id=load_balancer.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def change_dns_ptr(self, server, ip, dns_ptr): # type: (servers.domain.Server, str, str) -> actions.domainAction """Changes the hostname that will appear when getting the hostname belonging to the primary IPs (ipv4 and ipv6) of this server. :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>` :param ip: str The IP address for which to set the reverse DNS entry :param dns_ptr: Hostname to set as a reverse DNS PTR entry, will reset to original default value if `None` :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = {"ip": ip, "dns_ptr": dns_ptr} response = self._client.request( url="/servers/{server_id}/actions/change_dns_ptr".format( server_id=server.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def change_type(self, server, server_type, upgrade_disk): # type: (servers.domain.Server, BoundServerType, bool) -> actions.domainAction """Changes the type (Cores, RAM and disk sizes) of a server. :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>` :param server_type: :class:`BoundServerType <hcloud.server_types.client.BoundServerType>` or :class:`ServerType <hcloud.server_types.domain.ServerType>` Server type the server should migrate to :param upgrade_disk: boolean If false, do not upgrade the disk. This allows downgrading the server type later. :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = { "server_type": server_type.id_or_name, "upgrade_disk": upgrade_disk } response = self._client.request(url="/servers/{server_id}/actions/change_type".format(server_id=server.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def remove_target(self, load_balancer, target): # type: (Union[LoadBalancer, BoundLoadBalancer], LoadBalancerTarget) -> List[BoundAction] """Removes a target from a Load Balancer. :param load_balancer: :class:`BoundLoadBalancer <hcloud.load_balancers.client.BoundLoadBalancer>` or :class:`LoadBalancer <hcloud.load_balancers.domain.LoadBalancer>` :param target: :class:`LoadBalancerTarget <hcloud.load_balancers.domain.LoadBalancerTarget>` The LoadBalancerTarget you want to remove from the Load Balancer :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = { "type": target.type, "server": {"id": target.server.id}, } response = self._client.request( url="/load_balancers/{load_balancer_id}/actions/remove_target".format(load_balancer_id=load_balancer.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def change_protection(self, network, delete=None): # type: (Union[Network, BoundNetwork], Optional[bool]) -> BoundAction """Changes the protection configuration of a network. :param network: :class:`BoundNetwork <hcloud.networks.client.BoundNetwork>` or :class:`Network <hcloud.networks.domain.Network>` :param delete: boolean If True, prevents the network from being deleted :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = {} if delete is not None: data.update({"delete": delete}) response = self._client.request( url="/networks/{network_id}/actions/change_protection".format( network_id=network.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def change_ip_range(self, network, ip_range): # type: (Union[Network, BoundNetwork], str) -> List[BoundAction] """Changes the IP range of a network. :param network: :class:`BoundNetwork <hcloud.networks.client.BoundNetwork>` or :class:`Network <hcloud.networks.domain.Network>` :param ip_range: str The new prefix for the whole network. :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = { "ip_range": ip_range, } response = self._client.request( url="/networks/{network_id}/actions/change_ip_range".format( network_id=network.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def delete_subnet(self, network, subnet): # type: (Union[Network, BoundNetwork], NetworkSubnet) -> List[BoundAction] """Removes a subnet entry from a network :param network: :class:`BoundNetwork <hcloud.networks.client.BoundNetwork>` or :class:`Network <hcloud.networks.domain.Network>` :param subnet: :class:`NetworkSubnet <hcloud.networks.domain.NetworkSubnet>` The NetworkSubnet you want to remove from the Network :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = { "ip_range": subnet.ip_range, } response = self._client.request( url="/networks/{network_id}/actions/delete_subnet".format( network_id=network.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def change_protection(self, floating_ip, delete=None): # type: (FloatingIP, Optional[bool]) -> BoundAction """Changes the protection configuration of the Floating IP. :param floating_ip: :class:`BoundFloatingIP <hcloud.floating_ips.client.BoundFloatingIP>` or :class:`FloatingIP <hcloud.floating_ips.domain.FloatingIP>` :param delete: boolean If true, prevents the Floating IP from being deleted :return: :class:`BoundAction <hcloud.actions.client.BoundAction>` """ data = {} if delete is not None: data.update({"delete": delete}) response = self._client.request( url="/floating_ips/{floating_ip_id}/actions/change_protection". format(floating_ip_id=floating_ip.id), method="POST", json=data) return BoundAction(self._client.actions, response['action'])
def get_actions_list( self, floating_ip, # type: FloatingIP status=None, # type: Optional[List[str]] sort=None, # type: Optional[List[str]] page=None, # type: Optional[int] per_page=None, # type: Optional[int] ): # type: (...) -> PageResults[List[BoundAction], Meta] """Returns all action objects for a Floating IP. :param floating_ip: :class:`BoundFloatingIP <hcloud.floating_ips.client.BoundFloatingIP>` or :class:`FloatingIP <hcloud.floating_ips.domain.FloatingIP>` :param status: List[str] (optional) Response will have only actions with specified statuses. Choices: `running` `success` `error` :param sort: List[str] (optional) Specify how the results are sorted. Choices: `id` `id:asc` `id:desc` `command` `command:asc` `command:desc` `status` `status:asc` `status:desc` `progress` `progress:asc` `progress:desc` `started` `started:asc` `started:desc` `finished` `finished:asc` `finished:desc` :param page: int (optional) Specifies the page to fetch :param per_page: int (optional) Specifies how many results are returned by page :return: (List[:class:`BoundAction <hcloud.actions.client.BoundAction>`], :class:`Meta <hcloud.core.domain.Meta>`) """ params = {} # type: Dict[str, Any] if status is not None: params["status"] = status if sort is not None: params["sort"] = sort if page is not None: params["page"] = page if per_page is not None: params["per_page"] = per_page response = self._client.request( url="/floating_ips/{floating_ip_id}/actions".format( floating_ip_id=floating_ip.id), method="GET", params=params, ) actions = [ BoundAction(self._client.actions, action_data) for action_data in response["actions"] ] return add_meta_to_result(actions, response, "actions")