mpl_client.py

from . import socket, AF_INET, SOCK_STREAM
import pickle
from . import Query, Status, Answer, Signal
from . import DBUG, WARN, SPCE, SEVR, INFO
from . import MplUnpickler

from . import D_DEBUG

debug = D_DEBUG


class MplClient():

    def __init__(self):

        self.host, self.port = (None, None)

        # just a list of names
        self.current_remotedata = []

    def connect(self, con):

        self.host, self.port = con      # give (IP,PORT)
        self.sock = socket(AF_INET, SOCK_STREAM)
        self.sock.connect(con)
        self.connected = True

    def disconnect(self):
        ''' shutdown socket. Warning:
        If server and client are local the client can not shut down
        the port because the server has still a handle on it'''
        print('closing the connection...')
        # shutdown() is meant to shut down server without wait.
        # _Warning_ enabling will cause break of program. !!!
        # self.sock.shutdown(socket.SHUT_WR)
        self.sock.close()
        self.connected = False
        print('closing the connection... DONE')

    def reset_connection(self, new_con=None):

        self.disconnect()
        if new_con is not None:
            self.connect(new_con)
        else:                         # try to use the old values
            if (self.host is not None) and (self.port is not None):
                self.connect((self.host, self.port))
            else:
                print('connection not initialized with correct values:')
                print('please provide host,port. currently host: ',
                      self.host,
                      ' , port:',
                      self.port)

    def send(self, sig):
        """ Sending a Type derived from Signal through the socket
        after 'pickling' it"""
        print('prepare sending')
        wf = self.sock.makefile(mode='wb')
        print('makefile done')
        #~ if debug:
        if isinstance(sig, Query):
            print('Client sending {sig_type}, {query_type} with content {sig_content}'.format(sig_type=type(sig), query_type=sig.query_type, sig_content=sig.content))
        else:
            print('Client sending ',
                  type(sig), 
                  ' with content \"',
                  sig.content, '\"')
        try:
            pickle.dump(sig, wf)
        except Exception:
            return False
        wf.close()
        return True

    def wait_for_signal(self):

        # wait for signal
        # unpickel

        rf = self.sock.makefile(mode='rb')
        try:
            unpickler = MplUnpickler(rf)
            response = unpickler.load()
# THIS CAN RAISE AN EXCEPTION IF DATA TOO LARGE!!
#            if debug and isinstance(response, Signal):
#                print('CLIENT Received: {} with content \"{}\"'.format(
#                    type(response), response.content))
        except EOFError:
            print('no answer received - or connection closed unexpectedly')
            response = None
        except Exception as e:
            print('unknown error while waiting for response')
            print(type(e))
            print(e)
            response = None
        rf.close()
        if isinstance(response, Signal):
            return response

    def test_status_sig(self, org_query, status_sig):

        if isinstance(status_sig, Status):
            if status_sig.value:
                if debug:
                    print('request type ',
                          org_query.query_type,
                          ' successful')
                    print(status_sig.content)
                return True
            else:
                if debug:
                    print('something went wrong on the '
                          'server side handling request type ',
                          org_query.query_type)
                    print(status_sig.content)
                return False
        else:
            print('request type ', org_query.query_type,
                  ' returned unknown status type')
            return False

    def read_data(self, io_function, data_name, *args, **kwargs):
        # create a Signal of type Query with arguments
        self.connect((self.host, self.port))

        if not isinstance(io_function, str): # in case function is given instead of string
            io_function = io_function.__name__
            print('WARNING: You gave the function object instead of the function name in cilent.read_data.')

        query = Query(Query.READDATA, {'func': io_function,
                                       'data_name': data_name,
                                       'args': args,
                                       'kwargs': kwargs})
        status = self.send(query)
        if not status:
            print('''something went wrong with the
                    sending of readData request...''')
        status_sig = self.wait_for_signal()
        self.disconnect()
        return self.test_status_sig(query, status_sig)

    def merge_data(self, merged_name, data_names):
        # create a Signal of type Query with arguments
        self.connect((self.host, self.port))
        query = Query(Query.MERGEDATA, {'merged_name': merged_name,
                                       'data_names': data_names,})
        status = self.send(query)
        if not status:
            print('''something went wrong with the
                    sending of readData request...''')
        status_sig = self.wait_for_signal()
        self.disconnect()
        return self.test_status_sig(query, status_sig)

    def list_remote_data(self):
        """ The server retuns a list with the content of its G_RAWDATA
        """
        self.connect((self.host, self.port))
        query = Query(Query.LISTDATA, None)
        status = self.send(query)
        if not status:
            print('something went wrong with the '
                  'sending of listRemoteData request...')
        answer = self.wait_for_signal()

        self.disconnect()

        if isinstance(answer, Answer):
            return answer.content
        elif isinstance(answer, Status):
            print(answer.content)
            return None

    def list_remote_fig(self):
        """ The server retuns a list with the content of its G_FIGURES
        """
        self.connect((self.host, self.port))
        query = Query(Query.LISTFIG, None)
        status = self.send(query)
        if not status:
            print('something went wrong with the '
                  'sending of listRemoteFig request...')
        answer = self.wait_for_signal()

        self.disconnect()

        if isinstance(answer, Answer):
            return answer.content
        elif isinstance(answer, Status):
            print(answer.content)
            return None

    def get_data(self, dataname):
        """ The server returns the actual data known under "dataname"
        warning: this can possibly be HUGE
        """
        self.connect((self.host, self.port))
        query = Query(Query.GETDATA, dataname)
        status = self.send(query)
        if not status:
            print('something went wrong with the '
                  'sending of readData request...')
        answer = self.wait_for_signal()

        self.disconnect()

        if isinstance(answer, Answer):
            return answer.content
        elif isinstance(answer, Status):
            print(answer.content)
            return None

    def new_sync_figure(self, figname, dataname, *args, **kwargs):
        '''
        Send a query NEWSYNCFIGURE to the server
        wait for the status.
        if status ok then sync.
        '''

        self.connect((self.host, self.port))

        # create a Signal of type Query with args
        query = Query(Query.NEWSYNCFIGURE, {
            'fig_class_came': figname.__name__,
            'data_name': dataname,
            'args': args,
            'kwargs': kwargs})
        status = self.send(query)

        if not status:
            print('something went wrong '
                  'with the sending of new_sync_figure request...')
        answer = self.wait_for_signal()

        self.disconnect()

        # try to create a figure of the same class on the client side
        if isinstance(answer, Answer):
            print('trying to create a figure of the same '
                  'class on the client side')
            fig = figname(dataname, *args, **kwargs)
            # Link the temporary Sync Figure
            fig.sync_id = answer.content
            fig.client = self
            return fig

        elif isinstance(answer, Status):
            self.test_status_sig(query, answer)
            print('>>>>>>>>>>>>>>>>>>>>>>>>>> response is not an Answer!!!')
            return None
        else:
            print('an unknown error occured')
            return None

    def update_sync_figure(self, sync_id, kwargs):
        ''' Send a UPDATE_SYNC_FIGURE query to the server.

        wait for the status
        if status ok then sync.
        '''

        self.connect((self.host, self.port))

        # create a signal with args
        query = Query(Query.UPDATESYNCFIGURE, (sync_id, kwargs))
        self.send(query)
        status_sig = self.wait_for_signal()

        self.disconnect()

        if status_sig.value:
            return True
        else:
            return False

    def delete_sync_figure(self, sync_id):
        '''
        Send a DELETESYNCFIGURE query to the server.
        If the FigID is known delete it from G_FIGURES (server)
        wait for the confirmation status
        if status ok then proceed deletion.'''

        self.connect((self.host, self.port))

        # create a signal with sync_id as content
        query = Query(Query.DELETESYNCFIGURE, sync_id)
        status = self.send(query)

        status_sig = self.wait_for_signal()

        self.disconnect()

        if status and status_sig.value:
            return True
        else:
            print('The remote figure could not be deleted')
            print(status_sig.content)
            return False

    # SYNC FIGURE FORMAT RAWDATA ---------------------------------------
    def sync_fig_format_rawdata(self, sync_id):
        ''' Send a FORMAT_SYNC_FIGURE query to the server.
        wait for the answer
        if answer not empty then set data to answer's value.'''

        self.connect((self.host, self.port))

        # Send the signal with sync_id as content
        signal = Query(Query.SYNCFIGFORMATRAWDATA, sync_id)
        status = self.send(signal)

        if debug:
            if not status:
                print(INFO + 'Sent Signal')

        formated_data = self.wait_for_signal()

        self.disconnect()

        if not isinstance(formated_data, Answer):
            print(WARN + 'The server could not format the rawdata.')

            if isinstance(formated_data, Status):
                if formated_data.value:
                    print('WARNING: This should not happen...')
                    print('Client recieved an Error with success status (True):')

                else:
                    print('instead of answer an error was received:')

                # Print error message
                print(str(formated_data.content))
                
            datas = None

        else:
            # set the figure data to answerSig.value
            datas = formated_data.content
        return datas