def run(self, version: ProjectVersion):
logger = logging.getLogger("tasks.checkout")
try:
checkout = version.get_checkout(self.checkouts_path)
except ValueError as e:
raise UserWarning("Checkout data corrupted: %s", e)
if self.force_checkout:
checkout.delete()
checkout_exists = checkout.exists()
logger.debug("Checkout exists = %r", checkout_exists)
if checkout_exists:
logger.debug("Already checked out %s.", version)
else:
logger.info("Fetching %s from %s...", version, checkout)
if self.use_temp_dir:
temp_dir = mkdtemp(prefix="mubench-checkout_")
temp_checkout = version.get_checkout(temp_dir)
temp_checkout.create(self.run_timestamp)
logger.debug("Copying checkout to persistent directory...")
copy_tree(temp_dir, self.checkouts_path)
remove_tree(temp_dir)
else:
checkout.create(self.run_timestamp)
return checkout
def create(self):
if not exists(self.checkout_dir):
self._logger.debug("Create checkout directory %s", self.checkout_dir)
makedirs(self.checkout_dir)
if not listdir(self.checkout_dir):
self._logger.debug("Copy from %s", self.url)
copy_tree(self.url, self.checkout_dir)
def test_copies_empty_directory(self):
src = join(self.temp_dir, "src")
makedirs(join(src, "empty"))
copy_tree(src, self.temp_dir)
assert exists(join(self.temp_dir, "empty"))
def test_copy_creates_destination(self):
src = join(self.temp_dir, "src")
makedirs(src)
dst = join(self.temp_dir, "dst")
copy_tree(src, dst)
assert exists(dst)
def test_copies_tree(self):
src = join(self.temp_dir, "src")
file1 = join("dir1", "dir2", "file1")
file2 = join("dir1", "file2")
file3 = join("file3")
create_file(join(src, file1))
create_file(join(src, file2))
create_file(join(src, file3))
copy_tree(src, self.temp_dir)
assert exists(join(self.temp_dir, file1))
assert exists(join(self.temp_dir, file2))
assert exists(join(self.temp_dir, file3))
def run(self, version: ProjectVersion, checkout: ProjectCheckout):
logger = logging.getLogger("task.compile")
version_compile = version.get_compile(self.compiles_base_path)
build_path = mkdtemp(prefix='mubench-compile_') if self.use_temp_dir else version_compile.build_dir
if self.force_compile or checkout.timestamp > version_compile.timestamp:
logger.debug("Force compile - removing previous compiles...")
version_compile.delete()
try:
if not version.is_compilable:
raise UserWarning("Skipping compilation: not configured.")
if version_compile.needs_compile():
logger.info("Compiling %s...", version)
logger.debug("Copying checkout to build directory...")
checkout_path = checkout.checkout_dir
copy_tree(checkout_path, build_path)
logger.debug("Copying additional resources...")
self.__copy_additional_compile_sources(version, build_path)
logger.debug("Compiling project...")
self._compile(version.compile_commands,
build_path,
version_compile.dependencies_path,
self.compiles_base_path,
logger)
logger.debug("Create project jar...")
zip_dir_contents(version_compile.original_classes_paths, version_compile.original_classpath)
version_compile.save(self.run_timestamp)
if self.use_temp_dir:
logger.debug("Moving complete build to persistent directory...")
copy_tree(build_path, version_compile.build_dir)
remove_tree(build_path)
except Exception:
version_compile.delete()
raise
return version_compile
def run(self, misuse: Misuse, version_compile: VersionCompile):
logger = logging.getLogger("task.compile_patterns")
misuse_compile = misuse.get_misuse_compile(self.compile_base_path)
if self.force_compile or version_compile.timestamp > misuse_compile.timestamp:
misuse_compile.delete()
if not exists(misuse_compile.misuse_source_path):
logger.debug("Copying misuse sources...")
for source_path in version_compile.original_sources_paths:
CompileMisuseTask._copy_misuse_sources(source_path, misuse, misuse_compile.misuse_source_path)
if not exists(misuse_compile.misuse_classes_path):
logger.debug("Copying misuse classes...")
for classes_path in version_compile.original_classes_paths:
CompileMisuseTask._copy_misuse_classes(classes_path, misuse, misuse_compile.misuse_classes_path)
try:
if misuse_compile.needs_copy_sources() or misuse_compile.needs_compile():
logger.info("Compiling correct usage for %s...", misuse)
if misuse_compile.needs_copy_sources():
logger.debug("Copying correct-usage sources...")
copy_tree(misuse.correct_usage_path, misuse_compile.correct_usage_sources_path)
if misuse_compile.needs_compile():
logger.debug("Compiling correct usages...")
CompileMisuseTask._compile_correct_usages(misuse_compile.correct_usage_sources_path,
misuse_compile.correct_usage_classes_path,
version_compile.get_full_classpath())
misuse_compile.save(self.run_timestamp)
elif misuse.correct_usages:
logger.info("Correct usage already compiled.")
except Exception:
misuse_compile.delete()
raise
return misuse_compile
def process_project_version(self, project: Project,
version: ProjectVersion) -> List[str]:
logger = logging.getLogger("checkout")
try:
checkout = version.get_checkout(self.checkouts_path)
except ValueError as e:
logger.error("Checkout data corrupted: %s", e)
return self.skip(version)
try:
if self.force_checkout:
checkout.delete()
checkout_exists = checkout.exists()
logger.debug("Checkout exists = %r", checkout_exists)
if checkout_exists:
logger.debug("Already checked out %s.", version)
else:
logger.info("Fetching %s from %s...", version, checkout)
if self.use_temp_dir:
temp_dir = mkdtemp(prefix="mubench-checkout_")
temp_checkout = version.get_checkout(temp_dir)
temp_checkout.create()
logger.debug("Copying checkout to persistent directory...")
copy_tree(temp_dir, self.checkouts_path)
remove_tree(temp_dir)
else:
checkout.create()
return self.ok()
except CommandFailedError as e:
logger.error("Checkout failed: %s", e)
return self.skip(version)
except IOError:
logger.error("Checkout failed.", exc_info=True)
return self.skip(version)
def test_exists(self):
uut = GitProjectCheckout(self.git_url, self.checkouts_dir, "-project-",
"-id-", "HEAD")
copy_tree(self.git_url, uut.checkout_dir)
assert uut.exists()
def __copy_additional_compile_sources(version: ProjectVersion, checkout_dir: str):
additional_sources = version.additional_compile_sources
if exists(additional_sources):
copy_tree(additional_sources, checkout_dir)
def _create(self) -> None:
if not exists(self.checkout_dir):
self._logger.debug("Create checkout directory %s", self.checkout_dir)
makedirs(self.checkout_dir)
copy_tree(join(self.data_path, "repo"), self.checkout_dir)
def process_project_version(self, project: Project,
version: ProjectVersion):
logger = logging.getLogger("compile")
logger.info("Compiling %s...", version)
logger = logging.getLogger("compile.tasks")
project_compile = version.get_compile(self.compiles_base_path)
build_path = mkdtemp(
prefix='mubench-compile_'
) if self.use_temp_dir else project_compile.build_dir
sources_path = join(build_path, version.source_dir)
classes_path = join(build_path, version.classes_dir)
if self.force_compile:
logger.debug("Force compile - removing previous compiles...")
project_compile.delete()
try:
needs_copy_sources = project_compile.needs_copy_sources()
needs_compile = project_compile.needs_compile()
if needs_copy_sources or needs_compile:
logger.debug("Copying checkout to build directory...")
checkout_path = version.get_checkout(
self.checkouts_base_path).checkout_dir
copy_tree(checkout_path, build_path)
logger.debug("Copying additional resources...")
self.__copy_additional_compile_sources(version, build_path)
if not needs_copy_sources:
logger.debug("Already copied source.")
else:
logger.info("Copying sources...")
logger.debug("Copying project sources...")
copy_tree(sources_path, project_compile.original_sources_path)
logger.debug("Copying misuse sources...")
self.__copy_misuse_sources(sources_path, version.misuses,
project_compile.misuse_source_path)
logger.info("Copying pattern sources...")
self.__copy_pattern_sources(version.misuses, project_compile)
if not version.compile_commands:
logger.warning("Skipping compilation: not configured.")
return self.skip(version)
if not needs_compile:
logger.debug("Already compiled project.")
else:
logger.info("Compiling project...")
logger.debug("Copying patterns to source directory...")
self.__copy(version.patterns, sources_path)
self._compile(version.compile_commands, build_path,
project_compile.dependencies_path,
self.compiles_base_path, logger)
logger.debug("Move pattern classes...")
self.__copy_pattern_classes(version.misuses, classes_path,
project_compile)
self.__remove_pattern_classes(version.misuses, classes_path)
logger.debug("Copy project classes...")
copy_tree(classes_path, project_compile.original_classes_path)
logger.debug("Create project jar...")
self.__create_jar(project_compile.original_classes_path,
project_compile.original_classpath)
logger.debug("Copy misuse classes...")
self.__copy_misuse_classes(classes_path, version.misuses,
project_compile.misuse_classes_path)
if self.use_temp_dir:
logger.debug(
"Moving complete build to persistent directory...")
copy_tree(build_path, project_compile.build_dir)
remove_tree(build_path)
except Exception as e:
logger.error("Compilation failed: %s", e)
project_compile.delete()
return self.skip(version)
return self.ok()
def test_copy_fails_if_source_misssing(self):
src = join(self.temp_dir, "src")
with assert_raises(FileNotFoundError):
copy_tree(src, "-irrelevant-")
def __clean_copy(sources_path: str, destination: str):
remove_tree(destination)
copy_tree(sources_path, destination)
