cp_dlls.py

#!/usr/bin/env python
"""
%s <src_dir> <dest_dir> [dest_dir2, [dest_dir3, ...]] [flags]

Copies the macOS or Linux build artifacts of the firebase-unity-sdk to the
directory of the Firestore Unity testapp.

This script is designed for use during iterative development. The idea is that
you make changes to a source file, rebuild with cmake --build, then use this
script to copy the build artifacts into a Unity project to test them out.

src_dir
 The directory into which the build artifacts of firebase-unity-sdk were
 written. This is the directory that was specified to cmake as the -B argument.

dest_dir
 The directories of the Unity projects into which to copy the build artifacts.
 The same "copy" steps will be repeated for each of these directories. Each of
 these Unity projects must have imported FirebaseFirestore.unitypackage at
 some point in the past, since this script only publishes a minimal subset of
 build artifacts and not everything needed for the Firebase Unity SDK.
"""

# NOTE: This script requires Python 3.9 or newer.

fromcollections.abcimportIterator, Sequence
importabc
importenum
importfnmatch
importpathlib
importre
importshutil
fromtypingimportOptional

fromabslimportapp
fromabslimportflags
fromabslimportlogging


FLAG_FILTER=flags.DEFINE_string(
name="filter",
default=None,
help="The names of the files to include when copying; only the files whose "
"names match this filter will be copied. The pattern uses Python's "
"fnmatch module, which recognizes *, ?, and [anychar]. One use case would "
"be to specify *dll so that only the .dll files are copied, since copying "
"the .so files can crash the Unity Editor, and is not necessary if only C# "
"files have been modified.",
)

FLAG_DRY_RUN=flags.DEFINE_boolean(
name="dry_run",
default=False,
help="Log what file operations would be performed, without actually "
"performing them.",
)


defmain(argv: Sequence[str]) ->None:
iflen(argv) <2:
raiseapp.UsageError("src_dir must be specified")
eliflen(argv) <3:
raiseapp.UsageError("at least one dest_dir must be specified")

src_dir=pathlib.Path(argv[1])
dest_dirs=tuple(pathlib.Path(dest_dir_str) fordest_dir_strinargv[2:])

ifFLAG_FILTER.value:
copy_pattern=re.compile(fnmatch.translate(FLAG_FILTER.value))
else:
copy_pattern=None

ifFLAG_DRY_RUN.value:
fs=NoOpFileSystem()
else:
fs=RealFileSystem()

fordest_dirindest_dirs:
copier=BuildArtifactCopier(src_dir, dest_dir, fs, copy_pattern)
copier.run()


@enum.unique
classOS(enum.Enum):
MAC= (".bundle")
LINUX= (".so")

def__init__(self, lib_filename_suffix: str) ->None:
self.lib_filename_suffix=lib_filename_suffix


classFileSystem(abc.ABC):

@abc.abstractmethod
defunlink(self, path: pathlib.Path) ->None:
raiseNotImplementedError()

@abc.abstractmethod
defcopy_file(self, src: pathlib.Path, dest: pathlib.Path) ->None:
raiseNotImplementedError()


classRealFileSystem(FileSystem):

defunlink(self, path: pathlib.Path) ->None:
path.unlink()

defcopy_file(self, src: pathlib.Path, dest: pathlib.Path) ->None:
shutil.copy2(src, dest)


classNoOpFileSystem(FileSystem):

defunlink(self, path: pathlib.Path) ->None:
pass

defcopy_file(self, src: pathlib.Path, dest: pathlib.Path) ->None:
pass


classBuildArtifactCopier:

def__init__(
self,
src_dir: pathlib.Path,
dest_dir: pathlib.Path,
fs: FileSystem,
copy_pattern: Optional[re.Pattern],
 ) ->None:
self.src_dir=src_dir
self.dest_dir=dest_dir
self.fs=fs
self.copy_pattern=copy_pattern

defrun(self) ->None:
logging.info("Copying build artifacts from %s to %s", self.src_dir, self.dest_dir)
 (src_cpp_app_library_os, src_cpp_app_library_file) =self.find_src_cpp_app_library()
self.delete_old_cpp_app_library_files(src_cpp_app_library_os, src_cpp_app_library_file.name)
self.copy_files(src_cpp_app_library_os, src_cpp_app_library_file)

deffind_src_cpp_app_library(self) ->tuple[OS, pathlib.Path]:
found_artifacts: list[tuple[OS, pathlib.Path]] = []

logging.info("Searching for C++ library build artifact files in directory: %s", self.src_dir)
forcandidate_artifact_pathinself.src_dir.iterdir():
forcandidate_osinOS:
ifcandidate_artifact_path.name.endswith(candidate_os.lib_filename_suffix):
logging.info("Found C++ library build artifact file: %s", candidate_artifact_path)
found_artifacts.append((candidate_os, candidate_artifact_path))

iflen(found_artifacts) ==0:
raiseFirebaseCppLibraryBuildArtifactNotFound(
f"No C++ library build artifact files found in {self.src_dir}, but "
f"expected to find exactly one file whose name ends with one of the "
f"following suffixes: "+", ".join(os.lib_filename_suffixforosinOS)
 )
eliflen(found_artifacts) >1:
raiseFirebaseCppLibraryBuildArtifactNotFound(
f"Found {len(found_artifacts)} C++ library build artifacts in "
f"{self.src_dir}, but expected to find exactly one: "
+", ".join(found_artifact[1].nameforfound_artifactinfound_artifacts)
 )

returnfound_artifacts[0]

defdelete_old_cpp_app_library_files(
self,
os: OS,
src_cpp_app_library_file_name: str
 ) ->None:
expr=re.compile(r"FirebaseCppApp-\d+_\d+_\d+"+re.escape(os.lib_filename_suffix))
ifnotexpr.fullmatch(src_cpp_app_library_file_name):
raiseValueError(f"invalid filename: {src_cpp_app_library_file_name}")

# Do not delete old CPP app library files if we aren't even copying them
# due to the copy_pattern not matching the file name.
ifself.copy_patternisnotNone \
andnotself.copy_pattern.fullmatch(src_cpp_app_library_file_name):
return

# TODO(dconeybe) Update this logic to also support Mac M1, which probably
# uses a different directory than "x86_64".
x86_64_dir=self.dest_dir/"Assets"/"Firebase"/"Plugins"/"x86_64"
forcandidate_dll_fileinx86_64_dir.iterdir():
ifexpr.fullmatch(candidate_dll_file.name):
# Don't delete the file that is going to be overwritten anyways; because
# deleting it is unnecessary and adds noise to the log output.
ifcandidate_dll_file.name==src_cpp_app_library_file_name:
continue
logging.info("Deleting %s", candidate_dll_file)
self.fs.unlink(candidate_dll_file)
candidate_dll_meta_file=candidate_dll_file.parent \
/ (candidate_dll_file.name+".meta")
ifcandidate_dll_meta_file.exists():
logging.info("Deleting %s", candidate_dll_meta_file)
self.fs.unlink(candidate_dll_meta_file)

defcopy_files(self, os: OS, src_cpp_app_library_file: pathlib.Path) ->None:
files_to_copy=sorted(self.files_to_copy(os, src_cpp_app_library_file))
for (src_file, dest_file) infiles_to_copy:
ifself.copy_patternisNoneorself.copy_pattern.fullmatch(src_file.name):
logging.info("Copying %s to %s", src_file, dest_file)
self.fs.copy_file(src_file, dest_file)

deffiles_to_copy(
self,
os: OS,
src_cpp_app_library_file: pathlib.Path
 ) ->Iterator[tuple[pathlib.Path, pathlib.Path]]:
# As a special case, yield the src_cpp_app_library_file.
# Since its name encodes the version number, which changes over time, we
# cannot simply hardcode it like the other files in the dict below.
dest_cpp_app_library_file=self.dest_dir/"Assets"/"Firebase" \
/"Plugins"/"x86_64"/src_cpp_app_library_file.name
yield (src_cpp_app_library_file, dest_cpp_app_library_file )

src_file_strs_by_dest_dir_str: dict[str, tuple[str, ...]] = {
"Assets/Firebase/Plugins": (
"app/obj/x86/Release/Firebase.App.dll",
"app/platform/obj/x86/Release/Firebase.Platform.dll",
"app/task_extension/obj/x86/Release/Firebase.TaskExtension.dll",
"auth/obj/x86/Release/Firebase.Auth.dll",
"firestore/obj/x86/Release/Firebase.Firestore.dll",
 ),
"Assets/Firebase/Plugins/x86_64": (
"firestore/FirebaseCppFirestore"+os.lib_filename_suffix,
"auth/FirebaseCppAuth"+os.lib_filename_suffix,
 ),
 }

# Yield (src_file, dest_file) pairs from the dict above.
for (dest_dir_str, src_file_strs) insrc_file_strs_by_dest_dir_str.items():
forsrc_file_strinsrc_file_strs:
src_file=self.src_dir/src_file_str
dest_file=self.dest_dir/dest_dir_str/src_file.name
yield (src_file, dest_file)


classFirebaseCppLibraryBuildArtifactNotFound(Exception):
pass


if__name__=="__main__":
app.run(main)