Deep copy any proto values that might outlive the message

appengine/swarming/swarming_bot/bot_code/remote_client_grpc.py

 # Copyright 2016 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 # This is a reimplementation of RemoteClientNative but it uses (will use)
 # a gRPC method to communicate with a server instead of REST.
 
+import copy
 import json
 import logging
 import time
 
 import grpc
 import google.protobuf.json_format
 from proto_bot import swarming_bot_pb2
 from remote_client_errors import InternalError
 from remote_client_errors import PollError
 from utils import net
 
 
 # How long to wait for a response from the server. Keeping the same as
 # the equivalent in remote_client.py for now.
 NET_CONNECTION_TIMEOUT_SEC = 5*60
 
 
 # How many times to retry a gRPC call
 MAX_GRPC_ATTEMPTS = 30
 
 
 # Longest time to sleep between gRPC calls
 MAX_GRPC_SLEEP = 10.
 
 
 class RemoteClientGrpc(object):
   """RemoteClientGrpc knows how to make calls via gRPC.
+
+  Any non-scalar value that is returned that references values from the proto
+  messages should be deepcopy'd since protos make use of weak references and
+  might be garbage-collected before the values are used.
   """
 
   def __init__(self, server):
     logging.info('Communicating with host %s via gRPC', server)
     self._server = server
     self._channel = grpc.insecure_channel(server)
     self._stub = swarming_bot_pb2.BotServiceStub(self._channel)
     self._log_is_asleep = False
 
   def is_grpc(self):
@@ skipping 65 matching lines @@
         'server_version': response.server_version,
         'bot_version': response.bot_version,
         'bot_group_cfg_version': response.bot_group_cfg_version,
         'bot_group_cfg': {
             'dimensions': {
                 d.name: d.values for d in response.bot_group_cfg.dimensions
             },
         },
     }
     logging.info('Completed handshake: %s', resp)
-    return resp
+    return copy.deepcopy(resp)
 
   def poll(self, attributes):
     request = swarming_bot_pb2.PollRequest()
     self._attributes_json_to_proto(attributes, request.attributes)
     # TODO(aludwin): gRPC-specific exception handling (raise PollError).
     response = call_grpc(self._stub.Poll, request)
 
     if response.cmd == swarming_bot_pb2.PollResponse.UPDATE:
       return 'update', response.version
 
@@ skipping 36 matching lines @@
         'task_id': protoManifest.task_id,
 
         # These keys are only needed by raw commands. While this method
         # only supports isolated commands, the keys need to exist to avoid
         # missing key errors.
         'command': None,
         'extra_args': None,
       }
       logging.info('Received job manifest: %s', manifest)
       self._log_is_asleep = False
-      return 'run', manifest
+      return 'run', copy.deepcopy(manifest)
 
     raise PollError('Unknown command in response: %s' % response)
 
   def get_bot_code(self, new_zip_fn, bot_version, _bot_id):
     # TODO(aludwin): exception handling, pass bot_id
     logging.info('Updating to version: %s', bot_version)
     request = swarming_bot_pb2.BotUpdateRequest()
     request.bot_version = bot_version
     response = call_grpc(self._stub.BotUpdate, request)
     with open(new_zip_fn, 'wb') as f:
@@ skipping 53 matching lines @@
     except grpc.RpcError as g:
       if g.code() is not grpc.StatusCode.UNAVAILABLE:
         raise
       logging.warning('call_grpc - proxy is unavailable (attempt %d/%d)',
                       attempt, MAX_GRPC_ATTEMPTS)
       grpc_error = g
       time.sleep(net.calculate_sleep_before_retry(attempt, MAX_GRPC_SLEEP))
   # If we get here, it must be because we got (and saved) an error
   assert grpc_error is not None
   raise grpc_error