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