def mutex(self, args, kwargs, delete=False):
'''Creates the mutex locks and yields the mutex status.'''
conf = self.app.conf
global_timeout = getattr(conf, 'MUTEX_TIMEOUT', None)
items = getcallargs(self.run, *args, **kwargs)
timeout = items.get('mutex_timeout') or global_timeout or 3600
success = False
try:
hosts = getattr(conf, 'ZOOKEEPER_HOSTS', '127.0.0.1:2181')
client = kazoo.client.KazooClient(hosts=hosts)
client.start()
lock_node = self._get_node(args, kwargs)
if client.exists(lock_node):
if time.time() - client.get(lock_node)[1].created > timeout:
client.delete(lock_node)
success = True
else:
success = True
except kazoo.exceptions.KazooException:
yield False
else:
if success:
client.create(lock_node, makepath=True)
yield True
if delete:
client.delete(lock_node)
else:
yield False
finally:
try:
client.stop()
client.close()
except kazoo.exceptions.KazooException:
pass
def mutex(self, args, kwargs, delete=False):
'''Creates the mutex locks and yields the mutex status.'''
conf = self.app.conf
global_timeout = getattr(conf, 'MUTEX_TIMEOUT', None)
items = getcallargs(self.run, *args, **kwargs)
timeout = items.get('mutex_timeout') or global_timeout or 3600
success = False
try:
hosts = getattr(conf, 'ZOOKEEPER_HOSTS', '127.0.0.1:2181')
client = kazoo.client.KazooClient(hosts=hosts)
client.start()
lock_node = self._get_node(args, kwargs)
if client.exists(lock_node):
if time.time() - client.get(lock_node)[1].created > timeout:
client.delete(lock_node)
success = True
else:
success = True
except kazoo.exceptions.KazooException:
yield False
else:
if success:
client.create(lock_node, makepath=True)
yield True
if delete:
client.delete(lock_node)
else:
yield False
finally:
try:
client.stop()
client.close()
except kazoo.exceptions.KazooException:
pass
def get_or_create_node(self,
path,
value='',
acl=None,
ephemeral=False,
sequence=False,
makepath=False):
client = None
hosts = getattr(self.app.conf, 'ZOOKEEPER_HOSTS', '127.0.0.1:2181')
try:
client = kazoo.client.KazooClient(hosts=hosts)
client.start()
if not client.exists(path):
client.create(path,
value=value,
acl=acl,
ephemeral=ephemeral,
sequence=sequence,
makepath=makepath)
return client.get(path)
except Exception as ex:
raise ex
finally:
if client:
client.stop()
client.close()
def get_or_create_node(self,
path,
value='',
acl=None,
ephemeral=False,
sequence=False,
makepath=False):
client = None
try:
client = self.get_kazoo_client()
client.start()
if not client.exists(path):
client.create(path,
value=value,
acl=acl,
ephemeral=ephemeral,
sequence=sequence,
makepath=makepath)
return client.get(path)
except Exception as ex:
raise ex
finally:
if client:
client.stop()
client.close()
def now(self):
'''Get the catch-up time or current time'''
client = kazoo.client.KazooClient(hosts=self.hosts)
client.start(timeout=1)
if client.exists(self.now_node):
ret = cPickle.loads(client.get(self.now_node)[0])
else:
ret = celery.current_app._get_current_object().now()
client.stop()
client.close()
return ret
def __init__(self, client, path, max_count=sys.maxint, default=0):
super(ZookeeperCounter, self).__init__(client, path, default)
self.max_count = max_count
# Delete existing counter if it exists with stale data
if client.exists(path):
data = client.get(path)[0]
if data != b'':
try:
self.default_type(data)
except (TypeError, ValueError):
client.delete(path)
self._ensure_node()
def __init__(self, client, path, max_count=sys.maxint, default=0):
super(ZookeeperCounter, self).__init__(client, path, default)
self.max_count = max_count
# Delete existing counter if it exists with stale data
if client.exists(path):
data = client.get(path)[0]
if data != b'':
try:
self.default_type(data)
except (TypeError, ValueError):
client.delete(path)
self._ensure_node()
def list_controls():
'''View current locks/semaphores/mutexes'''
client = kazoo.client.KazooClient('localhost:2181')
client.start()
# Locks
lock_node = u'/zkcelery/locks'
lock_header = False
if client.exists(lock_node):
for lock_name in client.get_children(lock_node):
full_path = u'%s/%s' % (lock_node, lock_name)
lock = client.Lock(full_path)
contenders = lock.contenders()
if contenders:
if not lock_header:
print 'Current Locks'
lock_header = True
print '\t%s - %s' % (full_path, contenders)
# Semaphores
semaphore_node = u'/zkcelery/semaphores'
semaphore_header = False
if client.exists(semaphore_node):
for semaphore_name in client.get_children(semaphore_node):
if '__lock__' not in semaphore_name:
full_path = u'%s/%s' % (semaphore_node, semaphore_name)
semaphore = client.Semaphore(full_path)
lease_holders = semaphore.lease_holders()
if lease_holders:
if not semaphore_header:
print 'Current Semaphores'
semaphore_header = True
print '\t%s - %s' % (full_path, lease_holders)
# Mutex
mutex_node = u'/zkcelery/mutexes'
mutex_header = False
if client.exists(mutex_node):
for mutex_name in client.get_children(mutex_node):
full_path = u'%s/%s' % (mutex_node, mutex_name)
lock_time = time.localtime(client.get(full_path)[1].created)
lock_str = time.strftime('Set at %Y-%m-%d %H:%M:%S', lock_time)
if not mutex_header:
print 'Current Mutexes'
mutex_header = True
print '\t%s - %s' % (full_path, lock_str)
client.stop()
client.close()
def list_controls():
'''View current locks/semaphores/mutexes'''
client = kazoo.client.KazooClient('localhost:2181')
client.start()
# Locks
lock_node = u'/zkcelery/locks'
lock_header = False
if client.exists(lock_node):
for lock_name in client.get_children(lock_node):
full_path = u'%s/%s' % (lock_node, lock_name)
lock = client.Lock(full_path)
contenders = lock.contenders()
if contenders:
if not lock_header:
print 'Current Locks'
lock_header = True
print '\t%s - %s' % (full_path, contenders)
# Semaphores
semaphore_node = u'/zkcelery/semaphores'
semaphore_header = False
if client.exists(semaphore_node):
for semaphore_name in client.get_children(semaphore_node):
if '__lock__' not in semaphore_name:
full_path = u'%s/%s' % (semaphore_node, semaphore_name)
semaphore = client.Semaphore(full_path)
lease_holders = semaphore.lease_holders()
if lease_holders:
if not semaphore_header:
print 'Current Semaphores'
semaphore_header = True
print '\t%s - %s' % (full_path, lease_holders)
# Mutex
mutex_node = u'/zkcelery/mutexes'
mutex_header = False
if client.exists(mutex_node):
for mutex_name in client.get_children(mutex_node):
full_path = u'%s/%s' % (mutex_node, mutex_name)
lock_time = time.localtime(client.get(full_path)[1].created)
lock_str = time.strftime('Set at %Y-%m-%d %H:%M:%S', lock_time)
if not mutex_header:
print 'Current Mutexes'
mutex_header = True
print '\t%s - %s' % (full_path, lock_str)
client.stop()
client.close()
def mutex(self, args, kwargs, delete=False):
'''Creates the mutex locks and yields the mutex status.'''
conf = self._get_app().conf
global_timeout = getattr(conf, 'MUTEX_TIMEOUT', None)
items = inspect.getcallargs(self.run, *args, **kwargs)
timeout = items.get('mutex_timeout') or global_timeout or 3600
success = False
try:
hosts = conf.ZOOKEEPER_HOSTS
client = kazoo.client.KazooClient(hosts=hosts)
client.start()
lock_node = self._get_node(args, kwargs)
if client.exists(lock_node):
if time.time() - float(client.get(lock_node)[0]) > timeout:
client.delete(lock_node)
success = True
else:
success = True
except kazoo.exceptions.KazooException as exc:
logger.exception('Error stopping execution')
yield False
else:
if success:
client.create(lock_node, six.text_type(time.time()).encode(), makepath=True)
yield True
if delete:
client.delete(lock_node)
else:
logger.debug('This task has been locked.')
yield False
finally:
try:
client.stop()
client.close()
except kazoo.exceptions.KazooException as exc:
pass
def get_nodes(client):
base = Path("/nodepool/nodes")
return list(filter(lambda x: x[1] is not None, [
(base / node, decode_zknode(client.get(str(base / node))))
for node in client.get_children(str(base))
]))
return t[0]
else:
return t
except Exception:
return ""
print("Removing any oci requests")
try:
requests = client.get_children("/nodepool/requests")
except Exception:
requests = []
for req in requests:
req_path = os.path.join("/nodepool/requests", req)
try:
req = json.loads(client.get(req_path)[0].decode('utf-8'))
if get_type(req["node_types"]).endswith("-oci"):
print("Deleting %s" % req_path)
client.delete(req_path, recursive=True)
except Exception:
print("Couldn't decode %s" % req_path)
print("Removing any oci nodes")
try:
nodes = client.get_children("/nodepool/nodes")
except Exception:
nodes = []
for node in nodes:
node_path = os.path.join("/nodepool/nodes", node)
try:
node = json.loads(client.get(node_path)[0].decode('utf-8'))
filter(
lambda x: x['fixed_ips'][0]['ip_address'] != router_interface[
'fixed_ips'][0]['ip_address'], ports))
# Remove ACTIVE port from ports list
ports = list(filter(lambda x: x['status'] != 'ACTIVE', ports))
if not args.skip_zookeeper:
# Kazoo - get zookeeper nodes
client = kazoo.client.KazooClient(hosts="zookeeper")
client.start()
kz_to_delete = []
for node in client.get_children("/nodepool/nodes"):
node_path = os.path.join("/nodepool/nodes", node)
node_data = client.get(node_path)[0].decode('utf-8')
try:
node = json.loads(node_data)
except:
print("%s: decode failed" % node_path)
if not node_data:
print("Deleting empty %s" % node_path)
client.delete(node_path, recursive=True)
else:
print(node_data)
continue
if node["provider"] != args.os_cloud:
continue
kz_to_delete.append(node_path)
print("%d zookeeper node" % len(kz_to_delete))
# Copyright 2019, Red Hat
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys
import kazoo.client
try:
nodepath = sys.argv[1]
except IndexError:
print("usage: %s zk-node-path" % sys.argv[0])
exit(1)
client = kazoo.client.KazooClient(hosts="zookeeper")
client.start()
if nodepath.endswith('/'):
print(client.get_children(nodepath))
else:
print(client.get(nodepath))
