def create_data_bag(chefapi, data_bag_data, force_update=False):
#Checking, chef server has this data bag and will we update it if necessary
data_bag_list = chef.DataBag.list(api=chefapi)
if data_bag_data['id'] in data_bag_list and not force_update:
logger.warning("Found data bag with name '%s'. Skipping it" %
data_bag_data['id'])
else:
if not data_bag_data['id'] in data_bag_list:
logger.info("Data bag with name '%s' not found on chef server" %
data_bag_data['id'])
logger.info("Adding data bag '%s' to chef server" %
data_bag_data['id'])
new_data_bag = chef.DataBag.create(name=data_bag_data['id'],
api=chefapi)
bag = chef.DataBagItem.create(new_data_bag,
data_bag_data['id'],
api=chefapi)
else:
logger.info(
"Data bag with name '%s' found on chef server and will be updated"
% data_bag_data['id'])
logger.info("Updating data bag '%s' on chef server" %
data_bag_data['id'])
new_data_bag = chef.DataBag(name=data_bag_data['id'], api=chefapi)
bag = chef.DataBagItem(new_data_bag,
data_bag_data['id'],
api=chefapi)
bag.clear()
bag.update(data_bag_data)
bag.save()
def _get_databag(self, target_system):
"""get databag."""
import chef
if target_system not in self.tmp_databags_:
self.tmp_databags_[target_system] = chef.DataBag(target_system,
api=self.api_)
return self.tmp_databags_[target_system]
def test_update_databags(self):
import chef
vars_dict = {
"cluster": {
"deployed_package_config": {
"service_credentials": {
"nova": {
"username": "******",
"password": "******"
}
},
"users_credentials": {
"ksadmin": {
"username": "******",
"password": "******"
},
"demo": {
"username": "******",
"password": "******"
}
}
}
}
}
expected_output = {
"user_passwords": {
"admin": {
"admin": "admin",
},
"ksadmin": {
"ksadmin": "ksadmin"
},
"demo": {
"demo": "demo"
}
},
"db_passwords": {
"nova": {
"nova": "compute",
},
"horizon": {
"horizon": "horizon"
},
"keystone": {
"keystone": "keystone"
}
}
}
self.test_chef.update_databags(vars_dict)
databag_names = self.test_chef.get_chef_databag_names()
for name in databag_names:
test_databag = chef.DataBag(name, self.chef_test_api)
self.maxDiff = None
expected_items = expected_output[name]
for item, value in test_databag.iteritems():
self.assertDictEqual(expected_items[item], value)
def get_create_databag(self, databag_name):
"""Get databag object from chef server.
Creates the databag if it does not exist.
"""
import chef
databag = None
if databag_name not in chef.DataBag.list(api=self.chef_api):
databag = chef.DataBag.create(databag_name, api=self.chef_api)
else:
databag = chef.DataBag(databag_name, api=self.chef_api)
return databag
def tearDown(self):
import chef
super(TestChefInstaller, self).tearDown()
databag_names = self.test_chef.get_chef_databag_names()
del self.test_chef
for obj in self.objects:
try:
obj.delete()
except chef.exceptions.ChefError as ex:
print ex
for name in databag_names:
temp = chef.DataBag(name, self.chef_test_api)
if temp in chef.DataBag.list(api=self.chef_test_api):
temp.delete()
del self.chef_test_api
def update_data_bag_item(node):
data_bag_item_name = 'deployment_{}'.format(
node.CHEF_ATTRIBUTES['zuun']['deployment'])
data_bag_item_node_data = {
'version': node.mongodb_version,
'conf': base64.b64encode(generate_mongo_conf(node))
}
try:
search_key = node.expanded_replica_set
except AttributeError:
search_key = None
if search_key is None: search_key = node.CHEF_MONGODB_TYPE
data_bag_item = {'replica-sets': {}}
with chef.autoconfigure(node.chef_path):
data_bag = chef.DataBag('zuun')
data_bag_item_exists = False
if data_bag_item_name in data_bag.keys():
node.log.info(
'Data bag item {} already exists; updating (but not overwriting) if required'
.format(data_bag_item_name))
data_bag_item = chef.DataBagItem(data_bag, data_bag_item_name)
data_bag_item_exists = True
else:
node.log.info('Data bag item {} does not exist; creating'.format(
data_bag_item_name))
if node.CHEF_MONGODB_TYPE == 'data':
source = data_bag_item['replica-sets']
source[search_key] = {'data': data_bag_item_node_data}
elif node.CHEF_MONGODB_TYPE == 'config' and search_key != 'config':
source = data_bag_item['replica-sets']
source[search_key] = {'config': data_bag_item_node_data}
else:
source = data_bag_item
source[search_key] = data_bag_item_node_data
if data_bag_item_exists:
data_bag_item.save()
else:
chef.DataBagItem.create('zuun', data_bag_item_name,
**data_bag_item)
def run(self, terms, variables=None, **kwargs):
# Ensure pychef has been loaded
if not HAS_CHEF:
raise AnsibleError('PyChef needed for lookup plugin, try `pip install pychef`')
for term in terms:
self.parse_kv_args(parse_kv(term))
api_object = chef.autoconfigure()
if not isinstance(api_object, chef.api.ChefAPI):
raise AnsibleError('Unable to connect to Chef Server API.')
data_bag_object = chef.DataBag(self.name)
data_bag_item = data_bag_object[self.item]
return [dict(data_bag_item)]
def clean(self):
try:
for node_name in chef.Node.list(api=self.api):
node = chef.Node(node_name, api=self.api)
node.delete()
logging.info('delete node %s', node_name)
except Exception as error:
logging.error('failed to delete some nodes')
logging.exception(error)
try:
for client_name in chef.Client.list(api=self.api):
if client_name in ['chef-webui', 'chef-validator']:
continue
client = chef.Client(client_name, api=self.api)
client.delete()
logging.info('delete client %s', client_name)
except Exception as error:
logging.error('failed to delete some clients')
logging.exception(error)
try:
for env_name in chef.Environment.list(api=self.api):
if env_name == '_default':
continue
env = chef.Environment(env_name, api=self.api)
env.delete()
logging.info('delete env %s', env_name)
except Exception as error:
logging.error('failed to delete some envs')
logging.exception(error)
try:
for databag_name in chef.DataBag.list(api=self.api):
databag = chef.DataBag(databag_name, api=self.api)
for item_name, item in databag.items():
item.delete()
logging.info(
'delete item %s from databag %s',
item_name, databag_name
)
except Exception as error:
logging.error('failed to delete some databag items')
logging.exception(error)
def get_databag():
api = get_chef_api()
databag = chef.DataBag('multi_node', api)
return databag['hd-cluster-setting']
'''
def get_cluster_users(cluster_name):
bag = chef.DataBag('mysql')
return bag[cluster_name]['users']
def get_cluster_id(cluster_name):
print cluster_name
bag = chef.DataBag('mysql')
return bag[cluster_name]['cluster_id']
