Unblock gappalib-coq and frama-c (thanks Jerry James).
[goals.git] / fedora.ml
1 (* Various useful functions for handling Fedora packages & rebuilds. *)
2
3 open ExtString
4 open Printf
5
6 open Goaljobs
7
8 (* Repo dir, etc. *)
9 let fedora_dir = Sys.getenv "HOME" // "d/fedora"
10 let fedora_repo pkg branch = fedora_dir // pkg // branch
11 let fedora_specfile pkg branch =
12   sprintf "%s/%s.spec" (fedora_repo pkg branch) pkg
13
14 (* Get the current version of a package. *)
15 let fedora_verrel pkg branch =
16   shout "
17     cd %s
18     fedpkg verrel
19   " (fedora_repo pkg branch)
20
21 (* Note most of these assume that the package is already cloned
22  * under ~/d/fedora using:
23  *
24  * cd ~/d/fedora
25  * fedpkg clone -B pkgname
26  *)
27
28 (* Take a list of Fedora source packages and work out the dependencies
29  * (only within the list of source packages).  Returns a list of
30  * (package, [list of deps...])
31  *)
32 let dependencies branch source_packages =
33   (* For each source package, get the list of binary packages that it
34    * provides.  XXX Not sure if this is totally technically correct, but
35    * it seems to work.
36    *)
37   let bin_to_src =
38     List.concat (
39       List.map (
40         fun pkg ->
41           let provides =
42             shlines "rpmspec -q --provides %s | awk '{print $1}'"
43               (fedora_specfile pkg branch) in
44           List.map (fun bin -> (bin, pkg)) provides
45       ) source_packages
46     ) in
47
48   (* For each package, get the list of build requires that appear
49    * elsewhere in the list of packages.
50    *)
51   let mem dep = List.mem dep source_packages in
52
53   List.map (
54     fun pkg ->
55       let deps =
56         shlines "rpmspec -q --buildrequires %s | awk '{print $1}'"
57           (fedora_specfile pkg branch) in
58       let deps = List.map (
59         fun dep ->
60           try List.assoc dep bin_to_src
61           with Not_found -> "xxx" (* filtered out in next line *)
62       ) deps in
63       let deps = Utils.sort_uniq (List.filter mem deps) in
64       (* eprintf "%s <- %s\n" pkg (String.concat " " deps); *)
65       pkg, deps
66   ) source_packages
67
68 let contains_substring substr str =
69   try ignore (String.find str substr); true
70   with Invalid_string -> false
71
72 (* Not helped by the fact that the 'koji' tool actively
73  * resists automation: RHBZ#760924.
74  *)
75
76 (* XXX koji_build_state verrel: If you do a build and it fails, then
77  * do another build without bumping the release field, 'koji buildinfo'
78  * seems to always return the failed build, at least until the second
79  * build completes.  This means the code below fails.  Unclear how it
80  * can be fixed, but best to always bump the release to avoid the
81  * problem.
82  *)
83
84 (* Get build state. *)
85 let rec koji_build_state verrel =
86   fst (koji_build_state_task verrel)
87
88 (* Get build state and task ID. *)
89 and koji_build_state_task =
90   let state = Pcre.regexp "State: (\\w+)" in
91   let task_id = Pcre.regexp "Task: (\\d+)" in
92   let no_such_build = contains_substring "No such build" in
93   fun verrel ->
94     (* For speed, if a build is complete memoize it. *)
95     let key = sprintf "koji_build_complete_%s" verrel in
96     if memory_exists key then
97       `Complete, None
98     else (
99       let out = shout "timeout 120 koji buildinfo %s 2>&1 ||:" verrel in
100       if no_such_build out then
101         `No_such_build, None
102       else (
103         let state =
104           try
105             let subs = Pcre.exec ~rex:state out in
106             match Pcre.get_substring subs 1 with
107             | "BUILDING" -> `Building
108             | "COMPLETE" -> `Complete
109             | "DELETED" -> `Deleted
110             | "FAILED" -> `Failed
111             | "CANCELED" -> `Canceled
112             | sub ->
113               failwith (sprintf "koji_build_state_task: %s: unknown build state '%s'"
114                           verrel sub)
115           with
116             Not_found ->
117               failwith (sprintf "koji_build_state_task: %s: no build state found"
118                           verrel) in
119         let task =
120           try
121             let subs = Pcre.exec ~rex:task_id out in
122             Some (int_of_string (Pcre.get_substring subs 1))
123           with
124             Not_found -> None in
125
126         if state == `Complete then
127           memory_set key "1";
128
129         state, task
130       )
131     )
132
133 (* Perform a Koji build and wait until it finishes.  If it fails,
134  * throw an exception.
135  *)
136 let koji_build =
137   let created_task = Pcre.regexp "Created task: (\\d+)" in
138   let name_or_service_not_known =
139     contains_substring "Name or service not known" in
140   let completed_successfully = contains_substring "completed successfully" in
141   let failed = contains_substring "FAILED" in
142   fun ?(wait = true) pkg branch ->
143     let repodir = fedora_repo pkg branch in
144     let out =
145       shout "
146         cd %s
147         fedpkg build%s 2>&1
148     " repodir (if not wait then " --nowait" else "")
149     in
150     if not wait then (
151       (* Just check the task was created. *)
152       if not (Pcre.pmatch ~rex:created_task out) then (
153         failwith "fedpkg build: build failed to start"
154       )
155     ) else (
156       let task_id =
157         try
158           let subs = Pcre.exec ~rex:created_task out in
159           int_of_string (Pcre.get_substring subs 1)
160         with Not_found ->
161           failwith "could not find task ID in fedpkg build output" in
162       let rec loop out =
163         if name_or_service_not_known out then (
164           let out =
165             shout "cd %s && koji watch-task %d 2>&1 ||:" repodir task_id in
166           loop out
167         )
168         else if completed_successfully out then
169           ()
170         else if failed out then (
171           failwith "koji build failed"
172         )
173         else
174           failwith (sprintf "koji_build: unknown output: %s" out)
175       in
176       loop out
177     )
178
179 let koji_wait_repo =
180   let successfully_waited = contains_substring "Successfully waited" in
181   fun target verrel ->
182     let out = shout "koji wait-repo %s --build=%s 2>&1 ||:" target verrel in
183     if successfully_waited out then
184       ()
185     else
186       failwith (sprintf "koji_wait_repo: unknown output: %s" out)