Open Source Monorail

appengine/monorail/framework/framework_helpers.py

+# Copyright 2016 The Chromium Authors. All rights reserved.
+# Use of this source code is govered by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Helper functions and classes used throughout Monorail."""
+
+import logging
+import random
+import string
+import textwrap
+import threading
+import time
+import traceback
+import urllib
+import urlparse
+
+from google.appengine.api import app_identity
+
+from third_party import ezt
+
+import settings
+from framework import actionlimit
+from framework import framework_constants
+from framework import template_helpers
+from framework import timestr
+from framework import urls
+from services import client_config_svc
+
+
+# For random key generation
+RANDOM_KEY_LENGTH = 128
+RANDOM_KEY_CHARACTERS = string.ascii_letters + string.digits
+
+# params recognized by FormatURL, in the order they will appear in the url
+RECOGNIZED_PARAMS = ['can', 'start', 'num', 'q', 'colspec', 'groupby', 'sort',
+                     'show', 'format', 'me', 'table_title', 'projects']
+
+
+def retry(tries, delay=1, backoff=2):
+  """A retry decorator with exponential backoff.
+
+  Functions are retried when Exceptions occur.
+
+  Args:
+    tries: int Number of times to retry, set to 0 to disable retry.
+    delay: float Initial sleep time in seconds.
+    backoff: float Must be greater than 1, further failures would sleep
+             delay*=backoff seconds.
+  """
+  if backoff <= 1:
+    raise ValueError("backoff must be greater than 1")
+  if tries < 0:
+    raise ValueError("tries must be 0 or greater")
+  if delay <= 0:
+    raise ValueError("delay must be greater than 0")
+
+  def decorator(func):
+    def wrapper(*args, **kwargs):
+      _tries, _delay = tries, delay
+      _tries += 1  # Ensure we call func at least once.
+      while _tries > 0:
+        try:
+          ret = func(*args, **kwargs)
+          return ret
+        except Exception:
+          _tries -= 1
+          if _tries == 0:
+            logging.error('Exceeded maximum number of retries for %s.',
+                          func.__name__)
+            raise
+          trace_str = traceback.format_exc()
+          logging.warning('Retrying %s due to Exception: %s',
+                          func.__name__, trace_str)
+          time.sleep(_delay)
+          _delay *= backoff  # Wait longer the next time we fail.
+    return wrapper
+  return decorator
+
+
+class PromiseCallback(object):
+  """Executes the work of a Promise and then dereferences everything."""
+
+  def __init__(self, promise, callback, *args, **kwargs):
+    self.promise = promise
+    self.callback = callback
+    self.args = args
+    self.kwargs = kwargs
+
+  def __call__(self):
+    try:
+      self.promise._WorkOnPromise(self.callback, *self.args, **self.kwargs)
+    finally:
+      # Make sure we no longer hold onto references to anything.
+      self.promise = self.callback = self.args = self.kwargs = None
+
+
+class Promise(object):
+  """Class for promises to deliver a value in the future.
+
+  A thread is started to run callback(args), that thread
+  should return the value that it generates, or raise an expception.
+  p.WaitAndGetValue() will block until a value is available.
+  If an exception was raised, p.WaitAndGetValue() will re-raise the
+  same exception.
+  """
+
+  def __init__(self, callback, *args, **kwargs):
+    """Initialize the promise and immediately call the supplied function.
+
+    Args:
+      callback: Function that takes the args and returns the promise value.
+      *args:  Any arguments to the target function.
+      **kwargs: Any keyword args for the target function.
+    """
+
+    self.has_value = False
+    self.value = None
+    self.event = threading.Event()
+    self.exception = None
+
+    promise_callback = PromiseCallback(self, callback, *args, **kwargs)
+
+    # Execute the callback in another thread.
+    promise_thread = threading.Thread(target=promise_callback)
+    promise_thread.start()
+
+  def _WorkOnPromise(self, callback, *args, **kwargs):
+    """Run callback to compute the promised value.  Save any exceptions."""
+    try:
+      self.value = callback(*args, **kwargs)
+    except Exception as e:
+      trace_str = traceback.format_exc()
+      logging.info('Exception while working on promise: %s\n', trace_str)
+      # Add the stack trace at this point to the exception.  That way, in the
+      # logs, we can see what happened further up in the call stack
+      # than WaitAndGetValue(), which re-raises exceptions.
+      e.pre_promise_trace = trace_str
+      self.exception = e
+    finally:
+      self.has_value = True
+      self.event.set()
+
+  def WaitAndGetValue(self):
+    """Block until my value is available, then return it or raise exception."""
+    self.event.wait()
+    if self.exception:
+      raise self.exception  # pylint: disable=raising-bad-type
+    return self.value
+
+
+def FormatAbsoluteURLForDomain(
+    host, project_name, servlet_name, scheme='https', **kwargs):
+  """A variant of FormatAbsoluteURL for when request objects are not available.
+
+  Args:
+    host: string with hostname and optional port, e.g. 'localhost:8080'.
+    project_name: the destination project name, if any.
+    servlet_name: site or project-local url fragement of dest page.
+    scheme: url scheme, e.g., 'http' or 'https'.
+    **kwargs: additional query string parameters may be specified as named
+      arguments to this function.
+
+  Returns:
+    A full url beginning with 'http[s]://'.
+  """
+  path_and_args = FormatURL(None, servlet_name, **kwargs)
+
+  if host:
+    domain_port = host.split(':')
+    domain_port[0] = GetPreferredDomain(domain_port[0])
+    host = ':'.join(domain_port)
+
+  absolute_domain_url = '%s://%s' % (scheme, host)
+  if project_name:
+    return '%s/p/%s%s' % (absolute_domain_url, project_name, path_and_args)
+  return absolute_domain_url + path_and_args
+
+
+def FormatAbsoluteURL(
+    mr, servlet_name, include_project=True, project_name=None,
+    scheme=None, copy_params=True, **kwargs):
+  """Return an absolute URL to a servlet with old and new params.
+
+  Args:
+    mr: info parsed from the current request.
+    servlet_name: site or project-local url fragement of dest page.
+    include_project: if True, include the project home url as part of the
+      destination URL (as long as it is specified either in mr
+      or as the project_name param.)
+    project_name: the destination project name, to override
+      mr.project_name if include_project is True.
+    scheme: either 'http' or 'https', to override mr.request.scheme.
+    copy_params: if True, copy well-known parameters from the existing request.
+    **kwargs: additional query string parameters may be specified as named
+      arguments to this function.
+
+  Returns:
+    A full url beginning with 'http[s]://'.  The destination URL will be in
+    the same domain as the current request.
+  """
+  path_and_args = FormatURL(
+      mr if copy_params else None, servlet_name, **kwargs)
+  scheme = scheme or mr.request.scheme
+
+  project_base = ''
+  if include_project:
+    project_base = '/p/%s' % (project_name or mr.project_name)
+
+  return '%s://%s%s%s' % (scheme, mr.request.host, project_base, path_and_args)
+
+
+def FormatMovedProjectURL(mr, moved_to):
+  """Return a transformation of the given url into the given project.
+
+  Args:
+    mr: common information parsed from the HTTP request.
+    moved_to: A string from a project's moved_to field that matches
+      framework_bizobj.RE_PROJECT_NAME.
+
+  Returns:
+    The url transposed into the given destination project.
+  """
+  project_name = moved_to
+  _, _, path, parameters, query, fragment_identifier = urlparse.urlparse(
+      mr.current_page_url)
+  # Strip off leading "/p/<moved from project>"
+  path = '/' + path.split('/', 3)[3]
+  rest_of_url = urlparse.urlunparse(
+    ('', '', path, parameters, query, fragment_identifier))
+  return '/p/%s%s' % (project_name, rest_of_url)
+
+
+def FormatURL(mr, servlet_path, **kwargs):
+  """Return a project relative URL to a servlet with old and new params."""
+  # Standard params not overridden in **kwargs come first, followed by kwargs.
+  # The exception is the 'id' param. If present then the 'id' param always comes
+  # first. See bugs.chromium.org/p/monorail/issues/detail?id=374
+  all_params = []
+  if kwargs.get('id'):
+    all_params.append(('id', kwargs['id']))
+  if mr:
+    all_params.extend(
+        (name, mr.GetParam(name)) for name in RECOGNIZED_PARAMS
+        if name not in kwargs)
+
+  all_params.extend(
+      # Ignore the 'id' param since we already added it above.
+      sorted([kwarg for kwarg in kwargs.items() if kwarg[0] != 'id']))
+  return _FormatQueryString(servlet_path, all_params)
+
+
+def _FormatQueryString(url, params):
+  """URLencode a list of parameters and attach them to the end of a URL."""
+  param_string = '&'.join(
+      '%s=%s' % (name, urllib.quote(unicode(value).encode('utf-8')))
+      for name, value in params if value is not None)
+  if not param_string:
+    qs_start_char = ''
+  elif '?' in url:
+    qs_start_char = '&'
+  else:
+    qs_start_char = '?'
+  return '%s%s%s' % (url, qs_start_char, param_string)
+
+
+def WordWrapSuperLongLines(s, max_cols=100):
+  """Reformat input that was not word-wrapped by the browser.
+
+  Args:
+    s: the string to be word-wrapped, it may have embedded newlines.
+    max_cols: int maximum line length.
+
+  Returns:
+    Wrapped text string.
+
+  Rather than wrap the whole thing, we only wrap super-long lines and keep
+  all the reasonable lines formated as-is.
+  """
+  lines = [textwrap.fill(line, max_cols) for line in s.splitlines()]
+  wrapped_text = '\n'.join(lines)
+
+  # The split/join logic above can lose one final blank line.
+  if s.endswith('\n') or s.endswith('\r'):
+    wrapped_text += '\n'
+
+  return wrapped_text
+
+
+def StaticCacheHeaders():
+  """Returns HTTP headers for static content, based on the current time."""
+  year_from_now = int(time.time()) + framework_constants.SECS_PER_YEAR
+  headers = [
+      ('Cache-Control',
+       'max-age=%d, private' % framework_constants.SECS_PER_YEAR),
+      ('Last-Modified', timestr.TimeForHTMLHeader()),
+      ('Expires', timestr.TimeForHTMLHeader(when=year_from_now)),
+  ]
+  logging.info('static headers are %r', headers)
+  return headers
+
+
+def ComputeListDeltas(old_list, new_list):
+  """Given an old and new list, return the items added and removed.
+
+  Args:
+    old_list: old list of values for comparison.
+    new_list: new list of values for comparison.
+
+  Returns:
+    Two lists: one with all the values added (in new_list but was not
+    in old_list), and one with all the values removed (not in new_list
+    but was in old_lit).
+  """
+  if old_list == new_list:
+    return [], []  # A common case: nothing was added or removed.
+
+  added = set(new_list)
+  added.difference_update(old_list)
+  removed = set(old_list)
+  removed.difference_update(new_list)
+  return list(added), list(removed)
+
+
+def GetRoleName(effective_ids, project):
+  """Determines the name of the role a member has for a given project.
+
+  Args:
+    effective_ids: set of user IDs to get the role name for.
+    project: Project PB containing the different the different member lists.
+
+  Returns:
+    The name of the role.
+  """
+  if not effective_ids.isdisjoint(project.owner_ids):
+    return 'Owner'
+  if not effective_ids.isdisjoint(project.committer_ids):
+    return 'Committer'
+  if not effective_ids.isdisjoint(project.contributor_ids):
+    return 'Contributor'
+  return None
+
+
+class UserSettings(object):
+  """Abstract class providing static methods for user settings forms."""
+
+  @classmethod
+  def GatherUnifiedSettingsPageData(
+      cls, logged_in_user_id, settings_user_view, settings_user):
+    """Gather EZT variables needed for the unified user settings form.
+
+    Args:
+      logged_in_user_id: The user ID of the acting user.
+      settings_user_view: The UserView of the target user.
+      settings_user: The User PB of the target user.
+
+    Returns:
+      A dictionary giving the names and values of all the variables to
+      be exported to EZT to support the unified user settings form template.
+    """
+
+    def ActionLastReset(action_limit):
+      """Return a formatted time string for the last action limit reset."""
+      if action_limit:
+        return time.asctime(time.localtime(action_limit.reset_timestamp))
+      return 'Never'
+
+    def DefaultLifetimeLimit(action_type):
+      """Return the deault lifetime limit for the give type of action."""
+      return actionlimit.ACTION_LIMITS[action_type][3]
+
+    def DefaultPeriodSoftLimit(action_type):
+      """Return the deault period soft limit for the give type of action."""
+      return actionlimit.ACTION_LIMITS[action_type][1]
+
+    def DefaultPeriodHardLimit(action_type):
+      """Return the deault period jard limit for the give type of action."""
+      return actionlimit.ACTION_LIMITS[action_type][2]
+
+    project_creation_lifetime_limit = (
+        (settings_user.project_creation_limit and
+         settings_user.project_creation_limit.lifetime_limit) or
+        DefaultLifetimeLimit(actionlimit.PROJECT_CREATION))
+    project_creation_soft_limit = (
+        (settings_user.project_creation_limit and
+         settings_user.project_creation_limit.period_soft_limit) or
+        DefaultPeriodSoftLimit(actionlimit.PROJECT_CREATION))
+    project_creation_hard_limit = (
+        (settings_user.project_creation_limit and
+         settings_user.project_creation_limit.period_hard_limit) or
+        DefaultPeriodHardLimit(actionlimit.PROJECT_CREATION))
+    issue_comment_lifetime_limit = (
+        (settings_user.issue_comment_limit and
+         settings_user.issue_comment_limit.lifetime_limit) or
+        DefaultLifetimeLimit(actionlimit.ISSUE_COMMENT))
+    issue_comment_soft_limit = (
+        (settings_user.issue_comment_limit and
+         settings_user.issue_comment_limit.period_soft_limit) or
+        DefaultPeriodSoftLimit(actionlimit.ISSUE_COMMENT))
+    issue_comment_hard_limit = (
+        (settings_user.issue_comment_limit and
+         settings_user.issue_comment_limit.period_hard_limit) or
+        DefaultPeriodHardLimit(actionlimit.ISSUE_COMMENT ))
+    issue_attachment_lifetime_limit = (
+        (settings_user.issue_attachment_limit and
+         settings_user.issue_attachment_limit.lifetime_limit) or
+        DefaultLifetimeLimit(actionlimit.ISSUE_ATTACHMENT))
+    issue_attachment_soft_limit = (
+        (settings_user.issue_attachment_limit and
+         settings_user.issue_attachment_limit.period_soft_limit) or
+        DefaultPeriodSoftLimit(actionlimit.ISSUE_ATTACHMENT))
+    issue_attachment_hard_limit = (
+        (settings_user.issue_attachment_limit and
+         settings_user.issue_attachment_limit.period_hard_limit) or
+        DefaultPeriodHardLimit(actionlimit.ISSUE_ATTACHMENT))
+    issue_bulk_edit_lifetime_limit = (
+        (settings_user.issue_bulk_edit_limit and
+         settings_user.issue_bulk_edit_limit.lifetime_limit) or
+        DefaultLifetimeLimit(actionlimit.ISSUE_BULK_EDIT))
+    issue_bulk_edit_soft_limit = (
+        (settings_user.issue_bulk_edit_limit and
+         settings_user.issue_bulk_edit_limit.period_soft_limit) or
+        DefaultPeriodSoftLimit(actionlimit.ISSUE_BULK_EDIT))
+    issue_bulk_edit_hard_limit = (
+        (settings_user.issue_bulk_edit_limit and
+         settings_user.issue_bulk_edit_limit.period_hard_limit) or
+        DefaultPeriodHardLimit(actionlimit.ISSUE_BULK_EDIT))
+    api_request_lifetime_limit = (
+        (settings_user.api_request_limit and
+         settings_user.api_request_limit.lifetime_limit) or
+        DefaultLifetimeLimit(actionlimit.API_REQUEST))
+    api_request_soft_limit = (
+        (settings_user.api_request_limit and
+         settings_user.api_request_limit.period_soft_limit) or
+        DefaultPeriodSoftLimit(actionlimit.API_REQUEST))
+    api_request_hard_limit = (
+        (settings_user.api_request_limit and
+         settings_user.api_request_limit.period_hard_limit) or
+        DefaultPeriodHardLimit(actionlimit.API_REQUEST))
+
+    return {
+        'settings_user': settings_user_view,
+        'settings_user_pb': template_helpers.PBProxy(settings_user),
+        'settings_user_is_banned': ezt.boolean(settings_user.banned),
+        'settings_user_ignore_action_limits': (
+            ezt.boolean(settings_user.ignore_action_limits)),
+        'self': ezt.boolean(logged_in_user_id == settings_user_view.user_id),
+        'project_creation_reset': (
+            ActionLastReset(settings_user.project_creation_limit)),
+        'issue_comment_reset': (
+            ActionLastReset(settings_user.issue_comment_limit)),
+        'issue_attachment_reset': (
+            ActionLastReset(settings_user.issue_attachment_limit)),
+        'issue_bulk_edit_reset': (
+            ActionLastReset(settings_user.issue_bulk_edit_limit)),
+        'api_request_reset': (
+            ActionLastReset(settings_user.api_request_limit)),
+        'project_creation_lifetime_limit': project_creation_lifetime_limit,
+        'project_creation_soft_limit': project_creation_soft_limit,
+        'project_creation_hard_limit': project_creation_hard_limit,
+        'issue_comment_lifetime_limit': issue_comment_lifetime_limit,
+        'issue_comment_soft_limit': issue_comment_soft_limit,
+        'issue_comment_hard_limit': issue_comment_hard_limit,
+        'issue_attachment_lifetime_limit': issue_attachment_lifetime_limit,
+        'issue_attachment_soft_limit': issue_attachment_soft_limit,
+        'issue_attachment_hard_limit': issue_attachment_hard_limit,
+        'issue_bulk_edit_lifetime_limit': issue_bulk_edit_lifetime_limit,
+        'issue_bulk_edit_soft_limit': issue_bulk_edit_soft_limit,
+        'issue_bulk_edit_hard_limit': issue_bulk_edit_hard_limit,
+        'api_request_lifetime_limit': api_request_lifetime_limit,
+        'api_request_soft_limit': api_request_soft_limit,
+        'api_request_hard_limit': api_request_hard_limit,
+        'profile_url_fragment': (
+            settings_user_view.profile_url[len('/u/'):]),
+        'preview_on_hover': ezt.boolean(settings_user.preview_on_hover),
+        }
+
+  @classmethod
+  def ProcessSettingsForm(
+      cls, cnxn, user_service, post_data, user_id, user, admin=False):
+    """Process the posted form data from the unified user settings form.
+
+    Args:
+      cnxn: connection to the SQL database.
+      user_service: An instance of UserService for saving changes.
+      post_data: The parsed post data from the form submission request.
+      user_id: The user id of the target user.
+      user: The user PB of the target user.
+      admin: Whether settings reserved for admins are supported.
+    """
+    obscure_email = 'obscure_email' in post_data
+
+    kwargs = {}
+    if admin:
+      kwargs.update(is_site_admin='site_admin' in post_data,
+                    ignore_action_limits='ignore_action_limits' in post_data)
+      kwargs.update(is_banned='banned' in post_data,
+                    banned_reason=post_data.get('banned_reason', ''))
+
+      # action limits
+      action_limit_updates = {}
+      for action_name in actionlimit.ACTION_TYPE_NAMES.iterkeys():
+        reset_input = 'reset_' + action_name
+        lifetime_input = action_name + '_lifetime_limit'
+        soft_input = action_name + '_soft_limit'
+        hard_input = action_name + '_hard_limit'
+        pb_getter = action_name + '_limit'
+        old_lifetime_limit = getattr(user, pb_getter).lifetime_limit
+        old_soft_limit = getattr(user, pb_getter).period_soft_limit
+        old_hard_limit = getattr(user, pb_getter).period_hard_limit
+
+        # Try and get the new limit from post data.
+        # If the user doesn't use an integer, act as if no change requested.
+        def _GetLimit(post_data, limit_input, old_limit):
+          try:
+            new_limit = int(post_data[limit_input])
+          except (KeyError, ValueError):
+            new_limit = old_limit
+          return new_limit
+
+        new_lifetime_limit = _GetLimit(post_data, lifetime_input,
+            old_lifetime_limit)
+        new_soft_limit = _GetLimit(post_data, soft_input,
+            old_soft_limit)
+        new_hard_limit = _GetLimit(post_data, hard_input,
+            old_hard_limit)
+
+        if ((new_lifetime_limit >= 0 and
+             new_lifetime_limit != old_lifetime_limit) or
+            (new_soft_limit >= 0 and new_soft_limit != old_soft_limit) or
+            (new_hard_limit >= 0 and new_hard_limit != old_hard_limit)):
+          action_limit_updates[action_name] = (
+              new_soft_limit, new_hard_limit, new_lifetime_limit)
+        elif reset_input in post_data:
+          action_limit_updates[action_name] = None
+      kwargs.update(action_limit_updates=action_limit_updates)
+
+    user_service.UpdateUserSettings(
+        cnxn, user_id, user, notify='notify' in post_data,
+        notify_starred='notify_starred' in post_data,
+        preview_on_hover='preview_on_hover' in post_data,
+        obscure_email=obscure_email, **kwargs)
+
+
+def GetHostPort():
+  """Get string domain name and port number."""
+
+  app_id = app_identity.get_application_id()
+  if ':' in app_id:
+    domain, app_id = app_id.split(':')
+  else:
+    domain = ''
+
+  if domain.startswith('google'):
+    hostport = '%s.googleplex.com' % app_id
+  else:
+    hostport = '%s.appspot.com' % app_id
+
+  return GetPreferredDomain(hostport)
+
+
+def IssueCommentURL(hostport, project, local_id, seq_num=None):
+  """Return a URL pointing directly to the specified comment."""
+  detail_url = FormatAbsoluteURLForDomain(
+      hostport, project.project_name, urls.ISSUE_DETAIL, id=local_id)
+  if seq_num:
+    detail_url += '#c%d' % seq_num
+
+  return detail_url
+
+
+def MurmurHash3_x86_32(key, seed=0x0):
+  """Implements the x86/32-bit version of Murmur Hash 3.0.
+
+  MurmurHash3 is written by Austin Appleby, and is placed in the public
+  domain. See https://code.google.com/p/smhasher/ for details.
+
+  This pure python implementation of the x86/32 bit version of MurmurHash3 is
+  written by Fredrik Kihlander and also placed in the public domain.
+  See https://github.com/wc-duck/pymmh3 for details.
+
+  The MurmurHash3 algorithm is chosen for these reasons:
+  * It is fast, even when implemented in pure python.
+  * It is remarkably well distributed, and unlikely to cause collisions.
+  * It is stable and unchanging (any improvements will be in MurmurHash4).
+  * It is well-tested, and easily usable in other contexts (such as bulk
+    data imports).
+
+  Args:
+    key (string): the data that you want hashed
+    seed (int): An offset, treated as essentially part of the key.
+
+  Returns:
+    A 32-bit integer (can be interpreted as either signed or unsigned).
+  """
+  key = bytearray(key.encode('utf-8'))
+
+  def fmix(h):
+    h ^= h >> 16
+    h  = (h * 0x85ebca6b) & 0xFFFFFFFF
+    h ^= h >> 13
+    h  = (h * 0xc2b2ae35) & 0xFFFFFFFF
+    h ^= h >> 16
+    return h;
+
+  length = len(key)
+  nblocks = int(length / 4)
+
+  h1 = seed;
+
+  c1 = 0xcc9e2d51
+  c2 = 0x1b873593
+
+  # body
+  for block_start in xrange(0, nblocks * 4, 4):
+    k1 = key[ block_start + 3 ] << 24 | \
+         key[ block_start + 2 ] << 16 | \
+         key[ block_start + 1 ] <<  8 | \
+         key[ block_start + 0 ]
+
+    k1 = c1 * k1 & 0xFFFFFFFF
+    k1 = (k1 << 15 | k1 >> 17) & 0xFFFFFFFF
+    k1 = (c2 * k1) & 0xFFFFFFFF;
+
+    h1 ^= k1
+    h1  = ( h1 << 13 | h1 >> 19 ) & 0xFFFFFFFF
+    h1  = ( h1 * 5 + 0xe6546b64 ) & 0xFFFFFFFF
+
+  # tail
+  tail_index = nblocks * 4
+  k1 = 0
+  tail_size = length & 3
+
+  if tail_size >= 3:
+    k1 ^= key[ tail_index + 2 ] << 16
+  if tail_size >= 2:
+    k1 ^= key[ tail_index + 1 ] << 8
+  if tail_size >= 1:
+    k1 ^= key[ tail_index + 0 ]
+
+  if tail_size != 0:
+    k1  = ( k1 * c1 ) & 0xFFFFFFFF
+    k1  = ( k1 << 15 | k1 >> 17 ) & 0xFFFFFFFF
+    k1  = ( k1 * c2 ) & 0xFFFFFFFF
+    h1 ^= k1
+
+  return fmix( h1 ^ length )
+
+
+def MakeRandomKey(length=RANDOM_KEY_LENGTH, chars=RANDOM_KEY_CHARACTERS):
+  """Return a string with lots of random characters."""
+  chars = [random.choice(chars) for _ in range(length)]
+  return ''.join(chars)
+
+
+def IsServiceAccount(email):
+  """Return a boolean value whether this email is a service account."""
+  if email.endswith('gserviceaccount.com'):
+    return True
+  _, client_emails = (
+      client_config_svc.GetClientConfigSvc().GetClientIDEmails())
+  return email in client_emails
+
+
+def GetPreferredDomain(domain):
+  """Get preferred domain to display.
+
+  The preferred domain replaces app_id for default version of monorail-prod
+  and monorail-staging.
+  """
+  return settings.preferred_domains.get(domain, domain)