import org.sdnplatform.sync.internal.util.CryptoUtil; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    AuthToolSettings settings = new AuthToolSettings();
    settings.init(args);        
    
    switch (settings.authScheme) {
        case NO_AUTH:
            System.err.println("No credentials required for NO_AUTH");
            break;
        case CHALLENGE_RESPONSE:
            CryptoUtil.writeSharedSecret(settings.keyStorePath, 
                                         settings.keyStorePassword, 
                                         CryptoUtil.secureRandom(16));
            System.out.println("Wrote random 128-bit secret to " +
                               settings.keyStorePath);
            break;
    }        
}
 

import org.sdnplatform.sync.internal.util.CryptoUtil; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    keyStoreFile = new File(keyStoreFolder.getRoot(), 
            "keystore.jceks");
    CryptoUtil.writeSharedSecret(keyStoreFile.getAbsolutePath(), 
                                 keyStorePassword, 
                                 CryptoUtil.secureRandom(16));

    tp = new ThreadPool();
    
    syncManagers = new SyncManager[4];
    moduleContexts = new FloodlightModuleContext[4];

    nodes = new ArrayList<Node>();
    nodes.add(new Node("localhost", 40101, (short)1, (short)1));
    nodes.add(new Node("localhost", 40102, (short)2, (short)2));
    nodes.add(new Node("localhost", 40103, (short)3, (short)1));
    nodes.add(new Node("localhost", 40104, (short)4, (short)2));
    nodeString = mapper.writeValueAsString(nodes);

    for(int i = 0; i < 4; i++) {
        moduleContexts[i] = new FloodlightModuleContext();
        syncManagers[i] = new SyncManager();
        setupSyncManager(moduleContexts[i], syncManagers[i], nodes.get(i));
    }
}
 

import org.sdnplatform.sync.internal.util.CryptoUtil; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    AuthToolSettings settings = new AuthToolSettings();
    settings.init(args);

    switch (settings.authScheme) {
        case NO_AUTH:
            System.err.println("No credentials required for NO_AUTH");
            break;
        case CHALLENGE_RESPONSE:
            CryptoUtil.writeSharedSecret(settings.keyStorePath,
                                         settings.keyStorePassword,
                                         CryptoUtil.secureRandom(16));
            System.out.println("Wrote random 128-bit secret to " +
                               settings.keyStorePath);
            break;
    }
}
 

import org.sdnplatform.sync.internal.util.CryptoUtil; //导入依赖的package包/类
@Override
protected byte[] getSharedSecret() throws AuthException {
    String path = syncManager.getClusterConfig().getKeyStorePath();
    String pass = syncManager.getClusterConfig().getKeyStorePassword();
    try {
        return CryptoUtil.getSharedSecret(path, pass);
    } catch (Exception e) {
        throw new AuthException("Could not read challenge/response " +
                "shared secret from key store " + path, e);
    }
}
 

import org.sdnplatform.sync.internal.util.CryptoUtil; //导入依赖的package包/类
@Override
protected byte[] getSharedSecret() throws AuthException {
    try {
        return CryptoUtil.getSharedSecret(bootstrap.keyStorePath, 
                                          bootstrap.keyStorePassword);
    } catch (Exception e) {
        throw new AuthException("Could not read challenge/response " + 
                "shared secret from key store " + 
                bootstrap.keyStorePath, e);
    }
}
 

import org.sdnplatform.sync.internal.util.CryptoUtil; //导入依赖的package包/类
@Override
protected byte[] getSharedSecret() throws AuthException {
    try {
        return CryptoUtil.getSharedSecret(syncManager.keyStorePath, 
                                          syncManager.keyStorePassword);
    } catch (Exception e) {
        throw new AuthException("Could not read challenge/response " + 
                "shared secret from key store " + 
                syncManager.keyStorePath, e);
    }
}
 

import org.sdnplatform.sync.internal.util.CryptoUtil; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    keyStoreFile = new File(keyStoreFolder.getRoot(), 
            "keystore.jceks");
    CryptoUtil.writeSharedSecret(keyStoreFile.getAbsolutePath(), 
                                 keyStorePassword, 
                                 CryptoUtil.secureRandom(16));
    
    nodes = new ArrayList<Node>();
    nodes.add(new Node("localhost", 40101, (short)1, (short)1));
    nodeString = mapper.writeValueAsString(nodes);
    
    debugCounterService = new MockDebugCounterService();
    
    tp = new ThreadPool();
    syncManager = new SyncManager();
    
    FloodlightModuleContext fmc = new FloodlightModuleContext();
    fmc.addService(IThreadPoolService.class, tp);
    fmc.addService(IDebugCounterService.class, new MockDebugCounterService());
    fmc.addService(IDebugEventService.class, new MockDebugEventService());
    
    fmc.addConfigParam(syncManager, "nodes", nodeString);
    fmc.addConfigParam(syncManager, "thisNode", ""+1);
    fmc.addConfigParam(syncManager, "persistenceEnabled", "false");
    fmc.addConfigParam(syncManager, "authScheme", "CHALLENGE_RESPONSE");
    fmc.addConfigParam(syncManager, "keyStorePath", 
                       keyStoreFile.getAbsolutePath());
    fmc.addConfigParam(syncManager, "keyStorePassword", keyStorePassword);
    tp.init(fmc);
    syncManager.init(fmc);

    tp.startUp(fmc);
    syncManager.startUp(fmc);

    syncManager.registerStore("global", Scope.GLOBAL);
}