src/couch/src/couch_att.erl - couchdb - Git at Google

 % Licensed under the Apache License, Version 2.0 (the "License"); you may not
 % use this file except in compliance with the License. You may obtain a copy of
 % the License at
 %
 %   http://www.apache.org/licenses/LICENSE-2.0
 %
 % Unless required by applicable law or agreed to in writing, software
 % distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 % WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 % License for the specific language governing permissions and limitations under
 % the License.

 -module(couch_att).

 -export([
     new/0,
     new/1,
     fetch/2,
     store/2,
     store/3,
     transform/3
 ]).

 -export([
     is_stub/1,
     merge_stubs/2
 ]).

 -export([
     size_info/1,
     to_disk_term/1,
     from_disk_term/3
 ]).

 -export([
     from_json/2,
     to_json/4
 ]).

 -export([
     flush/3,
     foldl/3,
     range_foldl/5,
     foldl_decode/3,
     to_binary/1
 ]).

 -export([
     max_attachment_size/0,
     validate_attachment_size/3
 ]).

 -compile(nowarn_deprecated_type).
 -export_type([att/0]).


 -include_lib("couch/include/couch_db.hrl").


 -define(CURRENT_ATT_FORMAT, 0).


 -type prop_name() ::
     name |
     type |
     att_len |
     disk_len |
     md5 |
     revpos |
     data |
     encoding.


 -type data_prop_type() ::
     {loc, #{}, binary(), binary()} |
     stub |
     follows |
     binary() |
     {follows, pid(), reference()} |
     fun(() -> binary()).


 -type att() :: #{
     name := binary(),
     type := binary(),
     att_len := non_neg_integer() | undefined,
     disk_len := non_neg_integer() | undefined,
     md5 := binary() | undefined,
     revpos := non_neg_integer(),
     data := data_prop_type(),
     encoding := identity | gzip | undefined,
     headers := [{binary(), binary()}] | undefined
 }.


 new() ->
     #{
         name => <<>>,
         type => <<>>,
         att_len => undefined,
         disk_len => undefined,
         md5 => undefined,
         revpos => 0,
         data => undefined,
         encoding => undefined,
         headers => undefined
     }.


 -spec new([{prop_name(), any()}]) -> att().
 new(Props) ->
     store(Props, new()).


 -spec fetch([atom()], att()) -> [any()];
            (atom(), att()) -> any().
 fetch(Fields, Att) when is_list(Fields) ->
     [fetch(Field, Att) || Field <- Fields];
 fetch(Field, Att) ->
     maps:get(Field, Att).


 -spec store([{atom(), any()}], att()) -> att().
 store(Props, Att0) ->
     lists:foldl(fun({Field, Value}, Att) ->
         maps:update(Field, Value, Att)
     end, Att0, Props).


 store(Field, Value, Att) ->
     maps:update(Field, Value, Att).


 -spec transform(atom(), fun(), att()) -> att().
 transform(Field, Fun, Att) ->
     maps:update_with(Field, Fun, Att).


 is_stub(#{data := stub}) -> true;
 is_stub(#{}) -> false.


 %% merge_stubs takes all stub attachments and replaces them with on disk
 %% attachments. It will return {missing, Name} if a stub isn't matched with
 %% an existing attachment on disk. If the revpos is supplied with the stub
 %% it is also only counted to match if is the same as the disk attachment.
 merge_stubs(MemAtts, DiskAtts) ->
     OnDisk = dict:from_list(
         [{fetch(name, Att), Att} || Att <- DiskAtts]
     ),
     merge_stubs(MemAtts, OnDisk, []).


 -spec merge_stubs([att()], dict:dict(), [att()]) -> [att()].
 merge_stubs([Att | Rest], OnDisk, Merged) ->
     case fetch(data, Att) of
         stub ->
             [Name, Pos] = fetch([name, revpos], Att),
             case dict:find(Name, OnDisk) of
                 {ok, DiskAtt} ->
                     RevPos = fetch(revpos, DiskAtt),
                     if
                         %% We want to check for consistency between the stub and
                         %% disk revpos here. If the stub's revpos is undefined
                         %% it means it wasn't provided by the user and does not
                         %% require being matched.
                         RevPos == Pos orelse Pos == undefined ->
                             merge_stubs(Rest, OnDisk, [DiskAtt | Merged]);
                         true ->
                             {missing, Name}
                     end;
                 _ ->
                     {missing, Name}
             end;
         _ ->
             merge_stubs(Rest, OnDisk, [Att | Merged])
     end;
 merge_stubs([], _, Merged) ->
     {ok, lists:reverse(Merged)}.


 size_info([]) ->
     {ok, []};
 size_info(Atts) ->
     Info = lists:map(fun(Att) ->
         [{loc, _Db, _DocId, AttId}, AttLen] = fetch([data, att_len], Att),
         {AttId, AttLen}
     end, Atts),
     {ok, lists:usort(Info)}.


 %% When converting an attachment to disk term format, attempt to stay with the
 %% old format when possible. This should help make the attachment lazy upgrade
 %% as safe as possible, avoiding the need for complicated disk versioning
 %% schemes.
 to_disk_term(Att) ->
     {loc, #{}, _DocId, AttId} = fetch(data, Att),
     {?CURRENT_ATT_FORMAT, {
         fetch(name, Att),
         fetch(type, Att),
         AttId,
         fetch(att_len, Att),
         fetch(disk_len, Att),
         fetch(revpos, Att),
         fetch(md5, Att),
         fetch(encoding, Att),
         fetch(headers, Att)
     }}.


 from_disk_term(#{} = Db, DocId, {?CURRENT_ATT_FORMAT, Props}) ->
     {
         Name,
         Type,
         AttId,
         AttLen,
         DiskLen,
         RevPos,
         Md5,
         Encoding,
         Headers
     } = Props,
     new([
         {name, Name},
         {type, Type},
         {data, {loc, Db#{tx := undefined}, DocId, AttId}},
         {att_len, AttLen},
         {disk_len, DiskLen},
         {revpos, RevPos},
         {md5, Md5},
         {encoding, Encoding},
         {headers, Headers}
     ]).


 %% from_json reads in embedded JSON attachments and creates usable attachment
 %% values. The attachment may be a stub,
 from_json(Name, Props) ->
     Type = couch_util:get_value(
         <<"content_type">>, Props, ?DEFAULT_ATTACHMENT_CONTENT_TYPE
     ),
     Att = new([{name, Name}, {type, Type}]),
     IsStub = couch_util:get_value(<<"stub">>, Props),
     Follows = couch_util:get_value(<<"follows">>, Props),
     if
         IsStub -> stub_from_json(Att, Props);
         Follows -> follow_from_json(Att, Props);
         true -> inline_from_json(Att, Props)
     end.


 stub_from_json(Att, Props) ->
     {DiskLen, EncodedLen, Encoding} = encoded_lengths_from_json(Props),
     Digest = digest_from_json(Props),
     %% We specifically want undefined rather than the default 0 here to skip
     %% the revpos consistency check on stubs when it's not provided in the
     %% json object. See merge_stubs/3 for the stub check.
     RevPos = couch_util:get_value(<<"revpos">>, Props),
     store([
         {data, stub},
         {disk_len, DiskLen},
         {att_len, EncodedLen},
         {revpos, RevPos},
         {md5, Digest},
         {encoding, Encoding}
     ], Att).


 follow_from_json(Att, Props) ->
     {DiskLen, EncodedLen, Encoding} = encoded_lengths_from_json(Props),
     Digest = digest_from_json(Props),
     RevPos = couch_util:get_value(<<"revpos">>, Props, 0),
     store([
         {data, follows},
         {disk_len, DiskLen},
         {att_len, EncodedLen},
         {revpos, RevPos},
         {md5, Digest},
         {encoding, Encoding}
     ], Att).


 inline_from_json(Att, Props) ->
     B64Data = couch_util:get_value(<<"data">>, Props),
     try base64:decode(B64Data) of
         Data ->
             Length = size(Data),
             RevPos = couch_util:get_value(<<"revpos">>, Props, 0),
             store([
                 {data, Data},
                 {disk_len, Length},
                 {att_len, Length},
                 {revpos, RevPos}
             ], Att)
     catch
         _:_ ->
             Name = fetch(name, Att),
             ErrMsg =  <<"Invalid attachment data for ", Name/binary>>,
             throw({bad_request, ErrMsg})
     end.


 encoded_lengths_from_json(Props) ->
     Len = couch_util:get_value(<<"length">>, Props),
     case couch_util:get_value(<<"encoding">>, Props) of
         undefined ->
             Encoding = identity,
             EncodedLen = Len;
         EncodingValue ->
             EncodedLen = couch_util:get_value(<<"encoded_length">>, Props, Len),
             Encoding = list_to_existing_atom(binary_to_list(EncodingValue))
     end,
     {Len, EncodedLen, Encoding}.


 digest_from_json(Props) ->
     case couch_util:get_value(<<"digest">>, Props) of
         <<"md5-", EncodedMd5/binary>> -> base64:decode(EncodedMd5);
         _ -> <<>>
     end.


 to_json(Att, OutputData, DataToFollow, ShowEncoding) ->
     #{
         name := Name,
         type := Type,
         data := Data,
         disk_len := DiskLen,
         att_len := AttLen,
         revpos := RevPos,
         md5 := Md5,
         encoding := Encoding,
         headers := Headers
     } = Att,
     Props = [
         {<<"content_type">>, Type},
         {<<"revpos">>, RevPos}
     ],
     DigestProp = case base64:encode(Md5) of
         <<>> -> [];
         Digest -> [{<<"digest">>, <<"md5-", Digest/binary>>}]
     end,
     DataProps = if
         not OutputData orelse Data == stub ->
             [{<<"length">>, DiskLen}, {<<"stub">>, true}];
         DataToFollow ->
             [{<<"length">>, DiskLen}, {<<"follows">>, true}];
         true ->
             AttData = case Encoding of
                 gzip -> zlib:gunzip(to_binary(Att));
                 identity -> to_binary(Att)
             end,
             [{<<"data">>, base64:encode(AttData)}]
     end,
     EncodingProps = if
         ShowEncoding andalso Encoding /= identity ->
             [
                 {<<"encoding">>, couch_util:to_binary(Encoding)},
                 {<<"encoded_length">>, AttLen}
             ];
         true ->
             []
     end,
     HeadersProp = case Headers of
         undefined -> [];
         Headers -> [{<<"headers">>, Headers}]
     end,
     {Name, {Props ++ DigestProp ++ DataProps ++ EncodingProps ++ HeadersProp}}.


 flush(Db, DocId, Att1) ->
     Att2 = read_data(fetch(data, Att1), Att1),
     [
         Data,
         AttLen,
         DiskLen,
         ReqMd5,
         Encoding
     ] = fetch([data, att_len, disk_len, md5, encoding], Att2),

     % Eventually, we'll check if we can compress this
     % attachment here and do so if possible.

     % If we were sent a gzip'ed attachment with no
     % length data, we have to set it here.
     Att3 = case DiskLen of
         undefined -> store(disk_len, AttLen, Att2);
         _ -> Att2
     end,

     % If no encoding has been set, default to
     % identity
     Att4 = case Encoding of
         undefined -> store(encoding, identity, Att3);
         _ -> Att3
     end,

     case Data of
         {loc, _, _, _} ->
             % Already flushed
             Att1;
         _ when is_binary(Data) ->
             DataMd5 = couch_hash:md5_hash(Data),
             if ReqMd5 == undefined -> ok; true ->
                 couch_util:check_md5(DataMd5, ReqMd5)
             end,
             Att5 = store(md5, DataMd5, Att4),
             Att6 = maybe_compress(Att5),
             fabric2_db:write_attachment(Db, DocId, Att6)
     end.


 read_data({loc, #{}, _DocId, _AttId}, Att) ->
     % Attachment already written to fdb
     Att;

 read_data({follows, Parser, Ref}, Att) ->
     ParserRef = erlang:monitor(process, Parser),
     Fun = fun() ->
         Parser ! {get_bytes, Ref, self()},
         receive
             {started_open_doc_revs, NewRef} ->
                 couch_doc:restart_open_doc_revs(Parser, Ref, NewRef);
             {bytes, Ref, Bytes} ->
                 Bytes;
             {'DOWN', ParserRef, _, _, Reason} ->
                 throw({mp_parser_died, Reason})
         end
     end,
     try
         read_data(Fun, store(data, Fun, Att))
     after
         erlang:demonitor(ParserRef, [flush])
     end;

 read_data(Data, Att) when is_binary(Data) ->
     Att;

 read_data(Fun, Att) when is_function(Fun) ->
     [AttName, AttLen, InMd5] = fetch([name, att_len, md5], Att),
     MaxAttSize = max_attachment_size(),
     case AttLen of
         undefined ->
             % Fun(MaxChunkSize, WriterFun) must call WriterFun
             % once for each chunk of the attachment,
             WriterFun = fun
                 ({0, Footers}, {Len, Acc}) ->
                     F = mochiweb_headers:from_binary(Footers),
                     Md5 = case mochiweb_headers:get_value("Content-MD5", F) of
                         undefined -> undefined;
                         Value -> base64:decode(Value)
                     end,
                     Props0 = [
                         {data, iolist_to_binary(lists:reverse(Acc))},
                         {att_len, Len}
                     ],
                     Props1 = if InMd5 /= md5_in_footer -> Props0; true ->
                         [{md5, Md5} | Props0]
                     end,
                     store(Props1, Att);
                 ({ChunkLen, Chunk}, {Len, Acc}) ->
                     NewLen = Len + ChunkLen,
                     validate_attachment_size(AttName, NewLen, MaxAttSize),
                     {NewLen, [Chunk | Acc]}
             end,
             Fun(8192, WriterFun, {0, []});
         AttLen ->
             validate_attachment_size(AttName, AttLen, MaxAttSize),
             read_streamed_attachment(Att, Fun, AttLen, [])
     end.


 read_streamed_attachment(Att, _F, 0, Acc) ->
     Bin = iolist_to_binary(lists:reverse(Acc)),
     store([
         {data, Bin},
         {att_len, size(Bin)}
     ], Att);

 read_streamed_attachment(_Att, _F, LenLeft, _Acc) when LenLeft < 0 ->
     throw({bad_request, <<"attachment longer than expected">>});

 read_streamed_attachment(Att, F, LenLeft, Acc) when LenLeft > 0 ->
     Bin = try
         read_next_chunk(F, LenLeft)
     catch
         {mp_parser_died, normal} ->
             throw({bad_request, <<"attachment shorter than expected">>})
     end,
     Size = iolist_size(Bin),
     read_streamed_attachment(Att, F, LenLeft - Size, [Bin | Acc]).


 read_next_chunk(F, _) when is_function(F, 0) ->
     F();

 read_next_chunk(F, LenLeft) when is_function(F, 1) ->
     F(lists:min([LenLeft, 16#2000])).


 foldl(Att, Fun, Acc) ->
     foldl(fetch(data, Att), Att, Fun, Acc).


 foldl({loc, Db, DocId, AttId}, _Att, Fun, Acc) ->
     Bin = fabric2_db:read_attachment(Db#{tx := undefined}, DocId, AttId),
     Fun(Bin, Acc);

 foldl(Bin, _Att, Fun, Acc) when is_binary(Bin) ->
     Fun(Bin, Acc);

 foldl(DataFun, Att, Fun, Acc) when is_function(DataFun) ->
     Len = fetch(att_len, Att),
     fold_streamed_data(DataFun, Len, Fun, Acc);

 foldl({follows, Parser, Ref}, Att, Fun, Acc) ->
     ParserRef = erlang:monitor(process, Parser),
     DataFun = fun() ->
         Parser ! {get_bytes, Ref, self()},
         receive
             {started_open_doc_revs, NewRef} ->
                 couch_doc:restart_open_doc_revs(Parser, Ref, NewRef);
             {bytes, Ref, Bytes} ->
                 Bytes;
             {'DOWN', ParserRef, _, _, Reason} ->
                 throw({mp_parser_died, Reason})
         end
     end,
     try
         foldl(DataFun, store(data, DataFun, Att), Fun, Acc)
     after
         erlang:demonitor(ParserRef, [flush])
     end.


 range_foldl(Bin1, From, To, Fun, Acc) when is_binary(Bin1) ->
     ReadLen = To - From,
     Bin2 = case Bin1 of
         _ when size(Bin1) < From -> <<>>;
         <<_:From/binary, B2>> -> B2
     end,
     Bin3 = case Bin2 of
         _ when size(Bin2) < ReadLen -> Bin2;
         <<B3:ReadLen/binary, _/binary>> -> B3
     end,
     Fun(Bin3, Acc);

 range_foldl(Att, From, To, Fun, Acc) ->
     {loc, Db, DocId, AttId} = fetch(data, Att),
     Bin = fabric2_db:read_attachment(Db, DocId, AttId),
     range_foldl(Bin, From, To, Fun, Acc).


 foldl_decode(Att, Fun, Acc) ->
     [Encoding, Data] = fetch([encoding, data], Att),
     case {Encoding, Data} of
         {gzip, {loc, Db, DocId, AttId}} ->
             NoTxDb = Db#{tx := undefined},
             Bin = fabric2_db:read_attachment(NoTxDb, DocId, AttId),
             foldl_decode(store(data, Bin, Att), Fun, Acc);
         {gzip, _} when is_binary(Data) ->
             Z = zlib:open(),
             ok = zlib:inflateInit(Z, 16 + 15),
             Inflated = iolist_to_binary(zlib:inflate(Z, Data)),
             ok = zlib:inflateEnd(Z),
             ok = zlib:close(Z),
             foldl(Inflated, Att, Fun, Acc);
         _ ->
             foldl(Att, Fun, Acc)
     end.


 to_binary(Att) ->
     to_binary(fetch(data, Att), Att).


 to_binary(Bin, _Att) when is_binary(Bin) ->
     Bin;
 to_binary(Iolist, _Att) when is_list(Iolist) ->
     iolist_to_binary(Iolist);
 to_binary({loc, Db, DocId, AttId}, _Att) ->
     NoTxDb = Db#{tx := undefined},
     fabric2_db:read_attachment(NoTxDb, DocId, AttId);
 to_binary(DataFun, Att) when is_function(DataFun)->
     Len = fetch(att_len, Att),
     iolist_to_binary(
         lists:reverse(fold_streamed_data(
             DataFun,
             Len,
             fun(Data, Acc) -> [Data | Acc] end,
             []
         ))
     ).


 fold_streamed_data(_RcvFun, 0, _Fun, Acc) ->
     Acc;

 fold_streamed_data(RcvFun, LenLeft, Fun, Acc) when LenLeft > 0->
     Bin = RcvFun(),
     ResultAcc = Fun(Bin, Acc),
     fold_streamed_data(RcvFun, LenLeft - size(Bin), Fun, ResultAcc).


 maybe_compress(Att) ->
     [Encoding, Type] = fetch([encoding, type], Att),
     IsCompressible = is_compressible(Type),
     CompLevel = config:get_integer("attachments", "compression_level", 0),
     case Encoding of
         identity when IsCompressible, CompLevel >= 1, CompLevel =< 9 ->
             compress(Att, CompLevel);
         _ ->
             Att
     end.


 compress(Att, Level) ->
     Data = fetch(data, Att),

     Z = zlib:open(),
     % 15 = ?MAX_WBITS (defined in the zlib module)
     % the 16 + ?MAX_WBITS formula was obtained by inspecting zlib:gzip/1
     ok = zlib:deflateInit(Z, Level, deflated, 16 + 15, 8, default),
     CompData = iolist_to_binary(zlib:deflate(Z, Data, finish)),
     ok = zlib:deflateEnd(Z),
     ok = zlib:close(Z),

     store([
         {att_len, size(CompData)},
         {md5, couch_hash:md5_hash(CompData)},
         {data, CompData},
         {encoding, gzip}
     ], Att).


 is_compressible(Type) when is_binary(Type) ->
     is_compressible(binary_to_list(Type));
 is_compressible(Type) ->
     TypeExpList = re:split(
         config:get("attachments", "compressible_types", ""),
         "\\s*,\\s*",
         [{return, list}]
     ),
     lists:any(
         fun(TypeExp) ->
             Regexp = ["^\\s*", re:replace(TypeExp, "\\*", ".*"),
                 "(?:\\s*;.*?)?\\s*", $$],
             re:run(Type, Regexp, [caseless]) =/= nomatch
         end,
         [T || T <- TypeExpList, T /= []]
     ).


 max_attachment_size() ->
     case config:get("couchdb", "max_attachment_size", "infinity") of
         "infinity" ->
             infinity;
         MaxAttSize ->
             list_to_integer(MaxAttSize)
     end.


 validate_attachment_size(AttName, AttSize, MaxAttSize)
         when is_integer(AttSize),  AttSize > MaxAttSize ->
     throw({request_entity_too_large, {attachment, AttName}});
 validate_attachment_size(_AttName, _AttSize, _MAxAttSize) ->
     ok.


 %% -ifdef(TEST).
 %% -include_lib("eunit/include/eunit.hrl").
 %%
 %% % Eww...
 %% -include("couch_bt_engine.hrl").
 %%
 %% %% Test utilities
 %%
 %%
 %% empty_att() -> new().
 %%
 %%
 %% upgraded_empty_att() ->
 %%     new([{headers, undefined}]).
 %%
 %%
 %% %% Test groups
 %%
 %%
 %% attachment_upgrade_test_() ->
 %%     {"Lazy record upgrade tests", [
 %%         {"Existing record fields don't upgrade",
 %%             {with, empty_att(), [fun test_non_upgrading_fields/1]}
 %%         },
 %%         {"New fields upgrade",
 %%             {with, empty_att(), [fun test_upgrading_fields/1]}
 %%         }
 %%     ]}.
 %%
 %%
 %% attachment_defaults_test_() ->
 %%     {"Attachment defaults tests", [
 %%         {"Records retain old default values", [
 %%             {with, empty_att(), [fun test_legacy_defaults/1]}
 %%         ]},
 %%         {"Upgraded records inherit defaults", [
 %%             {with, upgraded_empty_att(), [fun test_legacy_defaults/1]}
 %%         ]},
 %%         {"Undefined entries are elided on upgrade", [
 %%             {with, upgraded_empty_att(), [fun test_elided_entries/1]}
 %%         ]}
 %%     ]}.
 %%
 %% attachment_field_api_test_() ->
 %%     {"Basic attachment field api", [
 %%         fun test_construction/0,
 %%         fun test_store_and_fetch/0,
 %%         fun test_transform/0
 %%     ]}.
 %%
 %%
 %% attachment_disk_term_test_() ->
 %%     BaseAttachment = new([
 %%         {name, <<"empty">>},
 %%         {type, <<"application/octet-stream">>},
 %%         {att_len, 0},
 %%         {disk_len, 0},
 %%         {md5, <<212,29,140,217,143,0,178,4,233,128,9,152,236,248,66,126>>},
 %%         {revpos, 4},
 %%         {data, {stream, {couch_bt_engine_stream, {fake_fd, fake_sp}}}},
 %%         {encoding, identity}
 %%     ]),
 %%     BaseDiskTerm = {
 %%         <<"empty">>,
 %%         <<"application/octet-stream">>,
 %%         fake_sp,
 %%         0, 0, 4,
 %%         <<212,29,140,217,143,0,178,4,233,128,9,152,236,248,66,126>>,
 %%         identity
 %%     },
 %%     Headers = [{<<"X-Foo">>, <<"bar">>}],
 %%     ExtendedAttachment = store(headers, Headers, BaseAttachment),
 %%     ExtendedDiskTerm = {BaseDiskTerm, [{headers, Headers}]},
 %%     FakeDb = test_util:fake_db([{engine, {couch_bt_engine, #st{fd=fake_fd}}}]),
 %%     {"Disk term tests", [
 %%         ?_assertEqual(BaseDiskTerm, to_disk_term(BaseAttachment)),
 %%         ?_assertEqual(BaseAttachment, from_disk_term(FakeDb, BaseDiskTerm)),
 %%         ?_assertEqual(ExtendedDiskTerm, to_disk_term(ExtendedAttachment)),
 %%         ?_assertEqual(ExtendedAttachment, from_disk_term(FakeDb, ExtendedDiskTerm))
 %%     ]}.
 %%
 %%
 %% attachment_json_term_test_() ->
 %%     Props = [
 %%         {<<"content_type">>, <<"application/json">>},
 %%         {<<"digest">>, <<"md5-QCNtWUNXV0UzJnEjMk92YUk1JA==">>},
 %%         {<<"length">>, 14},
 %%         {<<"revpos">>, 1}
 %%     ],
 %%     PropsInline = [{<<"data">>, <<"eyJhbnN3ZXIiOiA0Mn0=">>}] ++ Props,
 %%     InvalidProps = [{<<"data">>, <<"!Base64Encoded$">>}] ++ Props,
 %%     Att = couch_att:new([
 %%         {name, <<"attachment.json">>},
 %%         {type, <<"application/json">>}
 %%     ]),
 %%     ResultStub = couch_att:new([
 %%         {name, <<"attachment.json">>},
 %%         {type, <<"application/json">>},
 %%         {att_len, 14},
 %%         {disk_len, 14},
 %%         {md5, <<"@#mYCWWE3&q#2OvaI5$">>},
 %%         {revpos, 1},
 %%         {data, stub},
 %%         {encoding, identity}
 %%     ]),
 %%     ResultFollows = ResultStub#att{data = follows},
 %%     ResultInline = ResultStub#att{md5 = <<>>, data = <<"{\"answer\": 42}">>},
 %%     {"JSON term tests", [
 %%         ?_assertEqual(ResultStub, stub_from_json(Att, Props)),
 %%         ?_assertEqual(ResultFollows, follow_from_json(Att, Props)),
 %%         ?_assertEqual(ResultInline, inline_from_json(Att, PropsInline)),
 %%         ?_assertThrow({bad_request, _}, inline_from_json(Att, Props)),
 %%         ?_assertThrow({bad_request, _}, inline_from_json(Att, InvalidProps))
 %%     ]}.
 %%
 %%
 %% attachment_stub_merge_test_() ->
 %%     %% Stub merging needs to demonstrate revpos matching, skipping, and missing
 %%     %% attachment errors.
 %%     {"Attachment stub merging tests", []}.
 %%
 %%
 %% %% Test generators
 %%
 %%
 %% test_non_upgrading_fields(Attachment) ->
 %%     Pairs = [
 %%         {name, "cat.gif"},
 %%         {type, "text/very-very-plain"},
 %%         {att_len, 1024},
 %%         {disk_len, 42},
 %%         {md5, <<"md5-hashhashhash">>},
 %%         {revpos, 4},
 %%         {data, stub},
 %%         {encoding, gzip}
 %%     ],
 %%     lists:foreach(
 %%         fun({Field, Value}) ->
 %%             ?assertMatch(#att{}, Attachment),
 %%             Updated = store(Field, Value, Attachment),
 %%             ?assertMatch(#att{}, Updated)
 %%         end,
 %%     Pairs).
 %%
 %%
 %% test_upgrading_fields(Attachment) ->
 %%     ?assertMatch(#att{}, Attachment),
 %%     UpdatedHeaders = store(headers, [{<<"Ans">>, <<"42">>}], Attachment),
 %%     ?assertMatch(X when is_list(X), UpdatedHeaders),
 %%     UpdatedHeadersUndefined = store(headers, undefined, Attachment),
 %%     ?assertMatch(X when is_list(X), UpdatedHeadersUndefined).
 %%
 %%
 %% test_legacy_defaults(Attachment) ->
 %%     ?assertEqual(<<>>, fetch(md5, Attachment)),
 %%     ?assertEqual(0, fetch(revpos, Attachment)),
 %%     ?assertEqual(identity, fetch(encoding, Attachment)).
 %%
 %%
 %% test_elided_entries(Attachment) ->
 %%     ?assertNot(lists:keymember(name, 1, Attachment)),
 %%     ?assertNot(lists:keymember(type, 1, Attachment)),
 %%     ?assertNot(lists:keymember(att_len, 1, Attachment)),
 %%     ?assertNot(lists:keymember(disk_len, 1, Attachment)),
 %%     ?assertNot(lists:keymember(data, 1, Attachment)).
 %%
 %%
 %% test_construction() ->
 %%     ?assert(new() == new()),
 %%     Initialized = new([{name, <<"foo.bar">>}, {type, <<"application/qux">>}]),
 %%     ?assertEqual(<<"foo.bar">>, fetch(name, Initialized)),
 %%     ?assertEqual(<<"application/qux">>, fetch(type, Initialized)).
 %%
 %%
 %% test_store_and_fetch() ->
 %%     Attachment = empty_att(),
 %%     ?assertEqual(<<"abc">>, fetch(name, store(name, <<"abc">>, Attachment))),
 %%     ?assertEqual(42, fetch(ans, store(ans, 42, Attachment))).
 %%
 %%
 %% test_transform() ->
 %%     Attachment = new([{counter, 0}]),
 %%     Transformed = transform(counter, fun(Count) -> Count + 1 end, Attachment),
 %%     ?assertEqual(1, fetch(counter, Transformed)).
 %%
 %%
 %% -endif.
	% Licensed under the Apache License, Version 2.0 (the "License"); you may not
	% use this file except in compliance with the License. You may obtain a copy of
	% the License at
	%
	% http://www.apache.org/licenses/LICENSE-2.0
	%
	% Unless required by applicable law or agreed to in writing, software
	% distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	% WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	% License for the specific language governing permissions and limitations under
	% the License.

	-module(couch_att).

	-export([
	new/0,
	new/1,
	fetch/2,
	store/2,
	store/3,
	transform/3
	]).

	-export([
	is_stub/1,
	merge_stubs/2
	]).

	-export([
	size_info/1,
	to_disk_term/1,
	from_disk_term/3
	]).

	-export([
	from_json/2,
	to_json/4
	]).

	-export([
	flush/3,
	foldl/3,
	range_foldl/5,
	foldl_decode/3,
	to_binary/1
	]).

	-export([
	max_attachment_size/0,
	validate_attachment_size/3
	]).

	-compile(nowarn_deprecated_type).
	-export_type([att/0]).


	-include_lib("couch/include/couch_db.hrl").


	-define(CURRENT_ATT_FORMAT, 0).


	-type prop_name() ::
	name \|
	type \|
	att_len \|
	disk_len \|
	md5 \|
	revpos \|
	data \|
	encoding.


	-type data_prop_type() ::
	{loc, #{}, binary(), binary()} \|
	stub \|
	follows \|
	binary() \|
	{follows, pid(), reference()} \|
	fun(() -> binary()).


	-type att() :: #{
	name := binary(),
	type := binary(),
	att_len := non_neg_integer() \| undefined,
	disk_len := non_neg_integer() \| undefined,
	md5 := binary() \| undefined,
	revpos := non_neg_integer(),
	data := data_prop_type(),
	encoding := identity \| gzip \| undefined,
	headers := [{binary(), binary()}] \| undefined
	}.


	new() ->
	#{
	name => <<>>,
	type => <<>>,
	att_len => undefined,
	disk_len => undefined,
	md5 => undefined,
	revpos => 0,
	data => undefined,
	encoding => undefined,
	headers => undefined
	}.


	-spec new([{prop_name(), any()}]) -> att().
	new(Props) ->
	store(Props, new()).


	-spec fetch([atom()], att()) -> [any()];
	(atom(), att()) -> any().
	fetch(Fields, Att) when is_list(Fields) ->
	[fetch(Field, Att) \|\| Field <- Fields];
	fetch(Field, Att) ->
	maps:get(Field, Att).


	-spec store([{atom(), any()}], att()) -> att().
	store(Props, Att0) ->
	lists:foldl(fun({Field, Value}, Att) ->
	maps:update(Field, Value, Att)
	end, Att0, Props).


	store(Field, Value, Att) ->
	maps:update(Field, Value, Att).


	-spec transform(atom(), fun(), att()) -> att().
	transform(Field, Fun, Att) ->
	maps:update_with(Field, Fun, Att).


	is_stub(#{data := stub}) -> true;
	is_stub(#{}) -> false.


	%% merge_stubs takes all stub attachments and replaces them with on disk
	%% attachments. It will return {missing, Name} if a stub isn't matched with
	%% an existing attachment on disk. If the revpos is supplied with the stub
	%% it is also only counted to match if is the same as the disk attachment.
	merge_stubs(MemAtts, DiskAtts) ->
	OnDisk = dict:from_list(
	[{fetch(name, Att), Att} \|\| Att <- DiskAtts]
	),
	merge_stubs(MemAtts, OnDisk, []).


	-spec merge_stubs([att()], dict:dict(), [att()]) -> [att()].
	merge_stubs([Att \| Rest], OnDisk, Merged) ->
	case fetch(data, Att) of
	stub ->
	[Name, Pos] = fetch([name, revpos], Att),
	case dict:find(Name, OnDisk) of
	{ok, DiskAtt} ->
	RevPos = fetch(revpos, DiskAtt),
	if
	%% We want to check for consistency between the stub and
	%% disk revpos here. If the stub's revpos is undefined
	%% it means it wasn't provided by the user and does not
	%% require being matched.
	RevPos == Pos orelse Pos == undefined ->
	merge_stubs(Rest, OnDisk, [DiskAtt \| Merged]);
	true ->
	{missing, Name}
	end;
	_ ->
	{missing, Name}
	end;
	_ ->
	merge_stubs(Rest, OnDisk, [Att \| Merged])
	end;
	merge_stubs([], _, Merged) ->
	{ok, lists:reverse(Merged)}.


	size_info([]) ->
	{ok, []};
	size_info(Atts) ->
	Info = lists:map(fun(Att) ->
	[{loc, _Db, _DocId, AttId}, AttLen] = fetch([data, att_len], Att),
	{AttId, AttLen}
	end, Atts),
	{ok, lists:usort(Info)}.


	%% When converting an attachment to disk term format, attempt to stay with the
	%% old format when possible. This should help make the attachment lazy upgrade
	%% as safe as possible, avoiding the need for complicated disk versioning
	%% schemes.
	to_disk_term(Att) ->
	{loc, #{}, _DocId, AttId} = fetch(data, Att),
	{?CURRENT_ATT_FORMAT, {
	fetch(name, Att),
	fetch(type, Att),
	AttId,
	fetch(att_len, Att),
	fetch(disk_len, Att),
	fetch(revpos, Att),
	fetch(md5, Att),
	fetch(encoding, Att),
	fetch(headers, Att)
	}}.


	from_disk_term(#{} = Db, DocId, {?CURRENT_ATT_FORMAT, Props}) ->
	{
	Name,
	Type,
	AttId,
	AttLen,
	DiskLen,
	RevPos,
	Md5,
	Encoding,
	Headers
	} = Props,
	new([
	{name, Name},
	{type, Type},
	{data, {loc, Db#{tx := undefined}, DocId, AttId}},
	{att_len, AttLen},
	{disk_len, DiskLen},
	{revpos, RevPos},
	{md5, Md5},
	{encoding, Encoding},
	{headers, Headers}
	]).


	%% from_json reads in embedded JSON attachments and creates usable attachment
	%% values. The attachment may be a stub,
	from_json(Name, Props) ->
	Type = couch_util:get_value(
	<<"content_type">>, Props, ?DEFAULT_ATTACHMENT_CONTENT_TYPE
	),
	Att = new([{name, Name}, {type, Type}]),
	IsStub = couch_util:get_value(<<"stub">>, Props),
	Follows = couch_util:get_value(<<"follows">>, Props),
	if
	IsStub -> stub_from_json(Att, Props);
	Follows -> follow_from_json(Att, Props);
	true -> inline_from_json(Att, Props)
	end.


	stub_from_json(Att, Props) ->
	{DiskLen, EncodedLen, Encoding} = encoded_lengths_from_json(Props),
	Digest = digest_from_json(Props),
	%% We specifically want undefined rather than the default 0 here to skip
	%% the revpos consistency check on stubs when it's not provided in the
	%% json object. See merge_stubs/3 for the stub check.
	RevPos = couch_util:get_value(<<"revpos">>, Props),
	store([
	{data, stub},
	{disk_len, DiskLen},
	{att_len, EncodedLen},
	{revpos, RevPos},
	{md5, Digest},
	{encoding, Encoding}
	], Att).


	follow_from_json(Att, Props) ->
	{DiskLen, EncodedLen, Encoding} = encoded_lengths_from_json(Props),
	Digest = digest_from_json(Props),
	RevPos = couch_util:get_value(<<"revpos">>, Props, 0),
	store([
	{data, follows},
	{disk_len, DiskLen},
	{att_len, EncodedLen},
	{revpos, RevPos},
	{md5, Digest},
	{encoding, Encoding}
	], Att).


	inline_from_json(Att, Props) ->
	B64Data = couch_util:get_value(<<"data">>, Props),
	try base64:decode(B64Data) of
	Data ->
	Length = size(Data),
	RevPos = couch_util:get_value(<<"revpos">>, Props, 0),
	store([
	{data, Data},
	{disk_len, Length},
	{att_len, Length},
	{revpos, RevPos}
	], Att)
	catch
	_:_ ->
	Name = fetch(name, Att),
	ErrMsg = <<"Invalid attachment data for ", Name/binary>>,
	throw({bad_request, ErrMsg})
	end.


	encoded_lengths_from_json(Props) ->
	Len = couch_util:get_value(<<"length">>, Props),
	case couch_util:get_value(<<"encoding">>, Props) of
	undefined ->
	Encoding = identity,
	EncodedLen = Len;
	EncodingValue ->
	EncodedLen = couch_util:get_value(<<"encoded_length">>, Props, Len),
	Encoding = list_to_existing_atom(binary_to_list(EncodingValue))
	end,
	{Len, EncodedLen, Encoding}.


	digest_from_json(Props) ->
	case couch_util:get_value(<<"digest">>, Props) of
	<<"md5-", EncodedMd5/binary>> -> base64:decode(EncodedMd5);
	_ -> <<>>
	end.


	to_json(Att, OutputData, DataToFollow, ShowEncoding) ->
	#{
	name := Name,
	type := Type,
	data := Data,
	disk_len := DiskLen,
	att_len := AttLen,
	revpos := RevPos,
	md5 := Md5,
	encoding := Encoding,
	headers := Headers
	} = Att,
	Props = [
	{<<"content_type">>, Type},
	{<<"revpos">>, RevPos}
	],
	DigestProp = case base64:encode(Md5) of
	<<>> -> [];
	Digest -> [{<<"digest">>, <<"md5-", Digest/binary>>}]
	end,
	DataProps = if
	not OutputData orelse Data == stub ->
	[{<<"length">>, DiskLen}, {<<"stub">>, true}];
	DataToFollow ->
	[{<<"length">>, DiskLen}, {<<"follows">>, true}];
	true ->
	AttData = case Encoding of
	gzip -> zlib:gunzip(to_binary(Att));
	identity -> to_binary(Att)
	end,
	[{<<"data">>, base64:encode(AttData)}]
	end,
	EncodingProps = if
	ShowEncoding andalso Encoding /= identity ->
	[
	{<<"encoding">>, couch_util:to_binary(Encoding)},
	{<<"encoded_length">>, AttLen}
	];
	true ->
	[]
	end,
	HeadersProp = case Headers of
	undefined -> [];
	Headers -> [{<<"headers">>, Headers}]
	end,
	{Name, {Props ++ DigestProp ++ DataProps ++ EncodingProps ++ HeadersProp}}.


	flush(Db, DocId, Att1) ->
	Att2 = read_data(fetch(data, Att1), Att1),
	[
	Data,
	AttLen,
	DiskLen,
	ReqMd5,
	Encoding
	] = fetch([data, att_len, disk_len, md5, encoding], Att2),

	% Eventually, we'll check if we can compress this
	% attachment here and do so if possible.

	% If we were sent a gzip'ed attachment with no
	% length data, we have to set it here.
	Att3 = case DiskLen of
	undefined -> store(disk_len, AttLen, Att2);
	_ -> Att2
	end,

	% If no encoding has been set, default to
	% identity
	Att4 = case Encoding of
	undefined -> store(encoding, identity, Att3);
	_ -> Att3
	end,

	case Data of
	{loc, _, _, _} ->
	% Already flushed
	Att1;
	_ when is_binary(Data) ->
	DataMd5 = couch_hash:md5_hash(Data),
	if ReqMd5 == undefined -> ok; true ->
	couch_util:check_md5(DataMd5, ReqMd5)
	end,
	Att5 = store(md5, DataMd5, Att4),
	Att6 = maybe_compress(Att5),
	fabric2_db:write_attachment(Db, DocId, Att6)
	end.


	read_data({loc, #{}, _DocId, _AttId}, Att) ->
	% Attachment already written to fdb
	Att;

	read_data({follows, Parser, Ref}, Att) ->
	ParserRef = erlang:monitor(process, Parser),
	Fun = fun() ->
	Parser ! {get_bytes, Ref, self()},
	receive
	{started_open_doc_revs, NewRef} ->
	couch_doc:restart_open_doc_revs(Parser, Ref, NewRef);
	{bytes, Ref, Bytes} ->
	Bytes;
	{'DOWN', ParserRef, _, _, Reason} ->
	throw({mp_parser_died, Reason})
	end
	end,
	try
	read_data(Fun, store(data, Fun, Att))
	after
	erlang:demonitor(ParserRef, [flush])
	end;

	read_data(Data, Att) when is_binary(Data) ->
	Att;

	read_data(Fun, Att) when is_function(Fun) ->
	[AttName, AttLen, InMd5] = fetch([name, att_len, md5], Att),
	MaxAttSize = max_attachment_size(),
	case AttLen of
	undefined ->
	% Fun(MaxChunkSize, WriterFun) must call WriterFun
	% once for each chunk of the attachment,
	WriterFun = fun
	({0, Footers}, {Len, Acc}) ->
	F = mochiweb_headers:from_binary(Footers),
	Md5 = case mochiweb_headers:get_value("Content-MD5", F) of
	undefined -> undefined;
	Value -> base64:decode(Value)
	end,
	Props0 = [
	{data, iolist_to_binary(lists:reverse(Acc))},
	{att_len, Len}
	],
	Props1 = if InMd5 /= md5_in_footer -> Props0; true ->
	[{md5, Md5} \| Props0]
	end,
	store(Props1, Att);
	({ChunkLen, Chunk}, {Len, Acc}) ->
	NewLen = Len + ChunkLen,
	validate_attachment_size(AttName, NewLen, MaxAttSize),
	{NewLen, [Chunk \| Acc]}
	end,
	Fun(8192, WriterFun, {0, []});
	AttLen ->
	validate_attachment_size(AttName, AttLen, MaxAttSize),
	read_streamed_attachment(Att, Fun, AttLen, [])
	end.


	read_streamed_attachment(Att, _F, 0, Acc) ->
	Bin = iolist_to_binary(lists:reverse(Acc)),
	store([
	{data, Bin},
	{att_len, size(Bin)}
	], Att);

	read_streamed_attachment(_Att, _F, LenLeft, _Acc) when LenLeft < 0 ->
	throw({bad_request, <<"attachment longer than expected">>});

	read_streamed_attachment(Att, F, LenLeft, Acc) when LenLeft > 0 ->
	Bin = try
	read_next_chunk(F, LenLeft)
	catch
	{mp_parser_died, normal} ->
	throw({bad_request, <<"attachment shorter than expected">>})
	end,
	Size = iolist_size(Bin),
	read_streamed_attachment(Att, F, LenLeft - Size, [Bin \| Acc]).


	read_next_chunk(F, _) when is_function(F, 0) ->
	F();

	read_next_chunk(F, LenLeft) when is_function(F, 1) ->
	F(lists:min([LenLeft, 16#2000])).


	foldl(Att, Fun, Acc) ->
	foldl(fetch(data, Att), Att, Fun, Acc).


	foldl({loc, Db, DocId, AttId}, _Att, Fun, Acc) ->
	Bin = fabric2_db:read_attachment(Db#{tx := undefined}, DocId, AttId),
	Fun(Bin, Acc);

	foldl(Bin, _Att, Fun, Acc) when is_binary(Bin) ->
	Fun(Bin, Acc);

	foldl(DataFun, Att, Fun, Acc) when is_function(DataFun) ->
	Len = fetch(att_len, Att),
	fold_streamed_data(DataFun, Len, Fun, Acc);

	foldl({follows, Parser, Ref}, Att, Fun, Acc) ->
	ParserRef = erlang:monitor(process, Parser),
	DataFun = fun() ->
	Parser ! {get_bytes, Ref, self()},
	receive
	{started_open_doc_revs, NewRef} ->
	couch_doc:restart_open_doc_revs(Parser, Ref, NewRef);
	{bytes, Ref, Bytes} ->
	Bytes;
	{'DOWN', ParserRef, _, _, Reason} ->
	throw({mp_parser_died, Reason})
	end
	end,
	try
	foldl(DataFun, store(data, DataFun, Att), Fun, Acc)
	after
	erlang:demonitor(ParserRef, [flush])
	end.


	range_foldl(Bin1, From, To, Fun, Acc) when is_binary(Bin1) ->
	ReadLen = To - From,
	Bin2 = case Bin1 of
	_ when size(Bin1) < From -> <<>>;
	<<_:From/binary, B2>> -> B2
	end,
	Bin3 = case Bin2 of
	_ when size(Bin2) < ReadLen -> Bin2;
	<<B3:ReadLen/binary, _/binary>> -> B3
	end,
	Fun(Bin3, Acc);

	range_foldl(Att, From, To, Fun, Acc) ->
	{loc, Db, DocId, AttId} = fetch(data, Att),
	Bin = fabric2_db:read_attachment(Db, DocId, AttId),
	range_foldl(Bin, From, To, Fun, Acc).


	foldl_decode(Att, Fun, Acc) ->
	[Encoding, Data] = fetch([encoding, data], Att),
	case {Encoding, Data} of
	{gzip, {loc, Db, DocId, AttId}} ->
	NoTxDb = Db#{tx := undefined},
	Bin = fabric2_db:read_attachment(NoTxDb, DocId, AttId),
	foldl_decode(store(data, Bin, Att), Fun, Acc);
	{gzip, _} when is_binary(Data) ->
	Z = zlib:open(),
	ok = zlib:inflateInit(Z, 16 + 15),
	Inflated = iolist_to_binary(zlib:inflate(Z, Data)),
	ok = zlib:inflateEnd(Z),
	ok = zlib:close(Z),
	foldl(Inflated, Att, Fun, Acc);
	_ ->
	foldl(Att, Fun, Acc)
	end.


	to_binary(Att) ->
	to_binary(fetch(data, Att), Att).


	to_binary(Bin, _Att) when is_binary(Bin) ->
	Bin;
	to_binary(Iolist, _Att) when is_list(Iolist) ->
	iolist_to_binary(Iolist);
	to_binary({loc, Db, DocId, AttId}, _Att) ->
	NoTxDb = Db#{tx := undefined},
	fabric2_db:read_attachment(NoTxDb, DocId, AttId);
	to_binary(DataFun, Att) when is_function(DataFun)->
	Len = fetch(att_len, Att),
	iolist_to_binary(
	lists:reverse(fold_streamed_data(
	DataFun,
	Len,
	fun(Data, Acc) -> [Data \| Acc] end,
	[]
	))
	).


	fold_streamed_data(_RcvFun, 0, _Fun, Acc) ->
	Acc;

	fold_streamed_data(RcvFun, LenLeft, Fun, Acc) when LenLeft > 0->
	Bin = RcvFun(),
	ResultAcc = Fun(Bin, Acc),
	fold_streamed_data(RcvFun, LenLeft - size(Bin), Fun, ResultAcc).


	maybe_compress(Att) ->
	[Encoding, Type] = fetch([encoding, type], Att),
	IsCompressible = is_compressible(Type),
	CompLevel = config:get_integer("attachments", "compression_level", 0),
	case Encoding of
	identity when IsCompressible, CompLevel >= 1, CompLevel =< 9 ->
	compress(Att, CompLevel);
	_ ->
	Att
	end.


	compress(Att, Level) ->
	Data = fetch(data, Att),

	Z = zlib:open(),
	% 15 = ?MAX_WBITS (defined in the zlib module)
	% the 16 + ?MAX_WBITS formula was obtained by inspecting zlib:gzip/1
	ok = zlib:deflateInit(Z, Level, deflated, 16 + 15, 8, default),
	CompData = iolist_to_binary(zlib:deflate(Z, Data, finish)),
	ok = zlib:deflateEnd(Z),
	ok = zlib:close(Z),

	store([
	{att_len, size(CompData)},
	{md5, couch_hash:md5_hash(CompData)},
	{data, CompData},
	{encoding, gzip}
	], Att).


	is_compressible(Type) when is_binary(Type) ->
	is_compressible(binary_to_list(Type));
	is_compressible(Type) ->
	TypeExpList = re:split(
	config:get("attachments", "compressible_types", ""),
	"\\s,\\s",
	[{return, list}]
	),
	lists:any(
	fun(TypeExp) ->
	Regexp = ["^\\s", re:replace(TypeExp, "\\", ".*"),
	"(?:\\s;.?)?\\s*", $$],
	re:run(Type, Regexp, [caseless]) =/= nomatch
	end,
	[T \|\| T <- TypeExpList, T /= []]
	).


	max_attachment_size() ->
	case config:get("couchdb", "max_attachment_size", "infinity") of
	"infinity" ->
	infinity;
	MaxAttSize ->
	list_to_integer(MaxAttSize)
	end.


	validate_attachment_size(AttName, AttSize, MaxAttSize)
	when is_integer(AttSize), AttSize > MaxAttSize ->
	throw({request_entity_too_large, {attachment, AttName}});
	validate_attachment_size(_AttName, _AttSize, _MAxAttSize) ->
	ok.


	%% -ifdef(TEST).
	%% -include_lib("eunit/include/eunit.hrl").
	%%
	%% % Eww...
	%% -include("couch_bt_engine.hrl").
	%%
	%% %% Test utilities
	%%
	%%
	%% empty_att() -> new().
	%%
	%%
	%% upgraded_empty_att() ->
	%% new([{headers, undefined}]).
	%%
	%%
	%% %% Test groups
	%%
	%%
	%% attachment_upgrade_test_() ->
	%% {"Lazy record upgrade tests", [
	%% {"Existing record fields don't upgrade",
	%% {with, empty_att(), [fun test_non_upgrading_fields/1]}
	%% },
	%% {"New fields upgrade",
	%% {with, empty_att(), [fun test_upgrading_fields/1]}
	%% }
	%% ]}.
	%%
	%%
	%% attachment_defaults_test_() ->
	%% {"Attachment defaults tests", [
	%% {"Records retain old default values", [
	%% {with, empty_att(), [fun test_legacy_defaults/1]}
	%% ]},
	%% {"Upgraded records inherit defaults", [
	%% {with, upgraded_empty_att(), [fun test_legacy_defaults/1]}
	%% ]},
	%% {"Undefined entries are elided on upgrade", [
	%% {with, upgraded_empty_att(), [fun test_elided_entries/1]}
	%% ]}
	%% ]}.
	%%
	%% attachment_field_api_test_() ->
	%% {"Basic attachment field api", [
	%% fun test_construction/0,
	%% fun test_store_and_fetch/0,
	%% fun test_transform/0
	%% ]}.
	%%
	%%
	%% attachment_disk_term_test_() ->
	%% BaseAttachment = new([
	%% {name, <<"empty">>},
	%% {type, <<"application/octet-stream">>},
	%% {att_len, 0},
	%% {disk_len, 0},
	%% {md5, <<212,29,140,217,143,0,178,4,233,128,9,152,236,248,66,126>>},
	%% {revpos, 4},
	%% {data, {stream, {couch_bt_engine_stream, {fake_fd, fake_sp}}}},
	%% {encoding, identity}
	%% ]),
	%% BaseDiskTerm = {
	%% <<"empty">>,
	%% <<"application/octet-stream">>,
	%% fake_sp,
	%% 0, 0, 4,
	%% <<212,29,140,217,143,0,178,4,233,128,9,152,236,248,66,126>>,
	%% identity
	%% },
	%% Headers = [{<<"X-Foo">>, <<"bar">>}],
	%% ExtendedAttachment = store(headers, Headers, BaseAttachment),
	%% ExtendedDiskTerm = {BaseDiskTerm, [{headers, Headers}]},
	%% FakeDb = test_util:fake_db([{engine, {couch_bt_engine, #st{fd=fake_fd}}}]),
	%% {"Disk term tests", [
	%% ?_assertEqual(BaseDiskTerm, to_disk_term(BaseAttachment)),
	%% ?_assertEqual(BaseAttachment, from_disk_term(FakeDb, BaseDiskTerm)),
	%% ?_assertEqual(ExtendedDiskTerm, to_disk_term(ExtendedAttachment)),
	%% ?_assertEqual(ExtendedAttachment, from_disk_term(FakeDb, ExtendedDiskTerm))
	%% ]}.
	%%
	%%
	%% attachment_json_term_test_() ->
	%% Props = [
	%% {<<"content_type">>, <<"application/json">>},
	%% {<<"digest">>, <<"md5-QCNtWUNXV0UzJnEjMk92YUk1JA==">>},
	%% {<<"length">>, 14},
	%% {<<"revpos">>, 1}
	%% ],
	%% PropsInline = [{<<"data">>, <<"eyJhbnN3ZXIiOiA0Mn0=">>}] ++ Props,
	%% InvalidProps = [{<<"data">>, <<"!Base64Encoded$">>}] ++ Props,
	%% Att = couch_att:new([
	%% {name, <<"attachment.json">>},
	%% {type, <<"application/json">>}
	%% ]),
	%% ResultStub = couch_att:new([
	%% {name, <<"attachment.json">>},
	%% {type, <<"application/json">>},
	%% {att_len, 14},
	%% {disk_len, 14},
	%% {md5, <<"@#mYCWWE3&q#2OvaI5$">>},
	%% {revpos, 1},
	%% {data, stub},
	%% {encoding, identity}
	%% ]),
	%% ResultFollows = ResultStub#att{data = follows},
	%% ResultInline = ResultStub#att{md5 = <<>>, data = <<"{\"answer\": 42}">>},
	%% {"JSON term tests", [
	%% ?_assertEqual(ResultStub, stub_from_json(Att, Props)),
	%% ?_assertEqual(ResultFollows, follow_from_json(Att, Props)),
	%% ?_assertEqual(ResultInline, inline_from_json(Att, PropsInline)),
	%% ?_assertThrow({bad_request, _}, inline_from_json(Att, Props)),
	%% ?_assertThrow({bad_request, _}, inline_from_json(Att, InvalidProps))
	%% ]}.
	%%
	%%
	%% attachment_stub_merge_test_() ->
	%% %% Stub merging needs to demonstrate revpos matching, skipping, and missing
	%% %% attachment errors.
	%% {"Attachment stub merging tests", []}.
	%%
	%%
	%% %% Test generators
	%%
	%%
	%% test_non_upgrading_fields(Attachment) ->
	%% Pairs = [
	%% {name, "cat.gif"},
	%% {type, "text/very-very-plain"},
	%% {att_len, 1024},
	%% {disk_len, 42},
	%% {md5, <<"md5-hashhashhash">>},
	%% {revpos, 4},
	%% {data, stub},
	%% {encoding, gzip}
	%% ],
	%% lists:foreach(
	%% fun({Field, Value}) ->
	%% ?assertMatch(#att{}, Attachment),
	%% Updated = store(Field, Value, Attachment),
	%% ?assertMatch(#att{}, Updated)
	%% end,
	%% Pairs).
	%%
	%%
	%% test_upgrading_fields(Attachment) ->
	%% ?assertMatch(#att{}, Attachment),
	%% UpdatedHeaders = store(headers, [{<<"Ans">>, <<"42">>}], Attachment),
	%% ?assertMatch(X when is_list(X), UpdatedHeaders),
	%% UpdatedHeadersUndefined = store(headers, undefined, Attachment),
	%% ?assertMatch(X when is_list(X), UpdatedHeadersUndefined).
	%%
	%%
	%% test_legacy_defaults(Attachment) ->
	%% ?assertEqual(<<>>, fetch(md5, Attachment)),
	%% ?assertEqual(0, fetch(revpos, Attachment)),
	%% ?assertEqual(identity, fetch(encoding, Attachment)).
	%%
	%%
	%% test_elided_entries(Attachment) ->
	%% ?assertNot(lists:keymember(name, 1, Attachment)),
	%% ?assertNot(lists:keymember(type, 1, Attachment)),
	%% ?assertNot(lists:keymember(att_len, 1, Attachment)),
	%% ?assertNot(lists:keymember(disk_len, 1, Attachment)),
	%% ?assertNot(lists:keymember(data, 1, Attachment)).
	%%
	%%
	%% test_construction() ->
	%% ?assert(new() == new()),
	%% Initialized = new([{name, <<"foo.bar">>}, {type, <<"application/qux">>}]),
	%% ?assertEqual(<<"foo.bar">>, fetch(name, Initialized)),
	%% ?assertEqual(<<"application/qux">>, fetch(type, Initialized)).
	%%
	%%
	%% test_store_and_fetch() ->
	%% Attachment = empty_att(),
	%% ?assertEqual(<<"abc">>, fetch(name, store(name, <<"abc">>, Attachment))),
	%% ?assertEqual(42, fetch(ans, store(ans, 42, Attachment))).
	%%
	%%
	%% test_transform() ->
	%% Attachment = new([{counter, 0}]),
	%% Transformed = transform(counter, fun(Count) -> Count + 1 end, Attachment),
	%% ?assertEqual(1, fetch(counter, Transformed)).
	%%
	%%
	%% -endif.