pcep/pcc-mock/src/main/java/org/opendaylight/protocol/pcep/pcc/mock/Main.java

   1 /*
   2  * Copyright (c) 2014 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
   9 package org.opendaylight.protocol.pcep.pcc.mock;
  10
  11 import ch.qos.logback.classic.Level;
  12 import ch.qos.logback.classic.LoggerContext;
  13 import com.google.common.base.Function;
  14 import com.google.common.base.Predicate;
  15 import com.google.common.collect.Iterables;
  16 import com.google.common.collect.Lists;
  17 import com.google.common.net.InetAddresses;
  18 import io.netty.util.concurrent.GlobalEventExecutor;
  19 import java.net.InetAddress;
  20 import java.net.InetSocketAddress;
  21 import java.net.UnknownHostException;
  22 import java.util.Arrays;
  23 import java.util.List;
  24 import java.util.concurrent.ExecutionException;
  25 import org.opendaylight.protocol.framework.NeverReconnectStrategy;
  26 import org.opendaylight.protocol.framework.SessionListenerFactory;
  27 import org.opendaylight.protocol.framework.SessionNegotiatorFactory;
  28 import org.opendaylight.protocol.pcep.PCEPSessionListener;
  29 import org.opendaylight.protocol.pcep.ietf.stateful07.StatefulActivator;
  30 import org.opendaylight.protocol.pcep.impl.DefaultPCEPSessionNegotiatorFactory;
  31 import org.opendaylight.protocol.pcep.impl.PCEPHandlerFactory;
  32 import org.opendaylight.protocol.pcep.impl.PCEPSessionImpl;
  33 import org.opendaylight.protocol.pcep.spi.pojo.ServiceLoaderPCEPExtensionProviderContext;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.OpenBuilder;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 public final class Main {
  40
  41     private static final Logger LOG = LoggerFactory.getLogger(Main.class);
  42
  43     private static final int DEFAULT_PORT = 4189;
  44     private static final short DEFAULT_KEEP_ALIVE = 30;
  45     private static final short DEFAULT_DEAD_TIMER = 120;
  46     private static final int RECONNECT_STRATEGY_TIMEOUT = 2000;
  47
  48     private Main() { }
  49
  50     public static void main(final String[] args) throws InterruptedException, ExecutionException, UnknownHostException {
  51         InetAddress localAddress = InetAddress.getByName("127.0.0.1");
  52         List<InetAddress> remoteAddress = Lists.newArrayList(InetAddress.getByName("127.0.0.1"));
  53         int pccCount = 1;
  54         int lsps = 1;
  55         boolean pcError = false;
  56         final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
  57         short ka = DEFAULT_KEEP_ALIVE;
  58         short dt = DEFAULT_DEAD_TIMER;
  59
  60         getRootLogger(lc).setLevel(ch.qos.logback.classic.Level.INFO);
  61         int argIdx = 0;
  62         while (argIdx < args.length) {
  63             if (args[argIdx].equals("--local-address")) {
  64                 localAddress = InetAddress.getByName(args[++argIdx]);
  65             } else if (args[argIdx].equals("--remote-address")) {
  66                 remoteAddress = parseAddresses(args[++argIdx]);
  67             } else if (args[argIdx].equals("--pcc")) {
  68                 pccCount = Integer.valueOf(args[++argIdx]);
  69             } else if (args[argIdx].equals("--lsp")) {
  70                 lsps = Integer.valueOf(args[++argIdx]);
  71             } else if (args[argIdx].equals("--pcerr")) {
  72                 pcError = true;
  73             } else if (args[argIdx].equals("--log-level")) {
  74                 getRootLogger(lc).setLevel(Level.toLevel(args[++argIdx], ch.qos.logback.classic.Level.INFO));
  75             } else if (args[argIdx].equals("--keepalive") || args[argIdx].equals("-ka")) {
  76                 ka = Short.valueOf(args[++argIdx]);
  77             } else if (args[argIdx].equals("--deadtimer") || args[argIdx].equals("-d")) {
  78                 dt = Short.valueOf(args[++argIdx]);
  79             } else {
  80                 LOG.warn("WARNING: Unrecognized argument: {}", args[argIdx]);
  81             }
  82             argIdx++;
  83         }
  84         createPCCs(lsps, pcError, pccCount, localAddress, remoteAddress, ka, dt);
  85     }
  86
  87     public static void createPCCs(final int lspsPerPcc, final boolean pcerr, final int pccCount,
  88             final InetAddress localAddress, final List<InetAddress> remoteAddress, final short keepalive, final short deadtimer) throws InterruptedException, ExecutionException {
  89         final SessionNegotiatorFactory<Message, PCEPSessionImpl, PCEPSessionListener> snf = new DefaultPCEPSessionNegotiatorFactory(
  90                 new OpenBuilder().setKeepalive(keepalive).setDeadTimer(deadtimer).setSessionId((short) 0).build(), 0);
  91
  92         final StatefulActivator activator07 = new StatefulActivator();
  93         activator07.start(ServiceLoaderPCEPExtensionProviderContext.getSingletonInstance());
  94         final PCCMock<Message, PCEPSessionImpl, PCEPSessionListener> pcc = new PCCMock<>(snf, new PCEPHandlerFactory(
  95                 ServiceLoaderPCEPExtensionProviderContext.getSingletonInstance().getMessageHandlerRegistry()));
  96
  97         for (final InetAddress pceAddress : remoteAddress) {
  98             InetAddress currentAddress = localAddress;
  99             int i = 0;
 100             while (i < pccCount) {
 101                 final InetAddress pccAddress = currentAddress;
 102                 pcc.createClient(new InetSocketAddress(pccAddress, 0), new InetSocketAddress(pceAddress, DEFAULT_PORT),
 103                         new NeverReconnectStrategy(GlobalEventExecutor.INSTANCE, RECONNECT_STRATEGY_TIMEOUT),
 104                         new SessionListenerFactory<PCEPSessionListener>() {
 105
 106                             @Override
 107                             public PCEPSessionListener getSessionListener() {
 108                                 return new SimpleSessionListener(lspsPerPcc, pcerr, pccAddress);
 109                             }
 110                         }).get();
 111                 i++;
 112                 currentAddress = InetAddresses.increment(currentAddress);
 113             }
 114         }
 115     }
 116
 117     private static ch.qos.logback.classic.Logger getRootLogger(final LoggerContext lc) {
 118         return Iterables.find(lc.getLoggerList(), new Predicate<Logger>() {
 119             @Override
 120             public boolean apply(final Logger input) {
 121                 return (input != null) ? input.getName().equals(Logger.ROOT_LOGGER_NAME) : false;
 122             }
 123         });
 124     }
 125
 126     private static List<InetAddress> parseAddresses(final String address) {
 127         return Lists.transform(Arrays.asList(address.split(",")), new Function<String, InetAddress>() {
 128             @Override
 129             public InetAddress apply(String input) {
 130                 try {
 131                     return InetAddress.getByName(input);
 132                 } catch (UnknownHostException e) {
 133                     throw new RuntimeException("Not an IP address: " + input, e);
 134                 }
 135             }
 136         });
 137     }
 138
 139 }