try to fix acpid detection on nixos

capsulflask/console.py

···
   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, get_agent_details) -> VirtualMachine:
+def double_check_capsul_address(id, existing_ipv4, get_ssh_host_keys, get_agent_details, vm_os_id) -> VirtualMachine:
   try:
-    result = current_app.config["HUB_MODEL"].get(id, get_ssh_host_keys, get_agent_details)
+    result = current_app.config["HUB_MODEL"].get(id, get_ssh_host_keys, get_agent_details, vm_os_id)
 
     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)
···
     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"], get_ssh_host_keys, get_agent_details)
+    vm_from_virt_model = double_check_capsul_address(vm["id"], vm["ipv4"], get_ssh_host_keys, get_agent_details, vm['os'])
     
     if vm_from_virt_model is not None:
       vm["ipv4"] = vm_from_virt_model.ipv4

capsulflask/db_model.py

···
     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,
-            vms.has_agent_socket, vms.has_guest_agent, vms.has_acpid, vms.last_backup_finished, vms.host
+            vms.has_agent_socket, vms.has_guest_agent, vms.has_acpid, vms.last_backup_finished, vms.host, vms.os
       FROM vms 
         JOIN os_images on vms.os = os_images.id
         JOIN vm_sizes on vms.size = vm_sizes.id
···
       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], agent_socket=row[12], guest_agent=row[13], acpid=row[14], 
-      last_backup_finished=last_backup_finished, host=row[16]
+      last_backup_finished=last_backup_finished, host=row[16], os=row[17]
     )
 
     self.cursor.execute(""" 

capsulflask/shell_scripts/get-guest-agent.sh

···
 #!/bin/sh -e
 
 vmname="$1"
+os_image_id="$2"
 
 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
 
+pidof_command_json='{"path":"/usr/bin/env", "arg":["pidof","acpid"], "capture-output":true}'
+if echo "$os_image_id" | grep -q 'nixos'; then
+  pidof_command_json='{"path":"/run/current-system/sw/bin/pidof", "arg":["acpid"], "capture-output":true}'
+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}}'
+  isAcpidRunning='{"execute": "guest-exec", "arguments":'"$pidof_command_json}"
   qemuAgentCommandOutput="$( { virsh qemu-agent-command "$vmname" --cmd "$isAcpidRunning" || printf '%s' 'no-qemu-guest-agent'; } |  tr -d '\n' )"
 
   if [ "$qemuAgentCommandOutput" != "no-qemu-guest-agent" ] ; then

capsulflask/spoke_api.py

···
     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'], request_body['get_agent_details'])
+  vm = current_app.config['SPOKE_MODEL'].get(request_body['id'], request_body['get_ssh_host_keys'], request_body['get_agent_details'], request_body['vm_os_id'])
   if vm is None: 
     return jsonify(dict(assignment_status="assigned"))
   return jsonify(dict(assignment_status="assigned", id=vm.id, host=vm.host, state=vm.state, ipv4=vm.ipv4, ipv6=vm.ipv6, ssh_host_keys=vm.ssh_host_keys, agent_socket=vm.agent_socket, guest_agent=vm.guest_agent, acpid=vm.acpid))

capsulflask/spoke_model.py

···
   def capacity_avaliable(self, additional_ram_bytes):
     return True
 
-  def get(self, id, get_ssh_host_keys: bool, get_agent_details: bool):
+  def get(self, id, get_ssh_host_keys: bool, get_agent_details: bool, vm_os_id: str):
     validate_capsul_id(id)
 
     ipv4 = "1.1.1.1"
···
 
     return True
 
-  def get(self, id, get_ssh_host_keys: bool, get_agent_details: bool):
+  def get(self, id, get_ssh_host_keys: bool, get_agent_details: bool, os_image_id: str):
     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)
 
+    if not re.match(r"^[a-z0-9]+$", os_image_id):
+      raise ValueError(f"os_image_id '{os_image_id}' is not a valid value")
+
     guest_agent=False
     agent_socket=False
     acpid=False
···
 
     if get_agent_details:
       try:
-        completed_process3 = run([join(current_app.root_path, 'shell_scripts/get-guest-agent.sh'), id], capture_output=True)
+        completed_process3 = run([join(current_app.root_path, 'shell_scripts/get-guest-agent.sh'), id, os_image_id], capture_output=True)
         self.validate_completed_process(completed_process3)
         result = completed_process3.stdout.decode("utf-8").strip(" \t\n\r")
-        current_app.logger.info(f"get_agent_details result: {result}")
+        #current_app.logger.info(f"get_agent_details result: {result}")
         if result != 'no-guest-agent-socket':
           agent_socket = True
         if result == "ok" or result == 'no-acpid':