def on_connection_error(self, connection, msg):
oldhost = self.__get_whole_host_name()
time_passed = datetime.datetime.now() - self.__start_connect_time
time_passed_seconds = time_passed.total_seconds()
logerror(
LOGGER,
'Could not connect to %s: "%s" (connection failure after %s seconds)',
oldhost, msg, time_passed_seconds)
self.__store_connection_error_info(msg, oldhost)
# If there was a force-finish, we do not reconnect.
if self.statemachine.is_FORCE_FINISHED():
errormsg = 'Permanently failed to connect to RabbitMQ.'
if self.statemachine.detail_asked_to_gently_close_by_publisher:
errormsg += ' Tried all hosts until was force-closed by user.'
elif self.statemachine.detail_asked_to_force_close_by_publisher:
errormsg += ' Tried all hosts until a user close-down forced us to give up (e.g. the maximum waiting time was reached).'
errormsg += ' Giving up. No PID requests will be sent.'
self.__give_up_reconnecting_and_raise_exception(errormsg)
# If there is alternative URLs, try one of them:
if self.__node_manager.has_more_urls():
logdebug(LOGGER,
'Connection failure: %s fallback URLs left to try.',
self.__node_manager.get_num_left_urls())
self.__node_manager.set_next_host()
newhost = self.__get_whole_host_name()
loginfo(LOGGER,
'Connection failure: Trying to connect (now) to %s.',
newhost)
reopen_seconds = 0
self.__wait_and_trigger_reconnection(connection, reopen_seconds)
# If there is no URLs, reset the node manager to
# start at the first nodes again...
else:
self.__reconnect_counter += 1
if self.__reconnect_counter <= self.__max_reconnection_tries:
reopen_seconds = self.__wait_seconds_before_reconnect
logdebug(
LOGGER,
'Connection failure: Failed connecting to all hosts. Waiting %s seconds and starting over.',
reopen_seconds)
self.__node_manager.reset_nodes()
newhost = self.__node_manager.get_connection_parameters().host
loginfo(
LOGGER,
'Connection failure: Trying to connect (in %s seconds) to %s.',
reopen_seconds, newhost)
self.__wait_and_trigger_reconnection(connection,
reopen_seconds)
# Give up after so many tries...
else:
errormsg = (
'Permanently failed to connect to RabbitMQ. Tried all hosts %s times. Giving up. No PID requests will be sent.'
% (self.__max_reconnection_tries + 1))
self.__give_up_reconnecting_and_raise_exception(errormsg)
def make_data_cart_pid(self, dict_of_drs_ids_and_pids):
logdebug(LOGGER, 'Making a PID for a data cart full of datasets...')
# Check arg
if not type(dict_of_drs_ids_and_pids) == type(dict()):
if type(dict_of_drs_ids_and_pids) == type([]):
raise esgfpid.exceptions.ArgumentError(
'Please provide a dictionary of dataset ids and handles, not a list'
)
else:
raise esgfpid.exceptions.ArgumentError(
'Please provide a dictionary of dataset ids and handles')
# Make a pid (hash on the content):
cart_handle = DataCartAssistant._get_handle_string_for_datacart(
dict_of_drs_ids_and_pids, self.__prefix)
# Make and send message
message = self.__make_message(cart_handle, dict_of_drs_ids_and_pids)
self.__send_message_to_queue(message)
# Return pid
logdebug(LOGGER,
'Making a PID for a data cart full of datasets... done.')
loginfo(LOGGER, 'Requesting to create PID for data cart (%s).',
cart_handle)
return cart_handle
def on_message_not_accepted(self, channel, returned_frame, props, body):
# Messages that are returned are confirmed anyways.
# If we sent 20 messages that are returned, all 20 are acked,
# so we do not need to retrieve them from the unconfirmed
# messages after resending.
# In the end, we'll have published 40 messages and received 40 acks.
# Logging...
logtrace(
LOGGER, 'Return frame: %s', returned_frame
) # <Basic.Return(['exchange=rabbitsender_integration_tests', 'reply_code=312', 'reply_text=NO_ROUTE', 'routing_key=cmip6.publisher.HASH.cart.datasets'])>
logtrace(
LOGGER, 'Return props: %s', props
) # <BasicProperties(['content_type=application/json', 'delivery_mode=2'])>
logtrace(LOGGER, 'Return body: %s', body)
# Was it the first or second time it comes back?
if returned_frame.reply_text == 'NO_ROUTE':
loginfo(
LOGGER,
'The message was returned because it could not be assigned to any queue. No binding for routing key "%s".',
returned_frame.routing_key)
if returned_frame.routing_key.startswith(
esgfpid.utils.RABBIT_EMERGENCY_ROUTING_KEY):
self.__log_about_double_return(returned_frame, body)
else:
self.__resend_message(returned_frame, props, body)
else:
logerror(
LOGGER,
'The message was returned. Routing key: %s. Unknown reason: %s',
returned_frame.routing_key, returned_frame.reply_text)
self.__resend_message(returned_frame, props, body)
def get_routing_key_and_string_message_from_message_if_possible(msg):
# Try to convert message to json:
json_ok = False
msg_json = None
msg_string = None
if msg is None:
raise ValueError('The message that was passed is None.')
# Get JSON from message, if possible!
if isinstance(msg, basestring):
try:
# Valid string message --> JSON
msg_string = msg
msg_json = json.loads(msg)
json_ok = True
logdebug(LOGGER, 'Message was transformed to json.')
except ValueError as e:
# Invalid string message
loginfo(LOGGER, 'Message seems to be invalid json: %s', msg)
msg_string = str(msg)
json_ok = False
else:
try:
# Message is json already.
msg_string = json.dumps(msg)
msg_json = msg
json_ok = True
logtrace(LOGGER, 'Message was already json.')
except TypeError as e:
if 'not JSON serializable' in e.message:
# Message was whatever.
msg_string = str(msg)
json_ok = False
msg = (
'Message was neither JSON nor string and not understandable: %s'
% msg_string)
loginfo(LOGGER, msg)
raise ValueError(msg)
# If we succeeded, try to get routing key:
routing_key = None
if json_ok:
try:
routing_key = msg_json['ROUTING_KEY']
logtrace(LOGGER, 'Routing key extracted from message.')
except (KeyError, TypeError) as e:
logdebug(LOGGER, 'No routing key in message.')
routing_key = esgfpid.defaults.RABBIT_DEFAULT_ROUTING_KEY
pass # There is no routing key in the message
else:
routing_key = esgfpid.defaults.RABBIT_DEFAULT_ROUTING_KEY
return routing_key, msg_string
def __log_previously_stored_files_found(self):
concat_files = ', '.join(self.__list_of_previous_files)
type_files = type(self.__list_of_previous_files)
logdebug(LOGGER, 'Previously published fileset: %s (%s)', concat_files,
type_files)
loginfo(
LOGGER,
'Data integrity check will be run after files were specified.')
def __close_because_all_done(self, iteration):
logdebug(
LOGGER,
'Gentle finish (iteration %i): All messages sent and confirmed in %ith try (waited and rechecked %i times).',
self.__close_decision_iterations, iteration, iteration - 1)
loginfo(LOGGER, 'All messages sent and confirmed. Closing.')
self.__normal_finish()
self.__tell_publisher_to_stop_waiting_for_gentle_finish()
def __inform_about_state_at_shutdown(self):
unsent = self.thread.get_num_unpublished()
unconfirmed = self.thread.get_num_unconfirmed()
if unsent + unconfirmed > 0:
logwarn(LOGGER,
'At close down: %i pending messages (%i unpublished messages, %i unconfirmed messages).',
(unsent+unconfirmed), unsent, unconfirmed)
else:
loginfo(LOGGER, 'After close down: All messages were published and confirmed.')
def __init__(self, nodemanager):
loginfo(LOGGER, 'Init of SynchronousRabbitConnector!!! Bla')
'''
NodeManager provices info about all
hosts.
'''
self.__nodemanager = nodemanager
'''
Props for basic_publish. Does not
depend on host, so store it once for all.
'''
self.__props = self.__nodemanager.get_properties_for_message_publications(
)
'''
To count how many times we have tried to reconnect the set of
RabbitMQ hosts.
'''
self.__reconnect_counter = 0
'''
To see how many times we should try reconnecting to the set
of RabbitMQ hosts. Note that if there is 3 hosts, and we try 2
times, this means 6 connection tries in total.
'''
self.__max_reconnection_tries = defaults.RABBIT_RECONNECTION_MAX_TRIES
'''
How many seconds to wait before reconnecting after having tried
all hosts. (There is no waiting time trying to connect to a different
host after one fails).
'''
self.__wait_seconds_before_reconnect = defaults.RABBIT_RECONNECTION_SECONDS
'''
To see how much time it takes to connect. Once a connection is
established or failed, we print the time delta to logs.
'''
self.__start_connect_time = None
'''
If the messages should not be published to the exchange that
was passed from the publisher in config, but to a fallback
solution, this will be set:
'''
self.__fallback_exchange = None
''' Set of all tried hosts, for logging. '''
self.__all_hosts_that_were_tried = set()
# Defaults:
self.__mandatory_flag = esgfpid.defaults.RABBIT_MANDATORY_DELIVERY
self.__max_tries = esgfpid.defaults.RABBIT_SYN_MESSAGE_MAX_TRIES
self.__timeout_milliseconds = esgfpid.defaults.RABBIT_SYN_MESSAGE_TIMEOUT_MILLISEC
self.__candidate_fallback_exchange_name = defaults.RABBIT_FALLBACK_EXCHANGE_NAME
# Other settings:
self.__channel = None
self.__connection = None
self.__communication_established = False
self.__connection_last_process_event_call = 0
self.__error_messages_during_init = []
def __wait_and_trigger_reconnection(self, connection, wait_seconds):
if self.statemachine.is_FORCE_FINISHED():
errormsg = 'Permanently failed to connect to RabbitMQ. Tried all hosts until received a force-finish. Giving up. No PID requests will be sent.'
self.__give_up_reconnecting_and_raise_exception(errormsg)
else:
self.statemachine.set_to_waiting_to_be_available()
loginfo(LOGGER, 'Trying to reconnect to RabbitMQ in %s seconds.',
wait_seconds)
connection.add_timeout(wait_seconds, self.reconnect)
logtrace(LOGGER,
'Reconnect event added to connection %s (not to %s)',
connection, self.thread._connection)
def __please_open_connection(self):
params = self.__node_manager.get_connection_parameters()
self.__start_connect_time = datetime.datetime.now()
logdebug(LOGGER, 'Connecting to RabbitMQ at %s... (%s)', params.host,
get_now_utc_as_formatted_string())
loginfo(LOGGER, 'Opening connection to RabbitMQ...')
self.thread._connection = pika.SelectConnection(
parameters=params,
on_open_callback=self.on_connection_open,
on_open_error_callback=self.on_connection_error,
on_close_callback=self.on_connection_closed,
stop_ioloop_on_close=False # why? see below.
)
def remove_errata_ids(self, **args):
logdebug(LOGGER, 'Removing errata ids...')
mandatory_args = ['drs_id', 'version_number', 'errata_ids']
esgfpid.utils.check_presence_of_mandatory_args(args, mandatory_args)
esgfpid.utils.check_noneness_of_mandatory_args(args, mandatory_args)
dataset_handle = self.__get_dataset_handle(args)
errata_ids = self.__get_errata_ids_as_list(args)
message = self.__make_remove_message(errata_ids, dataset_handle, args['drs_id'], args['version_number'])
self.__send_message_to_queue(message)
loginfo(LOGGER, 'Requesting to remove errata ids "%s" from dataset "%s".', ', '.join(errata_ids), dataset_handle)
logdebug(LOGGER, 'Removing errata ids... done')
def __please_open_connection(self):
params = self.__node_manager.get_connection_parameters()
self.__start_connect_time = datetime.datetime.now()
logdebug(LOGGER, 'Connecting to RabbitMQ at %s... (%s)', params.host,
get_now_utc_as_formatted_string())
loginfo(LOGGER, 'Opening connection to RabbitMQ...')
self.thread._connection = pika.SelectConnection(
parameters=params,
on_open_callback=self.on_connection_open,
on_open_error_callback=self.on_connection_error,
on_close_callback=self.on_connection_closed
# Removed parameter, see https://github.com/pika/pika/issues/961
)
def __join_and_rescue(self):
success = self.__join()
if success:
self.__rescue_leftovers()
else:
for i in xrange(10):
time.sleep(1) # blocking
loginfo(LOGGER, 'Joining the thread failed once... Retrying.')
self.__thread.add_event_force_finish()
success = self.__join()
if success:
self.__rescue_leftovers()
else:
logerror(LOGGER, 'Joining failed again. No idea why.')
def __react_on_ack(self, deliv_tag, multiple):
if self.__first_confirm_receival:
self.__first_confirm_receival = False
loginfo(LOGGER,
'Received first message confirmation from RabbitMQ.')
if multiple:
logtrace(
LOGGER,
'Received "ACK" for multiple messages from messaging service.')
self.__react_on_multiple_delivery_ack(deliv_tag)
else:
logtrace(
LOGGER,
'Received "ACK" for single message from messaging service.')
self.__react_on_single_delivery_ack(deliv_tag)
def __postparations_after_successful_feeding(self, msg):
# Pass the successfully published message and its delivery_number
# to the confirmer module, to wait for its confirmation.
# Increase the delivery number for the next message.
self.thread.put_to_unconfirmed_delivery_tags(self.__delivery_number)
self.thread.put_to_unconfirmed_messages_dict(self.__delivery_number, msg)
self.__delivery_number += 1
# Logging
self.__logcounter_success += 1
log_every_x_times(LOGGER, self.__logcounter_success, self.__LOGFREQUENCY, 'Actual publish to channel done (trigger no. %i, publish no. %i).', self.__logcounter_trigger, self.__logcounter_success)
logtrace(LOGGER, 'Publishing messages %i to RabbitMQ... done.', self.__delivery_number-1)
if (self.__delivery_number-1 == 1):
loginfo(LOGGER, 'First message published to RabbitMQ.')
logdebug(LOGGER, 'Message published (no. %i)', self.__delivery_number-1)
def on_connection_open(self, unused_connection):
logdebug(LOGGER, 'Opening connection... done.')
loginfo(LOGGER, 'Connection to RabbitMQ at %s opened... (%s)',
self.__node_manager.get_connection_parameters().host,
get_now_utc_as_formatted_string())
# Tell the main thread we're open for events now:
# When the connection is open, the thread is ready to accept events.
# Note: It was already ready when the connection object was created,
# not just now that it's actually open. There was already a call to
# "...stop_waiting..." in start_waiting_for_events(), which quite
# certainly was carried out before this callback. So this call to
# "...stop_waiting..." is likelily redundant!
self.thread.tell_publisher_to_stop_waiting_for_thread_to_accept_events(
)
self.__please_open_rabbit_channel()
def make_permanently_closed_by_user(self):
# This changes the state of the state machine!
# This needs to be called from the shutter module
# in case there is a force_finish while the connection
# is already closed (as the callback on_connection_closed
# is not called then).
self.statemachine.set_to_permanently_unavailable()
logtrace(LOGGER, 'Stop waiting for events due to user interrupt!')
logtrace(LOGGER,
'Permanent close: Stopping ioloop of connection %s...',
self.thread._connection)
self.thread._connection.ioloop.stop()
loginfo(LOGGER, 'Stopped listening for RabbitMQ events (%s).',
get_now_utc_as_formatted_string())
logdebug(
LOGGER,
'Connection to messaging service closed by user. Will not reopen.')
def dataset_publication_finished(self, ignore_exception=False):
'''
This is the "commit". It triggers the creation/update of handles.
* Check if the set of files corresponds to the previously published set (if applicable, and if solr url given, and if solr replied)
* The dataset publication message is created and sent to the queue.
* All file publication messages are sent to the queue.
'''
self.__check_if_dataset_publication_allowed_right_now()
self.__check_data_consistency(ignore_exception)
self.__coupler.start_rabbit_business() # Synchronous: Opens connection. Asynchronous: Ignored.
self.__create_and_send_dataset_publication_message_to_queue()
self.__send_existing_file_messages_to_queue()
self.__coupler.done_with_rabbit_business() # Synchronous: Closes connection. Asynchronous: Ignored.
self.__set_machine_state_to_finished()
loginfo(LOGGER, 'Requesting to publish PID for dataset "%s" (version %s) and its files at "%s" (handle %s).', self.__drs_id, self.__version_number, self.__data_node, self.__dataset_handle)
def __check_for_already_arrived_messages_and_publish_them(self):
logdebug(LOGGER,
'Checking if messages have arrived in the meantime...')
num = self.thread.get_num_unpublished()
if num > 0:
loginfo(
LOGGER,
'Ready to publish messages to RabbitMQ. %s messages are already waiting to be published.',
num)
for i in xrange(int(num * 1.1)):
self.thread.add_event_publish_message()
else:
loginfo(LOGGER, 'Ready to publish messages to RabbitMQ.')
logdebug(
LOGGER,
'Ready to publish messages to RabbitMQ. No messages waiting yet.'
)
def __check_data_consistency(self, ignore_exception):
checker = esgfpid.assistant.consistency.Checker(
coupler=self.__coupler,
drs_id=self.__drs_id,
version_number=self.__version_number,
data_node=self.__data_node
)
check_possible = checker.can_run_check()
if check_possible:
check_passed = checker.data_consistency_check(self.__list_of_file_handles)
if check_passed:
loginfo(LOGGER, 'Data consistency check passed for dataset %s.', self.__dataset_handle)
else:
msg = 'Dataset consistency check failed'
logwarn(LOGGER, msg)
if not ignore_exception:
raise esgfpid.exceptions.InconsistentFilesetException(msg)
else:
logdebug(LOGGER, 'No consistency check was carried out.')
def __wait_and_trigger_reconnection(self, connection, wait_seconds):
if self.statemachine.is_FORCE_FINISHED():
# TODO This is the same code as above. Make a give_up function from it?
#self.statemachine.set_to_permanently_unavailable()
#self.statemachine.detail_could_not_connect = True
#max_tries = defaults.RABBIT_RECONNECTION_MAX_TRIES
errormsg = (
'Permanently failed to connect to RabbitMQ. Tried all hosts %s until received a force-finish. Giving up. No PID requests will be sent.'
% list(self.__all_hosts_that_were_tried))
logerror(LOGGER, errormsg)
raise PIDServerException(errormsg)
else:
self.statemachine.set_to_waiting_to_be_available()
loginfo(LOGGER, 'Trying to reconnect to RabbitMQ in %s seconds.',
wait_seconds)
connection.add_timeout(wait_seconds, self.reconnect)
logtrace(LOGGER,
'Reconnect event added to connection %s (not to %s)',
connection, self.thread._connection)
def __finish_gently(self):
# Called directly from outside the thread!
#self.statemachine.asked_to_closed_by_publisher = True # TODO
# Make sure no more messages are accepted from publisher # TODO
# while publishes/confirms are still accepted:
#if self.statemachine.is_available_for_client_publishes():
# self.statemachine.set_to_wanting_to_stop()
# Inform user
if self.__are_any_messages_pending():
wait_seconds = defaults.RABBIT_ASYN_FINISH_WAIT_SECONDS
max_waits = defaults.RABBIT_ASYN_FINISH_MAX_TRIES
loginfo(LOGGER, 'Preparing to close PID module. Some messages are pending. Maximum waiting time: %i seconds. (%s)', wait_seconds*max_waits, get_now_utc_as_formatted_string())
else:
loginfo(LOGGER, 'Closing PID module. No pending messages. (%s)', get_now_utc_as_formatted_string())
# Go through decision tree (close or wait for pending messages)
self.__close_decision_iterations = 1
self.__is_in_process_of_gently_closing = True
self.recursive_decision_about_closing()
def on_connection_closed(self, connection, exception):
# From the docs: The exception will either be an instance of
# exceptions.ConnectionClosed if a fully-open connection was closed
# by user or broker or exception of another type (...)
if isinstance(exception, pika.exceptions.ConnectionClosed):
reply_code = exception.reply_code
reply_text = exception.reply_text
else:
# TODO Not sure when this might happen, could not reproduce.
reply_code = -1
reply_text = str(exception)
loginfo(LOGGER, 'Connection to RabbitMQ was closed. Reason: %s.',
reply_text)
self.thread._channel = None
if self.__was_user_shutdown(reply_code, reply_text):
loginfo(LOGGER, 'Connection to %s closed.',
self.__node_manager.get_connection_parameters().host)
self.make_permanently_closed_by_user()
elif self.__was_permanent_error(reply_code, reply_text):
loginfo(LOGGER, 'Connection to %s closed.',
self.__node_manager.get_connection_parameters().host)
self.__make_permanently_closed_by_error(connection, reply_text)
else:
# This reconnects to next host:
self.on_connection_error(connection, reply_text)
def __have_we_waited_enough_now(self, iteration):
logdebug(LOGGER, 'Gentle finish (iteration %i): Check if the rabbit thread has waited long enough...', self.__close_decision_iterations)
wait_seconds = defaults.RABBIT_ASYN_FINISH_WAIT_SECONDS
max_waits = defaults.RABBIT_ASYN_FINISH_MAX_TRIES
tried = iteration
waited = iteration-1
# Logging:
logdebug(LOGGER, 'Gentle finish (iteration %i): At this point we have tried %i times and waited %i/%i times (%i seconds)', self.__close_decision_iterations, tried, waited, max_waits, waited*wait_seconds)
log_every_x_seconds = 2
if ((waited*wait_seconds)%log_every_x_seconds==0 or waited>=max_waits):
msg = self.__get_string_about_pending_messages()
loginfo(LOGGER, 'Still pending: %s messages... (waited %.1f/%.1f seconds)', msg, waited*wait_seconds, max_waits*wait_seconds)
# Return:
if waited >= max_waits:
logdebug(LOGGER, 'Gentle finish (iteration %i): The rabbit thread has waited long enough for pending messages at close down.', self.__close_decision_iterations)
return True
logdebug(LOGGER, 'Gentle finish (iteration %i): We should wait a little more for pending messages.', self.__close_decision_iterations)
return False
def __finish_gently(self):
# Called directly from outside the thread!
# No more messages can arrive from publisher (because
# the main thread blocks), but publishes/confirms are still
# accepted.
# Inform user
if self.__are_any_messages_pending():
wait_seconds = defaults.RABBIT_ASYN_FINISH_WAIT_SECONDS
max_waits = defaults.RABBIT_ASYN_FINISH_MAX_TRIES
loginfo(
LOGGER,
'Preparing to close PID module. Some messages are pending. Maximum waiting time: %i seconds. (%s)',
wait_seconds * max_waits, get_now_utc_as_formatted_string())
else:
loginfo(LOGGER, 'Closing PID module. No pending messages. (%s)',
get_now_utc_as_formatted_string())
# Go through decision tree (close or wait for pending messages)
self.__close_decision_iterations = 1
self.__is_in_process_of_gently_closing = True
self.recursive_decision_about_closing()
def make_permanently_closed_by_error(self, connection, reply_text):
# This changes the state of the state machine!
# This needs to be called if there is a permanent
# error and we don't want the library to reonnect,
# and we also don't want to pretend it was closed
# by the user.
# This is really rarely needed.
self.statemachine.set_to_permanently_unavailable()
logtrace(LOGGER, 'Stop waiting for events due to permanent error!')
# In case the main thread was waiting for any synchronization event.
self.thread.unblock_events()
# Close ioloop, which blocks the thread.
logdebug(LOGGER,
'Permanent close: Stopping ioloop of connection %s...',
self.thread._connection)
self.thread._connection.ioloop.stop()
loginfo(LOGGER, 'Stopped listening for RabbitMQ events (%s).',
get_now_utc_as_formatted_string())
logdebug(
LOGGER,
'Connection to messaging service closed because of error. Will not reopen. Reason: %s',
reply_text)
def unpublish_all_dataset_versions(self):
# If solr is switched off, consumer must find versions:
if self._coupler.is_solr_switched_off():
self.__unpublish_allversions_consumer_must_find_versions()
# Get handles or version numbers from solr:
else:
all_handles_or_versionnumbers = self.__get_all_handles_or_versionnumbers()
all_handles = all_handles_or_versionnumbers['dataset_handles']
all_version_numbers = all_handles_or_versionnumbers['version_numbers']
# If we can have all versions' handles, it's easy.
if all_handles is not None:
self.__unpublish_all_dataset_versions_by_handle(all_handles)
# If not, we have the version numbers (and can make the handles from them):
elif all_version_numbers is not None:
self.__unpublish_all_dataset_versions_by_version(all_version_numbers)
# If neither, let the consumer find them
else:
self.__unpublish_allversions_consumer_must_find_versions()
loginfo(LOGGER, 'Requesting to unpublish all versions of dataset %s from %s', self._drs_id, self._data_node)
def on_connection_closed(self, connection, reply_code, reply_text):
loginfo(LOGGER, 'Connection to RabbitMQ was closed. Reason: %s.',
reply_text)
self.thread._channel = None
if self.__was_user_shutdown(reply_code, reply_text):
loginfo(LOGGER, 'Connection to %s closed.',
self.__node_manager.get_connection_parameters().host)
self.make_permanently_closed_by_user()
elif self.__was_permanent_error(reply_code, reply_text):
loginfo(LOGGER, 'Connection to %s closed.',
self.__node_manager.get_connection_parameters().host)
self.__make_permanently_closed_by_error(connection, reply_text)
else:
# This reconnects to next host_
self.on_connection_error(connection, reply_text)
def on_connection_closed(self, connection, reply_code, reply_text):
loginfo(LOGGER, 'Connection to RabbitMQ was closed. Reason: %s.',
reply_text)
self.thread._channel = None
if self.__was_user_shutdown(reply_code, reply_text):
loginfo(LOGGER, 'Connection to %s closed.',
self.__node_manager.get_connection_parameters().host)
self.make_permanently_closed_by_user()
elif self.__was_permanent_error(reply_code, reply_text):
loginfo(LOGGER, 'Connection to %s closed.',
self.__node_manager.get_connection_parameters().host)
self.make_permanently_closed_by_error(connection, reply_text)
else:
#reopen_seconds = defaults.RABBIT_RECONNECTION_SECONDS
#self.__wait_and_trigger_reconnection(connection, reopen_seconds)
self.on_connection_error(connection, reply_text)
def unpublish_one_dataset_version(self, **args):
optional_args = ['dataset_handle', 'version_number']
esgfpid.utils.add_missing_optional_args_with_value_none(args, optional_args)
handle = args['dataset_handle']
version_number = args['version_number']
if handle and version_number:
self.__both_given(handle, version_number)
loginfo(LOGGER, 'Requesting to unpublish version %s of dataset %s from %s (handle: %s).', version_number, self._drs_id, self._data_node, handle)
elif handle:
self.__only_handle_given(handle)
loginfo(LOGGER, 'Requesting to unpublish a version of dataset %s from %s (handle: %s).', self._drs_id, self._data_node, handle)
elif version_number:
self.__only_version_given(version_number)
loginfo(LOGGER, 'Requesting to unpublish version %s of dataset %s from %s.', version_number, self._drs_id, self._data_node)
else:
msg = 'Neither a handle nor a version number were specified for unpublication!'
raise esgfpid.exceptions.ArgumentError(msg)
