def delete_complete_cluster(context, cluster_id): cluster_obj = objects.Cluster.get_cluster_by_id(context, cluster_id) target = {'tenant_id': cluster_obj.project_id} policy.check("cluster:delete", context, target) # update cluster to deleting objects.Cluster.update_cluster_deleting(context, cluster_id) # retrieve cluster nodes nodes = objects.Node.get_nodes_by_cluster_id(context, cluster_id) # create list with node id's for create cluster flow node_ids = [node.id for node in nodes] # retrieve cluster record cluster = objects.Cluster.get_cluster_by_id(context, cluster_id) # prepare and post cluster delete job to backend flow_kwargs = { 'cluster_id': cluster_id, 'node_ids': node_ids, 'group_id': cluster.group_id, } job_args = { 'context': context.to_dict(), } job_client = task_flow_client.get_client_instance() # TODO(dagnello): might be better to use request_id for job_uuid job_uuid = uuidutils.generate_uuid() job_client.post(delete_cluster, job_args, flow_kwargs=flow_kwargs, tx_uuid=job_uuid) LOG.info( _LI('Delete Cluster Request Cluster ID %(cluster_id)s Job ID ' '%(job_id)s') % ({ "cluster_id": cluster_id, "job_id": job_uuid }))
def check(self): if not self.lock.acquired: self.lock.acquire(blocking=False) if self.lock.acquired: clusters = get_cluster_id_node_ids() taskflow_client_instance = taskflow_client.get_client_instance() job_list = taskflow_client_instance.joblist() cluster_ids = [] for job in job_list: if 'cluster_status_check' in job.details['store']: cluster_ids.append(job.details['store']['cluster_id']) filtered_clusters = [] for cluster in clusters: if cluster[0] not in cluster_ids: filtered_clusters.append(cluster) for cluster in filtered_clusters: job_args = { 'cluster_status_check': '', 'cluster_id': cluster[0], 'context': {}, 'default_rabbit_user': '******', 'default_rabbit_pass': cluster[0], } flow_kwargs = { 'cluster_id': cluster[0], 'node_ids': cluster[1] } taskflow_client_instance.post(check_cluster_status, job_args, flow_kwargs=flow_kwargs)
def test_check(self): tf_instance = tf_client.get_client_instance() start_job_list = tf_instance.joblist() start_job_list_length = len(start_job_list) # Test while job board is empty self.cue_monitor_service.check() end_job_list = sorted(tf_instance.joblist()) end_job_list_length = len(end_job_list) self.assertEqual( 2, end_job_list_length - start_job_list_length, "Job list should only have two " "clusters: " + str(tf_instance.joblist())) # Test while job board has 2 entries self.cue_monitor_service.check() # No new jobs should have been added. new_end_job_list = sorted(tf_instance.joblist()) self.assertEqual(end_job_list, new_end_job_list, "Job list should not have changed")
# Copyright 2015 Hewlett-Packard Development Company, L.P. # # Authors: Davide Agnello <*****@*****.**> # # 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. # Copyright [2014] Hewlett-Packard Development Company, L.P. # limitations under the License. import zake.fake_client as fake_client import cue.taskflow.client as tf_client _zk_client = fake_client.FakeClient() persistence = tf_client.create_persistence(client=_zk_client) jobboard = tf_client.create_jobboard("test_board", persistence=persistence, client=_zk_client) tf_client = tf_client.get_client_instance(persistence=persistence, jobboard=jobboard)
def post(self, data): """Create a new Cluster. :param data: cluster parameters within the request body. """ context = pecan.request.context request_data = data.as_dict() cluster_flavor = request_data['flavor'] if data.size <= 0: raise exception.Invalid(_("Invalid cluster size provided")) elif data.size > CONF.api.max_cluster_size: raise exception.RequestEntityTooLarge( _("Invalid cluster size, max size is: %d") % CONF.api.max_cluster_size) if len(data.network_id) > 1: raise exception.Invalid(_("Invalid number of network_id's")) # extract username/password if (data.authentication and data.authentication.type and data.authentication.token): auth_validator = auth_validate.AuthTokenValidator.validate_token( auth_type=data.authentication.type, token=data.authentication.token) if not auth_validator or not auth_validator.validate(): raise exception.Invalid( _("Invalid broker authentication " "parameter(s)")) else: raise exception.Invalid( _("Missing broker authentication " "parameter(s)")) default_rabbit_user = data.authentication.token['username'] default_rabbit_pass = data.authentication.token['password'] broker_name = CONF.default_broker_name # get the image id of default broker image_id = objects.BrokerMetadata.get_image_id_by_broker_name( context, broker_name) # validate cluster flavor self._validate_flavor(image_id, cluster_flavor) # convert 'network_id' from list to string type for objects/cluster # compatibility request_data['network_id'] = request_data['network_id'][0] # create new cluster object with required data from user new_cluster = objects.Cluster(**request_data) # create new cluster with node related data from user new_cluster.create(context) # retrieve cluster data cluster = get_complete_cluster(context, new_cluster.id) nodes = objects.Node.get_nodes_by_cluster_id(context, cluster.id) # create list with node id's for create cluster flow node_ids = [node.id for node in nodes] # prepare and post cluster create job to backend flow_kwargs = { 'cluster_id': cluster.id, 'node_ids': node_ids, 'user_network_id': cluster.network_id[0], 'management_network_id': CONF.management_network_id, } # generate unique erlang cookie to be used by all nodes in the new # cluster, erlang cookies are strings of up to 255 characters erlang_cookie = uuidutils.generate_uuid() job_args = { 'tenant_id': new_cluster.project_id, 'flavor': cluster.flavor, 'image': image_id, 'volume_size': cluster.volume_size, 'port': '5672', 'context': context.to_dict(), # TODO(sputnik13: this needs to come from the create request # and default to a configuration value rather than always using # config value 'security_groups': [CONF.os_security_group], 'port': CONF.rabbit_port, 'key_name': CONF.openstack.os_key_name, 'erlang_cookie': erlang_cookie, 'default_rabbit_user': default_rabbit_user, 'default_rabbit_pass': default_rabbit_pass, } job_client = task_flow_client.get_client_instance() # TODO(dagnello): might be better to use request_id for job_uuid job_uuid = uuidutils.generate_uuid() job_client.post(create_cluster, job_args, flow_kwargs=flow_kwargs, tx_uuid=job_uuid) LOG.info( _LI('Create Cluster Request Cluster ID %(cluster_id)s ' 'Cluster size %(size)s network ID %(network_id)s ' 'Job ID %(job_id)s Broker name %(broker_name)s') % ({ "cluster_id": cluster.id, "size": cluster.size, "network_id": cluster.network_id, "job_id": job_uuid, "broker_name": broker_name })) cluster.additional_information = [] cluster.additional_information.append( dict(def_rabbit_user=default_rabbit_user)) cluster.additional_information.append( dict(def_rabbit_pass=default_rabbit_pass)) cluster.unset_empty_fields() return cluster
def setUp(self): super(ApiTaskFlowClientTest, self).setUp() self.tf_client = tf_client.get_client_instance()