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         var conf []folder.FolderConfig
 172
 173         for _, v := range f.folders {
 174                 conf = append(conf, (*v).GetConfig())
 175         }
 176         return conf
 177 }
 178
 179 // Add adds a new folder
 180 func (f *Folders) Add(newF folder.FolderConfig) (*folder.FolderConfig, error) {
 181         return f.createUpdate(newF, true, false)
 182 }
 183
 184 // CreateUpdate creates or update a folder
 185 func (f *Folders) createUpdate(newF folder.FolderConfig, create bool, initial bool) (*folder.FolderConfig, error) {
 186
 187         fcMutex.Lock()
 188         defer fcMutex.Unlock()
 189
 190         // Sanity check
 191         if _, exist := f.folders[newF.ID]; create && exist {
 192                 return nil, fmt.Errorf("ID already exists")
 193         }
 194         if newF.ClientPath == "" {
 195                 return nil, fmt.Errorf("ClientPath must be set")
 196         }
 197
 198         // Create a new folder object
 199         var fld folder.IFOLDER
 200         switch newF.Type {
 201         // SYNCTHING
 202         case folder.TypeCloudSync:
 203                 if f.SThg != nil {
 204                         fld = f.SThg.NewFolderST(f.Conf)
 205                 } else {
 206                         f.Log.Debugf("Disable project %v (syncthing not initialized)", newF.ID)
 207                         fld = folder.NewFolderSTDisable(f.Conf)
 208                 }
 209
 210         // PATH MAP
 211         case folder.TypePathMap:
 212                 fld = folder.NewFolderPathMap(f.Conf)
 213         default:
 214                 return nil, fmt.Errorf("Unsupported folder type")
 215         }
 216
 217         // Set default value if needed
 218         if newF.Status == "" {
 219                 newF.Status = folder.StatusDisable
 220         }
 221         if newF.Label == "" {
 222                 newF.Label = filepath.Base(newF.ClientPath) + "_" + newF.ID[0:8]
 223         }
 224
 225         // Allocate a new UUID
 226         if create {
 227                 i := len(newF.Label)
 228                 if i > 20 {
 229                         i = 20
 230                 }
 231                 newF.ID = fld.NewUID(newF.Label[:i])
 232         }
 233         if !create && newF.ID == "" {
 234                 return nil, fmt.Errorf("Cannot update folder with null ID")
 235         }
 236
 237         // Normalize path (needed for Windows path including bashlashes)
 238         newF.ClientPath = common.PathNormalize(newF.ClientPath)
 239
 240         // Add new folder
 241         newFolder, err := fld.Add(newF)
 242         if err != nil {
 243                 newF.Status = folder.StatusErrorConfig
 244                 log.Printf("ERROR Adding folder: %v\n", err)
 245                 return newFolder, err
 246         }
 247
 248         // Add to folders list
 249         f.folders[newF.ID] = &fld
 250
 251         // Save config on disk
 252         if !initial {
 253                 if err := f.SaveConfig(); err != nil {
 254                         return newFolder, err
 255                 }
 256         }
 257
 258         // Register event change callback
 259         for _, rcb := range f.registerCB {
 260                 if err := fld.RegisterEventChange(rcb.cb, rcb.data); err != nil {
 261                         return newFolder, err
 262                 }
 263         }
 264
 265         // Force sync after creation
 266         // (need to defer to be sure that WS events will arrive after HTTP creation reply)
 267         go func() {
 268                 time.Sleep(time.Millisecond * 500)
 269                 fld.Sync()
 270         }()
 271
 272         return newFolder, nil
 273 }
 274
 275 // Delete deletes a specific folder
 276 func (f *Folders) Delete(id string) (folder.FolderConfig, error) {
 277         var err error
 278
 279         fcMutex.Lock()
 280         defer fcMutex.Unlock()
 281
 282         fld := folder.FolderConfig{}
 283         fc, exist := f.folders[id]
 284         if !exist {
 285                 return fld, fmt.Errorf("unknown id")
 286         }
 287
 288         fld = (*fc).GetConfig()
 289
 290         if err = (*fc).Remove(); err != nil {
 291                 return fld, err
 292         }
 293
 294         delete(f.folders, id)
 295
 296         // Save config on disk
 297         err = f.SaveConfig()
 298
 299         return fld, err
 300 }
 301
 302 // RegisterEventChange requests registration for folder event change
 303 func (f *Folders) RegisterEventChange(id string, cb *folder.EventCB, data *folder.EventCBData) error {
 304
 305         flds := make(map[string]*folder.IFOLDER)
 306         if id != "" {
 307                 // Register to a specific folder
 308                 flds[id] = f.Get(id)
 309         } else {
 310                 // Register to all folders
 311                 flds = f.folders
 312                 f.registerCB = append(f.registerCB, RegisteredCB{cb: cb, data: data})
 313         }
 314
 315         for _, fld := range flds {
 316                 err := (*fld).RegisterEventChange(cb, data)
 317                 if err != nil {
 318                         return err
 319                 }
 320         }
 321
 322         return nil
 323 }
 324
 325 // ForceSync Force the synchronization of a folder
 326 func (f *Folders) ForceSync(id string) error {
 327         fc := f.Get(id)
 328         if fc == nil {
 329                 return fmt.Errorf("Unknown id")
 330         }
 331         return (*fc).Sync()
 332 }
 333
 334 // IsFolderInSync Returns true when folder is in sync
 335 func (f *Folders) IsFolderInSync(id string) (bool, error) {
 336         fc := f.Get(id)
 337         if fc == nil {
 338                 return false, fmt.Errorf("Unknown id")
 339         }
 340         return (*fc).IsInSync()
 341 }
 342
 343 //*** Private functions ***
 344
 345 // Use XML format and not json to be able to save/load all fields including
 346 // ones that are masked in json (IOW defined with `json:"-"`)
 347 type xmlFolders struct {
 348         XMLName xml.Name              `xml:"folders"`
 349         Version string                `xml:"version,attr"`
 350         Folders []folder.FolderConfig `xml:"folders"`
 351 }
 352
 353 // foldersConfigRead reads folders config from disk
 354 func foldersConfigRead(file string, folders *[]folder.FolderConfig) error {
 355         if !common.Exists(file) {
 356                 return fmt.Errorf("No folder config file found (%s)", file)
 357         }
 358
 359         ffMutex.Lock()
 360         defer ffMutex.Unlock()
 361
 362         fd, err := os.Open(file)
 363         defer fd.Close()
 364         if err != nil {
 365                 return err
 366         }
 367
 368         data := xmlFolders{}
 369         err = xml.NewDecoder(fd).Decode(&data)
 370         if err == nil {
 371                 *folders = data.Folders
 372         }
 373         return err
 374 }
 375
 376 // foldersConfigWrite writes folders config on disk
 377 func foldersConfigWrite(file string, folders []folder.FolderConfig) error {
 378         ffMutex.Lock()
 379         defer ffMutex.Unlock()
 380
 381         fd, err := os.OpenFile(file, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
 382         defer fd.Close()
 383         if err != nil {
 384                 return err
 385         }
 386
 387         data := &xmlFolders{
 388                 Version: "1",
 389                 Folders: folders,
 390         }
 391
 392         enc := xml.NewEncoder(fd)
 393         enc.Indent("", "  ")
 394         return enc.Encode(data)
 395 }