问程控SauceLabs隧道控制

EN

Process tunnel = sauceTunnelManager.openConnection( 
        sauceUser,      // username 
        sauceKey,       // apiKey 
        port,           // port 
        null,           // sauceConnectJar 
        tunnelOptions,  // Tunnel options 
        null,           // printStream 
        null,           // verboseLogging 
        null            // sauceConnectPath );

sauceTunnelManager.closeTunnelsForPlan(
     sauceUser,      // username (same as start tunnel)
     tunnelOptions,  // tunnelOptions (same as start tunnel)
     null);

package au.com.somecompany.devops.tunnels;

import au.com.somecompany.devops.tunnels.channel.Channel;
import au.com.somecompany.devops.tunnels.channel.SauceLabsChannel;
import au.com.somecompany.devops.utils.Drop;

public class SauceLabsTunnel extends Thread implements Runnable {
    private Channel Jar;
    private Drop Tunnelled;
    private Drop Tested;

    public SauceLabsTunnel(Drop tunnelled, Drop tested){
        String command = "java -jar lib/Sauce-Connect.jar ";
        String successMessage = "Successful handshake with Sauce Connect server";
        String failureMessage = "Could not reach Sauce Labs REST API";
        String outputTerminal = "Connected! You may start your tests.";

        Jar = new SauceLabsChannel(command, System.getProperty("ACCESSKEY"), successMessage, failureMessage, outputTerminal, System.getProperty("USERNAME"));
        Tunnelled = tunnelled;
        Tested = tested;
    }

    @Override
    public void run() {
        Jar.Launch();

        while(!Jar.IsJARSuccessfullyLaunched()){
            Jar.Launch();
        }
        Jar.PrintOutput();
        Tunnelled.put("TUNNELLED");

        for (String message = Tested.take(); !message.equals("TESTED"); message = Tested.take()) {
            System.out.println("I see Testing is completed. Closing Tunnel...");
        }
        Shutdown();
    }

    public void Shutdown(){
        Jar.Shutdown();
    }
}

package au.com.somecompany.devops.tunnels.channel;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class Channel {
    protected Process Process;
    protected String ChannelCommand = null;
    protected String ProcessOutput = null;
    protected String SuccessMessage = null;
    protected String FailureMessage = null;
    protected String OutputTerminal = null;

    public Channel(String command, String successMessage, String failureMessage, String outputTerminal){
        ChannelCommand = command;
        SuccessMessage = successMessage;
        FailureMessage = failureMessage;
        OutputTerminal = outputTerminal;
    }

    public void Launch(){
        Process = ExecuteJAR();
        ProcessOutput = GetOutput(Process.getInputStream());
    }

    public boolean IsJARSuccessfullyLaunched(){
        return ProcessOutput.contains(SuccessMessage) && 
               !ProcessOutput.contains(FailureMessage);
    }

    public void PrintOutput(){
        System.out.print(ProcessOutput);
    }

    public void Shutdown(){
        Process.destroy();
    }

    private String GetOutput(InputStream is){
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        StringBuffer sb = new StringBuffer();
        try {
            String s = br.readLine();
            if(s == null) {
                return null;
            }
            while(!s.contains(OutputTerminal)){
                sb.append(s).append("\n");
                s = br.readLine();
                if(s == null || s.contains(OutputTerminal)){
                    break;
                }
            }
        } catch (IOException e){
            e.printStackTrace();
        }
        return sb.toString();
    }

    private Process ExecuteJAR() {
        Process p;
        try {
            p = Runtime.getRuntime().exec(ChannelCommand);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
        catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return p;
    }
}

package au.com.somecompany.devops.tunnels.channel;

public class SauceLabsChannel extends Channel {
    public SauceLabsChannel(String command, String accessKey, String successMessage, String failureMessage, String outputTerminal, String username){
        super(command, successMessage, failureMessage, outputTerminal);
        ChannelCommand += username + " " + accessKey;
    }
}

package au.com.somecompany.devops.utils;

public class Drop {
    // Message sent from producer
    // to consumer.
    private String message;
    // True if consumer should wait
    // for producer to send message,
    // false if producer should wait for
    // consumer to retrieve message.
    private boolean empty = true;

    public synchronized String take() {
        // Wait until message is
        // available.
        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {}
        }
        // Toggle status.
        empty = true;
        // Notify producer that
        // status has changed.
        notifyAll();
        return message;
    }

    public synchronized void put(String message) {
        // Wait until message has
        // been retrieved.
        while (!empty) {
            try { 
                wait();
            } catch (InterruptedException e) {}
        }
        // Toggle status.
        empty = false;
        // Store message.
        this.message = message;
        // Notify consumer that status
        // has changed.
        notifyAll();
    }
}