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