XBT_PUBLIC(void) simcall_file_set_data(smx_file_t fd, void *data);
XBT_PUBLIC(sg_size_t) simcall_file_read(smx_file_t fd, sg_size_t size, smx_host_t host);
XBT_PUBLIC(sg_size_t) simcall_file_write(smx_file_t fd, sg_size_t size, smx_host_t host);
-XBT_PUBLIC(smx_file_t) simcall_file_open(const char* fullpath);
-XBT_PUBLIC(int) simcall_file_close(smx_file_t fd);
+XBT_PUBLIC(smx_file_t) simcall_file_open(const char* fullpath, smx_host_t host);
+XBT_PUBLIC(int) simcall_file_close(smx_file_t fd, smx_host_t host);
XBT_PUBLIC(int) simcall_file_unlink(smx_file_t fd);
XBT_PUBLIC(sg_size_t) simcall_file_get_size(smx_file_t fd);
XBT_PUBLIC(xbt_dynar_t) simcall_file_get_info(smx_file_t fd);
XBT_PUBLIC(sg_size_t) simcall_file_tell(smx_file_t fd);
XBT_PUBLIC(int) simcall_file_seek(smx_file_t fd, sg_size_t offset, int origin);
XBT_PUBLIC(int) simcall_file_move(smx_file_t fd, const char* fullpath);
-XBT_PUBLIC(int) simcall_file_rcopy(smx_file_t fd, smx_host_t host, const char* fullpath);
/***************************** Storage **********************************/
XBT_PUBLIC(sg_size_t) simcall_storage_get_free_size (const char* name);
XBT_PUBLIC(sg_size_t) simcall_storage_get_used_size (const char* name);
*/
XBT_PUBLIC(int) surf_workstation_file_seek(surf_resource_t workstation, surf_file_t fd, sg_size_t offset, int origin);
-/**
- * @brief Copy a file to another location on a remote host.
- * @details [long description]
- *
- * @param workstation The surf workstation
- * @param fd The file descriptor
- * @param host_dest The workstation destination
- * @param fullpath The new full path
- *
- * @return MSG_OK if successful, otherwise MSG_TASK_CANCELED
- */
-XBT_PUBLIC(int) surf_workstation_file_rcopy(surf_resource_t workstation, surf_file_t fd, surf_resource_t host_dest, const char* fullpath);
-
/**
* @brief [brief description]
* @details [long description]
priv->data = data;
priv->fullpath = xbt_strdup(fullpath);
priv->simdata = xbt_new0(s_simdata_file_t,1);
- priv->simdata->smx_file = simcall_file_open(fullpath);
+ priv->simdata->smx_file = simcall_file_open(fullpath, MSG_host_self());
xbt_lib_set(file_lib, fullpath, MSG_FILE_LEVEL, priv);
msg_file_t fd = (msg_file_t) xbt_lib_get_elm_or_null(file_lib, fullpath);
__MSG_file_get_info(fd);
int MSG_file_close(msg_file_t fd)
{
msg_file_priv_t priv = MSG_file_priv(fd);
- int res = simcall_file_close(priv->simdata->smx_file);
+ int res = simcall_file_close(priv->simdata->smx_file, MSG_host_self());
xbt_lib_unset(file_lib, priv->fullpath, MSG_FILE_LEVEL, 1);
return res;
}
msg_error_t MSG_file_rcopy (msg_file_t file, msg_host_t host, const char* fullpath)
{
msg_file_priv_t file_priv = MSG_file_priv(file);
+ sg_size_t read_size;
- /* Find the host source where the file is physically located */
+ /* Find the host where the file is physically located and read it */
msg_storage_t storage_src =(msg_storage_t) xbt_lib_get_elm_or_null(storage_lib, file_priv->storageId);
-
msg_storage_priv_t storage_priv_src = MSG_storage_priv(storage_src);
- const char *host_name_src, *host_name_dest;
- host_name_src = storage_priv_src->hostname;
+ msg_host_t attached_host = MSG_get_host_by_name(storage_priv_src->hostname);
+ read_size = simcall_file_read(file_priv->simdata->smx_file, file_priv->size, attached_host);
/* Find the real host destination where the file will be physically stored */
xbt_dict_cursor_t cursor = NULL;
- char *mount_name, *storage_name, *file_mount_name;
+ char *mount_name, *storage_name, *file_mount_name, *host_name_dest;
msg_storage_t storage_dest;
+ msg_host_t host_dest;
size_t longest_prefix_length = 0;
xbt_dict_t storage_list = simcall_host_get_mounted_storage_list(host);
if(longest_prefix_length>0){
/* Mount point found, retrieve the host the storage is attached to */
msg_storage_priv_t storage_dest_priv = MSG_storage_priv(storage_dest);
- host_name_dest = storage_dest_priv->hostname;
+ host_name_dest = (char*)storage_dest_priv->hostname;
+ host_dest = MSG_get_host_by_name(host_name_dest);
}else{
XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath, SIMIX_host_get_name(host));
return MSG_TASK_CANCELED;
}
- XBT_INFO("HOST SRC %s HOST DEST %s", host_name_src, host_name_dest);
- /* Try to send file calling SIMIX network layer */
+ XBT_DEBUG("Initiate data transfer of %llu bytes between %s and %s.", read_size, storage_priv_src->hostname, host_name_dest);
+ msg_host_t *m_host_list = NULL;
+ m_host_list = calloc(2, sizeof(msg_host_t));
+
+ m_host_list[0] = attached_host;
+ m_host_list[1] = host_dest;
+ double computation_amount[] = { 0, 0 };
+ double communication_amount[] = { 0, (double)read_size, 0, 0 };
+
+ msg_task_t task = MSG_parallel_task_create("file transfer for write", 2, m_host_list, computation_amount, communication_amount, NULL);
+ msg_error_t transfer = MSG_parallel_task_execute(task);
+ MSG_task_destroy(task);
+ free(m_host_list);
+ if(transfer != MSG_OK){
+ if (transfer == MSG_HOST_FAILURE)
+ XBT_WARN("Transfer error, %s remote host just turned off!", host_name_dest);
+ if (transfer == MSG_TASK_CANCELED)
+ XBT_WARN("Transfer error, task has been canceled!");
+
+ return -1;
+ }
- size_t file_size = simcall_file_read(file_priv->simdata->smx_file, file_priv->size, MSG_get_host_by_name(host_name_src));
- xbt_ex_t e;
- msg_error_t ret = MSG_OK;
+ /* Create file on remote host, write it and close it */
+ smx_file_t smx_file = simcall_file_open(fullpath, host_dest);
+ simcall_file_write(smx_file, read_size, host_dest);
+ simcall_file_close(smx_file, host_dest);
+ return MSG_OK;
- TRY {
- msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(host_name_dest);
- simcall_comm_isend(mailbox, (double) file_size, -1.0, file, sizeof(void *), NULL, NULL, (void*)file, 0);
- simcall_comm_irecv(mailbox, file, NULL, NULL, NULL, -1.0);
- }
- CATCH(e) {
- switch (e.category) {
- case cancel_error:
- ret = MSG_HOST_FAILURE;
- break;
- case network_error:
- ret = MSG_TRANSFER_FAILURE;
- break;
- case timeout_error:
- ret = MSG_TIMEOUT;
- break;
- default:
- RETHROW;
- }
- xbt_ex_free(e);
- }
- return ret;
}
/**
*/
msg_error_t MSG_file_rmove (msg_file_t file, msg_host_t host, const char* fullpath)
{
- msg_file_priv_t file_priv = MSG_file_priv(file);
- msg_error_t res = simcall_file_rcopy(file_priv->simdata->smx_file, host, fullpath);
- simcall_file_unlink(file_priv->simdata->smx_file);
+ msg_error_t res = MSG_file_rcopy(file, host, fullpath);
+ MSG_file_unlink(file);
return res;
}
sem_get_capacity True (int) (sem, void*, smx_sem_t)
file_read False (sg_size_t) (fd, void*, smx_file_t) (size, sg_size_t) (host, void*, smx_host_t)
file_write False (sg_size_t) (fd, void*, smx_file_t) (size, sg_size_t) (host, void*, smx_host_t)
-file_open False (void*, smx_file_t) (fullpath, const char*)
-file_close False (int) (fd, void*, smx_file_t)
+file_open False (void*, smx_file_t) (fullpath, const char*) (host, void*, smx_host_t)
+file_close False (int) (fd, void*, smx_file_t) (host, void*, smx_host_t)
file_unlink True (int) (fd, void*, smx_file_t)
file_get_size True (sg_size_t) (fd, void*, smx_file_t)
file_tell True (sg_size_t) (fd, void*, smx_file_t)
file_seek True (int) (fd, void*, smx_file_t) (offset, sg_size_t) (origin, int)
file_get_info True (void*, xbt_dynar_t) (fd, void*, smx_file_t)
file_move True (int) (fd, void*, smx_file_t) (fullpath, const char*)
-file_rcopy True (int) (fd, void*, smx_file_t) (host, void*, smx_host_t) (fullpath, const char*)
storage_get_free_size True (sg_size_t) (name, const char*)
storage_get_used_size True (sg_size_t) (name, const char*)
storage_get_properties True (void*, xbt_dict_t) (storage, void*, smx_storage_t)
static inline void simcall_file_open__set__fullpath(smx_simcall_t simcall, const char* arg){
simcall->args[0].cc = arg;
}
+static inline smx_host_t simcall_file_open__get__host(smx_simcall_t simcall){
+ return (smx_host_t) simcall->args[1].dp;
+}
+static inline void simcall_file_open__set__host(smx_simcall_t simcall, void* arg){
+ simcall->args[1].dp = arg;
+}
static inline smx_file_t simcall_file_close__get__fd(smx_simcall_t simcall){
return (smx_file_t) simcall->args[0].dp;
}
static inline void simcall_file_close__set__fd(smx_simcall_t simcall, void* arg){
simcall->args[0].dp = arg;
}
+static inline smx_host_t simcall_file_close__get__host(smx_simcall_t simcall){
+ return (smx_host_t) simcall->args[1].dp;
+}
+static inline void simcall_file_close__set__host(smx_simcall_t simcall, void* arg){
+ simcall->args[1].dp = arg;
+}
static inline smx_file_t simcall_file_unlink__get__fd(smx_simcall_t simcall){
return (smx_file_t) simcall->args[0].dp;
}
static inline void simcall_file_move__set__fullpath(smx_simcall_t simcall, const char* arg){
simcall->args[1].cc = arg;
}
-static inline smx_file_t simcall_file_rcopy__get__fd(smx_simcall_t simcall){
- return (smx_file_t) simcall->args[0].dp;
-}
-static inline void simcall_file_rcopy__set__fd(smx_simcall_t simcall, void* arg){
- simcall->args[0].dp = arg;
-}
-static inline smx_host_t simcall_file_rcopy__get__host(smx_simcall_t simcall){
- return (smx_host_t) simcall->args[1].dp;
-}
-static inline void simcall_file_rcopy__set__host(smx_simcall_t simcall, void* arg){
- simcall->args[1].dp = arg;
-}
-static inline const char* simcall_file_rcopy__get__fullpath(smx_simcall_t simcall){
- return simcall->args[2].cc;
-}
-static inline void simcall_file_rcopy__set__fullpath(smx_simcall_t simcall, const char* arg){
- simcall->args[2].cc = arg;
-}
static inline const char* simcall_storage_get_free_size__get__name(smx_simcall_t simcall){
return simcall->args[0].cc;
}
}
return self->simcall.result.sgsz;
}
- inline static smx_file_t simcall_BODY_file_open(const char* fullpath) {
+ inline static smx_file_t simcall_BODY_file_open(const char* fullpath, smx_host_t host) {
smx_process_t self = SIMIX_process_self();
self->simcall.call = SIMCALL_FILE_OPEN;
memset(&self->simcall.result, 0, sizeof(self->simcall.result));
memset(self->simcall.args, 0, sizeof(self->simcall.args));
self->simcall.args[0].cc = (const char*) fullpath;
+ self->simcall.args[1].dp = (void*) host;
if (self != simix_global->maestro_process) {
XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
}
return self->simcall.result.dp;
}
- inline static int simcall_BODY_file_close(smx_file_t fd) {
+ inline static int simcall_BODY_file_close(smx_file_t fd, smx_host_t host) {
smx_process_t self = SIMIX_process_self();
self->simcall.call = SIMCALL_FILE_CLOSE;
memset(&self->simcall.result, 0, sizeof(self->simcall.result));
memset(self->simcall.args, 0, sizeof(self->simcall.args));
self->simcall.args[0].dp = (void*) fd;
+ self->simcall.args[1].dp = (void*) host;
if (self != simix_global->maestro_process) {
XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
}
return self->simcall.result.i;
}
- inline static int simcall_BODY_file_rcopy(smx_file_t fd, smx_host_t host, const char* fullpath) {
- smx_process_t self = SIMIX_process_self();
- self->simcall.call = SIMCALL_FILE_RCOPY;
- memset(&self->simcall.result, 0, sizeof(self->simcall.result));
- memset(self->simcall.args, 0, sizeof(self->simcall.args));
- self->simcall.args[0].dp = (void*) fd;
- self->simcall.args[1].dp = (void*) host;
- self->simcall.args[2].cc = (const char*) fullpath;
- if (self != simix_global->maestro_process) {
- XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
- SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
- SIMIX_process_yield(self);
- } else {
- SIMIX_simcall_pre(&self->simcall, 0);
- }
- return self->simcall.result.i;
- }
inline static sg_size_t simcall_BODY_storage_get_free_size(const char* name) {
smx_process_t self = SIMIX_process_self();
self->simcall.call = SIMCALL_STORAGE_GET_FREE_SIZE;
break;
case SIMCALL_FILE_OPEN:
- SIMIX_pre_file_open(simcall , simcall->args[0].cc);
+ SIMIX_pre_file_open(simcall , simcall->args[0].cc, (smx_host_t) simcall->args[1].dp);
break;
case SIMCALL_FILE_CLOSE:
- SIMIX_pre_file_close(simcall , (smx_file_t) simcall->args[0].dp);
+ SIMIX_pre_file_close(simcall , (smx_file_t) simcall->args[0].dp, (smx_host_t) simcall->args[1].dp);
break;
case SIMCALL_FILE_UNLINK:
SIMIX_simcall_answer(simcall);
break;
-case SIMCALL_FILE_RCOPY:
- simcall->result.i = SIMIX_pre_file_rcopy(simcall , (smx_file_t) simcall->args[0].dp, (smx_host_t) simcall->args[1].dp, simcall->args[2].cc);
- SIMIX_simcall_answer(simcall);
- break;
-
case SIMCALL_STORAGE_GET_FREE_SIZE:
simcall->result.sgsz = SIMIX_pre_storage_get_free_size(simcall , simcall->args[0].cc);
SIMIX_simcall_answer(simcall);
SIMCALL_FILE_SEEK,
SIMCALL_FILE_GET_INFO,
SIMCALL_FILE_MOVE,
-SIMCALL_FILE_RCOPY,
SIMCALL_STORAGE_GET_FREE_SIZE,
SIMCALL_STORAGE_GET_USED_SIZE,
SIMCALL_STORAGE_GET_PROPERTIES,
static inline void simcall_file_move__set__result(smx_simcall_t simcall, int result){
simcall->result.i = result;
}
-static inline int simcall_file_rcopy__get__result(smx_simcall_t simcall){
- return simcall->result.i;
-}
-static inline void simcall_file_rcopy__set__result(smx_simcall_t simcall, int result){
- simcall->result.i = result;
-}
static inline sg_size_t simcall_storage_get_free_size__get__result(smx_simcall_t simcall){
return simcall->result.sgsz;
}
[SIMCALL_FILE_SEEK] = "SIMCALL_FILE_SEEK",
[SIMCALL_FILE_GET_INFO] = "SIMCALL_FILE_GET_INFO",
[SIMCALL_FILE_MOVE] = "SIMCALL_FILE_MOVE",
-[SIMCALL_FILE_RCOPY] = "SIMCALL_FILE_RCOPY",
[SIMCALL_STORAGE_GET_FREE_SIZE] = "SIMCALL_STORAGE_GET_FREE_SIZE",
[SIMCALL_STORAGE_GET_USED_SIZE] = "SIMCALL_STORAGE_GET_USED_SIZE",
[SIMCALL_STORAGE_GET_PROPERTIES] = "SIMCALL_STORAGE_GET_PROPERTIES",
}
//SIMIX FILE OPEN
-void SIMIX_pre_file_open(smx_simcall_t simcall, const char* fullpath)
+void SIMIX_pre_file_open(smx_simcall_t simcall, const char* fullpath, smx_host_t host)
{
- smx_action_t action = SIMIX_file_open(simcall->issuer, fullpath);
+ smx_action_t action = SIMIX_file_open(simcall->issuer, fullpath, host);
xbt_fifo_push(action->simcalls, simcall);
simcall->issuer->waiting_action = action;
}
-smx_action_t SIMIX_file_open(smx_process_t process, const char* fullpath)
+smx_action_t SIMIX_file_open(smx_process_t process, const char* fullpath, smx_host_t host)
{
smx_action_t action;
- smx_host_t host = process->smx_host;
/* check if the host is active */
if (surf_resource_get_state(surf_workstation_resource_priv(host)) != SURF_RESOURCE_ON) {
}
//SIMIX FILE CLOSE
-void SIMIX_pre_file_close(smx_simcall_t simcall, smx_file_t fd)
+void SIMIX_pre_file_close(smx_simcall_t simcall, smx_file_t fd, smx_host_t host)
{
- smx_action_t action = SIMIX_file_close(simcall->issuer, fd);
+ smx_action_t action = SIMIX_file_close(simcall->issuer, fd, host);
xbt_fifo_push(action->simcalls, simcall);
simcall->issuer->waiting_action = action;
}
-smx_action_t SIMIX_file_close(smx_process_t process, smx_file_t fd)
+smx_action_t SIMIX_file_close(smx_process_t process, smx_file_t fd, smx_host_t host)
{
smx_action_t action;
- smx_host_t host = process->smx_host;
/* check if the host is active */
if (surf_resource_get_state(surf_workstation_resource_priv(host)) != SURF_RESOURCE_ON) {
return surf_workstation_file_move(host, file->surf_file, fullpath);
}
-int SIMIX_pre_file_rcopy(smx_simcall_t simcall, smx_file_t fd, smx_host_t host, const char* fullpath)
-{
- return SIMIX_file_rcopy(simcall->issuer, fd, host, fullpath);
-}
-
-int SIMIX_file_rcopy(smx_process_t process, smx_file_t file, smx_host_t host_dest, const char* fullpath)
-{
- smx_host_t host = process->smx_host;
- return surf_workstation_file_rcopy(host, file->surf_file, host_dest, fullpath);
-}
-
sg_size_t SIMIX_pre_storage_get_free_size(smx_simcall_t simcall, const char* name)
{
return SIMIX_storage_get_free_size(simcall->issuer, name);
void SIMIX_storage_destroy(void *s);
void SIMIX_pre_file_read(smx_simcall_t simcall, smx_file_t fd, sg_size_t size, smx_host_t host);
void SIMIX_pre_file_write(smx_simcall_t simcall,smx_file_t fd, sg_size_t size, smx_host_t host);
-void SIMIX_pre_file_open(smx_simcall_t simcall, const char* fullpath);
-void SIMIX_pre_file_close(smx_simcall_t simcall, smx_file_t fd);
+void SIMIX_pre_file_open(smx_simcall_t simcall, const char* fullpath, smx_host_t host);
+void SIMIX_pre_file_close(smx_simcall_t simcall, smx_file_t fd, smx_host_t host);
int SIMIX_pre_file_unlink(smx_simcall_t simcall, smx_file_t fd);
sg_size_t SIMIX_pre_file_get_size(smx_simcall_t simcall, smx_file_t fd);
sg_size_t SIMIX_pre_file_tell(smx_simcall_t simcall, smx_file_t fd);
xbt_dynar_t SIMIX_pre_file_get_info(smx_simcall_t simcall, smx_file_t fd);
int SIMIX_pre_file_seek(smx_simcall_t simcall, smx_file_t fd, sg_size_t offset, int origin);
int SIMIX_pre_file_move(smx_simcall_t simcall, smx_file_t fd, const char* fullpath);
-int SIMIX_pre_file_rcopy(smx_simcall_t simcall, smx_file_t fd, smx_host_t dest, const char* fullpath);
smx_action_t SIMIX_file_read(smx_process_t process, smx_file_t fd, sg_size_t size, smx_host_t host);
smx_action_t SIMIX_file_write(smx_process_t process, smx_file_t fd, sg_size_t size, smx_host_t host);
-smx_action_t SIMIX_file_open(smx_process_t process, const char* fullpath);
-smx_action_t SIMIX_file_close(smx_process_t process, smx_file_t fd);
+smx_action_t SIMIX_file_open(smx_process_t process, const char* fullpath, smx_host_t host);
+smx_action_t SIMIX_file_close(smx_process_t process, smx_file_t fd, smx_host_t host);
int SIMIX_file_unlink(smx_process_t process, smx_file_t fd);
sg_size_t SIMIX_file_get_size(smx_process_t process, smx_file_t fd);
sg_size_t SIMIX_file_tell(smx_process_t process, smx_file_t fd);
xbt_dynar_t SIMIX_file_get_info(smx_process_t process, smx_file_t fd);
int SIMIX_file_seek(smx_process_t process, smx_file_t fd, sg_size_t offset, int origin);
int SIMIX_file_move(smx_process_t process, smx_file_t fd, const char* fullpath);
-int SIMIX_file_rcopy(smx_process_t process, smx_file_t fd, smx_host_t dest, const char* fullpath);
sg_size_t SIMIX_pre_storage_get_free_size(smx_simcall_t simcall,const char* name);
sg_size_t SIMIX_storage_get_free_size(smx_process_t process,const char* name);
* \ingroup simix_file_management
* \brief
*/
-smx_file_t simcall_file_open(const char* fullpath)
+smx_file_t simcall_file_open(const char* fullpath, smx_host_t host)
{
- return simcall_BODY_file_open(fullpath);
+ return simcall_BODY_file_open(fullpath, host);
}
/**
* \ingroup simix_file_management
*
*/
-int simcall_file_close(smx_file_t fd)
+int simcall_file_close(smx_file_t fd, smx_host_t host)
{
- return simcall_BODY_file_close(fd);
+ return simcall_BODY_file_close(fd, host);
}
/**
return simcall_BODY_file_move(fd, fullpath);
}
-/**
- * \ingroup simix_file_management
- * \brief Copy a file to another location on a remote host.
- *
- */
-int simcall_file_rcopy(smx_file_t fd, smx_host_t host, const char* fullpath)
-{
- return simcall_BODY_file_rcopy(fd, host, fullpath);
-}
-
/**
* \ingroup simix_storage_management
* \brief Returns the free space size on a given storage element.
return get_casted_workstation(workstation)->fileMove(fd, fullpath);
}
-int surf_workstation_file_rcopy(surf_resource_t workstation, surf_file_t fd, surf_resource_t host_dest, const char* fullpath){
- return get_casted_workstation(workstation)->fileRcopy(fd, host_dest, fullpath);
-}
-
xbt_dynar_t surf_workstation_get_vms(surf_resource_t resource){
return get_casted_workstation(resource)->getVms();
}
}
}
-int Workstation::fileRcopy(surf_file_t fd, surf_resource_t host_dest, const char* fullpath){
-
- XBT_DEBUG("Rcopy file %s on %s to %s",fd->name, host_dest->key, fullpath);
-
- /* Find the host src where the file is located */
- StoragePtr storage = findStorageOnMountList(fd->mount);
- const char* host_name_src = (const char*)storage->p_attach;
-
- /* Find the real host dest where the file will be stored */
- s_mount_t mnt;
- unsigned int cursor;
- StoragePtr storage_dest = NULL;
- const char* host_name_dest;
- char *file_mount_name;
- size_t longest_prefix_length = 0;
- WorkstationPtr dest_ws, src_ws;
-
- dest_ws = static_cast<WorkstationPtr>(surf_workstation_resource_priv(host_dest));
-
- xbt_dynar_foreach(dest_ws->p_storage,cursor,mnt)
- {
- file_mount_name = (char *) xbt_malloc ((strlen(mnt.name)+1));
- strncpy(file_mount_name,fullpath,strlen(mnt.name)+1);
- file_mount_name[strlen(mnt.name)] = '\0';
-
- if(!strcmp(file_mount_name,mnt.name) && strlen(mnt.name)>longest_prefix_length)
- {/* The current mount name is found in the full path and is bigger than the previous*/
- longest_prefix_length = strlen(mnt.name);
- storage_dest = static_cast<StoragePtr>(mnt.storage);
- }
- free(file_mount_name);
- }
- if(longest_prefix_length>0)
- { /* Mount point found, retrieve the host the storage is attached to */
- host_name_dest = storage_dest->p_attach;
- }
- else
- {
- XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath, host_dest->key);
- return MSG_TASK_CANCELED;
- }
-
- /* Check that there is a route between src and dest workstations */
- xbt_dynar_t route = NULL;
- dest_ws = static_cast<WorkstationPtr>(surf_workstation_resource_priv(xbt_lib_get_elm_or_null(host_lib, host_name_dest)));
- src_ws = static_cast<WorkstationPtr>(surf_workstation_resource_priv(xbt_lib_get_elm_or_null(host_lib, host_name_src)));
-
- routing_get_route_and_latency(src_ws->p_netElm, dest_ws->p_netElm, &route, NULL);
- if(!xbt_dynar_length (route))
- {
- XBT_WARN("There is no route between %s and %s. Action has been canceled", src_ws->getName(), dest_ws->getName());
- return MSG_TASK_CANCELED;
- }
- else
- {/* There is a route between src and dest, let's copy the file */
-
- /* Read the file on the src side */
- src_ws->read(fd, fd->size);
-
- /* Send a message from src to dest to simulate data transfer */
- surf_network_model->communicate(src_ws->p_netElm, dest_ws->p_netElm, fd->size, .0);
-
- /* Create the file on the dest side and write data into it*/
- char *mount_name, *path;
- path = (char *) xbt_malloc ((strlen(fullpath)-longest_prefix_length+1));
- mount_name = (char *) xbt_malloc ((longest_prefix_length+1));
-
- /* deduce mount_name and path from fullpath */
- strncpy(mount_name, fullpath, longest_prefix_length+1);
- strncpy(path, fullpath+longest_prefix_length, strlen(fullpath)-longest_prefix_length+1);
- path[strlen(fullpath)-longest_prefix_length] = '\0';
- mount_name[longest_prefix_length] = '\0';
-
- /* create the file */
- StorageActionPtr open_action = storage_dest->open((const char*)mount_name, (const char*)path);
-
- surf_file_t surf_file = xbt_new(s_surf_file_t, 1);
- surf_file->current_position = 0;
- surf_file->mount = mount_name;
- surf_file->name = strdup(path);
- surf_file->size = 0;
-
- /* write data and close file*/
- storage_dest->write(surf_file, fd->size);
- storage_dest->close(open_action->p_file);
-
- free(path);
- free(mount_name);
- XBT_DEBUG("File %s has been copied on %s to %s",fd->name, host_dest->key, fullpath);
- return MSG_OK;
- }
-}
-
sg_size_t Workstation::getFreeSize(const char* name)
{
StoragePtr st = findStorageOnMountList(name);
*/
virtual int fileMove(surf_file_t fd, const char* fullpath);
- /**
- * @brief Copy a file to another location on a remote host.
- * @details [long description]
- *
- * @param fd The file descriptor
- * @param host_dest The worstation destination
- * @param fullpath The new full path
- * @return MSG_OK if successful, otherwise MSG_TASK_CANCELED
- */
- virtual int fileRcopy(surf_file_t fd, surf_resource_t host_dest, const char* fullpath);
-
xbt_dynar_t p_storage;
RoutingEdgePtr p_netElm;
CpuPtr p_cpu;
