BaseTools/BinToPcd: Fix Python 2.7.x compatibility issue
[mirror_edk2.git] / OvmfPkg / create-release.py
1 #!/usr/bin/python
2 #
3 # Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>
4 #
5 # This program and the accompanying materials
6 # are licensed and made available under the terms and conditions of the BSD License
7 # which accompanies this distribution. The full text of the license may be found at
8 # http://opensource.org/licenses/bsd-license.php
9 #
10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12 #
13
14 import os
15 import re
16 import StringIO
17 import subprocess
18 import sys
19 import zipfile
20
21 is_unix = not sys.platform.startswith('win')
22
23 if not is_unix:
24 print "This script currently only supports unix-like systems"
25 sys.exit(-1)
26
27 if os.path.exists('OvmfPkgX64.dsc'):
28 os.chdir('..')
29
30 if not os.path.exists(os.path.join('OvmfPkg', 'OvmfPkgX64.dsc')):
31 print "OvmfPkg/OvmfPkgX64.dsc doesn't exist"
32 sys.exit(-1)
33
34 def run_and_capture_output(args, checkExitCode = True):
35 p = subprocess.Popen(args=args, stdout=subprocess.PIPE)
36 stdout = p.stdout.read()
37 ret_code = p.wait()
38 if checkExitCode:
39 assert ret_code == 0
40 return stdout
41
42 gcc_version = run_and_capture_output(args=('gcc', '--version'))
43 gcc_re = re.compile(r'\s*\S+\s+\([^\)]+?\)\s+(\d+(?:\.\d+)*)(?:\s+.*)?')
44 mo = gcc_re.match(gcc_version)
45 if not mo:
46 print "Unable to find GCC version"
47 sys.exit(-1)
48 gcc_version = map(lambda n: int(n), mo.group(1).split('.'))
49
50 if 'TOOLCHAIN' in os.environ:
51 TOOLCHAIN = os.environ['TOOLCHAIN']
52 else:
53 assert(gcc_version[0] == 4)
54 minor = max(4, min(7, gcc_version[1]))
55 TOOLCHAIN = 'GCC4' + str(minor)
56
57 def git_based_version():
58 dir = os.getcwd()
59 if not os.path.exists('.git'):
60 os.chdir('OvmfPkg')
61 stdout = run_and_capture_output(args=('git', 'log',
62 '-n', '1',
63 '--abbrev-commit'))
64 regex = re.compile(r'^\s*git-svn-id:\s+\S+@(\d+)\s+[0-9a-f\-]+$',
65 re.MULTILINE)
66 mo = regex.search(stdout)
67 if mo:
68 version = 'r' + mo.group(1)
69 else:
70 version = stdout.split(None, 3)[1]
71 os.chdir(dir)
72 return version
73
74 def svn_info():
75 dir = os.getcwd()
76 os.chdir('OvmfPkg')
77 stdout = run_and_capture_output(args=('svn', 'info'))
78 os.chdir(dir)
79 return stdout
80
81 def svn_based_version():
82 buf = svn_info()
83 revision_re = re.compile('^Revision\:\s*([\da-f]+)$', re.MULTILINE)
84 mo = revision_re.search(buf)
85 assert(mo is not None)
86 return 'r' + mo.group(1)
87
88 def get_revision():
89 if os.path.exists(os.path.join('OvmfPkg', '.svn')):
90 return svn_based_version()
91 else:
92 return git_based_version()
93
94 revision = get_revision()
95
96 newline_re = re.compile(r'(\n|\r\n|\r(?!\n))', re.MULTILINE)
97 def to_dos_text(str):
98 return newline_re.sub('\r\n', str)
99
100 def gen_build_info():
101 distro = run_and_capture_output(args=('lsb_release', '-sd')).strip()
102
103 machine = run_and_capture_output(args=('uname', '-m')).strip()
104
105 gcc_version_str = '.'.join(map(lambda v: str(v), gcc_version))
106
107 ld_version = run_and_capture_output(args=('ld', '--version'))
108 ld_version = ld_version.split('\n')[0].split()[-1]
109
110 iasl_version = run_and_capture_output(args=('iasl'), checkExitCode=False)
111 iasl_version = filter(lambda s: s.find(' version ') >= 0, iasl_version.split('\n'))[0]
112 iasl_version = iasl_version.split(' version ')[1].strip()
113
114 sb = StringIO.StringIO()
115 print >> sb, 'edk2: ', revision
116 print >> sb, 'compiler: GCC', gcc_version_str, '(' + TOOLCHAIN + ')'
117 print >> sb, 'binutils:', ld_version
118 print >> sb, 'iasl: ', iasl_version
119 print >> sb, 'system: ', distro, machine.replace('_', '-')
120 return to_dos_text(sb.getvalue())
121
122 def read_file(filename):
123 f = open(filename)
124 d = f.read()
125 f.close()
126 return d
127
128 LICENSE = to_dos_text(
129 '''This OVMF binary release is built from source code licensed under
130 the BSD open source license. The BSD license is documented at
131 http://opensource.org/licenses/bsd-license.php, and a copy is
132 shown below.
133
134 One sub-component of the OVMF project is a FAT filesystem driver. The FAT
135 filesystem driver code is also BSD licensed, but the code license contains
136 one additional term. This license can be found at
137 https://github.com/tianocore/tianocore.github.io/wiki/Edk2-fat-driver
138 and a copy is shown below (following the normal BSD license).
139
140 === BSD license: START ===
141
142 ''')
143
144 LICENSE += read_file(os.path.join('MdePkg', 'License.txt'))
145
146 LICENSE += to_dos_text(
147 '''
148 === BSD license: END ===
149
150 === FAT filesystem driver license: START ===
151
152 ''')
153
154 LICENSE += read_file(os.path.join('FatBinPkg', 'License.txt'))
155
156 LICENSE += to_dos_text(
157 '''
158 === FAT filesystem driver license: END ===
159 ''')
160
161 def build(arch):
162 args = (
163 'OvmfPkg/build.sh',
164 '-t', TOOLCHAIN,
165 '-a', arch,
166 '-b', 'RELEASE'
167 )
168 logname = 'build-%s.log' % arch
169 build_log = open(logname, 'w')
170 print 'Building OVMF for', arch, '(%s)' % logname, '...',
171 sys.stdout.flush()
172 p = subprocess.Popen(args=args, stdout=build_log, stderr=build_log)
173 ret_code = p.wait()
174 if ret_code == 0:
175 print '[done]'
176 else:
177 print '[error 0x%x]' % ret_code
178 return ret_code
179
180 def create_zip(arch):
181 global build_info
182 filename = 'OVMF-%s-%s.zip' % (arch, revision)
183 print 'Creating', filename, '...',
184 sys.stdout.flush()
185 if os.path.exists(filename):
186 os.remove(filename)
187 zipf = zipfile.ZipFile(filename, 'w', zipfile.ZIP_DEFLATED)
188
189 zipf.writestr('BUILD_INFO', build_info)
190 zipf.writestr('LICENSE', LICENSE)
191 zipf.write(os.path.join('OvmfPkg', 'README'), 'README')
192 FV_DIR = os.path.join(
193 'Build',
194 'Ovmf' + arch.title(),
195 'RELEASE_' + TOOLCHAIN,
196 'FV'
197 )
198 zipf.write(os.path.join(FV_DIR, 'OVMF.fd'), 'OVMF.fd')
199 zipf.close()
200 print '[done]'
201
202 build_info = gen_build_info()
203 build('IA32')
204 build('X64')
205 create_zip('IA32')
206 create_zip('X64')
207
208