001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements. See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership. The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License. You may obtain a copy of the License at
009 *
010 * http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018 package org.apache.hadoop.fs;
019
020 import java.io.DataInput;
021 import java.io.DataOutput;
022 import java.io.IOException;
023
024 import org.apache.hadoop.classification.InterfaceAudience;
025 import org.apache.hadoop.classification.InterfaceStability;
026 import org.apache.hadoop.fs.permission.FsPermission;
027 import org.apache.hadoop.io.Text;
028 import org.apache.hadoop.io.Writable;
029
030 /** Interface that represents the client side information for a file.
031 */
032 @InterfaceAudience.Public
033 @InterfaceStability.Stable
034 public class FileStatus implements Writable, Comparable {
035
036 private Path path;
037 private long length;
038 private boolean isdir;
039 private short block_replication;
040 private long blocksize;
041 private long modification_time;
042 private long access_time;
043 private FsPermission permission;
044 private String owner;
045 private String group;
046 private Path symlink;
047
048 public FileStatus() { this(0, false, 0, 0, 0, 0, null, null, null, null); }
049
050 //We should deprecate this soon?
051 public FileStatus(long length, boolean isdir, int block_replication,
052 long blocksize, long modification_time, Path path) {
053
054 this(length, isdir, block_replication, blocksize, modification_time,
055 0, null, null, null, path);
056 }
057
058 /**
059 * Constructor for file systems on which symbolic links are not supported
060 */
061 public FileStatus(long length, boolean isdir,
062 int block_replication,
063 long blocksize, long modification_time, long access_time,
064 FsPermission permission, String owner, String group,
065 Path path) {
066 this(length, isdir, block_replication, blocksize, modification_time,
067 access_time, permission, owner, group, null, path);
068 }
069
070 public FileStatus(long length, boolean isdir,
071 int block_replication,
072 long blocksize, long modification_time, long access_time,
073 FsPermission permission, String owner, String group,
074 Path symlink,
075 Path path) {
076 this.length = length;
077 this.isdir = isdir;
078 this.block_replication = (short)block_replication;
079 this.blocksize = blocksize;
080 this.modification_time = modification_time;
081 this.access_time = access_time;
082 if (permission != null) {
083 this.permission = permission;
084 } else if (isdir) {
085 this.permission = FsPermission.getDirDefault();
086 } else if (symlink!=null) {
087 this.permission = FsPermission.getDefault();
088 } else {
089 this.permission = FsPermission.getFileDefault();
090 }
091 this.owner = (owner == null) ? "" : owner;
092 this.group = (group == null) ? "" : group;
093 this.symlink = symlink;
094 this.path = path;
095 // The variables isdir and symlink indicate the type:
096 // 1. isdir implies directory, in which case symlink must be null.
097 // 2. !isdir implies a file or symlink, symlink != null implies a
098 // symlink, otherwise it's a file.
099 assert (isdir && symlink == null) || !isdir;
100 }
101
102 /**
103 * Get the length of this file, in bytes.
104 * @return the length of this file, in bytes.
105 */
106 public long getLen() {
107 return length;
108 }
109
110 /**
111 * Is this a file?
112 * @return true if this is a file
113 */
114 public boolean isFile() {
115 return !isdir && !isSymlink();
116 }
117
118 /**
119 * Is this a directory?
120 * @return true if this is a directory
121 */
122 public boolean isDirectory() {
123 return isdir;
124 }
125
126 /**
127 * Old interface, instead use the explicit {@link FileStatus#isFile()},
128 * {@link FileStatus#isDirectory()}, and {@link FileStatus#isSymlink()}
129 * @return true if this is a directory.
130 * @deprecated Use {@link FileStatus#isFile()},
131 * {@link FileStatus#isDirectory()}, and {@link FileStatus#isSymlink()}
132 * instead.
133 */
134 @Deprecated
135 public boolean isDir() {
136 return isdir;
137 }
138
139 /**
140 * Is this a symbolic link?
141 * @return true if this is a symbolic link
142 */
143 public boolean isSymlink() {
144 return symlink != null;
145 }
146
147 /**
148 * Get the block size of the file.
149 * @return the number of bytes
150 */
151 public long getBlockSize() {
152 return blocksize;
153 }
154
155 /**
156 * Get the replication factor of a file.
157 * @return the replication factor of a file.
158 */
159 public short getReplication() {
160 return block_replication;
161 }
162
163 /**
164 * Get the modification time of the file.
165 * @return the modification time of file in milliseconds since January 1, 1970 UTC.
166 */
167 public long getModificationTime() {
168 return modification_time;
169 }
170
171 /**
172 * Get the access time of the file.
173 * @return the access time of file in milliseconds since January 1, 1970 UTC.
174 */
175 public long getAccessTime() {
176 return access_time;
177 }
178
179 /**
180 * Get FsPermission associated with the file.
181 * @return permssion. If a filesystem does not have a notion of permissions
182 * or if permissions could not be determined, then default
183 * permissions equivalent of "rwxrwxrwx" is returned.
184 */
185 public FsPermission getPermission() {
186 return permission;
187 }
188
189 /**
190 * Get the owner of the file.
191 * @return owner of the file. The string could be empty if there is no
192 * notion of owner of a file in a filesystem or if it could not
193 * be determined (rare).
194 */
195 public String getOwner() {
196 return owner;
197 }
198
199 /**
200 * Get the group associated with the file.
201 * @return group for the file. The string could be empty if there is no
202 * notion of group of a file in a filesystem or if it could not
203 * be determined (rare).
204 */
205 public String getGroup() {
206 return group;
207 }
208
209 public Path getPath() {
210 return path;
211 }
212
213 public void setPath(final Path p) {
214 path = p;
215 }
216
217 /* These are provided so that these values could be loaded lazily
218 * by a filesystem (e.g. local file system).
219 */
220
221 /**
222 * Sets permission.
223 * @param permission if permission is null, default value is set
224 */
225 protected void setPermission(FsPermission permission) {
226 this.permission = (permission == null) ?
227 FsPermission.getFileDefault() : permission;
228 }
229
230 /**
231 * Sets owner.
232 * @param owner if it is null, default value is set
233 */
234 protected void setOwner(String owner) {
235 this.owner = (owner == null) ? "" : owner;
236 }
237
238 /**
239 * Sets group.
240 * @param group if it is null, default value is set
241 */
242 protected void setGroup(String group) {
243 this.group = (group == null) ? "" : group;
244 }
245
246 /**
247 * @return The contents of the symbolic link.
248 */
249 public Path getSymlink() throws IOException {
250 if (!isSymlink()) {
251 throw new IOException("Path " + path + " is not a symbolic link");
252 }
253 return symlink;
254 }
255
256 public void setSymlink(final Path p) {
257 symlink = p;
258 }
259
260 //////////////////////////////////////////////////
261 // Writable
262 //////////////////////////////////////////////////
263 public void write(DataOutput out) throws IOException {
264 Text.writeString(out, getPath().toString());
265 out.writeLong(getLen());
266 out.writeBoolean(isDirectory());
267 out.writeShort(getReplication());
268 out.writeLong(getBlockSize());
269 out.writeLong(getModificationTime());
270 out.writeLong(getAccessTime());
271 getPermission().write(out);
272 Text.writeString(out, getOwner());
273 Text.writeString(out, getGroup());
274 out.writeBoolean(isSymlink());
275 if (isSymlink()) {
276 Text.writeString(out, getSymlink().toString());
277 }
278 }
279
280 public void readFields(DataInput in) throws IOException {
281 String strPath = Text.readString(in);
282 this.path = new Path(strPath);
283 this.length = in.readLong();
284 this.isdir = in.readBoolean();
285 this.block_replication = in.readShort();
286 blocksize = in.readLong();
287 modification_time = in.readLong();
288 access_time = in.readLong();
289 permission.readFields(in);
290 owner = Text.readString(in);
291 group = Text.readString(in);
292 if (in.readBoolean()) {
293 this.symlink = new Path(Text.readString(in));
294 } else {
295 this.symlink = null;
296 }
297 }
298
299 /**
300 * Compare this object to another object
301 *
302 * @param o the object to be compared.
303 * @return a negative integer, zero, or a positive integer as this object
304 * is less than, equal to, or greater than the specified object.
305 *
306 * @throws ClassCastException if the specified object's is not of
307 * type FileStatus
308 */
309 public int compareTo(Object o) {
310 FileStatus other = (FileStatus)o;
311 return this.getPath().compareTo(other.getPath());
312 }
313
314 /** Compare if this object is equal to another object
315 * @param o the object to be compared.
316 * @return true if two file status has the same path name; false if not.
317 */
318 public boolean equals(Object o) {
319 if (o == null) {
320 return false;
321 }
322 if (this == o) {
323 return true;
324 }
325 if (!(o instanceof FileStatus)) {
326 return false;
327 }
328 FileStatus other = (FileStatus)o;
329 return this.getPath().equals(other.getPath());
330 }
331
332 /**
333 * Returns a hash code value for the object, which is defined as
334 * the hash code of the path name.
335 *
336 * @return a hash code value for the path name.
337 */
338 public int hashCode() {
339 return getPath().hashCode();
340 }
341
342 @Override
343 public String toString() {
344 StringBuilder sb = new StringBuilder();
345 sb.append(getClass().getSimpleName());
346 sb.append("{");
347 sb.append("path=" + path);
348 sb.append("; isDirectory=" + isdir);
349 if(!isDirectory()){
350 sb.append("; length=" + length);
351 sb.append("; replication=" + block_replication);
352 sb.append("; blocksize=" + blocksize);
353 }
354 sb.append("; modification_time=" + modification_time);
355 sb.append("; access_time=" + access_time);
356 sb.append("; owner=" + owner);
357 sb.append("; group=" + group);
358 sb.append("; permission=" + permission);
359 sb.append("; isSymlink=" + isSymlink());
360 if(isSymlink()) {
361 sb.append("; symlink=" + symlink);
362 }
363 sb.append("}");
364 return sb.toString();
365 }
366 }