lib/syncthing/stfolder.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 st
  19
  20 import (
  21         "encoding/json"
  22         "fmt"
  23         "strings"
  24
  25         common "gerrit.automotivelinux.org/gerrit/src/xds/xds-common.git"
  26         stconfig "github.com/syncthing/syncthing/lib/config"
  27         "github.com/syncthing/syncthing/lib/protocol"
  28 )
  29
  30 // FolderChangeArg argument structure used by FolderChange
  31 type FolderChangeArg struct {
  32         ID           string
  33         Label        string
  34         RelativePath string
  35         SyncThingID  string
  36 }
  37
  38 // FolderLoadFromStConfig Load/Retrieve folder config from syncthing database
  39 /*
  40 func (s *SyncThing) FolderLoadFromStConfig(f *[]xsapiv1.FolderConfig) error {
  41
  42         defaultSdk := "" // cannot know which was the default sdk
  43
  44         stCfg, err := s.ConfigGet()
  45         if err != nil {
  46                 return err
  47         }
  48         if len(stCfg.Devices) < 1 {
  49                 return fmt.Errorf("Cannot load syncthing config: no device defined")
  50         }
  51         devID := stCfg.Devices[0].DeviceID.String()
  52         if devID == s.MyID {
  53                 if len(stCfg.Devices) < 2 {
  54                         return fmt.Errorf("Cannot load syncthing config: no valid device found")
  55                 }
  56                 devID = stCfg.Devices[1].DeviceID.String()
  57         }
  58
  59         for _, stFld := range stCfg.Folders {
  60                 *f = append(*f, xsapiv1.FolderConfig{
  61                         ID:            stFld.ID,
  62                         Label:         stFld.Label,
  63                         ClientPath:    strings.TrimRight(stFld.Path, "/"),
  64                         Type:          xsapiv1.TypeCloudSync,
  65                         Status:        StatusDisable,
  66                         DefaultSdk:    defaultSdk,
  67                         RootPath:      "",
  68                         DataCloudSync: xsapiv1.CloudSyncConfig{SyncThingID: devID},
  69                 })
  70         }
  71
  72         return nil
  73 }
  74 */
  75
  76 // FolderChange is called when configuration has changed
  77 func (s *SyncThing) FolderChange(f FolderChangeArg) (string, error) {
  78
  79         // Get current config
  80         stCfg, err := s.ConfigGet()
  81         if err != nil {
  82                 s.log.Errorln(err)
  83                 return "", err
  84         }
  85
  86         stClientID := f.SyncThingID
  87         // Add new Device if needed
  88         var devID protocol.DeviceID
  89         if err := devID.UnmarshalText([]byte(stClientID)); err != nil {
  90                 s.log.Errorf("not a valid device id (err %v)", err)
  91                 return "", err
  92         }
  93
  94         newDevice := stconfig.DeviceConfiguration{
  95                 DeviceID:  devID,
  96                 Name:      stClientID,
  97                 Addresses: []string{"dynamic"},
  98         }
  99
 100         var found = false
 101         for _, device := range stCfg.Devices {
 102                 if device.DeviceID == devID {
 103                         found = true
 104                         break
 105                 }
 106         }
 107         if !found {
 108                 stCfg.Devices = append(stCfg.Devices, newDevice)
 109         }
 110
 111         // Add or update Folder settings
 112         var label, id string
 113         if label = f.Label; label == "" {
 114                 label = strings.Split(id, "/")[0]
 115         }
 116         if id = f.ID; id == "" {
 117                 id = stClientID[0:15] + "_" + label
 118         }
 119
 120         // Resolve local path
 121         pathCli, err := common.ResolveEnvVar(f.RelativePath)
 122         if err != nil {
 123                 pathCli = f.RelativePath
 124         }
 125
 126         folder := stconfig.FolderConfiguration{
 127                 ID:            id,
 128                 Label:         label,
 129                 Path:          pathCli,
 130                 AutoNormalize: true,
 131         }
 132
 133         /* TODO - add it ?
 134         if s.conf.FileConf.SThgConf.RescanIntervalS > 0 {
 135                 folder.RescanIntervalS = s.conf.FileConf.SThgConf.RescanIntervalS
 136         }
 137         */
 138
 139         folder.Devices = append(folder.Devices, stconfig.FolderDeviceConfiguration{
 140                 DeviceID: newDevice.DeviceID,
 141         })
 142
 143         found = false
 144         var fld stconfig.FolderConfiguration
 145         for _, fld = range stCfg.Folders {
 146                 if folder.ID == fld.ID {
 147                         fld = folder
 148                         found = true
 149                         break
 150                 }
 151         }
 152         if !found {
 153                 stCfg.Folders = append(stCfg.Folders, folder)
 154                 fld = stCfg.Folders[0]
 155         }
 156
 157         err = s.ConfigSet(stCfg)
 158
 159         return id, err
 160 }
 161
 162 // FolderDelete is called to delete a folder config
 163 func (s *SyncThing) FolderDelete(id string) error {
 164         // Get current config
 165         stCfg, err := s.ConfigGet()
 166         if err != nil {
 167                 s.log.Errorln(err)
 168                 return err
 169         }
 170
 171         for i, fld := range stCfg.Folders {
 172                 if id == fld.ID {
 173                         stCfg.Folders = append(stCfg.Folders[:i], stCfg.Folders[i+1:]...)
 174                         err = s.ConfigSet(stCfg)
 175                         if err != nil {
 176                                 s.log.Errorln(err)
 177                                 return err
 178                         }
 179                 }
 180         }
 181
 182         return nil
 183 }
 184
 185 // FolderConfigGet Returns the configuration of a specific folder
 186 func (s *SyncThing) FolderConfigGet(folderID string) (stconfig.FolderConfiguration, error) {
 187         fc := stconfig.FolderConfiguration{}
 188         if folderID == "" {
 189                 return fc, fmt.Errorf("folderID not set")
 190         }
 191         cfg, err := s.ConfigGet()
 192         if err != nil {
 193                 return fc, err
 194         }
 195         for _, f := range cfg.Folders {
 196                 if f.ID == folderID {
 197                         fc = f
 198                         return fc, nil
 199                 }
 200         }
 201         return fc, fmt.Errorf("id not found")
 202 }
 203
 204 // FolderStatus Returns all information about the current
 205 func (s *SyncThing) FolderStatus(folderID string) (*FolderStatus, error) {
 206         var data []byte
 207         var res FolderStatus
 208         if folderID == "" {
 209                 return nil, fmt.Errorf("folderID not set")
 210         }
 211         if err := s.client.HTTPGet("db/status?folder="+folderID, &data); err != nil {
 212                 return nil, err
 213         }
 214         if err := json.Unmarshal(data, &res); err != nil {
 215                 return nil, err
 216         }
 217         return &res, nil
 218 }
 219
 220 // IsFolderInSync Returns true when folder is in sync
 221 func (s *SyncThing) IsFolderInSync(folderID string) (bool, error) {
 222         sts, err := s.FolderStatus(folderID)
 223         if err != nil {
 224                 return false, err
 225         }
 226         return sts.NeedBytes == 0 && sts.State == "idle", nil
 227 }
 228
 229 // FolderScan Request immediate folder scan.
 230 // Scan all folders if folderID param is empty
 231 func (s *SyncThing) FolderScan(folderID string, subpath string) error {
 232         url := "db/scan"
 233         if folderID != "" {
 234                 url += "?folder=" + folderID
 235
 236                 if subpath != "" {
 237                         url += "&sub=" + subpath
 238                 }
 239         }
 240         return s.client.HTTPPost(url, "")
 241 }