Use go module as dependency tool instead of glide
[src/xds/xds-agent.git] / 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 }