Roll infra_libs to 564aaf7480f24c90687df79d9cef910cc342a54d

client/third_party/infra_libs/ts_mon/common/monitors.py

 # Copyright 2015 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.
 
 """Classes representing the monitoring interface for tasks or devices."""
 
 
 import base64
 import httplib2
 import json
 import logging
 import socket
 import traceback
 
 from googleapiclient import discovery
 from googleapiclient import errors
 from infra_libs import httplib2_utils
+from infra_libs.ts_mon.common import interface
 from infra_libs.ts_mon.common import http_metrics
 from infra_libs.ts_mon.common import pb_to_popo
-from infra_libs.ts_mon.protos import metrics_pb2
-from oauth2client import gce
+from infra_libs.ts_mon.protos.current import metrics_pb2
+try: # pragma: no cover
+  from oauth2client import gce
+except ImportError: # pragma: no cover
+  from oauth2client.contrib import gce
 from oauth2client.client import GoogleCredentials
 from oauth2client.file import Storage
 
 # Special string that can be passed through as the credentials path to use the
 # default Appengine or GCE service account.
 APPENGINE_CREDENTIALS = ':appengine'
 GCE_CREDENTIALS = ':gce'
 
 
 class Monitor(object):
@@ skipping 56 matching lines @@
 
   def __init__(self, endpoint, credentials_file_path, http=None):
     self._endpoint = endpoint
     credentials = self._load_credentials(credentials_file_path)
     if http is None:
       http = httplib2_utils.RetriableHttp(
           httplib2_utils.InstrumentedHttp('acq-mon-api'))
     self._http = credentials.authorize(http)
 
   def encodeToJson(self, metric_pb):
-    return json.dumps({ 'resource': pb_to_popo.convert(metric_pb) })
+    if interface.state.use_new_proto:
+      return json.dumps({'payload': pb_to_popo.convert(metric_pb)})
+    else:
+      return json.dumps({'resource': pb_to_popo.convert(metric_pb)})
 
   def send(self, metric_pb):
-    body = self.encodeToJson(self._wrap_proto(metric_pb))
+    if interface.state.use_new_proto:
+      body = self.encodeToJson(metric_pb)
+    else:
+      body = self.encodeToJson(self._wrap_proto(metric_pb))
 
     try:
       resp, content = self._http.request(self._endpoint, method='POST',
                                          body=body)
       if resp.status != 200:
         logging.warning('HttpsMonitor.send received status %d: %s', resp.status,
                         content)
     except (ValueError, errors.Error,
             socket.timeout, socket.error, socket.herror, socket.gaierror,
             httplib2.HttpLib2Error):
@@ skipping 34 matching lines @@
       # Log a warning, not error, to avoid false alarms in AppEngine apps.
       logging.warning('PubSubMonitor._initialize failed:\n%s',
                       traceback.format_exc())
       self._api = None
       self._update_init_metrics(http_metrics.STATUS_ERROR)
       return False
 
     self._update_init_metrics(http_metrics.STATUS_OK)
     return True
 
-  def __init__(self, credsfile, project, topic, use_instrumented_http=True):
+  def __init__(self, credsfile, project, topic, use_instrumented_http=True,
+               ca_certs=None):
     """Process monitoring related command line flags and initialize api.
 
     Args:
       credsfile (str): path to the credentials json file
       project (str): the name of the Pub/Sub project to publish to.
       topic (str): the name of the Pub/Sub topic to publish to.
       use_instrumented_http (bool): whether to record monitoring metrics for
           HTTP requests made to the pubsub API.
+      ca_certs (str): path to file containing root CA certificates for SSL
+                      server certificate validation. If not set, a CA cert
+                      file bundled with httplib2 is used.
     """
     # Do not call self._check_initialize() in the constructor. This
     # class is constructed during app initialization on AppEngine, and
     # network calls are especially flaky during that time.
     self._api = None
     self._use_instrumented_http = use_instrumented_http
     if use_instrumented_http:
       self._http = httplib2_utils.InstrumentedHttp(
-          'acq-mon-api-pubsub', timeout=self.TIMEOUT)
+          'acq-mon-api-pubsub', timeout=self.TIMEOUT, ca_certs=ca_certs)
     else:
-      self._http = httplib2.Http(timeout=self.TIMEOUT)
+      self._http = httplib2.Http(timeout=self.TIMEOUT, ca_certs=ca_certs)
     self._credsfile = credsfile
     self._topic = 'projects/%s/topics/%s' % (project, topic)
 
   def send(self, metric_pb):
     """Send a metric proto to the monitoring api.
 
     Args:
       metric_pb (MetricsData or MetricsCollection): the metric protobuf to send
     """
     if not self._check_initialize():
@@ skipping 34 matching lines @@
     logging.info('Flushing monitoring metrics:\n%s', text)
     if self._fh is not None:
       self._fh.write(text + '\n\n')
       self._fh.flush()
 
 
 class NullMonitor(Monitor):
   """Class that doesn't send metrics anywhere."""
   def send(self, metric_pb):
     pass