def __init__(self, config, connections={}):
self.config = config
merge_root = get_default(self.config, 'merger', 'git_dir',
'/var/lib/zuul/merger-git')
merge_email = get_default(self.config, 'merger', 'git_user_email')
merge_name = get_default(self.config, 'merger', 'git_user_name')
speed_limit = get_default(
config, 'merger', 'git_http_low_speed_limit', '1000')
speed_time = get_default(
config, 'merger', 'git_http_low_speed_time', '30')
git_timeout = get_default(config, 'merger', 'git_timeout', 300)
self.merger = merger.Merger(
merge_root, connections, merge_email, merge_name, speed_limit,
speed_time, git_timeout=git_timeout)
self.command_map = dict(
stop=self.stop)
command_socket = get_default(
self.config, 'merger', 'command_socket',
'/var/lib/zuul/merger.socket')
self.command_socket = commandsocket.CommandSocket(command_socket)
self.jobs = {
'merger:merge': self.merge,
'merger:cat': self.cat,
'merger:refstate': self.refstate,
'merger:fileschanges': self.fileschanges,
}
self.gearworker = ZuulGearWorker(
'Zuul Merger',
'zuul.MergeServer',
'merger-gearman-worker',
self.config,
self.jobs)
def start(self):
self.rpc = zuul.rpcclient.RPCClient(
self.gear_server,
self.gear_port,
self.gear_ssl_key,
self.gear_ssl_cert,
self.gear_ssl_ca)
self.server = streamer_utils.CustomThreadingTCPServer(
self.address,
functools.partial(RequestHandler, rpc=self.rpc),
user=self.user,
pid_file=self.pid_file)
# Start the command processor after the server and privilege drop
if self.command_socket:
self.log.debug("Starting command processor")
self.command_socket = commandsocket.CommandSocket(
self.command_socket)
self.command_socket.start()
self.command_running = True
self.command_thread = threading.Thread(
target=self._runCommand, name='command')
self.command_thread.daemon = True
self.command_thread.start()
# The socketserver shutdown() call will hang unless the call
# to server_forever() happens in another thread. So let's do that.
self.server_thread = threading.Thread(target=self._run)
self.server_thread.daemon = True
self.server_thread.start()
self.log.info("Finger gateway is started")
def __init__(self, config, keep_jobdir=False):
self.config = config
self.keep_jobdir = keep_jobdir
self.hostname = socket.gethostname()
self.registered_functions = set()
self.node_workers = {}
self.jobs = {}
self.builds = {}
self.zmq_send_queue = Queue.Queue()
self.termination_queue = Queue.Queue()
self.sites = {}
self.static_nodes = {}
if config.has_option('launcher', 'accept-nodes'):
self.accept_nodes = config.get('launcher', 'accept-nodes')
else:
self.accept_nodes = True
if self.config.has_option('zuul', 'state_dir'):
state_dir = os.path.expanduser(
self.config.get('zuul', 'state_dir'))
else:
state_dir = '/var/lib/zuul'
path = os.path.join(state_dir, 'launcher.socket')
self.command_socket = commandsocket.CommandSocket(path)
for section in config.sections():
m = self.site_section_re.match(section)
if m:
sitename = m.group(1)
d = {}
d['host'] = config.get(section, 'host')
d['user'] = config.get(section, 'user')
if config.has_option(section, 'pass'):
d['pass'] = config.get(section, 'pass')
else:
d['pass'] = ''
if config.has_option(section, 'root'):
d['root'] = config.get(section, 'root')
else:
d['root'] = '/'
self.sites[sitename] = d
continue
m = self.node_section_re.match(section)
if m:
nodename = m.group(1)
d = {}
d['name'] = nodename
d['host'] = config.get(section, 'host')
if config.has_option(section, 'description'):
d['description'] = config.get(section, 'description')
else:
d['description'] = ''
if config.has_option(section, 'labels'):
d['labels'] = config.get(section, 'labels').split(',')
else:
d['labels'] = []
self.static_nodes[nodename] = d
continue
def __init__(self, config, connections=None):
super().__init__(config, 'merger', connections)
self.command_map = dict(
stop=self.stop,
pause=self.pause,
unpause=self.unpause,
)
command_socket = get_default(self.config, 'merger', 'command_socket',
'/var/lib/zuul/merger.socket')
self.command_socket = commandsocket.CommandSocket(command_socket)
self._command_running = False
def __init__(self, config, testonly=False):
threading.Thread.__init__(self)
self.daemon = True
self.hostname = socket.getfqdn()
self.wake_event = threading.Event()
self.layout_lock = threading.Lock()
self.run_handler_lock = threading.Lock()
self.command_map = dict(stop=self.stop, )
self._pause = False
self._exit = False
self._stopped = False
self.executor = None
self.merger = None
self.connections = None
self.statsd = get_statsd(config)
self.rpc = rpclistener.RPCListener(config, self)
self.stats_thread = threading.Thread(target=self.runStats)
self.stats_thread.daemon = True
self.stats_stop = threading.Event()
# TODO(jeblair): fix this
# Despite triggers being part of the pipeline, there is one trigger set
# per scheduler. The pipeline handles the trigger filters but since
# the events are handled by the scheduler itself it needs to handle
# the loading of the triggers.
# self.triggers['connection_name'] = triggerObject
self.triggers = dict()
self.config = config
self.trigger_event_queue = queue.Queue()
self.result_event_queue = queue.Queue()
self.management_event_queue = zuul.lib.queue.MergedQueue()
self.abide = model.Abide()
self.unparsed_abide = model.UnparsedAbideConfig()
if not testonly:
time_dir = self._get_time_database_dir()
self.time_database = model.TimeDataBase(time_dir)
command_socket = get_default(self.config, 'scheduler',
'command_socket',
'/var/lib/zuul/scheduler.socket')
self.command_socket = commandsocket.CommandSocket(command_socket)
if zuul_version.is_release is False:
self.zuul_version = "%s %s" % (zuul_version.release_string,
zuul_version.git_version)
else:
self.zuul_version = zuul_version.release_string
self.last_reconfigured = None
self.tenant_last_reconfigured = {}
self.autohold_requests = {}
def __init__(self, config, connections={}):
self.config = config
merge_root = get_default(self.config, 'merger', 'git_dir',
'/var/lib/zuul/merger-git')
merge_email = get_default(self.config, 'merger', 'git_user_email')
merge_name = get_default(self.config, 'merger', 'git_user_name')
speed_limit = get_default(config, 'merger', 'git_http_low_speed_limit',
'1000')
speed_time = get_default(config, 'merger', 'git_http_low_speed_time',
'30')
self.merger = merger.Merger(merge_root, connections, merge_email,
merge_name, speed_limit, speed_time)
self.command_map = dict(stop=self.stop)
command_socket = get_default(self.config, 'merger', 'command_socket',
'/var/lib/zuul/merger.socket')
self.command_socket = commandsocket.CommandSocket(command_socket)
def __init__(
self,
listen_address,
listen_port,
gear_server,
gear_port,
ssl_key=None,
ssl_cert=None,
ssl_ca=None,
static_cache_expiry=3600,
connections=None,
info=None,
static_path=None,
zk_hosts=None,
authenticators=None,
command_socket=None,
):
self.start_time = time.time()
self.listen_address = listen_address
self.listen_port = listen_port
self.event_loop = None
self.term = None
self.server = None
self.static_cache_expiry = static_cache_expiry
self.info = info
self.static_path = os.path.abspath(static_path or STATIC_DIR)
# instanciate handlers
self.rpc = zuul.rpcclient.RPCClient(gear_server, gear_port, ssl_key,
ssl_cert, ssl_ca)
self.zk = zuul.zk.ZooKeeper()
if zk_hosts:
self.zk.connect(hosts=zk_hosts, read_only=True)
self.connections = connections
self.authenticators = authenticators
self.stream_manager = StreamManager()
self.command_socket = commandsocket.CommandSocket(command_socket)
self.repl = None
self.command_map = {
'stop': self.stop,
'repl': self.start_repl,
'norepl': self.stop_repl,
}
route_map = cherrypy.dispatch.RoutesDispatcher()
api = ZuulWebAPI(self)
route_map.connect('api', '/api', controller=api, action='index')
route_map.connect('api', '/api/info', controller=api, action='info')
route_map.connect('api',
'/api/connections',
controller=api,
action='connections')
route_map.connect('api',
'/api/tenants',
controller=api,
action='tenants')
route_map.connect('api',
'/api/tenant/{tenant}/info',
controller=api,
action='tenant_info')
route_map.connect('api',
'/api/tenant/{tenant}/status',
controller=api,
action='status')
route_map.connect('api',
'/api/tenant/{tenant}/status/change/{change}',
controller=api,
action='status_change')
route_map.connect('api',
'/api/tenant/{tenant}/jobs',
controller=api,
action='jobs')
route_map.connect('api',
'/api/tenant/{tenant}/job/{job_name}',
controller=api,
action='job')
# if no auth configured, deactivate admin routes
if self.authenticators.authenticators:
# route order is important, put project actions before the more
# generic tenant/{tenant}/project/{project} route
route_map.connect(
'api',
'/api/tenant/{tenant}/project/{project:.*}/autohold',
controller=api,
action='autohold')
route_map.connect(
'api',
'/api/tenant/{tenant}/project/{project:.*}/enqueue',
controller=api,
action='enqueue')
route_map.connect(
'api',
'/api/tenant/{tenant}/project/{project:.*}/dequeue',
controller=api,
action='dequeue')
route_map.connect('api',
'/api/tenant/{tenant}/autohold',
controller=api,
action='autohold_list')
route_map.connect('api',
'/api/tenant/{tenant}/projects',
controller=api,
action='projects')
route_map.connect('api',
'/api/tenant/{tenant}/project/{project:.*}',
controller=api,
action='project')
route_map.connect(
'api', '/api/tenant/{tenant}/pipeline/{pipeline}'
'/project/{project:.*}/branch/{branch:.*}/freeze-jobs',
controller=api,
action='project_freeze_jobs')
route_map.connect('api',
'/api/tenant/{tenant}/pipelines',
controller=api,
action='pipelines')
route_map.connect('api',
'/api/tenant/{tenant}/labels',
controller=api,
action='labels')
route_map.connect('api',
'/api/tenant/{tenant}/nodes',
controller=api,
action='nodes')
route_map.connect('api',
'/api/tenant/{tenant}/key/{project:.*}.pub',
controller=api,
action='key')
route_map.connect('api', '/api/tenant/{tenant}/'
'project-ssh-key/{project:.*}.pub',
controller=api,
action='project_ssh_key')
route_map.connect('api',
'/api/tenant/{tenant}/console-stream',
controller=api,
action='console_stream')
route_map.connect('api',
'/api/tenant/{tenant}/builds',
controller=api,
action='builds')
route_map.connect('api',
'/api/tenant/{tenant}/build/{uuid}',
controller=api,
action='build')
route_map.connect('api',
'/api/tenant/{tenant}/buildsets',
controller=api,
action='buildsets')
route_map.connect('api',
'/api/tenant/{tenant}/buildset/{uuid}',
controller=api,
action='buildset')
route_map.connect('api',
'/api/tenant/{tenant}/config-errors',
controller=api,
action='config_errors')
for connection in connections.connections.values():
controller = connection.getWebController(self)
if controller:
cherrypy.tree.mount(
controller,
'/api/connection/%s' % connection.connection_name)
# Add fallthrough routes at the end for the static html/js files
route_map.connect('root_static',
'/{path:.*}',
controller=StaticHandler(self.static_path),
action='default')
conf = {'/': {'request.dispatch': route_map}}
cherrypy.config.update({
'global': {
'environment': 'production',
'server.socket_host': listen_address,
'server.socket_port': int(listen_port),
},
})
cherrypy.tree.mount(api, '/', config=conf)
