def main():
logger = CLILogger()
parser = argparse.ArgumentParser(description="SD-card Wiping Tool")
parser.add_argument("--sdcard", help="Device path for the SD-card", required=True)
# defaults to help
args = parser.parse_args(["--help"] if len(sys.argv) < 2 else None)
sys.exit(wipe_card(logger, sd_card=args.sdcard))
def main():
def default(logger, build_folder, cache_folder, **kwargs):
parser.parse_args(["--help"])
parser = argparse.ArgumentParser(
description="Cache Folder management tool")
parser.add_argument("--build",
help="Build Folder containing the cache one",
required=True)
parser.set_defaults(func=default)
subparsers = parser.add_subparsers()
parser_show = subparsers.add_parser("show", help="List files in cache")
parser_show.set_defaults(func=list_cache_files)
parser_clean = subparsers.add_parser(
"clean", help="Remove obsolete files from cache")
parser_clean.set_defaults(func=clean_cache)
parser_reset = subparsers.add_parser("reset",
help="Reset cache folder completely")
parser_reset.set_defaults(func=reset_cache)
parser_reset.add_argument(
"--keep-master",
help="Keep the latest master image if it exists",
action="store_true",
)
# defaults to help
args = parser.parse_args(["--help"] if len(sys.argv) < 2 else None)
logger = CLILogger()
build_folder = args.build
if not os.path.exists(build_folder) or not os.path.isdir(build_folder):
logger.err("Build folder is not a directory.")
sys.exit(1)
cache_folder = get_cache(build_folder)
# ensure we have a proper list of contents and packages to match against
init(logger)
sys.exit(args.func(logger, build_folder, cache_folder, **args.__dict__))
def flash_image_with_etcher(image_fpath,
device_fpath,
retcode,
from_cli=False):
""" flash an image onto SD-card
use only with small image as there is no output capture on OSX
and it is not really cancellable.
retcode is a multiprocessing.Value """
logger = CLILogger()
cmd, log_to_file, log_file = get_etcher_command(image_fpath, device_fpath,
logger, from_cli)
returncode, _ = subprocess_pretty_call(cmd, check=False, logger=logger)
retcode.value = returncode
if log_to_file:
try:
subprocess_pretty_call(["/bin/cat", log_file.name], logger)
log_file.close()
os.unlink(log_file.name)
except Exception as exp:
logger.err(str(exp))
return returncode == 0
def get_package_content(package_id):
""" content-like dict for packages (zim file or static site) """
for catalog in get_catalogs(CLILogger()):
try:
package = catalog["all"][package_id]
package.update(
{"ext": "zip" if package["type"] != "zim" else "zim"})
package.update({"langid": package.get("langid") or package_id})
return {
"url":
package["url"],
"name":
"{langid}.{ext}".format(**package),
"checksum":
package["sha256sum"],
"archive_size":
package["size"],
# add a 10% margin for non-zim (zip file mostly)
"expanded_size":
package["size"] *
1.1 if package["type"] != "zim" else package["size"],
}
except KeyError:
continue
error = run_in_qemu(image_fpath, disk_size, root_size, logger,
CancelEvent(), qemu_ram)
if error:
logger.err("ERROR: unable to properly create image: {}".format(error))
sys.exit(1)
logger.std("SUCCESS! {} was built successfuly".format(image_fpath))
parser = argparse.ArgumentParser(
description="Kiwix Hotspot master image creator")
parser.add_argument("--root", help="root partition size (GB)", default=7)
parser.add_argument("--size", help="Image (SD card) size (GB)", default=8)
parser.add_argument("--build",
help="Folder to create files in",
default=os.path.abspath("."))
parser.add_argument("--ram", help="RAM to be used by QEMU", default="2G")
parser.add_argument("--out", help="Master image filename (inside --build)")
args = parser.parse_args()
main(
logger=CLILogger(),
disk_size=args.size,
root_size=args.root,
build_folder=args.build,
image_fname=args.out,
qemu_ram=args.ram,
)
from util import CancelEvent
from util import check_user_inputs
from version import get_version_str
from util import CLILogger, b64decode
from util import get_free_space_in_dir
from util import get_adjusted_image_size
from backend.catalog import get_catalogs
from run_installation import run_installation
from util import human_readable_size, get_cache
from backend.util import sd_has_single_partition, is_admin
import tzlocal
import humanfriendly
CANCEL_TIMEOUT = 5
logger = CLILogger()
logger.std("Kiwix Hotspot {v}".format(v=get_version_str()))
def set_config(config, args):
def get_choices(option):
return [x for x in parser._actions if x.dest == option][-1].choices
def setif(key, value):
if getattr(args, key, None) is None:
setattr(args, key, value)
if not isinstance(config, dict):
return
# direct arguments