pcep/testtool/src/main/java/org/opendaylight/protocol/pcep/testtool/TestingSessionListener.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.protocol.pcep.testtool;
   9
  10 import groovy.lang.GroovyClassLoader;
  11
  12 import java.io.BufferedReader;
  13 import java.io.File;
  14 import java.io.IOException;
  15 import java.io.InputStream;
  16 import java.io.InputStreamReader;
  17 import java.util.ArrayList;
  18 import java.util.LinkedList;
  19 import java.util.List;
  20 import java.util.Queue;
  21 import java.util.Timer;
  22 import java.util.TimerTask;
  23
  24 import org.slf4j.Logger;
  25 import org.slf4j.LoggerFactory;
  26
  27 import org.opendaylight.protocol.framework.TerminationReason;
  28 import org.opendaylight.protocol.concepts.IPv4Address;
  29 import org.opendaylight.protocol.concepts.IPv4Prefix;
  30 import org.opendaylight.protocol.concepts.Prefix;
  31 import org.opendaylight.protocol.pcep.PCEPMessage;
  32 import org.opendaylight.protocol.pcep.PCEPSession;
  33 import org.opendaylight.protocol.pcep.PCEPSessionListener;
  34 import org.opendaylight.protocol.pcep.message.PCEPXRAddTunnelMessage;
  35 import org.opendaylight.protocol.pcep.object.PCEPCloseObject;
  36 import org.opendaylight.protocol.pcep.object.PCEPEndPointsObject;
  37 import org.opendaylight.protocol.pcep.object.PCEPExplicitRouteObject;
  38 import org.opendaylight.protocol.pcep.object.PCEPLspObject;
  39 import org.opendaylight.protocol.pcep.object.PCEPOpenObject;
  40 import org.opendaylight.protocol.pcep.subobject.EROIPPrefixSubobject;
  41 import org.opendaylight.protocol.pcep.subobject.ExplicitRouteSubobject;
  42
  43 public class TestingSessionListener extends PCEPSessionListener {
  44
  45         public List<PCEPMessage> messages = new ArrayList<PCEPMessage>();
  46
  47         private static final Logger logger = LoggerFactory.getLogger(TestingSessionListener.class);
  48
  49         public final Queue<PCEPMessage> replyMessages;
  50         public final Queue<PCEPMessage> sendNowMessages;
  51         public final Queue<PCEPMessage> periodicalMessages;
  52         public final int period;
  53
  54         private class MessageTimer extends TimerTask {
  55                 private final PCEPMessage message;
  56                 private final PCEPSession session;
  57
  58                 MessageTimer(final PCEPMessage message, final PCEPSession session) {
  59                         this.message = message;
  60                         this.session = session;
  61                 }
  62
  63                 @Override
  64                 public void run() {
  65                         this.session.sendMessage(this.message);
  66                 }
  67         }
  68
  69         public TestingSessionListener() {
  70                 /**
  71                  * default messages are set to null
  72                  */
  73                 this.period = 0;
  74                 this.replyMessages = new LinkedList<PCEPMessage>();
  75                 this.sendNowMessages = new LinkedList<PCEPMessage>();
  76                 this.periodicalMessages = new LinkedList<PCEPMessage>();
  77         }
  78
  79         public TestingSessionListener(final String autoResponseMessagesSrc, final String periodicallySendMessagesSrc, final int period,
  80                         final String sendNowMessageSrc) {
  81                 this.period = period;
  82                 this.replyMessages = this.loadMessageGeneratorFromFile(autoResponseMessagesSrc).generateMessages();
  83                 this.sendNowMessages = this.loadMessageGeneratorFromFile(sendNowMessageSrc).generateMessages();
  84                 this.periodicalMessages = this.loadMessageGeneratorFromFile(periodicallySendMessagesSrc).generateMessages();
  85         }
  86
  87         /**
  88          * Periodically send messages from loaded queue.
  89          *
  90          * @param session the session used to send message
  91          * @param period the time between two sent messages
  92          */
  93         public void sendPeriodically(final PCEPSession session, final int seconds) {
  94                 if (!this.periodicalMessages.isEmpty()) {
  95                         this.sendPeriodically(session, this.periodicalMessages.poll(), seconds);
  96                 } else
  97                         logger.debug("DON'T starting PERIODICAL sender. Messages queue is empty.");
  98         }
  99
 100         /**
 101          * Periodically send specified message.
 102          *
 103          * @param session the session used to send message
 104          * @param message the message to send
 105          * @param period the time between two sent messages
 106          */
 107         public void sendPeriodically(final PCEPSession session, final PCEPMessage message, final int seconds) {
 108                 final Timer timer = new Timer();
 109
 110                 logger.debug("Starting periodical sending of messages with {} seconds delay.", seconds);
 111                 timer.schedule(new MessageTimer(message, session), seconds * 1000);
 112         }
 113
 114         public void sendNow(final PCEPSession session) {
 115                 if (!this.sendNowMessages.isEmpty()) {
 116                         final PCEPMessage msg = this.sendNowMessages.poll();
 117                         this.sendNow(session, msg);
 118                 } else
 119                         logger.debug("DON'T sending NOW. Messages queue is empty.");
 120         }
 121
 122         public void sendNow(final PCEPSession session, final PCEPMessage message) {
 123                 logger.debug("Sending NOW.");
 124                 session.sendMessage(message);
 125         }
 126
 127         @Override
 128         public void onMessage(final PCEPSession session, final PCEPMessage message) {
 129                 logger.debug("Received message: " + message);
 130                 this.messages.add(message);
 131
 132                 // if (!this.replyMessages.isEmpty()) {
 133                 // this.logger.debug("Remaining messages in queue: {}", this.replyMessages.size());
 134                 // session.sendMessage(this.replyMessages.poll());
 135                 // } else
 136                 // this.logger.debug("Reply messages queue is empty.");
 137         }
 138
 139         @Override
 140         public void onSessionUp(final PCEPSession session, final PCEPOpenObject local, final PCEPOpenObject remote) {
 141                 logger.debug("Session up.");
 142                 final List<ExplicitRouteSubobject> subs = new ArrayList<ExplicitRouteSubobject>();
 143                 subs.add(new EROIPPrefixSubobject<Prefix<?>>(new IPv4Prefix(new IPv4Address(new byte[] { 10, 1, 1, 2 }), 32), false));
 144                 subs.add(new EROIPPrefixSubobject<Prefix<?>>(new IPv4Prefix(new IPv4Address(new byte[] { 2, 2, 2, 2 }), 32), false));
 145                 session.sendMessage(new PCEPXRAddTunnelMessage(new PCEPLspObject(23, false, false, false, false), new PCEPEndPointsObject<IPv4Address>(new IPv4Address(new byte[] {
 146                                 1, 1, 1, 1 }), new IPv4Address(new byte[] { 2, 2, 2, 2 })), new PCEPExplicitRouteObject(subs, false)));
 147                 this.sendNow(session);
 148                 this.sendPeriodically(session, this.period);
 149         }
 150
 151         @Override
 152         public void onSessionDown(final PCEPSession session, final PCEPCloseObject reason, final Exception e) {
 153                 logger.debug("Session down because: " + reason);
 154                 try {
 155                         session.close();
 156                 } catch (final IOException ex) {
 157                         logger.warn("Session could not be closed.", e);
 158                 }
 159         }
 160
 161         @Override
 162         public void onSessionTerminated(final PCEPSession session, final TerminationReason cause) {
 163                 logger.debug("Session terminated. Cause : " + cause.toString());
 164         }
 165
 166         private MessageGeneratorService loadMessageGeneratorFromFile(final String path) {
 167                 try {
 168                         final GroovyClassLoader l = new GroovyClassLoader();
 169                         final Class<?> scriptClass = l.parseClass(new File(path));
 170                         l.close();
 171                         logger.debug("Loaded '{}'", path);
 172                         final MessageGeneratorService generator = (MessageGeneratorService) scriptClass.newInstance();
 173                         logger.debug("Instantiated '{}'", path);
 174                         return generator;
 175                 } catch (final Exception e) {
 176                         logger.error("Failed to load '{}'. Using empty queue.", path);
 177                         return new MessageGeneratorService() {
 178
 179                                 @Override
 180                                 public Queue<PCEPMessage> generateMessages() {
 181                                         return new LinkedList<PCEPMessage>();
 182                                 }
 183                         };
 184                 }
 185
 186         }
 187
 188         @SuppressWarnings("unused")
 189         private MessageGeneratorService loadMessageGeneratorFormSysResource(final String path) {
 190                 try {
 191                         final InputStream is = this.getClass().getResourceAsStream(path);
 192                         final BufferedReader buffReader = new BufferedReader(new InputStreamReader(is));
 193                         final StringBuilder script = new StringBuilder();
 194                         String scriptLine;
 195                         while ((scriptLine = buffReader.readLine()) != null) {
 196                                 script.append(scriptLine + "\n");
 197                         }
 198                         final GroovyClassLoader l = new GroovyClassLoader();
 199                         final Class<?> scriptClass = l.parseClass(script.toString());
 200                         l.close();
 201                         logger.debug("Loaded '{}'", path);
 202                         final MessageGeneratorService generator = (MessageGeneratorService) scriptClass.newInstance();
 203                         logger.debug("Instantiated '{}'", path);
 204                         return generator;
 205
 206                 } catch (final Exception e) {
 207                         logger.error("Failed to load '{}' from system resources. Using empty queue.", path);
 208                         return new MessageGeneratorService() {
 209
 210                                 @Override
 211                                 public Queue<PCEPMessage> generateMessages() {
 212                                         return new LinkedList<PCEPMessage>();
 213                                 }
 214                         };
 215                 }
 216         }
 217 }