[Emu] [ONOS-2591,ONOS-2594] Implementation of BGP channel handler to manage each…

… BGP peer connection.

Change-Id: I14e90c9437f676698f89da79e736a81035689492

@@ -25,6 +25,21 @@ import org.onosproject.bgpio.protocol.BGPMessage;
 public interface BGPController {
 public interface BGPController {
 
 
     /**
     /**
+     * Returns list of bgp peers connected to this BGP controller.
+     *
+     * @return Iterable of BGPPeer elements
+     */
+    Iterable<BGPPeer> getPeers();
+
+    /**
+     * Returns the actual bgp peer for the given ip address.
+     *
+     * @param bgpId the id of the bgp peer to fetch
+     * @return the interface to this bgp peer
+     */
+    BGPPeer getPeer(BGPId bgpId);
+
+    /**
      * Send a message to a particular bgp peer.
      * Send a message to a particular bgp peer.
      *
      *
      * @param bgpId the id of the peer to send message.
      * @param bgpId the id of the peer to send message.
@@ -41,9 +56,22 @@ public interface BGPController {
     void processBGPPacket(BGPId bgpId, BGPMessage msg);
     void processBGPPacket(BGPId bgpId, BGPMessage msg);
 
 
     /**
     /**
+     * Close all connected BGP peers.
+     *
+     */
+    void closeConnectedPeers();
+
+    /**
      * Get the BGPConfig class to the caller.
      * Get the BGPConfig class to the caller.
      *
      *
      * @return configuration object
      * @return configuration object
      */
      */
     BGPCfg getConfig();
     BGPCfg getConfig();
+
+    /**
+     * Get the BGP connected peers to this controller.
+     *
+     * @return the integer number
+     */
+    int getBGPConnNumber();
 }
 }
\ No newline at end of file

+/*
+ * 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.bgp.controller;
+import java.util.List;
+import org.jboss.netty.channel.Channel;
+import org.onosproject.bgpio.protocol.BGPMessage;
+import org.onosproject.bgpio.protocol.BGPVersion;
+
+/**
+ * Represents the peer side of an bgp peer.
+ *
+ */
+public interface BGPPeer {
+
+    /**
+     * Sets the BGP version for this bgp peer.
+     *
+     * @param bgpVersion the version to set.
+     */
+    void setBgpPeerVersion(BGPVersion bgpVersion);
+
+    /**
+     * Gets the BGP version for this bgp peer.
+     *
+     * @return bgp identifier.
+     */
+    int getBgpPeerIdentifier();
+
+    /**
+     * Sets the associated Netty channel for this bgp peer.
+     *
+     * @param channel the Netty channel
+     */
+    void setChannel(Channel channel);
+
+    /**
+     * Gets the associated Netty channel handler for this bgp peer.
+     *
+     * @return Channel channel connected.
+     */
+    Channel getChannel();
+
+    /**
+     * Sets the AS Number for this bgp peer.
+     *
+     * @param peerASNum the autonomous system number value to set.
+     */
+    void setBgpPeerASNum(short peerASNum);
+
+    /**
+     * Sets the hold time for this bgp peer.
+     *
+     * @param peerHoldTime the hold timer value to set.
+     */
+    void setBgpPeerHoldTime(short peerHoldTime);
+
+    /**
+     * Sets the peer identifier value.
+     *
+     * @param peerIdentifier the bgp peer identifier value.
+     */
+    void setBgpPeerIdentifier(int peerIdentifier);
+
+    /**
+     * Sets whether the bgp peer is connected.
+     *
+     * @param connected whether the bgp peer is connected
+     */
+    void setConnected(boolean connected);
+
+    /**
+     * Initialises the behaviour.
+     *
+     * @param bgpId id of bgp peer
+     * @param bgpVersion BGP version
+     * @param pktStats packet statistics
+     */
+    void init(BGPId bgpId, BGPVersion bgpVersion, BGPPacketStats pktStats);
+
+    /**
+     * Checks whether the handshake is complete.
+     *
+     * @return true is finished, false if not.
+     */
+    boolean isHandshakeComplete();
+
+    /**
+     * Writes the message to the peer.
+     *
+     * @param msg the message to write
+     */
+    void sendMessage(BGPMessage msg);
+
+    /**
+     * Writes the BGPMessage list to the peer.
+     *
+     * @param msgs the messages to be written
+     */
+    void sendMessage(List<BGPMessage> msgs);
+
+    /**
+     * Gets a string version of the ID for this bgp peer.
+     *
+     * @return string version of the ID
+     */
+    String getStringId();
+
+    /**
+     * Gets the ipAddress of the peer.
+     *
+     * @return the peer bgpId in IPAddress format
+     */
+    BGPId getBGPId();
+
+    /**
+     * Checks if the bgp peer is still connected.
+     *
+     * @return whether the bgp peer is still connected
+     */
+    boolean isConnected();
+
+    /**
+     * Disconnects the bgp peer by closing the TCP connection. Results in a call to the channel handler's
+     * channelDisconnected method for cleanup
+     */
+    void disconnectPeer();
+
+    /**
+     * Identifies the channel used to communicate with the bgp peer.
+     *
+     * @return string representation of the connection to the peer
+     */
+    String channelId();
+
+    /**
+     * Gets the negotiated hold time.
+     *
+     * @return the negotiated hold time
+     */
+    int getNegotiatedHoldTime();
+
+    /**
+     * Sets negotiated hold time for the peer.
+     *
+     * @param negotiatedHoldTime negotiated hold time
+     */
+    void setNegotiatedHoldTime(short negotiatedHoldTime);
+}

@@ -61,27 +61,6 @@ public interface BGPMessage extends Writeable {
         BGPMessage build() throws BGPParseException;
         BGPMessage build() throws BGPParseException;
 
 
         /**
         /**
-         * Returns BGP Version of BGP Message.
-         *
-         * @return BGP Version of BGP Message
-         */
-        BGPVersion getVersion();
-
-        /**
-         * Returns BGP Type of BGP Message.
-         *
-         * @return BGP Type of BGP Message
-         */
-        BGPType getType();
-
-        /**
-         * Returns BGP Header of BGP Message.
-         *
-         * @return BGP Header of BGP Message
-         */
-        BGPHeader getHeader();
-
-        /**
          * Sets BgpHeader and return its builder.
          * Sets BgpHeader and return its builder.
          *
          *
          * @param bgpMsgHeader BGP Message Header
          * @param bgpMsgHeader BGP Message Header

@@ -16,19 +16,616 @@
 
 
 package org.onosproject.bgp.controller.impl;
 package org.onosproject.bgp.controller.impl;
 
 
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.channels.ClosedChannelException;
+import java.util.Date;
+import java.util.List;
+import java.util.concurrent.RejectedExecutionException;
+
+import org.jboss.netty.channel.Channel;
+import org.jboss.netty.channel.ChannelHandlerContext;
+import org.jboss.netty.channel.ChannelStateEvent;
+import org.jboss.netty.channel.ExceptionEvent;
+import org.jboss.netty.channel.MessageEvent;
 import org.jboss.netty.handler.timeout.IdleStateAwareChannelHandler;
 import org.jboss.netty.handler.timeout.IdleStateAwareChannelHandler;
+import org.jboss.netty.handler.timeout.ReadTimeoutException;
+import org.jboss.netty.handler.timeout.ReadTimeoutHandler;
+import org.onlab.packet.IpAddress;
+import org.onosproject.bgp.controller.BGPCfg;
+import org.onosproject.bgp.controller.BGPId;
+import org.onosproject.bgp.controller.BGPPeer;
+import org.onosproject.bgp.controller.BGPPeerCfg;
+import org.onosproject.bgp.controller.impl.BGPControllerImpl.BGPPeerManager;
+import org.onosproject.bgpio.exceptions.BGPParseException;
+import org.onosproject.bgpio.protocol.BGPMessage;
+//import org.onosproject.bgpio.protocol.BGPOpenMsg;
+import org.onosproject.bgpio.protocol.BGPType;
+import org.onosproject.bgpio.protocol.BGPVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 
 /**
 /**
  * Channel handler deals with the bgp peer connection and dispatches messages from peer to the appropriate locations.
  * Channel handler deals with the bgp peer connection and dispatches messages from peer to the appropriate locations.
  */
  */
 class BGPChannelHandler extends IdleStateAwareChannelHandler {
 class BGPChannelHandler extends IdleStateAwareChannelHandler {
 
 
-    // TODO: implement FSM and session handling mechanism
+    private static final Logger log = LoggerFactory.getLogger(BGPChannelHandler.class);
+
+    static final int BGP_MAX_KEEPALIVE_INTERVAL = 3;
+    private BGPPeer bgpPeer;
+    private BGPId thisbgpId;
+    Channel channel;
+    private BGPKeepAliveTimer keepAliveTimer = null;
+    private short peerHoldTime = 0;
+    private short negotiatedHoldTime = 0;
+    private short peerAsNum;
+    private int peerIdentifier;
+    private BGPPacketStatsImpl bgpPacketStats;
+    static final int MAX_WRONG_COUNT_PACKET = 5;
+
+    // State needs to be volatile because the HandshakeTimeoutHandler
+    // needs to check if the handshake is complete
+    private volatile ChannelState state;
+
+    // When a bgp peer with a ip addresss is found (i.e we already have a
+    // connected peer with the same ip), the new peer is immediately
+    // disconnected. At that point netty callsback channelDisconnected() which
+    // proceeds to cleaup peer state - we need to ensure that it does not cleanup
+    // peer state for the older (still connected) peer
+    private volatile Boolean duplicateBGPIdFound;
+    // Indicates the bgp version used by this bgp peer
+    protected BGPVersion bgpVersion;
+    private BGPControllerImpl bgpControllerImpl;
+    private BGPPeerManager peerManager;
+    private InetSocketAddress inetAddress;
+    private IpAddress ipAddress;
+    private SocketAddress address;
+    private String peerAddr;
+    private BGPCfg bgpconfig;
+
     /**
     /**
      * Create a new unconnected BGPChannelHandler.
      * Create a new unconnected BGPChannelHandler.
      *
      *
      * @param bgpCtrlImpl bgp controller implementation object
      * @param bgpCtrlImpl bgp controller implementation object
      */
      */
     BGPChannelHandler(BGPControllerImpl bgpCtrlImpl) {
     BGPChannelHandler(BGPControllerImpl bgpCtrlImpl) {
+        this.bgpControllerImpl = bgpCtrlImpl;
+        this.peerManager = bgpCtrlImpl.getPeerManager();
+        this.state = ChannelState.IDLE;
+        this.duplicateBGPIdFound = Boolean.FALSE;
+        this.bgpPacketStats = new BGPPacketStatsImpl();
+        this.bgpconfig = bgpCtrlImpl.getConfig();
+    }
+
+    // To disconnect peer session.
+    public void disconnectPeer() {
+        bgpPeer.disconnectPeer();
+    }
+
+    // *************************
+    // Channel State Machine
+    // *************************
+
+    /**
+     * The state machine for handling the peer/channel state. All state transitions should happen from within the state
+     * machine (and not from other parts of the code)
+     */
+    enum ChannelState {
+        /**
+         * Initial state before channel is connected.
+         */
+        IDLE(false) {
+
+        },
+
+        OPENSENT(false) {
+            @Override
+            void processBGPMessage(BGPChannelHandler h, BGPMessage m) throws IOException, BGPParseException {
+                log.debug("message received in OPENSENT state");
+                // check for OPEN message
+                if (m.getType() != BGPType.OPEN) {
+                    // When the message type is not keep alive message increment the wrong packet statistics
+                    h.processUnknownMsg();
+                    log.debug("Message is not OPEN message");
+                } else {
+                    log.debug("Sending keep alive message in OPENSENT state");
+                    h.bgpPacketStats.addInPacket();
+
+                    // TODO: initialize openmessage BGPOpenMsg pOpenmsg = (BGPOpenMsg) m;
+                    // TODO: initialize identifier from open messgae h.peerIdentifier = pOpenmsg.getBgpId();
+
+                    // validate capabilities and open msg
+                    if (h.openMsgValidation(h)) {
+                        log.debug("Sending handshake OPEN message");
+
+                        /*
+                         * RFC 4271, section 4.2: Upon receipt of an OPEN message, a BGP speaker MUST calculate the
+                         * value of the Hold Timer by using the smaller of its configured Hold Time and the Hold Time
+                         * received in the OPEN message
+                         */
+                        // TODO: initialize holdtime from open message h.peerHoldTime = pOpenmsg.getHoldTime();
+                        if (h.peerHoldTime < h.bgpconfig.getHoldTime()) {
+                            h.channel.getPipeline().replace("holdTime",
+                                                            "holdTime",
+                                                            new ReadTimeoutHandler(BGPPipelineFactory.TIMER,
+                                                                                   h.peerHoldTime));
+                        }
+
+                        log.info("Hold Time : " + h.peerHoldTime);
+
+                        // TODO: get AS number for open message update AS number
+                    }
+
+                    // Send keepalive message to peer.
+                    h.sendKeepAliveMessage();
+                    h.bgpPacketStats.addOutPacket();
+                    h.setState(OPENCONFIRM);
+                    h.bgpconfig.setPeerConnState(h.peerAddr, BGPPeerCfg.State.OPENCONFIRM);
+                }
+            }
+        },
+
+        OPENWAIT(false) {
+            @Override
+            void processBGPMessage(BGPChannelHandler h, BGPMessage m) throws IOException, BGPParseException {
+                log.debug("Message received in OPEN WAIT State");
+
+                // check for open message
+                if (m.getType() != BGPType.OPEN) {
+                    // When the message type is not open message increment the wrong packet statistics
+                    h.processUnknownMsg();
+                    log.debug("Message is not OPEN message");
+                } else {
+                    h.bgpPacketStats.addInPacket();
+
+                    // TODO: initialize open message BGPOpenMsg pOpenmsg = (BGPOpenMsg) m;
+
+                    // Validate open message
+                    if (h.openMsgValidation(h)) {
+                        log.debug("Sending handshake OPEN message");
+
+                        /*
+                         * RFC 4271, section 4.2: Upon receipt of an OPEN message, a BGP speaker MUST calculate the
+                         * value of the Hold Timer by using the smaller of its configured Hold Time and the Hold Time
+                         * received in the OPEN message
+                         */
+                        // TODO: get hold time from open message h.peerHoldTime = pOpenmsg.getHoldTime();
+                        if (h.peerHoldTime < h.bgpconfig.getHoldTime()) {
+                            h.channel.getPipeline().replace("holdTime",
+                                                            "holdTime",
+                                                            new ReadTimeoutHandler(BGPPipelineFactory.TIMER,
+                                                                                   h.peerHoldTime));
+                        }
+
+                        log.debug("Hold Time : " + h.peerHoldTime);
+
+                        //TODO: update AS number form open messsage update AS number
+
+                        h.sendHandshakeOpenMessage();
+                        h.bgpPacketStats.addOutPacket();
+                        h.setState(OPENCONFIRM);
+                    }
+                }
+            }
+        },
+
+        OPENCONFIRM(false) {
+            @Override
+            void processBGPMessage(BGPChannelHandler h, BGPMessage m) throws IOException, BGPParseException {
+                log.debug("Message received in OPENCONFIRM state");
+                // check for keep alive message
+                if (m.getType() != BGPType.KEEP_ALIVE) {
+                    // When the message type is not keep alive message handle the wrong packet
+                    h.processUnknownMsg();
+                    log.debug("Message is not KEEPALIVE message");
+                } else {
+
+                    // Set the peer connected status
+                    h.bgpPacketStats.addInPacket();
+                    log.debug("Sending keep alive message in OPENCONFIRM state");
+
+                    final InetSocketAddress inetAddress = (InetSocketAddress) h.address;
+                    h.thisbgpId = BGPId.bgpId(IpAddress.valueOf(inetAddress.getAddress()));
+
+                    h.bgpPeer = h.peerManager.getBGPPeerInstance(h.thisbgpId, h.bgpVersion, h.bgpPacketStats);
+                    // set the status fo bgp as connected
+                    h.bgpPeer.setConnected(true);
+                    h.bgpPeer.setChannel(h.channel);
+
+                    // set specific parameters to bgp peer
+                    h.bgpPeer.setBgpPeerVersion(h.bgpVersion);
+                    h.bgpPeer.setBgpPeerASNum(h.peerAsNum);
+                    h.bgpPeer.setBgpPeerHoldTime(h.peerHoldTime);
+                    h.bgpPeer.setBgpPeerIdentifier(h.peerIdentifier);
+
+                    h.negotiatedHoldTime = (h.peerHoldTime < h.bgpconfig.getHoldTime()) ? h.peerHoldTime : h.bgpconfig
+                            .getHoldTime();
+                    h.bgpPeer.setNegotiatedHoldTime(h.negotiatedHoldTime);
+                    /*
+                     * RFC 4271, When an OPEN message is received, sends a KEEPALIVE message, If the negotiated hold
+                     * time value is zero, then the HoldTimer and KeepaliveTimer are not started. A reasonable maximum
+                     * time between KEEPALIVE messages would be one third of the Hold Time interval.
+                     */
+                    h.sendKeepAliveMessage();
+
+                    if (h.negotiatedHoldTime != 0) {
+                        h.keepAliveTimer
+                            = new BGPKeepAliveTimer(h, (h.negotiatedHoldTime / BGP_MAX_KEEPALIVE_INTERVAL));
+                    }
+
+                    h.bgpPacketStats.addOutPacket();
+
+                    // set the state handshake completion.
+                    h.setHandshakeComplete(true);
+
+                    if (!h.peerManager.addConnectedPeer(h.thisbgpId, h.bgpPeer)) {
+                        /*
+                         * RFC 4271, Section 6.8, Based on the value of the BGP identifier, a convention is established
+                         * for detecting which BGP connection is to be preserved when a collision occurs. The convention
+                         * is to compare the BGP Identifiers of the peers involved in the collision and to retain only
+                         * the connection initiated by the BGP speaker with the higher-valued BGP Identifier..
+                         */
+                        // TODO: Connection collision handling.
+                        disconnectDuplicate(h);
+                    } else {
+                        h.setState(ESTABLISHED);
+                        h.bgpconfig.setPeerConnState(h.peerAddr, BGPPeerCfg.State.ESTABLISHED);
+                    }
+                }
+            }
+        },
+
+        ESTABLISHED(true) {
+            @Override
+            void processBGPMessage(BGPChannelHandler h, BGPMessage m) throws IOException, BGPParseException {
+                log.debug("Message received in established state " + m.getType());
+                // dispatch the message
+                h.dispatchMessage(m);
+            }
+        };
+
+        private boolean handshakeComplete;
+
+        ChannelState(boolean handshakeComplete) {
+            this.handshakeComplete = handshakeComplete;
+        }
+
+        /**
+         * Is this a state in which the handshake has completed?
+         *
+         * @return true if the handshake is complete
+         */
+        public boolean isHandshakeComplete() {
+            return this.handshakeComplete;
+        }
+
+        /**
+         * Disconnect duplicate peer connection.
+         *
+         * @param h channel handler
+         */
+        protected void disconnectDuplicate(BGPChannelHandler h) {
+            log.error("Duplicated BGP IP or incompleted cleanup - " + "" + "disconnecting channel {}",
+                      h.getPeerInfoString());
+            h.duplicateBGPIdFound = Boolean.TRUE;
+            h.channel.disconnect();
+        }
+
+        // set handshake completion status
+        public void setHandshakeComplete(boolean handshakeComplete) {
+            this.handshakeComplete = handshakeComplete;
+        }
+
+        void processBGPMessage(BGPChannelHandler bgpChannelHandler, BGPMessage pm)
+                throws IOException, BGPParseException {
+            // TODO Auto-generated method stub
+            log.debug("BGP message stub");
+        }
+
+    }
+
+    // *************************
+    // Channel handler methods
+    // *************************
+
+    @Override
+    public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
+
+        channel = e.getChannel();
+        log.info("BGP connected from {}", channel.getRemoteAddress());
+
+        address = channel.getRemoteAddress();
+        if (!(address instanceof InetSocketAddress)) {
+            throw new IOException("Invalid peer connection.");
+        }
+
+        // Connection should establish only if local ip and Autonomous system number is configured.
+        if (bgpconfig.getState() != BGPCfg.State.IP_AS_CONFIGURED) {
+            channel.close();
+            log.info("BGP local AS and router ID not configured");
+            return;
+        }
+
+        inetAddress = (InetSocketAddress) address;
+        ipAddress = IpAddress.valueOf(inetAddress.getAddress());
+        peerAddr = ipAddress.toString();
+
+        // if peer is not configured disconnect session
+        if (!bgpconfig.isPeerConfigured(peerAddr)) {
+            log.debug("Peer is not configured {}", peerAddr);
+            channel.close();
+            return;
+        }
+
+        // if connection is already established close channel
+        if (peerManager.isPeerConnected(peerAddr)) {
+            log.debug("Duplicate connection received, peer {}", peerAddr);
+            channel.close();
+            return;
+        }
+
+        if (null != channel.getPipeline().get("PassiveHandler")) {
+            log.info("BGP handle connection request from peer");
+            // Wait for open message from bgp peer
+            setState(ChannelState.OPENWAIT);
+        } else if (null != channel.getPipeline().get("ActiveHandler")) {
+            log.info("BGP handle connection response from peer");
+
+            sendHandshakeOpenMessage();
+            bgpPacketStats.addOutPacket();
+            setState(ChannelState.OPENSENT);
+            bgpconfig.setPeerConnState(peerAddr, BGPPeerCfg.State.OPENSENT);
+        }
+    }
+
+    @Override
+    public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
+
+        channel = e.getChannel();
+        log.info("BGP disconnected callback for bgp:{}. Cleaning up ...", getPeerInfoString());
+
+        address = channel.getRemoteAddress();
+        if (!(address instanceof InetSocketAddress)) {
+            throw new IOException("Invalid peer connection.");
+        }
+
+        inetAddress = (InetSocketAddress) address;
+        ipAddress = IpAddress.valueOf(inetAddress.getAddress());
+        peerAddr = ipAddress.toString();
+
+        if (thisbgpId != null) {
+            if (!duplicateBGPIdFound) {
+                // if the disconnected peer (on this ChannelHandler)
+                // was not one with a duplicate, it is safe to remove all
+                // state for it at the controller. Notice that if the disconnected
+                // peer was a duplicate-ip, calling the method below would clear
+                // all state for the original peer (with the same ip),
+                // which we obviously don't want.
+                log.debug("{}:removal called", getPeerInfoString());
+                if (bgpPeer != null) {
+                    peerManager.removeConnectedPeer(thisbgpId);
+                }
+            } else {
+                // A duplicate was disconnected on this ChannelHandler,
+                // this is the same peer reconnecting, but the original state was
+                // not cleaned up - XXX check liveness of original ChannelHandler
+                log.debug("{}:duplicate found", getPeerInfoString());
+                duplicateBGPIdFound = Boolean.FALSE;
+            }
+
+            if (null != keepAliveTimer) {
+                keepAliveTimer.getKeepAliveTimer().cancel();
+            }
+        } else {
+            log.warn("No bgp ip in channelHandler registered for " + "disconnected peer {}", getPeerInfoString());
+        }
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
+
+        log.info("[exceptionCaught]: " + e.toString());
+
+        if (e.getCause() instanceof ReadTimeoutException) {
+            if ((ChannelState.OPENWAIT == state) || (ChannelState.OPENSENT == state)) {
+
+                // When ReadTimeout timer is expired in OPENWAIT/OPENSENT state, it is considered
+                // TODO: Send notification
+                channel.close();
+                state = ChannelState.IDLE;
+                return;
+            } else if (ChannelState.OPENCONFIRM == state) {
+
+                // When ReadTimeout timer is expired in OPENCONFIRM state.
+                // TODO: Send Notification
+                channel.close();
+                state = ChannelState.IDLE;
+                return;
+            }
+        } else if (e.getCause() instanceof ClosedChannelException) {
+            log.debug("Channel for bgp {} already closed", getPeerInfoString());
+        } else if (e.getCause() instanceof IOException) {
+            log.error("Disconnecting peer {} due to IO Error: {}", getPeerInfoString(), e.getCause().getMessage());
+            if (log.isDebugEnabled()) {
+                // still print stack trace if debug is enabled
+                log.debug("StackTrace for previous Exception: ", e.getCause());
+            }
+            channel.close();
+        } else if (e.getCause() instanceof BGPParseException) {
+            // TODO: SEND NOTIFICATION
+            log.debug("BGP Parse Exception: ", e.getCause());
+        } else if (e.getCause() instanceof RejectedExecutionException) {
+            log.warn("Could not process message: queue full");
+        } else {
+            log.error("Error while processing message from peer " + getPeerInfoString() + "state " + this.state);
+            channel.close();
+        }
+    }
+
+    @Override
+    public String toString() {
+        return getPeerInfoString();
+    }
+
+    @Override
+    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
+        if (e.getMessage() instanceof List) {
+            @SuppressWarnings("Unchecked")
+            List<BGPMessage> msglist = (List<BGPMessage>) e.getMessage();
+            for (BGPMessage pm : msglist) {
+                // Do the actual packet processing
+                state.processBGPMessage(this, pm);
+            }
+        } else {
+            state.processBGPMessage(this, (BGPMessage) e.getMessage());
+        }
+    }
+
+    // *************************
+    // Channel utility methods
+    // *************************
+    /**
+     * Set handshake status.
+     *
+     * @param handshakeComplete handshake complete status
+     */
+    public void setHandshakeComplete(boolean handshakeComplete) {
+        this.state.setHandshakeComplete(handshakeComplete);
+    }
+
+    /**
+     * Is this a state in which the handshake has completed?
+     *
+     * @return true if the handshake is complete
+     */
+    public boolean isHandshakeComplete() {
+        return state.isHandshakeComplete();
+    }
+
+    /**
+     * To handle the BGP message.
+     *
+     * @param m BGP message
+     */
+    private void dispatchMessage(BGPMessage m) throws BGPParseException {
+        bgpPacketStats.addInPacket();
+        bgpControllerImpl.processBGPPacket(thisbgpId, m);
+    }
+
+    /**
+     * Return a string describing this peer based on the already available information (ip address and/or remote
+     * socket).
+     *
+     * @return display string
+     */
+    private String getPeerInfoString() {
+        if (bgpPeer != null) {
+            return bgpPeer.toString();
+        }
+        String channelString;
+        if (channel == null || channel.getRemoteAddress() == null) {
+            channelString = "?";
+        } else {
+            channelString = channel.getRemoteAddress().toString();
+        }
+        String bgpIpString;
+        // TODO: implement functionality to get bgp id string
+        bgpIpString = "?";
+        return String.format("[%s BGP-IP[%s]]", channelString, bgpIpString);
+    }
+
+    /**
+     * Update the channels state. Only called from the state machine. TODO: enforce restricted state transitions
+     *
+     * @param state
+     */
+    private void setState(ChannelState state) {
+        this.state = state;
+    }
+
+    /**
+     * get packet statistics.
+     *
+     * @return packet statistics
+     */
+    public BGPPacketStatsImpl getBgpPacketStats() {
+        return bgpPacketStats;
+    }
+
+    /**
+     * Send handshake open message to the peer.
+     *
+     * @throws IOException ,BGPParseException
+     */
+    private void sendHandshakeOpenMessage() throws IOException, BGPParseException {
+        // TODO: send open message.
+
+    }
+
+    /**
+     * Send keep alive message.
+     *
+     * @throws IOException when channel is disconnected
+     * @throws BGPParseException while building keep alive message
+     */
+    synchronized void sendKeepAliveMessage() throws IOException, BGPParseException {
+
+        // TODO: send keep alive message.
+    }
+
+    /**
+     * Send notification and close channel with peer.
+     */
+    private void sendErrNotificationAndCloseChannel() {
+        // TODO: send notification
+        channel.close();
+    }
+
+    /**
+     * Process unknown BGP message received.
+     *
+     * @throws BGPParseException when received invalid message
+     */
+    public void processUnknownMsg() throws BGPParseException {
+        log.debug("UNKNOWN message received");
+        Date now = null;
+        if (bgpPacketStats.wrongPacketCount() == 0) {
+            now = new Date();
+            bgpPacketStats.setTime(now.getTime());
+            bgpPacketStats.addWrongPacket();
+            sendErrNotificationAndCloseChannel();
+        }
+        if (bgpPacketStats.wrongPacketCount() > 1) {
+            Date lastest = new Date();
+            bgpPacketStats.addWrongPacket();
+            // converting to seconds
+            if (((lastest.getTime() - bgpPacketStats.getTime()) / 1000) > 60) {
+                now = lastest;
+                bgpPacketStats.setTime(now.getTime());
+                bgpPacketStats.resetWrongPacket();
+                bgpPacketStats.addWrongPacket();
+            } else if (((int) (lastest.getTime() - now.getTime()) / 1000) < 60) {
+                if (MAX_WRONG_COUNT_PACKET <= bgpPacketStats.wrongPacketCount()) {
+                    // reset once wrong packet count reaches MAX_WRONG_COUNT_PACKET
+                    bgpPacketStats.resetWrongPacket();
+                    // max wrong packets received send error message and close the session
+                    sendErrNotificationAndCloseChannel();
+                }
+            }
+        }
+    }
+
+    /**
+     * Open message validation.
+     *
+     * @param h channel handler
+     * @return true if validation succeed, otherwise false
+     * @throws BGPParseException when received invalid message
+     */
+    public boolean openMsgValidation(BGPChannelHandler h) throws BGPParseException {
+        // TODO: Open message validation.
+        return true;
     }
     }
-}
\ No newline at end of file
+}

@@ -17,16 +17,24 @@
 package org.onosproject.bgp.controller.impl;
 package org.onosproject.bgp.controller.impl;
 
 
 import static org.onlab.util.Tools.groupedThreads;
 import static org.onlab.util.Tools.groupedThreads;
+
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Executors;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 import org.apache.felix.scr.annotations.Activate;
 import org.apache.felix.scr.annotations.Activate;
 import org.apache.felix.scr.annotations.Component;
 import org.apache.felix.scr.annotations.Component;
 import org.apache.felix.scr.annotations.Deactivate;
 import org.apache.felix.scr.annotations.Deactivate;
 import org.apache.felix.scr.annotations.Service;
 import org.apache.felix.scr.annotations.Service;
+import org.onlab.packet.IpAddress;
 import org.onosproject.bgp.controller.BGPCfg;
 import org.onosproject.bgp.controller.BGPCfg;
 import org.onosproject.bgp.controller.BGPController;
 import org.onosproject.bgp.controller.BGPController;
 import org.onosproject.bgp.controller.BGPId;
 import org.onosproject.bgp.controller.BGPId;
+import org.onosproject.bgp.controller.BGPPacketStats;
+import org.onosproject.bgp.controller.BGPPeer;
 import org.onosproject.bgpio.protocol.BGPMessage;
 import org.onosproject.bgpio.protocol.BGPMessage;
+import org.onosproject.bgpio.protocol.BGPVersion;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
@@ -42,8 +50,10 @@ public class BGPControllerImpl implements BGPController {
 
 
     private final ExecutorService executorBarrier = Executors.newFixedThreadPool(4,
     private final ExecutorService executorBarrier = Executors.newFixedThreadPool(4,
                                                                                  groupedThreads("onos/bgp",
                                                                                  groupedThreads("onos/bgp",
-                                                                                         "event-barrier-%d"));
+                                                                                                "event-barrier-%d"));
+    protected ConcurrentHashMap<BGPId, BGPPeer> connectedPeers = new ConcurrentHashMap<BGPId, BGPPeer>();
 
 
+    protected BGPPeerManager peerManager = new BGPPeerManager();
     final Controller ctrl = new Controller(this);
     final Controller ctrl = new Controller(this);
 
 
     private BGPConfig bgpconfig = new BGPConfig();
     private BGPConfig bgpconfig = new BGPConfig();
@@ -57,11 +67,22 @@ public class BGPControllerImpl implements BGPController {
     @Deactivate
     @Deactivate
     public void deactivate() {
     public void deactivate() {
         // Close all connected peers
         // Close all connected peers
+        closeConnectedPeers();
         this.ctrl.stop();
         this.ctrl.stop();
         log.info("Stopped");
         log.info("Stopped");
     }
     }
 
 
     @Override
     @Override
+    public Iterable<BGPPeer> getPeers() {
+        return this.connectedPeers.values();
+    }
+
+    @Override
+    public BGPPeer getPeer(BGPId bgpId) {
+        return this.connectedPeers.get(bgpId);
+    }
+
+    @Override
     public void writeMsg(BGPId bgpId, BGPMessage msg) {
     public void writeMsg(BGPId bgpId, BGPMessage msg) {
         // TODO: Send message
         // TODO: Send message
     }
     }
@@ -88,17 +109,167 @@ public class BGPControllerImpl implements BGPController {
         }
         }
     }
     }
 
 
+    @Override
+    public void closeConnectedPeers() {
+        BGPPeer bgpPeer;
+        for (BGPId id : this.connectedPeers.keySet()) {
+            bgpPeer = getPeer(id);
+            bgpPeer.disconnectPeer();
+        }
+    }
+
     /**
     /**
-     * Get controller instance.
-     *
-     * @return ctrl the controller.
+     * Implementation of an BGP Peer which is responsible for keeping track of connected peers and the state in which
+     * they are.
      */
      */
+    public class BGPPeerManager {
+
+        private final Logger log = LoggerFactory.getLogger(BGPPeerManager.class);
+        private final Lock peerLock = new ReentrantLock();
+
+        /**
+         * Add a BGP peer that has just connected to the system.
+         *
+         * @param bgpId the id of bgp peer to add
+         * @param bgpPeer the actual bgp peer object.
+         * @return true if added, false otherwise.
+         */
+        public boolean addConnectedPeer(BGPId bgpId, BGPPeer bgpPeer) {
+
+            if (connectedPeers.get(bgpId) != null) {
+                this.log.error("Trying to add connectedPeer but found previous " + "value for bgp ip: {}",
+                               bgpId.toString());
+                return false;
+            } else {
+                this.log.debug("Added Peer {}", bgpId.toString());
+                connectedPeers.put(bgpId, bgpPeer);
+                return true;
+            }
+        }
+
+        /**
+         * Checks if the activation for this bgp peer is valid.
+         *
+         * @param bgpId the id of bgp peer to check
+         * @return true if valid, false otherwise
+         */
+        public boolean isPeerConnected(BGPId bgpId) {
+            if (connectedPeers.get(bgpId) == null) {
+                this.log.error("Trying to activate peer but is not in " + "connected peer: bgpIp {}. Aborting ..",
+                               bgpId.toString());
+                return false;
+            }
+
+            return true;
+        }
+
+        /**
+         * Checks if the activation for this bgp peer is valid.
+         *
+         * @param routerid the routerid of bgp peer to check
+         * @return true if valid, false otherwise
+         */
+        public boolean isPeerConnected(String routerid) {
+
+            final BGPId bgpId;
+            bgpId = BGPId.bgpId(IpAddress.valueOf(routerid));
+
+            if (connectedPeers.get(bgpId) != null) {
+                this.log.info("Peer connection exist ");
+                return true;
+            }
+            this.log.info("Initiate connect request to " + "peer: bgpIp {}", bgpId.toString());
+
+            return false;
+        }
+
+        /**
+         * Clear all state in controller peer maps for a bgp peer that has
+         * disconnected from the local controller.
+         *
+         * @param bgpId the id of bgp peer to remove.
+         */
+        public void removeConnectedPeer(BGPId bgpId) {
+            connectedPeers.remove(bgpId);
+        }
+
+        /**
+         * Clear all state in controller peer maps for a bgp peer that has
+         * disconnected from the local controller.
+         *
+         * @param routerid the router id of bgp peer to remove.
+         */
+        public void removeConnectedPeer(String routerid) {
+            final BGPId bgpId;
+
+            bgpId = BGPId.bgpId(IpAddress.valueOf(routerid));
+
+            connectedPeers.remove(bgpId);
+        }
+
+        /**
+          * Gets bgp peer for connected peer map.
+          *
+          * @param routerid router id
+          * @return peer if available, null otherwise
+          */
+        public BGPPeer getPeer(String routerid) {
+            final BGPId bgpId;
+            bgpId = BGPId.bgpId(IpAddress.valueOf(routerid));
+
+            return connectedPeers.get(bgpId);
+        }
+
+        /**
+          * Gets bgp peer instance.
+          *
+          * @param bgpId bgp identifier.
+          * @param pv bgp version.
+          * @param pktStats packet statistics.
+          * @return BGPPeer peer instance.
+          */
+        public BGPPeer getBGPPeerInstance(BGPId bgpId, BGPVersion pv, BGPPacketStats pktStats) {
+            BGPPeer bgpPeer = new BGPPeerImpl();
+            bgpPeer.init(bgpId, pv, pktStats);
+            return bgpPeer;
+        }
+
+    }
+
+    /**
+      * Gets controller instance.
+      *
+      * @return Controller instance.
+      */
     public Controller getController() {
     public Controller getController() {
         return ctrl;
         return ctrl;
     }
     }
 
 
+    /**
+      * Gets connected peers.
+      *
+      * @return connectedPeers from connected Peers Map.
+      */
+    public ConcurrentHashMap<BGPId, BGPPeer> getConnectedPeers() {
+        return connectedPeers;
+    }
+
+    /**
+      * Gets peer manager.
+      *
+      * @return peerManager.
+      */
+    public BGPPeerManager getPeerManager() {
+        return peerManager;
+    }
+
     @Override
     @Override
     public BGPCfg getConfig() {
     public BGPCfg getConfig() {
         return this.bgpconfig;
         return this.bgpconfig;
     }
     }
+
+    @Override
+    public int getBGPConnNumber() {
+        return connectedPeers.size();
+    }
 }
 }
\ No newline at end of file

+/*
+ * 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.bgp.controller.impl;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Implement sending keepalive message to connected peer periodically based on negotiated holdtime.
+ */
+public class BGPKeepAliveTimer {
+
+    private Timer keepAliveTimer;
+    private BGPChannelHandler handler;
+    private static final Logger log = LoggerFactory.getLogger(BGPKeepAliveTimer.class);
+
+    /**
+     * Gets keepalive timer object.
+     *
+     * @return keepAliveTimer keepalive timer.
+     */
+    public Timer getKeepAliveTimer() {
+        return keepAliveTimer;
+    }
+
+    /**
+     * Initialize timer to send keepalive message periodically.
+     *
+     * @param h channel handler
+     * @param seconds time interval.
+     */
+    public BGPKeepAliveTimer(BGPChannelHandler h, int seconds) {
+        this.handler = h;
+        this.keepAliveTimer = new Timer();
+        this.keepAliveTimer.schedule(new SendKeepAlive(), 0, seconds * 1000);
+    }
+
+    /**
+     * Send keepalive message to connected peer on schedule.
+     */
+    class SendKeepAlive extends TimerTask {
+        @Override
+        public void run() {
+            log.debug("Sending periodic KeepAlive");
+
+            try {
+                // Send keep alive message
+                handler.sendKeepAliveMessage();
+                handler.getBgpPacketStats().addOutPacket();
+            } catch (Exception e) {
+                log.info("Exception occured while sending keepAlive message" + e.toString());
+            }
+        }
+    }
+}

@@ -43,8 +43,7 @@ public class BGPPacketStatsImpl implements BGPPacketStats {
     /**
     /**
      * Get the outgoing packet count number.
      * Get the outgoing packet count number.
      *
      *
-     * @return
-     *          packet count
+     * @return packet count
      */
      */
     public int outPacketCount() {
     public int outPacketCount() {
         return outPacketCount;
         return outPacketCount;
@@ -53,8 +52,7 @@ public class BGPPacketStatsImpl implements BGPPacketStats {
     /**
     /**
      * Get the incoming packet count number.
      * Get the incoming packet count number.
      *
      *
-     * @return
-     *          packet count
+     * @return packet count
      */
      */
     public int inPacketCount() {
     public int inPacketCount() {
         return inPacketCount;
         return inPacketCount;
@@ -63,8 +61,7 @@ public class BGPPacketStatsImpl implements BGPPacketStats {
     /**
     /**
      * Get the wrong packet count number.
      * Get the wrong packet count number.
      *
      *
-     * @return
-     *          packet count
+     * @return packet count
      */
      */
     public int wrongPacketCount() {
     public int wrongPacketCount() {
         return wrongPacketCount;
         return wrongPacketCount;
@@ -110,8 +107,7 @@ public class BGPPacketStatsImpl implements BGPPacketStats {
     /**
     /**
      * Get the time.
      * Get the time.
      *
      *
-     * @return
-     *          time
+     * @return time
      */
      */
     public long getTime() {
     public long getTime() {
         return this.time;
         return this.time;

+/*
+ * 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.bgp.controller.impl;
+
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.RejectedExecutionException;
+
+import org.jboss.netty.channel.Channel;
+import org.onlab.packet.IpAddress;
+import org.onosproject.bgp.controller.BGPId;
+import org.onosproject.bgp.controller.BGPPacketStats;
+import org.onosproject.bgp.controller.BGPPeer;
+import org.onosproject.bgpio.protocol.BGPMessage;
+import org.onosproject.bgpio.protocol.BGPVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * BGPPeerImpl implements BGPPeer, maintains peer information and store updates in RIB .
+ */
+public class BGPPeerImpl implements BGPPeer {
+
+    protected final Logger log = LoggerFactory.getLogger(BGPPeerImpl.class);
+
+    private static final String SHUTDOWN_MSG = "Worker has already been shutdown";
+
+    private Channel channel;
+    protected String channelId;
+    private boolean connected;
+    protected boolean isHandShakeComplete = false;
+    public BGPSessionInfo sessionInfo;
+    private BGPPacketStatsImpl pktStats;
+
+    @Override
+    public void init(BGPId bgpId, BGPVersion bgpVersion, BGPPacketStats pktStats) {
+        this.sessionInfo.setRemoteBgpId(bgpId);
+        this.sessionInfo.setRemoteBgpVersion(bgpVersion);
+        this.pktStats = (BGPPacketStatsImpl) pktStats;
+        this.sessionInfo = new BGPSessionInfo();
+    }
+
+    // ************************
+    // Channel related
+    // ************************
+
+    @Override
+    public final void disconnectPeer() {
+        this.channel.close();
+    }
+
+    @Override
+    public final void sendMessage(BGPMessage m) {
+        log.debug("Sending message to {}", channel.getRemoteAddress());
+        try {
+            channel.write(Collections.singletonList(m));
+            this.pktStats.addOutPacket();
+        } catch (RejectedExecutionException e) {
+            log.warn(e.getMessage());
+            if (!e.getMessage().contains(SHUTDOWN_MSG)) {
+                throw e;
+            }
+        }
+    }
+
+    @Override
+    public final void sendMessage(List<BGPMessage> msgs) {
+        try {
+            channel.write(msgs);
+            this.pktStats.addOutPacket(msgs.size());
+        } catch (RejectedExecutionException e) {
+            log.warn(e.getMessage());
+            if (!e.getMessage().contains(SHUTDOWN_MSG)) {
+                throw e;
+            }
+        }
+    }
+
+    @Override
+    public final boolean isConnected() {
+        return this.connected;
+    }
+
+    @Override
+    public final void setConnected(boolean connected) {
+        this.connected = connected;
+    };
+
+    @Override
+    public final void setChannel(Channel channel) {
+        this.channel = channel;
+        final SocketAddress address = channel.getRemoteAddress();
+        if (address instanceof InetSocketAddress) {
+            final InetSocketAddress inetAddress = (InetSocketAddress) address;
+            final IpAddress ipAddress = IpAddress.valueOf(inetAddress.getAddress());
+            if (ipAddress.isIp4()) {
+                channelId = ipAddress.toString() + ':' + inetAddress.getPort();
+            } else {
+                channelId = '[' + ipAddress.toString() + "]:" + inetAddress.getPort();
+            }
+        }
+    };
+
+    @Override
+    public final Channel getChannel() {
+        return this.channel;
+    };
+
+    @Override
+    public String channelId() {
+        return channelId;
+    }
+
+    // ************************
+    // BGP Peer features related
+    // ************************
+
+    @Override
+    public final BGPId getBGPId() {
+        return this.sessionInfo.getRemoteBgpId();
+    };
+
+    @Override
+    public final String getStringId() {
+        return this.sessionInfo.getRemoteBgpId().toString();
+    }
+
+    @Override
+    public final void setBgpPeerVersion(BGPVersion peerVersion) {
+        this.sessionInfo.setRemoteBgpVersion(peerVersion);
+    }
+
+    @Override
+    public void setBgpPeerASNum(short peerASNum) {
+        this.sessionInfo.setRemoteBgpASNum(peerASNum);
+    }
+
+    @Override
+    public void setBgpPeerHoldTime(short peerHoldTime) {
+        this.sessionInfo.setRemoteBgpHoldTime(peerHoldTime);
+    }
+
+    @Override
+    public void setBgpPeerIdentifier(int peerIdentifier) {
+        this.sessionInfo.setRemoteBgpIdentifier(peerIdentifier);
+    }
+
+    @Override
+    public int getBgpPeerIdentifier() {
+        return this.sessionInfo.getRemoteBgpIdentifier();
+    }
+
+    @Override
+    public int getNegotiatedHoldTime() {
+        return this.sessionInfo.getNegotiatedholdTime();
+    }
+
+    @Override
+    public void setNegotiatedHoldTime(short negotiatedHoldTime) {
+        this.sessionInfo.setNegotiatedholdTime(negotiatedHoldTime);
+    }
+
+    @Override
+    public boolean isHandshakeComplete() {
+        return isHandShakeComplete;
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass()).omitNullValues().add("channel", channelId())
+                .add("bgpId", getBGPId()).toString();
+    }
+}

+/*
+ * 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.bgp.controller.impl;
+
+import org.onosproject.bgp.controller.BGPId;
+import org.onosproject.bgpio.protocol.BGPVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Class maintains BGP peer session info.
+ */
+public class BGPSessionInfo {
+
+    protected final Logger log = LoggerFactory.getLogger(BGPSessionInfo.class);
+    private BGPId remoteBgpId;
+    private BGPVersion remoteBgpVersion;
+    private short remoteBgpASNum;
+    private short remoteBgpholdTime;
+    private int remoteBgpIdentifier;
+    private short negotiatedholdTime;
+
+    /**
+     * Gets the negotiated hold time for the session.
+     *
+     * @return negotiated hold time.
+     */
+    public short getNegotiatedholdTime() {
+        return negotiatedholdTime;
+    }
+
+    /**
+     * Sets the negotiated hold time for the session.
+     *
+     * @param negotiatedholdTime negotiated hold time.
+     */
+    public void setNegotiatedholdTime(short negotiatedholdTime) {
+        this.negotiatedholdTime = negotiatedholdTime;
+    }
+
+    /**
+     * Gets the BGP ID of BGP peer.
+     *
+     * @return bgp ID.
+     */
+    public BGPId getRemoteBgpId() {
+        return remoteBgpId;
+    }
+
+    /**
+     * Sets the BGP ID of bgp peer.
+     *
+     * @param bgpId BGP ID to set.
+     */
+    public void setRemoteBgpId(BGPId bgpId) {
+        log.debug("Remote BGP ID {}", bgpId);
+        this.remoteBgpId = bgpId;
+    }
+
+    /**
+     * Gets the BGP version of peer.
+     *
+     * @return bgp version.
+     */
+    public BGPVersion getRemoteBgpVersion() {
+        return remoteBgpVersion;
+    }
+
+    /**
+     * Sets the BGP version for this bgp peer.
+     *
+     * @param bgpVersion bgp version to set.
+     */
+    public void setRemoteBgpVersion(BGPVersion bgpVersion) {
+        log.debug("Remote BGP version {}", bgpVersion);
+        this.remoteBgpVersion = bgpVersion;
+    }
+
+    /**
+     * Gets the BGP remote bgp AS number.
+     *
+     * @return remoteBgpASNum peer AS number.
+     */
+    public short getRemoteBgpASNum() {
+        return remoteBgpASNum;
+    }
+
+    /**
+     * Sets the AS Number for this bgp peer.
+     *
+     * @param bgpASNum the autonomous system number value to set.
+     */
+    public void setRemoteBgpASNum(short bgpASNum) {
+        log.debug("Remote BGP AS number {}", bgpASNum);
+        this.remoteBgpASNum = bgpASNum;
+    }
+
+    /**
+     * Gets the BGP peer hold time.
+     *
+     * @return bgp hold time.
+     */
+    public short getRemoteBgpHoldTime() {
+        return remoteBgpholdTime;
+    }
+
+    /**
+     * Sets the hold time for this bgp peer.
+     *
+     * @param holdTime the hold timer value to set.
+     */
+    public void setRemoteBgpHoldTime(short holdTime) {
+        log.debug("Remote BGP HoldTime {}", holdTime);
+        this.remoteBgpholdTime = holdTime;
+    }
+
+    /**
+     * Gets the BGP version for this bgp peer.
+     *
+     * @return bgp identifier.
+     */
+    public int getRemoteBgpIdentifier() {
+        return remoteBgpIdentifier;
+    }
+
+    /**
+     * Sets the peer identifier value.
+     *
+     * @param bgpIdentifier the bgp peer identifier value.
+     */
+    public void setRemoteBgpIdentifier(int bgpIdentifier) {
+        log.debug("Remote BGP Identifier {}", bgpIdentifier);
+        this.remoteBgpIdentifier = bgpIdentifier;
+    }
+}