text
stringlengths 0
601k
|
|---|
let create ? buf_len ( ? syscall = ` Per_cycle ) ? buffer_age_limit ( ? raise_when_consumer_leaves = true ) ( ? line_ending = Line_ending . Unix ) ? time_source fd = let time_source = match time_source with | Some x -> Time_source . read_only x | None -> Time_source . wall_clock ( ) in let buffer_age_limit = match buffer_age_limit with | Some z -> z | None -> ( match Fd . kind fd with | File -> ` Unlimited | Char | Fifo | Socket _ -> ` At_most ( Time . Span . of_min 2 . ) ) in let buf_len = match buf_len with | None -> 65 * 1024 * 2 | Some buf_len -> if buf_len <= 0 then invalid_arg " Writer . create : buf_len <= 0 " else buf_len in let id = Id . create ( ) in let monitor = Monitor . create ( ) ? name ( : if am_running_inline_test then Some " Writer . monitor " else None ) in let inner_monitor = Monitor . create ( ) ? name ( : if am_running_inline_test then Some " Writer . inner_monitor " else None ) in let consumer_left = Ivar . create ( ) in let open_flags = try_with ( fun ( ) -> Unix . fcntl_getfl fd ) in let t = { id ; fd ; syscall ; monitor ; inner_monitor ; buf = Bigstring . create buf_len ; back = 0 ; scheduled_back = 0 ; scheduled = Deque . create ( ) ; scheduled_bytes = 0 ; bytes_received = Int63 . zero ; bytes_written = Int63 . zero ; time_source ; flushes = Queue . create ( ) ; background_writer_state = ` Not_running ; background_writer_stopped = Ivar . create ( ) ; close_state = ` Open ; close_finished = Ivar . create ( ) ; close_started = Ivar . create ( ) ; producers_to_flush_at_close = Bag . create ( ) ; flush_at_shutdown_elt = None ; check_buffer_age = Check_buffer_age . dummy ; consumer_left ; raise_when_consumer_leaves ; open_flags ; line_ending ; backing_out_channel = None } in Monitor . detach_and_iter_errors inner_monitor ~ f ( : fun ( exn : Exn . t ) -> Monitor . send_exn monitor ( Exn . create_s [ % message " Writer error from inner_monitor " ~ _ ( : Monitor . extract_exn exn : Exn . t ) ~ writer ( : t : t_internals ) ] ) ) ; t . check_buffer_age <- Check_buffer_age . create t ~ maximum_age : buffer_age_limit ; t . flush_at_shutdown_elt <- Some ( Bag . add writers_to_flush_at_shutdown t ) ; t ; ; |
let set_buffer_age_limit t maximum_age = Check_buffer_age . destroy t . check_buffer_age ; t . check_buffer_age <- Check_buffer_age . create t ~ maximum_age ; ; |
let of_out_channel oc kind = create ( Fd . of_out_channel oc kind ) |
let can_write t = match t . close_state with | ` Open | ` Closed_and_flushing -> true | ` Closed -> false ; ; |
let ensure_can_write t = if not ( can_write t ) then raise_s [ % message " attempt to use closed writer " ~ _ ( : t : t ) ] ; ; |
let open_file ( ? append = false ) ? buf_len ? syscall ( ? perm = 0o666 ) ? line_ending ? time_source file = let mode = [ ` Wronly ; ` Creat ] in let mode = ( if append then ` Append else ` Trunc ) :: mode in Unix . openfile file ~ mode ~ perm >>| create ? buf_len ? syscall ? line_ending ? time_source ; ; |
let with_close t ~ f = Monitor . protect f ~ finally ( : fun ( ) -> close t ) |
let with_writer_exclusive t f = let % bind ( ) = Unix . lockf t . fd Exclusive in Monitor . protect f ~ finally ( : fun ( ) -> let % map ( ) = flushed t in Unix . unlockf t . fd ) ; ; |
let with_file ? perm ? append ? syscall ( ? exclusive = false ) ? line_ending ? time_source file ~ f = let % bind t = open_file ? perm ? append ? syscall ? line_ending ? time_source file in with_close t ~ f ( : fun ( ) -> if exclusive then with_writer_exclusive t ( fun ( ) -> f t ) else f t ) ; ; |
let got_bytes t n = t . bytes_received <- Int63 . ( t . bytes_received + of_int n ) |
let add_iovec t kind ( iovec : _ IOVec . t ) ~ count_bytes_as_received = assert ( t . scheduled_back = t . back ) ; if count_bytes_as_received then got_bytes t iovec . len ; if not ( is_stopped_permanently t ) then ( t . scheduled_bytes <- t . scheduled_bytes + iovec . len ; Deque . enqueue_back t . scheduled ( iovec , kind ) ) ; assert ( t . scheduled_back = t . back ) ; ; |
let schedule_unscheduled t kind = let need_to_schedule = t . back - t . scheduled_back in assert ( need_to_schedule >= 0 ) ; if need_to_schedule > 0 then ( let pos = t . scheduled_back in t . scheduled_back <- t . back ; add_iovec t kind ( IOVec . of_bigstring t . buf ~ pos ~ len : need_to_schedule ) ~ count_bytes_as_received : false ) ; ; |
let dummy_iovec = IOVec . empty IOVec . bigstring_kind |
let mk_iovecs t = schedule_unscheduled t Keep ; let n_iovecs = Int . min ( Deque . length t . scheduled ) ( Lazy . force IOVec . max_iovecs ) in let iovecs = Array . create ~ len : n_iovecs dummy_iovec in let contains_mmapped_ref = ref false in let iovecs_len = ref 0 in with_return ( fun r -> let i = ref 0 in Deque . iter t . scheduled ~ f ( : fun ( iovec , _ ) -> if ! i >= n_iovecs then r . return ( ) ; if ( not ! contains_mmapped_ref ) && Bigstring . is_mmapped iovec . buf then contains_mmapped_ref := true ; iovecs_len := ! iovecs_len + iovec . len ; iovecs . ( ! i ) <- iovec ; incr i ) ) ; iovecs , ! contains_mmapped_ref , ! iovecs_len ; ; |
let is_running = function | ` Running -> true | _ -> false ; ; |
let fd_closed t = if not ( is_closed t ) then die t [ % message " writer fd unexpectedly closed " ] ; ; |
let rec start_write t = if debug then Debug . log " Writer . start_write " t [ % sexp_of : t ] ; assert ( is_running t . background_writer_state ) ; let iovecs , contains_mmapped , iovecs_len = mk_iovecs t in let handle_write_result = function | ` Already_closed -> fd_closed t | ` Ok n -> if n >= 0 then write_finished t n else die t [ % message " write system call returned negative result " ( n : int ) ] | ` Error ( Unix . Unix_error ( ( EWOULDBLOCK | EAGAIN ) , _ , _ ) ) -> write_when_ready t | ` Error ( Unix . Unix_error ( EBADF , _ , _ ) ) -> die t [ % message " write got EBADF " ] | ` Error ( Unix . Unix_error ( ( EPIPE | ECONNRESET | EHOSTUNREACH | ENETDOWN | ENETRESET | ENETUNREACH | ETIMEDOUT ) , _ , _ ) as exn ) -> assert ( Ivar . is_empty t . consumer_left ) ; Ivar . fill t . consumer_left ( ) ; if t . raise_when_consumer_leaves then ( stop_permanently t Error ; raise exn ) else stop_permanently t Consumer_left | ` Error exn -> die t [ % message " " ~ _ ( : exn : Exn . t ) ] in let should_write_in_thread = ( not ( Fd . supports_nonblock t . fd ) ) || iovecs_len > thread_io_cutoff || contains_mmapped in if should_write_in_thread then Fd . syscall_in_thread t . fd ~ name " : writev " ( fun file_descr -> Bigstring_unix . writev file_descr iovecs ) >>> handle_write_result else handle_write_result ( Fd . syscall t . fd ~ nonblocking : true ( fun file_descr -> Bigstring_unix . writev_assume_fd_is_nonblocking file_descr iovecs ) ) if debug then Debug . log " Writer . write_when_ready " t [ % sexp_of : t ] ; assert ( is_running t . background_writer_state ) ; Fd . ready_to t . fd ` Write >>> function | ` Bad_fd -> die t [ % message " writer ready_to got Bad_fd " ] | ` Closed -> fd_closed t | ` Ready -> start_write t if debug then Debug . log " Writer . write_finished " ( bytes_written , t ) [ % sexp_of : int * t ] ; assert ( is_running t . background_writer_state ) ; let int63_bytes_written = Int63 . of_int bytes_written in Io_stats . update io_stats ~ kind ( : Fd . kind t . fd ) ~ bytes : int63_bytes_written ; t . bytes_written <- Int63 . ( int63_bytes_written + t . bytes_written ) ; if Int63 . ( t . bytes_written > t . bytes_received ) then die t [ % message " writer wrote more bytes than it received " ] ; fill_flushes t ; t . scheduled_bytes <- t . scheduled_bytes - bytes_written ; let rec remove_done bytes_written = assert ( bytes_written >= 0 ) ; match Deque . dequeue_front t . scheduled with | None -> if bytes_written > 0 then die t [ % message " writer wrote nonzero amount but IO_queue is empty " ] | Some ( { buf ; pos ; len } , kind ) -> if bytes_written >= len then ( ( match kind with | Destroy -> Bigstring . unsafe_destroy buf | Keep -> ( ) ) ; remove_done ( bytes_written - len ) ) else ( let new_iovec = IOVec . of_bigstring buf ~ pos ( : pos + bytes_written ) ~ len ( : len - bytes_written ) in Deque . enqueue_front t . scheduled ( new_iovec , kind ) ) in remove_done bytes_written ; schedule_unscheduled t Keep ; if Deque . is_empty t . scheduled then ( t . back <- 0 ; t . scheduled_back <- 0 ; t . background_writer_state <- ` Not_running ) else ( match t . syscall with | ` Per_cycle -> write_when_ready t | ` Periodic span -> Time_source . after t . time_source ( Time_ns . Span . of_span_float_round_nearest span ) >>> fun _ -> start_write t ) ; ; |
let maybe_start_writer t = match t . background_writer_state with | ` Stopped_permanently _ | ` Running -> ( ) | ` Not_running -> if bytes_to_write t > 0 then ( t . background_writer_state <- ` Running ; schedule ~ monitor : t . inner_monitor ~ priority : Priority . low ( fun ( ) -> t . open_flags >>> fun open_flags -> let can_write_fd = match open_flags with | Error _ -> false | Ok flags -> Unix . Open_flags . can_write flags in if not can_write_fd then die t [ % message " not allowed to write due to file - descriptor flags " ( open_flags : open_flags ) ] ; start_write t ) ) ; ; |
let give_buf t desired = assert ( desired > 0 ) ; assert ( not ( is_stopped_permanently t ) ) ; got_bytes t desired ; let buf_len = Bigstring . length t . buf in let available = buf_len - t . back in if desired <= available then ( let pos = t . back in t . back <- t . back + desired ; t . buf , pos ) else if desired > buf_len / 2 then ( schedule_unscheduled t Keep ; let buf = Bigstring . create desired in add_iovec t Destroy ( IOVec . of_bigstring ~ len : desired buf ) ~ count_bytes_as_received : false ; buf , 0 ) else ( schedule_unscheduled t Destroy ; let buf = Bigstring . create buf_len in t . buf <- buf ; t . scheduled_back <- 0 ; t . back <- desired ; buf , 0 ) ; ; |
let write_gen_internal ( type a ) t src ~ src_pos ~ src_len ~ allow_partial_write ( ~ blit_to_bigstring : ( a , Bigstring . t ) Blit . blit ) = if is_stopped_permanently t then got_bytes t src_len else ( match t . backing_out_channel with | Some backing_out_channel -> got_bytes t src_len ; Backing_out_channel . output backing_out_channel ~ blit_to_bigstring ~ src ~ src_len ~ src_pos ; t . bytes_written <- Int63 . ( t . bytes_written + of_int src_len ) | None -> let available = Bigstring . length t . buf - t . back in if available >= src_len then ( got_bytes t src_len ; let dst_pos = t . back in t . back <- dst_pos + src_len ; blit_to_bigstring ~ src ~ src_pos ~ len : src_len ~ dst : t . buf ~ dst_pos ) else if allow_partial_write then ( got_bytes t available ; let dst_pos = t . back in t . back <- dst_pos + available ; blit_to_bigstring ~ src ~ src_pos ~ len : available ~ dst : t . buf ~ dst_pos ; let remaining = src_len - available in let dst , dst_pos = give_buf t remaining in blit_to_bigstring ~ src ~ src_pos ( : src_pos + available ) ~ len : remaining ~ dst ~ dst_pos ) else ( let dst , dst_pos = give_buf t src_len in blit_to_bigstring ~ src ~ src_pos ~ dst ~ dst_pos ~ len : src_len ) ; maybe_start_writer t ) ; ; |
let write_direct t ~ f = if is_stopped_permanently t then None else ( let pos = t . back in let len = Bigstring . length t . buf - pos in let x , written = f t . buf ~ pos ~ len in if written < 0 || written > len then raise_s [ % message " [ write_direct ] ' s [ ~ f ] argument returned invalid [ written ] " ( written : int ) ( len : int ) ~ writer ( : t : t ) ] ; t . back <- pos + written ; got_bytes t written ; maybe_start_writer t ; Some x ) ; ; |
let write_gen_unchecked ? pos ? len t src ~ blit_to_bigstring ~ length = let src_pos , src_len = Ordered_collection_common . get_pos_len_exn ( ) ? pos ? len ~ total_length ( : length src ) in write_gen_internal t src ~ src_pos ~ src_len ~ allow_partial_write : true ~ blit_to_bigstring ; ; |
let write_gen_whole_unchecked t src ~ blit_to_bigstring ~ length = let src_len = length src in write_gen_internal t src ~ src_pos : 0 ~ src_len ~ allow_partial_write : false ~ blit_to_bigstring ( : fun ~ src ~ src_pos ~ dst ~ dst_pos ~ len -> assert ( src_pos = 0 ) ; assert ( len = src_len ) ; blit_to_bigstring src dst ~ pos : dst_pos ) ; ; |
let write_bytes ? pos ? len t src = write_gen_unchecked ? pos ? len t src ~ blit_to_bigstring : Bigstring . From_bytes . blit ~ length : Bytes . length ; ; |
let write ? pos ? len t src = write_gen_unchecked ? pos ? len t src ~ blit_to_bigstring : Bigstring . From_string . blit ~ length : String . length ; ; |
let write_bigstring ? pos ? len t src = write_gen_unchecked ? pos ? len t src ~ blit_to_bigstring : Bigstring . blit ~ length : Bigstring . length ; ; |
let write_iobuf ? pos ? len t iobuf = let iobuf = Iobuf . read_only ( Iobuf . no_seek iobuf ) in write_gen_unchecked ? pos ? len t iobuf ~ blit_to_bigstring : Iobuf . Peek . To_bigstring . blit ~ length : Iobuf . length ; ; |
let write_substring t substring = write_bytes t ( Substring . base substring ) ~ pos ( : Substring . pos substring ) ~ len ( : Substring . length substring ) ; ; |
let write_bigsubstring t bigsubstring = write_bigstring t ( Bigsubstring . base bigsubstring ) ~ pos ( : Bigsubstring . pos bigsubstring ) ~ len ( : Bigsubstring . length bigsubstring ) ; ; |
let writef t = ksprintf ( fun s -> write t s ) |
let write_gen ? pos ? len t src ~ blit_to_bigstring ~ length = try write_gen_unchecked ? pos ? len t src ~ blit_to_bigstring ~ length with | exn -> die t [ % message " Writer . write_gen : error writing value " ( exn : exn ) ] ; ; |
let write_gen_whole t src ~ blit_to_bigstring ~ length = try write_gen_whole_unchecked t src ~ blit_to_bigstring ~ length with | exn -> die t [ % message " Writer . write_gen_whole : error writing value " ( exn : exn ) ] ; ; |
let to_formatter t = Format . make_formatter ( fun str pos len -> let str = Bytes . of_string str in ensure_can_write t ; write_substring t ( Substring . create str ~ pos ~ len ) ) ignore ; ; |
let write_char t c = if is_stopped_permanently t then got_bytes t 1 else ( match t . backing_out_channel with | Some backing_out_channel -> got_bytes t 1 ; Backing_out_channel . output_char backing_out_channel c ; t . bytes_written <- Int63 . ( t . bytes_written + of_int 1 ) | None -> if Bigstring . length t . buf - t . back >= 1 then ( got_bytes t 1 ; t . buf . { t . back } <- c ; t . back <- t . back + 1 ) else ( let dst , dst_pos = give_buf t 1 in dst . { dst_pos } <- c ) ; maybe_start_writer t ) ; ; |
let newline ? line_ending t = let line_ending = match line_ending with | Some x -> x | None -> t . line_ending in ( match line_ending with | Unix -> ( ) | Dos -> write_char t ' \ r ' ) ; write_char t ' \ n ' ; ; |
let write_line ? line_ending t s = write t s ; newline t ? line_ending ; ; |
let write_byte t i = write_char t ( char_of_int ( i % 256 ) ) |
module Terminate_with = struct type t = | Newline | Space_if_needed [ @@ deriving sexp_of ] end |
let write_sexp_internal = let initial_size = 10 * 1024 in let buffer = lazy ( Buffer . create initial_size ) in let blit_str = ref ( Bytes . create 0 ) in fun ( ~ terminate_with : Terminate_with . t ) ( ? hum = false ) t sexp -> let buffer = Lazy . force buffer in Buffer . clear buffer ; if hum then Sexp . to_buffer_hum ~ buf : buffer ~ indent :! Sexp . default_indent sexp else Sexp . to_buffer ~ buf : buffer sexp ; let len = Buffer . length buffer in let blit_str_len = Bytes . length ! blit_str in if len > blit_str_len then blit_str := Bytes . create ( max len ( max initial_size ( 2 * blit_str_len ) ) ) ; Buffer . blit ~ src : buffer ~ src_pos : 0 ~ dst :! blit_str ~ dst_pos : 0 ~ len ; write_bytes t ! blit_str ~ len ; match terminate_with with | Newline -> newline t | Space_if_needed -> let c = Bytes . get ! blit_str 0 in if not Char . O . ( c = ' ( ' || c = ' " ' ) then write_char t ' ' ; ; |
let write_sexp ? hum ( ? terminate_with = Terminate_with . Space_if_needed ) t sexp = write_sexp_internal t sexp ? hum ~ terminate_with ; ; |
let write_bin_prot t ( writer : _ Bin_prot . Type_class . writer ) v = let len = writer . size v in assert ( len > 0 ) ; let tot_len = len + Bin_prot . Utils . size_header_length in if is_stopped_permanently t then got_bytes t tot_len else ( let buf , start_pos = give_buf t tot_len in ignore ( Bigstring . write_bin_prot buf ~ pos : start_pos writer v : int ) ; maybe_start_writer t ) ; ; |
let write_bin_prot_no_size_header t ~ size write v = if is_stopped_permanently t then got_bytes t size else ( let buf , start_pos = give_buf t size in let end_pos = write buf ~ pos : start_pos v in let written = end_pos - start_pos in if written <> size then raise_s [ % message " Writer . write_bin_prot_no_size_header bug " ! ( written : int ) ( size : int ) ] ; maybe_start_writer t ) ; ; |
let send t s = write t ( string_of_int ( String . length s ) ^ " \ n " ) ; write t s ; ; |
let schedule_iovec ( ? destroy_or_keep = Destroy_or_keep . Keep ) t iovec = schedule_unscheduled t Keep ; add_iovec t destroy_or_keep iovec ~ count_bytes_as_received : true ; maybe_start_writer t ; ; |
let schedule_iovecs t iovecs = schedule_unscheduled t Keep ; Queue . iter iovecs ~ f ( : add_iovec t Keep ~ count_bytes_as_received : true ) ; Queue . clear iovecs ; maybe_start_writer t ; ; |
let schedule_bigstring ? destroy_or_keep t ? pos ? len bstr = schedule_iovec t ( IOVec . of_bigstring ? pos ? len bstr ) ? destroy_or_keep ; ; |
let schedule_bigsubstring t bigsubstring = schedule_bigstring t ( Bigsubstring . base bigsubstring ) ~ pos ( : Bigsubstring . pos bigsubstring ) ~ len ( : Bigsubstring . length bigsubstring ) ; ; |
let schedule_iobuf_peek t ? pos ? len iobuf = schedule_iovec t ( Iobuf_unix . Expert . to_iovec_shared ? pos ? len iobuf ) ; ; |
let schedule_iobuf_consume t ? len iobuf = let iovec = Iobuf_unix . Expert . to_iovec_shared ? len iobuf in let len = iovec . len in schedule_iovec t iovec ; let % map _ = flushed_time t in Iobuf . advance iobuf len ; ; |
let fsync t = ensure_can_write t ; let % bind ( ) = flushed t in Unix . fsync t . fd ; ; |
let fdatasync t = ensure_can_write t ; let % bind ( ) = flushed t in Unix . fdatasync t . fd ; ; |
let write_bin_prot t sw_arg v = ensure_can_write t ; write_bin_prot t sw_arg v ; ; |
let send t s = ensure_can_write t ; send t s ; ; |
let schedule_iovec ? destroy_or_keep t iovec = ensure_can_write t ; schedule_iovec ? destroy_or_keep t iovec ; ; |
let schedule_iovecs t iovecs = ensure_can_write t ; schedule_iovecs t iovecs ; ; |
let schedule_bigstring t ? pos ? len bstr = ensure_can_write t ; schedule_bigstring t ? pos ? len bstr ; ; |
let schedule_bigsubstring t bigsubstring = ensure_can_write t ; schedule_bigsubstring t bigsubstring ; ; |
let schedule_iobuf_peek t ? pos ? len iobuf = ensure_can_write t ; schedule_iobuf_peek t ? pos ? len iobuf ; ; |
let schedule_iobuf_consume t ? len iobuf = ensure_can_write t ; schedule_iobuf_consume t ? len iobuf ; ; |
let write_gen ? pos ? len t src ~ blit_to_bigstring ~ length = ensure_can_write t ; write_gen ? pos ? len t src ~ blit_to_bigstring ~ length ; ; |
let write_bytes ? pos ? len t s = ensure_can_write t ; write_bytes ? pos ? len t s ; ; |
let write ? pos ? len t s = ensure_can_write t ; write ? pos ? len t s ; ; |
let write_line ? line_ending t s = ensure_can_write t ; write_line t s ? line_ending ; ; |
let writef t = ensure_can_write t ; writef t ; ; |
let write_sexp ? hum ? terminate_with t s = ensure_can_write t ; write_sexp ? hum ? terminate_with t s ; ; |
let write_iobuf ? pos ? len t iobuf = ensure_can_write t ; write_iobuf ? pos ? len t iobuf ; ; |
let write_bigstring ? pos ? len t src = ensure_can_write t ; write_bigstring ? pos ? len t src ; ; |
let write_bigsubstring t s = ensure_can_write t ; write_bigsubstring t s ; ; |
let write_substring t s = ensure_can_write t ; write_substring t s ; ; |
let write_byte t b = ensure_can_write t ; write_byte t b ; ; |
let write_char t c = ensure_can_write t ; write_char t c ; ; |
let newline ? line_ending t = ensure_can_write t ; newline ? line_ending t ; ; |
let stdout_and_stderr = lazy ( match Scheduler . within_v ~ monitor : Monitor . main ( fun ( ) -> let stdout = Fd . stdout ( ) in let stderr = Fd . stderr ( ) in let t = create stdout in let dev_and_ino fd = let stats = Core . Unix . fstat ( Fd . file_descr_exn fd ) in stats . st_dev , stats . st_ino in match am_test_runner with | true -> set_backing_out_channel t ( Backing_out_channel . of_out_channel Out_channel . stdout ) ; t , t | false -> if [ % compare . equal : int * int ] ( dev_and_ino stdout ) ( dev_and_ino stderr ) then t , t else t , create stderr ) with | None -> raise_s [ % message [ % here ] " unable to create stdout / stderr " ] | Some v -> v ) ; ; |
let stdout = lazy ( fst ( Lazy . force stdout_and_stderr ) ) |
let stderr = lazy ( snd ( Lazy . force stdout_and_stderr ) ) |
let use_synchronous_stdout_and_stderr ( ) = let stdout , stderr = Lazy . force stdout_and_stderr in let ts_and_channels = ( stdout , Out_channel . stdout ) :: ( match phys_equal stdout stderr with | true -> [ ] | false -> [ stderr , Out_channel . stderr ] ) in List . map ts_and_channels ~ f ( : fun ( t , out_channel ) -> set_synchronous_out_channel t out_channel ) |> Deferred . all_unit ; ; print_s [ % message ( Lazy . is_val stdout : bool ) ] ; [ % expect { | ( " Lazy . is_val stdout " false ) } ] ; | print_s [ % message ( Lazy . is_val stderr : bool ) ] ; [ % expect { | ( " Lazy . is_val stderr " false ) } ] ; | let module U = Core . Unix in let saved_stderr = U . dup U . stderr in let pipe_r , pipe_w = U . pipe ( ) in U . dup2 ~ src : pipe_w ~ dst : U . stderr ( ) ; U . close pipe_r ; U . close pipe_w ; let stdout = Lazy . force stdout in let stderr = Lazy . force stderr in U . dup2 ~ src : saved_stderr ~ dst : U . stderr ( ) ; U . close saved_stderr ; print_s [ % message ( phys_equal stdout stderr : bool ) ] ; [ % expect { | ( " phys_equal stdout stderr " true ) } ] | ; ; |
let behave_nicely_in_pipeline ? writers ( ) = let writers = match writers with | Some z -> z | None -> List . map [ stdout ; stderr ] ~ f : force in List . iter writers ~ f ( : fun writer -> set_buffer_age_limit writer ` Unlimited ; set_raise_when_consumer_leaves writer false ; don ' t_wait_for ( let % map ( ) = consumer_left writer in Shutdown . shutdown 0 ) ) ; ; |
let with_file_atomic ? temp_file ? perm ? fsync ( : do_fsync = false ) ? time_source file ~ f = let % bind current_file_permissions = match % map Monitor . try_with ( fun ( ) -> Unix . stat file ) with | Ok stats -> Some stats . perm | Error _ -> None in let initial_permissions = match perm with | Some p -> p | None -> ( match current_file_permissions with | None -> 0o666 | Some p -> p ) in let % bind temp_file , fd = let temp_file = Option . value temp_file ~ default : file in let % map temp_file , fd = let dir = Filename . dirname temp_file in let prefix = Filename . basename temp_file in In_thread . run ( fun ( ) -> Core . Filename . open_temp_file_fd ~ perm : initial_permissions ~ in_dir : dir prefix " " ) in temp_file , Fd . create File fd ( Info . of_string temp_file ) in let t = create ? time_source fd in let % bind result = with_close t ~ f ( : fun ( ) -> let % bind result = f t in if is_closed t then raise_s [ % message " Writer . with_file_atomic : writer closed by [ f ] " ~ _ ( : file : string ) ] ; let % bind ( ) = match current_file_permissions with | None -> return ( ) | Some _ -> Unix . fchmod fd ~ perm : initial_permissions in let % map ( ) = if do_fsync then fsync t else return ( ) in result ) in match % bind Monitor . try_with ( fun ( ) -> Unix . rename ~ src : temp_file ~ dst : file ) with | Ok ( ) -> return result | Error exn -> let fail v sexp_of_v = raise_s [ % message " Writer . with_file_atomic could not create file " ( file : string ) ~ _ ( : v : v ) ] in ( match % map Monitor . try_with ( fun ( ) -> Unix . unlink temp_file ) with | Ok ( ) -> fail exn [ % sexp_of : exn ] | Error exn2 -> fail ( exn , ` Cleanup_failed exn2 ) [ % sexp_of : exn * [ ` Cleanup_failed of exn ] ] ) ; ; |
let save ? temp_file ? perm ? fsync file ~ contents = with_file_atomic ? temp_file ? perm ? fsync file ~ f ( : fun t -> write t contents ; return ( ) ) ; ; |
let save_lines ? temp_file ? perm ? fsync file lines = with_file_atomic ? temp_file ? perm ? fsync file ~ f ( : fun t -> List . iter lines ~ f ( : fun line -> write t line ; newline t ) ; return ( ) ) ; ; |
let save_sexp ? temp_file ? perm ? fsync ( ? hum = true ) file sexp = with_file_atomic ? temp_file ? perm ? fsync file ~ f ( : fun t -> write_sexp_internal t sexp ~ hum ~ terminate_with : Newline ; return ( ) ) ; ; |
let save_sexps ? temp_file ? perm ? fsync ( ? hum = true ) file sexps = with_file_atomic ? temp_file ? perm ? fsync file ~ f ( : fun t -> List . iter sexps ~ f ( : fun sexp -> write_sexp_internal t sexp ~ hum ~ terminate_with : Newline ) ; return ( ) ) ; ; |
let save_bin_prot ? temp_file ? perm ? fsync file bin_writer a = with_file_atomic ? temp_file ? perm ? fsync file ~ f ( : fun t -> write_bin_prot t bin_writer a ; return ( ) ) ; ; |
let with_flushed_at_close t ~ flushed ~ f = let producers_to_flush_at_close_elt = Bag . add t . producers_to_flush_at_close flushed in Monitor . protect f ~ finally ( : fun ( ) -> Bag . remove t . producers_to_flush_at_close producers_to_flush_at_close_elt ; return ( ) ) ; ; |
let make_transfer ( ? stop = Deferred . never ( ) ) ? max_num_values_per_read t pipe_r write_f = let consumer = Pipe . add_consumer pipe_r ~ downstream_flushed ( : fun ( ) -> let % map ( ) = flushed t in ` Ok ) in let end_of_pipe_r = Ivar . create ( ) in let rec iter ( ) = if Ivar . is_full t . consumer_left || ( not ( can_write t ) ) || Deferred . is_determined stop then ( ) else ( let read_result = match max_num_values_per_read with | None -> Pipe . read_now ' pipe_r ~ consumer | Some max_queue_length -> Pipe . read_now ' pipe_r ~ consumer ~ max_queue_length in match read_result with | ` Eof -> Ivar . fill end_of_pipe_r ( ) | ` Nothing_available -> Pipe . values_available pipe_r >>> fun _ -> iter ( ) | ` Ok q -> write_f q ~ cont ( : fun ( ) -> Pipe . Consumer . values_sent_downstream consumer ; flushed t >>> iter ) ) in let doit ( ) = iter ( ) ; match % map choose [ choice ( Ivar . read end_of_pipe_r ) ( fun ( ) -> ` End_of_pipe_r ) ; choice stop ( fun ( ) -> ` Stop ) ; choice ( close_finished t ) ( fun ( ) -> ` Writer_closed ) ; choice ( consumer_left t ) ( fun ( ) -> ` Consumer_left ) ] with | ` End_of_pipe_r | ` Stop -> ( ) | ` Writer_closed | ` Consumer_left -> Pipe . close_read pipe_r in with_flushed_at_close t ~ f : doit ~ flushed ( : fun ( ) -> Deferred . ignore_m ( Pipe . upstream_flushed pipe_r ) ) ; ; |
let transfer ? stop ? max_num_values_per_read t pipe_r write_f = make_transfer ? stop ? max_num_values_per_read t pipe_r ( fun q ~ cont -> Queue . iter q ~ f : write_f ; cont ( ) ) ; ; |
let transfer ' ? stop ? max_num_values_per_read t pipe_r write_f = make_transfer ? stop ? max_num_values_per_read t pipe_r ( fun q ~ cont -> write_f q >>> cont ) ; ; |
let pipe t = let pipe_r , pipe_w = Pipe . create ( ) in don ' t_wait_for ( transfer t pipe_r ( fun s -> write t s ) ) ; pipe_w ; ; |
let version_assembler ( ver , res ) _ = let buf = Writer . assemble_protocol_version ver in assert_cs_eq buf res |
let version_assembler_tests = [ ( ` TLS_1_0 , list_to_cstruct [ 3 ; 1 ] ) ; ( ` TLS_1_1 , list_to_cstruct [ 3 ; 2 ] ) ; ( ` TLS_1_2 , list_to_cstruct [ 3 ; 3 ] ) ; ] |
let version_tests = List . mapi ( fun i f -> " Assemble version " ^ string_of_int i >:: version_assembler f ) version_assembler_tests |
let hdr_assembler ( ver , ct , cs , res ) _ = let buf = Writer . assemble_hdr ver ( ct , ( list_to_cstruct cs ) ) in let res ' = list_to_cstruct res in assert_cs_eq buf res ' |
let hdr_assembler_tests = [ ( ` TLS_1_2 , Packet . CHANGE_CIPHER_SPEC , [ ] , [ 20 ; 3 ; 3 ; 0 ; 0 ] ) ; ( ` TLS_1_1 , Packet . CHANGE_CIPHER_SPEC , [ ] , [ 20 ; 3 ; 2 ; 0 ; 0 ] ) ; ( ` TLS_1_0 , Packet . CHANGE_CIPHER_SPEC , [ ] , [ 20 ; 3 ; 1 ; 0 ; 0 ] ) ; ( ` TLS_1_2 , Packet . CHANGE_CIPHER_SPEC , [ 0 ; 0 ; 0 ] , [ 20 ; 3 ; 3 ; 0 ; 3 ; 0 ; 0 ; 0 ] ) ; ( ` TLS_1_2 , Packet . ALERT , [ ] , [ 21 ; 3 ; 3 ; 0 ; 0 ] ) ; ( ` TLS_1_1 , Packet . ALERT , [ ] , [ 21 ; 3 ; 2 ; 0 ; 0 ] ) ; ( ` TLS_1_0 , Packet . ALERT , [ ] , [ 21 ; 3 ; 1 ; 0 ; 0 ] ) ; ( ` TLS_1_2 , Packet . ALERT , [ 0 ; 0 ; 0 ] , [ 21 ; 3 ; 3 ; 0 ; 3 ; 0 ; 0 ; 0 ] ) ; ( ` TLS_1_2 , Packet . HANDSHAKE , [ ] , [ 22 ; 3 ; 3 ; 0 ; 0 ] ) ; ( ` TLS_1_1 , Packet . HANDSHAKE , [ ] , [ 22 ; 3 ; 2 ; 0 ; 0 ] ) ; ( ` TLS_1_0 , Packet . HANDSHAKE , [ ] , [ 22 ; 3 ; 1 ; 0 ; 0 ] ) ; ( ` TLS_1_2 , Packet . HANDSHAKE , [ 0 ; 0 ; 0 ] , [ 22 ; 3 ; 3 ; 0 ; 3 ; 0 ; 0 ; 0 ] ) ; ( ` TLS_1_2 , Packet . APPLICATION_DATA , [ ] , [ 23 ; 3 ; 3 ; 0 ; 0 ] ) ; ( ` TLS_1_1 , Packet . APPLICATION_DATA , [ ] , [ 23 ; 3 ; 2 ; 0 ; 0 ] ) ; ( ` TLS_1_0 , Packet . APPLICATION_DATA , [ ] , [ 23 ; 3 ; 1 ; 0 ; 0 ] ) ; ( ` TLS_1_2 , Packet . APPLICATION_DATA , [ 0 ; 0 ; 0 ] , [ 23 ; 3 ; 3 ; 0 ; 3 ; 0 ; 0 ; 0 ] ) ; ( ` TLS_1_2 , Packet . HEARTBEAT , [ ] , [ 24 ; 3 ; 3 ; 0 ; 0 ] ) ; ( ` TLS_1_1 , Packet . HEARTBEAT , [ ] , [ 24 ; 3 ; 2 ; 0 ; 0 ] ) ; ( ` TLS_1_0 , Packet . HEARTBEAT , [ ] , [ 24 ; 3 ; 1 ; 0 ; 0 ] ) ; ( ` TLS_1_2 , Packet . HEARTBEAT , [ 0 ; 0 ; 0 ] , [ 24 ; 3 ; 3 ; 0 ; 3 ; 0 ; 0 ; 0 ] ) ; ] |
let hdr_tests = List . mapi ( fun i f -> " Assemble header " ^ string_of_int i >:: hdr_assembler f ) hdr_assembler_tests |
let alert_assembler ( level , t , res ) _ = let buf = match level with | None -> Writer . assemble_alert t | Some l -> Writer . assemble_alert ~ level : l t in let res ' = list_to_cstruct res in assert_cs_eq buf res ' |
let alert_assembler_tests = Packet . ( [ ( None , CLOSE_NOTIFY , [ 2 ; 0 ; ] ) ; ( None , UNEXPECTED_MESSAGE , [ 2 ; 10 ; ] ) ; ( None , BAD_RECORD_MAC , [ 2 ; 20 ; ] ) ; ( None , DECRYPTION_FAILED , [ 2 ; 21 ; ] ) ; ( None , RECORD_OVERFLOW , [ 2 ; 22 ; ] ) ; ( None , DECOMPRESSION_FAILURE , [ 2 ; 30 ; ] ) ; ( None , HANDSHAKE_FAILURE , [ 2 ; 40 ; ] ) ; ( None , NO_CERTIFICATE_RESERVED , [ 2 ; 41 ; ] ) ; ( None , BAD_CERTIFICATE , [ 2 ; 42 ; ] ) ; ( None , UNSUPPORTED_CERTIFICATE , [ 2 ; 43 ; ] ) ; ( None , CERTIFICATE_REVOKED , [ 2 ; 44 ; ] ) ; ( None , CERTIFICATE_EXPIRED , [ 2 ; 45 ; ] ) ; ( None , CERTIFICATE_UNKNOWN , [ 2 ; 46 ; ] ) ; ( None , ILLEGAL_PARAMETER , [ 2 ; 47 ; ] ) ; ( None , UNKNOWN_CA , [ 2 ; 48 ; ] ) ; ( None , ACCESS_DENIED , [ 2 ; 49 ; ] ) ; ( None , DECODE_ERROR , [ 2 ; 50 ; ] ) ; ( None , DECRYPT_ERROR , [ 2 ; 51 ; ] ) ; ( None , EXPORT_RESTRICTION_RESERVED , [ 2 ; 60 ; ] ) ; ( None , PROTOCOL_VERSION , [ 2 ; 70 ; ] ) ; ( None , INSUFFICIENT_SECURITY , [ 2 ; 71 ; ] ) ; ( None , INTERNAL_ERROR , [ 2 ; 80 ; ] ) ; ( None , USER_CANCELED , [ 2 ; 90 ; ] ) ; ( None , NO_RENEGOTIATION , [ 2 ; 100 ; ] ) ; ( None , UNSUPPORTED_EXTENSION , [ 2 ; 110 ; ] ) ; ( None , CERTIFICATE_UNOBTAINABLE , [ 2 ; 111 ; ] ) ; ( None , UNRECOGNIZED_NAME , [ 2 ; 112 ; ] ) ; ( None , BAD_CERTIFICATE_STATUS_RESPONSE , [ 2 ; 113 ; ] ) ; ( None , BAD_CERTIFICATE_HASH_VALUE , [ 2 ; 114 ; ] ) ; ( None , UNKNOWN_PSK_IDENTITY , [ 2 ; 115 ; ] ) ; ( None , NO_APPLICATION_PROTOCOL , [ 2 ; 120 ; ] ) ; ( Some FATAL , CLOSE_NOTIFY , [ 2 ; 0 ; ] ) ; ( Some FATAL , UNEXPECTED_MESSAGE , [ 2 ; 10 ; ] ) ; ( Some FATAL , BAD_RECORD_MAC , [ 2 ; 20 ; ] ) ; ( Some FATAL , DECRYPTION_FAILED , [ 2 ; 21 ; ] ) ; ( Some FATAL , RECORD_OVERFLOW , [ 2 ; 22 ; ] ) ; ( Some FATAL , DECOMPRESSION_FAILURE , [ 2 ; 30 ; ] ) ; ( Some FATAL , HANDSHAKE_FAILURE , [ 2 ; 40 ; ] ) ; ( Some FATAL , NO_CERTIFICATE_RESERVED , [ 2 ; 41 ; ] ) ; ( Some FATAL , BAD_CERTIFICATE , [ 2 ; 42 ; ] ) ; ( Some FATAL , UNSUPPORTED_CERTIFICATE , [ 2 ; 43 ; ] ) ; ( Some FATAL , CERTIFICATE_REVOKED , [ 2 ; 44 ; ] ) ; ( Some FATAL , CERTIFICATE_EXPIRED , [ 2 ; 45 ; ] ) ; ( Some FATAL , CERTIFICATE_UNKNOWN , [ 2 ; 46 ; ] ) ; ( Some FATAL , ILLEGAL_PARAMETER , [ 2 ; 47 ; ] ) ; ( Some FATAL , UNKNOWN_CA , [ 2 ; 48 ; ] ) ; ( Some FATAL , ACCESS_DENIED , [ 2 ; 49 ; ] ) ; ( Some FATAL , DECODE_ERROR , [ 2 ; 50 ; ] ) ; ( Some FATAL , DECRYPT_ERROR , [ 2 ; 51 ; ] ) ; ( Some FATAL , EXPORT_RESTRICTION_RESERVED , [ 2 ; 60 ; ] ) ; ( Some FATAL , PROTOCOL_VERSION , [ 2 ; 70 ; ] ) ; ( Some FATAL , INSUFFICIENT_SECURITY , [ 2 ; 71 ; ] ) ; ( Some FATAL , INTERNAL_ERROR , [ 2 ; 80 ; ] ) ; ( Some FATAL , USER_CANCELED , [ 2 ; 90 ; ] ) ; ( Some FATAL , NO_RENEGOTIATION , [ 2 ; 100 ; ] ) ; ( Some FATAL , UNSUPPORTED_EXTENSION , [ 2 ; 110 ; ] ) ; ( Some FATAL , CERTIFICATE_UNOBTAINABLE , [ 2 ; 111 ; ] ) ; ( Some FATAL , UNRECOGNIZED_NAME , [ 2 ; 112 ; ] ) ; ( Some FATAL , BAD_CERTIFICATE_STATUS_RESPONSE , [ 2 ; 113 ; ] ) ; ( Some FATAL , BAD_CERTIFICATE_HASH_VALUE , [ 2 ; 114 ; ] ) ; ( Some FATAL , UNKNOWN_PSK_IDENTITY , [ 2 ; 115 ; ] ) ; ( Some FATAL , NO_APPLICATION_PROTOCOL , [ 2 ; 120 ; ] ) ; ( Some WARNING , CLOSE_NOTIFY , [ 1 ; 0 ; ] ) ; ( Some WARNING , UNEXPECTED_MESSAGE , [ 1 ; 10 ; ] ) ; ( Some WARNING , BAD_RECORD_MAC , [ 1 ; 20 ; ] ) ; ( Some WARNING , DECRYPTION_FAILED , [ 1 ; 21 ; ] ) ; ( Some WARNING , RECORD_OVERFLOW , [ 1 ; 22 ; ] ) ; ( Some WARNING , DECOMPRESSION_FAILURE , [ 1 ; 30 ; ] ) ; ( Some WARNING , HANDSHAKE_FAILURE , [ 1 ; 40 ; ] ) ; ( Some WARNING , NO_CERTIFICATE_RESERVED , [ 1 ; 41 ; ] ) ; ( Some WARNING , BAD_CERTIFICATE , [ 1 ; 42 ; ] ) ; ( Some WARNING , UNSUPPORTED_CERTIFICATE , [ 1 ; 43 ; ] ) ; ( Some WARNING , CERTIFICATE_REVOKED , [ 1 ; 44 ; ] ) ; ( Some WARNING , CERTIFICATE_EXPIRED , [ 1 ; 45 ; ] ) ; ( Some WARNING , CERTIFICATE_UNKNOWN , [ 1 ; 46 ; ] ) ; ( Some WARNING , ILLEGAL_PARAMETER , [ 1 ; 47 ; ] ) ; ( Some WARNING , UNKNOWN_CA , [ 1 ; 48 ; ] ) ; ( Some WARNING , ACCESS_DENIED , [ 1 ; 49 ; ] ) ; ( Some WARNING , DECODE_ERROR , [ 1 ; 50 ; ] ) ; ( Some WARNING , DECRYPT_ERROR , [ 1 ; 51 ; ] ) ; ( Some WARNING , EXPORT_RESTRICTION_RESERVED , [ 1 ; 60 ; ] ) ; ( Some WARNING , PROTOCOL_VERSION , [ 1 ; 70 ; ] ) ; ( Some WARNING , INSUFFICIENT_SECURITY , [ 1 ; 71 ; ] ) ; ( Some WARNING , INTERNAL_ERROR , [ 1 ; 80 ; ] ) ; ( Some WARNING , USER_CANCELED , [ 1 ; 90 ; ] ) ; ( Some WARNING , NO_RENEGOTIATION , [ 1 ; 100 ; ] ) ; ( Some WARNING , UNSUPPORTED_EXTENSION , [ 1 ; 110 ; ] ) ; ( Some WARNING , CERTIFICATE_UNOBTAINABLE , [ 1 ; 111 ; ] ) ; ( Some WARNING , UNRECOGNIZED_NAME , [ 1 ; 112 ; ] ) ; ( Some WARNING , BAD_CERTIFICATE_STATUS_RESPONSE , [ 1 ; 113 ; ] ) ; ( Some WARNING , BAD_CERTIFICATE_HASH_VALUE , [ 1 ; 114 ; ] ) ; ( Some WARNING , UNKNOWN_PSK_IDENTITY , [ 1 ; 115 ; ] ) ; ] ) |
let alert_tests = List . mapi ( fun i f -> " Assemble alert " ^ string_of_int i >:: alert_assembler f ) alert_assembler_tests |
let ccs_test _ = let buf = Writer . assemble_change_cipher_spec in assert_cs_eq buf ( list_to_cstruct [ 1 ] ) |
let dh_assembler ( p , res ) _ = let buf = Writer . assemble_dh_parameters p in assert_cs_eq buf res |
let dh_assembler_tests = let a = list_to_cstruct [ 0 ; 1 ; 2 ; 3 ; 4 ; 5 ; 6 ; 7 ; 8 ; 9 ; 10 ; 11 ; 12 ; 13 ; 14 ; 15 ] in let le = list_to_cstruct [ 0 ; 16 ] in let le2 = list_to_cstruct [ 0 ; 32 ] in let emp , empl = ( list_to_cstruct [ ] , list_to_cstruct [ 0 ; 0 ] ) in Core . ( [ ( { dh_p = a ; dh_g = a ; dh_Ys = a } , le <+> a <+> le <+> a <+> le <+> a ) ; ( { dh_p = a <+> a ; dh_g = a ; dh_Ys = a <+> a } , le2 <+> a <+> a <+> le <+> a <+> le2 <+> a <+> a ) ; ( { dh_p = emp ; dh_g = emp ; dh_Ys = emp } , empl <+> empl <+> empl ) ; ( { dh_p = a ; dh_g = emp ; dh_Ys = emp } , le <+> a <+> empl <+> empl ) ; ( { dh_p = emp ; dh_g = a ; dh_Ys = emp } , empl <+> le <+> a <+> empl ) ; ( { dh_p = emp ; dh_g = emp ; dh_Ys = a } , empl <+> empl <+> le <+> a ) ; ( { dh_p = emp ; dh_g = a ; dh_Ys = a } , empl <+> le <+> a <+> le <+> a ) ; ( { dh_p = a ; dh_g = a ; dh_Ys = emp } , le <+> a <+> le <+> a <+> empl ) ; ( { dh_p = a ; dh_g = emp ; dh_Ys = a } , le <+> a <+> empl <+> le <+> a ) ; ] ) |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.