client = mqtt.Client(client_id="myclientid",clean_session=False)

client.on_connect = on_connect
client.on_message = on_message

client.connect("localhost",1883,60)
client.loop_forever()
```

Execute this example python program to watch for MQTT events on the console.

```py
python mqtt.py
```

// Op is operation type messages.
type Op uint8

// HandlerID is the ID for the handler of a specific type.
type HandlerID uint8

const (
	// OpConnect is a connect request.
	OpConnect Op = iota + 1

	// OpConnectResponse is a response to a connect request.
	OpConnectResponse

	// OpPing is a ping request.
	// If a mux id is specified that mux is pinged.

package grid

import "strconv"

func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[OpConnect-1]
	_ = x[OpConnectResponse-2]
	_ = x[OpPing-3]
	_ = x[OpPong-4]
	_ = x[OpConnectMux-5]
	_ = x[OpMuxConnectError-6]
	_ = x[OpDisconnectClientMux-7]
	_ = x[OpDisconnectServerMux-8]
	_ = x[OpMuxClientMsg-9]

        if (body != null) {
            throw new CurlException("body method is already called.");
        }
        this.bodyStream = stream;
        return this;
    }

    public CurlRequest onConnect(final BiConsumer<CurlRequest, HttpURLConnection> connectionBuilder) {
        this.connectionBuilder = connectionBuilder;
        return this;
    }

    public CurlRequest param(final String key, final String value) {

            } else if (entry.getValue().length == 1) {
                curlRequest.param(entry.getKey(), entry.getValue()[0]);
            }
        });
        try (final CurlResponse curlResponse = curlRequest.onConnect((req, con) -> {
            con.setDoOutput(true);
            if (httpMethod != Method.GET && request.getContentLength() > 2) {

		}

		var message message
		_, _, err = message.parse(msg)
		if err != nil {
			writeErr(fmt.Errorf("error parsing grid connect: %w", err))
			return
		}
		if message.Op != OpConnect {
			writeErr(fmt.Errorf("unexpected connect op: %v", message.Op))
			return
		}
		var cReq connectReq
		_, err = cReq.UnmarshalMsg(message.Payload)
		if err != nil {

        final ObjectMapper mapper = new ObjectMapper();
        final AtomicBoolean resetJobs = new AtomicBoolean(false);
        try (CurlResponse response = ComponentUtil.getCurlHelper().post("/_bulk").onConnect((req, con) -> {
            con.setDoOutput(true);
            try (final BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(tempFile)));

			}
			c.updateState(StateConnectionError)
			time.Sleep(sleep)
		}
		if err != nil {
			retry(err)
			continue
		}
		// Send connect message.
		m := message{
			Op: OpConnect,
		}
		req := connectReq{
			Host: c.Local,
			ID:   c.id,
		}
		err = c.sendMsg(conn, m, &req)
		if err != nil {
			retry(err)
			continue
		}
		// Wait for response