ricochet-go/core/contactlist.go

176 lines
4.0 KiB
Go

package core
import (
"errors"
"fmt"
"github.com/ricochet-im/ricochet-go/core/utils"
"github.com/ricochet-im/ricochet-go/rpc"
"strconv"
"sync"
"time"
)
type ContactList struct {
core *Ricochet
mutex sync.RWMutex
events *utils.Publisher
contacts map[int]*Contact
}
func LoadContactList(core *Ricochet) (*ContactList, error) {
list := &ContactList{
core: core,
events: utils.CreatePublisher(),
}
config := core.Config.OpenRead()
defer config.Close()
list.contacts = make(map[int]*Contact, len(config.Contacts))
for idStr, data := range config.Contacts {
id, err := strconv.Atoi(idStr)
if err != nil {
return nil, fmt.Errorf("Invalid contact id '%s'", idStr)
}
if _, exists := list.contacts[id]; exists {
return nil, fmt.Errorf("Duplicate contact id '%d'", id)
}
contact, err := ContactFromConfig(core, id, data, list.events)
if err != nil {
return nil, err
}
list.contacts[id] = contact
}
// XXX Requests aren't implemented
return list, nil
}
func (this *ContactList) EventMonitor() utils.Subscribable {
return this.events
}
func (this *ContactList) Contacts() []*Contact {
this.mutex.RLock()
defer this.mutex.RUnlock()
re := make([]*Contact, 0, len(this.contacts))
for _, contact := range this.contacts {
re = append(re, contact)
}
return re
}
func (this *ContactList) ContactById(id int) *Contact {
this.mutex.RLock()
defer this.mutex.RUnlock()
return this.contacts[id]
}
func (this *ContactList) ContactByAddress(address string) *Contact {
this.mutex.RLock()
defer this.mutex.RUnlock()
for _, contact := range this.contacts {
if contact.Address() == address {
return contact
}
}
return nil
}
func (this *ContactList) AddContactRequest(address, name, fromName, text string) (*Contact, error) {
this.mutex.Lock()
defer this.mutex.Unlock()
// XXX check that address is valid before relying on format below
// XXX validity checks on name/text also useful
for _, contact := range this.contacts {
if contact.Address() == address {
return nil, errors.New("Contact already exists with this address")
}
if contact.Nickname() == name {
return nil, errors.New("Contact already exists with this nickname")
}
}
// XXX check inbound requests
// Write new contact into config
config := this.core.Config.OpenWrite()
maxContactId := 0
for idstr, _ := range config.Contacts {
if id, err := strconv.Atoi(idstr); err == nil {
if maxContactId < id {
maxContactId = id
}
}
}
contactId := maxContactId + 1
configContact := ConfigContact{
Hostname: address[9:] + ".onion",
Nickname: name,
WhenCreated: time.Now().Format(time.RFC3339),
Request: ConfigContactRequest{
Pending: true,
MyNickname: fromName,
Message: text,
},
}
config.Contacts[strconv.Itoa(contactId)] = configContact
if err := config.Save(); err != nil {
return nil, err
}
// Create Contact
// XXX This starts connection immediately, which could cause contact update
// events before the add event in an unlikely race case
contact, err := ContactFromConfig(this.core, contactId, configContact, this.events)
if err != nil {
return nil, err
}
this.contacts[contactId] = contact
event := ricochet.ContactEvent{
Type: ricochet.ContactEvent_ADD,
Subject: &ricochet.ContactEvent_Contact{
Contact: contact.Data(),
},
}
this.events.Publish(event)
return contact, nil
}
func (this *ContactList) RemoveContact(contact *Contact) error {
this.mutex.Lock()
defer this.mutex.Unlock()
if this.contacts[contact.Id()] != contact {
return errors.New("Not in contact list")
}
// XXX Not persisting in config
// XXX This will have to do some things to the contact itself
// eventually too, such as killing connections and other resources.
delete(this.contacts, contact.Id())
event := ricochet.ContactEvent{
Type: ricochet.ContactEvent_DELETE,
Subject: &ricochet.ContactEvent_Contact{
Contact: &ricochet.Contact{
Id: int32(contact.Id()),
Address: contact.Address(),
},
},
}
this.events.Publish(event)
return nil
}