janware/jw-pkg
1
mirror of ssh://git.janware.com/janware/proj/jw-pkg synced 2026-04-25 09:35:54 +02:00
Code Activity Actions

jw.build.cmds: Move build.cmds -> cmds.projects

Browse source 
Reorganize the Python module structure. Placing the command classes
under jw.cmds.projects instead of jw.build.cmds will allow to add a
nested command structure, with the current commands, being mostly
related to building software, found below a "projects" toplevel
command.

Other conceivable commands could be "package" for packaging, or
"distro" for commands wrapping the distribution's package manager.

Signed-off-by: Jan Lindemann <jan@janware.com>
This commit is contained in:
Jan Lindemann 2026-01-20 15:49:53 +01:00
commit 0b83c863a2
43 changed files with 49 additions and 13 deletions
Download patch file Download diff file Expand all files Collapse all files

24
src/python/jw/pkg/cmds/Cmd.py Normal file
View file

@ -0,0 +1,24 @@
# -*- coding: utf-8 -*-
from __future__ import annotations
from argparse import ArgumentParser
from ..lib.Cmd import Cmd as Base
from ..lib.Types import LoadTypes
class Cmd(Base): # export
def __init__(self, name: str, help: str) -> None:
super().__init__(name, help)
def _add_subcommands(self) -> None:
self.add_subcommands(
LoadTypes(
[__name__.rsplit('.', 1)[0] + '.' + self.name],
type_name_filter=r'Cmd[^.]'
)
)
async def run(self, args):
return self._run(args)

19
src/python/jw/pkg/cmds/CmdProjects.py Normal file
View file

@ -0,0 +1,19 @@
# -*- coding: utf-8 -*-
import sys, inspect, re
from argparse import ArgumentParser
from .Cmd import Cmd as CmdBase
class CmdProjects(CmdBase): # export
def __init__(self) -> None:
super().__init__('projects', help='Project metadata evaluation for building packages')
self._add_subcommands()
def add_arguments(self, p: ArgumentParser) -> None:
super().add_arguments(p)
def _run(self, args):
breakpoint()
raise Exception("Running with args", args)

5
src/python/jw/pkg/cmds/Makefile Normal file
View file

@ -0,0 +1,5 @@
TOPDIR = ../../../../..
PY_UPDATE_INIT_PY = false
include $(TOPDIR)/make/proj.mk
include $(JWBDIR)/make/py-mod.mk

1
src/python/jw/pkg/cmds/__init__.py Normal file
View file

@ -0,0 +1 @@
from .CmdProjects import CmdProjects

102
src/python/jw/pkg/cmds/projects/BaseCmdPkgRelations.py Normal file
View file

@ -0,0 +1,102 @@
# -*- coding: utf-8 -*-
import re
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class BaseCmdPkgRelations(Cmd):
def pkg_relations(self, rel_type, args):
version_pattern=re.compile("[0-9-.]*")
if args.subsections is None:
subsecs = self.app.os_cascade()
subsecs.append('jw')
else:
subsecs = args.subsections.split(',')
self.app.debug('flavour = ', args.flavour, ', subsecs = ', ' '.join(subsecs))
ignore = args.ignore.split(',')
self.app.debug("ignore = ", ignore)
r = []
flavours = args.flavour.split(',')
for flavour in flavours:
for s in subsecs:
section = 'pkg.' + rel_type + '.' + s
visited = set()
modules = args.module.copy()
while len(modules):
m = modules.pop(0)
if m in visited or m in ignore:
continue
visited.add(m)
value = self.app.get_value(m, section, flavour)
if not value:
continue
deps = value.split(',')
for spec in deps:
dep = re.split('([=><]+)', spec)
if args.no_version:
dep = dep[:1]
dep = list(map(str.strip, dep))
dep_name = re.sub('-dev$|-devel$|-run$', '', dep[0])
if dep_name in ignore or dep[0] in ignore:
continue
if args.no_subpackages:
dep[0] = dep_name
for i, item in enumerate(dep):
dep[i] = item.strip()
if s == 'jw':
if args.recursive and not dep_name in visited and not dep_name in modules:
modules.append(dep_name)
if len(dep) == 3:
if args.dont_expand_version_macros and dep_name in args.module:
version = dep[2]
else:
version = self.app.get_value(dep_name, 'version', '')
if dep[2] == 'VERSION':
if args.dont_strip_revision:
dep[2] = version
else:
dep[2] = version.split('-')[0]
elif dep[2] == 'VERSION-REVISION':
dep[2] = version
elif version_pattern.match(dep[2]):
# dep[2] = dep[2]
pass
else:
raise Exception("Unknown version specifier in " + spec)
cleaned_dep = ' '.join(dep)
if not cleaned_dep in r:
self.app.debug("appending", cleaned_dep)
r.append(cleaned_dep)
return args.delimiter.join(r)
def print_pkg_relations(self, rel_type, args_):
print(self.pkg_relations(rel_type, args_))
def __init__(self, relation: str, help: str) -> None:
super().__init__('pkg-' + relation, help=help)
self.relation = relation
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('-S', '--subsections', nargs='?', default=None, help='Subsections to consider, comma-separated')
parser.add_argument('-d', '--delimiter', nargs='?', default=', ', help='Output words delimiter')
parser.add_argument('flavour', help='Flavour')
parser.add_argument('module', nargs='*', help='Modules')
parser.add_argument('-p', '--no-subpackages', action='store_true',
default=False, help='Cut -run and -devel from package names')
parser.add_argument('--no-version', action='store_true',
default=False, help='Don\'t report version information')
parser.add_argument('--dont-strip-revision', action='store_true',
default=False, help='Always treat VERSION macro as VERSION-REVISION')
parser.add_argument('--recursive', action='store_true',
default=False, help='Find dependencies recursively')
parser.add_argument('--dont-expand-version-macros', action='store_true',
default=False, help='Don\'t expand VERSION and REVISION macros')
parser.add_argument('--ignore', nargs='?', default='', help='Packages that '
'should be ignored together with their dependencies')
def _run(self, args: Namespace) -> None:
return self.print_pkg_relations(self.relation, args)

174
src/python/jw/pkg/cmds/projects/CmdBuild.py Normal file
View file

@ -0,0 +1,174 @@
# -*- coding: utf-8 -*-
import os, re, sys, subprocess, datetime, time
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdBuild(Cmd): # export
def __init__(self) -> None:
super().__init__('build', help='janware software project build tool')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('--exclude', default='', help='Space seperated ist of modules to be excluded from build')
parser.add_argument('-n', '--dry-run', action='store_true',
default=False, help='Don\'t build anything, just print what would be done.')
parser.add_argument('-O', '--build-order', action='store_true',
default=False, help='Don\'t build anything, just print the build order.')
parser.add_argument('-I', '--ignore-deps', action='store_true',
default=False, help='Don\'t build dependencies, i.e. build only modules specified on the command line')
parser.add_argument('target', default='all', help='Build target')
parser.add_argument('modules', nargs='+', default='', help='Modules to be built')
def _run(self, args: Namespace) -> None:
def read_deps(cur, prereq_type):
# dep cache doesn't make a difference at all
if prereq_type in self.app.dep_cache:
if cur in self.app.dep_cache[prereq_type]:
return self.app.dep_cache[prereq_type][cur]
else:
self.app.dep_cache[prereq_type] = {}
r = self.app.get_modules_from_project_txt([ cur ], ['pkg.requires.jw'],
prereq_type, scope = 2, add_self=False, names_only=True)
self.app.debug('prerequisites = ' + ' '.join(r))
if cur in r:
r.remove(cur)
self.app.debug('inserting', prereq_type, "prerequisites of", cur, ":", ' '.join(r))
self.app.dep_cache[prereq_type][cur] = r
return r
def read_deps_cached(cur, prereq_type):
return self.app.res_cache.run(read_deps, [ cur, prereq_type ])
def add_dep_tree(cur, prereq_types, tree, all_deps):
self.app.debug("adding prerequisites " + ' '.join(prereq_types) + " of module " + cur)
if cur in all_deps:
self.app.debug('already handled module ' + cur)
return 0
deps = set()
all_deps.add(cur)
for t in prereq_types:
self.app.debug("checking prereqisites of type " + t)
deps.update(read_deps_cached(cur, t))
for d in deps:
add_dep_tree(d, prereq_types, tree, all_deps)
tree[cur] = deps
return len(deps)
def calculate_order(order, modules, prereq_types):
all_deps = set()
dep_tree = {}
for m in modules:
self.app.debug("--- adding dependency tree of module " + m)
add_dep_tree(m, prereq_types, dep_tree, all_deps)
while len(all_deps):
# Find any leaf
for d in all_deps:
if not len(dep_tree[d]): # Dependency d doesn't have dependencies itself
break # found
else: # no Leaf found
print(all_deps)
raise Exception("fatal: the dependencies between these modules are unresolvable")
order.append(d) # do it
# bookkeep it
all_deps.remove(d)
for k in dep_tree.keys():
if d in dep_tree[k]:
dep_tree[k].remove(d)
return 1
def run_make(module, target, cur_project, num_projects):
#make_cmd = "make " + target + " 2>&1"
make_cmd = [ "make", target ]
path = self.app.proj_dir(module)
delim_len = 120
delim = '---- [%d/%d]: running %s in %s -' % (cur_project, num_projects, make_cmd, path)
delim = delim + '-' * (delim_len - len(delim))
print(',' + delim + ' >')
patt = self.app.is_excluded_from_build(module)
if patt is not None:
print('| Configured to skip build on platform >' + patt + '<')
print('`' + delim + ' <')
return
os.chdir(path)
p = subprocess.Popen(make_cmd, shell=False, stdout=subprocess.PIPE, stderr=None, close_fds=True)
for line in iter(p.stdout.readline, b''):
line = line.decode(sys.stdout.encoding)
sys.stdout.write('| ' + line) # avoid extra newlines from print()
sys.stdout.flush()
p.wait()
print('`' + delim + ' <')
if p.returncode:
print(' '.join(make_cmd) + ' failed')
raise Exception(time.strftime("%Y-%m-%d %H:%M") + ": failed to make target " + target + " in module " + module + " below base " + self.app.projs_root)
def run_make_on_modules(modules, order, target):
cur_project = 0
num_projects = len(order)
if target in ["clean", "distclean"]:
for m in reversed(order):
cur_project += 1
run_make(m, target, cur_project, num_projects)
if m in modules:
modules.remove(m)
if not len(modules):
print("all modules cleaned")
return
else:
for m in order:
cur_project += 1
run_make(m, target, cur_project, num_projects)
def run(args):
self.app.debug("----------------------------------------- running ", ' '.join(sys.argv))
modules = args.modules
exclude = args.exclude.split()
target = args.target
env_exclude = os.getenv('BUILD_EXCLUDE', '')
if len(env_exclude):
print("exluding modules from environment: " + env_exclude)
exclude += " " + env_exclude
# -- build
order = []
glob_prereq_types = [ "build" ]
if re.match("pkg-.*", target) is not None:
glob_prereq_types = [ "build", "run", "release", "devel" ]
if target != 'order' and not args.build_order:
print("using prerequisite types " + ' '.join(glob_prereq_types))
print("calculating order for modules ... ")
calculate_order(order, modules, glob_prereq_types)
if args.ignore_deps:
order = [m for m in order if m in args.modules]
order = [m for m in order if m not in exclude]
if target == 'order' or args.build_order:
print(' '.join(order))
exit(0)
cur_project = 0
print("Building target %s in %d projects:" % (target, len(order)))
for m in order:
cur_project += 1
print(" %3d %s" % (cur_project, m))
if args.dry_run:
exit(0)
run_make_on_modules(modules, order, target)
print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
run(args)

28
src/python/jw/pkg/cmds/projects/CmdCflags.py Normal file
View file

@ -0,0 +1,28 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdCflags(Cmd): # export
def __init__(self) -> None:
super().__init__('cflags', help='cflags')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
def _run(self, args: Namespace) -> None:
deps = self.app.get_modules_from_project_txt(args.module, ['pkg.requires.jw'], 'build',
scope = 2, add_self=True, names_only=True)
r = ''
for m in reversed(deps):
try:
pd = self.app.proj_dir(m)
if pd is None:
continue
r = r + ' -I' + pd + '/include'
except Exception as e:
self.app.warn(f'No include path for module "{m}", ignoring: {e}')
print(r[1:])

33
src/python/jw/pkg/cmds/projects/CmdCheck.py Normal file
View file

@ -0,0 +1,33 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdCheck(Cmd): # export
def __init__(self) -> None:
super().__init__('check', help='Check for circular dependencies between given modules')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
parser.add_argument('-f', '--flavour', nargs='?', default = 'build')
def _run(self, args: Namespace) -> None:
graph = {}
path = []
self.app.read_dep_graph(args.module, args.flavour, graph)
unvisited = list(graph.keys())
temp = set()
while len(unvisited) != 0:
m = unvisited[0]
self.app.debug('Checking circular dependency of', m)
last = self.app.check_circular_deps(m, args.flavour, self.app.flip_graph(graph), unvisited, temp, path)
if last is not None:
self.app.debug('Found circular dependency below', m, ', last is', last)
print('Found circular dependency in flavour', args.flavour, ':', ' -> '.join(path))
exit(1)
print('No circular dependency found for flavour', args.flavour, ' in modules:',
' '.join(args.module))
exit(0)

23
src/python/jw/pkg/cmds/projects/CmdCommands.py Normal file
View file

@ -0,0 +1,23 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdCommands(Cmd): # export
def __init__(self) -> None:
super().__init__('commands', help='List available commands')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
def _run(self, args: Namespace) -> None:
import sys, re, os, glob
this_dir = os.path.dirname(sys.modules[__name__].__file__)
ret = []
for file_name in glob.glob('Cmd*.py', root_dir=this_dir):
cc_name = re.sub(r'^Cmd|\.py', '', file_name)
name = re.sub(r'(?<!^)(?=[A-Z])', '-', cc_name).lower()
ret.append(name)
print(' '.join(ret))

57
src/python/jw/pkg/cmds/projects/CmdCreatePkgConfig.py Normal file
View file

@ -0,0 +1,57 @@
# -*- coding: utf-8 -*-
import textwrap
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdCreatePkgConfig(Cmd): # export
def __init__(self) -> None:
super().__init__('create-pkg-config', help='Generate a pkg-config file for a module')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('-F', '--project-descr-file', default=None)
parser.add_argument('-d', '--description', default=None)
parser.add_argument('-n', '--name', default=None)
parser.add_argument('-s', '--summary', default=None)
parser.add_argument('-p', '--prefix', default=None)
parser.add_argument('-v', '--version', default=None)
parser.add_argument('-c', '--cflags', default=None)
parser.add_argument('-l', '--libflags', default=None)
parser.add_argument('-r', '--requires_run', default=None)
parser.add_argument('-R', '--requires_build', default=None)
parser.add_argument('-V', '--variables', nargs='*')
def _run(self, args: Namespace) -> None:
project_conf_var_keys = ['description', 'summary', 'requires_run', 'requires_build']
merged: dict[str, str] = {}
for key in project_conf_var_keys:
val = getattr(args, key)
if val is not None and args.project_descr_file:
val = self.app.get_value(args.name, key, None)
merged[key] = val
contents = textwrap.dedent(f"""\
prefix={args.prefix}
exec_prefix={{prefix}}
includedir={{prefix}}/include
libdir={{exec_prefix}}/lib
Name: {args.name}
Description: {merged['summary']}
Version: {args.version}
""")
if args.cflags is not None:
contents += f"Cflags: {args.cflags}\n"
if args.libflags is not None:
contents += f"Libs: {args.libflags}\n"
if merged['requires_run'] is not None:
contents += f"Requires: {cleanup_requires(merged['requires_run'])}"
if merged['requires_build'] is not None:
contents += f"Requires.private: {cleanup_requires(merged['requires_build'])}"
# not sure what to do with requires_devel
print(contents)

26
src/python/jw/pkg/cmds/projects/CmdExepath.py Normal file
View file

@ -0,0 +1,26 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdExepath(Cmd): # export
def __init__(self) -> None:
super().__init__('exepath', help='exepath')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
def _run(self, args: Namespace) -> None:
deps = self.app.get_modules_from_project_txt(args.module, ['pkg.requires.jw'], [ 'run', 'build', 'devel' ],
scope = 2, add_self=True, names_only=True)
self.app.debug('deps = ', deps)
r = ''
for m in deps:
pd = self.app.proj_dir(m)
if pd is None:
continue
r = r + ':' + pd + '/bin'
print(r[1:])

55
src/python/jw/pkg/cmds/projects/CmdGetAuthInfo.py Normal file
View file

@ -0,0 +1,55 @@
# -*- coding: utf-8 -*-
import re, os
from argparse import Namespace, ArgumentParser
from urllib.parse import urlparse
from ..Cmd import Cmd
from ...lib.util import run_cmd
class CmdGetAuthInfo(Cmd): # export
def __init__(self) -> None:
super().__init__('get-auth-info', help='Try to retrieve authentication information from the source tree')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('--only-values', help='Don\'t prefix values by "<field-name>="', action='store_true', default=False)
parser.add_argument('--username', help='Show user name', action='store_true', default=False)
parser.add_argument('--password', help='Show password', action='store_true', default=False)
parser.add_argument('--remote-base', help='Show remote base URL', action='store_true', default=False)
def _run(self, args: Namespace) -> None:
keys = ['username', 'password']
# --- Milk jw-pkg repo
jw_pkg_dir = self.app.proj_dir('jw-pkg')
if not os.path.isdir(jw_pkg_dir + '/.git'):
self.app.debug(f'jw-pkg directory is not a Git repo: {jw_pkg_dir}')
return
remotes = run_cmd(['git', '-C', jw_pkg_dir, 'remote', '-v'])
result: dict[str, str] = {}
for line in remotes.split('\n'):
if re.match(r'^\s*$', line):
continue
name, url, typ = re.split(r'\s+', line)
if name == 'origin' and typ == '(pull)': # TODO: Use other remotes, too?
parsed = urlparse(url)
for key in keys:
result[key] = getattr(parsed, key)
base = parsed.geturl()
base = re.sub(r'/jw-pkg', '', base)
base = re.sub(r'/proj$', '', base)
url['remote-base'] = base
break
# --- Print results
for key, val in result.items():
if getattr(args, key, None) != True:
continue
if val is None:
continue
if args.only_values:
print(val)
continue
print(f'{key}="{val}"')

22
src/python/jw/pkg/cmds/projects/CmdGetval.py Normal file
View file

@ -0,0 +1,22 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdGetval(Cmd): # export
def __init__(self) -> None:
super().__init__('getval', help='Get value from project config')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('--project', default = None, help = 'Project name, default is name of project\'s topdir')
parser.add_argument('section', default = '', help = 'Config section')
parser.add_argument('key', default = '', help = 'Config key')
def _run(self, args: Namespace) -> None:
project = args.project
if project is None:
args.project = self.app.top_name
print(self.app.get_value(args.project, args.section, args.key))

20
src/python/jw/pkg/cmds/projects/CmdHtdocsDir.py Normal file
View file

@ -0,0 +1,20 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdHtdocsDir(Cmd): # export
def __init__(self) -> None:
super().__init__('htdocs-dir', help='Print source directory containing document root of a given module')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
def _run(self, args: Namespace) -> None:
r = []
for m in args.module:
r.append(self.app.htdocs_dir(m))
print(' '.join(r))

20
src/python/jw/pkg/cmds/projects/CmdLdflags.py Normal file
View file

@ -0,0 +1,20 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdLdflags(Cmd): # export
def __init__(self) -> None:
super().__init__('ldflags', help='ldflags')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
parser.add_argument('--exclude', action='append', help='Exclude Modules', default=[])
parser.add_argument('-s', '--add-self', action='store_true',
default=False, help='Include libflags of specified modules, too, not only their dependencies')
def _run(self, args: Namespace) -> None:
print(self.app.get_ldflags(args.module, args.exclude, args.add_self))

25
src/python/jw/pkg/cmds/projects/CmdLdlibpath.py Normal file
View file

@ -0,0 +1,25 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdLdlibpath(Cmd): # export
def __init__(self) -> None:
super().__init__('ldlibpath', help='ldlibpath')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
def _run(self, args: Namespace) -> None:
deps = self.app.get_modules_from_project_txt(args.module, ['pkg.requires.jw'], [ 'run', 'build', 'devel' ],
scope = 2, add_self=True, names_only=True)
r = ''
for m in deps:
pd = self.app.proj_dir(m)
if pd is None:
continue
r = r + ':' + pd + '/lib'
print(r[1:])

17
src/python/jw/pkg/cmds/projects/CmdLibname.py Normal file
View file

@ -0,0 +1,17 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdLibname(Cmd): # export
def __init__(self) -> None:
super().__init__('libname', help='libname')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
def _run(self, args: Namespace) -> None:
print(self.app.get_libname(args.module))

88
src/python/jw/pkg/cmds/projects/CmdListRepos.py Normal file
View file

@ -0,0 +1,88 @@
# -*- coding: utf-8 -*-
import re, os
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
from ...lib.util import get_username, get_password, run_curl
class CmdListRepos(Cmd): # export
def __init__(self) -> None:
super().__init__('list-repos', help='Query a remote GIT server for repositories')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('base_url', help='Base URL of all Git repositories')
parser.add_argument('--name-only', help='Only list names of repos, not URLs')
parser.add_argument('--username', help='Username for SSH or HTTP authentication, don\'t specify for unauthenticated', default=None)
parser.add_argument('--askpass', help='Program to echo password for SSH or HTTP authentication, don\'t specify for unauthenticated', default=None)
parser.add_argument('--from-user', help='List from-user\'s projects', default='janware')
def _run(self, args: Namespace) -> None:
from urllib.parse import urlparse
url = urlparse(args.base_url)
askpass_env=['GIT_ASKPASS', 'SSH_ASKPASS']
username = get_username(args=args, url=args.base_url, askpass_env=askpass_env)
password = None
if username is not None:
password = get_password(args=args, url=args.base_url, askpass_env=askpass_env)
match url.scheme:
case 'ssh':
if re.match(r'ssh://.*git\.janware\.com/', args.base_url):
from jw.pkg.lib.SSHClient import SSHClientCmd as SSHClient
ssh = SSHClient(hostname=url.hostname)
if username is not None:
ssh.set_username(username)
if password is not None:
ssh.set_password(password)
cmd = f'/opt/jw-pkg/bin/git-srv-admin.sh -u {args.from_user} -j list-personal-projects'
out = ssh.run_cmd(cmd)
print(out)
return
case 'https':
cmd_input = None
if re.match(r'https://github.com', args.base_url):
curl_args = [
'-f',
'-H', 'Accept: application/vnd.github+json',
'-H', 'X-GitHub-Api-Version: 2022-11-28',
]
if password is not None:
assert username is not None
cmd_input = (f'-u {username}:{password}').encode('utf-8')
curl_args.extend(['-K-'])
curl_args.append(f'https://api.github.com/users/{args.from_user}/repos')
repos = run_curl(curl_args, cmd_input=cmd_input)
for repo in repos:
print(repo['name'])
return
if re.match(r'https://', args.base_url):
# assume Forgejo Backend
curl_args = ['-f']
if re.match(r'https://janware.test', args.base_url):
curl_args.append('--insecure')
if password is not None:
assert username is not None
cmd_input = (f'-u {username}:{password}').encode('utf-8')
curl_args.extend(['-K-'])
curl_args.extend([
f'https://{url.hostname}/code/api/v1/orgs/{args.from_user}/repos'
])
repos = run_curl(curl_args, cmd_input=cmd_input)
for repo in repos:
print(repo['name'])
return
if os.path.isdir(args.base_url):
for subdir in ["." , args.from_user]:
out = []
for entry in os.scandir(args.base_url + "/" + subdir):
path = entry.path
if os.path.isdir(path + "/.git") or os.path.exists(path + "/HEAD"):
out.append(path)
if out:
print('\n'.join(out))
break
return
raise Exception(f'Don\'t know how to enumerate Git repos at base url {args.base_url}')

42
src/python/jw/pkg/cmds/projects/CmdModules.py Normal file
View file

@ -0,0 +1,42 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdModules(Cmd): # export
def __init__(self) -> None:
super().__init__('modules', help='Query existing janware packages')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('-F', '--filter', nargs='?', default=None, help='Key-value pairs, seperated by commas, to be searched for in project.conf')
def _run(self, args: Namespace) -> None:
import pathlib
proj_root = self.app.projs_root
self.app.debug("proj_root = " + proj_root)
path = pathlib.Path(self.app.projs_root)
modules = [p.parents[1].name for p in path.glob('*/make/project.conf')]
self.app.debug("modules = ", modules)
out = []
filters = None if args.filter is None else [re.split("=", f) for f in re.split(",", args.filter)]
for m in modules:
if filters:
for f in filters:
path = f[0].rsplit('.')
if len(path) > 1:
sec = path[0]
key = path[1]
else:
sec = None
key = path[0]
val = self.app.get_value(m, sec, key)
self.app.debug('Checking in {} if {}="{}", is "{}"'.format(m, f[0], f[1], val))
if val and val == f[1]:
out.append(m)
break
else:
out.append(m)
print(' '.join(out))

17
src/python/jw/pkg/cmds/projects/CmdOsCascade.py Normal file
View file

@ -0,0 +1,17 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdOsCascade(Cmd): # export
def __init__(self) -> None:
super().__init__('os-cascade', help='Print project.conf\'s OS configuration precedence of machine this script runs on')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
def _run(self, args: Namespace) -> None:
print(' '.join(self.app.os_cascade()))

25
src/python/jw/pkg/cmds/projects/CmdPath.py Normal file
View file

@ -0,0 +1,25 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdPath(Cmd): # export
def __init__(self) -> None:
super().__init__('path', help='path')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
def _run(self, args: Namespace) -> None:
deps = self.app.get_modules_from_project_txt(args.module, ['pkg.requires.jw'], 'run',
scope = 2, add_self=True, names_only=True)
r = ''
for m in deps:
pd = self.app.proj_dir(m)
if pd is None:
continue
r = r + ':' + pd + '/bin'
print(r[1:])

10
src/python/jw/pkg/cmds/projects/CmdPkgConflicts.py Normal file
View file

@ -0,0 +1,10 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from .BaseCmdPkgRelations import BaseCmdPkgRelations as Base
class CmdPkgConflicts(Base): # export
def __init__(self) -> None:
super().__init__('conflicts', help='Print packages conflicting with a given package')

10
src/python/jw/pkg/cmds/projects/CmdPkgProvides.py Normal file
View file

@ -0,0 +1,10 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from .BaseCmdPkgRelations import BaseCmdPkgRelations as Base
class CmdPkgProvides(Base): # export
def __init__(self) -> None:
super().__init__('provides', help='Print packages and capabilities provided by a given package')

10
src/python/jw/pkg/cmds/projects/CmdPkgRequires.py Normal file
View file

@ -0,0 +1,10 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from .BaseCmdPkgRelations import BaseCmdPkgRelations as Base
class CmdPkgRequires(Base): # export
def __init__(self) -> None:
super().__init__('requires', help='Print packages required for a given package')

21
src/python/jw/pkg/cmds/projects/CmdPrereq.py Normal file
View file

@ -0,0 +1,21 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
# TODO: seems at least partly redundant to CmdPkgRequires / print_pkg_relations
class CmdPrereq(Cmd): # export
def __init__(self) -> None:
super().__init__('prereq', help='path')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('flavour', help='Flavour')
parser.add_argument('module', nargs='*', help='Modules')
def _run(self, args: Namespace) -> None:
deps = self.app.get_modules_from_project_txt(args.module, ['pkg.requires.jw'],
args.flavour, scope = 2, add_self=False, names_only=True)
print(' '.join(deps))

27
src/python/jw/pkg/cmds/projects/CmdProjDir.py Normal file
View file

@ -0,0 +1,27 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdProjDir(Cmd): # export
def __init__(self) -> None:
super().__init__('proj-dir', help='Print directory of a given package')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
def _run(self, args: Namespace) -> None:
r = []
for m in args.module:
try:
pd = self.app.proj_dir(m)
if pd is None:
continue
r.append(pd)
except Exception as e:
self.app.warn(f'No project directory for module "{m}: {e}')
continue
print(' '.join(r))

29
src/python/jw/pkg/cmds/projects/CmdPythonpath.py Normal file
View file

@ -0,0 +1,29 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdPythonpath(Cmd): # export
def __init__(self) -> None:
super().__init__('pythonpath', help='Generate PYTHONPATH for given modules')
def add_arguments(self, p: ArgumentParser) -> None:
super().add_arguments(p)
p.add_argument('module', help='Modules', nargs='*')
def _run(self, args: Namespace) -> None:
import os
deps = self.app.get_modules_from_project_txt(args.module, ['pkg.requires.jw'], [ 'run', 'build' ],
scope = 2, add_self=True, names_only=True)
r = ''
for m in deps:
pd = self.app.proj_dir(m)
if pd is None:
continue
for subdir in [ 'src/python', 'tools/python' ]:
cand = pd + "/" + subdir
if os.path.isdir(cand):
r = r + ':' + cand
print(r[1:])

28
src/python/jw/pkg/cmds/projects/CmdPythonpathOrig.py Normal file
View file

@ -0,0 +1,28 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdPythonpathOrig(Cmd): # export
def __init__(self) -> None:
super().__init__('pythonpath_orig', help='pythonpath')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
def _run(self, args: Namespace) -> None:
deps = self.app.get_modules_from_project_txt(args.module, ['pkg.requires.jw'], [ 'run', 'build' ],
scope = 2, add_self=True, names_only=True)
r = ''
for m in deps:
pd = self.app.proj_dir(m)
if pd is None:
continue
for subdir in [ 'src/python', 'tools/python' ]:
cand = pd + "/" + subdir
if isdir(cand):
r = r + ':' + cand
print(r[1:])

45
src/python/jw/pkg/cmds/projects/CmdRequiredOsPkg.py Normal file
View file

@ -0,0 +1,45 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
# TODO: seems at least partly redundant to CmdPkgRequires / print_pkg_relations
class CmdRequiredOsPkg(Cmd): # export
def __init__(self) -> None:
super().__init__('required-os-pkg', help='List distribution packages required for a package')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
parser.add_argument('--flavours', help='Dependency flavours', default='build')
parser.add_argument('--skip-excluded', action='store_true', default=False,
help='Output empty prerequisite list if module is excluded')
def _run(self, args: Namespace) -> None:
modules = args.module
flavours = args.flavours.split()
if 'build' in flavours and not 'run' in flavours:
# TODO: This adds too much. Only the run dependencies of the build dependencies would be needed.
flavours.append('run')
self.app.debug("flavours = " + args.flavours)
deps = self.app.get_modules_from_project_txt(modules, ['pkg.requires.jw'], flavours,
scope = 2, add_self=True, names_only=True)
if args.skip_excluded:
for d in deps:
if self.app.is_excluded_from_build(d) is not None:
deps.remove(d)
subsecs = self.app.os_cascade()
self.app.debug("subsecs = ", subsecs)
requires = []
for s in subsecs:
for f in flavours:
vals = self.app.collect_values(deps, 'pkg.requires.' + s, f)
if vals:
requires = requires + vals
# TODO: add all not in build tree as -devel
r = ''
for m in requires:
r = r + ' ' + m
print(r[1:])

22
src/python/jw/pkg/cmds/projects/CmdSummary.py Normal file
View file

@ -0,0 +1,22 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdSummary(Cmd): # export
def __init__(self) -> None:
super().__init__('summary', help='Print summary description of given modules')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
def _run(self, args: Namespace) -> None:
r = []
for m in args.module:
summary = self.app.get_value(m, "summary", None)
if summary is not None:
r.append(summary)
print(' '.join(r))

17
src/python/jw/pkg/cmds/projects/CmdTest.py Normal file
View file

@ -0,0 +1,17 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdTest(Cmd): # export
def __init__(self) -> None:
super().__init__('test', help='Test')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('blah', default='', help='The blah argument')
def _run(self, args: Namespace) -> None:
print("blah = " + args.blah)

20
src/python/jw/pkg/cmds/projects/CmdTmplDir.py Normal file
View file

@ -0,0 +1,20 @@
# -*- coding: utf-8 -*-
from argparse import Namespace, ArgumentParser
from ..Cmd import Cmd
class CmdTmplDir(Cmd): # export
def __init__(self) -> None:
super().__init__('tmpl-dir', help='Print directory containing templates of a given module')
def add_arguments(self, parser: ArgumentParser) -> None:
super().add_arguments(parser)
parser.add_argument('module', nargs='*', help='Modules')
def _run(self, args: Namespace) -> None:
r = []
for m in args.module:
r.append(self.app.tmpl_dir(m))
print(' '.join(r))

5
src/python/jw/pkg/cmds/projects/Makefile Normal file
View file

@ -0,0 +1,5 @@
TOPDIR = ../../../../../..
PY_UPDATE_INIT_PY = false
include $(TOPDIR)/make/proj.mk
include $(JWBDIR)/make/py-mod.mk

11
src/python/jw/pkg/cmds/projects/__init__.py Normal file
View file

@ -0,0 +1,11 @@
import importlib, pkgutil
__all__ = []
for finder, module_name, ispkg in pkgutil.iter_modules(__path__):
if not module_name.startswith("Cmd"):
continue
module = importlib.import_module(f".{module_name}", __name__)
cls = getattr(module, module_name)
globals()[module_name] = cls
__all__.append(module_name)