def show_external_release_file(root, request):
"""
Download a release from a download url from its package information.
Must be used with :func:`pyshop.helpers.download.renderer_factory`
to download the release file.
:return: download informations
:rtype: dict
"""
session = DBSession()
settings = request.registry.settings
whlify = asbool(settings.get('pyshop.mirror.wheelify', '0'))
release = Release.by_id(session, int(request.matchdict['release_id']))
filename = (release.whlify_download_url_file if whlify else
release.download_url_file)
rv = {'url': release.download_url,
'filename': filename,
'original': release.download_url_file,
'whlify': whlify
}
release.downloads += 1
release.package.downloads += 1
session.add(release.package)
session.add(release)
request.response.date = datetime.datetime.utcnow()
return rv
def authenticated_userid(self, request):
auth = request.environ.get('HTTP_AUTHORIZATION')
try:
authmeth, auth = auth.split(' ', 1)
except AttributeError: # not enough values to unpack
return None
if authmeth.lower() != 'basic':
return None
try:
# Python 3's string is already unicode
auth = base64.b64decode(auth.strip())
except binascii.Error: # can't decode
return None
if not isinstance(auth, unicode):
auth = auth.decode('utf-8')
try:
login, password = auth.split(':', 1)
except ValueError: # not enough values to unpack
return None
if User.by_credentials(DBSession(), login, password):
return login
if User.by_ldap_credentials(DBSession(), login, password,
request.registry.settings):
return login
return None
def list_packages(self):
"""
Retrieve a list of the package names registered with the package index.
Returns a list of name strings.
"""
session = DBSession()
names = [p.name for p in Package.all(session, order_by=Package.name)]
session.rollback()
return names
def package_releases(self, package_name, show_hidden=False):
"""
Retrieve a list of the releases registered for the given package_name.
Returns a list with all version strings if show_hidden is True or
only the non-hidden ones otherwise."""
session = DBSession()
releases = Release.by_package_name(session, package_name, show_hidden)
session.rollback()
return releases
def list_packages(self):
"""
Retrieve a list of the package names registered with the package index.
Returns a list of name strings.
"""
session = DBSession()
names = [p.name for p in Package.all(session, order_by=Package.name)]
session.rollback()
return names
def package_releases(self, package_name, show_hidden=False):
"""
Retrieve a list of the releases registered for the given package_name.
Returns a list with all version strings if show_hidden is True or
only the non-hidden ones otherwise."""
session = DBSession()
releases = Release.by_package_name(session, package_name, show_hidden)
session.rollback()
return releases
def setUp(self):
from pyshop.config import includeme
from .conf import settings
super(UnauthenticatedViewTestCase, self).setUp()
self.maxDiff = None
authz_policy = ACLAuthorizationPolicy()
self.config = testing.setUp(settings=settings)
self.config.include(includeme)
self.session = DBSession()
transaction.begin()
def release_downloads(self, package_name, version):
"""
Retrieve a list of files and download count for a given package and
release version.
"""
session = DBSession()
release_files = ReleaseFile.by_release(session, package_name, version)
if release_files:
release_files = [(f.release.package.name,
f.filename) for f in release_files]
session.rollback()
return release_files
def user_packages(self, user):
"""
Retrieve a list of [role_name, package_name] for a given username.
Role is either 'Maintainer' or 'Owner'.
"""
session = DBSession()
owned = Package.by_owner(session, user)
maintained = Package.by_maintainer(session, user)
owned = [('Owner', p.name) for p in owned]
maintained = [('Maintainer', p.name) for p in maintained]
session.rollback()
return owned + maintained
def release_downloads(self, package_name, version):
"""
Retrieve a list of files and download count for a given package and
release version.
"""
session = DBSession()
release_files = ReleaseFile.by_release(session, package_name, version)
if release_files:
release_files = [(f.release.package.name, f.filename)
for f in release_files]
session.rollback()
return release_files
class ModelTestCase(TestCase):
def setUp(self):
transaction.begin()
self.session = DBSession()
# With SQLite3 - used for tests - 'x' LIKE 'X' returns true which is
# not the case of, for instance, PostgreSQL. Disabling this behaviour
# makes tests more realistic.
self.session.execute('PRAGMA case_sensitive_like = ON')
def tearDown(self):
transaction.commit()
def user_packages(self, user):
"""
Retrieve a list of [role_name, package_name] for a given username.
Role is either 'Maintainer' or 'Owner'.
"""
session = DBSession()
owned = Package.by_owner(session, user)
maintained = Package.by_maintainer(session, user)
owned = [('Owner', p.name) for p in owned]
maintained = [('Maintainer', p.name) for p in maintained]
session.rollback()
return owned + maintained
class UnauthenticatedViewTestCase(fake_filesystem_unittest.TestCase):
def setUp(self):
from pyshop.config import includeme
from .conf import settings
super(UnauthenticatedViewTestCase, self).setUp()
self.maxDiff = None
authz_policy = ACLAuthorizationPolicy()
self.config = testing.setUp(settings=settings)
self.config.include('pyramid_rpc.xmlrpc')
self.config.include(includeme)
self.session = DBSession()
transaction.begin()
# NB: testing.setUp() etc. depend on the real filesystem, so leave
# pyfakefs setup until last.
self.setUpPyfakefs()
def tearDown(self):
super(UnauthenticatedViewTestCase, self).tearDown()
self.session.flush()
transaction.commit()
testing.tearDown()
def create_request(self,
params=None,
environ=None,
matchdict=None,
headers=None,
path='/',
cookies=None,
post=None,
**kw):
if params and not isinstance(params, MultiDict):
mparams = MultiDict()
for k, v in params.items():
if isinstance(v, (list, tuple)):
[mparams.add(k, vv) for vv in v]
else:
mparams.add(k, v)
params = mparams
rv = DummyRequest(params,
environ,
headers,
path,
cookies,
post,
matchdict=(matchdict or {}),
**kw)
return rv
def assertIsRedirect(self, view):
self.assertIsInstance(view, HTTPFound)
def search(self, spec, operator='and'):
"""
Search the package database using the indicated search spec.
The spec may include any of the keywords described in the above list
(except 'stable_version' and 'classifiers'),
for example: {'description': 'spam'} will search description fields.
Within the spec, a field's value can be a string or a list of strings
(the values within the list are combined with an OR),
for example: {'name': ['foo', 'bar']}.
Valid keys for the spec dict are listed here. Invalid keys are ignored:
name
version
author
author_email
maintainer
maintainer_email
home_page
license
summary
description
keywords
platform
download_url
Arguments for different fields are combined using either "and"
(the default) or "or".
Example: search({'name': 'foo', 'description': 'bar'}, 'or').
The results are returned as a list of dicts
{'name': package name,
'version': package release version,
'summary': package release summary}
"""
api = pypi.proxy
rv = []
# search in proxy
for k, v in spec.items():
rv += api.search({k: v}, True)
# search in local
session = DBSession()
release = Release.search(session, spec, operator)
session.rollback()
rv += [
{
'name': r.package.name,
'version': r.version,
'summary': r.summary,
# hack https://mail.python.org/pipermail/catalog-sig/2012-October/004633.html
'_pypi_ordering': '',
} for r in release
]
return rv
def show_release_file(root, request):
"""
Download a release file.
Must be used with :func:`pyshop.helpers.download.renderer_factory`
to download the release file.
:return: download informations
:rtype: dict
"""
settings = request.registry.settings
whlify = asbool(settings.get('pyshop.mirror.wheelify', '0'))
session = DBSession()
f = ReleaseFile.by_id(session, int(request.matchdict['file_id']))
whlify = whlify and f.package_type == 'sdist'
filename = f.filename_whlified if whlify else f.filename
url = f.url
if url and url.startswith('http://pypi.python.org'):
url = 'https' + url[4:]
rv = {
'url': url,
'filename': filename,
'original': f.filename,
'whlify': whlify
}
f.downloads += 1
f.release.downloads += 1
f.release.package.downloads += 1
session.add(f.release.package)
session.add(f.release)
session.add(f)
return rv
def search(self, spec, operator='and'):
"""
Search the package database using the indicated search spec.
The spec may include any of the keywords described in the above list
(except 'stable_version' and 'classifiers'),
for example: {'description': 'spam'} will search description fields.
Within the spec, a field's value can be a string or a list of strings
(the values within the list are combined with an OR),
for example: {'name': ['foo', 'bar']}.
Valid keys for the spec dict are listed here. Invalid keys are ignored:
name
version
author
author_email
maintainer
maintainer_email
home_page
license
summary
description
keywords
platform
download_url
Arguments for different fields are combined using either "and"
(the default) or "or".
Example: search({'name': 'foo', 'description': 'bar'}, 'or').
The results are returned as a list of dicts
{'name': package name,
'version': package release version,
'summary': package release summary}
"""
api = pypi.proxy
rv = []
# search in proxy
for k, v in spec.items():
rv += api.search({k: v}, True)
# search in local
session = DBSession()
release = Release.search(session, spec, operator)
session.rollback()
rv += [{'name': r.package.name,
'version': r.version,
'summary': r.summary,
# hack https://mail.python.org/pipermail/catalog-sig/2012-October/004633.html
'_pypi_ordering':'',
} for r in release]
return rv
def setUp(self):
from pyshop.config import includeme
from .conf import settings
super(UnauthenticatedViewTestCase, self).setUp()
self.maxDiff = None
authz_policy = ACLAuthorizationPolicy()
self.config = testing.setUp(settings=settings)
self.config.include('pyramid_rpc.xmlrpc')
self.config.include(includeme)
self.session = DBSession()
transaction.begin()
# NB: testing.setUp() etc. depend on the real filesystem, so leave
# pyfakefs setup until last.
self.setUpPyfakefs()
def release_urls(self, package_name, version):
"""
Retrieve a list of download URLs for the given package release.
Returns a list of dicts with the following keys:
url
packagetype ('sdist', 'bdist', etc)
filename
size
md5_digest
downloads
has_sig
python_version (required version, or 'source', or 'any')
comment_text
"""
session = DBSession()
release_files = ReleaseFile.by_release(session, package_name, version)
return [{
'url': f.url,
'packagetype': f.package_type,
'filename': f.filename,
'size': f.size,
'md5_digest': f.md5_digest,
'downloads': f.downloads,
'has_sig': f.has_sig,
'comment_text': f.comment_text,
'python_version': f.python_version
} for f in release_files]
def package_releases(self, package_name, show_hidden=False):
"""
Retrieve a list of the releases registered for the given package_name.
Returns a list with all version strings if show_hidden is True or
only the non-hidden ones otherwise."""
session = DBSession()
package = Package.by_name(session, package_name)
return [rel.version for rel in package.sorted_releases]
def show_release_file(root, request):
"""
Download a release file.
Must be used with :func:`pyshop.helpers.download.renderer_factory`
to download the release file.
:return: download informations
:rtype: dict
"""
settings = request.registry.settings
whlify = asbool(settings.get('pyshop.mirror.wheelify', '0'))
session = DBSession()
f = ReleaseFile.by_id(session, int(request.matchdict['file_id']))
whlify = whlify and f.package_type == 'sdist'
filename = f.filename_whlified if whlify else f.filename
url = f.url
if url and url.startswith('http://pypi.python.org'):
url = 'https' + url[4:]
rv = {'url': url,
'filename': filename,
'original': f.filename,
'whlify': whlify
}
f.downloads += 1
f.release.downloads += 1
f.release.package.downloads += 1
session.add(f.release.package)
session.add(f.release)
session.add(f)
return rv
def show_release_file(root, request):
"""
Download a release file.
Must be used with :func:`pyshop.helpers.download.renderer_factory`
to download the release file.
:return: download informations
:rtype: dict
"""
session = DBSession()
f = ReleaseFile.by_id(session, int(request.matchdict['file_id']))
url = f.url
if url and url.startswith('http://pypi.python.org'):
url = 'https' + url[4:]
rv = {'url': url,
'filename': f.filename,
}
f.downloads += 1
f.release.downloads += 1
f.release.package.downloads += 1
session.add(f.release.package)
session.add(f.release)
session.add(f)
return rv
def package_roles(self, package_name):
"""
Retrieve a list of users and their attributes roles for a given
package_name. Role is either 'Maintainer' or 'Owner'.
"""
session = DBSession()
package = Package.by_name(session, package_name)
owners = [('Owner', o.name) for o in package.owners]
maintainers = [('Maintainer', o.name) for o in package.maintainers]
return owners + maintainers
def setUp(self):
from pyshop.config import includeme
from .conf import settings
super(UnauthenticatedViewTestCase, self).setUp()
self.maxDiff = None
authz_policy = ACLAuthorizationPolicy()
self.config = testing.setUp(settings=settings)
self.config.include(includeme)
self.session = DBSession()
transaction.begin()
class UnauthenticatedViewTestCase(fake_filesystem_unittest.TestCase):
def setUp(self):
from pyshop.config import includeme
from .conf import settings
super(UnauthenticatedViewTestCase, self).setUp()
self.maxDiff = None
authz_policy = ACLAuthorizationPolicy()
self.config = testing.setUp(settings=settings)
self.config.include('pyramid_rpc.xmlrpc')
self.config.include(includeme)
self.session = DBSession()
transaction.begin()
# NB: testing.setUp() etc. depend on the real filesystem, so leave
# pyfakefs setup until last.
self.setUpPyfakefs()
def tearDown(self):
super(UnauthenticatedViewTestCase, self).tearDown()
self.session.flush()
transaction.commit()
testing.tearDown()
def create_request(self, params=None, environ=None, matchdict=None,
headers=None,
path='/', cookies=None, post=None, **kw):
if params and not isinstance(params, MultiDict):
mparams = MultiDict()
for k, v in params.items():
if isinstance(v, (list, tuple)):
[mparams.add(k, vv) for vv in v]
else:
mparams.add(k, v)
params = mparams
rv = DummyRequest(params, environ, headers, path, cookies,
post, matchdict=(matchdict or {}), **kw)
return rv
def assertIsRedirect(self, view):
self.assertIsInstance(view, HTTPFound)
def authbasic(request):
"""
Authentification basic, Upload pyshop repository access
"""
if len(request.environ.get('HTTP_AUTHORIZATION','')) > 0:
auth = request.environ.get('HTTP_AUTHORIZATION')
scheme, data = auth.split(None, 1)
assert scheme.lower() == 'basic'
data = base64.b64decode(data)
if not isinstance(data, unicode):
data = data.decode('utf-8')
username, password = data.split(':', 1)
if User.by_ldap_credentials(DBSession(), username, password, request.registry.settings):
return HTTPFound(location=request.url)
if User.by_credentials(DBSession(), username, password):
return HTTPFound(location=request.url)
return Response(status=401,
headerlist=[(b'WWW-Authenticate',
b'Basic realm="pyshop repository access"'
)],
)
def show_external_release_file(root, request):
"""
Download a release from a download url from its package information.
Must be used with :func:`pyshop.helpers.download.renderer_factory`
to download the release file.
:return: download informations
:rtype: dict
"""
session = DBSession()
settings = request.registry.settings
whlify = asbool(settings.get('pyshop.mirror.wheelify', '0'))
release = Release.by_id(session, int(request.matchdict['release_id']))
filename = (release.whlify_download_url_file
if whlify else release.download_url_file)
rv = {
'url': release.download_url,
'filename': filename,
'original': release.download_url_file,
'whlify': whlify
}
release.downloads += 1
release.package.downloads += 1
session.add(release.package)
session.add(release)
request.response.date = datetime.datetime.utcnow()
return rv
def show_external_release_file(root, request):
"""
Download a release from a download url from its package information.
Must be used with :func:`pyshop.helpers.download.renderer_factory`
to download the release file.
:return: download informations
:rtype: dict
"""
session = DBSession()
release = Release.by_id(session, int(request.matchdict['release_id']))
rv = {'url': release.download_url,
'filename': release.download_url_file,
}
release.downloads += 1
release.package.downloads += 1
session.add(release.package)
session.add(release)
return rv
def search(self, spec, operator='and'):
"""
Search the package database using the indicated search spec.
The spec may include any of the keywords described in the above list
(except 'stable_version' and 'classifiers'),
for example: {'description': 'spam'} will search description fields.
Within the spec, a field's value can be a string or a list of strings
(the values within the list are combined with an OR),
for example: {'name': ['foo', 'bar']}.
Valid keys for the spec dict are listed here. Invalid keys are ignored:
name
version
author
author_email
maintainer
maintainer_email
home_page
license
summary
description
keywords
platform
download_url
Arguments for different fields are combined using either "and"
(the default) or "or".
Example: search({'name': 'foo', 'description': 'bar'}, 'or').
The results are returned as a list of dicts
{'name': package name,
'version': package release version,
'summary': package release summary}
"""
session = DBSession()
release = Release.search(session, spec, operator)
session.rollback()
rv = [{'name': r.package.name,
'version': r.version,
'summary': r.summary} for r in release]
return rv
def setUp(self):
from pyshop.config import includeme
from .conf import settings
super(UnauthenticatedViewTestCase, self).setUp()
self.maxDiff = None
authz_policy = ACLAuthorizationPolicy()
self.config = testing.setUp(settings=settings)
self.config.include('pyramid_rpc.xmlrpc')
self.config.include(includeme)
self.session = DBSession()
transaction.begin()
# NB: testing.setUp() etc. depend on the real filesystem, so leave
# pyfakefs setup until last.
self.setUpPyfakefs()
class UnauthenticatedViewTestCase(unittest.TestCase):
def setUp(self):
from pyshop.config import includeme
from .conf import settings
super(UnauthenticatedViewTestCase, self).setUp()
self.maxDiff = None
authz_policy = ACLAuthorizationPolicy()
self.config = testing.setUp(settings=settings)
self.config.include(includeme)
self.session = DBSession()
transaction.begin()
def tearDown(self):
super(UnauthenticatedViewTestCase, self).tearDown()
self.session.flush()
transaction.commit()
testing.tearDown()
def create_request(self, params=None, environ=None, matchdict=None,
headers=None,
path='/', cookies=None, post=None, **kw):
if params and not isinstance(params, MultiDict):
mparams = MultiDict()
for k, v in params.items():
if hasattr(v, '__iter__'):
[mparams.add(k, vv) for vv in v]
else:
mparams.add(k, v)
params = mparams
rv = DummyRequest(params, environ, headers, path, cookies,
post, matchdict=(matchdict or {}), **kw)
return rv
def assertIsRedirect(self, view):
self.assertIsInstance(view, HTTPFound)
def browse(self, classifiers):
"""
Retrieve a list of (name, version) pairs of all releases classified
with all of the given classifiers. 'classifiers' must be a list of
Trove classifier strings.
changelog(since)
Retrieve a list of four-tuples (name, version, timestamp, action)
since the given timestamp. All timestamps are UTC values.
The argument is a UTC integer seconds since the epoch.
"""
session = DBSession()
release = Release.by_classifiers(session, classifiers)
rv = [(r.package.name, r.version) for r in release]
return rv
def get_release_file(root, request):
session = DBSession()
f = ReleaseFile.by_id(session, int(request.matchdict['file_id']))
url = f.url
if url and url.startswith('http://pypi.python.org'):
url = 'https' + url[4:]
rv = {'id': f.id,
'url': url,
'filename': f.filename,
}
f.downloads += 1
f.release.downloads += 1
f.release.package.downloads += 1
session.add(f.release.package)
session.add(f.release)
session.add(f)
return rv
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
settings = get_appsettings(config_uri)
engine = create_engine('pyshop', settings, scoped=False)
config = Configurator(settings=settings)
config.end()
from pyshop.models import (User, Group, Classifier, Package, Release,
ReleaseFile)
session = DBSession()
try:
from IPython import embed
from IPython.config.loader import Config
cfg = Config()
cfg.InteractiveShellEmbed.confirm_exit = False
embed(config=cfg, banner1="Welcome to PyShop shell.")
except ImportError:
import code
code.interact("pyshop shell", local=locals())
def setUpModule():
engine = create_engine(settings)
populate(engine, interactive=False)
session = DBSession()
admin_user = User.by_login(session, u'admin')
local_user = User(login=u'local_user',
password=u'secret',
local=True,
firstname=u'Local',
lastname=u'User')
local_user.groups.append(Group.by_name(session, u'developer'))
jdo = User(login=u'johndo', local=False)
jdoe = User(login=u'janedoe', local=False)
session.add(jdo)
session.add(jdoe)
session.add(local_user)
classifiers_names = [
u'Programming Language :: Python',
u'Programming Language :: Python :: 2.6',
u'Programming Language :: Python :: 2.7',
u'Topic :: Software Development',
u'Topic :: System :: Archiving :: Mirroring',
u'Topic :: System :: Archiving :: Packaging',
u'Intended Audience :: Developers',
u'Intended Audience :: System Administrators'
]
classifiers = [
Classifier.by_name(session, name=c, create_if_not_exists=True)
for c in classifiers_names
]
pack1 = Package(name=u'mirrored_package1')
pack1.owners.append(jdo)
pack1.owners.append(jdoe)
pack1.downloads = 7
session.add(pack1)
release1 = Release(package=pack1,
version=u'0.1',
summary=u'Common Usage Library',
author=jdoe)
for c in classifiers[:3]:
release1.classifiers.append(c)
session.add(release1)
release1.files.append(
ReleaseFile(filename=u'mirrored_package1-0.1.tar.gz',
package_type=u'sdist'))
session.add(release1)
release2 = Release(package=pack1,
version=u'0.2',
summary=u'Common Usage Library')
for c in classifiers[:5]:
release2.classifiers.append(c)
release2.files.append(
ReleaseFile(filename=u'mirrored_package1-0.2.tar.gz',
package_type=u'sdist'))
release2.files.append(
ReleaseFile(filename=u'mirrored_package1-0.2.egg',
package_type=u'bdist_egg'))
session.add(release2)
pack2 = Package(name=u'mirrored_package2')
pack2.owners.append(jdo)
pack2.maintainers.append(jdoe)
pack2.downloads = 1
session.add(pack2)
release3 = Release(package=pack2,
version=u'1.0',
summary=u'Web Framework For Everybody')
for c in classifiers[:3] + classifiers[-2:-2]:
release3.classifiers.append(c)
session.add(release3)
release3.files.append(
ReleaseFile(filename=u'mirrored_package2-1.0.tar.gz',
package_type=u'sdist'))
session.add(release3)
pack3 = Package(name=u'local_package1', local=True)
pack3.owners.append(local_user)
pack3.owners.append(admin_user)
session.add(pack3)
release4 = Release(package=pack3,
version=u'0.1',
summary=u'Pet Shop Application')
for c in classifiers:
release4.classifiers.append(c)
release4.files.append(
ReleaseFile(filename=u'local_package1-0.1.tar.gz',
package_type=u'sdist'))
session.add(release4)
session.commit()
def release_data(self, package_name, version):
"""
Retrieve metadata describing a specific package release.
Returns a dict with keys for:
name
version
stable_version
author
author_email
maintainer
maintainer_email
home_page
license
summary
description
keywords
platform
download_url
classifiers (list of classifier strings)
requires
requires_dist
provides
provides_dist
requires_external
requires_python
obsoletes
obsoletes_dist
project_url
docs_url (URL of the packages.python.org docs
if they've been supplied)
If the release does not exist, an empty dictionary is returned.
"""
session = DBSession()
release = Release.by_version(session, package_name, version)
if release:
result = {
'name': release.package.name,
'version': release.version,
'stable_version': '',
'author': release.author.name,
'author_email': release.author.email,
'home_page': release.home_page,
'license': release.license,
'summary': release.summary,
'description': release.description,
'keywords': release.keywords,
'platform': release.platform,
'download_url': release.download_url,
'classifiers': [c.name for c in release.classifiers],
#'requires': '',
#'requires_dist': '',
#'provides': '',
#'provides_dist': '',
#'requires_external': '',
#'requires_python': '',
#'obsoletes': '',
#'obsoletes_dist': '',
'bugtrack_url': release.bugtrack_url,
'docs_url': release.docs_url,
}
if release.maintainer:
result.update({
'maintainer': release.maintainer.name,
'maintainer_email': release.maintainer.email,
})
return dict([(key, val or '') for key, val in result.items()])
def main(argv=sys.argv):
session = DBSession()
session.execute("""
CREATE TABLE release_file_new (
id INTEGER NOT NULL,
created_at DATETIME,
release_id INTEGER NOT NULL,
filename VARCHAR(200) NOT NULL,
md5_digest VARCHAR(50),
size INTEGER,
package_type VARCHAR(13) NOT NULL,
python_version VARCHAR(25),
url VARCHAR(1024),
downloads INTEGER,
has_sig BOOLEAN,
comment_text TEXT,
PRIMARY KEY (id),
FOREIGN KEY(release_id) REFERENCES release (id),
UNIQUE (filename),
CHECK (package_type IN ('sdist', 'bdist_egg', 'bdist_msi',
'bdist_dmg', 'bdist_rpm', 'bdist_dumb',
'bdist_wininst', 'bdist_wheel'))
CHECK (has_sig IN (0, 1))
);
""")
session.execute("""
INSERT INTO release_file_new (
id, created_at, release_id, filename,
md5_digest, size, package_type, python_version,
url, downloads, has_sig, comment_text)
SELECT id, created_at, release_id, filename,
md5_digest, size, package_type, python_version,
url, downloads, has_sig, comment_text
FROM release_file;
""")
session.execute("""
DROP TABLE release_file;
""")
session.execute("""
ALTER TABLE release_file_new RENAME TO release_file;
""")
session.commit()
def populate(engine, interactive=True):
Base.metadata.create_all(engine)
session = DBSession()
user_perm = Permission(name=u'user_view')
admin_perm = Permission(name=u'admin_view')
download_perm = Permission(name=u'download_releasefile')
upload_perm = Permission(name=u'upload_releasefile')
session.add(user_perm)
session.add(upload_perm)
session.add(download_perm)
session.add(admin_perm)
admin_group = Group(name=u'admin')
admin_group.permissions.append(user_perm)
admin_group.permissions.append(download_perm)
admin_group.permissions.append(upload_perm)
admin_group.permissions.append(admin_perm)
session.add(admin_group)
user_group = Group(name=u'developer')
user_group.permissions.append(user_perm)
user_group.permissions.append(download_perm)
user_group.permissions.append(upload_perm)
session.add(user_group)
pip_group = Group(name=u'installer')
pip_group.permissions.append(download_perm)
session.add(pip_group)
if interactive:
login = (raw_input('administrator login [admin]:')
or 'admin')
password = (raw_input('administrator password [changeme]:')
or 'changeme')
email = (raw_input('administrator email [[email protected]]')
or '*****@*****.**')
piplogin = (raw_input('installer login [pip]:') or 'pip')
pippassword = (raw_input('installer password [changeme]:') or
'changeme')
else:
login = '******'
password = '******'
email = '*****@*****.**'
piplogin = '******'
pippassword = '******'
admin = User(login=unicode(login),
password=unicode(password),
email=unicode(email))
admin.groups.append(admin_group)
session.add(admin)
pip = User(login=unicode(piplogin),
password=unicode(pippassword),
)
pip.groups.append(pip_group)
session.add(pip)
session.commit()
def setUp(self):
transaction.begin()
self.session = DBSession()
def authbasic(request):
"""
Authentification basic, Upload pyshop repository access
"""
if len(request.environ.get('HTTP_AUTHORIZATION', '')) > 0:
transaction.manager
auth = request.environ.get('HTTP_AUTHORIZATION')
scheme, data = auth.split(None, 1)
assert scheme.lower() == 'basic'
data = base64.b64decode(data)
if not isinstance(data, unicode):
data = data.decode('utf-8')
username, password = data.split(':', 1)
# if User.by_ldap_credentials(
# DBSession(), username, password, request.registry.settings):
# return HTTPFound(location=request.url)
# if User.by_credentials(DBSession(), username, password):
# return HTTPFound(location=request.url)
# if user:
# return HTTPFound(location=request.url)
user = None
session = DBSession()
if request.registry.settings["pyshop.ldap.use_for_auth"]:
user = User.by_ldap_credentials(session, username, password,
request.registry.settings)
if user:
user = User.by_login(session, username)
else:
user = User.by_login(session, username)
if user:
session.delete(user)
user = None
else:
user = User.by_credentials(session, username, password)
# if user:
# return HTTPFound(location=request.url)
if user:
group_names = []
for group in user.groups:
group_names.append(group.name)
transaction.commit()
if request.matched_route:
print("*" * 200)
print(request.matched_route.name)
if request.matched_route.name in ["upload_releasefile"]:
if not "developer" in group_names:
return Response(
status=401,
headerlist=[
(b'WWW-Authenticate',
b'Basic realm="pyshop repository access"')
],
)
return HTTPFound(location=request.url)
else:
return Response(
status=402,
headerlist=[(b'WWW-Authenticate',
b'Basic realm="pyshop repository access"')],
)
return Response(
status=401,
headerlist=[(b'WWW-Authenticate',
b'Basic realm="pyshop repository access"')],
)
def populate(engine, interactive=True):
Base.metadata.create_all(engine)
session = DBSession()
if Group.by_name(session, u'admin'):
return
user_perm = Permission(name=u'user_view')
admin_perm = Permission(name=u'admin_view')
download_perm = Permission(name=u'download_releasefile')
upload_perm = Permission(name=u'upload_releasefile')
session.add(user_perm)
session.add(upload_perm)
session.add(download_perm)
session.add(admin_perm)
admin_group = Group(name=u'admin')
admin_group.permissions.append(user_perm)
admin_group.permissions.append(download_perm)
admin_group.permissions.append(upload_perm)
admin_group.permissions.append(admin_perm)
session.add(admin_group)
user_group = Group(name=u'developer')
user_group.permissions.append(user_perm)
user_group.permissions.append(download_perm)
user_group.permissions.append(upload_perm)
session.add(user_group)
pip_group = Group(name=u'installer')
pip_group.permissions.append(download_perm)
session.add(pip_group)
if interactive:
login = (input('administrator login [admin]:') or 'admin')
password = (input('administrator password [changeme]:') or 'changeme')
email = (input('administrator email [[email protected]]')
or '*****@*****.**')
piplogin = (input('installer login [pip]:') or 'pip')
pippassword = (input('installer password [changeme]:') or 'changeme')
else:
login = '******'
password = '******'
email = '*****@*****.**'
piplogin = '******'
pippassword = '******'
admin = User(login=unicode(login),
password=unicode(password),
email=unicode(email))
admin.groups.append(admin_group)
session.add(admin)
pip = User(
login=unicode(piplogin),
password=unicode(pippassword),
)
pip.groups.append(pip_group)
session.add(pip)
session.commit()
def setUpModule():
engine = create_engine(settings)
populate(engine, interactive=False)
session = DBSession()
admin_user = User.by_login(session, u"admin")
local_user = User(login=u"local_user", password=u"secret", local=True, firstname=u"Local", lastname=u"User")
local_user.groups.append(Group.by_name(session, u"developer"))
jdo = User(login=u"johndo", local=False)
jdoe = User(login=u"janedoe", local=False)
session.add(jdo)
session.add(jdoe)
session.add(local_user)
classifiers_names = [
u"Programming Language :: Python",
u"Programming Language :: Python :: 2.6",
u"Programming Language :: Python :: 2.7",
u"Topic :: Software Development",
u"Topic :: System :: Archiving :: Mirroring",
u"Topic :: System :: Archiving :: Packaging",
u"Intended Audience :: Developers",
u"Intended Audience :: System Administrators",
]
classifiers = [Classifier.by_name(session, name=c) for c in classifiers_names]
pack1 = Package(name=u"mirrored_package1")
pack1.owners.append(jdo)
pack1.owners.append(jdoe)
pack1.downloads = 7
session.add(pack1)
release1 = Release(package=pack1, version=u"0.1", summary=u"Common Usage Library", author=jdoe)
for c in classifiers[:3]:
release1.classifiers.append(c)
session.add(release1)
release1.files.append(ReleaseFile(filename=u"mirrored_package1-0.1.tar.gz", package_type=u"sdist"))
session.add(release1)
release2 = Release(package=pack1, version=u"0.2", summary=u"Common Usage Library")
for c in classifiers[:5]:
release2.classifiers.append(c)
release2.files.append(ReleaseFile(filename=u"mirrored_package1-0.2.tar.gz", package_type=u"sdist"))
release2.files.append(ReleaseFile(filename=u"mirrored_package1-0.2.egg", package_type=u"bdist_egg"))
session.add(release2)
pack2 = Package(name=u"mirrored_package2")
pack2.owners.append(jdo)
pack2.maintainers.append(jdoe)
pack2.downloads = 1
session.add(pack2)
release3 = Release(package=pack2, version=u"1.0", summary=u"Web Framework For Everybody")
for c in classifiers[:3] + classifiers[-2:-2]:
release3.classifiers.append(c)
session.add(release3)
release3.files.append(ReleaseFile(filename=u"mirrored_package2-1.0.tar.gz", package_type=u"sdist"))
session.add(release3)
pack3 = Package(name=u"local_package1", local=True)
pack3.owners.append(local_user)
pack3.owners.append(admin_user)
session.add(pack3)
release4 = Release(package=pack3, version=u"0.1", summary=u"Pet Shop Application")
for c in classifiers:
release4.classifiers.append(c)
release4.files.append(ReleaseFile(filename=u"local_package1-0.1.tar.gz", package_type=u"sdist"))
session.add(release4)
session.commit()
def setUpModule():
engine = create_engine(settings)
populate(engine, interactive=False)
session = DBSession()
admin_user = User.by_login(session, u'admin')
local_user = User(login=u'local_user', password=u'secret', local=True,
firstname=u'Local', lastname=u'User')
local_user.groups.append(Group.by_name(session, u'developer'))
jdo = User(login=u'johndo', local=False)
jdoe = User(login=u'janedoe', local=False)
session.add(jdo)
session.add(jdoe)
session.add(local_user)
classifiers_names = [u'Programming Language :: Python',
u'Programming Language :: Python :: 2.6',
u'Programming Language :: Python :: 2.7',
u'Topic :: Software Development',
u'Topic :: System :: Archiving :: Mirroring',
u'Topic :: System :: Archiving :: Packaging',
u'Intended Audience :: Developers',
u'Intended Audience :: System Administrators'
]
classifiers = [Classifier.by_name(session, name=c,
create_if_not_exists=True)
for c in classifiers_names]
pack1 = Package(name=u'mirrored_package1')
pack1.owners.append(jdo)
pack1.owners.append(jdoe)
pack1.downloads = 7
session.add(pack1)
release1 = Release(package=pack1, version=u'0.1',
summary=u'Common Usage Library',
author=jdoe)
for c in classifiers[:3]:
release1.classifiers.append(c)
session.add(release1)
release1.files.append(ReleaseFile(filename=u'mirrored_package1-0.1.tar.gz',
package_type=u'sdist'))
session.add(release1)
release2 = Release(package=pack1, version=u'0.2',
summary=u'Common Usage Library')
for c in classifiers[:5]:
release2.classifiers.append(c)
release2.files.append(ReleaseFile(filename=u'mirrored_package1-0.2.tar.gz',
package_type=u'sdist'))
release2.files.append(ReleaseFile(filename=u'mirrored_package1-0.2.egg',
package_type=u'bdist_egg'))
session.add(release2)
pack2 = Package(name=u'mirrored_package2')
pack2.owners.append(jdo)
pack2.maintainers.append(jdoe)
pack2.downloads = 1
session.add(pack2)
release3 = Release(package=pack2, version=u'1.0',
summary=u'Web Framework For Everybody')
for c in classifiers[:3] + classifiers[-2:-2]:
release3.classifiers.append(c)
session.add(release3)
release3.files.append(ReleaseFile(filename=u'mirrored_package2-1.0.tar.gz',
package_type=u'sdist'))
session.add(release3)
pack3 = Package(name=u'local_package1', local=True)
pack3.owners.append(local_user)
pack3.owners.append(admin_user)
session.add(pack3)
release4 = Release(package=pack3, version=u'0.1',
summary=u'Pet Shop Application')
for c in classifiers:
release4.classifiers.append(c)
release4.files.append(ReleaseFile(filename=u'local_package1-0.1.tar.gz',
package_type=u'sdist'))
session.add(release4)
session.commit()
def main(argv=sys.argv):
session = DBSession()
# Create temp table
session.execute("""
CREATE TABLE classifier__release_new (
classifier_id integer REFERENCES classifier ON DELETE CASCADE,
release_id integer REFERENCES release
);
""")
# Copy data to new table
session.execute("""
INSERT INTO classifier__release_new (
classifier_id, release_id)
SELECT classifier_id, release_id
FROM classifier__release;
""")
# Swap the tables
session.execute("""
DROP TABLE classifier__release;
""")
session.execute("""
ALTER TABLE classifier__release_new RENAME TO classifier__release;
""")
session.commit()
