git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2022 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.bondhome.internal.api;
  14
  15 import static java.nio.charset.StandardCharsets.*;
  16 import static org.openhab.binding.bondhome.internal.BondHomeBindingConstants.*;
  17
  18 import java.io.IOException;
  19 import java.net.DatagramPacket;
  20 import java.net.DatagramSocket;
  21 import java.net.InetAddress;
  22 import java.net.SocketException;
  23 import java.net.SocketTimeoutException;
  24 import java.util.concurrent.Executor;
  25
  26 import org.eclipse.jdt.annotation.NonNullByDefault;
  27 import org.eclipse.jdt.annotation.Nullable;
  28 import org.openhab.binding.bondhome.internal.handler.BondBridgeHandler;
  29 import org.openhab.core.thing.ThingStatusDetail;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32
  33 import com.google.gson.Gson;
  34 import com.google.gson.GsonBuilder;
  35 import com.google.gson.JsonParseException;
  36
  37 /**
  38  * This Thread is responsible maintaining the Bond Push UDP Protocol
  39  *
  40  * @author Sara Geleskie Damiano - Initial contribution
  41  *
  42  */
  43 @NonNullByDefault
  44 public class BPUPListener implements Runnable {
  45
  46     private static final int SOCKET_TIMEOUT_MILLISECONDS = 3000;
  47     private static final int SOCKET_RETRY_TIMEOUT_MILLISECONDS = 3000;
  48
  49     private final Logger logger = LoggerFactory.getLogger(BPUPListener.class);
  50
  51     // To parse the JSON responses
  52     private final Gson gsonBuilder;
  53
  54     // Used for callbacks to handler
  55     private final BondBridgeHandler bridgeHandler;
  56
  57     // UDP socket used to receive status events
  58     private @Nullable DatagramSocket socket;
  59
  60     public @Nullable String lastRequestId;
  61     private long timeOfLastKeepAlivePacket;
  62     private boolean shutdown;
  63
  64     private int numberOfKeepAliveTimeouts;
  65
  66     /**
  67      * Constructor of the receiver runnable thread.
  68      *
  69      * @param address The address of the Bond Bridge
  70      * @throws SocketException is some problem occurs opening the socket.
  71      */
  72     public BPUPListener(BondBridgeHandler bridgeHandler) {
  73         logger.debug("Starting BPUP Listener...");
  74
  75         this.bridgeHandler = bridgeHandler;
  76         this.timeOfLastKeepAlivePacket = -1;
  77         this.numberOfKeepAliveTimeouts = 0;
  78
  79         GsonBuilder gsonBuilder = new GsonBuilder();
  80         gsonBuilder.excludeFieldsWithoutExposeAnnotation();
  81         Gson gson = gsonBuilder.create();
  82         this.gsonBuilder = gson;
  83         this.shutdown = true;
  84     }
  85
  86     public boolean isRunning() {
  87         return !shutdown;
  88     }
  89
  90     public void start(Executor executor) {
  91         shutdown = false;
  92         executor.execute(this);
  93     }
  94
  95     /**
  96      * Send keep-alive as necessary and listen for push messages
  97      */
  98     @Override
  99     public void run() {
 100         receivePackets();
 101     }
 102
 103     /**
 104      * Gracefully shutdown thread. Worst case takes TIMEOUT_TO_DATAGRAM_RECEPTION to
 105      * shutdown.
 106      */
 107     public void shutdown() {
 108         this.shutdown = true;
 109         DatagramSocket s = this.socket;
 110         if (s != null) {
 111             s.close();
 112             logger.debug("Listener closed socket");
 113             this.socket = null;
 114         }
 115     }
 116
 117     private void sendBPUPKeepAlive() {
 118         // Create a buffer and packet for the response
 119         byte[] buffer = new byte[256];
 120         DatagramPacket inPacket = new DatagramPacket(buffer, buffer.length);
 121
 122         DatagramSocket sock = this.socket;
 123         if (sock != null) {
 124             logger.trace("Sending keep-alive request ('\\n')");
 125             try {
 126                 byte[] outBuffer = { (byte) '\n' };
 127                 InetAddress inetAddress = InetAddress.getByName(bridgeHandler.getBridgeIpAddress());
 128                 DatagramPacket outPacket = new DatagramPacket(outBuffer, 1, inetAddress, BOND_BPUP_PORT);
 129                 sock.send(outPacket);
 130                 sock.receive(inPacket);
 131                 BPUPUpdate response = transformUpdatePacket(inPacket);
 132                 if (response != null) {
 133                     if (!response.bondId.equalsIgnoreCase(bridgeHandler.getBridgeId())) {
 134                         logger.warn("Response isn't from expected Bridge!  Expected: {}  Got: {}",
 135                                 bridgeHandler.getBridgeId(), response.bondId);
 136                     } else {
 137                         bridgeHandler.setBridgeOnline(inPacket.getAddress().getHostAddress());
 138                         numberOfKeepAliveTimeouts = 0;
 139                     }
 140                 }
 141             } catch (SocketTimeoutException e) {
 142                 numberOfKeepAliveTimeouts++;
 143                 logger.trace("BPUP Socket timeout, number of timeouts: {}", numberOfKeepAliveTimeouts);
 144                 if (numberOfKeepAliveTimeouts > 10) {
 145                     bridgeHandler.setBridgeOffline(ThingStatusDetail.COMMUNICATION_ERROR,
 146                             "@text/offline.comm-error.timeout");
 147                 }
 148             } catch (IOException e) {
 149                 logger.debug("One exception has occurred", e);
 150             }
 151         }
 152     }
 153
 154     private void receivePackets() {
 155         try {
 156             DatagramSocket s = new DatagramSocket(null);
 157             s.setSoTimeout(SOCKET_TIMEOUT_MILLISECONDS);
 158             s.bind(null);
 159             socket = s;
 160             logger.debug("Listener created UDP socket on port {} with timeout {}", s.getPort(),
 161                     SOCKET_TIMEOUT_MILLISECONDS);
 162         } catch (SocketException e) {
 163             logger.debug("Listener got SocketException", e);
 164             datagramSocketHealthRoutine();
 165         }
 166
 167         // Create a buffer and packet for the response
 168         byte[] buffer = new byte[256];
 169         DatagramPacket inPacket = new DatagramPacket(buffer, buffer.length);
 170
 171         DatagramSocket sock = this.socket;
 172         while (sock != null && !this.shutdown) {
 173             // Check if we're due to send something to keep the connection
 174             long now = System.nanoTime() / 1000000L;
 175             long timePassedFromLastKeepAlive = now - timeOfLastKeepAlivePacket;
 176
 177             if (timeOfLastKeepAlivePacket == -1 || timePassedFromLastKeepAlive >= 60000L) {
 178                 sendBPUPKeepAlive();
 179                 timeOfLastKeepAlivePacket = now;
 180             }
 181
 182             try {
 183                 sock.receive(inPacket);
 184                 processPacket(inPacket);
 185             } catch (SocketTimeoutException e) {
 186                 // Ignore. Means there was no updates while we waited.
 187                 // We'll just loop around and try again after sending a keep alive.
 188             } catch (IOException e) {
 189                 logger.debug("Listener got IOException waiting for datagram: {}", e.getMessage());
 190                 datagramSocketHealthRoutine();
 191             }
 192         }
 193         logger.debug("Listener exiting");
 194     }
 195
 196     private void processPacket(DatagramPacket packet) {
 197         logger.trace("Got datagram of length {} from {}", packet.getLength(), packet.getAddress().getHostAddress());
 198
 199         BPUPUpdate update = transformUpdatePacket(packet);
 200         if (update != null) {
 201             if (!update.bondId.equalsIgnoreCase(bridgeHandler.getBridgeId())) {
 202                 logger.warn("Response isn't from expected Bridge!  Expected: {}  Got: {}", bridgeHandler.getBridgeId(),
 203                         update.bondId);
 204             }
 205
 206             // Check for duplicate packet
 207             if (isDuplicate(update)) {
 208                 logger.trace("Dropping duplicate packet");
 209                 return;
 210             }
 211
 212             // Send the update the the bridge for it to pass on to the devices
 213             if (update.topic != null) {
 214                 logger.trace("Forwarding message to bridge handler");
 215                 bridgeHandler.forwardUpdateToThing(update);
 216             } else {
 217                 logger.debug("No topic in incoming message!");
 218             }
 219         }
 220     }
 221
 222     /**
 223      * Method that transforms {@link DatagramPacket} to a {@link BPUPUpdate} Object
 224      *
 225      * @param packet the {@link DatagramPacket}
 226      * @return the {@link BPUPUpdate}
 227      */
 228     public @Nullable BPUPUpdate transformUpdatePacket(final DatagramPacket packet) {
 229         String responseJson = new String(packet.getData(), 0, packet.getLength(), UTF_8);
 230         logger.debug("Message from {}:{} -> {}", packet.getAddress().getHostAddress(), packet.getPort(), responseJson);
 231
 232         @Nullable
 233         BPUPUpdate response = null;
 234         try {
 235             response = this.gsonBuilder.fromJson(responseJson, BPUPUpdate.class);
 236         } catch (JsonParseException e) {
 237             logger.warn("Error parsing json! {}", e.getMessage());
 238         }
 239         return response;
 240     }
 241
 242     private boolean isDuplicate(BPUPUpdate update) {
 243         boolean packetIsDuplicate = false;
 244         String newReqestId = update.requestId;
 245         String lastRequestId = this.lastRequestId;
 246         if (lastRequestId != null && newReqestId != null) {
 247             if (lastRequestId.equalsIgnoreCase(newReqestId)) {
 248                 packetIsDuplicate = true;
 249             }
 250         }
 251         // Remember this packet for duplicate check
 252         lastRequestId = newReqestId;
 253         return packetIsDuplicate;
 254     }
 255
 256     private void datagramSocketHealthRoutine() {
 257         @Nullable
 258         DatagramSocket datagramSocket = this.socket;
 259         if (datagramSocket == null || (datagramSocket.isClosed() || !datagramSocket.isConnected())) {
 260             logger.trace("Datagram Socket is disconnected or has been closed, reconnecting...");
 261             try {
 262                 // close the socket before trying to reopen
 263                 if (datagramSocket != null) {
 264                     datagramSocket.close();
 265                 }
 266                 logger.trace("Old socket closed.");
 267                 try {
 268                     Thread.sleep(SOCKET_RETRY_TIMEOUT_MILLISECONDS);
 269                 } catch (InterruptedException e) {
 270                     Thread.currentThread().interrupt();
 271                 }
 272                 DatagramSocket s = new DatagramSocket(null);
 273                 s.setSoTimeout(SOCKET_TIMEOUT_MILLISECONDS);
 274                 s.bind(null);
 275                 this.socket = s;
 276                 logger.trace("Datagram Socket reconnected using port {}.", s.getPort());
 277             } catch (SocketException exception) {
 278                 logger.warn("Problem creating new socket : {}", exception.getLocalizedMessage());
 279             }
 280         }
 281     }
 282 }