api_utils.go 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642
  1. package httpd
  2. import (
  3. "bytes"
  4. "context"
  5. "encoding/json"
  6. "errors"
  7. "fmt"
  8. "io"
  9. "io/ioutil"
  10. "net/http"
  11. "net/url"
  12. "os"
  13. "path"
  14. "path/filepath"
  15. "strconv"
  16. "strings"
  17. "time"
  18. "github.com/drakkan/sftpgo/dataprovider"
  19. "github.com/drakkan/sftpgo/sftpd"
  20. "github.com/drakkan/sftpgo/utils"
  21. "github.com/go-chi/render"
  22. )
  23. var (
  24. httpBaseURL = "http://127.0.0.1:8080"
  25. authUsername = ""
  26. authPassword = ""
  27. )
  28. // SetBaseURLAndCredentials sets the base url and the optional credentials to use for HTTP requests.
  29. // Default URL is "http://127.0.0.1:8080" with empty credentials
  30. func SetBaseURLAndCredentials(url, username, password string) {
  31. httpBaseURL = url
  32. authUsername = username
  33. authPassword = password
  34. }
  35. // gets an HTTP Client with a timeout
  36. func getHTTPClient() *http.Client {
  37. return &http.Client{
  38. Timeout: 15 * time.Second,
  39. }
  40. }
  41. func sendHTTPRequest(method, url string, body io.Reader, contentType string) (*http.Response, error) {
  42. req, err := http.NewRequest(method, url, body)
  43. if err != nil {
  44. return nil, err
  45. }
  46. if len(contentType) > 0 {
  47. req.Header.Set("Content-Type", "application/json")
  48. }
  49. if len(authUsername) > 0 || len(authPassword) > 0 {
  50. req.SetBasicAuth(authUsername, authPassword)
  51. }
  52. return getHTTPClient().Do(req)
  53. }
  54. func buildURLRelativeToBase(paths ...string) string {
  55. // we need to use path.Join and not filepath.Join
  56. // since filepath.Join will use backslash separator on Windows
  57. p := path.Join(paths...)
  58. return fmt.Sprintf("%s/%s", strings.TrimRight(httpBaseURL, "/"), strings.TrimLeft(p, "/"))
  59. }
  60. func sendAPIResponse(w http.ResponseWriter, r *http.Request, err error, message string, code int) {
  61. var errorString string
  62. if err != nil {
  63. errorString = err.Error()
  64. }
  65. resp := apiResponse{
  66. Error: errorString,
  67. Message: message,
  68. HTTPStatus: code,
  69. }
  70. ctx := context.WithValue(r.Context(), render.StatusCtxKey, code)
  71. render.JSON(w, r.WithContext(ctx), resp)
  72. }
  73. func getRespStatus(err error) int {
  74. if _, ok := err.(*dataprovider.ValidationError); ok {
  75. return http.StatusBadRequest
  76. }
  77. if _, ok := err.(*dataprovider.MethodDisabledError); ok {
  78. return http.StatusForbidden
  79. }
  80. if os.IsNotExist(err) {
  81. return http.StatusBadRequest
  82. }
  83. return http.StatusInternalServerError
  84. }
  85. // AddUser adds a new user and checks the received HTTP Status code against expectedStatusCode.
  86. func AddUser(user dataprovider.User, expectedStatusCode int) (dataprovider.User, []byte, error) {
  87. var newUser dataprovider.User
  88. var body []byte
  89. userAsJSON, err := json.Marshal(user)
  90. if err != nil {
  91. return newUser, body, err
  92. }
  93. resp, err := sendHTTPRequest(http.MethodPost, buildURLRelativeToBase(userPath), bytes.NewBuffer(userAsJSON),
  94. "application/json")
  95. if err != nil {
  96. return newUser, body, err
  97. }
  98. defer resp.Body.Close()
  99. err = checkResponse(resp.StatusCode, expectedStatusCode)
  100. if expectedStatusCode != http.StatusOK {
  101. body, _ = getResponseBody(resp)
  102. return newUser, body, err
  103. }
  104. if err == nil {
  105. err = render.DecodeJSON(resp.Body, &newUser)
  106. } else {
  107. body, _ = getResponseBody(resp)
  108. }
  109. if err == nil {
  110. err = checkUser(&user, &newUser)
  111. }
  112. return newUser, body, err
  113. }
  114. // UpdateUser updates an existing user and checks the received HTTP Status code against expectedStatusCode.
  115. func UpdateUser(user dataprovider.User, expectedStatusCode int) (dataprovider.User, []byte, error) {
  116. var newUser dataprovider.User
  117. var body []byte
  118. userAsJSON, err := json.Marshal(user)
  119. if err != nil {
  120. return user, body, err
  121. }
  122. resp, err := sendHTTPRequest(http.MethodPut, buildURLRelativeToBase(userPath, strconv.FormatInt(user.ID, 10)),
  123. bytes.NewBuffer(userAsJSON), "application/json")
  124. if err != nil {
  125. return user, body, err
  126. }
  127. defer resp.Body.Close()
  128. body, _ = getResponseBody(resp)
  129. err = checkResponse(resp.StatusCode, expectedStatusCode)
  130. if expectedStatusCode != http.StatusOK {
  131. return newUser, body, err
  132. }
  133. if err == nil {
  134. newUser, body, err = GetUserByID(user.ID, expectedStatusCode)
  135. }
  136. if err == nil {
  137. err = checkUser(&user, &newUser)
  138. }
  139. return newUser, body, err
  140. }
  141. // RemoveUser removes an existing user and checks the received HTTP Status code against expectedStatusCode.
  142. func RemoveUser(user dataprovider.User, expectedStatusCode int) ([]byte, error) {
  143. var body []byte
  144. resp, err := sendHTTPRequest(http.MethodDelete, buildURLRelativeToBase(userPath, strconv.FormatInt(user.ID, 10)), nil, "")
  145. if err != nil {
  146. return body, err
  147. }
  148. defer resp.Body.Close()
  149. body, _ = getResponseBody(resp)
  150. return body, checkResponse(resp.StatusCode, expectedStatusCode)
  151. }
  152. // GetUserByID gets an user by database id and checks the received HTTP Status code against expectedStatusCode.
  153. func GetUserByID(userID int64, expectedStatusCode int) (dataprovider.User, []byte, error) {
  154. var user dataprovider.User
  155. var body []byte
  156. resp, err := sendHTTPRequest(http.MethodGet, buildURLRelativeToBase(userPath, strconv.FormatInt(userID, 10)), nil, "")
  157. if err != nil {
  158. return user, body, err
  159. }
  160. defer resp.Body.Close()
  161. err = checkResponse(resp.StatusCode, expectedStatusCode)
  162. if err == nil && expectedStatusCode == http.StatusOK {
  163. err = render.DecodeJSON(resp.Body, &user)
  164. } else {
  165. body, _ = getResponseBody(resp)
  166. }
  167. return user, body, err
  168. }
  169. // GetUsers allows to get a list of users and checks the received HTTP Status code against expectedStatusCode.
  170. // The number of results can be limited specifying a limit.
  171. // Some results can be skipped specifying an offset.
  172. // The results can be filtered specifying an username, the username filter is an exact match
  173. func GetUsers(limit int64, offset int64, username string, expectedStatusCode int) ([]dataprovider.User, []byte, error) {
  174. var users []dataprovider.User
  175. var body []byte
  176. url, err := url.Parse(buildURLRelativeToBase(userPath))
  177. if err != nil {
  178. return users, body, err
  179. }
  180. q := url.Query()
  181. if limit > 0 {
  182. q.Add("limit", strconv.FormatInt(limit, 10))
  183. }
  184. if offset > 0 {
  185. q.Add("offset", strconv.FormatInt(offset, 10))
  186. }
  187. if len(username) > 0 {
  188. q.Add("username", username)
  189. }
  190. url.RawQuery = q.Encode()
  191. resp, err := sendHTTPRequest(http.MethodGet, url.String(), nil, "")
  192. if err != nil {
  193. return users, body, err
  194. }
  195. defer resp.Body.Close()
  196. err = checkResponse(resp.StatusCode, expectedStatusCode)
  197. if err == nil && expectedStatusCode == http.StatusOK {
  198. err = render.DecodeJSON(resp.Body, &users)
  199. } else {
  200. body, _ = getResponseBody(resp)
  201. }
  202. return users, body, err
  203. }
  204. // GetQuotaScans gets active quota scans and checks the received HTTP Status code against expectedStatusCode.
  205. func GetQuotaScans(expectedStatusCode int) ([]sftpd.ActiveQuotaScan, []byte, error) {
  206. var quotaScans []sftpd.ActiveQuotaScan
  207. var body []byte
  208. resp, err := sendHTTPRequest(http.MethodGet, buildURLRelativeToBase(quotaScanPath), nil, "")
  209. if err != nil {
  210. return quotaScans, body, err
  211. }
  212. defer resp.Body.Close()
  213. err = checkResponse(resp.StatusCode, expectedStatusCode)
  214. if err == nil && expectedStatusCode == http.StatusOK {
  215. err = render.DecodeJSON(resp.Body, &quotaScans)
  216. } else {
  217. body, _ = getResponseBody(resp)
  218. }
  219. return quotaScans, body, err
  220. }
  221. // StartQuotaScan start a new quota scan for the given user and checks the received HTTP Status code against expectedStatusCode.
  222. func StartQuotaScan(user dataprovider.User, expectedStatusCode int) ([]byte, error) {
  223. var body []byte
  224. userAsJSON, err := json.Marshal(user)
  225. if err != nil {
  226. return body, err
  227. }
  228. resp, err := sendHTTPRequest(http.MethodPost, buildURLRelativeToBase(quotaScanPath), bytes.NewBuffer(userAsJSON), "")
  229. if err != nil {
  230. return body, err
  231. }
  232. defer resp.Body.Close()
  233. body, _ = getResponseBody(resp)
  234. return body, checkResponse(resp.StatusCode, expectedStatusCode)
  235. }
  236. // GetConnections returns status and stats for active SFTP/SCP connections
  237. func GetConnections(expectedStatusCode int) ([]sftpd.ConnectionStatus, []byte, error) {
  238. var connections []sftpd.ConnectionStatus
  239. var body []byte
  240. resp, err := sendHTTPRequest(http.MethodGet, buildURLRelativeToBase(activeConnectionsPath), nil, "")
  241. if err != nil {
  242. return connections, body, err
  243. }
  244. defer resp.Body.Close()
  245. err = checkResponse(resp.StatusCode, expectedStatusCode)
  246. if err == nil && expectedStatusCode == http.StatusOK {
  247. err = render.DecodeJSON(resp.Body, &connections)
  248. } else {
  249. body, _ = getResponseBody(resp)
  250. }
  251. return connections, body, err
  252. }
  253. // CloseConnection closes an active connection identified by connectionID
  254. func CloseConnection(connectionID string, expectedStatusCode int) ([]byte, error) {
  255. var body []byte
  256. resp, err := sendHTTPRequest(http.MethodDelete, buildURLRelativeToBase(activeConnectionsPath, connectionID), nil, "")
  257. if err != nil {
  258. return body, err
  259. }
  260. defer resp.Body.Close()
  261. err = checkResponse(resp.StatusCode, expectedStatusCode)
  262. body, _ = getResponseBody(resp)
  263. return body, err
  264. }
  265. // GetVersion returns version details
  266. func GetVersion(expectedStatusCode int) (utils.VersionInfo, []byte, error) {
  267. var version utils.VersionInfo
  268. var body []byte
  269. resp, err := sendHTTPRequest(http.MethodGet, buildURLRelativeToBase(versionPath), nil, "")
  270. if err != nil {
  271. return version, body, err
  272. }
  273. defer resp.Body.Close()
  274. err = checkResponse(resp.StatusCode, expectedStatusCode)
  275. if err == nil && expectedStatusCode == http.StatusOK {
  276. err = render.DecodeJSON(resp.Body, &version)
  277. } else {
  278. body, _ = getResponseBody(resp)
  279. }
  280. return version, body, err
  281. }
  282. // GetProviderStatus returns provider status
  283. func GetProviderStatus(expectedStatusCode int) (map[string]interface{}, []byte, error) {
  284. var response map[string]interface{}
  285. var body []byte
  286. resp, err := sendHTTPRequest(http.MethodGet, buildURLRelativeToBase(providerStatusPath), nil, "")
  287. if err != nil {
  288. return response, body, err
  289. }
  290. defer resp.Body.Close()
  291. err = checkResponse(resp.StatusCode, expectedStatusCode)
  292. if err == nil && (expectedStatusCode == http.StatusOK || expectedStatusCode == http.StatusInternalServerError) {
  293. err = render.DecodeJSON(resp.Body, &response)
  294. } else {
  295. body, _ = getResponseBody(resp)
  296. }
  297. return response, body, err
  298. }
  299. // Dumpdata requests a backup to outputFile.
  300. // outputFile is relative to the configured backups_path
  301. func Dumpdata(outputFile, indent string, expectedStatusCode int) (map[string]interface{}, []byte, error) {
  302. var response map[string]interface{}
  303. var body []byte
  304. url, err := url.Parse(buildURLRelativeToBase(dumpDataPath))
  305. if err != nil {
  306. return response, body, err
  307. }
  308. q := url.Query()
  309. q.Add("output_file", outputFile)
  310. if len(indent) > 0 {
  311. q.Add("indent", indent)
  312. }
  313. url.RawQuery = q.Encode()
  314. resp, err := sendHTTPRequest(http.MethodGet, url.String(), nil, "")
  315. if err != nil {
  316. return response, body, err
  317. }
  318. defer resp.Body.Close()
  319. err = checkResponse(resp.StatusCode, expectedStatusCode)
  320. if err == nil && expectedStatusCode == http.StatusOK {
  321. err = render.DecodeJSON(resp.Body, &response)
  322. } else {
  323. body, _ = getResponseBody(resp)
  324. }
  325. return response, body, err
  326. }
  327. // Loaddata restores a backup.
  328. // New users are added, existing users are updated. Users will be restored one by one and the restore is stopped if a
  329. // user cannot be added/updated, so it could happen a partial restore
  330. func Loaddata(inputFile, scanQuota, mode string, expectedStatusCode int) (map[string]interface{}, []byte, error) {
  331. var response map[string]interface{}
  332. var body []byte
  333. url, err := url.Parse(buildURLRelativeToBase(loadDataPath))
  334. if err != nil {
  335. return response, body, err
  336. }
  337. q := url.Query()
  338. q.Add("input_file", inputFile)
  339. if len(scanQuota) > 0 {
  340. q.Add("scan_quota", scanQuota)
  341. }
  342. if len(mode) > 0 {
  343. q.Add("mode", mode)
  344. }
  345. url.RawQuery = q.Encode()
  346. resp, err := sendHTTPRequest(http.MethodGet, url.String(), nil, "")
  347. if err != nil {
  348. return response, body, err
  349. }
  350. defer resp.Body.Close()
  351. err = checkResponse(resp.StatusCode, expectedStatusCode)
  352. if err == nil && expectedStatusCode == http.StatusOK {
  353. err = render.DecodeJSON(resp.Body, &response)
  354. } else {
  355. body, _ = getResponseBody(resp)
  356. }
  357. return response, body, err
  358. }
  359. func checkResponse(actual int, expected int) error {
  360. if expected != actual {
  361. return fmt.Errorf("wrong status code: got %v want %v", actual, expected)
  362. }
  363. return nil
  364. }
  365. func getResponseBody(resp *http.Response) ([]byte, error) {
  366. return ioutil.ReadAll(resp.Body)
  367. }
  368. func checkUser(expected *dataprovider.User, actual *dataprovider.User) error {
  369. if len(actual.Password) > 0 {
  370. return errors.New("User password must not be visible")
  371. }
  372. if expected.ID <= 0 {
  373. if actual.ID <= 0 {
  374. return errors.New("actual user ID must be > 0")
  375. }
  376. } else {
  377. if actual.ID != expected.ID {
  378. return errors.New("user ID mismatch")
  379. }
  380. }
  381. if len(expected.Permissions) != len(actual.Permissions) {
  382. return errors.New("Permissions mismatch")
  383. }
  384. for dir, perms := range expected.Permissions {
  385. if actualPerms, ok := actual.Permissions[dir]; ok {
  386. for _, v := range actualPerms {
  387. if !utils.IsStringInSlice(v, perms) {
  388. return errors.New("Permissions contents mismatch")
  389. }
  390. }
  391. } else {
  392. return errors.New("Permissions directories mismatch")
  393. }
  394. }
  395. if err := compareUserFilters(expected, actual); err != nil {
  396. return err
  397. }
  398. if err := compareUserFsConfig(expected, actual); err != nil {
  399. return err
  400. }
  401. if err := compareUserVirtualFolders(expected, actual); err != nil {
  402. return err
  403. }
  404. return compareEqualsUserFields(expected, actual)
  405. }
  406. func compareUserVirtualFolders(expected *dataprovider.User, actual *dataprovider.User) error {
  407. if len(actual.VirtualFolders) != len(expected.VirtualFolders) {
  408. return errors.New("Virtual folders mismatch")
  409. }
  410. for _, v := range actual.VirtualFolders {
  411. found := false
  412. for _, v1 := range expected.VirtualFolders {
  413. if path.Clean(v.VirtualPath) == path.Clean(v1.VirtualPath) &&
  414. filepath.Clean(v.MappedPath) == filepath.Clean(v1.MappedPath) {
  415. found = true
  416. break
  417. }
  418. }
  419. if !found {
  420. return errors.New("Virtual folders mismatch")
  421. }
  422. }
  423. return nil
  424. }
  425. func compareUserFsConfig(expected *dataprovider.User, actual *dataprovider.User) error {
  426. if expected.FsConfig.Provider != actual.FsConfig.Provider {
  427. return errors.New("Fs provider mismatch")
  428. }
  429. if err := compareS3Config(expected, actual); err != nil {
  430. return err
  431. }
  432. if err := compareGCSConfig(expected, actual); err != nil {
  433. return err
  434. }
  435. return nil
  436. }
  437. func compareS3Config(expected *dataprovider.User, actual *dataprovider.User) error {
  438. if expected.FsConfig.S3Config.Bucket != actual.FsConfig.S3Config.Bucket {
  439. return errors.New("S3 bucket mismatch")
  440. }
  441. if expected.FsConfig.S3Config.Region != actual.FsConfig.S3Config.Region {
  442. return errors.New("S3 region mismatch")
  443. }
  444. if expected.FsConfig.S3Config.AccessKey != actual.FsConfig.S3Config.AccessKey {
  445. return errors.New("S3 access key mismatch")
  446. }
  447. if err := checkS3AccessSecret(expected.FsConfig.S3Config.AccessSecret, actual.FsConfig.S3Config.AccessSecret); err != nil {
  448. return err
  449. }
  450. if expected.FsConfig.S3Config.Endpoint != actual.FsConfig.S3Config.Endpoint {
  451. return errors.New("S3 endpoint mismatch")
  452. }
  453. if expected.FsConfig.S3Config.StorageClass != actual.FsConfig.S3Config.StorageClass {
  454. return errors.New("S3 storage class mismatch")
  455. }
  456. if expected.FsConfig.S3Config.UploadPartSize != actual.FsConfig.S3Config.UploadPartSize {
  457. return errors.New("S3 upload part size mismatch")
  458. }
  459. if expected.FsConfig.S3Config.UploadConcurrency != actual.FsConfig.S3Config.UploadConcurrency {
  460. return errors.New("S3 upload concurrency mismatch")
  461. }
  462. if expected.FsConfig.S3Config.KeyPrefix != actual.FsConfig.S3Config.KeyPrefix &&
  463. expected.FsConfig.S3Config.KeyPrefix+"/" != actual.FsConfig.S3Config.KeyPrefix {
  464. return errors.New("S3 key prefix mismatch")
  465. }
  466. return nil
  467. }
  468. func compareGCSConfig(expected *dataprovider.User, actual *dataprovider.User) error {
  469. if expected.FsConfig.GCSConfig.Bucket != actual.FsConfig.GCSConfig.Bucket {
  470. return errors.New("GCS bucket mismatch")
  471. }
  472. if expected.FsConfig.GCSConfig.StorageClass != actual.FsConfig.GCSConfig.StorageClass {
  473. return errors.New("GCS storage class mismatch")
  474. }
  475. if expected.FsConfig.GCSConfig.KeyPrefix != actual.FsConfig.GCSConfig.KeyPrefix &&
  476. expected.FsConfig.GCSConfig.KeyPrefix+"/" != actual.FsConfig.GCSConfig.KeyPrefix {
  477. return errors.New("GCS key prefix mismatch")
  478. }
  479. if expected.FsConfig.GCSConfig.AutomaticCredentials != actual.FsConfig.GCSConfig.AutomaticCredentials {
  480. return errors.New("GCS automatic credentials mismatch")
  481. }
  482. return nil
  483. }
  484. func checkS3AccessSecret(expectedAccessSecret, actualAccessSecret string) error {
  485. if len(expectedAccessSecret) > 0 {
  486. vals := strings.Split(expectedAccessSecret, "$")
  487. if strings.HasPrefix(expectedAccessSecret, "$aes$") && len(vals) == 4 {
  488. expectedAccessSecret = utils.RemoveDecryptionKey(expectedAccessSecret)
  489. if expectedAccessSecret != actualAccessSecret {
  490. return fmt.Errorf("S3 access secret mismatch, expected: %v", expectedAccessSecret)
  491. }
  492. } else {
  493. // here we check that actualAccessSecret is aes encrypted without the nonce
  494. parts := strings.Split(actualAccessSecret, "$")
  495. if !strings.HasPrefix(actualAccessSecret, "$aes$") || len(parts) != 3 {
  496. return errors.New("Invalid S3 access secret")
  497. }
  498. if len(parts) == len(vals) {
  499. if expectedAccessSecret != actualAccessSecret {
  500. return errors.New("S3 encrypted access secret mismatch")
  501. }
  502. }
  503. }
  504. } else {
  505. if expectedAccessSecret != actualAccessSecret {
  506. return errors.New("S3 access secret mismatch")
  507. }
  508. }
  509. return nil
  510. }
  511. func compareUserFilters(expected *dataprovider.User, actual *dataprovider.User) error {
  512. if len(expected.Filters.AllowedIP) != len(actual.Filters.AllowedIP) {
  513. return errors.New("AllowedIP mismatch")
  514. }
  515. if len(expected.Filters.DeniedIP) != len(actual.Filters.DeniedIP) {
  516. return errors.New("DeniedIP mismatch")
  517. }
  518. if len(expected.Filters.DeniedLoginMethods) != len(actual.Filters.DeniedLoginMethods) {
  519. return errors.New("Denied login methods mismatch")
  520. }
  521. for _, IPMask := range expected.Filters.AllowedIP {
  522. if !utils.IsStringInSlice(IPMask, actual.Filters.AllowedIP) {
  523. return errors.New("AllowedIP contents mismatch")
  524. }
  525. }
  526. for _, IPMask := range expected.Filters.DeniedIP {
  527. if !utils.IsStringInSlice(IPMask, actual.Filters.DeniedIP) {
  528. return errors.New("DeniedIP contents mismatch")
  529. }
  530. }
  531. for _, method := range expected.Filters.DeniedLoginMethods {
  532. if !utils.IsStringInSlice(method, actual.Filters.DeniedLoginMethods) {
  533. return errors.New("Denied login methods contents mismatch")
  534. }
  535. }
  536. if err := compareUserFileExtensionsFilters(expected, actual); err != nil {
  537. return err
  538. }
  539. return nil
  540. }
  541. func compareUserFileExtensionsFilters(expected *dataprovider.User, actual *dataprovider.User) error {
  542. if len(expected.Filters.FileExtensions) != len(actual.Filters.FileExtensions) {
  543. return errors.New("file extensions mismatch")
  544. }
  545. for _, f := range expected.Filters.FileExtensions {
  546. found := false
  547. for _, f1 := range actual.Filters.FileExtensions {
  548. if path.Clean(f.Path) == path.Clean(f1.Path) {
  549. if len(f.AllowedExtensions) != len(f1.AllowedExtensions) || len(f.DeniedExtensions) != len(f1.DeniedExtensions) {
  550. return errors.New("file extensions contents mismatch")
  551. }
  552. for _, e := range f.AllowedExtensions {
  553. if !utils.IsStringInSlice(e, f1.AllowedExtensions) {
  554. return errors.New("file extensions contents mismatch")
  555. }
  556. }
  557. for _, e := range f.DeniedExtensions {
  558. if !utils.IsStringInSlice(e, f1.DeniedExtensions) {
  559. return errors.New("file extensions contents mismatch")
  560. }
  561. }
  562. found = true
  563. }
  564. }
  565. if !found {
  566. return errors.New("file extensions contents mismatch")
  567. }
  568. }
  569. return nil
  570. }
  571. func compareEqualsUserFields(expected *dataprovider.User, actual *dataprovider.User) error {
  572. if expected.Username != actual.Username {
  573. return errors.New("Username mismatch")
  574. }
  575. if expected.HomeDir != actual.HomeDir {
  576. return errors.New("HomeDir mismatch")
  577. }
  578. if expected.UID != actual.UID {
  579. return errors.New("UID mismatch")
  580. }
  581. if expected.GID != actual.GID {
  582. return errors.New("GID mismatch")
  583. }
  584. if expected.MaxSessions != actual.MaxSessions {
  585. return errors.New("MaxSessions mismatch")
  586. }
  587. if expected.QuotaSize != actual.QuotaSize {
  588. return errors.New("QuotaSize mismatch")
  589. }
  590. if expected.QuotaFiles != actual.QuotaFiles {
  591. return errors.New("QuotaFiles mismatch")
  592. }
  593. if len(expected.Permissions) != len(actual.Permissions) {
  594. return errors.New("Permissions mismatch")
  595. }
  596. if expected.UploadBandwidth != actual.UploadBandwidth {
  597. return errors.New("UploadBandwidth mismatch")
  598. }
  599. if expected.DownloadBandwidth != actual.DownloadBandwidth {
  600. return errors.New("DownloadBandwidth mismatch")
  601. }
  602. if expected.Status != actual.Status {
  603. return errors.New("Status mismatch")
  604. }
  605. if expected.ExpirationDate != actual.ExpirationDate {
  606. return errors.New("ExpirationDate mismatch")
  607. }
  608. return nil
  609. }