cwtch/peer/connections/peerpeerconnection.go

package connections

import (
	"git.mascherari.press/cwtch/peer/peer"
	"git.mascherari.press/cwtch/protocol"
	"github.com/s-rah/go-ricochet"
	"github.com/s-rah/go-ricochet/channels"
	"github.com/s-rah/go-ricochet/connection"
	"github.com/s-rah/go-ricochet/identity"
	//"github.com/s-rah/go-ricochet/utils"
	"git.mascherari.press/cwtch/model"
	"time"
)

type PeerPeerConnection struct {
	connection.AutoConnectionHandler
	PeerHostname string
	state        ConnectionState
	connection   connection.Connection
	profile      *model.Profile
}

func NewPeerPeerConnection(peerhostname string, profile *model.Profile) *PeerPeerConnection {
	ppc := new(PeerPeerConnection)
	ppc.PeerHostname = peerhostname
	ppc.profile = profile
	ppc.Init()
	return ppc
}

// GetState returns the current connection state
func (ppc *PeerPeerConnection) GetState() ConnectionState {
	return ppc.state
}

func (ppc *PeerPeerConnection) ClientIdentity(ci *protocol.CwtchIdentity) {
	ppc.profile.AddCwtchIdentity(ppc.PeerHostname, ci)
}

func (ppc *PeerPeerConnection) HandleGroupInvite(gci *protocol.GroupChatInvite) {
	ppc.profile.ProcessInvite(gci, ppc.PeerHostname)
}

func (ppc *PeerPeerConnection) SendGroupInvite(invite []byte) {
	ppc.connection.Do(func() error {
		channel := ppc.connection.Channel("im.cwtch.peer", channels.Outbound)
		if channel != nil {
			peerchannel, ok := channel.Handler.(*peer.CwtchPeerChannel)
			if ok {
				peerchannel.SendMessage(invite)
			}
		}
		return nil
	})
}

// Run manages the setup and teardown of a peer->peer connection
func (ppc *PeerPeerConnection) Run() error {
	rc, err := goricochet.Open(ppc.PeerHostname)
	if err == nil {
		rc.TraceLog(true)
		ppc.connection = *rc
		ppc.state = CONNECTED
		_, err := connection.HandleOutboundConnection(&ppc.connection).ProcessAuthAsClient(identity.Initialize(ppc.profile.Name, ppc.profile.OnionPrivateKey))
		if err == nil {
			ppc.state = AUTHENTICATED
			go func() {
				ppc.connection.Do(func() error {
					ppc.connection.RequestOpenChannel("im.cwtch.peer", &peer.CwtchPeerChannel{Handler: ppc})
					return nil
				})

				time.Sleep(time.Second * 1)
				ppc.connection.Do(func() error {
					channel := ppc.connection.Channel("im.cwtch.peer", channels.Outbound)
					if channel != nil {
						peerchannel, ok := channel.Handler.(*peer.CwtchPeerChannel)
						if ok {
							peerchannel.SendMessage(ppc.profile.GetCwtchIdentityPacket())
						}
					}
					return nil
				})

			}()

			ppc.connection.Process(ppc)
		}
	}
	ppc.state = FAILED
	return err
}