add support for aliases, better parsing ovl, refactoring

Signed-off-by: Igor Gnatenko <i.gnatenko.brain@gmail.com>

doc/overlay.yml

@@ -0,0 +1,19 @@
+---
+aliases:
+  - name: github
+    url: https://github.com/
+  - name: fedorapkgs
+    url: git://pkgs.fedoraproject.org/rpms/
+
+components:
+  - name: libsolv
+    git:
+      src: github:openSUSE/libsolv
+      # https://github.com/rpm-software-management/libhif/issues/118
+      freeze: e48fbd2121efa59911b87c070125e3f774a1bd55
+    distgit:
+      src: fedorapkgs:libsolv
+
+  - name: libhif
+    git:
+      src: github:rpm-software-management/libhif

rgo/__main__.py

@@ -16,14 +16,13 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 import argparse
-import json
 import os
+import sys
 import tempfile
 
 import yaml
 
-from . import logger
-from .utils import Component, try_prepare
+from . import logger, utils
 from .builders import CoprBuilder
 
 def setup_logger(loglevel):
@@ -37,61 +36,84 @@ def setup_logger(loglevel):
         handler.setFormatter(formatter)
     logger.addHandler(handler)
 
+def fatal(msg):
+    print(msg, file=sys.stderr)
+    sys.exit(1)
+
+def dump_ovl(ovl, f):
+    with open(f, "w") as yml:
+        yml.write(yaml.dump(ovl))
+
+def load_ovl(f):
+    with open(f, "r") as yml:
+        ovl = yaml.load(yml)
+    if not isinstance(ovl, utils.Overlay):
+        fatal("{!f} doesn't looks correctly auto-generated")
+    return ovl
+
 def main(args=None):
     parser = argparse.ArgumentParser()
     parser.add_argument("--log", help="Log level",
                         choices=("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"))
-    parser.add_argument("--owner", help="COPR project owner",
-                        required=True)
-    parser.add_argument("--project", help="COPR project name")
-    parser.add_argument("--no-prep", help="Don't try %%prep section",
-                        dest="prep", action="store_false")
-    fmt = parser.add_mutually_exclusive_group()
-    fmt.add_argument("--json", help="Print output in JSON format", action="store_true")
-    parser.add_argument("-o", "--output", help="Output file")
-    parser.add_argument("overlay", help="Path to overlay directory with overlay.yml file")
-    args = parser.parse_args()
+    action = parser.add_subparsers(help="Action", dest="action")
+    action.required = True
+    action.add_parser("resolve", help="Clone repos, do checkout, etc.")
+    build = action.add_parser("build", help="Build")
+    build.add_argument("-o", "--output", help="Output file for list of (S)RPMs")
+    build_action = build.add_subparsers(help="What to build", dest="build_action")
+    build_action.required = True
+    srpm = build_action.add_parser("srpm", help="Build SRPMs")
+    rpm = build_action.add_parser("rpm", help="Build RPMs")
+    builder = rpm.add_subparsers(help="Builder", dest="builder")
+    builder.required = True
+    copr = builder.add_parser("copr", help="Build using COPR")
+    copr.add_argument("--owner", help="COPR project owner", required=True)
+    copr.add_argument("--project", help="COPR project name")
 
+    args = parser.parse_args()
     setup_logger(args.log)
 
-    if not os.path.isdir(args.overlay):
-        raise Exception("{} is not a directory".format(args.overlay))
-
-    _ovl = os.path.join(args.overlay, "overlay.yml")
-    if not os.path.isfile(_ovl):
-        raise Exception("{} is not a file".format(_ovl))
+    if not os.path.isfile("overlay.yml"):
+        fatal("overlay.yml in current working directory doesn't exist")
+    with open("overlay.yml") as yml:
+        _ovl = yaml.safe_load(yml)
+    ovl = utils.Overlay(_ovl)
 
-    with open(_ovl, "r") as yml:
-        ovl = yaml.load(yml)
-    components = [Component(c) for c in ovl["components"]]
-
-    with tempfile.TemporaryDirectory(prefix="rpm-gitoverlay") as tmp:
-        for c in components:
-            c.clone(tmp)
-
-        srpms = [c.build_srpm(tmp) for c in components]
-        if args.prep:
-            for srpm in srpms:
-                try_prepare(srpm)
-
-        builder = CoprBuilder()
-        project = builder.mkproject(args.owner, args.project)
-        project_url = builder.get_project_url(project)
-        logger.debug("Project URL: %r", project_url)
-        rpms = []
-        for srpm in srpms:
-            rpms.extend(builder.build_from_srpm(project, srpm))
+    f_ovl = os.path.join(ovl.cwd_src, "overlay.yml")
+    if args.action == "resolve":
+        if os.path.isdir(ovl.cwd_src):
+            fatal("Source directory {!r} already exists".format(ovl.cwd_src))
+        os.makedirs(ovl.cwd_src)
+        for component in ovl.components:
+            component.resolve()
+        dump_ovl(ovl, f_ovl)
+    elif args.action == "build":
+        if not os.path.isfile(f_ovl):
+            fatal("Please run 'resolve' first")
+        ovl = load_ovl(f_ovl)
+        tmpdir = tempfile.mkdtemp(prefix="rpm-gitoverlay", suffix="-build")
+        srpms = {}
+        for component in ovl.components:
+            srpm = component.build_srpm(tmpdir)
+            utils.try_prep(srpm)
+            srpms[component] = srpm
+        if args.build_action == "srpm":
+            out = srpms.values()
+        elif args.build_action == "rpm":
+            out = []
+            if args.builder == "copr":
+                builder = CoprBuilder()
+                project = builder.mkproject(args.owner, args.project)
+                logger.debug("Project URL: %r", builder.get_project_url(project))
+                for srpm in srpms.values():
+                    # TODO: add support for multiple builds at the same time
+                    out.extend(builder.build_from_srpm(project, srpm))
 
-    if args.json:
-        content = json.dumps({"project_url": project_url, "rpms": rpms})
-    else:
-        content = "Project URL: {!s}\nRPMs:\n{}".format(project_url, "\n".join(rpms))
-
-    if args.output:
-        with open(args.output, "w") as out:
-            out.write(content)
-    else:
-        print(content)
+        if args.output:
+            with open(args.output, "w") as f_out:
+                f_out.writelines("{!s}\n".format(l) for l in out)
+        else:
+            print("\n".join(out))
 
 if __name__ == "__main__":
     main()