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.Charsets;
  14 import com.google.common.base.Function;
  15 import com.google.common.base.Predicate;
  16 import com.google.common.collect.Iterables;
  17 import com.google.common.collect.Lists;
  18 import com.google.common.net.HostAndPort;
  19 import com.google.common.net.InetAddresses;
  20 import io.netty.util.HashedWheelTimer;
  21 import io.netty.util.Timer;
  22 import io.netty.util.concurrent.GlobalEventExecutor;
  23 import java.net.InetAddress;
  24 import java.net.InetSocketAddress;
  25 import java.net.UnknownHostException;
  26 import java.util.Arrays;
  27 import java.util.List;
  28 import java.util.concurrent.ExecutionException;
  29 import org.opendaylight.protocol.framework.NeverReconnectStrategy;
  30 import org.opendaylight.protocol.framework.ReconnectStrategy;
  31 import org.opendaylight.protocol.framework.ReconnectStrategyFactory;
  32 import org.opendaylight.protocol.framework.SessionListenerFactory;
  33 import org.opendaylight.protocol.framework.SessionNegotiatorFactory;
  34 import org.opendaylight.protocol.framework.TimedReconnectStrategy;
  35 import org.opendaylight.protocol.pcep.PCEPSessionListener;
  36 import org.opendaylight.protocol.pcep.ietf.initiated00.CrabbeInitiatedActivator;
  37 import org.opendaylight.protocol.pcep.ietf.stateful07.StatefulActivator;
  38 import org.opendaylight.protocol.pcep.impl.DefaultPCEPSessionNegotiatorFactory;
  39 import org.opendaylight.protocol.pcep.impl.PCEPSessionImpl;
  40 import org.opendaylight.protocol.pcep.pcc.mock.api.PccTunnelManager;
  41 import org.opendaylight.protocol.pcep.spi.PCEPExtensionProviderContext;
  42 import org.opendaylight.protocol.pcep.spi.pojo.ServiceLoaderPCEPExtensionProviderContext;
  43 import org.opendaylight.tcpmd5.api.KeyMapping;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated.rev131126.Stateful1;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated.rev131126.Stateful1Builder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.Tlvs1;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.Tlvs1Builder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.stateful.capability.tlv.StatefulBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.Open;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.OpenBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.open.TlvsBuilder;
  53 import org.slf4j.Logger;
  54 import org.slf4j.LoggerFactory;
  55
  56 public final class Main {
  57
  58     private static final Logger LOG = LoggerFactory.getLogger(Main.class);
  59
  60     private static final int DEFAULT_REMOTE_PORT = 4189;
  61     private static final int DEFAULT_LOCAL_PORT = 0;
  62     private static final short DEFAULT_KEEP_ALIVE = 30;
  63     private static final short DEFAULT_DEAD_TIMER = 120;
  64     private static final int RECONNECT_STRATEGY_TIMEOUT = 2000;
  65     private static final InetAddress LOCALHOST = InetAddresses.forString("127.0.0.1");
  66
  67     private Main() { }
  68
  69     public static void main(final String[] args) throws InterruptedException, ExecutionException, UnknownHostException {
  70         InetSocketAddress localAddress = new InetSocketAddress(LOCALHOST, DEFAULT_LOCAL_PORT);
  71         List<InetSocketAddress> remoteAddress = Lists.newArrayList(new InetSocketAddress(LOCALHOST, DEFAULT_REMOTE_PORT));
  72         int pccCount = 1;
  73         int lsps = 1;
  74         boolean pcError = false;
  75         final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
  76         short ka = DEFAULT_KEEP_ALIVE;
  77         short dt = DEFAULT_DEAD_TIMER;
  78         String password = null;
  79         int reconnectTime = -1;
  80         int redelegationTimeout = 0;
  81         int stateTimeout = -1;
  82         final Timer timer = new HashedWheelTimer();
  83
  84         getRootLogger(lc).setLevel(ch.qos.logback.classic.Level.INFO);
  85         int argIdx = 0;
  86         while (argIdx < args.length) {
  87             if (args[argIdx].equals("--local-address")) {
  88                 localAddress = getInetSocketAddress(args[++argIdx], DEFAULT_LOCAL_PORT);
  89             } else if (args[argIdx].equals("--remote-address")) {
  90                 remoteAddress = parseAddresses(args[++argIdx], DEFAULT_REMOTE_PORT);
  91             } else if (args[argIdx].equals("--pcc")) {
  92                 pccCount = Integer.valueOf(args[++argIdx]);
  93             } else if (args[argIdx].equals("--lsp")) {
  94                 lsps = Integer.valueOf(args[++argIdx]);
  95             } else if (args[argIdx].equals("--pcerr")) {
  96                 pcError = true;
  97             } else if (args[argIdx].equals("--log-level")) {
  98                 getRootLogger(lc).setLevel(Level.toLevel(args[++argIdx], ch.qos.logback.classic.Level.INFO));
  99             } else if (args[argIdx].equals("--keepalive") || args[argIdx].equals("-ka")) {
 100                 ka = Short.valueOf(args[++argIdx]);
 101             } else if (args[argIdx].equals("--deadtimer") || args[argIdx].equals("-d")) {
 102                 dt = Short.valueOf(args[++argIdx]);
 103             } else if (args[argIdx].equals("--password")) {
 104                 password = args[++argIdx];
 105             } else if (args[argIdx].equals("--reconnect")) {
 106                 reconnectTime = Integer.valueOf(args[++argIdx]).intValue() * 1000;
 107             } else if (args[argIdx].equals("--redelegation-timeout")) {
 108                 redelegationTimeout = Integer.valueOf(args[++argIdx]);
 109             } else if (args[argIdx].equals("--state-timeout")) {
 110                 stateTimeout = Integer.valueOf(args[++argIdx]);
 111             } else {
 112                 LOG.warn("WARNING: Unrecognized argument: {}", args[argIdx]);
 113             }
 114             argIdx++;
 115         }
 116         createPCCs(lsps, pcError, pccCount, localAddress, remoteAddress, ka, dt, password, reconnectTime, redelegationTimeout, stateTimeout, timer);
 117     }
 118
 119     public static void createPCCs(final int lspsPerPcc, final boolean pcerr, final int pccCount,
 120             final InetSocketAddress localAddress, final List<InetSocketAddress> remoteAddress, final short keepalive, final short deadtimer,
 121             final String password, final int reconnectTime, final int redelegationTimeout, final int stateTimeout, final Timer timer) throws InterruptedException, ExecutionException {
 122         startActivators();
 123         InetAddress currentAddress = localAddress.getAddress();
 124         final Open openMessage = getOpenMessage(keepalive, deadtimer);
 125         final PCCDispatcher pccDispatcher = new PCCDispatcher(ServiceLoaderPCEPExtensionProviderContext.getSingletonInstance().getMessageHandlerRegistry(),
 126                 getSessionNegotiatorFactory(openMessage));
 127         for (int i = 0; i < pccCount; i++) {
 128             final PccTunnelManager tunnelManager = new PccTunnelManagerImpl(lspsPerPcc, currentAddress,
 129                     redelegationTimeout, stateTimeout, timer);
 130             createPCC(pcerr, new InetSocketAddress(currentAddress, localAddress.getPort()),
 131                     remoteAddress, openMessage, pccDispatcher, password, reconnectTime, tunnelManager);
 132             currentAddress = InetAddresses.increment(currentAddress);
 133         }
 134     }
 135
 136     @SuppressWarnings("deprecation")
 137     private static void createPCC(final boolean pcerr, final InetSocketAddress localAddress,
 138             final List<InetSocketAddress> remoteAddress, final Open openMessage, final PCCDispatcher pccDispatcher,
 139             final String password, final int reconnectTime, final PccTunnelManager tunnelManager) throws InterruptedException, ExecutionException {
 140         final SessionNegotiatorFactory<Message, PCEPSessionImpl, PCEPSessionListener> snf = getSessionNegotiatorFactory(openMessage);
 141
 142         for (final InetSocketAddress pceAddress : remoteAddress) {
 143             pccDispatcher.createClient(localAddress, pceAddress, reconnectTime == -1 ? getNeverReconnectStrategyFactory() : getTimedReconnectStrategyFactory(reconnectTime),
 144                     new SessionListenerFactory<PCEPSessionListener>() {
 145                         @Override
 146                         public PCEPSessionListener getSessionListener() {
 147                             return new PccSessionListener(remoteAddress.indexOf(pceAddress), tunnelManager, pcerr);
 148                         }
 149                     } ,snf, getKeyMapping(pceAddress.getAddress(), password));
 150         }
 151     }
 152
 153     @SuppressWarnings("deprecation")
 154     private static SessionNegotiatorFactory<Message, PCEPSessionImpl, PCEPSessionListener> getSessionNegotiatorFactory(final Open openMessage) {
 155         return new DefaultPCEPSessionNegotiatorFactory(openMessage, 0);
 156     }
 157
 158     private static ch.qos.logback.classic.Logger getRootLogger(final LoggerContext lc) {
 159         return Iterables.find(lc.getLoggerList(), new Predicate<Logger>() {
 160             @Override
 161             public boolean apply(final Logger input) {
 162                 return (input != null) ? input.getName().equals(Logger.ROOT_LOGGER_NAME) : false;
 163             }
 164         });
 165     }
 166
 167     private static List<InetSocketAddress> parseAddresses(final String address, final int defaultPort) {
 168         return Lists.transform(Arrays.asList(address.split(",")), new Function<String, InetSocketAddress>() {
 169             @Override
 170             public InetSocketAddress apply(final String input) {
 171                 return getInetSocketAddress(input, defaultPort);
 172             }
 173         });
 174     }
 175
 176     private static InetSocketAddress getInetSocketAddress(final String hostPortString, final int defaultPort) {
 177         final HostAndPort hostAndPort = HostAndPort.fromString(hostPortString).withDefaultPort(defaultPort);
 178         return new InetSocketAddress(hostAndPort.getHostText(), hostAndPort.getPort());
 179     }
 180
 181     private static KeyMapping getKeyMapping(final InetAddress inetAddress, final String password) {
 182         if (password != null) {
 183             final KeyMapping keyMapping = new KeyMapping();
 184             keyMapping.put(inetAddress, password.getBytes(Charsets.US_ASCII));
 185             return keyMapping;
 186         }
 187         return null;
 188     }
 189
 190     private static Open getOpenMessage(final short keepalive, final short deadtimer) {
 191         final Tlvs1 tlvs1 = new Tlvs1Builder().setStateful(new StatefulBuilder().addAugmentation(Stateful1.class,
 192                 new Stateful1Builder().setInitiation(true).build()).setLspUpdateCapability(true).build()).build();
 193         return new OpenBuilder().setTlvs(new TlvsBuilder().addAugmentation(Tlvs1.class, tlvs1).build())
 194                 .setKeepalive(keepalive).setDeadTimer(deadtimer).setSessionId((short) 0).build();
 195     }
 196
 197     private static void startActivators() {
 198         final PCCActivator pccActivator = new PCCActivator();
 199         final StatefulActivator stateful = new StatefulActivator();
 200         final CrabbeInitiatedActivator activator = new CrabbeInitiatedActivator();
 201         final PCEPExtensionProviderContext ctx = ServiceLoaderPCEPExtensionProviderContext.getSingletonInstance();
 202         pccActivator.start(ctx);
 203         stateful.start(ctx);
 204         activator.start(ctx);
 205     }
 206
 207     @SuppressWarnings("deprecation")
 208     private static ReconnectStrategyFactory getNeverReconnectStrategyFactory() {
 209         return new ReconnectStrategyFactory() {
 210
 211             @Override
 212             public ReconnectStrategy createReconnectStrategy() {
 213                 return new NeverReconnectStrategy(GlobalEventExecutor.INSTANCE, RECONNECT_STRATEGY_TIMEOUT);
 214             }
 215         };
 216     }
 217
 218     @SuppressWarnings("deprecation")
 219     private static ReconnectStrategyFactory getTimedReconnectStrategyFactory(final int reconnectTime) {
 220         return new ReconnectStrategyFactory() {
 221
 222             @Override
 223             public ReconnectStrategy createReconnectStrategy() {
 224                 return new TimedReconnectStrategy(GlobalEventExecutor.INSTANCE, RECONNECT_STRATEGY_TIMEOUT, reconnectTime, 1.0, null, null, null);
 225             }
 226         };
 227     }
 228
 229 }