Send a info message
 @param message [String]
 @yield optionally set the message using a block
343293
def info(message = nil, &block)
      logger.add(Logger::INFO, message, self.logging_prefix, &block)
    end
434073
def handle_message(message, &block)
      Timeout.timeout(timeout) do
        block.call(message.body, message.topic.name)
      end
    rescue => e
      logger.error("Error handling message #{message.id}: #{e}")
      raise e
    end
983992
public void setMessage(String message) {
        requireArgument(message != null && !message.isEmpty(), "Message cannot be null or empty.");
        this.message = message;
    }
553794
def send(self, message):
        
        try:
            self.ws.send(json.dumps(message))
        except websocket._exceptions.WebSocketConnectionClosedException:
            raise SelenolWebSocketClosedException()
635748
def send(message, options = {})
      message_format = options[:message_format] ? options[:message_format] : 'text'
      notify         = options[:notify]         ? options[:notify]         : false

      response = self.class.post(@api.send_config[:url],
                                 :query => { :auth_token => @token },
                                 :body => {
                                     :message => message,
                                     :message_format => message_format,
                                     :notify => notify
                                 }.send(@api.send_config[:body_format]),
                                 :headers => @api.headers
      )
      ErrorHandler.response_code_to_exception_for :user, user_id, response
      true
    end
259081
def send_notification(self, method, *args):
        
        message = self._version.create_request(method, args, notification=True)
        self.send_message(message)
1055972
def send_notification(self, method, params):
        
        msg = self._encoder.create_notification(method, params)
        self._send_message(msg)
419340
def send_message(type, message=nil)
      message = message.nil? ? message = '' : message.to_json
      body = type + ' ' + message
      body.strip!
      length = body.bytesize
      @client.write("#{length}\n#{body}")
    end
742544
def info(message)
      indentation = verbose? ? @indentation_level : 0
      indented = wrap_string(message, indentation)
      puts(indented)

      if block_given?
        @indentation_level += 2
        @treat_titles_as_messages = true
        yield
        @treat_titles_as_messages = false
        @indentation_level -= 2
      end
    end
217893
def send_message(self, message, all_credentials):
        
        _, data, max_doc_size = self._split_message(message)
        with self.get_socket(all_credentials) as sock_info:
            sock_info.send_message(data, max_doc_size)
508436
void sendMessage(IMessage message) throws IOException, AvpDataException, NotInitializedException, ParseException {

    if (!isConnected()) {
      throw new IOException("Failed to send message over [" + socketDescription + "]");
    }

    //switch to wait for SSL handshake to workout.
    if (!isExchangeAllowed()) {
      //TODO: do more?
      return;
    }

    doTLSPreSendProcessing(message);

    final ByteBuffer messageBuffer = this.parser.encodeMessage(message);
    if (logger.isDebugEnabled()) {
      logger.debug("About to send a byte buffer of size [{}] over the TLS socket [{}]", messageBuffer.array().length, socketDescription);
    }
    lock.lock();
    try {
      this.outputStream.write(messageBuffer.array(), messageBuffer.position(), messageBuffer.limit());
      doTLSPostSendProcessing(message);

    } catch (Exception e) {
      logger.debug("Unable to send message", e);
      throw new IOException("Error while sending message: " + e);
    }
    finally {
      lock.unlock();
    }

    if (logger.isDebugEnabled()) {
      logger.debug("Sent a byte buffer of size [{}] over the TLS nio socket [{}]", messageBuffer.array().length, socketDescription);
    }
  }
1359602
def send_message(self,message):
        
        if self._state == STATE_DISCONNECTED:
            raise Exception("WAMP is currently disconnected!")
        message = message.as_str()
        logger.debug("SND>: {}".format(message))
        if not self.ws:
            raise Exception("WAMP is currently disconnected!")
        self.ws.send(message)
1263251
def mass_inform(self, msg):
        
        assert (msg.mtype == Message.INFORM)
        self._server.mass_send_message_from_thread(msg)
572121
public void setMessage(String message) {
    pushData.clear();
    Map<String, Object> map = AVUtils.createStringObjectMap("alert", message);
    pushData.put("data", map);
  }
1349659
def extract_message_information(message)
      informations = Hash[message.scan(/^(.*)=(.*)$/).map { |(key, value)| [key.to_sym, value] }]
    end
1180215
def wifi_info
      send_message!(Protocol::Device::GetWifiInfo.new,
          wait_for: Protocol::Device::StateWifiInfo) do |payload|
        {
          signal: payload.signal, # This is in Milliwatts
          tx: payload.tx,
          rx: payload.rx
        }
      end
    end
997072
def send_notification(method, params)
      data = MessagePack.dump([2, method, params]).bytes
      ws.send(data)
    rescue => exc
      warn exc
      abort exc
    end