display last backup on capsul detail page, add acpi shutdown

capsulflask/__init__.py

···
 
   VM_STORAGE_DIR=os.environ.get("VM_STORAGE_DIR", default="/tank/vm"),
   BACKUP_STORAGE_MOUNTS=os.environ.get("BACKUP_STORAGE_MOUNTS", default="/mnt/backup1"),
-  BACKUP_DEBUG_LOG=os.environ.get("BACKUP_DEBUG_LOG", default="true"),
+  BACKUP_DEBUG_LOG=os.environ.get("BACKUP_DEBUG_LOG", default="false"),
 
   MAIL_DELIVERY_MANAGER_URL=os.environ.get("MAIL_DELIVERY_MANAGER_URL", default=""),
   MAIL_DELIVERY_MANAGER_SECRET=os.environ.get("MAIL_DELIVERY_MANAGER_SECRET", default=""),
···
 
       backup_maintenance_task_url = f"{app.config['HUB_URL']}/hub/backup-maintenance"
       trigger_backup_maintenance_task = lambda: requests.post(backup_maintenance_task_url, headers=hub_token_headers)
-      scheduler.add_job(name="backup-maintenance", func=trigger_backup_maintenance_task, trigger="interval", seconds=10)
+      scheduler.add_job(name="backup-maintenance", func=trigger_backup_maintenance_task, trigger="interval", seconds=15)
 
       scheduler.start()
 

capsulflask/console.py

···
 from capsulflask.metrics import metric_durations
 from capsulflask.auth import account_required
 from capsulflask.db import get_model
-from capsulflask.shared import my_exec_info_message, get_warnings_list, get_warning_headline, get_vm_months_float, get_account_balance, average_number_of_days_in_a_month
+from capsulflask.shared import my_exec_info_message, get_warnings_list, get_warning_headline, get_vm_months_float, get_account_balance, average_number_of_days_in_a_month, VirtualMachine
 from capsulflask.payment import poll_btcpay_session, check_if_shortterm_flag_can_be_unset
 from capsulflask import cli
 
···
   letters_n_nummers = generate(alphabet="1234567890qwertyuiopasdfghjklzxcvbnm", size=10)
   return f"capsul-{letters_n_nummers}"
 
-def double_check_capsul_address(id, existing_ipv4, get_ssh_host_keys):
+def double_check_capsul_address(id, existing_ipv4, get_ssh_host_keys, get_agent_details) -> VirtualMachine:
   try:
-    result = current_app.config["HUB_MODEL"].get(id, get_ssh_host_keys)
+    result = current_app.config["HUB_MODEL"].get(id, get_ssh_host_keys, get_agent_details)
 
     if result != None and result.ipv4 != "" and (existing_ipv4 == None or existing_ipv4 == ""):
       get_model().update_vm_ip(email=session["account"], id=id, ipv4=result.ipv4)
 
     if result != None and result.ssh_host_keys != None and get_ssh_host_keys:
       get_model().update_vm_ssh_host_keys(email=session["account"], id=id, ssh_host_keys=result.ssh_host_keys)
+
+    if result != None and get_agent_details:
+      get_model().update_vm_agent_details(email=session["account"], id=id, agent_socket=result.agent_socket, guest_agent=result.guest_agent, acpid=result.acpid)
   except:
     current_app.logger.error(f"""
       the virtualization model threw an error in double_check_capsul_address of {id}:
···
   # for now we are going to check the IP according to the virt model
   # on every request. this could be done by a background job and cached later on...
   for vm in vms:
-    result = double_check_capsul_address(vm["id"], vm["ipv4"], False)
+    result = double_check_capsul_address(vm["id"], vm["ipv4"], False, False)
     if result is not None:
       vm["ipv4"] = result.ipv4
       vm["state"] = result.state
···
         check_if_shortterm_flag_can_be_unset(session['account'])
 
         return render_template("capsul-detail.html", vm=vm, deleted=True)
+    elif request.form['action'] == "acpi-shutdown":
+      current_app.logger.info(f"acpi-shutdown {vm['id']} per user request ({session['account']})")
+      get_model().set_desired_state(email=session["account"], vm_id=id, desired_state="shut off")
+      current_app.config["HUB_MODEL"].vm_state_command(email=session['account'], id=id, command="acpi-shutdown")
+      vm["state"] = "stopping"
+      flash("please note that your account will still be billed for this capsul while it is in a stopped state")
+      
+      return render_template(
+        "capsul-detail.html",
+        csrf_token = session["csrf-token"],
+        vm=vm,
+        durations=list(map(lambda x: x.strip("_"), metric_durations.keys())),
+        duration=duration
+      )
+
     elif request.form['action'] == "force-stop":
       if 'are_you_sure' not in request.form or not request.form['are_you_sure']:
         return render_template(
···
 
 
   else:
-    needs_ssh_host_keys = "ssh_host_keys" not in vm or len(vm["ssh_host_keys"]) == 0
+    get_ssh_host_keys = "ssh_host_keys" not in vm or len(vm["ssh_host_keys"]) == 0
+    get_agent_details = True
 
-    vm_from_virt_model = double_check_capsul_address(vm["id"], vm["ipv4"], needs_ssh_host_keys)
+    vm_from_virt_model = double_check_capsul_address(vm["id"], vm["ipv4"], get_ssh_host_keys, get_agent_details)
     
     if vm_from_virt_model is not None:
       vm["ipv4"] = vm_from_virt_model.ipv4
       vm["state"] = vm_from_virt_model.state
-      if needs_ssh_host_keys:
+      if get_ssh_host_keys:
         vm["ssh_host_keys"] = vm_from_virt_model.ssh_host_keys
+      if get_agent_details:
+        vm["agent_socket"] = vm_from_virt_model.agent_socket
+        vm["guest_agent"] = vm_from_virt_model.guest_agent
+        vm["acpid"] = vm_from_virt_model.acpid
     else:
       vm["state"] = "unknown"
 
     if vm["state"] == "running" and not vm["ipv4"]:
       vm["state"] = "starting"
+
+    vm['last_backup_str'] = 'never'
+    if vm['last_backup_finished']:
+      seconds_since_last_backup_finished = (datetime.utcnow() - vm['last_backup_finished']).total_seconds()
+      if seconds_since_last_backup_finished < 60*60:
+        vm['last_backup_str'] = f"{round(seconds_since_last_backup_finished/60)} minutes ago"
+      elif seconds_since_last_backup_finished < 60*60*24:
+        vm['last_backup_str'] = f"{round(seconds_since_last_backup_finished/(60*60))} hours ago"
+      elif seconds_since_last_backup_finished < 60*60*24*365:
+        vm['last_backup_str'] = f"{round(seconds_since_last_backup_finished/(60*60*24))} days ago"
 
     return render_template(
       "capsul-detail.html", 

capsulflask/db_model.py

···
       )
     self.connection.commit()
 
+  def update_vm_agent_details(self, email, id, agent_socket, guest_agent, acpid):
+    self.cursor.execute("UPDATE vms SET has_agent_socket = %s, has_guest_agent = %s, has_acpid = %s WHERE email = %s AND id = %s", (agent_socket, guest_agent, acpid, email, id))
+    self.connection.commit()
+
   def create_vm(self, email, id, size, shortterm, os, host, network_name, public_ipv4, ssh_authorized_keys):
     self.cursor.execute(""" 
       INSERT INTO vms (email, id, size, shortterm, os, host, network_name, public_ipv4)
···
   def get_vm_detail(self, email, id):
     self.cursor.execute(""" 
       SELECT vms.id, vms.public_ipv4, vms.public_ipv6, os_images.description, vms.created, vms.deleted,
-            vm_sizes.id, vms.shortterm, vm_sizes.dollars_per_month, vm_sizes.vcpus, vm_sizes.memory_mb, vm_sizes.bandwidth_gb_per_month
+            vm_sizes.id, vms.shortterm, vm_sizes.dollars_per_month, vm_sizes.vcpus, vm_sizes.memory_mb, vm_sizes.bandwidth_gb_per_month,
+            vms.has_agent_socket, vms.has_guest_agent, vms.has_acpid, vms.last_backup_finished
       FROM vms 
         JOIN os_images on vms.os = os_images.id
         JOIN vm_sizes on vms.size = vm_sizes.id
···
     vm = dict(
       id=row[0], ipv4=row[1], ipv6=row[2], os_description=row[3], created=row[4], deleted=row[5],
       size=row[6], shortterm=row[7], dollars_per_month=row[8], vcpus=row[9], memory_mb=row[10],
-      bandwidth_gb_per_month=row[11],
+      bandwidth_gb_per_month=row[11], agent_socket=row[12], guest_agent=row[13], acpid=row[14], last_backup_finished=row[15]
     )
 
     self.cursor.execute(""" 

capsulflask/hub_model.py

···
   def capacity_avaliable(self, additional_ram_bytes):
     return True
 
-  def get(self, id, get_ssh_host_keys):
+  def get(self, id, get_ssh_host_keys: bool, get_agent_details: bool):
     validate_capsul_id(id)
 
+    ssh_host_keys = []
     if get_ssh_host_keys:
       ssh_host_keys = json.loads("""[
         {"key_type":"ED25519", "content":"ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIN8cna0zeKSKl/r8whdn/KmDWhdzuWRVV0GaKIM+eshh", "sha256":"V4X2apAF6btGAfS45gmpldknoDX0ipJ5c6DLfZR2ttQ"},
         {"key_type":"RSA", "content":"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCvotgzgEP65JUQ8S8OoNKy1uEEPEAcFetSp7QpONe6hj4wPgyFNgVtdoWdNcU19dX3hpdse0G8OlaMUTnNVuRlbIZXuifXQ2jTtCFUA2mmJ5bF+XjGm3TXKMNGh9PN+wEPUeWd14vZL+QPUMev5LmA8cawPiU5+vVMLid93HRBj118aCJFQxLgrdP48VPfKHFRfCR6TIjg1ii3dH4acdJAvlmJ3GFB6ICT42EmBqskz2MPe0rIFxH8YohCBbAbrbWYcptHt4e48h4UdpZdYOhEdv89GrT8BF2C5cbQ5i9qVpI57bXKrj8hPZU5of48UHLSpXG8mbH0YDiOQOfKX/Mt", "sha256":"ghee6KzRnBJhND2kEUZSaouk7CD6o6z2aAc8GPkV+GQ"},
         {"key_type":"ECDSA", "content":"ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBLLgOoATz9R4aS2kk7vWoxX+lshK63t9+5BIHdzZeFE1o+shlcf0Wji8cN/L1+m3bi0uSETZDOAWMP3rHLJj9Hk=", "sha256":"aCYG1aD8cv/TjzJL0bi9jdabMGksdkfa7R8dCGm1yYs"}
       ]""")
-      return VirtualMachine(id, current_app.config["SPOKE_HOST_ID"], ipv4=self.default_ipv4, ssh_host_keys=ssh_host_keys)
-
-    return VirtualMachine(id, current_app.config["SPOKE_HOST_ID"], ipv4=self.default_ipv4)
+    
+    return VirtualMachine(id, current_app.config["SPOKE_HOST_ID"], ipv4=self.default_ipv4, state="running", ssh_host_keys=ssh_host_keys, guest_agent=True, agent_socket=True, acpid=True)
 
   def get_all_by_id(self) -> dict:
     by_host_and_network = get_model().non_deleted_vms_by_host_and_network(None)
···
     return False
     
 
-  def get(self, id, get_ssh_host_keys) -> VirtualMachine:
+  def get(self, id, get_ssh_host_keys, get_agent_details) -> VirtualMachine:
     validate_capsul_id(id)
     host = get_model().host_of_capsul(id)
     if host is not None:
-      payload = json.dumps(dict(type="get", id=id, get_ssh_host_keys=get_ssh_host_keys))
+      payload = json.dumps(dict(type="get", id=id, get_ssh_host_keys=get_ssh_host_keys, get_agent_details=get_agent_details))
       results = self.synchronous_operation([host], None, payload)
       for result in results:
         try:

capsulflask/schema_migrations/27_up_backups.sql

···
+ALTER TABLE vms ADD COLUMN has_agent_socket BOOLEAN NOT NULL DEFAULT FALSE;
 ALTER TABLE vms ADD COLUMN has_guest_agent BOOLEAN NOT NULL DEFAULT FALSE;
+ALTER TABLE vms ADD COLUMN has_acpid BOOLEAN NOT NULL DEFAULT FALSE;
 ALTER TABLE vms ADD COLUMN last_backup_started TIMESTAMP;
 ALTER TABLE vms ADD COLUMN last_backup_finished TIMESTAMP;
 

capsulflask/shared.py

···
 #     self.sha256 = sha256
 
 class VirtualMachine:
-  def __init__(self, id, host, ipv4=None, ipv6=None, state="unknown", ssh_host_keys: List[dict] = list()):
+  def __init__(self, id, host, ipv4=None, ipv6=None, state="unknown", ssh_host_keys: List[dict] = list(), agent_socket: bool = False, guest_agent: bool = False, acpid = False ):
     self.id = id
     self.host = host
     self.ipv4 = ipv4
     self.ipv6 = ipv6
     self.state = state
     self.ssh_host_keys = ssh_host_keys
+    self.agent_socket = agent_socket
+    self.guest_agent = guest_agent
+    self.acpid = acpid
 
 class VirtualizationInterface:
   def capacity_avaliable(self, additional_ram_bytes: int) -> bool:

capsulflask/shell_scripts/acpi-shutdown.sh

···
+#!/bin/sh -e
+
+# State Key
+# NOSTATE: 0 - no state
+# RUNNING: 1 - the domain is running
+# BLOCKED: 2 - the domain is blocked on resource
+# PAUSED: 3 - the domain is paused by user
+# SHUTDOWN: 4 - the domain is being shut down
+# SHUTOFF: 5 - the domain is shut off
+# CRASHED: 6 - the domain is crashed
+# PMSUSPENDED: 7 - the domain is suspended by guest power management
+# LAST: 8 NB: this enum value will increase over time as new events are added to the libvirt API. It reflects the last state supported by this version of the libvirt API.
+
+vmname="$1"
+
+[ "$vmname" = '' ] && printf 'you must set $vmname\n' && exit 1
+
+if printf "$vmname" | grep -vqE '^(cvm|capsul)-[a-z0-9]{10}$'; then
+  printf 'vmname %s must match ^capsul-[a-z0-9]{10}$\n' "$vmname"
+  exit 1
+fi
+
+state="$(virsh domstats $vmname | grep state.state | cut -d '=' -f 2)"
+
+[ "$state" = '' ] && printf 'state was not detected. must match ^[0-8]$\n' && exit 1
+
+if printf "$state" | grep -vqE '^[0-8]$'; then
+  printf 'state %s must match ^[0-8]$\n' "$state"
+  exit 1
+fi
+
+case "$state" in
+  [1-47]) virsh shutdown --mode acpi "$vmname" > /dev/null ;; 
+  [5-6]) printf "%s is already off\n" "$vmname" ;;
+esac
+

capsulflask/shell_scripts/get-guest-agent.sh

···
+#!/bin/sh -e
+
+vmname="$1"
+
+if echo "$vmname" | grep -vqE '^(cvm|capsul)-[a-z0-9]{10}$'; then
+  echo "vmname $vmname must match "'"^capsul-[a-z0-9]{10}$"'
+  exit 1
+fi
+
+qemuAgentCommandOutput="no-guest-agent-socket"
+if virsh dumpxml "$vmname" | grep -q guest_agent ; then
+  isAcpidRunning='{"execute": "guest-exec", "arguments":{"path":"/usr/bin/env", "arg":["pidof","acpid"], "capture-output":true}}'
+  qemuAgentCommandOutput="$( { virsh qemu-agent-command "$vmname" --cmd "$isAcpidRunning" || printf '%s' 'no-qemu-guest-agent'; } |  tr -d '\n' )"
+
+  if [ "$qemuAgentCommandOutput" != "no-qemu-guest-agent" ] ; then
+    # {"return":{"pid":2967}}
+    pidInsideVm="$(echo "$qemuAgentCommandOutput" | jq -r '.return.pid')"
+    qemuAgentCommandOutput="error"
+    if echo "$pidInsideVm" | grep -vqE '^[0-9]+$'; then
+      echo "pidInsideVm: $pidInsideVm WTF!!?!?"
+      exit 1
+    fi
+    getStatusOfProcessInsideVm='{"execute": "guest-exec-status", "arguments":{"pid":'"$pidInsideVm"'}}'
+    exited='false'
+    tries=0
+    while [ "$exited" = "false" ] && [ "$tries" -lt 10 ] ; do
+      tries=$((tries+1))
+      sleep 0.1
+      processStatusInfo="$( virsh qemu-agent-command "$vmname" --cmd "$getStatusOfProcessInsideVm" )"
+      # {"return":{"exitcode":0,"out-data":"MTgwNAo=","exited":true}}
+      exited="$(echo "$processStatusInfo" | jq -r '.return.exited')"
+      if [ "$exited" = "true" ] ; then
+        exitCode="$(echo "$processStatusInfo" | jq -r '.return.exitcode')"
+        if [ "$exitCode" = "0" ] ; then
+          qemuAgentCommandOutput="ok"
+        else
+          qemuAgentCommandOutput="no-acpid"
+        fi
+      fi
+    done
+  fi
+fi
+
+echo "$qemuAgentCommandOutput"

capsulflask/shell_scripts/get.sh

···
 # this gets the ipv4
 ipv4="$(virsh domifaddr "$vmname" | awk '/vnet/ {print $4}' | cut -d'/' -f1)"
 
-echo "$exists $state $ipv4"
+echo "$exists $state $ipv4"

capsulflask/spoke_api.py

···
   if 'id' not in request_body:
     current_app.logger.error(f"/hosts/operation returned 400: id is required for get")
     return abort(400, f"bad request; id is required for get")
-
-  vm = current_app.config['SPOKE_MODEL'].get(request_body['id'], request_body['get_ssh_host_keys'])
+  
+  vm = current_app.config['SPOKE_MODEL'].get(request_body['id'], request_body['get_ssh_host_keys'], request_body['get_agent_details'])
   if vm is None: 
     return jsonify(dict(assignment_status="assigned"))
   

capsulflask/spoke_model.py

···
   def capacity_avaliable(self, additional_ram_bytes):
     return True
 
-  def get(self, id, get_ssh_host_keys):
+  def get(self, id, get_ssh_host_keys: bool, get_agent_details: bool):
     validate_capsul_id(id)
 
     ipv4 = "1.1.1.1"
     if id in self.capsuls:
       ipv4 = self.capsuls[id]['public_ipv4']
 
+    ssh_host_keys=[]
     if get_ssh_host_keys:
       ssh_host_keys = json.loads("""[
         {"key_type":"ED25519", "content":"ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIN8cna0zeKSKl/r8whdn/KmDWhdzuWRVV0GaKIM+eshh", "sha256":"V4X2apAF6btGAfS45gmpldknoDX0ipJ5c6DLfZR2ttQ"},
         {"key_type":"RSA", "content":"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCvotgzgEP65JUQ8S8OoNKy1uEEPEAcFetSp7QpONe6hj4wPgyFNgVtdoWdNcU19dX3hpdse0G8OlaMUTnNVuRlbIZXuifXQ2jTtCFUA2mmJ5bF+XjGm3TXKMNGh9PN+wEPUeWd14vZL+QPUMev5LmA8cawPiU5+vVMLid93HRBj118aCJFQxLgrdP48VPfKHFRfCR6TIjg1ii3dH4acdJAvlmJ3GFB6ICT42EmBqskz2MPe0rIFxH8YohCBbAbrbWYcptHt4e48h4UdpZdYOhEdv89GrT8BF2C5cbQ5i9qVpI57bXKrj8hPZU5of48UHLSpXG8mbH0YDiOQOfKX/Mt", "sha256":"ghee6KzRnBJhND2kEUZSaouk7CD6o6z2aAc8GPkV+GQ"},
         {"key_type":"ECDSA", "content":"ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBLLgOoATz9R4aS2kk7vWoxX+lshK63t9+5BIHdzZeFE1o+shlcf0Wji8cN/L1+m3bi0uSETZDOAWMP3rHLJj9Hk=", "sha256":"aCYG1aD8cv/TjzJL0bi9jdabMGksdkfa7R8dCGm1yYs"}
       ]""")
-      return VirtualMachine(id, current_app.config["SPOKE_HOST_ID"], ipv4=ipv4, state="running", ssh_host_keys=ssh_host_keys)
 
-    return VirtualMachine(id, current_app.config["SPOKE_HOST_ID"], ipv4=ipv4, state="running")
+    return VirtualMachine(id, current_app.config["SPOKE_HOST_ID"], ipv4=ipv4, state="running", ssh_host_keys=ssh_host_keys,  guest_agent=True, agent_socket=True, acpid=True)
 
   def get_all_by_id(self) -> dict:
     by_host_and_network = get_model().non_deleted_vms_by_host_and_network(current_app.config["SPOKE_HOST_ID"])
···
 
     return True
 
-  def get(self, id, get_ssh_host_keys):
+  def get(self, id, get_ssh_host_keys: bool, get_agent_details: bool):
     validate_capsul_id(id)
     completed_process = run([join(current_app.root_path, 'shell_scripts/get.sh'), id], capture_output=True)
     self.validate_completed_process(completed_process)
···
     if not re.match(r"^([0-9]{1,3}\.){3}[0-9]{1,3}$", ipaddr):
       return VirtualMachine(id, current_app.config["SPOKE_HOST_ID"], state=state)
 
+    guest_agent=False
+    agent_socket=False
+    acpid=False
+    ssh_host_keys = []
     if get_ssh_host_keys:
       try:
         completed_process2 = run([join(current_app.root_path, 'shell_scripts/ssh-keyscan.sh'), ipaddr], capture_output=True)
         self.validate_completed_process(completed_process2)
         ssh_host_keys = json.loads(completed_process2.stdout.decode("utf-8"))
-        return VirtualMachine(id, current_app.config["SPOKE_HOST_ID"], state=state, ipv4=ipaddr, ssh_host_keys=ssh_host_keys)
       except:
         current_app.logger.warning(f"""
           failed to ssh-keyscan {id} at {ipaddr}:
           {my_exec_info_message(sys.exc_info())}"""
         )
 
-    return VirtualMachine(id, current_app.config["SPOKE_HOST_ID"], state=state, ipv4=ipaddr)
+    if get_agent_details:
+      try:
+        completed_process3 = run([join(current_app.root_path, 'shell_scripts/get-guest-agent.sh'), id], capture_output=True)
+        self.validate_completed_process(completed_process3)
+        result = completed_process3.stdout.decode("utf-8")
+        if result != 'no-guest-agent-socket':
+          agent_socket = True
+        if result == "ok" or result == 'no-acpid':
+          guest_agent = True
+        if result == "ok":
+          acpid = True
+        if result not in ['ok', 'no-acpid', 'no-qemu-guest-agent', 'no-guest-agent-socket']:
+          raise ValueError(result)
+      except:
+        current_app.logger.warning(f"""
+          failed to get-guest-agent {id} at {ipaddr}:
+          {my_exec_info_message(sys.exc_info())}"""
+        )
+
+    return VirtualMachine(id, current_app.config["SPOKE_HOST_ID"], state=state, ipv4=ipaddr, ssh_host_keys=ssh_host_keys, agent_socket=agent_socket, guest_agent=guest_agent, acpid=acpid)
 
   def get_all_by_id(self) -> dict:
 
···
 
   def vm_state_command(self, email: str, id: str, command: str):
     validate_capsul_id(id)
-    if command not in ["stop", "force-stop", "start", "restart"]:
+    if command not in ["stop", "force-stop", "acpi-shutdown", "start", "restart"]:
       raise ValueError(f"command ({command}) must be one of stop, force-stop, start, or restart")
 
     completed_process = run([join(current_app.root_path, f"shell_scripts/{command}.sh"), id], capture_output=True)

capsulflask/templates/capsul-detail.html

···
         <label class="align" for="ssh_username">SSH Username</label>
         <span id="ssh_username">cyberian</span>
       </div>
-
       <div class="row justify-start">
-        <!-- spacer to make authorized keys show up on its own line -->
-        <label class="align" for="spacer">&nbsp;</label>
-        <span id="spacer">&nbsp;</span>
+        <label class="align" for="last_backup">Last Backup</label>
+        <span id="last_backup">{{ vm['last_backup_str'] }}</span>
       </div>
       <div class="row justify-start">
         <label class="align" for="ssh_authorized_keys">SSH Authorized Keys</label>
···
       </div>
       
     </div>
+    <div class="row">
+      <hr/>
+    </div>
     <div class="row center justify-start vm-actions">
       <label class="align" for="delete_action">Actions</label>
       <form id="delete_action" method="post">
···
       </form>
       {% endif  %}
       {% if vm['state'] != 'stopped' %}
+        {% if vm['acpid'] %}
+        <form id="acpi_shutdown_action" method="post">
+          <input type="hidden" name="action" value="acpi-shutdown"/>
+          <input type="hidden" name="csrf-token" value="{{ csrf_token }}"/>
+          <input type="submit" class="form-submit-link" value="[ ACPI Shutdown... ]">
+        </form>
+        {% endif  %}
       <form id="force_stop_action" method="post">
         <input type="hidden" name="action" value="force-stop"/>
         <input type="hidden" name="csrf-token" value="{{ csrf_token }}"/>