File: 0alias

package info (click to toggle)
zeroinstall-injector 0.34-1
  • links: PTS
  • area: main
  • in suites: lenny
  • size: 1,048 kB
  • ctags: 1,236
  • sloc: python: 10,189; xml: 167; makefile: 34; sh: 16
file content (202 lines) | stat: -rwxr-xr-x 6,637 bytes parent folder | download
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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
#!/usr/bin/env python
import os, sys
from optparse import OptionParser

from zeroinstall.injector import reader, model
from zeroinstall import support, alias, helpers
from zeroinstall.support import basedir

def export(name, value):
	"""Try to guess the command to set an environment variable."""
	shell = os.environ.get('SHELL', '?')
	if 'csh' in shell:
		return "setenv %s %s" % (name, value)
	return "export %s=%s" % (name, value)

def find_path(paths):
	"""Find the first writable path in : separated list."""
	for path in paths:
		if os.path.realpath(path).startswith(basedir.xdg_cache_home):
			pass # print "Skipping cache", first_path
		elif not os.access(path, os.W_OK):
			pass # print "No access", first_path
		else:
			break
	else:
		return None

	return path

# Do this here so we can include it in the help message.
# But, don't abort if there isn't one because we might
# be doing something else (e.g. --manpage)
first_path = find_path(os.environ['PATH'].split(':'))

parser = OptionParser(usage="usage: %%prog [options] alias [interface [command]]\n\n"
		"Creates a script in the first usable directory in $PATH\n"
		"(%s) to run 'interface' unless overridden by --dir.\n"
		"If no interface is given, edits the policy for an existing alias.\n"
		"For interfaces providing more than one command, the desired command\n"
		"may also be given." % first_path)
parser.add_option("-m", "--manpage", help="show the manual page for an existing alias", action='store_true')
parser.add_option("-r", "--resolve", help="show the URI for an alias", action='store_true')
parser.add_option("-V", "--version", help="display version information", action='store_true')
parser.add_option("-d", "--dir", help="install in DIR", dest="user_path", metavar="DIR")
parser.disable_interspersed_args()

(options, args) = parser.parse_args()

if options.version:
	import zeroinstall
	print "0alias (zero-install) " + zeroinstall.version
	print "Copyright (C) 2007 Thomas Leonard"
	print "This program comes with ABSOLUTELY NO WARRANTY,"
	print "to the extent permitted by law."
	print "You may redistribute copies of this program"
	print "under the terms of the GNU Lesser General Public License."
	print "For more information about these matters, see the file named COPYING."
	sys.exit(0)

if options.manpage:
	if len(args) != 1:
		os.execlp('man', 'man', *args)
		sys.exit(1)

if len(args) < 1 or len(args) > 3:
	parser.print_help()
	sys.exit(1)
alias_prog, interface_uri, main = (list(args) + [None, None])[:3]

if options.resolve or options.manpage:
	if interface_uri is not None:
		parser.print_help()
		sys.exit(1)

if options.user_path:
	first_path = options.user_path
	if not os.path.isdir(first_path):
		print >>sys.stderr, "Directory '%s' does not exist." % first_path
		sys.exit(1)

if interface_uri is None:
	try:
		if not os.path.isabs(alias_prog):
			full_path = support.find_in_path(alias_prog)
			if not full_path:
				raise alias.NotAnAliasScript("Not found in $PATH: " + alias_prog)
		else:
			full_path = alias_prog

		interface_uri, main = alias.parse_script(full_path)
	except alias.NotAnAliasScript, ex:
		if options.manpage:
			os.execlp('man', 'man', *args)
		print >>sys.stderr, str(ex)
		sys.exit(1)

interface_uri = model.canonical_iface_uri(interface_uri)

if options.resolve:
	print interface_uri
	sys.exit(0)

if options.manpage:
	sels = helpers.ensure_cached(interface_uri)
	if not sels:
		# Cancelled by user
		sys.exit(1)

	selected_impl = sels.selections[interface_uri]
	if selected_impl.id.startswith('/'):
		impl_path = selected_impl.id
	else:
		from zeroinstall.injector.iface_cache import iface_cache
		impl_path = iface_cache.stores.lookup(selected_impl.id)

	if main is None:
		main = selected_impl.main
		if main is None:
			print >>sys.stderr, "No main program for interface '%s'" % interface_uri
			sys.exit(1)

	prog_name = os.path.basename(main)
	alias_name = os.path.basename(args[0])

	assert impl_path

	# TODO: the feed should say where the man-pages are, but for now we'll accept
	# a directory called man in some common locations...
	for mandir in ['man', 'share/man', 'usr/man', 'usr/share/man']:
		manpath = os.path.join(impl_path, mandir)
		if os.path.isdir(manpath):
			# Note: unlike "man -M", this also copes with LANG settings...
			os.environ['MANPATH'] = manpath
			os.execlp('man', 'man', prog_name)
			sys.exit(1)

	# No man directory given or found, so try searching for man files

	manpages = []
	for root, dirs, files in os.walk(impl_path):
		for f in files:
			if f.endswith('.gz'):
				manpage_file = f[:-3]
			else:
				manpage_file = f
			if manpage_file.endswith('.1') or \
			   manpage_file.endswith('.6') or \
			   manpage_file.endswith('.8'):
			   	manpage_prog = manpage_file[:-2]
				if manpage_prog == prog_name or manpage_prog == alias_name:
					os.execlp('man', 'man', os.path.join(root, f))
					sys.exit(1)
				else:
					manpages.append((root, f))

	print "No matching manpage was found for '%s' (%s)" % (alias_name, interface_uri)
	if manpages:
		print "These non-matching man-pages were found, however:"
		for root, file in manpages:
			print os.path.join(root, file)
	sys.exit(1)

if first_path is None:
	print >>sys.stderr, ("No writable non-cache directory in $PATH, which currently contains:\n\n%s\n\n"
			     "To create a directory for your scripts, use these commands:\n"
			     "$ mkdir ~/bin\n"
			     "$ %s\n"
			     "or specify a writable path with --path"
			     % ('\n'.join(os.environ['PATH'].split(':')), export('PATH', '$HOME/bin:$PATH')))
	sys.exit(1)

if len(args) == 1:
	os.execlp('0launch', '0launch', '-gd', '--', interface_uri)
	sys.exit(1)

try:
	interface = model.Interface(interface_uri)
	if not reader.update_from_cache(interface):
		print >>sys.stderr, "Interface '%s' not currently in cache. Fetching..." % interface_uri
		if os.spawnlp(os.P_WAIT, '0launch', '0launch', '-d', interface_uri):
			raise model.SafeException("0launch failed")
		if not reader.update_from_cache(interface):
			raise model.SafeException("Interface still not in cache. Aborting.")

	script = os.path.join(first_path, alias_prog)
	if os.path.exists(script):
		raise model.SafeException("File '%s' already exists. Delete it first." % script)
		sys.exit(1)
except model.SafeException, ex:
	print >>sys.stderr, ex
	sys.exit(1)

wrapper = file(script, 'w')
alias.write_script(wrapper, interface_uri, main)

# Make new script executable
os.chmod(script, 0111 | os.fstat(wrapper.fileno()).st_mode)
wrapper.close()

print "Created script '%s'." % script
print "To edit policy: 0alias %s" % alias_prog
print "(note: some shells require you to type 'rehash' now)"