def main(args):
if len(args) != 1:
print('ERROR: sadm-listen exec invalid args', file=sys.stderr)
return 1
taskfn = args[0]
obj = None
try:
with open(taskfn, 'r') as fh:
obj = json.load(fh)
except Exception as err:
log.error("%s" % err)
return 2
finally:
path.unlink(taskfn)
log.init(obj.get('sadm.log', 'warn'))
log.debug(version.string('sadm-listen'))
log.debug("task file %s" % taskfn)
task = obj.get('task', None)
if task is None:
log.error('listen.exec task not set')
return 3
taskAction = obj.get('task.action', None)
if taskAction is None:
log.error("listen.exec task %s: no action" % task)
return 4
taskArgs = obj.get('task.args', None)
if taskArgs is None:
log.error("listen.exec task %s: no args" % task)
return 5
cliURL = obj.get('sadm.listen.url', 'http://127.0.0.1:3666')
cli = ListenClient(cliURL)
return cli.exec(task, taskAction, taskArgs)
def _tplData(view, d, _start):
log.debug("view data %s" % view)
d['view'] = view
d['version'] = version.get()
d['now'] = datetime.strftime(datetime.now(), '%Y-%m-%d %H:%M:%S')
d['took'] = "%.5f" % (datetime.timestamp(datetime.now()) - _start)
return d
def test_dummyLogger():
log._logger = log._dummyLogger()
log.debug('')
log.error('')
log.warn('')
log.info('')
log.msg('')
def exec(self, task, action, args):
log.debug("exec: %s %s" % (task, action))
path = self._path('_', 'exec', task, action)
status = self._post(path, json.dumps(args).encode('UTF-8'))
if status != 200:
return 9
return 0
def main(argv = None):
if argv is None:
argv = sys.argv[1:] # pragma: no cover
args = _getArgs(argv)
log.debug("build %s/%s" % (args.profile, args.env))
rc, _ = env.run(args.profile, args.env, 'build')
return rc
def index():
log.debug("index")
config = cfg.new()
return {
'cfgfile': config.filename(),
'cfg': _getCfg(config),
}
def main(argv=None):
if argv is None:
argv = sys.argv[1:] # pragma: no cover
sumode = 'not'
if '--sumode-pre' in argv:
argv.remove('--sumode-pre')
sumode = 'pre'
elif '--sumode-post' in argv:
argv.remove('--sumode-post')
sumode = 'post'
_parser = flags.new('sadm', desc='deploy sadm env')
args = _getArgs(_parser, argv)
log.debug("deploy %s/%s sumode=%s" % (args.profile, args.env, sumode))
if sumode == 'not' and sh.getuid() == 0:
log.error('do not run as root')
return 9
try:
cmd = args.command
except AttributeError: # pragma: no cover
log.error('invalid usage')
_parser.print_usage()
return 1
log.debug("dispatch command %s" % cmd)
if args.command == 'import':
return loader.main(args)
return deploy.main(args, sumode)
def check(self, req):
log.debug('check')
self.cookie(req)
if self._id is not None:
row = self._db.get(self._id, update = True)
if row:
return Session(row['pk'], row['id'], row['user'], row['last'])
return None
def index():
log.debug("index")
config = cfg.new()
return {
'cfgfile': config.filename(),
'cfg': _getCfg(config),
'user': getenv('USER', 'nouser?'),
}
def about():
log.debug("about")
return {
'pythonVersion': python_version,
'bottleVersion': bottle_version,
'sqliteVersion': "%s" % sqlite3.version,
'sqliteLibVersion': "%s" % sqlite3.sqlite_version,
'curyear': str(date.today().year),
}
def __init__(self, name, config=None):
log.debug("profile init %s" % name)
if config is None:
config = cfg.new()
if name == 'default':
name = config.get('default', 'profile')
self._name = name
self._load(config)
self.config = config
def login(self, req, sessid):
username = self._auth.login(req)
if not username:
err = AuthError('could not get the username')
log.debug("%s" % err)
raise err
sess = self.sess.save(sessid, username)
log.info("user login: %s" % username)
return self._user(sess)
def _sumode(env, step):
sumode = '-'.join(['--sumode', step])
log.debug("call sumode %s" % sumode)
sudo = env.profile.config.get('deploy', 'sudo.command')
cmd = sudo.strip().split()
cmd.extend(flags.cmdline.split())
cmd.append(sumode)
log.debug("sumode cmd %s" % ' '.join(cmd))
return call(cmd)
def hook(self, action, args):
repodir = args.get('repo.path', 'NOREPOPATH')
log.debug("hook action %s repo dir %s" % (action, repodir))
if action == 'push':
commit = args.get('repo.checkout', 'NOCOMMIT')
log.debug("git deploy %s %s" % (repodir, commit))
git.pull(repodir)
git.checkout(repodir, commit)
vcs.deploy(repodir)
def serve(filename):
filename = path.normpath(filename)
ext = path.splitext(filename)[1]
if ext == '' or filename.startswith('.') or \
not _serveExtension.get(ext, False):
log.warn("static file refuse %s" % filename)
return bottle.HTTPError(404, "file not found")
log.debug("serve %s" % filename)
return bottle.static_file(filename, root=_rootdir)
def _init(self, cfgfile=None):
if cfgfile is None:
cfgfile = _cfgFile
self._fn = cfgfile
log.debug("cfg init %s" % self._fn)
self.reload()
n = self.get('default', 'name')
self._name = n.strip()
if self._name == '':
self._name = self._getName()
def _dbInit():
log.debug("syslog init %s" % _dbfile)
log.debug("sqlite version %s (lib %s)" % (sqlite3.version, sqlite3.sqlite_version))
mkdb = not path.isfile(_dbfile)
if mkdb:
dbdir = path.dirname(_dbfile)
makedirs(dbdir, mode = 0o700, exist_ok = True)
db = sqlite3.connect(_dbfile)
db.row_factory = sqlite3.Row
return _dbCheck(db, mkdb)
def apply(self, callback, ctx):
log.debug("apply for rule: %s" % ctx.rule)
def wrapper(*args, **kwargs):
log.debug('apply.wrapper')
resp = callback(*args, **kwargs)
response.headers['Content-Type'] = 'text/plain; charset=UTF-8'
return resp
return wrapper
def handle(task, action):
log.debug("exec handle: %s %s" % (task, action))
taskman = _taskman.get(task, None)
if taskman is None:
raise error(500, "listen.exec task %s: no manager" % task)
try:
args = json.load(request.body)
taskman.hook(action, args)
except Exception as err:
raise error(500, "%s" % err)
return 'OK\n'
def init(wapp, config):
wapp.install(ResponsePlugin())
wapp.route('/_/exec/<task>/<action>', 'POST', _exec.handle, name = '_exec')
initDone = {}
for sect in config.sections():
if sect.startswith('sadm.webhook:') or sect.startswith('webhook.repo:'):
if not initDone.get('webhook', False):
log.debug('enable webhook')
_initWebhooks(wapp)
initDone['webhook'] = True
def new(cfgfile=None):
log.debug('cfg.new')
config = Config(
defaults=_DEFAULT,
strict=True,
default_section='default',
empty_lines_in_values=False,
comment_prefixes=('#', ),
delimiters=('=', ),
)
config._init(cfgfile=cfgfile)
return config
def _getURL(req):
# ~ for k, v in req.headers.items():
# ~ log.debug("%s: %s" % (k, v))
u = urlparse(req.url)
scheme = u.scheme
if not scheme: # pragma: no cover
scheme = 'http'
port = u.port
if not port:
port = '3666'
url = "%s://127.0.0.1:%s" % (scheme, port)
log.debug("URL: %s" % url)
return url
def __init__(self, config):
if not config.has_section('devops.auth'):
config.add_section('devops.auth')
self._cfg = config
self.sess = WebappSession()
self.type = config.get('devops', 'auth', fallback='config')
log.debug("init %s manager" % self.type)
if self.type == 'config':
self._auth = AuthConfig(config)
elif self.type == 'sslcert':
self._auth = AuthSSLCert(config)
else:
raise RuntimeError("invalid auth type: %s" % self.type)
def _handler(error):
log.debug("%d - %s" % (error.status_code, error.status))
argsLen = len(error.args)
if argsLen >= 3:
log.error("%s %d - %s" %
(request.remote_addr, error.status_code, error.args[2]))
if argsLen >= 4:
log.debug("%s" % error.args[3])
else:
log.error("%s %d - %s" %
(request.remote_addr, error.status_code, request.path))
response.headers['Content-Type'] = 'text/html; charset=UTF-8'
return tpl.parse('errors', error=error)
def login(self, req):
log.debug('login sslcert')
username = req.forms.get('username')
if not username:
raise bottle.HTTPError(401, 'username not provided')
uid = self.check(req)
x = self.auth.get(username, fallback=None)
if x is None:
raise AuthError("invalid username: %s" % username)
uid = self.digest(uid.strip())
if x != uid:
raise AuthError("user %s: invalid id" % username)
return username
def dispatch(req, task, action, taskArgs):
log.debug("dispatch task: %s - action: %s" % (task, action))
reqURL = _getURL(req)
obj = {
'sadm.log': log.curLevel(),
'sadm.listen.url': reqURL,
'task': task,
'task.action': action,
'task.args': taskArgs,
}
taskfn = None
with sh.mktmp(prefix=__name__, suffix=".%s.json" % task) as fh:
taskfn = fh.name()
fh.write(json.dumps(obj))
_sched(taskfn)
def login(self, req):
log.debug('login')
username = req.forms.get('username')
password = req.forms.get('password')
if not username:
raise bottle.HTTPError(401, 'username not provided')
if not password:
raise bottle.HTTPError(401, 'user password not provided')
p = self.cfg.get(username, fallback=None)
if p is None:
raise AuthError("invalid username: %s" % username)
h = self.digest(password)
if h != p:
raise AuthError("user %s: invalid password" % username)
return username
def parse(p, argv = None):
global cmdline
if argv is None:
cmdline = ' '.join(sys.argv).strip() # pragma: no cover
else:
cmdline = [program]
cmdline.extend(argv)
cmdline = ' '.join(cmdline).strip()
args = p.parse_args(args = argv)
if args.debug:
log.init('debug') # pragma: no cover
else:
log.init(args.log)
log.debug("sadm version %s" % version.get())
return args
def index(limit = '100'):
limit = request.query.get('limit', limit)
try:
if int(limit) < 0:
limit = '0'
except ValueError:
limit = '0'
log.debug("last %s messages" % limit)
lvlmap = dict()
for lname, lid in syslog._LVLMAP.items():
lvlmap[lid] = lname
return {
'limit': limit,
'msgs': syslog.last(int(limit)),
'lvlmap': lvlmap,
}
def wrapper(*args, **kwargs):
log.debug('apply.wrapper')
user = None
autherr = None
try:
log.debug('user auth check')
user = self.auth.check(bottle.request)
except AuthError as err:
autherr = err
if autherr is None:
kwargs['user'] = user
resp = callback(*args, **kwargs)
return resp
else:
log.error("auth error: %s" % autherr)
return self.auth.error()
