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