hdfs.h
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:16k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. #ifndef LIBHDFS_HDFS_H
  19. #define LIBHDFS_HDFS_H
  20. #include <sys/types.h>
  21. #include <sys/stat.h>
  22. #include <fcntl.h>
  23. #include <stdio.h>
  24. #include <stdint.h>
  25. #include <string.h>
  26. #include <stdlib.h>
  27. #include <time.h>
  28. #include <errno.h>
  29. #include <jni.h>
  30. #ifndef O_RDONLY
  31. #define O_RDONLY 1
  32. #endif
  33. #ifndef O_WRONLY 
  34. #define O_WRONLY 2
  35. #endif
  36. #ifndef EINTERNAL
  37. #define EINTERNAL 255 
  38. #endif
  39. /** All APIs set errno to meaningful values */
  40. #ifdef __cplusplus
  41. extern  "C" {
  42. #endif
  43.     /**
  44.      * Some utility decls used in libhdfs.
  45.      */
  46.     typedef int32_t   tSize; /// size of data for read/write io ops 
  47.     typedef time_t    tTime; /// time type in seconds
  48.     typedef int64_t   tOffset;/// offset within the file
  49.     typedef uint16_t  tPort; /// port
  50.     typedef enum tObjectKind {
  51.         kObjectKindFile = 'F',
  52.         kObjectKindDirectory = 'D',
  53.     } tObjectKind;
  54.     /**
  55.      * The C reflection of org.apache.org.hadoop.FileSystem .
  56.      */
  57.     typedef void* hdfsFS;
  58.     
  59.     /**
  60.      * The C equivalent of org.apache.org.hadoop.FSData(Input|Output)Stream .
  61.      */
  62.     enum hdfsStreamType
  63.     {
  64.         UNINITIALIZED = 0,
  65.         INPUT = 1,
  66.         OUTPUT = 2,
  67.     };
  68.     
  69.     /**
  70.      * The 'file-handle' to a file in hdfs.
  71.      */
  72.     struct hdfsFile_internal {
  73.         void* file;
  74.         enum hdfsStreamType type;
  75.     };
  76.     typedef struct hdfsFile_internal* hdfsFile;
  77.       
  78.     /** 
  79.      * hdfsConnectAsUser - Connect to a hdfs file system as a specific user
  80.      * Connect to the hdfs.
  81.      * @param host A string containing either a host name, or an ip address
  82.      * of the namenode of a hdfs cluster. 'host' should be passed as NULL if
  83.      * you want to connect to local filesystem. 'host' should be passed as
  84.      * 'default' (and port as 0) to used the 'configured' filesystem
  85.      * (core-site/core-default.xml).
  86.      * @param port The port on which the server is listening.
  87.      * @param user the user name (this is hadoop domain user). Or NULL is equivelant to hhdfsConnect(host, port)
  88.      * @param groups the groups (these are hadoop domain groups)
  89.      * @return Returns a handle to the filesystem or NULL on error.
  90.      */
  91.      hdfsFS hdfsConnectAsUser(const char* host, tPort port, const char *user , const char *groups[], int groups_size );
  92.     /** 
  93.      * hdfsConnect - Connect to a hdfs file system.
  94.      * Connect to the hdfs.
  95.      * @param host A string containing either a host name, or an ip address
  96.      * of the namenode of a hdfs cluster. 'host' should be passed as NULL if
  97.      * you want to connect to local filesystem. 'host' should be passed as
  98.      * 'default' (and port as 0) to used the 'configured' filesystem
  99.      * (core-site/core-default.xml).
  100.      * @param port The port on which the server is listening.
  101.      * @return Returns a handle to the filesystem or NULL on error.
  102.      */
  103.      hdfsFS hdfsConnect(const char* host, tPort port);
  104.     /** 
  105.      * hdfsDisconnect - Disconnect from the hdfs file system.
  106.      * Disconnect from hdfs.
  107.      * @param fs The configured filesystem handle.
  108.      * @return Returns 0 on success, -1 on error.  
  109.      */
  110.     int hdfsDisconnect(hdfsFS fs);
  111.         
  112.     /** 
  113.      * hdfsOpenFile - Open a hdfs file in given mode.
  114.      * @param fs The configured filesystem handle.
  115.      * @param path The full path to the file.
  116.      * @param flags - an | of bits/fcntl.h file flags - supported flags are O_RDONLY, O_WRONLY (meaning create or overwrite i.e., implies O_TRUNCAT), 
  117.      * O_WRONLY|O_APPEND. Other flags are generally ignored other than (O_RDWR || (O_EXCL & O_CREAT)) which return NULL and set errno equal ENOTSUP.
  118.      * @param bufferSize Size of buffer for read/write - pass 0 if you want
  119.      * to use the default configured values.
  120.      * @param replication Block replication - pass 0 if you want to use
  121.      * the default configured values.
  122.      * @param blocksize Size of block - pass 0 if you want to use the
  123.      * default configured values.
  124.      * @return Returns the handle to the open file or NULL on error.
  125.      */
  126.     hdfsFile hdfsOpenFile(hdfsFS fs, const char* path, int flags,
  127.                           int bufferSize, short replication, tSize blocksize);
  128.     /** 
  129.      * hdfsCloseFile - Close an open file. 
  130.      * @param fs The configured filesystem handle.
  131.      * @param file The file handle.
  132.      * @return Returns 0 on success, -1 on error.  
  133.      */
  134.     int hdfsCloseFile(hdfsFS fs, hdfsFile file);
  135.     /** 
  136.      * hdfsExists - Checks if a given path exsits on the filesystem 
  137.      * @param fs The configured filesystem handle.
  138.      * @param path The path to look for
  139.      * @return Returns 0 on success, -1 on error.  
  140.      */
  141.     int hdfsExists(hdfsFS fs, const char *path);
  142.     /** 
  143.      * hdfsSeek - Seek to given offset in file. 
  144.      * This works only for files opened in read-only mode. 
  145.      * @param fs The configured filesystem handle.
  146.      * @param file The file handle.
  147.      * @param desiredPos Offset into the file to seek into.
  148.      * @return Returns 0 on success, -1 on error.  
  149.      */
  150.     int hdfsSeek(hdfsFS fs, hdfsFile file, tOffset desiredPos); 
  151.     /** 
  152.      * hdfsTell - Get the current offset in the file, in bytes.
  153.      * @param fs The configured filesystem handle.
  154.      * @param file The file handle.
  155.      * @return Current offset, -1 on error.
  156.      */
  157.     tOffset hdfsTell(hdfsFS fs, hdfsFile file);
  158.     /** 
  159.      * hdfsRead - Read data from an open file.
  160.      * @param fs The configured filesystem handle.
  161.      * @param file The file handle.
  162.      * @param buffer The buffer to copy read bytes into.
  163.      * @param length The length of the buffer.
  164.      * @return Returns the number of bytes actually read, possibly less
  165.      * than than length;-1 on error.
  166.      */
  167.     tSize hdfsRead(hdfsFS fs, hdfsFile file, void* buffer, tSize length);
  168.     /** 
  169.      * hdfsPread - Positional read of data from an open file.
  170.      * @param fs The configured filesystem handle.
  171.      * @param file The file handle.
  172.      * @param position Position from which to read
  173.      * @param buffer The buffer to copy read bytes into.
  174.      * @param length The length of the buffer.
  175.      * @return Returns the number of bytes actually read, possibly less than
  176.      * than length;-1 on error.
  177.      */
  178.     tSize hdfsPread(hdfsFS fs, hdfsFile file, tOffset position,
  179.                     void* buffer, tSize length);
  180.     /** 
  181.      * hdfsWrite - Write data into an open file.
  182.      * @param fs The configured filesystem handle.
  183.      * @param file The file handle.
  184.      * @param buffer The data.
  185.      * @param length The no. of bytes to write. 
  186.      * @return Returns the number of bytes written, -1 on error.
  187.      */
  188.     tSize hdfsWrite(hdfsFS fs, hdfsFile file, const void* buffer,
  189.                     tSize length);
  190.     /** 
  191.      * hdfsWrite - Flush the data. 
  192.      * @param fs The configured filesystem handle.
  193.      * @param file The file handle.
  194.      * @return Returns 0 on success, -1 on error. 
  195.      */
  196.     int hdfsFlush(hdfsFS fs, hdfsFile file);
  197.     /**
  198.      * hdfsAvailable - Number of bytes that can be read from this
  199.      * input stream without blocking.
  200.      * @param fs The configured filesystem handle.
  201.      * @param file The file handle.
  202.      * @return Returns available bytes; -1 on error. 
  203.      */
  204.     int hdfsAvailable(hdfsFS fs, hdfsFile file);
  205.     /**
  206.      * hdfsCopy - Copy file from one filesystem to another.
  207.      * @param srcFS The handle to source filesystem.
  208.      * @param src The path of source file. 
  209.      * @param dstFS The handle to destination filesystem.
  210.      * @param dst The path of destination file. 
  211.      * @return Returns 0 on success, -1 on error. 
  212.      */
  213.     int hdfsCopy(hdfsFS srcFS, const char* src, hdfsFS dstFS, const char* dst);
  214.     /**
  215.      * hdfsMove - Move file from one filesystem to another.
  216.      * @param srcFS The handle to source filesystem.
  217.      * @param src The path of source file. 
  218.      * @param dstFS The handle to destination filesystem.
  219.      * @param dst The path of destination file. 
  220.      * @return Returns 0 on success, -1 on error. 
  221.      */
  222.     int hdfsMove(hdfsFS srcFS, const char* src, hdfsFS dstFS, const char* dst);
  223.     /**
  224.      * hdfsDelete - Delete file. 
  225.      * @param fs The configured filesystem handle.
  226.      * @param path The path of the file. 
  227.      * @return Returns 0 on success, -1 on error. 
  228.      */
  229.     int hdfsDelete(hdfsFS fs, const char* path);
  230.     /**
  231.      * hdfsRename - Rename file. 
  232.      * @param fs The configured filesystem handle.
  233.      * @param oldPath The path of the source file. 
  234.      * @param newPath The path of the destination file. 
  235.      * @return Returns 0 on success, -1 on error. 
  236.      */
  237.     int hdfsRename(hdfsFS fs, const char* oldPath, const char* newPath);
  238.     /** 
  239.      * hdfsGetWorkingDirectory - Get the current working directory for
  240.      * the given filesystem.
  241.      * @param fs The configured filesystem handle.
  242.      * @param buffer The user-buffer to copy path of cwd into. 
  243.      * @param bufferSize The length of user-buffer.
  244.      * @return Returns buffer, NULL on error.
  245.      */
  246.     char* hdfsGetWorkingDirectory(hdfsFS fs, char *buffer, size_t bufferSize);
  247.     /** 
  248.      * hdfsSetWorkingDirectory - Set the working directory. All relative
  249.      * paths will be resolved relative to it.
  250.      * @param fs The configured filesystem handle.
  251.      * @param path The path of the new 'cwd'. 
  252.      * @return Returns 0 on success, -1 on error. 
  253.      */
  254.     int hdfsSetWorkingDirectory(hdfsFS fs, const char* path);
  255.     /** 
  256.      * hdfsCreateDirectory - Make the given file and all non-existent
  257.      * parents into directories.
  258.      * @param fs The configured filesystem handle.
  259.      * @param path The path of the directory. 
  260.      * @return Returns 0 on success, -1 on error. 
  261.      */
  262.     int hdfsCreateDirectory(hdfsFS fs, const char* path);
  263.     /** 
  264.      * hdfsSetReplication - Set the replication of the specified
  265.      * file to the supplied value
  266.      * @param fs The configured filesystem handle.
  267.      * @param path The path of the file. 
  268.      * @return Returns 0 on success, -1 on error. 
  269.      */
  270.     int hdfsSetReplication(hdfsFS fs, const char* path, int16_t replication);
  271.     /** 
  272.      * hdfsFileInfo - Information about a file/directory.
  273.      */
  274.     typedef struct  {
  275.         tObjectKind mKind;   /* file or directory */
  276.         char *mName;         /* the name of the file */
  277.         tTime mLastMod;      /* the last modification time for the file in seconds */
  278.         tOffset mSize;       /* the size of the file in bytes */
  279.         short mReplication;    /* the count of replicas */
  280.         tOffset mBlockSize;  /* the block size for the file */
  281.         char *mOwner;        /* the owner of the file */
  282.         char *mGroup;        /* the group associated with the file */
  283.         short mPermissions;  /* the permissions associated with the file */
  284.         tTime mLastAccess;    /* the last access time for the file in seconds */
  285.     } hdfsFileInfo;
  286.     /** 
  287.      * hdfsListDirectory - Get list of files/directories for a given
  288.      * directory-path. hdfsFreeFileInfo should be called to deallocate memory. 
  289.      * @param fs The configured filesystem handle.
  290.      * @param path The path of the directory. 
  291.      * @param numEntries Set to the number of files/directories in path.
  292.      * @return Returns a dynamically-allocated array of hdfsFileInfo
  293.      * objects; NULL on error.
  294.      */
  295.     hdfsFileInfo *hdfsListDirectory(hdfsFS fs, const char* path,
  296.                                     int *numEntries);
  297.     /** 
  298.      * hdfsGetPathInfo - Get information about a path as a (dynamically
  299.      * allocated) single hdfsFileInfo struct. hdfsFreeFileInfo should be
  300.      * called when the pointer is no longer needed.
  301.      * @param fs The configured filesystem handle.
  302.      * @param path The path of the file. 
  303.      * @return Returns a dynamically-allocated hdfsFileInfo object;
  304.      * NULL on error.
  305.      */
  306.     hdfsFileInfo *hdfsGetPathInfo(hdfsFS fs, const char* path);
  307.     /** 
  308.      * hdfsFreeFileInfo - Free up the hdfsFileInfo array (including fields) 
  309.      * @param hdfsFileInfo The array of dynamically-allocated hdfsFileInfo
  310.      * objects.
  311.      * @param numEntries The size of the array.
  312.      */
  313.     void hdfsFreeFileInfo(hdfsFileInfo *hdfsFileInfo, int numEntries);
  314.     /** 
  315.      * hdfsGetHosts - Get hostnames where a particular block (determined by
  316.      * pos & blocksize) of a file is stored. The last element in the array
  317.      * is NULL. Due to replication, a single block could be present on
  318.      * multiple hosts.
  319.      * @param fs The configured filesystem handle.
  320.      * @param path The path of the file. 
  321.      * @param start The start of the block.
  322.      * @param length The length of the block.
  323.      * @return Returns a dynamically-allocated 2-d array of blocks-hosts;
  324.      * NULL on error.
  325.      */
  326.     char*** hdfsGetHosts(hdfsFS fs, const char* path, 
  327.             tOffset start, tOffset length);
  328.     /** 
  329.      * hdfsFreeHosts - Free up the structure returned by hdfsGetHosts
  330.      * @param hdfsFileInfo The array of dynamically-allocated hdfsFileInfo
  331.      * objects.
  332.      * @param numEntries The size of the array.
  333.      */
  334.     void hdfsFreeHosts(char ***blockHosts);
  335.     /** 
  336.      * hdfsGetDefaultBlockSize - Get the optimum blocksize.
  337.      * @param fs The configured filesystem handle.
  338.      * @return Returns the blocksize; -1 on error. 
  339.      */
  340.     tOffset hdfsGetDefaultBlockSize(hdfsFS fs);
  341.     /** 
  342.      * hdfsGetCapacity - Return the raw capacity of the filesystem.  
  343.      * @param fs The configured filesystem handle.
  344.      * @return Returns the raw-capacity; -1 on error. 
  345.      */
  346.     tOffset hdfsGetCapacity(hdfsFS fs);
  347.     /** 
  348.      * hdfsGetUsed - Return the total raw size of all files in the filesystem.
  349.      * @param fs The configured filesystem handle.
  350.      * @return Returns the total-size; -1 on error. 
  351.      */
  352.     tOffset hdfsGetUsed(hdfsFS fs);
  353.     /** 
  354.      * hdfsChown 
  355.      * @param fs The configured filesystem handle.
  356.      * @param path the path to the file or directory
  357.      * @param owner this is a string in Hadoop land. Set to null or "" if only setting group
  358.      * @param group  this is a string in Hadoop land. Set to null or "" if only setting user
  359.      * @return 0 on success else -1
  360.      */
  361.     int hdfsChown(hdfsFS fs, const char* path, const char *owner, const char *group);
  362.     /** 
  363.      * hdfsChmod
  364.      * @param fs The configured filesystem handle.
  365.      * @param path the path to the file or directory
  366.      * @param mode the bitmask to set it to
  367.      * @return 0 on success else -1
  368.      */
  369.       int hdfsChmod(hdfsFS fs, const char* path, short mode);
  370.     /** 
  371.      * hdfsUtime
  372.      * @param fs The configured filesystem handle.
  373.      * @param path the path to the file or directory
  374.      * @param mtime new modification time or 0 for only set access time in seconds
  375.      * @param atime new access time or 0 for only set modification time in seconds
  376.      * @return 0 on success else -1
  377.      */
  378.     int hdfsUtime(hdfsFS fs, const char* path, tTime mtime, tTime atime);
  379.     
  380. #ifdef __cplusplus
  381. }
  382. #endif
  383. #endif /*LIBHDFS_HDFS_H*/
  384. /**
  385.  * vim: ts=4: sw=4: et
  386.  */