lib/agent/projects.go

   1 package agent
   2
   3 import (
   4         "fmt"
   5         "log"
   6         "strings"
   7         "time"
   8
   9         "github.com/franciscocpg/reflectme"
  10         "github.com/iotbzh/xds-agent/lib/syncthing"
  11         "github.com/iotbzh/xds-agent/lib/xaapiv1"
  12         "github.com/iotbzh/xds-server/lib/xsapiv1"
  13         "github.com/syncthing/syncthing/lib/sync"
  14 )
  15
  16 // Projects Represent a an XDS Projects
  17 type Projects struct {
  18         *Context
  19         SThg     *st.SyncThing
  20         projects map[string]*IPROJECT
  21 }
  22
  23 // Mutex to make add/delete atomic
  24 var pjMutex = sync.NewMutex()
  25
  26 // NewProjects Create a new instance of Project Model
  27 func NewProjects(ctx *Context, st *st.SyncThing) *Projects {
  28         return &Projects{
  29                 Context:  ctx,
  30                 SThg:     st,
  31                 projects: make(map[string]*IPROJECT),
  32         }
  33 }
  34
  35 // Init Load Projects configuration
  36 func (p *Projects) Init(server *XdsServer) error {
  37         svrList := make(map[string]*XdsServer)
  38         // If server not set, load for all servers
  39         if server == nil {
  40                 svrList = p.xdsServers
  41         } else {
  42                 svrList[server.ID] = server
  43         }
  44         errMsg := ""
  45         for _, svr := range svrList {
  46                 if svr.Disabled {
  47                         continue
  48                 }
  49                 xFlds := []xsapiv1.FolderConfig{}
  50                 if err := svr.GetFolders(&xFlds); err != nil {
  51                         errMsg += fmt.Sprintf("Cannot retrieve folders config of XDS server ID %s : %v \n", svr.ID, err.Error())
  52                         continue
  53                 }
  54                 p.Log.Debugf("Connected to XDS Server %s, %d projects detected", svr.ID, len(xFlds))
  55                 for _, prj := range xFlds {
  56                         newP := svr.FolderToProject(prj)
  57                         if _, err := p.createUpdate(newP, false, true); err != nil {
  58                                 errMsg += "Error while creating project id " + prj.ID + ": " + err.Error() + "\n "
  59                                 continue
  60                         }
  61                 }
  62         }
  63
  64         p.Log.Infof("Number of loaded Projects: %d", len(p.projects))
  65
  66         if errMsg != "" {
  67                 return fmt.Errorf(errMsg)
  68         }
  69         return nil
  70 }
  71
  72 // ResolveID Complete a Project ID (helper for user that can use partial ID value)
  73 func (p *Projects) ResolveID(id string) (string, error) {
  74         if id == "" {
  75                 return "", nil
  76         }
  77
  78         match := []string{}
  79         for iid := range p.projects {
  80                 if strings.HasPrefix(iid, id) {
  81                         match = append(match, iid)
  82                 }
  83         }
  84
  85         if len(match) == 1 {
  86                 return match[0], nil
  87         } else if len(match) == 0 {
  88                 return id, fmt.Errorf("Unknown id")
  89         }
  90         return id, fmt.Errorf("Multiple IDs found with provided prefix: " + id)
  91 }
  92
  93 // Get returns the folder config or nil if not existing
  94 func (p *Projects) Get(id string) *IPROJECT {
  95         if id == "" {
  96                 return nil
  97         }
  98         fc, exist := p.projects[id]
  99         if !exist {
 100                 return nil
 101         }
 102         return fc
 103 }
 104
 105 // GetProjectArr returns the config of all folders as an array
 106 func (p *Projects) GetProjectArr() []xaapiv1.ProjectConfig {
 107         pjMutex.Lock()
 108         defer pjMutex.Unlock()
 109
 110         return p.GetProjectArrUnsafe()
 111 }
 112
 113 // GetProjectArrUnsafe Same as GetProjectArr without mutex protection
 114 func (p *Projects) GetProjectArrUnsafe() []xaapiv1.ProjectConfig {
 115         conf := []xaapiv1.ProjectConfig{}
 116         for _, v := range p.projects {
 117                 prj := (*v).GetProject()
 118                 conf = append(conf, *prj)
 119         }
 120         return conf
 121 }
 122
 123 // Add adds a new folder
 124 func (p *Projects) Add(newF xaapiv1.ProjectConfig, fromSid string) (*xaapiv1.ProjectConfig, error) {
 125         prj, err := p.createUpdate(newF, true, false)
 126         if err != nil {
 127                 return prj, err
 128         }
 129
 130         // Notify client with event
 131         if err := p.events.Emit(xaapiv1.EVTProjectAdd, *prj, fromSid); err != nil {
 132                 p.Log.Warningf("Cannot notify project deletion: %v", err)
 133         }
 134
 135         return prj, err
 136 }
 137
 138 // CreateUpdate creates or update a folder
 139 func (p *Projects) createUpdate(newF xaapiv1.ProjectConfig, create bool, initial bool) (*xaapiv1.ProjectConfig, error) {
 140         var err error
 141
 142         pjMutex.Lock()
 143         defer pjMutex.Unlock()
 144
 145         // Sanity check
 146         if _, exist := p.projects[newF.ID]; create && exist {
 147                 return nil, fmt.Errorf("ID already exists")
 148         }
 149         if newF.ClientPath == "" {
 150                 return nil, fmt.Errorf("ClientPath must be set")
 151         }
 152         if newF.ServerID == "" {
 153                 return nil, fmt.Errorf("Server ID must be set")
 154         }
 155         var svr *XdsServer
 156         var exist bool
 157         if svr, exist = p.xdsServers[newF.ServerID]; !exist {
 158                 return nil, fmt.Errorf("Unknown Server ID %s", newF.ServerID)
 159         }
 160
 161         // Check type supported
 162         b, exist := svr.ServerConfig.SupportedSharing[string(newF.Type)]
 163         if !exist || !b {
 164                 return nil, fmt.Errorf("Server doesn't support project type %s", newF.Type)
 165         }
 166
 167         // Create a new folder object
 168         var fld IPROJECT
 169         switch newF.Type {
 170         // SYNCTHING
 171         case xaapiv1.TypeCloudSync:
 172                 if p.SThg != nil {
 173                         fld = NewProjectST(p.Context, svr)
 174                 } else {
 175                         return nil, fmt.Errorf("Cloud Sync project not supported")
 176                 }
 177
 178         // PATH MAP
 179         case xaapiv1.TypePathMap:
 180                 fld = NewProjectPathMap(p.Context, svr)
 181         default:
 182                 return nil, fmt.Errorf("Unsupported folder type")
 183         }
 184
 185         var newPrj *xaapiv1.ProjectConfig
 186         if create {
 187                 // Add project on server
 188                 if newPrj, err = fld.Add(newF); err != nil {
 189                         newF.Status = xaapiv1.StatusErrorConfig
 190                         log.Printf("ERROR Adding project: %v\n", err)
 191                         return newPrj, err
 192                 }
 193         } else {
 194                 // Just update project config
 195                 if newPrj, err = fld.Setup(newF); err != nil {
 196                         newF.Status = xaapiv1.StatusErrorConfig
 197                         log.Printf("ERROR Updating project: %v\n", err)
 198                         return newPrj, err
 199                 }
 200         }
 201
 202         // Sanity check
 203         if newPrj.ID == "" {
 204                 log.Printf("ERROR project ID empty: %v", newF)
 205                 return newPrj, fmt.Errorf("Project ID empty")
 206         }
 207
 208         // Add to folders list
 209         p.projects[newPrj.ID] = &fld
 210
 211         // Force sync after creation
 212         // (need to defer to be sure that WS events will arrive after HTTP creation reply)
 213         go func() {
 214                 time.Sleep(time.Millisecond * 500)
 215                 fld.Sync()
 216         }()
 217
 218         return newPrj, nil
 219 }
 220
 221 // Delete deletes a specific folder
 222 func (p *Projects) Delete(id, fromSid string) (xaapiv1.ProjectConfig, error) {
 223         var err error
 224
 225         pjMutex.Lock()
 226         defer pjMutex.Unlock()
 227
 228         fld := xaapiv1.ProjectConfig{}
 229         fc, exist := p.projects[id]
 230         if !exist {
 231                 return fld, fmt.Errorf("Unknown id")
 232         }
 233
 234         prj := (*fc).GetProject()
 235
 236         if err = (*fc).Delete(); err != nil {
 237                 return *prj, err
 238         }
 239
 240         delete(p.projects, id)
 241
 242         // Notify client with event
 243         if err := p.events.Emit(xaapiv1.EVTProjectDelete, *prj, fromSid); err != nil {
 244                 p.Log.Warningf("Cannot notify project deletion: %v", err)
 245         }
 246
 247         return *prj, err
 248 }
 249
 250 // ForceSync Force the synchronization of a folder
 251 func (p *Projects) ForceSync(id string) error {
 252         fc := p.Get(id)
 253         if fc == nil {
 254                 return fmt.Errorf("Unknown id")
 255         }
 256         return (*fc).Sync()
 257 }
 258
 259 // IsProjectInSync Returns true when folder is in sync
 260 func (p *Projects) IsProjectInSync(id string) (bool, error) {
 261         fc := p.Get(id)
 262         if fc == nil {
 263                 return false, fmt.Errorf("Unknown id")
 264         }
 265         return (*fc).IsInSync()
 266 }
 267
 268 // Update Update some field of a project
 269 func (p *Projects) Update(id string, prj xaapiv1.ProjectConfig, fromSid string) (*xaapiv1.ProjectConfig, error) {
 270
 271         pjMutex.Lock()
 272         defer pjMutex.Unlock()
 273
 274         fc, exist := p.projects[id]
 275         if !exist {
 276                 return nil, fmt.Errorf("Unknown id")
 277         }
 278
 279         // Copy current in a new object to change nothing in case of an error rises
 280         newFld := xaapiv1.ProjectConfig{}
 281         reflectme.Copy((*fc).GetProject(), &newFld)
 282
 283         // Only update some fields
 284         dirty := false
 285         for _, fieldName := range xaapiv1.ProjectConfigUpdatableFields {
 286                 valNew, err := reflectme.GetField(prj, fieldName)
 287                 if err == nil {
 288                         valCur, err := reflectme.GetField(newFld, fieldName)
 289                         if err == nil && valNew != valCur {
 290                                 err = reflectme.SetField(&newFld, fieldName, valNew)
 291                                 if err != nil {
 292                                         return nil, err
 293                                 }
 294                                 dirty = true
 295                         }
 296                 }
 297         }
 298
 299         if !dirty {
 300                 return &newFld, nil
 301         }
 302
 303         upPrj, err := (*fc).Update(newFld)
 304         if err != nil {
 305                 return nil, err
 306         }
 307
 308         // Notify client with event
 309         if err := p.events.Emit(xaapiv1.EVTProjectChange, *upPrj, fromSid); err != nil {
 310                 p.Log.Warningf("Cannot notify project change: %v", err)
 311         }
 312         return upPrj, err
 313 }