Debian Codegraph @

third_party/glslang/build_info.py

raw ◀ ▶
1 Debian patch touch this file
•1 #!/usr/bin/env python3
2
3 # Copyright (c) 2020 Google Inc.
4 #
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at
8 #
9 # http://www.apache.org/licenses/LICENSE-2.0
10 #
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
16
17 import datetime
18 import errno
19 import os
20 import os.path
21 import re
22 import subprocess
23 import sys
24 import time
25
26 usage = """{} emits a string to stdout or file with project version information.
27
28 args: <project-dir> [<input-string>] [-i <input-file>] [-o <output-file>]
29
30 Either <input-string> or -i <input-file> needs to be provided.
31
32 The tool will output the provided string or file content with the following
33 tokens substituted:
34
35 <major> - The major version point parsed from the CHANGES.md file.
36 <minor> - The minor version point parsed from the CHANGES.md file.
37 <patch> - The point version point parsed from the CHANGES.md file.
38 <flavor> - The optional dash suffix parsed from the CHANGES.md file (excluding
39 dash prefix).
40 <-flavor> - The optional dash suffix parsed from the CHANGES.md file (including
41 dash prefix).
42 <date> - The optional date of the release in the form YYYY-MM-DD
43 <commit> - The git commit information for the directory taken from
44 "git describe" if that succeeds, or "git rev-parse HEAD"
45 if that succeeds, or otherwise a message containing the phrase
46 "unknown hash".
47
48 -o is an optional flag for writing the output string to the given file. If
49 ommitted then the string is printed to stdout.
50 """
51
52 def mkdir_p(directory):
53 """Make the directory, and all its ancestors as required. Any of the
54 directories are allowed to already exist."""
55
56 if directory == "":
57 # We're being asked to make the current directory.
58 return
59
60 try:
61 os.makedirs(directory)
62 except OSError as e:
63 if e.errno == errno.EEXIST and os.path.isdir(directory):
64 pass
65 else:
66 raise
67
68
69 def command_output(cmd, directory):
70 """Runs a command in a directory and returns its standard output stream.
71
72 Captures the standard error stream.
73
74 Raises a RuntimeError if the command fails to launch or otherwise fails.
75 """
76 p = subprocess.Popen(cmd,
77 cwd=directory,
78 stdout=subprocess.PIPE,
79 stderr=subprocess.PIPE)
80 (stdout, _) = p.communicate()
81 if p.returncode != 0:
82 raise RuntimeError('Failed to run %s in %s' % (cmd, directory))
83 return stdout
84
85
86 def deduce_software_version(directory):
87 """Returns a software version number parsed from the CHANGES.md file
88 in the given directory.
89
90 The CHANGES.md file describes most recent versions first.
91 """
92
93 # Match the first well-formed version-and-date line.
94 # Allow trailing whitespace in the checked-out source code has
95 # unexpected carriage returns on a linefeed-only system such as
96 # Linux.
97 pattern = re.compile(r'^#* +(\d+)\.(\d+)\.(\d+)(-\w+)? (\d\d\d\d-\d\d-\d\d)? *$')
98 changes_file = os.path.join(directory, 'CHANGES.md')
99 with open(changes_file, mode='r') as f:
100 for line in f.readlines():
101 match = pattern.match(line)
102 if match:
103 flavor = match.group(4)
104 if flavor == None:
105 flavor = ""
106 return {
107 "major": match.group(1),
108 "minor": match.group(2),
109 "patch": match.group(3),
110 "flavor": flavor.lstrip("-"),
111 "-flavor": flavor,
112 "date": match.group(5),
113 }
114 raise Exception('No version number found in {}'.format(changes_file))
115
116
117 def describe(directory):
118 """Returns a string describing the current Git HEAD version as descriptively
119 as possible.
120
121 Runs 'git describe', or alternately 'git rev-parse HEAD', in directory. If
122 successful, returns the output; otherwise returns 'unknown hash, <date>'."""
123 try:
124 # decode() is needed here for Python3 compatibility. In Python2,
125 # str and bytes are the same type, but not in Python3.
126 # Popen.communicate() returns a bytes instance, which needs to be
127 # decoded into text data first in Python3. And this decode() won't
128 # hurt Python2.
129 return command_output(['git', 'describe'], directory).rstrip().decode()
130 except:
131 try:
132 return command_output(
133 ['git', 'rev-parse', 'HEAD'], directory).rstrip().decode()
134 except:
135 # This is the fallback case where git gives us no information,
136 # e.g. because the source tree might not be in a git tree.
137 # In this case, usually use a timestamp. However, to ensure
138 # reproducible builds, allow the builder to override the wall
139 # clock time with environment variable SOURCE_DATE_EPOCH
140 # containing a (presumably) fixed timestamp.
141 timestamp = int(os.environ.get('SOURCE_DATE_EPOCH', time.time()))
142 formatted = datetime.datetime.utcfromtimestamp(timestamp).isoformat()
143 return 'unknown hash, {}'.format(formatted)
144
145 def parse_args():
146 directory = None
147 input_string = None
148 input_file = None
149 output_file = None
150
151 if len(sys.argv) < 2:
152 raise Exception("Invalid number of arguments")
153
154 directory = sys.argv[1]
155 i = 2
156
157 if not sys.argv[i].startswith("-"):
158 input_string = sys.argv[i]
159 i = i + 1
160
161 while i < len(sys.argv):
162 opt = sys.argv[i]
163 i = i + 1
164
165 if opt == "-i" or opt == "-o":
166 if i == len(sys.argv):
167 raise Exception("Expected path after {}".format(opt))
168 val = sys.argv[i]
169 i = i + 1
170 if (opt == "-i"):
171 input_file = val
172 elif (opt == "-o"):
173 output_file = val
174 else:
175 raise Exception("Unknown flag {}".format(opt))
176
177 return {
178 "directory": directory,
179 "input_string": input_string,
180 "input_file": input_file,
181 "output_file": output_file,
182 }
183
184 def main():
185 args = None
186 try:
187 args = parse_args()
188 except Exception as e:
189 print(e)
190 print("\nUsage:\n")
191 print(usage.format(sys.argv[0]))
192 sys.exit(1)
193
194 directory = args["directory"]
195 template = args["input_string"]
196 if template == None:
197 with open(args["input_file"], 'r') as f:
198 template = f.read()
199 output_file = args["output_file"]
200
201 software_version = deduce_software_version(directory)
202 commit = describe(directory)
203 output = template \
204 .replace("<major>", software_version["major"]) \
205 .replace("<minor>", software_version["minor"]) \
206 .replace("<patch>", software_version["patch"]) \
207 .replace("<flavor>", software_version["flavor"]) \
208 .replace("<-flavor>", software_version["-flavor"]) \
209 .replace("<date>", software_version["date"]) \
210 .replace("<commit>", commit)
211
212 if output_file is None:
213 print(output)
214 else:
215 mkdir_p(os.path.dirname(output_file))
216
217 if os.path.isfile(output_file):
218 with open(output_file, 'r') as f:
219 if output == f.read():
220 return
221
222 with open(output_file, 'w') as f:
223 f.write(output)
224
225 if __name__ == '__main__':
226 main()