Guard null host in releaseVmCapacity and reuse resolved lastHost

Two defensive fixes from Copilot's review of PR #13363:

1. releaseVmCapacity(VM, ..., Long hostId): _hostDao.findById(hostId)
   can return null when last_host_id points to a deleted host. The
   subsequent host.getHypervisorType() check would NPE. The Host
   overload already null-checks AND has the External check, so
   delegate to it instead of duplicating the External check here.

2. postStateTransitionEvent: the lastHost was being fetched twice
   (once for logging at L942, again inside releaseVmCapacity via
   the Long overload at L987). Reuse the already-resolved Host. The
   Host overload also handles null, so the explicit null check on
   getLastHostId() becomes redundant.

(Skipped Copilot's third suggestion to guard findById(null) — the
GenericDaoBase.findById(ID, boolean, Boolean) implementation at
GenericDaoBase.java:1066 explicitly returns null for null id, so
the existing code is already safe.)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Kukunin

server/src/main/java/com/cloud/capacity/CapacityManagerImpl.java

@@ -172,9 +172,6 @@ public boolean releaseVmCapacity(VirtualMachine vm, final boolean moveFromReserv
             return true;
         }
         HostVO host = _hostDao.findById(hostId);
-        if (HypervisorType.External.equals(host.getHypervisorType())) {
-            return true;
-        }
         return releaseVmCapacity(vm, moveFromReserved, moveToReserved, host);
     }
 
@@ -983,9 +980,7 @@ public boolean postStateTransitionEvent(StateMachine2.Transition<State, Event> t
       }
 
       if ((newState == State.Starting || newState == State.Migrating || event == Event.AgentReportMigrated) && vm.getHostId() != null) {
-        if (vm.getLastHostId() != null) {
-          releaseVmCapacity(vm, true, false, vm.getLastHostId());
-        }
+        releaseVmCapacity(vm, true, false, lastHost);
         allocateVmCapacity(vm);
       }
 

server/src/test/java/com/cloud/capacity/CapacityManagerImplTest.java

@@ -21,7 +21,6 @@
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.ArgumentMatchers.anyList;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.doNothing;
@@ -46,6 +45,7 @@
 
 import com.cloud.dc.ClusterDetailsDao;
 import com.cloud.host.Host;
+import com.cloud.host.HostVO;
 import com.cloud.host.dao.HostDao;
 import com.cloud.offering.ServiceOffering;
 import com.cloud.service.ServiceOfferingVO;
@@ -174,44 +174,48 @@ public void testCheckIfHostHasNoCpuCapabilityButHasCapacity() {
     public void testPostStateTransitionReleasesStaleReservationWhenStartingOnDifferentHost() {
         final Long oldHostId = 1L;
         final Long newHostId = 2L;
+        HostVO oldHost = mock(HostVO.class);
+        when(hostDao.findById(oldHostId)).thenReturn(oldHost);
 
         VirtualMachine vm = mock(VirtualMachine.class);
         when(vm.getHostId()).thenReturn(newHostId);
         when(vm.getLastHostId()).thenReturn(oldHostId);
 
         doNothing().when(capacityManager).allocateVmCapacity(any(VirtualMachine.class));
         doReturn(true).when(capacityManager).releaseVmCapacity(
-                any(VirtualMachine.class), anyBoolean(), anyBoolean(), anyLong());
+                any(VirtualMachine.class), anyBoolean(), anyBoolean(), any(Host.class));
 
         StateMachine2.Transition<State, Event> transition = new StateMachine2.Transition<>(
                 State.Stopped, Event.StartRequested, State.Starting, Collections.emptyList());
         Pair<Long, Long> opaque = new Pair<>(null, 0L);
 
         capacityManager.postStateTransitionEvent(transition, vm, true, opaque);
 
-        verify(capacityManager).releaseVmCapacity(vm, true, false, oldHostId);
+        verify(capacityManager).releaseVmCapacity(vm, true, false, oldHost);
         verify(capacityManager).allocateVmCapacity(vm);
     }
 
     @Test
     public void testPostStateTransitionReleasesReservationWhenStartingOnSameHost() {
         final Long hostId = 1L;
+        HostVO h = mock(HostVO.class);
+        when(hostDao.findById(hostId)).thenReturn(h);
 
         VirtualMachine vm = mock(VirtualMachine.class);
         when(vm.getHostId()).thenReturn(hostId);
         when(vm.getLastHostId()).thenReturn(hostId);
 
         doNothing().when(capacityManager).allocateVmCapacity(any(VirtualMachine.class));
         doReturn(true).when(capacityManager).releaseVmCapacity(
-                any(VirtualMachine.class), anyBoolean(), anyBoolean(), anyLong());
+                any(VirtualMachine.class), anyBoolean(), anyBoolean(), any(Host.class));
 
         StateMachine2.Transition<State, Event> transition = new StateMachine2.Transition<>(
                 State.Stopped, Event.StartRequested, State.Starting, Collections.emptyList());
         Pair<Long, Long> opaque = new Pair<>(null, 0L);
 
         capacityManager.postStateTransitionEvent(transition, vm, true, opaque);
 
-        verify(capacityManager).releaseVmCapacity(vm, true, false, hostId);
+        verify(capacityManager).releaseVmCapacity(vm, true, false, h);
         verify(capacityManager).allocateVmCapacity(vm);
     }