src/com/android/tradefed/command/RemoteManager.java - platform/tools/tradefederation - Gitiles

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.android.tradefed.command;

 import com.android.ddmlib.Log;
 import com.android.ddmlib.Log.LogLevel;
 import com.android.tradefed.device.IDeviceManager;
 import com.android.tradefed.device.IDeviceManager.FreeDeviceState;
 import com.android.tradefed.device.ITestDevice;
 import com.android.tradefed.log.LogUtil.CLog;
 import com.android.tradefed.util.ArrayUtil;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.PrintWriter;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.util.Arrays;
 import java.util.Hashtable;
 import java.util.Map;

 /**
  * Class that receives remote commands to add and remove devices from use via a socket.
  * <p/>
  * Currently accepts only one remote connection at one time, and processes incoming commands
  * serially.
  * <p/>
  * Usage:
  * <pre>
  * RemoteManager r = new RemoteManager(deviceMgr, scheduler);
  * r.start();
  * int port = r.getPort();
  * ... inform client of port to use. Shuts down when instructed by client or on #cancel()
  * </pre>
  */
 public class RemoteManager extends Thread {

     // constants that define wire protocol between RemoteClient and RemoteManager
     static final String DELIM = ";";
     static final String FILTER = "filter";
     static final String UNFILTER = "unfilter";
     static final String ALL_DEVICES = "*";
     static final String CLOSE = "close";
     static final String ADD_COMMAND = "add_command";

     private ServerSocket mServerSocket = null;
     private boolean mCancel = false;
     private final IDeviceManager mDeviceManager;
     private final ICommandScheduler mScheduler;
     private Map<String, ITestDevice> mFilteredDeviceMap = new Hashtable<String, ITestDevice>();

     /**
      * Creates a {@link RemoteManager}.
      *
      * @param manager the {@link IDeviceManager} to use to allocate and free devices.
      * @param scheduler the {@link ICommandScheduler} to use to schedule commands.
      */
     public RemoteManager(IDeviceManager manager, ICommandScheduler scheduler) {
         mDeviceManager = manager;
         mScheduler = scheduler;
     }

     /**
      * The main thread body of the remote manager.
      * <p/>
      * Creates a server socket, and waits for client connections.
      */
     @Override
     public void run() {
         synchronized (this) {
             try {
                 mServerSocket = new ServerSocket(0);
             } catch (IOException e) {
                 CLog.e("Failed to open server socket: %s", e);
                 return;
             } finally {
                 // notify any listeners that the socket has been created
                 notifyAll();
             }
         }
         try {
             processClientConnections(mServerSocket);
         } finally {
             freeAllDevices();
             closeSocket(mServerSocket);
         }
     }

     /**
      * Gets the socket port the remote manager is listening on, blocking for a short time if
      * necessary.
      * <p/>
      * {@link #start()} should be called before this method.
      * @return
      */
     public synchronized int getPort() {
         if (mServerSocket == null) {
             try {
                 wait(10*1000);
             } catch (InterruptedException e) {
                 // ignore
             }
         }
         if (mServerSocket == null) {
             return -1;
         }
         return mServerSocket.getLocalPort();
     }

     private void processClientConnections(ServerSocket serverSocket) {
         while (!mCancel) {
             Socket clientSocket = null;
             BufferedReader in = null;
             PrintWriter out = null;
             try {
                 clientSocket = serverSocket.accept();
                 in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                 out = new PrintWriter(clientSocket.getOutputStream(), true);
                 processClientCommands(in, out);
             } catch (IOException e) {
                 CLog.e("Failed to accept connection: %s", e);
             } finally {
                 closeReader(in);
                 closeWriter(out);
                 closeSocket(clientSocket);
             }
         }
     }

     private void processClientCommands(BufferedReader in, PrintWriter out) throws IOException {
         String line = null;
         while ((line = in.readLine()) != null && !mCancel) {
             boolean result = false;
             String[] commandSegments = line.split(DELIM);
             String cmdType = commandSegments[0];
             if (FILTER.equals(cmdType)) {
                 result = processFilterCommand(commandSegments);
             } else if (UNFILTER.equals(cmdType)) {
                 result = processUnfilterCommand(commandSegments);
             } else if (CLOSE.equals(cmdType)) {
                 cancel();
                 result = true;
             } else if (ADD_COMMAND.equals(cmdType)) {
                 result = processAddCommand(commandSegments);
             }
             sendAck(result, out);
         }
     }

     private boolean processFilterCommand(final String[] commandSegments) {
         if (commandSegments.length < 2) {
             CLog.e("Invalid command received: %s", ArrayUtil.join(" ", (Object[])commandSegments));
             return false;
         }
         final String serial = commandSegments[1];
         ITestDevice allocatedDevice = mDeviceManager.forceAllocateDevice(serial);
         if (allocatedDevice != null) {
             Log.logAndDisplay(LogLevel.INFO, "RemoteManager",
                     String.format("Allocating device %s that is still in use by remote tradefed",
                             serial));
             mFilteredDeviceMap.put(serial, allocatedDevice);
             return true;
         } else {
             CLog.e("Failed to allocate remote device %s", serial);
             return false;
         }
     }

     private boolean processUnfilterCommand(final String[] commandSegments) {
         if (commandSegments.length < 2) {
             CLog.e("Invalid command received: %s", ArrayUtil.join(" ", (Object[])commandSegments));
             return false;
         }
         // TODO: consider making this synchronous, and sending ack back to client once allocated
         final String serial = commandSegments[1];
         if (ALL_DEVICES.equals(serial)) {
             freeAllDevices();
             return true;
         } else {
             ITestDevice d = mFilteredDeviceMap.remove(serial);
             if (d != null) {
                 Log.logAndDisplay(LogLevel.INFO, "RemoteManager",
                         String.format("Freeing device %s no longer in use by remote tradefed",
                                 serial));
                 mDeviceManager.freeDevice(d, FreeDeviceState.AVAILABLE);
                 return true;
             } else {
                 CLog.w("Could not find device to free %s", serial);
             }
         }
         return false;
     }

     private boolean processAddCommand(final String[] commandSegments) {
         if (commandSegments.length < 3) {
             CLog.e("Invalid command received: %s", ArrayUtil.join(" ", (Object[])commandSegments));
             return false;
         }
         long totalTime = Long.parseLong(commandSegments[1]);
         String[] cmdArgs = Arrays.copyOfRange(commandSegments, 2, commandSegments.length);
         Log.logAndDisplay(LogLevel.INFO, "RemoteManager",
                 String.format("Adding command '%s'", ArrayUtil.join(" ", (Object[])cmdArgs)));
         return mScheduler.addCommand(cmdArgs, totalTime);
     }

     private void freeAllDevices() {
         for (ITestDevice d : mFilteredDeviceMap.values()) {
             Log.logAndDisplay(LogLevel.INFO, "RemoteManager",
                     String.format("Freeing device %s no longer in use by remote tradefed",
                             d.getSerialNumber()));

             mDeviceManager.freeDevice(d, FreeDeviceState.AVAILABLE);
         }
         mFilteredDeviceMap.clear();
     }

     private void sendAck(boolean result, PrintWriter out) {
         out.println(result);
     }

     /**
      * Cancel the remote manager.
      */
     public synchronized void cancel() {
         if (!mCancel) {
             mCancel  = true;
             Log.logAndDisplay(LogLevel.INFO, "RemoteManager", "Closing remote manager");
         }
     }

     private void closeSocket(ServerSocket serverSocket) {
         if (serverSocket != null) {
             try {
                 serverSocket.close();
             } catch (IOException e) {
                 // ignore
             }
         }
     }

     private void closeSocket(Socket clientSocket) {
         if (clientSocket != null) {
             try {
                 clientSocket.close();
             } catch (IOException e) {
                 // ignore
                 e.printStackTrace();
             }
         }
     }

     private void closeReader(BufferedReader in) {
         if (in != null) {
             try {
                 in.close();
             } catch (IOException e) {
                 // ignore
             }
         }
     }

     private void closeWriter(PrintWriter out) {
         if (out != null) {
             out.close();
         }
     }

     /**
      * @return <code>true</code> if a cancel has been requested
      */
     public boolean isCanceled() {
         return mCancel;
     }
 }
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.android.tradefed.command;

	import com.android.ddmlib.Log;
	import com.android.ddmlib.Log.LogLevel;
	import com.android.tradefed.device.IDeviceManager;
	import com.android.tradefed.device.IDeviceManager.FreeDeviceState;
	import com.android.tradefed.device.ITestDevice;
	import com.android.tradefed.log.LogUtil.CLog;
	import com.android.tradefed.util.ArrayUtil;

	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.io.PrintWriter;
	import java.net.ServerSocket;
	import java.net.Socket;
	import java.util.Arrays;
	import java.util.Hashtable;
	import java.util.Map;

	/**
	* Class that receives remote commands to add and remove devices from use via a socket.
	* <p/>
	* Currently accepts only one remote connection at one time, and processes incoming commands
	* serially.
	* <p/>
	* Usage:
	* <pre>
	* RemoteManager r = new RemoteManager(deviceMgr, scheduler);
	* r.start();
	* int port = r.getPort();
	* ... inform client of port to use. Shuts down when instructed by client or on #cancel()
	* </pre>
	*/
	public class RemoteManager extends Thread {

	// constants that define wire protocol between RemoteClient and RemoteManager
	static final String DELIM = ";";
	static final String FILTER = "filter";
	static final String UNFILTER = "unfilter";
	static final String ALL_DEVICES = "*";
	static final String CLOSE = "close";
	static final String ADD_COMMAND = "add_command";

	private ServerSocket mServerSocket = null;
	private boolean mCancel = false;
	private final IDeviceManager mDeviceManager;
	private final ICommandScheduler mScheduler;
	private Map<String, ITestDevice> mFilteredDeviceMap = new Hashtable<String, ITestDevice>();

	/**
	* Creates a {@link RemoteManager}.
	*
	* @param manager the {@link IDeviceManager} to use to allocate and free devices.
	* @param scheduler the {@link ICommandScheduler} to use to schedule commands.
	*/
	public RemoteManager(IDeviceManager manager, ICommandScheduler scheduler) {
	mDeviceManager = manager;
	mScheduler = scheduler;
	}

	/**
	* The main thread body of the remote manager.
	* <p/>
	* Creates a server socket, and waits for client connections.
	*/
	@Override
	public void run() {
	synchronized (this) {
	try {
	mServerSocket = new ServerSocket(0);
	} catch (IOException e) {
	CLog.e("Failed to open server socket: %s", e);
	return;
	} finally {
	// notify any listeners that the socket has been created
	notifyAll();
	}
	}
	try {
	processClientConnections(mServerSocket);
	} finally {
	freeAllDevices();
	closeSocket(mServerSocket);
	}
	}

	/**
	* Gets the socket port the remote manager is listening on, blocking for a short time if
	* necessary.
	* <p/>
	* {@link #start()} should be called before this method.
	* @return
	*/
	public synchronized int getPort() {
	if (mServerSocket == null) {
	try {
	wait(10*1000);
	} catch (InterruptedException e) {
	// ignore
	}
	}
	if (mServerSocket == null) {
	return -1;
	}
	return mServerSocket.getLocalPort();
	}

	private void processClientConnections(ServerSocket serverSocket) {
	while (!mCancel) {
	Socket clientSocket = null;
	BufferedReader in = null;
	PrintWriter out = null;
	try {
	clientSocket = serverSocket.accept();
	in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
	out = new PrintWriter(clientSocket.getOutputStream(), true);
	processClientCommands(in, out);
	} catch (IOException e) {
	CLog.e("Failed to accept connection: %s", e);
	} finally {
	closeReader(in);
	closeWriter(out);
	closeSocket(clientSocket);
	}
	}
	}

	private void processClientCommands(BufferedReader in, PrintWriter out) throws IOException {
	String line = null;
	while ((line = in.readLine()) != null && !mCancel) {
	boolean result = false;
	String[] commandSegments = line.split(DELIM);
	String cmdType = commandSegments[0];
	if (FILTER.equals(cmdType)) {
	result = processFilterCommand(commandSegments);
	} else if (UNFILTER.equals(cmdType)) {
	result = processUnfilterCommand(commandSegments);
	} else if (CLOSE.equals(cmdType)) {
	cancel();
	result = true;
	} else if (ADD_COMMAND.equals(cmdType)) {
	result = processAddCommand(commandSegments);
	}
	sendAck(result, out);
	}
	}

	private boolean processFilterCommand(final String[] commandSegments) {
	if (commandSegments.length < 2) {
	CLog.e("Invalid command received: %s", ArrayUtil.join(" ", (Object[])commandSegments));
	return false;
	}
	final String serial = commandSegments[1];
	ITestDevice allocatedDevice = mDeviceManager.forceAllocateDevice(serial);
	if (allocatedDevice != null) {
	Log.logAndDisplay(LogLevel.INFO, "RemoteManager",
	String.format("Allocating device %s that is still in use by remote tradefed",
	serial));
	mFilteredDeviceMap.put(serial, allocatedDevice);
	return true;
	} else {
	CLog.e("Failed to allocate remote device %s", serial);
	return false;
	}
	}

	private boolean processUnfilterCommand(final String[] commandSegments) {
	if (commandSegments.length < 2) {
	CLog.e("Invalid command received: %s", ArrayUtil.join(" ", (Object[])commandSegments));
	return false;
	}
	// TODO: consider making this synchronous, and sending ack back to client once allocated
	final String serial = commandSegments[1];
	if (ALL_DEVICES.equals(serial)) {
	freeAllDevices();
	return true;
	} else {
	ITestDevice d = mFilteredDeviceMap.remove(serial);
	if (d != null) {
	Log.logAndDisplay(LogLevel.INFO, "RemoteManager",
	String.format("Freeing device %s no longer in use by remote tradefed",
	serial));
	mDeviceManager.freeDevice(d, FreeDeviceState.AVAILABLE);
	return true;
	} else {
	CLog.w("Could not find device to free %s", serial);
	}
	}
	return false;
	}

	private boolean processAddCommand(final String[] commandSegments) {
	if (commandSegments.length < 3) {
	CLog.e("Invalid command received: %s", ArrayUtil.join(" ", (Object[])commandSegments));
	return false;
	}
	long totalTime = Long.parseLong(commandSegments[1]);
	String[] cmdArgs = Arrays.copyOfRange(commandSegments, 2, commandSegments.length);
	Log.logAndDisplay(LogLevel.INFO, "RemoteManager",
	String.format("Adding command '%s'", ArrayUtil.join(" ", (Object[])cmdArgs)));
	return mScheduler.addCommand(cmdArgs, totalTime);
	}

	private void freeAllDevices() {
	for (ITestDevice d : mFilteredDeviceMap.values()) {
	Log.logAndDisplay(LogLevel.INFO, "RemoteManager",
	String.format("Freeing device %s no longer in use by remote tradefed",
	d.getSerialNumber()));

	mDeviceManager.freeDevice(d, FreeDeviceState.AVAILABLE);
	}
	mFilteredDeviceMap.clear();
	}

	private void sendAck(boolean result, PrintWriter out) {
	out.println(result);
	}

	/**
	* Cancel the remote manager.
	*/
	public synchronized void cancel() {
	if (!mCancel) {
	mCancel = true;
	Log.logAndDisplay(LogLevel.INFO, "RemoteManager", "Closing remote manager");
	}
	}

	private void closeSocket(ServerSocket serverSocket) {
	if (serverSocket != null) {
	try {
	serverSocket.close();
	} catch (IOException e) {
	// ignore
	}
	}
	}

	private void closeSocket(Socket clientSocket) {
	if (clientSocket != null) {
	try {
	clientSocket.close();
	} catch (IOException e) {
	// ignore
	e.printStackTrace();
	}
	}
	}

	private void closeReader(BufferedReader in) {
	if (in != null) {
	try {
	in.close();
	} catch (IOException e) {
	// ignore
	}
	}
	}

	private void closeWriter(PrintWriter out) {
	if (out != null) {
	out.close();
	}
	}

	/**
	* @return <code>true</code> if a cancel has been requested
	*/
	public boolean isCanceled() {
	return mCancel;
	}
	}