Merge pull request igniterealtime#669 from Flowdalic/flow

Flow

Author: Flowdalic

smack-extensions/src/main/java/org/jivesoftware/smackx/muc/MucConfigFormManager.java

@@ -1,6 +1,6 @@
 /**
  *
- * Copyright 2015-2024 Florian Schmaus
+ * Copyright 2015-2025 Florian Schmaus
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,6 +19,9 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
 
 import org.jivesoftware.smack.SmackException.NoResponseException;
 import org.jivesoftware.smack.SmackException.NotConnectedException;
@@ -53,6 +56,8 @@ public class MucConfigFormManager {
 
     private static final String HASH_ROOMCONFIG = "#roomconfig";
 
+    private static final Logger LOGGER = Logger.getLogger(MucConfigFormManager.class.getName());
+
     public static final String FORM_TYPE = MultiUserChatConstants.NAMESPACE + HASH_ROOMCONFIG;
 
                     /**
@@ -111,6 +116,10 @@ public class MucConfigFormManager {
      */
     public static final String MUC_ROOMCONFIG_CHANGE_SUBJECT = "muc#roomconfig_changesubject";
 
+    public static final String MUC_ROOMCONFIG_WHOIS = "muc#roomconfig_whois";
+
+    public static final String MUC_ROOMCONFIG_MAXUSERS = "muc#roomconfig_maxusers";
+
     private final MultiUserChat multiUserChat;
     private final FillableForm answerForm;
     private final List<Jid> owners;
@@ -453,6 +462,50 @@ public MucConfigFormManager disallowOccupantsToChangeSubject() throws MucConfigu
         return setChangeSubjectByOccupant(false);
     }
 
+    enum WhoisAllowedBy {
+        moderators,
+        anyone,
+    }
+
+    public boolean supportsWhoisAllowedBy() {
+        return answerForm.hasField(MUC_ROOMCONFIG_WHOIS);
+    }
+
+    public MucConfigFormManager setWhoisAllowedBy(WhoisAllowedBy whoisAllowedBy)
+                    throws MucConfigurationNotSupportedException {
+        if (!supportsWhoisAllowedBy()) {
+            throw new MucConfigurationNotSupportedException(MUC_ROOMCONFIG_WHOIS);
+        }
+        answerForm.setAnswer(MUC_ROOMCONFIG_WHOIS, whoisAllowedBy.name());
+        return this;
+    }
+
+    public boolean supportsMaxUsers() {
+        return answerForm.hasField(MUC_ROOMCONFIG_MAXUSERS);
+    }
+
+    public List<Integer> getPossibleMaxUsersValues() throws MucConfigurationNotSupportedException {
+        if (!supportsMaxUsers()) {
+            throw new MucConfigurationNotSupportedException(MUC_ROOMCONFIG_MAXUSERS);
+        }
+        return answerForm.getField(MUC_ROOMCONFIG_MAXUSERS)
+                        .getValuesAsString()
+                        .stream()
+                        .map(s -> Integer.valueOf(s))
+                        .collect(Collectors.toList());
+    }
+
+    public MucConfigFormManager setMaxUsers(int maxUsers) throws MucConfigurationNotSupportedException {
+        if (!supportsMaxUsers()) {
+            throw new MucConfigurationNotSupportedException(MUC_ROOMCONFIG_MAXUSERS);
+        }
+        if (maxUsers < 1) {
+            throw new IllegalArgumentException();
+        }
+        answerForm.setAnswer(MUC_ROOMCONFIG_MAXUSERS, maxUsers);
+        return this;
+    }
+
     /**
      * Submit the configuration as {@link FilledForm} to the room.
      *
@@ -471,4 +524,32 @@ public void submitConfigurationForm() throws NoResponseException, XMPPErrorExcep
         }
         multiUserChat.sendConfigurationForm(answerForm);
     }
+
+    public void cancel() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
+        var cancelForm = FillableForm.newCancelForm();
+        multiUserChat.sendConfigurationForm(cancelForm);
+    }
+
+    public interface MucConfigApplier {
+        void apply(MucConfigFormManager manager)
+                        throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException, MucConfigurationNotSupportedException;
+    }
+
+    public MultiUserChat applyAndSubmit(MucConfigApplier applier)
+                    throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException, MucConfigurationNotSupportedException {
+        try {
+            applier.apply(this);
+            submitConfigurationForm();
+        } catch (XMPPErrorException | InterruptedException | MucConfigurationNotSupportedException e) {
+            try {
+                cancel();
+            } catch (NoResponseException | XMPPErrorException | NotConnectedException
+                            | InterruptedException cancelException) {
+                LOGGER.log(Level.SEVERE, "Exception while canceling MUC configuration for " + multiUserChat, e);
+            }
+            throw e;
+        }
+
+        return multiUserChat;
+    }
 }

smack-extensions/src/main/java/org/jivesoftware/smackx/muc/MucFeature.java

@@ -0,0 +1,35 @@
+/**
+ *
+ * Copyright 2025 Florian Schmaus
+ *
+ * Licensed 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 org.jivesoftware.smackx.muc;
+
+public enum MucFeature {
+    NonAnonymous("muc_nonanonymous"),
+    SemiAnonymous("muc_semianonymous"),
+    PasswordProtected("muc_passwordprotected"),
+    StableIds(MultiUserChatConstants.STABLE_ID_FEATURE),
+    ;
+
+    MucFeature(String name) {
+        this.name = name;
+    }
+
+    private final String name;
+
+    public String getName() {
+        return name;
+    }
+}

smack-extensions/src/main/java/org/jivesoftware/smackx/muc/MultiUserChat.java

@@ -2634,6 +2634,16 @@ public XMPPConnection getXmppConnection() {
         return connection;
     }
 
+    public boolean supports(MucFeature feature) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
+        return supports(feature.getName());
+    }
+
+    public boolean supports(String feature) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
+        var sdm = ServiceDiscoveryManager.getInstanceFor(connection);
+        var info = sdm.discoverInfo(myRoomJid);
+        return info.containsFeature(feature);
+    }
+
     public boolean serviceSupportsStableIds() {
         return DiscoverInfo.nullSafeContainsFeature(mucServiceDiscoInfo, MultiUserChatConstants.STABLE_ID_FEATURE);
     }

smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FillableForm.java

@@ -295,4 +295,9 @@ public SubmitForm getSubmitForm() {
         DataForm form = getDataFormToSubmit();
         return new SubmitForm(form);
     }
+
+    public static FillableForm newCancelForm() {
+        var cancelDataForm = DataForm.builder(DataForm.Type.cancel).build();
+        return new FillableForm(cancelDataForm);
+    }
 }

smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FilledForm.java

@@ -71,7 +71,7 @@ public boolean hasField(String fieldName) {
     protected FormField getFieldOrThrow(String fieldName) {
         FormField formField = getField(fieldName);
         if (formField == null) {
-            throw new IllegalArgumentException("No field named " + fieldName);
+            throw new IllegalArgumentException("The data form has no field named " + fieldName);
         }
         return formField;
     }

smack-integration-test/src/main/java/org/igniterealtime/smack/inttest/SmackIntegrationTestFramework.java

@@ -411,6 +411,9 @@ private void runTests(Set<Class<? extends AbstractSmackIntTest>> classes)
                 continue;
             }
 
+            if (sinttestDebugger != null) {
+                sinttestDebugger.onTestClassConstruction(cons);
+            }
             final AbstractSmackIntTest test;
             try {
                 test = cons.newInstance(environment);

smack-integration-test/src/main/java/org/igniterealtime/smack/inttest/debugger/SinttestDebugger.java

@@ -17,10 +17,12 @@
 package org.igniterealtime.smack.inttest.debugger;
 
 import java.io.IOException;
+import java.lang.reflect.Constructor;
 import java.time.ZonedDateTime;
 
 import org.jivesoftware.smack.debugger.SmackDebuggerFactory;
 
+import org.igniterealtime.smack.inttest.AbstractSmackIntTest;
 import org.igniterealtime.smack.inttest.ConnectionConfigurationBuilderApplier;
 import org.igniterealtime.smack.inttest.SmackIntegrationTestFramework.ConcreteTest;
 import org.igniterealtime.smack.inttest.SmackIntegrationTestFramework.TestRunResult;
@@ -29,6 +31,8 @@ public interface SinttestDebugger {
 
     SmackDebuggerFactory getSmackDebuggerFactory();
 
+    default void onTestClassConstruction(Constructor<? extends AbstractSmackIntTest> cons) throws IOException { };
+
     default void onTestStart(ConcreteTest test, ZonedDateTime testStart) throws IOException { };
 
     default void onTestSuccess(ConcreteTest test, ZonedDateTime endTime) throws IOException { };

smack-integration-test/src/main/java/org/igniterealtime/smack/inttest/debugger/StandardSinttestDebugger.java

@@ -1,6 +1,6 @@
 /**
  *
- * Copyright 2024 Florian Schmaus
+ * Copyright 2024-2025 Florian Schmaus
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.Writer;
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -32,6 +33,7 @@
 import org.jivesoftware.smack.debugger.SmackDebuggerFactory;
 import org.jivesoftware.smack.util.ExceptionUtil;
 
+import org.igniterealtime.smack.inttest.AbstractSmackIntTest;
 import org.igniterealtime.smack.inttest.SmackIntegrationTestFramework.ConcreteTest;
 import org.igniterealtime.smack.inttest.SmackIntegrationTestFramework.TestRunResult;
 import org.igniterealtime.smack.inttest.util.ResultSyncPoint.ResultSyncPointTimeoutException;
@@ -112,12 +114,7 @@ public StandardSinttestDebugger(ZonedDateTime restRunStart, String testRunId, St
             Path outsideTestLogFile = this.basePath.resolve("outsideTestLog");
             Path testsFile = this.basePath.resolve("tests");
             try {
-                if (!this.basePath.toFile().exists()) {
-                    boolean created = this.basePath.toFile().mkdirs();
-                    if (!created) {
-                        throw new IOException("Could not create directory " + this.basePath);
-                    }
-                }
+                mkdirs(this.basePath);
 
                 completeWriter = Files.newBufferedWriter(completeLogFile);
                 outsideTestWriter = currentWriter = Files.newBufferedWriter(outsideTestLogFile);
@@ -152,7 +149,7 @@ private void logSink(String logMessage) {
                     currentWriter.append(logMessage).append('\n');
                 }
 
-                completeWriter.append(logMessage + "\n");
+                completeWriter.append(logMessage).append('\n');
             } catch (IOException e) {
                 LOGGER.log(Level.WARNING, e + " while appending log message", e);
             }
@@ -170,6 +167,24 @@ public SmackDebuggerFactory getSmackDebuggerFactory() {
         return c -> new StandardSinttestSmackDebugger(c);
     }
 
+    @Override
+    public void onTestClassConstruction(Constructor<? extends AbstractSmackIntTest> constructor) throws IOException {
+        if (basePath == null) {
+            return;
+        }
+
+        Path testClassDirectory = basePath.resolve(constructor.getDeclaringClass().getSimpleName());
+        mkdirs(testClassDirectory);
+
+        Path logFile = testClassDirectory.resolve("log");
+        Writer newWriter = Files.newBufferedWriter(logFile);
+        synchronized (currentWriterLock) {
+            currentWriter = newWriter;
+        }
+
+        completeWriter.append("Constructing: " + constructor.getDeclaringClass() + "\n");
+    };
+
     @Override
     public void onTestStart(ConcreteTest test, ZonedDateTime startTime) throws IOException {
         if (basePath == null) {
@@ -186,12 +201,7 @@ public void onTestStart(ConcreteTest test, ZonedDateTime startTime) throws IOExc
         }
         currentTestMethodDirectory = testClassDirectory.resolve(testName.toString());
 
-        if (!currentTestMethodDirectory.toFile().exists()) {
-            boolean created = currentTestMethodDirectory.toFile().mkdirs();
-            if (!created) {
-                throw new IOException("Could not create directory " + currentTestMethodDirectory);
-            }
-        }
+        mkdirs(currentTestMethodDirectory);
 
         Path logFile = currentTestMethodDirectory.resolve("log");
         Writer newWriter = Files.newBufferedWriter(logFile);
@@ -288,4 +298,14 @@ public void onSinttestFinished(TestRunResult testRunResult) throws IOException {
 
         LOGGER.info("Test data file://" + basePath);
     }
+
+    private static void mkdirs(Path path) throws IOException {
+        var dir = path.toFile();
+        if (dir.exists())
+            return;
+
+        boolean created = dir.mkdirs();
+        if (!created)
+            throw new IOException("Could not create directory " + path);
+    }
 }