418 lines
10 KiB
Java
418 lines
10 KiB
Java
/*
|
|
* Title: CloudSim Toolkit
|
|
* Description: CloudSim (Cloud Simulation) Toolkit for Modeling and Simulation of Clouds
|
|
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
|
|
*
|
|
* Copyright (c) 2009-2012, The University of Melbourne, Australia
|
|
*/
|
|
|
|
package org.cloudbus.cloudsim;
|
|
|
|
/**
|
|
* A class for representing a physical file in a DataCloud environment
|
|
*
|
|
* @author Uros Cibej
|
|
* @author Anthony Sulistio
|
|
* @since CloudSim Toolkit 1.0
|
|
*/
|
|
public class File {
|
|
|
|
private String name; // logical file name
|
|
|
|
private FileAttribute attribute; // a file attribute
|
|
|
|
// a transaction time for adding / getting /deleting this file
|
|
private double transactionTime;
|
|
|
|
/** Denotes that this file has not been registered to a Replica Catalogue */
|
|
public static final int NOT_REGISTERED = -1;
|
|
|
|
/** Denotes that the type of this file is unknown */
|
|
public static final int TYPE_UNKOWN = 0;
|
|
|
|
/** Denotes that the type of this file is a raw data */
|
|
public static final int TYPE_RAW_DATA = 1;
|
|
|
|
/** Denotes that the type of this file is a reconstructed data */
|
|
public static final int TYPE_RECONSTRUCTED_DATA = 2;
|
|
|
|
/** Denotes that the type of this file is a tag data */
|
|
public static final int TYPE_TAG_DATA = 3;
|
|
|
|
/**
|
|
* Creates a new DataCloud file with a given size (in MBytes). <br>
|
|
* NOTE: By default, a newly-created file is set to a <b>master</b> copy.
|
|
*
|
|
* @param fileName file name
|
|
* @param fileSize file size is in MBytes
|
|
* @throws ParameterException This happens when one of the following scenarios occur:
|
|
* <ul>
|
|
* <li>the file name is empty or <tt>null</tt>
|
|
* <li>the file size is zero or negative numbers
|
|
* </ul>
|
|
*/
|
|
public File(String fileName, int fileSize) throws ParameterException {
|
|
if (fileName == null || fileName.length() == 0) {
|
|
throw new ParameterException("File(): Error - invalid file name.");
|
|
}
|
|
|
|
if (fileSize <= 0) {
|
|
throw new ParameterException("File(): Error - size <= 0.");
|
|
}
|
|
|
|
name = fileName;
|
|
attribute = new FileAttribute(fileName, fileSize);
|
|
transactionTime = 0;
|
|
}
|
|
|
|
/**
|
|
* Copy constructor, i.e. cloning from a source file into this object, but this object is set to
|
|
* a <b>replica</b>
|
|
*
|
|
* @param file the source of a File object to copy
|
|
* @throws ParameterException This happens when the source file is <tt>null</tt>
|
|
*/
|
|
public File(File file) throws ParameterException {
|
|
if (file == null) {
|
|
throw new ParameterException("File(): Error - file is null.");
|
|
}
|
|
|
|
// copy the attributes into the file
|
|
FileAttribute fileAttr = file.getFileAttribute();
|
|
attribute.copyValue(fileAttr);
|
|
fileAttr.setMasterCopy(false); // set this file to replica
|
|
}
|
|
|
|
/**
|
|
* Clone this file but the clone file is set to a <b>replica</b>
|
|
*
|
|
* @return a clone of this file (as a replica) or <tt>null</tt> if an error occurs
|
|
*/
|
|
public File makeReplica() {
|
|
return makeCopy();
|
|
}
|
|
|
|
/**
|
|
* Clone this file and make the new file as a <b>master</b> copy as well
|
|
*
|
|
* @return a clone of this file (as a master copy) or <tt>null</tt> if an error occurs
|
|
*/
|
|
public File makeMasterCopy() {
|
|
File file = makeCopy();
|
|
if (file != null) {
|
|
file.setMasterCopy(true);
|
|
}
|
|
|
|
return file;
|
|
}
|
|
|
|
/**
|
|
* Makes a copy of this file
|
|
*
|
|
* @return a clone of this file (as a replica) or <tt>null</tt> if an error occurs
|
|
*/
|
|
private File makeCopy() {
|
|
File file = null;
|
|
try {
|
|
file = new File(name, attribute.getFileSize());
|
|
FileAttribute fileAttr = file.getFileAttribute();
|
|
attribute.copyValue(fileAttr);
|
|
fileAttr.setMasterCopy(false); // set this file to replica
|
|
} catch (Exception e) {
|
|
file = null;
|
|
}
|
|
|
|
return file;
|
|
}
|
|
|
|
/**
|
|
* Gets an attribute of this file
|
|
*
|
|
* @return a file attribute
|
|
*/
|
|
public FileAttribute getFileAttribute() {
|
|
return attribute;
|
|
}
|
|
|
|
/**
|
|
* Gets the size of this object (in byte).<br>
|
|
* NOTE: This object size is NOT the actual file size. Moreover, this size is used for
|
|
* transferring this object over a network.
|
|
*
|
|
* @return the object size (in byte)
|
|
*/
|
|
public int getAttributeSize() {
|
|
return attribute.getAttributeSize();
|
|
}
|
|
|
|
/**
|
|
* Sets the resource ID that stores this file
|
|
*
|
|
* @param resourceID a resource ID
|
|
* @return <tt>true</tt> if successful, <tt>false</tt> otherwise
|
|
*/
|
|
public boolean setResourceID(int resourceID) {
|
|
return attribute.setResourceID(resourceID);
|
|
}
|
|
|
|
/**
|
|
* Gets the resource ID that stores this file
|
|
*
|
|
* @return the resource ID
|
|
*/
|
|
public int getResourceID() {
|
|
return attribute.getResourceID();
|
|
}
|
|
|
|
/**
|
|
* Returns the file name
|
|
*
|
|
* @return the file name
|
|
*/
|
|
public String getName() {
|
|
return attribute.getName();
|
|
}
|
|
|
|
/**
|
|
* Sets the file name
|
|
*
|
|
* @param name the file name
|
|
*/
|
|
public void setName(String name) {
|
|
attribute.setName(name);
|
|
}
|
|
|
|
/**
|
|
* Sets the owner name of this file
|
|
*
|
|
* @param name the owner name
|
|
* @return <tt>true</tt> if successful, <tt>false</tt> otherwise
|
|
*/
|
|
public boolean setOwnerName(String name) {
|
|
return attribute.setOwnerName(name);
|
|
}
|
|
|
|
/**
|
|
* Gets the owner name of this file
|
|
*
|
|
* @return the owner name or <tt>null</tt> if empty
|
|
*/
|
|
public String getOwnerName() {
|
|
return attribute.getOwnerName();
|
|
}
|
|
|
|
/**
|
|
* Gets the file size (in MBytes)
|
|
*
|
|
* @return the file size (in MBytes)
|
|
*/
|
|
public int getSize() {
|
|
return attribute.getFileSize();
|
|
}
|
|
|
|
/**
|
|
* Gets the file size (in bytes)
|
|
*
|
|
* @return the file size (in bytes)
|
|
*/
|
|
public int getSizeInByte() {
|
|
return attribute.getFileSizeInByte();
|
|
}
|
|
|
|
/**
|
|
* Sets the file size (in MBytes)
|
|
*
|
|
* @param fileSize the file size (in MBytes)
|
|
* @return <tt>true</tt> if successful, <tt>false</tt> otherwise
|
|
*/
|
|
public boolean setFileSize(int fileSize) {
|
|
return attribute.setFileSize(fileSize);
|
|
}
|
|
|
|
/**
|
|
* Sets the last update time of this file (in seconds)<br>
|
|
* NOTE: This time is relative to the start time. Preferably use
|
|
* {@link gridsim.CloudSim#clock()} method.
|
|
*
|
|
* @param time the last update time (in seconds)
|
|
* @return <tt>true</tt> if successful, <tt>false</tt> otherwise
|
|
*/
|
|
public boolean setUpdateTime(double time) {
|
|
return attribute.setUpdateTime(time);
|
|
}
|
|
|
|
/**
|
|
* Gets the last update time (in seconds)
|
|
*
|
|
* @return the last update time (in seconds)
|
|
*/
|
|
public double getLastUpdateTime() {
|
|
return attribute.getLastUpdateTime();
|
|
}
|
|
|
|
/**
|
|
* Sets the file registration ID (published by a Replica Catalogue entity)
|
|
*
|
|
* @param id registration ID
|
|
* @return <tt>true</tt> if successful, <tt>false</tt> otherwise
|
|
*/
|
|
public boolean setRegistrationID(int id) {
|
|
return attribute.setRegistrationId(id);
|
|
}
|
|
|
|
/**
|
|
* Gets the file registration ID
|
|
*
|
|
* @return registration ID
|
|
*/
|
|
public int getRegistrationID() {
|
|
return attribute.getRegistrationID();
|
|
}
|
|
|
|
/**
|
|
* Sets the file type (e.g. raw, tag, etc)
|
|
*
|
|
* @param type a file type
|
|
* @return <tt>true</tt> if successful, <tt>false</tt> otherwise
|
|
*/
|
|
public boolean setType(int type) {
|
|
return attribute.setType(type);
|
|
}
|
|
|
|
/**
|
|
* Gets this file type
|
|
*
|
|
* @return file type
|
|
*/
|
|
public int getType() {
|
|
return attribute.getType();
|
|
}
|
|
|
|
/**
|
|
* Sets the checksum of this file
|
|
*
|
|
* @param checksum the checksum of this file
|
|
* @return <tt>true</tt> if successful, <tt>false</tt> otherwise
|
|
*/
|
|
public boolean setChecksum(int checksum) {
|
|
return attribute.setChecksum(checksum);
|
|
}
|
|
|
|
/**
|
|
* Gets the file checksum
|
|
*
|
|
* @return file checksum
|
|
*/
|
|
public int getChecksum() {
|
|
return attribute.getChecksum();
|
|
}
|
|
|
|
/**
|
|
* Sets the cost associated with this file
|
|
*
|
|
* @param cost cost of this file
|
|
* @return <tt>true</tt> if successful, <tt>false</tt> otherwise
|
|
*/
|
|
public boolean setCost(double cost) {
|
|
return attribute.setCost(cost);
|
|
}
|
|
|
|
/**
|
|
* Gets the cost associated with this file
|
|
*
|
|
* @return the cost of this file
|
|
*/
|
|
public double getCost() {
|
|
return attribute.getCost();
|
|
}
|
|
|
|
/**
|
|
* Gets the file creation time (in millisecond)
|
|
*
|
|
* @return the file creation time (in millisecond)
|
|
*/
|
|
public long getCreationTime() {
|
|
return attribute.getCreationTime();
|
|
}
|
|
|
|
/**
|
|
* Checks if this file already registered to a Replica Catalogue
|
|
*
|
|
* @return <tt>true</tt> if it is registered, <tt>false</tt> otherwise
|
|
*/
|
|
public boolean isRegistered() {
|
|
return attribute.isRegistered();
|
|
}
|
|
|
|
/**
|
|
* Marks this file as a master copy or replica
|
|
*
|
|
* @param masterCopy a flag denotes <tt>true</tt> for master copy or <tt>false</tt> for a
|
|
* replica
|
|
*/
|
|
public void setMasterCopy(boolean masterCopy) {
|
|
attribute.setMasterCopy(masterCopy);
|
|
}
|
|
|
|
/**
|
|
* Checks whether this file is a master copy or replica
|
|
*
|
|
* @return <tt>true</tt> if it is a master copy or <tt>false</tt> otherwise
|
|
*/
|
|
public boolean isMasterCopy() {
|
|
return attribute.isMasterCopy();
|
|
}
|
|
|
|
/**
|
|
* Marks this file as a read only or not
|
|
*
|
|
* @param readOnly a flag denotes <tt>true</tt> for read only or <tt>false</tt> for re-writeable
|
|
*/
|
|
public void setReadOnly(boolean readOnly) {
|
|
attribute.setReadOnly(readOnly);
|
|
}
|
|
|
|
/**
|
|
* Checks whether this file is a read only or not
|
|
*
|
|
* @return <tt>true</tt> if it is a read only or <tt>false</tt> otherwise
|
|
*/
|
|
public boolean isReadOnly() {
|
|
return attribute.isReadOnly();
|
|
}
|
|
|
|
/**
|
|
* Sets the current transaction time (in second) of this file. This transaction time can be
|
|
* related to the operation of adding / deleting / getting this file on a resource's storage.
|
|
*
|
|
* @param time the transaction time (in second)
|
|
* @return <tt>true</tt> if successful, <tt>false</tt> otherwise
|
|
* @see gridsim.datagrid.storage.Storage#addFile(File)
|
|
* @see gridsim.datagrid.storage.Storage#addFile(List)
|
|
* @see gridsim.datagrid.storage.Storage#addReservedFile(File)
|
|
* @see gridsim.datagrid.storage.Storage#deleteFile(File)
|
|
* @see gridsim.datagrid.storage.Storage#deleteFile(String)
|
|
* @see gridsim.datagrid.storage.Storage#deleteFile(String, File)
|
|
* @see gridsim.datagrid.storage.Storage#getFile(String)
|
|
* @see gridsim.datagrid.storage.Storage#renameFile(File, String)
|
|
*/
|
|
public boolean setTransactionTime(double time) {
|
|
if (time < 0) {
|
|
return false;
|
|
}
|
|
|
|
transactionTime = time;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Gets the last transaction time of this file (in second).
|
|
*
|
|
* @return the transaction time (in second)
|
|
*/
|
|
public double getTransactionTime() {
|
|
return transactionTime;
|
|
}
|
|
|
|
}
|