lib/agent/projects.go

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