Scope host tag-rule matches to deployment plan in allocators

engine/schema/src/main/java/com/cloud/host/dao/HostDao.java

@@ -182,6 +182,7 @@ public interface HostDao extends GenericDao<HostVO, Long>, StateDao<Status, Stat
     List<String> listOrderedHostsHypervisorVersionsInDatacenter(long datacenterId, HypervisorType hypervisorType);
 
     List<HostVO> findHostsWithTagRuleThatMatchComputeOferringTags(String computeOfferingTags);
+    List<HostVO> findHostsWithTagRuleThatMatchComputeOferringTags(String computeOfferingTags, Long clusterId, Long podId, Long dcId);
 
     List<Long> findClustersThatMatchHostTagRule(String computeOfferingTags);
 

engine/schema/src/main/java/com/cloud/host/dao/HostDaoImpl.java

@@ -1456,6 +1456,7 @@ private List<Long> findHostIdsByHostTags(String hostTags){
         }
     }
 
+    @Override
     public List<HostVO> findHostsWithTagRuleThatMatchComputeOferringTags(String computeOfferingTags) {
         List<HostTagVO> hostTagVOList = _hostTagsDao.findHostRuleTags();
         List<HostVO> result = new ArrayList<>();
@@ -1468,6 +1469,20 @@ public List<HostVO> findHostsWithTagRuleThatMatchComputeOferringTags(String comp
         return result;
     }
 
+    @Override
+    public List<HostVO> findHostsWithTagRuleThatMatchComputeOferringTags(String computeOfferingTags, Long clusterId, Long podId, Long dcId) {
+        List<HostVO> hosts = findHostsWithTagRuleThatMatchComputeOferringTags(computeOfferingTags);
+        if (dcId == null && podId == null && clusterId == null) {
+            return hosts;
+        }
+
+        return hosts.stream()
+                .filter(host -> host != null && (dcId == null || host.getDataCenterId() == dcId))
+                .filter(host -> podId == null || Objects.equals(host.getPodId(), podId))
+                .filter(host -> clusterId == null || Objects.equals(host.getClusterId(), clusterId))
+                .collect(Collectors.toList());
+    }
+
     public List<Long> findClustersThatMatchHostTagRule(String computeOfferingTags) {
         Set<Long> result = new HashSet<>();
         List<HostVO> hosts = findHostsWithTagRuleThatMatchComputeOferringTags(computeOfferingTags);

plugins/host-allocators/random/src/main/java/com/cloud/agent/manager/allocator/impl/RandomAllocator.java

@@ -122,7 +122,7 @@ private List<Host> findSuitableHosts(VirtualMachineProfile vmProfile, Deployment
                 hostsCopy = _hostDao.listAllHostsThatHaveNoRuleTag(type, clusterId, podId, dcId);
             }
         }
-        hostsCopy = ListUtils.union(hostsCopy, _hostDao.findHostsWithTagRuleThatMatchComputeOferringTags(offeringHostTag));
+        hostsCopy = ListUtils.union(hostsCopy, _hostDao.findHostsWithTagRuleThatMatchComputeOferringTags(offeringHostTag, clusterId, podId, dcId));
 
         if (hostsCopy.isEmpty()) {
             logger.info("No suitable host found for VM [{}] in {}.", vmProfile, hostTag);

plugins/host-allocators/random/src/test/java/com/cloud/agent/manager/allocator/impl/RandomAllocatorTest.java

@@ -28,15 +28,24 @@
 import org.mockito.Mockito;
 import org.mockito.junit.MockitoJUnitRunner;
 
+import com.cloud.deploy.DeploymentPlan;
+import com.cloud.deploy.DeploymentPlanner.ExcludeList;
 import com.cloud.host.Host;
 import com.cloud.host.HostVO;
 import com.cloud.host.dao.HostDao;
+import com.cloud.capacity.CapacityManager;
+import com.cloud.offering.ServiceOffering;
+import com.cloud.storage.VMTemplateVO;
+import com.cloud.utils.Pair;
+import com.cloud.vm.VirtualMachineProfile;
 
 @RunWith(MockitoJUnitRunner.class)
 public class RandomAllocatorTest {
 
     @Mock
     HostDao hostDao;
+    @Mock
+    CapacityManager capacityManager;
     @InjectMocks
     RandomAllocator randomAllocator;
 
@@ -77,4 +86,37 @@
         Assert.assertFalse(CollectionUtils.isEmpty(result));
         Assert.assertEquals(1, result.size());
     }
+
+    @Test
+    public void testAllocateToUsesScopedRuleTagLookup() {
+        Host.Type type = Host.Type.Routing;
+        long dcId = 1L;
+        Long podId = 2L;
+        Long clusterId = 3L;
+        String offeringTag = "compute";
+
+        DeploymentPlan plan = Mockito.mock(DeploymentPlan.class);
+        Mockito.when(plan.getDataCenterId()).thenReturn(dcId);
+        Mockito.when(plan.getPodId()).thenReturn(podId);
+        Mockito.when(plan.getClusterId()).thenReturn(clusterId);
+
+        VirtualMachineProfile vmProfile = Mockito.mock(VirtualMachineProfile.class);
+        ServiceOffering offering = Mockito.mock(ServiceOffering.class);
+        VMTemplateVO template = Mockito.mock(VMTemplateVO.class);
+        Mockito.when(vmProfile.getServiceOffering()).thenReturn(offering);
+        Mockito.when(vmProfile.getTemplate()).thenReturn(template);
+        Mockito.when(offering.getHostTag()).thenReturn(offeringTag);
+
+        HostVO host = Mockito.mock(HostVO.class);
+        List<Host> hosts = List.of(host);
+        Mockito.when(hostDao.listByHostTag(type, clusterId, podId, dcId, offeringTag)).thenReturn(List.of(host));
+        Mockito.when(hostDao.findHostsWithTagRuleThatMatchComputeOferringTags(offeringTag, clusterId, podId, dcId)).thenReturn(new ArrayList<>());
+        Mockito.when(capacityManager.checkIfHostHasCpuCapabilityAndCapacity(host, offering, true)).thenReturn(new Pair<>(true, true));
+
+        List<Host> result = randomAllocator.allocateTo(vmProfile, plan, type, new ExcludeList(), hosts, 1, true);
+
+        Assert.assertEquals(1, result.size());
+        Mockito.verify(hostDao).findHostsWithTagRuleThatMatchComputeOferringTags(offeringTag, clusterId, podId, dcId);
+        Mockito.verify(hostDao, Mockito.never()).findHostsWithTagRuleThatMatchComputeOferringTags(offeringTag);
+    }
 }

server/src/main/java/com/cloud/agent/manager/allocator/impl/FirstFitAllocator.java

@@ -198,7 +198,7 @@ public List<Host> allocateTo(VirtualMachineProfile vmProfile, DeploymentPlan pla
             clusterHosts.retainAll(hostsMatchingUefiTag);
         }
 
-        clusterHosts.addAll(_hostDao.findHostsWithTagRuleThatMatchComputeOferringTags(hostTagOnOffering));
+        clusterHosts.addAll(_hostDao.findHostsWithTagRuleThatMatchComputeOferringTags(hostTagOnOffering, clusterId, podId, dcId));
 
 
         if (clusterHosts.isEmpty()) {
@@ -274,7 +274,7 @@ public List<Host> allocateTo(VirtualMachineProfile vmProfile, DeploymentPlan pla
             }
         }
 
-        hostsCopy.addAll(_hostDao.findHostsWithTagRuleThatMatchComputeOferringTags(hostTagOnOffering));
+        hostsCopy.addAll(_hostDao.findHostsWithTagRuleThatMatchComputeOferringTags(hostTagOnOffering, clusterId, podId, dcId));
 
         if (!hostsCopy.isEmpty()) {
             suitableHosts = allocateTo(plan, offering, template, avoid, hostsCopy, returnUpTo, considerReservedCapacity, account);

server/src/test/java/com/cloud/agent/manager/allocator/impl/FirstFitAllocatorTest.java

@@ -0,0 +1,85 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+package com.cloud.agent.manager.allocator.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.Spy;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import com.cloud.deploy.DeploymentPlan;
+import com.cloud.deploy.DeploymentPlanner.ExcludeList;
+import com.cloud.host.Host;
+import com.cloud.host.HostVO;
+import com.cloud.host.dao.HostDao;
+import com.cloud.offering.ServiceOffering;
+import com.cloud.storage.VMTemplateVO;
+import com.cloud.user.Account;
+import com.cloud.vm.VirtualMachineProfile;
+
+@RunWith(MockitoJUnitRunner.class)
+public class FirstFitAllocatorTest {
+
+    @Mock
+    HostDao hostDao;
+    @Spy
+    @InjectMocks
+    FirstFitAllocator firstFitAllocator;
+
+    @Test
+    public void testAllocateToWithHostsUsesScopedRuleTagLookup() {
+        Host.Type type = Host.Type.Routing;
+        long dcId = 1L;
+        Long podId = 2L;
+        Long clusterId = 3L;
+        String offeringTag = "compute";
+
+        DeploymentPlan plan = Mockito.mock(DeploymentPlan.class);
+        Mockito.when(plan.getDataCenterId()).thenReturn(dcId);
+        Mockito.when(plan.getPodId()).thenReturn(podId);
+        Mockito.when(plan.getClusterId()).thenReturn(clusterId);
+
+        VirtualMachineProfile vmProfile = Mockito.mock(VirtualMachineProfile.class);
+        ServiceOffering offering = Mockito.mock(ServiceOffering.class);
+        VMTemplateVO template = Mockito.mock(VMTemplateVO.class);
+        Account account = Mockito.mock(Account.class);
+        Mockito.when(vmProfile.getServiceOffering()).thenReturn(offering);
+        Mockito.when(vmProfile.getTemplate()).thenReturn(template);
+        Mockito.when(vmProfile.getOwner()).thenReturn(account);
+        Mockito.when(offering.getHostTag()).thenReturn(offeringTag);
+
+        HostVO host = Mockito.mock(HostVO.class);
+        List<Host> selectedHosts = List.of(host);
+        Mockito.when(hostDao.listByHostTag(type, clusterId, podId, dcId, offeringTag)).thenReturn(List.of(host));
+        Mockito.when(hostDao.findHostsWithTagRuleThatMatchComputeOferringTags(offeringTag, clusterId, podId, dcId)).thenReturn(new ArrayList<>());
+        Mockito.doReturn(selectedHosts).when(firstFitAllocator).allocateTo(
+                Mockito.eq(plan), Mockito.eq(offering), Mockito.eq(template), Mockito.any(ExcludeList.class), Mockito.anyList(), Mockito.eq(1), Mockito.eq(true), Mockito.eq(account));
+
+        List<Host> result = firstFitAllocator.allocateTo(vmProfile, plan, type, new ExcludeList(), selectedHosts, 1, true);
+
+        Assert.assertEquals(1, result.size());
+        Mockito.verify(hostDao).findHostsWithTagRuleThatMatchComputeOferringTags(offeringTag, clusterId, podId, dcId);
+        Mockito.verify(hostDao, Mockito.never()).findHostsWithTagRuleThatMatchComputeOferringTags(offeringTag);
+    }
+}