code cleanup
Jeromy committed
Mar 15, 2015 at 00:14 UTC
0ee7091cbcb86f08a93d23418e7f9737fca767f7
3 files changed
+81
-124
ipnsfs/dir.go
+58
-102
@@ -60,7 +60,7 @@ func (d *Directory) Open(tpath []string, mode int) (*File, error) {
60
return nfi, nil
61
}
62
63
- return nil, ErrNoSuch
63
+ return nil, os.ErrNotExist
64
}
65
66
dir, err := d.childDir(tpath[0])
@@ -99,86 +99,92 @@ func (d *Directory) Type() NodeType {
99
return TDir
100
}
101
102
+// childFile returns a file under this directory by the given name if it exists
103
func (d *Directory) childFile(name string) (*File, error) {
104
fi, ok := d.files[name]
105
if ok {
106
return fi, nil
107
}
108
108
- // search dag
109
- for _, lnk := range d.node.Links {
110
- if lnk.Name == name {
111
- nd, err := lnk.GetNode(d.fs.dserv)
112
- if err != nil {
113
- return nil, err
114
- }
115
- i, err := ft.FromBytes(nd.Data)
116
- if err != nil {
117
- return nil, err
118
- }
109
+ nd, err := d.childFromDag(name)
110
+ if err != nil {
111
+ return nil, err
112
+ }
113
+ i, err := ft.FromBytes(nd.Data)
114
+ if err != nil {
115
+ return nil, err
116
+ }
117
120
- switch i.GetType() {
121
- case ufspb.Data_Directory:
122
- return nil, ErrIsDirectory
123
- case ufspb.Data_File:
124
- nfi, err := NewFile(name, nd, d, d.fs)
125
- if err != nil {
126
- return nil, err
127
- }
128
- d.files[name] = nfi
129
- return nfi, nil
130
- case ufspb.Data_Metadata:
131
- return nil, ErrNotYetImplemented
132
- default:
133
- return nil, ErrInvalidChild
134
- }
118
+ switch i.GetType() {
119
+ case ufspb.Data_Directory:
120
+ return nil, ErrIsDirectory
121
+ case ufspb.Data_File:
122
+ nfi, err := NewFile(name, nd, d, d.fs)
123
+ if err != nil {
124
+ return nil, err
125
}
126
+ d.files[name] = nfi
127
+ return nfi, nil
128
+ case ufspb.Data_Metadata:
129
+ return nil, ErrNotYetImplemented
130
+ default:
131
+ return nil, ErrInvalidChild
132
}
137
- return nil, ErrNoSuch
133
}
134
135
+// childDir returns a directory under this directory by the given name if it
136
+// exists.
137
func (d *Directory) childDir(name string) (*Directory, error) {
138
dir, ok := d.childDirs[name]
139
if ok {
140
return dir, nil
141
}
142
143
+ nd, err := d.childFromDag(name)
144
+ if err != nil {
145
+ return nil, err
146
+ }
147
+
148
+ i, err := ft.FromBytes(nd.Data)
149
+ if err != nil {
150
+ return nil, err
151
+ }
152
+
153
+ switch i.GetType() {
154
+ case ufspb.Data_Directory:
155
+ ndir := NewDirectory(name, nd, d, d.fs)
156
+ d.childDirs[name] = ndir
157
+ return ndir, nil
158
+ case ufspb.Data_File:
159
+ return nil, fmt.Errorf("%s is not a directory", name)
160
+ case ufspb.Data_Metadata:
161
+ return nil, ErrNotYetImplemented
162
+ default:
163
+ return nil, ErrInvalidChild
164
+ }
165
+}
166
+
167
+// childFromDag searches through this directories dag node for a child link
168
+// with the given name
169
+func (d *Directory) childFromDag(name string) (*dag.Node, error) {
170
for _, lnk := range d.node.Links {
171
if lnk.Name == name {
148
- nd, err := lnk.GetNode(d.fs.dserv)
149
- if err != nil {
150
- return nil, err
151
- }
152
- i, err := ft.FromBytes(nd.Data)
153
- if err != nil {
154
- return nil, err
155
- }
156
-
157
- switch i.GetType() {
158
- case ufspb.Data_Directory:
159
- ndir := NewDirectory(name, nd, d, d.fs)
160
- d.childDirs[name] = ndir
161
- return ndir, nil
162
- case ufspb.Data_File:
163
- return nil, fmt.Errorf("%s is not a directory", name)
164
- case ufspb.Data_Metadata:
165
- return nil, ErrNotYetImplemented
166
- default:
167
- return nil, ErrInvalidChild
168
- }
172
+ return lnk.GetNode(d.fs.dserv)
173
}
170
-
174
}
175
173
- return nil, ErrNoSuch
176
+ return nil, os.ErrNotExist
177
}
178
179
+// Child returns the child of this directory by the given name
180
func (d *Directory) Child(name string) (FSNode, error) {
181
d.lock.Lock()
182
defer d.lock.Unlock()
183
return d.childUnsync(name)
184
}
185
186
+// childUnsync returns the child under this directory by the given name
187
+// without locking, useful for operations which already hold a lock
188
func (d *Directory) childUnsync(name string) (FSNode, error) {
189
dir, err := d.childDir(name)
190
if err == nil {
@@ -189,7 +195,7 @@ func (d *Directory) childUnsync(name string) (FSNode, error) {
195
return fi, nil
196
}
197
192
- return nil, ErrNoSuch
198
+ return nil, os.ErrNotExist
199
}
200
201
func (d *Directory) List() []string {
@@ -245,56 +251,6 @@ func (d *Directory) Unlink(name string) error {
251
return d.parent.closeChild(d.name, d.node)
252
}
253
248
-// RenameEntry renames the child by 'oldname' of this directory to 'newname'
249
-func (d *Directory) RenameEntry(oldname, newname string) error {
250
- d.Lock()
251
- defer d.Unlock()
252
- // Is the child a directory?
253
- dir, err := d.childDir(oldname)
254
- if err == nil {
255
- dir.name = newname
256
-
257
- err := d.node.RemoveNodeLink(oldname)
258
- if err != nil {
259
- return err
260
- }
261
- err = d.node.AddNodeLinkClean(newname, dir.node)
262
- if err != nil {
263
- return err
264
- }
265
-
266
- delete(d.childDirs, oldname)
267
- d.childDirs[newname] = dir
268
- return d.parent.closeChild(d.name, d.node)
269
- }
270
-
271
- // Is the child a file?
272
- fi, err := d.childFile(oldname)
273
- if err == nil {
274
- fi.name = newname
275
-
276
- err := d.node.RemoveNodeLink(oldname)
277
- if err != nil {
278
- return err
279
- }
280
-
281
- nd, err := fi.GetNode()
282
- if err != nil {
283
- return err
284
- }
285
-
286
- err = d.node.AddNodeLinkClean(newname, nd)
287
- if err != nil {
288
- return err
289
- }
290
-
291
- delete(d.childDirs, oldname)
292
- d.files[newname] = fi
293
- return d.parent.closeChild(d.name, d.node)
294
- }
295
- return ErrNoSuch
296
-}
297
-
254
// AddChild adds the node 'nd' under this directory giving it the name 'name'
255
func (d *Directory) AddChild(name string, nd *dag.Node) error {
256
d.Lock()
ipnsfs/file.go
+20
-18
@@ -36,19 +36,21 @@ func NewFile(name string, node *dag.Node, parent childCloser, fs *Filesystem) (*
36
}
37
38
func (fi *File) Write(b []byte) (int, error) {
39
+ fi.Lock()
40
+ defer fi.Unlock()
41
fi.hasChanges = true
42
return fi.mod.Write(b)
43
}
44
45
func (fi *File) Read(b []byte) (int, error) {
44
- fi.lock.Lock()
45
- defer fi.lock.Unlock()
46
+ fi.Lock()
47
+ defer fi.Unlock()
48
return fi.mod.Read(b)
49
}
50
51
func (fi *File) Close() error {
50
- fi.lock.Lock()
51
- defer fi.lock.Unlock()
52
+ fi.Lock()
53
+ defer fi.Unlock()
54
if fi.hasChanges {
55
err := fi.mod.Flush()
56
if err != nil {
@@ -60,9 +62,9 @@ func (fi *File) Close() error {
62
return err
63
}
64
63
- fi.lock.Unlock()
65
+ fi.Unlock()
66
err = fi.parent.closeChild(fi.name, nd)
65
- fi.lock.Lock()
67
+ fi.Lock()
68
if err != nil {
69
return err
70
}
@@ -74,39 +76,39 @@ func (fi *File) Close() error {
76
}
77
78
func (fi *File) Flush() error {
77
- fi.lock.Lock()
78
- defer fi.lock.Unlock()
79
+ fi.Lock()
80
+ defer fi.Unlock()
81
return fi.mod.Flush()
82
}
83
84
func (fi *File) Seek(offset int64, whence int) (int64, error) {
83
- fi.lock.Lock()
84
- defer fi.lock.Unlock()
85
+ fi.Lock()
86
+ defer fi.Unlock()
87
return fi.mod.Seek(offset, whence)
88
}
89
90
func (fi *File) WriteAt(b []byte, at int64) (int, error) {
89
- fi.lock.Lock()
90
- defer fi.lock.Unlock()
91
+ fi.Lock()
92
+ defer fi.Unlock()
93
fi.hasChanges = true
94
return fi.mod.WriteAt(b, at)
95
}
96
97
func (fi *File) Size() (int64, error) {
96
- fi.lock.Lock()
97
- defer fi.lock.Unlock()
98
+ fi.Lock()
99
+ defer fi.Unlock()
100
return fi.mod.Size()
101
}
102
103
func (fi *File) GetNode() (*dag.Node, error) {
102
- fi.lock.Lock()
103
- defer fi.lock.Unlock()
104
+ fi.Lock()
105
+ defer fi.Unlock()
106
return fi.mod.GetNode()
107
}
108
109
func (fi *File) Truncate(size int64) error {
108
- fi.lock.Lock()
109
- defer fi.lock.Unlock()
110
+ fi.Lock()
111
+ defer fi.Unlock()
112
fi.hasChanges = true
113
return fi.mod.Truncate(size)
114
}
ipnsfs/system.go
+3
-4
@@ -3,6 +3,7 @@ package ipnsfs
3
import (
4
"errors"
5
"fmt"
6
+ "os"
7
"strings"
8
"time"
9
@@ -21,8 +22,6 @@ var log = eventlog.Logger("ipnsfs")
22
23
var ErrIsDirectory = errors.New("error: is a directory")
24
24
-var ErrNoSuch = errors.New("no such file or directory")
25
-
25
// Filesystem is the writeable fuse filesystem structure
26
type Filesystem struct {
27
dserv dag.DAGService
@@ -62,7 +61,7 @@ func (fs *Filesystem) Open(tpath string, mode int) (*File, error) {
61
pathelem := strings.Split(tpath, "/")
62
r, ok := fs.roots[pathelem[0]]
63
if !ok {
65
- return nil, ErrNoSuch
64
+ return nil, os.ErrNotExist
65
}
66
67
return r.Open(pathelem[1:], mode)
@@ -83,7 +82,7 @@ func (fs *Filesystem) GetRoot(name string) (*KeyRoot, error) {
82
if ok {
83
return r, nil
84
}
86
- return nil, ErrNoSuch
85
+ return nil, os.ErrNotExist
86
}
87
88
type NodeType int