ONOS-3605 Create thread Session input stream mechanism, adding listener for events from the device

Change-Id: Ib323487f61d9e595f7ccdc1957a92e58b7002d2a

@@ -19,7 +19,6 @@ package org.onosproject.netconf;
 import org.onlab.packet.IpAddress;
 import org.onlab.packet.IpAddress;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.DeviceId;
 
 
-import java.io.IOException;
 import java.util.Map;
 import java.util.Map;
 
 
 /**
 /**
@@ -48,8 +47,9 @@ public interface NetconfController {
      *
      *
      * @param deviceInfo info about the device to add
      * @param deviceInfo info about the device to add
      * @return NetconfDevice Netconf device
      * @return NetconfDevice Netconf device
+     * @throws NetconfException when device is not available
      */
      */
-    NetconfDevice connectDevice(NetconfDeviceInfo deviceInfo) throws IOException;
+    NetconfDevice connectDevice(NetconfDeviceInfo deviceInfo) throws NetconfException;
 
 
     /**
     /**
      * Removes a Netconf device.
      * Removes a Netconf device.

+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.netconf;
+
+import org.onosproject.event.AbstractEvent;
+
+/**
+ * Describes network configuration event.
+ */
+public final class NetconfDeviceOutputEvent extends
+        AbstractEvent<NetconfDeviceOutputEvent.Type, Object> {
+
+    private final String messagePayload;
+    private final int messageID;
+    private final NetconfDeviceInfo deviceInfo;
+
+    /**
+     * Type of network configuration events.
+     */
+    public enum Type {
+        /**
+         * Signifies that sent a reply to a request.
+         */
+        DEVICE_REPLY,
+
+        /**
+         * Signifies that the device sent a notification.
+         */
+        DEVICE_NOTIFICATION,
+
+        /**
+         * Signifies that the device is not reachable.
+         */
+        DEVICE_UNREGISTERED,
+
+        /**
+         * Signifies that the device has encountered an error.
+         */
+        DEVICE_ERROR,
+
+    }
+
+    /**
+     * Creates an event of a given type and for the specified subject and the
+     * current time.
+     *
+     * @param type              event type
+     * @param subject           event subject
+     * @param payload           message from the device
+     * @param msgID             id of the message related to the event
+     * @param netconfDeviceInfo device of event
+     */
+    public NetconfDeviceOutputEvent(Type type, Object subject, String payload, int msgID,
+                                    NetconfDeviceInfo netconfDeviceInfo) {
+        super(type, subject);
+        messagePayload = payload;
+        this.messageID = msgID;
+        deviceInfo = netconfDeviceInfo;
+    }
+
+    /**
+     * Creates an event of a given type and for the specified subject and time.
+     *
+     * @param type              event type
+     * @param subject           event subject
+     * @param payload           message from the device
+     * @param msgID             id of the message related to the event
+     * @param netconfDeviceInfo device of event
+     * @param msgID             id of the message related to the event
+     * @param time              occurrence time
+     */
+    public NetconfDeviceOutputEvent(Type type, Object subject, String payload, int msgID,
+                                    NetconfDeviceInfo netconfDeviceInfo, long time) {
+        super(type, subject, time);
+        messagePayload = payload;
+        deviceInfo = netconfDeviceInfo;
+        this.messageID = msgID;
+    }
+
+    public String getMessagePayload() {
+        return messagePayload;
+    }
+
+    public NetconfDeviceInfo getDeviceInfo() {
+        return deviceInfo;
+    }
+
+    public Integer getMessageID() {
+        return messageID;
+    }
+}

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.netconf;
+
+import org.onosproject.event.EventListener;
+
+/**
+ * Interface for Netconf device output Listeners.
+ */
+public interface NetconfDeviceOutputEventListener extends EventListener<NetconfDeviceOutputEvent> {
+}

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.netconf;
+
+import java.io.IOException;
+
+/**
+ * Represents class of errors related to NETCONF SB protocol.
+ */
+public class NetconfException extends IOException {
+    /**
+     * Constructs an exception with the specified message.
+     *
+     * @param message the message describing the specific nature of the error
+     */
+    public NetconfException(String message) {
+        super(message);
+    }
+
+    /**
+     * Constructs an exception with the specified message and the underlying cause.
+     *
+     * @param message the message describing the specific nature of the error
+     * @param cause   the underlying cause of this error
+     */
+    public NetconfException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

@@ -16,8 +16,8 @@
 
 
 package org.onosproject.netconf;
 package org.onosproject.netconf;
 
 
-import java.io.IOException;
 import java.util.List;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
 
 
 /**
 /**
  * NETCONF session object that allows NETCONF operations on top with the physical
  * NETCONF session object that allows NETCONF operations on top with the physical
@@ -27,28 +27,45 @@ import java.util.List;
 public interface NetconfSession {
 public interface NetconfSession {
 
 
     /**
     /**
+     * Executes an asynchronous RPC to the server and obtains a future to be completed.
+     *
+     * @param request the XML containing the RPC for the server.
+     * @return Server response or ERROR
+     * @throws NetconfException when there is a problem in the communication process on
+     * the underlying connection
+     */
+    CompletableFuture<String> request(String request) throws NetconfException;
+
+
+    /**
      * Retrives the requested configuration, different from get-config.
      * Retrives the requested configuration, different from get-config.
      *
      *
      * @param request the XML containing the request to the server.
      * @param request the XML containing the request to the server.
      * @return device running configuration
      * @return device running configuration
+     * @throws NetconfException when there is a problem in the communication process on
+     * the underlying connection
      */
      */
-    String get(String request) throws IOException;
+    String get(String request) throws NetconfException;
 
 
     /**
     /**
-     * Executes an RPC to the server.
+     * Executes an synchronous RPC to the server.
      *
      *
      * @param request the XML containing the RPC for the server.
      * @param request the XML containing the RPC for the server.
      * @return Server response or ERROR
      * @return Server response or ERROR
+     * @throws NetconfException when there is a problem in the communication process on
+     * the underlying connection
      */
      */
-    String doRPC(String request) throws IOException;
+    String requestSync(String request) throws NetconfException;
 
 
     /**
     /**
      * Retrives the specified configuration.
      * Retrives the specified configuration.
      *
      *
      * @param targetConfiguration the type of configuration to retrieve.
      * @param targetConfiguration the type of configuration to retrieve.
      * @return specified configuration.
      * @return specified configuration.
+     * @throws NetconfException when there is a problem in the communication process on
+     * the underlying connection
      */
      */
-    String getConfig(String targetConfiguration) throws IOException;
+    String getConfig(String targetConfiguration) throws NetconfException;
 
 
     /**
     /**
      * Retrives part of the specivied configuration based on the filterSchema.
      * Retrives part of the specivied configuration based on the filterSchema.
@@ -57,28 +74,35 @@ public interface NetconfSession {
      * @param configurationFilterSchema XML schema to filter the configuration
      * @param configurationFilterSchema XML schema to filter the configuration
      *                                  elements we are interested in
      *                                  elements we are interested in
      * @return device running configuration.
      * @return device running configuration.
+     * @throws NetconfException when there is a problem in the communication process on
+     * the underlying connection
      */
      */
     String getConfig(String targetConfiguration, String configurationFilterSchema)
     String getConfig(String targetConfiguration, String configurationFilterSchema)
-            throws IOException;
+            throws NetconfException;
 
 
     /**
     /**
      * Retrives part of the specified configuration based on the filterSchema.
      * Retrives part of the specified configuration based on the filterSchema.
      *
      *
      * @param newConfiguration configuration to set
      * @param newConfiguration configuration to set
      * @return true if the configuration was edited correctly
      * @return true if the configuration was edited correctly
+     * @throws NetconfException when there is a problem in the communication process on
+     * the underlying connection
      */
      */
 
 
-    boolean editConfig(String newConfiguration) throws IOException;
+    boolean editConfig(String newConfiguration) throws NetconfException;
 
 
     /**
     /**
      * Retrives part of the specified configuration based on the filterSchema.
      * Retrives part of the specified configuration based on the filterSchema.
+     *
      * @param targetConfiguration the targetConfiguration to change
      * @param targetConfiguration the targetConfiguration to change
      * @param mode                selected mode to change the configuration
      * @param mode                selected mode to change the configuration
      * @param newConfiguration    configuration to set
      * @param newConfiguration    configuration to set
      * @return true if the configuration was edited correctly
      * @return true if the configuration was edited correctly
+     * @throws NetconfException when there is a problem in the communication process on
+     * the underlying connection
      */
      */
     boolean editConfig(String targetConfiguration, String mode, String newConfiguration)
     boolean editConfig(String targetConfiguration, String mode, String newConfiguration)
-            throws IOException;
+            throws NetconfException;
 
 
     /**
     /**
      * Copies the new configuration, an Url or a complete configuration xml tree
      * Copies the new configuration, an Url or a complete configuration xml tree
@@ -88,39 +112,49 @@ public interface NetconfSession {
      * @param targetConfiguration the type of configuration to retrieve.
      * @param targetConfiguration the type of configuration to retrieve.
      * @param newConfiguration    configuration to set
      * @param newConfiguration    configuration to set
      * @return true if the configuration was copied correctly
      * @return true if the configuration was copied correctly
+     * @throws NetconfException when there is a problem in the communication process on
+     * the underlying connection
      */
      */
     boolean copyConfig(String targetConfiguration, String newConfiguration)
     boolean copyConfig(String targetConfiguration, String newConfiguration)
-            throws IOException;
+            throws NetconfException;
 
 
     /**
     /**
      * Deletes part of the specified configuration based on the filterSchema.
      * Deletes part of the specified configuration based on the filterSchema.
      *
      *
      * @param targetConfiguration the name of the configuration to delete
      * @param targetConfiguration the name of the configuration to delete
      * @return true if the configuration was copied correctly
      * @return true if the configuration was copied correctly
+     * @throws NetconfException when there is a problem in the communication process on
+     * the underlying connection
      */
      */
-    boolean deleteConfig(String targetConfiguration) throws IOException;
+    boolean deleteConfig(String targetConfiguration) throws NetconfException;
 
 
     /**
     /**
      * Locks the candidate configuration.
      * Locks the candidate configuration.
      *
      *
      * @return true if successful.
      * @return true if successful.
+     * @throws NetconfException when there is a problem in the communication process on
+     * the underlying connection
      */
      */
-    boolean lock() throws IOException;
+    boolean lock() throws NetconfException;
 
 
     /**
     /**
      * Unlocks the candidate configuration.
      * Unlocks the candidate configuration.
      *
      *
      * @return true if successful.
      * @return true if successful.
+     * @throws NetconfException when there is a problem in the communication process on
+     * the underlying connection
      */
      */
-    boolean unlock() throws IOException;
+    boolean unlock() throws NetconfException;
 
 
     /**
     /**
      * Closes the Netconf session with the device.
      * Closes the Netconf session with the device.
      * the first time it tries gracefully, then kills it forcefully
      * the first time it tries gracefully, then kills it forcefully
      *
      *
      * @return true if closed
      * @return true if closed
+     * @throws NetconfException when there is a problem in the communication process on
+     * the underlying connection
      */
      */
-    boolean close() throws IOException;
+    boolean close() throws NetconfException;
 
 
     /**
     /**
      * Gets the session ID of the Netconf session.
      * Gets the session ID of the Netconf session.
@@ -137,10 +171,24 @@ public interface NetconfSession {
     String getServerCapabilities();
     String getServerCapabilities();
 
 
     /**
     /**
-     * Sets the device capabilities.
+     * Sets the ONOS side capabilities.
      *
      *
      * @param capabilities list of capabilities the device has.
      * @param capabilities list of capabilities the device has.
      */
      */
     void setDeviceCapabilities(List<String> capabilities);
     void setDeviceCapabilities(List<String> capabilities);
 
 
+    /**
+     * Remove a listener from the underlying stream handler implementation.
+     *
+     * @param listener event listener.
+     */
+    void addDeviceOutputListener(NetconfDeviceOutputEventListener listener);
+
+    /**
+     * Remove a listener from the underlying stream handler implementation.
+     *
+     * @param listener event listener.
+     */
+    void removeDeviceOutputListener(NetconfDeviceOutputEventListener listener);
+
 }
 }

@@ -26,11 +26,11 @@ import org.onosproject.netconf.NetconfController;
 import org.onosproject.netconf.NetconfDevice;
 import org.onosproject.netconf.NetconfDevice;
 import org.onosproject.netconf.NetconfDeviceInfo;
 import org.onosproject.netconf.NetconfDeviceInfo;
 import org.onosproject.netconf.NetconfDeviceListener;
 import org.onosproject.netconf.NetconfDeviceListener;
+import org.onosproject.netconf.NetconfException;
 import org.osgi.service.component.ComponentContext;
 import org.osgi.service.component.ComponentContext;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
-import java.io.IOException;
 import java.util.Map;
 import java.util.Map;
 import java.util.Set;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentHashMap;
@@ -90,9 +90,9 @@ public class NetconfControllerImpl implements NetconfController {
     }
     }
 
 
     @Override
     @Override
-    public NetconfDevice connectDevice(NetconfDeviceInfo deviceInfo) throws IOException {
+    public NetconfDevice connectDevice(NetconfDeviceInfo deviceInfo) throws NetconfException {
         if (netconfDeviceMap.containsKey(deviceInfo.getDeviceId())) {
         if (netconfDeviceMap.containsKey(deviceInfo.getDeviceId())) {
-            log.warn("Device {} is already present", deviceInfo);
+            log.info("Device {} is already present", deviceInfo);
             return netconfDeviceMap.get(deviceInfo.getDeviceId());
             return netconfDeviceMap.get(deviceInfo.getDeviceId());
         } else {
         } else {
             log.info("Creating NETCONF device {}", deviceInfo);
             log.info("Creating NETCONF device {}", deviceInfo);
@@ -109,9 +109,8 @@ public class NetconfControllerImpl implements NetconfController {
         }
         }
     }
     }
 
 
-    private NetconfDevice createDevice(NetconfDeviceInfo deviceInfo) throws IOException {
-        NetconfDevice netconfDevice = null;
-        netconfDevice = new NetconfDeviceImpl(deviceInfo);
+    private NetconfDevice createDevice(NetconfDeviceInfo deviceInfo) throws NetconfException {
+        NetconfDevice netconfDevice = new NetconfDeviceImpl(deviceInfo);
         for (NetconfDeviceListener l : netconfDeviceListeners) {
         for (NetconfDeviceListener l : netconfDeviceListeners) {
             l.deviceAdded(deviceInfo);
             l.deviceAdded(deviceInfo);
         }
         }

@@ -18,6 +18,7 @@ package org.onosproject.netconf.ctl;
 
 
 import org.onosproject.netconf.NetconfDevice;
 import org.onosproject.netconf.NetconfDevice;
 import org.onosproject.netconf.NetconfDeviceInfo;
 import org.onosproject.netconf.NetconfDeviceInfo;
+import org.onosproject.netconf.NetconfException;
 import org.onosproject.netconf.NetconfSession;
 import org.onosproject.netconf.NetconfSession;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
@@ -36,12 +37,13 @@ public class NetconfDeviceImpl implements NetconfDevice {
     private boolean deviceState = false;
     private boolean deviceState = false;
     private NetconfSession netconfSession;
     private NetconfSession netconfSession;
 
 
-    public NetconfDeviceImpl(NetconfDeviceInfo deviceInfo) throws IOException {
+    public NetconfDeviceImpl(NetconfDeviceInfo deviceInfo) throws NetconfException {
         netconfDeviceInfo = deviceInfo;
         netconfDeviceInfo = deviceInfo;
         try {
         try {
             netconfSession = new NetconfSessionImpl(netconfDeviceInfo);
             netconfSession = new NetconfSessionImpl(netconfDeviceInfo);
         } catch (IOException e) {
         } catch (IOException e) {
-            throw new IOException("Cannot create connection and session", e);
+            throw new NetconfException("Cannot create connection and session for device " +
+                                               deviceInfo, e);
         }
         }
         deviceState = true;
         deviceState = true;
     }
     }

+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.netconf.ctl;
+
+import org.onosproject.netconf.NetconfDeviceInfo;
+import org.onosproject.netconf.NetconfDeviceOutputEvent;
+import org.onosproject.netconf.NetconfDeviceOutputEventListener;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Example of a listener for events that happen a Netconf session established
+ * for a particular NETCONF device.
+ */
+public class NetconfDeviceOutputEventListenerImpl implements NetconfDeviceOutputEventListener {
+
+    private static final Logger log =
+            LoggerFactory.getLogger(NetconfDeviceOutputEventListenerImpl.class);
+
+    private NetconfDeviceInfo deviceInfo;
+
+    public NetconfDeviceOutputEventListenerImpl(NetconfDeviceInfo deviceInfo) {
+        this.deviceInfo = deviceInfo;
+    }
+
+    @Override
+    public void event(NetconfDeviceOutputEvent event) {
+        switch (event.type()) {
+            case DEVICE_REPLY:
+                log.debug("Device {} has reply: {}", deviceInfo, event.getMessagePayload());
+                break;
+            case DEVICE_NOTIFICATION:
+                log.info("Device {} has notification: {}", deviceInfo, event.getMessagePayload());
+                break;
+            case DEVICE_UNREGISTERED:
+                log.warn("Device {} has closed session", deviceInfo);
+                //TODO tell onos about closed session
+                break;
+            case DEVICE_ERROR:
+                log.warn("Device {} has error: {}", deviceInfo, event.getMessagePayload());
+                break;
+            default:
+                log.warn("Wrong event type {} ", event.type());
+        }
+
+    }
+
+    @Override
+    public boolean isRelevant(NetconfDeviceOutputEvent event) {
+        return deviceInfo.equals(event.getDeviceInfo());
+    }
+}

+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.netconf.ctl;
+
+import org.onosproject.netconf.NetconfDeviceOutputEvent;
+
+/**
+ * Entity associated with a NetconfSessionImpl and capable of receiving notifications of
+ * events about the session.
+ */
+public interface NetconfSessionDelegate {
+
+        /**
+         * Notifies the delegate via the specified event.
+         *
+         * @param event store generated event
+         */
+        void notify(NetconfDeviceOutputEvent event);
+}

+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.netconf.ctl;
+
+import org.onosproject.netconf.NetconfDeviceOutputEventListener;
+
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * Interface to represent an objects that does all the IO on a NETCONF session
+ * with a device.
+ */
+public interface NetconfStreamHandler {
+    /**
+     * Sends the request on the stream that is used to communicate to and from the device.
+     *
+     * @param request request to send to the physical device
+     * @return a CompletableFuture of type String that will contain the response for the request.
+     */
+    CompletableFuture<String> sendMessage(String request);
+
+    /**
+     * Adds a listener for netconf events on the handled stream.
+     *
+     * @param listener Netconf device event listener
+     */
+    void addDeviceEventListener(NetconfDeviceOutputEventListener listener);
+
+    /**
+     * Removes a listener for netconf events on the handled stream.
+     *
+     * @param listener Netconf device event listener
+     */
+    void removeDeviceEventListener(NetconfDeviceOutputEventListener listener);
+}

+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.netconf.ctl;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+import org.onosproject.netconf.NetconfDeviceInfo;
+import org.onosproject.netconf.NetconfDeviceOutputEvent;
+import org.onosproject.netconf.NetconfDeviceOutputEventListener;
+import org.onosproject.netconf.NetconfException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * Thread that gets spawned each time a session is established and handles all the input
+ * and output from the session's streams to and from the NETCONF device the session is
+ * established with.
+ */
+public class NetconfStreamThread extends Thread implements NetconfStreamHandler {
+
+    private static final Logger log = LoggerFactory
+            .getLogger(NetconfStreamThread.class);
+    private static final String HELLO = "hello";
+    private static final String END_PATTERN = "]]>]]>";
+    private static final String RPC_REPLY = "rpc-reply";
+    private static final String RPC_ERROR = "rpc-error";
+    private static final String NOTIFICATION_LABEL = "<notification>";
+
+    private static PrintWriter outputStream;
+    private static NetconfDeviceInfo netconfDeviceInfo;
+    private static NetconfSessionDelegate sessionDelegate;
+    private static NetconfMessageState state;
+    private static List<NetconfDeviceOutputEventListener> netconfDeviceEventListeners
+            = Lists.newArrayList();
+
+    public NetconfStreamThread(final InputStream in, final OutputStream out,
+                               final InputStream err, NetconfDeviceInfo deviceInfo,
+                               NetconfSessionDelegate delegate) {
+        super(handler(in, err));
+        outputStream = new PrintWriter(out);
+        netconfDeviceInfo = deviceInfo;
+        state = NetconfMessageState.NO_MATCHING_PATTERN;
+        sessionDelegate = delegate;
+        log.debug("Stream thread for device {} session started", deviceInfo);
+        start();
+    }
+
+    @Override
+    public CompletableFuture<String> sendMessage(String request) {
+        outputStream.print(request);
+        outputStream.flush();
+        return new CompletableFuture<>();
+    }
+
+    public enum NetconfMessageState {
+
+        NO_MATCHING_PATTERN {
+            @Override
+            NetconfMessageState evaluateChar(char c) {
+                if (c == ']') {
+                    return FIRST_BRAKET;
+                } else {
+                    return this;
+                }
+            }
+        },
+        FIRST_BRAKET {
+            @Override
+            NetconfMessageState evaluateChar(char c) {
+                if (c == ']') {
+                    return SECOND_BRAKET;
+                } else {
+                    return NO_MATCHING_PATTERN;
+                }
+            }
+        },
+        SECOND_BRAKET {
+            @Override
+            NetconfMessageState evaluateChar(char c) {
+                if (c == '>') {
+                    return FIRST_BIGGER;
+                } else {
+                    return NO_MATCHING_PATTERN;
+                }
+            }
+        },
+        FIRST_BIGGER {
+            @Override
+            NetconfMessageState evaluateChar(char c) {
+                if (c == ']') {
+                    return THIRD_BRAKET;
+                } else {
+                    return NO_MATCHING_PATTERN;
+                }
+            }
+        },
+        THIRD_BRAKET {
+            @Override
+            NetconfMessageState evaluateChar(char c) {
+                if (c == ']') {
+                    return ENDING_BIGGER;
+                } else {
+                    return NO_MATCHING_PATTERN;
+                }
+            }
+        },
+        ENDING_BIGGER {
+            @Override
+            NetconfMessageState evaluateChar(char c) {
+                if (c == '>') {
+                    return END_PATTERN;
+                } else {
+                    return NO_MATCHING_PATTERN;
+                }
+            }
+        },
+        END_PATTERN {
+            @Override
+            NetconfMessageState evaluateChar(char c) {
+                return NO_MATCHING_PATTERN;
+            }
+        };
+
+        abstract NetconfMessageState evaluateChar(char c);
+    }
+
+    private static Runnable handler(final InputStream in, final InputStream err) {
+        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(in));
+        return () -> {
+            try {
+                boolean socketClosed = false;
+                StringBuilder deviceReplyBuilder = new StringBuilder();
+                while (!socketClosed) {
+                    int cInt = bufferReader.read();
+                    if (cInt == -1) {
+                        socketClosed = true;
+                        NetconfDeviceOutputEvent event = new NetconfDeviceOutputEvent(
+                                NetconfDeviceOutputEvent.Type.DEVICE_UNREGISTERED,
+                                null, null, -1, netconfDeviceInfo);
+                        netconfDeviceEventListeners.forEach(
+                                listener -> listener.event(event));
+                    }
+                    char c = (char) cInt;
+                    state = state.evaluateChar(c);
+                    deviceReplyBuilder.append(c);
+                    if (state == NetconfMessageState.END_PATTERN) {
+                        String deviceReply = deviceReplyBuilder.toString()
+                                .replace(END_PATTERN, "");
+                        if (deviceReply.contains(RPC_REPLY) ||
+                                deviceReply.contains(RPC_ERROR) ||
+                                deviceReply.contains(HELLO)) {
+                            NetconfDeviceOutputEvent event = new NetconfDeviceOutputEvent(
+                                    NetconfDeviceOutputEvent.Type.DEVICE_REPLY,
+                                    null, deviceReply, getMsgId(deviceReply), netconfDeviceInfo);
+                            sessionDelegate.notify(event);
+                            netconfDeviceEventListeners.forEach(
+                                    listener -> listener.event(event));
+                        } else if (deviceReply.contains(NOTIFICATION_LABEL)) {
+                            final String finalDeviceReply = deviceReply;
+                            netconfDeviceEventListeners.forEach(
+                                    listener -> listener.event(new NetconfDeviceOutputEvent(
+                                            NetconfDeviceOutputEvent.Type.DEVICE_NOTIFICATION,
+                                            null, finalDeviceReply, getMsgId(finalDeviceReply), netconfDeviceInfo)));
+                        } else {
+                            log.info("Error on replay from device {} ", deviceReply);
+                        }
+                        deviceReplyBuilder.setLength(0);
+                    }
+                }
+            } catch (IOException e) {
+                log.warn("Error in reading from the session for device " + netconfDeviceInfo, e);
+                throw new RuntimeException(new NetconfException("Error in reading from the session for device {}" +
+                                                                        netconfDeviceInfo, e));
+                //TODO should we send a socket closed message to listeners ?
+            }
+        };
+    }
+
+    private static int getMsgId(String reply) {
+        if (!reply.contains(HELLO)) {
+            String[] outer = reply.split("message-id=");
+            Preconditions.checkArgument(outer.length != 1,
+                                        "Error in retrieving the message id");
+            String messageID = outer[1].substring(0, 3).replace("\"", "");
+            Preconditions.checkNotNull(Integer.parseInt(messageID),
+                                       "Error in retrieving the message id");
+            return Integer.parseInt(messageID);
+        } else {
+            return 0;
+        }
+    }
+
+    public void addDeviceEventListener(NetconfDeviceOutputEventListener listener) {
+        if (!netconfDeviceEventListeners.contains(listener)) {
+            netconfDeviceEventListeners.add(listener);
+        }
+    }
+
+    public void removeDeviceEventListener(NetconfDeviceOutputEventListener listener) {
+        netconfDeviceEventListeners.remove(listener);
+    }
+}

@@ -65,7 +65,7 @@ public class NetconfDeviceProvider extends AbstractProvider
     protected DeviceProviderRegistry providerRegistry;
     protected DeviceProviderRegistry providerRegistry;
 
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected NetconfController controller; //where is initiated ?
+    protected NetconfController controller;
 
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected NetworkConfigRegistry cfgService;
     protected NetworkConfigRegistry cfgService;
@@ -73,11 +73,13 @@ public class NetconfDeviceProvider extends AbstractProvider
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected CoreService coreService;
     protected CoreService coreService;
 
 
+    private static final String APP_NAME = "org.onosproject.netconf";
+    private static final String SCHEME_NAME = "netconf";
+    private static final String DEVICE_PROVIDER_PACKAGE = "org.onosproject.netconf.provider.device";
+    private static final String UNKNOWN = "unknown";
 
 
     private DeviceProviderService providerService;
     private DeviceProviderService providerService;
     private NetconfDeviceListener innerNodeListener = new InnerNetconfDeviceListener();
     private NetconfDeviceListener innerNodeListener = new InnerNetconfDeviceListener();
-    protected static final String ISNOTNULL = "NetconfDeviceInfo is not null";
-    private static final String UNKNOWN = "unknown";
 
 
     private final ConfigFactory factory =
     private final ConfigFactory factory =
             new ConfigFactory<ApplicationId, NetconfProviderConfig>(APP_SUBJECT_FACTORY,
             new ConfigFactory<ApplicationId, NetconfProviderConfig>(APP_SUBJECT_FACTORY,
@@ -96,10 +98,10 @@ public class NetconfDeviceProvider extends AbstractProvider
     @Activate
     @Activate
     public void activate() {
     public void activate() {
         providerService = providerRegistry.register(this);
         providerService = providerRegistry.register(this);
+        appId = coreService.registerApplication(APP_NAME);
         cfgService.registerConfigFactory(factory);
         cfgService.registerConfigFactory(factory);
         cfgService.addListener(cfgLister);
         cfgService.addListener(cfgLister);
         controller.addDeviceListener(innerNodeListener);
         controller.addDeviceListener(innerNodeListener);
-        appId = coreService.registerApplication("org.onosproject.netconf");
         connectDevices();
         connectDevices();
         log.info("Started");
         log.info("Started");
     }
     }
@@ -110,11 +112,12 @@ public class NetconfDeviceProvider extends AbstractProvider
         providerRegistry.unregister(this);
         providerRegistry.unregister(this);
         providerService = null;
         providerService = null;
         cfgService.unregisterConfigFactory(factory);
         cfgService.unregisterConfigFactory(factory);
+        controller.removeDeviceListener(innerNodeListener);
         log.info("Stopped");
         log.info("Stopped");
     }
     }
 
 
     public NetconfDeviceProvider() {
     public NetconfDeviceProvider() {
-        super(new ProviderId("netconf", "org.onosproject.netconf.provider.device"));
+        super(new ProviderId(SCHEME_NAME, DEVICE_PROVIDER_PACKAGE));
     }
     }
 
 
     @Override
     @Override
@@ -142,15 +145,18 @@ public class NetconfDeviceProvider extends AbstractProvider
 
 
     private class InnerNetconfDeviceListener implements NetconfDeviceListener {
     private class InnerNetconfDeviceListener implements NetconfDeviceListener {
 
 
+        private static final String IPADDRESS = "ipaddress";
+        protected static final String ISNULL = "NetconfDeviceInfo is null";
+
         @Override
         @Override
         public void deviceAdded(NetconfDeviceInfo nodeId) {
         public void deviceAdded(NetconfDeviceInfo nodeId) {
-            Preconditions.checkNotNull(nodeId, ISNOTNULL);
+            Preconditions.checkNotNull(nodeId, ISNULL);
             DeviceId deviceId = nodeId.getDeviceId();
             DeviceId deviceId = nodeId.getDeviceId();
             //Netconf configuration object
             //Netconf configuration object
             ChassisId cid = new ChassisId();
             ChassisId cid = new ChassisId();
             String ipAddress = nodeId.ip().toString();
             String ipAddress = nodeId.ip().toString();
             SparseAnnotations annotations = DefaultAnnotations.builder()
             SparseAnnotations annotations = DefaultAnnotations.builder()
-                    .set("ipaddress", ipAddress).build();
+                    .set(IPADDRESS, ipAddress).build();
             DeviceDescription deviceDescription = new DefaultDeviceDescription(
             DeviceDescription deviceDescription = new DefaultDeviceDescription(
                     deviceId.uri(),
                     deviceId.uri(),
                     Device.Type.SWITCH,
                     Device.Type.SWITCH,
@@ -164,7 +170,7 @@ public class NetconfDeviceProvider extends AbstractProvider
 
 
         @Override
         @Override
         public void deviceRemoved(NetconfDeviceInfo nodeId) {
         public void deviceRemoved(NetconfDeviceInfo nodeId) {
-            Preconditions.checkNotNull(nodeId, ISNOTNULL);
+            Preconditions.checkNotNull(nodeId, ISNULL);
             DeviceId deviceId = nodeId.getDeviceId();
             DeviceId deviceId = nodeId.getDeviceId();
             providerService.deviceDisconnected(deviceId);
             providerService.deviceDisconnected(deviceId);
 
 
@@ -184,7 +190,7 @@ public class NetconfDeviceProvider extends AbstractProvider
                                                                        addr.ip(),
                                                                        addr.ip(),
                                                                        addr.port()));
                                                                        addr.port()));
                                      } catch (IOException e) {
                                      } catch (IOException e) {
-                                         log.warn("Can't connect to NETCONF " +
+                                         log.info("Can't connect to NETCONF " +
                                                           "device on {}:{}",
                                                           "device on {}:{}",
                                                   addr.ip(),
                                                   addr.ip(),
                                                   addr.port());
                                                   addr.port());