ricochet-go/cli/client.go

286 lines
7.0 KiB
Go

package main
import (
"fmt"
"github.com/special/notricochet/rpc"
"golang.org/x/net/context"
"gopkg.in/readline.v1"
"log"
"strings"
)
type Client struct {
Backend ricochet.RicochetCoreClient
Input *readline.Instance
ServerStatus ricochet.ServerStatusReply
Identity ricochet.Identity
// XXX threadsafety
NetworkStatus ricochet.NetworkStatus
Contacts []*ricochet.Contact
CurrentContact *ricochet.Contact
}
// XXX need to handle backend connection loss/reconnection..
func (c *Client) Initialize() error {
// Query server status and version
status, err := c.Backend.GetServerStatus(context.Background(), &ricochet.ServerStatusRequest{
RpcVersion: 1,
})
if err != nil {
return err
}
c.ServerStatus = *status
if status.RpcVersion != 1 {
return fmt.Errorf("Unsupported backend RPC version %d", status.RpcVersion)
}
// Query identity
identity, err := c.Backend.GetIdentity(context.Background(), &ricochet.IdentityRequest{})
if err != nil {
return err
}
c.Identity = *identity
// Spawn routines to query and monitor state changes
go c.monitorNetwork()
go c.monitorContacts()
go c.monitorConversations()
// XXX block until populated/initialized?
return nil
}
func (c *Client) SetCurrentContact(contact *ricochet.Contact) {
c.CurrentContact = contact
if c.CurrentContact != nil {
config := *c.Input.Config
config.Prompt = fmt.Sprintf("%s > ", c.CurrentContact.Nickname)
config.UniqueEditLine = true
c.Input.SetConfig(&config)
fmt.Printf("--- %s (%s) ---\n", c.CurrentContact.Nickname, strings.ToLower(c.CurrentContact.Status.String()))
} else {
config := *c.Input.Config
config.Prompt = "> "
config.UniqueEditLine = false
c.Input.SetConfig(&config)
}
}
func (c *Client) monitorNetwork() {
stream, err := c.Backend.MonitorNetwork(context.Background(), &ricochet.MonitorNetworkRequest{})
if err != nil {
log.Printf("Initializing network status monitor failed: %v", err)
// XXX handle
return
}
for {
status, err := stream.Recv()
if err != nil {
log.Printf("Network status monitor error: %v", err)
// XXX handle
break
}
log.Printf("Network status changed: %v", status)
c.NetworkStatus = *status
}
}
func (c *Client) monitorContacts() {
stream, err := c.Backend.MonitorContacts(context.Background(), &ricochet.MonitorContactsRequest{})
if err != nil {
log.Printf("Initializing contact status monitor failed: %v", err)
// XXX handle
return
}
// Populate initial contacts list
for {
event, err := stream.Recv()
if err != nil {
log.Printf("Contact populate error: %v", err)
// XXX handle
break
}
if event.Type != ricochet.ContactEvent_POPULATE {
log.Printf("Ignoring unexpected contact event during populate: %v", event)
continue
}
// Populate is terminated by a nil subject
if event.Subject == nil {
break
}
if contact := event.GetContact(); contact != nil {
c.Contacts = append(c.Contacts, contact)
} else if request := event.GetRequest(); request != nil {
// XXX handle requests
log.Printf("XXX contact requests not supported")
} else {
log.Printf("XXX invalid event")
}
}
log.Printf("Loaded %d contacts", len(c.Contacts))
for {
event, err := stream.Recv()
if err != nil {
log.Printf("Contact status monitor error: %v", err)
// XXX handle
break
}
contact := event.GetContact()
switch event.Type {
case ricochet.ContactEvent_ADD:
if contact == nil {
log.Printf("Ignoring contact add event with null contact")
continue
}
c.Contacts = append(c.Contacts, contact)
log.Printf("new contact: %v", contact)
case ricochet.ContactEvent_UPDATE:
if contact == nil {
log.Printf("Ignoring contact update event with null contact")
continue
}
var found bool
for i, match := range c.Contacts {
if match.Id == contact.Id && match.Address == contact.Address {
contacts := append(c.Contacts[0:i], contact)
contacts = append(contacts, c.Contacts[i+1:]...)
c.Contacts = contacts
found = true
break
}
}
if !found {
log.Printf("Ignoring contact update event for unknown contact: %v", contact)
} else {
log.Printf("updated contact: %v", contact)
}
if c.CurrentContact != nil && c.CurrentContact.Id == contact.Id {
c.SetCurrentContact(contact)
}
case ricochet.ContactEvent_DELETE:
if contact == nil {
log.Printf("Ignoring contact delete event with null contact")
continue
}
var found bool
for i, match := range c.Contacts {
if match.Id == contact.Id && match.Address == contact.Address {
c.Contacts = append(c.Contacts[0:i], c.Contacts[i+1:]...)
found = true
break
}
}
if !found {
log.Printf("Ignoring contact delete event for unknown contact: %v", contact)
} else {
log.Printf("deleted contact: %v", contact)
}
if c.CurrentContact != nil && c.CurrentContact.Id == contact.Id {
c.SetCurrentContact(nil)
}
default:
log.Printf("Ignoring unknown contact event: %v", event)
}
}
}
func (c *Client) monitorConversations() {
stream, err := c.Backend.MonitorConversations(context.Background(), &ricochet.MonitorConversationsRequest{})
if err != nil {
log.Printf("Initializing conversations monitor failed: %v", err)
// XXX handle
return
}
log.Printf("Monitoring conversations")
for {
event, err := stream.Recv()
if err != nil {
log.Printf("Conversations monitor error: %v", err)
// XXX handle
break
}
// XXX Should also handle POPULATE
if event.Type != ricochet.ConversationEvent_RECEIVE &&
event.Type != ricochet.ConversationEvent_SEND {
continue
}
message := event.Msg
if message == nil || message.Recipient == nil || message.Sender == nil {
log.Printf("Ignoring invalid conversation event: %v", event)
continue
}
var remoteContact *ricochet.Contact
var remoteEntity *ricochet.Entity
if !message.Sender.IsSelf {
remoteEntity = message.Sender
} else {
remoteEntity = message.Recipient
}
for _, contact := range c.Contacts {
if remoteEntity.ContactId == contact.Id && remoteEntity.Address == contact.Address {
remoteContact = contact
break
}
}
if remoteContact == nil {
log.Printf("Ignoring conversation event with unknown contact: %v", event)
continue
}
if remoteContact == c.CurrentContact {
// XXX so unsafe
if message.Sender.IsSelf {
fmt.Fprintf(c.Input.Stdout(), "\r%s > %s\n", remoteContact.Nickname, message.Text)
} else {
fmt.Fprintf(c.Input.Stdout(), "\r%s < %s\n", remoteContact.Nickname, message.Text)
}
} else if !message.Sender.IsSelf {
fmt.Fprintf(c.Input.Stdout(), "\r---- %s < %s\n", remoteContact.Nickname, message.Text)
}
if !message.Sender.IsSelf {
backend := c.Backend
message := message
go func() {
_, err := backend.MarkConversationRead(context.Background(), &ricochet.MarkConversationReadRequest{
Entity: message.Sender,
LastRecvIdentifier: message.Identifier,
})
if err != nil {
log.Printf("Mark conversation read failed: %v", err)
}
}()
}
}
}