Updating App Remoting build files to include an OAuth2 client ID and manifest key which we will set…

remoting/webapp/build-webapp.py

 #!/usr/bin/env python
 # 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.
 
 """Creates a directory with with the unpacked contents of the remoting webapp.
 
 The directory will contain a copy-of or a link-to to all remoting webapp
 resources.  This includes HTML/JS and any plugin binaries. The script also
 massages resulting files appropriately with host plugin data. Finally,
@@ skipping 89 matching lines @@
   sys.path.append(os.path.split(jinja2_path)[0])
   import jinja2
   (template_path, template_name) = os.path.split(input_file)
   include_paths = [template_path] + include_paths
   env = jinja2.Environment(loader=jinja2.FileSystemLoader(include_paths))
   template = env.get_template(template_name)
   rendered = template.render(context)
   io.open(output_file, 'w', encoding='utf-8').write(rendered)
 
 def buildWebApp(buildtype, version, destination, zip_path,
-                manifest_template, webapp_type, appid, app_name,
-                app_description, app_capabilities, files, locales_listfile,
-                jinja_paths, service_environment, use_gcd):
+                manifest_template, webapp_type, appid, app_client_id, app_name,
+                app_description, app_capabilities, manifest_key, files,
+                locales_listfile, jinja_paths, service_environment, use_gcd):
   """Does the main work of building the webapp directory and zipfile.
 
   Args:
     buildtype: the type of build ("Official", "Release" or "Dev").
     destination: A string with path to directory where the webapp will be
                  written.
     zipfile: A string with path to the zipfile to create containing the
              contents of |destination|.
     manifest_template: jinja2 template file for manifest.
     webapp_type: webapp type ("v1", "v2", "v2_pnacl" or "app_remoting").
     appid: A string with the Remoting Application Id (only used for app
              remoting webapps). If supplied, it defaults to using the
              test API server.
+    app_client_id: The OAuth2 client ID for the webapp.
     app_name: A string with the name of the application.
     app_description: A string with the description of the application.
     app_capabilities: A set of strings naming the capabilities that should be
                       enabled for this application.
+    manifest_key: The manifest key for the webapp.
     files: An array of strings listing the paths for resources to include
            in this webapp.
     locales_listfile: The name of a file containing a list of locales, one per
              line, which are copied, along with their directory structure, from
              the _locales directory down.
     jinja_paths: An array of paths to search for {%include} directives in
                  addition to the directory containing the manifest template.
-    service_environment: Used to point the webApp to one of the
-                         dev/test/staging/prod environments
+    service_environment: Used to point the webapp to one of the
+                         dev/test/staging/prod/prod-testing environments
     use_gcd: True if GCD support should be enabled.
   """
 
   # Load the locales files from the locales_listfile.
   if not locales_listfile:
     raise Exception('You must specify a locales_listfile')
   locales = []
   with open(locales_listfile) as input:
     for s in input:
       locales.append(s.rstrip())
@@ skipping 56 matching lines @@
                  "'CLIENT_PLUGIN_TYPE'", "'" + client_plugin + "'")
 
   # Allow host names for google services/apis to be overriden via env vars.
   oauth2AccountsHost = os.environ.get(
       'OAUTH2_ACCOUNTS_HOST', 'https://accounts.google.com')
   oauth2ApiHost = os.environ.get(
       'OAUTH2_API_HOST', 'https://www.googleapis.com')
   directoryApiHost = os.environ.get(
       'DIRECTORY_API_HOST', 'https://www.googleapis.com')
 
-  if webapp_type == 'app_remoting':
+  is_app_remoting_webapp = webapp_type == 'app_remoting'
+  is_prod_service_environment = service_environment == 'prod' or \
+                                service_environment == 'prod-testing'
+  if is_app_remoting_webapp:
     appRemotingApiHost = os.environ.get(
         'APP_REMOTING_API_HOST', None)
     appRemotingApplicationId = os.environ.get(
         'APP_REMOTING_APPLICATION_ID', None)
 
     # Release/Official builds are special because they are what we will upload
     # to the web store.  The checks below will validate that prod builds are
     # being generated correctly (no overrides) and with the correct buildtype.
     # They also verify that folks are not accidentally building dev/test/staging
     # apps for release (no impersonation) instead of dev.
-    if service_environment == 'prod' and buildtype == 'Dev':
+    if is_prod_service_environment and buildtype == 'Dev':
       raise Exception("Prod environment cannot be built for 'dev' builds")
 
     if buildtype != 'Dev':
-      if service_environment != 'prod':
+      if not is_prod_service_environment:
         raise Exception('Invalid service_environment targeted for '
                         + buildtype + ': ' + service_environment)
       if 'out/Release' not in destination and 'out\Release' not in destination:
         raise Exception('Prod builds must be placed in the out/Release folder')
       if appid != None:
         raise Exception('Cannot pass in an appid for '
                         + buildtype + ' builds: ' + service_environment)
       if appRemotingApiHost != None:
         raise Exception('Cannot set APP_REMOTING_API_HOST env var for '
                         + buildtype + ' builds')
       if appRemotingApplicationId != None:
         raise Exception('Cannot set APP_REMOTING_APPLICATION_ID env var for '
                         + buildtype + ' builds')
 
     # If an Application ID was set (either from service_environment variable or
     # from a command line argument), hardcode it, otherwise get it at runtime.
     effectiveAppId = appRemotingApplicationId or appid
     if effectiveAppId:
       appRemotingApplicationId = "'" + effectiveAppId + "'"
     else:
       appRemotingApplicationId = "chrome.i18n.getMessage('@@extension_id')"
     findAndReplace(os.path.join(destination, 'plugin_settings.js'),
                    "'APP_REMOTING_APPLICATION_ID'", appRemotingApplicationId)
 
   oauth2BaseUrl = oauth2AccountsHost + '/o/oauth2'
   oauth2ApiBaseUrl = oauth2ApiHost + '/oauth2'
   directoryApiBaseUrl = directoryApiHost + '/chromoting/v1'
 
-  if webapp_type == 'app_remoting':
+  if is_app_remoting_webapp:
     # Set the apiary endpoint and then set the endpoint version
     if not appRemotingApiHost:
-      if service_environment == 'prod':
+      if is_prod_service_environment:
         appRemotingApiHost = 'https://www.googleapis.com'
       else:
         appRemotingApiHost = 'https://www-googleapis-test.sandbox.google.com'
 
     if service_environment == 'dev':
       appRemotingServicePath = '/appremoting/v1beta1_dev'
     elif service_environment == 'test':
       appRemotingServicePath = '/appremoting/v1beta1'
     elif service_environment == 'staging':
       appRemotingServicePath = '/appremoting/v1beta1_staging'
     elif service_environment == 'prod':
       appRemotingServicePath = '/appremoting/v1beta1'
+    elif service_environment == 'prod-testing':
+      appRemotingServicePath = '/appremoting/v1beta1_prod_testing'
     else:
       raise Exception('Unknown service environment: ' + service_environment)
     appRemotingApiBaseUrl = appRemotingApiHost + appRemotingServicePath
   else:
     appRemotingApiBaseUrl = ''
 
   replaceBool(destination, 'USE_GCD', use_gcd)
   replaceString(destination, 'OAUTH2_BASE_URL', oauth2BaseUrl)
   replaceString(destination, 'OAUTH2_API_BASE_URL', oauth2ApiBaseUrl)
   replaceString(destination, 'DIRECTORY_API_BASE_URL', directoryApiBaseUrl)
-  if webapp_type == 'app_remoting':
+  if is_app_remoting_webapp:
     replaceString(destination, 'APP_REMOTING_API_BASE_URL',
                   appRemotingApiBaseUrl)
 
   # Substitute hosts in the manifest's CSP list.
   # Ensure we list the API host only once if it's the same for multiple APIs.
   googleApiHosts = ' '.join(set([oauth2ApiHost, directoryApiHost]))
 
   # WCS and the OAuth trampoline are both hosted on talkgadget. Split them into
   # separate suffix/prefix variables to allow for wildcards in manifest.json.
   talkGadgetHostSuffix = os.environ.get(
@@ skipping 40 matching lines @@
   replaceString(destination, 'DIRECTORY_BOT_JID',
                 os.environ.get('DIRECTORY_BOT_JID',
                                'remoting@bot.talk.google.com'))
   replaceString(destination, 'THIRD_PARTY_AUTH_REDIRECT_URL',
                 thirdPartyAuthUrlJs)
 
   # Set the correct API keys.
   # For overriding the client ID/secret via env vars, see google_api_keys.py.
   apiClientId = google_api_keys.GetClientID('REMOTING')
   apiClientSecret = google_api_keys.GetClientSecret('REMOTING')
-  apiClientIdV2 = google_api_keys.GetClientID('REMOTING_IDENTITY_API')
+
+  if is_app_remoting_webapp and buildtype != 'Dev':
+    if not app_client_id:
+      raise Exception('Invalid app_client_id passed in: "' +
+          app_client_id + '"')
+    apiClientIdV2 = app_client_id
+  else:
+    apiClientIdV2 = google_api_keys.GetClientID('REMOTING_IDENTITY_API')
 
   replaceString(destination, 'API_CLIENT_ID', apiClientId)
   replaceString(destination, 'API_CLIENT_SECRET', apiClientSecret)
 
   # Write the application capabilities.
   appCapabilities = ','.join(
       ['remoting.ClientSession.Capability.' + x for x in app_capabilities])
   findAndReplace(os.path.join(destination, 'app_capabilities.js'),
                  "'APPLICATION_CAPABILITIES'", appCapabilities)
 
   # Use a consistent extension id for dev builds.
   # AppRemoting builds always use the dev app id - the correct app id gets
   # written into the manifest later.
-  if buildtype != 'Official' or webapp_type == 'app_remoting':
+  if is_app_remoting_webapp:
+    if buildtype != 'Dev':
+      if not manifest_key:
+        raise Exception('Invalid manifest_key passed in: "' +
+            manifest_key + '"')
+      manifestKey = '"key": "' + manifest_key + '",'
+    else:
+      manifestKey = '"key": "remotingdevbuild",'
+  elif buildtype != 'Official':
+    # TODO(joedow): Update the chromoting webapp GYP entries to include keys.
     manifestKey = '"key": "remotingdevbuild",'
   else:
     manifestKey = ''
 
   # Generate manifest.
   if manifest_template:
     context = {
         'webapp_type': webapp_type,
         'FULL_APP_VERSION': version,
         'MANIFEST_KEY_FOR_UNOFFICIAL_BUILD': manifestKey,
@@ skipping 34 matching lines @@
   parser.add_argument('destination')
   parser.add_argument('zip_path')
   parser.add_argument('manifest_template')
   parser.add_argument('webapp_type')
   parser.add_argument('files', nargs='*', metavar='file', default=[])
   parser.add_argument('--app_name', metavar='NAME')
   parser.add_argument('--app_description', metavar='TEXT')
   parser.add_argument('--app_capabilities',
                       nargs='*', default=[], metavar='CAPABILITY')
   parser.add_argument('--appid')
+  parser.add_argument('--app_client_id', default='')
+  parser.add_argument('--manifest_key', default='')
   parser.add_argument('--locales_listfile', default='', metavar='PATH')
   parser.add_argument('--jinja_paths', nargs='*', default=[], metavar='PATH')
   parser.add_argument('--service_environment', default='', metavar='ENV')
   parser.add_argument('--use_gcd', choices=['0', '1'], default='0')
 
   args = parser.parse_args()
   args.use_gcd = (args.use_gcd != '0')
   args.app_capabilities = set(args.app_capabilities)
   return buildWebApp(**vars(args))
 
 
 if __name__ == '__main__':
   sys.exit(main())