telegram_bot_api_webhook_server (telegram_bot_api v2.0.0)

View Source

The server that runs the cowboy rest api to receive webhook data.

Allows you to add or remove new handlers for bots.

See telegram_bot_api

Summary

Types

bot()

-type bot() :: #{event := telegram_bot_api_app:event(), name := webhook_botname_param()}.

bots()

-type bots() :: #{webhook_botname() := bot()} | #{}.

Example:

            #{
                <<"webhook_botname1">>=>#{
                    event=>{global,gen_event_server_bot1},
                    name=>bot_pool1
                },
                <<"bot2">>=>#{
                    event=>{global,gen_event_server_bot2},
                    name=>bot_pool2
                },
            }

filename()

-type filename() :: binary() | string().

http2_opts()

-type http2_opts() ::
          #{active_n => pos_integer(),
            alpn_default_protocol => http | http2,
            compress_buffering => boolean(),
            compress_threshold => non_neg_integer(),
            connection_type => worker | supervisor,
            connection_window_margin_size => 0..2147483647,
            connection_window_update_threshold => 0..2147483647,
            dynamic_buffer => false | {pos_integer(), pos_integer()},
            dynamic_buffer_initial_average => non_neg_integer(),
            dynamic_buffer_initial_size => pos_integer(),
            enable_connect_protocol => boolean(),
            env => cowboy_middleware:env(),
            goaway_initial_timeout => timeout(),
            goaway_complete_timeout => timeout(),
            hibernate => boolean(),
            idle_timeout => timeout(),
            inactivity_timeout => timeout(),
            initial_connection_window_size => 65535..2147483647,
            initial_stream_window_size => 0..2147483647,
            linger_timeout => timeout(),
            logger => module(),
            max_concurrent_streams => non_neg_integer() | infinity,
            max_connection_buffer_size => non_neg_integer(),
            max_connection_window_size => 0..2147483647,
            max_decode_table_size => non_neg_integer(),
            max_encode_table_size => non_neg_integer(),
            max_fragmented_header_block_size => 16384..2147483647,
            max_frame_size_received => 16384..16777215,
            max_frame_size_sent => 16384..16777215 | infinity,
            max_received_frame_rate => {pos_integer(), timeout()},
            max_reset_stream_rate => {pos_integer(), timeout()},
            max_cancel_stream_rate => {pos_integer(), timeout()},
            max_stream_buffer_size => non_neg_integer(),
            max_stream_window_size => 0..2147483647,
            metrics_callback => cowboy_metrics_h:metrics_callback(),
            metrics_req_filter => fun((cowboy_req:req()) -> map()),
            metrics_resp_headers_filter => fun((cowboy:http_headers()) -> cowboy:http_headers()),
            middlewares => [module()],
            preface_timeout => timeout(),
            protocols => [http | http2],
            proxy_header => boolean(),
            reset_idle_timeout_on_send => boolean(),
            sendfile => boolean(),
            settings_timeout => timeout(),
            shutdown_timeout => timeout(),
            stream_handlers => [module()],
            stream_window_data_threshold => 0..2147483647,
            stream_window_margin_size => 0..2147483647,
            stream_window_update_threshold => 0..2147483647,
            tracer_callback => cowboy_tracer_h:tracer_callback(),
            tracer_flags => [atom()],
            tracer_match_specs => cowboy_tracer_h:tracer_match_specs(),
            _ => _}.

http_opts()

-type http_opts() ::
          #{active_n => pos_integer(),
            alpn_default_protocol => http | http2,
            chunked => boolean(),
            compress_buffering => boolean(),
            compress_threshold => non_neg_integer(),
            connection_type => worker | supervisor,
            dynamic_buffer => false | {pos_integer(), pos_integer()},
            dynamic_buffer_initial_average => non_neg_integer(),
            dynamic_buffer_initial_size => pos_integer(),
            env => cowboy_middleware:env(),
            hibernate => boolean(),
            http10_keepalive => boolean(),
            idle_timeout => timeout(),
            inactivity_timeout => timeout(),
            initial_stream_flow_size => non_neg_integer(),
            linger_timeout => timeout(),
            logger => module(),
            max_authority_length => non_neg_integer(),
            max_empty_lines => non_neg_integer(),
            max_header_name_length => non_neg_integer(),
            max_header_value_length => non_neg_integer(),
            max_headers => non_neg_integer(),
            max_keepalive => non_neg_integer(),
            max_method_length => non_neg_integer(),
            max_request_line_length => non_neg_integer(),
            metrics_callback => cowboy_metrics_h:metrics_callback(),
            metrics_req_filter => fun((cowboy_req:req()) -> map()),
            metrics_resp_headers_filter => fun((cowboy:http_headers()) -> cowboy:http_headers()),
            middlewares => [module()],
            protocols => [http | http2],
            proxy_header => boolean(),
            request_timeout => timeout(),
            reset_idle_timeout_on_send => boolean(),
            sendfile => boolean(),
            shutdown_timeout => timeout(),
            stream_handlers => [module()],
            tracer_callback => cowboy_tracer_h:tracer_callback(),
            tracer_flags => [atom()],
            tracer_match_specs => cowboy_tracer_h:tracer_match_specs(),
            _ => _}.

log_level()

-type log_level() :: logger:level() | none | all.

protocol_opts()

-type protocol_opts() :: http_opts() | http2_opts().

Example:

        #{
        ip=>{0,0,0,0},
        port=>8443,
        certfile=><<"/etc/telegram_bot_api/ssl/YOURPUBLIC.pem">>,
        keyfile=><<"/etc/telegram_bot_api/ssl/YOURPRIVATE.key">>,
        verify=> verify_none
        }

transport_opts()

-type transport_opts() ::
          #{ip := inet:ip_address() | inet:local_address(),
            port := inet:port_number(),
            backlog => non_neg_integer(),
            buffer => non_neg_integer(),
            delay_send => boolean(),
            dontroute => boolean(),
            exit_on_close => boolean(),
            fd => non_neg_integer(),
            high_msgq_watermark => non_neg_integer(),
            high_watermark => non_neg_integer(),
            inet => true,
            inet6 => true,
            ipv6_v6only => boolean(),
            keepalive => boolean(),
            linger => boolean() | non_neg_integer(),
            low_msgq_watermark => non_neg_integer(),
            low_watermark => non_neg_integer(),
            nodelay => boolean(),
            priority => integer(),
            raw => non_neg_integer() | non_neg_integer() | binary(),
            recbuf => non_neg_integer(),
            send_timeout => timeout(),
            send_timeout_close => boolean(),
            sndbuf => non_neg_integer(),
            tos => integer(),
            alpn_preferred_protocols => [binary()],
            anti_replay => '10k' | '100k' | {integer(), integer(), integer()},
            beast_mitigation => one_n_minus_one | zero_n | disabled,
            cacertfile => filename(),
            cacerts => [public_key:der_encoded()],
            cert => public_key:der_encoded(),
            certs_keys =>
                [#{cert => public_key:der_encoded(),
                   key => ssl:key(),
                   certfile => filename(),
                   keyfile => filename(),
                   key_pem_password => iodata() | fun(() -> iodata())}],
            certfile => filename(),
            ciphers => ssl:ciphers(),
            client_renegotiation => boolean(),
            crl_cache => [any()],
            crl_check => boolean() | peer | best_effort,
            depth => integer(),
            dh => binary(),
            dhfile => filename(),
            eccs => [ssl:named_curve()],
            fail_if_no_peer_cert => boolean(),
            handshake => hello | full,
            hibernate_after => timeout(),
            honor_cipher_order => boolean(),
            honor_ecc_order => boolean(),
            key => ssl:key(),
            key_update_at => pos_integer(),
            keyfile => filename(),
            log_alert => boolean(),
            log_level => log_level(),
            max_handshake_size => integer(),
            middlebox_comp_mode => boolean(),
            next_protocols_advertised => [binary()],
            padding_check => boolean(),
            partial_chain => fun(),
            password => string(),
            protocol => tls | dtls,
            psk_identity => string(),
            reuse_session => fun(),
            reuse_sessions => boolean(),
            secure_renegotiate => boolean(),
            session_tickets => disabled | stateful | stateless,
            signature_algs => [{ssl:hash(), ssl:sign_algo()}],
            signature_algs_cert => [ssl:sign_scheme()],
            sni_fun => fun(),
            sni_hosts => [{string(), any()}],
            supported_groups => [ssl:group()],
            user_lookup_fun => {fun(), any()},
            verify => verify_none | verify_peer,
            verify_fun => {fun(), any()},
            versions => [ssl:protocol_version()],
            _ => _}.

webhook_botname()

-type webhook_botname() :: binary().

webhook_botname_param()

-type webhook_botname_param() :: atom() | telegram_bot_api:pool_name().

webhook_pid()

-type webhook_pid() :: atom() | {atom(), node()} | {global, term()} | {via, atom(), term()} | pid().

Functions

add_bot(Pid, Name, Bot)

-spec add_bot(Pid :: webhook_pid(), Name :: webhook_botname(), Bot :: bot()) -> ok | term().

Adds a new bot to the webhook api

Example:

    %%URL=https://myip:myport/telegram/webhook_botname123/update
    ok= telegram_bot_api_webhook_server:add_bot({global,WebhookServer},<<"webhook_botname123">
     		#{
     				event=>{global,BotEvent},
     				name=>bot1
     		}
     )

child_spec/1

code_change(OldVsn, State, Extra)

delete_bot(Pid, Name)

-spec delete_bot(Pid :: webhook_pid(), Name :: webhook_botname()) -> ok | term().

get_port(Pid)

handle_call/3

handle_cast(Msg, State)

handle_info(Info, State)

init/1

make_url(Ip, Port, BotName)

make_url(Scheme, Ip, Port, BotName)

name_server/2

start_link(Opts)

-spec start_link(Opts ::
                     #{id := Id :: term(),
                       bots => Boots :: bots(),
                       secret_token := WebhookSecretToken :: telegram_bot_api:secret_token(),
                       transport_opts := TransportOpts :: transport_opts(),
                       protocol_opts => ProtocolOpts :: protocol_opts()}) ->
                    {ok, pid()} | {error, {already_started, pid()}} | {error, term()}.

stop(Pid)

terminate/2