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

   1 /**
   2  * Copyright (c) 2010-2021 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.icalendar.internal.handler;
  14
  15 import static org.openhab.binding.icalendar.internal.ICalendarBindingConstants.HTTP_TIMEOUT_SECS;
  16
  17 import java.io.File;
  18 import java.io.FileInputStream;
  19 import java.io.FileOutputStream;
  20 import java.io.IOException;
  21 import java.io.InputStream;
  22 import java.net.URI;
  23 import java.nio.file.Files;
  24 import java.nio.file.StandardCopyOption;
  25 import java.util.concurrent.ExecutionException;
  26 import java.util.concurrent.TimeUnit;
  27 import java.util.concurrent.TimeoutException;
  28
  29 import org.eclipse.jdt.annotation.NonNullByDefault;
  30 import org.eclipse.jdt.annotation.Nullable;
  31 import org.eclipse.jetty.client.HttpClient;
  32 import org.eclipse.jetty.client.api.Authentication;
  33 import org.eclipse.jetty.client.api.Request;
  34 import org.eclipse.jetty.client.api.Response;
  35 import org.eclipse.jetty.client.util.BasicAuthentication;
  36 import org.eclipse.jetty.client.util.InputStreamResponseListener;
  37 import org.eclipse.jetty.http.HttpHeader;
  38 import org.eclipse.jetty.http.HttpMethod;
  39 import org.eclipse.jetty.http.HttpStatus;
  40 import org.openhab.binding.icalendar.internal.logic.AbstractPresentableCalendar;
  41 import org.openhab.binding.icalendar.internal.logic.CalendarException;
  42 import org.slf4j.Logger;
  43 import org.slf4j.LoggerFactory;
  44
  45 /**
  46  * The Job for pulling an update of a calendar. Fires
  47  * {@link CalendarUpdateListener#onCalendarUpdated()} after successful update.
  48  *
  49  * @author Michael Wodniok - Initial contribution
  50  * @author Michael Wodniok - Added better descriptions for some errors while
  51  *         downloading calendar
  52  */
  53 @NonNullByDefault
  54 class PullJob implements Runnable {
  55     private static final String TMP_FILE_PREFIX = "icalendardld";
  56
  57     private final Authentication.@Nullable Result authentication;
  58     private final File destination;
  59     private final HttpClient httpClient;
  60     private final CalendarUpdateListener listener;
  61     private final Logger logger = LoggerFactory.getLogger(PullJob.class);
  62     private final int maxSize;
  63     private final URI sourceURI;
  64
  65     /**
  66      * Constructor of PullJob for creating a single pull of a calendar.
  67      *
  68      * @param httpClient A HttpClient for getting the source
  69      * @param sourceURI The source as URI
  70      * @param username Optional username for basic auth. Must be set together with a password.
  71      * @param password Optional password for basic auth. Must be set together with an username.
  72      * @param destination The destination the downloaded calendar should be saved to.
  73      * @param maxSize The maximum size of the downloaded calendar in bytes.
  74      * @param listener The listener that should be fired when update succeed.
  75      */
  76     public PullJob(HttpClient httpClient, URI sourceURI, @Nullable String username, @Nullable String password,
  77             File destination, int maxSize, CalendarUpdateListener listener) {
  78         this.httpClient = httpClient;
  79         this.sourceURI = sourceURI;
  80         if (username != null && password != null) {
  81             authentication = new BasicAuthentication.BasicResult(this.sourceURI, username, password);
  82         } else {
  83             authentication = null;
  84         }
  85         this.destination = destination;
  86         this.listener = listener;
  87         this.maxSize = maxSize;
  88     }
  89
  90     @Override
  91     public void run() {
  92         final Request request = httpClient.newRequest(sourceURI).followRedirects(true).method(HttpMethod.GET);
  93         final Authentication.Result currentAuthentication = authentication;
  94         if (currentAuthentication != null) {
  95             currentAuthentication.apply(request);
  96         }
  97
  98         final InputStreamResponseListener asyncListener = new InputStreamResponseListener();
  99         request.send(asyncListener);
 100
 101         Response response;
 102         try {
 103             response = asyncListener.get(HTTP_TIMEOUT_SECS, TimeUnit.SECONDS);
 104         } catch (InterruptedException e1) {
 105             logger.warn("Download of calendar was interrupted.");
 106             logger.debug("InterruptedException message is: {}", e1.getMessage());
 107             return;
 108         } catch (TimeoutException e1) {
 109             logger.warn("Download of calendar timed out (waited too long for headers).");
 110             logger.debug("TimeoutException message is: {}", e1.getMessage());
 111             return;
 112         } catch (ExecutionException e1) {
 113             logger.warn("Download of calendar failed.");
 114             logger.debug("ExecutionException message is: {}", e1.getCause().getMessage());
 115             return;
 116         }
 117
 118         if (response.getStatus() != HttpStatus.OK_200) {
 119             logger.warn("Response status for getting \"{}\" was {} instead of 200. Ignoring it.", sourceURI,
 120                     response.getStatus());
 121             return;
 122         }
 123
 124         final String responseLength = response.getHeaders().get(HttpHeader.CONTENT_LENGTH);
 125         if (responseLength != null) {
 126             try {
 127                 if (Integer.parseInt(responseLength) > maxSize) {
 128                     logger.warn(
 129                             "Calendar is too big ({} bytes > {} bytes), aborting request. You may change the maximum calendar size in configuration, if appropriate.",
 130                             responseLength, maxSize);
 131                     response.abort(new ResponseTooBigException());
 132                     return;
 133                 }
 134             } catch (NumberFormatException e) {
 135                 logger.debug(
 136                         "While requesting calendar Content-Length was set, but is malformed. Falling back to read-loop.",
 137                         e);
 138             }
 139         }
 140
 141         File tmpTargetFile;
 142         try {
 143             tmpTargetFile = File.createTempFile(TMP_FILE_PREFIX, null);
 144         } catch (IOException e) {
 145             logger.warn("Not able to create temporary file for downloading iCal. Error message is: {}", e.getMessage());
 146             return;
 147         }
 148
 149         try (final FileOutputStream tmpOutStream = new FileOutputStream(tmpTargetFile);
 150                 final InputStream httpInputStream = asyncListener.getInputStream()) {
 151             final byte[] buffer = new byte[1024];
 152             int readBytesTotal = 0;
 153             int currentReadBytes = -1;
 154             while ((currentReadBytes = httpInputStream.read(buffer)) > -1) {
 155                 readBytesTotal += currentReadBytes;
 156                 if (readBytesTotal > maxSize) {
 157                     logger.warn(
 158                             "Calendar is too big (> {} bytes). Stopping receiving calendar. You may change the maximum calendar size in configuration, if appropriate.",
 159                             maxSize);
 160                     response.abort(new ResponseTooBigException());
 161                     return;
 162                 }
 163                 tmpOutStream.write(buffer, 0, currentReadBytes);
 164             }
 165         } catch (IOException e) {
 166             logger.warn("Not able to write temporary file with downloaded iCal. Error Message is: {}", e.getMessage());
 167             return;
 168         }
 169
 170         try (final FileInputStream tmpInput = new FileInputStream(tmpTargetFile)) {
 171             AbstractPresentableCalendar.create(tmpInput);
 172         } catch (IOException | CalendarException e) {
 173             logger.warn(
 174                     "Not able to read downloaded iCal. Validation failed or file not readable. Error message is: {}",
 175                     e.getMessage());
 176             return;
 177         }
 178
 179         try {
 180             Files.move(tmpTargetFile.toPath(), destination.toPath(), StandardCopyOption.REPLACE_EXISTING);
 181         } catch (IOException e) {
 182             logger.warn("Failed to replace iCal file. Error message is: {}", e.getMessage());
 183             return;
 184         }
 185
 186         try {
 187             listener.onCalendarUpdated();
 188         } catch (Exception e) {
 189             logger.debug("An Exception was thrown while calling back", e);
 190         }
 191     }
 192
 193     /**
 194      * Interface for calling back when the update succeed.
 195      */
 196     public static interface CalendarUpdateListener {
 197         /**
 198          * Callback when update was successful and result was placed onto target file.
 199          */
 200         public void onCalendarUpdated();
 201     }
 202
 203     /**
 204      * Exception for failure if size of the response is greater than allowed.
 205      */
 206     private static class ResponseTooBigException extends Exception {
 207
 208         /**
 209          * The only local definition. Rest of implementation is taken from Exception or is default.
 210          */
 211         private static final long serialVersionUID = 7033851403473533793L;
 212     }
 213 }