class DispatcherConfig(BaseWorker.CONFIG_CLASS):
receive_inbound_connectors = ConfigList(
"List of connectors that will receive inbound messages and events.",
required=True,
static=True)
receive_outbound_connectors = ConfigList(
"List of connectors that will receive outbound messages.",
required=True,
static=True)
class MxitTransportConfig(HttpRpcTransport.CONFIG_CLASS):
client_id = ConfigText('The OAuth2 ClientID assigned to this transport.',
required=True,
static=True)
client_secret = ConfigText(
'The OAuth2 ClientSecret assigned to this transport.',
required=True,
static=True)
timeout = ConfigInt('Timeout for outbound Mxit HTTP API calls.',
required=False,
default=30,
static=True)
redis_manager = ConfigDict('How to connect to Redis',
required=True,
static=True)
api_send_url = ConfigText('The URL for the Mxit message sending API.',
required=False,
default="https://api.mxit.com/message/send/",
static=True)
api_auth_url = ConfigText('The URL for the Mxit authentication API.',
required=False,
default='https://auth.mxit.com',
static=True)
api_auth_scopes = ConfigList('The list of scopes to request access to.',
required=False,
static=True,
default=['message/send'])
class SequentialSendConfig(GoApplicationWorker.CONFIG_CLASS):
poll_interval = ConfigInt(
"Interval between polling watched conversations for scheduled events.",
default=60,
static=True)
schedule = ConfigDict("Scheduler config.")
messages = ConfigList("List of messages to send in sequence")
class HttpApiConfig(HttpRpcTransport.CONFIG_CLASS):
"HTTP API configuration."
reply_expected = ConfigBool(
"True if a reply message is expected.", default=False, static=True)
allowed_fields = ConfigList(
"The list of fields a request is allowed to contain. Defaults to the"
" DEFAULT_ALLOWED_FIELDS class attribute.", static=True)
field_defaults = ConfigDict(
"Default values for fields not sent by the client.",
default={}, static=True)
class RapidSMSRelayConfig(ApplicationWorker.CONFIG_CLASS):
"""RapidSMS relay configuration."""
web_path = ConfigText(
"Path to listen for outbound messages from RapidSMS on.", static=True)
web_port = ConfigInt(
"Port to listen for outbound messages from RapidSMS on.", static=True)
redis_manager = ConfigDict(
"Redis manager configuration (only required if"
" `allow_replies` is true)",
default={},
static=True)
allow_replies = ConfigBool(
"Whether to support replies via the `in_reply_to` argument"
" from RapidSMS.",
default=True,
static=True)
vumi_username = ConfigText(
"Username required when calling `web_path` (default: no"
" authentication)",
default=None)
vumi_password = ConfigText("Password required when calling `web_path`",
default=None)
vumi_auth_method = ConfigText(
"Authentication method required when calling `web_path`."
"The 'basic' method is currently the only available method",
default='basic')
vumi_reply_timeout = ConfigInt(
"Number of seconds to keep original messages in redis so that"
" replies may be sent via `in_reply_to`.",
default=10 * 60)
allowed_endpoints = ConfigList('List of allowed endpoints to send from.',
required=True,
default=("default", ))
rapidsms_url = ConfigUrl("URL of the rapidsms http backend.")
rapidsms_username = ConfigText(
"Username to use for the `rapidsms_url` (default: no authentication)",
default=None)
rapidsms_password = ConfigText("Password to use for the `rapidsms_url`",
default=None)
rapidsms_auth_method = ConfigText(
"Authentication method to use with `rapidsms_url`."
" The 'basic' method is currently the only available method.",
default='basic')
rapidsms_http_method = ConfigText(
"HTTP request method to use for the `rapidsms_url`", default='POST')
class SandboxConfig(ApplicationWorker.CONFIG_CLASS):
sandbox = ConfigDict(
"Dictionary of resources to provide to the sandbox."
" Keys are the names of resources (as seen inside the sandbox)."
" Values are dictionaries which must contain a `cls` key that"
" gives the full name of the class that provides the resource."
" Other keys are additional configuration for that resource.",
default={},
static=True)
executable = ConfigText(
"Full path to the executable to run in the sandbox.")
args = ConfigList(
"List of arguments to pass to the executable (not including"
" the path of the executable itself).",
default=[])
path = ConfigText("Current working directory to run the executable in.")
env = ConfigDict("Custom environment variables for the sandboxed process.",
default={})
timeout = ConfigInt(
"Length of time the subprocess is given to process a message.",
default=60)
recv_limit = ConfigInt(
"Maximum number of bytes that will be read from a sandboxed"
" process' stdout and stderr combined.",
default=1024 * 1024)
rlimits = ConfigDict(
"Dictionary of resource limits to be applied to sandboxed"
" processes. Defaults are fairly restricted. Keys maybe"
" names or values of the RLIMIT constants in"
" Python `resource` module. Values should be appropriate integers.",
default={})
logging_resource = ConfigText(
"Name of the logging resource to use to report errors detected"
" in sandboxed code (e.g. lines written to stderr, unexpected"
" process termination). Set to null to disable and report"
" these directly using Twisted logging instead.",
default=None)
sandbox_id = ConfigText("This is set based on individual messages.")
class ApplicationMultiplexerConfig(GoRouterWorker.CONFIG_CLASS):
# Static configuration
session_expiry = ConfigInt(
"Maximum amount of time in seconds to keep session data around",
default=300, static=True)
# Dynamic, per-message configuration
menu_title = ConfigDict(
"Content for the menu title",
default={'content': "Please select a choice."})
entries = ConfigList(
"A list of application endpoints and associated labels",
default=[])
invalid_input_message = ConfigText(
"Prompt to display when warning about an invalid choice",
default=("That is an incorrect choice. Please enter the number "
"of the menu item you wish to choose.\n\n 1) Try Again"))
error_message = ConfigText(
("Prompt to display when a configuration change invalidates "
"an active session."),
default=("Oops! We experienced a temporary error. "
"Please try and dial the line again."))
class GroupRouterConfig(GoRouterWorker.CONFIG_CLASS):
rules = ConfigList("List of groups and endpoint pairs", default=[])