1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
# This file is part of ipsutils.
# ipsutils is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# ipsutils is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with ipsutils. If not, see <http://www.gnu.org/licenses/>.
from . import env, task
from pprint import pprint
import os
import shutil
import subprocess
import string
from . import tpl
class Build(env.Environment):
def __init__(self, ipsfile):
# Parent Config parses configuration data in .ips file
# Inherited members are used to populate package information
# as well as build tasks
super(Build, self).__init__(ipsfile)
os.chdir(self.env['IPSBUILD'])
# Create list of build tasks
ordered_tasks = ['prep', 'build', 'install']
self.controller = task.TaskController()
# Assign built-in IPS tasks
self.controller.task(task.NamedTask('Extract source', self.source_unpack))
self.controller.task(task.NamedTask('Create buildroot', self.create_buildroot))
self.controller.task(task.NamedTask('Create metadata', self.create_metadata))
# Assign user defined .ips tasks in build order
for user_task in ordered_tasks:
self.controller.task(task.NamedTask(user_task, self.exec_scripted_process, self.script_dict[user_task]))
def exec_scripted_process(self, *p):
"""Execute script in .ips
This function needs to be rewritten BAD
p: tuple of function arguments
"""
# All execution occurs from within the build directory.
# This includes all installation-like tasks
os.chdir(self.env_pkg['BUILD'])
for t in map(list, p):
for i in t:
if not i:
continue
for e in i:
# Variable expansion occurs here. Unfortunately, env_pkg is NOT available
# from within the configuration class
t = string.Template(string.join(e))
e = t.safe_substitute(self.env_pkg)
print("+ {0:s}".format(e))
# Using "shell" is dangerous, but we're in the business of danger... right?
output = subprocess.check_output(e, shell=True)
if output:
print("+ {0:s}".format(output).rstrip('\n'))
os.chdir(self.env['IPSBUILD'])
return True
def source_unpack(self, *p):
path = os.path.relpath(self.env_pkg['SOURCES'], self.env['IPSBUILD'])
if not os.path.exists(path):
print("{0:s}: does not exist".format(path))
return False
ext = {
'.tar': '{0:s} xf {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
'.tar.gz': '{0:s} xfz {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
'.tar.bz2': '{0:s} xfj {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
'.tar.xz': '{0:s} xfJ {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
'.gz': self.tool['gunzip'],
'.bz2': self.tool['bunzip'],
'.zip': self.tool['unzip']
}
cmd = []
for k, v in ext.items():
if k in path:
cmd = v.split()
print(string.join(cmd))
subprocess.check_output(cmd)
break
return True
def create_buildroot(self, *p):
"""Destroy/Create BUILDROOT per execution to keep the envrionment stable
p: tuple of function arguments
"""
# BUILDPROTO is a subdirectory of BUILDROOT/pkgname
path = self.env_pkg['BUILDPROTO']
if os.path.exists(path):
shutil.rmtree(path)
os.makedirs(path, 0755)
return True
def create_metadata(self, *p):
output = []
meta_map = {
'pkg.fmri': self.key_dict['name'],
'pkg.description': self.key_dict['description'],
'pkg.summary': self.key_dict['summary'],
'variant.arch': self.key_dict['arch'],
'info.upstream_url': self.key_dict['upstream_url'],
'info.source_url': self.key_dict['source_url'],
'info.classification': self.key_dict['classification']
}
# Perform manifest template mapping and expansion
template = file(tpl.metadata, 'r')
for line in template.readlines():
for k, v in meta_map.items():
if k in line:
# pkg.fmri requires special attention to build the proper
# package name IPS wants
if k == 'pkg.fmri':
output.append(line.replace('{}',
self.key_dict['group'] +
"/" +
self.key_dict['name'] +
"@" +
self.key_dict['version'] +
"," +
self.key_dict['release']
))
continue
# The rest of the value replacements are rather simple
output.append(line.replace('{}', v))
template.close()
# Generate intial IPS manifest file in buildroot
manifest = file(os.path.join(self.env_pkg['BUILDROOT'], self.complete_name + '.mog'), 'w+')
for line in output:
manifest.writelines(line)
print(manifest.name)
manifest.close()
return True
def create_package_list(self, *p):
pass
def show_summary(self):
print("Summary of {0:s}".format(self.key_dict['name']))
for k, v in sorted(self.key_dict.items()):
print("+ {0:s}: {1:s}".format(k, v))
|
