1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144 |
- // Copyright (C) 2014 The Syncthing Authors.
- //
- // This Source Code Form is subject to the terms of the Mozilla Public
- // License, v. 2.0. If a copy of the MPL was not distributed with this file,
- // You can obtain one at https://mozilla.org/MPL/2.0/.
- package model
- import (
- "bytes"
- "context"
- "encoding/json"
- "errors"
- "fmt"
- "io"
- mrand "math/rand"
- "os"
- "path/filepath"
- "runtime/pprof"
- "sort"
- "strconv"
- "strings"
- "sync"
- "testing"
- "time"
- "github.com/syncthing/syncthing/lib/build"
- "github.com/syncthing/syncthing/lib/config"
- "github.com/syncthing/syncthing/lib/db"
- "github.com/syncthing/syncthing/lib/db/backend"
- "github.com/syncthing/syncthing/lib/events"
- "github.com/syncthing/syncthing/lib/fs"
- "github.com/syncthing/syncthing/lib/ignore"
- "github.com/syncthing/syncthing/lib/osutil"
- "github.com/syncthing/syncthing/lib/protocol"
- protocolmocks "github.com/syncthing/syncthing/lib/protocol/mocks"
- srand "github.com/syncthing/syncthing/lib/rand"
- "github.com/syncthing/syncthing/lib/semaphore"
- "github.com/syncthing/syncthing/lib/testutil"
- "github.com/syncthing/syncthing/lib/versioner"
- )
- func newState(t testing.TB, cfg config.Configuration) (*testModel, context.CancelFunc) {
- wcfg, cancel := newConfigWrapper(cfg)
- m := setupModel(t, wcfg)
- for _, dev := range cfg.Devices {
- m.AddConnection(newFakeConnection(dev.DeviceID, m), protocol.Hello{})
- }
- return m, cancel
- }
- func createClusterConfig(remote protocol.DeviceID, ids ...string) protocol.ClusterConfig {
- cc := protocol.ClusterConfig{
- Folders: make([]protocol.Folder, len(ids)),
- }
- for i, id := range ids {
- cc.Folders[i] = protocol.Folder{
- ID: id,
- Label: id,
- }
- }
- return addFolderDevicesToClusterConfig(cc, remote)
- }
- func addFolderDevicesToClusterConfig(cc protocol.ClusterConfig, remote protocol.DeviceID) protocol.ClusterConfig {
- for i := range cc.Folders {
- cc.Folders[i].Devices = []protocol.Device{
- {ID: myID},
- {ID: remote},
- }
- }
- return cc
- }
- func TestRequest(t *testing.T) {
- wrapper, fcfg, cancel := newDefaultCfgWrapper()
- ffs := fcfg.Filesystem(nil)
- defer cancel()
- m := setupModel(t, wrapper)
- defer cleanupModel(m)
- fd, err := ffs.Create("foo")
- if err != nil {
- t.Fatal(err)
- }
- if _, err := fd.Write([]byte("foobar")); err != nil {
- t.Fatal(err)
- }
- fd.Close()
- m.ScanFolder("default")
- // Existing, shared file
- res, err := m.Request(device1Conn, "default", "foo", 0, 6, 0, nil, 0, false)
- if err != nil {
- t.Fatal(err)
- }
- bs := res.Data()
- if !bytes.Equal(bs, []byte("foobar")) {
- t.Errorf("Incorrect data from request: %q", string(bs))
- }
- // Existing, nonshared file
- _, err = m.Request(device2Conn, "default", "foo", 0, 6, 0, nil, 0, false)
- if err == nil {
- t.Error("Unexpected nil error on insecure file read")
- }
- // Nonexistent file
- _, err = m.Request(device1Conn, "default", "nonexistent", 0, 6, 0, nil, 0, false)
- if err == nil {
- t.Error("Unexpected nil error on insecure file read")
- }
- // Shared folder, but disallowed file name
- _, err = m.Request(device1Conn, "default", "../walk.go", 0, 6, 0, nil, 0, false)
- if err == nil {
- t.Error("Unexpected nil error on insecure file read")
- }
- // Negative offset
- _, err = m.Request(device1Conn, "default", "foo", 0, -4, 0, nil, 0, false)
- if err == nil {
- t.Error("Unexpected nil error on insecure file read")
- }
- // Larger block than available
- _, err = m.Request(device1Conn, "default", "foo", 0, 42, 0, []byte("hash necessary but not checked"), 0, false)
- if err == nil {
- t.Error("Unexpected nil error on read past end of file")
- }
- _, err = m.Request(device1Conn, "default", "foo", 0, 42, 0, nil, 0, false)
- if err != nil {
- t.Error("Unexpected error when large read should be permitted")
- }
- }
- func genFiles(n int) []protocol.FileInfo {
- files := make([]protocol.FileInfo, n)
- t := time.Now().Unix()
- for i := 0; i < n; i++ {
- files[i] = protocol.FileInfo{
- Name: fmt.Sprintf("file%d", i),
- ModifiedS: t,
- Sequence: int64(i + 1),
- Blocks: []protocol.BlockInfo{{Offset: 0, Size: 100, Hash: []byte("some hash bytes")}},
- Version: protocol.Vector{Counters: []protocol.Counter{{ID: 42, Value: 1}}},
- }
- }
- return files
- }
- func BenchmarkIndex_10000(b *testing.B) {
- benchmarkIndex(b, 10000)
- }
- func BenchmarkIndex_100(b *testing.B) {
- benchmarkIndex(b, 100)
- }
- func benchmarkIndex(b *testing.B, nfiles int) {
- m, _, fcfg, wcfgCancel := setupModelWithConnection(b)
- defer wcfgCancel()
- defer cleanupModelAndRemoveDir(m, fcfg.Filesystem(nil).URI())
- files := genFiles(nfiles)
- must(b, m.Index(device1Conn, fcfg.ID, files))
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- must(b, m.Index(device1Conn, fcfg.ID, files))
- }
- b.ReportAllocs()
- }
- func BenchmarkIndexUpdate_10000_10000(b *testing.B) {
- benchmarkIndexUpdate(b, 10000, 10000)
- }
- func BenchmarkIndexUpdate_10000_100(b *testing.B) {
- benchmarkIndexUpdate(b, 10000, 100)
- }
- func BenchmarkIndexUpdate_10000_1(b *testing.B) {
- benchmarkIndexUpdate(b, 10000, 1)
- }
- func benchmarkIndexUpdate(b *testing.B, nfiles, nufiles int) {
- m, _, fcfg, wcfgCancel := setupModelWithConnection(b)
- defer wcfgCancel()
- defer cleanupModelAndRemoveDir(m, fcfg.Filesystem(nil).URI())
- files := genFiles(nfiles)
- ufiles := genFiles(nufiles)
- must(b, m.Index(device1Conn, fcfg.ID, files))
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- must(b, m.IndexUpdate(device1Conn, fcfg.ID, ufiles))
- }
- b.ReportAllocs()
- }
- func BenchmarkRequestOut(b *testing.B) {
- m := setupModel(b, defaultCfgWrapper)
- defer cleanupModel(m)
- const n = 1000
- files := genFiles(n)
- fc := newFakeConnection(device1, m)
- for _, f := range files {
- fc.addFile(f.Name, 0o644, protocol.FileInfoTypeFile, []byte("some data to return"))
- }
- m.AddConnection(fc, protocol.Hello{})
- must(b, m.Index(device1Conn, "default", files))
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- data, err := m.requestGlobal(context.Background(), device1, "default", files[i%n].Name, 0, 0, 32, nil, 0, false)
- if err != nil {
- b.Error(err)
- }
- if data == nil {
- b.Error("nil data")
- }
- }
- }
- func BenchmarkRequestInSingleFile(b *testing.B) {
- w, cancel := newConfigWrapper(defaultCfg)
- defer cancel()
- ffs := w.FolderList()[0].Filesystem(nil)
- m := setupModel(b, w)
- defer cleanupModel(m)
- buf := make([]byte, 128<<10)
- srand.Read(buf)
- must(b, ffs.MkdirAll("request/for/a/file/in/a/couple/of/dirs", 0o755))
- writeFile(b, ffs, "request/for/a/file/in/a/couple/of/dirs/128k", buf)
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- if _, err := m.Request(device1Conn, "default", "request/for/a/file/in/a/couple/of/dirs/128k", 0, 128<<10, 0, nil, 0, false); err != nil {
- b.Error(err)
- }
- }
- b.SetBytes(128 << 10)
- }
- func TestDeviceRename(t *testing.T) {
- hello := protocol.Hello{
- ClientName: "syncthing",
- ClientVersion: "v0.9.4",
- }
- rawCfg := config.New(device1)
- rawCfg.Devices = []config.DeviceConfiguration{
- {
- DeviceID: device1,
- },
- }
- cfg, cfgCancel := newConfigWrapper(rawCfg)
- defer cfgCancel()
- m := newModel(t, cfg, myID, nil)
- if cfg.Devices()[device1].Name != "" {
- t.Errorf("Device already has a name")
- }
- conn := newFakeConnection(device1, m)
- m.AddConnection(conn, hello)
- m.ServeBackground()
- defer cleanupModel(m)
- if cfg.Devices()[device1].Name != "" {
- t.Errorf("Device already has a name")
- }
- m.Closed(conn, protocol.ErrTimeout)
- hello.DeviceName = "tester"
- m.AddConnection(conn, hello)
- if cfg.Devices()[device1].Name != "tester" {
- t.Errorf("Device did not get a name")
- }
- m.Closed(conn, protocol.ErrTimeout)
- hello.DeviceName = "tester2"
- m.AddConnection(conn, hello)
- if cfg.Devices()[device1].Name != "tester" {
- t.Errorf("Device name got overwritten")
- }
- ffs := fs.NewFilesystem(fs.FilesystemTypeFake, srand.String(32)+"?content=true")
- path := "someConfigfile"
- must(t, saveConfig(ffs, path, cfg.RawCopy()))
- cfgw, _, err := loadConfig(ffs, path, myID, events.NoopLogger)
- if err != nil {
- t.Error(err)
- return
- }
- if cfgw.Devices()[device1].Name != "tester" {
- t.Errorf("Device name not saved in config")
- }
- m.Closed(conn, protocol.ErrTimeout)
- waiter, err := cfg.Modify(func(cfg *config.Configuration) {
- cfg.Options.OverwriteRemoteDevNames = true
- })
- must(t, err)
- waiter.Wait()
- hello.DeviceName = "tester2"
- m.AddConnection(conn, hello)
- if cfg.Devices()[device1].Name != "tester2" {
- t.Errorf("Device name not overwritten")
- }
- }
- // Adjusted copy of the original function for testing purposes
- func saveConfig(ffs fs.Filesystem, path string, cfg config.Configuration) error {
- fd, err := ffs.Create(path)
- if err != nil {
- l.Debugln("Create:", err)
- return err
- }
- if err := cfg.WriteXML(osutil.LineEndingsWriter(fd)); err != nil {
- l.Debugln("WriteXML:", err)
- fd.Close()
- return err
- }
- if err := fd.Close(); err != nil {
- l.Debugln("Close:", err)
- return err
- }
- if _, err := ffs.Lstat(path); err != nil {
- return err
- }
- return nil
- }
- // Adjusted copy of the original function for testing purposes
- func loadConfig(ffs fs.Filesystem, path string, myID protocol.DeviceID, evLogger events.Logger) (config.Wrapper, int, error) {
- if _, err := ffs.Lstat(path); err != nil {
- return nil, 0, err
- }
- fd, err := ffs.OpenFile(path, fs.OptReadWrite, 0o666)
- if err != nil {
- return nil, 0, err
- }
- defer fd.Close()
- cfg, originalVersion, err := config.ReadXML(fd, myID)
- if err != nil {
- return nil, 0, err
- }
- return config.Wrap(path, cfg, myID, evLogger), originalVersion, nil
- }
- func TestClusterConfig(t *testing.T) {
- cfg := config.New(device1)
- cfg.Options.MinHomeDiskFree.Value = 0 // avoids unnecessary free space checks
- cfg.Devices = []config.DeviceConfiguration{
- {
- DeviceID: device1,
- Introducer: true,
- },
- {
- DeviceID: device2,
- },
- }
- cfg.Folders = []config.FolderConfiguration{
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder1",
- Path: "testdata1",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- {DeviceID: device2},
- },
- },
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder2",
- Path: "testdata2",
- Paused: true, // should still be included
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- {DeviceID: device2},
- },
- },
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder3",
- Path: "testdata3",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- // should not be included, does not include device2
- },
- },
- }
- wrapper, cancel := newConfigWrapper(cfg)
- defer cancel()
- m := newModel(t, wrapper, myID, nil)
- m.ServeBackground()
- defer cleanupModel(m)
- cm, _ := m.generateClusterConfig(device2)
- if l := len(cm.Folders); l != 2 {
- t.Fatalf("Incorrect number of folders %d != 2", l)
- }
- r := cm.Folders[0]
- if r.ID != "folder1" {
- t.Errorf("Incorrect folder %q != folder1", r.ID)
- }
- if l := len(r.Devices); l != 2 {
- t.Errorf("Incorrect number of devices %d != 2", l)
- }
- if id := r.Devices[0].ID; id != device1 {
- t.Errorf("Incorrect device ID %s != %s", id, device1)
- }
- if !r.Devices[0].Introducer {
- t.Error("Device1 should be flagged as Introducer")
- }
- if id := r.Devices[1].ID; id != device2 {
- t.Errorf("Incorrect device ID %s != %s", id, device2)
- }
- if r.Devices[1].Introducer {
- t.Error("Device2 should not be flagged as Introducer")
- }
- r = cm.Folders[1]
- if r.ID != "folder2" {
- t.Errorf("Incorrect folder %q != folder2", r.ID)
- }
- if l := len(r.Devices); l != 2 {
- t.Errorf("Incorrect number of devices %d != 2", l)
- }
- if id := r.Devices[0].ID; id != device1 {
- t.Errorf("Incorrect device ID %s != %s", id, device1)
- }
- if !r.Devices[0].Introducer {
- t.Error("Device1 should be flagged as Introducer")
- }
- if id := r.Devices[1].ID; id != device2 {
- t.Errorf("Incorrect device ID %s != %s", id, device2)
- }
- if r.Devices[1].Introducer {
- t.Error("Device2 should not be flagged as Introducer")
- }
- }
- func TestIntroducer(t *testing.T) {
- var introducedByAnyone protocol.DeviceID
- // LocalDeviceID is a magic value meaning don't check introducer
- contains := func(cfg config.FolderConfiguration, id, introducedBy protocol.DeviceID) bool {
- for _, dev := range cfg.Devices {
- if dev.DeviceID.Equals(id) {
- if introducedBy.Equals(introducedByAnyone) {
- return true
- }
- return dev.IntroducedBy.Equals(introducedBy)
- }
- }
- return false
- }
- m, cancel := newState(t, config.Configuration{
- Version: config.CurrentVersion,
- Devices: []config.DeviceConfiguration{
- {
- DeviceID: device1,
- Introducer: true,
- },
- },
- Folders: []config.FolderConfiguration{
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder1",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- },
- },
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder2",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- },
- },
- },
- })
- cc := basicClusterConfig(myID, device1, "folder1", "folder2")
- cc.Folders[0].Devices = append(cc.Folders[0].Devices, protocol.Device{
- ID: device2,
- Introducer: true,
- SkipIntroductionRemovals: true,
- })
- cc.Folders[1].Devices = append(cc.Folders[1].Devices, protocol.Device{
- ID: device2,
- Introducer: true,
- SkipIntroductionRemovals: true,
- EncryptionPasswordToken: []byte("faketoken"),
- })
- m.ClusterConfig(device1Conn, cc)
- if newDev, ok := m.cfg.Device(device2); !ok || !newDev.Introducer || !newDev.SkipIntroductionRemovals {
- t.Error("device 2 missing or wrong flags")
- }
- if !contains(m.cfg.Folders()["folder1"], device2, device1) {
- t.Error("expected folder 1 to have device2 introduced by device 1")
- }
- for _, devCfg := range m.cfg.Folders()["folder2"].Devices {
- if devCfg.DeviceID == device2 {
- t.Error("Device was added even though it's untrusted")
- }
- }
- cleanupModel(m)
- cancel()
- m, cancel = newState(t, config.Configuration{
- Version: config.CurrentVersion,
- Devices: []config.DeviceConfiguration{
- {
- DeviceID: device1,
- Introducer: true,
- },
- {
- DeviceID: device2,
- IntroducedBy: device1,
- },
- },
- Folders: []config.FolderConfiguration{
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder1",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- {DeviceID: device2, IntroducedBy: device1},
- },
- },
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder2",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- },
- },
- },
- })
- cc = basicClusterConfig(myID, device1, "folder2")
- cc.Folders[0].Devices = append(cc.Folders[0].Devices, protocol.Device{
- ID: device2,
- Introducer: true,
- SkipIntroductionRemovals: true,
- })
- m.ClusterConfig(device1Conn, cc)
- // Should not get introducer, as it's already unset, and it's an existing device.
- if newDev, ok := m.cfg.Device(device2); !ok || newDev.Introducer || newDev.SkipIntroductionRemovals {
- t.Error("device 2 missing or changed flags")
- }
- if contains(m.cfg.Folders()["folder1"], device2, introducedByAnyone) {
- t.Error("expected device 2 to be removed from folder 1")
- }
- if !contains(m.cfg.Folders()["folder2"], device2, device1) {
- t.Error("expected device 2 to be added to folder 2")
- }
- cleanupModel(m)
- cancel()
- m, cancel = newState(t, config.Configuration{
- Version: config.CurrentVersion,
- Devices: []config.DeviceConfiguration{
- {
- DeviceID: device1,
- Introducer: true,
- },
- {
- DeviceID: device2,
- IntroducedBy: device1,
- },
- },
- Folders: []config.FolderConfiguration{
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder1",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- {DeviceID: device2, IntroducedBy: device1},
- },
- },
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder2",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- {DeviceID: device2, IntroducedBy: device1},
- },
- },
- },
- })
- m.ClusterConfig(device1Conn, protocol.ClusterConfig{})
- if _, ok := m.cfg.Device(device2); ok {
- t.Error("device 2 should have been removed")
- }
- if contains(m.cfg.Folders()["folder1"], device2, introducedByAnyone) {
- t.Error("expected device 2 to be removed from folder 1")
- }
- if contains(m.cfg.Folders()["folder2"], device2, introducedByAnyone) {
- t.Error("expected device 2 to be removed from folder 2")
- }
- // Two cases when removals should not happen
- // 1. Introducer flag no longer set on device
- cleanupModel(m)
- cancel()
- m, cancel = newState(t, config.Configuration{
- Version: config.CurrentVersion,
- Devices: []config.DeviceConfiguration{
- {
- DeviceID: device1,
- Introducer: false,
- },
- {
- DeviceID: device2,
- IntroducedBy: device1,
- },
- },
- Folders: []config.FolderConfiguration{
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder1",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- {DeviceID: device2, IntroducedBy: device1},
- },
- },
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder2",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- {DeviceID: device2, IntroducedBy: device1},
- },
- },
- },
- })
- m.ClusterConfig(device1Conn, protocol.ClusterConfig{})
- if _, ok := m.cfg.Device(device2); !ok {
- t.Error("device 2 should not have been removed")
- }
- if !contains(m.cfg.Folders()["folder1"], device2, device1) {
- t.Error("expected device 2 not to be removed from folder 1")
- }
- if !contains(m.cfg.Folders()["folder2"], device2, device1) {
- t.Error("expected device 2 not to be removed from folder 2")
- }
- // 2. SkipIntroductionRemovals is set
- cleanupModel(m)
- cancel()
- m, cancel = newState(t, config.Configuration{
- Version: config.CurrentVersion,
- Devices: []config.DeviceConfiguration{
- {
- DeviceID: device1,
- Introducer: true,
- SkipIntroductionRemovals: true,
- },
- {
- DeviceID: device2,
- IntroducedBy: device1,
- },
- },
- Folders: []config.FolderConfiguration{
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder1",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- {DeviceID: device2, IntroducedBy: device1},
- },
- },
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder2",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- },
- },
- },
- })
- cc = basicClusterConfig(myID, device1, "folder2")
- cc.Folders[0].Devices = append(cc.Folders[0].Devices, protocol.Device{
- ID: device2,
- Introducer: true,
- SkipIntroductionRemovals: true,
- })
- m.ClusterConfig(device1Conn, cc)
- if _, ok := m.cfg.Device(device2); !ok {
- t.Error("device 2 should not have been removed")
- }
- if !contains(m.cfg.Folders()["folder1"], device2, device1) {
- t.Error("expected device 2 not to be removed from folder 1")
- }
- if !contains(m.cfg.Folders()["folder2"], device2, device1) {
- t.Error("expected device 2 not to be added to folder 2")
- }
- // Test device not being removed as it's shared without an introducer.
- cleanupModel(m)
- cancel()
- m, cancel = newState(t, config.Configuration{
- Version: config.CurrentVersion,
- Devices: []config.DeviceConfiguration{
- {
- DeviceID: device1,
- Introducer: true,
- },
- {
- DeviceID: device2,
- IntroducedBy: device1,
- },
- },
- Folders: []config.FolderConfiguration{
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder1",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- {DeviceID: device2, IntroducedBy: device1},
- },
- },
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder2",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- {DeviceID: device2},
- },
- },
- },
- })
- m.ClusterConfig(device1Conn, protocol.ClusterConfig{})
- if _, ok := m.cfg.Device(device2); !ok {
- t.Error("device 2 should not have been removed")
- }
- if contains(m.cfg.Folders()["folder1"], device2, introducedByAnyone) {
- t.Error("expected device 2 to be removed from folder 1")
- }
- if !contains(m.cfg.Folders()["folder2"], device2, introducedByAnyone) {
- t.Error("expected device 2 not to be removed from folder 2")
- }
- // Test device not being removed as it's shared by a different introducer.
- cleanupModel(m)
- cancel()
- m, cancel = newState(t, config.Configuration{
- Version: config.CurrentVersion,
- Devices: []config.DeviceConfiguration{
- {
- DeviceID: device1,
- Introducer: true,
- },
- {
- DeviceID: device2,
- IntroducedBy: device1,
- },
- },
- Folders: []config.FolderConfiguration{
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder1",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- {DeviceID: device2, IntroducedBy: device1},
- },
- },
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder2",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- {DeviceID: device2, IntroducedBy: myID},
- },
- },
- },
- })
- defer cleanupModel(m)
- defer cancel()
- m.ClusterConfig(device1Conn, protocol.ClusterConfig{})
- if _, ok := m.cfg.Device(device2); !ok {
- t.Error("device 2 should not have been removed")
- }
- if contains(m.cfg.Folders()["folder1"], device2, introducedByAnyone) {
- t.Error("expected device 2 to be removed from folder 1")
- }
- if !contains(m.cfg.Folders()["folder2"], device2, introducedByAnyone) {
- t.Error("expected device 2 not to be removed from folder 2")
- }
- }
- func TestIssue4897(t *testing.T) {
- m, cancel := newState(t, config.Configuration{
- Version: config.CurrentVersion,
- Devices: []config.DeviceConfiguration{
- {
- DeviceID: device1,
- Introducer: true,
- },
- },
- Folders: []config.FolderConfiguration{
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder1",
- Path: "testdata",
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- },
- Paused: true,
- },
- },
- })
- defer cleanupModel(m)
- cancel()
- cm, _ := m.generateClusterConfig(device1)
- if l := len(cm.Folders); l != 1 {
- t.Errorf("Cluster config contains %v folders, expected 1", l)
- }
- }
- // TestIssue5063 is about a panic in connection with modifying config in quick
- // succession, related with auto accepted folders. It's unclear what exactly, a
- // relevant bit seems to be here:
- // PR-comments: https://github.com/syncthing/syncthing/pull/5069/files#r203146546
- // Issue: https://github.com/syncthing/syncthing/pull/5509
- func TestIssue5063(t *testing.T) {
- m, cancel := newState(t, defaultAutoAcceptCfg)
- defer cleanupModel(m)
- defer cancel()
- m.pmut.Lock()
- for _, c := range m.connections {
- conn := c.(*fakeConnection)
- conn.CloseCalls(func(_ error) {})
- defer m.Closed(c, errStopped) // to unblock deferred m.Stop()
- }
- m.pmut.Unlock()
- wg := sync.WaitGroup{}
- addAndVerify := func(id string) {
- m.ClusterConfig(device1Conn, createClusterConfig(device1, id))
- if fcfg, ok := m.cfg.Folder(id); !ok || !fcfg.SharedWith(device1) {
- t.Error("expected shared", id)
- }
- wg.Done()
- }
- reps := 10
- ids := make([]string, reps)
- for i := 0; i < reps; i++ {
- wg.Add(1)
- ids[i] = srand.String(8)
- go addAndVerify(ids[i])
- }
- finished := make(chan struct{})
- go func() {
- wg.Wait()
- close(finished)
- }()
- select {
- case <-finished:
- case <-time.After(10 * time.Second):
- pprof.Lookup("goroutine").WriteTo(os.Stdout, 1)
- t.Fatal("Timed out before all devices were added")
- }
- }
- func TestAutoAcceptRejected(t *testing.T) {
- // Nothing happens if AutoAcceptFolders not set
- tcfg := defaultAutoAcceptCfg.Copy()
- for i := range tcfg.Devices {
- tcfg.Devices[i].AutoAcceptFolders = false
- }
- m, cancel := newState(t, tcfg)
- // defer cleanupModel(m)
- defer cancel()
- id := srand.String(8)
- m.ClusterConfig(device1Conn, createClusterConfig(device1, id))
- if cfg, ok := m.cfg.Folder(id); ok && cfg.SharedWith(device1) {
- t.Error("unexpected shared", id)
- }
- }
- func TestAutoAcceptNewFolder(t *testing.T) {
- // New folder
- m, cancel := newState(t, defaultAutoAcceptCfg)
- defer cleanupModel(m)
- defer cancel()
- id := srand.String(8)
- m.ClusterConfig(device1Conn, createClusterConfig(device1, id))
- if fcfg, ok := m.cfg.Folder(id); !ok || !fcfg.SharedWith(device1) {
- t.Error("expected shared", id)
- }
- }
- func TestAutoAcceptNewFolderFromTwoDevices(t *testing.T) {
- m, cancel := newState(t, defaultAutoAcceptCfg)
- defer cleanupModel(m)
- defer cancel()
- id := srand.String(8)
- defer os.RemoveAll(id)
- m.ClusterConfig(device1Conn, createClusterConfig(device1, id))
- if fcfg, ok := m.cfg.Folder(id); !ok || !fcfg.SharedWith(device1) {
- t.Error("expected shared", id)
- }
- if fcfg, ok := m.cfg.Folder(id); !ok || fcfg.SharedWith(device2) {
- t.Error("unexpected expected shared", id)
- }
- m.ClusterConfig(device2Conn, createClusterConfig(device2, id))
- if fcfg, ok := m.cfg.Folder(id); !ok || !fcfg.SharedWith(device2) {
- t.Error("expected shared", id)
- }
- }
- func TestAutoAcceptNewFolderFromOnlyOneDevice(t *testing.T) {
- modifiedCfg := defaultAutoAcceptCfg.Copy()
- modifiedCfg.Devices[2].AutoAcceptFolders = false
- m, cancel := newState(t, modifiedCfg)
- id := srand.String(8)
- defer os.RemoveAll(id)
- defer cleanupModel(m)
- defer cancel()
- m.ClusterConfig(device1Conn, createClusterConfig(device1, id))
- if fcfg, ok := m.cfg.Folder(id); !ok || !fcfg.SharedWith(device1) {
- t.Error("expected shared", id)
- }
- if fcfg, ok := m.cfg.Folder(id); !ok || fcfg.SharedWith(device2) {
- t.Error("unexpected expected shared", id)
- }
- m.ClusterConfig(device2Conn, createClusterConfig(device2, id))
- if fcfg, ok := m.cfg.Folder(id); !ok || fcfg.SharedWith(device2) {
- t.Error("unexpected shared", id)
- }
- }
- func TestAutoAcceptNewFolderPremutationsNoPanic(t *testing.T) {
- if testing.Short() {
- t.Skip("short tests only")
- }
- id := srand.String(8)
- label := srand.String(8)
- premutations := []protocol.Folder{
- {ID: id, Label: id},
- {ID: id, Label: label},
- {ID: label, Label: id},
- {ID: label, Label: label},
- }
- localFolders := append(premutations, protocol.Folder{})
- for _, localFolder := range localFolders {
- for _, localFolderPaused := range []bool{false, true} {
- for _, dev1folder := range premutations {
- for _, dev2folder := range premutations {
- cfg := defaultAutoAcceptCfg.Copy()
- if localFolder.Label != "" {
- fcfg := newFolderConfiguration(defaultCfgWrapper, localFolder.ID, localFolder.Label, fs.FilesystemTypeFake, localFolder.ID)
- fcfg.Paused = localFolderPaused
- cfg.Folders = append(cfg.Folders, fcfg)
- }
- m, cancel := newState(t, cfg)
- m.ClusterConfig(device1Conn, protocol.ClusterConfig{
- Folders: []protocol.Folder{dev1folder},
- })
- m.ClusterConfig(device2Conn, protocol.ClusterConfig{
- Folders: []protocol.Folder{dev2folder},
- })
- cleanupModel(m)
- cancel()
- }
- }
- }
- }
- }
- func TestAutoAcceptMultipleFolders(t *testing.T) {
- // Multiple new folders
- id1 := srand.String(8)
- defer os.RemoveAll(id1)
- id2 := srand.String(8)
- defer os.RemoveAll(id2)
- m, cancel := newState(t, defaultAutoAcceptCfg)
- defer cleanupModel(m)
- defer cancel()
- m.ClusterConfig(device1Conn, createClusterConfig(device1, id1, id2))
- if fcfg, ok := m.cfg.Folder(id1); !ok || !fcfg.SharedWith(device1) {
- t.Error("expected shared", id1)
- }
- if fcfg, ok := m.cfg.Folder(id2); !ok || !fcfg.SharedWith(device1) {
- t.Error("expected shared", id2)
- }
- }
- func TestAutoAcceptExistingFolder(t *testing.T) {
- // Existing folder
- id := srand.String(8)
- idOther := srand.String(8) // To check that path does not get changed.
- tcfg := defaultAutoAcceptCfg.Copy()
- tcfg.Folders = []config.FolderConfiguration{
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: id,
- Path: idOther, // To check that path does not get changed.
- },
- }
- m, cancel := newState(t, tcfg)
- defer cleanupModel(m)
- defer cancel()
- if fcfg, ok := m.cfg.Folder(id); !ok || fcfg.SharedWith(device1) {
- t.Error("missing folder, or shared", id)
- }
- m.ClusterConfig(device1Conn, createClusterConfig(device1, id))
- if fcfg, ok := m.cfg.Folder(id); !ok || !fcfg.SharedWith(device1) || fcfg.Path != idOther {
- t.Error("missing folder, or unshared, or path changed", id)
- }
- }
- func TestAutoAcceptNewAndExistingFolder(t *testing.T) {
- // New and existing folder
- id1 := srand.String(8)
- id2 := srand.String(8)
- tcfg := defaultAutoAcceptCfg.Copy()
- tcfg.Folders = []config.FolderConfiguration{
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: id1,
- Path: id1, // from previous test case, to verify that path doesn't get changed.
- },
- }
- m, cancel := newState(t, tcfg)
- defer cleanupModel(m)
- defer cancel()
- if fcfg, ok := m.cfg.Folder(id1); !ok || fcfg.SharedWith(device1) {
- t.Error("missing folder, or shared", id1)
- }
- m.ClusterConfig(device1Conn, createClusterConfig(device1, id1, id2))
- for i, id := range []string{id1, id2} {
- if fcfg, ok := m.cfg.Folder(id); !ok || !fcfg.SharedWith(device1) {
- t.Error("missing folder, or unshared", i, id)
- }
- }
- }
- func TestAutoAcceptAlreadyShared(t *testing.T) {
- // Already shared
- id := srand.String(8)
- tcfg := defaultAutoAcceptCfg.Copy()
- tcfg.Folders = []config.FolderConfiguration{
- {
- FilesystemType: fs.FilesystemTypeFake,
- ID: id,
- Path: id,
- Devices: []config.FolderDeviceConfiguration{
- {
- DeviceID: device1,
- },
- },
- },
- }
- m, cancel := newState(t, tcfg)
- defer cleanupModel(m)
- defer cancel()
- if fcfg, ok := m.cfg.Folder(id); !ok || !fcfg.SharedWith(device1) {
- t.Error("missing folder, or not shared", id)
- }
- m.ClusterConfig(device1Conn, createClusterConfig(device1, id))
- if fcfg, ok := m.cfg.Folder(id); !ok || !fcfg.SharedWith(device1) {
- t.Error("missing folder, or not shared", id)
- }
- }
- func TestAutoAcceptNameConflict(t *testing.T) {
- ffs := fs.NewFilesystem(fs.FilesystemTypeFake, srand.String(32))
- id := srand.String(8)
- label := srand.String(8)
- ffs.MkdirAll(id, 0o777)
- ffs.MkdirAll(label, 0o777)
- m, cancel := newState(t, defaultAutoAcceptCfg)
- defer cleanupModel(m)
- defer cancel()
- m.ClusterConfig(device1Conn, protocol.ClusterConfig{
- Folders: []protocol.Folder{
- {
- ID: id,
- Label: label,
- },
- },
- })
- if fcfg, ok := m.cfg.Folder(id); ok && fcfg.SharedWith(device1) {
- t.Error("unexpected folder", id)
- }
- }
- func TestAutoAcceptPrefersLabel(t *testing.T) {
- // Prefers label, falls back to ID.
- m, cancel := newState(t, defaultAutoAcceptCfg)
- id := srand.String(8)
- label := srand.String(8)
- defer cleanupModel(m)
- defer cancel()
- m.ClusterConfig(device1Conn, addFolderDevicesToClusterConfig(protocol.ClusterConfig{
- Folders: []protocol.Folder{
- {
- ID: id,
- Label: label,
- },
- },
- }, device1))
- if fcfg, ok := m.cfg.Folder(id); !ok || !fcfg.SharedWith(device1) || !strings.HasSuffix(fcfg.Path, label) {
- t.Error("expected shared, or wrong path", id, label, fcfg.Path)
- }
- }
- func TestAutoAcceptFallsBackToID(t *testing.T) {
- // Prefers label, falls back to ID.
- m, cancel := newState(t, defaultAutoAcceptCfg)
- ffs := defaultFolderConfig.Filesystem(nil)
- id := srand.String(8)
- label := srand.String(8)
- if err := ffs.MkdirAll(label, 0o777); err != nil {
- t.Error(err)
- }
- defer cleanupModel(m)
- defer cancel()
- m.ClusterConfig(device1Conn, addFolderDevicesToClusterConfig(protocol.ClusterConfig{
- Folders: []protocol.Folder{
- {
- ID: id,
- Label: label,
- },
- },
- }, device1))
- fcfg, ok := m.cfg.Folder(id)
- if !ok {
- t.Error("folder configuration missing")
- }
- if !fcfg.SharedWith(device1) {
- t.Error("folder is not shared with device1")
- }
- }
- func TestAutoAcceptPausedWhenFolderConfigChanged(t *testing.T) {
- // Existing folder
- id := srand.String(8)
- idOther := srand.String(8) // To check that path does not get changed.
- tcfg := defaultAutoAcceptCfg.Copy()
- fcfg := newFolderConfiguration(defaultCfgWrapper, id, "", fs.FilesystemTypeFake, idOther)
- fcfg.Paused = true
- // The order of devices here is wrong (cfg.clean() sorts them), which will cause the folder to restart.
- // Because of the restart, folder gets removed from m.deviceFolder, which means that generateClusterConfig will not panic.
- // This wasn't an issue before, yet keeping the test case to prove that it still isn't.
- fcfg.Devices = append(fcfg.Devices, config.FolderDeviceConfiguration{
- DeviceID: device1,
- })
- tcfg.Folders = []config.FolderConfiguration{fcfg}
- m, cancel := newState(t, tcfg)
- defer cleanupModel(m)
- defer cancel()
- if fcfg, ok := m.cfg.Folder(id); !ok || !fcfg.SharedWith(device1) {
- t.Error("missing folder, or not shared", id)
- }
- if _, ok := m.folderRunners.Get(id); ok {
- t.Fatal("folder running?")
- }
- m.ClusterConfig(device1Conn, createClusterConfig(device1, id))
- m.generateClusterConfig(device1)
- if fcfg, ok := m.cfg.Folder(id); !ok {
- t.Error("missing folder")
- } else if fcfg.Path != idOther {
- t.Error("folder path changed")
- } else {
- for _, dev := range fcfg.DeviceIDs() {
- if dev == device1 {
- return
- }
- }
- t.Error("device missing")
- }
- if _, ok := m.folderRunners.Get(id); ok {
- t.Error("folder started")
- }
- }
- func TestAutoAcceptPausedWhenFolderConfigNotChanged(t *testing.T) {
- // Existing folder
- id := srand.String(8)
- idOther := srand.String(8) // To check that path does not get changed.
- tcfg := defaultAutoAcceptCfg.Copy()
- fcfg := newFolderConfiguration(defaultCfgWrapper, id, "", fs.FilesystemTypeFake, idOther)
- fcfg.Paused = true
- // The new folder is exactly the same as the one constructed by handleAutoAccept, which means
- // the folder will not be restarted (even if it's paused), yet handleAutoAccept used to add the folder
- // to m.deviceFolders which had caused panics when calling generateClusterConfig, as the folder
- // did not have a file set.
- fcfg.Devices = append([]config.FolderDeviceConfiguration{
- {
- DeviceID: device1,
- },
- }, fcfg.Devices...) // Need to ensure this device order to avoid folder restart.
- tcfg.Folders = []config.FolderConfiguration{fcfg}
- m, cancel := newState(t, tcfg)
- defer cleanupModel(m)
- defer cancel()
- if fcfg, ok := m.cfg.Folder(id); !ok || !fcfg.SharedWith(device1) {
- t.Error("missing folder, or not shared", id)
- }
- if _, ok := m.folderRunners.Get(id); ok {
- t.Fatal("folder running?")
- }
- m.ClusterConfig(device1Conn, createClusterConfig(device1, id))
- m.generateClusterConfig(device1)
- if fcfg, ok := m.cfg.Folder(id); !ok {
- t.Error("missing folder")
- } else if fcfg.Path != idOther {
- t.Error("folder path changed")
- } else {
- for _, dev := range fcfg.DeviceIDs() {
- if dev == device1 {
- return
- }
- }
- t.Error("device missing")
- }
- if _, ok := m.folderRunners.Get(id); ok {
- t.Error("folder started")
- }
- }
- func TestAutoAcceptEnc(t *testing.T) {
- tcfg := defaultAutoAcceptCfg.Copy()
- m, cancel := newState(t, tcfg)
- defer cleanupModel(m)
- defer cancel()
- id := srand.String(8)
- defer os.RemoveAll(id)
- token := []byte("token")
- basicCC := func() protocol.ClusterConfig {
- return protocol.ClusterConfig{
- Folders: []protocol.Folder{{
- ID: id,
- Label: id,
- }},
- }
- }
- // Earlier tests might cause the connection to get closed, thus ClusterConfig
- // would panic.
- clusterConfig := func(deviceID protocol.DeviceID, cm protocol.ClusterConfig) {
- conn := newFakeConnection(deviceID, m)
- m.AddConnection(conn, protocol.Hello{})
- m.ClusterConfig(conn, cm)
- }
- clusterConfig(device1, basicCC())
- if _, ok := m.cfg.Folder(id); ok {
- t.Fatal("unexpected added")
- }
- cc := basicCC()
- cc.Folders[0].Devices = []protocol.Device{{ID: device1}}
- clusterConfig(device1, cc)
- if _, ok := m.cfg.Folder(id); ok {
- t.Fatal("unexpected added")
- }
- cc = basicCC()
- cc.Folders[0].Devices = []protocol.Device{{ID: myID}}
- clusterConfig(device1, cc)
- if _, ok := m.cfg.Folder(id); ok {
- t.Fatal("unexpected added")
- }
- // New folder, encrypted -> add as enc
- cc = createClusterConfig(device1, id)
- cc.Folders[0].Devices[1].EncryptionPasswordToken = token
- clusterConfig(device1, cc)
- if cfg, ok := m.cfg.Folder(id); !ok {
- t.Fatal("unexpected unadded")
- } else {
- if !cfg.SharedWith(device1) {
- t.Fatal("unexpected unshared")
- }
- if cfg.Type != config.FolderTypeReceiveEncrypted {
- t.Fatal("Folder not added as receiveEncrypted")
- }
- }
- // New device, unencrypted on encrypted folder -> reject
- clusterConfig(device2, createClusterConfig(device2, id))
- if cfg, _ := m.cfg.Folder(id); cfg.SharedWith(device2) {
- t.Fatal("unexpected shared")
- }
- // New device, encrypted on encrypted folder -> share
- cc = createClusterConfig(device2, id)
- cc.Folders[0].Devices[1].EncryptionPasswordToken = token
- clusterConfig(device2, cc)
- if cfg, _ := m.cfg.Folder(id); !cfg.SharedWith(device2) {
- t.Fatal("unexpected unshared")
- }
- // New folder, no encrypted -> add "normal"
- id = srand.String(8)
- defer os.RemoveAll(id)
- clusterConfig(device1, createClusterConfig(device1, id))
- if cfg, ok := m.cfg.Folder(id); !ok {
- t.Fatal("unexpected unadded")
- } else {
- if !cfg.SharedWith(device1) {
- t.Fatal("unexpected unshared")
- }
- if cfg.Type != config.FolderTypeSendReceive {
- t.Fatal("Folder not added as send-receive")
- }
- }
- // New device, encrypted on unencrypted folder -> reject
- cc = createClusterConfig(device2, id)
- cc.Folders[0].Devices[1].EncryptionPasswordToken = token
- clusterConfig(device2, cc)
- if cfg, _ := m.cfg.Folder(id); cfg.SharedWith(device2) {
- t.Fatal("unexpected shared")
- }
- // New device, unencrypted on unencrypted folder -> share
- clusterConfig(device2, createClusterConfig(device2, id))
- if cfg, _ := m.cfg.Folder(id); !cfg.SharedWith(device2) {
- t.Fatal("unexpected unshared")
- }
- }
- func changeIgnores(t *testing.T, m *testModel, expected []string) {
- arrEqual := func(a, b []string) bool {
- if len(a) != len(b) {
- return false
- }
- for i := range a {
- if a[i] != b[i] {
- return false
- }
- }
- return true
- }
- ignores, _, err := m.LoadIgnores("default")
- if err != nil {
- t.Error(err)
- }
- if !arrEqual(ignores, expected) {
- t.Errorf("Incorrect ignores: %v != %v", ignores, expected)
- }
- ignores = append(ignores, "pox")
- err = m.SetIgnores("default", ignores)
- if err != nil {
- t.Error(err)
- }
- ignores2, _, err := m.LoadIgnores("default")
- if err != nil {
- t.Error(err)
- }
- if !arrEqual(ignores, ignores2) {
- t.Errorf("Incorrect ignores: %v != %v", ignores2, ignores)
- }
- if build.IsDarwin {
- // see above
- time.Sleep(time.Second)
- } else {
- time.Sleep(time.Millisecond)
- }
- err = m.SetIgnores("default", expected)
- if err != nil {
- t.Error(err)
- }
- ignores, _, err = m.LoadIgnores("default")
- if err != nil {
- t.Error(err)
- }
- if !arrEqual(ignores, expected) {
- t.Errorf("Incorrect ignores: %v != %v", ignores, expected)
- }
- }
- func TestIgnores(t *testing.T) {
- w, cancel := newConfigWrapper(defaultCfg)
- defer cancel()
- ffs := w.FolderList()[0].Filesystem(nil)
- m := setupModel(t, w)
- defer cleanupModel(m)
- // Assure a clean start state
- must(t, ffs.MkdirAll(config.DefaultMarkerName, 0o644))
- writeFile(t, ffs, ".stignore", []byte(".*\nquux\n"))
- folderIgnoresAlwaysReload(t, m, defaultFolderConfig)
- // Make sure the initial scan has finished (ScanFolders is blocking)
- m.ScanFolders()
- expected := []string{
- ".*",
- "quux",
- }
- changeIgnores(t, m, expected)
- _, _, err := m.LoadIgnores("doesnotexist")
- if err == nil {
- t.Error("No error")
- }
- err = m.SetIgnores("doesnotexist", expected)
- if err == nil {
- t.Error("No error")
- }
- // Invalid path, treated like no patterns at all.
- fcfg := config.FolderConfiguration{
- ID: "fresh", Path: "XXX",
- FilesystemType: fs.FilesystemTypeFake,
- }
- ignores := ignore.New(fcfg.Filesystem(nil), ignore.WithCache(m.cfg.Options().CacheIgnoredFiles))
- m.fmut.Lock()
- m.folderCfgs[fcfg.ID] = fcfg
- m.folderIgnores[fcfg.ID] = ignores
- m.fmut.Unlock()
- _, _, err = m.LoadIgnores("fresh")
- if err != nil {
- t.Error("Got error for inexistent folder path")
- }
- // Repeat tests with paused folder
- pausedDefaultFolderConfig := defaultFolderConfig
- pausedDefaultFolderConfig.Paused = true
- m.restartFolder(defaultFolderConfig, pausedDefaultFolderConfig, false)
- // Here folder initialization is not an issue as a paused folder isn't
- // added to the model and thus there is no initial scan happening.
- changeIgnores(t, m, expected)
- // Make sure no .stignore file is considered valid
- defer func() {
- must(t, ffs.Rename(".stignore.bak", ".stignore"))
- }()
- must(t, ffs.Rename(".stignore", ".stignore.bak"))
- changeIgnores(t, m, []string{})
- }
- func TestEmptyIgnores(t *testing.T) {
- w, cancel := newConfigWrapper(defaultCfg)
- defer cancel()
- ffs := w.FolderList()[0].Filesystem(nil)
- m := setupModel(t, w)
- defer cleanupModel(m)
- if err := m.SetIgnores("default", []string{}); err != nil {
- t.Error(err)
- }
- if _, err := ffs.Stat(".stignore"); err == nil {
- t.Error(".stignore was created despite being empty")
- }
- if err := m.SetIgnores("default", []string{".*", "quux"}); err != nil {
- t.Error(err)
- }
- if _, err := ffs.Stat(".stignore"); os.IsNotExist(err) {
- t.Error(".stignore does not exist")
- }
- if err := m.SetIgnores("default", []string{}); err != nil {
- t.Error(err)
- }
- if _, err := ffs.Stat(".stignore"); err == nil {
- t.Error(".stignore should have been deleted because it is empty")
- }
- }
- func waitForState(t *testing.T, sub events.Subscription, folder, expected string) {
- t.Helper()
- timeout := time.After(5 * time.Second)
- var err string
- for {
- select {
- case ev := <-sub.C():
- data := ev.Data.(map[string]interface{})
- if data["folder"].(string) == folder {
- if data["error"] == nil {
- err = ""
- } else {
- err = data["error"].(string)
- }
- if err == expected {
- return
- } else {
- t.Error(ev)
- }
- }
- case <-timeout:
- t.Fatalf("Timed out waiting for status: %s, current status: %v", expected, err)
- }
- }
- }
- func TestROScanRecovery(t *testing.T) {
- fcfg := config.FolderConfiguration{
- FilesystemType: fs.FilesystemTypeFake,
- ID: "default",
- Path: srand.String(32),
- Type: config.FolderTypeSendOnly,
- RescanIntervalS: 1,
- MarkerName: config.DefaultMarkerName,
- }
- cfg, cancel := newConfigWrapper(config.Configuration{
- Version: config.CurrentVersion,
- Folders: []config.FolderConfiguration{fcfg},
- Devices: []config.DeviceConfiguration{
- {
- DeviceID: device1,
- },
- },
- })
- defer cancel()
- m := newModel(t, cfg, myID, nil)
- set := newFileSet(t, "default", m.db)
- set.Update(protocol.LocalDeviceID, []protocol.FileInfo{
- {Name: "dummyfile", Version: protocol.Vector{Counters: []protocol.Counter{{ID: 42, Value: 1}}}},
- })
- ffs := fcfg.Filesystem(nil)
- // Remove marker to generate an error
- ffs.Remove(fcfg.MarkerName)
- sub := m.evLogger.Subscribe(events.StateChanged)
- defer sub.Unsubscribe()
- m.ServeBackground()
- defer cleanupModel(m)
- waitForState(t, sub, "default", config.ErrMarkerMissing.Error())
- fd, err := ffs.Create(config.DefaultMarkerName)
- if err != nil {
- t.Fatal(err)
- }
- fd.Close()
- waitForState(t, sub, "default", "")
- }
- func TestRWScanRecovery(t *testing.T) {
- fcfg := config.FolderConfiguration{
- FilesystemType: fs.FilesystemTypeFake,
- ID: "default",
- Path: srand.String(32),
- Type: config.FolderTypeSendReceive,
- RescanIntervalS: 1,
- MarkerName: config.DefaultMarkerName,
- }
- cfg, cancel := newConfigWrapper(config.Configuration{
- Version: config.CurrentVersion,
- Folders: []config.FolderConfiguration{fcfg},
- Devices: []config.DeviceConfiguration{
- {
- DeviceID: device1,
- },
- },
- })
- defer cancel()
- m := newModel(t, cfg, myID, nil)
- set := newFileSet(t, "default", m.db)
- set.Update(protocol.LocalDeviceID, []protocol.FileInfo{
- {Name: "dummyfile", Version: protocol.Vector{Counters: []protocol.Counter{{ID: 42, Value: 1}}}},
- })
- ffs := fcfg.Filesystem(nil)
- // Generate error
- if err := ffs.Remove(config.DefaultMarkerName); err != nil {
- t.Fatal(err)
- }
- sub := m.evLogger.Subscribe(events.StateChanged)
- defer sub.Unsubscribe()
- m.ServeBackground()
- defer cleanupModel(m)
- waitForState(t, sub, "default", config.ErrMarkerMissing.Error())
- fd, err := ffs.Create(config.DefaultMarkerName)
- if err != nil {
- t.Error(err)
- }
- fd.Close()
- waitForState(t, sub, "default", "")
- }
- func TestGlobalDirectoryTree(t *testing.T) {
- m, conn, fcfg, wCancel := setupModelWithConnection(t)
- defer wCancel()
- defer cleanupModelAndRemoveDir(m, fcfg.Filesystem(nil).URI())
- b := func(isfile bool, path ...string) protocol.FileInfo {
- typ := protocol.FileInfoTypeDirectory
- var blocks []protocol.BlockInfo
- if isfile {
- typ = protocol.FileInfoTypeFile
- blocks = []protocol.BlockInfo{{Offset: 0x0, Size: 0xa, Hash: []uint8{0x2f, 0x72, 0xcc, 0x11, 0xa6, 0xfc, 0xd0, 0x27, 0x1e, 0xce, 0xf8, 0xc6, 0x10, 0x56, 0xee, 0x1e, 0xb1, 0x24, 0x3b, 0xe3, 0x80, 0x5b, 0xf9, 0xa9, 0xdf, 0x98, 0xf9, 0x2f, 0x76, 0x36, 0xb0, 0x5c}}}
- }
- return protocol.FileInfo{
- Name: filepath.Join(path...),
- Type: typ,
- ModifiedS: 0x666,
- Blocks: blocks,
- Size: 0xa,
- }
- }
- f := func(name string) *TreeEntry {
- return &TreeEntry{
- Name: name,
- ModTime: time.Unix(0x666, 0),
- Size: 0xa,
- Type: protocol.FileInfoTypeFile,
- }
- }
- d := func(name string, entries ...*TreeEntry) *TreeEntry {
- return &TreeEntry{
- Name: name,
- ModTime: time.Unix(0x666, 0),
- Size: 128,
- Type: protocol.FileInfoTypeDirectory,
- Children: entries,
- }
- }
- testdata := []protocol.FileInfo{
- b(false, "another"),
- b(false, "another", "directory"),
- b(true, "another", "directory", "afile"),
- b(false, "another", "directory", "with"),
- b(false, "another", "directory", "with", "a"),
- b(true, "another", "directory", "with", "a", "file"),
- b(true, "another", "directory", "with", "file"),
- b(true, "another", "file"),
- b(false, "other"),
- b(false, "other", "rand"),
- b(false, "other", "random"),
- b(false, "other", "random", "dir"),
- b(false, "other", "random", "dirx"),
- b(false, "other", "randomx"),
- b(false, "some"),
- b(false, "some", "directory"),
- b(false, "some", "directory", "with"),
- b(false, "some", "directory", "with", "a"),
- b(true, "some", "directory", "with", "a", "file"),
- b(true, "zzrootfile"),
- }
- expectedResult := []*TreeEntry{
- d("another",
- d("directory",
- f("afile"),
- d("with",
- d("a",
- f("file"),
- ),
- f("file"),
- ),
- ),
- f("file"),
- ),
- d("other",
- d("rand"),
- d("random",
- d("dir"),
- d("dirx"),
- ),
- d("randomx"),
- ),
- d("some",
- d("directory",
- d("with",
- d("a",
- f("file"),
- ),
- ),
- ),
- ),
- f("zzrootfile"),
- }
- mm := func(data interface{}) string {
- bytes, err := json.MarshalIndent(data, "", " ")
- if err != nil {
- panic(err)
- }
- return string(bytes)
- }
- must(t, m.Index(conn, "default", testdata))
- result, _ := m.GlobalDirectoryTree("default", "", -1, false)
- if mm(result) != mm(expectedResult) {
- t.Errorf("Does not match:\n%s\n============\n%s", mm(result), mm(expectedResult))
- }
- result, _ = m.GlobalDirectoryTree("default", "another", -1, false)
- if mm(result) != mm(findByName(expectedResult, "another").Children) {
- t.Errorf("Does not match:\n%s\n============\n%s", mm(result), mm(findByName(expectedResult, "another").Children))
- }
- result, _ = m.GlobalDirectoryTree("default", "", 0, false)
- currentResult := []*TreeEntry{
- d("another"),
- d("other"),
- d("some"),
- f("zzrootfile"),
- }
- if mm(result) != mm(currentResult) {
- t.Errorf("Does not match:\n%s\n============\n%s", mm(result), mm(currentResult))
- }
- result, _ = m.GlobalDirectoryTree("default", "", 1, false)
- currentResult = []*TreeEntry{
- d("another",
- d("directory"),
- f("file"),
- ),
- d("other",
- d("rand"),
- d("random"),
- d("randomx"),
- ),
- d("some",
- d("directory"),
- ),
- f("zzrootfile"),
- }
- if mm(result) != mm(currentResult) {
- t.Errorf("Does not match:\n%s\n%s", mm(result), mm(currentResult))
- }
- result, _ = m.GlobalDirectoryTree("default", "", -1, true)
- currentResult = []*TreeEntry{
- d("another",
- d("directory",
- d("with",
- d("a"),
- ),
- ),
- ),
- d("other",
- d("rand"),
- d("random",
- d("dir"),
- d("dirx"),
- ),
- d("randomx"),
- ),
- d("some",
- d("directory",
- d("with",
- d("a"),
- ),
- ),
- ),
- }
- if mm(result) != mm(currentResult) {
- t.Errorf("Does not match:\n%s\n%s", mm(result), mm(currentResult))
- }
- result, _ = m.GlobalDirectoryTree("default", "", 1, true)
- currentResult = []*TreeEntry{
- d("another",
- d("directory"),
- ),
- d("other",
- d("rand"),
- d("random"),
- d("randomx"),
- ),
- d("some",
- d("directory"),
- ),
- }
- if mm(result) != mm(currentResult) {
- t.Errorf("Does not match:\n%s\n%s", mm(result), mm(currentResult))
- }
- result, _ = m.GlobalDirectoryTree("default", "another", 0, false)
- currentResult = []*TreeEntry{
- d("directory"),
- f("file"),
- }
- if mm(result) != mm(currentResult) {
- t.Errorf("Does not match:\n%s\n%s", mm(result), mm(currentResult))
- }
- result, _ = m.GlobalDirectoryTree("default", "some/directory", 0, false)
- currentResult = []*TreeEntry{
- d("with"),
- }
- if mm(result) != mm(currentResult) {
- t.Errorf("Does not match:\n%s\n%s", mm(result), mm(currentResult))
- }
- result, _ = m.GlobalDirectoryTree("default", "some/directory", 1, false)
- currentResult = []*TreeEntry{
- d("with",
- d("a"),
- ),
- }
- if mm(result) != mm(currentResult) {
- t.Errorf("Does not match:\n%s\n%s", mm(result), mm(currentResult))
- }
- result, _ = m.GlobalDirectoryTree("default", "some/directory", 2, false)
- currentResult = []*TreeEntry{
- d("with",
- d("a",
- f("file"),
- ),
- ),
- }
- if mm(result) != mm(currentResult) {
- t.Errorf("Does not match:\n%s\n%s", mm(result), mm(currentResult))
- }
- result, _ = m.GlobalDirectoryTree("default", "another", -1, true)
- currentResult = []*TreeEntry{
- d("directory",
- d("with",
- d("a"),
- ),
- ),
- }
- if mm(result) != mm(currentResult) {
- t.Errorf("Does not match:\n%s\n%s", mm(result), mm(currentResult))
- }
- // No prefix matching!
- result, _ = m.GlobalDirectoryTree("default", "som", -1, false)
- currentResult = []*TreeEntry{}
- if mm(result) != mm(currentResult) {
- t.Errorf("Does not match:\n%s\n%s", mm(result), mm(currentResult))
- }
- }
- func genDeepFiles(n, d int) []protocol.FileInfo {
- mrand.Seed(int64(n))
- files := make([]protocol.FileInfo, n)
- t := time.Now().Unix()
- for i := 0; i < n; i++ {
- path := ""
- for i := 0; i <= d; i++ {
- path = filepath.Join(path, strconv.Itoa(mrand.Int()))
- }
- sofar := ""
- for _, path := range filepath.SplitList(path) {
- sofar = filepath.Join(sofar, path)
- files[i] = protocol.FileInfo{
- Name: sofar,
- }
- i++
- }
- files[i].ModifiedS = t
- files[i].Blocks = []protocol.BlockInfo{{Offset: 0, Size: 100, Hash: []byte("some hash bytes")}}
- }
- return files
- }
- func BenchmarkTree_10000_50(b *testing.B) {
- benchmarkTree(b, 10000, 50)
- }
- func BenchmarkTree_100_50(b *testing.B) {
- benchmarkTree(b, 100, 50)
- }
- func BenchmarkTree_100_10(b *testing.B) {
- benchmarkTree(b, 100, 10)
- }
- func benchmarkTree(b *testing.B, n1, n2 int) {
- m, _, fcfg, wcfgCancel := setupModelWithConnection(b)
- defer wcfgCancel()
- defer cleanupModelAndRemoveDir(m, fcfg.Filesystem(nil).URI())
- m.ScanFolder(fcfg.ID)
- files := genDeepFiles(n1, n2)
- must(b, m.Index(device1Conn, fcfg.ID, files))
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- m.GlobalDirectoryTree(fcfg.ID, "", -1, false)
- }
- b.ReportAllocs()
- }
- func TestIssue3028(t *testing.T) {
- w, cancel := newConfigWrapper(defaultCfg)
- defer cancel()
- ffs := w.FolderList()[0].Filesystem(nil)
- m := setupModel(t, w)
- defer cleanupModel(m)
- // Create two files that we'll delete, one with a name that is a prefix of the other.
- writeFile(t, ffs, "testrm", []byte("Hello"))
- writeFile(t, ffs, "testrm2", []byte("Hello"))
- // Scan, and get a count of how many files are there now
- m.ScanFolderSubdirs("default", []string{"testrm", "testrm2"})
- locorigfiles := localSize(t, m, "default").Files
- globorigfiles := globalSize(t, m, "default").Files
- // Delete
- must(t, ffs.Remove("testrm"))
- must(t, ffs.Remove("testrm2"))
- // Verify that the number of files decreased by two and the number of
- // deleted files increases by two
- m.ScanFolderSubdirs("default", []string{"testrm", "testrm2"})
- loc := localSize(t, m, "default")
- glob := globalSize(t, m, "default")
- if loc.Files != locorigfiles-2 {
- t.Errorf("Incorrect local accounting; got %d current files, expected %d", loc.Files, locorigfiles-2)
- }
- if glob.Files != globorigfiles-2 {
- t.Errorf("Incorrect global accounting; got %d current files, expected %d", glob.Files, globorigfiles-2)
- }
- if loc.Deleted != 2 {
- t.Errorf("Incorrect local accounting; got %d deleted files, expected 2", loc.Deleted)
- }
- if glob.Deleted != 2 {
- t.Errorf("Incorrect global accounting; got %d deleted files, expected 2", glob.Deleted)
- }
- }
- func TestIssue4357(t *testing.T) {
- cfg := defaultCfgWrapper.RawCopy()
- // Create a separate wrapper not to pollute other tests.
- wrapper, cancel := newConfigWrapper(config.Configuration{Version: config.CurrentVersion})
- defer cancel()
- m := newModel(t, wrapper, myID, nil)
- m.ServeBackground()
- defer cleanupModel(m)
- // Force the model to wire itself and add the folders
- replace(t, wrapper, cfg)
- if _, ok := m.folderCfgs["default"]; !ok {
- t.Error("Folder should be running")
- }
- newCfg := wrapper.RawCopy()
- newCfg.Folders[0].Paused = true
- replace(t, wrapper, newCfg)
- if _, ok := m.folderCfgs["default"]; ok {
- t.Error("Folder should not be running")
- }
- if _, ok := m.cfg.Folder("default"); !ok {
- t.Error("should still have folder in config")
- }
- replace(t, wrapper, config.Configuration{Version: config.CurrentVersion})
- if _, ok := m.cfg.Folder("default"); ok {
- t.Error("should not have folder in config")
- }
- // Add the folder back, should be running
- replace(t, wrapper, cfg)
- if _, ok := m.folderCfgs["default"]; !ok {
- t.Error("Folder should be running")
- }
- if _, ok := m.cfg.Folder("default"); !ok {
- t.Error("should still have folder in config")
- }
- // Should not panic when removing a running folder.
- replace(t, wrapper, config.Configuration{Version: config.CurrentVersion})
- if _, ok := m.folderCfgs["default"]; ok {
- t.Error("Folder should not be running")
- }
- if _, ok := m.cfg.Folder("default"); ok {
- t.Error("should not have folder in config")
- }
- }
- func TestIndexesForUnknownDevicesDropped(t *testing.T) {
- m := newModel(t, defaultCfgWrapper, myID, nil)
- files := newFileSet(t, "default", m.db)
- files.Drop(device1)
- files.Update(device1, genFiles(1))
- files.Drop(device2)
- files.Update(device2, genFiles(1))
- if len(files.ListDevices()) != 2 {
- t.Error("expected two devices")
- }
- m.newFolder(defaultFolderConfig, false)
- defer cleanupModel(m)
- // Remote sequence is cached, hence need to recreated.
- files = newFileSet(t, "default", m.db)
- if l := len(files.ListDevices()); l != 1 {
- t.Errorf("Expected one device got %v", l)
- }
- }
- func TestSharedWithClearedOnDisconnect(t *testing.T) {
- wcfg, cancel := newConfigWrapper(defaultCfg)
- defer cancel()
- addDevice2(t, wcfg, wcfg.FolderList()[0])
- m := setupModel(t, wcfg)
- defer cleanupModel(m)
- conn1 := newFakeConnection(device1, m)
- m.AddConnection(conn1, protocol.Hello{})
- conn2 := newFakeConnection(device2, m)
- m.AddConnection(conn2, protocol.Hello{})
- m.ClusterConfig(conn1, protocol.ClusterConfig{
- Folders: []protocol.Folder{
- {
- ID: "default",
- Devices: []protocol.Device{
- {ID: myID},
- {ID: device1},
- {ID: device2},
- },
- },
- },
- })
- m.ClusterConfig(conn2, protocol.ClusterConfig{
- Folders: []protocol.Folder{
- {
- ID: "default",
- Devices: []protocol.Device{
- {ID: myID},
- {ID: device1},
- {ID: device2},
- },
- },
- },
- })
- if fcfg, ok := m.cfg.Folder("default"); !ok || !fcfg.SharedWith(device1) {
- t.Error("not shared with device1")
- }
- if fcfg, ok := m.cfg.Folder("default"); !ok || !fcfg.SharedWith(device2) {
- t.Error("not shared with device2")
- }
- select {
- case <-conn2.Closed():
- t.Error("conn already closed")
- default:
- }
- if _, err := wcfg.RemoveDevice(device2); err != nil {
- t.Error(err)
- }
- time.Sleep(100 * time.Millisecond) // Committer notification happens in a separate routine
- fcfg, ok := m.cfg.Folder("default")
- if !ok {
- t.Fatal("default folder missing")
- }
- if !fcfg.SharedWith(device1) {
- t.Error("not shared with device1")
- }
- if fcfg.SharedWith(device2) {
- t.Error("shared with device2")
- }
- for _, dev := range fcfg.Devices {
- if dev.DeviceID == device2 {
- t.Error("still there")
- }
- }
- select {
- case <-conn2.Closed():
- default:
- t.Error("connection not closed")
- }
- if _, ok := wcfg.Devices()[device2]; ok {
- t.Error("device still in config")
- }
- if _, ok := m.deviceConnIDs[device2]; ok {
- t.Error("conn not missing")
- }
- if _, ok := m.helloMessages[device2]; ok {
- t.Error("hello not missing")
- }
- if _, ok := m.deviceDownloads[device2]; ok {
- t.Error("downloads not missing")
- }
- }
- func TestIssue3804(t *testing.T) {
- m := setupModel(t, defaultCfgWrapper)
- defer cleanupModel(m)
- // Subdirs ending in slash should be accepted
- if err := m.ScanFolderSubdirs("default", []string{"baz/", "foo"}); err != nil {
- t.Error("Unexpected error:", err)
- }
- }
- func TestIssue3829(t *testing.T) {
- m := setupModel(t, defaultCfgWrapper)
- defer cleanupModel(m)
- // Empty subdirs should be accepted
- if err := m.ScanFolderSubdirs("default", []string{""}); err != nil {
- t.Error("Unexpected error:", err)
- }
- }
- // TestIssue4573 tests that contents of an unavailable dir aren't marked deleted
- func TestIssue4573(t *testing.T) {
- w, fcfg, wCancel := newDefaultCfgWrapper()
- defer wCancel()
- testFs := fcfg.Filesystem(nil)
- defer os.RemoveAll(testFs.URI())
- must(t, testFs.MkdirAll("inaccessible", 0o755))
- defer testFs.Chmod("inaccessible", 0o777)
- file := filepath.Join("inaccessible", "a")
- fd, err := testFs.Create(file)
- must(t, err)
- fd.Close()
- m := setupModel(t, w)
- defer cleanupModel(m)
- must(t, testFs.Chmod("inaccessible", 0o000))
- m.ScanFolder("default")
- if file, ok := m.testCurrentFolderFile("default", file); !ok {
- t.Fatalf("File missing in db")
- } else if file.Deleted {
- t.Errorf("Inaccessible file has been marked as deleted.")
- }
- }
- // TestInternalScan checks whether various fs operations are correctly represented
- // in the db after scanning.
- func TestInternalScan(t *testing.T) {
- w, fcfg, wCancel := newDefaultCfgWrapper()
- defer wCancel()
- testFs := fcfg.Filesystem(nil)
- defer os.RemoveAll(testFs.URI())
- testCases := map[string]func(protocol.FileInfo) bool{
- "removeDir": func(f protocol.FileInfo) bool {
- return !f.Deleted
- },
- "dirToFile": func(f protocol.FileInfo) bool {
- return f.Deleted || f.IsDirectory()
- },
- }
- baseDirs := []string{"dirToFile", "removeDir"}
- for _, dir := range baseDirs {
- sub := filepath.Join(dir, "subDir")
- for _, dir := range []string{dir, sub} {
- if err := testFs.MkdirAll(dir, 0o775); err != nil {
- t.Fatalf("%v: %v", dir, err)
- }
- }
- testCases[sub] = func(f protocol.FileInfo) bool {
- return !f.Deleted
- }
- for _, dir := range []string{dir, sub} {
- file := filepath.Join(dir, "a")
- fd, err := testFs.Create(file)
- must(t, err)
- fd.Close()
- testCases[file] = func(f protocol.FileInfo) bool {
- return !f.Deleted
- }
- }
- }
- m := setupModel(t, w)
- defer cleanupModel(m)
- for _, dir := range baseDirs {
- must(t, testFs.RemoveAll(dir))
- }
- fd, err := testFs.Create("dirToFile")
- must(t, err)
- fd.Close()
- m.ScanFolder("default")
- for path, cond := range testCases {
- if f, ok := m.testCurrentFolderFile("default", path); !ok {
- t.Fatalf("%v missing in db", path)
- } else if cond(f) {
- t.Errorf("Incorrect db entry for %v", path)
- }
- }
- }
- func TestCustomMarkerName(t *testing.T) {
- fcfg := newFolderConfig()
- fcfg.ID = "default"
- fcfg.RescanIntervalS = 1
- fcfg.MarkerName = "myfile"
- cfg, cancel := newConfigWrapper(config.Configuration{
- Version: config.CurrentVersion,
- Folders: []config.FolderConfiguration{fcfg},
- Devices: []config.DeviceConfiguration{
- {
- DeviceID: device1,
- },
- },
- })
- defer cancel()
- ffs := fcfg.Filesystem(nil)
- m := newModel(t, cfg, myID, nil)
- set := newFileSet(t, "default", m.db)
- set.Update(protocol.LocalDeviceID, []protocol.FileInfo{
- {Name: "dummyfile"},
- })
- if err := ffs.Remove(config.DefaultMarkerName); err != nil {
- t.Fatal(err)
- }
- sub := m.evLogger.Subscribe(events.StateChanged)
- defer sub.Unsubscribe()
- m.ServeBackground()
- defer cleanupModel(m)
- waitForState(t, sub, "default", config.ErrMarkerMissing.Error())
- fd, _ := ffs.Create("myfile")
- fd.Close()
- waitForState(t, sub, "default", "")
- }
- func TestRemoveDirWithContent(t *testing.T) {
- m, conn, fcfg, wcfgCancel := setupModelWithConnection(t)
- defer wcfgCancel()
- tfs := fcfg.Filesystem(nil)
- defer cleanupModelAndRemoveDir(m, tfs.URI())
- tfs.MkdirAll("dirwith", 0o755)
- content := filepath.Join("dirwith", "content")
- fd, err := tfs.Create(content)
- must(t, err)
- fd.Close()
- must(t, m.ScanFolder(fcfg.ID))
- dir, ok := m.testCurrentFolderFile(fcfg.ID, "dirwith")
- if !ok {
- t.Fatalf("Can't get dir \"dirwith\" after initial scan")
- }
- dir.Deleted = true
- dir.Version = dir.Version.Update(device1.Short()).Update(device1.Short())
- file, ok := m.testCurrentFolderFile(fcfg.ID, content)
- if !ok {
- t.Fatalf("Can't get file \"%v\" after initial scan", content)
- }
- file.Deleted = true
- file.Version = file.Version.Update(device1.Short()).Update(device1.Short())
- must(t, m.IndexUpdate(conn, fcfg.ID, []protocol.FileInfo{dir, file}))
- // Is there something we could trigger on instead of just waiting?
- timeout := time.NewTimer(5 * time.Second)
- for {
- dir, ok := m.testCurrentFolderFile(fcfg.ID, "dirwith")
- if !ok {
- t.Fatalf("Can't get dir \"dirwith\" after index update")
- }
- file, ok := m.testCurrentFolderFile(fcfg.ID, content)
- if !ok {
- t.Fatalf("Can't get file \"%v\" after index update", content)
- }
- if dir.Deleted && file.Deleted {
- return
- }
- select {
- case <-timeout.C:
- if !dir.Deleted && !file.Deleted {
- t.Errorf("Neither the dir nor its content was deleted before timing out.")
- } else if !dir.Deleted {
- t.Errorf("The dir was not deleted before timing out.")
- } else {
- t.Errorf("The content of the dir was not deleted before timing out.")
- }
- return
- default:
- time.Sleep(100 * time.Millisecond)
- }
- }
- }
- func TestIssue4475(t *testing.T) {
- m, conn, fcfg, wcfgCancel := setupModelWithConnection(t)
- defer wcfgCancel()
- defer cleanupModel(m)
- testFs := fcfg.Filesystem(nil)
- // Scenario: Dir is deleted locally and before syncing/index exchange
- // happens, a file is create in that dir on the remote.
- // This should result in the directory being recreated and added to the
- // db locally.
- must(t, testFs.MkdirAll("delDir", 0o755))
- m.ScanFolder("default")
- if fcfg, ok := m.cfg.Folder("default"); !ok || !fcfg.SharedWith(device1) {
- t.Fatal("not shared with device1")
- }
- fileName := filepath.Join("delDir", "file")
- conn.addFile(fileName, 0o644, protocol.FileInfoTypeFile, nil)
- conn.sendIndexUpdate()
- // Is there something we could trigger on instead of just waiting?
- timeout := time.NewTimer(5 * time.Second)
- created := false
- for {
- if !created {
- if _, ok := m.testCurrentFolderFile("default", fileName); ok {
- created = true
- }
- } else {
- dir, ok := m.testCurrentFolderFile("default", "delDir")
- if !ok {
- t.Fatalf("can't get dir from db")
- }
- if !dir.Deleted {
- return
- }
- }
- select {
- case <-timeout.C:
- if created {
- t.Errorf("Timed out before file from remote was created")
- } else {
- t.Errorf("Timed out before directory was resurrected in db")
- }
- return
- default:
- time.Sleep(100 * time.Millisecond)
- }
- }
- }
- func TestVersionRestore(t *testing.T) {
- t.Skip("incompatible with fakefs")
- // We create a bunch of files which we restore
- // In each file, we write the filename as the content
- // We verify that the content matches at the expected filenames
- // after the restore operation.
- fcfg := newFolderConfiguration(defaultCfgWrapper, "default", "default", fs.FilesystemTypeFake, srand.String(32))
- fcfg.Versioning.Type = "simple"
- fcfg.FSWatcherEnabled = false
- filesystem := fcfg.Filesystem(nil)
- rawConfig := config.Configuration{
- Version: config.CurrentVersion,
- Folders: []config.FolderConfiguration{fcfg},
- }
- cfg, cancel := newConfigWrapper(rawConfig)
- defer cancel()
- m := setupModel(t, cfg)
- defer cleanupModel(m)
- m.ScanFolder("default")
- sentinel, err := time.ParseInLocation(versioner.TimeFormat, "20180101-010101", time.Local)
- if err != nil {
- t.Fatal(err)
- }
- for _, file := range []string{
- // Versions directory
- ".stversions/file~20171210-040404.txt", // will be restored
- ".stversions/existing~20171210-040404", // exists, should expect to be archived.
- ".stversions/something~20171210-040404", // will become directory, hence error
- ".stversions/dir/file~20171210-040404.txt",
- ".stversions/dir/file~20171210-040405.txt",
- ".stversions/dir/file~20171210-040406.txt",
- ".stversions/very/very/deep/one~20171210-040406.txt", // lives deep down, no directory exists.
- ".stversions/dir/existing~20171210-040406.txt", // exists, should expect to be archived.
- ".stversions/dir/cat", // untagged which was used by trashcan, supported
- // "file.txt" will be restored
- "existing",
- "something/file", // Becomes directory
- "dir/file.txt",
- "dir/existing.txt",
- } {
- if build.IsWindows {
- file = filepath.FromSlash(file)
- }
- dir := filepath.Dir(file)
- must(t, filesystem.MkdirAll(dir, 0o755))
- if fd, err := filesystem.Create(file); err != nil {
- t.Fatal(err)
- } else if _, err := fd.Write([]byte(file)); err != nil {
- t.Fatal(err)
- } else if err := fd.Close(); err != nil {
- t.Fatal(err)
- } else if err := filesystem.Chtimes(file, sentinel, sentinel); err != nil {
- t.Fatal(err)
- }
- }
- versions, err := m.GetFolderVersions("default")
- must(t, err)
- expectedVersions := map[string]int{
- "file.txt": 1,
- "existing": 1,
- "something": 1,
- "dir/file.txt": 3,
- "dir/existing.txt": 1,
- "very/very/deep/one.txt": 1,
- "dir/cat": 1,
- }
- for name, vers := range versions {
- cnt, ok := expectedVersions[name]
- if !ok {
- t.Errorf("unexpected %s", name)
- }
- if len(vers) != cnt {
- t.Errorf("%s: %d != %d", name, cnt, len(vers))
- }
- // Delete, so we can check if we didn't hit something we expect afterwards.
- delete(expectedVersions, name)
- }
- for name := range expectedVersions {
- t.Errorf("not found expected %s", name)
- }
- // Restoring non existing folder fails.
- _, err = m.RestoreFolderVersions("does not exist", nil)
- if err == nil {
- t.Errorf("expected an error")
- }
- makeTime := func(s string) time.Time {
- tm, err := time.ParseInLocation(versioner.TimeFormat, s, time.Local)
- if err != nil {
- t.Error(err)
- }
- return tm.Truncate(time.Second)
- }
- restore := map[string]time.Time{
- "file.txt": makeTime("20171210-040404"),
- "existing": makeTime("20171210-040404"),
- "something": makeTime("20171210-040404"),
- "dir/file.txt": makeTime("20171210-040406"),
- "dir/existing.txt": makeTime("20171210-040406"),
- "very/very/deep/one.txt": makeTime("20171210-040406"),
- }
- beforeRestore := time.Now().Truncate(time.Second)
- ferr, err := m.RestoreFolderVersions("default", restore)
- must(t, err)
- if err, ok := ferr["something"]; len(ferr) > 1 || !ok || !errors.Is(err, versioner.ErrDirectory) {
- t.Fatalf("incorrect error or count: %d %s", len(ferr), ferr)
- }
- // Failed items are not expected to be restored.
- // Remove them from expectations
- for name := range ferr {
- delete(restore, name)
- }
- // Check that content of files matches to the version they've been restored.
- for file, version := range restore {
- if build.IsWindows {
- file = filepath.FromSlash(file)
- }
- tag := version.In(time.Local).Truncate(time.Second).Format(versioner.TimeFormat)
- taggedName := filepath.Join(versioner.DefaultPath, versioner.TagFilename(file, tag))
- fd, err := filesystem.Open(file)
- if err != nil {
- t.Error(err)
- }
- defer fd.Close()
- content, err := io.ReadAll(fd)
- if err != nil {
- t.Error(err)
- }
- if !bytes.Equal(content, []byte(taggedName)) {
- t.Errorf("%s: %s != %s", file, string(content), taggedName)
- }
- }
- // Simple versioner uses now for timestamp generation, so we can check
- // if existing stuff was correctly archived as we restored (oppose to deleteD), and version time as after beforeRestore
- expectArchived := map[string]struct{}{
- "existing": {},
- "dir/file.txt": {},
- "dir/existing.txt": {},
- }
- allFileVersions, err := m.GetFolderVersions("default")
- must(t, err)
- for file, versions := range allFileVersions {
- key := file
- if build.IsWindows {
- file = filepath.FromSlash(file)
- }
- for _, version := range versions {
- if version.VersionTime.Equal(beforeRestore) || version.VersionTime.After(beforeRestore) {
- fd, err := filesystem.Open(versioner.DefaultPath + "/" + versioner.TagFilename(file, version.VersionTime.Format(versioner.TimeFormat)))
- must(t, err)
- defer fd.Close()
- content, err := io.ReadAll(fd)
- if err != nil {
- t.Error(err)
- }
- // Even if they are at the archived path, content should have the non
- // archived name.
- if !bytes.Equal(content, []byte(file)) {
- t.Errorf("%s (%s): %s != %s", file, fd.Name(), string(content), file)
- }
- _, ok := expectArchived[key]
- if !ok {
- t.Error("unexpected archived file with future timestamp", file, version.VersionTime)
- }
- delete(expectArchived, key)
- }
- }
- }
- if len(expectArchived) != 0 {
- t.Fatal("missed some archived files", expectArchived)
- }
- }
- func TestPausedFolders(t *testing.T) {
- // Create a separate wrapper not to pollute other tests.
- wrapper, cancel := newConfigWrapper(defaultCfgWrapper.RawCopy())
- defer cancel()
- m := setupModel(t, wrapper)
- defer cleanupModel(m)
- if err := m.ScanFolder("default"); err != nil {
- t.Error(err)
- }
- pausedConfig := wrapper.RawCopy()
- pausedConfig.Folders[0].Paused = true
- replace(t, wrapper, pausedConfig)
- if err := m.ScanFolder("default"); err != ErrFolderPaused {
- t.Errorf("Expected folder paused error, received: %v", err)
- }
- if err := m.ScanFolder("nonexistent"); err != ErrFolderMissing {
- t.Errorf("Expected missing folder error, received: %v", err)
- }
- }
- func TestIssue4094(t *testing.T) {
- // Create a separate wrapper not to pollute other tests.
- wrapper, cancel := newConfigWrapper(config.Configuration{Version: config.CurrentVersion})
- defer cancel()
- m := newModel(t, wrapper, myID, nil)
- m.ServeBackground()
- defer cleanupModel(m)
- // Force the model to wire itself and add the folders
- folderPath := "nonexistent"
- cfg := defaultCfgWrapper.RawCopy()
- fcfg := config.FolderConfiguration{
- FilesystemType: fs.FilesystemTypeFake,
- ID: "folder1",
- Path: folderPath,
- Paused: true,
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- },
- }
- cfg.Folders = []config.FolderConfiguration{fcfg}
- replace(t, wrapper, cfg)
- if err := m.SetIgnores(fcfg.ID, []string{"foo"}); err != nil {
- t.Fatalf("failed setting ignores: %v", err)
- }
- if _, err := fcfg.Filesystem(nil).Lstat(".stignore"); err != nil {
- t.Fatalf("failed stating .stignore: %v", err)
- }
- }
- func TestIssue4903(t *testing.T) {
- wrapper, cancel := newConfigWrapper(config.Configuration{Version: config.CurrentVersion})
- defer cancel()
- m := setupModel(t, wrapper)
- defer cleanupModel(m)
- // Force the model to wire itself and add the folders
- folderPath := "nonexistent"
- cfg := defaultCfgWrapper.RawCopy()
- fcfg := config.FolderConfiguration{
- ID: "folder1",
- Path: folderPath,
- Paused: true,
- Devices: []config.FolderDeviceConfiguration{
- {DeviceID: device1},
- },
- }
- cfg.Folders = []config.FolderConfiguration{fcfg}
- replace(t, wrapper, cfg)
- if err := fcfg.CheckPath(); err != config.ErrPathMissing {
- t.Fatalf("expected path missing error, got: %v, debug: %s", err, fcfg.CheckPath())
- }
- if _, err := fcfg.Filesystem(nil).Lstat("."); !fs.IsNotExist(err) {
- t.Fatalf("Expected missing path error, got: %v", err)
- }
- }
- func TestIssue5002(t *testing.T) {
- // recheckFile should not panic when given an index equal to the number of blocks
- w, fcfg, wCancel := newDefaultCfgWrapper()
- defer wCancel()
- ffs := fcfg.Filesystem(nil)
- fd, err := ffs.Create("foo")
- must(t, err)
- _, err = fd.Write([]byte("foobar"))
- must(t, err)
- fd.Close()
- m := setupModel(t, w)
- defer cleanupModel(m)
- if err := m.ScanFolder("default"); err != nil {
- t.Error(err)
- }
- file, ok := m.testCurrentFolderFile("default", "foo")
- if !ok {
- t.Fatal("test file should exist")
- }
- blockSize := int32(file.BlockSize())
- m.recheckFile(protocol.LocalDeviceID, "default", "foo", file.Size-int64(blockSize), []byte{1, 2, 3, 4}, 0)
- m.recheckFile(protocol.LocalDeviceID, "default", "foo", file.Size, []byte{1, 2, 3, 4}, 0) // panic
- m.recheckFile(protocol.LocalDeviceID, "default", "foo", file.Size+int64(blockSize), []byte{1, 2, 3, 4}, 0)
- }
- func TestParentOfUnignored(t *testing.T) {
- w, fcfg, wCancel := newDefaultCfgWrapper()
- defer wCancel()
- ffs := fcfg.Filesystem(nil)
- must(t, ffs.Mkdir("bar", 0o755))
- must(t, ffs.Mkdir("baz", 0o755))
- must(t, ffs.Mkdir("baz/quux", 0o755))
- m := setupModel(t, w)
- defer cleanupModel(m)
- m.SetIgnores("default", []string{"!quux", "*"})
- m.ScanFolder("default")
- if bar, ok := m.testCurrentFolderFile("default", "bar"); !ok {
- t.Error(`Directory "bar" missing in db`)
- } else if !bar.IsIgnored() {
- t.Error(`Directory "bar" is not ignored`)
- }
- if baz, ok := m.testCurrentFolderFile("default", "baz"); !ok {
- t.Error(`Directory "baz" missing in db`)
- } else if baz.IsIgnored() {
- t.Error(`Directory "baz" is ignored`)
- }
- }
- // TestFolderRestartZombies reproduces issue 5233, where multiple concurrent folder
- // restarts would leave more than one folder runner alive.
- func TestFolderRestartZombies(t *testing.T) {
- wrapper, cancel := newConfigWrapper(defaultCfg.Copy())
- defer cancel()
- waiter, err := wrapper.Modify(func(cfg *config.Configuration) {
- cfg.Options.RawMaxFolderConcurrency = -1
- _, i, _ := cfg.Folder("default")
- cfg.Folders[i].FilesystemType = fs.FilesystemTypeFake
- })
- must(t, err)
- waiter.Wait()
- folderCfg, _ := wrapper.Folder("default")
- m := setupModel(t, wrapper)
- defer cleanupModel(m)
- // Make sure the folder is up and running, because we want to count it.
- m.ScanFolder("default")
- // Check how many running folders we have running before the test.
- if r := m.foldersRunning.Load(); r != 1 {
- t.Error("Expected one running folder, not", r)
- }
- // Run a few parallel configuration changers for one second. Each waits
- // for the commit to complete, but there are many of them.
- var wg sync.WaitGroup
- for i := 0; i < 25; i++ {
- wg.Add(1)
- go func() {
- defer wg.Done()
- t0 := time.Now()
- for time.Since(t0) < time.Second {
- fcfg := folderCfg.Copy()
- fcfg.MaxConflicts = mrand.Int() // safe change that should cause a folder restart
- setFolder(t, wrapper, fcfg)
- }
- }()
- }
- // Wait for the above to complete and check how many folders we have
- // running now. It should not have increased.
- wg.Wait()
- // Make sure the folder is up and running, because we want to count it.
- m.ScanFolder("default")
- if r := m.foldersRunning.Load(); r != 1 {
- t.Error("Expected one running folder, not", r)
- }
- }
- func TestRequestLimit(t *testing.T) {
- wrapper, fcfg, cancel := newDefaultCfgWrapper()
- ffs := fcfg.Filesystem(nil)
- file := "tmpfile"
- fd, err := ffs.Create(file)
- must(t, err)
- fd.Close()
- defer cancel()
- waiter, err := wrapper.Modify(func(cfg *config.Configuration) {
- _, i, _ := cfg.Device(device1)
- cfg.Devices[i].MaxRequestKiB = 1
- })
- must(t, err)
- waiter.Wait()
- m, conn := setupModelWithConnectionFromWrapper(t, wrapper)
- defer cleanupModel(m)
- m.ScanFolder("default")
- befReq := time.Now()
- first, err := m.Request(conn, "default", file, 0, 2000, 0, nil, 0, false)
- if err != nil {
- t.Fatalf("First request failed: %v", err)
- }
- reqDur := time.Since(befReq)
- returned := make(chan struct{})
- go func() {
- second, err := m.Request(conn, "default", file, 0, 2000, 0, nil, 0, false)
- if err != nil {
- t.Errorf("Second request failed: %v", err)
- }
- close(returned)
- second.Close()
- }()
- time.Sleep(10 * reqDur)
- select {
- case <-returned:
- t.Fatalf("Second request returned before first was done")
- default:
- }
- first.Close()
- select {
- case <-returned:
- case <-time.After(time.Second):
- t.Fatalf("Second request did not return after first was done")
- }
- }
- // TestConnCloseOnRestart checks that there is no deadlock when calling Close
- // on a protocol connection that has a blocking reader (blocking writer can't
- // be done as the test requires clusterconfigs to go through).
- func TestConnCloseOnRestart(t *testing.T) {
- oldCloseTimeout := protocol.CloseTimeout
- protocol.CloseTimeout = 100 * time.Millisecond
- defer func() {
- protocol.CloseTimeout = oldCloseTimeout
- }()
- w, fcfg, wCancel := newDefaultCfgWrapper()
- defer wCancel()
- m := setupModel(t, w)
- defer cleanupModelAndRemoveDir(m, fcfg.Filesystem(nil).URI())
- br := &testutil.BlockingRW{}
- nw := &testutil.NoopRW{}
- ci := &protocolmocks.ConnectionInfo{}
- ci.ConnectionIDReturns(srand.String(16))
- m.AddConnection(protocol.NewConnection(device1, br, nw, testutil.NoopCloser{}, m, ci, protocol.CompressionNever, nil, m.keyGen), protocol.Hello{})
- m.pmut.RLock()
- if len(m.closed) != 1 {
- t.Fatalf("Expected just one conn (len(m.closed) == %v)", len(m.closed))
- }
- var closed chan struct{}
- for _, c := range m.closed {
- closed = c
- }
- m.pmut.RUnlock()
- waiter, err := w.RemoveDevice(device1)
- if err != nil {
- t.Fatal(err)
- }
- done := make(chan struct{})
- go func() {
- waiter.Wait()
- close(done)
- }()
- select {
- case <-done:
- case <-time.After(5 * time.Second):
- t.Fatal("Timed out before config took effect")
- }
- select {
- case <-closed:
- case <-time.After(5 * time.Second):
- t.Fatal("Timed out before connection was closed")
- }
- }
- func TestModTimeWindow(t *testing.T) {
- w, fcfg, wCancel := newDefaultCfgWrapper()
- defer wCancel()
- tfs := modtimeTruncatingFS{
- trunc: 0,
- Filesystem: fcfg.Filesystem(nil),
- }
- // fcfg.RawModTimeWindowS = 2
- setFolder(t, w, fcfg)
- m := setupModel(t, w)
- defer cleanupModelAndRemoveDir(m, tfs.URI())
- name := "foo"
- fd, err := tfs.Create(name)
- must(t, err)
- stat, err := fd.Stat()
- must(t, err)
- modTime := stat.ModTime()
- fd.Close()
- m.ScanFolders()
- // Get current version
- fi, ok := m.testCurrentFolderFile("default", name)
- if !ok {
- t.Fatal("File missing")
- }
- v := fi.Version
- // Change the filesystem to only return modtimes to the closest two
- // seconds, like FAT.
- tfs.trunc = 2 * time.Second
- // Scan again
- m.ScanFolders()
- // No change due to within window
- fi, _ = m.testCurrentFolderFile("default", name)
- if !fi.Version.Equal(v) {
- t.Fatalf("Got version %v, expected %v", fi.Version, v)
- }
- // Update to be outside window
- err = tfs.Chtimes(name, time.Now(), modTime.Add(2*time.Second))
- must(t, err)
- m.ScanFolders()
- // Version should have updated
- fi, _ = m.testCurrentFolderFile("default", name)
- if fi.Version.Compare(v) != protocol.Greater {
- t.Fatalf("Got result %v, expected %v", fi.Version.Compare(v), protocol.Greater)
- }
- }
- func TestDevicePause(t *testing.T) {
- m, _, fcfg, wcfgCancel := setupModelWithConnection(t)
- defer wcfgCancel()
- defer cleanupModelAndRemoveDir(m, fcfg.Filesystem(nil).URI())
- sub := m.evLogger.Subscribe(events.DevicePaused)
- defer sub.Unsubscribe()
- m.pmut.RLock()
- var closed chan struct{}
- for _, c := range m.closed {
- closed = c
- }
- m.pmut.RUnlock()
- pauseDevice(t, m.cfg, device1, true)
- timeout := time.NewTimer(5 * time.Second)
- select {
- case <-sub.C():
- select {
- case <-closed:
- case <-timeout.C:
- t.Fatal("Timed out before connection was closed")
- }
- case <-timeout.C:
- t.Fatal("Timed out before device was paused")
- }
- }
- func TestDeviceWasSeen(t *testing.T) {
- m, _, fcfg, wcfgCancel := setupModelWithConnection(t)
- defer wcfgCancel()
- defer cleanupModelAndRemoveDir(m, fcfg.Filesystem(nil).URI())
- m.deviceWasSeen(device1)
- stats, err := m.DeviceStatistics()
- if err != nil {
- t.Error("Unexpected error:", err)
- }
- entry := stats[device1]
- if time.Since(entry.LastSeen) > time.Second {
- t.Error("device should have been seen now")
- }
- }
- func TestNewLimitedRequestResponse(t *testing.T) {
- l0 := semaphore.New(0)
- l1 := semaphore.New(1024)
- l2 := (*semaphore.Semaphore)(nil)
- // Should take 500 bytes from any non-unlimited non-nil limiters.
- res := newLimitedRequestResponse(500, l0, l1, l2)
- if l1.Available() != 1024-500 {
- t.Error("should have taken bytes from limited limiter")
- }
- // Closing the result should return the bytes.
- res.Close()
- // Try to take 1024 bytes to make sure the bytes were returned.
- done := make(chan struct{})
- go func() {
- l1.Take(1024)
- close(done)
- }()
- select {
- case <-done:
- case <-time.After(time.Second):
- t.Error("Bytes weren't returned in a timely fashion")
- }
- }
- func TestSummaryPausedNoError(t *testing.T) {
- wcfg, fcfg, wcfgCancel := newDefaultCfgWrapper()
- defer wcfgCancel()
- pauseFolder(t, wcfg, fcfg.ID, true)
- m := setupModel(t, wcfg)
- defer cleanupModel(m)
- fss := NewFolderSummaryService(wcfg, m, myID, events.NoopLogger)
- if _, err := fss.Summary(fcfg.ID); err != nil {
- t.Error("Expected no error getting a summary for a paused folder:", err)
- }
- }
- func TestFolderAPIErrors(t *testing.T) {
- wcfg, fcfg, wcfgCancel := newDefaultCfgWrapper()
- defer wcfgCancel()
- pauseFolder(t, wcfg, fcfg.ID, true)
- m := setupModel(t, wcfg)
- defer cleanupModel(m)
- methods := []func(folder string) error{
- m.ScanFolder,
- func(folder string) error {
- return m.ScanFolderSubdirs(folder, nil)
- },
- func(folder string) error {
- _, err := m.GetFolderVersions(folder)
- return err
- },
- func(folder string) error {
- _, err := m.RestoreFolderVersions(folder, nil)
- return err
- },
- }
- for i, method := range methods {
- if err := method(fcfg.ID); err != ErrFolderPaused {
- t.Errorf(`Expected "%v", got "%v" (method no %v)`, ErrFolderPaused, err, i)
- }
- if err := method("notexisting"); err != ErrFolderMissing {
- t.Errorf(`Expected "%v", got "%v" (method no %v)`, ErrFolderMissing, err, i)
- }
- }
- }
- func TestRenameSequenceOrder(t *testing.T) {
- wcfg, fcfg, wcfgCancel := newDefaultCfgWrapper()
- defer wcfgCancel()
- m := setupModel(t, wcfg)
- defer cleanupModel(m)
- numFiles := 20
- ffs := fcfg.Filesystem(nil)
- for i := 0; i < numFiles; i++ {
- v := fmt.Sprintf("%d", i)
- writeFile(t, ffs, v, []byte(v))
- }
- m.ScanFolders()
- count := 0
- snap := dbSnapshot(t, m, "default")
- snap.WithHave(protocol.LocalDeviceID, func(i protocol.FileIntf) bool {
- count++
- return true
- })
- snap.Release()
- if count != numFiles {
- t.Errorf("Unexpected count: %d != %d", count, numFiles)
- }
- // Modify all the files, other than the ones we expect to rename
- for i := 0; i < numFiles; i++ {
- if i == 3 || i == 17 || i == 16 || i == 4 {
- continue
- }
- v := fmt.Sprintf("%d", i)
- writeFile(t, ffs, v, []byte(v+"-new"))
- }
- // Rename
- must(t, ffs.Rename("3", "17"))
- must(t, ffs.Rename("16", "4"))
- // Scan
- m.ScanFolders()
- // Verify sequence of a appearing is followed by c disappearing.
- snap = dbSnapshot(t, m, "default")
- defer snap.Release()
- var firstExpectedSequence int64
- var secondExpectedSequence int64
- failed := false
- snap.WithHaveSequence(0, func(i protocol.FileIntf) bool {
- t.Log(i)
- if i.FileName() == "17" {
- firstExpectedSequence = i.SequenceNo() + 1
- }
- if i.FileName() == "4" {
- secondExpectedSequence = i.SequenceNo() + 1
- }
- if i.FileName() == "3" {
- failed = i.SequenceNo() != firstExpectedSequence || failed
- }
- if i.FileName() == "16" {
- failed = i.SequenceNo() != secondExpectedSequence || failed
- }
- return true
- })
- if failed {
- t.Fail()
- }
- }
- func TestRenameSameFile(t *testing.T) {
- wcfg, fcfg, wcfgCancel := newDefaultCfgWrapper()
- defer wcfgCancel()
- m := setupModel(t, wcfg)
- defer cleanupModel(m)
- ffs := fcfg.Filesystem(nil)
- writeFile(t, ffs, "file", []byte("file"))
- m.ScanFolders()
- count := 0
- snap := dbSnapshot(t, m, "default")
- snap.WithHave(protocol.LocalDeviceID, func(i protocol.FileIntf) bool {
- count++
- return true
- })
- snap.Release()
- if count != 1 {
- t.Errorf("Unexpected count: %d != %d", count, 1)
- }
- must(t, ffs.Rename("file", "file1"))
- must(t, osutil.Copy(fs.CopyRangeMethodStandard, ffs, ffs, "file1", "file0"))
- must(t, osutil.Copy(fs.CopyRangeMethodStandard, ffs, ffs, "file1", "file2"))
- must(t, osutil.Copy(fs.CopyRangeMethodStandard, ffs, ffs, "file1", "file3"))
- must(t, osutil.Copy(fs.CopyRangeMethodStandard, ffs, ffs, "file1", "file4"))
- m.ScanFolders()
- snap = dbSnapshot(t, m, "default")
- defer snap.Release()
- prevSeq := int64(0)
- seen := false
- snap.WithHaveSequence(0, func(i protocol.FileIntf) bool {
- if i.SequenceNo() <= prevSeq {
- t.Fatalf("non-increasing sequences: %d <= %d", i.SequenceNo(), prevSeq)
- }
- if i.FileName() == "file" {
- if seen {
- t.Fatal("already seen file")
- }
- seen = true
- }
- prevSeq = i.SequenceNo()
- return true
- })
- }
- func TestRenameEmptyFile(t *testing.T) {
- wcfg, fcfg, wcfgCancel := newDefaultCfgWrapper()
- defer wcfgCancel()
- m := setupModel(t, wcfg)
- defer cleanupModel(m)
- ffs := fcfg.Filesystem(nil)
- writeFile(t, ffs, "file", []byte("data"))
- writeFile(t, ffs, "empty", nil)
- m.ScanFolders()
- snap := dbSnapshot(t, m, "default")
- defer snap.Release()
- empty, eok := snap.Get(protocol.LocalDeviceID, "empty")
- if !eok {
- t.Fatal("failed to find empty file")
- }
- file, fok := snap.Get(protocol.LocalDeviceID, "file")
- if !fok {
- t.Fatal("failed to find non-empty file")
- }
- count := 0
- snap.WithBlocksHash(empty.BlocksHash, func(_ protocol.FileIntf) bool {
- count++
- return true
- })
- if count != 0 {
- t.Fatalf("Found %d entries for empty file, expected 0", count)
- }
- count = 0
- snap.WithBlocksHash(file.BlocksHash, func(_ protocol.FileIntf) bool {
- count++
- return true
- })
- if count != 1 {
- t.Fatalf("Found %d entries for non-empty file, expected 1", count)
- }
- must(t, ffs.Rename("file", "new-file"))
- must(t, ffs.Rename("empty", "new-empty"))
- // Scan
- m.ScanFolders()
- snap = dbSnapshot(t, m, "default")
- defer snap.Release()
- count = 0
- snap.WithBlocksHash(empty.BlocksHash, func(_ protocol.FileIntf) bool {
- count++
- return true
- })
- if count != 0 {
- t.Fatalf("Found %d entries for empty file, expected 0", count)
- }
- count = 0
- snap.WithBlocksHash(file.BlocksHash, func(i protocol.FileIntf) bool {
- count++
- if i.FileName() != "new-file" {
- t.Fatalf("unexpected file name %s, expected new-file", i.FileName())
- }
- return true
- })
- if count != 1 {
- t.Fatalf("Found %d entries for non-empty file, expected 1", count)
- }
- }
- func TestBlockListMap(t *testing.T) {
- wcfg, fcfg, wcfgCancel := newDefaultCfgWrapper()
- defer wcfgCancel()
- m := setupModel(t, wcfg)
- defer cleanupModel(m)
- ffs := fcfg.Filesystem(nil)
- writeFile(t, ffs, "one", []byte("content"))
- writeFile(t, ffs, "two", []byte("content"))
- writeFile(t, ffs, "three", []byte("content"))
- writeFile(t, ffs, "four", []byte("content"))
- writeFile(t, ffs, "five", []byte("content"))
- m.ScanFolders()
- snap := dbSnapshot(t, m, "default")
- defer snap.Release()
- fi, ok := snap.Get(protocol.LocalDeviceID, "one")
- if !ok {
- t.Error("failed to find existing file")
- }
- var paths []string
- snap.WithBlocksHash(fi.BlocksHash, func(fi protocol.FileIntf) bool {
- paths = append(paths, fi.FileName())
- return true
- })
- snap.Release()
- expected := []string{"one", "two", "three", "four", "five"}
- if !equalStringsInAnyOrder(paths, expected) {
- t.Errorf("expected %q got %q", expected, paths)
- }
- // Fudge the files around
- // Remove
- must(t, ffs.Remove("one"))
- // Modify
- must(t, ffs.Remove("two"))
- writeFile(t, ffs, "two", []byte("mew-content"))
- // Rename
- must(t, ffs.Rename("three", "new-three"))
- // Change type
- must(t, ffs.Remove("four"))
- must(t, ffs.Mkdir("four", 0o644))
- m.ScanFolders()
- // Check we're left with 2 of the 5
- snap = dbSnapshot(t, m, "default")
- defer snap.Release()
- paths = paths[:0]
- snap.WithBlocksHash(fi.BlocksHash, func(fi protocol.FileIntf) bool {
- paths = append(paths, fi.FileName())
- return true
- })
- snap.Release()
- expected = []string{"new-three", "five"}
- if !equalStringsInAnyOrder(paths, expected) {
- t.Errorf("expected %q got %q", expected, paths)
- }
- }
- func TestScanRenameCaseOnly(t *testing.T) {
- wcfg, fcfg, wcfgCancel := newDefaultCfgWrapper()
- defer wcfgCancel()
- m := setupModel(t, wcfg)
- defer cleanupModel(m)
- ffs := fcfg.Filesystem(nil)
- name := "foo"
- writeFile(t, ffs, name, []byte("contents"))
- m.ScanFolders()
- snap := dbSnapshot(t, m, fcfg.ID)
- defer snap.Release()
- found := false
- snap.WithHave(protocol.LocalDeviceID, func(i protocol.FileIntf) bool {
- if found {
- t.Fatal("got more than one file")
- }
- if i.FileName() != name {
- t.Fatalf("got file %v, expected %v", i.FileName(), name)
- }
- found = true
- return true
- })
- snap.Release()
- upper := strings.ToUpper(name)
- must(t, ffs.Rename(name, upper))
- m.ScanFolders()
- snap = dbSnapshot(t, m, fcfg.ID)
- defer snap.Release()
- found = false
- snap.WithHave(protocol.LocalDeviceID, func(i protocol.FileIntf) bool {
- if i.FileName() == name {
- if i.IsDeleted() {
- return true
- }
- t.Fatal("renamed file not deleted")
- }
- if i.FileName() != upper {
- t.Fatalf("got file %v, expected %v", i.FileName(), upper)
- }
- if found {
- t.Fatal("got more than the expected files")
- }
- found = true
- return true
- })
- }
- func TestClusterConfigOnFolderAdd(t *testing.T) {
- testConfigChangeTriggersClusterConfigs(t, false, true, nil, func(wrapper config.Wrapper) {
- fcfg := newFolderConfig()
- fcfg.ID = "second"
- fcfg.Label = "second"
- fcfg.Devices = []config.FolderDeviceConfiguration{{
- DeviceID: device2,
- IntroducedBy: protocol.EmptyDeviceID,
- }}
- setFolder(t, wrapper, fcfg)
- })
- }
- func TestClusterConfigOnFolderShare(t *testing.T) {
- testConfigChangeTriggersClusterConfigs(t, true, true, nil, func(cfg config.Wrapper) {
- fcfg := cfg.FolderList()[0]
- fcfg.Devices = []config.FolderDeviceConfiguration{{
- DeviceID: device2,
- IntroducedBy: protocol.EmptyDeviceID,
- }}
- setFolder(t, cfg, fcfg)
- })
- }
- func TestClusterConfigOnFolderUnshare(t *testing.T) {
- testConfigChangeTriggersClusterConfigs(t, true, false, nil, func(cfg config.Wrapper) {
- fcfg := cfg.FolderList()[0]
- fcfg.Devices = nil
- setFolder(t, cfg, fcfg)
- })
- }
- func TestClusterConfigOnFolderRemove(t *testing.T) {
- testConfigChangeTriggersClusterConfigs(t, true, false, nil, func(cfg config.Wrapper) {
- rcfg := cfg.RawCopy()
- rcfg.Folders = nil
- replace(t, cfg, rcfg)
- })
- }
- func TestClusterConfigOnFolderPause(t *testing.T) {
- testConfigChangeTriggersClusterConfigs(t, true, false, nil, func(cfg config.Wrapper) {
- pauseFolder(t, cfg, cfg.FolderList()[0].ID, true)
- })
- }
- func TestClusterConfigOnFolderUnpause(t *testing.T) {
- testConfigChangeTriggersClusterConfigs(t, true, false, func(cfg config.Wrapper) {
- pauseFolder(t, cfg, cfg.FolderList()[0].ID, true)
- }, func(cfg config.Wrapper) {
- pauseFolder(t, cfg, cfg.FolderList()[0].ID, false)
- })
- }
- func TestAddFolderCompletion(t *testing.T) {
- // Empty folders are always 100% complete.
- comp := newFolderCompletion(db.Counts{}, db.Counts{}, 0, remoteFolderValid)
- comp.add(newFolderCompletion(db.Counts{}, db.Counts{}, 0, remoteFolderPaused))
- if comp.CompletionPct != 100 {
- t.Error(comp.CompletionPct)
- }
- // Completion is of the whole
- comp = newFolderCompletion(db.Counts{Bytes: 100}, db.Counts{}, 0, remoteFolderValid) // 100% complete
- comp.add(newFolderCompletion(db.Counts{Bytes: 400}, db.Counts{Bytes: 50}, 0, remoteFolderValid)) // 82.5% complete
- if comp.CompletionPct != 90 { // 100 * (1 - 50/500)
- t.Error(comp.CompletionPct)
- }
- }
- func TestScanDeletedROChangedOnSR(t *testing.T) {
- m, conn, fcfg, wCancel := setupModelWithConnection(t)
- ffs := fcfg.Filesystem(nil)
- defer wCancel()
- defer cleanupModelAndRemoveDir(m, ffs.URI())
- fcfg.Type = config.FolderTypeReceiveOnly
- setFolder(t, m.cfg, fcfg)
- name := "foo"
- writeFile(t, ffs, name, []byte(name))
- m.ScanFolders()
- file, ok := m.testCurrentFolderFile(fcfg.ID, name)
- if !ok {
- t.Fatal("file missing in db")
- }
- // A remote must have the file, otherwise the deletion below is
- // automatically resolved as not a ro-changed item.
- must(t, m.IndexUpdate(conn, fcfg.ID, []protocol.FileInfo{file}))
- must(t, ffs.Remove(name))
- m.ScanFolders()
- if receiveOnlyChangedSize(t, m, fcfg.ID).Deleted != 1 {
- t.Fatal("expected one receive only changed deleted item")
- }
- fcfg.Type = config.FolderTypeSendReceive
- setFolder(t, m.cfg, fcfg)
- m.ScanFolders()
- if receiveOnlyChangedSize(t, m, fcfg.ID).Deleted != 0 {
- t.Fatal("expected no receive only changed deleted item")
- }
- if localSize(t, m, fcfg.ID).Deleted != 1 {
- t.Fatal("expected one local deleted item")
- }
- }
- func testConfigChangeTriggersClusterConfigs(t *testing.T, expectFirst, expectSecond bool, pre func(config.Wrapper), fn func(config.Wrapper)) {
- t.Helper()
- wcfg, _, wcfgCancel := newDefaultCfgWrapper()
- defer wcfgCancel()
- m := setupModel(t, wcfg)
- defer cleanupModel(m)
- setDevice(t, wcfg, newDeviceConfiguration(wcfg.DefaultDevice(), device2, "device2"))
- if pre != nil {
- pre(wcfg)
- }
- cc1 := make(chan struct{}, 1)
- cc2 := make(chan struct{}, 1)
- fc1 := newFakeConnection(device1, m)
- fc1.ClusterConfigCalls(func(_ protocol.ClusterConfig) {
- cc1 <- struct{}{}
- })
- fc2 := newFakeConnection(device2, m)
- fc2.ClusterConfigCalls(func(_ protocol.ClusterConfig) {
- cc2 <- struct{}{}
- })
- m.AddConnection(fc1, protocol.Hello{})
- m.AddConnection(fc2, protocol.Hello{})
- m.promoteConnections()
- // Initial CCs
- select {
- case <-cc1:
- default:
- t.Fatal("missing initial CC from device1")
- }
- select {
- case <-cc2:
- default:
- t.Fatal("missing initial CC from device2")
- }
- t.Log("Applying config change")
- fn(wcfg)
- timeout := time.NewTimer(time.Second)
- if expectFirst {
- select {
- case <-cc1:
- case <-timeout.C:
- t.Errorf("timed out before receiving cluste rconfig for first device")
- }
- }
- if expectSecond {
- select {
- case <-cc2:
- case <-timeout.C:
- t.Errorf("timed out before receiving cluste rconfig for second device")
- }
- }
- }
- // The end result of the tested scenario is that the global version entry has an
- // empty version vector and is not deleted, while everything is actually deleted.
- // That then causes these files to be considered as needed, while they are not.
- // https://github.com/syncthing/syncthing/issues/6961
- func TestIssue6961(t *testing.T) {
- wcfg, fcfg, wcfgCancel := newDefaultCfgWrapper()
- defer wcfgCancel()
- tfs := fcfg.Filesystem(nil)
- waiter, err := wcfg.Modify(func(cfg *config.Configuration) {
- cfg.SetDevice(newDeviceConfiguration(cfg.Defaults.Device, device2, "device2"))
- fcfg.Type = config.FolderTypeReceiveOnly
- fcfg.Devices = append(fcfg.Devices, config.FolderDeviceConfiguration{DeviceID: device2})
- cfg.SetFolder(fcfg)
- })
- must(t, err)
- waiter.Wait()
- // Always recalc/repair when opening a fileset.
- m := newModel(t, wcfg, myID, nil)
- m.db.Close()
- m.db, err = db.NewLowlevel(backend.OpenMemory(), m.evLogger, db.WithRecheckInterval(time.Millisecond))
- if err != nil {
- t.Fatal(err)
- }
- m.ServeBackground()
- defer cleanupModelAndRemoveDir(m, tfs.URI())
- conn1 := addFakeConn(m, device1, fcfg.ID)
- conn2 := addFakeConn(m, device2, fcfg.ID)
- m.ScanFolders()
- name := "foo"
- version := protocol.Vector{}.Update(device1.Short())
- // Remote, valid and existing file
- must(t, m.Index(conn1, fcfg.ID, []protocol.FileInfo{{Name: name, Version: version, Sequence: 1}}))
- // Remote, invalid (receive-only) and existing file
- must(t, m.Index(conn2, fcfg.ID, []protocol.FileInfo{{Name: name, RawInvalid: true, Sequence: 1}}))
- // Create a local file
- if fd, err := tfs.OpenFile(name, fs.OptCreate, 0o666); err != nil {
- t.Fatal(err)
- } else {
- fd.Close()
- }
- if info, err := tfs.Lstat(name); err != nil {
- t.Fatal(err)
- } else {
- l.Infoln("intest", info.Mode)
- }
- m.ScanFolders()
- // Get rid of valid global
- waiter, err = wcfg.RemoveDevice(device1)
- if err != nil {
- t.Fatal(err)
- }
- waiter.Wait()
- // Delete the local file
- must(t, tfs.Remove(name))
- m.ScanFolders()
- // Drop the remote index, add some other file.
- must(t, m.Index(conn2, fcfg.ID, []protocol.FileInfo{{Name: "bar", RawInvalid: true, Sequence: 1}}))
- // Pause and unpause folder to create new db.FileSet and thus recalculate everything
- pauseFolder(t, wcfg, fcfg.ID, true)
- pauseFolder(t, wcfg, fcfg.ID, false)
- if comp := m.testCompletion(device2, fcfg.ID); comp.NeedDeletes != 0 {
- t.Error("Expected 0 needed deletes, got", comp.NeedDeletes)
- } else {
- t.Log(comp)
- }
- }
- func TestCompletionEmptyGlobal(t *testing.T) {
- m, conn, fcfg, wcfgCancel := setupModelWithConnection(t)
- defer wcfgCancel()
- defer cleanupModelAndRemoveDir(m, fcfg.Filesystem(nil).URI())
- files := []protocol.FileInfo{{Name: "foo", Version: protocol.Vector{}.Update(myID.Short()), Sequence: 1}}
- m.fmut.Lock()
- m.folderFiles[fcfg.ID].Update(protocol.LocalDeviceID, files)
- m.fmut.Unlock()
- files[0].Deleted = true
- files[0].Version = files[0].Version.Update(device1.Short())
- must(t, m.IndexUpdate(conn, fcfg.ID, files))
- comp := m.testCompletion(protocol.LocalDeviceID, fcfg.ID)
- if comp.CompletionPct != 95 {
- t.Error("Expected completion of 95%, got", comp.CompletionPct)
- }
- }
- func TestNeedMetaAfterIndexReset(t *testing.T) {
- w, fcfg, wCancel := newDefaultCfgWrapper()
- defer wCancel()
- addDevice2(t, w, fcfg)
- m := setupModel(t, w)
- defer cleanupModelAndRemoveDir(m, fcfg.Path)
- conn1 := addFakeConn(m, device1, fcfg.ID)
- conn2 := addFakeConn(m, device2, fcfg.ID)
- var seq int64 = 1
- files := []protocol.FileInfo{{Name: "foo", Size: 10, Version: protocol.Vector{}.Update(device1.Short()), Sequence: seq}}
- // Start with two remotes having one file, then both deleting it, then
- // only one adding it again.
- must(t, m.Index(conn1, fcfg.ID, files))
- must(t, m.Index(conn2, fcfg.ID, files))
- seq++
- files[0].SetDeleted(device2.Short())
- files[0].Sequence = seq
- must(t, m.IndexUpdate(conn1, fcfg.ID, files))
- must(t, m.IndexUpdate(conn2, fcfg.ID, files))
- seq++
- files[0].Deleted = false
- files[0].Size = 20
- files[0].Version = files[0].Version.Update(device1.Short())
- files[0].Sequence = seq
- must(t, m.IndexUpdate(conn1, fcfg.ID, files))
- if comp := m.testCompletion(device2, fcfg.ID); comp.NeedItems != 1 {
- t.Error("Expected one needed item for device2, got", comp.NeedItems)
- }
- // Pretend we had an index reset on device 1
- must(t, m.Index(conn1, fcfg.ID, files))
- if comp := m.testCompletion(device2, fcfg.ID); comp.NeedItems != 1 {
- t.Error("Expected one needed item for device2, got", comp.NeedItems)
- }
- }
- func TestCcCheckEncryption(t *testing.T) {
- if testing.Short() {
- t.Skip("skipping on short testing - generating encryption tokens is slow")
- }
- w, fcfg, wCancel := newDefaultCfgWrapper()
- defer wCancel()
- m := setupModel(t, w)
- m.cancel()
- defer cleanupModel(m)
- pw := "foo"
- token := protocol.PasswordToken(m.keyGen, fcfg.ID, pw)
- m.folderEncryptionPasswordTokens[fcfg.ID] = token
- testCases := []struct {
- tokenRemote, tokenLocal []byte
- isEncryptedRemote, isEncryptedLocal bool
- expectedErr error
- }{
- {
- tokenRemote: token,
- tokenLocal: token,
- expectedErr: errEncryptionInvConfigRemote,
- },
- {
- isEncryptedRemote: true,
- isEncryptedLocal: true,
- expectedErr: errEncryptionInvConfigLocal,
- },
- {
- tokenRemote: token,
- tokenLocal: nil,
- isEncryptedRemote: false,
- isEncryptedLocal: false,
- expectedErr: errEncryptionNotEncryptedLocal,
- },
- {
- tokenRemote: token,
- tokenLocal: nil,
- isEncryptedRemote: true,
- isEncryptedLocal: false,
- expectedErr: nil,
- },
- {
- tokenRemote: token,
- tokenLocal: nil,
- isEncryptedRemote: false,
- isEncryptedLocal: true,
- expectedErr: nil,
- },
- {
- tokenRemote: nil,
- tokenLocal: token,
- isEncryptedRemote: true,
- isEncryptedLocal: false,
- expectedErr: nil,
- },
- {
- tokenRemote: nil,
- tokenLocal: token,
- isEncryptedRemote: false,
- isEncryptedLocal: true,
- expectedErr: nil,
- },
- {
- tokenRemote: nil,
- tokenLocal: token,
- isEncryptedRemote: false,
- isEncryptedLocal: false,
- expectedErr: errEncryptionNotEncryptedLocal,
- },
- {
- tokenRemote: nil,
- tokenLocal: nil,
- isEncryptedRemote: true,
- isEncryptedLocal: false,
- expectedErr: errEncryptionPlainForRemoteEncrypted,
- },
- {
- tokenRemote: nil,
- tokenLocal: nil,
- isEncryptedRemote: false,
- isEncryptedLocal: true,
- expectedErr: errEncryptionPlainForReceiveEncrypted,
- },
- {
- tokenRemote: nil,
- tokenLocal: nil,
- isEncryptedRemote: false,
- isEncryptedLocal: false,
- expectedErr: nil,
- },
- }
- for i, tc := range testCases {
- tfcfg := fcfg.Copy()
- if tc.isEncryptedLocal {
- tfcfg.Type = config.FolderTypeReceiveEncrypted
- m.folderEncryptionPasswordTokens[fcfg.ID] = token
- }
- dcfg := config.FolderDeviceConfiguration{DeviceID: device1}
- if tc.isEncryptedRemote {
- dcfg.EncryptionPassword = pw
- }
- deviceInfos := &clusterConfigDeviceInfo{
- remote: protocol.Device{ID: device1, EncryptionPasswordToken: tc.tokenRemote},
- local: protocol.Device{ID: myID, EncryptionPasswordToken: tc.tokenLocal},
- }
- err := m.ccCheckEncryption(tfcfg, dcfg, deviceInfos, false)
- if err != tc.expectedErr {
- t.Errorf("Testcase %v: Expected error %v, got %v", i, tc.expectedErr, err)
- }
- if tc.expectedErr == nil {
- err := m.ccCheckEncryption(tfcfg, dcfg, deviceInfos, true)
- if tc.isEncryptedRemote || tc.isEncryptedLocal {
- if err != nil {
- t.Errorf("Testcase %v: Expected no error, got %v", i, err)
- }
- } else {
- if err != errEncryptionNotEncryptedUntrusted {
- t.Errorf("Testcase %v: Expected error %v, got %v", i, errEncryptionNotEncryptedUntrusted, err)
- }
- }
- }
- if err != nil || (!tc.isEncryptedRemote && !tc.isEncryptedLocal) {
- continue
- }
- if tc.isEncryptedLocal {
- m.folderEncryptionPasswordTokens[fcfg.ID] = []byte("notAMatch")
- } else {
- dcfg.EncryptionPassword = "notAMatch"
- }
- err = m.ccCheckEncryption(tfcfg, dcfg, deviceInfos, false)
- if err != errEncryptionPassword {
- t.Errorf("Testcase %v: Expected error %v, got %v", i, errEncryptionPassword, err)
- }
- }
- }
- func TestCCFolderNotRunning(t *testing.T) {
- // Create the folder, but don't start it.
- w, fcfg, wCancel := newDefaultCfgWrapper()
- defer wCancel()
- tfs := fcfg.Filesystem(nil)
- m := newModel(t, w, myID, nil)
- defer cleanupModelAndRemoveDir(m, tfs.URI())
- // A connection can happen before all the folders are started.
- cc, _ := m.generateClusterConfig(device1)
- if l := len(cc.Folders); l != 1 {
- t.Fatalf("Expected 1 folder in CC, got %v", l)
- }
- folder := cc.Folders[0]
- if id := folder.ID; id != fcfg.ID {
- t.Fatalf("Expected folder %v, got %v", fcfg.ID, id)
- }
- if l := len(folder.Devices); l != 2 {
- t.Fatalf("Expected 2 devices in CC, got %v", l)
- }
- local := folder.Devices[1]
- if local.ID != myID {
- local = folder.Devices[0]
- }
- if !folder.Paused && local.IndexID == 0 {
- t.Errorf("Folder isn't paused, but index-id is zero")
- }
- }
- func TestPendingFolder(t *testing.T) {
- w, _, wCancel := newDefaultCfgWrapper()
- defer wCancel()
- m := setupModel(t, w)
- defer cleanupModel(m)
- setDevice(t, w, config.DeviceConfiguration{DeviceID: device2})
- pfolder := "default"
- of := db.ObservedFolder{
- Time: time.Now().Truncate(time.Second),
- Label: pfolder,
- }
- if err := m.db.AddOrUpdatePendingFolder(pfolder, of, device2); err != nil {
- t.Fatal(err)
- }
- deviceFolders, err := m.PendingFolders(protocol.EmptyDeviceID)
- if err != nil {
- t.Fatal(err)
- } else if pf, ok := deviceFolders[pfolder]; !ok {
- t.Errorf("folder %v not pending", pfolder)
- } else if _, ok := pf.OfferedBy[device2]; !ok {
- t.Errorf("folder %v not pending for device %v", pfolder, device2)
- } else if len(pf.OfferedBy) > 1 {
- t.Errorf("folder %v pending for too many devices %v", pfolder, pf.OfferedBy)
- }
- device3, err := protocol.DeviceIDFromString("AIBAEAQ-CAIBAEC-AQCAIBA-EAQCAIA-BAEAQCA-IBAEAQC-CAIBAEA-QCAIBA7")
- if err != nil {
- t.Fatal(err)
- }
- setDevice(t, w, config.DeviceConfiguration{DeviceID: device3})
- if err := m.db.AddOrUpdatePendingFolder(pfolder, of, device3); err != nil {
- t.Fatal(err)
- }
- deviceFolders, err = m.PendingFolders(device2)
- if err != nil {
- t.Fatal(err)
- } else if pf, ok := deviceFolders[pfolder]; !ok {
- t.Errorf("folder %v not pending when filtered", pfolder)
- } else if _, ok := pf.OfferedBy[device2]; !ok {
- t.Errorf("folder %v not pending for device %v when filtered", pfolder, device2)
- } else if _, ok := pf.OfferedBy[device3]; ok {
- t.Errorf("folder %v pending for device %v, but not filtered out", pfolder, device3)
- }
- waiter, err := w.RemoveDevice(device3)
- if err != nil {
- t.Fatal(err)
- }
- waiter.Wait()
- deviceFolders, err = m.PendingFolders(protocol.EmptyDeviceID)
- if err != nil {
- t.Fatal(err)
- } else if pf, ok := deviceFolders[pfolder]; !ok {
- t.Errorf("folder %v not pending", pfolder)
- } else if _, ok := pf.OfferedBy[device3]; ok {
- t.Errorf("folder %v pending for removed device %v", pfolder, device3)
- }
- waiter, err = w.RemoveFolder(pfolder)
- if err != nil {
- t.Fatal(err)
- }
- waiter.Wait()
- deviceFolders, err = m.PendingFolders(protocol.EmptyDeviceID)
- if err != nil {
- t.Fatal(err)
- } else if _, ok := deviceFolders[pfolder]; ok {
- t.Errorf("folder %v still pending after local removal", pfolder)
- }
- }
- func TestDeletedNotLocallyChangedReceiveOnly(t *testing.T) {
- deletedNotLocallyChanged(t, config.FolderTypeReceiveOnly)
- }
- func TestDeletedNotLocallyChangedReceiveEncrypted(t *testing.T) {
- deletedNotLocallyChanged(t, config.FolderTypeReceiveEncrypted)
- }
- func deletedNotLocallyChanged(t *testing.T, ft config.FolderType) {
- w, fcfg, wCancel := newDefaultCfgWrapper()
- tfs := fcfg.Filesystem(nil)
- fcfg.Type = ft
- setFolder(t, w, fcfg)
- defer wCancel()
- m := setupModel(t, w)
- defer cleanupModelAndRemoveDir(m, tfs.URI())
- name := "foo"
- writeFile(t, tfs, name, nil)
- must(t, m.ScanFolder(fcfg.ID))
- fi, ok, err := m.CurrentFolderFile(fcfg.ID, name)
- must(t, err)
- if !ok {
- t.Fatal("File hasn't been added")
- }
- if !fi.IsReceiveOnlyChanged() {
- t.Fatal("File isn't receive-only-changed")
- }
- must(t, tfs.Remove(name))
- must(t, m.ScanFolder(fcfg.ID))
- _, ok, err = m.CurrentFolderFile(fcfg.ID, name)
- must(t, err)
- if ok {
- t.Error("Expected file to be removed from db")
- }
- }
- func equalStringsInAnyOrder(a, b []string) bool {
- if len(a) != len(b) {
- return false
- }
- sort.Strings(a)
- sort.Strings(b)
- for i := range a {
- if a[i] != b[i] {
- return false
- }
- }
- return true
- }
- // modtimeTruncatingFS is a FileSystem that returns modification times only
- // to the closest two `trunc` interval.
- type modtimeTruncatingFS struct {
- trunc time.Duration
- fs.Filesystem
- }
- func (f modtimeTruncatingFS) Lstat(name string) (fs.FileInfo, error) {
- fmt.Println("lstat", name)
- info, err := f.Filesystem.Lstat(name)
- return modtimeTruncatingFileInfo{trunc: f.trunc, FileInfo: info}, err
- }
- func (f modtimeTruncatingFS) Stat(name string) (fs.FileInfo, error) {
- fmt.Println("stat", name)
- info, err := f.Filesystem.Stat(name)
- return modtimeTruncatingFileInfo{trunc: f.trunc, FileInfo: info}, err
- }
- func (f modtimeTruncatingFS) Walk(root string, walkFn fs.WalkFunc) error {
- return f.Filesystem.Walk(root, func(path string, info fs.FileInfo, err error) error {
- if err != nil {
- return walkFn(path, nil, err)
- }
- fmt.Println("walk", info.Name())
- return walkFn(path, modtimeTruncatingFileInfo{trunc: f.trunc, FileInfo: info}, nil)
- })
- }
- type modtimeTruncatingFileInfo struct {
- trunc time.Duration
- fs.FileInfo
- }
- func (fi modtimeTruncatingFileInfo) ModTime() time.Time {
- return fi.FileInfo.ModTime().Truncate(fi.trunc)
- }
|