def xmlrpc_dropPackage(self, pid):
ret = Common().dropPackage(pid, self.mp)
if not ret: return False
ret = Common().desassociatePackage2mp(pid, self.mp)
if not ret: return False
return pid
def initialize(self, config):
self.logger = logging.getLogger()
self.config = config
config_addons(config)
Common().init(config)
sync_status = PkgsRsyncStateSerializer().init(Common())
if self.config.package_detect_activate:
self.logger.info("Package detection activated")
if self.config.package_detect_tmp_activate:
self.logger.info(
"Package detection activated for temporary folder")
if self.config.package_detect_smart:
self.logger.info(
"Package detection mechanism will be '%s' (%s)" %
(self.config.packageDetectSmartMethod(),
str(self.config.package_detect_smart_time)))
self.logger.info("Starting package detection thread")
threadpd = ThreadPackageDetect(config)
threadpd.setDaemon(True)
threadpd.start()
self.logger.info("Package detection thread started")
if self.config.package_mirror_activate:
self.logger.info("Starting package mirror thread")
self.threadpm = ThreadPackageMirror(config, sync_status)
self.threadpm.setDaemon(True)
self.logger.info("Package mirror thread started")
if self.config.package_global_mirror_activate:
self.logger.info("Starting global package mirror thread")
self.threadgp = ThreadPackageGlobalMirror(config)
self.threadgp.setDaemon(True)
self.logger.info("Global package mirror thread started")
self.logger.info("Starting TFTPServer thread")
# TFTPServer disabled (waiting to be stabilized)
#if 0:
# threadtftp = ThreadTFTP(config)
# threadtftp.setDaemon(True)
# threadtftp.start()
# self.logger.info("TFTPServer thread started")
from pulse2.package_server import thread_webserver
if not thread_webserver.initialize(self.config):
self.logger.error(
"Package server XML-RPC service initialization failed, exiting."
)
sys.exit(1)
# FIXME: Little sleep because sometimes Python exits before the
# threads have the time to start
time.sleep(5)
def xmlrpc_getAllPendingPackages(self, mirror = None):
ret = Common().getPendingPackages(self.mp)
r = []
for x in ret:
p = ret[x].toH()
self.logger.debug(Common().newAssociation)
self.logger.debug(Common().inEdition)
if p['id'] in Common().newAssociation or p['id'] in Common().inEdition:
p['why'] = 'association'
r.append(p)
return r
def __init__(self, mp, name=''):
MyXmlrpc.__init__(self)
self.logger = logging.getLogger()
self.name = name
self.mp = mp
if Common().getPackages(self.mp) == None:
e = "(%s) %s : can't initialise at %s correctly" % (
self.type, self.name, self.mp)
self.logger.error(e)
raise e
self.logger.info(
"(%s) %s : initialised with packages : %s" %
(self.type, self.name, str(Common().getPackages(self.mp).keys())))
def xmlrpc_putPackageDetail(self, package, need_assign=True):
self.logger.debug("xmlrpc_putPackageDetail")
pa = Package()
pa.fromH(package)
if pa.id in Common().dontgivepkgs and len(
Common().dontgivepkgs[pa.id]) > 0:
return (False, "This package is curently locked")
ret = Common().editPackage(package['id'], pa, need_assign, self.mp)
if not ret: return False
# Create conf file in package
ret = Common().writePackageTo(package['id'], self.mp)
ret, confdir = ret
if not ret: return False
ret = Common().associatePackage2mp(package['id'], self.mp)
if not ret: return False
if not P2PServerCP().package_detect_activate:
del Common().inEdition[package['id']]
# Force packavge detection
Common().detectNewPackages()
Common()._createMD5File(pa.root, force_compute=True)
# Reload all package info
#desc = Common().desc
#Common().init(Common().config)
#Common().desc = desc
return (True, package['id'], confdir, pa.toH())
def mirror_level0(result, args):
pid, target, is_deletion = args
out, err, code = result
if code == 0:
pkg = Common().packages[pid]
try:
self.logger.debug("Removing %s" % (pkg.root))
os.rmdir(pkg.root)
exe = self.config.package_mirror_command
args = []
args.extend(
self.config.package_mirror_level0_command_options)
if type(self.config.
package_mirror_command_options_ssh_options
) == list:
args.extend([
'--rsh',
'/usr/bin/ssh -o %s' % (" -o ".join(
self.config.
package_mirror_command_options_ssh_options))
])
args.append(
str("%s%s" % (os.path.dirname(pkg.root), os.path.sep)))
args.append("%s:%s" % (target, os.path.dirname(pkg.root)))
self.logger.debug(
"ThreadPackageMirror execute mirror level0 : %s %s" %
(exe, str(args)))
return createDeferred(exe, args, pid, target, False)
except Exception, e:
self.logger.error(
"ThreadPackageMirror mirror level0 failed for package %s : %s"
% (pid, str(e)))
def xmlrpc_getPackageDetail(self, pid):
try:
ret = Common().package(pid, self.mp).toH()
except KeyError:
# We don't own this package
ret = {}
except Exception, e:
# Another unknown error
self.logger.exception(e)
ret = {}
def xmlrpc_getLocalPackagePath(self, pid):
try:
ret = os.path.dirname(Common().package(pid, self.mp).root)
except KeyError:
# We don't own this package
ret = {}
except Exception, e:
# Another unknown error
self.logger.exception(e)
ret = {}
def onSuccess(self, result, args):
pid, target, is_deletion = args
out, err, code = result
if code == 0:
self.logger.debug("ThreadPackageMirror succeed %s" % (str(result)))
Common().removePackagesFromRsyncList(pid, target)
else:
self.logger.error(
"ThreadPackageMirror mirroring command failed %s" %
(str(result)))
def runSub(self):
try:
if self.working:
self.logger.debug(
"###############= ThreadPackageDetect already running")
return
self.working = True
logging.getLogger().debug("\n")
logging.getLogger().debug(
"###############> ThreadPackageDetect is running")
if self.config.package_detect_tmp_activate:
Common().moveCorrectPackages()
Common().detectNewPackages()
logging.getLogger().debug(
"###############< ThreadPackageDetect end\n")
except Exception, e:
logging.getLogger().error(
'an Exception happened when trying to detect packages:' +
str(e))
def xmlrpc_associatePackages(self, pid, fs, level=0):
files = []
ret = True
for f in fs:
if not os.path.exists(os.path.join(self.tmp_input_dir, f)):
ret = False
else:
files.append(os.path.join(self.tmp_input_dir, f))
if not ret:
return [False, 'Some files are missing']
try:
ret_assoc = Common().associateFiles(self.mp, pid, files, level)
except exceptions.OSError, e:
return [False, str(e)]
def _runSub(self):
def createDeferred(exe, args, target, root):
d = utils.getProcessOutputAndValue(exe, args)
d.addCallback(self.onSuccess, (target, root))
d.addErrback(self.onError, (target, root))
return d
def cbEnding(result, self):
self.logger.debug("ThreadPackageGlobalMirror end mirroring")
self.working = False
if self.working:
return
self.working = True
self.logger.debug("ThreadPackageGlobalMirror start global mirroring")
dlist = []
all_roots = Common().getAllPackageRoot()
for root in all_roots:
exe = self.config.package_mirror_command
args = []
args.extend(self.config.package_global_mirror_command_options)
if type(self.config.package_mirror_command_options_ssh_options
) == list:
args.extend([
'--rsh',
'/usr/bin/ssh -o %s' %
(" -o ".join(self.config.
package_mirror_command_options_ssh_options))
])
args.append(root)
for target in self.config.package_mirror_target:
l_args = args[:]
l_args.append("%s:%s%s.." % (target, root, os.path.sep))
self.logger.debug("ThreadPackageGlobalMirror execute : %s %s" %
(exe, str(l_args)))
dlist.append(createDeferred(exe, l_args, target, root))
dl = defer.DeferredList(dlist)
dl.addCallback(cbEnding, (self))
return dl
def xmlrpc_putPackageDetail(self, package, need_assign = True):
self.logger.debug("xmlrpc_putPackageDetail")
pa = Package()
pa.fromH(package)
if Common().dontgivepkgs.has_key(pa.id) and len(Common().dontgivepkgs[pa.id]) > 0:
return (False, "This package is curently locked")
ret = Common().editPackage(package['id'], pa, need_assign)
if not ret: return False
# Create conf.xml file in package
ret = Common().writePackageTo(package['id'], self.mp)
ret, confdir = ret
if not ret: return False
ret = Common().associatePackage2mp(package['id'], self.mp)
if not ret: return False
if not P2PServerCP().package_detect_activate:
del Common().inEdition[package['id']]
return (True, package['id'], confdir, pa.toH())
def xmlrpc_getPackageQversion(self, pid):
return Common().package(pid, self.mp).Qversion
def xmlrpc_getPackageQsoftware(self, pid):
return Common().package(pid, self.mp).Qsoftware
def xmlrpc_getPackageBoolcnd(self, pid):
return Common().package(pid, self.mp).boolcnd
def xmlrpc_getPackagesIds(self, label):
return Common().reverse(self.mp)[label]
def xmlrpc_getAllPackages(self, mirror=None):
return map(lambda x: Common().package(x).toH(),
Common().getPackages(self.mp))
def xmlrpc_getPackageFiles(self, pid): # TODO remove the internals
return map(lambda x: x.toH(),
Common().package(pid, self.mp).files.internals)
def xmlrpc_getPackageCommand(self, pid):
return Common().package(pid, self.mp).cmd.toH()
def xmlrpc_getPackageId(self, label, version):
return Common().reverse(self.mp)[label][version]
def xmlrpc_getPackagePostCommandSuccess(self, pid):
return Common().package(pid, self.mp).postcmd_ok.toH()
def xmlrpc_getServerDetails(self):
return map(lambda x: Common().package(x).toH(),
Common().getPackages(self.mp))
def xmlrpc_getPackagePostCommandFailure(self, pid):
return Common().package(pid, self.mp).postcmd_ko.toH()
def xmlrpc_getPackagesDetail(self, pidlist):
return map(lambda p: p.toH(), Common().packagelist(pidlist, self.mp))
def xmlrpc_getPackageHasToReboot(self, pid):
return Common().package(pid, self.mp).reboot
def xmlrpc_getLocalPackagesPath(self, pidlist):
return map(lambda p: os.path.dirname(p.root),
Common().packagelist(pidlist))
def xmlrpc_getPackageLicenses(self, pid):
return Common().package(pid, self.mp).licenses
services.append({
'type': 'imaging',
'mp': config.imaging_api['mount_point'],
'server': config.public_ip,
'port': config.port,
'proto': config.proto
})
logger.info("Package Server initialized with imaging API")
except Exception, e:
logger.exception("Imaging error: %s" % e)
logger.error("Error while initializing the imaging API")
logger.error("Package Server will run WITHOUT the imaging API")
desc = Description(services)
server.register(desc, '/desc')
Common().setDesc(services)
try:
if config.enablessl:
pulse2.xmlrpc.OpenSSLContext().setup(config.localcert,
config.cacert,
config.verifypeer)
twisted.internet.reactor.listenSSL(
port,
P2PSite(server),
interface=config.bind,
contextFactory=pulse2.xmlrpc.OpenSSLContext().getContext())
logger.info('activating SSL mode')
else:
twisted.internet.reactor.listenTCP(port,
twisted.web.server.Site(server),
def xmlrpc_getPackageAssociateinventory(self, pid):
return Common().package(pid, self.mp).associateinventory
