<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def tail( self, line_prefix=None, callback=None, output_callback=None, stop_callback=lambda x: False, timeout=None ):
 """ This function takes control of an SSH channel and displays line by line of output as \n is recieved. This function is specifically made for tail-like commands. :param line_prefix: Text to append to the left of each line of output. This is especially useful if you are using my MultiSSH class to run tail commands over multiple servers. :param callback: You may optionally supply a callback function which takes two paramaters. The first is the line prefix and the second is current line of output. The callback should return the string that is to be displayed (including the \n character). This allows users to grep the output or manipulate it as required. :param output_callback: A function used to print ssh output. Printed to stdout by default. A user-defined logger may be passed like output_callback=lambda m: mylog.debug(m) :param stop_callback: A function usesd to stop the tail, when function retruns True tail will stop, by default stop_callback=lambda x: False :param timeout: how much time to wait for data, default to None which mean almost forever. """


        output_callback = output_callback if output_callback else self.output_callback

        # Set the channel timeout to the maximum integer the server allows,
        # setting this to None breaks the KeyboardInterrupt exception and
        # won't allow us to Ctrl+C out of teh script
        timeout = timeout if timeout else 2 ** (struct.Struct(str('i')).size * 8 - 1) - 1
        self.channel.settimeout(timeout)

        # Create an empty line buffer and a line counter
        current_line = b''
        line_counter = 0
        line_feed_byte = '\n'.encode(self.encoding)

        # Loop forever, Ctrl+C (KeyboardInterrupt) is used to break the tail
        while True:

            # Read the output one byte at a time so we can detect \n correctly
            buffer = self.channel.recv(1)

            # If we have an empty buffer, then the SSH session has been closed
            if len(buffer) == 0:
                break

            # Add the currently read buffer to the current line output
            current_line += buffer

            # Display the last read line in realtime when we reach a \n
            # character
            if buffer == line_feed_byte:
                current_line_decoded = current_line.decode(self.encoding)
                if line_counter:
                    if callback:
                        output_callback(callback(line_prefix, current_line_decoded))
                    else:
                        if line_prefix:
                            output_callback(line_prefix)
                        output_callback(current_line_decoded)

                if stop_callback(current_line_decoded):
                    break

                line_counter += 1
                current_line = b''