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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
|
# Copyright 2009 Canonical Ltd. This software is licensed under the
# GNU Affero General Public License version 3 (see the file LICENSE).
# pylint: disable-msg=E0611,W0212
"""Launchpad Pillars share a namespace.
Pillars are currently Product, ProjectGroup and Distribution.
"""
__metaclass__ = type
import warnings
from sqlobject import (
BoolCol,
ForeignKey,
StringCol,
)
from storm.expr import LeftJoin
from storm.info import ClassAlias
from storm.locals import SQL
from storm.store import Store
from zope.component import getUtility
from zope.interface import implements
from canonical.config import config
from canonical.database.sqlbase import (
cursor,
SQLBase,
sqlvalues,
)
from lp.services.helpers import ensure_unicode
from canonical.launchpad.webapp.interfaces import (
DEFAULT_FLAVOR,
IStoreSelector,
MAIN_STORE,
)
from lp.app.errors import NotFoundError
from lp.registry.interfaces.distribution import (
IDistribution,
IDistributionSet,
)
from lp.registry.interfaces.pillar import (
IPillarName,
IPillarNameSet,
)
from lp.registry.interfaces.product import (
IProduct,
IProductSet,
)
from lp.registry.interfaces.projectgroup import IProjectGroupSet
from lp.registry.model.featuredproject import FeaturedProject
__all__ = [
'pillar_sort_key',
'HasAliasMixin',
'PillarNameSet',
'PillarName',
]
def pillar_sort_key(pillar):
"""A sort key for a set of pillars. We want:
- products first, alphabetically
- distributions, with ubuntu first and the rest alphabetically
"""
product_name = None
distribution_name = None
if IProduct.providedBy(pillar):
product_name = pillar.name
elif IDistribution.providedBy(pillar):
distribution_name = pillar.name
# Move ubuntu to the top.
if distribution_name == 'ubuntu':
distribution_name = '-'
return (distribution_name, product_name)
class PillarNameSet:
implements(IPillarNameSet)
def __contains__(self, name):
"""See `IPillarNameSet`."""
store = getUtility(IStoreSelector).get(MAIN_STORE, DEFAULT_FLAVOR)
name = ensure_unicode(name)
result = store.execute("""
SELECT TRUE
FROM PillarName
WHERE (id IN (SELECT alias_for FROM PillarName WHERE name=?)
OR name=?)
AND alias_for IS NULL
AND active IS TRUE
""", [name, name])
return result.get_one() is not None
def __getitem__(self, name):
"""See `IPillarNameSet`."""
pillar = self.getByName(name, ignore_inactive=True)
if pillar is None:
raise NotFoundError(name)
return pillar
def getByName(self, name, ignore_inactive=False):
"""Return the pillar with the given name.
If ignore_inactive is True, then only active pillars are considered.
If no pillar is found, None is returned.
"""
# We could attempt to do this in a single database query, but I
# expect that doing two queries will be faster that OUTER JOINing
# the Project, Product and Distribution tables (and this approach
# works better with SQLObject too.
# Retrieve information out of the PillarName table.
store = getUtility(IStoreSelector).get(MAIN_STORE, DEFAULT_FLAVOR)
cur = cursor()
query = """
SELECT id, product, project, distribution
FROM PillarName
WHERE (id IN (SELECT alias_for FROM PillarName WHERE name=?)
OR name=?)
AND alias_for IS NULL
"""
if ignore_inactive:
query += " AND active IS TRUE"
name = ensure_unicode(name)
result = store.execute(query, [name, name])
row = result.get_one()
if row is None:
return None
assert len([column for column in row[1:] if column is None]) == 2, (
"One (and only one) of product, project or distribution may be "
"NOT NULL: %s" % row[1:])
id, product, project, distribution = row
if product is not None:
return getUtility(IProductSet).get(product)
elif project is not None:
return getUtility(IProjectGroupSet).get(project)
else:
return getUtility(IDistributionSet).get(distribution)
def build_search_query(self, text, extra_columns=()):
"""Query parameters shared by search() and count_search_matches().
:returns: Storm ResultSet object
"""
# These classes are imported in this method to prevent an import loop.
from lp.registry.model.product import Product
from lp.registry.model.projectgroup import ProjectGroup
from lp.registry.model.distribution import Distribution
OtherPillarName = ClassAlias(PillarName)
origin = [
PillarName,
LeftJoin(
OtherPillarName, PillarName.alias_for == OtherPillarName.id),
LeftJoin(Product, PillarName.product == Product.id),
LeftJoin(ProjectGroup, PillarName.project == ProjectGroup.id),
LeftJoin(
Distribution, PillarName.distribution == Distribution.id),
]
conditions = SQL('''
PillarName.active = TRUE
AND (PillarName.name = lower(%(text)s) OR
Product.fti @@ ftq(%(text)s) OR
lower(Product.title) = lower(%(text)s) OR
Project.fti @@ ftq(%(text)s) OR
lower(Project.title) = lower(%(text)s) OR
Distribution.fti @@ ftq(%(text)s) OR
lower(Distribution.title) = lower(%(text)s)
)
''' % sqlvalues(text=ensure_unicode(text)))
store = getUtility(IStoreSelector).get(MAIN_STORE, DEFAULT_FLAVOR)
columns = [
PillarName, OtherPillarName, Product, ProjectGroup, Distribution]
for column in extra_columns:
columns.append(column)
return store.using(*origin).find(tuple(columns), conditions)
def count_search_matches(self, text):
result = self.build_search_query(text)
return result.count()
def search(self, text, limit):
"""See `IPillarSet`."""
# Avoid circular import.
from lp.registry.model.product import ProductWithLicenses
if limit is None:
limit = config.launchpad.default_batch_size
# Pull out the licenses as a subselect which is converted
# into a PostgreSQL array so that multiple licenses per product
# can be retrieved in a single row for each product.
extra_column = ProductWithLicenses.composeLicensesColumn()
result = self.build_search_query(text, [extra_column])
# If the search text matches the name or title of the
# Product, Project, or Distribution exactly, then this
# row should get the highest search rank (9999999).
# Each row in the PillarName table will join with only one
# of either the Product, Project, or Distribution tables,
# so the coalesce() is necessary to find the rank() which
# is not null.
result.order_by(SQL('''
(CASE WHEN PillarName.name = lower(%(text)s)
OR lower(Product.title) = lower(%(text)s)
OR lower(Project.title) = lower(%(text)s)
OR lower(Distribution.title) = lower(%(text)s)
THEN 9999999
ELSE coalesce(rank(Product.fti, ftq(%(text)s)),
rank(Project.fti, ftq(%(text)s)),
rank(Distribution.fti, ftq(%(text)s)))
END) DESC, PillarName.name
''' % sqlvalues(text=text)))
# People shouldn't be calling this method with too big limits
longest_expected = 2 * config.launchpad.default_batch_size
if limit > longest_expected:
warnings.warn(
"The search limit (%s) was greater "
"than the longest expected size (%s)"
% (limit, longest_expected),
stacklevel=2)
pillars = []
# Prefill pillar.product.licenses.
for pillar_name, other, product, project, distro, licenses in (
result[:limit]):
pillar = pillar_name.pillar
if IProduct.providedBy(pillar):
pillar = ProductWithLicenses(pillar, licenses)
pillars.append(pillar)
return pillars
def add_featured_project(self, project):
"""See `IPillarSet`."""
query = """
PillarName.name = %s
AND PillarName.id = FeaturedProject.pillar_name
""" % sqlvalues(project.name)
existing = FeaturedProject.selectOne(
query, clauseTables=['PillarName'])
if existing is None:
pillar_name = PillarName.selectOneBy(name=project.name)
return FeaturedProject(pillar_name=pillar_name.id)
def remove_featured_project(self, project):
"""See `IPillarSet`."""
query = """
PillarName.name = %s
AND PillarName.id = FeaturedProject.pillar_name
""" % sqlvalues(project.name)
existing = FeaturedProject.selectOne(
query, clauseTables=['PillarName'])
if existing is not None:
existing.destroySelf()
@property
def featured_projects(self):
"""See `IPillarSet`."""
query = "PillarName.id = FeaturedProject.pillar_name"
return [pillar_name.pillar for pillar_name in PillarName.select(
query, clauseTables=['FeaturedProject'])]
class PillarName(SQLBase):
implements(IPillarName)
_table = 'PillarName'
_defaultOrder = 'name'
name = StringCol(
dbName='name', notNull=True, unique=True, alternateID=True)
product = ForeignKey(
foreignKey='Product', dbName='product')
project = ForeignKey(
foreignKey='ProjectGroup', dbName='project')
distribution = ForeignKey(
foreignKey='Distribution', dbName='distribution')
active = BoolCol(dbName='active', notNull=True, default=True)
alias_for = ForeignKey(
foreignKey='PillarName', dbName='alias_for', default=None)
@property
def pillar(self):
pillar_name = self
if self.alias_for is not None:
pillar_name = self.alias_for
if pillar_name.distribution is not None:
return pillar_name.distribution
elif pillar_name.project is not None:
return pillar_name.project
elif pillar_name.product is not None:
return pillar_name.product
else:
raise AssertionError("Unknown pillar type: %s" % pillar_name.name)
class HasAliasMixin:
"""Mixin for classes that implement IHasAlias."""
@property
def aliases(self):
"""See `IHasAlias`."""
aliases = PillarName.selectBy(alias_for=PillarName.byName(self.name))
return [alias.name for alias in aliases]
def setAliases(self, names):
"""See `IHasAlias`."""
store = Store.of(self)
existing_aliases = set(self.aliases)
self_pillar = store.find(PillarName, name=self.name).one()
to_remove = set(existing_aliases).difference(names)
to_add = set(names).difference(existing_aliases)
for name in to_add:
assert store.find(PillarName, name=name).count() == 0, (
"This alias is already in use: %s" % name)
PillarName(name=name, alias_for=self_pillar)
for name in to_remove:
pillar_name = store.find(PillarName, name=name).one()
assert pillar_name.alias_for == self_pillar, (
"Can't remove an alias of another pillar.")
store.remove(pillar_name)
|