def main(): """Launches the Schema Conversion Tool.""" bootstrapping.CommandStart(_COMPONENT_ID, component_id=_COMPONENT_ID) bootstrapping.CheckUpdates(_COMPONENT_ID) update_manager.UpdateManager.EnsureInstalledAndRestart([_COMPONENT_ID], command=__file__) try: java_bin = java.RequireJavaInstalled('Schema Conversion Tool', min_version=9) java_9plus = True except java.JavaVersionError: java_bin = java.RequireJavaInstalled('Schema Conversion Tool', min_version=8) java_9plus = False os.environ.setdefault('SCT_UPDATE_CHECK', 'false') jar_name = 'schema_conversion_gui.jar' main_jar = os.path.join(_JAR_DIR, jar_name) # Accept a platform-appropriate default added as 1st arg in sct.sh/sct.cmd. working_dir_default = bootstrapping.GetDecodedArgv()[1] flags = [ '-Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager', '-Dspring.profiles.active=production', '-Dgcloud.component.dir={}'.format(_COMPONENT_DIR), '-Dsct.working.dir.default={}'.format(working_dir_default), '-jar', main_jar, ] if java_9plus: # Open modules to reflection explicitly to avoid Java 9+ warnings. flags = [ '--add-opens', 'java.base/java.io=ALL-UNNAMED', '--add-opens', 'java.base/java.lang=ALL-UNNAMED', '--add-opens', 'java.base/java.net=ALL-UNNAMED', '--add-opens', 'java.rmi/sun.rmi.transport=ALL-UNNAMED', ] + flags bootstrapping.ExecuteJarTool( java_bin, _JAR_DIR, jar_name, None, # No main classname for Springboot JAR. Use -jar flag instead. flags, '--server.address=127.0.0.1')
def testJavaExecutableNotJava7(self): find_exec_mock = self.StartObjectPatch(files, 'FindExecutableOnPath') find_exec_mock.return_value = '/path/to/java' check_out_mock = self.StartObjectPatch(subprocess, 'check_output') check_out_mock.return_value = 'version "not1.7' with self.assertRaises(java.JavaError): java.RequireJavaInstalled('foo') check_out_mock.return_value = 'version "1.6' with self.assertRaises(java.JavaError): java.RequireJavaInstalled('foo')
def testJava7InstalledAndOnPath(self): find_exec_mock = self.StartObjectPatch(files, 'FindExecutableOnPath') find_exec_mock.return_value = '/path/to/java' check_out_mock = self.StartObjectPatch(subprocess, 'check_output') check_out_mock.return_value = 'version "1.7.' try: java.RequireJavaInstalled('foo') except java.JavaError: self.fail('JavaError should not be thrown here') check_out_mock.return_value = 'version "1.8.' self.assertEqual(java.RequireJavaInstalled('foo'), '/path/to/java')
def main(): """Launches the Java dev_appserver 1.""" update_manager.UpdateManager.EnsureInstalledAndRestart(['app-engine-java'], command=__file__) java_bin = java.RequireJavaInstalled('Java local development server') bootstrapping.ExecuteJarTool(java_bin, _JAR_DIR, _JAR_NAME, _CLASSNAME, _FLAGS, *_ARGS)
def Filter(self, context, args): java.RequireJavaInstalled(pubsub_util.PUBSUB_TITLE) util.EnsureComponentIsInstalled('pubsub-emulator', pubsub_util.PUBSUB_TITLE) if not args.data_dir: args.data_dir = pubsub_util.GetDataDir()
def Filter(self, context, args): java.RequireJavaInstalled(datastore_util.DATASTORE_TITLE, min_version=8) util.EnsureComponentIsInstalled('cloud-datastore-emulator', datastore_util.DATASTORE_TITLE) if not args.data_dir: args.data_dir = datastore_util.GetDataDir()
def testJava9InstalledAndOnPath_JustMajorVersion(self): find_exec_mock = self.StartObjectPatch(files, 'FindExecutableOnPath') find_exec_mock.return_value = '/path/to/java' check_out_mock = self.StartObjectPatch(subprocess, 'check_output') check_out_mock.return_value = 'version "9"' self.assertEqual(java.RequireJavaInstalled('foo', min_version=7), '/path/to/java')
def Filter(self, context, args): java.RequireJavaInstalled(datastore_util.DATASTORE_TITLE) if args.legacy: util.EnsureComponentIsInstalled('gcd-emulator', datastore_util.DATASTORE_TITLE) else: util.EnsureComponentIsInstalled('cloud-datastore-emulator', datastore_util.DATASTORE_TITLE) if not args.data_dir: args.data_dir = datastore_util.GetDataDir()
def testJavaExecutableNotExecutable(self): find_exec_mock = self.StartObjectPatch(files, 'FindExecutableOnPath') find_exec_mock.return_value = '/path/to/java' check_out_mock = self.StartObjectPatch(subprocess, 'check_output') called_process_err = subprocess.CalledProcessError(1, 'cmd', 'output') check_out_mock.side_effect = called_process_err with self.assertRaises(java.JavaError): java.RequireJavaInstalled('foo')
def main(): """Launches the Dataflow SQL shell.""" bootstrapping.CommandStart('dataflow-sql', component_id='dataflow-sql') bootstrapping.CheckUpdates('dataflow-sql') update_manager.UpdateManager.EnsureInstalledAndRestart( ['dataflow-sql'], command=__file__) java_bin = java.RequireJavaInstalled('Dataflow SQL') bootstrapping.ExecuteJavaClass( java_bin, jar_dir=_JAR_DIR, main_jar=_MAIN_JAR, main_class=_CLASSNAME, main_args=['-nn', 'DFSQL', '-u', 'jdbc:beam:userAgent=DataflowSQL'])
def LogJavaVersionWarning(self): """Log a warning message notifying users about Java version change. Log the warning when the installed JRE has an earlier version than Java 11. """ try: java.RequireJavaInstalled(firestore_util.FIRESTORE_TITLE, min_version=11) except java.JavaVersionError: log.warning( 'Cloud Firestore Emulator support for Java JRE version 8 will be ' 'dropped after gcloud command-line tool release 392.0.0. Please ' 'upgrade to Java JRE version 11 or higher to continue using the ' 'latest Cloud Firestore Emulator.') except java.JavaError: # A JRE could not be found. Not logging the warning since the user will # not be able to start an emulator anyways. pass
def _JavaStagingMapper(command_path, descriptor, app_dir, staging_dir): """Map a java staging request to the right args. Args: command_path: str, path to the jar tool file. descriptor: str, path to the `appengine-web.xml` app_dir: str, path to the unstaged app directory staging_dir: str, path to the empty staging dir Raises: java.JavaError, if Java is not installed. Returns: [str], args for executable invocation. """ del descriptor # Unused, app_dir is sufficient java_bin = java.RequireJavaInstalled('local staging for java') args = ([java_bin, '-classpath', command_path, _JAVA_APPCFG_ENTRY_POINT] + _JAVA_APPCFG_STAGE_FLAGS + ['stage', app_dir, staging_dir]) return args
def main(): """Launches dev_appserver.py.""" argv = bootstrapping.GetDecodedArgv() runtimes = wrapper_util.GetRuntimes(argv[1:]) options = wrapper_util.ParseDevAppserverFlags(sys.argv[1:]) if options.support_datastore_emulator: java.RequireJavaInstalled(datastore_util.DATASTORE_TITLE, min_version=8) components = wrapper_util.GetComponents(runtimes) components.append('cloud-datastore-emulator') if (platforms.OperatingSystem.Current() == platforms.OperatingSystem.LINUX and 'app-engine-php' in components): components.remove('app-engine-php') update_manager.UpdateManager.EnsureInstalledAndRestart( components, command=__file__) args = [ '--skip_sdk_update_check=True' ] google_analytics_client_id = metrics.GetCIDIfMetricsEnabled() google_analytics_user_agent = metrics.GetUserAgentIfMetricsEnabled() if google_analytics_client_id: args.extend([ '--google_analytics_client_id={}'.format(google_analytics_client_id), '--google_analytics_user_agent={}'.format(google_analytics_user_agent) ]) # Pass the path to cloud datastore emulator to dev_appserver. # realpath is needed in the case where __file__ is a path containing symlinks. sdk_root = os.path.dirname( os.path.dirname(os.path.abspath(os.path.realpath(__file__)))) emulator_dir = os.path.join(sdk_root, 'platform', 'cloud-datastore-emulator') emulator_script = ( 'cloud_datastore_emulator.cmd' if platforms.OperatingSystem.IsWindows() else 'cloud_datastore_emulator') args.append('--datastore_emulator_cmd={}'.format( os.path.join(emulator_dir, emulator_script))) bootstrapping.ExecutePythonTool( os.path.join('platform', 'google_appengine'), 'dev_appserver.py', *args)
def Filter(self, context, args): java.RequireJavaInstalled(firestore_util.FIRESTORE_TITLE, min_version=8) util.EnsureComponentIsInstalled('cloud-firestore-emulator', firestore_util.FIRESTORE_TITLE)
def testJava8Error(self): check_out_mock = self.StartObjectPatch(subprocess, 'check_output') check_out_mock.return_value = 'version "1.7.' with self.assertRaises(java.JavaError): java.RequireJavaInstalled('foo', min_version=8)
def SetUp(self): # Verify that Java is installed or skip these tests with self.SkipTestIfRaises(java.JavaError): java.RequireJavaInstalled('test')
def Run(self, args): if 'all' in args.emulators: if len(args.emulators) > 1: raise util.EmulatorArgumentsError( "Cannot specify 'all' with other emulators") if args.route_to_public: raise util.EmulatorArgumentsError( 'Cannot specify --route-to-public and --emulators=all') else: unknown_emulators = [x for x in args.emulators if x not in config.EMULATORS] if unknown_emulators: raise util.EmulatorArgumentsError('Specified unrecognized emulators: ' ','.join(unknown_emulators)) proxy_port = args.proxy_port if args.proxy_port is None: proxy_port = util.DefaultPortIfAvailable() if not portpicker.is_port_free(proxy_port): raise util.EmulatorArgumentsError( 'Specified proxy port [{}] is not available'.format(proxy_port)) util.EnsureComponentIsInstalled('emulator-reverse-proxy', 'gcloud emulators start') for flag, emulator in six.iteritems(config.EMULATORS): title = emulator.emulator_title component = emulator.emulator_component if (args.emulators is not None and (flag in args.emulators or 'all' in args.emulators)): java.RequireJavaInstalled(title) util.EnsureComponentIsInstalled(component, title) with contextlib.ExitStack() as stack: local_emulator_ports = {} for emulator in args.emulators: port = portpicker.pick_unused_port() local_emulator_ports[emulator] = port stack.enter_context(config.EMULATORS[emulator].Start(port)) _, routes_config_file = tempfile.mkstemp() config.WriteRoutesConfig(config.EMULATORS, routes_config_file) log.status.Print( 'routes configuration written to file: {}'.format(routes_config_file)) proxy_config = config.ProxyConfiguration(local_emulator_ports, args.route_to_public, proxy_port) _, proxy_config_file = tempfile.mkstemp() proxy_config.WriteJsonToFile(proxy_config_file) log.status.Print( 'proxy configuration written to file: {}'.format(proxy_config_file)) # TODO(b/35872500) for some reason, in this case, this will block. Maybe # we need to flush something, maybe not. Regardless, this is fine for # now, but would be nice for it to not block like everything else with proxy_util.StartEmulatorProxy( args=[routes_config_file, proxy_config_file]) as proxy_process: # This will block the console util.PrefixOutput(proxy_process, 'emulator-reverse-proxy')
def testJavaExecutableNotFound(self): find_exec_mock = self.StartObjectPatch(files, 'FindExecutableOnPath') find_exec_mock.return_value = None with self.assertRaises(java.JavaError): java.RequireJavaInstalled('foo')