import os
import shutil
from sqlalchemy.orm.exc import NoResultFound
+from sqlalchemy.orm import object_session
import sqlalchemy.exc
import tempfile
import traceback
session.flush()
path = os.path.join(archive.path, 'pool', component.component_name, poolname)
- hashed_file_path = os.path.join(directory, hashed_file.filename)
+ hashed_file_path = os.path.join(directory, hashed_file.input_filename)
self.fs.copy(hashed_file_path, path, link=False, mode=archive.mode)
return poolfile
maintainer=maintainer,
poolfile=db_file,
binarytype=binary.type,
+ )
+ # Other attributes that are ignored for purposes of equality with
+ # an existing source
+ rest2 = dict(
fingerprint=fingerprint,
)
db_binary = DBBinary(**unique)
for key, value in rest.iteritems():
setattr(db_binary, key, value)
+ for key, value in rest2.iteritems():
+ setattr(db_binary, key, value)
session.add(db_binary)
session.flush()
import_metadata_into_db(db_binary, session)
"""Add Built-Using sources to C{db_binary.extra_sources}
"""
session = self.session
- built_using = control.get('Built-Using', None)
-
- if built_using is not None:
- for dep in apt_pkg.parse_depends(built_using):
- assert len(dep) == 1, 'Alternatives are not allowed in Built-Using field'
- bu_source_name, bu_source_version, comp = dep[0]
- assert comp == '=', 'Built-Using must contain strict dependencies'
-
- bu_source = session.query(DBSource).filter_by(source=bu_source_name, version=bu_source_version).first()
- if bu_source is None:
- raise ArchiveException('{0}: Built-Using refers to non-existing source package {1} (= {2})'.format(filename, bu_source_name, bu_source_version))
-
- self._ensure_extra_source_exists(filename, bu_source, suite.archive, extra_archives=extra_archives)
-
- db_binary.extra_sources.append(bu_source)
-
- def install_source(self, directory, source, suite, component, changed_by, allow_tainted=False, fingerprint=None):
- """Install a source package
-
- @type directory: str
- @param directory: directory the source package is located in
-
- @type source: L{daklib.upload.Source}
- @param source: source package to install
- @type suite: L{daklib.dbconn.Suite}
- @param suite: target suite
+ for bu_source_name, bu_source_version in daklib.utils.parse_built_using(control):
+ bu_source = session.query(DBSource).filter_by(source=bu_source_name, version=bu_source_version).first()
+ if bu_source is None:
+ raise ArchiveException('{0}: Built-Using refers to non-existing source package {1} (= {2})'.format(filename, bu_source_name, bu_source_version))
- @type component: L{daklib.dbconn.Component}
- @param component: target component
+ self._ensure_extra_source_exists(filename, bu_source, suite.archive, extra_archives=extra_archives)
- @type changed_by: L{daklib.dbconn.Maintainer}
- @param changed_by: person who prepared this version of the package
-
- @type allow_tainted: bool
- @param allow_tainted: allow to copy additional files from tainted archives
-
- @type fingerprint: L{daklib.dbconn.Fingerprint}
- @param fingerprint: optional fingerprint
+ db_binary.extra_sources.append(bu_source)
- @rtype: L{daklib.dbconn.DBSource}
- @return: database object for the new source
- """
+ def install_source_to_archive(self, directory, source, archive, component, changed_by, allow_tainted=False, fingerprint=None):
session = self.session
- archive = suite.archive
control = source.dsc
maintainer = get_or_set_maintainer(control['Maintainer'], session)
source_name = control['Source']
)
rest = dict(
maintainer=maintainer,
- changedby=changed_by,
#install_date=datetime.now().date(),
poolfile=db_file_dsc,
- fingerprint=fingerprint,
dm_upload_allowed=(control.get('DM-Upload-Allowed', 'no') == 'yes'),
)
+ # Other attributes that are ignored for purposes of equality with
+ # an existing source
+ rest2 = dict(
+ changedby=changed_by,
+ fingerprint=fingerprint,
+ )
created = False
try:
db_source = DBSource(**unique)
for key, value in rest.iteritems():
setattr(db_source, key, value)
+ for key, value in rest2.iteritems():
+ setattr(db_source, key, value)
# XXX: set as default in postgres?
db_source.install_date = datetime.now().date()
session.add(db_source)
session.add(db_dsc_file)
session.flush()
- if suite in db_source.suites:
- return db_source
-
- db_source.suites.append(suite)
-
if not created:
for f in db_source.srcfiles:
self._copy_file(f.poolfile, archive, component, allow_tainted=allow_tainted)
### Now add remaining files and copy them to the archive.
for hashed_file in source.files.itervalues():
- hashed_file_path = os.path.join(directory, hashed_file.filename)
+ hashed_file_path = os.path.join(directory, hashed_file.input_filename)
if os.path.exists(hashed_file_path):
db_file = self._install_file(directory, hashed_file, archive, component, source_name)
session.add(db_file)
return db_source
+ def install_source(self, directory, source, suite, component, changed_by, allow_tainted=False, fingerprint=None):
+ """Install a source package
+
+ @type directory: str
+ @param directory: directory the source package is located in
+
+ @type source: L{daklib.upload.Source}
+ @param source: source package to install
+
+ @type suite: L{daklib.dbconn.Suite}
+ @param suite: target suite
+
+ @type component: L{daklib.dbconn.Component}
+ @param component: target component
+
+ @type changed_by: L{daklib.dbconn.Maintainer}
+ @param changed_by: person who prepared this version of the package
+
+ @type allow_tainted: bool
+ @param allow_tainted: allow to copy additional files from tainted archives
+
+ @type fingerprint: L{daklib.dbconn.Fingerprint}
+ @param fingerprint: optional fingerprint
+
+ @rtype: L{daklib.dbconn.DBSource}
+ @return: database object for the new source
+ """
+ db_source = self.install_source_to_archive(directory, source, suite.archive, component, changed_by, allow_tainted, fingerprint)
+
+ if suite in db_source.suites:
+ return db_source
+ db_source.suites.append(suite)
+ self.session.flush()
+
+ return db_source
+
def _copy_file(self, db_file, archive, component, allow_tainted=False):
"""Copy a file to the given archive and component
self.session.rollback()
self.fs.rollback()
+ def flush(self):
+ self.session.flush()
+
def __enter__(self):
return self
self.rollback()
return None
+def source_component_from_package_list(package_list, suite):
+ """Get component for a source package
+
+ This function will look at the Package-List field to determine the
+ component the source package belongs to. This is the first component
+ the source package provides binaries for (first with respect to the
+ ordering of components).
+
+ It the source package has no Package-List field, None is returned.
+
+ @type package_list: L{daklib.packagelist.PackageList}
+ @param package_list: package list of the source to get the override for
+
+ @type suite: L{daklib.dbconn.Suite}
+ @param suite: suite to consider for binaries produced
+
+ @rtype: L{daklib.dbconn.Component} or C{None}
+ @return: component for the given source or C{None}
+ """
+ if package_list.fallback:
+ return None
+ session = object_session(suite)
+ packages = package_list.packages_for_suite(suite)
+ components = set(p.component for p in packages)
+ query = session.query(Component).order_by(Component.ordering) \
+ .filter(Component.component_name.in_(components))
+ return query.first()
+
class ArchiveUpload(object):
"""handle an upload
suites = session.query(Suite).filter(Suite.suite_name.in_(suite_names))
return suites
+ def _check_new_binary_overrides(self, suite):
+ new = False
+
+ binaries = self.changes.binaries
+ source = self.changes.source
+ if source is not None and not source.package_list.fallback:
+ packages = source.package_list.packages_for_suite(suite)
+ binaries = [ entry for entry in packages ]
+
+ for b in binaries:
+ override = self._binary_override(suite, b)
+ if override is None:
+ self.warnings.append('binary:{0} is NEW.'.format(b.name))
+ new = True
+
+ return new
+
def _check_new(self, suite):
"""Check if upload is NEW
new = False
# Check for missing overrides
- for b in self.changes.binaries:
- override = self._binary_override(suite, b)
- if override is None:
- self.warnings.append('binary:{0} is NEW.'.format(b.control['Package']))
- new = True
-
+ if self._check_new_binary_overrides(suite):
+ new = True
if self.changes.source is not None:
override = self._source_override(suite, self.changes.source)
if override is None:
@type suite: L{daklib.dbconn.Suite}
@param suite: suite to get override for
- @type binary: L{daklib.upload.Binary}
+ @type binary: L{daklib.upload.Binary} or L{daklib.packagelist.PackageListEntry}
@param binary: binary to get override for
@rtype: L{daklib.dbconn.Override} or C{None}
if mapped_component is None:
return None
- query = self.session.query(Override).filter_by(suite=suite, package=binary.control['Package']) \
+ query = self.session.query(Override).filter_by(suite=suite, package=binary.name) \
.join(Component).filter(Component.component_name == mapped_component.component_name) \
.join(OverrideType).filter(OverrideType.overridetype == binary.type)
if suite.overridesuite is not None:
suite = self.session.query(Suite).filter_by(suite_name=suite.overridesuite).one()
- # XXX: component for source?
query = self.session.query(Override).filter_by(suite=suite, package=source.dsc['Source']) \
.join(OverrideType).filter(OverrideType.overridetype == 'dsc')
+ component = source_component_from_package_list(source.package_list, suite)
+ if component is not None:
+ query = query.filter(Override.component == component)
+
try:
return query.one()
except NoResultFound:
# Validate signatures and hashes before we do any real work:
for chk in (
checks.SignatureAndHashesCheck,
+ checks.SignatureTimestampCheck,
checks.ChangesCheck,
checks.ExternalHashesCheck,
checks.SourceCheck,