diff --git a/cli/cli-interpreter/src/main/java/org/infinispan/cli/interpreter/statement/SiteStatement.java b/cli/cli-interpreter/src/main/java/org/infinispan/cli/interpreter/statement/SiteStatement.java
index 87b3ab52d48..f506468be26 100644
--- a/cli/cli-interpreter/src/main/java/org/infinispan/cli/interpreter/statement/SiteStatement.java
+++ b/cli/cli-interpreter/src/main/java/org/infinispan/cli/interpreter/statement/SiteStatement.java
@@ -1,9 +1,5 @@
 package org.infinispan.cli.interpreter.statement;
 
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
 import org.infinispan.Cache;
 import org.infinispan.cli.interpreter.logging.Log;
 import org.infinispan.cli.interpreter.result.EmptyResult;
@@ -11,9 +7,15 @@
 import org.infinispan.cli.interpreter.result.StatementException;
 import org.infinispan.cli.interpreter.result.StringResult;
 import org.infinispan.cli.interpreter.session.Session;
+import org.infinispan.manager.EmbeddedCacheManager;
 import org.infinispan.util.logging.LogFactory;
+import org.infinispan.xsite.GlobalXSiteAdminOperations;
 import org.infinispan.xsite.XSiteAdminOperations;
 
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
 /**
  * Performs operation related to Cross-Site Replication
  *
@@ -23,8 +25,9 @@
 public class SiteStatement implements Statement {
    private static final Log log = LogFactory.getLog(SiteStatement.class, Log.class);
 
-   static enum Options {
-      OFFLINE, ONLINE, STATUS, PUSH, CANCELPUSH, CANCELRECEIVE, PUSHSTATUS, CLEARPUSHSTATUS, SENDINGSITE
+   enum Options {
+      OFFLINE, ONLINE, STATUS, PUSH, CANCELPUSH, CANCELRECEIVE, PUSHSTATUS, CLEARPUSHSTATUS, SENDINGSITE,
+      ONLINEALL, OFFLINEALL, PUSHALL, CANCELPUSHALL
    }
 
    final private SiteData siteData;
@@ -37,31 +40,36 @@ public SiteStatement(List<Option> options, SiteData siteData) {
 
    @Override
    public Result execute(Session session) throws StatementException {
+      if (options.isEmpty()) {
+         return EmptyResult.RESULT;
+      }
+      Options option = options.get(0).toEnum(Options.class);
+      if (isGlobalOption(option)) {
+         return executeContainerOperation(option, session);
+      } else {
+         return executeCacheOperation(option, session);
+      }
+
+   }
+
+   private Result executeCacheOperation(Options option, Session session) throws StatementException {
       Cache<Object, Object> cache = session.getCache(siteData != null ? siteData.getCacheName() : null);
       String siteName = siteData != null ? siteData.getSiteName() : null;
       XSiteAdminOperations xsiteAdmin = cache.getAdvancedCache().getComponentRegistry().getComponent(XSiteAdminOperations.class);
-      if (xsiteAdmin == null) {
-         throw log.noBackupsForCache(cache.getName());
-      }
-      for (Option opt : options) {
-         switch (opt.toEnum(Options.class)) {
+
+      requireXSiteAdmin(xsiteAdmin, cache.getName());
+
+      switch (option) {
          case STATUS: {
-            String status = siteName == null ? xsiteAdmin.status() : xsiteAdmin.siteStatus(siteName);
-            return new StringResult(status);
+            return new StringResult(siteName == null ? xsiteAdmin.status() : xsiteAdmin.siteStatus(siteName));
          }
          case ONLINE: {
-            if (siteName != null) {
-               return new StringResult(xsiteAdmin.bringSiteOnline(siteName));
-            } else {
-               throw log.siteNameNotSpecified();
-            }
+            requireSiteName(siteName);
+            return new StringResult(xsiteAdmin.bringSiteOnline(siteName));
          }
          case OFFLINE: {
-            if (siteName != null) {
-               return new StringResult(xsiteAdmin.takeSiteOffline(siteName));
-            } else {
-               throw log.siteNameNotSpecified();
-            }
+            requireSiteName(siteName);
+            return new StringResult(xsiteAdmin.takeSiteOffline(siteName));
          }
          case PUSH: {
             requireSiteName(siteName);
@@ -84,10 +92,51 @@ public Result execute(Session session) throws StatementException {
          case SENDINGSITE: {
             return new StringResult(xsiteAdmin.getSendingSiteName());
          }
+         default:
+            return EmptyResult.RESULT;
+      }
+   }
+
+   private Result executeContainerOperation(Options option, Session session) throws StatementException {
+      EmbeddedCacheManager cacheManager = session.getCacheManager();
+      GlobalXSiteAdminOperations xSiteAdmin = cacheManager.getGlobalComponentRegistry().getComponent(GlobalXSiteAdminOperations.class);
+      String siteName = siteData != null ? siteData.getSiteName() : null;
+      requireSiteName(siteName);
+
+      switch (option) {
+         case OFFLINEALL: {
+            return new StringResult(xSiteAdmin.takeSiteOffline(siteName));
+         }
+         case ONLINEALL: {
+            return new StringResult(xSiteAdmin.bringSiteOnline(siteName));
          }
+         case PUSHALL: {
+            return new StringResult(xSiteAdmin.pushState(siteName));
+         }
+         case CANCELPUSHALL: {
+            return new StringResult(xSiteAdmin.cancelPushState(siteName));
+         }
+         default:
+            return EmptyResult.RESULT;
       }
+   }
 
-      return EmptyResult.RESULT;
+   private static boolean isGlobalOption(Options option) {
+      switch (option) {
+         case OFFLINEALL:
+         case ONLINEALL:
+         case PUSHALL:
+         case CANCELPUSHALL:
+            return true;
+         default:
+            return false;
+      }
+   }
+
+   private static void requireXSiteAdmin(XSiteAdminOperations xSiteAdminOperations, String cacheName) throws StatementException {
+      if (xSiteAdminOperations == null) {
+         throw log.noBackupsForCache(cacheName);
+      }
    }
 
    private static void requireSiteName(String siteName) throws StatementException {
diff --git a/cli/cli-interpreter/src/test/java/org/infinispan/cli/interpreter/SiteStatementTest.java b/cli/cli-interpreter/src/test/java/org/infinispan/cli/interpreter/SiteStatementTest.java
index a6a0229543f..6deb0eabba4 100644
--- a/cli/cli-interpreter/src/test/java/org/infinispan/cli/interpreter/SiteStatementTest.java
+++ b/cli/cli-interpreter/src/test/java/org/infinispan/cli/interpreter/SiteStatementTest.java
@@ -2,6 +2,7 @@
 
 import org.infinispan.Cache;
 import org.infinispan.cli.interpreter.result.ResultKeys;
+import org.infinispan.commons.api.BasicCacheContainer;
 import org.infinispan.configuration.cache.CacheMode;
 import org.infinispan.configuration.cache.ConfigurationBuilder;
 import org.infinispan.context.Flag;
@@ -9,16 +10,20 @@
 import org.infinispan.statetransfer.CommitManager;
 import org.infinispan.test.CacheManagerCallable;
 import org.infinispan.xsite.AbstractTwoSitesTest;
+import org.infinispan.xsite.XSiteAdminOperations;
 import org.infinispan.xsite.statetransfer.XSiteStateProvider;
 import org.infinispan.xsite.statetransfer.XSiteStateTransferManager;
 import org.testng.annotations.Test;
 
 import java.util.Map;
+import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 
+import static java.lang.String.format;
 import static org.infinispan.test.TestingUtil.extractComponent;
 import static org.infinispan.test.TestingUtil.withCacheManager;
 import static org.testng.AssertJUnit.assertEquals;
+import static org.testng.AssertJUnit.fail;
 
 /**
  * @author Tristan Tarrant
@@ -27,6 +32,10 @@
 @Test(groups = "xsite", testName = "cli.interpreter.SiteStatementTest")
 public class SiteStatementTest extends AbstractTwoSitesTest {
 
+   public SiteStatementTest() {
+      implicitBackupCache = true;
+   }
+
    @Override
    protected ConfigurationBuilder getNycActiveConfig() {
       return getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true);
@@ -47,7 +56,7 @@ public void testSiteStatus() throws Exception {
 
       assertInterpreterOutput(lonInterpreter, lonSessionId, "site --status NYC;", "online");
 
-      assertInterpreterOutput(nycInterpreter, nycSessionId, String.format("site --status %s.LON;", lonCache), "online");
+      assertInterpreterOutput(nycInterpreter, nycSessionId, format("site --status %s.LON;", lonCache), "online");
 
       assertInterpreterOutput(lonInterpreter, lonSessionId, "site --offline NYC;", "ok");
 
@@ -73,7 +82,7 @@ public void testSiteStateTransfer() throws Exception {
       assertInterpreterOutput(nycInterpreter, nycSessionId, "site --sendingsite;", "null");
       assertInterpreterOutput(lonInterpreter, lonSessionId, "site --pushstatus;", "NYC=OK");
       assertInterpreterOutput(lonInterpreter, lonSessionId, "site --clearpushstatus;", "ok");
-      assertInterpreterOutput(lonInterpreter, lonSessionId, "site --pushstatus;", null);
+      assertInterpreterOutput(lonInterpreter, lonSessionId, "site --pushstatus;", (String) null);
       assertInterpreterOutput(lonInterpreter, lonSessionId, "site --cancelpush NYC;", "ok");
       assertInterpreterOutput(nycInterpreter, nycSessionId, "site --cancelreceive LON;", "ok");
    }
@@ -97,17 +106,98 @@ public void call() {
             }
          }
       });
+   }
+
+   public void testContainerOperations() throws Exception {
+      site(LON).cacheManagers().forEach(cacheManager -> cacheManager.defineConfiguration("another-cache", lonConfigurationBuilder().build()));
+      site(LON).cacheManagers().forEach(cacheManager -> cacheManager.defineConfiguration("another-cache-2", getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC).build()));
+      site(LON).waitForClusterToForm("another-cache");
+      site(LON).waitForClusterToForm("another-cache-2");
+
+      Interpreter lonInterpreter = interpreter(LON, 0);
+      String lonCache = cache(LON, 0).getName();
+      String lonSessionId = lonInterpreter.createSessionId(lonCache);
+
+      assertInterpreterOutput(lonInterpreter, lonSessionId, "site --offlineall NYC;", (output, error) -> {
+         assertEquals(null, error);
+         String outFormat = "%s: %s";
+         if (!output.contains(format(outFormat, BasicCacheContainer.DEFAULT_CACHE_NAME, XSiteAdminOperations.SUCCESS))) {
+            fail(format("Cache '%s' should be present in the output: %s", BasicCacheContainer.DEFAULT_CACHE_NAME, output));
+         }
+         if (!output.contains(format(outFormat, "another-cache", XSiteAdminOperations.SUCCESS))) {
+            fail(format("Cache '%s' should be present in the output: %s", "another-cache", output));
+         }
+         if (output.contains("another-cache-2")) {
+            fail(format("Cache '%s' should not be present in the output: %s", "another-cache-2", output));
+         }
+      });
+      assertInterpreterOutput(lonInterpreter, lonSessionId, "site --status NYC;", "offline");
+      assertInterpreterOutput(lonInterpreter, lonSessionId, "site --status \"another-cache\".NYC;", "offline");
+
+      assertInterpreterOutput(lonInterpreter, lonSessionId, "site --onlineall NYC;", (output, error) -> {
+         assertEquals(null, error);
+         String outFormat = "%s: %s";
+         if (!output.contains(format(outFormat, BasicCacheContainer.DEFAULT_CACHE_NAME, XSiteAdminOperations.SUCCESS))) {
+            fail(format("Cache '%s' should be present in the output: %s", BasicCacheContainer.DEFAULT_CACHE_NAME, output));
+         }
+         if (!output.contains(format(outFormat, "another-cache", XSiteAdminOperations.SUCCESS))) {
+            fail(format("Cache '%s' should be present in the output: %s", "another-cache", output));
+         }
+         if (output.contains("another-cache-2")) {
+            fail(format("Cache '%s' should not be present in the output: %s", "another-cache-2", output));
+         }
+      });
+      assertInterpreterOutput(lonInterpreter, lonSessionId, "site --status NYC;", "online");
+      assertInterpreterOutput(lonInterpreter, lonSessionId, "site --status \"another-cache\".NYC;", "online");
+
+      assertInterpreterOutput(lonInterpreter, lonSessionId, "site --pushall NYC;", (output, error) -> {
+         assertEquals(null, error);
+         String outFormat = "%s: %s";
+         if (!output.contains(format(outFormat, BasicCacheContainer.DEFAULT_CACHE_NAME, XSiteAdminOperations.SUCCESS))) {
+            fail(format("Cache '%s' should be present in the output: %s", BasicCacheContainer.DEFAULT_CACHE_NAME, output));
+         }
+         if (!output.contains(format(outFormat, "another-cache", XSiteAdminOperations.SUCCESS))) {
+            fail(format("Cache '%s' should be present in the output: %s", "another-cache", output));
+         }
+         if (output.contains("another-cache-2")) {
+            fail(format("Cache '%s' should not be present in the output: %s", "another-cache-2", output));
+         }
+      });
+
+      assertInterpreterOutput(lonInterpreter, lonSessionId, "site --cancelpushall NYC;", (output, error) -> {
+         assertEquals(null, error);
+         String outFormat = "%s: %s";
+         if (!output.contains(format(outFormat, BasicCacheContainer.DEFAULT_CACHE_NAME, XSiteAdminOperations.SUCCESS))) {
+            fail(format("Cache '%s' should be present in the output: %s", BasicCacheContainer.DEFAULT_CACHE_NAME, output));
+         }
+         if (!output.contains(format(outFormat, "another-cache", XSiteAdminOperations.SUCCESS))) {
+            fail(format("Cache '%s' should be present in the output: %s", "another-cache", output));
+         }
+         if (output.contains("another-cache-2")) {
+            fail(format("Cache '%s' should not be present in the output: %s", "another-cache-2", output));
+         }
+      });
 
    }
 
-   private void assertInterpreterOutput(Interpreter interpreter, String sessionId, String command, String output) throws Exception {
-      Map<String, String> result = interpreter.execute(sessionId, command);
-      assertEquals(output, result.get(ResultKeys.OUTPUT.toString()));
+   private void assertInterpreterOutput(Interpreter interpreter, String sessionId, String command, String expected) throws Exception {
+      assertInterpreterOutput(interpreter, sessionId, command, (output, error) -> {
+         assertEquals(null, error);
+         assertEquals(expected, output);
+      });
    }
 
-   private void assertInterpreterError(Interpreter interpreter, String sessionId, String command, String output) throws Exception {
+   private void assertInterpreterOutput(Interpreter interpreter, String sessionId, String command, OutputValidator validator) throws Exception {
+      Objects.requireNonNull(validator);
       Map<String, String> result = interpreter.execute(sessionId, command);
-      assertEquals(output, result.get(ResultKeys.ERROR.toString()));
+      validator.validate(result.get(ResultKeys.OUTPUT.toString()), result.get(ResultKeys.ERROR.toString()));
+   }
+
+   private void assertInterpreterError(Interpreter interpreter, String sessionId, String command, String expected) throws Exception {
+      assertInterpreterOutput(interpreter, sessionId, command, (output, error) -> {
+         assertEquals(null, output);
+         assertEquals(expected, error);
+      });
    }
 
    private Interpreter interpreter(String site, int cache) {
@@ -115,25 +205,21 @@ private Interpreter interpreter(String site, int cache) {
    }
 
    private void assertEventuallyNoStateTransferInReceivingSite(String siteName, String cacheName, long timeout, TimeUnit unit) {
-      assertEventuallyInSite(siteName, cacheName, new EventuallyAssertCondition<Object, Object>() {
-         @Override
-         public boolean assertInCache(Cache<Object, Object> cache) {
-            CommitManager commitManager = extractComponent(cache, CommitManager.class);
-            return !commitManager.isTracking(Flag.PUT_FOR_STATE_TRANSFER) &&
-                  !commitManager.isTracking(Flag.PUT_FOR_X_SITE_STATE_TRANSFER) &&
-                  commitManager.isEmpty();
-         }
+      assertEventuallyInSite(siteName, cacheName, cache -> {
+         CommitManager commitManager = extractComponent(cache, CommitManager.class);
+         return !commitManager.isTracking(Flag.PUT_FOR_STATE_TRANSFER) &&
+               !commitManager.isTracking(Flag.PUT_FOR_X_SITE_STATE_TRANSFER) &&
+               commitManager.isEmpty();
       }, timeout, unit);
    }
 
    private void assertEventuallyNoStateTransferInSendingSite(String siteName, String cacheName, long timeout, TimeUnit unit) {
-      assertEventuallyInSite(siteName, cacheName, new EventuallyAssertCondition<Object, Object>() {
-         @Override
-         public boolean assertInCache(Cache<Object, Object> cache) {
-            return extractComponent(cache, XSiteStateProvider.class).getCurrentStateSending().isEmpty() &&
-                  extractComponent(cache, XSiteStateTransferManager.class).getRunningStateTransfers().isEmpty();
-         }
-      }, timeout, unit);
+      assertEventuallyInSite(siteName, cacheName, cache ->
+            extractComponent(cache, XSiteStateProvider.class).getCurrentStateSending().isEmpty() &&
+            extractComponent(cache, XSiteStateTransferManager.class).getRunningStateTransfers().isEmpty(), timeout, unit);
    }
 
+   private interface OutputValidator {
+      void validate(String output, String error);
+   }
 }
diff --git a/core/src/main/java/org/infinispan/factories/GlobalComponentRegistry.java b/core/src/main/java/org/infinispan/factories/GlobalComponentRegistry.java
index 0452ae73bb7..d27c256479a 100644
--- a/core/src/main/java/org/infinispan/factories/GlobalComponentRegistry.java
+++ b/core/src/main/java/org/infinispan/factories/GlobalComponentRegistry.java
@@ -32,6 +32,7 @@
 import org.infinispan.util.TimeService;
 import org.infinispan.util.logging.Log;
 import org.infinispan.util.logging.LogFactory;
+import org.infinispan.xsite.GlobalXSiteAdminOperations;
 
 import javax.management.MBeanServer;
 import javax.management.MBeanServerFactory;
@@ -115,6 +116,7 @@ public GlobalComponentRegistry(GlobalConfiguration configuration,
          registerComponent(new InternalCacheRegistryImpl(), InternalCacheRegistry.class);
          registerComponent(new ClusterRegistryImpl(), ClusterRegistry.class);
          registerComponent(new CacheStoreFactoryRegistry(), CacheStoreFactoryRegistry.class);
+         registerComponent(new GlobalXSiteAdminOperations(), GlobalXSiteAdminOperations.class);
 
          moduleProperties.loadModuleCommandHandlers(configuredClassLoader);
          Map<Byte, ModuleCommandFactory> factories = moduleProperties.moduleCommandFactories();
diff --git a/core/src/main/java/org/infinispan/xsite/GlobalXSiteAdminOperations.java b/core/src/main/java/org/infinispan/xsite/GlobalXSiteAdminOperations.java
new file mode 100644
index 00000000000..56be0db71d8
--- /dev/null
+++ b/core/src/main/java/org/infinispan/xsite/GlobalXSiteAdminOperations.java
@@ -0,0 +1,128 @@
+package org.infinispan.xsite;
+
+import org.infinispan.Cache;
+import org.infinispan.factories.annotations.Inject;
+import org.infinispan.factories.scopes.Scope;
+import org.infinispan.factories.scopes.Scopes;
+import org.infinispan.jmx.annotations.MBean;
+import org.infinispan.jmx.annotations.ManagedOperation;
+import org.infinispan.jmx.annotations.Parameter;
+import org.infinispan.manager.EmbeddedCacheManager;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * A per-container (cache manager) cross-site admin operations.
+ * <p>
+ * All the operations invoked in this class will be applied to all caches which remotely backups its data.
+ *
+ * @author Pedro Ruivo
+ * @since 8.1
+ */
+@Scope(Scopes.GLOBAL)
+@MBean(objectName = "GlobalXSiteAdminOperations", description = "Exposes tooling for handling backing up data to remote sites.")
+public class GlobalXSiteAdminOperations {
+
+   public static final String CACHE_DELIMITER = ",";
+
+   private EmbeddedCacheManager cacheManager;
+
+   private static void addCacheAdmin(Cache cache, List<CacheXSiteAdminOperation> list) {
+      if (cache != null) {
+         XSiteAdminOperations operation = cache.getAdvancedCache().getComponentRegistry().getComponent(XSiteAdminOperations.class);
+         if (operation != null) {
+            list.add(new CacheXSiteAdminOperation(cache.getName(), operation));
+         }
+      }
+   }
+
+   @Inject
+   public void inject(EmbeddedCacheManager cacheManager) {
+      this.cacheManager = cacheManager;
+   }
+
+   @ManagedOperation(
+         description = "Takes this site offline in all caches in the cluster.",
+         displayName = "Takes this site offline in all caches in the cluster."
+   )
+   public String takeSiteOffline(@Parameter(name = "site", description = "The name of the backup site") String site) {
+      return performOperation(operations -> operations.takeSiteOffline(site));
+   }
+
+   @ManagedOperation(
+         description = "Brings the given site back online on all the caches.",
+         displayName = "Brings the given site back online on all the caches."
+   )
+   public String bringSiteOnline(@Parameter(name = "site", description = "The name of the backup site") String site) {
+      return performOperation(operations -> operations.bringSiteOnline(site));
+   }
+
+   @ManagedOperation(
+         displayName = "Push state to site",
+         description = "Pushes the state of all caches to the corresponding remote site if the cache backups to it. " +
+               "The remote site will be bring back online",
+         name = "pushState"
+   )
+   public final String pushState(@Parameter(description = "The destination site name", name = "SiteName") String site) {
+      return performOperation(operations -> operations.pushState(site));
+   }
+
+   @ManagedOperation(
+         displayName = "Cancel Push State",
+         description = "Cancels the push state on all the caches to remote site.",
+         name = "CancelPushState"
+   )
+   public final String cancelPushState(@Parameter(description = "The destination site name", name = "SiteName")
+                                       final String site) {
+      return performOperation(operations -> operations.cancelPushState(site));
+   }
+
+   private String performOperation(Operation operation) {
+      final Iterator<CacheXSiteAdminOperation> iterator = collectXSiteAdminOperation().iterator();
+      if (!iterator.hasNext()) {
+         return XSiteAdminOperations.SUCCESS;
+      }
+      StringBuilder builder = new StringBuilder();
+      while (iterator.hasNext()) {
+         CacheXSiteAdminOperation xsiteAdminOperation = iterator.next();
+         try {
+            String result = operation.execute(xsiteAdminOperation.xSiteAdminOperations);
+            builder.append(xsiteAdminOperation.cacheName).append(": ").append(result);
+            if (iterator.hasNext()) {
+               builder.append(CACHE_DELIMITER);
+            }
+         } catch (Exception e) {
+            builder.append("Exception on ").append(xsiteAdminOperation.cacheName).append(": ").append(e.getMessage());
+         }
+      }
+      return builder.length() == 0 ? XSiteAdminOperations.SUCCESS : builder.toString();
+   }
+
+   private Collection<CacheXSiteAdminOperation> collectXSiteAdminOperation() {
+      Collection<String> cacheNames = cacheManager.getCacheNames();
+      List<CacheXSiteAdminOperation> operations = new ArrayList<>(cacheNames.size() + 1);
+      for (String cacheName : cacheNames) {
+         addCacheAdmin(cacheManager.getCache(cacheName, false), operations);
+      }
+      addCacheAdmin(cacheManager.getCache(), operations);
+      return operations;
+   }
+
+   private interface Operation {
+      String execute(XSiteAdminOperations admins);
+   }
+
+   private static class CacheXSiteAdminOperation {
+      private final String cacheName;
+      private final XSiteAdminOperations xSiteAdminOperations;
+
+      private CacheXSiteAdminOperation(String cacheName, XSiteAdminOperations xSiteAdminOperations) {
+         this.cacheName = cacheName;
+         this.xSiteAdminOperations = xSiteAdminOperations;
+      }
+   }
+
+}
diff --git a/core/src/test/java/org/infinispan/xsite/AbstractMultipleSitesTest.java b/core/src/test/java/org/infinispan/xsite/AbstractMultipleSitesTest.java
new file mode 100644
index 00000000000..d651e299963
--- /dev/null
+++ b/core/src/test/java/org/infinispan/xsite/AbstractMultipleSitesTest.java
@@ -0,0 +1,101 @@
+package org.infinispan.xsite;
+
+import org.infinispan.configuration.cache.ConfigurationBuilder;
+import org.infinispan.configuration.global.GlobalConfigurationBuilder;
+
+/**
+ * Abstract test class that allows to create multiple combination of sites and nodes.
+ * <p>
+ * So far, each site only has the same number of nodes. But it can modified to support asymmetric number of nodes per
+ * site.
+ *
+ * @author Pedro Ruivo
+ * @since 8.1
+ */
+public abstract class AbstractMultipleSitesTest extends AbstractXSiteTest {
+
+   //if more sites are needed, you have to update these constants and the configuration file in config/xsite/relay-config.xml
+   //the SITE_NAME should have the same site name as in configuration
+   private static final int MAX_NUM_SITE = 3;
+   private static final String[] SITE_NAME = new String[]{"LON", "NYC", "SFO"};
+
+   /**
+    * It returns the number of sites to create.
+    * <p>
+    * It may be overwrite for different number of sites needed. The default value is 2 and it the value should be less
+    * than {@link #MAX_NUM_SITE}.
+    */
+   protected int defaultNumberOfSites() {
+      return 2;
+   }
+
+   /**
+    * @return the number of nodes per site.
+    */
+   protected int defaultNumberOfNodes() {
+      return 2;
+   }
+
+   /**
+    * The default cache configuration for that site index.
+    *
+    * @param siteIndex the site index.
+    */
+   protected ConfigurationBuilder defaultConfigurationForSite(int siteIndex) {
+      return new ConfigurationBuilder();
+   }
+
+   /**
+    * The default global configuration for a site.
+    *
+    * @param siteIndex the site index.
+    */
+   protected GlobalConfigurationBuilder defaultGlobalConfigurationForSite(int siteIndex) {
+      GlobalConfigurationBuilder builder = GlobalConfigurationBuilder.defaultClusteredBuilder();
+      builder.site().localSite(siteName(siteIndex));
+      return builder;
+   }
+
+   /**
+    * It converts the site index to a name.
+    *
+    * @param siteIndex the site index to be converted.
+    * @return the site name corresponding to the site index.
+    */
+   protected final String siteName(int siteIndex) {
+      assertValidSiteIndex(siteIndex);
+      return SITE_NAME[siteIndex];
+   }
+
+   /**
+    * Invoked after all the sites and default caches are created.
+    */
+   protected void afterSitesCreated() {
+
+   }
+
+   @Override
+   protected void createSites() {
+      final int numberOfSites = defaultNumberOfSites();
+      if (numberOfSites <= 0) {
+         throw new IllegalArgumentException("Default number of sites must be positive.");
+      } else if (numberOfSites > MAX_NUM_SITE) {
+         throw new IllegalArgumentException("Default number of sites must be less than the max number of configured sites.");
+      }
+      for (int siteIndex = 0; siteIndex < defaultNumberOfSites(); siteIndex++) {
+         createSite(siteName(siteIndex), defaultNumberOfNodes(), defaultGlobalConfigurationForSite(siteIndex), defaultConfigurationForSite(siteIndex));
+      }
+      afterSitesCreated();
+   }
+
+   private void assertValidSiteIndex(int index) {
+      if (index < 0) {
+         throw new IllegalArgumentException("Site index must be positive or zero.");
+      } else if (index >= MAX_NUM_SITE) {
+         throw new IllegalArgumentException("Site index must be less than the max number of configured sites.");
+      } else if (index >= defaultNumberOfSites()) {
+         throw new IllegalArgumentException("Site index must be less than the number of sites configured.");
+      }
+   }
+
+}
diff --git a/core/src/test/java/org/infinispan/xsite/AbstractXSiteTest.java b/core/src/test/java/org/infinispan/xsite/AbstractXSiteTest.java
index f94c40642e5..7108eed3bed 100644
--- a/core/src/test/java/org/infinispan/xsite/AbstractXSiteTest.java
+++ b/core/src/test/java/org/infinispan/xsite/AbstractXSiteTest.java
@@ -21,7 +21,6 @@
 import org.testng.annotations.Test;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -270,8 +269,8 @@ public <K, V> Cache<K, V> cache(String cacheName, int index) {
          return cacheManagers.get(index).getCache(cacheName);
       }
 
-      public Collection<EmbeddedCacheManager> cacheManagers() {
-         return Collections.unmodifiableCollection(cacheManagers);
+      public List<EmbeddedCacheManager> cacheManagers() {
+         return Collections.unmodifiableList(cacheManagers);
       }
    }
 
diff --git a/core/src/test/java/org/infinispan/xsite/GlobalXSiteAdminOpsTest.java b/core/src/test/java/org/infinispan/xsite/GlobalXSiteAdminOpsTest.java
new file mode 100644
index 00000000000..374916f7c09
--- /dev/null
+++ b/core/src/test/java/org/infinispan/xsite/GlobalXSiteAdminOpsTest.java
@@ -0,0 +1,427 @@
+package org.infinispan.xsite;
+
+import org.infinispan.Cache;
+import org.infinispan.configuration.cache.BackupConfiguration;
+import org.infinispan.configuration.cache.CacheMode;
+import org.infinispan.configuration.cache.Configuration;
+import org.infinispan.configuration.cache.ConfigurationBuilder;
+import org.infinispan.manager.EmbeddedCacheManager;
+import org.infinispan.remoting.transport.AbstractDelegatingTransport;
+import org.infinispan.remoting.transport.Transport;
+import org.infinispan.test.TestingUtil;
+import org.infinispan.test.fwk.CleanupAfterTest;
+import org.infinispan.util.NotifierLatch;
+import org.infinispan.xsite.statetransfer.XSiteStatePushCommand;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.Test;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+
+import static java.lang.String.format;
+import static org.infinispan.test.TestingUtil.extractGlobalComponent;
+import static org.infinispan.test.TestingUtil.k;
+import static org.infinispan.test.TestingUtil.v;
+import static org.testng.AssertJUnit.assertEquals;
+import static org.testng.AssertJUnit.assertTrue;
+
+/**
+ * Test for {@link GlobalXSiteAdminOperations}.
+ *
+ * @author Pedro Ruivo
+ * @since 8.1
+ */
+@CleanupAfterTest
+@Test(groups = "xsite", testName = "xsite.GlobalXSiteAdminOpsTest")
+public class GlobalXSiteAdminOpsTest extends AbstractMultipleSitesTest {
+
+   protected final Map<CacheType, CacheConfiguration> caches;
+
+   protected GlobalXSiteAdminOpsTest() {
+      caches = new EnumMap<>(CacheType.class);
+   }
+
+   protected static void defineInSite(TestSite site, String cacheName, Configuration configuration) {
+      site.cacheManagers().forEach(cacheManager -> cacheManager.defineConfiguration(cacheName, configuration));
+   }
+
+   protected static ConfigurationBuilder newConfiguration() {
+      return getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false);
+   }
+
+   public void testTakeSiteOffline(Method m) {
+      final String key = k(m);
+      final String value = v(m);
+
+      assertAllCachesEmpty();
+      assertSiteStatusInAllCaches(XSiteAdminOperations.ONLINE);
+
+      extractGlobalComponent(site(0).cacheManagers().get(0), GlobalXSiteAdminOperations.class).takeSiteOffline(siteName(1));
+
+      assertSiteStatus(0, 0, null, 1, XSiteAdminOperations.OFFLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), 1, XSiteAdminOperations.OFFLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), 2, XSiteAdminOperations.ONLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_2).cacheName(), 2, XSiteAdminOperations.ONLINE);
+
+      //double check with data
+      putInAllCache(key, value);
+      assertValueInAllCachesInPrimarySite(key, value); //all caches should have the value in primary site
+
+      assertCacheEmpty(1, 0, null);
+      assertCacheEmpty(1, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+      assertValueInCache(2, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName(), key, value);
+      assertValueInCache(2, caches.get(CacheType.BACKUP_TO_SITE_2).backupCacheName(), key, value);
+   }
+
+   public void testBringSiteOnline(Method m) {
+      final String key = k(m);
+      final String value = v(m);
+
+      assertAllCachesEmpty();
+      setSitesStatus(false);
+      assertSiteStatusInAllCaches(XSiteAdminOperations.OFFLINE);
+
+      extractGlobalComponent(site(0).cacheManagers().get(0), GlobalXSiteAdminOperations.class).bringSiteOnline(siteName(1));
+
+      assertSiteStatus(0, 0, null, 1, XSiteAdminOperations.ONLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), 1, XSiteAdminOperations.ONLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), 2, XSiteAdminOperations.OFFLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_2).cacheName(), 2, XSiteAdminOperations.OFFLINE);
+
+      //double check with data
+      putInAllCache(key, value);
+      assertValueInAllCachesInPrimarySite(key, value); //all caches should have the value in primary site
+
+      assertValueInCache(1, null, key, value);
+      assertValueInCache(1, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName(), key, value);
+      assertCacheEmpty(2, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+      assertCacheEmpty(2, 0, caches.get(CacheType.BACKUP_TO_SITE_2).backupCacheName());
+   }
+
+   public void testPushState(Method m) {
+      final String key = k(m);
+      final String value = v(m);
+
+      assertAllCachesEmpty();
+      setSitesStatus(false);
+      assertSiteStatusInAllCaches(XSiteAdminOperations.OFFLINE);
+
+      putInAllCache(key, value);
+      assertValueInAllCachesInPrimarySite(key, value);
+
+      //check the value is not in the backups
+      assertCacheEmpty(1, 0, null);
+      assertCacheEmpty(1, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+      assertCacheEmpty(2, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+      assertCacheEmpty(2, 0, caches.get(CacheType.BACKUP_TO_SITE_2).backupCacheName());
+
+      extractGlobalComponent(site(0).cacheManagers().get(0), GlobalXSiteAdminOperations.class).pushState(siteName(1));
+      awaitXSiteStateTransfer();
+
+      //check state and data
+      assertSiteStatus(0, 0, null, 1, XSiteAdminOperations.ONLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), 1, XSiteAdminOperations.ONLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), 2, XSiteAdminOperations.OFFLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_2).cacheName(), 2, XSiteAdminOperations.OFFLINE);
+
+      assertValueInCache(1, null, key, value);
+      assertValueInCache(1, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName(), key, value);
+      assertCacheEmpty(2, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+      assertCacheEmpty(2, 0, caches.get(CacheType.BACKUP_TO_SITE_2).backupCacheName());
+
+      extractGlobalComponent(site(0).cacheManagers().get(0), GlobalXSiteAdminOperations.class).pushState(siteName(2));
+      awaitXSiteStateTransfer();
+
+      //check state and data
+      assertSiteStatus(0, 0, null, 1, XSiteAdminOperations.ONLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), 1, XSiteAdminOperations.ONLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), 2, XSiteAdminOperations.ONLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_2).cacheName(), 2, XSiteAdminOperations.ONLINE);
+
+      assertValueInCache(1, null, key, value);
+      assertValueInCache(1, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName(), key, value);
+      assertValueInCache(2, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName(), key, value);
+      assertValueInCache(2, caches.get(CacheType.BACKUP_TO_SITE_2).backupCacheName(), key, value);
+   }
+
+   public void testCancelPushState(Method m) {
+      final String key = k(m);
+      final String value = v(m);
+
+      assertAllCachesEmpty();
+      setSitesStatus(false);
+      assertSiteStatusInAllCaches(XSiteAdminOperations.OFFLINE);
+
+      putInAllCache(key, value);
+      assertValueInAllCachesInPrimarySite(key, value);
+
+      //check the value is not in the backups
+      assertCacheEmpty(1, 0, null);
+      assertCacheEmpty(1, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+      assertCacheEmpty(2, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+      assertCacheEmpty(2, 0, caches.get(CacheType.BACKUP_TO_SITE_2).backupCacheName());
+
+      List<BlockingTransport> blockingTransportList = getBlockingTransport(0, true);
+      blockingTransportList.forEach(BlockingTransport::blockCommands);
+
+      extractGlobalComponent(site(0).cacheManagers().get(0), GlobalXSiteAdminOperations.class).pushState(siteName(1));
+
+      extractGlobalComponent(site(0).cacheManagers().get(0), GlobalXSiteAdminOperations.class).cancelPushState(siteName(1));
+
+      //check state and data
+      assertSiteStatus(0, 0, null, 1, XSiteAdminOperations.ONLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), 1, XSiteAdminOperations.ONLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), 2, XSiteAdminOperations.OFFLINE);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_2).cacheName(), 2, XSiteAdminOperations.OFFLINE);
+
+      assertCacheEmpty(1, 0, null);
+      assertCacheEmpty(1, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+      assertCacheEmpty(2, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+      assertCacheEmpty(2, 0, caches.get(CacheType.BACKUP_TO_SITE_2).backupCacheName());
+
+      blockingTransportList.forEach(BlockingTransport::unblockCommands);
+   }
+
+   @AfterMethod(alwaysRun = true)
+   public void resetStatusAfterMethod() {
+      setSitesStatus(true);
+      getBlockingTransport(0, false).forEach(BlockingTransport::unblockCommands);
+   }
+
+   @Override
+   protected ConfigurationBuilder defaultConfigurationForSite(int siteIndex) {
+      if (siteIndex == 0) {
+         //default cache will backup to site_1
+         ConfigurationBuilder builder = newConfiguration();
+         builder.sites().addBackup().site(siteName(1)).strategy(BackupConfiguration.BackupStrategy.SYNC);
+         return builder;
+      } else {
+         return newConfiguration();
+      }
+   }
+
+   @Override
+   protected int defaultNumberOfSites() {
+      return 3;
+   }
+
+   protected void createCachesConfiguration() {
+      caches.put(CacheType.BACKUP_TO_SITE_2, new CacheConfiguration("cache2") {
+
+         @Override
+         public void defineConfiguration() {
+            ConfigurationBuilder builder = newConfiguration();
+            builder.sites().addBackup().site(siteName(2)).strategy(BackupConfiguration.BackupStrategy.SYNC);
+            defineInSite(site(0), cacheName(), builder.build());
+            defineInSite(site(2), backupCacheName(), newConfiguration().build());
+         }
+      });
+      caches.put(CacheType.BACKUP_TO_SITE_1_AND_2, new CacheConfiguration("cache3") {
+
+         @Override
+         public void defineConfiguration() {
+            ConfigurationBuilder builder = newConfiguration();
+            builder.sites().addBackup().site(siteName(1)).strategy(BackupConfiguration.BackupStrategy.SYNC);
+            builder.sites().addBackup().site(siteName(2)).strategy(BackupConfiguration.BackupStrategy.SYNC);
+            defineInSite(site(0), cacheName(), builder.build());
+            defineInSite(site(1), backupCacheName(), newConfiguration().build());
+            defineInSite(site(2), backupCacheName(), newConfiguration().build());
+         }
+      });
+      caches.put(CacheType.NO_BACKUP, new CacheConfiguration("cache4") {
+
+         @Override
+         public void defineConfiguration() {
+            defineInSite(site(0), cacheName(), newConfiguration().build());
+         }
+      });
+   }
+
+   @Override
+   protected void afterSitesCreated() {
+      super.afterSitesCreated();
+      createCachesConfiguration();
+      for (CacheType cacheType : CacheType.values()) {
+         assertTrue(format("CacheType '%s' is missing in caches map.", cacheType), caches.containsKey(cacheType));
+      }
+      caches.values().forEach(GlobalXSiteAdminOpsTest.CacheConfiguration::defineConfiguration);
+      //wait for caches in primary cluster
+      site(0).waitForClusterToForm(null);
+      site(0).waitForClusterToForm(caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName());
+      site(0).waitForClusterToForm(caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName());
+      site(0).waitForClusterToForm(caches.get(CacheType.BACKUP_TO_SITE_2).cacheName());
+
+      //wait for caches in backup site 1
+      site(1).waitForClusterToForm(null);
+      site(1).waitForClusterToForm(caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+
+      //wait for caches in backup site 2
+      site(2).waitForClusterToForm(caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+      site(2).waitForClusterToForm(caches.get(CacheType.BACKUP_TO_SITE_2).backupCacheName());
+   }
+
+   private void awaitXSiteStateTransfer() {
+      awaitXSiteStateTransferFor(null);
+      awaitXSiteStateTransferFor(caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName());
+      awaitXSiteStateTransferFor(caches.get(CacheType.BACKUP_TO_SITE_2).cacheName());
+   }
+
+   private void awaitXSiteStateTransferFor(String cacheName) {
+      eventually(format("Failed to complete the x-site state transfer for cache '%s'", cacheName),
+                 () -> xSiteAdminOperations(0, 0, cacheName).getRunningStateTransfer().isEmpty());
+   }
+
+   private void setSitesStatus(boolean online) {
+      if (online) {
+         xSiteAdminOperations(0, 0, null).bringSiteOnline(siteName(1));
+         xSiteAdminOperations(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName()).bringSiteOnline(siteName(1));
+         xSiteAdminOperations(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName()).bringSiteOnline(siteName(2));
+         xSiteAdminOperations(0, 0, caches.get(CacheType.BACKUP_TO_SITE_2).cacheName()).bringSiteOnline(siteName(2));
+      } else {
+         xSiteAdminOperations(0, 0, null).takeSiteOffline(siteName(1));
+         xSiteAdminOperations(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName()).takeSiteOffline(siteName(1));
+         xSiteAdminOperations(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName()).takeSiteOffline(siteName(2));
+         xSiteAdminOperations(0, 0, caches.get(CacheType.BACKUP_TO_SITE_2).cacheName()).takeSiteOffline(siteName(2));
+      }
+   }
+
+   private void putInAllCache(String key, String value) {
+      cache(0, 0, null).put(key, value);
+      cache(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName()).put(key, value);
+      cache(0, 0, caches.get(CacheType.BACKUP_TO_SITE_2).cacheName()).put(key, value);
+      cache(0, 0, caches.get(CacheType.NO_BACKUP).cacheName()).put(key, value);
+   }
+
+   private void assertValueInAllCachesInPrimarySite(String key, String value) {
+      assertValueInCache(0, null, key, value);
+      assertValueInCache(0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), key, value);
+      assertValueInCache(0, caches.get(CacheType.BACKUP_TO_SITE_2).cacheName(), key, value);
+      assertValueInCache(0, caches.get(CacheType.NO_BACKUP).cacheName(), key, value);
+   }
+
+   private void assertValueInCache(int siteIndex, String cacheName, String key, String value) {
+      for (int nodeIndex = 0; nodeIndex < defaultNumberOfNodes(); nodeIndex++) {
+         assertEquals(format("Wrong value for key '%s' in cache '%s' on site '%d' and node '%d'",
+                             key, cacheName, siteIndex, nodeIndex),
+                      value, cache(siteIndex, nodeIndex, cacheName).get(key));
+      }
+   }
+
+   private XSiteAdminOperations xSiteAdminOperations(int siteIndex, int nodeIndex, String cacheName) {
+      return TestingUtil.extractComponent(cache(siteIndex, nodeIndex, cacheName), XSiteAdminOperations.class);
+   }
+
+   private <K, V> Cache<K, V> cache(int siteIndex, int nodeIndex, String cacheName) {
+      if (cacheName == null) {
+         return site(siteIndex).cache(nodeIndex);
+      } else {
+         return site(siteIndex).cache(cacheName, nodeIndex);
+      }
+   }
+
+   private void assertCacheEmpty(int siteIndex, int nodeIndex, String cacheName) {
+      assertTrue(format("Cache '%s' is not empty in site '%d'", cacheName, siteIndex),
+                 cache(siteIndex, nodeIndex, cacheName).isEmpty());
+   }
+
+   private void assertAllCachesEmpty() {
+      for (CacheConfiguration configuration : caches.values()) {
+         assertCacheEmpty(0, 0, configuration.cacheName());
+      }
+      assertCacheEmpty(1, 0, null);
+      assertCacheEmpty(1, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+      assertCacheEmpty(2, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).backupCacheName());
+      assertCacheEmpty(2, 0, caches.get(CacheType.BACKUP_TO_SITE_2).backupCacheName());
+   }
+
+   private void assertSiteStatusInAllCaches(String status) {
+      assertSiteStatus(0, 0, null, 1, status);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), 1, status);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_1_AND_2).cacheName(), 2, status);
+      assertSiteStatus(0, 0, caches.get(CacheType.BACKUP_TO_SITE_2).cacheName(), 2, status);
+   }
+
+   private void assertSiteStatus(int siteIndex, int nodeIndex, String cacheName, int backupSiteIndex, String status) {
+      assertEquals(format("Wrong site status for cache '%s' in site '%d' for backup site '%d'.", cacheName, siteIndex, backupSiteIndex),
+                   status,
+                   xSiteAdminOperations(siteIndex, nodeIndex, cacheName).siteStatus(siteName(backupSiteIndex)));
+   }
+
+   private List<BlockingTransport> getBlockingTransport(int siteIndex, boolean createIfAbsent) {
+      List<EmbeddedCacheManager> cacheManagerList = site(siteIndex).cacheManagers();
+      List<BlockingTransport> blockingTransportList = new ArrayList<>(cacheManagerList.size());
+      cacheManagerList.forEach(cacheManager -> {
+         Transport transport = cacheManager.getTransport();
+         if (transport instanceof BlockingTransport) {
+            blockingTransportList.add((BlockingTransport) transport);
+         } else if (createIfAbsent) {
+            BlockingTransport blockingTransport = new BlockingTransport(transport);
+            cacheManager.getGlobalComponentRegistry().registerComponent(blockingTransport, Transport.class);
+            cacheManager.getGlobalComponentRegistry().rewire();
+            cacheManager.getGlobalComponentRegistry().rewireNamedRegistries();
+            blockingTransportList.add(blockingTransport);
+         }
+      });
+      return blockingTransportList.isEmpty() ? Collections.emptyList() : blockingTransportList;
+   }
+
+   protected enum CacheType {
+      BACKUP_TO_SITE_2,
+      BACKUP_TO_SITE_1_AND_2,
+      NO_BACKUP
+   }
+
+   public static abstract class CacheConfiguration {
+
+      protected final String cacheName;
+
+      public CacheConfiguration(String cacheName) {
+         this.cacheName = cacheName;
+      }
+
+      public String cacheName() {
+         return cacheName;
+      }
+
+      public String backupCacheName() {
+         return cacheName;
+      }
+
+      public abstract void defineConfiguration();
+   }
+
+   private static class BlockingTransport extends AbstractDelegatingTransport {
+
+      private final NotifierLatch notifierLatch;
+
+      public BlockingTransport(Transport actual) {
+         super(actual);
+         notifierLatch = new NotifierLatch();
+         notifierLatch.stopBlocking();
+      }
+
+      public void blockCommands() {
+         notifierLatch.startBlocking();
+      }
+
+      public void unblockCommands() {
+         notifierLatch.stopBlocking();
+      }
+
+      @Override
+      public void start() {
+         //skip start it again.
+      }
+
+      @Override
+      protected void beforeBackupRemotely(XSiteReplicateCommand command) {
+         if (command instanceof XSiteStatePushCommand) {
+            notifierLatch.blockIfNeeded();
+         }
+      }
+   }
+}
diff --git a/core/src/test/java/org/infinispan/xsite/GlobalXSiteAdminOpsWithBackupForTest.java b/core/src/test/java/org/infinispan/xsite/GlobalXSiteAdminOpsWithBackupForTest.java
new file mode 100644
index 00000000000..0c716530bc4
--- /dev/null
+++ b/core/src/test/java/org/infinispan/xsite/GlobalXSiteAdminOpsWithBackupForTest.java
@@ -0,0 +1,65 @@
+package org.infinispan.xsite;
+
+import org.infinispan.configuration.cache.BackupConfiguration;
+import org.infinispan.configuration.cache.ConfigurationBuilder;
+import org.infinispan.test.fwk.CleanupAfterTest;
+import org.testng.annotations.Test;
+
+/**
+ * Same as {@link GlobalXSiteAdminOpsTest} but using {@code backup-for} to configure the backup caches.
+ *
+ * @author Pedro Ruivo
+ * @since 8.0
+ */
+@CleanupAfterTest
+@Test(groups = "xsite", testName = "xsite.GlobalXSiteAdminOpsWithBackupForTest")
+public class GlobalXSiteAdminOpsWithBackupForTest extends GlobalXSiteAdminOpsTest {
+
+   protected void createCachesConfiguration() {
+      caches.put(CacheType.BACKUP_TO_SITE_2, new CacheConfiguration("cache2") {
+
+         @Override
+         public String backupCacheName() {
+            return cacheName + "_backup";
+         }
+
+         @Override
+         public void defineConfiguration() {
+            ConfigurationBuilder builder = newConfiguration();
+            builder.sites().addBackup().site(siteName(2)).strategy(BackupConfiguration.BackupStrategy.SYNC);
+            defineInSite(site(0), cacheName(), builder.build());
+            builder = newConfiguration();
+            builder.sites().backupFor().remoteSite(siteName(0)).remoteCache(cacheName());
+            defineInSite(site(2), backupCacheName(), builder.build());
+         }
+      });
+      caches.put(CacheType.BACKUP_TO_SITE_1_AND_2, new CacheConfiguration("cache3") {
+
+         @Override
+         public String backupCacheName() {
+            return cacheName + "_backup";
+         }
+
+         @Override
+         public void defineConfiguration() {
+            ConfigurationBuilder builder = newConfiguration();
+            builder.sites().addBackup().site(siteName(1)).strategy(BackupConfiguration.BackupStrategy.SYNC);
+            builder.sites().addBackup().site(siteName(2)).strategy(BackupConfiguration.BackupStrategy.SYNC);
+            defineInSite(site(0), cacheName(), builder.build());
+            builder = newConfiguration();
+            builder.sites().backupFor().remoteSite(siteName(0)).remoteCache(cacheName());
+            defineInSite(site(1), backupCacheName(), builder.build());
+            defineInSite(site(2), backupCacheName(), builder.build());
+         }
+      });
+      caches.put(CacheType.NO_BACKUP, new CacheConfiguration("cache4") {
+
+         @Override
+         public void defineConfiguration() {
+            defineInSite(site(0), cacheName(), newConfiguration().build());
+         }
+      });
+   }
+
+
+}
diff --git a/server/integration/cli/src/main/java/org/infinispan/server/cli/handlers/SiteCommandHandler.java b/server/integration/cli/src/main/java/org/infinispan/server/cli/handlers/SiteCommandHandler.java
index 3ca9dc84595..858da0f6e59 100644
--- a/server/integration/cli/src/main/java/org/infinispan/server/cli/handlers/SiteCommandHandler.java
+++ b/server/integration/cli/src/main/java/org/infinispan/server/cli/handlers/SiteCommandHandler.java
@@ -1,6 +1,5 @@
 package org.infinispan.server.cli.handlers;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
@@ -37,7 +36,11 @@ public SiteCommandHandler(CliCommandBuffer buffer) {
             new ArgumentWithoutValue(this, -1, "--cancelreceive"),
             new ArgumentWithoutValue(this, -1, "--pushstatus"),
             new ArgumentWithoutValue(this, -1, "--clearpushstatus"),
-            new ArgumentWithoutValue(this, -1, "--sendingsite")
+            new ArgumentWithoutValue(this, -1, "--sendingsite"),
+            new ArgumentWithoutValue(this, -1, "--onlineall"),
+            new ArgumentWithoutValue(this, -1, "--offlineall"),
+            new ArgumentWithoutValue(this, -1, "--pushall"),
+            new ArgumentWithoutValue(this, -1, "--cancelpushall")
       );
       new ArgumentWithValue(this, null, 0, "--site-name");
    }
diff --git a/server/integration/cli/src/main/resources/help/site.txt b/server/integration/cli/src/main/resources/help/site.txt
index 2d652fbc009..92594abca03 100644
--- a/server/integration/cli/src/main/resources/help/site.txt
+++ b/server/integration/cli/src/main/resources/help/site.txt
@@ -1,6 +1,6 @@
 
 SYNOPSIS
-    site [ --status | --online | --offline | --push | --cancelpush | --cancelreceive | --pushstatus | --clearpushstatus | --sendingsite ] [ cachename.sitename ]
+    site [ --status | --online | --offline | --push | --cancelpush | --cancelreceive | --pushstatus | --clearpushstatus | --sendingsite | --onlineall | --offlineall | --pushall | --cancelpushall ] [ cachename.sitename ]
     
 DESCRIPTION 
     Inspects or changes the status of sites for X-Site replication