# Copyright (c) 2012 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 collections
import os
import random
import re
import sys

import buildbot
from buildbot import interfaces, util
from buildbot.buildslave import BuildSlave
from buildbot.interfaces import IRenderable
from buildbot.status import mail
from buildbot.status.builder import BuildStatus
from buildbot.status.status_push import HttpStatusPush
from infra_libs import command_line
from twisted.python import log
from zope.interface import implements

from master.autoreboot_buildslave import AutoRebootBuildSlave
from buildbot.status.web.authz import Authz
from buildbot.status.web.baseweb import WebStatus

import master.chromium_status_bb8 as chromium_status

from common import chromium_utils
from master import buildbucket
from master import cbe_json_status_push
from master import monitoring_status_receiver
from master import pubsub_json_status_push
from master import status_logger
import config


# CQ uses this service account to authenticate to other services, including
# buildbucket.
CQ_SERVICE_ACCOUNT = (
  '5071639625-1lppvbtck1morgivc6sq4dul7klu27sd@developer.gserviceaccount.com')


# Sanity timeout for CQ builders - they are expected to finish under one hour
# anyway. The timeout is deliberately larger than that so that we only
# kill really crazy long builds that also gum up resources.
CQ_MAX_TIME = 4*60*60


def HackMaxTime(maxTime=8*60*60):
  """Set maxTime default value to 8 hours. This function must be called before
  adding steps."""
  from buildbot.process.buildstep import RemoteShellCommand
  assert RemoteShellCommand.__init__.func_defaults == (None, 1, 1, 1200, None,
      {}, 'slave-config', True)
  RemoteShellCommand.__init__.im_func.func_defaults = (None, 1, 1, 1200,
      maxTime, {}, 'slave-config', True)
  assert RemoteShellCommand.__init__.func_defaults == (None, 1, 1, 1200,
      maxTime, {}, 'slave-config', True)

HackMaxTime()


def HackBuildStatus():
  """Adds a property to Build named 'blamelist' with the blamelist."""
  old_setBlamelist = BuildStatus.setBlamelist
  def setBlamelist(self, blamelist):
    self.setProperty('blamelist', blamelist, 'Build')
    old_setBlamelist(self, blamelist)
  BuildStatus.setBlamelist = setBlamelist

HackBuildStatus()


class InvalidConfig(Exception):
  """Used by VerifySetup."""
  pass


def AutoSetupSlaves(builders, bot_password, max_builds=1,
                    missing_recipients=None,
                    preferred_builder_dict=None,
                    missing_timeout=300):
  """Helper function for master.cfg to quickly setup c['slaves']."""
  missing_recipients = missing_recipients or []

  slaves_dict = {}
  for builder in builders:
    auto_reboot = builder.get('auto_reboot', True)
    notify_on_missing = builder.get('notify_on_missing', False)
    slavenames = builder.get('slavenames', [])[:]
    if 'slavename' in builder:
      slavenames.append(builder['slavename'])
    for slavename in slavenames:
      properties = {}
      if preferred_builder_dict:
        preferred_builder = preferred_builder_dict.get(slavename)
        if preferred_builder:
          properties['preferred_builder'] = preferred_builder
      # If a prior builder has configured this same slave, we treat
      # auto_reboot and notify_on_missing as the disjunction of what all
      # builders configure for that slave. Note, however, that if multiple
      # builders configure properties for the same slave, the last one wins.
      slaves_dict[slavename] = (
          slaves_dict.get(slavename, [None])[0] or auto_reboot,
          slaves_dict.get(slavename, [None, None])[1] or notify_on_missing,
          properties)

  slaves = []
  for (slavename,
       (auto_reboot, notify_on_missing, properties)) in slaves_dict.iteritems():
    if auto_reboot:
      slave_class = AutoRebootBuildSlave
    else:
      slave_class = BuildSlave

    if notify_on_missing:
      slaves.append(slave_class(slavename, bot_password, max_builds=max_builds,
                                properties=properties,
                                notify_on_missing=missing_recipients,
                                missing_timeout=missing_timeout))
    else:
      slaves.append(slave_class(slavename, bot_password,
                                properties=properties, max_builds=max_builds))

  return slaves


# TODO(phajdan.jr): Make enforce_sane_slave_pools unconditional,
# http://crbug.com/435559 . No new code should use it.
def VerifySetup(c, slaves, enforce_sane_slave_pools=True):
  """Verify all the available slaves in the slave configuration are used and
  that all the builders have a slave."""
  # Extract the list of slaves associated to a builder and make sure each
  # builder has its slaves connected.
  # Verify each builder has at least one slave.
  builders_slaves = set()
  slaves_name = [s.slavename for s in c['slaves']]
  slave_mapping = {}
  for b in c['builders']:
    builder_slaves = set()
    slavename = b.get('slavename')
    if slavename:
      builder_slaves.add(slavename)
    slavenames = b.get('slavenames', [])
    for s in slavenames:
      builder_slaves.add(s)
    if not slavename and not slavenames:
      raise InvalidConfig('Builder %s has no slave' % b['name'])
    # Now test.
    for s in builder_slaves:
      if not s in slaves_name:
        raise InvalidConfig('Builder %s using undefined slave %s' % (b['name'],
                                                                     s))
    slave_mapping[b['name']] = builder_slaves
    builders_slaves |= builder_slaves
  if len(builders_slaves) != len(slaves_name):
    raise InvalidConfig('Same slave defined multiple times')

  slaves_by_name = {chromium_utils.EntryToSlaveName(s): s
                    for s in slaves.GetSlaves()}

  # Make sure slave pools are either equal or disjoint. This makes capacity
  # analysis and planning simpler, easier, and more reliable.
  if enforce_sane_slave_pools:
    for b1, b1_slaves in slave_mapping.iteritems():
      for b2, b2_slaves in slave_mapping.iteritems():
        if b1_slaves != b2_slaves and not b1_slaves.isdisjoint(b2_slaves):
          raise InvalidConfig(
              'Builders %r and %r should have either equal or disjoint slave '
              'pools' % (b1, b2))

      # Explicitly specified slave pools must be consistent.
      b1_pool = None
      for slave in b1_slaves:
        pool = chromium_utils.EntryToSlavePool(slaves_by_name.get(slave, {}))
        if b1_pool is None:
          b1_pool = pool
        if b1_pool != pool:
          raise InvalidConfig(
            'Slave %s for build %r belongs to pool %s, but expected %s' % (
                slave, b1, pool, b1_pool))

  # Make sure each slave has their builder.
  builders_name = [b['name'] for b in c['builders']]
  for s in c['slaves']:
    name = s.slavename
    if not name in builders_slaves:
      raise InvalidConfig('Slave %s not associated with any builder' % name)

  # Make sure every defined slave is used.
  for s in slaves.GetSlaves():
    name = chromium_utils.EntryToSlaveName(s)
    if not name in slaves_name:
      raise InvalidConfig('Slave %s defined in your slaves_list is not '
                          'referenced at all' % name)
    builders = s.get('builder', [])
    if not isinstance(builders, (list, tuple)):
      builders = [builders]
    testers = s.get('testers', [])
    if not isinstance(testers, (list, tuple)):
      testers = [testers]
    builders.extend(testers)
    for b in builders:
      if not b in builders_name:
        raise InvalidConfig('Slave %s uses non-existent builder %s' % (name,
                                                                       b))

class UsersAreEmails(util.ComparableMixin):
  """Chromium already uses email addresses as user name so no need to do
  anything.
  """
  # Class has no __init__ method
  # pylint: disable=W0232
  implements(interfaces.IEmailLookup)

  @staticmethod
  def getAddress(name):
    return name


class FilterDomain(util.ComparableMixin):
  """Similar to buildbot.mail.Domain but permits filtering out people we don't
  want to spam.

  Also loads default values from chromium_config."""
  implements(interfaces.IEmailLookup)

  compare_attrs = ['domain', 'permitted_domains']


  def __init__(self, domain=None, permitted_domains=None):
    """domain is the default domain to append when only the naked username is
    available.
    permitted_domains is a whitelist of domains that emails will be sent to."""
    # pylint: disable=E1101
    self.domain = domain or config.Master.master_domain
    self.permitted_domains = (permitted_domains or
                              config.Master.permitted_domains)
    if self.permitted_domains:
      assert isinstance(self.permitted_domains, tuple), (
          'permitted_domains must be a tuple, now it is a %s (value: %s)' %
          (type(self.permitted_domains), self.permitted_domains))

  def getAddress(self, name):
    """If name is already an email address, pass it through."""
    result = name
    if self.domain and not '@' in result:
      result = '%s@%s' % (name, self.domain)
    if not '@' in result:
      log.msg('Invalid blame email address "%s"' % result)
      return None
    if self.permitted_domains:
      for p in self.permitted_domains:
        if result.endswith(p):
          return result
      return None
    return result

# Based on django.utils.html.escapejs from the Django project
def EscapeJs(t):
  """Replaces javascript special characters in the supplied string.

  Characters are replaced with a textual representation of their integer
  ordinal."""
  js_escapes = {
    '\\': '\\u005C',
    '\'': '\\u0027',
    '"': '\\u0022',
    '>': '\\u003E',
    '<': '\\u003C',
    '&': '\\u0026',
    '=': '\\u003D',
    '-': '\\u002D',
    ';': '\\u003B',
    u'\u2028': '\\u2028',
    u'\u2029': '\\u2029',
  }
  for k, v in js_escapes.items():
    t = t.replace(k, v)
  return t

def CreateWebStatus(port, templates=None, tagComparator=None,
                    customEndpoints=None, console_repo_filter=None,
                    console_builder_filter=None, web_template_globals=None,
                    **kwargs):
  webstatus = WebStatus(port, **kwargs)
  webstatus.templates.filters.update({"escapejs": EscapeJs})
  if templates:
    # Manipulate the search path for jinja templates
    # pylint: disable=F0401
    import jinja2
    # pylint: disable=E1101
    old_loaders = webstatus.templates.loader.loaders
    # pylint: disable=E1101
    new_loaders = old_loaders[:1]
    new_loaders.extend([jinja2.FileSystemLoader(x) for x in templates])
    new_loaders.extend(old_loaders[1:])
    webstatus.templates.loader.loaders = new_loaders
  chromium_status.SetupChromiumPages(
      webstatus, tagComparator, customEndpoints,
      console_repo_filter=console_repo_filter,
      console_builder_filter=console_builder_filter)
  if web_template_globals:
    webstatus.templates.globals.update(web_template_globals)
  return webstatus


def GetMastername():
  # Get the master name from the directory name. Remove leading "master.".
  return re.sub('^master.', '', os.path.basename(os.getcwd()))


class WrongHostException(Exception):
  pass


def AutoSetupMaster(c, active_master, mail_notifier=False,
                    mail_notifier_mode=None,
                    public_html=None, templates=None,
                    order_console_by_time=False,
                    tagComparator=None,
                    customEndpoints=None,
                    enable_http_status_push=False,  # DEPRECATED (NO-OP)
                    console_repo_filter=None,
                    console_builder_filter=None,
                    web_template_globals=None):
  """Add common settings and status services to a master.

  If you wonder what all these mean, PLEASE go check the official doc!
  http://buildbot.net/buildbot/docs/0.7.12/ or
  http://buildbot.net/buildbot/docs/latest/full.html

  - Default number of logs to keep
  - WebStatus and MailNotifier
  - Debug ssh port. Just add a file named .manhole beside master.cfg and
    simply include one line containing 'port = 10101', then you can
    'ssh localhost -p' and you can access your buildbot from the inside."""
  if active_master.in_production and not active_master.is_production_host:
    log.err('ERROR: Trying to start the master on the wrong host.')
    log.err('ERROR: This machine is %s, expected %s.' % (
        active_master.current_host, active_master.master_host))
    raise WrongHostException

  c['slavePortnum'] = active_master.slave_port
  c['projectName'] = active_master.project_name
  c['projectURL'] = config.Master.project_url

  c['properties'] = {'mastername': GetMastername()}
  if 'buildbotURL' in c:
    c['properties']['buildbotURL'] = c['buildbotURL']

  # 'status' is a list of Status Targets. The results of each build will be
  # pushed to these targets. buildbot/status/*.py has a variety to choose from,
  # including web pages, email senders, and IRC bots.
  c.setdefault('status', [])
  if mail_notifier:
    # pylint: disable=E1101
    c['status'].append(mail.MailNotifier(
        fromaddr=active_master.from_address,
        mode=mail_notifier_mode or 'problem',
        relayhost=config.Master.smtp,
        lookup=FilterDomain()))

  # Add in the pubsub pusher, which pushes all status updates to a pubsub
  # topic.  This will not run unless is_production_host is set to True.
  # This will fail on a production host if it cannot find the service
  # account file.
  pubsub_pusher = pubsub_json_status_push.StatusPush.CreateStatusPush(
      activeMaster=active_master)
  if pubsub_pusher:
    c['status'].append(pubsub_pusher)
  else:
    log.msg('Pubsub not enabled.')

  # Enable Chrome Build Extract status push if configured. This requires the
  # configuration file to be defined and valid for this master.
  status_push = None
  try:
    status_push = cbe_json_status_push.StatusPush.load(
        active_master,
        pushInterval=30, # Push every 30 seconds.
    )
  except cbe_json_status_push.ConfigError as e:
    log.err(None, 'Failed to load configuration; not installing CBE status '
            'push: %s' % (e.message,))
  if status_push:
    # A status push configuration was identified.
    c['status'].append(status_push)

  kwargs = {}
  if public_html:
    kwargs['public_html'] = public_html
  kwargs['order_console_by_time'] = order_console_by_time
  # In Buildbot 0.8.4p1, pass provide_feeds as a list to signal what extra
  # services Buildbot should be able to provide over HTTP.
  if buildbot.version == '0.8.4p1':
    kwargs['provide_feeds'] = ['json']
  if active_master.master_port:
    # Actions we want to allow must be explicitly listed here.
    # Deliberately omitted are:
    #   - gracefulShutdown
    #   - cleanShutdown
    authz = Authz(forceBuild=True,
                  forceAllBuilds=True,
                  pingBuilder=True,
                  stopBuild=True,
                  stopAllBuilds=True,
                  cancelPendingBuild=True)
    c['status'].append(CreateWebStatus(
        active_master.master_port,
        tagComparator=tagComparator,
        customEndpoints=customEndpoints,
        authz=authz,
        num_events_max=3000,
        templates=templates,
        console_repo_filter=console_repo_filter,
        console_builder_filter=console_builder_filter,
        web_template_globals=web_template_globals,
        **kwargs))
  if active_master.master_port_alt:
    c['status'].append(CreateWebStatus(
        active_master.master_port_alt,
        tagComparator=tagComparator,
        customEndpoints=customEndpoints,
        num_events_max=3000,
        templates=templates,
        console_repo_filter=console_repo_filter,
        console_builder_filter=console_builder_filter,
        web_template_globals=web_template_globals,
        **kwargs))

  # Add a status logger and a ts_mon flushing receiver.
  c['status'].append(status_logger.StatusEventLogger())
  c['status'].append(monitoring_status_receiver.MonitoringStatusReceiver())

  # Keep last build logs, the default is too low.
  c['buildHorizon'] = 1000
  c['logHorizon'] = 500
  # Must be at least 2x the number of slaves.
  c['eventHorizon'] = 200
  # Tune cache sizes to speed up web UI.
  c['caches'] = {
    'BuildRequests': 1000,
    'Changes': 1000,
    'SourceStamps': 1000,
    'chdicts': 1000,
    'ssdicts': 1000,
  }
  # Must be at least 2x the number of on-going builds.
  c['buildCacheSize'] = 200

  # See http://buildbot.net/buildbot/docs/0.8.1/Debug-Options.html for more
  # details.
  if os.path.isfile('.manhole'):
    try:
      from buildbot import manhole
    except ImportError:
      log.msg('Using manhole has an implicit dependency on Crypto.Cipher. You '
              'need to install it manually:\n'
              '  sudo apt-get install python-crypto\n'
              'on ubuntu or run:\n'
              '  pip install --user pycrypto\n'
              '  pip install --user pyasn1\n')
      raise

    # If 'port' is defined, it uses the same valid keys as the current user.
    values = {}
    execfile('.manhole', values)
    if 'debugPassword' in values:
      c['debugPassword'] = values['debugPassword']
    interface = 'tcp:%s:interface=127.0.0.1' % values.get('port', 0)
    if 'port' in values and 'user' in values and 'password' in values:
      c['manhole'] = manhole.PasswordManhole(interface, values['user'],
                                            values['password'])
    elif 'port' in values:
      c['manhole'] = manhole.AuthorizedKeysManhole(interface,
          os.path.expanduser("~/.ssh/authorized_keys"))

  if active_master.buildbucket_bucket and active_master.service_account_path:
    SetupBuildbucket(c, active_master)

  SetMasterProcessName()


def SetupBuildbucket(c, active_master):
  def params_hook(params, build):
    config_hook = c.get('buildbucket_params_hook')
    if callable(config_hook):
      config_hook(params, build)

    properties = params.setdefault('properties', {})
    properties.pop('requester', None)  # Ignore externally set requester.
    if build['created_by']:
      identity_type, name = build['created_by'].split(':', 1)
      if identity_type == 'user':
        # There other types of identity, such as service, anonymous. We are
        # interested in users only. For users, name is email address.
        if name == CQ_SERVICE_ACCOUNT:
          # Most of systems expect CQ's builds to be requested by
          # 'commit-bot@chromium.org', so replace the service account with it.
          name = 'commit-bot@chromium.org'
        properties['requester'] = name

  buildbucket.setup(
      c,
      active_master,
      buckets=[active_master.buildbucket_bucket],
      build_params_hook=params_hook,
      max_lease_count=buildbucket.NO_LEASE_LIMIT,
      unique_change_urls=getattr(
          active_master, 'buildbucket_unique_change_urls', False),
  )


def DumpSetup(c, important=None, filename='config.current.txt'):
  """Writes a flattened version of the setup to a text file.
     Some interesting classes are exploded with their variables
     exposed,  by default the BuildFactories and Schedulers.
     Newlines and indentation are sprinkled through the representation,
     to make the output more easily broken up and groked with grep or diff.

     Note that the heuristics of how to find classes that you want expanded
     is not too hard to fool, but it seems to handle it usefully for
     normal master configs.

     c         The config: same as the rest of the utilities here.
     important Array of classes to also expand.
     filename  Where to write this ill-defined but useful information.
  """
  from buildbot.schedulers.base import BaseScheduler
  from buildbot.process.factory import BuildFactory

  def hacky_repr(obj, name, indent, important):
    def hacky_repr_class(obj, indent, subdent, important):
      r = '%s {\n' % obj.__class__.__name__
      for (n, v) in vars(obj).iteritems():
        if not n.startswith('_'):
          r += hacky_repr(v, "%s: " % n, indent + subdent, important) + ',\n'
      r += indent + '}'
      return r

    if isinstance(obj, list):
      r = '[' + ', '.join(hacky_repr(o, '', '', important) for o in obj) + ']'
    elif isinstance(obj, tuple):
      r = '(' + ', '.join(hacky_repr(o, '', '', important) for o in obj) + ')'
    else:
      r = repr(obj)
      if not isinstance(obj, basestring):
        r = re.sub(' at 0x[0-9a-fA-F]*>', '>', r)

    subdent = '  '
    if any(isinstance(obj, c) for c in important):
      r = hacky_repr_class(obj, indent, subdent, important)
    elif len(r) > max(30, 76-len(indent)-len(name)) and \
        not isinstance(obj, basestring):
      if isinstance(obj, list):
        r = '[\n'
        for o in obj:
          r += hacky_repr(o, '', indent + subdent, important) + ',\n'
        r += indent + ']'
      elif isinstance(obj, tuple):
        r = '(\n'
        for o in obj:
          r += hacky_repr(o, '', indent + subdent, important) + ',\n'
        r += indent + ')'
      elif isinstance(obj, dict):
        r = '{\n'
        for (n, v) in sorted(obj.iteritems(), key=lambda x: x[0]):
          if not n.startswith('_'):
            r += hacky_repr(v, "'%s': " % n, indent + subdent, important)
            r += ',\n'
        r += indent + '}'
    return "%s%s%s" % (indent, name, r)

  important = (important or []) + [BaseScheduler, BuildFactory]

  with open(filename, 'w') as f:
    print >> f, hacky_repr(c, 'config = ', '', important)


def Partition(item_tuples, num_partitions):
  """Divides |item_tuples| into |num_partitions| separate lists.

  Perfect partitioning is NP hard, this is a "good enough" estimate.

  Args:
    item_tuples: tuple in the format (weight, item_name).
    num_partitions: int number of partitions to generate.

  Returns:
    A list of lists of item_names with as close to equal weight as possible.
  """
  assert num_partitions > 0, 'Must pass a positive number of partitions'
  assert len(item_tuples) >= num_partitions, 'Need more items than partitions'
  partitions = [[] for _ in xrange(num_partitions)]
  def GetLowestSumPartition():
    return sorted(partitions, key=lambda x: sum([i[0] for i in x]))[0]
  for item in sorted(item_tuples, reverse=True):
    GetLowestSumPartition().append(item)
  return sorted([sorted([name for _, name in p]) for p in partitions])


class ConditionalProperty(util.ComparableMixin):
  """A IRenderable that chooses between IRenderable options given a condition.

  A typical 'WithProperties' will be rendered as a string and included as an
  argument. If it's an empty string, it will become a position argment, "".

  This property wraps two IRenderables (which can be 'WithProperties' instances)
  and chooses between them based on a condition. This allows the full exclusion
  and tailoring of property output.

  For example, to optionally add a parameter, one can use the following recipe:
  args.append(
      ConditionalProperty(
          'author_name',
          WithProperties('--author-name=%(author_name)s'),
          [],
      )
  )

  In this example, if 'author_name' is defined as a property, the first
  IRenderable (WithProperties) will be rendered and the '--author-name' argument
  will be inclided. Otherwise, the second will be rendered. Since 'step'
  flattens the command list, returning '[]' will result in the argument being
  completely omitted.

  If a more complex condition is required, a callable function may be used
  as the 'prop' argument. In this case, the function will be passed a single
  parameter, the build object, and is expected to return True if the 'present'
  IRenderable should be used and 'False' if the 'absent' one should be used.
  """
  implements(IRenderable)
  compare_attrs = ('prop', 'present', 'absent')

  def __init__(self, condition, present, absent):
    if not callable(condition):
      self.prop = condition
      condition = lambda build: (self.prop in build.getProperties())
    else:
      self.prop = None
    self.condition = condition
    self.present = present
    self.absent = absent

  def getRenderingFor(self, build):
    # Test whether we're going to render
    is_present = self.condition(build)

    # Choose our inner IRenderer and render it
    renderer = (self.present) if is_present else (self.absent)
    # Disable 'too many positional arguments' error | pylint: disable=E1121
    return IRenderable(renderer).getRenderingFor(build)


class PreferredBuilderNextSlaveFunc(object):
  """
  This object, when used as a Builder's 'nextSlave' function, will choose
  a slave builder whose 'preferred_builder' value is the same as the builder
  name. If there is no such a builder, a builder is randomly chosen.
  """

  def __call__(self, builder, slave_builders):
    if not slave_builders:
      return None

    preferred_slaves = [
        s for s in slave_builders
        if s.slave.properties.getProperty('preferred_builder') == builder.name]
    return random.choice(preferred_slaves or slave_builders)


class PreferredBuilderNextSlaveFuncNG(object):
  """
  This object, when used as a Builder's 'nextSlave' function, will choose
  a slave whose 'preferred_builder' value is the same as the builder
  name. If there is no such slave, a slave is randomly chosen that doesn't
  prefer any builder. If there is no such slave, a slave is randomly
  chosen with preference on slaves whose preferred builder has largest
  currently available capacity. If several sets of slaves have equally large
  capacity, a set is chosen arbitrarily dependent on internal dictionary order.
  """

  def __init__(self, choice=random.choice):
    # Allow overriding the choice function for testability.
    self._choice = choice

  def __call__(self, builder, slave_builders):
    if not slave_builders:
      return None

    prefs = collections.Counter(
        s.slave.properties.getProperty('preferred_builder')
        for s in slave_builders)
    if builder.name in prefs:
       # First choice: Slaves that prefer this builder.
      key = builder.name
    elif None in prefs:
      # Second choice: Slaves that don't prefer any builders.
      key = None
    else:
      # Third choice: Slaves that prefer other builders but have largest
      # capacity left. If several groups of slaves with equal capacity exist,
      # one group will be chosen arbitrarily, the actual slave will be chosen
      # randomly.
      key = prefs.most_common()[0][0]
    result = self._choice(
        [s for s in slave_builders
         if s.slave.properties.getProperty('preferred_builder') == key])

    log.msg('Assigning slave to %s. Preferred: %s. Chose %s.' % (
        builder.name,
        [s.slave.properties.getProperty('preferred_builder')
         for s in slave_builders],
        result))

    return result


def SetMasterProcessName():
  """Sets the name of this process to the name of the master.  Linux only."""

  if sys.platform != 'linux2':
    return

  command_line.set_command_line("master: %s" % GetMastername())