def get_supervisord_conn(self):
"""
获取supervisor的连接
:return:
"""
transport = SupervisorTransport(self.supervisord_user, self.supervisord_pass, self.supervisord_url)
s = ServerProxy('http://127.0.0.1', transport=transport)
return s
def getRPCTransport(env):
'''
env = {'SUPERVISOR_SERVER_URL':'http://localhost:9001',
'SUPERVISOR_USERNAME':'******',
'SUPERVISOR_PASSWORD':'******'}
'''
u = env.get('SUPERVISOR_USERNAME', '')
p = env.get('SUPERVISOR_PASSWORD', '')
return SupervisorTransport(u, p, env['SUPERVISOR_SERVER_URL'])
def test_issue_1483b_identifier_from_config_file(self):
"""When the identifier is supplied in the config file only, that
identifier is used instead of the default."""
filename = pkg_resources.resource_filename(
__name__, 'fixtures/issue-1483b.conf')
args = ['-m', 'supervisor.supervisord', '-c', filename]
supervisord = pexpect.spawn(sys.executable, args, encoding='utf-8')
self.addCleanup(supervisord.kill, signal.SIGINT)
supervisord.expect_exact('supervisord started with pid')
from supervisor.compat import xmlrpclib
from supervisor.xmlrpc import SupervisorTransport
transport = SupervisorTransport('', '', 'unix:///tmp/issue-1483b.sock')
try:
server = xmlrpclib.ServerProxy(
'http://transport.ignores.host/RPC2', transport)
ident = server.supervisor.getIdentification()
finally:
transport.close()
self.assertEqual(ident, "from_config_file")
def test_issue_835(self):
filename = pkg_resources.resource_filename(__name__, 'fixtures/issue-835.conf')
args = ['-m', 'supervisor.supervisord', '-c', filename]
supervisord = pexpect.spawn(sys.executable, args, encoding='utf-8')
self.addCleanup(supervisord.kill, signal.SIGINT)
supervisord.expect_exact('cat entered RUNNING state', timeout=60)
transport = SupervisorTransport('', '', 'unix:///tmp/issue-835.sock')
server = xmlrpclib.ServerProxy('http://anything/RPC2', transport)
try:
for s in ('The Øresund bridge ends in Malmö', 'hello'):
result = server.supervisor.sendProcessStdin('cat', s)
self.assertTrue(result)
supervisord.expect_exact(s, timeout=30)
finally:
transport.connection.close()
def __init__(self):
username = None
password = None
if settings.DEBUG:
# In development, use inet_http_server set up by django-supervisor
username = hashlib.md5(settings.SECRET_KEY).hexdigest()[:7]
password = hashlib.md5(username).hexdigest()
url = "http://localhost:9100/RPC2"
else:
# In production, use static inet_http_server settings
url = "http://localhost:9100/RPC2"
self._xmlrpc = xmlrpclib.ServerProxy('http://127.0.0.1',
transport=SupervisorTransport(
username, password, url))
def main():
module = AnsibleModule(
argument_spec = dict(
config=dict(required=True, type='path'),
state=dict(default='present', choices=['present', 'absent'])
),
supports_check_mode=True
)
configfile = module.params['config']
options = ServerOptions()
options.configfile = configfile
options.progname = 'supervisord'
try:
options.process_config(do_usage=True)
except ValueError as e:
module.fail_json(msg = e.message.message)
options.realize(args=[], progname='supervisord')
server = xmlrpclib.ServerProxy(
'http://127.0.0.1',
allow_none=True,
transport=SupervisorTransport(serverurl=options.serverurl))
try:
server.supervisor.getPID()
state = 'present'
except socket.error:
state = 'absent'
desired = module.params['state']
if state == desired:
module.exit_json(changed=False)
if not module.check_mode:
if desired == 'present':
module.run_command(["supervisord", "-c", configfile], check_rc=True)
elif desired == 'absent':
server.supervisor.shutdown()
module.exit_json(changed=True)
def getRPCInterface(address, env):
""" The getRPCInterface creates a proxy to a supervisor XML-RPC server.
Information about the HTTP configuration is required in env. """
# get configuration info from env
try:
serverurl = env['SUPERVISOR_SERVER_URL']
except KeyError:
raise KeyError('SUPERVISOR_SERVER_URL must be set in environment')
username = env.get('SUPERVISOR_USERNAME', '')
password = env.get('SUPERVISOR_PASSWORD', '')
# check that Supervisor is configured in HTTP
if not serverurl.startswith('http://'):
raise ValueError(
'Incompatible protocol for Supvisors: serverurl={}'.format(
serverurl))
# replace address in URL
serverurl = serverurl.split(':')
serverurl[1] = '//' + address
serverurl = ':'.join(serverurl)
# create transport and return proxy
transport = SupervisorTransport(username, password, serverurl)
return xmlrpclib.ServerProxy('http://{}'.format(address), transport)
def __init__(self):
self.base = conf.CANNULA_BASE
self.supervisor_base = os.path.join(self.base, 'supervisor')
self.socket_path = os.path.join(self.base, 'supervisor.sock')
self.pid_file = os.path.join(self.base, 'supervisor.pid')
self.socket = 'unix://%s' % self.socket_path
self.username = conf.CANNULA_SUPERVISOR_USER
self.password = conf.CANNULA_SUPERVISOR_PASSWORD
self.use_inet = conf.CANNULA_SUPERVISOR_USE_INET
self.inet_port = conf.CANNULA_SUPERVISOR_INET_PORT
self.manages_proxy = conf.CANNULA_SUPERVISOR_MANAGES_PROXY
self.proxy = api.proxy if self.manages_proxy else None
self.serverurl = self.inet_port if self.use_inet else self.socket
self.context = {
'cmd': self.cmd,
'ctl_cmd': self.ctl_cmd,
'main_conf': self.main_conf,
'cannula_base': self.base,
'inet_port': self.inet_port,
'serverurl': self.serverurl,
'use_inet_port': self.use_inet,
'http_user': self.username,
'http_password': self.password,
'supervisor_sock': self.socket,
'socket_path': self.socket_path,
'manages_proxy': self.manages_proxy,
'proxy': self.proxy,
}
# Setup the connection to the xmlrpc backend
# xmlrpclib forces you to use an http uri, the SupervisorTransport
# handles unix sockets as well as usernames and passwords.
self.server = xmlrpclib.ServerProxy('http://127.0.0.1',
transport=SupervisorTransport(
username=self.username,
password=self.password,
serverurl=self.serverurl
)
)
def supervisor_restart(
service: str = "web-api",
# default supervisor configuration
socketpath: str = "unix:///var/run/supervisor.sock"
) -> bool:
"""Restart service by xml-rpc of supervisor.
"""
if no_lib:
return False
server = ServerProxy("http://127.0.0.1",
transport=SupervisorTransport(None, None, socketpath))
result = True
try:
if service:
server.supervisor.stopProcess(service)
server.supervisor.startProcess(service)
else:
server.supervisor.restart()
except Exception as err:
result = False
return True
def begin(self):
self.xmlrpc = xmlrpclib.ServerProxy(
'http://127.0.0.1', # will always be local
transport=SupervisorTransport(None, None, self.url))
self.sapi = self.xmlrpc.supervisor
def main():
arg_parser = create_argument_parser()
args = arg_parser.parse_args()
if not args.connection_monitor and not args.output_collect:
arg_parser.print_help()
sys.exit("\n\n--connection-monitor or --output-collect is required.")
if args.connection_monitor:
if not args.group:
sys.exit("--process-group must be defined")
if args.rpc_url.startswith('http://'):
server = xmlrpclib.Server(args.rpc_url)
elif args.rpc_url.startswith('unix://'):
server = xmlrpclib.ServerProxy('http://localhost:9001/RPC2',SupervisorTransport('', '', args.rpc_url))
else:
write_stderr("Can't select method for connect to supervisor")
sys.exit(1)
if server.supervisor.getState()['statecode'] == SupervisorStates.RUNNING:
write_stderr("Connected to RPC\n")
write_stderr("Supervisor status: %s\n" % (server.supervisor.getState()['statename']))
process_tick_event = EventTick(server, args.duration, args.status, args.group, args.process, args.kill, args.kill_timeout, args.verbose)
if args.output_collect:
env = os.environ
if not args.http_endpoint:
if 'HTTP_ENDPOINT' in env.keys():
http_endpoint = env['HTTP_ENDPOINT']
else:
sys.exit("HTTP_ENDPOINT is required.")
else:
http_endpoint = args.http_endpoint
if not args.http_error_endpoint:
if 'HTTP_ERROR_ENDPOINT' in env.keys():
http_error_endpoint = env['HTTP_ERROR_ENDPOINT']
else:
write_stderr("Endpoint for errors not found.")
http_error_endpoint = None
else:
http_error_endpoint = args.http_error_endpoint
process_log_event = EventLog(http_endpoint, http_error_endpoint, args.strip_streams, args.verbose)
# Main loop
while 1:
headers, payload = childutils.listener.wait(sys.stdin, sys.stdout)
if args.verbose: write_stderr("Get event with headers: " + str(headers) + ". And payload: " + str(payload) + "\n")
if args.connection_monitor and headers['eventname'].startswith('TICK'):
process_tick_event.process_event(headers, payload)
if args.output_collect and headers['eventname'].startswith('PROCESS_LOG'):
process_log_event.process_event(headers, payload)
childutils.listener.ok(sys.stdout) # Ready for next event
def getRPCTransport(env):
u = env.get('SUPERVISOR_USERNAME', '')
p = env.get('SUPERVISOR_PASSWORD', '')
return SupervisorTransport(u, p, env['SUPERVISOR_SERVER_URL'])
"""
import sys
import traceback
import logging
import os
import time
import xmlrpc.client as xmlrpclib
from jproperties import Properties
from mcstatus import MinecraftServer
from quarry.net.proxy import DownstreamFactory, Bridge, Downstream
from supervisor.xmlrpc import SupervisorTransport
from twisted.internet import reactor
transport = SupervisorTransport(None, None, 'http://localhost:9001/RPC2')
transport.verbose = True
server = xmlrpclib.Server('http://unused', transport=transport)
starting = 'starting'
started = 'started'
stopped = 'stopped'
def str2bool(v):
return v.lower() in ("yes", "true", "t", "1")
class PersistentState:
server = stopped
def get_rpc(options):
transport = SupervisorTransport(options.username, options.password,
options.serverurl)
return xmlrpclib.ServerProxy('http://127.0.0.1', transport)
supervisor_rpc_address = 'http://{{supervisor_http_host}}:{{supervisor_http_port}}/RPC2'
supervisor_rpc_user = '******'
supervisor_rpc_pass = '******'
{%raw%}
if sys.version_info[0] == 2:
from xmlrpclib import Server
if sys.version_info[0] == 3:
#from xmlrpclib import Server
from xmlrpc.client import ServerProxy
Server = ServerProxy
from supervisor.xmlrpc import SupervisorTransport
transport = SupervisorTransport(supervisor_rpc_user, supervisor_rpc_pass,
supervisor_rpc_address)
server = Server(supervisor_rpc_address, transport)
def get_all_process():
"""
这个函数是产生 lld 数据的
{
"data":[
{
"{#PROCNAME}": "app1"
},
{
"{#PROCNAME}": "app2"
}
]
}
def __init__(self):
t = SupervisorTransport(None, None, "unix:///var/run/supervisor.sock")
self.server = xmlrpc.client.ServerProxy("http://127.0.0.1", transport=t)
def _get_supervisor_proxy(self):
return xmlrpc.client.ServerProxy("http://{}".format(self.internal_ip),
transport=SupervisorTransport(
None, None, "unix://{}".format(
self.socket_file)))
