Check environment

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
+import subprocess
+import uuid
 
 from devil.android import device_blacklist
 from devil.android import device_errors
 from devil.android import device_list
 from devil.android import device_utils
 from devil.android import logcat_monitor
 from devil.utils import file_utils
 from devil.utils import parallelizer
 from pylib import constants
 from pylib.base import environment
@@ skipping 16 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_dir = args.logdog_butler_dir
 
   #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.')
@@ skipping 53 matching lines @@
 
   @property
   def tool(self):
     return self._tool_name
 
   #override
   def TearDown(self):
     # Write the cache even when not using it so that it will be ready the first
     # time that it is enabled. Writing it every time is also necessary so that
     # an invalid cache can be flushed just by disabling it for one run.
+

[jbudorick, 2016/07/08 02:50:40]

?

     for d in self._devices:
       cache_path = _DeviceCachePath(d)
       with open(cache_path, 'w') as f:
         f.write(d.DumpCacheData())
         logging.info('Wrote device cache: %s', cache_path)
     for m in self._logcat_monitors:
       m.Stop()
       m.Close()
+    #Might be redundant with usage of logdog

[jbudorick, 2016/07/08 02:50:40]

Remove this.

     if self._logcat_output_file:
       file_utils.MergeFiles(
           self._logcat_output_file,
           [m.output_file for m in self._logcat_monitors])
       shutil.rmtree(self._logcat_output_dir)
 
+    #if the logdog_butler is pushed onto the swarming slave,
+    #use it to output the device logcats in a unified view
+    elif self._logcat_output_dir and self._logdog_butler_dir:
+      temp_dir = tempfile.mkdtemp()
+      temp_file = os.path.join(temp_dir, 'logcat')
+      # add device serial to each line of logcat output
+      for m in self._logcat_monitors:

[jbudorick, 2016/07/08 02:50:40]

Can we run this in parallel?
https://codesearch.chromium.org/chromium/src/third_party/catapult/devil/devil...
?

+        device_serial = (m._adb).__str__()

[jbudorick, 2016/07/08 02:50:41]

1) The linter should have been unhappy about this, particularly the protected
member access. If you need to grab the AdbWrapper instance from the
LogcatMonitor instead of the DeviceUtils instance (which, AFAICT, you do), then
let's add a property to LogcatMonitor that exposes _adb.
2) Use AdbWrapper.GetDeviceSerial() instead of __str__() if you want the serial.

+        add_device_args = ['sed', '-i', '-e',

[jbudorick, 2016/07/08 02:50:40]

Do this in-process rather than calling out to sed.

+                           's/^/device({0}) /'.format(device_serial),
+                           m.output_file]
+        subprocess.check_call(add_device_args)

[jbudorick, 2016/07/08 02:50:40]

Use cmd_helper instead of subprocess:
https://codesearch.chromium.org/chromium/src/third_party/catapult/devil/devil...

+      file_utils.MergeFiles(temp_file,
+          [m.output_file for m in self._logcat_monitors])
+      butler_location = os.path.join(self._logdog_butler_dir, 'logdog_butler')
+      prefix = str(uuid.uuid4())
+     # will be used once recipes are intergrated

[jbudorick, 2016/07/08 02:50:40]

1) Commented-out code shouldn't be here.
2) What is this doing...? This seems way too specific.

+     # prefix = "/".join(["swarming",
+     #                    os.environ['SWARMING_TASK_ID']])
+      name = temp_file
+      project = 'chromium'
+      logdog_args = [butler_location, '-log-level', 'debug', '-project',

[jbudorick, 2016/07/08 02:50:41]

This knows way too much about logdog and how to run it. If we're running this at
the end, why can't a post-processing step in the recipe -- i.e., outside the
test runner -- handle this?

+                     project, '-prefix', prefix,
+                     '-output', 'logdog,host=luci-logdog-dev.appspot.com',
+                     'stream', "-source", os.path.abspath(temp_file),
+                     '-stream', 'name=testing1234']
+
+      def url_constructor(project, prefix, name):
+        # Constucts and returns the url of where the logcats will
+        # be stored once logdog has streamed them to
+        # luci-logdog.appspot.com
+
+        def construct_prefix(prefix):
+          # Constructs the logdog prefix in URL form
+          return prefix.replace('/', '%2F')
+        
+        def construct_name(name):
+          # Constructs the logdog streamname in URL form
+          return 'file:{0}'.format(name.replace('/', '_', 20))
+
+        return 'luci-logdog-dev.appspot.com/v/?s={0}%2F{1}%2F%2B%2F{2}'.format(
+            project, construct_prefix(prefix), construct_name(name))
+      
+      #surpress logdog output to not clutter stdout
+      FNULL = open(os.devnull, 'w')
+      subprocess.check_call(logdog_args, stdout=FNULL, stderr=subprocess.STDOUT)
+
+      print 'Logcats are located at {0}'.format(url_constructor(project, prefix, name))

[jbudorick, 2016/07/08 02:50:40]

No prints, please. If you want to log something, use logging (this would be
logging.info).

+      shutil.rmtree(temp_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]