Added API endpoints to indicate the current session state + API server is available immediately upon startup (#166)

devgianlu · devgianlu · commit b933939e165f · 2020-01-11T14:40:12.000+01:00
diff --git a/api/README.md b/api/README.md
@@ -5,6 +5,8 @@ This module depends on `librespot-core` and provides an API to interact with the
 
 ## Available endpoints
 
+All the endpoints will respond with `200` if successful or `204` if there isn't any active session.
+
 ### Player
 - `POST \player\load` Load a track from a given uri. The request body should contain two parameters: `uri` and `play`.
 - `POST \player\pause` Pause playback.
@@ -30,6 +32,9 @@ The currently available events are:
 - `trackSeeked`
 - `metadataAvailable`
 - `playbackHaltStateChanged`
+- `sessionCleared`
+- `sessionChanged`
+- `inactiveSession`
 
 ## Examples
 
diff --git a/api/src/main/java/xyz/gianlu/librespot/api/ApiServer.java b/api/src/main/java/xyz/gianlu/librespot/api/ApiServer.java
@@ -9,32 +9,29 @@
 import xyz.gianlu.librespot.api.handlers.EventsHandler;
 import xyz.gianlu.librespot.api.handlers.MetadataHandler;
 import xyz.gianlu.librespot.api.handlers.PlayerHandler;
-import xyz.gianlu.librespot.core.Session;
 
 public class ApiServer {
     private static final Logger LOGGER = Logger.getLogger(ApiServer.class);
     private final int port;
     private final String host;
+    private final RoutingHandler handler;
     private Undertow undertow = null;
 
-    public ApiServer(@NotNull ApiConfiguration conf) {
+    public ApiServer(@NotNull ApiConfiguration conf, @NotNull SessionWrapper wrapper) {
         this.port = conf.apiPort();
         this.host = conf.apiHost();
 
-        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
-            if (undertow != null) undertow.stop();
-        }));
-    }
+        EventsHandler events = new EventsHandler();
+        wrapper.setListener(events);
 
-    private static void prepareHandlers(@NotNull RoutingHandler root, @NotNull Session session) {
-        root.post("/player/{cmd}", new PlayerHandler(session))
-                .post("/metadata/{type}/{uri}", new MetadataHandler(session))
-                .get("/events", new EventsHandler(session));
+        handler = new RoutingHandler();
+        handler.post("/player/{cmd}", new PlayerHandler(wrapper))
+                .post("/metadata/{type}/{uri}", new MetadataHandler(wrapper))
+                .get("/events", events);
     }
 
-    public void start(@NotNull Session session) {
-        RoutingHandler handler = new RoutingHandler();
-        prepareHandlers(handler, session);
+    public void start() {
+        if (undertow != null) throw new IllegalStateException("Already started!");
 
         Filter corsFilter = new Filter(handler);
         corsFilter.setPolicyClass(AllowAll.class.getCanonicalName());
@@ -54,9 +51,4 @@ public void stop() {
 
         LOGGER.info("Server stopped!");
     }
-
-    public void restart(@NotNull Session session) {
-        stop();
-        start(session);
-    }
 }
diff --git a/api/src/main/java/xyz/gianlu/librespot/api/Main.java b/api/src/main/java/xyz/gianlu/librespot/api/Main.java
@@ -17,11 +17,15 @@ public class Main {
 
     public static void main(String[] args) throws IOException, MercuryClient.MercuryException, GeneralSecurityException, Session.SpotifyAuthenticationException {
         AbsConfiguration conf = new FileConfiguration(args);
-        ApiServer server = new ApiServer(conf);
-        if (conf.authStrategy() == AuthConfiguration.Strategy.ZEROCONF) {
-            ZeroconfServer.create(conf).addSessionListener(server::restart);
-        } else {
-            server.start(new Session.Builder(conf).create());
-        }
+
+        SessionWrapper wrapper;
+        if (conf.authStrategy() == AuthConfiguration.Strategy.ZEROCONF)
+            wrapper = SessionWrapper.fromZeroconf(ZeroconfServer.create(conf));
+        else
+            wrapper = SessionWrapper.fromSession(new Session.Builder(conf).create());
+
+        ApiServer server = new ApiServer(conf, wrapper);
+        Runtime.getRuntime().addShutdownHook(new Thread(server::stop));
+        server.start();
     }
 }
diff --git a/api/src/main/java/xyz/gianlu/librespot/api/SessionWrapper.java b/api/src/main/java/xyz/gianlu/librespot/api/SessionWrapper.java
@@ -0,0 +1,80 @@
+package xyz.gianlu.librespot.api;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.gianlu.librespot.core.Session;
+import xyz.gianlu.librespot.core.ZeroconfServer;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * @author Gianlu
+ */
+public final class SessionWrapper {
+    private final AtomicReference<Session> ref = new AtomicReference<>(null);
+    private Listener listener = null;
+
+    private SessionWrapper() {
+    }
+
+    /**
+     * Convenience method to create an instance of {@link SessionWrapper} that is updated by {@link ZeroconfServer}
+     *
+     * @param server The {@link ZeroconfServer}
+     * @return A wrapper that holds a changing session
+     */
+    @NotNull
+    public static SessionWrapper fromZeroconf(@NotNull ZeroconfServer server) {
+        SessionWrapper wrapper = new SessionWrapper();
+        server.addSessionListener(wrapper::set);
+        return wrapper;
+    }
+
+    /**
+     * Convenience method to create an instance of {@link SessionWrapper} that holds a static session
+     *
+     * @param session The static session
+     * @return A wrapper that holds a never-changing session
+     */
+    @NotNull
+    public static SessionWrapper fromSession(@NotNull Session session) {
+        SessionWrapper wrapper = new SessionWrapper();
+        wrapper.ref.set(session);
+        return wrapper;
+    }
+
+    public void setListener(@NotNull Listener listener) {
+        this.listener = listener;
+
+        Session s;
+        if ((s = ref.get()) != null) listener.onNewSession(s);
+    }
+
+    private void set(@NotNull Session session) {
+        ref.set(session);
+        session.addCloseListener(this::clear);
+        if (listener != null) listener.onNewSession(session);
+    }
+
+    private void clear() {
+        ref.set(null);
+        if (listener != null) listener.onSessionCleared();
+    }
+
+    @Nullable
+    public Session get() {
+        Session s = ref.get();
+        if (s != null) {
+            if (s.valid()) return s;
+            else clear();
+        }
+
+        return null;
+    }
+
+    public interface Listener {
+        void onSessionCleared();
+
+        void onNewSession(@NotNull Session session);
+    }
+}
diff --git a/api/src/main/java/xyz/gianlu/librespot/api/handlers/AbsSessionHandler.java b/api/src/main/java/xyz/gianlu/librespot/api/handlers/AbsSessionHandler.java
@@ -0,0 +1,32 @@
+package xyz.gianlu.librespot.api.handlers;
+
+import io.undertow.server.HttpHandler;
+import io.undertow.server.HttpServerExchange;
+import io.undertow.util.StatusCodes;
+import org.jetbrains.annotations.NotNull;
+import xyz.gianlu.librespot.api.SessionWrapper;
+import xyz.gianlu.librespot.core.Session;
+
+/**
+ * @author Gianlu
+ */
+public abstract class AbsSessionHandler implements HttpHandler {
+    private final SessionWrapper wrapper;
+
+    public AbsSessionHandler(@NotNull SessionWrapper wrapper) {
+        this.wrapper = wrapper;
+    }
+
+    @Override
+    public final void handleRequest(HttpServerExchange exchange) throws Exception {
+        Session s = wrapper.get();
+        if (s == null) {
+            exchange.setStatusCode(StatusCodes.NO_CONTENT);
+            return;
+        }
+
+        handleRequest(exchange, s);
+    }
+
+    protected abstract void handleRequest(@NotNull HttpServerExchange exchange, @NotNull Session session) throws Exception;
+}
diff --git a/api/src/main/java/xyz/gianlu/librespot/api/handlers/EventsHandler.java b/api/src/main/java/xyz/gianlu/librespot/api/handlers/EventsHandler.java
@@ -9,17 +9,17 @@
 import org.apache.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import xyz.gianlu.librespot.api.SessionWrapper;
 import xyz.gianlu.librespot.common.ProtobufToJson;
 import xyz.gianlu.librespot.core.Session;
 import xyz.gianlu.librespot.mercury.model.PlayableId;
 import xyz.gianlu.librespot.player.Player;
 
-public final class EventsHandler extends WebSocketProtocolHandshakeHandler implements Player.EventsListener {
+public final class EventsHandler extends WebSocketProtocolHandshakeHandler implements Player.EventsListener, SessionWrapper.Listener {
     private static final Logger LOGGER = Logger.getLogger(EventsHandler.class);
 
-    public EventsHandler(@NotNull Session session) {
+    public EventsHandler() {
         super((WebSocketConnectionCallback) (exchange, channel) -> LOGGER.info(String.format("Accepted new websocket connection from %s.", channel.getSourceAddress().getAddress())));
-        session.player().addEventsListener(this);
     }
 
     private void dispatch(@NotNull JsonObject obj) {
@@ -86,4 +86,29 @@ public void onPlaybackHaltStateChanged(boolean halted, long trackTime) {
         obj.addProperty("halted", halted);
         dispatch(obj);
     }
+
+    @Override
+    public void onInactiveSession(boolean timeout) {
+        JsonObject obj = new JsonObject();
+        obj.addProperty("event", "inactiveSession");
+        obj.addProperty("timeout", timeout);
+        dispatch(obj);
+    }
+
+    @Override
+    public void onSessionCleared() {
+        JsonObject obj = new JsonObject();
+        obj.addProperty("event", "sessionCleared");
+        dispatch(obj);
+    }
+
+    @Override
+    public void onNewSession(@NotNull Session session) {
+        JsonObject obj = new JsonObject();
+        obj.addProperty("event", "sessionChanged");
+        obj.addProperty("username", session.username());
+        dispatch(obj);
+
+        session.player().addEventsListener(this);
+    }
 }
diff --git a/api/src/main/java/xyz/gianlu/librespot/api/handlers/MetadataHandler.java b/api/src/main/java/xyz/gianlu/librespot/api/handlers/MetadataHandler.java
@@ -1,11 +1,11 @@
 package xyz.gianlu.librespot.api.handlers;
 
 import com.google.gson.JsonObject;
-import io.undertow.server.HttpHandler;
 import io.undertow.server.HttpServerExchange;
 import org.apache.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import xyz.gianlu.librespot.api.SessionWrapper;
 import xyz.gianlu.librespot.api.Utils;
 import xyz.gianlu.librespot.common.ProtobufToJson;
 import xyz.gianlu.librespot.core.Session;
@@ -21,16 +21,15 @@
 /**
  * @author Gianlu
  */
-public final class MetadataHandler implements HttpHandler {
+public final class MetadataHandler extends AbsSessionHandler {
     private static final Logger LOGGER = Logger.getLogger(MetadataHandler.class);
-    private final Session session;
 
-    public MetadataHandler(@NotNull Session session) {
-        this.session = session;
+    public MetadataHandler(@NotNull SessionWrapper wrapper) {
+        super(wrapper);
     }
 
     @Override
-    public void handleRequest(HttpServerExchange exchange) throws Exception {
+    public void handleRequest(@NotNull HttpServerExchange exchange, @NotNull Session session) throws Exception {
         exchange.startBlocking();
         if (exchange.isInIoThread()) {
             exchange.dispatch(this);
@@ -57,7 +56,7 @@ public void handleRequest(HttpServerExchange exchange) throws Exception {
         }
 
         try {
-            JsonObject obj = handle(type, uri);
+            JsonObject obj = handle(session, type, uri);
             exchange.getResponseSender().send(obj.toString());
         } catch (ApiClient.StatusCodeException ex) {
             if (ex.code == 404) {
@@ -76,7 +75,7 @@ public void handleRequest(HttpServerExchange exchange) throws Exception {
     }
 
     @NotNull
-    private JsonObject handle(@NotNull MetadataType type, @NotNull String uri) throws IOException, MercuryClient.MercuryException, IllegalArgumentException {
+    private JsonObject handle(@NotNull Session session, @NotNull MetadataType type, @NotNull String uri) throws IOException, MercuryClient.MercuryException, IllegalArgumentException {
         switch (type) {
             case ALBUM:
                 return ProtobufToJson.convert(session.api().getMetadata4Album(AlbumId.fromUri(uri)));
diff --git a/api/src/main/java/xyz/gianlu/librespot/api/handlers/PlayerHandler.java b/api/src/main/java/xyz/gianlu/librespot/api/handlers/PlayerHandler.java
@@ -2,10 +2,10 @@
 
 import com.google.gson.JsonObject;
 import com.spotify.metadata.proto.Metadata;
-import io.undertow.server.HttpHandler;
 import io.undertow.server.HttpServerExchange;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import xyz.gianlu.librespot.api.SessionWrapper;
 import xyz.gianlu.librespot.api.Utils;
 import xyz.gianlu.librespot.common.ProtobufToJson;
 import xyz.gianlu.librespot.core.Session;
@@ -18,14 +18,13 @@
 import java.util.Map;
 import java.util.Objects;
 
-public final class PlayerHandler implements HttpHandler {
-    private final Session session;
+public final class PlayerHandler extends AbsSessionHandler {
 
-    public PlayerHandler(@NotNull Session session) {
-        this.session = session;
+    public PlayerHandler(@NotNull SessionWrapper wrapper) {
+        super(wrapper);
     }
 
-    private void setVolume(HttpServerExchange exchange, @Nullable String valStr) {
+    private void setVolume(HttpServerExchange exchange, Session session, @Nullable String valStr) {
         if (valStr == null) {
             Utils.invalidParameter(exchange, "volume");
             return;
@@ -47,7 +46,7 @@ private void setVolume(HttpServerExchange exchange, @Nullable String valStr) {
         session.player().setVolume(val);
     }
 
-    private void load(HttpServerExchange exchange, @Nullable String uri, boolean play) {
+    private void load(HttpServerExchange exchange, Session session, @Nullable String uri, boolean play) {
         if (uri == null) {
             Utils.invalidParameter(exchange, "uri");
             return;
@@ -56,7 +55,7 @@ private void load(HttpServerExchange exchange, @Nullable String uri, boolean pla
         session.player().load(uri, play);
     }
 
-    private void current(HttpServerExchange exchange) {
+    private void current(HttpServerExchange exchange, Session session) {
         PlayableId id = session.player().currentPlayableId();
 
         JsonObject obj = new JsonObject();
@@ -90,7 +89,7 @@ private void current(HttpServerExchange exchange) {
     }
 
     @Override
-    public void handleRequest(HttpServerExchange exchange) throws Exception {
+    protected void handleRequest(@NotNull HttpServerExchange exchange, @NotNull Session session) throws Exception {
         exchange.startBlocking();
         if (exchange.isInIoThread()) {
             exchange.dispatch(this);
@@ -112,10 +111,10 @@ public void handleRequest(HttpServerExchange exchange) throws Exception {
 
         switch (cmd) {
             case CURRENT:
-                current(exchange);
+                current(exchange, session);
                 return;
             case SET_VOLUME:
-                setVolume(exchange, Utils.getFirstString(params, "volume"));
+                setVolume(exchange, session, Utils.getFirstString(params, "volume"));
                 return;
             case VOLUME_UP:
                 session.player().volumeUp();
@@ -124,7 +123,7 @@ public void handleRequest(HttpServerExchange exchange) throws Exception {
                 session.player().volumeDown();
                 return;
             case LOAD:
-                load(exchange, Utils.getFirstString(params, "uri"), Utils.getFirstBoolean(params, "play"));
+                load(exchange, session, Utils.getFirstString(params, "uri"), Utils.getFirstBoolean(params, "play"));
                 return;
             case PAUSE:
                 session.player().pause();
diff --git a/core/src/main/java/xyz/gianlu/librespot/core/Session.java b/core/src/main/java/xyz/gianlu/librespot/core/Session.java
diff --git a/core/src/main/java/xyz/gianlu/librespot/player/Player.java b/core/src/main/java/xyz/gianlu/librespot/player/Player.java
