// Start begins the local Lantern discovery process
func Start(advertise bool, portToAdvertise string) {
if service != nil {
// Dev error: this service shouldn't be started unless stopped
panic("The " + messageType + " service is already registered")
return
}
var err error
service, err = ui.Register(messageType, nil, func(write func(interface{}) error) error {
// When connecting the UI we push the current peer list. For this reason, we need
// to hold this list beyond the add/remove events.
return write(buildPeersList())
})
if err != nil {
log.Errorf("Unable to register Local Discovery service: %q", err)
return
}
addOrRemoveCb := func(peer string, peersInfo []multicast.PeerInfo) {
peersMutex.Lock()
lastPeers = peersInfo
peersMutex.Unlock()
service.Out <- buildPeersList()
}
mc = multicast.JoinMulticast(addOrRemoveCb, addOrRemoveCb)
if advertise {
mc.SetPayload(portToAdvertise)
mc.StartMulticast()
}
mc.ListenPeers()
}
// start the settings service
// that synchronizes Lantern's configuration
// with every UI client
func start(baseSettings *Settings) error {
var err error
helloFn := func(write func(interface{}) error) error {
log.Debugf("Sending Lantern settings to new client")
settingsMutex.RLock()
defer settingsMutex.RUnlock()
return write(baseSettings)
}
service, err = ui.Register(messageType, nil, helloFn)
return err
}
// start the settings service that synchronizes Lantern's configuration with every UI client
func (s *Settings) start() error {
var err error
ui.PreferProxiedUI(s.SystemProxy)
helloFn := func(write func(interface{}) error) error {
log.Debugf("Sending Lantern settings to new client")
s.Lock()
defer s.Unlock()
return write(&msg{Settings: s})
}
service, err = ui.Register(messageType, nil, helloFn)
return err
}
func registerService() error {
helloFn := func(write func(interface{}) error) error {
location := GetLocation()
if location == nil {
log.Trace("No lastKnownLocation, not sending anything to client")
return nil
}
log.Trace("Sending last known location to new client")
return write(location)
}
var err error
service, err = ui.Register(messageType, nil, helloFn)
return err
}
func registerService() error {
helloFn := func(write func(interface{}) error) error {
country := GetCountry()
if country == "" {
log.Trace("No lastKnownCountry, not sending anything to client")
return nil
}
log.Trace("Sending last known location to new client")
return write(country)
}
var err error
service, err = ui.Register(messageType, nil, helloFn)
return err
}
func start() (err error) {
newMessage := func() interface{} {
return &proxiedsites.Delta{}
}
// Registering a websocket service.
helloFn := func(write func(interface{}) error) error {
return write(proxiedsites.ActiveDelta())
}
if service, err = ui.Register(messageType, newMessage, helloFn); err != nil {
return fmt.Errorf("Unable to register channel: %q", err)
}
// Initializing reader.
go read()
return nil
}
func registerService() error {
peers = make(map[string]*Peer)
helloFn := func(write func(interface{}) error) error {
log.Tracef("Writing all peers to new client")
peersMutex.RLock()
defer peersMutex.RUnlock()
for _, peer := range peers {
err := write(peerUpdate(peer))
if err != nil {
return err
}
}
return nil
}
var err error
service, err = ui.Register("Stats", nil, helloFn)
return err
}
// Used with clients to track user interaction with the UI
func StartService() error {
var err error
if service != nil {
return nil
}
newMessage := func() interface{} {
return &analytics.Payload{}
}
if service, err = ui.Register(messageType, newMessage, nil); err != nil {
log.Errorf("Unable to register analytics service: %q", err)
return err
}
stopCh = make(chan bool)
// process analytics messages
go read()
return err
}
