def _checkRpmInfo(self, package_name):
package_info = utils.getPackageInfoByName(package_name)
if package_info is None:
io.error('setbranch', utils.PACKAGE_NAME_FORMAT)
return False
else:
return True
def _recvResponse(self, output=True):
try:
pdu = self.skt.recvPdu()
return self._parseResponse(pdu, output)
except:
io.error('', 'response message receive error.')
return False
def _recvResponse(self, output=True):
try:
pdu = self.skt.recvPdu()
return self._parseResponse(pdu, output)
except:
io.error('', 'response message receive error.')
return False
def work(self):
# get socket object
skt = None
try:
skt = self.app.queue_cmdproc.get(timeout=10)
except:
return
is_succ = True
skt, peer = skt
skt = net.SafeTcp(skt)
io.debug("cmdproc worker", "new client: %s" % str(peer))
try:
# check auth
if is_succ:
is_succ, resp = self.checkAuth(skt)
skt.sendPdu(resp)
io.debug('TRACE', '验证通过')
# dispatch
if is_succ:
is_succ, resp = self.dispatch(skt)
skt.sendPdu(resp)
except Exception, _ex:
is_succ = False
io.error("cmdproc worker", str(_ex))
def _checkRpmInfo(self, package_name):
package_info = utils.getPackageInfoByName(package_name)
if package_info is None:
io.error('setbranch', utils.PACKAGE_NAME_FORMAT)
return False
else:
return True
def execCommand(command, args):
exit_code = error.EXIT_SUCCEED
try:
exit_code = command.execute(args)
except KeyboardInterrupt, _ex:
io.error("", "yumtools has been terminated.")
exit_code = error.EXIT_INTERRUPTED
def execCommand(command, args):
exit_code = error.EXIT_SUCCEED
try:
exit_code = command.execute(args)
except KeyboardInterrupt, _ex:
io.error("", "yumtools has been terminated.")
exit_code = error.EXIT_INTERRUPTED
def _checkBranch(self, branch):
try:
validate.is_string(branch)
return True
except Exception:
io.error('remove', 'branch is not valid')
return False
def _checkBranch(self, from_branch, to_branch):
try:
validate.is_string(from_branch)
validate.is_string(to_branch)
return True
except Exception:
io.error('setbranch', 'branch is not valid')
return False
def invokeRemote(self, pdu, output=True):
try:
self.skt.sendPdu(pdu)
except:
io.error('', 'pdu send error.')
return False
return self._recvResponse(output)
def main():
cfg = config.ServerConfig()
io.use_colored = False
if not cfg.load("/etc/yumtools-serv.conf"):
io.error("yumtools-serv", "load config failed.")
return
d = YumtoolsServDaemon("yumtools-serv", cfg.pid_file, cfg.verbose)
d.doshell(sys.argv)
def _checkBranch(self, from_branch, to_branch):
try:
validate.is_string(from_branch)
validate.is_string(to_branch)
return True
except Exception:
io.error('setbranch', 'branch is not valid')
return False
def invokeRemote(self, pdu, output=True):
try:
self.skt.sendPdu(pdu)
except:
io.error('', 'pdu send error.')
return False
return self._recvResponse(output)
def main():
cfg = config.ServerConfig()
io.use_colored = False
if not cfg.load('/etc/yumtools-serv.conf'):
io.error('yumtools-serv', 'load config failed.')
return
d = YumtoolsServDaemon("yumtools-serv", cfg.pid_file, cfg.verbose)
d.doshell(sys.argv)
def _checkConfigFile(self, file_name):
if not os.access(file_name, os.F_OK):
io.error('config', '%s not found.' % file_name)
return False
elif not os.access(file_name, os.R_OK):
io.error('config', '%s permission denied.' % file_name)
return False
else:
return True
def _parseAllConfig(self, file_content, file_name):
result = True
try:
if not self._parseGlobalConfig(file_content):
return False
result = self.parseAttr(file_content)
except LoadConfigError, _ex:
io.error('config', '%s | %s' % (file_name, str(_ex)))
result = False
def run(self, options, args):
if not self._checkArgs(args):
return error.ERROR_COMMAND_PARM_INVALID
command = getCommand(args[0])
if command is None:
io.error('', 'command %s not supported.' % args[0])
return error.ERROR_UNSUPPORT_COMMAND
command.showHelp()
return error.ERROR_SUCCEED
def run(self, options, args):
if not self._checkArgs(args):
return error.ERROR_COMMAND_PARM_INVALID
command = getCommand(args[0])
if command is None:
io.error('', 'command %s not supported.' % args[0])
return error.ERROR_UNSUPPORT_COMMAND
command.showHelp()
return error.ERROR_SUCCEED
def _checkRpmFileAccess(self, package_name):
if not os.access(package_name, os.F_OK):
io.error('upload', '%s not found.' % package_name)
return False
elif not os.access(package_name, os.R_OK):
io.error('upload', '%s permission denied.' % package_name)
return False
else:
return True
def _getFileContent(self, file_name):
try:
fp = open(file_name, 'r')
lines = fp.read()
fp.close()
file_content = yaml.load(lines)
except Exception, _ex:
io.error('config', str(_ex))
return None
def _getFileContent(self, file_name):
try:
fp = open(file_name, 'r')
lines = fp.read()
fp.close()
file_content = yaml.load(lines)
except Exception, _ex:
io.error('config', str(_ex))
return None
def _parseAllConfig(self, file_content, file_name):
result = True
try:
if not self._parseGlobalConfig(file_content):
return False
result = self.parseAttr(file_content)
except LoadConfigError, _ex:
io.error('config', '%s | %s' % (file_name, str(_ex)))
result = False
def _checkConfigFile(self, file_name):
if not os.access(file_name, os.F_OK):
io.error('config', '%s not found.' % file_name)
return False
elif not os.access(file_name, os.R_OK):
io.error('config', '%s permission denied.' % file_name)
return False
else:
return True
def _parseBranchAttr(self, file_content):
self.branches = {}
branches = loadAttr(file_content, "server", "branch_list", type=dict)
for k, v in branches.items():
self.branches[str(k)] = str(v)
if len(self.branches) < 1:
io.error("config", "branch_list not found.")
return False
else:
return True
def _parseOSVersionAttr(self, file_content):
self.os_version_list = []
os_version_list = loadAttr(file_content, "server", "os_version_list", type=list)
for o in os_version_list:
self.os_version_list.append(int(o))
if len(self.os_version_list) < 1:
io.error("config", "os_version_list not found.")
return False
else:
return True
def _parseArchAttr(self, file_content):
self.arch_list = []
arch_list = loadAttr(file_content, "server", "arch_list", type=list)
for o in arch_list:
self.arch_list.append(str(o))
if len(self.arch_list) < 1:
io.error("config", "arch_list not found.")
return False
else:
return True
def _parseArchAttr(self, file_content):
self.arch_list = []
arch_list = loadAttr(file_content, "server", "arch_list", type=list)
for o in arch_list:
self.arch_list.append(str(o))
if len(self.arch_list) < 1:
io.error("config", "arch_list not found.")
return False
else:
return True
def _parseBranchAttr(self, file_content):
self.branches = {}
branches = loadAttr(file_content, "server", "branch_list", type=dict)
for k, v in branches.items():
self.branches[str(k)] = str(v)
if len(self.branches) < 1:
io.error("config", "branch_list not found.")
return False
else:
return True
def load(self, file_name):
if not self._checkConfigFile(file_name):
return False
file_content = self._getFileContent(file_name)
if file_content is None:
io.error('config', '[%s] is not in valid config syntax' % file_name)
return False
else:
return self._parseAllConfig(file_content, file_name)
def login(self, user_name, password):
pdu = net.AuthPdu()
pdu.set("username", user_name)
pdu.set("password", password)
try:
self.skt.sendPdu(pdu)
if not self._recvResponse():
return False
except Exception, _ex:
io.error('', str(_ex))
return False
def _parseResponse(self, response, output=True):
error_code = response.get("error_code")
msg = response.get("msg")
if error_code == net.PDU_ERROR_SUCCESSED:
if output:
io.log('', msg)
return True
else:
if output:
io.error('0x%08X' % error_code, msg)
return False
def _parseResponse(self, response, output=True):
error_code = response.get("error_code")
msg = response.get("msg")
if error_code == net.PDU_ERROR_SUCCESSED:
if output:
io.log('', msg)
return True
else:
if output:
io.error('0x%08X' % error_code, msg)
return False
def login(self, user_name, password):
pdu = net.AuthPdu()
pdu.set("username", user_name)
pdu.set("password", password)
try:
self.skt.sendPdu(pdu)
if not self._recvResponse():
return False
except Exception, _ex:
io.error('', str(_ex))
return False
def load(self, file_name):
if not self._checkConfigFile(file_name):
return False
file_content = self._getFileContent(file_name)
if file_content is None:
io.error('config',
'[%s] is not in valid config syntax' % file_name)
return False
else:
return self._parseAllConfig(file_content, file_name)
def dispatch(self, skt):
pdu = skt.recvPdu()
if pdu.commandid.name == "UPLOAD_INFO":
return self.procUpload(skt, pdu)
elif pdu.commandid.name == "SETBRANCH":
return self.procSetbranch(skt, pdu)
elif pdu.commandid.name == "REMOVE":
return self.procRemove(skt, pdu)
else:
io.error('cmdproc worker', 'command not supported!')
self._makeResponsePdu(net.PDU_ERROR_ATK, "package name is not a valid value.")
return False, self._makeResponsePdu(net.PDU_ERROR_ATK, "command not supported!")
def login(self, options):
user_name, password = self._getLoginInfo(options)
client = YumtoolsClient()
if client.connect(options.host, options.port):
io.debug("upload", "yum server %s:%d connected." % (self.cfg.server_host, self.cfg.server_port))
else:
io.error("upload", "server %s:%d connect error." % (self.cfg.server_host, self.cfg.server_port))
return False, None
if not client.login(user_name, password):
io.error('upload', 'auth failed')
return False, None
else:
return True, client
def work(self):
repo_path = None
try:
repo_path = self.app.queue_createrepo.get(timeout=5)
except:
pass
if repo_path is None:
return
try:
self.doCommand("/usr/bin/createrepo", "-d", "-s", "md5", repo_path)
except Exception, _ex:
io.error("create repo worker", str(_ex))
def work(self):
repo_path = None
try:
repo_path = self.app.queue_createrepo.get(timeout=5)
except:
pass
if repo_path is None:
return
try:
self.doCommand("/usr/bin/createrepo", "-d", "-s", "md5", repo_path)
except Exception, _ex:
io.error("create repo worker", str(_ex))
def _parseOSVersionAttr(self, file_content):
self.os_version_list = []
os_version_list = loadAttr(file_content,
"server",
"os_version_list",
type=list)
for o in os_version_list:
self.os_version_list.append(int(o))
if len(self.os_version_list) < 1:
io.error("config", "os_version_list not found.")
return False
else:
return True
def login(self, options):
user_name, password = self._getLoginInfo(options)
client = YumtoolsClient()
if client.connect(options.host, options.port):
io.debug(
"upload", "yum server %s:%d connected." %
(self.cfg.server_host, self.cfg.server_port))
else:
io.error(
"upload", "server %s:%d connect error." %
(self.cfg.server_host, self.cfg.server_port))
return False, None
if not client.login(user_name, password):
io.error('upload', 'auth failed')
return False, None
else:
return True, client
def checkAuth(self, skt):
pdu = skt.recvPdu()
if not isinstance(pdu, net.AuthPdu):
io.error("cmdproc worker", "pdu is not a AuthPdu instance")
return False, self._makeResponsePdu(net.PDU_ERROR_AUTH_FAIL, "permission denied, please try later.")
username = pdu.get("username")
password = pdu.get("password")
self.operator_name = username
io.debug("cmdproc worker", "username=%s, password=%s" % (username, password))
print self.cfg.auth_method
if self.cfg.auth_method == "admin_list":
if not self.cfg.admin_list.has_key(username) or self.cfg.admin_list[username] != password:
return False, self._makeResponsePdu(net.PDU_ERROR_AUTH_FAIL, "permission denied, please try later.")
elif self.cfg.auth_method == "ldap":
try:
if password == "":
raise ldap.LDAPError
ldap_conn = ldap.open("qunarldap.corp.qunar.com")
ldap_conn.simple_bind_s("*****@*****.**" % username, password)
pass
except Exception, _ex:
return False, self._makeResponsePdu(net.PDU_ERROR_AUTH_FAIL, "permission denied, please try later.")
def _checkRpmInfo(self, package_name):
package_info = utils.getPackageInfoByName(package_name)
if package_info is None:
io.error('upload', 'package name is not a valid format. format: <package_name>-<package_version>-<release>.el<os_version>.<arch>.rpm')
return False
package_name_from_file = utils.getPackageNameFromFile(package_name)
if package_name_from_file is None:
io.error('upload', 'not a rpm file')
return False
if not utils.isPackageAccord(package_name_from_file, package_infos=package_info):
io.error('upload', 'rpm filename disaccord with real package name')
return False
return True
def _checkArgs(slef, args):
if len(args) != 3:
io.error('setbranch', 'arguments count is not correct')
return False
else:
return True
def _checkArgs(slef, args):
if len(args) != 1:
io.error('', "Usage: yumtools {help | h} command")
return False
else:
return True
def _checkArgs(slef, args):
if len(args) != 1:
io.error('upload', 'no such package name.')
return False
else:
return True
def procUpload(self, skt, first_pdu):
io.debug('upload', 'start upload command')
pdu = first_pdu
# check package_name
package_name = pdu.get("package_name")
if not utils.isValidPackageName(package_name):
return False, self._makeResponsePdu(net.PDU_ERROR_UPLOADERR, "package name is not a valid value.")
# check version
version = pdu.get("version")
if not utils.isValidVersion(version):
return False, self._makeResponsePdu(net.PDU_ERROR_UPLOADERR, "version is not a valid value.")
# check release
release = pdu.get("release")
# check os_version
os_version = pdu.get("os_version")
if os_version not in self.cfg.os_version_list:
return False, self._makeResponsePdu(net.PDU_ERROR_UPLOADERR, "os version not a valid value.")
# check arch
arch = pdu.get("arch")
if arch not in self.cfg.arch_list:
return False, self._makeResponsePdu(net.PDU_ERROR_UPLOADERR, "arch not a valid value.")
# check file_size
file_size = pdu.get("file_size")
if file_size > 1024 * self.cfg.max_file_size:
return False, self._makeResponsePdu(net.PDU_ERROR_UPLOADERR, "file size is out of maximum value")
# generate dist file name
dest_file_name = self._makePackageFullName(self.cfg.upload_branch, release, os_version, arch, package_name, version)
print dest_file_name
md5_code = ""
if os.path.exists(dest_file_name):
return False, self._makeResponsePdu(net.PDU_ERROR_UPLOADERR, "file already exists")
# send first response
skt.sendPdu(self._makeResponsePdu(net.PDU_ERROR_SUCCESSED, "package meta-data check is complete."))
with tempfile.NamedTemporaryFile('wb+') as temp_file:
total_binary = 0
md5_hash = md5.new()
# recv blocks
while True:
pdu = skt.recvPdu()
if pdu.commandid.name == "UPLOAD_BLOCK":
binary = pdu.get('binary')
total_binary += len(binary)
temp_file.write( binary )
md5_hash.update( binary )
if total_binary > file_size:
return False, self._makeResponsePdu(net.PDU_ERROR_UPLOADERR, "denied!")
skt.sendPdu(self._makeResponsePdu(net.PDU_ERROR_SUCCESSED, ""))
elif pdu.commandid.name == "UPLOAD_END":
# check md5
md5_code = pdu.get("md5")
break
temp_file.flush()
# check md5
if md5_hash.hexdigest().upper() != md5_code.upper():
io.error('upload', 'file md5 code is inequality')
return False, self._makeResponsePdu(net.PDU_ERROR_UPLOADERR, "md5 check error")
# cp file
shutil.copy(temp_file.name, dest_file_name)
os.chmod(dest_file_name, stat.S_IRUSR | stat.S_IWUSR | stat.S_IROTH | stat.S_IRGRP)
#basic_info = os.popen('rpm -qip %s' % dest_file_name).readlines()
#install_path = os.popen('rpm -qlp %s' % dest_file_name).readlines()
text = u"RPM包信息\n"
try:
reload(sys)
sys.setdefaultencoding('utf8')
os.system(u'echo RPM包信息 > /usr/share/yumtools/rpm_basic.info')
os.system(u'echo 安装信息 > /usr/share/yumtools/rpm_install.info')
os.system(u'rpm -qip %s > /usr/share/yumtools/rpm_basic.info' % dest_file_name)
os.system(u'rpm -qlp %s > /usr/share/yumtools/rpm_install.info' % dest_file_name)
basic_info = open('/usr/share/yumtools/rpm_basic.info', 'r')
install_info = open('/usr/share/yumtools/rpm_install.info', 'r')
for i in basic_info:
text = text + i.encode('utf8')
text = text + u'--------------------------------------------------------\n'
for i in install_info:
text = text + i.encode('utf8')
except Exception, _ex:
io.error("rpm info error", str(_ex))
pass
io.debug("cmdproc worker", "username=%s, password=%s" % (username, password))
print self.cfg.auth_method
if self.cfg.auth_method == "admin_list":
if not self.cfg.admin_list.has_key(username) or self.cfg.admin_list[username] != password:
return False, self._makeResponsePdu(net.PDU_ERROR_AUTH_FAIL, "permission denied, please try later.")
elif self.cfg.auth_method == "ldap":
try:
if password == "":
raise ldap.LDAPError
ldap_conn = ldap.open("qunarldap.corp.qunar.com")
ldap_conn.simple_bind_s("*****@*****.**" % username, password)
pass
except Exception, _ex:
return False, self._makeResponsePdu(net.PDU_ERROR_AUTH_FAIL, "permission denied, please try later.")
else:
io.error('cmdproc worker', "server auth module not found.")
return False, self._makeResponsePdu(net.PDU_ERROR_AUTH_FAIL, "server auth module not found.")
return True, self._makeResponsePdu(net.PDU_ERROR_SUCCESSED, "login successed!")
def dispatch(self, skt):
pdu = skt.recvPdu()
if pdu.commandid.name == "UPLOAD_INFO":
return self.procUpload(skt, pdu)
elif pdu.commandid.name == "SETBRANCH":
return self.procSetbranch(skt, pdu)
elif pdu.commandid.name == "REMOVE":
return self.procRemove(skt, pdu)
else:
io.error('cmdproc worker', 'command not supported!')
self._makeResponsePdu(net.PDU_ERROR_ATK, "package name is not a valid value.")
def _checkArgs(slef, args):
if len(args) != 1:
io.error('', "Usage: yumtools {help | h} command")
return False
else:
return True
def _checkArgs(slef, args):
if len(args) != 3:
io.error('setbranch', 'arguments count is not correct')
return False
else:
return True
def _checkArgs(self, args):
if len(args) != 2:
io.error('remove', 'arguments count is not correct.')
return False
else:
return True
