lib/model/folders.go

   1 package model
   2
   3 import (
   4         "encoding/xml"
   5         "fmt"
   6         "log"
   7         "os"
   8         "path/filepath"
   9         "strings"
  10         "time"
  11
  12         "github.com/Sirupsen/logrus"
  13         common "github.com/iotbzh/xds-common/golib"
  14         "github.com/iotbzh/xds-server/lib/folder"
  15         "github.com/iotbzh/xds-server/lib/syncthing"
  16         "github.com/iotbzh/xds-server/lib/xdsconfig"
  17         "github.com/syncthing/syncthing/lib/sync"
  18 )
  19
  20 // Folders Represent a an XDS folders
  21 type Folders struct {
  22         fileOnDisk string
  23         Conf       *xdsconfig.Config
  24         Log        *logrus.Logger
  25         SThg       *st.SyncThing
  26         folders    map[string]*folder.IFOLDER
  27         registerCB []RegisteredCB
  28 }
  29
  30 type RegisteredCB struct {
  31         cb   *folder.EventCB
  32         data *folder.EventCBData
  33 }
  34
  35 // Mutex to make add/delete atomic
  36 var fcMutex = sync.NewMutex()
  37 var ffMutex = sync.NewMutex()
  38
  39 // FoldersNew Create a new instance of Model Folders
  40 func FoldersNew(cfg *xdsconfig.Config, st *st.SyncThing) *Folders {
  41         file, _ := xdsconfig.FoldersConfigFilenameGet()
  42         return &Folders{
  43                 fileOnDisk: file,
  44                 Conf:       cfg,
  45                 Log:        cfg.Log,
  46                 SThg:       st,
  47                 folders:    make(map[string]*folder.IFOLDER),
  48                 registerCB: []RegisteredCB{},
  49         }
  50 }
  51
  52 // LoadConfig Load folders configuration from disk
  53 func (f *Folders) LoadConfig() error {
  54         var flds []folder.FolderConfig
  55         var stFlds []folder.FolderConfig
  56
  57         // load from disk
  58         if f.Conf.Options.NoFolderConfig {
  59                 f.Log.Infof("Don't read folder config file (-no-folderconfig option is set)")
  60         } else if f.fileOnDisk != "" {
  61                 f.Log.Infof("Use folder config file: %s", f.fileOnDisk)
  62                 err := foldersConfigRead(f.fileOnDisk, &flds)
  63                 if err != nil {
  64                         if strings.HasPrefix(err.Error(), "No folder config") {
  65                                 f.Log.Warnf(err.Error())
  66                         } else {
  67                                 return err
  68                         }
  69                 }
  70         } else {
  71                 f.Log.Warnf("Folders config filename not set")
  72         }
  73
  74         // Retrieve initial Syncthing config (just append don't overwrite existing ones)
  75         if f.SThg != nil {
  76                 f.Log.Infof("Retrieve syncthing folder config")
  77                 if err := f.SThg.FolderLoadFromStConfig(&stFlds); err != nil {
  78                         // Don't exit on such error, just log it
  79                         f.Log.Errorf(err.Error())
  80                 }
  81         } else {
  82                 f.Log.Infof("Syncthing support is disabled.")
  83         }
  84
  85         // Merge syncthing folders into XDS folders
  86         for _, stf := range stFlds {
  87                 found := false
  88                 for i, xf := range flds {
  89                         if xf.ID == stf.ID {
  90                                 found = true
  91                                 // sanity check
  92                                 if xf.Type != folder.TypeCloudSync {
  93                                         flds[i].Status = folder.StatusErrorConfig
  94                                 }
  95                                 break
  96                         }
  97                 }
  98                 // add it
  99                 if !found {
 100                         flds = append(flds, stf)
 101                 }
 102         }
 103
 104         // Detect ghost project
 105         // (IOW existing in xds file config and not in syncthing database)
 106         if f.SThg != nil {
 107                 for i, xf := range flds {
 108                         // only for syncthing project
 109                         if xf.Type != folder.TypeCloudSync {
 110                                 continue
 111                         }
 112                         found := false
 113                         for _, stf := range stFlds {
 114                                 if stf.ID == xf.ID {
 115                                         found = true
 116                                         break
 117                                 }
 118                         }
 119                         if !found {
 120                                 flds[i].Status = folder.StatusErrorConfig
 121                         }
 122                 }
 123         }
 124
 125         // Update folders
 126         f.Log.Infof("Loading initial folders config: %d folders found", len(flds))
 127         for _, fc := range flds {
 128                 if _, err := f.createUpdate(fc, false, true); err != nil {
 129                         return err
 130                 }
 131         }
 132
 133         // Save config on disk
 134         err := f.SaveConfig()
 135
 136         return err
 137 }
 138
 139 // SaveConfig Save folders configuration to disk
 140 func (f *Folders) SaveConfig() error {
 141         if f.fileOnDisk == "" {
 142                 return fmt.Errorf("Folders config filename not set")
 143         }
 144
 145         // FIXME: buffered save or avoid to write on disk each time
 146         return foldersConfigWrite(f.fileOnDisk, f.getConfigArrUnsafe())
 147 }
 148
 149 // Get returns the folder config or nil if not existing
 150 func (f *Folders) Get(id string) *folder.IFOLDER {
 151         if id == "" {
 152                 return nil
 153         }
 154         fc, exist := f.folders[id]
 155         if !exist {
 156                 return nil
 157         }
 158         return fc
 159 }
 160
 161 // GetConfigArr returns the config of all folders as an array
 162 func (f *Folders) GetConfigArr() []folder.FolderConfig {
 163         fcMutex.Lock()
 164         defer fcMutex.Unlock()
 165
 166         return f.getConfigArrUnsafe()
 167 }
 168
 169 // getConfigArrUnsafe Same as GetConfigArr without mutex protection
 170 func (f *Folders) getConfigArrUnsafe() []folder.FolderConfig {
 171         conf := []folder.FolderConfig{}
 172         for _, v := range f.folders {
 173                 conf = append(conf, (*v).GetConfig())
 174         }
 175         return conf
 176 }
 177
 178 // Add adds a new folder
 179 func (f *Folders) Add(newF folder.FolderConfig) (*folder.FolderConfig, error) {
 180         return f.createUpdate(newF, true, false)
 181 }
 182
 183 // CreateUpdate creates or update a folder
 184 func (f *Folders) createUpdate(newF folder.FolderConfig, create bool, initial bool) (*folder.FolderConfig, error) {
 185
 186         fcMutex.Lock()
 187         defer fcMutex.Unlock()
 188
 189         // Sanity check
 190         if _, exist := f.folders[newF.ID]; create && exist {
 191                 return nil, fmt.Errorf("ID already exists")
 192         }
 193         if newF.ClientPath == "" {
 194                 return nil, fmt.Errorf("ClientPath must be set")
 195         }
 196
 197         // Create a new folder object
 198         var fld folder.IFOLDER
 199         switch newF.Type {
 200         // SYNCTHING
 201         case folder.TypeCloudSync:
 202                 if f.SThg != nil {
 203                         fld = f.SThg.NewFolderST(f.Conf)
 204                 } else {
 205                         f.Log.Debugf("Disable project %v (syncthing not initialized)", newF.ID)
 206                         fld = folder.NewFolderSTDisable(f.Conf)
 207                 }
 208
 209         // PATH MAP
 210         case folder.TypePathMap:
 211                 fld = folder.NewFolderPathMap(f.Conf)
 212         default:
 213                 return nil, fmt.Errorf("Unsupported folder type")
 214         }
 215
 216         // Allocate a new UUID
 217         if create {
 218                 newF.ID = fld.NewUID("")
 219         }
 220         if !create && newF.ID == "" {
 221                 return nil, fmt.Errorf("Cannot update folder with null ID")
 222         }
 223
 224         // Set default value if needed
 225         if newF.Status == "" {
 226                 newF.Status = folder.StatusDisable
 227         }
 228         if newF.Label == "" {
 229                 newF.Label = filepath.Base(newF.ClientPath)
 230                 if len(newF.ID) > 8 {
 231                         newF.Label += "_" + newF.ID[0:8]
 232                 }
 233         }
 234
 235         // Normalize path (needed for Windows path including bashlashes)
 236         newF.ClientPath = common.PathNormalize(newF.ClientPath)
 237
 238         // Add new folder
 239         newFolder, err := fld.Add(newF)
 240         if err != nil {
 241                 newF.Status = folder.StatusErrorConfig
 242                 log.Printf("ERROR Adding folder: %v\n", err)
 243                 return newFolder, err
 244         }
 245
 246         // Add to folders list
 247         f.folders[newF.ID] = &fld
 248
 249         // Save config on disk
 250         if !initial {
 251                 if err := f.SaveConfig(); err != nil {
 252                         return newFolder, err
 253                 }
 254         }
 255
 256         // Register event change callback
 257         for _, rcb := range f.registerCB {
 258                 if err := fld.RegisterEventChange(rcb.cb, rcb.data); err != nil {
 259                         return newFolder, err
 260                 }
 261         }
 262
 263         // Force sync after creation
 264         // (need to defer to be sure that WS events will arrive after HTTP creation reply)
 265         go func() {
 266                 time.Sleep(time.Millisecond * 500)
 267                 fld.Sync()
 268         }()
 269
 270         return newFolder, nil
 271 }
 272
 273 // Delete deletes a specific folder
 274 func (f *Folders) Delete(id string) (folder.FolderConfig, error) {
 275         var err error
 276
 277         fcMutex.Lock()
 278         defer fcMutex.Unlock()
 279
 280         fld := folder.FolderConfig{}
 281         fc, exist := f.folders[id]
 282         if !exist {
 283                 return fld, fmt.Errorf("unknown id")
 284         }
 285
 286         fld = (*fc).GetConfig()
 287
 288         if err = (*fc).Remove(); err != nil {
 289                 return fld, err
 290         }
 291
 292         delete(f.folders, id)
 293
 294         // Save config on disk
 295         err = f.SaveConfig()
 296
 297         return fld, err
 298 }
 299
 300 // RegisterEventChange requests registration for folder event change
 301 func (f *Folders) RegisterEventChange(id string, cb *folder.EventCB, data *folder.EventCBData) error {
 302
 303         flds := make(map[string]*folder.IFOLDER)
 304         if id != "" {
 305                 // Register to a specific folder
 306                 flds[id] = f.Get(id)
 307         } else {
 308                 // Register to all folders
 309                 flds = f.folders
 310                 f.registerCB = append(f.registerCB, RegisteredCB{cb: cb, data: data})
 311         }
 312
 313         for _, fld := range flds {
 314                 err := (*fld).RegisterEventChange(cb, data)
 315                 if err != nil {
 316                         return err
 317                 }
 318         }
 319
 320         return nil
 321 }
 322
 323 // ForceSync Force the synchronization of a folder
 324 func (f *Folders) ForceSync(id string) error {
 325         fc := f.Get(id)
 326         if fc == nil {
 327                 return fmt.Errorf("Unknown id")
 328         }
 329         return (*fc).Sync()
 330 }
 331
 332 // IsFolderInSync Returns true when folder is in sync
 333 func (f *Folders) IsFolderInSync(id string) (bool, error) {
 334         fc := f.Get(id)
 335         if fc == nil {
 336                 return false, fmt.Errorf("Unknown id")
 337         }
 338         return (*fc).IsInSync()
 339 }
 340
 341 //*** Private functions ***
 342
 343 // Use XML format and not json to be able to save/load all fields including
 344 // ones that are masked in json (IOW defined with `json:"-"`)
 345 type xmlFolders struct {
 346         XMLName xml.Name              `xml:"folders"`
 347         Version string                `xml:"version,attr"`
 348         Folders []folder.FolderConfig `xml:"folders"`
 349 }
 350
 351 // foldersConfigRead reads folders config from disk
 352 func foldersConfigRead(file string, folders *[]folder.FolderConfig) error {
 353         if !common.Exists(file) {
 354                 return fmt.Errorf("No folder config file found (%s)", file)
 355         }
 356
 357         ffMutex.Lock()
 358         defer ffMutex.Unlock()
 359
 360         fd, err := os.Open(file)
 361         defer fd.Close()
 362         if err != nil {
 363                 return err
 364         }
 365
 366         data := xmlFolders{}
 367         err = xml.NewDecoder(fd).Decode(&data)
 368         if err == nil {
 369                 *folders = data.Folders
 370         }
 371         return err
 372 }
 373
 374 // foldersConfigWrite writes folders config on disk
 375 func foldersConfigWrite(file string, folders []folder.FolderConfig) error {
 376         ffMutex.Lock()
 377         defer ffMutex.Unlock()
 378
 379         fd, err := os.OpenFile(file, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
 380         defer fd.Close()
 381         if err != nil {
 382                 return err
 383         }
 384
 385         data := &xmlFolders{
 386                 Version: "1",
 387                 Folders: folders,
 388         }
 389
 390         enc := xml.NewEncoder(fd)
 391         enc.Indent("", "  ")
 392         return enc.Encode(data)
 393 }