MessageQueue.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2021 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package org.turro.message;
 
import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Stream;
import org.turro.string.Strings;
import org.turro.collections.KeyValueMap;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.direct.AbstractDirectContentCtrl;
import org.turro.elephant.direct.DirectContent;
import org.turro.elephant.impl.util.FileUtil;
import org.turro.marker.ElephantMarker;
import org.turro.plugin.contacts.IContact;
 
@DirectContent(identifier="message-queue")
public class MessageQueue extends AbstractDirectContentCtrl {
 
  public static void pushMessage(IContact contact, String msg) {
    getQueue(contact).add(msg);
  }
 
  public static String pollMessage(IContact contact) {
    return getQueue(contact).poll();
  }
 
  public static boolean hasMessage(IContact contact) {
    return !(getQueue(contact).isEmpty());
  }
 
  public static void pushMessage(String idContact, String msg) {
    getQueue(idContact).add(msg);
  }
 
  public static String pollMessage(String idContact) {
    return getQueue(idContact).poll();
  }
 
  public static boolean hasMessage(String idContact) {
    return !(getQueue(idContact).isEmpty());
  }
 
  public String getIntervalCall(IConstructor constructor) {
    IContact user = constructor.getUser();
    if(user != null) {
      KeyValueMap map = new KeyValueMap();
      map.put("userId", user.getId());
      map.put("type", "query");
      return getAjaxEvalUrl(map);
    } else {
      return null;
    }
  }
  
  /* Generic message */
  
  private static final String GENERIC_MESSAGE_FOLDER = "/WEB-INF/elephant/message";
  
  public static void pushGenerics(String idContact) {
    Path folder = Path.of(ElephantContext.getRealPath(GENERIC_MESSAGE_FOLDER));
    if(Files.exists(folder)) {
      PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:**.txt");
      try (Stream<Path> entries = Files.list(folder).filter(p -> matcher.matches(p))) {
        entries.forEach(file -> {
          try {
            pushMessage(idContact, FileUtil.getContent(file.toFile()));
          } catch (IOException ex) {
            Logger.getLogger(MessageQueue.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
          }
        });
      } catch (IOException ex) {
        Logger.getLogger(MessageQueue.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
  }
  
  /* Queue map */
  
  private static final ConcurrentMap<String, BlockingQueue<String>> QUEUE_MAP = new ConcurrentHashMap<>();
    
  public static BlockingQueue<String> getQueue(IContact contact) {
    return getQueue(contact.getId());
  }
  
  public static BlockingQueue<String> getQueue(String idContact) {
    return QUEUE_MAP.computeIfAbsent(idContact, k -> new LinkedBlockingQueue<String>());
  }
 
  /* DirectContent */
  
  public MessageQueue() {
    super("widgets/messages");
    setNeedsUser(true);
  }
  
  @Override
  protected String getIdentifier() {
    return MessageQueue.class.getAnnotation(DirectContent.class).identifier();
  }
 
  @Override
  protected void prepareMarker(ElephantMarker marker) {
    setTemplate("init");
  }
 
  @Override
  protected void prepareCleanMarker(ElephantMarker marker, KeyValueMap map) {
    setTemplate("toast");
    marker.putAll(map);
  }
 
  @Override
  protected void doExecute(IConstructor constructor, KeyValueMap map) {
    String type = map.get("type"),
           userId = map.get("userId");
    if("query".equals(type) && !Strings.isBlank(userId)) {
      Set<String> messages = new HashSet<>();
      while(hasMessage(userId)) {
        messages.add(pollMessage(userId));
      }
      if(!messages.isEmpty()) {
        HashMap extra = new HashMap();
        extra.put("messages", messages);
        writeMarkerToResponse(constructor, map, extra);
      }
    }
  }
 
}