src/buildservice/__init__.py
src/buildservice/keys.py
src/buildservice/logs.py
-src/buildservice/main.py
src/buildservice/messages.py
src/buildservice/mirrors.py
src/buildservice/misc.py
#!/usr/bin/python
+from __future__ import absolute_import
+
import ConfigParser
import logging
import os
#!/usr/bin/python
-import base
+from . import base
class Arches(base.Object):
def get_all(self, really=False):
import xmlrpclib
-import base
+from . import base
class BugzillaBug(base.Object):
def __init__(self, bugzilla, bug_id):
#!/usr/bin/python
-from __future__ import division
+from __future__ import absolute_import, division
import datetime
import hashlib
import string
import time
-import base
-import logs
+from . import base
+from . import logs
-from users import generate_password_hash, check_password_hash, generate_random_string
+from .users import generate_password_hash, check_password_hash, generate_random_string
class Builders(base.Object):
def auth(self, name, passphrase):
import pakfire.config
import pakfire.packages
-import base
-import builders
-import logs
-import packages
-import repository
-import updates
-import users
-
-from constants import *
+from . import base
+from . import builders
+from . import logs
+from . import packages
+from . import repository
+from . import updates
+from . import users
+
+from .constants import *
def import_from_package(_pakfire, filename, distro=None, commit=None, type="release",
arches=None, check_for_duplicates=True, owner=None):
import logging
import memcache
-import base
+from . import base
class Client(memcache.Client):
def debuglog(self, str):
import logging
-import arches
-import base
-import builds
-import packages
-import sources
-import updates
-
-from repository import Repository, RepositoryAux
+from . import arches
+from . import base
+from . import builds
+from . import packages
+from . import sources
+from . import updates
+
+from .repository import Repository, RepositoryAux
class Distributions(base.Object):
def get_all(self):
import os
import subprocess
-import base
-import sources
+from . import base
+from . import sources
class Repo(base.Object):
def __init__(self, pakfire, id, mode="normal"):
import shutil
import tempfile
-import base
+from . import base
def read_key(data):
data = str(data)
import os
-import base
-import builds
+from . import base
_ = lambda x: x
from email.mime.text import MIMEText
-import base
+from . import base
class Messages(base.Object):
def add(self, to, subject, text, frm=None):
import math
import socket
-import base
-import logs
+from . import base
+from . import logs
class GeoIP(object):
def __init__(self, pakfire):
from tornado.escape import xhtml_escape
-from constants import *
+from .constants import *
def format_size(s):
units = ("B", "k", "M", "G", "T")
import pakfire
import pakfire.packages as packages
-import arches
-import base
-import builds
-import database
-import misc
-import sources
+from . import arches
+from . import base
+from . import database
+from . import misc
+from . import sources
-from constants import *
+from .constants import *
class Packages(base.Object):
def get_all_names(self, public=None, user=None, states=None):
WHERE type = 'release' AND pkg_id = %s", self.id)
if build:
- return builds.Build(self.pakfire, build.id)
+ return self.pakfire.builds.get_by_id(build.id)
@property
def job(self):
WHERE pkg_id = %s", self.id)
if job:
- self._job = builds.Job(self.pakfire, job.id)
+ self._job = self.pakfire.jobs.get_by_id(job.id)
return self._job
import os.path
-import base
-import builds
-import logs
-import packages
+from . import base
+from . import logs
class Repositories(base.Object):
def get_all(self):
_builds = []
for build in self.db.query(query, *args):
- build = builds.Build(self.pakfire, build.id)
+ build = self.pakfire.builds.get_by_id(build.id)
build._repo = self
_builds.append(build)
return pkgs
def get_packages(self, arch):
- pkgs = [packages.Package(self.pakfire, p.id) for p in self._get_packages(arch)]
+ pkgs = [self.pakfire.packages.get_by_id(p.id) for p in self._get_packages(arch)]
pkgs.sort()
return pkgs
ret = []
for row in query:
- b = builds.Build(self.pakfire, row.build_id)
+ b = self.pakfire.builds.get_by_id(row.build_id)
ret.append(b)
return ret
import time
import traceback
-import backend.main
+from . import Pakfire
class Event(object):
interval = None
@staticmethod
def fork(method, *args, **kwargs):
# Create new pakfire instance.
- _pakfire = backend.main.Pakfire()
+ _pakfire = Pakfire()
return method(_pakfire, *args, **kwargs)
import uuid
-import base
-import users
+from . import base
+from . import users
class Sessions(base.Object):
def get(self, session_id):
import time
-import base
-import cache
+from . import base
+from . import cache
class Settings(base.Object):
def __init__(self, pakfire):
import os
import subprocess
-import base
-import builds
-import database
-import packages
+from . import base
+from . import database
class Sources(base.Object):
def get_all(self):
self._packages = []
for pkg in self.db.query("SELECT id FROM packages WHERE commit_id = %s", self.id):
- pkg = packages.Package(self.pakfire, pkg.id)
+ pkg = self.pakfire.packages.get_by_id(pkg.id)
self._packages.append(pkg)
self._packages.sort()
#!/usr/bin/python
-import base
-import builds
-import distribution
+from . import base
class Updates(base.Object):
def __init__(self, pakfire):
import pakfire.packages
-import base
-import misc
-import packages
+from . import base
+from . import misc
+from . import packages
-from constants import *
+from .constants import *
class Uploads(base.Object):
def get_by_uuid(self, _uuid):
import tornado.locale
-import base
+from . import base
# A list of possible random characters.
random_chars = string.ascii_letters + string.digits
import tornado.options
import tornado.web
-import backend
-import handlers
+from .. import Pakfire
+
+from . import handlers
BASEDIR = os.path.join(os.path.dirname(__file__), "..", "data")
if self.__pakfire is None:
config_file = os.path.join(BASEDIR, "..", "pbs.conf")
- self.__pakfire = backend.Pakfire(config_file=config_file)
+ self.__pakfire = Pakfire(config_file=config_file)
return self.__pakfire
#!/usr/bin/python
-import backend
-
import base64
import hashlib
import json
import time
import tornado.web
+from .. import builds
+from .. import builders
+from .. import uploads
+from .. import users
+
class LongPollMixin(object):
def initialize(self):
self._start_time = time.time()
@property
def builder(self):
- if isinstance(self.current_user, backend.builders.Builder):
+ if isinstance(self.current_user, builders.Builder):
return self.current_user
@property
def user(self):
- if isinstance(self.current_user, backend.users.User):
+ if isinstance(self.current_user, users.User):
return self.current_user
def get_argument_int(self, *args, **kwargs):
filesize = self.get_argument_int("filesize")
filehash = self.get_argument("hash")
- upload = backend.uploads.Upload.create(self.backend, filename, filesize,
+ upload = uploads.Upload.create(self.backend, filename, filesize,
filehash, user=self.user, builder=self.builder)
self.finish(upload.uuid)
args["owner"] = self.user
try:
- pkg, build = backend.builds.import_from_package(self.backend, upload.path, **args)
+ pkg, build = builds.import_from_package(self.backend, upload.path, **args)
except:
# Raise any exception.
if pkg.type == "source":
ret["supported_arches"] = pkg.supported_arches
- if isinstance(pkg.maintainer, backend.users.User):
+ if isinstance(pkg.maintainer, users.User):
ret["maintainer"] = "%s <%s>" % (pkg.maintainer.realname, pkg.maintainer.email)
elif pkg.maintainer:
ret["maintainer"] = pkg.maintainer
#!/usr/bin/python
-import base
+from . import base
-from bugs import BugsUpdateEvent
-from builds import BuildsFailedRestartEvent, CheckBuildDependenciesEvent
-from builds import CreateTestBuildsEvent, DistEvent
-from messages import MessagesSendEvent
-from repositories import RepositoriesUpdateEvent
-from sessions import SessionsCleanupEvent
-from sources import SourcesPullEvent
-from uploads import UploadsCleanupEvent
+from .bugs import BugsUpdateEvent
+from .builds import BuildsFailedRestartEvent, CheckBuildDependenciesEvent
+from .builds import CreateTestBuildsEvent, DistEvent
+from .messages import MessagesSendEvent
+from .repositories import RepositoriesUpdateEvent
+from .sessions import SessionsCleanupEvent
+from .sources import SourcesPullEvent
+from .uploads import UploadsCleanupEvent
# Events that do not fit anywhere else.
#!/usr/bin/python
-import backend.scheduler
+from .. import scheduler
-class Event(backend.scheduler.Event):
+class Event(scheduler.Event):
def __init__(self, pakfire, *args, **kwargs):
- backend.scheduler.Event.__init__(self, *args, **kwargs)
+ scheduler.Event.__init__(self, *args, **kwargs)
self.pakfire = pakfire
import logging
-import base
+from . import base
class BugsUpdateEvent(base.Event):
# User feedback gets a high priority.
import shutil
import tempfile
-import backend.builds
-import backend.git
+from .. import builds
+from .. import git
-import base
+from . import base
-from pakfire.constants import *
+from ..constants import *
class BuildsFailedRestartEvent(base.Event):
# Run when idle.
logging.debug("Processing commit %s: %s" % (commit.revision, commit.subject))
# Get the repository of this commit.
- repo = backend.git.Repo(self.pakfire, commit.source_id)
+ repo = git.Repo(self.pakfire, commit.source_id)
# Make sure, it is checked out.
if not repo.cloned:
continue
# Initialize the repository or and clone it if necessary.
- repo = backend.git.Repo(self.pakfire, source.id)
+ repo = git.Repo(self.pakfire, source.id)
if not repo.cloned:
repo.clone()
# Import all packages in one swoop.
for pkg in pkgs:
# Import the package file and create a build out of it.
- backend.builds.import_from_package(_pakfire, pkg,
+ builds.import_from_package(_pakfire, pkg,
distro=source.distro, commit=commit, type="release")
except:
#!/usr/bin/python
-import base
+from . import base
class MessagesSendEvent(base.Event):
# Emails should be sent out as quickly as possible.
import os
import pakfire
-import base
+from . import base
-from backend.constants import *
+from ..constants import *
class RepositoriesUpdateEvent(base.Event):
priority = 6
#!/usr/bin/python
-import base
+from . import base
class SessionsCleanupEvent(base.Event):
"""
#!/usr/bin/python
-import backend.git
+from .. import git
-import base
+from . import base
class SourcesPullEvent(base.Event):
# This should run whenever possible, so the user can see his commits
def run(self):
for source in self.pakfire.sources.get_all():
- repo = backend.git.Repo(self.pakfire, source.id, mode="mirror")
+ repo = git.Repo(self.pakfire, source.id, mode="mirror")
# If the repository is not yet cloned, we need to make a local
# clone to work with.
#!/usr/bin/python
-import base
+from . import base
class UploadsCleanupEvent(base.Event):
interval = 3600
#!/usr/bin/python
-import hub
-
-app = hub.Application()
-app.run()
+import pakfire.buildservice.hub
+app = pakfire.buildservice.hub.Application()
+app.run()
\ No newline at end of file
#!/usr/bin/python
-import backend.main
-import backend.scheduler
-
-import manager
+import pakfire.buildservice
+import pakfire.buildservice.manager
# Use tornado's logging options.
import tornado.options
# main
# Create Scheduler instance.
-s = backend.scheduler.Scheduler()
+s = pakfire.buildservice.scheduler.Scheduler()
# Create Pakfire instance.
-p = backend.main.Pakfire()
+p = pakfire.buildservice.Pakfire()
events = (
- manager.BugsUpdateEvent,
- manager.BuildsFailedRestartEvent,
- manager.CheckBuildDependenciesEvent,
- manager.CleanupFilesEvent,
- manager.CreateTestBuildsEvent,
- manager.DistEvent,
- manager.MessagesSendEvent,
- manager.RepositoriesUpdateEvent,
- manager.SessionsCleanupEvent,
- manager.SourcesPullEvent,
- manager.UploadsCleanupEvent,
+ pakfire.buildservice.manager.BugsUpdateEvent,
+ pakfire.buildservice.manager.BuildsFailedRestartEvent,
+ pakfire.buildservice.manager.CheckBuildDependenciesEvent,
+ pakfire.buildservice.manager.CleanupFilesEvent,
+ pakfire.buildservice.manager.CreateTestBuildsEvent,
+ pakfire.buildservice.manager.DistEvent,
+ pakfire.buildservice.manager.MessagesSendEvent,
+ pakfire.buildservice.manager.RepositoriesUpdateEvent,
+ pakfire.buildservice.manager.SessionsCleanupEvent,
+ pakfire.buildservice.manager.SourcesPullEvent,
+ pakfire.buildservice.manager.UploadsCleanupEvent,
)
# Add all events to the scheduler.
import tornado.options
-from web import Application
-
+from pakfire.buildservice.web import Application
#tornado.options.parse_command_line()
import tornado.options
import tornado.web
-from handlers import *
-from ui_modules import *
+from . import handlers_api
-import handlers_api
+from .handlers import *
+from .ui_modules import *
BASEDIR = os.path.join(os.path.dirname(__file__), "..", "data")
import tornado.web
-from handlers_auth import *
-from handlers_base import *
-from handlers_builds import *
-from handlers_builders import *
-from handlers_distro import *
-from handlers_jobs import *
-from handlers_keys import *
-from handlers_mirrors import *
-from handlers_packages import *
-from handlers_search import *
-from handlers_updates import *
-from handlers_users import *
+from .handlers_auth import *
+from .handlers_base import *
+from .handlers_builds import *
+from .handlers_builders import *
+from .handlers_distro import *
+from .handlers_jobs import *
+from .handlers_keys import *
+from .handlers_mirrors import *
+from .handlers_packages import *
+from .handlers_search import *
+from .handlers_updates import *
+from .handlers_users import *
class IndexHandler(BaseHandler):
def get(self):
import tornado.web
-import backend.sessions
-import backend.users
+from .. import sessions
-from handlers_base import *
+from .handlers_base import *
class LoginHandler(BaseHandler):
def get(self):
if user:
# Create a new session for the user.
- session = backend.sessions.Session.create(self.pakfire, user)
+ session = sessions.Session.create(self.pakfire, user)
# Set a cookie and update the current user.
self.set_cookie("session_id", session.id, expires=session.valid_until)
else:
# Automatically login the user.
- session = backend.sessions.Session.create(self.pakfire, user)
+ session = sessions.Session.create(self.pakfire, user)
# Set a cookie and update the current user.
self.set_cookie("session_id", session.id, expires=session.valid_until)
import tornado.web
import traceback
-import backend
-import backend.misc
+from .. import misc
class BaseHandler(tornado.web.RequestHandler):
@property
"bugtracker" : self.pakfire.bugzilla,
"hostname" : self.request.host,
"format_date" : self.format_date,
- "format_size" : backend.misc.format_size,
- "friendly_time" : backend.misc.friendly_time,
- "format_email" : backend.misc.format_email,
- "format_filemode" : backend.misc.format_filemode,
+ "format_size" : misc.format_size,
+ "friendly_time" : misc.friendly_time,
+ "format_email" : misc.format_email,
+ "format_filemode" : misc.format_filemode,
"lang" : self.locale.code[:2],
"pakfire_version" : pakfire.__version__,
"session" : session,
import tornado.web
-import backend
+from .. import builders
-from handlers_base import *
+from .handlers_base import *
class BuilderListHandler(BaseHandler):
def get(self):
# Create a new builder.
builder, passphrase = \
- backend.builders.Builder.create(self.pakfire, name, user=self.current_user)
+ builders.Builder.create(self.pakfire, name, user=self.current_user)
self.render("builders/pass.html", action="new", builder=builder,
passphrase=passphrase)
import tornado.web
-from handlers_base import BaseHandler
+from .handlers_base import BaseHandler
class BuildsHandler(BaseHandler):
def get(self):
#!/usr/bin/python
-from handlers_base import *
-
+from .handlers_base import *
class DistributionListHandler(BaseHandler):
def get(self):
import tornado.web
-from handlers_base import BaseHandler
-
+from .handlers_base import BaseHandler
class JobsIndexHandler(BaseHandler):
def get(self):
import tornado.web
-from handlers_base import BaseHandler
+from .handlers_base import BaseHandler
class KeysActionHandler(BaseHandler):
def prepare(self):
import tornado.web
-import backend
+from .. import mirrors
-from handlers_base import BaseHandler
+from .handlers_base import BaseHandler
class MirrorListHandler(BaseHandler):
def get(self):
})
return self.get(**errors)
- mirror = backend.mirrors.Mirror.create(self.pakfire, hostname, path,
+ mirror = mirrors.Mirror.create(self.pakfire, hostname, path,
user=self.current_user)
assert mirror
import os.path
import tornado.web
-from handlers_base import BaseHandler
+from .handlers_base import BaseHandler
-from backend.constants import BUFFER_SIZE
+from ..constants import BUFFER_SIZE
class PackageIDDetailHandler(BaseHandler):
def get(self, id):
import re
-from handlers_base import *
+from .handlers_base import *
class SearchHandler(BaseHandler):
def get(self):
import tornado.web
-from handlers_base import BaseHandler
+from .handlers_base import BaseHandler
class UpdatesHandler(BaseHandler):
def get(self):
import tornado.locale
import tornado.web
-from handlers_base import *
+from .handlers_base import *
class UserHandler(BaseHandler):
@tornado.web.authenticated
import tornado.escape
import tornado.web
-import backend.users
-from backend.constants import *
+from .. import users
+from ..constants import *
class UIModule(tornado.web.UIModule):
@property
class MaintainerModule(UIModule):
def render(self, maintainer):
- if isinstance(maintainer, backend.users.User):
+ if isinstance(maintainer, users.User):
type = "user"
else:
type = "string"
projects / pbs.git / commitdiff
