Anubis / Anubis


 *Project*                     Anubis
   
 *Title*                  generic files functions. 
   
 *Copyright*       Copyright (c) David René 2006-2007. 

   
 *Author*    David René
 *Created*   May 2005
 *Status*    Released  
 *Overview* 
 
read tools/connections.anubis
read tools/streams.anubis
read tools/basis.anubis
read system/data_io.anubis
read system/string.anubis

public define String      normalize_path(String given_path).
public define Maybe(One)  flush(ByteArray buffer, WStream target).

public type ResultCopy:
  cant_read_file,
  cant_create_file,
  copy_error,
  copy_file_mode_error,
  copy_file_times_error, 
  copy_ok(Int written).         //copy ok of 'written' bytes

define ResultCopy 
  _copy_file
  (
    RStream source, 
    WStream target, 
    Int   so_far
  ) =

  if read(source, 65536, 10) is
  {
    error     then copy_error,
    timeout   then copy_error,
    ok(buffer)then
      with len = length(buffer),
      if len = 0 then 
        copy_ok(so_far)
      else
        if flush(buffer, target) is
        {
          failure    then copy_error,
          success(_) then _copy_file(source, target, so_far + len)
        }
  }.

define ResultCopy 
  _copy_file
  (
    RStream source, 
    WStream target,
    Int   remaining,
    Int   so_far
  ) =
  with read_length = min(remaining, 65536),
  if read_length = 0 then 
    copy_ok(so_far)
  else if read(source, read_length, 10) is
  {
    error     then copy_error,
    timeout   then copy_error,
    ok(buffer)then
      if flush(buffer, target) is
      {
        failure    then copy_error,
        success(_) then _copy_file(source, target, remaining - read_length, so_far + read_length)
      }
  }.
  
public define ResultCopy 
  copy_file
  (
    RStream source, 
    WStream target, 
  ) =
  _copy_file(source, target, 0).

public define ResultCopy 
  copy_file
  (
    RStream source, 
    WStream target,
    Int   length
  ) =
  _copy_file(source, target, length, 0).
  
define ResultCopy 
  copy_file_data
  ( 
    String source_file, 
    String target_file
  ) =
  //open the source file
  if (Maybe(RStream))file(source_file, read) is
  {
     failure          then cant_read_file,
     success(source)  then 
    //open the target file
    if (Maybe(RWStream))file(target_file, new) is
    {
      failure         then println("can't create target file "+target_file);cant_create_file, //nothing to write 
      success(target) then copy_file(source, weaken(target))
    }
  }.
  
public define ResultCopy 
  append_file_to_file
  ( 
    String source_file, 
    String target_file
  ) =
  //open the source file
  if (Maybe(RStream))file(source_file, read) is
  {
     failure          then cant_read_file,
     success(source)  then 
    //open the target file
    if (Maybe(RWStream))file(target_file, append) is
    {
      failure         then println("can't create target file"+target_file);cant_create_file, //nothing to write 
      success(target) then copy_file(source, weaken(target))
    }
  }.

  
public define ResultCopy 
  copy_file
  ( 
    String the_source_file, 
    String the_target_file
  ) =

  // copy only the data of the file
  with source_file = normalize_path(the_source_file),
       target_file = normalize_path(the_target_file),
  with result = copy_file_data(source_file, target_file),
  if result is copy_ok(size) then
  // copy date and times
    if get_file_times(source_file) is 
    {
      failure then print("get copy_file_times_error\n"); copy_file_times_error,
      success(ftimes) then 
        if ftimes is times(modif, access) then
          if set_file_times(target_file, ftimes) is 
          {
            failure     then print("set copy_file_times_error\n");copy_file_times_error, 
            success(_)  then 
              //copy file_mode
              if get_file_mode(source_file) is
              {
                failure             then print("get get_file_mode error\n");copy_file_mode_error,
                success (file_mode) then 
                if set_file_mode(target_file, file_mode) is
                {
                  failure     then print("set set_file_mode error\n");copy_file_mode_error,
                  success(_)  then copy_ok(size)
                } 
              }
          }
    }
  else
    result .

    
public define Bool
  move_file
  (
    String  source_file,
    String  target_file
  )=
  
  with result = copy_file(source_file, target_file),
  if result is copy_ok(_) then
    remove(source_file)
  else
    false.
  
/** copy file into the socket
 */ 
public define Maybe(One)
  copy_file_to_stream
  (
    RStream   source_file, 
    RWStream  socket, 
    Int     length
  ) =
  //we send the mail content by 16KB buffer
  with read_length = min(length, 16384),
  if read_length = 0 then 
    success(unique)
  else if read(source_file, read_length, 10) is
  {
    error     then failure,
    timeout   then  failure,
    ok(buffer)then
    if reliable_write(tcp(socket), buffer) is
    {
      failure           then failure,
      success(how_many) then 
        if read_length = how_many then 
          copy_file_to_stream(source_file, socket, length - how_many)
        else 
          failure
    }
  }.

/** copy file into the socket
 */ 
public define Maybe(One)
  copy_file_to_Connection
  (
    Connection  source_file, 
    Connection  socket, 
    Int       length
  ) =
  //we send the mail content by 16KB buffer
  with read_length = min(length, 16384),
  if read_length = 0 then 
    success(unique)
  else if read(source_file, read_length, 10) is
  {
    error     then failure,
    timeout   then  failure,
    ok(buffer)then
    if write(socket, buffer) is
    {
      failure           then failure,
      success(how_many) then 
        if read_length = how_many then 
          copy_file_to_Connection(source_file, socket, length - how_many)
        else 
          failure
    }
  }.

define Maybe(One)
  flush
  (
    ByteArray buffer,
    WStream   target
  )=
  if write( target , buffer) is
  {
    failure           then failure,
    success(nb_write) then
      with buffer_size = length(buffer),      
      if nb_write = buffer_size then
        success(unique)
      else
        with new_buffer = extract(buffer, nb_write, buffer_size),
        flush(new_buffer, target)
  }.
  
public define ResultCopy 
  copy_Data_IO_to_Stream
  (
    Data_IO source, 
    WStream target,
    Int   so_far
  ) =
  if read_bytes(source, 65536) is
  {
    failure         then copy_error,
    time_out        then copy_error, 
    success(buffer) then 
      if flush( buffer, target ) is
      {
        failure     then copy_error,
        success(_)  then copy_Data_IO_to_Stream(source, target, so_far + 65536)
      },
      
    truncated(buffer)       then
      with len = length(buffer),
      if len = 0 then
        copy_ok(so_far)
      else 
        if flush( buffer, target ) is
        {
          failure     then copy_error,
          success(_)  then copy_ok(so_far + len)
        }
  }.

define ResultCopy
  copy_Data_IO_List_to_Stream
  (
    List(Data_IO) io_list,
    WStream       target,
    Int         so_far
  )=
  if io_list is
  {
    []        then copy_ok(so_far),
    [ h . t ]  then
      if rewind(h)(unique) then
        with result = copy_Data_IO_to_Stream(h, target, 0),
        if result is copy_ok(written) then 
          copy_Data_IO_List_to_Stream(t, target, so_far + written)
        else
          result
      else
        copy_error
  }.
  
public define ResultCopy
  copy_Data_IO_List_to_Stream
  (
    List(Data_IO) io_list,
    WStream       target
  )=
  if io_list is
  {
    []        then copy_ok(0),
    [ h . t ]  then copy_Data_IO_List_to_Stream(io_list, target, 0)
  }.

public define ResultCopy
  copy_Data_IO_List_to_Stream
  (
    List(Data_IO) io_list,
    String        target_file
  )=
  with norm_target_file = normalize_path(target_file),
  if (Maybe(RWStream))file(norm_target_file, new) is
  {
      failure         then print("copy_Data_IO_to_file: can't create '"+norm_target_file+"' file\n");cant_create_file, //nothing to write 
      success(target) then copy_Data_IO_List_to_Stream(io_list, weaken(target))
  }.
  
public define ResultCopy
  copy_Data_IO_to_file
  (
    Data_IO io,
    String  target_file
  )=
  with norm_target_file = normalize_path(target_file),
  if (Maybe(RWStream))file(norm_target_file, new) is
  {
      failure         then print("copy_Data_IO_to_file: can't create '"+norm_target_file+"' file\n");cant_create_file, //nothing to write 
      success(target) then copy_Data_IO_to_Stream(io, weaken(target), 0)
  }.
  
define String
  normalize_path
  (
    List(Word8)  path,
    List(Word8)  so_far,
    Bool        in_slash
  )=
  if path is
  {
    []        then implode(reverse(so_far)),
    [h . t ]  then
      if h = '\\'  & in_slash then
        normalize_path(t, so_far, true)
      else if h = '\\' & in_slash = false then
        normalize_path(t, [ '/' . so_far], true)
      else if h = '/' & in_slash then
        normalize_path(t, so_far, true)
      else if h = '/' & in_slash = false then
        normalize_path(t, [h . so_far], true)
      else
        normalize_path(t, [h . so_far], false)
  }.


  /** Normalize path, change the anti-slash in the file_path string by slash. Also
   * the double slash are remove to be only slash at the end
   * For example the given path to normalize is:
   *          "\general_dir\/my_dir/foo.foo"
   * 
   * result of normalize path will be   "/general_dir/my_dir/foo.foo"
   */ 
public define String 
  normalize_path
  (
    String given_path
  )=
  normalize_path(explode(given_path),[], false).


define Maybe(String)
  normalize_path
  (
    List(String)  folders,
    List(String)  so_far,
  )=
  if folders is
  {
    []    then success(join("/", reverse(so_far))),
    [h . t] then
      if h = "" | h = "." then
        if so_far is
        {
          [] then normalize_path(t, [h . so_far]),   // the first '/'or '.' have to be added to keep absolute or relative path
          [_ . _] then
            if t is 
            {
              []    then if h = "" then normalize_path(t, [h . so_far]) // the last '/' should be keeped too
                                   else normalize_path(t, so_far),      // but not the '.'
              [_ . _] then normalize_path(t, so_far)
            }
        }
      else if h = ".." then 
        if so_far is
        {
          []    then failure,
          [_ . h2] then normalize_path(t, h2)
        }
      else
        normalize_path(t, [h . so_far])
  }.

public define Maybe(String)
  normalize_path_ex
  (
    String given_path
  )=
  normalize_path(split_by_tokens(given_path, ['/', '\\']),[]).
  
define Int 
  last_char
  (
    List(Word8)  path,
    Int       last_slash,
    Int       current_pos
  ) = 
  if path is
  {
    []        then last_slash,
    [h . t ]  then
      if h = '/' then
        last_char(t, current_pos, current_pos + 1)
      else  
        last_char(t, last_slash, current_pos + 1)
  }.
  
  /** extract dir, extract the directory path from the given path. The given path
   * can have file in the tail of it.
   * the result of extract_dir apply on "/general_dir/my_dir/foo.foo" is
   * "/general_dir/my_dir/"
   */
   
public define String
  extract_dir
  (
    String given_path
  )=
  with path = normalize_path(given_path),
  with pos = last_char(explode(path), 0, 0),
  if sub_string(path, 0, pos+1) is
  {
    failure           then given_path,
    success(new_path) then new_path
  } .

public define List(String)
  extract_dir
  (
    String given_path
  )=
  split_by_token(extract_dir(given_path), '/').
  
public define One
   make_directories
     (
       String dir
     ) =
     with list_dir = (List(String))extract_dir(dir),
     //println("try to make dir "+dir);
     make_directories("", list_dir).
    
public define String 
  extract_file_name
  (
    String  given_path
  )=
  with path = normalize_path(given_path),
        len = length(path),
        pos = last_char(explode(path), -1, 0),
   file_len = len - (pos+1),
  if sub_string(path, pos + 1, file_len) is
  {
    failure             then "",
    success(file_name)  then file_name
  } .
  
public define Bool
  is_dir
  (
    String  given_path
  ) =
  with path = normalize_path(given_path),
        len = length(path),
  if sub_string(path, len - 1, 1) is
  {
    failure     then false,
    success(c)  then
      if c = "/" then 
        true
      else
        false
  }.
  
define Bool
  remove_files
  (
    String       path,
    List(String) files
  )=
  if files is
  {
    []        then true,  //we have finished
    [file_name . t ]  then
      if file_name = "." | file_name = ".." then 
        remove_files(path, t)
      else if remove(path + file_name) then
//        println("removing "+path+file_name);
        remove_files(path, t)
      else
        println("can't remove file ["+path+file_name+"]"); false
  }.

  /**
   * Emptying directory, remove all files matching with the given mask
   * If something wrong happend during the deletion of files the function
   * may return false otherwise true
   */
public define Bool
  emptying_directory
  (
    String  path,
    String  mask
  )=
  with norm_path = normalize_path(path),
  remove_files(norm_path +"/", directory_list(norm_path, mask)).