cmake: Moved finding and running CMake out of dependency

4 files changed, 229 insertions, 16 deletions

diff --git a/mesonbuild/cmake/__init__.py b/mesonbuild/cmake/__init__.py
index d449324..6d036e0 100644
--- a/mesonbuild/cmake/__init__.py
+++ b/mesonbuild/cmake/__init__.py
@@ -17,10 +17,12 @@
 
 __all__ = [
     'CMakeClient',
+    'CMakeExecutor',
     'CMakeException',
     'CMakeInterpreter',
 ]
 
 from .common import CMakeException
 from .client import CMakeClient
+from .executor import CMakeExecutor
 from .interpreter import CMakeInterpreter
diff --git a/mesonbuild/cmake/client.py b/mesonbuild/cmake/client.py
index 93985e9..f77e0cc 100644
--- a/mesonbuild/cmake/client.py
+++ b/mesonbuild/cmake/client.py
@@ -16,8 +16,8 @@
 # or an interpreter-based tool.
 
 from .common import CMakeException
+from .executor import CMakeExecutor
 from ..environment import Environment
-from ..dependencies.base import CMakeDependency, ExternalProgram
 from ..mesonlib import MachineChoice
 from .. import mlog
 from contextlib import contextmanager
@@ -475,14 +475,11 @@ class CMakeClient:
         if self.proc is not None:
             raise CMakeException('The CMake server was already started')
         for_machine = MachineChoice.HOST # TODO make parameter
-        cmake_exe, cmake_vers, _ = CMakeDependency.find_cmake_binary(self.env, for_machine)
-        if cmake_exe is None or cmake_exe is False:
-            raise CMakeException('Unable to find CMake')
-        assert(isinstance(cmake_exe, ExternalProgram))
+        cmake_exe = CMakeExecutor(self.env, '>=3.7', for_machine)
         if not cmake_exe.found():
             raise CMakeException('Unable to find CMake')
 
-        mlog.debug('Starting CMake server with CMake', mlog.bold(' '.join(cmake_exe.get_command())), 'version', mlog.cyan(cmake_vers))
+        mlog.debug('Starting CMake server with CMake', mlog.bold(' '.join(cmake_exe.get_command())), 'version', mlog.cyan(cmake_exe.version()))
         self.proc = Popen(cmake_exe.get_command() + ['-E', 'server', '--experimental', '--debug'], stdin=PIPE, stdout=PIPE)
 
     def shutdown(self) -> None:
diff --git a/mesonbuild/cmake/executor.py b/mesonbuild/cmake/executor.py
new file mode 100644
index 0000000..13e31c1
--- /dev/null
+++ b/mesonbuild/cmake/executor.py
@@ -0,0 +1,215 @@
+# Copyright 2019 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This class contains the basic functionality needed to run any interpreter
+# or an interpreter-based tool.
+
+from .. import mlog, mesonlib
+from ..mesonlib import PerMachine, Popen_safe, version_compare, MachineChoice
+from ..environment import Environment
+
+from typing import List, Tuple, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..dependencies.base import ExternalProgram
+
+import re, os, ctypes
+
+class CMakeExecutor:
+    # The class's copy of the CMake path. Avoids having to search for it
+    # multiple times in the same Meson invocation.
+    class_cmakebin = PerMachine(None, None)
+    class_cmakevers = PerMachine(None, None)
+    class_cmake_cache = {}
+
+    def __init__(self, environment: Environment, version: str, for_machine: MachineChoice, silent: bool = False):
+        self.min_version = version
+        self.environment = environment
+        self.for_machine = for_machine
+        self.cmakebin, self.cmakevers = self.find_cmake_binary(self.environment, silent=silent)
+        if self.cmakebin is False:
+            self.cmakebin = None
+            return
+
+        if not version_compare(self.cmakevers, self.min_version):
+            self.cmakebin = None
+            mlog.warning(
+                'The version of CMake', mlog.bold(self.cmakebin.get_path()),
+                'is', mlog.bold(self.cmakevers), 'but version', mlog.bold(self.min_version),
+                'is required')
+            return
+
+    def find_cmake_binary(self, environment: Environment, silent: bool = False) -> Tuple['ExternalProgram', str]:
+        from ..dependencies.base import ExternalProgram
+
+        # Create an iterator of options
+        def search():
+            # Lookup in cross or machine file.
+            potential_cmakepath = environment.binaries[self.for_machine].lookup_entry('cmake')
+            if potential_cmakepath is not None:
+                mlog.debug('CMake binary for %s specified from cross file, native file, or env var as %s.', self.for_machine, potential_cmakepath)
+                yield ExternalProgram.from_entry('cmake', potential_cmakepath)
+                # We never fallback if the user-specified option is no good, so
+                # stop returning options.
+                return
+            mlog.debug('CMake binary missing from cross or native file, or env var undefined.')
+            # Fallback on hard-coded defaults.
+            # TODO prefix this for the cross case instead of ignoring thing.
+            if environment.machines.matches_build_machine(self.for_machine):
+                for potential_cmakepath in environment.default_cmake:
+                    mlog.debug('Trying a default CMake fallback at', potential_cmakepath)
+                    yield ExternalProgram(potential_cmakepath, silent=True)
+
+        # Only search for CMake the first time and store the result in the class
+        # definition
+        if CMakeExecutor.class_cmakebin[self.for_machine] is False:
+            mlog.debug('CMake binary for %s is cached as not found' % self.for_machine)
+        elif CMakeExecutor.class_cmakebin[self.for_machine] is not None:
+            mlog.debug('CMake binary for %s is cached.' % self.for_machine)
+        else:
+            assert CMakeExecutor.class_cmakebin[self.for_machine] is None
+            mlog.debug('CMake binary for %s is not cached' % self.for_machine)
+            for potential_cmakebin in search():
+                mlog.debug('Trying CMake binary {} for machine {} at {}'
+                           .format(potential_cmakebin.name, self.for_machine, potential_cmakebin.command))
+                version_if_ok = self.check_cmake(potential_cmakebin)
+                if not version_if_ok:
+                    continue
+                if not silent:
+                    mlog.log('Found CMake:', mlog.bold(potential_cmakebin.get_path()),
+                             '(%s)' % version_if_ok)
+                CMakeExecutor.class_cmakebin[self.for_machine] = potential_cmakebin
+                CMakeExecutor.class_cmakevers[self.for_machine] = version_if_ok
+                break
+            else:
+                if not silent:
+                    mlog.log('Found CMake:', mlog.red('NO'))
+                # Set to False instead of None to signify that we've already
+                # searched for it and not found it
+                CMakeExecutor.class_cmakebin[self.for_machine] = False
+                CMakeExecutor.class_cmakevers[self.for_machine] = None
+
+        return CMakeExecutor.class_cmakebin[self.for_machine], CMakeExecutor.class_cmakevers[self.for_machine]
+
+    def check_cmake(self, cmakebin: 'ExternalProgram') -> Optional[str]:
+        if not cmakebin.found():
+            mlog.log('Did not find CMake {!r}'.format(cmakebin.name))
+            return None
+        try:
+            p, out = Popen_safe(cmakebin.get_command() + ['--version'])[0:2]
+            if p.returncode != 0:
+                mlog.warning('Found CMake {!r} but couldn\'t run it'
+                             ''.format(' '.join(cmakebin.get_command())))
+                return None
+        except FileNotFoundError:
+            mlog.warning('We thought we found CMake {!r} but now it\'s not there. How odd!'
+                         ''.format(' '.join(cmakebin.get_command())))
+            return None
+        except PermissionError:
+            msg = 'Found CMake {!r} but didn\'t have permissions to run it.'.format(' '.join(cmakebin.get_command()))
+            if not mesonlib.is_windows():
+                msg += '\n\nOn Unix-like systems this is often caused by scripts that are not executable.'
+            mlog.warning(msg)
+            return None
+        cmvers = re.sub(r'\s*cmake version\s*', '', out.split('\n')[0]).strip()
+        return cmvers
+
+    def _cache_key(self, args: List[str], build_dir: str, env):
+        fenv = frozenset(env.items()) if env is not None else None
+        targs = tuple(args)
+        return (self.cmakebin, targs, build_dir, fenv)
+
+    def _call_real(self, args: List[str], build_dir: str, env) -> Tuple[int, str, str]:
+        os.makedirs(build_dir, exist_ok=True)
+        cmd = self.cmakebin.get_command() + args
+        p, out, err = Popen_safe(cmd, env=env, cwd=build_dir)
+        rc = p.returncode
+        call = ' '.join(cmd)
+        mlog.debug("Called `{}` in {} -> {}".format(call, build_dir, rc))
+        return rc, out, err
+
+    def call(self, args: List[str], build_dir: str, env=None, disable_cache: bool = False):
+        if env is None:
+            env = os.environ
+
+        if disable_cache:
+            return self._call_real(args, build_dir, env)
+
+        # First check if cached, if not call the real cmake function
+        cache = CMakeExecutor.class_cmake_cache
+        key = self._cache_key(args, build_dir, env)
+        if key not in cache:
+            cache[key] = self._call_real(args, build_dir, env)
+        return cache[key]
+
+    def call_with_fake_build(self, args: List[str], build_dir: str, env=None):
+        # First check the cache
+        cache = CMakeExecutor.class_cmake_cache
+        key = self._cache_key(args, build_dir, env)
+        if key in cache:
+            return cache[key]
+
+        os.makedirs(build_dir, exist_ok=True)
+
+        # Reset the CMake cache
+        with open('{}/CMakeCache.txt'.format(build_dir), 'w') as fp:
+            fp.write('CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1\n')
+
+        # Fake the compiler files
+        comp_dir = '{}/CMakeFiles/{}'.format(build_dir, self.cmakevers)
+        os.makedirs(comp_dir, exist_ok=True)
+
+        c_comp = '{}/CMakeCCompiler.cmake'.format(comp_dir)
+        cxx_comp = '{}/CMakeCXXCompiler.cmake'.format(comp_dir)
+
+        if not os.path.exists(c_comp):
+            with open(c_comp, 'w') as fp:
+                fp.write('''# Fake CMake file to skip the boring and slow stuff
+set(CMAKE_C_COMPILER "{}") # Just give CMake a valid full path to any file
+set(CMAKE_C_COMPILER_ID "GNU") # Pretend we have found GCC
+set(CMAKE_COMPILER_IS_GNUCC 1)
+set(CMAKE_C_COMPILER_LOADED 1)
+set(CMAKE_C_COMPILER_WORKS TRUE)
+set(CMAKE_C_ABI_COMPILED TRUE)
+set(CMAKE_SIZEOF_VOID_P "{}")
+'''.format(os.path.realpath(__file__), ctypes.sizeof(ctypes.c_voidp)))
+
+        if not os.path.exists(cxx_comp):
+            with open(cxx_comp, 'w') as fp:
+                fp.write('''# Fake CMake file to skip the boring and slow stuff
+set(CMAKE_CXX_COMPILER "{}") # Just give CMake a valid full path to any file
+set(CMAKE_CXX_COMPILER_ID "GNU") # Pretend we have found GCC
+set(CMAKE_COMPILER_IS_GNUCXX 1)
+set(CMAKE_CXX_COMPILER_LOADED 1)
+set(CMAKE_CXX_COMPILER_WORKS TRUE)
+set(CMAKE_CXX_ABI_COMPILED TRUE)
+set(CMAKE_SIZEOF_VOID_P "{}")
+'''.format(os.path.realpath(__file__), ctypes.sizeof(ctypes.c_voidp)))
+
+        return self.call(args, build_dir, env)
+
+    def found(self) -> bool:
+        return self.cmakebin is not None
+
+    def version(self) -> str:
+        return self.cmakevers
+
+    def executable_path(self) -> str:
+        return self.cmakebin.get_path()
+
+    def get_command(self):
+        return self.cmakebin.get_command()
+
+    def machine_choice(self) -> MachineChoice:
+        return self.for_machine
diff --git a/mesonbuild/cmake/interpreter.py b/mesonbuild/cmake/interpreter.py
index 435f8d2..88700f1 100644
--- a/mesonbuild/cmake/interpreter.py
+++ b/mesonbuild/cmake/interpreter.py
@@ -17,18 +17,20 @@
 
 from .common import CMakeException
 from .client import CMakeClient, RequestCMakeInputs, RequestConfigure, RequestCompute, RequestCodeModel, CMakeTarget
+from .executor import CMakeExecutor
 from .. import mlog
-from ..build import Build
 from ..environment import Environment
 from ..mesonlib import MachineChoice
 from ..mparser import Token, BaseNode, CodeBlockNode, FunctionNode, ArrayNode, ArgumentNode, AssignmentNode, BooleanNode, StringNode, IdNode, MethodNode
-from ..backend.backends import Backend
 from ..compilers.compilers import lang_suffixes, header_suffixes, obj_suffixes
-from ..dependencies.base import CMakeDependency, ExternalProgram
 from subprocess import Popen, PIPE, STDOUT
-from typing import List, Dict, Optional
+from typing import List, Dict, Optional, TYPE_CHECKING
 import os, re
 
+if TYPE_CHECKING:
+    from ..build import Build
+    from ..backend.backends import Backend
+
 backend_generator_map = {
     'ninja': 'Ninja',
     'xcode': 'Xcode',
@@ -276,7 +278,7 @@ class ConverterTarget:
             mlog.log('    -', key, '=', mlog.bold(str(val)))
 
 class CMakeInterpreter:
-    def __init__(self, build: Build, subdir: str, src_dir: str, install_prefix: str, env: Environment, backend: Backend):
+    def __init__(self, build: 'Build', subdir: str, src_dir: str, install_prefix: str, env: Environment, backend: 'Backend'):
         assert(hasattr(backend, 'name'))
         self.build = build
         self.subdir = subdir
@@ -303,10 +305,7 @@ class CMakeInterpreter:
     def configure(self, extra_cmake_options: List[str]) -> None:
         for_machine = MachineChoice.HOST # TODO make parameter
         # Find CMake
-        cmake_exe, cmake_vers, _ = CMakeDependency.find_cmake_binary(self.env, for_machine)
-        if cmake_exe is None or cmake_exe is False:
-            raise CMakeException('Unable to find CMake')
-        assert(isinstance(cmake_exe, ExternalProgram))
+        cmake_exe = CMakeExecutor(self.env, '>=3.7', for_machine)
         if not cmake_exe.found():
             raise CMakeException('Unable to find CMake')
 
@@ -333,7 +332,7 @@ class CMakeInterpreter:
         # Run CMake
         mlog.log()
         with mlog.nested():
-            mlog.log('Configuring the build directory with', mlog.bold('CMake'), 'version', mlog.cyan(cmake_vers))
+            mlog.log('Configuring the build directory with', mlog.bold('CMake'), 'version', mlog.cyan(cmake_exe.version()))
             mlog.log(mlog.bold('Running:'), ' '.join(cmake_args))
             mlog.log()
             os.makedirs(self.build_dir, exist_ok=True)