Use /usr/bin/env to locate python.
[bitbake.git] / bin / oeinstall
1 #!/usr/bin/env python
2
3 import sys, os, string, oe
4 from oe import *
5
6 __version__ = 1.0
7 cfg_oe = data.init()
8
9 def usage():
10         print "Usage: oeinstall [options ...]"
11         print "Installs specified files of supported types into a root filesystem."
12         print "Currently only supports installing OEFILES into the rootfs directly"
13         print "using their do_install target."
14         print ""
15         print "  %s\t\t%s" % ("-r [arg], --root [arg]", "root directory (default=${IMAGE_ROOTFS})")
16         print "  %s\t\t%s" % ("-f [arg], --files [arg]", ".oe files available (default=${OEFILES})")
17         print "  %s\t\t%s" % ("-t [arg], --type [arg]", "installation type (direct, and any for which package_[type].oeclass exists)")
18         print "  %s\t\t%s" % ("-v, --version", "output version information and exit")
19         sys.exit(0)
20
21 def version():
22         print "OpenEmbedded Build Infrastructure Core version %s" % oe.__version__
23         print "OEInstall version %s" % __version__
24
25 def getopthash(l):
26         h = {}
27         for (opt, val) in l:
28                 h[opt] = val
29         return h
30
31 import getopt
32 try:
33         (opts, args) = getopt.getopt(sys.argv[1:], 'vr:f:t:', [ 'version', 'root=', 'files=', 'type=' ])
34 except getopt.GetoptError:
35         usage()
36
37 # handle opts
38 opthash = getopthash(opts)
39
40 if opthash.has_key('--version') or opthash.has_key('-v'):
41         version()
42         sys.exit(0)
43
44 try:
45         cfg_oe = parse.handle("conf/oe.conf", cfg_oe)
46 except IOError:
47         fatal("Unable to open oe.conf")
48
49 # sanity check
50 if cfg_oe is None:
51         fatal("Unable to open/parse conf/oe.conf")
52         usage(1)
53
54 rootfs = data.getVar('IMAGE_ROOTFS', cfg_oe, 1)
55
56 if opthash.has_key('--root'):
57         rootfs = opthash['--root']
58 if opthash.has_key('-r'):
59         rootfs = opthash['-r']
60
61 if not rootfs:
62         oe.fatal("root filesystem not specified")
63
64 data.setVar('IMAGE_ROOTFS', rootfs, cfg_oe)
65
66 #type = 'direct'
67 type = 'tar'
68
69 if opthash.has_key('--type'):
70         type = opthash['--type']
71 if opthash.has_key('-t'):
72         type = opthash['-t']
73
74 # grab OEDIR
75 topdir = data.getVar('TOPDIR', cfg_oe, 1) or os.getcwd()
76 oedir = data.getVar('OEDIR', cfg_oe, 1) or topdir
77 mkdirhier(oedir)
78
79 # Iterate through .oe files
80 files = string.split(data.getVar("OEFILES", cfg_oe, 1) or "")
81 if opthash.has_key('-f'):
82         files.extend(opthash['-f'])
83 if opthash.has_key('--files'):
84         files.extend(opthash['--files'])
85 data.setVar("OEFILES", string.join(files), cfg_oe)
86
87 def get_oefiles():
88         """Get default oefiles"""
89         dirs = os.listdir(os.getcwd())
90         oefiles = []
91         for f in dirs:
92                 (root, ext) = os.path.splitext(f)
93                 if ext == ".oe":
94                         oefiles.append(os.path.abspath(os.path.join(os.getcwd(),f)))
95         return oefiles
96
97 if not len(files):
98         files = get_oefiles()
99
100 if not len(files):
101         usage()
102
103 def inst_pkg(d):
104         from oe import data, build, error
105         if data.getVar('pkg_preinst', d):
106                 try:
107                         build.exec_func('pkg_preinst', d)
108                 except build.FuncFailed:
109                         oe.note("preinst execution failure")
110                         return 0
111         if type is not 'direct':
112                 try:
113                         build.exec_func('package_%s_fn' % type, d)
114                 except build.FuncFailed:
115                         oe.error("failed obtaining the filename of the outputted package for %s" % type)
116                         return 0
117         if data.getVar('package_%s_install' % type, d):
118                 try:
119                         build.exec_func('package_%s_install' % type, d)
120                         print "package %s (%s) installed." % (p, data.getVar('PN', d, 1))
121                 except build.FuncFailed:
122                         return 0
123         else:
124                 oe.error("no package_%s_install function to execute. skipping." % type)
125                 return 0
126         if data.getVar('pkg_postinst', d):
127                 try:
128                         build.exec_func('pkg_postinst', d)
129                 except build.FuncFailed:
130                         oe.note("postinst execution failure")
131                         pass
132         return 1
133
134
135 # if type is not direct, add 'package_[type]' to INHERIT
136 if type is not 'direct':
137         inherit = data.getVar('INHERIT', cfg_oe, 1) or ""
138         inherit += " base package_%s" % type
139         data.setVarFlag('INHERIT', 'export', 1, cfg_oe)
140         data.setVar('INHERIT', inherit, cfg_oe)
141
142 pkgs_to_install = None
143 if args:
144         if not pkgs_to_install:
145                 pkgs_to_install = []
146         pkgs_to_install.extend(args)
147 if not pkgs_to_install:
148         inst_oepkgs = data.getVar('INST_OEPKGS', cfg_oe, 1)
149         if inst_oepkgs:
150                 pkgs_to_install = string.split(inst_oepkgs)
151 debug(1, "installing: %s" % pkgs_to_install)
152
153 import glob
154 for f in files:
155         if pkgs_to_install is not None and len(pkgs_to_install) == 0:
156                 # done!
157                 break
158         globbed = glob.glob(f) or [ f ]
159         if globbed:
160                 if [ f ] != globbed:
161                         files += globbed
162                         continue
163         from copy import deepcopy
164         fdata = deepcopy(cfg_oe)
165         parse.handle(f, fdata)
166         if fdata is None:
167                 continue
168         # allow metadata files to add items to OEFILES
169         data.update_data(fdata)
170         addoefiles = data.getVar('OEFILES', fdata) or None
171         if addoefiles:
172                 for aof in string.split(addoefiles):
173                         if not files.count(aof):
174                                 if not os.path.isabs(aof):
175                                         aof = os.path.join(os.path.dirname(f),aof)
176                                 files.append(aof)
177         pkgs = string.split(data.getVar('PACKAGES', fdata, 1) or "")
178         # Iterate through PACKAGES
179         for p in pkgs:
180                 if pkgs_to_install is not None:
181                         if not p in pkgs_to_install:
182                                 continue
183                 d = deepcopy(fdata)
184                 data.setVar('PKG', p, d)
185                 # Add package to overrides, collapse the metadata
186                 overrides = data.getVar('OVERRIDES', d, 1) or ""
187                 overrides += ":%s" % p
188                 data.setVar('OVERRIDES', overrides, d)
189                 data.update_data(d)
190                 data.setVarFlag('INHERIT', 'export', 1, d)
191                 # Look at vars to determine the file names for the package type in question
192                 # Call installer for a given package type as pulled from the metadata with INHERIT set properly
193                 data.setVar('D', rootfs, d)
194                 if inst_pkg(d):
195                         if pkgs_to_install is not None:
196                                 del pkgs_to_install[pkgs_to_install.index(p)]
197                 if pkgs_to_install is not None and len(pkgs_to_install) == 0:
198                         break