lib/agent/projects.go

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