Esempio n. 1
0
// Publish announces a key / value pair
func (g *Gossip) Publish(key, value string) error {
	cmd := C.CString("PUBLISH")
	defer C.free(unsafe.Pointer(cmd))

	cKey := C.CString(key)
	defer C.free(unsafe.Pointer(cKey))

	cValue := C.CString(value)
	defer C.free(unsafe.Pointer(cValue))

	rc := C.zstr_sendm(unsafe.Pointer(g.zactorT), cmd)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_sendm(unsafe.Pointer(g.zactorT), cKey)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(g.zactorT), cValue)
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 2
0
// Publish publishes an announcement at an interval
func (b *Beacon) Publish(announcement string, interval int) error {
	cmd := C.CString("PUBLISH")
	defer C.free(unsafe.Pointer(cmd))

	cAnnouncement := C.CString(announcement)
	defer C.free(unsafe.Pointer(cAnnouncement))

	cInterval := C.CString(strconv.Itoa(interval))
	defer C.free(unsafe.Pointer(cInterval))

	rc := C.zstr_sendm(unsafe.Pointer(b.zactorT), cmd)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_sendm(unsafe.Pointer(b.zactorT), cAnnouncement)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(b.zactorT), cInterval)
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 3
0
// SetBackend accepts a socket type and endpoint, and sends a message
// to the zactor thread telling it to set up a socket bound to the endpoint.
func (p *Proxy) SetBackend(sockType int, endpoint string) error {
	typeString := getStringType(sockType)

	rc := C.zstr_sendm(unsafe.Pointer(p.zactorT), C.CString("BACKEND"))
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_sendm(unsafe.Pointer(p.zactorT), C.CString(typeString))
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(p.zactorT), C.CString(endpoint))
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zsock_wait(unsafe.Pointer(p.zactorT))
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 4
0
// SetBackend accepts a socket type and endpoint, and sends a message
// to the zactor thread telling it to set up a socket bound to the endpoint.
func (p *Proxy) SetBackend(sockType int, endpoint string) error {
	typeString := getStringType(sockType)

	cmd := C.CString("BACKEND")
	defer C.free(unsafe.Pointer(cmd))

	cTypeString := C.CString(typeString)
	defer C.free(unsafe.Pointer(cTypeString))

	cEndpoint := C.CString(endpoint)
	defer C.free(unsafe.Pointer(cEndpoint))

	rc := C.zstr_sendm(unsafe.Pointer(p.zactorT), cmd)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_sendm(unsafe.Pointer(p.zactorT), cTypeString)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(p.zactorT), cEndpoint)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zsock_wait(unsafe.Pointer(p.zactorT))
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 5
0
// Verbose sets the beacon to log information to stdout.
func (b *Beacon) Verbose() error {
	rc := C.zstr_send(unsafe.Pointer(b.zactorT), C.CString("VERBOSE"))
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 6
0
// Resume sends a message to the zproxy actor telling it to resume.
func (p *Proxy) Resume() error {
	rc := C.zstr_send(unsafe.Pointer(p.zactorT), C.CString("RESUME"))
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 7
0
// Verbose sets the beacon to log information to stdout.
func (b *Beacon) Verbose() error {
	cmd := C.CString("VERBOSE")
	defer C.free(unsafe.Pointer(cmd))

	rc := C.zstr_send(unsafe.Pointer(b.zactorT), cmd)
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 8
0
// Resume sends a message to the zproxy actor telling it to resume.
func (p *Proxy) Resume() error {
	cmd := C.CString("RESUME")
	defer C.free(unsafe.Pointer(cmd))

	rc := C.zstr_send(unsafe.Pointer(p.zactorT), cmd)
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 9
0
// Verbose sets the auth actor to log information to stdout.
func (a *Auth) Verbose() error {
	cmd := C.CString("VERBOSE")
	defer C.free(unsafe.Pointer(cmd))

	rc := C.zstr_send(unsafe.Pointer(a.zactorT), cmd)
	if rc == -1 {
		return ErrActorCmd
	}
	C.zsock_wait(unsafe.Pointer(a.zactorT))

	return nil
}
Esempio n. 10
0
// SetCapture accepts a socket endpoint and sets up a Push socket bound
// to that endpoint, that sends a copy of all messages passing through
// the proxy.
func (p *Proxy) SetCapture(endpoint string) error {
	rc := C.zstr_sendm(unsafe.Pointer(p.zactorT), C.CString("CAPTURE"))
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(p.zactorT), C.CString(endpoint))
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 11
0
// Subscribe subscribes to beacons matching the filter
func (b *Beacon) Subscribe(filter string) error {
	rc := C.zstr_sendm(unsafe.Pointer(b.zactorT), C.CString("SUBSCRIBE"))
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(b.zactorT), C.CString(filter))
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 12
0
// Configure accepts a port number and configures
// the beacon, returning an address
func (b *Beacon) Configure(port int) (string, error) {
	rc := C.zstr_sendm(unsafe.Pointer(b.zactorT), C.CString("CONFIGURE"))
	if rc == -1 {
		return "", ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(b.zactorT), C.CString(strconv.Itoa(port)))
	if rc == -1 {
		return "", ErrActorCmd
	}

	Chostname := C.zstr_recv(unsafe.Pointer(b.zactorT))
	hostname := C.GoString(Chostname)
	return hostname, nil
}
Esempio n. 13
0
// Publish publishes an announcement at an interval
func (b *Beacon) Publish(announcement string, interval int) error {
	rc := C.zstr_sendm(unsafe.Pointer(b.zactorT), C.CString("PUBLISH"))
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_sendm(unsafe.Pointer(b.zactorT), C.CString(announcement))
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(b.zactorT),
		C.CString(strconv.Itoa(interval)))
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 14
0
// Connect connects the gossip service to a specified endpoint
func (g *Gossip) Connect(endpoint string) error {
	cmd := C.CString("CONNECT")
	defer C.free(unsafe.Pointer(cmd))

	cEndpoint := C.CString(endpoint)
	defer C.free(unsafe.Pointer(cEndpoint))

	rc := C.zstr_sendm(unsafe.Pointer(g.zactorT), cmd)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(g.zactorT), cEndpoint)
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 15
0
// Subscribe subscribes to beacons matching the filter
func (b *Beacon) Subscribe(filter string) error {
	cmd := C.CString("SUBSCRIBE")
	defer C.free(unsafe.Pointer(cmd))

	cFilter := C.CString(filter)
	defer C.free(unsafe.Pointer(cFilter))

	rc := C.zstr_sendm(unsafe.Pointer(b.zactorT), cmd)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(b.zactorT), cFilter)
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 16
0
// SetCapture accepts a socket endpoint and sets up a Push socket bound
// to that endpoint, that sends a copy of all messages passing through
// the proxy.
func (p *Proxy) SetCapture(endpoint string) error {
	cmd := C.CString("CAPTURE")
	defer C.free(unsafe.Pointer(cmd))

	cEndpoint := C.CString(endpoint)
	defer C.free(unsafe.Pointer(cEndpoint))

	rc := C.zstr_sendm(unsafe.Pointer(p.zactorT), cmd)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(p.zactorT), cEndpoint)
	if rc == -1 {
		return ErrActorCmd
	}

	return nil
}
Esempio n. 17
0
// Allow removes a previous Deny
func (a *Auth) Allow(address string) error {
	cmd := C.CString("ALLOW")
	defer C.free(unsafe.Pointer(cmd))

	cAddress := C.CString(address)
	defer C.free(unsafe.Pointer(cAddress))

	rc := C.zstr_sendm(unsafe.Pointer(a.zactorT), cmd)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(a.zactorT), cAddress)
	if rc == -1 {
		return ErrActorCmd
	}

	C.zsock_wait(unsafe.Pointer(a.zactorT))

	return nil
}
Esempio n. 18
0
// Plain sets auth method to plain
func (a *Auth) Plain(directory string) error {
	cmd := C.CString("PLAIN")
	defer C.free(unsafe.Pointer(cmd))

	cDirectory := C.CString(directory)
	defer C.free(unsafe.Pointer(cDirectory))

	rc := C.zstr_sendm(unsafe.Pointer(a.zactorT), cmd)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(a.zactorT), cDirectory)
	if rc == -1 {
		return ErrActorCmd
	}

	C.zsock_wait(unsafe.Pointer(a.zactorT))

	return nil
}
Esempio n. 19
0
// Curve sets auth method to curve
func (a *Auth) Curve(allowed string) error {
	cmd := C.CString("CURVE")
	defer C.free(unsafe.Pointer(cmd))

	cAllowed := C.CString(allowed)
	defer C.free(unsafe.Pointer(cAllowed))

	rc := C.zstr_sendm(unsafe.Pointer(a.zactorT), cmd)
	if rc == -1 {
		return ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(a.zactorT), cAllowed)
	if rc == -1 {
		return ErrActorCmd
	}

	C.zsock_wait(unsafe.Pointer(a.zactorT))

	return nil
}
Esempio n. 20
0
// Configure accepts a port number and configures
// the beacon, returning an address
func (b *Beacon) Configure(port int) (string, error) {
	cmd := C.CString("CONFIGURE")
	defer C.free(unsafe.Pointer(cmd))

	cPort := C.CString(strconv.Itoa(port))
	defer C.free(unsafe.Pointer(cPort))

	rc := C.zstr_sendm(unsafe.Pointer(b.zactorT), cmd)
	if rc == -1 {
		return "", ErrActorCmd
	}

	rc = C.zstr_send(unsafe.Pointer(b.zactorT), cPort)
	if rc == -1 {
		return "", ErrActorCmd
	}

	cHostname := C.zstr_recv(unsafe.Pointer(b.zactorT))
	hostname := C.GoString(cHostname)

	return hostname, nil
}