Alien-uv
view release on metacpan or search on metacpan
libuv/ChangeLog view on Meta::CPAN
Changes since version 1.10.0:* Now working on version 1.10.1 (cjihrig)* win: fix anonymous union syntax (Brad King)* win: add missing break statement (cjihrig)* doc: fix wrong man pagelinkforuv_fs_lstat() (Michele Caini)* win, tty: handle empty buffer in uv_tty_write_bufs (Hitesh Kanwathirtha)* doc: add cjihrig alternative GPG ID (cjihrig)* Revert"win,tty: add support for ANSI codes in win10 v1511"(Ben Noordhuis)2016.10.25, Version 1.10.0 (Stable), c8a373c729b4c9392e0e14fc53cd6b67b3051ab9
libuv/docs/src/fs.rst view on Meta::CPAN
get `ent` populatedwiththenextdirectory entry data. When there arenomore entries ``UV_EOF`` will be returned... note::Unlike `scandir(3)`, this function does notreturnthe"."and".."entries... note::On Linux, getting the type of an entry is only supported by some file systems (btrfs, ext2,ext3 and ext4 at thetimeof this writing), check the :man:`getdents(2)` man page... c:function::intuv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb).. c:function::intuv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb).. c:function::intuv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb)Equivalent to :man:`stat(2)`, :man:`fstat(2)` and :man:`lstat(2)` respectively... c:function::intuv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, uv_fs_cb cb)Equivalent to :man:`rename(2)`... c:function::intuv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb)Equivalent to :man:`fsync(2)`... note::
libuv/docs/src/fs_event.rst view on Meta::CPAN
* Bydefault,ifthe fs event watcher isgivena directory name, we will* watchforall events in that directory. This flags overrides this behavior* and makes fs_event report only changes to the directory entry itself. This* flag does not affect individual files watched.* This flag is currently not implemented yet on any backend.*/UV_FS_EVENT_WATCH_ENTRY = 1,/** or kqueue to detect events. This may not work on remote file systems such* as NFS mounts. This flag makes fs_event fall back to callingstat() on a* regular interval.* This flag is currently not implemented yet on any backend.*/UV_FS_EVENT_STAT = 2,/** Bydefault, event watcher,whenwatching directory, is not registering* (is ignoring) changes in its subdirectories.* This flag willoverridethis behaviour on platforms that support it.*/UV_FS_EVENT_RECURSIVE = 4
libuv/include/uv.h view on Meta::CPAN
/* uv_fs_t is a subclass of uv_req_t. */struct uv_fs_s {UV_REQ_FIELDSuv_fs_type fs_type;uv_loop_t* loop;uv_fs_cb cb;ssize_t result;void* ptr;const char* path;uv_stat_t statbuf; /* Stores the result of uv_fs_stat() and uv_fs_fstat(). */UV_FS_PRIVATE_FIELDS};UV_EXTERN uv_fs_type uv_fs_get_type(const uv_fs_t*);UV_EXTERN ssize_t uv_fs_get_result(const uv_fs_t*);UV_EXTERN void* uv_fs_get_ptr(const uv_fs_t*);UV_EXTERN const char* uv_fs_get_path(const uv_fs_t*);UV_EXTERN uv_stat_t* uv_fs_get_statbuf(uv_fs_t*);UV_EXTERN void uv_fs_req_cleanup(uv_fs_t* req);
libuv/include/uv.h view on Meta::CPAN
const char* path,uv_fs_cb cb);UV_EXTERNintuv_fs_readdir(uv_loop_t* loop,uv_fs_t* req,uv_dir_t* dir,uv_fs_cb cb);UV_EXTERNintuv_fs_closedir(uv_loop_t* loop,uv_fs_t* req,uv_dir_t* dir,uv_fs_cb cb);UV_EXTERNintuv_fs_stat(uv_loop_t* loop,uv_fs_t* req,const char* path,uv_fs_cb cb);UV_EXTERNintuv_fs_fstat(uv_loop_t* loop,uv_fs_t* req,uv_file file,uv_fs_cb cb);UV_EXTERNintuv_fs_rename(uv_loop_t* loop,uv_fs_t* req,const char* path,const char* new_path,uv_fs_cb cb);UV_EXTERNintuv_fs_fsync(uv_loop_t* loop,uv_fs_t* req,
libuv/include/uv.h view on Meta::CPAN
const char* path,double atime,double mtime,uv_fs_cb cb);UV_EXTERNintuv_fs_futime(uv_loop_t* loop,uv_fs_t* req,uv_file file,double atime,double mtime,uv_fs_cb cb);UV_EXTERNintuv_fs_lstat(uv_loop_t* loop,uv_fs_t* req,const char* path,uv_fs_cb cb);UV_EXTERNintuv_fs_link(uv_loop_t* loop,uv_fs_t* req,const char* path,const char* new_path,uv_fs_cb cb);/*
libuv/include/uv.h view on Meta::CPAN
struct uv_fs_event_s {UV_HANDLE_FIELDS/* private */char* path;UV_FS_EVENT_PRIVATE_FIELDS};/** uv_fs_stat() based polling file watcher.*/struct uv_fs_poll_s {UV_HANDLE_FIELDS/* Private, don't touch. */void* poll_ctx;};UV_EXTERNintuv_fs_poll_init(uv_loop_t* loop, uv_fs_poll_t* handle);UV_EXTERNintuv_fs_poll_start(uv_fs_poll_t* handle,uv_fs_poll_cb poll_cb,
libuv/include/uv.h view on Meta::CPAN
* watchforall events in that directory. This flags overrides this behavior* and makes fs_event report only changes to the directory entry itself. This* flag does not affect individual files watched.* This flag is currently not implemented yet on any backend.*/UV_FS_EVENT_WATCH_ENTRY = 1,/** or kqueue to detect events. This may not work on remote filesystems such* as NFS mounts. This flag makes fs_event fall back to callingstat() on a* regular interval.* This flag is currently not implemented yet on any backend.*/UV_FS_EVENT_STAT = 2,/** Bydefault, event watcher,whenwatching directory, is not registering* (is ignoring) changes in it's subdirectories.* This flag willoverridethis behaviour on platforms that support it.*/
libuv/src/fs-poll.c view on Meta::CPAN
ctx->parent_handle = handle;memcpy(ctx->path, path, len + 1);err = uv_timer_init(loop,&ctx->timer_handle);if(err < 0)gotoerror;ctx->timer_handle.flags |= UV_HANDLE_INTERNAL;uv__handle_unref(&ctx->timer_handle);err = uv_fs_stat(loop,&ctx->fs_req, ctx->path, poll_cb);if(err < 0)gotoerror;if(handle->poll_ctx != NULL)ctx->previous = handle->poll_ctx;handle->poll_ctx = ctx;uv__handle_start(handle);return0;
libuv/src/fs-poll.c view on Meta::CPAN
static void timer_cb(uv_timer_t* timer) {struct poll_ctx* ctx;ctx = container_of(timer, struct poll_ctx, timer_handle);assert(ctx->parent_handle != NULL);assert(ctx->parent_handle->poll_ctx == ctx);ctx->start_time = uv_now(ctx->loop);if(uv_fs_stat(ctx->loop,&ctx->fs_req, ctx->path, poll_cb))abort();}static void poll_cb(uv_fs_t* req) {uv_stat_t* statbuf;struct poll_ctx* ctx;uint64_t interval;uv_fs_poll_t* handle;
libuv/src/fs-poll.c view on Meta::CPAN
ctx->busy_polling = 1;out:uv_fs_req_cleanup(req);if(!uv_is_active((uv_handle_t*)handle) || uv__is_closing(handle)) {uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);return;}/* Reschedule timer, subtract the delay from doing thestat(). */interval = ctx->interval;interval -= (uv_now(ctx->loop) - ctx->start_time) % interval;if(uv_timer_start(&ctx->timer_handle, timer_cb, interval, 0))abort();}static void timer_close_cb(uv_handle_t* timer) {struct poll_ctx* ctx;
libuv/src/unix/aix.c view on Meta::CPAN
/** Determine whethergivenpathname is a directory* Returns 0ifthe path is a directory, -1ifnot** Note: Opportunity hereformore detailed error information but* that requires changing callers of this function as well*/staticintuv__path_is_a_directory(char* filename) {structstatstatbuf;if(stat(filename,&statbuf) < 0)return-1; /* failed: not a directory, assume it is a file */if(statbuf.st_type == VDIR)return0;return-1;}/*
libuv/src/unix/fs.c view on Meta::CPAN
uv__free(req->bufs);req->bufs = NULL;req->nbufs = 0;#ifdef __PASE__/* PASE returns EOPNOTSUPPwhenreading a directory, convert to EISDIR */if(result == -1 && errno == EOPNOTSUPP) {structstatbuf;ssize_t rc;rc = fstat(req->file,&buf);if(rc == 0 && S_ISDIR(buf.st_mode)) {errno = EISDIR;}}#endifreturnresult;}
libuv/src/unix/fs.c view on Meta::CPAN
static ssize_t uv__fs_readlink(uv_fs_t* req) {ssize_t maxlen;ssize_t len;char* buf;char* newbuf;#if defined(UV__FS_PATH_MAX_FALLBACK)/* We may not have a real PATH_MAX. Read size oflink. */structstatst;intret;ret =lstat(req->path,&st);if(ret != 0)return-1;if(!S_ISLNK(st.st_mode)) {errno = EINVAL;return-1;}maxlen = st.st_size;/* According toreadlink(2)lstatcan report st_size == 0
libuv/src/unix/fs.c view on Meta::CPAN
err = 0;/* Open the source file. */srcfd = uv_fs_open(NULL,&fs_req, req->path, O_RDONLY, 0, NULL);uv_fs_req_cleanup(&fs_req);if(srcfd < 0)returnsrcfd;/* Get the source file's mode. */if(fstat(srcfd,&statsbuf)) {err = UV__ERR(errno);gotoout;}dst_flags = O_WRONLY | O_CREAT | O_TRUNC;if(req->flags & UV_FS_COPYFILE_EXCL)dst_flags |= O_EXCL;/* Open the destination file. */
libuv/src/unix/fs.c view on Meta::CPAN
}}if(result == 0)return0;errno = UV__ERR(result);return-1;}static void uv__to_stat(structstat* src, uv_stat_t* dst) {dst->st_dev = src->st_dev;dst->st_mode = src->st_mode;dst->st_nlink = src->st_nlink;dst->st_uid = src->st_uid;dst->st_gid = src->st_gid;dst->st_rdev = src->st_rdev;dst->st_ino = src->st_ino;dst->st_size = src->st_size;dst->st_blksize = src->st_blksize;dst->st_blocks = src->st_blocks;
libuv/src/unix/fs.c view on Meta::CPAN
buf->st_birthtim.tv_sec = statxbuf.stx_btime.tv_sec;buf->st_birthtim.tv_nsec = statxbuf.stx_btime.tv_nsec;return0;#elsereturnUV_ENOSYS;#endif /* __linux__ */}staticintuv__fs_stat(const char*path, uv_stat_t*buf) {structstatpbuf;intret;ret = uv__fs_statx(-1, path, /* is_fstat */ 0, /* is_lstat */ 0, buf);if(ret != UV_ENOSYS)returnret;ret =stat(path,&pbuf);if(ret == 0)uv__to_stat(&pbuf, buf);returnret;}staticintuv__fs_lstat(const char*path, uv_stat_t*buf) {structstatpbuf;intret;ret = uv__fs_statx(-1, path, /* is_fstat */ 0, /* is_lstat */ 1, buf);if(ret != UV_ENOSYS)returnret;ret =lstat(path,&pbuf);if(ret == 0)uv__to_stat(&pbuf, buf);returnret;}staticintuv__fs_fstat(intfd, uv_stat_t*buf) {structstatpbuf;intret;ret = uv__fs_statx(fd,"", /* is_fstat */ 1, /* is_lstat */ 0, buf);if(ret != UV_ENOSYS)returnret;ret = fstat(fd,&pbuf);if(ret == 0)uv__to_stat(&pbuf, buf);returnret;}static size_t uv__fs_buf_offset(uv_buf_t* bufs, size_t size) {size_t offset;/* Figure out which bufs are done */for(offset = 0; size > 0 && bufs[offset].len <= size; ++offset)size -= bufs[offset].len;
libuv/src/unix/fs.c view on Meta::CPAN
switch (req->fs_type) {X(ACCESS, access(req->path, req->flags));X(CHMOD,chmod(req->path, req->mode));X(CHOWN,chown(req->path, req->uid, req->gid));X(CLOSE, uv__fs_close(req->file));X(COPYFILE, uv__fs_copyfile(req));X(FCHMOD, fchmod(req->file, req->mode));X(FCHOWN, fchown(req->file, req->uid, req->gid));X(LCHOWN, lchown(req->path, req->uid, req->gid));X(FDATASYNC, uv__fs_fdatasync(req));X(FSTAT, uv__fs_fstat(req->file,&req->statbuf));X(FSYNC, uv__fs_fsync(req));X(FTRUNCATE, ftruncate(req->file, req->off));X(FUTIME, uv__fs_futime(req));X(LSTAT, uv__fs_lstat(req->path,&req->statbuf));X(LINK,link(req->path, req->new_path));X(MKDIR,mkdir(req->path, req->mode));X(MKDTEMP, uv__fs_mkdtemp(req));X(OPEN, uv__fs_open(req));X(READ, uv__fs_read(req));X(SCANDIR, uv__fs_scandir(req));X(OPENDIR, uv__fs_opendir(req));X(READDIR, uv__fs_readdir(req));X(CLOSEDIR, uv__fs_closedir(req));X(READLINK, uv__fs_readlink(req));X(REALPATH, uv__fs_realpath(req));X(RENAME,rename(req->path, req->new_path));X(RMDIR,rmdir(req->path));X(SENDFILE, uv__fs_sendfile(req));X(STAT, uv__fs_stat(req->path,&req->statbuf));X(SYMLINK,symlink(req->path, req->new_path));X(UNLINK,unlink(req->path));X(UTIME, uv__fs_utime(req));X(WRITE, uv__fs_write_all(req));default: abort();}#undef X}while(r == -1 && errno == EINTR && retry_on_eintr);if(r == -1)
libuv/src/unix/fs.c view on Meta::CPAN
}intuv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {INIT(FDATASYNC);req->file = file;POST;}intuv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {INIT(FSTAT);req->file = file;POST;}intuv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {INIT(FSYNC);req->file = file;POST;
libuv/src/unix/fs.c view on Meta::CPAN
double mtime,uv_fs_cb cb) {INIT(FUTIME);req->file = file;req->atime = atime;req->mtime = mtime;POST;}intuv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {INIT(LSTAT);PATH;POST;}intuv_fs_link(uv_loop_t* loop,uv_fs_t* req,const char* path,const char* new_path,
libuv/src/unix/fs.c view on Meta::CPAN
uv_fs_cb cb) {INIT(SENDFILE);req->flags = in_fd; /* hack */req->file = out_fd;req->off = off;req->bufsml[0].len = len;POST;}intuv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {INIT(STAT);PATH;POST;}intuv_fs_symlink(uv_loop_t* loop,uv_fs_t* req,const char* path,const char* new_path,
libuv/src/unix/pipe.c view on Meta::CPAN
if(name_buffer == NULL)returnUV_ENOMEM;r = uv_pipe_getsockname(handle, name_buffer,&name_len);if(r != 0) {uv__free(name_buffer);returnr;}/*statmust be used as fstathasa bug on Darwin */if(stat(name_buffer,&pipe_stat) == -1) {uv__free(name_buffer);return-errno;}desired_mode = 0;if(mode & UV_READABLE)desired_mode |= S_IRUSR | S_IRGRP | S_IROTH;if(mode & UV_WRITABLE)desired_mode |= S_IWUSR | S_IWGRP | S_IWOTH;
libuv/src/unix/tty.c view on Meta::CPAN
/* Lookup device's majorforthe pts driver and cache it. */static devmajor_t pts = NODEVMAJOR;if(pts == NODEVMAJOR) {pts = getdevmajor("pts", S_IFCHR);if(pts == NODEVMAJOR)abort();}/* Lookupstatstructure behind the file descriptor. */if(fstat(fd,&sb) != 0)abort();/* Assert character device. */if(!S_ISCHR(sb.st_mode))abort();/* Assert valid major. */if(major(sb.st_rdev) == NODEVMAJOR)abort();
libuv/src/unix/tty.c view on Meta::CPAN
structstats;socklen_t len;inttype;if(file < 0)returnUV_UNKNOWN_HANDLE;if(isatty(file))returnUV_TTY;if(fstat(file,&s))returnUV_UNKNOWN_HANDLE;if(S_ISREG(s.st_mode))returnUV_FILE;if(S_ISCHR(s.st_mode))returnUV_FILE; /* XXX UV_NAMED_PIPE? */if(S_ISFIFO(s.st_mode))returnUV_NAMED_PIPE;
libuv/src/win/fs.c view on Meta::CPAN
CloseHandle(handle);return;}req->ptr =&req->statbuf;req->result = 0;CloseHandle(handle);}static void fs__stat(uv_fs_t* req) {fs__stat_prepare_path(req->file.pathw);fs__stat_impl(req, 0);}static void fs__lstat(uv_fs_t* req) {fs__stat_prepare_path(req->file.pathw);fs__stat_impl(req, 1);}static void fs__fstat(uv_fs_t* req) {intfd = req->file.fd;HANDLE handle;VERIFY_FD(fd, req);handle = uv__get_osfhandle(fd);if(handle == INVALID_HANDLE_VALUE) {SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);return;
libuv/src/win/fs.c view on Meta::CPAN
INIT(UV_FS_LCHOWN);err = fs__capture_path(req, path, NULL, cb != NULL);if(err) {returnuv_translate_sys_error(err);}POST;}intuv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {interr;INIT(UV_FS_STAT);err = fs__capture_path(req, path, NULL, cb != NULL);if(err) {returnuv_translate_sys_error(err);}POST;}intuv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {interr;INIT(UV_FS_LSTAT);err = fs__capture_path(req, path, NULL, cb != NULL);if(err) {returnuv_translate_sys_error(err);}POST;}intuv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {INIT(UV_FS_FSTAT);req->file.fd = fd;POST;}intuv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path,const char* new_path, uv_fs_cb cb) {interr;
libuv/test/benchmark-fs-stat.c view on Meta::CPAN
#include "task.h"#include "uv.h"#include <stdio.h>#include <stdlib.h>#define NUM_SYNC_REQS (10 * 1e5)#define NUM_ASYNC_REQS (1 * (int) 1e5)#define MAX_CONCURRENT_REQS 32#define sync_stat(req, path) \do{ \uv_fs_stat(NULL, (req), (path), NULL); \uv_fs_req_cleanup((req)); \} \while(0)struct async_req {const char* path;uv_fs_t fs_req;int* count;};static void warmup(const char* path) {uv_fs_t reqs[MAX_CONCURRENT_REQS];unsignedinti;/* warm up the thread pool */for(i = 0; i < ARRAY_SIZE(reqs); i++)uv_fs_stat(uv_default_loop(), reqs + i, path, uv_fs_req_cleanup);uv_run(uv_default_loop(), UV_RUN_DEFAULT);/* warm up the OS dirent cache */for(i = 0; i < 16; i++)sync_stat(reqs + 0, path);}static void sync_bench(const char* path) {uint64_tbefore;uint64_tafter;uv_fs_t req;inti;/*dothe sync benchmark */before= uv_hrtime();for(i = 0; i < NUM_SYNC_REQS; i++)sync_stat(&req, path);after= uv_hrtime();printf("%s stats (sync): %.2fs (%s/s)\n",fmt(1.0 * NUM_SYNC_REQS),(after-before) / 1e9,fmt((1.0 * NUM_SYNC_REQS) / ((after-before) / 1e9)));fflush(stdout);}static void stat_cb(uv_fs_t* fs_req) {struct async_req* req = container_of(fs_req, struct async_req, fs_req);uv_fs_req_cleanup(&req->fs_req);if(*req->count == 0)return;uv_fs_stat(uv_default_loop(),&req->fs_req, req->path, stat_cb);(*req->count)--;}static void async_bench(const char* path) {struct async_req reqs[MAX_CONCURRENT_REQS];struct async_req* req;uint64_tbefore;uint64_tafter;intcount;inti;for(i = 1; i <= MAX_CONCURRENT_REQS; i++) {count = NUM_ASYNC_REQS;for(req = reqs; req < reqs + i; req++) {req->path = path;req->count =&count;uv_fs_stat(uv_default_loop(),&req->fs_req, req->path, stat_cb);}before= uv_hrtime();uv_run(uv_default_loop(), UV_RUN_DEFAULT);after= uv_hrtime();printf("%s stats (%d concurrent): %.2fs (%s/s)\n",fmt(1.0 * NUM_ASYNC_REQS),i,(after-before) / 1e9,fmt((1.0 * NUM_ASYNC_REQS) / ((after-before) / 1e9)));fflush(stdout);}}/* This benchmark aims to measure the overhead of doing I/O syscalls from* the thread pool. Thestat()syscallwas chosen because its results are* easyforthe operatingsystemto cache, taking the actual I/O overhead* out of the equation.*/BENCHMARK_IMPL(fs_stat) {const char path[] =".";warmup(path);sync_bench(path);async_bench(path);MAKE_VALGRIND_HAPPY();return0;
libuv/test/runner-unix.c view on Meta::CPAN
close(args.pipe[1]);returnretval;}/* Returns the number of bytes in the stdio output bufferforprocess `p`. */longintprocess_output_size(process_info_t*p) {/* Size of the p->stdout_file */structstatbuf;intr = fstat(fileno(p->stdout_file),&buf);if(r < 0) {return-1;}return(long)buf.st_size;}/* Copy the contents of the stdio output buffer to `fd`. */intprocess_copy_output(process_info_t* p, FILE* stream) {
libuv/test/test-fs-copyfile.c view on Meta::CPAN
static void handle_result(uv_fs_t* req) {uv_fs_t stat_req;uint64_t size;uint64_t mode;intr;ASSERT(req->fs_type == UV_FS_COPYFILE);ASSERT(req->result == 0);/* Verify that the file size and mode are the same. */r = uv_fs_stat(NULL,&stat_req, req->path, NULL);ASSERT(r == 0);size = stat_req.statbuf.st_size;mode = stat_req.statbuf.st_mode;uv_fs_req_cleanup(&stat_req);r = uv_fs_stat(NULL,&stat_req, dst, NULL);ASSERT(r == 0);ASSERT(stat_req.statbuf.st_size == size);ASSERT(stat_req.statbuf.st_mode == mode);uv_fs_req_cleanup(&stat_req);uv_fs_req_cleanup(req);result_check_count++;}static void touch_file(const char* name, unsignedintsize) {
libuv/test/test-fs-copyfile.c view on Meta::CPAN
uv_fs_req_cleanup(&req);/* FailswithENOENTifsource does not exist. */unlink(src);unlink(dst);r = uv_fs_copyfile(NULL,&req, src, dst, 0, NULL);ASSERT(req.result == UV_ENOENT);ASSERT(r == UV_ENOENT);uv_fs_req_cleanup(&req);/* The destination should not exist. */r = uv_fs_stat(NULL,&req, dst, NULL);ASSERT(r != 0);uv_fs_req_cleanup(&req);/* Copies file synchronously. Creates new file. */unlink(dst);r = uv_fs_copyfile(NULL,&req, fixture, dst, 0, NULL);ASSERT(r == 0);handle_result(&req);/* Copies a file of size zero. */
libuv/test/test-fs-event.c view on Meta::CPAN
loop = uv_default_loop();remove("watch_dir/file1");remove("watch_dir/");create_dir("watch_dir");create_file("watch_dir/file1");/* Newer version of Windows shipwithHKLM\SYSTEM\CurrentControlSet\Control\FileSystem\NtfsDisable8dot3NameCreationnot equal to 0. So we verify the files we created are addressable by a 8.3short name */has_shortnames = uv_fs_stat(NULL,&req,"watch_~1", NULL) != UV_ENOENT;if(has_shortnames) {r = uv_fs_event_init(loop,&fs_event);ASSERT(r == 0);r = uv_fs_event_start(&fs_event, fs_event_cb_dir,"watch_~1", 0);ASSERT(r == 0);r = uv_timer_init(loop,&timer);ASSERT(r == 0);r = uv_timer_start(&timer, timer_cb_file, 100, 0);ASSERT(r == 0);
libuv/test/test-fs.c view on Meta::CPAN
static GUID REPARSE_GUID = {0x1bf6205f, 0x46ae, 0x4527,{ 0xb1, 0x0c, 0xc5, 0x09, 0xb7, 0x55, 0x22, 0x80 }};#endifstatic void check_permission(const char* filename, unsignedintmode) {intr;uv_fs_t req;uv_stat_t* s;r = uv_fs_stat(NULL,&req, filename, NULL);ASSERT(r == 0);ASSERT(req.result == 0);s =&req.statbuf;#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)/** On Windows,chmodcan only modify S_IWUSR (_S_IWRITE) bit,* so only testingforthe specified flags.*/ASSERT((s->st_mode & 0777) & mode);
libuv/test/test-fs.c view on Meta::CPAN
ASSERT(req->fs_type == UV_FS_MKDTEMP);ASSERT(req->result == 0);ASSERT(req->path);ASSERT(strlen(req->path) == 15);ASSERT(memcmp(req->path,"test_dir_", 9) == 0);ASSERT(memcmp(req->path + 9,"XXXXXX", 6) != 0);check_permission(req->path, 0700);/* Checkifreq->path is actually a directory */r = uv_fs_stat(NULL,&stat_req, req->path, NULL);ASSERT(r == 0);ASSERT(((uv_stat_t*)stat_req.ptr)->st_mode & S_IFDIR);uv_fs_req_cleanup(&stat_req);}static void mkdtemp_cb(uv_fs_t* req) {ASSERT(req ==&mkdtemp_req1);check_mkdtemp_result(req);mkdtemp_cb_count++;
libuv/test/test-fs.c view on Meta::CPAN
MAKE_VALGRIND_HAPPY();return0;}static void check_utime(const char* path, double atime, double mtime) {uv_stat_t* s;uv_fs_t req;intr;r = uv_fs_stat(loop,&req, path, NULL);ASSERT(r == 0);ASSERT(req.result == 0);s =&req.statbuf;ASSERT(s->st_atim.tv_sec + (s->st_atim.tv_nsec / 1000000000.0) == atime);ASSERT(s->st_mtim.tv_sec + (s->st_mtim.tv_nsec / 1000000000.0) == mtime);uv_fs_req_cleanup(&req);}
libuv/test/test-fs.c view on Meta::CPAN
ASSERT(r == 2);ASSERT(scandir_req.result == 2);ASSERT(scandir_req.ptr);while(UV_EOF != uv_fs_scandir_next(&scandir_req,&dent)) {ASSERT(strcmp(dent.name,"file1") == 0 || strcmp(dent.name,"file2") == 0);assert_is_file_type(dent);}uv_fs_req_cleanup(&scandir_req);ASSERT(!scandir_req.ptr);r = uv_fs_stat(loop,&stat_req,"test_dir", stat_cb);ASSERT(r == 0);uv_run(loop, UV_RUN_DEFAULT);r = uv_fs_stat(loop,&stat_req,"test_dir/", stat_cb);ASSERT(r == 0);uv_run(loop, UV_RUN_DEFAULT);r = uv_fs_lstat(loop,&stat_req,"test_dir", stat_cb);ASSERT(r == 0);uv_run(loop, UV_RUN_DEFAULT);r = uv_fs_lstat(loop,&stat_req,"test_dir/", stat_cb);ASSERT(r == 0);uv_run(loop, UV_RUN_DEFAULT);ASSERT(stat_cb_count == 4);r = uv_fs_unlink(loop,&unlink_req,"test_dir/file1", unlink_cb);ASSERT(r == 0);uv_run(loop, UV_RUN_DEFAULT);ASSERT(unlink_cb_count == 1);
libuv/test/test-fs.c view on Meta::CPAN
ASSERT(sendfile_cb_count == 1);r = uv_fs_close(NULL,&close_req, open_req1.result, NULL);ASSERT(r == 0);uv_fs_req_cleanup(&close_req);r = uv_fs_close(NULL,&close_req, open_req2.result, NULL);ASSERT(r == 0);uv_fs_req_cleanup(&close_req);stat("test_file",&s1);stat("test_file2",&s2);ASSERT(65546 == s2.st_size && s1.st_size == s2.st_size);/* Cleanup. */unlink("test_file");unlink("test_file2");MAKE_VALGRIND_HAPPY();return0;}
libuv/test/test-fs.c view on Meta::CPAN
ASSERT(req.result >= 0);file = req.result;uv_fs_req_cleanup(&req);iov = uv_buf_init(test_buf, sizeof(test_buf));r = uv_fs_write(NULL,&req, file,&iov, 1, -1, NULL);ASSERT(r == sizeof(test_buf));ASSERT(req.result == sizeof(test_buf));uv_fs_req_cleanup(&req);r = uv_fs_fstat(NULL,&req, file, NULL);ASSERT(r == 0);ASSERT(req.result == 0);s = req.ptr;ASSERT(s->st_size == sizeof(test_buf));#ifndef _WIN32r = fstat(file,&t);ASSERT(r == 0);ASSERT(s->st_dev == (uint64_t) t.st_dev);ASSERT(s->st_mode == (uint64_t) t.st_mode);ASSERT(s->st_nlink == (uint64_t) t.st_nlink);ASSERT(s->st_uid == (uint64_t) t.st_uid);ASSERT(s->st_gid == (uint64_t) t.st_gid);ASSERT(s->st_rdev == (uint64_t) t.st_rdev);ASSERT(s->st_ino == (uint64_t) t.st_ino);ASSERT(s->st_size == (uint64_t) t.st_size);
libuv/test/test-fs.c view on Meta::CPAN
*/ASSERT(s->st_birthtim.tv_sec == 0 ||s->st_birthtim.tv_sec == t.st_ctim.tv_sec);ASSERT(s->st_birthtim.tv_nsec == 0 ||s->st_birthtim.tv_nsec == t.st_ctim.tv_nsec);#endifuv_fs_req_cleanup(&req);/* Nowdothe uv_fs_fstat call asynchronously */r = uv_fs_fstat(loop,&req, file, fstat_cb);ASSERT(r == 0);uv_run(loop, UV_RUN_DEFAULT);ASSERT(fstat_cb_count == 1);r = uv_fs_close(NULL,&req, file, NULL);ASSERT(r == 0);ASSERT(req.result == 0);uv_fs_req_cleanup(&req);
libuv/test/test-fs.c view on Meta::CPAN
if(type == UV_FS_SYMLINK_DIR && (r == UV_ENOTSUP || r == UV_EPERM)) {uv_fs_req_cleanup(&req);RETURN_SKIP("this version of Windows doesn't support unprivileged ""creation of directory symlinks");}fprintf(stderr,"r == %i\n", r);ASSERT(r == 0);ASSERT(req.result == 0);uv_fs_req_cleanup(&req);r = uv_fs_stat(NULL,&req,"test_dir_symlink", NULL);ASSERT(r == 0);ASSERT(((uv_stat_t*)req.ptr)->st_mode & S_IFDIR);uv_fs_req_cleanup(&req);r = uv_fs_lstat(NULL,&req,"test_dir_symlink", NULL);ASSERT(r == 0);#if defined(__MSYS__)RETURN_SKIP("symlink reading is not supported on MSYS2");#endifASSERT(((uv_stat_t*)req.ptr)->st_mode & S_IFLNK);#ifdef _WIN32ASSERT(((uv_stat_t*)req.ptr)->st_size == strlen(test_dir + 4));#elseASSERT(((uv_stat_t*)req.ptr)->st_size == strlen(test_dir));#endif
libuv/test/test-fs.c view on Meta::CPAN
r = uv_fs_readlink(NULL,&req,"test_dir/test_file", NULL);ASSERT(r == UV_EINVAL && GetLastError() == ERROR_SYMLINK_NOT_SUPPORTED);uv_fs_req_cleanup(&req);/*Placeholder testsforexercising the behavior fixed in issue#995.To run, update the pathwiththe IP address of a Macwiththe hard driveshared via SMB as"Macintosh HD".r = uv_fs_stat(NULL,&req,"\\\\<mac_ip>\\Macintosh HD\\.DS_Store", NULL);ASSERT(r == 0);uv_fs_req_cleanup(&req);r = uv_fs_lstat(NULL,&req,"\\\\<mac_ip>\\Macintosh HD\\.DS_Store", NULL);ASSERT(r == 0);uv_fs_req_cleanup(&req);*//*uv_fs_stat and uv_fs_lstat can only work on non-symlinkreparsepointswhena minifilter driver is registered which interceptsassociated filesystem requests. Installing a driver is beyondthe scope of this test.r = uv_fs_stat(NULL,&req,"test_dir/test_file", NULL);ASSERT(r == 0);uv_fs_req_cleanup(&req);r = uv_fs_lstat(NULL,&req,"test_dir/test_file", NULL);ASSERT(r == 0);uv_fs_req_cleanup(&req);*/r = uv_fs_scandir(NULL,&scandir_req,"test_dir", 0, NULL);ASSERT(r == 1);ASSERT(scandir_req.result == 1);ASSERT(scandir_req.ptr);while(UV_EOF != uv_fs_scandir_next(&scandir_req,&dent)) {ASSERT(strcmp(dent.name,"test_file") == 0);
libuv/test/test-fs.c view on Meta::CPAN
*/#ifdef _WIN32mtime += 0.444; /* 1982-09-10 11:22:33.444 */#endifr = uv_fs_utime(NULL,&req, path, atime, mtime, NULL);ASSERT(r == 0);ASSERT(req.result == 0);uv_fs_req_cleanup(&req);r = uv_fs_stat(NULL,&req, path, NULL);ASSERT(r == 0);ASSERT(req.result == 0);check_utime(path, atime, mtime);uv_fs_req_cleanup(&req);atime = mtime = 1291404900; /* 2010-12-03 20:35:00 - mees <3 */checkme.path = path;checkme.atime = atime;checkme.mtime = mtime;
libuv/test/test-fs.c view on Meta::CPAN
MAKE_VALGRIND_HAPPY();return0;}#ifdef _WIN32TEST_IMPL(fs_stat_root) {intr;r = uv_fs_stat(NULL,&stat_req,"\\", NULL);ASSERT(r == 0);r = uv_fs_stat(NULL,&stat_req,"..\\..\\..\\..\\..\\..\\..", NULL);ASSERT(r == 0);r = uv_fs_stat(NULL,&stat_req,"..", NULL);ASSERT(r == 0);r = uv_fs_stat(NULL,&stat_req,"..\\", NULL);ASSERT(r == 0);/* stats the current directory on c: */r = uv_fs_stat(NULL,&stat_req,"c:", NULL);ASSERT(r == 0);r = uv_fs_stat(NULL,&stat_req,"c:\\", NULL);ASSERT(r == 0);r = uv_fs_stat(NULL,&stat_req,"\\\\?\\C:\\", NULL);ASSERT(r == 0);MAKE_VALGRIND_HAPPY();return0;}#endifTEST_IMPL(fs_futime) {utime_check_t checkme;
libuv/test/test-fs.c view on Meta::CPAN
r = uv_fs_futime(NULL,&req, file, atime, mtime, NULL);#if defined(__CYGWIN__) || defined(__MSYS__)ASSERT(r == UV_ENOSYS);RETURN_SKIP("futime not supported on Cygwin");#elseASSERT(r == 0);ASSERT(req.result == 0);#endifuv_fs_req_cleanup(&req);r = uv_fs_stat(NULL,&req, path, NULL);ASSERT(r == 0);ASSERT(req.result == 0);check_utime(path, atime, mtime);uv_fs_req_cleanup(&req);atime = mtime = 1291404900; /* 2010-12-03 20:35:00 - mees <3 */checkme.atime = atime;checkme.mtime = mtime;checkme.path = path;
libuv/test/test-fs.c view on Meta::CPAN
return0;}TEST_IMPL(fs_stat_missing_path) {uv_fs_t req;intr;loop = uv_default_loop();r = uv_fs_stat(NULL,&req,"non_existent_file", NULL);ASSERT(r == UV_ENOENT);ASSERT(req.result == UV_ENOENT);uv_fs_req_cleanup(&req);MAKE_VALGRIND_HAPPY();return0;}TEST_IMPL(fs_scandir_empty_dir) {
libuv/test/test-fs.c view on Meta::CPAN
ASSERT((size_t)read_req.result == sizeof(test_buf) * iovcount);for(index= 0;index< iovcount; ++index)ASSERT(strncmp(buffer +index* sizeof(test_buf),test_buf,sizeof(test_buf)) == 0);uv_fs_req_cleanup(&read_req);free(buffer);r = uv_fs_stat(NULL,&stat_req,"test_file", NULL);ASSERT(r == 0);ASSERT((int64_t)((uv_stat_t*)stat_req.ptr)->st_size ==offset + (int64_t)write_req.result);uv_fs_req_cleanup(&stat_req);iov = uv_buf_init(buf, sizeof(buf));r = uv_fs_read(NULL,&read_req,open_req1.result,&iov,
libuv/test/test-fs.c view on Meta::CPAN
r = uv_fs_realpath(NULL, NULL, NULL, NULL);ASSERT(r == UV_EINVAL);r = uv_fs_chown(NULL, NULL, NULL, 0, 0, NULL);ASSERT(r == UV_EINVAL);r = uv_fs_fchown(NULL, NULL, 0, 0, 0, NULL);ASSERT(r == UV_EINVAL);r = uv_fs_stat(NULL, NULL, NULL, NULL);ASSERT(r == UV_EINVAL);r = uv_fs_lstat(NULL, NULL, NULL, NULL);ASSERT(r == UV_EINVAL);r = uv_fs_fstat(NULL, NULL, 0, NULL);ASSERT(r == UV_EINVAL);r = uv_fs_rename(NULL, NULL, NULL, NULL, NULL);ASSERT(r == UV_EINVAL);r = uv_fs_fsync(NULL, NULL, 0, NULL);ASSERT(r == UV_EINVAL);r = uv_fs_fdatasync(NULL, NULL, 0, NULL);ASSERT(r == UV_EINVAL);
libuv/test/test-getters-setters.c view on Meta::CPAN
ASSERT(uv_stream_get_write_queue_size((uv_stream_t*)pipe) == 0);pipe->write_queue_size++;ASSERT(uv_stream_get_write_queue_size((uv_stream_t*)pipe) == 1);pipe->write_queue_size--;uv_close((uv_handle_t*)pipe, NULL);r = uv_run(loop, UV_RUN_DEFAULT);ASSERT(r == 0);fs = malloc(uv_req_size(UV_FS));uv_fs_stat(loop, fs,".", NULL);r = uv_run(loop, UV_RUN_DEFAULT);ASSERT(r == 0);ASSERT(uv_fs_get_type(fs) == UV_FS_STAT);ASSERT(uv_fs_get_result(fs) == 0);ASSERT(uv_fs_get_ptr(fs) == uv_fs_get_statbuf(fs));ASSERT(uv_fs_get_statbuf(fs)->st_mode & S_IFDIR);ASSERT(strcmp(uv_fs_get_path(fs),".") == 0);uv_fs_req_cleanup(fs);
libuv/test/test-pipe-set-fchmod.c view on Meta::CPAN
/* No easy way to testifthis works, we will only make sure that the call is* successful. */r = uv_pipe_chmod(&pipe_handle, UV_READABLE);if(r == UV_EPERM) {MAKE_VALGRIND_HAPPY();RETURN_SKIP("Insufficient privileges to alter pipe fmode");}ASSERT(r == 0);#ifndef _WIN32stat(TEST_PIPENAME,&stat_buf);ASSERT(stat_buf.st_mode & S_IRUSR);ASSERT(stat_buf.st_mode & S_IRGRP);ASSERT(stat_buf.st_mode & S_IROTH);#endifr = uv_pipe_chmod(&pipe_handle, UV_WRITABLE);ASSERT(r == 0);#ifndef _WIN32stat(TEST_PIPENAME,&stat_buf);ASSERT(stat_buf.st_mode & S_IWUSR);ASSERT(stat_buf.st_mode & S_IWGRP);ASSERT(stat_buf.st_mode & S_IWOTH);#endifr = uv_pipe_chmod(&pipe_handle, UV_WRITABLE | UV_READABLE);ASSERT(r == 0);#ifndef _WIN32stat(TEST_PIPENAME,&stat_buf);ASSERT(stat_buf.st_mode & S_IRUSR);ASSERT(stat_buf.st_mode & S_IRGRP);ASSERT(stat_buf.st_mode & S_IROTH);ASSERT(stat_buf.st_mode & S_IWUSR);ASSERT(stat_buf.st_mode & S_IWGRP);ASSERT(stat_buf.st_mode & S_IWOTH);#endifr = uv_pipe_chmod(NULL, UV_WRITABLE | UV_READABLE);ASSERT(r == UV_EBADF);
libuv/test/test-thread.c view on Meta::CPAN
uv_freeaddrinfo(res);if(--req->counter)getaddrinfo_do(req);}static void fs_do(struct fs_req* req) {intr;r = uv_fs_stat(req->loop,&req->handle,".", fs_cb);ASSERT(r == 0);}static void fs_cb(uv_fs_t* handle) {struct fs_req* req = container_of(handle, struct fs_req, handle);uv_fs_req_cleanup(handle);if(--req->counter)
libuv/test/test-threadpool-cancel.c view on Meta::CPAN
iov = uv_buf_init(NULL, 0);/* Needs to match ARRAY_SIZE(fs_reqs). */n = 0;ASSERT(0 == uv_fs_chmod(loop, reqs + n++,"/", 0, fs_cb));ASSERT(0 == uv_fs_chown(loop, reqs + n++,"/", 0, 0, fs_cb));ASSERT(0 == uv_fs_close(loop, reqs + n++, 0, fs_cb));ASSERT(0 == uv_fs_fchmod(loop, reqs + n++, 0, 0, fs_cb));ASSERT(0 == uv_fs_fchown(loop, reqs + n++, 0, 0, 0, fs_cb));ASSERT(0 == uv_fs_fdatasync(loop, reqs + n++, 0, fs_cb));ASSERT(0 == uv_fs_fstat(loop, reqs + n++, 0, fs_cb));ASSERT(0 == uv_fs_fsync(loop, reqs + n++, 0, fs_cb));ASSERT(0 == uv_fs_ftruncate(loop, reqs + n++, 0, 0, fs_cb));ASSERT(0 == uv_fs_futime(loop, reqs + n++, 0, 0, 0, fs_cb));ASSERT(0 == uv_fs_link(loop, reqs + n++,"/","/", fs_cb));ASSERT(0 == uv_fs_lstat(loop, reqs + n++,"/", fs_cb));ASSERT(0 == uv_fs_mkdir(loop, reqs + n++,"/", 0, fs_cb));ASSERT(0 == uv_fs_open(loop, reqs + n++,"/", 0, 0, fs_cb));ASSERT(0 == uv_fs_read(loop, reqs + n++, 0,&iov, 1, 0, fs_cb));ASSERT(0 == uv_fs_scandir(loop, reqs + n++,"/", 0, fs_cb));ASSERT(0 == uv_fs_readlink(loop, reqs + n++,"/", fs_cb));ASSERT(0 == uv_fs_realpath(loop, reqs + n++,"/", fs_cb));ASSERT(0 == uv_fs_rename(loop, reqs + n++,"/","/", fs_cb));ASSERT(0 == uv_fs_mkdir(loop, reqs + n++,"/", 0, fs_cb));ASSERT(0 == uv_fs_sendfile(loop, reqs + n++, 0, 0, 0, 0, fs_cb));ASSERT(0 == uv_fs_stat(loop, reqs + n++,"/", fs_cb));ASSERT(0 == uv_fs_symlink(loop, reqs + n++,"/","/", 0, fs_cb));ASSERT(0 == uv_fs_unlink(loop, reqs + n++,"/", fs_cb));ASSERT(0 == uv_fs_utime(loop, reqs + n++,"/", 0, 0, fs_cb));ASSERT(0 == uv_fs_write(loop, reqs + n++, 0,&iov, 1, 0, fs_cb));ASSERT(n == ARRAY_SIZE(reqs));ASSERT(0 == uv_timer_init(loop,&ci.timer_handle));ASSERT(0 == uv_timer_start(&ci.timer_handle, timer_cb, 10, 0));ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));ASSERT(n == fs_cb_called);
( run in 0.562 second using v1.01-cache-2.11-cpan-3fc6ead820a )