зеркало из https://github.com/golang/build.git
1558 строки
53 KiB
Python
1558 строки
53 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
from __future__ import (
|
|
division,
|
|
print_function,
|
|
absolute_import,
|
|
unicode_literals,
|
|
with_statement,
|
|
)
|
|
from contextlib import contextmanager
|
|
import shutil
|
|
import sys
|
|
import argparse
|
|
from os.path import expanduser, join, dirname, abspath, exists, islink, lexists, isdir
|
|
from os import (
|
|
getenv,
|
|
geteuid,
|
|
listdir,
|
|
makedirs,
|
|
mkdir,
|
|
readlink,
|
|
remove,
|
|
getpid,
|
|
symlink,
|
|
)
|
|
import tempfile
|
|
import tarfile
|
|
import zipfile
|
|
import platform
|
|
import subprocess
|
|
import re
|
|
import logging
|
|
|
|
download_url = None
|
|
|
|
# Define version specific things
|
|
if sys.version_info[0] == 3:
|
|
import urllib.request
|
|
|
|
download_url = urllib.request.urlretrieve
|
|
|
|
def reraise(tp, value=None, tb=None):
|
|
if value is None:
|
|
value = tp
|
|
if value.__traceback__ is not tb:
|
|
raise value.with_traceback(tb)
|
|
raise value
|
|
|
|
else:
|
|
exec("def reraise(tp, value=None, tb=None):\n raise tp, value, tb\n")
|
|
|
|
import urllib
|
|
|
|
download_url = urllib.urlretrieve
|
|
|
|
|
|
def show_progress(block_num, block_size, total_size):
|
|
downloaded = block_num * block_size
|
|
|
|
print(
|
|
end=(
|
|
"\r|%-60s|" % ("=" * int(60 * downloaded / (total_size)))
|
|
+ "%6.2f %%" % (downloaded / (total_size) * 100)
|
|
)
|
|
)
|
|
|
|
if downloaded < total_size:
|
|
pass
|
|
else:
|
|
print("Downloaded")
|
|
|
|
|
|
@contextmanager
|
|
def opened_w_error(filename, mode="r"):
|
|
try:
|
|
f = open(filename, mode)
|
|
except IOError as err:
|
|
logging.critical("Error opening file: %s error: %s", filename, err.strerror)
|
|
yield None
|
|
else:
|
|
try:
|
|
yield f
|
|
finally:
|
|
f.close()
|
|
|
|
|
|
def _is_tarxz(filename):
|
|
return filename.endswith(".tar.xz")
|
|
|
|
|
|
def _is_tar(filename):
|
|
return filename.endswith(".tar")
|
|
|
|
|
|
def _is_targz(filename):
|
|
return filename.endswith(".tar.gz")
|
|
|
|
|
|
def _is_tgz(filename):
|
|
return filename.endswith(".tgz")
|
|
|
|
|
|
def _is_zip(filename):
|
|
return filename.endswith(".zip")
|
|
|
|
|
|
def extract_archive(
|
|
from_path, ipath, to_path=None, remove_finished=False, env_file_path=None
|
|
):
|
|
files_extracted = []
|
|
|
|
if to_path is None:
|
|
to_path = dirname(from_path)
|
|
|
|
if _is_tar(from_path):
|
|
with tarfile.open(from_path, "r") as tar:
|
|
tar.extractall(path=to_path)
|
|
files_extracted = tar.getnames()
|
|
elif _is_targz(from_path) or _is_tgz(from_path):
|
|
with tarfile.open(from_path, "r:gz") as tar:
|
|
tar.extractall(path=to_path)
|
|
files_extracted = tar.getnames()
|
|
elif _is_tarxz(from_path):
|
|
with tarfile.open(from_path, "r:xz") as tar:
|
|
tar.extractall(path=to_path)
|
|
files_extracted = tar.getnames()
|
|
elif _is_zip(from_path):
|
|
with zipfile.ZipFile(from_path, "r") as z:
|
|
z.extractall(to_path)
|
|
files_extracted = z.namelist()
|
|
else:
|
|
reraise(ValueError("Extraction of {} not supported".format(from_path)))
|
|
|
|
logging.debug("Writing installed files to %s file", env_file_path)
|
|
with opened_w_error(env_file_path, "a") as env_file:
|
|
if env_file is not None:
|
|
for filename in files_extracted:
|
|
fname = filename.replace(CONST_ipkg, ipath)
|
|
|
|
# Skip if it ends with "wasmedge" as it is going to be removed at a later stage
|
|
if fname.endswith("wasmedge") and not fname.endswith("bin/wasmedge"):
|
|
continue
|
|
|
|
# replace wasmedge folder name with include
|
|
if is_default_path(args):
|
|
fname = fname.replace("/lib64/", "/" + CONST_lib_dir + "/")
|
|
if fname.endswith("/lib64"):
|
|
fname = fname[:-5] + "lib"
|
|
if fname.startswith("/usr") and "lib64" in fname:
|
|
fname = fname.replace("lib64", "lib", 1)
|
|
if "Plugin" in fname:
|
|
if is_default_path(args):
|
|
fname = fname.replace(
|
|
join(ipath, CONST_lib_dir, "wasmedge/"), ""
|
|
)
|
|
|
|
fname = join(ipath, "plugin", fname)
|
|
else:
|
|
fname = join(ipath, CONST_lib_dir, "wasmedge", fname)
|
|
else:
|
|
if ipath not in fname:
|
|
fname = join(ipath, fname)
|
|
# replace GNUSparseFile.0 with nothing
|
|
fname = fname.replace("/GNUSparseFile.0", "")
|
|
# Don't append system directories
|
|
if (not is_default_path(args)) and isdir(fname):
|
|
continue
|
|
env_file.write("#" + fname + "\n")
|
|
logging.debug("Appending:%s", fname)
|
|
else:
|
|
logging.warning("Unable to write to env file")
|
|
|
|
if remove_finished:
|
|
remove(from_path)
|
|
|
|
|
|
# https://stackoverflow.com/questions/1868714/
|
|
# how-do-i-copy-an-entire-directory-of-files-
|
|
# into-an-existing-directory-using-pyth
|
|
def copytree(src, dst, symlinks=True, ignore=None):
|
|
if not exists(dst):
|
|
makedirs(dst)
|
|
shutil.copystat(src, dst)
|
|
lst = listdir(src)
|
|
if ignore:
|
|
excl = ignore(src, lst)
|
|
lst = [x for x in lst if x not in excl]
|
|
for item in lst:
|
|
s = join(src, item)
|
|
d = join(dst, item)
|
|
if symlinks and islink(s):
|
|
if lexists(d):
|
|
remove(d)
|
|
symlink(readlink(s), d)
|
|
elif isdir(s):
|
|
copytree(s, d, symlinks, ignore)
|
|
else:
|
|
shutil.copy2(s, d)
|
|
|
|
|
|
class VersionString:
|
|
def __init__(self, version):
|
|
self.version = version
|
|
|
|
def __str__(self):
|
|
return self.version
|
|
|
|
def __repr__(self):
|
|
return "VersionString:" + self.version
|
|
|
|
def _preprocess(self, v, separator, ignorecase):
|
|
if ignorecase:
|
|
v = v.lower()
|
|
return [
|
|
int(x)
|
|
if x.isdigit()
|
|
else [int(y) if y.isdigit() else y for y in re.findall("\d+|[a-zA-Z]+", x)]
|
|
for x in re.split(separator, v)
|
|
]
|
|
|
|
def compare(self, version2, separator=". |-", ignorecase=True):
|
|
# return 1 if self.version > version2
|
|
# return 0 if self.version == version2
|
|
# return -1 if self.version < version2
|
|
# return False if not comparable
|
|
if "rc" in self.version and not "rc" in version2:
|
|
a = self._preprocess(
|
|
self.version.split("rc")[0].strip("-"), separator, ignorecase
|
|
)
|
|
b = b = self._preprocess(version2, separator, ignorecase)
|
|
if ((a > b) - (a < b)) == 0:
|
|
return -1
|
|
else:
|
|
return (a > b) - (a < b)
|
|
else:
|
|
a = self._preprocess(self.version, separator, ignorecase)
|
|
b = self._preprocess(version2, separator, ignorecase)
|
|
try:
|
|
return (a > b) - (a < b)
|
|
except:
|
|
return False
|
|
|
|
|
|
SUPPORTED_PLATFORM_MACHINE = {
|
|
"Linux": ["x86_64", "amd64", "arm64", "armv8", "aarch64"],
|
|
"Darwin": ["x86_64", "arm64", "arm"],
|
|
}
|
|
|
|
SUPPORTED_MIN_VERSION = {
|
|
"Linux" + "x86_64": VersionString("0.9.0"),
|
|
"Linux" + "amd64": VersionString("0.9.0"),
|
|
"Linux" + "arm64": VersionString("0.9.0"),
|
|
"Linux" + "armv8": VersionString("0.9.0"),
|
|
"Linux" + "aarch64": VersionString("0.9.0"),
|
|
"Darwin" + "x86_64": VersionString("0.9.0"),
|
|
"Darwin" + "arm64": VersionString("0.9.0"),
|
|
"Darwin" + "arm": VersionString("0.9.0"),
|
|
}
|
|
|
|
WASMEDGE = "WasmEdge"
|
|
WASMEDGE_UNINSTALLER = "WasmEdge_Uninstaller"
|
|
TENSORFLOW = "tensorflow"
|
|
TENSORFLOW_LITE = "tensorflow_lite"
|
|
TENSORFLOW_DEPS = "tensorflow_deps"
|
|
TENSORFLOW_LITE_DEPS = "tensorflow_lite_deps"
|
|
TENSORFLOW_TOOLS = "tensorflow_tools"
|
|
IMAGE = "image"
|
|
EXTENSIONS = [TENSORFLOW, IMAGE]
|
|
|
|
SUPPORTED_EXTENSIONS = {
|
|
"Linux" + "x86_64": EXTENSIONS,
|
|
"Linux" + "amd64": EXTENSIONS,
|
|
"Linux" + "arm64": EXTENSIONS,
|
|
"Linux" + "armv8": EXTENSIONS,
|
|
"Linux" + "aarch64": EXTENSIONS,
|
|
"Darwin" + "x86_64": EXTENSIONS,
|
|
"Darwin" + "arm64": [],
|
|
"Darwin" + "arm": [],
|
|
}
|
|
|
|
SUPPORTED_EXTENSIONS_VERSION = {
|
|
"Linux" + "x86_64" + TENSORFLOW: VersionString("0.9.0"),
|
|
"Linux" + "x86_64" + IMAGE: VersionString("0.9.0"),
|
|
"Linux" + "amd64" + TENSORFLOW: VersionString("0.9.0"),
|
|
"Linux" + "amd64" + IMAGE: VersionString("0.9.0"),
|
|
"Linux" + "arm64" + TENSORFLOW: VersionString("0.9.0"),
|
|
"Linux" + "arm64" + IMAGE: VersionString("0.9.0"),
|
|
"Linux" + "armv8" + TENSORFLOW: VersionString("0.9.0"),
|
|
"Linux" + "armv8" + IMAGE: VersionString("0.9.0"),
|
|
"Linux" + "aarch64" + TENSORFLOW: VersionString("0.9.1-beta.1"),
|
|
"Linux" + "aarch64" + IMAGE: VersionString("0.9.1-beta.1"),
|
|
"Darwin" + "x86_64" + TENSORFLOW: VersionString("0.10.0-alpha.1"),
|
|
"Darwin" + "x86_64" + IMAGE: VersionString("0.10.0-alpha.1"),
|
|
"Darwin" + "arm64" + TENSORFLOW: VersionString("0.10.0-alpha.1"),
|
|
"Darwin" + "arm" + TENSORFLOW: VersionString("0.10.0-alpha.1"),
|
|
}
|
|
|
|
WASI_NN_OPENVINO = "wasi_nn-openvino"
|
|
WASI_CRYPTO = "wasi_crypto"
|
|
WASI_NN_PYTORCH = "wasi_nn-pytorch"
|
|
WASI_NN_TENSORFLOW_LITE = "wasi_nn-tensorflowlite"
|
|
WASMEDGE_HTTPSREQ = "wasmedge_httpsreq"
|
|
PLUGINS_AVAILABLE = [
|
|
WASI_NN_OPENVINO,
|
|
WASI_CRYPTO,
|
|
WASI_NN_PYTORCH,
|
|
WASI_NN_TENSORFLOW_LITE,
|
|
WASMEDGE_HTTPSREQ,
|
|
]
|
|
|
|
SUPPORTTED_PLUGINS = {
|
|
"ubuntu20.04" + "x86_64" + WASI_CRYPTO: VersionString("0.10.1-rc.1"),
|
|
"manylinux2014" + "x86_64" + WASI_CRYPTO: VersionString("0.10.1-rc.1"),
|
|
"manylinux2014" + "aarch64" + WASI_CRYPTO: VersionString("0.10.1-rc.1"),
|
|
"manylinux2014" + "arm64" + WASI_CRYPTO: VersionString("0.10.1-rc.1"),
|
|
"ubuntu20.04" + "x86_64" + WASI_NN_OPENVINO: VersionString("0.10.1-alpha.1"),
|
|
"ubuntu20.04" + "x86_64" + WASI_NN_PYTORCH: VersionString("0.11.1-alpha.1"),
|
|
"manylinux2014" + "x86_64" + WASI_NN_PYTORCH: VersionString("0.11.2-alpha.1"),
|
|
"manylinux2014"
|
|
+ "x86_64"
|
|
+ WASI_NN_TENSORFLOW_LITE: VersionString("0.11.2-alpha.1"),
|
|
"manylinux2014"
|
|
+ "aarch64"
|
|
+ WASI_NN_TENSORFLOW_LITE: VersionString("0.11.2-alpha.1"),
|
|
"ubuntu20.04" + "x86_64" + WASI_NN_TENSORFLOW_LITE: VersionString("0.11.2-rc.1"),
|
|
"ubuntu20.04" + "x86_64" + WASMEDGE_HTTPSREQ: VersionString("0.11.1"),
|
|
"manylinux2014" + "x86_64" + WASMEDGE_HTTPSREQ: VersionString("0.11.1"),
|
|
"manylinux2014" + "aarch64" + WASMEDGE_HTTPSREQ: VersionString("0.11.1"),
|
|
}
|
|
|
|
HOME = expanduser("~")
|
|
PATH = join(HOME, ".wasmedge")
|
|
SHELL = getenv("SHELL", "bash").split("/")[-1]
|
|
TEMP_PATH = join(tempfile.gettempdir(), "wasmedge." + str(getpid()))
|
|
CONST_shell_config = None
|
|
CONST_shell_profile = None
|
|
CONST_env = None
|
|
CONST_urls = None
|
|
CONST_release_pkg = None
|
|
CONST_ipkg = None
|
|
CONST_lib_ext = None
|
|
CONST_env_path = None
|
|
CONST_lib_dir = "lib"
|
|
|
|
try:
|
|
mkdir(TEMP_PATH)
|
|
except:
|
|
pass
|
|
|
|
|
|
def set_env(args, compat):
|
|
global CONST_env, CONST_env_path, CONST_lib_dir
|
|
|
|
CONST_env = """#!/bin/sh
|
|
# wasmedge shell setup
|
|
# affix colons on either side of $PATH to simplify matching
|
|
case :"${1}": in
|
|
*:"{0}/bin":*)
|
|
;;
|
|
*)
|
|
# Prepending path in case a system-installed wasmedge needs to be overridden
|
|
if [ -n "${1}" ]; then
|
|
export PATH="{0}/bin":$PATH
|
|
else
|
|
export PATH="{0}/bin"
|
|
fi
|
|
;;
|
|
esac
|
|
case :"${2}": in
|
|
*:"{0}/{6}":*)
|
|
;;
|
|
*)
|
|
# Prepending path in case a system-installed wasmedge libs needs to be overridden
|
|
if [ -n "${2}" ]; then
|
|
export {2}="{0}/{6}":${2}
|
|
else
|
|
export {2}="{0}/{6}"
|
|
fi
|
|
;;
|
|
esac
|
|
case :"${3}": in
|
|
*:"{0}/{6}":*)
|
|
;;
|
|
*)
|
|
if [ -n "${3}" ]; then
|
|
export LIBRARY_PATH="{0}/{6}":$LIBRARY_PATH
|
|
else
|
|
export LIBRARY_PATH="{0}/{6}"
|
|
fi
|
|
;;
|
|
esac
|
|
case :"${4}": in
|
|
*:"{0}/include":*)
|
|
;;
|
|
*)
|
|
if [ -n "${4}" ]; then
|
|
export C_INCLUDE_PATH="{0}/include":$C_INCLUDE_PATH
|
|
else
|
|
export C_INCLUDE_PATH="{0}/include"
|
|
fi
|
|
;;
|
|
esac
|
|
case :"${5}": in
|
|
*:"{0}/include":*)
|
|
;;
|
|
*)
|
|
if [ -n "${5}" ]; then
|
|
export CPLUS_INCLUDE_PATH="{0}/include":$CPLUS_INCLUDE_PATH
|
|
else
|
|
export CPLUS_INCLUDE_PATH="{0}/include"
|
|
fi
|
|
;;
|
|
esac
|
|
if [ -z ${{WASMEDGE_LIB_DIR+x}} ]; then
|
|
export WASMEDGE_LIB_DIR="{0}/{6}"
|
|
fi
|
|
# Please do not edit comments below this for uninstallation purpose
|
|
""".format(
|
|
args.path,
|
|
"PATH",
|
|
compat.ld_library_path,
|
|
"LIBRARY_PATH",
|
|
"C_INCLUDE_PATH",
|
|
"CPLUS_INCLUDE_PATH",
|
|
CONST_lib_dir,
|
|
)
|
|
|
|
try:
|
|
mkdir(args.path)
|
|
if is_default_path(args):
|
|
mkdir(join(args.path, "plugin"))
|
|
except:
|
|
pass
|
|
CONST_env_path = join(args.path, "env")
|
|
mode = "w+" if not exists(CONST_env_path) else "w"
|
|
with opened_w_error(CONST_env_path, mode) as env:
|
|
if env is not None:
|
|
env.write(CONST_env)
|
|
else:
|
|
logging.error("Not able to write to env file")
|
|
|
|
|
|
def shell_configure(args, compat):
|
|
global CONST_shell_profile, CONST_shell_config
|
|
|
|
source_string = '\n. "{0}"\n'.format(join(args.path, "env"))
|
|
|
|
if ("bash" in SHELL) or ("zsh" in SHELL):
|
|
CONST_shell_config = join(HOME, "." + SHELL + "rc")
|
|
|
|
if "zsh" in SHELL:
|
|
CONST_shell_profile = join(HOME, "." + "zprofile")
|
|
else:
|
|
CONST_shell_profile = join(HOME, "." + SHELL + "_profile")
|
|
|
|
# On Darwin: Create shell config only if shell_profile does not exist
|
|
# On Linux: Create shell config anyway
|
|
if not exists(CONST_shell_config) and compat.platform != "Darwin":
|
|
open(CONST_shell_config, "a").close()
|
|
|
|
write_shell = False
|
|
if compat.platform != "Darwin":
|
|
with opened_w_error(CONST_shell_config, "r") as shell_config:
|
|
if shell_config is not None:
|
|
if source_string not in shell_config.read():
|
|
write_shell = True
|
|
|
|
# On Darwin: Append to shell config only if shell_profile does not exist
|
|
# On Linux: Append to shell config anyway
|
|
if write_shell and compat.platform != "Darwin":
|
|
with opened_w_error(CONST_shell_config, "a") as shell_config:
|
|
if shell_config is not None:
|
|
shell_config.write(source_string)
|
|
write_shell = False
|
|
|
|
if exists(CONST_shell_profile):
|
|
with opened_w_error(CONST_shell_profile, "r") as shell_profile:
|
|
if shell_profile is not None:
|
|
if source_string not in shell_profile.read():
|
|
write_shell = True
|
|
if write_shell:
|
|
with opened_w_error(CONST_shell_profile, "a") as shell_profile:
|
|
if shell_profile is not None:
|
|
shell_profile.write(source_string)
|
|
write_shell = False
|
|
else:
|
|
logging.error("Unknown shell found")
|
|
return -1
|
|
|
|
print("shell configuration updated")
|
|
return 0
|
|
|
|
|
|
def fix_gnu_sparse(args):
|
|
# Fix GNUSparseFile.0 folder in macOS if exists
|
|
global CONST_lib_ext, CONST_lib_dir
|
|
|
|
for dir in listdir(args.path):
|
|
if not isdir(join(args.path, dir)):
|
|
continue
|
|
if "GNUSparseFile" in dir:
|
|
for file in listdir(join(args.path, dir)):
|
|
if file.endswith(CONST_lib_ext):
|
|
if isdir(join(args.path, CONST_lib_dir)):
|
|
shutil.move(
|
|
join(args.path, dir, file), join(args.path, CONST_lib_dir)
|
|
)
|
|
else:
|
|
logging.error(
|
|
"%s directory not found", join(args.path, CONST_lib_dir)
|
|
)
|
|
try:
|
|
mkdir(join(args.path, CONST_lib_dir))
|
|
shutil.move(
|
|
join(args.path, dir, file),
|
|
join(args.path, CONST_lib_dir),
|
|
)
|
|
except:
|
|
pass
|
|
elif (
|
|
file.endswith(".h")
|
|
or file.endswith(".hpp")
|
|
or file.endswith(".inc")
|
|
):
|
|
shutil.move(join(args.path, dir, file), join(args.path, "include"))
|
|
else:
|
|
shutil.move(join(args.path, dir, file), join(args.path, "bin"))
|
|
for sub_dir in listdir(join(args.path, dir)):
|
|
if not isdir(join(args.path, dir, sub_dir)):
|
|
continue
|
|
if "GNUSparseFile" in sub_dir:
|
|
for file in listdir(join(args.path, dir, sub_dir)):
|
|
shutil.move(
|
|
join(args.path, dir, sub_dir, file), join(args.path, dir)
|
|
)
|
|
if len(listdir(join(args.path, dir, sub_dir))) == 0:
|
|
shutil.rmtree(join(args.path, dir, sub_dir))
|
|
|
|
|
|
def ldconfig(args, compat):
|
|
if geteuid() == 0:
|
|
# Only run ldconfig or update_dyld_shared_cache when user is root/sudoer
|
|
if compat.platform == "Linux":
|
|
cmd = "ldconfig {0}".format(join(args.path, CONST_lib_dir))
|
|
output = run_shell_command(cmd)
|
|
logging.debug("%s: %s", cmd, output)
|
|
elif compat.platform == "Darwin":
|
|
cmd = "update_dyld_shared_cache {0}".format(join(args.path, CONST_lib_dir))
|
|
output = run_shell_command(cmd)
|
|
logging.debug("%s: %s", cmd, output)
|
|
else:
|
|
logging.warning("Help adding ldconfig for your platform")
|
|
else:
|
|
logging.debug("Not root or sudoer, skip ldconfig")
|
|
|
|
|
|
def is_default_path(args):
|
|
global PATH
|
|
return args.path == abspath(PATH) or args.path[:4] != "/usr"
|
|
|
|
|
|
def install_image_extension(args, compat):
|
|
global CONST_release_pkg, CONST_lib_dir
|
|
|
|
if not get_remote_version_availability(
|
|
"second-state/WasmEdge-image", args.image_version
|
|
):
|
|
logging.error(
|
|
"Image extension version incorrect: {0}".format(args.image_version)
|
|
)
|
|
return -1
|
|
if compat.prefix() + IMAGE not in SUPPORTED_EXTENSIONS_VERSION:
|
|
logging.error("Image extensions not compatible: {0}".format(compat.prefix()))
|
|
return -1
|
|
elif (
|
|
SUPPORTED_EXTENSIONS_VERSION[compat.prefix() + IMAGE].compare(
|
|
args.image_version
|
|
)
|
|
> 0
|
|
):
|
|
logging.error(
|
|
"Min image extensions version: {0}".format(
|
|
SUPPORTED_EXTENSIONS_VERSION[compat.prefix() + IMAGE],
|
|
)
|
|
)
|
|
return -1
|
|
|
|
print("Downloading image extension")
|
|
|
|
local_release_package = CONST_release_pkg
|
|
|
|
# From WasmEdge 0.11.1, we have the Ubuntu release.
|
|
# Installation of ubuntu version extensions when the ubuntu version of WasmEdge selected.
|
|
if VersionString(args.image_version).compare("0.11.1") >= 0:
|
|
local_release_package = compat.release_package_wasmedge
|
|
logging.debug("Downloading dist package: {0}".format(local_release_package))
|
|
|
|
image_pkg = "WasmEdge-image-" + args.image_version + "-" + local_release_package
|
|
|
|
download_url(CONST_urls[IMAGE], join(TEMP_PATH, image_pkg), show_progress)
|
|
|
|
# Extract archive
|
|
extract_archive(
|
|
join(TEMP_PATH, image_pkg),
|
|
args.path,
|
|
join(TEMP_PATH, "WasmEdge-image"),
|
|
env_file_path=CONST_env_path,
|
|
remove_finished=True,
|
|
)
|
|
|
|
wasmedge_image_temp = join(TEMP_PATH, "WasmEdge-image")
|
|
for dir in listdir(wasmedge_image_temp):
|
|
wasmedge_image_temp_dir = join(wasmedge_image_temp, dir)
|
|
for file in listdir(wasmedge_image_temp_dir):
|
|
if isdir(join(wasmedge_image_temp_dir, file)) and "wasmedge" == file:
|
|
copytree(
|
|
join(wasmedge_image_temp_dir, file),
|
|
join(args.path, "include", "wasmedge"),
|
|
)
|
|
elif CONST_lib_ext in file:
|
|
if isdir(join(args.path, CONST_lib_dir)):
|
|
shutil.move(
|
|
join(wasmedge_image_temp_dir, file),
|
|
join(args.path, CONST_lib_dir, file),
|
|
)
|
|
else:
|
|
logging.error(
|
|
"%s directory not found", join(args.path, CONST_lib_dir)
|
|
)
|
|
try:
|
|
mkdir(join(args.path, CONST_lib_dir))
|
|
shutil.move(
|
|
join(wasmedge_image_temp_dir, file),
|
|
join(args.path, "lib", file),
|
|
)
|
|
except:
|
|
pass
|
|
elif isdir(join(wasmedge_image_temp_dir, file)):
|
|
copytree(
|
|
join(wasmedge_image_temp_dir, file),
|
|
join(args.path, file),
|
|
)
|
|
else:
|
|
shutil.move(
|
|
join(wasmedge_image_temp_dir, file),
|
|
join(args.path, "bin", file),
|
|
)
|
|
|
|
fix_gnu_sparse(args)
|
|
|
|
return 0
|
|
|
|
|
|
def install_tensorflow_extension(args, compat):
|
|
global CONST_release_pkg, CONST_lib_ext, CONST_lib_dir, CONST_env_path
|
|
|
|
if not get_remote_version_availability(
|
|
"second-state/WasmEdge-tensorflow", args.tf_version
|
|
):
|
|
logging.error(
|
|
"Tensorflow extension version incorrect: {0}".format(args.tf_version)
|
|
)
|
|
return -1
|
|
elif not get_remote_version_availability(
|
|
"second-state/WasmEdge-tensorflow-deps", args.tf_deps_version
|
|
):
|
|
logging.error(
|
|
"Tensorflow Deps extension version incorrect: {0}".format(
|
|
args.tf_deps_version
|
|
)
|
|
)
|
|
return -1
|
|
elif not get_remote_version_availability(
|
|
"second-state/WasmEdge-tensorflow", args.tf_tools_version
|
|
):
|
|
logging.error(
|
|
"Tensorflow Tools version incorrect: {0}".format(args.tf_tools_version)
|
|
)
|
|
return -1
|
|
|
|
if compat.prefix() + TENSORFLOW not in SUPPORTED_EXTENSIONS_VERSION:
|
|
logging.error(
|
|
"Tensorflow extensions not compatible: {0}".format(compat.prefix())
|
|
)
|
|
return -1
|
|
elif (
|
|
SUPPORTED_EXTENSIONS_VERSION[compat.prefix() + TENSORFLOW].compare(
|
|
args.tf_version
|
|
)
|
|
> 0
|
|
):
|
|
logging.error(
|
|
"Min tensorflow extensions version: {0}".format(
|
|
SUPPORTED_EXTENSIONS_VERSION[compat.prefix() + TENSORFLOW],
|
|
)
|
|
)
|
|
return -1
|
|
|
|
download_tf = True
|
|
download_tf_lite = True
|
|
|
|
if compat.machine == "aarch64":
|
|
download_tf = False
|
|
|
|
local_release_package = CONST_release_pkg
|
|
|
|
# From WasmEdge 0.11.1, we have the Ubuntu release.
|
|
# Installation of ubuntu version extensions when the ubuntu version of WasmEdge selected.
|
|
if VersionString(args.tf_version).compare("0.11.1") >= 0:
|
|
local_release_package = compat.release_package_wasmedge
|
|
logging.debug("Downloading dist package: {0}".format(local_release_package))
|
|
|
|
if download_tf:
|
|
tf_pkg = "WasmEdge-tensorflow-" + args.tf_version + "-" + local_release_package
|
|
tf_deps_pkg = (
|
|
"WasmEdge-tensorflow-deps-TF-"
|
|
+ args.tf_deps_version
|
|
+ "-"
|
|
+ CONST_release_pkg
|
|
)
|
|
|
|
print("Downloading tensorflow extension")
|
|
download_url(CONST_urls[TENSORFLOW], join(TEMP_PATH, tf_pkg), show_progress)
|
|
|
|
print("Downloading tensorflow-deps")
|
|
download_url(
|
|
CONST_urls[TENSORFLOW_DEPS], join(TEMP_PATH, tf_deps_pkg), show_progress
|
|
)
|
|
|
|
# Extract archive
|
|
extract_archive(
|
|
join(TEMP_PATH, tf_pkg),
|
|
args.path,
|
|
join(TEMP_PATH, "WasmEdge-tensorflow"),
|
|
env_file_path=CONST_env_path,
|
|
remove_finished=True,
|
|
)
|
|
|
|
# Extract archive
|
|
extract_archive(
|
|
join(TEMP_PATH, tf_deps_pkg),
|
|
join(args.path, CONST_lib_dir),
|
|
join(TEMP_PATH, "WasmEdge-tensorflow-deps", CONST_lib_dir),
|
|
env_file_path=CONST_env_path,
|
|
remove_finished=True,
|
|
)
|
|
|
|
copytree(join(TEMP_PATH, "WasmEdge-tensorflow"), args.path)
|
|
copytree(join(TEMP_PATH, "WasmEdge-tensorflow-deps"), args.path)
|
|
|
|
if download_tf_lite:
|
|
tf_lite_pkg = (
|
|
"WasmEdge-tensorflowlite-" + args.tf_version + "-" + local_release_package
|
|
)
|
|
tf_deps_lite_pkg = (
|
|
"WasmEdge-tensorflow-deps-TFLite-"
|
|
+ args.tf_deps_version
|
|
+ "-"
|
|
+ CONST_release_pkg
|
|
)
|
|
|
|
print("Downloading tensorflow-lite extension")
|
|
download_url(
|
|
CONST_urls[TENSORFLOW_LITE], join(TEMP_PATH, tf_lite_pkg), show_progress
|
|
)
|
|
|
|
print("Downloading tensorflow-lite-deps")
|
|
download_url(
|
|
CONST_urls[TENSORFLOW_LITE_DEPS],
|
|
join(TEMP_PATH, tf_deps_lite_pkg),
|
|
show_progress,
|
|
)
|
|
|
|
# Extract archive
|
|
extract_archive(
|
|
join(TEMP_PATH, tf_lite_pkg),
|
|
args.path,
|
|
join(TEMP_PATH, "WasmEdge-tensorflow-lite"),
|
|
env_file_path=CONST_env_path,
|
|
remove_finished=True,
|
|
)
|
|
|
|
# Extract archive
|
|
extract_archive(
|
|
join(TEMP_PATH, tf_deps_lite_pkg),
|
|
join(args.path, CONST_lib_dir),
|
|
join(TEMP_PATH, "WasmEdge-tensorflow-lite-deps", CONST_lib_dir),
|
|
env_file_path=CONST_env_path,
|
|
remove_finished=True,
|
|
)
|
|
|
|
copytree(join(TEMP_PATH, "WasmEdge-tensorflow-lite"), args.path)
|
|
copytree(join(TEMP_PATH, "WasmEdge-tensorflow-lite-deps"), args.path)
|
|
|
|
tf_tools_pkg = (
|
|
"WasmEdge-tensorflow-tools-" + args.tf_tools_version + "-" + CONST_release_pkg
|
|
)
|
|
|
|
print("Downloading tensorflow-tools extension")
|
|
download_url(
|
|
CONST_urls[TENSORFLOW_TOOLS], join(TEMP_PATH, tf_tools_pkg), show_progress
|
|
)
|
|
|
|
# Extract archive
|
|
extract_archive(
|
|
join(TEMP_PATH, tf_tools_pkg),
|
|
join(args.path, "bin"),
|
|
join(TEMP_PATH, "WasmEdge-tensorflow-tools", "bin"),
|
|
env_file_path=CONST_env_path,
|
|
remove_finished=True,
|
|
)
|
|
|
|
copytree(join(TEMP_PATH, "WasmEdge-tensorflow-tools"), args.path)
|
|
|
|
fix_gnu_sparse(args)
|
|
|
|
all_files = run_shell_command("ls -R {0}".format(TEMP_PATH))
|
|
|
|
if not isdir(join(args.path, CONST_lib_dir)):
|
|
logging.error("Strange: No %s directory found", CONST_lib_dir)
|
|
|
|
for file in listdir(join(args.path, CONST_lib_dir)):
|
|
if CONST_lib_ext not in file:
|
|
# ignore files that are not libraries
|
|
continue
|
|
if file not in all_files:
|
|
# ignore files that are not downloaded by this script
|
|
continue
|
|
if "tensorflow" not in file:
|
|
continue
|
|
# check if it contains any digits
|
|
if not any(i.isdigit() for i in file):
|
|
continue
|
|
if compat.platform == "Linux":
|
|
name, version = file.split(CONST_lib_ext, 1)
|
|
if version[0] == ".":
|
|
version = version[1:]
|
|
if version != "" and version.count(".") >= 2:
|
|
no_v_name = name + CONST_lib_ext
|
|
single_v_name = name + CONST_lib_ext + "." + version.split(".")[0]
|
|
dual_v_name = (
|
|
name
|
|
+ CONST_lib_ext
|
|
+ "."
|
|
+ version.split(".")[0]
|
|
+ "."
|
|
+ version.split(".")[1]
|
|
)
|
|
file_path = join(args.path, CONST_lib_dir, file)
|
|
single_v_file_path = join(args.path, CONST_lib_dir, single_v_name)
|
|
dual_v_file_path = join(args.path, CONST_lib_dir, dual_v_name)
|
|
no_v_file_path = join(args.path, CONST_lib_dir, no_v_name)
|
|
try:
|
|
symlink(file_path, single_v_file_path)
|
|
symlink(file_path, dual_v_file_path)
|
|
symlink(file_path, no_v_file_path)
|
|
except Exception as e:
|
|
logging.debug(e)
|
|
else:
|
|
continue
|
|
elif compat.platform == "Darwin":
|
|
name, version = file.split(CONST_lib_ext, 1)[0].split(".", 1)
|
|
if version != "" and version.count(".") >= 2:
|
|
no_v_name = name + CONST_lib_ext
|
|
single_v_name = name + "." + version.split(".")[0] + CONST_lib_ext
|
|
dual_v_name = (
|
|
name
|
|
+ "."
|
|
+ version.split(".")[0]
|
|
+ "."
|
|
+ version.split(".")[1]
|
|
+ CONST_lib_ext
|
|
)
|
|
file_path = join(args.path, CONST_lib_dir, file)
|
|
single_v_file_path = join(args.path, CONST_lib_dir, single_v_name)
|
|
dual_v_file_path = join(args.path, CONST_lib_dir, dual_v_name)
|
|
no_v_file_path = join(args.path, CONST_lib_dir, no_v_name)
|
|
try:
|
|
symlink(file_path, single_v_file_path)
|
|
symlink(file_path, dual_v_file_path)
|
|
symlink(file_path, no_v_file_path)
|
|
except Exception as e:
|
|
logging.debug(e)
|
|
else:
|
|
continue
|
|
else:
|
|
reraise(Exception("Not implemented for {0}".format(compat.platform)))
|
|
with opened_w_error(CONST_env_path, "a") as env_file:
|
|
if env_file is not None:
|
|
env_file.write("#" + single_v_file_path + "\n")
|
|
logging.debug("Appending:%s", single_v_file_path)
|
|
env_file.write("#" + dual_v_file_path + "\n")
|
|
logging.debug("Appending:%s", dual_v_file_path)
|
|
env_file.write("#" + no_v_file_path + "\n")
|
|
logging.debug("Appending:%s", no_v_file_path)
|
|
else:
|
|
logging.error("Not able to append installed files to env file")
|
|
|
|
for main_dir in ["WasmEdge-tensorflow", "WasmEdge-tensorflow-lite"]:
|
|
if not isdir(join(TEMP_PATH, main_dir)):
|
|
continue
|
|
for directory_file in listdir(join(TEMP_PATH, main_dir)):
|
|
if isdir(directory_file):
|
|
wasmedge_tf_folder = join(TEMP_PATH, main_dir, directory_file)
|
|
for _file in listdir(wasmedge_tf_folder):
|
|
if (
|
|
_file == "wasmedge"
|
|
and isdir(join(wasmedge_tf_folder, _file))
|
|
and is_default_path(args)
|
|
):
|
|
copytree(
|
|
join(wasmedge_tf_folder, _file),
|
|
join(args.path, "include", "wasmedge"),
|
|
)
|
|
elif CONST_lib_ext in _file:
|
|
if isdir(join(args.path, CONST_lib_dir)):
|
|
shutil.move(
|
|
join(wasmedge_tf_folder, _file),
|
|
join(args.path, CONST_lib_dir, _file),
|
|
)
|
|
else:
|
|
logging.error(
|
|
"%s is not a directory", join(args.path, CONST_lib_dir)
|
|
)
|
|
try:
|
|
mkdir(join(args.path, CONST_lib_dir))
|
|
shutil.move(
|
|
join(wasmedge_tf_folder, _file),
|
|
join(args.path, CONST_lib_dir, _file),
|
|
)
|
|
except:
|
|
pass
|
|
|
|
elif isdir(join(wasmedge_tf_folder, _file)):
|
|
copytree(
|
|
join(wasmedge_tf_folder, _file),
|
|
join(args.path, _file),
|
|
)
|
|
else:
|
|
shutil.move(
|
|
join(wasmedge_tf_folder, _file),
|
|
join(args.path, "bin", _file),
|
|
)
|
|
|
|
if download_tf:
|
|
# Check if wasmedge binary works
|
|
wasmedge_tf_output = run_shell_command(
|
|
". {0}/env &&{0}/bin/wasmedge-tensorflow --version".format(args.path)
|
|
)
|
|
|
|
if args.tf_version in wasmedge_tf_output:
|
|
print("WasmEdge Successfully installed")
|
|
else:
|
|
logging.critical(
|
|
"WasmEdge Tensorflow installation incorrect: {0}".format(
|
|
wasmedge_tf_output
|
|
)
|
|
)
|
|
|
|
if download_tf_lite:
|
|
# Check if wasmedge binary works
|
|
wasmedge_tf_lite_output = run_shell_command(
|
|
". {0}/env && {0}/bin/wasmedge-tensorflow-lite --version".format(args.path)
|
|
)
|
|
|
|
if args.tf_version in wasmedge_tf_lite_output:
|
|
print("WasmEdge Tensorflow Lite Successfully installed")
|
|
else:
|
|
logging.critical(
|
|
"WasmEdge Tensorflow installation incorrect: {0}".format(
|
|
wasmedge_tf_lite_output
|
|
)
|
|
)
|
|
|
|
return 0
|
|
|
|
|
|
def install_plugins(args, compat):
|
|
global CONST_lib_dir
|
|
url_root = "https://github.com/WasmEdge/WasmEdge/releases/download/"
|
|
url_root += "$VERSION$/WasmEdge-plugin-$PLUGIN_NAME$-$VERSION$-$DIST$_$ARCH$.tar.gz"
|
|
|
|
if len(args.plugins) >= 1:
|
|
for plugin_name in args.plugins:
|
|
plugin_version_supplied = None
|
|
if plugin_name.find(":") != -1:
|
|
plugin_name, plugin_version_supplied = plugin_name.split(":")
|
|
|
|
if plugin_name not in PLUGINS_AVAILABLE:
|
|
logging.error(
|
|
"%s plugin not found, available names - %s",
|
|
plugin_name,
|
|
PLUGINS_AVAILABLE,
|
|
)
|
|
continue
|
|
|
|
if compat.dist + compat.machine + plugin_name not in SUPPORTTED_PLUGINS:
|
|
logging.error(
|
|
"Plugin not compatible: %s",
|
|
compat.dist + compat.machine + plugin_name,
|
|
)
|
|
logging.debug("Supported: %s", SUPPORTTED_PLUGINS)
|
|
continue
|
|
else:
|
|
if plugin_version_supplied is None:
|
|
plugin_version_supplied = args.version
|
|
elif (
|
|
SUPPORTTED_PLUGINS[
|
|
compat.dist + compat.machine + plugin_name
|
|
].compare(plugin_version_supplied)
|
|
> 0
|
|
):
|
|
logging.error(
|
|
"Plugin not compatible: %s %s",
|
|
plugin_name,
|
|
plugin_version_supplied,
|
|
)
|
|
continue
|
|
|
|
plugin_url = (
|
|
url_root.replace("$PLUGIN_NAME$", plugin_name)
|
|
.replace("$VERSION$", plugin_version_supplied)
|
|
.replace("$DIST$", compat.dist)
|
|
.replace("$ARCH$", compat.machine)
|
|
)
|
|
logging.debug("Plugin URL: %s", plugin_url)
|
|
|
|
print("Downloading Plugin: " + plugin_name)
|
|
download_url(
|
|
plugin_url,
|
|
join(TEMP_PATH, "Plugin" + plugin_name) + ".tar.gz",
|
|
show_progress,
|
|
)
|
|
extract_archive(
|
|
join(TEMP_PATH, "Plugin" + plugin_name + ".tar.gz"),
|
|
join(args.path),
|
|
join(TEMP_PATH, "Plugins"),
|
|
env_file_path=CONST_env_path,
|
|
remove_finished=True,
|
|
)
|
|
|
|
if isdir(join(TEMP_PATH, "Plugins")):
|
|
if is_default_path(args):
|
|
copytree(join(TEMP_PATH, "Plugins"), join(args.path, "plugin"))
|
|
else:
|
|
copytree(
|
|
join(TEMP_PATH, "Plugins"),
|
|
join(args.path, CONST_lib_dir, "wasmedge"),
|
|
)
|
|
|
|
|
|
def set_consts(args, compat):
|
|
global CONST_release_pkg, CONST_ipkg, CONST_lib_ext, CONST_urls, CONST_lib_dir, CONST_env_path
|
|
CONST_release_pkg = compat.release_package
|
|
CONST_ipkg = compat.install_package_name
|
|
CONST_lib_ext = compat.lib_extension
|
|
|
|
local_release_package_tf = CONST_release_pkg
|
|
|
|
# From WasmEdge 0.11.1, we have the Ubuntu release.
|
|
# Installation of ubuntu version extensions when the ubuntu version of WasmEdge selected.
|
|
if VersionString(args.tf_version).compare("0.11.1") >= 0:
|
|
local_release_package_tf = compat.release_package_wasmedge
|
|
logging.debug("Tensorflow release pkg: {0}".format(local_release_package_tf))
|
|
|
|
local_release_package_im = CONST_release_pkg
|
|
|
|
# From WasmEdge 0.11.1, we have the Ubuntu release.
|
|
# Installation of ubuntu version extensions when the ubuntu version of WasmEdge selected.
|
|
if VersionString(args.image_version).compare("0.11.1") >= 0:
|
|
local_release_package_im = compat.release_package_wasmedge
|
|
logging.debug("Image release pkg: {0}".format(local_release_package_im))
|
|
|
|
CONST_urls = {
|
|
WASMEDGE: "https://github.com/WasmEdge/WasmEdge/releases/download/{0}/WasmEdge-{0}-{1}".format(
|
|
args.version, compat.release_package_wasmedge
|
|
),
|
|
WASMEDGE_UNINSTALLER: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/{0}/utils/uninstall.sh".format(
|
|
args.uninstall_script_tag
|
|
),
|
|
IMAGE: "https://github.com/second-state/WasmEdge-image/releases/download/{0}/WasmEdge-image-{0}-{1}".format(
|
|
args.image_version, local_release_package_im
|
|
),
|
|
TENSORFLOW_DEPS: "https://github.com/second-state/WasmEdge-tensorflow-deps/releases/download/{0}/WasmEdge-tensorflow-deps-TF-{0}-{1}".format(
|
|
args.tf_deps_version, CONST_release_pkg
|
|
),
|
|
TENSORFLOW_LITE_DEPS: "https://github.com/second-state/WasmEdge-tensorflow-deps/releases/download/{0}/WasmEdge-tensorflow-deps-TFLite-{0}-{1}".format(
|
|
args.tf_deps_version, CONST_release_pkg
|
|
),
|
|
TENSORFLOW: "https://github.com/second-state/WasmEdge-tensorflow/releases/download/{0}/WasmEdge-tensorflow-{0}-{1}".format(
|
|
args.tf_version, local_release_package_tf
|
|
),
|
|
TENSORFLOW_LITE: "https://github.com/second-state/WasmEdge-tensorflow/releases/download/{0}/WasmEdge-tensorflowlite-{0}-{1}".format(
|
|
args.tf_version, local_release_package_tf
|
|
),
|
|
TENSORFLOW_TOOLS: "https://github.com/second-state/WasmEdge-tensorflow-tools/releases/download/{0}/WasmEdge-tensorflow-tools-{0}-{1}".format(
|
|
args.tf_tools_version, CONST_release_pkg
|
|
),
|
|
}
|
|
|
|
|
|
def run_shell_command(cmd):
|
|
try:
|
|
output = subprocess.check_output([cmd], shell=True)
|
|
return output.decode("utf8").strip()
|
|
except subprocess.CalledProcessError as e:
|
|
if "Cannot detect installation path" in str(e.output):
|
|
logging.warning("Uninstaller did not find previous installation")
|
|
else:
|
|
print("Exception on process, rc=", e.returncode, "output=", e.output, e.cmd)
|
|
|
|
return ""
|
|
|
|
|
|
def get_latest_github_release(repo):
|
|
return run_shell_command(
|
|
"""git ls-remote --refs --tags "https://github.com/{0}.git" |
|
|
cut -d '/' -f 3 |
|
|
awk {1} | sort --version-sort | sed 's/_$//' |
|
|
grep -e '^[0-9]\+.[0-9]\+.[0-9]\+$' |
|
|
tail -1""".format(
|
|
repo,
|
|
"'{ if ($1 ~ /-/) print; else print $0\"_\" ;}'",
|
|
)
|
|
)
|
|
|
|
|
|
def get_remote_version_availability(repo, version):
|
|
output = run_shell_command(
|
|
"""git ls-remote --refs --tags "https://github.com/{0}.git" |
|
|
cut -d '/' -f 3 |
|
|
awk {1} | sort --version-sort | sed 's/_$//'""".format(
|
|
repo,
|
|
"'{ if ($1 ~ /-/) print; else print $0\"_\" ;}'",
|
|
)
|
|
)
|
|
if version in output:
|
|
return True
|
|
return False
|
|
|
|
|
|
class Compat:
|
|
def __init__(
|
|
self,
|
|
platform_=platform.system(),
|
|
machine=platform.machine(),
|
|
dist_=None,
|
|
version=None,
|
|
extensions=None,
|
|
):
|
|
self.platform = platform_ # Linux, Darwin
|
|
self.machine = machine # x86_64, arm
|
|
self.version = VersionString(version)
|
|
self.extensions = extensions
|
|
self.release_package = None
|
|
self.install_package_name = None
|
|
self.lib_extension = None
|
|
self.ld_library_path = None
|
|
self.dist = dist_
|
|
self.release_package_wasmedge = None
|
|
|
|
if self.platform == "Linux":
|
|
self.install_package_name = "WasmEdge-{0}-Linux".format(self.version)
|
|
self.lib_extension = ".so"
|
|
self.ld_library_path = "LD_LIBRARY_PATH"
|
|
|
|
if self.machine in ["arm64", "armv8", "aarch64"]:
|
|
self.release_package = "manylinux2014_aarch64.tar.gz"
|
|
elif self.machine in ["x86_64", "amd64"]:
|
|
self.release_package = "manylinux2014_x86_64.tar.gz"
|
|
else:
|
|
reraise(Exception("Unsupported arch: {0}".format(self.machine)))
|
|
|
|
self.release_package_wasmedge = self.release_package
|
|
|
|
if self.dist is None:
|
|
if sys.version_info[0] == 2:
|
|
if (
|
|
"Ubuntu" in platform.dist() and "20.04" in platform.dist()
|
|
) or "Ubuntu 20.04" in run_shell_command(
|
|
"lsb_release -d | awk -F'\t' '{print $2}'"
|
|
):
|
|
self.dist = "ubuntu20.04"
|
|
else:
|
|
self.dist = "manylinux2014"
|
|
elif sys.version_info[0] == 3:
|
|
__lsb_rel = run_shell_command(
|
|
"cat /etc/lsb-release | grep RELEASE"
|
|
)[-5:]
|
|
if "20.04" == __lsb_rel or "Ubuntu 20.04" in run_shell_command(
|
|
"lsb_release -d | awk -F'\t' '{print $2}'"
|
|
):
|
|
self.dist = "ubuntu20.04"
|
|
else:
|
|
self.dist = "manylinux2014"
|
|
|
|
# Below version 0.11.1 different distributions for wasmedge binary do not exist
|
|
if self.version.compare("0.11.1") != -1:
|
|
if self.machine in ["arm64", "armv8", "aarch64"]:
|
|
self.release_package_wasmedge = self.dist + "_aarch64.tar.gz"
|
|
elif self.machine in ["x86_64", "amd64"]:
|
|
self.release_package_wasmedge = self.dist + "_x86_64.tar.gz"
|
|
else:
|
|
reraise(Exception("Unsupported arch: {0}".format(self.machine)))
|
|
|
|
elif self.platform == "Darwin":
|
|
self.ld_library_path = "DYLD_LIBRARY_PATH"
|
|
self.install_package_name = "WasmEdge-{0}-Darwin".format(self.version)
|
|
self.release_package = "darwin_{0}.tar.gz".format(self.machine)
|
|
self.release_package_wasmedge = self.release_package
|
|
self.lib_extension = ".dylib"
|
|
if self.dist is None:
|
|
self.dist = "darwin"
|
|
|
|
def __str__(self):
|
|
return (
|
|
"Platform:{0}\nMachine:{1}\nVersion:{2}\nExtensions:{3}\nDist:{4}\n".format(
|
|
self.platform, self.machine, self.version, self.extensions, self.dist
|
|
)
|
|
)
|
|
|
|
if sys.version_info[0] == 2:
|
|
|
|
def __nonzero__(self):
|
|
return self.bool_overload()
|
|
|
|
elif sys.version_info[0] == 3:
|
|
|
|
def __bool__(self):
|
|
return self.bool_overload()
|
|
|
|
def bool_overload(self):
|
|
if self.platform not in SUPPORTED_PLATFORM_MACHINE:
|
|
reraise(Exception("Unsupported platform: {0}".format(self.platform)))
|
|
if self.machine not in SUPPORTED_PLATFORM_MACHINE[self.platform]:
|
|
reraise(Exception("Unsupported machine: {0}".format(self.machine)))
|
|
if self.extensions is not None and len(self.extensions) > 0:
|
|
if not (
|
|
set(self.extensions)
|
|
<= set(SUPPORTED_EXTENSIONS[self.platform + self.machine])
|
|
):
|
|
reraise(
|
|
Exception(
|
|
"Extensions not supported: {0}. Supported extensions: {1}".format(
|
|
self.extensions,
|
|
SUPPORTED_EXTENSIONS[self.platform + self.machine],
|
|
)
|
|
)
|
|
)
|
|
if (
|
|
self.version.compare(
|
|
version2=SUPPORTED_MIN_VERSION[self.platform + self.machine].version
|
|
)
|
|
< 0
|
|
):
|
|
reraise(
|
|
Exception(
|
|
"Version not supported. Min Version: {0}".format(
|
|
SUPPORTED_MIN_VERSION[self.platform + self.machine].version
|
|
)
|
|
)
|
|
)
|
|
|
|
if not get_remote_version_availability(
|
|
"WasmEdge/WasmEdge", self.version.version
|
|
):
|
|
reraise(
|
|
Exception(
|
|
"Version {0} does not exist in remote repository of WasmEdge".format(
|
|
self.version.version
|
|
)
|
|
)
|
|
)
|
|
return True
|
|
|
|
def prefix(self):
|
|
return self.platform + self.machine
|
|
|
|
|
|
def main(args):
|
|
global CONST_env_path, CONST_release_pkg, CONST_ipkg, CONST_shell_config, CONST_shell_profile, CONST_lib_dir
|
|
|
|
compat = Compat(
|
|
version=args.version,
|
|
extensions=args.extensions,
|
|
platform_=args.platform,
|
|
machine=args.machine,
|
|
dist_=args.dist,
|
|
)
|
|
|
|
logging.debug("Compat object: %s", compat)
|
|
logging.debug("Temp path: %s", TEMP_PATH)
|
|
logging.debug("CLI Args:")
|
|
logging.debug(args)
|
|
|
|
if len(args.plugins) >= 1:
|
|
logging.warning("Experimental Option Selected: plugins")
|
|
logging.warning("plugins option may change later")
|
|
|
|
if compat:
|
|
print("Compatible with current configuration")
|
|
|
|
set_consts(args, compat)
|
|
|
|
# Run uninstaller
|
|
uninstaller_path = join(TEMP_PATH, "uninstall.sh")
|
|
download_url(CONST_urls[WASMEDGE_UNINSTALLER], uninstaller_path)
|
|
|
|
print("Running Uninstaller")
|
|
|
|
logging.debug(
|
|
run_shell_command("bash {0} -p {1} -q".format(uninstaller_path, args.path))
|
|
)
|
|
remove(uninstaller_path)
|
|
|
|
# If args.path is default then remove it initially
|
|
if PATH in args.path and exists(args.path):
|
|
shutil.rmtree(args.path)
|
|
|
|
set_env(args, compat)
|
|
|
|
logging.debug("CONST_env_path: %s", CONST_env_path)
|
|
logging.debug("CONST_release_pkg: %s", CONST_release_pkg)
|
|
logging.debug("CONST_ipkg: %s", CONST_ipkg)
|
|
logging.debug("CONST_lib_ext: %s", CONST_lib_ext)
|
|
logging.debug("CONST_urls: %s", CONST_urls)
|
|
logging.debug("CONST_lib_dir: %s", CONST_lib_dir)
|
|
|
|
if getenv("SHELL") != SHELL:
|
|
logging.warning("SHELL variable not found. Using %s as SHELL", SHELL)
|
|
|
|
if shell_configure(args, compat) != 0:
|
|
logging.error("Error in configuring shell")
|
|
|
|
logging.debug("CONST_shell_profile: %s", CONST_shell_profile)
|
|
logging.debug("CONST_shell_config: %s", CONST_shell_config)
|
|
|
|
print("Downloading WasmEdge")
|
|
|
|
# Download WasmEdge
|
|
download_url(
|
|
CONST_urls[WASMEDGE], join(TEMP_PATH, CONST_release_pkg), show_progress
|
|
)
|
|
|
|
# Extract archive
|
|
extract_archive(
|
|
join(TEMP_PATH, CONST_release_pkg),
|
|
args.path,
|
|
join(TEMP_PATH),
|
|
env_file_path=CONST_env_path,
|
|
remove_finished=True,
|
|
)
|
|
|
|
print("Installing WasmEdge")
|
|
# Copy the tree
|
|
for sub_dir in listdir(join(TEMP_PATH, CONST_ipkg)):
|
|
if sub_dir == "lib64":
|
|
copytree(join(TEMP_PATH, CONST_ipkg, sub_dir), join(args.path, "lib"))
|
|
else:
|
|
copytree(join(TEMP_PATH, CONST_ipkg, sub_dir), join(args.path, sub_dir))
|
|
|
|
if is_default_path(args):
|
|
# perform actions if default path
|
|
for dir in listdir(args.path):
|
|
path = join(args.path, dir)
|
|
if not isdir(path):
|
|
continue
|
|
for subdir in listdir(path):
|
|
sub_folder = join(path, subdir)
|
|
if isdir(sub_folder):
|
|
if any("Plugin" in s for s in listdir(sub_folder)):
|
|
# Handle plugins
|
|
copytree(sub_folder, join(args.path, "plugin"), True)
|
|
shutil.rmtree(sub_folder)
|
|
|
|
# Check if wasmedge binary works
|
|
wasmedge_output = run_shell_command(
|
|
". {0}/env && {0}/bin/wasmedge --version".format(args.path)
|
|
)
|
|
|
|
if args.version in wasmedge_output:
|
|
print("WasmEdge Successfully installed")
|
|
else:
|
|
logging.critical(
|
|
"WasmEdge installation incorrect: {0}".format(wasmedge_output)
|
|
)
|
|
|
|
if IMAGE in args.extensions or "all" in args.extensions:
|
|
if install_image_extension(args, compat) != 0:
|
|
logging.error("Error in installing image extensions")
|
|
else:
|
|
print("Image extension installed")
|
|
|
|
if TENSORFLOW in args.extensions or "all" in args.extensions:
|
|
if install_tensorflow_extension(args, compat) != 0:
|
|
logging.error("Error in installing tensorflow extensions")
|
|
else:
|
|
print("Tensorflow extension installed")
|
|
|
|
install_plugins(args, compat)
|
|
|
|
ldconfig(args, compat)
|
|
|
|
# Cleanup
|
|
shutil.rmtree(TEMP_PATH)
|
|
|
|
if compat.platform != "Darwin":
|
|
print("Run:\nsource {0}".format(CONST_shell_config))
|
|
else:
|
|
print("Run:\nsource {0}".format(CONST_shell_profile))
|
|
else:
|
|
reraise(Exception("Incompatible with your machine\n{0}".format(compat)))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser(
|
|
description="WasmEdge installation, uninstallation and extensions install"
|
|
)
|
|
parser.add_argument(
|
|
"-e",
|
|
"--extension",
|
|
dest="extensions",
|
|
choices=EXTENSIONS.append("all"),
|
|
required=False,
|
|
default=[],
|
|
nargs="*",
|
|
help="Supported Extensions - {0}".format(EXTENSIONS),
|
|
)
|
|
parser.add_argument(
|
|
"-v",
|
|
"--version",
|
|
dest="version",
|
|
default=get_latest_github_release("WasmEdge/WasmEdge"),
|
|
required=False,
|
|
help="Version for WasmEdge",
|
|
)
|
|
parser.add_argument(
|
|
"-D",
|
|
"--debug",
|
|
dest="loglevel",
|
|
required=False,
|
|
action="store_const",
|
|
const=logging.DEBUG,
|
|
help="Verbosity debug",
|
|
)
|
|
parser.add_argument(
|
|
"-p",
|
|
"--path",
|
|
dest="path",
|
|
required=False,
|
|
default=PATH,
|
|
help="Installation path for WasmEdge",
|
|
)
|
|
parser.add_argument(
|
|
"-r",
|
|
"--remove-old",
|
|
dest="remove_old",
|
|
required=False,
|
|
choices=["yes", "no"],
|
|
help="Run uninstaller script before installing",
|
|
)
|
|
parser.add_argument(
|
|
"-u",
|
|
"--uninstall-script-tag",
|
|
dest="uninstall_script_tag",
|
|
required=False,
|
|
default=get_latest_github_release("WasmEdge/WasmEdge"),
|
|
help="GitHub tag for uninstall script",
|
|
)
|
|
parser.add_argument(
|
|
"--plugins",
|
|
dest="plugins",
|
|
required=False,
|
|
default=[],
|
|
nargs="*",
|
|
help="(experimental option)Supported Plugins. Example\n"
|
|
+ "--plugins wasi_crypto:0.11.0\n"
|
|
+ "--plugins wasi_crypto",
|
|
)
|
|
parser.add_argument(
|
|
"--tf-version",
|
|
dest="tf_version",
|
|
required=False,
|
|
default=None,
|
|
help="Tensorflow and tensorflow lite version",
|
|
)
|
|
parser.add_argument(
|
|
"--tf-deps-version",
|
|
dest="tf_deps_version",
|
|
required=False,
|
|
default=None,
|
|
help="Tensorflow and tensorflow lite deps version",
|
|
)
|
|
parser.add_argument(
|
|
"--tf-tools-version",
|
|
dest="tf_tools_version",
|
|
required=False,
|
|
default=None,
|
|
help="Tensorflow and tensorflow lite tools version",
|
|
)
|
|
parser.add_argument(
|
|
"--image-version",
|
|
dest="image_version",
|
|
required=False,
|
|
default=None,
|
|
help="Image extension version",
|
|
)
|
|
parser.add_argument(
|
|
"--platform",
|
|
"--os",
|
|
dest="platform",
|
|
required=False,
|
|
default=platform.system(),
|
|
choices=["Linux", "Darwin"],
|
|
type=lambda s: s.title(),
|
|
help="Platform ex- Linux, Darwin, Windows",
|
|
)
|
|
parser.add_argument(
|
|
"--machine",
|
|
"--arch",
|
|
dest="machine",
|
|
required=False,
|
|
default=platform.machine(),
|
|
choices=["x86_64", "aarch64", "arm", "arm64"],
|
|
type=lambda s: s.lower(),
|
|
help="Machine ex- x86_64, aarch64",
|
|
)
|
|
parser.add_argument(
|
|
"--dist",
|
|
dest="dist",
|
|
required=False,
|
|
default=None,
|
|
choices=["ubuntu20.04", "manylinux2014"],
|
|
type=lambda s: s.lower(),
|
|
help="Dist ex- ubuntu20.04,manylinux2014",
|
|
)
|
|
args = parser.parse_args()
|
|
|
|
logging.basicConfig(format="%(levelname)-8s- %(message)s", level=args.loglevel)
|
|
|
|
args.path = abspath(args.path)
|
|
|
|
if args.tf_version is None:
|
|
args.tf_version = args.version
|
|
|
|
if args.tf_deps_version is None:
|
|
args.tf_deps_version = args.version
|
|
|
|
if args.tf_tools_version is None:
|
|
args.tf_tools_version = args.version
|
|
|
|
if args.image_version is None:
|
|
args.image_version = args.version
|
|
|
|
logging.debug("Python Version: %s", sys.version_info)
|
|
main(args)
|