def search_by_ip(ip): if request.method == 'GET': try: manage_paths = MangePathAssignment() logger.info("get object from MangePathAssignment.") show_list = manage_paths.search_by_ip(ip) logger.info("call search by ip function.") return show_list.write_json() except Exception as e: logger.error(e) return -1
def auto_assign_paths(type): if request.method == 'POST': try: manage_path_assignment = MangePathAssignment() logger.info("get object from MangePathAssignment.") manage_path_assignment.auto(int(type)) logger.info("call auto function.") # session['success'] = "ui_admin_disks_paths_assignment_list_success" logger.info("set success message and will redirect to paths list.") return redirect(url_for('disk_controller.paths_list')) except Exception as e: # session['err'] = "ui_admin_disks_paths_assignment_list_fail" logger.error(e)
def path_host(args): logger.info("Reassignment paths script invoked to run clean action.") if MangePathAssignment().clean_source_node(args.ip, args.disk_id): print "0" return print "-1"
def get_assignments_status(): """ DOCSTRING : this function is called to delete a certain pool , then redirect to the page : 'admin/disk/path_assignment_list.html'. Args : none Returns : redirect to the page : list of all disks status """ if request.method == 'GET': try: manage_paths = MangePathAssignment() logger.info("get object from MangePathAssignment.") show_list = manage_paths.get_assignments_stats() logger.info("call get assignments stats function.") return show_list.write_json() except Exception as e: logger.error(e) return -1
def server(args): try: logger.info("Reassignment paths script invoked to run process action.") MangePathAssignment().process() except Exception as ex: logger.error("error process reassignments actions.") logger.exception(ex.message) print(-1) sys.exit(-1)
def manual_assign_paths(): if request.method == 'POST': try: selected_paths = request.form.getlist('option_path[]') selected_paths_lst = [str(x) for x in selected_paths] paths_assign_info_lst = [] logger.info("User starts manual assignments.") for path in selected_paths_lst: selected_paths_assign_info = path.split('##') paths_assign_info = PathAssignmentInfo() paths_assign_info.node = selected_paths_assign_info[0] paths_assign_info.disk_name = selected_paths_assign_info[1] paths_assign_info.ip = selected_paths_assign_info[2] paths_assign_info.disk_id = selected_paths_assign_info[3] paths_assign_info_lst.append(paths_assign_info) logger.info("User selected path {} {} {}.".format( paths_assign_info.disk_id, paths_assign_info.disk_name, paths_assign_info.node)) assign_to = request.form.get('assign_to') manage_path_assignment = MangePathAssignment() if assign_to == "auto": logger.info("User selected auto option in manual assignment.") manage_path_assignment.manual(paths_assign_info_lst) logger.info("System started auto assignments.") # pass else: logger.info("User selected manual option in assignment.") manage_path_assignment.manual(paths_assign_info_lst, assign_to) logger.info("System started manual assignments.") session['success'] = "ui_admin_disks_paths_assignment_list_success" return redirect(url_for('disk_controller.paths_list')) except Exception as e: session['err'] = "ui_admin_disks_paths_assignment_list_fail" logger.error(e)
def __acquire_path(self, path, consul_kv): if self.__ignored_acquire_paths.get(path): logger.info("Ignore forced path {}".format(path)) return logger.debug("Start acquire path {} by node session {}.".format( path, self.__session)) consul_api = ConsulAPI() ceph_api = CephAPI() lio_api = LioAPI() network_api = NetworkAPI() config = configuration() try: disk_id, path_index = str(path).split("/") pool = self._get_pool_by_disk(disk_id) if not pool: logger.error('Could not find pool for disk ' + disk_id) return image_name = self.__image_name_prefix + disk_id logger.debug( "Start read image meta for acquire path {}.".format(path)) all_image_meta = ceph_api.read_image_metadata(image_name, pool) petasan_meta = all_image_meta.get( self.__app_conf.get_image_meta_key()) disk_meta = DiskMeta() disk_meta.load_json(petasan_meta) logger.debug( "End read image meta for acquire path {}.".format(path)) logger.debug("Try to acquire path {}.".format(path)) node_name = config.get_node_name() result = consul_api.lock_disk_path( self.__app_conf.get_consul_disks_path() + path, self.__session, node_name, str(consul_kv.CreateIndex)) if not result: logger.info("Could not lock path {} with session {}.".format( path, self.__session)) elif result: if consul_kv.Value != None and len(str( consul_kv.Value)) > 0 and node_name != str( consul_kv.Value): logger.info("The path {} was locked by {}.".format( path, str(consul_kv.Value))) logger.debug("Node {} will kill node {}.".format( config.get_node_name(), str(consul_kv.Value))) self.__fencing(str(consul_kv.Value)) # we locked it if disk_meta.paths: # if lio has the image name in its backstore already, do not perform rbd mapping if image_name not in self.__backstore: status = ceph_api.map_iamge(image_name, pool) else: status = Status.done if Status.done == status: # Get path info from metadata path_obj = disk_meta.get_paths()[int(path_index) - 1] # add path ips to our network interfaces network_api.add_ip(path_obj.ip, path_obj.subnet_mask, path_obj.eth, path_obj.vlan_id) #update neighbors arp table network_api.update_neighbors_arp( path_obj.ip, path_obj.eth) # add new target in lio if not there already if not lio_api.is_backstore_image_found(image_name): # Give ceph map image complete it job sleep(3) # Add rbd backstores and target status = lio_api.add_target( disk_meta, disk_meta.pool) """ wwn = self.calculate_disk_wwn(disk_meta) status = lio_api.add_target(disk_meta, wwn, disk_meta.pool) """ if Status.done == status: # enable the path we locked to true self.__last_acquire_succeeded = True lio_api.enable_path(disk_meta.iqn, path_index, True) logger.info("Path %s acquired successfully" % path) if self.__acquire_warning_counter > 2: logger.info( "PetaSAN finally succeeded to acquire path after retrying {} times." .format(self.__acquire_warning_counter)) self.__acquire_warning_counter = 0 path_assignment_info = self.__force_acquire_paths.get( path) if path_assignment_info: MangePathAssignment().update_path( path_obj.ip, ReassignPathStatus.succeeded) else: path_assignment_info = self.__force_acquire_paths.get( path) if path_assignment_info: logger.info( "Acquired forced path {}".format(path)) MangePathAssignment().update_path( path_obj.ip, ReassignPathStatus.failed) self.__last_acquire_succeeded = False if self.__acquire_warning_counter > 2: logger.warning( "PetaSAN failed to acquire path after {} times." .format(self.__acquire_warning_counter)) self.__acquire_warning_counter += 1 logger.error("Error could not acquire path %s" % path) else: self.__unlock_consul_path(path) except Exception as e: logger.info("---------------------------------") logger.error(str(e.message) + "\n") logger.exception(e) if str(e.message).find("invalid session") > -1: logger.error("Session is invalid") try: logger.info("Trying to create new session id") self.__session = ConsulAPI().get_new_session_ID( self.__session_name, self.__node_info.name) logger.info("New session id is {}".format(self.__session)) logger.info("Cleaning all mapped disks from old session") self.__clean() except Exception as ex: logger.exception(ex) logger.exception("Could not acquire path %s" % path) raise e logger.debug("End acquire path {}.".format(path)) return
def __read_resources_consul(self): logger.debug("Start read resources consul.") self.__paths_per_session = {} self.__total_cluster_paths = 0 unlock_kvs = set() consul_api = ConsulAPI() try: disk_kvs = consul_api.get_disk_kvs() for kv in disk_kvs: key = str(kv.Key).replace( self.__app_conf.get_consul_disks_path(), "") disk_id = str(key).split('/')[0] if disk_id in self.__disk_consul_stopped: continue if kv.Value == "disk": disk_id = str(key).split('/')[0] self.__paths_per_disk_local[disk_id] = 0 if str(kv.Flags) == "1": self.__disk_consul_stopped.add(disk_id) continue # Count paths in the cluster. self.__total_cluster_paths += 1 if hasattr(kv, "Session"): # locked paths if kv.Session == self.__session: self.__paths_consul_locked_node.add(key) disk_paths_count = self.__paths_per_disk_local.get( disk_id, 0) + 1 self.__paths_per_disk_local[disk_id] = disk_paths_count # Total count of paths for each session if self.__paths_per_session.has_key(kv.Session): count = self.__paths_per_session.get(kv.Session) self.__paths_per_session[kv.Session] = count + 1 else: self.__paths_per_session[kv.Session] = 1 # unlocked paths elif not hasattr(kv, "Session"): unlock_kvs.add(kv) # Filter unlocked paths reassignments = None if len(unlock_kvs) > 0: reassignments = MangePathAssignment().get_forced_paths() for kv in unlock_kvs: key = str(kv.Key).replace( self.__app_conf.get_consul_disks_path(), "") if reassignments: path_assignment_info = reassignments.get(key) if path_assignment_info and path_assignment_info.target_node == self.__node_info.name: self.__force_acquire_paths[key] = kv continue else: self.__ignored_acquire_paths[key] = kv continue disk_id = str(key).split('/')[0] if self.__paths_per_disk_local.get(disk_id, 0) > 0: self.__paths_consul_unlocked_siblings[key] = kv else: self.__paths_consul_unlocked_firstborn[key] = kv except Exception as e: logger.error("Could not read consul resources.") logger.exception(e) raise e logger.debug("End read resources consul.")