HubIOStream.java

/**
 * Copyright (c) 2010-2016 by the respective copyright holders.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 */
package org.openhab.binding.insteonplm.internal.driver.hub;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigInteger;
import java.nio.ByteBuffer;

import org.apache.http.HttpResponse;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.util.EntityUtils;
import org.openhab.binding.insteonplm.internal.driver.IOStream;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Implements IOStream for a Hub 2014 device
 * 
 * @author Daniel Pfrommer
 * @since 1.7.0
 *
 */
public class HubIOStream extends IOStream implements Runnable {
    private static final Logger logger = LoggerFactory.getLogger(HubIOStream.class);

    /** time between polls (in milliseconds */
    private int m_pollTime = 1000;

    private String m_host = null;
    private int m_port = -1;
    private String m_user = null;
    private String m_pass = null;

    private DefaultHttpClient m_client = null;
    private Thread m_pollThread = null;

    // index of the last byte we have read in the buffer
    private int m_bufferIdx = -1;

    /**
     * Constructor for HubIOStream
     * 
     * @param host host name of hub device
     * @param port port to connect to
     * @param pollTime time between polls (in milliseconds)
     * @param user hub user name
     * @param pass hub password
     */
    public HubIOStream(String host, int port, int pollTime, String user, String pass) {
        m_host = host;
        m_port = port;
        m_pollTime = pollTime;
        m_user = user;
        m_pass = pass;
    }

    @Override
    public boolean open() {
        m_client = new DefaultHttpClient();
        if (m_user != null && m_pass != null) {
            m_client.getCredentialsProvider().setCredentials(new AuthScope(m_host, m_port),
                    new UsernamePasswordCredentials(m_user, m_pass));
        }
        HttpConnectionParams.setConnectionTimeout(m_client.getParams(), 5000);

        m_in = new HubInputStream();

        m_pollThread = new Thread(this);
        m_pollThread.start();

        m_out = new HubOutputStream();
        return true;
    }

    @Override
    public void close() {
        m_pollThread.interrupt();
        m_client = null;

        try {
            m_in.close();
            m_out.close();
        } catch (IOException e) {
            logger.error("failed to close streams", e);
        }
    }

    /**
     * Fetches the latest status buffer from the Hub
     * 
     * @return string with status buffer
     * @throws IOException
     */
    private synchronized String bufferStatus() throws IOException {
        String result = getURL("/buffstatus.xml");
        String[] parts = result.split("<BS>");
        if (parts.length > 1) {
            result = parts[1].split("</BS>")[0].trim();
        } else if (result.startsWith("401 Unauthorized:")) {
            logger.error("bad username or password. See bottom label of hub for correct login");
            throw new IOException("login credentials incorrect");
        } else {
            logger.error("got invalid buffer status: {}", result);
            throw new IOException("malformed bufferstatus.xml");
        }
        return result;
    }

    /**
     * Sends command to Hub to clear the status buffer
     * 
     * @throws IOException
     */
    private synchronized void clearBuffer() throws IOException {
        getURL("/1?XB=M=1");
        m_bufferIdx = 0;
    }

    /**
     * Sends Insteon message (byte array) as a readable ascii string to the Hub
     * 
     * @param msg byte array representing the Insteon message
     * @throws IOException in case of I/O error
     */
    public synchronized void write(ByteBuffer msg) throws IOException {
        poll(); // fetch the status buffer before we send out commands
        clearBuffer(); // clear the status buffer explicitly.

        StringBuilder b = new StringBuilder();
        while (msg.remaining() > 0) {
            b.append(String.format("%02x", msg.get()));
        }
        String hexMSG = b.toString();
        getURL("/3?" + hexMSG + "=I=3");
    }

    /**
     * Polls the Hub web interface to fetch the status buffer
     * 
     * @throws IOException if something goes wrong with I/O
     */
    public synchronized void poll() throws IOException {
        String buffer = bufferStatus(); // fetch via http call
        logger.trace("poll: {}", buffer);
        //
        // The Hub maintains a ring buffer where the last two digits (in hex!) represent
        // the position of the last byte read.
        //
        String data = buffer.substring(0, buffer.length() - 2); // pure data w/o index pointer

        int nIdx = -1;
        try {
            nIdx = Integer.parseInt(buffer.substring(buffer.length() - 2, buffer.length()), 16);
        } catch (NumberFormatException e) {
            m_bufferIdx = -1;
            logger.error("invalid buffer size received in line: {}", buffer);
            return;
        }

        if (m_bufferIdx == -1) {
            // this is the first call or first call after error, no need for buffer copying
            m_bufferIdx = nIdx;
            return; // XXX why return here????
        }

        StringBuilder msg = new StringBuilder();
        if (nIdx < m_bufferIdx) {
            msg.append(data.substring(m_bufferIdx + 1, data.length()));
            msg.append(data.substring(0, nIdx));
            logger.trace("wrap around: copying new data on: {}", msg.toString());
        } else {
            msg.append(data.substring(m_bufferIdx, nIdx));
            logger.trace("no wrap:      appending new data: {}", msg.toString());
        }
        if (msg.length() != 0) {
            ByteBuffer buf = ByteBuffer.wrap(s_hexStringToByteArray(msg.toString()));
            ((HubInputStream) m_in).handle(buf);
        }
        m_bufferIdx = nIdx;
    }

    /**
     * Helper method to fetch url from http server
     * 
     * @param resource the url
     * @return contents returned by http server
     * @throws IOException
     */
    private String getURL(String resource) throws IOException {
        synchronized (m_client) {
            StringBuilder b = new StringBuilder();
            b.append("http://");
            b.append(m_host);
            if (m_port != -1) {
                b.append(":").append(m_port);
            }
            b.append(resource);

            HttpGet get = new HttpGet(b.toString());
            HttpResponse res = m_client.execute(get);
            String html = EntityUtils.toString(res.getEntity());
            return html;
        }
    }

    /**
     * Entry point for thread
     */
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                poll();
            } catch (IOException e) {
                logger.error("got exception while polling: {}", e.toString());
            }
            try {
                Thread.sleep(m_pollTime);
            } catch (InterruptedException e) {
                break;
            }
        }
    }

    /**
     * Helper function to convert an ascii hex string (received from hub)
     * into a byte array
     * 
     * @param s string received from hub
     * @return simple byte array
     */
    public static byte[] s_hexStringToByteArray(String s) {
        return new BigInteger(s, 16).toByteArray();
    }

    /**
     * Implements an InputStream for the Hub 2014
     * 
     * @author Daniel Pfrommer
     *
     */
    public class HubInputStream extends InputStream {

        // A buffer to keep bytes while we are waiting for the inputstream to read
        private ReadByteBuffer m_buffer = new ReadByteBuffer(1024);

        public HubInputStream() {
        }

        public void handle(ByteBuffer buffer) throws IOException {
            // Make sure we cleanup as much space as possible
            m_buffer.makeCompact();
            m_buffer.add(buffer.array());
        }

        @Override
        public int read() throws IOException {
            return m_buffer.get();
        }

        @Override
        public int read(byte[] b, int off, int len) throws IOException {
            return m_buffer.get(b, off, len);
        }

        @Override
        public void close() throws IOException {
        }
    }

    /**
     * Implements an OutputStream for the Hub 2014
     * 
     * @author Daniel Pfrommer
     *
     */
    public class HubOutputStream extends OutputStream {
        private ByteArrayOutputStream m_out = new ByteArrayOutputStream();

        @Override
        public void write(int b) {
            m_out.write(b);
            flushBuffer();
        }

        @Override
        public void write(byte[] b, int off, int len) {
            m_out.write(b, off, len);
            flushBuffer();
        }

        private void flushBuffer() {
            ByteBuffer buffer = ByteBuffer.wrap(m_out.toByteArray());
            try {
                HubIOStream.this.write(buffer);
            } catch (IOException e) {
                logger.error("failed to write to hub: {}", e.toString());
            }
            m_out.reset();
        }
    }
}