def test_simple(self):
ipkg = InstalledPkgDescription(self.sections, self.meta, {})
sections = ipkg.resolve_paths()
res = sorted([(kind, source, target) for kind, source, target in iter_files(sections)])
target_dir = ipkg.resolve_path(os.path.join("$prefix", "target"))
ref = [("pythonfiles", os.path.join("source", "scripts", "bar.py"), os.path.join(target_dir, "scripts", "bar.py")),
("pythonfiles", os.path.join("source", "scripts", "foo.py"), os.path.join(target_dir, "scripts", "foo.py"))]
self.assertEqual(res, ref)
def store(self, filename, pkg):
s = get_configured_state()
scheme = dict([(k, s.paths[k]) for k in s.paths])
meta = ipkg_meta_from_pkg(pkg)
p = InstalledPkgDescription(self.sections, meta, scheme,
pkg.executables)
p.write(filename)
def test_simple_roundtrip(self):
# FIXME: we compare the loaded json to avoid dealing with encoding
# differences when comparing objects, but this is kinda stupid
r_ipkg = InstalledPkgDescription(self.sections, self.meta, {})
f = StringIO()
r_ipkg._write(f)
r_s = f.getvalue()
ipkg = InstalledPkgDescription.from_string(r_s)
f = StringIO()
ipkg._write(f)
s = f.getvalue()
self.assertEqual(json.loads(r_s), json.loads(s))
def test_simple_roundtrip(self):
# FIXME: we compare the loaded json to avoid dealing with encoding
# differences when comparing objects, but this is kinda stupid
r_ipkg = InstalledPkgDescription(self.sections, self.meta, {})
f = StringIO()
r_ipkg._write(f)
r_s = f.getvalue()
ipkg = InstalledPkgDescription.from_string(r_s)
f = StringIO()
ipkg._write(f)
s = f.getvalue()
self.assertEqual(json.loads(r_s), json.loads(s))
def test_simple(self):
ipkg = InstalledPkgDescription(self.sections, self.meta, {})
sections = ipkg.resolve_paths(self.top_node)
res = sorted([(kind, source.abspath(), target.abspath()) \
for kind, source, target in iter_files(sections)])
target_dir = ipkg.resolve_path(os.path.join("$prefix", "target"))
ref = [("pythonfiles",
os.path.join(self.top_node.abspath(), "source", "scripts",
"bar.py"),
os.path.join(target_dir, "scripts", "bar.py")),
("pythonfiles",
os.path.join(self.top_node.abspath(), "source", "scripts",
"foo.py"),
os.path.join(target_dir, "scripts", "foo.py"))]
self.assertEqual(res, ref)
def run(self, ctx):
argv = ctx.get_command_arguments()
p = ctx.options_context.parser
o, a = p.parse_args(argv)
if o.help:
p.print_help()
return
if o.dry_run:
return
n = ctx.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
scheme = ctx.get_paths_scheme()
ipkg.update_paths(scheme)
node_sections = ipkg.resolve_paths_with_destdir(ctx.build_node)
if o.list_files:
# XXX: this won't take into account action in post install scripts.
# A better way would be to log install steps and display those, but
# this will do for now.
for kind, source, target in iter_files(node_sections):
print(target.abspath())
return
if o.transaction:
trans = TransactionLog("transaction.log")
try:
for kind, source, target in iter_files(node_sections):
trans.copy(source.abspath(), target.abspath(), kind)
finally:
trans.close()
else:
for kind, source, target in iter_files(node_sections):
copy_installer(source.abspath(), target.abspath(), kind)
def run(self, ctx):
argv = ctx.command_argv
p = ctx.options_context.parser
o, a = p.parse_args(argv)
if o.help:
p.print_help()
return
n = ctx.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
scheme = ctx.retrieve_configured_scheme()
ipkg.update_paths(scheme)
node_sections = ipkg.resolve_paths_with_destdir(ctx.build_node)
if o.list_files:
# XXX: this won't take into account action in post install scripts.
# A better way would be to log install steps and display those, but
# this will do for now.
for kind, source, target in iter_files(node_sections):
print(target.abspath())
return
if o.transaction:
trans = TransactionLog("transaction.log")
try:
for kind, source, target in iter_files(node_sections):
trans.copy(source.abspath(), target.abspath(), kind)
finally:
trans.close()
else:
for kind, source, target in iter_files(node_sections):
copy_installer(source.abspath(), target.abspath(), kind)
def run(self, ctx):
argv = ctx.get_command_arguments()
p = ctx.options_context.parser
o, a = p.parse_args(argv)
if o.help:
p.print_help()
return
root = ctx.top_node
while root.height() > 0:
root = root.parent
default_scheme = get_default_scheme(ctx.pkg.name)
default_prefix = default_scheme["prefix"]
default_sitedir = default_scheme["sitedir"]
n = ctx.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
name = ipkg.meta["name"]
version = ipkg.meta["version"]
py_short = ".".join([str(i) for i in sys.version_info[:2]])
mpkg_name = "%s-%s-py%s.mpkg" % (name, version, py_short)
categories = set()
file_sections = ipkg.resolve_paths(ctx.build_node)
for kind, source, target in iter_files(file_sections):
categories.add(kind)
# Mpkg metadata
mpkg_root = os.path.join(os.getcwd(), "dist", mpkg_name)
mpkg_cdir = os.path.join(mpkg_root, "Contents")
if os.path.exists(mpkg_root):
shutil.rmtree(mpkg_root)
os.makedirs(mpkg_cdir)
f = open(os.path.join(mpkg_cdir, "PkgInfo"), "w")
try:
f.write("pmkrpkg1")
finally:
f.close()
mpkg_info = MetaPackageInfo.from_ipkg(ipkg)
purelib_pkg = "%s-purelib-%s-py%s.pkg" % (name, version, py_short)
scripts_pkg = "%s-scripts-%s-py%s.pkg" % (name, version, py_short)
datafiles_pkg = "%s-datafiles-%s-py%s.pkg" % (name, version, py_short)
mpkg_info.packages = [purelib_pkg, scripts_pkg, datafiles_pkg]
make_mpkg_plist(mpkg_info, os.path.join(mpkg_cdir, "Info.plist"))
mpkg_rdir = os.path.join(mpkg_root, "Contents", "Resources")
os.makedirs(mpkg_rdir)
make_mpkg_description(mpkg_info, os.path.join(mpkg_rdir, "Description.plist"))
# Package the stuff which ends up into site-packages
pkg_root = os.path.join(mpkg_root, "Contents", "Packages", purelib_pkg)
build_pkg_from_temp(ctx, ipkg, pkg_root, root, "/", ["pythonfiles"], "Pure Python modules and packages")
pkg_root = os.path.join(mpkg_root, "Contents", "Packages", scripts_pkg)
build_pkg_from_temp(ctx, ipkg, pkg_root, root, "/", ["executables"], "Scripts and binaries")
pkg_root = os.path.join(mpkg_root, "Contents", "Packages", datafiles_pkg)
build_pkg_from_temp(ctx, ipkg, pkg_root, root, "/", ["bentofiles", "datafiles"], "Data files")
def test_create_exe(self):
# FIXME: do a real test here
meta, sections, nodes = create_simple_ipkg_args(self.top_node)
ipkg = InstalledPkgDescription(sections, meta, {})
fid, arcname = tempfile.mkstemp(prefix="zip")
try:
create_exe(ipkg, arcname, "some-name.exe")
finally:
os.close(fid)
def run(self, ctx):
argv = ctx.get_command_arguments()
p = ctx.options_context.parser
o, a = p.parse_args(argv)
if o.help:
p.print_help()
return
n = ctx.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
create_wininst(ipkg, src_root_node=ctx.build_node, build_node=ctx.build_node)
def run(self, ctx):
opts = ctx.cmd_opts
o, a = self.parser.parse_args(opts)
if o.help:
self.parser.print_help()
return
if not os.path.exists(IPKG_PATH):
raise UsageException("%s: error: %s subcommand require executed build" \
% (SCRIPT_NAME, "build_wininst"))
ipkg = InstalledPkgDescription.from_file(IPKG_PATH)
create_wininst(ipkg)
def run(self, ctx):
argv = ctx.command_argv
p = ctx.options_context.parser
o, a = p.parse_args(argv)
if o.help:
p.print_help()
return
output_dir = o.output_dir
output_file = o.output_file
n = ctx.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
build_egg(ipkg, ctx, ctx.build_node, output_dir, output_file)
def run(self, ctx):
argv = ctx.command_argv
p = ctx.options_context.parser
o, a = p.parse_args(argv)
if o.help:
p.print_help()
return
output_dir = o.output_dir
output_file = o.output_file
n = ctx.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
build_egg(ipkg, ctx, ctx.build_node, output_dir, output_file)
def run(self):
build = self.get_finalized_command("build")
build.run()
dist = build.distribution
n = dist.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
build_node = self.distribution.build_node
# FIXME: fix build_egg signature - we use a dummy context here to avoid
# creating the whole command context stuff
context = _FakeContext(build_node)
build_egg(ipkg, context, build_node.abspath())
def run(self):
self.run_command("build")
dist = self.distribution
n = dist.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
egg_info = EggInfo.from_ipkg(ipkg, dist.build_node)
egg_info_dir = op.join(self.egg_base, "%s.egg-info" % dist.pkg.name)
try:
os.makedirs(egg_info_dir)
except OSError, e:
if e.errno != 17:
raise
def run(self, ctx):
argv = ctx.command_argv
p = ctx.options_context.parser
o, a = p.parse_args(argv)
if o.help:
p.print_help()
return
n = ctx.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
create_wininst(ipkg,
src_root_node=ctx.build_node,
build_node=ctx.build_node,
wininst=o.output_file,
output_dir=o.output_dir)
def run(self):
self.run_command("build")
dist = self.distribution
n = dist.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
egg_info = EggInfo.from_ipkg(ipkg, dist.build_node)
egg_info_dir = op.join(self.egg_base, "%s.egg-info" % dist.pkg.name)
try:
os.makedirs(egg_info_dir)
except OSError, e:
if e.errno != 17:
raise
def run(self, ctx):
argv = ctx.get_command_arguments()
p = ctx.options_context.parser
o, a = p.parse_args(argv)
if o.help:
p.print_help()
return
if o.output_dir is None:
output_dir = None
else:
output_dir = o.output_dir
n = ctx.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
build_egg(ipkg, ctx, ctx.build_node, output_dir)
def run(self, ctx):
opts = ctx.cmd_opts
o, a = self.parser.parse_args(opts)
if o.help:
self.parser.print_help()
return
if not os.path.exists(IPKG_PATH):
msg = "%s file not found ! (Did you run build ?)" % IPKG_PATH
raise UsageException(msg)
ipkg = InstalledPkgDescription.from_file(IPKG_PATH)
file_sections = ipkg.resolve_paths()
for kind, source, target in iter_files(file_sections):
copy_installer(source, target, kind)
def write_record(self):
dist = self.distribution
options_context = dist.global_context.retrieve_options_context(self.cmd_name)
cmd_context_klass = dist.global_context.retrieve_command_context(self.cmd_name)
context = cmd_context_klass(dist.global_context, [], options_context, dist.pkg, dist.run_node)
n = context.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
scheme = context.retrieve_configured_scheme()
ipkg.update_paths(scheme)
file_sections = ipkg.resolve_paths_with_destdir(src_root_node=context.build_node)
def writer(fid):
for kind, source, target in iter_files(file_sections):
fid.write("%s\n" % target.abspath())
bento.utils.io2.safe_write(self.record, writer, "w")
def test_simple(self):
"""This just tests whether create_wininst runs at all and produces a zip-file."""
ipackage = InstalledPkgDescription({}, {
"name": "foo",
"version": "1.0"
}, {})
create_wininst(ipackage,
self.build_node,
self.build_node,
wininst="foo.exe",
output_dir="dist")
arcname = bento.commands.build_wininst.create_exe.call_args[0][1]
fp = zipfile.ZipFile(arcname)
try:
fp.namelist()
finally:
fp.close()
def write_record(self):
dist = self.distribution
install = InstallCommand()
options_context = OptionsContext.from_command(install)
context = CmdContext([], options_context, dist.pkg, dist.run_node)
if self.record:
n = context.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
scheme = context.get_paths_scheme()
ipkg.update_paths(scheme)
file_sections = ipkg.resolve_paths(src_root_dir=context.build_node.abspath())
fid = open(self.record, "w")
try:
for kind, source, target in iter_files(file_sections):
fid.write("%s\n" % target)
finally:
fid.close()
def extract_egg(egg, extract_dir):
# Given a bento-produced egg, extract its content in the given directory,
# and returned the corresponding ipkg info instance
ipkg = InstalledPkgDescription.from_egg(egg)
# egg scheme
ipkg.update_paths({"prefix": ".", "eprefix": ".", "sitedir": "."})
zid = zipfile.ZipFile(egg)
try:
for type, sections in ipkg.files.items():
for name, section in sections.items():
target_dir = ipkg.resolve_path(section.target_dir)
section.source_dir = os.path.join(extract_dir, target_dir)
for source, target in section.files:
g = os.path.join(target_dir, target)
g = os.path.normpath(g)
zid.extract(g, extract_dir)
finally:
zid.close()
return ipkg
def write_record(self):
dist = self.distribution
options_context = dist.global_context.retrieve_options_context(
self.cmd_name)
cmd_context_klass = dist.global_context.retrieve_command_context(
self.cmd_name)
context = cmd_context_klass(dist.global_context, [], options_context,
dist.pkg, dist.run_node)
n = context.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
scheme = context.retrieve_configured_scheme()
ipkg.update_paths(scheme)
file_sections = ipkg.resolve_paths_with_destdir(
src_root_node=context.build_node)
def writer(fid):
for kind, source, target in iter_files(file_sections):
fid.write("%s\n" % target.abspath())
bento.utils.io2.safe_write(self.record, writer, "w")
def test_simple_create(self):
InstalledPkgDescription(self.sections, self.meta, {})
def store(self, filename, pkg):
meta = ipkg_meta_from_pkg(pkg)
p = InstalledPkgDescription(self.sections, meta, pkg.executables)
p.write(filename)
def run(self, ctx):
argv = ctx.command_argv
p = ctx.options_context.parser
o, a = p.parse_args(argv)
if o.help:
p.print_help()
return
root = ctx.top_node
while root.height() > 0:
root = root.parent
default_scheme = get_default_scheme(ctx.pkg.name)
default_prefix = default_scheme["prefix"]
default_sitedir = default_scheme["sitedir"]
n = ctx.build_node.make_node(IPKG_PATH)
ipkg = InstalledPkgDescription.from_file(n.abspath())
name = ipkg.meta["name"]
version = ipkg.meta["version"]
py_short = ".".join([str(i) for i in sys.version_info[:2]])
if o.output_file is None:
mpkg_name = "%s-%s-py%s.mpkg" % (name, version, py_short)
else:
mpkg_name = o.output_file
categories = set()
file_sections = ipkg.resolve_paths(ctx.build_node)
for kind, source, target in iter_files(file_sections):
categories.add(kind)
# Mpkg metadata
mpkg_root = os.path.join(os.getcwd(), o.output_dir, mpkg_name)
mpkg_cdir = os.path.join(mpkg_root, "Contents")
if os.path.exists(mpkg_root):
shutil.rmtree(mpkg_root)
os.makedirs(mpkg_cdir)
f = open(os.path.join(mpkg_cdir, "PkgInfo"), "w")
try:
f.write("pmkrpkg1")
finally:
f.close()
mpkg_info = MetaPackageInfo.from_ipkg(ipkg)
purelib_pkg = "%s-purelib-%s-py%s.pkg" % (name, version, py_short)
scripts_pkg = "%s-scripts-%s-py%s.pkg" % (name, version, py_short)
datafiles_pkg = "%s-datafiles-%s-py%s.pkg" % (name, version, py_short)
mpkg_info.packages = [purelib_pkg, scripts_pkg, datafiles_pkg]
make_mpkg_plist(mpkg_info, os.path.join(mpkg_cdir, "Info.plist"))
mpkg_rdir = os.path.join(mpkg_root, "Contents", "Resources")
os.makedirs(mpkg_rdir)
make_mpkg_description(mpkg_info,
os.path.join(mpkg_rdir, "Description.plist"))
# Package the stuff which ends up into site-packages
pkg_root = os.path.join(mpkg_root, "Contents", "Packages", purelib_pkg)
build_pkg_from_temp(ctx, ipkg, pkg_root, root, "/", ["pythonfiles"],
"Pure Python modules and packages")
pkg_root = os.path.join(mpkg_root, "Contents", "Packages", scripts_pkg)
build_pkg_from_temp(ctx, ipkg, pkg_root, root, "/", ["executables"],
"Scripts and binaries")
pkg_root = os.path.join(mpkg_root, "Contents", "Packages",
datafiles_pkg)
build_pkg_from_temp(ctx, ipkg, pkg_root, root, "/",
["bentofiles", "datafiles"], "Data files")
def test_get_inidata_run(self):
"""Simply execute get_inidata."""
# FIXME: do a real test here
meta, sections, nodes = create_simple_ipkg_args(self.top_node)
ipkg = InstalledPkgDescription(sections, meta, {})
get_inidata(ipkg)
def store(self, filename, pkg):
meta = ipkg_meta_from_pkg(pkg)
p = InstalledPkgDescription(self.sections, meta, pkg.executables)
if not op.exists(op.dirname(filename)):
os.makedirs(op.dirname(filename))
p.write(filename)
import \
create_scripts
if __name__ == "__main__":
import tempfile
TMPDIR = tempfile.mkdtemp()
try:
EGG_PATH = sys.argv[1]
zid = zipfile.ZipFile(EGG_PATH)
try:
zid.extractall(path=TMPDIR)
finally:
zid.close()
ipkg = InstalledPkgDescription.from_egg(EGG_PATH)
# Build executables
bdir = os.path.join(TMPDIR, "SCRIPTS")
os.makedirs(bdir)
create_scripts(ipkg.executables, bdir)
# XXX: use internal API
for k in ipkg.files["executables"]:
ipkg.files["executables"][k].source_dir = bdir
meta = PackageMetadata.from_ipkg(ipkg)
wininst = wininst_filename(meta.fullname)
create_wininst(ipkg, src_root_dir=TMPDIR, wininst=wininst)
finally:
#shutil.rmtree(TMPDIR)
pass
def read_ipkg(wininst):
# See eof_cdir size in archive.h of bdist_wininst sources
eof_cdir_n = 22
eof_cdir_tag = 0x06054b50
meta_n = 12
stat_info = os.stat(WININST)
inst_size = stat_info.st_size
with open(WININST, "rb") as fid:
fid.seek(-eof_cdir_n, 2)
s = fid.read(4)
tag = struct.unpack("<l", s)[0]
if not tag == eof_cdir_tag:
raise ValueError("Unexpected bits")
fid.read(2 * 4)
s = fid.read(4)
nBytesCDir = struct.unpack("<l", s)[0]
s = fid.read(4)
ofsCDir = struct.unpack("<l", s)[0]
arc_start = inst_size - eof_cdir_n - nBytesCDir - ofsCDir
ofs = arc_start - meta_n
fid.seek(ofs, 0)
s = fid.read(4)
tag = struct.unpack("<l", s)[0]
if not tag == 0x1234567B:
raise ValueError("Unexpected bits")
s = fid.read(4)
uncomp_size = struct.unpack("<l", s)[0]
s = fid.read(4)
bitmap_size = struct.unpack("<l", s)[0]
pexe_size = ofs - uncomp_size - bitmap_size
fid.seek(pexe_size, 0)
data = fid.read(uncomp_size)
from configparser import ConfigParser
parser = ConfigParser()
sdata = StringIO(data)
def truncate_null(sdata):
cur = sdata.tell()
sdata.seek(0, 2)
nbytes = sdata.tell()
try:
n = 10
sdata.seek(-n, 2)
null_ind = sdata.read().find("\0")
sdata.truncate(nbytes - (n - null_ind))
finally:
sdata.seek(cur, 0)
truncate_null(sdata)
parser.readfp(sdata)
raise ValueError("YO - fix wininst METADATA")
ipkg_str = base64.b64decode(parser.get("IPKG_INFO", "value"))
ipkg = InstalledPkgDescription.from_string(ipkg_str)
return ipkg
def read_ipkg(wininst):
# See eof_cdir size in archive.h of bdist_wininst sources
eof_cdir_n = 22
eof_cdir_tag = 0x06054b50
meta_n = 12
stat_info = os.stat(WININST)
inst_size = stat_info.st_size
with open(WININST, "rb") as fid:
fid.seek(-eof_cdir_n, 2)
s = fid.read(4)
tag = struct.unpack("<l", s)[0]
if not tag == eof_cdir_tag:
raise ValueError("Unexpected bits")
fid.read(2 * 4)
s = fid.read(4)
nBytesCDir = struct.unpack("<l", s)[0]
s = fid.read(4)
ofsCDir = struct.unpack("<l", s)[0]
arc_start = inst_size - eof_cdir_n - nBytesCDir - ofsCDir
ofs = arc_start - meta_n
fid.seek(ofs, 0)
s = fid.read(4)
tag = struct.unpack("<l", s)[0]
if not tag == 0x1234567B:
raise ValueError("Unexpected bits")
s = fid.read(4)
uncomp_size = struct.unpack("<l", s)[0]
s = fid.read(4)
bitmap_size = struct.unpack("<l", s)[0]
pexe_size = ofs - uncomp_size - bitmap_size
fid.seek(pexe_size, 0)
data = fid.read(uncomp_size)
from ConfigParser import ConfigParser
parser = ConfigParser()
sdata = StringIO(data)
def truncate_null(sdata):
cur = sdata.tell()
sdata.seek(0, 2)
nbytes = sdata.tell()
try:
n = 10
sdata.seek(-n, 2)
null_ind = sdata.read().find("\0")
sdata.truncate(nbytes - (n-null_ind))
finally:
sdata.seek(cur, 0)
truncate_null(sdata)
parser.readfp(sdata)
raise ValueError("YO - fix wininst METADATA")
ipkg_str = base64.b64decode(parser.get("IPKG_INFO", "value"))
ipkg = InstalledPkgDescription.from_string(ipkg_str)
return ipkg
