Updated files

build/android/pylib/local/device/local_device_environment.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import datetime
 import logging
 import os
 import shutil
 import tempfile
 import threading
@@ skipping 26 matching lines @@
     self._devices = []
     self._concurrent_adb = args.enable_concurrent_adb
     self._enable_device_cache = args.enable_device_cache
     self._logcat_monitors = []
     self._logcat_output_dir = args.logcat_output_dir
     self._logcat_output_file = args.logcat_output_file
     self._max_tries = 1 + args.num_retries
     self._skip_clear_data = args.skip_clear_data
     self._target_devices_file = args.target_devices_file
     self._tool_name = args.tool
-
+    self._logdog_butler_pref = args.logdog_butler_prefix
+    self._logdog_butler_dir = args.logdog_butler_dir
+    self._logdog_butler_project = args.logdog_butler_project
   #override
   def SetUp(self):
     device_arg = 'default'
     if self._target_devices_file:
       device_arg = device_list.GetPersistentDeviceList(
           self._target_devices_file)
       if not device_arg:
         logging.warning('No target devices specified. Falling back to '
                         'running on all available devices.')
         device_arg = 'default'
     elif self._device_serial:
       device_arg = self._device_serial
 
     self._devices = device_utils.DeviceUtils.HealthyDevices(
         self._blacklist, enable_device_files_cache=self._enable_device_cache,
         default_retries=self._max_tries - 1, device_arg=device_arg)
     if not self._devices:
       raise device_errors.NoDevicesError
 
     if self._enable_device_cache:
       for d in self._devices:
         cache_path = _DeviceCachePath(d)
         if os.path.exists(cache_path):
           logging.info('Using device cache: %s', cache_path)
           with open(cache_path) as f:
             d.LoadCacheData(f.read())
           # Delete cached file so that any exceptions cause it to be cleared.
           os.unlink(cache_path)
+    # Add in logdog stuff
+    # subprocess.POpen(self._logdog_pref+'logdog_butler', '-project
+    # {0}'.format(self._logdog_butler_project), '-prefix
+    # {0}'.format(self._logdog_butler_pref), '-output', 'logdog',
+
+
     if self._logcat_output_file:
       self._logcat_output_dir = tempfile.mkdtemp()
     if self._logcat_output_dir:
       for d in self._devices:
+        logdog_name = None
+        if self._logdog_butler_pref:
+          logdog_name = 'swarming/device{0}'.format(d.adb.GetDeviceSerial())
         logcat_file = os.path.join(
             self._logcat_output_dir,
             '%s_%s' % (d.adb.GetDeviceSerial(),
                        datetime.datetime.utcnow().strftime('%Y%m%dT%H%M%S')))
         monitor = logcat_monitor.LogcatMonitor(
             d.adb, clear=True, output_file=logcat_file)
+           # logdog_prefix=self._logdog_butler_pref,
+           # logdog_name=logdog_name)
         self._logcat_monitors.append(monitor)
         monitor.Start()
 
   @property
   def concurrent_adb(self):
     return self._concurrent_adb
 
   @property
   def devices(self):
     if not self._devices:
@@ skipping 35 matching lines @@
           [m.output_file for m in self._logcat_monitors])
       shutil.rmtree(self._logcat_output_dir)
 
   def BlacklistDevice(self, device, reason='local_device_failure'):
     device_serial = device.adb.GetDeviceSerial()
     if self._blacklist:
       self._blacklist.Extend([device_serial], reason=reason)
     with self._devices_lock:
       self._devices = [d for d in self._devices if str(d) != device_serial]