You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by rr...@apache.org on 2019/04/27 01:34:10 UTC
[trafficserver] branch master updated: Purges log collation feature
This is an automated email from the ASF dual-hosted git repository.
rrm pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/trafficserver.git
The following commit(s) were added to refs/heads/master by this push:
new 82d5644 Purges log collation feature
82d5644 is described below
commit 82d564486e058ead160bfb8ad15e40b0507ff8aa
Author: Randall Meyer <ra...@yahoo.com>
AuthorDate: Mon Apr 22 14:11:02 2019 +0800
Purges log collation feature
This implements the deprecation noted in 26b30870d656eb26d752b7f7f841dbfb6e93c970
---
doc/.tx/config | 5 -
doc/admin-guide/files/logging.yaml.en.rst | 7 -
doc/admin-guide/files/records.config.en.rst | 99 +---
doc/admin-guide/logging/destinations.en.rst | 137 +-----
doc/admin-guide/logging/formatting.en.rst | 23 -
doc/admin-guide/logging/rotation.en.rst | 3 +-
doc/admin-guide/performance/index.en.rst | 1 -
include/ts/ts.h | 3 +-
iocore/cache/Makefile.am | 1 -
iocore/eventsystem/I_Event.h | 1 -
lib/perl/lib/Apache/TS/AdminClient.pm | 7 -
mgmt/RecordsConfig.cc | 22 +-
proxy/README-stats.otl | 1 -
proxy/logging/Log.cc | 263 ++--------
proxy/logging/Log.h | 12 +-
proxy/logging/LogBuffer.cc | 1 -
proxy/logging/LogCollationAccept.cc | 105 ----
proxy/logging/LogCollationAccept.h | 42 --
proxy/logging/LogCollationBase.h | 45 --
proxy/logging/LogCollationClientSM.cc | 716 ---------------------------
proxy/logging/LogCollationClientSM.h | 116 -----
proxy/logging/LogCollationHostSM.cc | 527 --------------------
proxy/logging/LogCollationHostSM.h | 109 -----
proxy/logging/LogConfig.cc | 196 +-------
proxy/logging/LogConfig.h | 29 +-
proxy/logging/LogFile.cc | 2 -
proxy/logging/LogFile.h | 1 -
proxy/logging/LogFilter.cc | 1 -
proxy/logging/LogFormat.cc | 27 -
proxy/logging/LogHost.cc | 466 ------------------
proxy/logging/LogHost.h | 165 -------
proxy/logging/LogObject.cc | 107 +---
proxy/logging/LogObject.h | 61 +--
proxy/logging/LogSock.cc | 734 ----------------------------
proxy/logging/LogSock.h | 128 -----
proxy/logging/Makefile.am | 17 +-
proxy/logging/YamlLogConfig.cc | 56 +--
proxy/shared/UglyLogStubs.cc | 16 -
src/traffic_logcat/logcat.cc | 2 -
src/traffic_server/InkAPI.cc | 7 +-
src/traffic_server/Makefile.inc | 1 -
41 files changed, 97 insertions(+), 4165 deletions(-)
diff --git a/doc/.tx/config b/doc/.tx/config
index be18c3c..6640ca1 100644
--- a/doc/.tx/config
+++ b/doc/.tx/config
@@ -162,11 +162,6 @@ file_filter = locale/<lang>/LC_MESSAGES/admin-guide/monitoring/logging/log-build
source_file = _build/locale/pot/admin-guide/monitoring/logging/log-builder.en.pot
source_lang = en
-[apache-traffic-server-6x.admin-guide--monitoring--logging--log-collation_en]
-file_filter = locale/<lang>/LC_MESSAGES/admin-guide/monitoring/logging/log-collation.en.po
-source_file = _build/locale/pot/admin-guide/monitoring/logging/log-collation.en.pot
-source_lang = en
-
[apache-traffic-server-6x.admin-guide--monitoring--logging--log-formats_en]
file_filter = locale/<lang>/LC_MESSAGES/admin-guide/monitoring/logging/log-formats.en.po
source_file = _build/locale/pot/admin-guide/monitoring/logging/log-formats.en.pot
diff --git a/doc/admin-guide/files/logging.yaml.en.rst b/doc/admin-guide/files/logging.yaml.en.rst
index a301aa5..96a6fe3 100644
--- a/doc/admin-guide/files/logging.yaml.en.rst
+++ b/doc/admin-guide/files/logging.yaml.en.rst
@@ -288,13 +288,6 @@ rolling_min_count number Specifies the minimum number of rolled logs t
filters array of The optional list of filter objects which
filters restrict the individual events logged. The array
may only contain one accept filter.
-collation_hosts array of If present, one or more strings specifying the
- strings log collation hosts to which logs should be
- delivered, each in the form of "<ip>:<port>".
- :ref:`admin-logging-collation` for more
- information. NOTE: This is a deprecated feature,
- which will be removed in ATS v9.0.0. See the
- logging documentation (above) for more details.
====================== =========== =================================================
Enabling log rolling may be done globally in :file:`records.config`, or on a
diff --git a/doc/admin-guide/files/records.config.en.rst b/doc/admin-guide/files/records.config.en.rst
index d9120b2..080a99b 100644
--- a/doc/admin-guide/files/records.config.en.rst
+++ b/doc/admin-guide/files/records.config.en.rst
@@ -2765,25 +2765,7 @@ Logging Configuration
.. note::
All files in the logging directory contribute to the space used,
- even if they are not log files. In collation client mode, if
- there is no local disk logging, or
- :ts:cv:`proxy.config.log.max_space_mb_for_orphan_logs` is set
- to a higher value than :ts:cv:`proxy.config.log.max_space_mb_for_logs`,
- |TS| will take :ts:cv:`proxy.config.log.max_space_mb_for_orphan_logs`
- for maximum allowed log space.
-
-.. ts:cv:: CONFIG proxy.config.log.max_space_mb_for_orphan_logs INT 25
- :units: megabytes
- :reloadable:
-
- The amount of space allocated to the logging directory (in MB) if this node is acting as a collation client.
-
-.. note::
-
- When max_space_mb_for_orphan_logs is take as the maximum allowed log space in the logging system, the same rule apply
- to proxy.config.log.max_space_mb_for_logs also apply to proxy.config.log.max_space_mb_for_orphan_logs, ie: All files
- in the logging directory contribute to the space used, even if they are not log files. you may need to consider this
- when you enable full remote logging, and bump to the same size as proxy.config.log.max_space_mb_for_logs.
+ even if they are not log files.
.. ts:cv:: CONFIG proxy.config.log.max_space_mb_headroom INT 1000
:units: megabytes
@@ -2826,85 +2808,6 @@ Logging Configuration
others, even if specified in the configuration file. Permissions for
existing log files are not changed when the configuration is modified.
-.. ts:cv:: LOCAL proxy.local.log.collation_mode INT 0
- :reloadable:
- :deprecated:
-
- Set the log collation mode.
-
- ===== ======================================================================
- Value Effect
- ===== ======================================================================
- ``0`` Log collation is disabled.
- ``1`` This host is a log collation server.
- ``2`` This host is a collation client and sends entries using standard
- formats to the collation server.
- ``3`` This host is a collation client and sends entries using the
- traditional custom formats to the collation server.
- ``4`` This host is a collation client and sends entries that use both the
- standard and traditional custom formats to the collation server.
- ===== ======================================================================
-
- For information on sending custom formats to the collation server,
- refer to :ref:`admin-logging-collating-custom-formats` and
- :file:`logging.yaml`.
-
-.. note::
-
- Log collation is a *deprecated* feature as of ATS v8.0.0, and will be
- removed in ATS v9.0.0. Our recommendation is to use one of the many existing
- log collection tools, such as Kafka, LogStash, FileBeat, Fluentd or even
- syslog / syslog-ng.
-
-.. ts:cv:: CONFIG proxy.config.log.collation_host STRING NULL
- :deprecated:
-
- The hostname of the log collation server.
-
-.. ts:cv:: CONFIG proxy.config.log.collation_port INT 8085
- :reloadable:
- :deprecated:
-
- The port used for communication between the collation server and client.
-
-.. ts:cv:: CONFIG proxy.config.log.collation_secret STRING foobar
- :reloadable:
- :deprecated:
-
- The password used to validate logging data and prevent the exchange of unauthorized information when a collation server is being used.
-
-.. ts:cv:: CONFIG proxy.config.log.collation_host_tagged INT 0
- :reloadable:
- :deprecated:
-
- When enabled (``1``), configures |TS| to include the hostname of the collation client that generated the log entry in each entry.
-
-.. ts:cv:: CONFIG proxy.config.log.collation_retry_sec INT 5
- :reloadable:
- :deprecated:
-
- The number of seconds between collation server connection retries.
-
-.. ts:cv:: CONFIG proxy.config.log.collation_host_timeout INT 86390
- :deprecated:
-
- The number of seconds before inactivity time-out events for the host side.
- This setting over-rides the default set with proxy.config.net.default_inactivity_timeout
- for log collation connections.
-
- The default is set for 10s less on the host side to help prevent any possible race
- conditions. If the host disconnects first, the client will see the disconnect
- before its own time-out and re-connect automatically. If the client does not see
- the disconnect, i.e., connection is "locked-up" for some reason, it will disconnect
- when it reaches its own time-out and then re-connect automatically.
-
-.. ts:cv:: CONFIG proxy.config.log.collation_client_timeout INT 86400
- :deprecated:
-
- The number of seconds before inactivity time-out events for the client side.
- This setting over-rides the default set with proxy.config.net.default_inactivity_timeout
- for log collation connections.
-
.. ts:cv:: CONFIG proxy.config.log.rolling_enabled INT 1
:reloadable:
diff --git a/doc/admin-guide/logging/destinations.en.rst b/doc/admin-guide/logging/destinations.en.rst
index f8521de..5b70913 100644
--- a/doc/admin-guide/logging/destinations.en.rst
+++ b/doc/admin-guide/logging/destinations.en.rst
@@ -31,8 +31,7 @@ Two classes of destinations are provided by |TS| currently: local and remote.
Local logging involves storing log data onto filesystems locally mounted on the
same system as the |TS| processes themselves and are covered below in
:ref:`admin-logging-destinations-local`, while remote logging options involving
-:manpage:`syslog` and built-in |TS| log collation, are covered below in
-:ref:`admin-logging-destinations-remote`.
+:manpage:`syslog`, are covered below in :ref:`admin-logging-destinations-remote`.
.. _admin-logging-destinations-local:
@@ -44,9 +43,8 @@ Local Logging
Log Directory Configuration
---------------------------
-All local logging output (including incoming collation logs on a |TS| instance
-configured as a :ref:`admin-logging-collation-server`) are stored within a
-single base directory. Individual log file configurations may optionally append
+All local logging output is stored within a single base directory.
+Individual log file configurations may optionally append
subdirectories to this base path. This location is adjusted with
:ts:cv:`proxy.config.log.logfile_dir` in :file:`records.config`.
@@ -196,132 +194,3 @@ system and emergency logs. Sending custom event or transaction error logs to
syslog is not directly supported. You may use external log aggregation tools,
such as Logstash, to accomplish this by having them handle the ingestion of
|TS| local log files and forwarding to whatever receivers you wish.
-
-.. _admin-logging-collation:
-
-Log Collation
--------------
-
-.. note::
-
- Log collation is a *deprecated* feature as of ATS v8.0.0, and will be
- removed in ATS v9.0.0. Our recommendation is to use one of the many existing
- log collection tools, such as Kafka, LogStash, FileBeat, Fluentd or even
- syslog / syslog-ng (see above).
-
-|TS| offers remote log shipping natively through the log collation feature,
-which allows one or more |TS| instances handling regular traffic to transmit
-their log data to one or more |TS| instances acting as collation servers.
-
-This allows you to centralize your |TS| logging for (potentially) easier
-analysis and reporting in environments with many |TS| instances. Collation
-servers may be |TS| instance running a stripped down configuration aimed
-at log collation only (and omitting any configuration for actual traffic
-proxying or caching).
-
-When a |TS| node generates a buffer of event log entries, it first determines
-if it is the collation server or a collation client. The collation server node
-writes all log buffers to its local disk (as per its :file:`logging.yaml`
-configuration), just as it would if log collation was not enabled. The
-collation client nodes prepare their log buffers for transfer across the
-network and send the buffers to the configured log collation server.
-
-If log clients cannot contact their log collation server, then they write their
-log buffers to their local disks, into orphan log files. Orphaned log files
-require manual collation.
-
-.. important::
-
- Log collation can have an impact on network performance. Because all nodes
- are forwarding their log data buffers to the single collation server, a
- bottleneck can occur. In addition, collated log files contain timestamp
- information for each entry, but entries in the files do not appear in strict
- chronological order. You may want to sort collated log files before doing
- analysis.
-
-.. _admin-logging-collation-client:
-
-Collation Client
-~~~~~~~~~~~~~~~~
-
-To configure a |TS| node to be a collation client, follow the steps below.
-
-#. In the :file:`records.config` file, edit the following variables:
-
- - :ts:cv:`proxy.local.log.collation_mode`: ``2`` to configure this node as
- log collation client and send standard formatted log entries to the
- collation server. For custom log entries, see :file:`logging.yaml`.
- - :ts:cv:`proxy.config.log.collation_host`
- - :ts:cv:`proxy.config.log.collation_port`
- - :ts:cv:`proxy.config.log.collation_secret`
- - :ts:cv:`proxy.config.log.collation_host_tagged`
- - :ts:cv:`proxy.config.log.max_space_mb_for_orphan_logs`
-
-#. Run the command :option:`traffic_ctl config reload` to apply the configuration
- changes.
-
-.. note::
-
- If you modify the collation port or secret after connections between the
- collation server and collation clients have been established, you must
- restart |TS| on all nodes.
-
-.. _admin-logging-collation-server:
-
-Collation Server
-~~~~~~~~~~~~~~~~
-
-To configure a |TS| node to be a collation server, perform the following
-configuration adjustments in :file:`records.config`:
-
-#. Set :ts:cv:`proxy.local.log.collation_mode` to ``1`` to indicate this node
- will be a server. ::
-
- CONFIG proxy.local.log.collation_mode INT 1
-
-#. Configure the port on which the server will listen to incoming collation
- transfers from clients, using :ts:cv:`proxy.config.log.collation_port`. If
- omitted, this defaults to port ``8085``. ::
-
- CONFIG proxy.config.log.collation_port INT 8085
-
-#. Configure the shared secret used by collation clients to authenticate their
- sessions, using :ts:cv:`proxy.config.log.collation_secret`. ::
-
- CONFIG proxy.config.log.collation_secret STRING seekrit
-
-#. Run the command :option:`traffic_ctl config reload` to apply the configuration
- changes.
-
-.. note::
-
- If you modify the collation port or secret after connections between the
- collation server and collation clients have been established, you must
- restart |TS| on all nodes.
-
-.. _admin-logging-collating-custom-formats:
-
-Collating Custom Logs
-~~~~~~~~~~~~~~~~~~~~~
-
-If you use custom event log files, then you must edit :file:`logging.yaml`,
-in addition to configuring a collation server and collation clients.
-
-To collate custom event log files:
-
-#. On each collation client, edit :file:`logging.yaml` and add the
- ``CollationHosts`` attribute to the relevant logs. For example, adding two
- collation hosts to an ASCII log that uses the Squid format would look like:
-
- .. code:: yaml
-
- logs:
- - mode: ascii
- format: squid
- filename: squid
- collationhosts:
- - 192.168.1.100:4567
- - 192.168.1.101:4567
-
-#. Run the command :option:`traffic_ctl config reload` to restart |TS|.
-
diff --git a/doc/admin-guide/logging/formatting.en.rst b/doc/admin-guide/logging/formatting.en.rst
index 1217663..bb5ccb7 100644
--- a/doc/admin-guide/logging/formatting.en.rst
+++ b/doc/admin-guide/logging/formatting.en.rst
@@ -89,7 +89,6 @@ down into the following broad categories for (hopefully) easier reference:
- :ref:`admin-logging-fields-methods`
- :ref:`admin-logging-fields-ids`
- :ref:`admin-logging-fields-lengths`
-- :ref:`admin-logging-fields-collation`
- :ref:`admin-logging-fields-network`
- :ref:`admin-logging-fields-plugin`
- :ref:`admin-logging-fields-proto`
@@ -447,28 +446,6 @@ ssql Origin Response Content body and header length combined of the
origin server response to |TS|.
===== ====================== ==================================================
-.. _admin-logging-fields-collation:
-
-Log Collation
-~~~~~~~~~~~~~
-
-.. _phn:
-.. _phi:
-
-Logging fields related to :ref:`admin-logging-collation`.
-
-===== ====== ==================================================================
-Field Source Description
-===== ====== ==================================================================
-phn Proxy Hostname of the |TS| node which generated the collated log entry.
-phi Proxy IP of the |TS| node which generated the collated log entry.
-===== ====== ==================================================================
-
-.. note::
-
- Log collation is a *deprecated* feature as of ATS v8.0.0, and will be
- removed in ATS v9.0.0.
-
.. _admin-logging-fields-network:
Network Addresses, Ports, and Interfaces
diff --git a/doc/admin-guide/logging/rotation.en.rst b/doc/admin-guide/logging/rotation.en.rst
index 01441c8..eaed409 100644
--- a/doc/admin-guide/logging/rotation.en.rst
+++ b/doc/admin-guide/logging/rotation.en.rst
@@ -67,8 +67,7 @@ the following information:
- The original log file's name (such as ``access.log``).
-- The hostname of the |TS| node that generated the log file (useful in |TS|
- log collation configurations).
+- The hostname of the |TS| node that generated the log file.
- Two timestamps separated by a hyphen (``-``). The first timestamp is
a *lower bound* for the timestamp of the first record in the log
diff --git a/doc/admin-guide/performance/index.en.rst b/doc/admin-guide/performance/index.en.rst
index 18f05dc..acd5c3d 100644
--- a/doc/admin-guide/performance/index.en.rst
+++ b/doc/admin-guide/performance/index.en.rst
@@ -521,7 +521,6 @@ Logging Configuration
binary vs. ascii output
multiple log formats (netscape+squid+custom vs. just custom)
- overhead to log collation
using direct writes vs. syslog target
Plugin Tuning
diff --git a/include/ts/ts.h b/include/ts/ts.h
index d5ee8b0..b156414 100644
--- a/include/ts/ts.h
+++ b/include/ts/ts.h
@@ -2087,8 +2087,7 @@ tsapi void TSRecordDump(int rec_type, TSRecordDumpCb callback, void *edata);
Creates a new custom log file that your plugin can write to. You
can design the fields and inputs to the log file using the
TSTextLogObjectWrite() function. The logs you create are treated
- like ordinary logs; they are rolled if log rolling is enabled. (Log
- collation is not supported though).
+ like ordinary logs; they are rolled if log rolling is enabled.
@param filename new log file being created. The new log file
is created in the logs directory. You can specify a path to a
diff --git a/iocore/cache/Makefile.am b/iocore/cache/Makefile.am
index b5d7c5d..b2161f0 100644
--- a/iocore/cache/Makefile.am
+++ b/iocore/cache/Makefile.am
@@ -99,7 +99,6 @@ test_LDADD = \
$(top_builddir)/iocore/hostdb/libinkhostdb.a \
$(top_builddir)/proxy/logging/liblogging.a \
$(top_builddir)/proxy/hdrs/libhdrs.a \
- $(top_builddir)/proxy/logging/liblogcollation.a \
$(top_builddir)/proxy/shared/libdiagsconfig.a \
$(top_builddir)/mgmt/libmgmt_p.la \
$(top_builddir)/iocore/utils/libinkutils.a \
diff --git a/iocore/eventsystem/I_Event.h b/iocore/eventsystem/I_Event.h
index 83c1bd0..3f708db 100644
--- a/iocore/eventsystem/I_Event.h
+++ b/iocore/eventsystem/I_Event.h
@@ -78,7 +78,6 @@
#define RAFT_EVENT_EVENTS_START 3200
#define SIMPLE_EVENT_EVENTS_START 3300
#define UPDATE_EVENT_EVENTS_START 3500
-#define LOG_COLLATION_EVENT_EVENTS_START 3800
#define AIO_EVENT_EVENTS_START 3900
#define BLOCK_CACHE_EVENT_EVENTS_START 4000
#define UTILS_EVENT_EVENTS_START 5000
diff --git a/lib/perl/lib/Apache/TS/AdminClient.pm b/lib/perl/lib/Apache/TS/AdminClient.pm
index 937d5ce..9892a90 100644
--- a/lib/perl/lib/Apache/TS/AdminClient.pm
+++ b/lib/perl/lib/Apache/TS/AdminClient.pm
@@ -520,12 +520,6 @@ The Apache Traffic Server Administration Manual will explain what these strings
proxy.config.local_state_dir
proxy.config.log.ascii_buffer_size
proxy.config.log.auto_delete_rolled_files
- proxy.config.log.collation_host
- proxy.config.log.collation_host_tagged
- proxy.config.log.collation_max_send_buffers
- proxy.config.log.collation_port
- proxy.config.log.collation_retry_sec
- proxy.config.log.collation_secret
proxy.config.log.file_stat_frequency
proxy.config.log.hostname
proxy.config.log.log_buffer_size
@@ -535,7 +529,6 @@ The Apache Traffic Server Administration Manual will explain what these strings
proxy.config.log.max_line_size
proxy.config.log.max_secs_per_buffer
proxy.config.log.max_space_mb_for_logs
- proxy.config.log.max_space_mb_for_orphan_logs
proxy.config.log.max_space_mb_headroom
proxy.config.log.overspill_report_count
proxy.config.log.rolling_enabled
diff --git a/mgmt/RecordsConfig.cc b/mgmt/RecordsConfig.cc
index 3003477..8e8b5a0 100644
--- a/mgmt/RecordsConfig.cc
+++ b/mgmt/RecordsConfig.cc
@@ -1010,8 +1010,6 @@ static const RecordElement RecordsConfig[] =
,
{RECT_CONFIG, "proxy.config.log.max_space_mb_for_logs", RECD_INT, "25000", RECU_DYNAMIC, RR_NULL, RECC_STR, "^[0-9]+$", RECA_NULL}
,
- {RECT_CONFIG, "proxy.config.log.max_space_mb_for_orphan_logs", RECD_INT, "25", RECU_DYNAMIC, RR_NULL, RECC_STR, "^[0-9]+$", RECA_NULL}
- ,
{RECT_CONFIG, "proxy.config.log.max_space_mb_headroom", RECD_INT, "1000", RECU_DYNAMIC, RR_NULL, RECC_STR, "^[0-9]+$", RECA_NULL}
,
{RECT_CONFIG, "proxy.config.log.hostname", RECD_STRING, "localhost", RECU_DYNAMIC, RR_NULL, RECC_NULL, nullptr, RECA_NULL}
@@ -1022,23 +1020,7 @@ static const RecordElement RecordsConfig[] =
,
{RECT_CONFIG, "proxy.config.log.config.filename", RECD_STRING, "logging.yaml", RECU_DYNAMIC, RR_NULL, RECC_NULL, nullptr, RECA_NULL}
,
- {RECT_CONFIG, "proxy.config.log.collation_host", RECD_STRING, nullptr, RECU_DYNAMIC, RR_NULL, RECC_STR, "^[^[:space:]]*$", RECA_NULL}
- ,
- {RECT_CONFIG, "proxy.config.log.collation_port", RECD_INT, "8085", RECU_DYNAMIC, RR_REQUIRED, RECC_INT, "[0-65535]", RECA_NULL}
- ,
- {RECT_CONFIG, "proxy.config.log.collation_secret", RECD_STRING, "foobar", RECU_DYNAMIC, RR_NULL, RECC_STR, ".*", RECA_NULL}
- ,
- {RECT_CONFIG, "proxy.config.log.collation_host_tagged", RECD_INT, "0", RECU_DYNAMIC, RR_NULL, RECC_INT, "[0-1]", RECA_NULL}
- ,
- {RECT_CONFIG, "proxy.config.log.collation_retry_sec", RECD_INT, "5", RECU_DYNAMIC, RR_NULL, RECC_NULL, nullptr, RECA_NULL}
- ,
- {RECT_CONFIG, "proxy.config.log.collation_max_send_buffers", RECD_INT, "16", RECU_DYNAMIC, RR_NULL, RECC_NULL, nullptr, RECA_NULL}
- ,
- {RECT_CONFIG, "proxy.config.log.collation_preproc_threads", RECD_INT, "1", RECU_DYNAMIC, RR_REQUIRED, RECC_INT, "[1-128]", RECA_NULL}
- ,
- {RECT_CONFIG, "proxy.config.log.collation_host_timeout", RECD_INT, "86390", RECU_NULL, RR_NULL, RECC_NULL, nullptr, RECA_NULL}
- ,
- {RECT_CONFIG, "proxy.config.log.collation_client_timeout", RECD_INT, "86400", RECU_NULL, RR_NULL, RECC_NULL, nullptr, RECA_NULL}
+ {RECT_CONFIG, "proxy.config.log.preproc_threads", RECD_INT, "1", RECU_DYNAMIC, RR_REQUIRED, RECC_INT, "[1-128]", RECA_NULL}
,
{RECT_CONFIG, "proxy.config.log.rolling_enabled", RECD_INT, "1", RECU_DYNAMIC, RR_NULL, RECC_INT, "[0-4]", RECA_NULL}
,
@@ -1339,8 +1321,6 @@ static const RecordElement RecordsConfig[] =
,
{RECT_LOCAL, "proxy.local.outgoing_ip_to_bind", RECD_STRING, nullptr, RECU_NULL, RR_NULL, RECC_NULL, nullptr, RECA_NULL}
,
- {RECT_LOCAL, "proxy.local.log.collation_mode", RECD_INT, "0", RECU_DYNAMIC, RR_NULL, RECC_INT, "[0-4]", RECA_NULL}
- ,
//# Librecords based stats system (new as of v2.1.3)
{RECT_CONFIG, "proxy.config.stat_api.max_stats_allowed", RECD_INT, "256", RECU_RESTART_TS, RR_NULL, RECC_INT, "[256-1000]", RECA_NULL}
diff --git a/proxy/README-stats.otl b/proxy/README-stats.otl
index 8064834..e57263f 100644
--- a/proxy/README-stats.otl
+++ b/proxy/README-stats.otl
@@ -521,7 +521,6 @@ Adam Beguelin wrote:
> o Cache/Freshness
> o Cache/Variable Content
> o HostDB page
-> o Logging/Log Collation
---------------------------------------------------------------------------------
---------------------------------------------------------------------------------
---------------------------------------------------------------------------------
diff --git a/proxy/logging/Log.cc b/proxy/logging/Log.cc
index 9762dae..090b6a5 100644
--- a/proxy/logging/Log.cc
+++ b/proxy/logging/Log.cc
@@ -44,13 +44,11 @@
#include "LogFilter.h"
#include "LogFormat.h"
#include "LogFile.h"
-#include "LogHost.h"
#include "LogObject.h"
#include "LogConfig.h"
#include "LogBuffer.h"
#include "LogUtils.h"
#include "Log.h"
-#include "LogSock.h"
#include "tscore/SimpleTokenizer.h"
#include "tscore/ink_apidefs.h"
@@ -69,14 +67,8 @@ EventNotify *Log::preproc_notify;
EventNotify *Log::flush_notify;
InkAtomicList *Log::flush_data_list;
-// Collate thread stuff
-EventNotify Log::collate_notify;
-ink_thread Log::collate_thread;
-int Log::collation_accept_file_descriptor;
-int Log::collation_preproc_threads;
-int Log::collation_port;
-
// Log private objects
+int Log::preproc_threads;
int Log::init_status = 0;
int Log::config_flags = 0;
bool Log::logging_mode_changed = false;
@@ -227,7 +219,7 @@ Log::periodic_tasks(long time_now)
// so that log objects are flushed
//
change_configuration();
- } else if (logging_mode > LOG_MODE_NONE || config->collation_mode == Log::COLLATION_HOST || config->has_api_objects()) {
+ } else if (logging_mode > LOG_MODE_NONE || config->has_api_objects()) {
Debug("log-periodic", "Performing periodic tasks");
Debug("log-periodic", "Periodic task interval = %d", periodic_tasks_interval);
@@ -300,17 +292,6 @@ struct LoggingFlushContinuation : public Continuation {
}
};
-struct LoggingCollateContinuation : public Continuation {
- int
- mainEvent(int /* event ATS_UNUSED */, void * /* data ATS_UNUSED */)
- {
- Log::collate_thread_main(nullptr);
- return 0;
- }
-
- LoggingCollateContinuation() : Continuation(nullptr) { SET_HANDLER(&LoggingCollateContinuation::mainEvent); }
-};
-
/*-------------------------------------------------------------------------
Log::init_fields
@@ -935,8 +916,7 @@ Log::handle_periodic_tasks_int_change(const char * /* name ATS_UNUSED */, RecDat
void
Log::init(int flags)
{
- collation_preproc_threads = 1;
- collation_accept_file_descriptor = NO_FD;
+ preproc_threads = 1;
// store the configuration flags
//
@@ -957,33 +937,28 @@ Log::init(int flags)
LogConfig::register_stat_callbacks();
config->read_configuration_variables();
- collation_port = config->collation_port;
- collation_preproc_threads = config->collation_preproc_threads;
-
- if (config_flags & STANDALONE_COLLATOR) {
- logging_mode = LOG_MODE_TRANSACTIONS;
+ preproc_threads = config->preproc_threads;
+
+ int val = (int)REC_ConfigReadInteger("proxy.config.log.logging_enabled");
+ if (val < LOG_MODE_NONE || val > LOG_MODE_FULL) {
+ logging_mode = LOG_MODE_FULL;
+ Warning("proxy.config.log.logging_enabled has an invalid "
+ "value, setting it to %d",
+ logging_mode);
} else {
- int val = (int)REC_ConfigReadInteger("proxy.config.log.logging_enabled");
- if (val < LOG_MODE_NONE || val > LOG_MODE_FULL) {
- logging_mode = LOG_MODE_FULL;
- Warning("proxy.config.log.logging_enabled has an invalid "
- "value, setting it to %d",
- logging_mode);
- } else {
- logging_mode = (LoggingMode)val;
- }
- // periodic task interval are set on a per instance basis
- MgmtInt pti = REC_ConfigReadInteger("proxy.config.log.periodic_tasks_interval");
- if (pti <= 0) {
- Error("proxy.config.log.periodic_tasks_interval = %" PRId64 " is invalid", pti);
- Note("falling back to default periodic tasks interval = %d", PERIODIC_TASKS_INTERVAL_FALLBACK);
- periodic_tasks_interval = PERIODIC_TASKS_INTERVAL_FALLBACK;
- } else {
- periodic_tasks_interval = static_cast<uint32_t>(pti);
- }
-
- REC_RegisterConfigUpdateFunc("proxy.config.log.periodic_tasks_interval", &Log::handle_periodic_tasks_int_change, nullptr);
+ logging_mode = (LoggingMode)val;
}
+ // periodic task interval are set on a per instance basis
+ MgmtInt pti = REC_ConfigReadInteger("proxy.config.log.periodic_tasks_interval");
+ if (pti <= 0) {
+ Error("proxy.config.log.periodic_tasks_interval = %" PRId64 " is invalid", pti);
+ Note("falling back to default periodic tasks interval = %d", PERIODIC_TASKS_INTERVAL_FALLBACK);
+ periodic_tasks_interval = PERIODIC_TASKS_INTERVAL_FALLBACK;
+ } else {
+ periodic_tasks_interval = static_cast<uint32_t>(pti);
+ }
+
+ REC_RegisterConfigUpdateFunc("proxy.config.log.periodic_tasks_interval", &Log::handle_periodic_tasks_int_change, nullptr);
}
// if remote management is enabled, do all necessary initialization to
@@ -992,8 +967,6 @@ Log::init(int flags)
if (!(config_flags & NO_REMOTE_MANAGEMENT)) {
REC_RegisterConfigUpdateFunc("proxy.config.log.logging_enabled", &Log::handle_logging_mode_change, nullptr);
- REC_RegisterConfigUpdateFunc("proxy.local.log.collation_mode", &Log::handle_logging_mode_change, nullptr);
-
// Clear any stat values that need to be reset on startup
//
RecSetRawStatSum(log_rsb, log_stat_log_files_open_stat, 0);
@@ -1003,9 +976,6 @@ Log::init(int flags)
init_fields();
if (!(config_flags & LOGCAT)) {
Debug("log-config", "Log::init(): logging_mode = %d init status = %d", logging_mode, init_status);
- if (config_flags & STANDALONE_COLLATOR) {
- config->collation_mode = Log::COLLATION_HOST;
- }
config->init();
init_when_enabled();
}
@@ -1018,26 +988,24 @@ Log::init_when_enabled()
ink_release_assert(config->initialized == true);
if (!(init_status & FULLY_INITIALIZED)) {
- if (!(config_flags & STANDALONE_COLLATOR)) {
- // register callbacks
- //
- if (!(config_flags & NO_REMOTE_MANAGEMENT)) {
- LogConfig::register_config_callbacks();
- }
-
- LogConfig::register_mgmt_callbacks();
+ // register callbacks
+ //
+ if (!(config_flags & NO_REMOTE_MANAGEMENT)) {
+ LogConfig::register_config_callbacks();
}
+
+ LogConfig::register_mgmt_callbacks();
// setup global scrap object
//
global_scrap_format = MakeTextLogFormat();
global_scrap_object =
new LogObject(global_scrap_format, Log::config->logfile_dir, "scrapfile.log", LOG_FILE_BINARY, nullptr,
- Log::config->rolling_enabled, Log::config->collation_preproc_threads, Log::config->rolling_interval_sec,
+ Log::config->rolling_enabled, Log::config->preproc_threads, Log::config->rolling_interval_sec,
Log::config->rolling_offset_hr, Log::config->rolling_size_mb);
- // create the flush thread and the collation thread
+ // create the flush thread
create_threads();
- eventProcessor.schedule_every(new PeriodicWakeup(collation_preproc_threads, 1), HRTIME_SECOND, ET_CALL);
+ eventProcessor.schedule_every(new PeriodicWakeup(preproc_threads, 1), HRTIME_SECOND, ET_CALL);
init_status |= FULLY_INITIALIZED;
}
@@ -1052,7 +1020,7 @@ void
Log::create_threads()
{
char desc[64];
- preproc_notify = new EventNotify[collation_preproc_threads];
+ preproc_notify = new EventNotify[preproc_threads];
size_t stacksize;
REC_ReadConfigInteger(stacksize, "proxy.config.thread.default.stacksize");
@@ -1061,7 +1029,7 @@ Log::create_threads()
//
// no need for the conditional var since it will be relying on
// on the event system.
- for (int i = 0; i < collation_preproc_threads; i++) {
+ for (int i = 0; i < preproc_threads; i++) {
Continuation *preproc_cont = new LoggingPreprocContinuation(i);
sprintf(desc, "[LOG_PREPROC %d]", i);
eventProcessor.spawn_thread(preproc_cont, desc, stacksize);
@@ -1400,166 +1368,3 @@ Log::flush_thread_main(void * /* args ATS_UNUSED */)
Log::flush_notify->unlock();
return nullptr;
}
-
-/*-------------------------------------------------------------------------
- Log::collate_thread_main
-
- This function defines the functionality of the log collation thread,
- whose purpose is to collate log buffers from other nodes.
- -------------------------------------------------------------------------*/
-
-void *
-Log::collate_thread_main(void * /* args ATS_UNUSED */)
-{
- LogSock *sock;
- LogBufferHeader *header;
- LogFormat *format;
- LogObject *obj;
- int bytes_read;
- int sock_id;
- int new_client;
-
- Debug("log-thread", "Log collation thread is alive ...");
-
- Log::collate_notify.lock();
-
- while (true) {
- ink_assert(Log::config != nullptr);
-
- // wait on the collation condition variable until we're sure that
- // we're a collation host. The while loop guards against spurious
- // wake-ups.
- //
- while (!Log::config->am_collation_host()) {
- Log::collate_notify.wait();
- }
-
- // Ok, at this point we know we're a log collation host, so get to
- // work. We still need to keep checking whether we're a collation
- // host to account for a reconfiguration.
- //
- Debug("log-sock", "collation thread starting, creating LogSock");
- sock = new LogSock(LogSock::LS_CONST_MAX_CONNS);
- ink_assert(sock != nullptr);
-
- if (sock->listen(Log::config->collation_port) != 0) {
- LogUtils::manager_alarm(LogUtils::LOG_ALARM_ERROR, "Collation server error; could not listen on port %d",
- Log::config->collation_port);
- Warning("Collation server error; could not listen on port %d", Log::config->collation_port);
- delete sock;
- //
- // go to sleep ...
- //
- Log::collate_notify.wait();
- continue;
- }
-
- while (true) {
- if (!Log::config->am_collation_host()) {
- break;
- }
-
- if (sock->pending_connect(0)) {
- Debug("log-sock", "pending connection ...");
- if ((new_client = sock->accept()) < 0) {
- Debug("log-sock", "error accepting new collation client");
- } else {
- Debug("log-sock", "connection %d accepted", new_client);
- if (!sock->authorized_client(new_client, Log::config->collation_secret)) {
- Warning("Unauthorized client connecting to "
- "log collation port; connection refused.");
- sock->close(new_client);
- }
- }
- }
-
- sock->check_connections();
-
- if (!sock->pending_message_any(&sock_id, 0)) {
- continue;
- }
-
- Debug("log-sock", "pending message ...");
- header = static_cast<LogBufferHeader *>(sock->read_alloc(sock_id, &bytes_read));
- if (!header) {
- Debug("log-sock", "Error reading LogBuffer from collation client");
- continue;
- }
-
- if (header->version != LOG_SEGMENT_VERSION) {
- Note("Invalid LogBuffer received; invalid version - buffer = %u, current = %u", header->version, LOG_SEGMENT_VERSION);
- delete[] header;
- continue;
- }
-
- Debug("log-sock", "message accepted, size = %d", bytes_read);
-
- obj = match_logobject(header);
- if (!obj) {
- Note("LogObject not found with fieldlist id; "
- "writing LogBuffer to scrap file");
- obj = global_scrap_object;
- }
-
- format = obj->m_format;
- Debug("log-sock", "Using format '%s'", format->name());
-
- delete[] header;
- }
-
- Debug("log", "no longer collation host, deleting LogSock");
- delete sock;
- }
-
- /* NOTREACHED */
- Log::collate_notify.unlock();
- return nullptr;
-}
-
-/*-------------------------------------------------------------------------
- Log::match_logobject
-
- This routine matches the given buffer with the local list of LogObjects.
- If a match cannot be found, then we'll try to construct a local LogObject
- using the information provided in the header. If all else fails, we
- return NULL.
- -------------------------------------------------------------------------*/
-
-LogObject *
-Log::match_logobject(LogBufferHeader *header)
-{
- if (!header) {
- return nullptr;
- }
-
- LogObject *obj;
- obj = Log::config->log_object_manager.get_object_with_signature(header->log_object_signature);
-
- if (!obj) {
- // object does not exist yet, create it
- //
- LogFormat fmt("__collation_format__", header->fmt_fieldlist(), header->fmt_printf());
-
- if (fmt.valid()) {
- LogFileFormat file_format = (header->log_object_flags & LogObject::BINARY) ?
- LOG_FILE_BINARY :
- ((header->log_object_flags & LogObject::WRITES_TO_PIPE) ? LOG_FILE_PIPE : LOG_FILE_ASCII);
-
- obj = new LogObject(&fmt, Log::config->logfile_dir, header->log_filename(), file_format, nullptr,
- (Log::RollingEnabledValues)Log::config->rolling_enabled, Log::config->collation_preproc_threads,
- Log::config->rolling_interval_sec, Log::config->rolling_offset_hr, Log::config->rolling_size_mb, true);
-
- obj->set_remote_flag();
-
- if (Log::config->log_object_manager.manage_object(obj)) {
- // object manager can't solve filename conflicts
- // delete the object and return NULL
- //
- delete obj;
- obj = nullptr;
- }
- }
- }
-
- return obj;
-}
diff --git a/proxy/logging/Log.h b/proxy/logging/Log.h
index d266019..01700a6 100644
--- a/proxy/logging/Log.h
+++ b/proxy/logging/Log.h
@@ -132,12 +132,9 @@ public:
enum ConfigFlags {
NO_REMOTE_MANAGEMENT = 1,
- STANDALONE_COLLATOR = 2,
LOGCAT = 4,
};
- enum CollationMode { NO_COLLATION = 0, COLLATION_HOST, N_COLLATION_MODES };
-
enum RollingEnabledValues {
NO_ROLLING = 0,
ROLL_ON_TIME_ONLY,
@@ -195,14 +192,7 @@ public:
static InkAtomicList *flush_data_list;
static void *flush_thread_main(void *args);
- // collation thread stuff
- static EventNotify collate_notify;
- static ink_thread collate_thread;
- static int collation_preproc_threads;
- static int collation_accept_file_descriptor;
- static int collation_port;
- static void *collate_thread_main(void *args);
- static LogObject *match_logobject(LogBufferHeader *header);
+ static int preproc_threads;
// reconfiguration stuff
static void change_configuration();
diff --git a/proxy/logging/LogBuffer.cc b/proxy/logging/LogBuffer.cc
index 21b4c87..b356694 100644
--- a/proxy/logging/LogBuffer.cc
+++ b/proxy/logging/LogBuffer.cc
@@ -38,7 +38,6 @@
#include "LogFormat.h"
#include "LogUtils.h"
#include "LogFile.h"
-#include "LogHost.h"
#include "LogObject.h"
#include "LogAccess.h"
#include "LogConfig.h"
diff --git a/proxy/logging/LogCollationAccept.cc b/proxy/logging/LogCollationAccept.cc
deleted file mode 100644
index 3e94143..0000000
--- a/proxy/logging/LogCollationAccept.cc
+++ /dev/null
@@ -1,105 +0,0 @@
-/** @file
-
- A brief file description
-
- @section license License
-
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you 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.
- */
-
-//-------------------------------------------------------------------------
-// include files
-//-------------------------------------------------------------------------
-
-#include "tscore/ink_platform.h"
-#include "P_EventSystem.h"
-
-#include "Log.h"
-#include "LogCollationAccept.h"
-#include "LogCollationHostSM.h"
-
-//-------------------------------------------------------------------------
-// LogCollationAccept::LogCollationAccept
-//-------------------------------------------------------------------------
-
-LogCollationAccept::LogCollationAccept(int port) : Continuation(new_ProxyMutex()), m_port(port)
-{
- NetProcessor::AcceptOptions opt;
- SET_HANDLER((LogCollationAcceptHandler)&LogCollationAccept::accept_event);
- // work around for iocore problem where _pre_fetch_buffer can get
- // appended to itself if multiple do_io_reads are called requesting
- // small amounts of data. Most arguments are default except for the
- // last one which we will set to true.
- // [amc] That argument is ignored so I dropped it.
- opt.local_port = m_port;
- opt.ip_family = AF_INET;
- opt.accept_threads = 0;
- m_accept_action = netProcessor.accept(this, opt);
- ink_assert(nullptr != m_accept_action);
-}
-
-//-------------------------------------------------------------------------
-// LogCollationAccept::~LogCollationAccept
-//-------------------------------------------------------------------------
-
-LogCollationAccept::~LogCollationAccept()
-{
- Debug("log-collation", "LogCollationAccept::~LogCollationAccept");
-
- // stop the netProcessor
- if (m_accept_action) {
- m_accept_action->cancel();
- m_accept_action = nullptr;
-
- Debug("log-collation",
- "closing Log::collation_accept_file_descriptor "
- "(%d)",
- Log::collation_accept_file_descriptor);
- if (::close(Log::collation_accept_file_descriptor) < 0) {
- Error("error closing collate listen file descriptor [%d]: %s", Log::collation_accept_file_descriptor, strerror(errno));
- } else {
- Log::collation_accept_file_descriptor = NO_FD;
- }
- } else {
- ink_assert(!"[ERROR] m_accept_action is NULL");
- }
-
- // stop the eventProcessor
- // ... but what if there's more than one pending?
- if (m_pending_event && (m_pending_event != ACTION_RESULT_DONE)) {
- m_pending_event->cancel();
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationAccept::accept_event
-//-------------------------------------------------------------------------
-
-int
-LogCollationAccept::accept_event(int event, NetVConnection *net_vc)
-{
- switch (event) {
- case NET_EVENT_ACCEPT:
- new LogCollationHostSM(net_vc);
- break;
-
- default:
- ink_assert(!"[ERROR] Unexpected Event");
- }
-
- return EVENT_CONT;
-}
diff --git a/proxy/logging/LogCollationAccept.h b/proxy/logging/LogCollationAccept.h
deleted file mode 100644
index 315ca89..0000000
--- a/proxy/logging/LogCollationAccept.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/** @file
-
- A brief file description
-
- @section license License
-
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you 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.
- */
-
-#pragma once
-
-#include "P_EventSystem.h"
-#include "P_Net.h"
-
-struct LogCollationAccept : public Continuation {
-public:
- LogCollationAccept(int port);
- ~LogCollationAccept() override;
-
- int accept_event(int event, NetVConnection *net_vc);
-
-private:
- int m_port;
- Action *m_accept_action = nullptr;
- Event *m_pending_event = nullptr;
-};
-
-typedef int (LogCollationAccept::*LogCollationAcceptHandler)(int, void *);
diff --git a/proxy/logging/LogCollationBase.h b/proxy/logging/LogCollationBase.h
deleted file mode 100644
index 17b783a..0000000
--- a/proxy/logging/LogCollationBase.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/** @file
-
- A brief file description
-
- @section license License
-
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you 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.
- */
-
-#pragma once
-
-//-------------------------------------------------------------------------
-// LogCollationBase
-//-------------------------------------------------------------------------
-
-class LogCollationBase
-{
-protected:
- // ToDo: Can we we use the stuff from LogSock.h instead??
- struct NetMsgHeader {
- int msg_bytes; // length of the following message
- };
-
- enum LogCollEvent {
- LOG_COLL_EVENT_NULL = LOG_COLLATION_EVENT_EVENTS_START,
- LOG_COLL_EVENT_SWITCH,
- LOG_COLL_EVENT_READ_COMPLETE,
- LOG_COLL_EVENT_WRITE_COMPLETE,
- LOG_COLL_EVENT_ERROR
- };
-};
diff --git a/proxy/logging/LogCollationClientSM.cc b/proxy/logging/LogCollationClientSM.cc
deleted file mode 100644
index 73051cc..0000000
--- a/proxy/logging/LogCollationClientSM.cc
+++ /dev/null
@@ -1,716 +0,0 @@
-/** @file
-
- A brief file description
-
- @section license License
-
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you 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.
- */
-
-//-------------------------------------------------------------------------
-// include files
-//-------------------------------------------------------------------------
-
-#include "tscore/ink_platform.h"
-
-#include <cstdio>
-#include <cstdlib>
-#include <climits>
-#include <cstring>
-#include <sys/types.h>
-
-#include "P_EventSystem.h"
-#include "P_Net.h"
-
-#include "LogUtils.h"
-#include "LogSock.h"
-#include "LogField.h"
-#include "LogFile.h"
-#include "LogFormat.h"
-#include "LogBuffer.h"
-#include "LogHost.h"
-#include "LogObject.h"
-#include "LogConfig.h"
-#include "Log.h"
-
-#include "LogCollationClientSM.h"
-
-//-------------------------------------------------------------------------
-// statics
-//-------------------------------------------------------------------------
-
-int LogCollationClientSM::ID = 0;
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::LogCollationClientSM
-//-------------------------------------------------------------------------
-
-LogCollationClientSM::LogCollationClientSM(LogHost *log_host) : Continuation(new_ProxyMutex()), m_log_host(log_host), m_id(ID++)
-{
- Debug("log-coll", "[%d]client::constructor", m_id);
-
- ink_assert(m_log_host != nullptr);
-
- // allocate send_list before we do anything
- // we can accept logs to send before we're fully initialized
- m_buffer_send_list = new LogBufferList();
- ink_assert(m_buffer_send_list != nullptr);
-
- SET_HANDLER((LogCollationClientSMHandler)&LogCollationClientSM::client_handler);
- client_init(LOG_COLL_EVENT_SWITCH, nullptr);
-}
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::~LogCollationClientSM
-//-------------------------------------------------------------------------
-
-LogCollationClientSM::~LogCollationClientSM()
-{
- Debug("log-coll", "[%d]client::destructor", m_id);
-
- ink_mutex_acquire(&(mutex->the_mutex));
- client_done(LOG_COLL_EVENT_SWITCH, nullptr);
- ink_mutex_release(&(mutex->the_mutex));
-}
-
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-//
-// handler
-//
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::client_handler
-//-------------------------------------------------------------------------
-
-int
-LogCollationClientSM::client_handler(int event, void *data)
-{
- switch (m_client_state) {
- case LOG_COLL_CLIENT_AUTH:
- return client_auth(event, (VIO *)data);
- case LOG_COLL_CLIENT_DNS:
- return client_dns(event, (HostDBInfo *)data);
- case LOG_COLL_CLIENT_DONE:
- return client_done(event, data);
- case LOG_COLL_CLIENT_FAIL:
- return client_fail(event, data);
- case LOG_COLL_CLIENT_IDLE:
- return client_idle(event, data);
- case LOG_COLL_CLIENT_INIT:
- return client_init(event, data);
- case LOG_COLL_CLIENT_OPEN:
- return client_open(event, (NetVConnection *)data);
- case LOG_COLL_CLIENT_SEND:
- return client_send(event, (VIO *)data);
- default:
- ink_assert(!"unexpcted state");
- return EVENT_CONT;
- }
-}
-
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-//
-// pubic interface
-//
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::send
-//-------------------------------------------------------------------------
-
-int
-LogCollationClientSM::send(LogBuffer *log_buffer)
-{
- ip_port_text_buffer ipb;
-
- // take lock (can block on call because we're on our own thread)
- ink_mutex_acquire(&(mutex->the_mutex));
-
- Debug("log-coll", "[%d]client::send", m_id);
-
- // deny if state is DONE or FAIL
- if (m_client_state == LOG_COLL_CLIENT_DONE || m_client_state == LOG_COLL_CLIENT_FAIL) {
- Debug("log-coll", "[%d]client::send - DONE/FAIL state; rejecting", m_id);
- ink_mutex_release(&(mutex->the_mutex));
- return 0;
- }
- // only allow send if m_flow is ALLOW
- if (m_flow == LOG_COLL_FLOW_DENY) {
- Debug("log-coll", "[%d]client::send - m_flow = DENY; rejecting", m_id);
- ink_mutex_release(&(mutex->the_mutex));
- return 0;
- }
- // add log_buffer to m_buffer_send_list
- ink_assert(log_buffer != nullptr);
- ink_assert(m_buffer_send_list != nullptr);
- m_buffer_send_list->add(log_buffer);
- Debug("log-coll", "[%d]client::send - new log_buffer to send_list", m_id);
-
- // disable m_flow if there's too much work to do now
- ink_assert(m_flow == LOG_COLL_FLOW_ALLOW);
- if (m_buffer_send_list->get_size() >= Log::config->collation_max_send_buffers) {
- Debug("log-coll", "[%d]client::send - m_flow = DENY", m_id);
- Note("[log-coll] send-queue full; orphaning logs "
- "[%s:%u]",
- m_log_host->ip_addr().toString(ipb, sizeof(ipb)), m_log_host->port());
- m_flow = LOG_COLL_FLOW_DENY;
- }
- // compute return value
- // must be done before call to client_send. log_buffer may
- // be converted to network order during that call.
- LogBufferHeader *log_buffer_header = log_buffer->header();
- ink_assert(log_buffer_header != nullptr);
- int bytes_to_write = log_buffer_header->byte_count;
-
- // re-initiate sending if currently idle
- if (m_client_state == LOG_COLL_CLIENT_IDLE) {
- m_client_state = LOG_COLL_CLIENT_SEND;
- ink_assert(m_pending_event == nullptr);
- m_pending_event = eventProcessor.schedule_imm(this);
- // eventProcessor.schedule_imm(this);
- // client_send(LOG_COLL_EVENT_SWITCH, NULL);
- }
-
- ink_mutex_release(&(mutex->the_mutex));
- return bytes_to_write;
-}
-
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-//
-// client states
-//
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::client_auth
-// next: client_fail || client_send
-//-------------------------------------------------------------------------
-
-int
-LogCollationClientSM::client_auth(int event, VIO * /* vio ATS_UNUSED */)
-{
- ip_port_text_buffer ipb;
-
- Debug("log-coll", "[%d]client::client_auth", m_id);
-
- switch (event) {
- case LOG_COLL_EVENT_SWITCH: {
- Debug("log-coll", "[%d]client::client_auth - SWITCH", m_id);
- m_client_state = LOG_COLL_CLIENT_AUTH;
-
- NetMsgHeader nmh;
- int bytes_to_send = (int)strlen(Log::config->collation_secret);
- nmh.msg_bytes = bytes_to_send;
-
- // memory copies, I know... but it happens rarely!!! ^_^
- ink_assert(m_auth_buffer != nullptr);
- m_auth_buffer->write((char *)&nmh, sizeof(NetMsgHeader));
- m_auth_buffer->write(Log::config->collation_secret, bytes_to_send);
- bytes_to_send += sizeof(NetMsgHeader);
-
- Debug("log-coll", "[%d]client::client_auth - do_io_write(%d)", m_id, bytes_to_send);
- ink_assert(m_host_vc != nullptr);
- m_host_vio = m_host_vc->do_io_write(this, bytes_to_send, m_auth_reader);
- ink_assert(m_host_vio != nullptr);
-
- return EVENT_CONT;
- }
-
- case VC_EVENT_WRITE_READY:
- Debug("log-coll", "[%d]client::client_auth - WRITE_READY", m_id);
- return EVENT_CONT;
-
- case VC_EVENT_WRITE_COMPLETE:
- Debug("log-coll", "[%d]client::client_auth - WRITE_COMPLETE", m_id);
-
- Note("[log-coll] host up [%s:%u]", m_log_host->ip_addr().toString(ipb, sizeof(ipb)), m_log_host->port());
- m_host_is_up = true;
-
- return client_send(LOG_COLL_EVENT_SWITCH, nullptr);
-
- case VC_EVENT_ACTIVE_TIMEOUT:
- case VC_EVENT_INACTIVITY_TIMEOUT:
- case VC_EVENT_EOS:
- case VC_EVENT_ERROR: {
- Debug("log-coll", "[%d]client::client_auth - TIMEOUT|EOS|ERROR", m_id);
- int64_t read_avail = m_auth_reader->read_avail();
-
- if (read_avail > 0) {
- Debug("log-coll", "[%d]client::client_auth - consuming unsent data", m_id);
- m_auth_reader->consume(read_avail);
- }
-
- return client_fail(LOG_COLL_EVENT_SWITCH, nullptr);
- }
-
- default:
- ink_assert(!"unexpected event");
- return EVENT_CONT;
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::client_dns
-// next: client_open || client_done
-//-------------------------------------------------------------------------
-int
-LogCollationClientSM::client_dns(int event, HostDBInfo *hostdb_info)
-{
- Debug("log-coll", "[%d]client::client_dns", m_id);
-
- switch (event) {
- case LOG_COLL_EVENT_SWITCH:
- m_client_state = LOG_COLL_CLIENT_DNS;
- if (m_log_host->m_name == nullptr) {
- return client_done(LOG_COLL_EVENT_SWITCH, nullptr);
- }
- hostDBProcessor.getbyname_re(this, m_log_host->m_name, 0,
- HostDBProcessor::Options().setFlags(HostDBProcessor::HOSTDB_FORCE_DNS_RELOAD));
- return EVENT_CONT;
-
- case EVENT_HOST_DB_LOOKUP:
- if (hostdb_info == nullptr) {
- return client_done(LOG_COLL_EVENT_SWITCH, nullptr);
- }
- m_log_host->m_ip.assign(hostdb_info->ip());
- m_log_host->m_ip.toString(m_log_host->m_ipstr, sizeof(m_log_host->m_ipstr));
-
- return client_open(LOG_COLL_EVENT_SWITCH, nullptr);
-
- default:
- ink_assert(!"unexpected event");
- return EVENT_CONT;
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::client_done
-// next: <none>
-//-------------------------------------------------------------------------
-
-int
-LogCollationClientSM::client_done(int event, void * /* data ATS_UNUSED */)
-{
- ip_port_text_buffer ipb;
-
- Debug("log-coll", "[%d]client::client_done", m_id);
-
- switch (event) {
- case LOG_COLL_EVENT_SWITCH:
- m_client_state = LOG_COLL_CLIENT_DONE;
-
- Note("[log-coll] client shutdown [%s:%u]", m_log_host->ip_addr().toString(ipb, sizeof(ipb)), m_log_host->port());
-
- // close connections
- if (m_host_vc) {
- Debug("log-coll", "[%d]client::client_done - disconnecting!", m_id);
- // do I need to delete this???
- m_host_vc->do_io_close(0);
- m_host_vc = nullptr;
- }
- // flush unsent logs to orphan
- flush_to_orphan();
-
- // cancel any pending events/actions
- if (m_pending_action != nullptr) {
- m_pending_action->cancel();
- }
- if (m_pending_event != nullptr) {
- m_pending_event->cancel();
- }
- // free memory
- if (m_auth_buffer) {
- if (m_auth_reader) {
- m_auth_buffer->dealloc_reader(m_auth_reader);
- }
- free_MIOBuffer(m_auth_buffer);
- }
- if (m_send_buffer) {
- if (m_send_reader) {
- m_send_buffer->dealloc_reader(m_send_reader);
- }
- free_MIOBuffer(m_send_buffer);
- }
- if (m_abort_buffer) {
- free_MIOBuffer(m_abort_buffer);
- }
- if (m_buffer_send_list) {
- delete m_buffer_send_list;
- }
-
- return EVENT_DONE;
-
- default:
- ink_assert(!"unexpected event");
- return EVENT_DONE;
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::client_fail
-// next: client_fail || client_open
-//-------------------------------------------------------------------------
-
-int
-LogCollationClientSM::client_fail(int event, void * /* data ATS_UNUSED */)
-{
- ip_port_text_buffer ipb;
-
- Debug("log-coll", "[%d]client::client_fail", m_id);
-
- switch (event) {
- case LOG_COLL_EVENT_SWITCH:
- Debug("log-coll", "[%d]client::client_fail - SWITCH", m_id);
- m_client_state = LOG_COLL_CLIENT_FAIL;
-
- // avoid flooding log when host is down
- if (m_host_is_up) {
- Note("[log-coll] host down [%s:%u]", m_log_host->ip_addr().toString(ipb, sizeof ipb), m_log_host->m_port);
- char msg_buf[128];
- snprintf(msg_buf, sizeof(msg_buf), "Collation host %s:%u down", m_log_host->ip_addr().toString(ipb, sizeof ipb),
- m_log_host->m_port);
- RecSignalManager(MGMT_SIGNAL_SAC_SERVER_DOWN, msg_buf);
- m_host_is_up = false;
- }
-
- // close our NetVConnection (do I need to delete this)
- if (m_host_vc) {
- m_host_vc->do_io_close(0);
- m_host_vc = nullptr;
- }
- // flush unsent logs to orphan
- flush_to_orphan();
-
- // call back in collation_retry_sec seconds
- ink_assert(m_pending_event == nullptr);
- m_pending_event = eventProcessor.schedule_in(this, HRTIME_SECONDS(Log::config->collation_retry_sec));
-
- return EVENT_CONT;
-
- case EVENT_INTERVAL:
- Debug("log-coll", "[%d]client::client_fail - INTERVAL", m_id);
- m_pending_event = nullptr;
- return client_open(LOG_COLL_EVENT_SWITCH, nullptr);
-
- default:
- ink_assert(!"unexpected event");
- return EVENT_CONT;
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::client_idle
-// next: client_send
-//-------------------------------------------------------------------------
-
-int
-LogCollationClientSM::client_idle(int event, void * /* data ATS_UNUSED */)
-{
- Debug("log-coll", "[%d]client::client_idle", m_id);
-
- switch (event) {
- case LOG_COLL_EVENT_SWITCH:
- m_client_state = LOG_COLL_CLIENT_IDLE;
- return EVENT_CONT;
-
- case VC_EVENT_ACTIVE_TIMEOUT:
- case VC_EVENT_INACTIVITY_TIMEOUT:
- case VC_EVENT_EOS:
- case VC_EVENT_ERROR:
- Debug("log-coll", "[%d]client::client_idle - TIMEOUT|EOS|ERROR", m_id);
- return client_fail(LOG_COLL_EVENT_SWITCH, nullptr);
-
- default:
- ink_assert(!"unexpcted state");
- return EVENT_CONT;
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::client_init
-// next: client_dns
-//-------------------------------------------------------------------------
-
-int
-LogCollationClientSM::client_init(int event, void * /* data ATS_UNUSED */)
-{
- Debug("log-coll", "[%d]client::client_init", m_id);
-
- switch (event) {
- case LOG_COLL_EVENT_SWITCH:
- m_client_state = LOG_COLL_CLIENT_INIT;
- ink_assert(m_pending_event == nullptr);
- ink_mutex_acquire(&(mutex->the_mutex));
- m_pending_event = eventProcessor.schedule_imm(this);
- ink_mutex_release(&(mutex->the_mutex));
- return EVENT_CONT;
-
- case EVENT_IMMEDIATE:
- // callback complete, reset m_pending_event
- m_pending_event = nullptr;
-
- // allocate buffers
- m_auth_buffer = new_MIOBuffer();
- ink_assert(m_auth_buffer != nullptr);
- m_auth_reader = m_auth_buffer->alloc_reader();
- ink_assert(m_auth_reader != nullptr);
- m_send_buffer = new_MIOBuffer();
- ink_assert(m_send_buffer != nullptr);
- m_send_reader = m_send_buffer->alloc_reader();
- ink_assert(m_send_reader != nullptr);
- m_abort_buffer = new_MIOBuffer();
- ink_assert(m_abort_buffer != nullptr);
-
- // if we don't have an ip already, switch to client_dns
- if (!m_log_host->ip_addr().isValid()) {
- return client_dns(LOG_COLL_EVENT_SWITCH, nullptr);
- } else {
- return client_open(LOG_COLL_EVENT_SWITCH, nullptr);
- }
-
- default:
- ink_assert(!"unexpected state");
- return EVENT_CONT;
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::client_open
-// next: client_auth || client_fail
-//-------------------------------------------------------------------------
-
-int
-LogCollationClientSM::client_open(int event, NetVConnection *net_vc)
-{
- RecInt rec_timeout;
- int timeout = 86400;
- ip_port_text_buffer ipb;
- Debug("log-coll", "[%d]client::client_open", m_id);
-
- switch (event) {
- case LOG_COLL_EVENT_SWITCH:
- Debug("log-coll", "[%d]client::client_open - SWITCH", m_id);
- m_client_state = LOG_COLL_CLIENT_OPEN;
-
- {
- IpEndpoint target;
- target.assign(m_log_host->ip_addr(), htons(m_log_host->port()));
- ink_assert(target.isValid());
- Action *connect_action_handle = netProcessor.connect_re(this, &target.sa);
-
- if (connect_action_handle != ACTION_RESULT_DONE) {
- ink_assert(!m_pending_action);
- m_pending_action = connect_action_handle;
- }
- }
-
- return EVENT_CONT;
-
- case NET_EVENT_OPEN:
- Debug("log-coll", "[%d]client::client_open - %s:%u", m_id, m_log_host->ip_addr().toString(ipb, sizeof ipb), m_log_host->port());
-
- // callback complete, reset m_pending_action
- m_pending_action = nullptr;
-
- ink_assert(net_vc != nullptr);
- m_host_vc = net_vc;
-
- // assign an explicit inactivity timeout so that it will not get the default value later
- if (RecGetRecordInt("proxy.config.log.collation_client_timeout", &rec_timeout) == REC_ERR_OKAY) {
- timeout = rec_timeout;
- }
- m_host_vc->set_inactivity_timeout(HRTIME_SECONDS(timeout));
-
- // setup a client reader just for detecting a host disconnnect
- // (iocore should call back this function with and EOS/ERROR)
- m_abort_vio = m_host_vc->do_io_read(this, 1, m_abort_buffer);
-
- // change states
- return client_auth(LOG_COLL_EVENT_SWITCH, nullptr);
-
- case NET_EVENT_OPEN_FAILED:
- Debug("log-coll", "[%d]client::client_open - OPEN_FAILED", m_id);
- // callback complete, reset m_pending_pending action
- m_pending_action = nullptr;
- return client_fail(LOG_COLL_EVENT_SWITCH, nullptr);
-
- default:
- ink_assert(!"unexpected event");
- return EVENT_CONT;
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::client_send
-// next: client_fail || client_idle || client_send
-//-------------------------------------------------------------------------
-
-int
-LogCollationClientSM::client_send(int event, VIO * /* vio ATS_UNUSED */)
-{
- ip_port_text_buffer ipb;
-
- Debug("log-coll", "[%d]client::client_send", m_id);
-
- switch (event) {
- case EVENT_IMMEDIATE:
- Debug("log-coll", "[%d]client::client_send - EVENT_IMMEDIATE", m_id);
- // callback complete, reset m_pending_event
- m_pending_event = nullptr;
- // fallthrough
-
- case LOG_COLL_EVENT_SWITCH: {
- Debug("log-coll", "[%d]client::client_send - SWITCH", m_id);
- m_client_state = LOG_COLL_CLIENT_SEND;
-
- // get a buffer off our queue
- ink_assert(m_buffer_send_list != nullptr);
- ink_assert(m_buffer_in_iocore == nullptr);
- if ((m_buffer_in_iocore = m_buffer_send_list->get()) == nullptr) {
- return client_idle(LOG_COLL_EVENT_SWITCH, nullptr);
- }
- Debug("log-coll", "[%d]client::client_send - send_list to m_buffer_in_iocore", m_id);
- Debug("log-coll", "[%d]client::client_send - send_list_size(%d)", m_id, m_buffer_send_list->get_size());
-
- // enable m_flow if we're out of work to do
- if (m_flow == LOG_COLL_FLOW_DENY && m_buffer_send_list->get_size() == 0) {
- Debug("log-coll", "[%d]client::client_send - m_flow = ALLOW", m_id);
- Note("[log-coll] send-queue clear; resuming collation [%s:%u]", m_log_host->ip_addr().toString(ipb, sizeof ipb),
- m_log_host->port());
- m_flow = LOG_COLL_FLOW_ALLOW;
- }
- // future work:
- // Wrap the buffer in a io_buffer_block and send directly to
- // do_io_write to save a memory copy. But for now, just
- // write the lame way.
-
-#if defined(LOG_BUFFER_TRACKING)
- Debug("log-buftrak", "[%d]client::client_send - network write begin", m_buffer_in_iocore->header()->id);
-#endif // defined(LOG_BUFFER_TRACKING)
-
- // prepare to send data
- ink_assert(m_buffer_in_iocore != nullptr);
- LogBufferHeader *log_buffer_header = m_buffer_in_iocore->header();
- ink_assert(log_buffer_header != nullptr);
- NetMsgHeader nmh;
- int bytes_to_send = log_buffer_header->byte_count;
- nmh.msg_bytes = bytes_to_send;
- // TODO: We currently don't try to make the log buffers handle little vs big endian. TS-1156.
- // m_buffer_in_iocore->convert_to_network_order();
-
- RecIncrRawStat(log_rsb, mutex->thread_holding, log_stat_num_sent_to_network_stat, log_buffer_header->entry_count);
-
- RecIncrRawStat(log_rsb, mutex->thread_holding, log_stat_bytes_sent_to_network_stat, log_buffer_header->byte_count);
-
- // copy into m_send_buffer
- ink_assert(m_send_buffer != nullptr);
- m_send_buffer->write((char *)&nmh, sizeof(NetMsgHeader));
- m_send_buffer->write((char *)log_buffer_header, bytes_to_send);
- bytes_to_send += sizeof(NetMsgHeader);
-
- // send m_send_buffer to iocore
- Debug("log-coll", "[%d]client::client_send - do_io_write(%d)", m_id, bytes_to_send);
- ink_assert(m_host_vc != nullptr);
- m_host_vio = m_host_vc->do_io_write(this, bytes_to_send, m_send_reader);
- ink_assert(m_host_vio != nullptr);
- }
- return EVENT_CONT;
-
- case VC_EVENT_WRITE_READY:
- Debug("log-coll", "[%d]client::client_send - WRITE_READY", m_id);
- return EVENT_CONT;
-
- case VC_EVENT_WRITE_COMPLETE:
- Debug("log-coll", "[%d]client::client_send - WRITE_COMPLETE", m_id);
-
- ink_assert(m_buffer_in_iocore != nullptr);
-#if defined(LOG_BUFFER_TRACKING)
- Debug("log-buftrak", "[%d]client::client_send - network write complete", m_buffer_in_iocore->header()->id);
-#endif // defined(LOG_BUFFER_TRACKING)
-
- // done with the buffer, delete it
- Debug("log-coll", "[%d]client::client_send - m_buffer_in_iocore[%p] to delete_list", m_id, m_buffer_in_iocore);
- LogBuffer::destroy(m_buffer_in_iocore);
- m_buffer_in_iocore = nullptr;
-
- // switch back to client_send
- return client_send(LOG_COLL_EVENT_SWITCH, nullptr);
-
- case VC_EVENT_ACTIVE_TIMEOUT:
- case VC_EVENT_INACTIVITY_TIMEOUT:
- case VC_EVENT_EOS:
- case VC_EVENT_ERROR: {
- Debug("log-coll", "[%d]client::client_send - TIMEOUT|EOS|ERROR", m_id);
- int64_t read_avail = m_send_reader->read_avail();
-
- if (read_avail > 0) {
- Debug("log-coll", "[%d]client::client_send - consuming unsent data", m_id);
- m_send_reader->consume(read_avail);
- }
-
- return client_fail(LOG_COLL_EVENT_SWITCH, nullptr);
- }
-
- default:
- Debug("log-coll", "[%d]client::client_send - default", m_id);
- return client_fail(LOG_COLL_EVENT_SWITCH, nullptr);
- }
-}
-
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-//
-// support functions
-//
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM::flush_to_orphan
-//-------------------------------------------------------------------------
-void
-LogCollationClientSM::flush_to_orphan()
-{
- Debug("log-coll", "[%d]client::flush_to_orphan", m_id);
-
- // if in middle of a write, flush buffer_in_iocore to orphan
- if (m_buffer_in_iocore != nullptr) {
- Debug("log-coll", "[%d]client::flush_to_orphan - m_buffer_in_iocore to oprhan", m_id);
- // TODO: We currently don't try to make the log buffers handle little vs big endian. TS-1156.
- // m_buffer_in_iocore->convert_to_host_order();
- m_log_host->orphan_write_and_try_delete(m_buffer_in_iocore);
- m_buffer_in_iocore = nullptr;
- }
- // flush buffers in send_list to orphan
- LogBuffer *log_buffer;
- ink_assert(m_buffer_send_list != nullptr);
- while ((log_buffer = m_buffer_send_list->get()) != nullptr) {
- Debug("log-coll", "[%d]client::flush_to_orphan - send_list to orphan", m_id);
- m_log_host->orphan_write_and_try_delete(log_buffer);
- }
-
- // Now send_list is empty, let's update m_flow to ALLOW status
- Debug("log-coll", "[%d]client::client_send - m_flow = ALLOW", m_id);
- m_flow = LOG_COLL_FLOW_ALLOW;
-}
diff --git a/proxy/logging/LogCollationClientSM.h b/proxy/logging/LogCollationClientSM.h
deleted file mode 100644
index e10cc1f..0000000
--- a/proxy/logging/LogCollationClientSM.h
+++ /dev/null
@@ -1,116 +0,0 @@
-/** @file
-
- A brief file description
-
- @section license License
-
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you 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.
- */
-
-#pragma once
-
-//-------------------------------------------------------------------------
-// includes
-//-------------------------------------------------------------------------
-#include "P_HostDB.h"
-#include "P_Net.h"
-#include "LogCollationBase.h"
-
-//-------------------------------------------------------------------------
-// pre-declarations
-//-------------------------------------------------------------------------
-
-class LogBuffer;
-class LogHost;
-
-//-------------------------------------------------------------------------
-// LogCollationClientSM
-//-------------------------------------------------------------------------
-
-class LogCollationClientSM : public LogCollationBase, public Continuation
-{
-public:
- LogCollationClientSM(LogHost *log_host);
- ~LogCollationClientSM() override;
-
- int client_handler(int event, void *data);
-
- // public interface (for LogFile)
- int send(LogBuffer *log_buffer);
-
-private:
- enum ClientState {
- LOG_COLL_CLIENT_START,
- LOG_COLL_CLIENT_AUTH,
- LOG_COLL_CLIENT_DNS,
- LOG_COLL_CLIENT_DONE,
- LOG_COLL_CLIENT_FAIL,
- LOG_COLL_CLIENT_IDLE,
- LOG_COLL_CLIENT_INIT,
- LOG_COLL_CLIENT_OPEN,
- LOG_COLL_CLIENT_SEND
- };
-
- enum ClientFlowControl {
- LOG_COLL_FLOW_ALLOW,
- LOG_COLL_FLOW_DENY,
- };
-
-private:
- // client states
- int client_auth(int event, VIO *vio);
- int client_dns(int event, HostDBInfo *hostdb_info);
- int client_done(int event, void *data);
- int client_fail(int event, void *data);
- int client_idle(int event, void *data);
- int client_init(int event, void *data);
- int client_open(int event, NetVConnection *net_vc);
- int client_send(int event, VIO *vio);
- ClientState m_client_state = LOG_COLL_CLIENT_START;
-
- // support functions
- void flush_to_orphan();
-
- // iocore stuff (two buffers to avoid races)
- NetVConnection *m_host_vc = nullptr;
- VIO *m_host_vio = nullptr;
- MIOBuffer *m_auth_buffer = nullptr;
- IOBufferReader *m_auth_reader = nullptr;
- MIOBuffer *m_send_buffer = nullptr;
- IOBufferReader *m_send_reader = nullptr;
- Action *m_pending_action = nullptr;
- Event *m_pending_event = nullptr;
-
- // to detect server closes (there's got to be a better way to do this)
- VIO *m_abort_vio = nullptr;
- MIOBuffer *m_abort_buffer = nullptr;
- bool m_host_is_up = false;
-
- // send stuff
- LogBufferList *m_buffer_send_list = nullptr;
- LogBuffer *m_buffer_in_iocore = nullptr;
- ClientFlowControl m_flow = LOG_COLL_FLOW_ALLOW;
-
- // back pointer to LogHost container
- LogHost *m_log_host;
-
- // debugging
- static int ID;
- int m_id = 0;
-};
-
-typedef int (LogCollationClientSM::*LogCollationClientSMHandler)(int, void *);
diff --git a/proxy/logging/LogCollationHostSM.cc b/proxy/logging/LogCollationHostSM.cc
deleted file mode 100644
index 2962271..0000000
--- a/proxy/logging/LogCollationHostSM.cc
+++ /dev/null
@@ -1,527 +0,0 @@
-/** @file
-
- A brief file description
-
- @section license License
-
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you 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.
- */
-
-//-------------------------------------------------------------------------
-// include files
-//-------------------------------------------------------------------------
-
-#include "tscore/ink_config.h"
-
-#include <cstdio>
-#include <cstdlib>
-#include <climits>
-#include <cstring>
-#include <sys/types.h>
-
-#include "P_EventSystem.h"
-#include "P_Net.h"
-
-#include "LogUtils.h"
-#include "LogSock.h"
-#include "LogField.h"
-#include "LogFile.h"
-#include "LogFormat.h"
-#include "LogBuffer.h"
-#include "LogHost.h"
-#include "LogObject.h"
-#include "LogConfig.h"
-#include "Log.h"
-
-#include "LogCollationHostSM.h"
-
-//-------------------------------------------------------------------------
-// statics
-//-------------------------------------------------------------------------
-
-int LogCollationHostSM::ID = 0;
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM::LogCollationHostSM
-//-------------------------------------------------------------------------
-
-LogCollationHostSM::LogCollationHostSM(NetVConnection *client_vc)
- : Continuation(new_ProxyMutex()),
- m_client_vc(client_vc),
- m_client_vio(nullptr),
- m_client_buffer(nullptr),
- m_client_reader(nullptr),
- m_pending_event(nullptr),
- m_read_buffer(nullptr),
- m_read_bytes_wanted(0),
- m_read_bytes_received(0),
- m_read_buffer_fast_allocator_size(-1),
- m_client_ip(0),
- m_client_port(0),
- m_id(ID++)
-{
- RecInt rec_timeout;
- int timeout = 86390;
- Debug("log-coll", "[%d]host::constructor", m_id);
-
- ink_assert(m_client_vc != nullptr);
-
- // assign an explicit inactivity timeout so that it will not get the default value later
- if (RecGetRecordInt("proxy.config.log.collation_host_timeout", &rec_timeout) == REC_ERR_OKAY) {
- timeout = rec_timeout;
- }
- m_client_vc->set_inactivity_timeout(HRTIME_SECONDS(timeout));
-
- // get client info
- m_client_ip = m_client_vc->get_remote_ip();
- m_client_port = m_client_vc->get_remote_port();
- Note("[log-coll] client connected [%d.%d.%d.%d:%d]", ((unsigned char *)(&m_client_ip))[0], ((unsigned char *)(&m_client_ip))[1],
- ((unsigned char *)(&m_client_ip))[2], ((unsigned char *)(&m_client_ip))[3], m_client_port);
-
- SET_HANDLER((LogCollationHostSMHandler)&LogCollationHostSM::host_handler);
- host_init(LOG_COLL_EVENT_SWITCH, nullptr);
-}
-
-void
-LogCollationHostSM::freeReadBuffer()
-{
- if (m_read_buffer) {
- if (m_read_buffer_fast_allocator_size >= 0) {
- ioBufAllocator[m_read_buffer_fast_allocator_size].free_void(m_read_buffer);
- } else {
- ats_free(m_read_buffer);
- }
- m_read_buffer = nullptr;
- }
-}
-
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-//
-// handlers
-//
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM::host_handler
-//-------------------------------------------------------------------------
-
-int
-LogCollationHostSM::host_handler(int event, void *data)
-{
- switch (m_host_state) {
- case LOG_COLL_HOST_AUTH:
- return host_auth(event, data);
- case LOG_COLL_HOST_DONE:
- return host_done(event, data);
- case LOG_COLL_HOST_INIT:
- return host_init(event, data);
- case LOG_COLL_HOST_RECV:
- return host_recv(event, data);
- default:
- ink_assert(!"unexpected state");
- return EVENT_CONT;
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM::read_handler
-//-------------------------------------------------------------------------
-
-int
-LogCollationHostSM::read_handler(int event, void *data)
-{
- switch (m_read_state) {
- case LOG_COLL_READ_BODY:
- return read_body(event, (VIO *)data);
- case LOG_COLL_READ_HDR:
- return read_hdr(event, (VIO *)data);
- default:
- ink_assert(!"unexpected state");
- return EVENT_CONT;
- }
-}
-
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-//
-// host states
-//
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM::host_auth
-// next: host_done || host_recv
-//-------------------------------------------------------------------------
-
-int
-LogCollationHostSM::host_auth(int event, void * /* data ATS_UNUSED */)
-{
- Debug("log-coll", "[%d]host::host_auth", m_id);
-
- switch (event) {
- case LOG_COLL_EVENT_SWITCH:
- Debug("log-coll", "[%d]host::host_auth - SWITCH", m_id);
- m_host_state = LOG_COLL_HOST_AUTH;
- return read_start();
-
- case LOG_COLL_EVENT_READ_COMPLETE:
- Debug("log-coll", "[%d]host::host_auth - READ_COMPLETE", m_id);
- {
- // compare authorization secrets
- ink_assert(m_read_buffer != nullptr);
- int diff = strncmp(m_read_buffer, Log::config->collation_secret, m_read_bytes_received);
- freeReadBuffer();
- if (!diff) {
- Debug("log-coll", "[%d]host::host_auth - authenticated!", m_id);
- return host_recv(LOG_COLL_EVENT_SWITCH, nullptr);
- } else {
- Debug("log-coll", "[%d]host::host_auth - authenticated failed!", m_id);
- Note("[log-coll] authentication failed [%d.%d.%d.%d:%d]", ((unsigned char *)(&m_client_ip))[0],
- ((unsigned char *)(&m_client_ip))[1], ((unsigned char *)(&m_client_ip))[2], ((unsigned char *)(&m_client_ip))[3],
- m_client_port);
- return host_done(LOG_COLL_EVENT_SWITCH, nullptr);
- }
- }
-
- case LOG_COLL_EVENT_ERROR:
- Debug("log-coll", "[%d]host::host_auth - ERROR", m_id);
- return host_done(LOG_COLL_EVENT_SWITCH, nullptr);
-
- default:
- ink_assert(!"unexpected state");
- return EVENT_CONT;
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM::host_done
-// next: none
-//-------------------------------------------------------------------------
-
-int
-LogCollationHostSM::host_done(int /* event ATS_UNUSED */, void * /* data ATS_UNUSED */)
-{
- Debug("log-coll", "[%d]host::host_done", m_id);
-
- // close connections
- if (m_client_vc) {
- Debug("log-coll", "[%d]host::host_done - disconnecting!", m_id);
- m_client_vc->do_io_close();
- m_client_vc = nullptr;
- Note("[log-coll] client disconnected [%d.%d.%d.%d:%d]", ((unsigned char *)(&m_client_ip))[0],
- ((unsigned char *)(&m_client_ip))[1], ((unsigned char *)(&m_client_ip))[2], ((unsigned char *)(&m_client_ip))[3],
- m_client_port);
- }
- // free memory
- if (m_client_buffer) {
- if (m_client_reader) {
- m_client_buffer->dealloc_reader(m_client_reader);
- }
- free_MIOBuffer(m_client_buffer);
- }
- // delete this state machine and return
- delete this;
- return EVENT_DONE;
-}
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM::host_init
-// next: host_auth || host_done
-//-------------------------------------------------------------------------
-
-int
-LogCollationHostSM::host_init(int event, void * /* data ATS_UNUSED */)
-{
- Debug("log-coll", "[%d]host::host_init", m_id);
-
- switch (event) {
- case LOG_COLL_EVENT_SWITCH:
- m_host_state = LOG_COLL_HOST_INIT;
- m_pending_event = eventProcessor.schedule_imm(this);
- return EVENT_CONT;
-
- case EVENT_IMMEDIATE:
- // allocate memory
- m_client_buffer = new_MIOBuffer();
- ink_assert(m_client_buffer != nullptr);
- m_client_reader = m_client_buffer->alloc_reader();
- ink_assert(m_client_reader != nullptr);
- return host_auth(LOG_COLL_EVENT_SWITCH, nullptr);
-
- default:
- ink_assert(!"unexpected state");
- return EVENT_DONE;
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM::host_recv
-// next: host_done || host_recv
-//-------------------------------------------------------------------------
-
-int
-LogCollationHostSM::host_recv(int event, void * /* data ATS_UNUSED */)
-{
- Debug("log-coll", "[%d]host::host_recv", m_id);
-
- switch (event) {
- case LOG_COLL_EVENT_SWITCH:
- Debug("log-coll", "[%d]host::host_recv - SWITCH", m_id);
- m_host_state = LOG_COLL_HOST_RECV;
- return read_start();
-
- case LOG_COLL_EVENT_READ_COMPLETE:
- Debug("log-coll", "[%d]host::host_recv - READ_COMPLETE", m_id);
- {
- // grab the log_buffer
- LogBufferHeader *log_buffer_header;
- LogBuffer *log_buffer;
- LogFormat *log_format;
- LogObject *log_object;
- unsigned version;
-
- ink_assert(m_read_buffer != nullptr);
- ink_assert(m_read_bytes_received >= (int64_t)sizeof(LogBufferHeader));
- log_buffer_header = (LogBufferHeader *)m_read_buffer;
-
- // convert the buffer we just received to host order
- // TODO: We currently don't try to make the log buffers handle little vs big endian. TS-1156.
- // LogBuffer::convert_to_host_order(log_buffer_header);
-
- version = log_buffer_header->version;
- if (version != LOG_SEGMENT_VERSION) {
- Note("[log-coll] invalid LogBuffer received; invalid version - "
- "buffer = %u, current = %u",
- version, LOG_SEGMENT_VERSION);
- freeReadBuffer();
-
- } else {
- log_object = Log::match_logobject(log_buffer_header);
- if (!log_object) {
- Note("[log-coll] LogObject not found with fieldlist id; "
- "writing LogBuffer to scrap file");
- log_object = Log::global_scrap_object;
- }
- log_format = log_object->m_format;
- Debug("log-coll", "[%d]host::host_recv - using format '%s'", m_id, log_format->name());
-
- // make a new LogBuffer (log_buffer_header plus subsequent
- // buffer already converted to host order) and add it to the
- // object's flush queue
- //
- log_buffer = new LogBuffer(log_object, log_buffer_header);
-
- RecIncrRawStat(log_rsb, mutex->thread_holding, log_stat_num_received_from_network_stat, log_buffer_header->entry_count);
-
- RecIncrRawStat(log_rsb, mutex->thread_holding, log_stat_bytes_received_from_network_stat, log_buffer_header->byte_count);
-
- int idx = log_object->add_to_flush_queue(log_buffer);
- Log::preproc_notify[idx].signal();
- }
-
-#if defined(LOG_BUFFER_TRACKING)
- Debug("log-buftrak", "[%d]host::host_recv - network read complete", log_buffer_header->id);
-#endif // defined(LOG_BUFFER_TRACKING)
-
- // get ready for next read (memory may not be freed!!!)
- m_read_buffer = nullptr;
-
- return host_recv(LOG_COLL_EVENT_SWITCH, nullptr);
- }
-
- case LOG_COLL_EVENT_ERROR:
- Debug("log-coll", "[%d]host::host_recv - ERROR", m_id);
- return host_done(LOG_COLL_EVENT_SWITCH, nullptr);
-
- default:
- ink_assert(!"unexpected state");
- return EVENT_DONE;
- }
-}
-
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-//
-// read states
-//
-//-------------------------------------------------------------------------
-//-------------------------------------------------------------------------
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM::read_start
-// next: read_hdr
-//-------------------------------------------------------------------------
-
-int
-LogCollationHostSM::read_start()
-{
- Debug("log-coll", "[%d]host::read_start", m_id);
-
- SET_HANDLER((LogCollationHostSMHandler)&LogCollationHostSM::read_handler);
- if (m_read_buffer) {
- ink_assert(!"m_read_buffer still points to something, doh!");
- }
- return read_hdr(LOG_COLL_EVENT_SWITCH, nullptr);
-}
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM::read_hdr
-// next: read_body || read_done
-//-------------------------------------------------------------------------
-
-int
-LogCollationHostSM::read_hdr(int event, VIO *vio)
-{
- Debug("log-coll", "[%d]host::read_hdr", m_id);
-
- switch (event) {
- case LOG_COLL_EVENT_SWITCH:
- Debug("log-coll", "[%d]host:read_hdr - SWITCH", m_id);
- m_read_state = LOG_COLL_READ_HDR;
-
- m_read_bytes_wanted = sizeof(NetMsgHeader);
- m_read_bytes_received = 0;
- m_read_buffer = (char *)&m_net_msg_header;
- ink_assert(m_client_vc != nullptr);
- Debug("log-coll", "[%d]host:read_hdr - do_io_read(%" PRId64 ")", m_id, m_read_bytes_wanted);
- m_client_vio = m_client_vc->do_io_read(this, m_read_bytes_wanted, m_client_buffer);
- ink_assert(m_client_vio != nullptr);
- return EVENT_CONT;
-
- case VC_EVENT_IMMEDIATE:
- Debug("log-coll", "[%d]host::read_hdr - IMMEDIATE", m_id);
- return EVENT_CONT;
-
- case VC_EVENT_READ_READY:
- Debug("log-coll", "[%d]host::read_hdr - READ_READY", m_id);
- read_partial(vio);
- return EVENT_CONT;
-
- case VC_EVENT_READ_COMPLETE:
- Debug("log-coll", "[%d]host::read_hdr - READ_COMPLETE", m_id);
- read_partial(vio);
- ink_assert(m_read_bytes_wanted == m_read_bytes_received);
- return read_body(LOG_COLL_EVENT_SWITCH, nullptr);
-
- case VC_EVENT_ACTIVE_TIMEOUT:
- case VC_EVENT_INACTIVITY_TIMEOUT:
- case VC_EVENT_EOS:
- case VC_EVENT_ERROR:
- Debug("log-coll", "[%d]host::read_hdr - TIMEOUT|EOS|ERROR", m_id);
- return read_done(LOG_COLL_EVENT_ERROR, nullptr);
-
- default:
- Debug("log-coll", "[%d]host::read_hdr - default %d", m_id, event);
- return read_done(LOG_COLL_EVENT_ERROR, nullptr);
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM::read_body
-// next: read_body || read_done
-//-------------------------------------------------------------------------
-
-int
-LogCollationHostSM::read_body(int event, VIO *vio)
-{
- Debug("log-coll", "[%d]host::read_body", m_id);
-
- switch (event) {
- case LOG_COLL_EVENT_SWITCH:
- Debug("log-coll", "[%d]host:read_body - SWITCH", m_id);
- m_read_state = LOG_COLL_READ_BODY;
-
- m_read_bytes_wanted = m_net_msg_header.msg_bytes;
- ink_assert(m_read_bytes_wanted > 0);
- m_read_bytes_received = 0;
- if (m_read_bytes_wanted <= max_iobuffer_size) {
- m_read_buffer_fast_allocator_size = buffer_size_to_index(m_read_bytes_wanted);
- m_read_buffer = (char *)ioBufAllocator[m_read_buffer_fast_allocator_size].alloc_void();
- } else {
- m_read_buffer_fast_allocator_size = -1;
- m_read_buffer = (char *)ats_malloc(m_read_bytes_wanted);
- }
- ink_assert(m_read_buffer != nullptr);
- ink_assert(m_client_vc != nullptr);
- Debug("log-coll", "[%d]host:read_body - do_io_read(%" PRId64 ")", m_id, m_read_bytes_wanted);
- m_client_vio = m_client_vc->do_io_read(this, m_read_bytes_wanted, m_client_buffer);
- ink_assert(m_client_vio != nullptr);
- return EVENT_CONT;
-
- case VC_EVENT_IMMEDIATE:
- Debug("log-coll", "[%d]host::read_body - IMMEDIATE", m_id);
- return EVENT_CONT;
-
- case VC_EVENT_READ_READY:
- Debug("log-coll", "[%d]host::read_body - READ_READY", m_id);
- read_partial(vio);
- return EVENT_CONT;
-
- case VC_EVENT_READ_COMPLETE:
- Debug("log-coll", "[%d]host::read_body - READ_COMPLETE", m_id);
- read_partial(vio);
- ink_assert(m_read_bytes_wanted == m_read_bytes_received);
- return read_done(LOG_COLL_EVENT_READ_COMPLETE, nullptr);
-
- case VC_EVENT_ACTIVE_TIMEOUT:
- case VC_EVENT_INACTIVITY_TIMEOUT:
- case VC_EVENT_EOS:
- case VC_EVENT_ERROR:
- Debug("log-coll", "[%d]host::read_body - TIMEOUT|EOS|ERROR", m_id);
- return read_done(LOG_COLL_EVENT_ERROR, nullptr);
-
- default:
- Debug("log-coll", "[%d]host::read_body - default %d", m_id, event);
- return read_done(LOG_COLL_EVENT_ERROR, nullptr);
- }
-}
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM::read_done
-// next: give control back to host state-machine
-//-------------------------------------------------------------------------
-
-int
-LogCollationHostSM::read_done(int event, void * /* data ATS_UNUSED */)
-{
- SET_HANDLER((LogCollationHostSMHandler)&LogCollationHostSM::host_handler);
- return host_handler(event, nullptr);
-}
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM::read_partial
-//-------------------------------------------------------------------------
-
-void
-LogCollationHostSM::read_partial(VIO *vio)
-{
- // checks
- ink_assert(vio != nullptr);
- ink_assert(vio->vc_server == m_client_vc);
- ink_assert(m_client_buffer != nullptr);
- ink_assert(m_client_reader != nullptr);
-
- // careful not to read more than we have memory for
- char *p = &(m_read_buffer[m_read_bytes_received]);
- int64_t bytes_wanted_now = m_read_bytes_wanted - m_read_bytes_received;
- int64_t bytes_received_now = m_client_reader->read(p, bytes_wanted_now);
-
- m_read_bytes_received += bytes_received_now;
-}
diff --git a/proxy/logging/LogCollationHostSM.h b/proxy/logging/LogCollationHostSM.h
deleted file mode 100644
index d7038fc..0000000
--- a/proxy/logging/LogCollationHostSM.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/** @file
-
- A brief file description
-
- @section license License
-
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you 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.
- */
-
-#pragma once
-
-//-------------------------------------------------------------------------
-// includes
-//-------------------------------------------------------------------------
-
-#include "P_EventSystem.h"
-#include "LogCollationBase.h"
-
-//-------------------------------------------------------------------------
-// pre-declarations
-//-------------------------------------------------------------------------
-
-struct LogBufferHeader;
-
-//-------------------------------------------------------------------------
-// LogCollationHostSM
-//-------------------------------------------------------------------------
-
-class LogCollationHostSM : public LogCollationBase, public Continuation
-{
-public:
- LogCollationHostSM(NetVConnection *client_vc);
-
- // handlers
- int host_handler(int event, void *data);
- int read_handler(int event, void *data);
-
-private:
- enum HostState {
- LOG_COLL_HOST_NULL,
- LOG_COLL_HOST_AUTH,
- LOG_COLL_HOST_DONE,
- LOG_COLL_HOST_INIT,
- LOG_COLL_HOST_RECV,
- };
-
- enum ReadState {
- LOG_COLL_READ_NULL,
- LOG_COLL_READ_BODY,
- LOG_COLL_READ_HDR,
- };
-
-private:
- // host states
- int host_init(int event, void *data);
- int host_auth(int event, void *data);
- int host_recv(int event, void *data);
- int host_done(int event, void *data);
- HostState m_host_state;
-
- // read states
- int read_hdr(int event, VIO *vio);
- int read_body(int event, VIO *vio);
- int read_done(int event, void *data);
- int read_start();
- void freeReadBuffer();
- ReadState m_read_state;
-
- // helper for read states
- void read_partial(VIO *vio);
-
- // iocore stuff
- NetVConnection *m_client_vc;
- VIO *m_client_vio;
- MIOBuffer *m_client_buffer;
- IOBufferReader *m_client_reader;
- Event *m_pending_event;
-
- // read_state stuff
- NetMsgHeader m_net_msg_header;
- char *m_read_buffer;
- int64_t m_read_bytes_wanted;
- int64_t m_read_bytes_received;
- int64_t m_read_buffer_fast_allocator_size;
-
- // client info
- int m_client_ip;
- int m_client_port;
-
- // debugging
- static int ID;
- int m_id;
-};
-
-typedef int (LogCollationHostSM::*LogCollationHostSMHandler)(int, void *);
diff --git a/proxy/logging/LogConfig.cc b/proxy/logging/LogConfig.cc
index e952605..2644011 100644
--- a/proxy/logging/LogConfig.cc
+++ b/proxy/logging/LogConfig.cc
@@ -41,14 +41,11 @@
#include "LogFormat.h"
#include "LogFile.h"
#include "LogBuffer.h"
-#include "LogHost.h"
#include "LogObject.h"
#include "LogConfig.h"
#include "LogUtils.h"
#include "tscore/SimpleTokenizer.h"
-#include "LogCollationAccept.h"
-
#include "YamlLogConfig.h"
#define DISK_IS_CONFIG_FULL_MESSAGE \
@@ -75,22 +72,14 @@ LogConfig::setup_default_values()
}
hostname = ats_strdup(name);
- log_buffer_size = (int)(10 * LOG_KILOBYTE);
- max_secs_per_buffer = 5;
- max_space_mb_for_logs = 100;
- max_space_mb_for_orphan_logs = 25;
- max_space_mb_headroom = 10;
- logfile_perm = 0644;
- logfile_dir = ats_strdup(".");
-
- collation_mode = Log::NO_COLLATION;
- collation_host = ats_strdup("none");
- collation_port = 0;
- collation_host_tagged = false;
- collation_preproc_threads = 1;
- collation_secret = ats_strdup("foobar");
- collation_retry_sec = 0;
- collation_max_send_buffers = 0;
+ log_buffer_size = (int)(10 * LOG_KILOBYTE);
+ max_secs_per_buffer = 5;
+ max_space_mb_for_logs = 100;
+ max_space_mb_headroom = 10;
+ logfile_perm = 0644;
+ logfile_dir = ats_strdup(".");
+
+ preproc_threads = 1;
rolling_enabled = Log::NO_ROLLING;
rolling_interval_sec = 86400; // 24 hours
@@ -103,8 +92,6 @@ LogConfig::setup_default_values()
file_stat_frequency = 16;
space_used_frequency = 900;
- use_orphan_log_space_value = false;
-
ascii_buffer_size = 4 * 9216;
max_line_size = 9216; // size of pipe buffer for SunOS 5.6
}
@@ -136,11 +123,6 @@ LogConfig::read_configuration_variables()
max_space_mb_for_logs = val;
}
- val = (int)REC_ConfigReadInteger("proxy.config.log.max_space_mb_for_orphan_logs");
- if (val > 0) {
- max_space_mb_for_orphan_logs = val;
- }
-
val = (int)REC_ConfigReadInteger("proxy.config.log.max_space_mb_headroom");
if (val > 0) {
max_space_mb_headroom = val;
@@ -169,45 +151,9 @@ LogConfig::read_configuration_variables()
::exit(1);
}
- // COLLATION
- val = (int)REC_ConfigReadInteger("proxy.local.log.collation_mode");
- // do not restrict value so that error message is logged if
- // collation_mode is out of range
- collation_mode = val;
-
- ptr = REC_ConfigReadString("proxy.config.log.collation_host");
- if (ptr != nullptr) {
- ats_free(collation_host);
- collation_host = ptr;
- }
-
- val = (int)REC_ConfigReadInteger("proxy.config.log.collation_port");
- if (val >= 0) {
- collation_port = val;
- }
-
- val = (int)REC_ConfigReadInteger("proxy.config.log.collation_host_tagged");
- collation_host_tagged = (val > 0);
-
- val = (int)REC_ConfigReadInteger("proxy.config.log.collation_preproc_threads");
+ val = (int)REC_ConfigReadInteger("proxy.config.log.preproc_threads");
if (val > 0 && val <= 128) {
- collation_preproc_threads = val;
- }
-
- ptr = REC_ConfigReadString("proxy.config.log.collation_secret");
- if (ptr != nullptr) {
- ats_free(collation_secret);
- collation_secret = ptr;
- }
-
- val = (int)REC_ConfigReadInteger("proxy.config.log.collation_retry_sec");
- if (val >= 0) {
- collation_retry_sec = val;
- }
-
- val = (int)REC_ConfigReadInteger("proxy.config.log.collation_max_send_buffers");
- if (val >= 0) {
- collation_max_send_buffers = val;
+ preproc_threads = val;
}
// ROLLING
@@ -302,77 +248,7 @@ LogConfig::LogConfig() : m_partition_space_left((int64_t)UINT_MAX)
LogConfig::~LogConfig()
{
- // we don't delete the log collation accept because it may be transferred
- // to another LogConfig object
- //
- // delete m_log_collation_accept;
-
- ats_free(hostname);
ats_free(logfile_dir);
- ats_free(collation_host);
- ats_free(collation_secret);
-}
-
-/*-------------------------------------------------------------------------
- LogConfig::setup_collation
- -------------------------------------------------------------------------*/
-
-void
-LogConfig::setup_collation(LogConfig *prev_config)
-{
- // Set-up the collation status, but only if collation is enabled and
- // there are valid entries for the collation host and port.
- //
- if (collation_mode < Log::NO_COLLATION || collation_mode >= Log::N_COLLATION_MODES) {
- Note("Invalid value %d for proxy.local.log.collation_mode"
- " configuration variable (valid range is from %d to %d)\n"
- "Log collation disabled",
- collation_mode, Log::NO_COLLATION, Log::N_COLLATION_MODES - 1);
- } else if (collation_mode == Log::NO_COLLATION) {
- // if the previous configuration had a collation accept, delete it
- //
- if (prev_config && prev_config->m_log_collation_accept) {
- delete prev_config->m_log_collation_accept;
- prev_config->m_log_collation_accept = nullptr;
- }
- } else {
- Warning("Log collation is deprecated as of ATS v8.0.0!");
- if (!collation_port) {
- Note("Cannot activate log collation, %d is an invalid collation port", collation_port);
- } else if (collation_mode > Log::COLLATION_HOST && strcmp(collation_host, "none") == 0) {
- Note("Cannot activate log collation, \"%s\" is an invalid collation host", collation_host);
- } else {
- if (collation_mode == Log::COLLATION_HOST) {
- ink_assert(m_log_collation_accept == nullptr);
-
- if (prev_config && prev_config->m_log_collation_accept) {
- if (prev_config->collation_port == collation_port) {
- m_log_collation_accept = prev_config->m_log_collation_accept;
- } else {
- delete prev_config->m_log_collation_accept;
- }
- }
-
- if (!m_log_collation_accept) {
- Log::collation_port = collation_port;
- m_log_collation_accept = new LogCollationAccept(collation_port);
- }
- Debug("log", "I am a collation host listening on port %d.", collation_port);
- } else {
- Debug("log",
- "I am a collation client (%d)."
- " My collation host is %s:%d",
- collation_mode, collation_host, collation_port);
- }
-
- Debug("log", "using iocore log collation");
- if (collation_host_tagged) {
- LogFormat::turn_tagging_on();
- } else {
- LogFormat::turn_tagging_off();
- }
- }
- }
}
/*-------------------------------------------------------------------------
@@ -386,8 +262,6 @@ LogConfig::init(LogConfig *prev_config)
ink_assert(!initialized);
- setup_collation(prev_config);
-
update_space_used();
// create log objects
@@ -404,7 +278,7 @@ LogConfig::init(LogConfig *prev_config)
Debug("log", "creating predefined error log object");
errlog = new LogObject(fmt.get(), logfile_dir, "error.log", LOG_FILE_ASCII, nullptr, (Log::RollingEnabledValues)rolling_enabled,
- collation_preproc_threads, rolling_interval_sec, rolling_offset_hr, rolling_size_mb);
+ preproc_threads, rolling_interval_sec, rolling_offset_hr, rolling_size_mb);
log_object_manager.manage_object(errlog);
errlog->set_fmt_timestamps();
@@ -425,16 +299,6 @@ LogConfig::init(LogConfig *prev_config)
ink_atomic_swap(&Log::error_log, errlog);
- // determine if we should use the orphan log space value or not
- // we use it if all objects are collation clients, or if some are and
- // the specified space for collation is larger than that for local files
- //
- size_t num_collation_clients = log_object_manager.get_num_collation_clients();
- use_orphan_log_space_value = (num_collation_clients == 0 ? false :
- (log_object_manager.get_num_objects() == num_collation_clients ?
- true :
- max_space_mb_for_orphan_logs > max_space_mb_for_logs));
-
initialized = true;
}
@@ -454,18 +318,12 @@ LogConfig::display(FILE *fd)
fprintf(fd, " log_buffer_size = %d\n", log_buffer_size);
fprintf(fd, " max_secs_per_buffer = %d\n", max_secs_per_buffer);
fprintf(fd, " max_space_mb_for_logs = %d\n", max_space_mb_for_logs);
- fprintf(fd, " max_space_mb_for_orphan_logs = %d\n", max_space_mb_for_orphan_logs);
- fprintf(fd, " use_orphan_log_space_value = %d\n", use_orphan_log_space_value);
fprintf(fd, " max_space_mb_headroom = %d\n", max_space_mb_headroom);
fprintf(fd, " hostname = %s\n", hostname);
fprintf(fd, " logfile_dir = %s\n", logfile_dir);
fprintf(fd, " logfile_perm = 0%o\n", logfile_perm);
- fprintf(fd, " collation_mode = %d\n", collation_mode);
- fprintf(fd, " collation_host = %s\n", collation_host);
- fprintf(fd, " collation_port = %d\n", collation_port);
- fprintf(fd, " collation_host_tagged = %d\n", collation_host_tagged);
- fprintf(fd, " collation_preproc_threads = %d\n", collation_preproc_threads);
- fprintf(fd, " collation_secret = %s\n", collation_secret);
+
+ fprintf(fd, " preproc_threads = %d\n", preproc_threads);
fprintf(fd, " rolling_enabled = %d\n", rolling_enabled);
fprintf(fd, " rolling_interval_sec = %d\n", rolling_interval_sec);
fprintf(fd, " rolling_offset_hr = %d\n", rolling_offset_hr);
@@ -543,29 +401,11 @@ void
LogConfig::register_config_callbacks()
{
static const char *names[] = {
- "proxy.config.log.log_buffer_size",
- "proxy.config.log.max_secs_per_buffer",
- "proxy.config.log.max_space_mb_for_logs",
- "proxy.config.log.max_space_mb_for_orphan_logs",
- "proxy.config.log.max_space_mb_headroom",
- "proxy.config.log.logfile_perm",
- "proxy.config.log.hostname",
- "proxy.config.log.logfile_dir",
- "proxy.local.log.collation_mode",
- "proxy.config.log.collation_host",
- "proxy.config.log.collation_port",
- "proxy.config.log.collation_host_tagged",
- "proxy.config.log.collation_secret",
- "proxy.config.log.collation_retry_sec",
- "proxy.config.log.collation_max_send_buffers",
- "proxy.config.log.rolling_enabled",
- "proxy.config.log.rolling_interval_sec",
- "proxy.config.log.rolling_offset_hr",
- "proxy.config.log.rolling_size_mb",
- "proxy.config.log.auto_delete_rolled_files",
- "proxy.config.log.config.filename",
- "proxy.config.log.sampling_frequency",
- "proxy.config.log.file_stat_frequency",
+ "proxy.config.log.log_buffer_size", "proxy.config.log.max_secs_per_buffer", "proxy.config.log.max_space_mb_for_logs",
+ "proxy.config.log.max_space_mb_headroom", "proxy.config.log.logfile_perm", "proxy.config.log.hostname",
+ "proxy.config.log.logfile_dir", "proxy.config.log.rolling_enabled", "proxy.config.log.rolling_interval_sec",
+ "proxy.config.log.rolling_offset_hr", "proxy.config.log.rolling_size_mb", "proxy.config.log.auto_delete_rolled_files",
+ "proxy.config.log.config.filename", "proxy.config.log.sampling_frequency", "proxy.config.log.file_stat_frequency",
"proxy.config.log.space_used_frequency",
};
diff --git a/proxy/logging/LogConfig.h b/proxy/logging/LogConfig.h
index fdf3def..c36d38b 100644
--- a/proxy/logging/LogConfig.h
+++ b/proxy/logging/LogConfig.h
@@ -77,7 +77,6 @@ enum {
extern RecRawStatBlock *log_rsb;
struct dirent;
-struct LogCollationAccept;
/*-------------------------------------------------------------------------
LogDeleteCandidate, LogDeletingInfo&Descriptor
@@ -189,12 +188,6 @@ public:
bool space_to_write(int64_t bytes_to_write) const;
bool
- am_collation_host() const
- {
- return collation_mode == Log::COLLATION_HOST;
- }
-
- bool
space_is_short() const
{
return !space_to_write(max_space_mb_headroom * LOG_MEGABYTE);
@@ -216,7 +209,7 @@ public:
int
get_max_space_mb() const
{
- return (use_orphan_log_space_value ? max_space_mb_for_orphan_logs : max_space_mb_for_logs);
+ return max_space_mb_for_logs;
}
void
@@ -247,15 +240,11 @@ public:
int log_buffer_size;
int max_secs_per_buffer;
int max_space_mb_for_logs;
- int max_space_mb_for_orphan_logs;
int max_space_mb_headroom;
int logfile_perm;
- int collation_mode;
- int collation_port;
- bool collation_host_tagged;
- int collation_preproc_threads;
- int collation_retry_sec;
- int collation_max_send_buffers;
+
+ int preproc_threads;
+
Log::RollingEnabledValues rolling_enabled;
int rolling_interval_sec;
int rolling_offset_hr;
@@ -274,23 +263,13 @@ public:
char *hostname;
char *logfile_dir;
- char *collation_host;
- char *collation_secret;
private:
bool evaluate_config();
void setup_default_values();
- void setup_collation(LogConfig *prev_config);
private:
- // if true, use max_space_mb_for_orphan_logs to determine the amount
- // of space that logging can use, otherwise use max_space_mb_for_logs
- //
- bool use_orphan_log_space_value;
-
- LogCollationAccept *m_log_collation_accept = nullptr;
-
bool m_disk_full = false;
bool m_disk_low = false;
bool m_partition_full = false;
diff --git a/proxy/logging/LogFile.cc b/proxy/logging/LogFile.cc
index 7d70bbd..3f9a581 100644
--- a/proxy/logging/LogFile.cc
+++ b/proxy/logging/LogFile.cc
@@ -38,7 +38,6 @@
#include "P_EventSystem.h"
#include "I_Machine.h"
-#include "LogSock.h"
#include "tscore/BaseLogFile.h"
#include "LogField.h"
@@ -46,7 +45,6 @@
#include "LogFormat.h"
#include "LogBuffer.h"
#include "LogFile.h"
-#include "LogHost.h"
#include "LogObject.h"
#include "LogUtils.h"
#include "LogConfig.h"
diff --git a/proxy/logging/LogFile.h b/proxy/logging/LogFile.h
index f439cb2..fe3b110 100644
--- a/proxy/logging/LogFile.h
+++ b/proxy/logging/LogFile.h
@@ -29,7 +29,6 @@
#include "tscore/ink_platform.h"
#include "LogBufferSink.h"
-class LogSock;
class LogBuffer;
struct LogBufferHeader;
class LogObject;
diff --git a/proxy/logging/LogFilter.cc b/proxy/logging/LogFilter.cc
index 900268f..8b85394 100644
--- a/proxy/logging/LogFilter.cc
+++ b/proxy/logging/LogFilter.cc
@@ -34,7 +34,6 @@
#include "LogFormat.h"
#include "LogFile.h"
#include "LogBuffer.h"
-#include "LogHost.h"
#include "LogObject.h"
#include "LogConfig.h"
#include "Log.h"
diff --git a/proxy/logging/LogFormat.cc b/proxy/logging/LogFormat.cc
index e4571d5..e87e154 100644
--- a/proxy/logging/LogFormat.cc
+++ b/proxy/logging/LogFormat.cc
@@ -40,7 +40,6 @@
#include "LogField.h"
#include "LogFilter.h"
#include "LogFormat.h"
-#include "LogHost.h"
#include "LogBuffer.h"
#include "LogObject.h"
#include "LogConfig.h"
@@ -201,32 +200,6 @@ LogFormat::LogFormat(const char *name, const char *format_str, unsigned interval
m_format_type = format_str ? LOG_FORMAT_CUSTOM : LOG_FORMAT_TEXT;
}
-//-----------------------------------------------------------------------------
-// This constructor is used only in Log::match_logobject
-//
-// It is awkward because it does not take a format_str but a fieldlist_str
-// and a printf_str. These should be derived from a format_str but a
-// LogBufferHeader does not store the format_str, if it did, we could probably
-// delete this.
-//
-LogFormat::LogFormat(const char *name, const char *fieldlist_str, const char *printf_str, unsigned interval_sec)
- : m_interval_sec(0),
- m_interval_next(0),
- m_agg_marshal_space(nullptr),
- m_valid(false),
- m_name_str(nullptr),
- m_name_id(0),
- m_fieldlist_str(nullptr),
- m_fieldlist_id(0),
- m_field_count(0),
- m_printf_str(nullptr),
- m_aggregate(false),
- m_format_str(nullptr)
-{
- init_variables(name, fieldlist_str, printf_str, interval_sec);
- m_format_type = LOG_FORMAT_CUSTOM;
-}
-
/*-------------------------------------------------------------------------
LogFormat::LogFormat
diff --git a/proxy/logging/LogHost.cc b/proxy/logging/LogHost.cc
deleted file mode 100644
index 649682b..0000000
--- a/proxy/logging/LogHost.cc
+++ /dev/null
@@ -1,466 +0,0 @@
-/** @file
-
- A brief file description
-
- @section license License
-
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you 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.
- */
-
-/***************************************************************************
- LogHost.cc
-
-
- ***************************************************************************/
-#include "tscore/ink_platform.h"
-
-#include "LogUtils.h"
-#include "LogSock.h"
-#include "LogField.h"
-#include "LogFile.h"
-#include "LogFormat.h"
-#include "LogBuffer.h"
-#include "LogHost.h"
-#include "LogObject.h"
-#include "LogConfig.h"
-#include "Log.h"
-
-#include "LogCollationClientSM.h"
-
-#define PING true
-#define NOPING false
-
-static Ptr<LogFile>
-make_orphan_logfile(LogHost *lh, const char *filename)
-{
- const char *ext = "orphan";
- unsigned name_len = (unsigned)(strlen(filename) + strlen(lh->name()) + strlen(ext) + 16);
- char *name_buf = (char *)ats_malloc(name_len);
-
- // NT: replace ':'s with '-'s. This change is necessary because
- // NT doesn't like filenames with ':'s in them. ^_^
- snprintf(name_buf, name_len, "%s%s%s-%u.%s", filename, LOGFILE_SEPARATOR_STRING, lh->name(), lh->port(), ext);
-
- // XXX should check for conflicts with orphan filename
-
- Ptr<LogFile> orphan(new LogFile(name_buf, nullptr, LOG_FILE_ASCII, lh->signature()));
-
- ats_free(name_buf);
- return orphan;
-}
-
-/*-------------------------------------------------------------------------
- LogHost
- -------------------------------------------------------------------------*/
-
-LogHost::LogHost(const char *object_filename, uint64_t object_signature)
- : m_object_filename(ats_strdup(object_filename)),
- m_object_signature(object_signature),
- m_port(0),
- m_name(nullptr),
- m_sock(nullptr),
- m_sock_fd(-1),
- m_connected(false),
- m_orphan_file(nullptr),
- m_log_collation_client_sm(nullptr)
-{
- ink_zero(m_ip);
- ink_zero(m_ipstr);
-}
-
-LogHost::LogHost(const LogHost &rhs)
- : m_object_filename(ats_strdup(rhs.m_object_filename)),
- m_object_signature(rhs.m_object_signature),
- m_ip(rhs.m_ip),
- m_port(0),
- m_name(ats_strdup(rhs.m_name)),
- m_sock(nullptr),
- m_sock_fd(-1),
- m_connected(false),
- m_orphan_file(nullptr),
- m_log_collation_client_sm(nullptr)
-{
- memcpy(m_ipstr, rhs.m_ipstr, sizeof(m_ipstr));
- m_orphan_file = make_orphan_logfile(this, m_object_filename);
-}
-
-LogHost::~LogHost()
-{
- clear();
- ats_free(m_object_filename);
-}
-
-//
-// There are 3 ways to establish a LogHost:
-// - by "hostname:port" or IP:port", where IP is a string of the
-// form "xxx.xxx.xxx.xxx".
-// - by specifying a hostname and a port (as separate arguments).
-// - by specifying an ip and a port (as separate arguments).
-//
-bool
-LogHost::set_name_port(const char *hostname, unsigned int pt)
-{
- if (!hostname || hostname[0] == 0) {
- Note("Cannot establish LogHost with NULL hostname");
- return false;
- }
-
- clear(); // remove all previous state for this LogHost
-
- m_name = ats_strdup(hostname);
- m_port = pt;
-
- Debug("log-host", "LogHost established as %s:%u", this->name(), this->port());
-
- m_orphan_file = make_orphan_logfile(this, m_object_filename);
- return true;
-}
-
-bool
-LogHost::set_ipstr_port(const char *ipstr, unsigned int pt)
-{
- if (!ipstr || ipstr[0] == 0) {
- Note("Cannot establish LogHost with NULL ipstr");
- return false;
- }
-
- clear(); // remove all previous state for this LogHost
-
- if (0 != m_ip.load(ipstr)) {
- Note("Log host failed to parse IP address %s", ipstr);
- }
-
- m_port = pt;
- ink_strlcpy(m_ipstr, ipstr, sizeof(m_ipstr));
- m_name = ats_strdup(ipstr);
-
- Debug("log-host", "LogHost established as %s:%u", name(), pt);
-
- m_orphan_file = make_orphan_logfile(this, m_object_filename);
- return true;
-}
-
-bool
-LogHost::set_name_or_ipstr(const char *name_or_ip)
-{
- if (name_or_ip && name_or_ip[0] != '\0') {
- std::string_view addr, port;
- if (ats_ip_parse(std::string_view(name_or_ip), &addr, &port) == 0) {
- uint16_t p = port.empty() ? Log::config->collation_port : atoi(port.data());
- char *n = const_cast<char *>(addr.data());
- // Force termination. We know we can do this because the address
- // string is followed by either a nul or a colon.
- n[addr.size()] = 0;
- if (AF_UNSPEC == ats_ip_check_characters(addr)) {
- return set_name_port(n, p);
- } else {
- return set_ipstr_port(n, p);
- }
- }
- }
-
- return false;
-}
-
-bool
-LogHost::connected(bool ping)
-{
- if (m_connected && m_sock && m_sock_fd >= 0) {
- if (m_sock->is_connected(m_sock_fd, ping)) {
- return true;
- }
- }
- return false;
-}
-
-bool
-LogHost::connect()
-{
- if (!m_ip.isValid()) {
- Note("Cannot connect to LogHost; host IP has not been established");
- return false;
- }
-
- if (connected(PING)) {
- return true;
- }
-
- IpEndpoint target;
- ip_port_text_buffer ipb;
- target.assign(m_ip, htons(m_port));
-
- if (is_debug_tag_set("log-host")) {
- Debug("log-host", "Connecting to LogHost %s", ats_ip_nptop(&target, ipb, sizeof ipb));
- }
-
- disconnect(); // make sure connection members are initialized
-
- if (m_sock == nullptr) {
- m_sock = new LogSock();
- ink_assert(m_sock != nullptr);
- }
- m_sock_fd = m_sock->connect(&target.sa);
- if (m_sock_fd < 0) {
- Note("Connection to LogHost %s failed", ats_ip_nptop(&target, ipb, sizeof ipb));
- return false;
- }
- m_connected = true;
-
- if (!authenticated()) {
- Note("Authentication to LogHost %s failed", ats_ip_nptop(&target, ipb, sizeof ipb));
- disconnect();
- return false;
- }
-
- return true;
-}
-
-void
-LogHost::disconnect()
-{
- if (m_sock && m_sock_fd >= 0) {
- m_sock->close(m_sock_fd);
- m_sock_fd = -1;
- }
- if (m_log_collation_client_sm) {
- delete m_log_collation_client_sm;
- m_log_collation_client_sm = nullptr;
- }
- m_connected = false;
-}
-
-//
-// preprocess the given buffer data before sent to target host
-// and try to delete it when its reference become zero.
-//
-bool
-LogHost::preproc_and_try_delete(LogBuffer *&lb)
-{
- if (lb == nullptr) {
- Note("Cannot write LogBuffer to LogHost %s; LogBuffer is NULL", name());
- return false;
- }
-
- LogBufferHeader *buffer_header = lb->header();
- if (buffer_header == nullptr) {
- Note("Cannot write LogBuffer to LogHost %s; LogBufferHeader is NULL", name());
- goto done;
- }
-
- if (buffer_header->entry_count == 0) {
- // no bytes to write
- goto done;
- }
-
- // create a new collation client if necessary
- if (m_log_collation_client_sm == nullptr) {
- m_log_collation_client_sm = new LogCollationClientSM(this);
- ink_assert(m_log_collation_client_sm != nullptr);
- }
-
- // send log_buffer
- if (m_log_collation_client_sm->send(lb) <= 0) {
- goto done;
- }
-
- return true;
-
-done:
- LogBuffer::destroy(lb);
- return false;
-}
-
-//
-// write the given buffer data to orphan file and
-// try to delete it when its reference become zero.
-//
-void
-LogHost::orphan_write_and_try_delete(LogBuffer *&lb)
-{
- RecIncrRawStat(log_rsb, this_thread()->mutex->thread_holding, log_stat_num_lost_before_sent_to_network_stat,
- lb->header()->entry_count);
-
- RecIncrRawStat(log_rsb, this_thread()->mutex->thread_holding, log_stat_bytes_lost_before_sent_to_network_stat,
- lb->header()->byte_count);
-
- if (!Log::config->logging_space_exhausted) {
- Debug("log-host", "Sending LogBuffer to orphan file %s", m_orphan_file->get_name());
- m_orphan_file->preproc_and_try_delete(lb);
- } else {
- Debug("log-host", "logging space exhausted, failed to write orphan file, drop(%" PRIu32 ") bytes", lb->header()->byte_count);
- }
- LogBuffer::destroy(lb);
-}
-
-void
-LogHost::display(FILE *fd)
-{
- fprintf(fd, "LogHost: %s:%u, %s\n", name(), port(), (connected(NOPING)) ? "connected" : "not connected");
-
- LogHost *host = this;
- while (host->failover_link.next != nullptr) {
- fprintf(fd, "Failover: %s:%u, %s\n", host->name(), host->port(), (host->connected(NOPING)) ? "connected" : "not connected");
- host = host->failover_link.next;
- }
-}
-
-void
-LogHost::clear()
-{
- // close an established connection and clear the state of this host
-
- disconnect();
-
- ats_free(m_name);
- delete m_sock;
- m_orphan_file.clear();
-
- ink_zero(m_ip);
- m_port = 0;
- ink_zero(m_ipstr);
- m_name = nullptr;
- m_sock = nullptr;
- m_sock_fd = -1;
- m_connected = false;
-}
-
-bool
-LogHost::authenticated()
-{
- if (!connected(NOPING)) {
- Note("Cannot authenticate LogHost %s; not connected", name());
- return false;
- }
-
- Debug("log-host", "Authenticating LogHost %s ...", name());
- char *auth_key = Log::config->collation_secret;
- unsigned auth_key_len = (unsigned)::strlen(auth_key) + 1; // incl null
- int bytes = m_sock->write(m_sock_fd, auth_key, auth_key_len);
- if ((unsigned)bytes != auth_key_len) {
- Debug("log-host", "... bad write on authenticate");
- return false;
- }
-
- Debug("log-host", "... authenticated");
- return true;
-}
-
-/*-------------------------------------------------------------------------
- LogHostList
- -------------------------------------------------------------------------*/
-
-LogHostList::LogHostList() {}
-
-LogHostList::~LogHostList()
-{
- clear();
-}
-
-void
-LogHostList::add(LogHost *object, bool copy)
-{
- ink_assert(object != nullptr);
- if (copy) {
- m_host_list.enqueue(new LogHost(*object));
- } else {
- m_host_list.enqueue(object);
- }
-}
-
-unsigned
-LogHostList::count()
-{
- unsigned cnt = 0;
- for (LogHost *host = first(); host; host = next(host)) {
- cnt++;
- }
- return cnt;
-}
-
-void
-LogHostList::clear()
-{
- LogHost *host;
- while ((host = m_host_list.dequeue())) {
- delete host;
- }
-}
-
-int
-LogHostList::preproc_and_try_delete(LogBuffer *lb)
-{
- int success = false;
- unsigned nr;
- bool need_orphan = true;
- LogHost *available_host = nullptr;
-
- ink_release_assert(lb->m_references == 0);
-
- nr = count();
- ink_atomic_increment(&lb->m_references, 1);
-
- for (LogHost *host = first(); host && nr; host = next(host)) {
- LogHost *lh = host;
- available_host = lh;
-
- do {
- ink_atomic_increment(&lb->m_references, 1);
- success = lh->preproc_and_try_delete(lb);
- need_orphan = need_orphan && (success == false);
- } while (lb && (success == false) && (lh = lh->failover_link.next));
-
- nr--;
- }
-
- if (lb != nullptr && need_orphan && available_host) {
- ink_atomic_increment(&lb->m_references, 1);
- available_host->orphan_write_and_try_delete(lb);
- }
-
- if (lb != nullptr) {
- LogBuffer::destroy(lb);
- }
- return 0;
-}
-
-void
-LogHostList::display(FILE *fd)
-{
- for (LogHost *host = first(); host; host = next(host)) {
- host->display(fd);
- }
-}
-
-bool
-LogHostList::operator==(LogHostList &rhs)
-{
- LogHost *host;
- for (host = first(); host; host = next(host)) {
- LogHost *rhs_host;
- for (rhs_host = rhs.first(); rhs_host; rhs_host = next(host)) {
- if ((host->port() == rhs_host->port() && host->ip_addr().isValid() && host->ip_addr() == rhs_host->ip_addr()) ||
- (host->name() && rhs_host->name() && (strcmp(host->name(), rhs_host->name()) == 0)) ||
- (*(host->ipstr()) && *(rhs_host->ipstr()) && (strcmp(host->ipstr(), rhs_host->ipstr()) == 0))) {
- break;
- }
- }
- if (rhs_host == nullptr) {
- return false;
- }
- }
- return true;
-}
diff --git a/proxy/logging/LogHost.h b/proxy/logging/LogHost.h
deleted file mode 100644
index cb62e10..0000000
--- a/proxy/logging/LogHost.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/** @file
-
- A brief file description
-
- @section license License
-
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you 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.
- */
-#pragma once
-
-class LogSock;
-class LogBuffer;
-class LogCollationClientSM;
-
-#include "LogBufferSink.h"
-
-/*-------------------------------------------------------------------------
- LogHost
- This object corresponds to a named log collation host.
- -------------------------------------------------------------------------*/
-class LogHost
-{
- friend class LogCollationClientSM;
-
-public:
- LogHost(const char *object_filename, uint64_t object_signature);
- LogHost(const LogHost &);
- ~LogHost();
-
- bool set_name_or_ipstr(const char *name_or_ipstr);
- bool set_ipstr_port(const char *ipstr, unsigned int port);
- bool set_name_port(const char *hostname, unsigned int port);
-
- bool connected(bool ping);
- bool connect();
- void disconnect();
- //
- // preprocess the given buffer data before sent to target host
- // and try to delete it when its reference become zero.
- //
- bool preproc_and_try_delete(LogBuffer *&lb);
-
- //
- // write the given buffer data to orphan file and
- // try to delete it when its reference become zero.
- //
- void orphan_write_and_try_delete(LogBuffer *&lb);
-
- const char *
- name() const
- {
- return m_name ? m_name : "UNKNOWN";
- }
-
- uint64_t
- signature() const
- {
- return m_object_signature;
- }
-
- IpAddr const &
- ip_addr() const
- {
- return m_ip;
- }
-
- in_port_t
- port() const
- {
- return m_port;
- }
-
- const char *
- ipstr() const
- {
- return m_ipstr;
- }
-
- void display(FILE *fd = stdout);
-
- LogFile *
- get_orphan_logfile() const
- {
- return m_orphan_file.get();
- }
-
-private:
- void clear();
- bool authenticated();
-
-private:
- char *m_object_filename;
- uint64_t m_object_signature;
- IpAddr m_ip; // IP address, network order.
- in_port_t m_port; // IP port, host order.
- ip_text_buffer m_ipstr;
- char *m_name;
- LogSock *m_sock;
- int m_sock_fd;
- bool m_connected;
- Ptr<LogFile> m_orphan_file;
- LogCollationClientSM *m_log_collation_client_sm;
-
-public:
- LINK(LogHost, link);
- SLINK(LogHost, failover_link);
-
- // noncopyable
- LogHost &operator=(const LogHost &) = delete;
-
-private:
- // -- member functions not allowed --
- LogHost();
-};
-
-/*-------------------------------------------------------------------------
- LogHostList
- -------------------------------------------------------------------------*/
-class LogHostList : public LogBufferSink
-{
-public:
- LogHostList();
- ~LogHostList() override;
-
- void add(LogHost *host, bool copy = true);
- unsigned count();
- void clear();
- int preproc_and_try_delete(LogBuffer *lb) override;
-
- LogHost *
- first()
- {
- return m_host_list.head;
- }
-
- LogHost *
- next(LogHost *here)
- {
- return (here->link).next;
- }
-
- void display(FILE *fd = stdout);
- bool operator==(LogHostList &rhs);
-
- // -- member functions not allowed --
- LogHostList(const LogHostList &) = delete;
- LogHostList &operator=(const LogHostList &) = delete;
-
-private:
- Queue<LogHost> m_host_list;
-};
diff --git a/proxy/logging/LogObject.cc b/proxy/logging/LogObject.cc
index 336815c..cb91f5b 100644
--- a/proxy/logging/LogObject.cc
+++ b/proxy/logging/LogObject.cc
@@ -91,8 +91,7 @@ LogBufferManager::preproc_buffers(LogBufferSink *sink)
LogObject::LogObject(const LogFormat *format, const char *log_dir, const char *basename, LogFileFormat file_format,
const char *header, Log::RollingEnabledValues rolling_enabled, int flush_threads, int rolling_interval_sec,
int rolling_offset_hr, int rolling_size_mb, bool auto_created)
- : m_auto_created(auto_created),
- m_alt_filename(nullptr),
+ : m_alt_filename(nullptr),
m_flags(0),
m_signature(0),
m_flush_threads(flush_threads),
@@ -117,9 +116,6 @@ LogObject::LogObject(const LogFormat *format, const char *log_dir, const char *b
// compute_signature is a static function
m_signature = compute_signature(m_format, m_basename, m_flags);
- // by default, create a LogFile for this object, if a loghost is
- // later specified, then we will delete the LogFile object
- //
m_logFile = new LogFile(m_filename, header, file_format, m_signature, Log::config->ascii_buffer_size, Log::config->max_line_size);
LogBuffer *b = new LogBuffer(this, Log::config->log_buffer_size);
@@ -133,7 +129,6 @@ LogObject::LogObject(const LogFormat *format, const char *log_dir, const char *b
LogObject::LogObject(LogObject &rhs)
: RefCountObj(rhs),
- m_auto_created(rhs.m_auto_created),
m_basename(ats_strdup(rhs.m_basename)),
m_filename(ats_strdup(rhs.m_filename)),
m_alt_filename(ats_strdup(rhs.m_alt_filename)),
@@ -162,11 +157,6 @@ LogObject::LogObject(LogObject &rhs)
add_filter(filter);
}
- LogHost *host;
- for (host = rhs.m_host_list.first(); host; host = rhs.m_host_list.next(host)) {
- add_loghost(host);
- }
-
// copy gets a fresh log buffer
//
LogBuffer *b = new LogBuffer(this, Log::config->log_buffer_size);
@@ -184,13 +174,6 @@ LogObject::~LogObject()
Debug("log-config", "entering LogObject destructor, this=%p", this);
preproc_buffers();
-
- // here we need to free LogHost if it is remote logging.
- if (is_collation_client()) {
- if (m_host_list.count()) {
- m_host_list.clear();
- }
- }
ats_free(m_basename);
ats_free(m_filename);
ats_free(m_alt_filename);
@@ -302,23 +285,6 @@ LogObject::set_filter_list(const LogFilterList &list, bool copy)
m_filter_list.set_conjunction(list.does_conjunction());
}
-void
-LogObject::add_loghost(LogHost *host, bool copy)
-{
- if (!host) {
- return;
- }
- m_host_list.add(host, copy);
-
- // A LogObject either writes to a file, or sends to a collation host, but
- // not both. By default, it writes to a file. If a LogHost is specified,
- // then clear the intelligent Ptr containing LogFile.
- //
- m_logFile.clear();
-
- Debug("log", "added log host %p to object %p for target %s:%d", host, this, host->name(), host->port());
-}
-
// we conpute the object signature from the fieldlist_str and the printf_str
// of the LogFormat rather than from the format_str because the format_str
// is not part of a LogBuffer header
@@ -355,11 +321,8 @@ LogObject::display(FILE *fd)
"flags = %u\n"
"signature = %" PRIu64 "\n",
this, m_format->name(), m_format, m_basename, m_flags, m_signature);
- if (is_collation_client()) {
- m_host_list.display(fd);
- } else {
- fprintf(fd, "full path = %s\n", get_full_filename());
- }
+
+ fprintf(fd, "full path = %s\n", get_full_filename());
m_filter_list.display(fd);
fprintf(fd, "++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
}
@@ -785,15 +748,8 @@ LogObject::_roll_files(long last_roll_time, long time_now)
if (!writes_to_pipe()) {
num_rolled += m_logFile->roll(last_roll_time, time_now);
}
- } else {
- LogHost *host;
- for (host = m_host_list.first(); host; host = m_host_list.next(host)) {
- LogFile *orphan_logfile = host->get_orphan_logfile();
- if (orphan_logfile) {
- num_rolled += orphan_logfile->roll(last_roll_time, time_now);
- }
- }
}
+
m_last_roll_time = time_now;
return num_rolled;
}
@@ -895,14 +851,10 @@ LogObjectManager::_manage_object(LogObject *log_object, bool is_api_object, int
ACQUIRE_API_MUTEX("A LogObjectManager::_manage_object");
}
- bool col_client = log_object->is_collation_client();
- int retVal = _solve_internal_filename_conflicts(log_object, maxConflicts);
+ int retVal = _solve_internal_filename_conflicts(log_object, maxConflicts);
if (retVal == NO_FILENAME_CONFLICTS) {
- // check for external conflicts only if the object is not a collation
- // client
- //
- if (col_client || (retVal = _solve_filename_conflicts(log_object, maxConflicts), retVal == NO_FILENAME_CONFLICTS)) {
+ if (retVal = _solve_filename_conflicts(log_object, maxConflicts), retVal == NO_FILENAME_CONFLICTS) {
// do filesystem checks
//
{
@@ -920,16 +872,15 @@ LogObjectManager::_manage_object(LogObject *log_object, bool is_api_object, int
Debug("log",
"LogObjectManager managing object %s (%s) "
"[signature = %" PRIu64 ", address = %p]",
- log_object->get_base_filename(), col_client ? "collation client" : log_object->get_full_filename(),
- log_object->get_signature(), log_object);
+ log_object->get_base_filename(), log_object->get_full_filename(), log_object->get_signature(), log_object);
if (log_object->has_alternate_name()) {
- Warning("The full path for the (%s) LogObject %s "
+ Warning("The full path for the (%s) LogObject "
"with signature %" PRIu64 " "
"has been set to %s rather than %s because the latter "
"is being used by another LogObject",
- log_object->receives_remote_data() ? "remote" : "local", log_object->get_base_filename(),
- log_object->get_signature(), log_object->get_full_filename(), log_object->get_original_filename());
+ log_object->get_base_filename(), log_object->get_signature(), log_object->get_full_filename(),
+ log_object->get_original_filename());
}
}
}
@@ -1063,14 +1014,12 @@ bool
LogObjectManager::_has_internal_filename_conflict(const char *filename, LogObjectList &objects)
{
for (auto &object : objects) {
- if (!object->is_collation_client()) {
- // an internal conflict exists if two objects request the
- // same filename, regardless of the object signatures, since
- // two objects writing to the same file would produce a
- // log with duplicate entries and non monotonic timestamps
- if (strcmp(object->get_full_filename(), filename) == 0) {
- return true;
- }
+ // an internal conflict exists if two objects request the
+ // same filename, regardless of the object signatures, since
+ // two objects writing to the same file would produce a
+ // log with duplicate entries and non monotonic timestamps
+ if (strcmp(object->get_full_filename(), filename) == 0) {
+ return true;
}
}
return false;
@@ -1189,7 +1138,7 @@ LogObjectManager::open_local_pipes()
//
for (unsigned i = 0; i < this->_objects.size(); i++) {
LogObject *obj = _objects[i];
- if (obj->writes_to_pipe() && !obj->is_collation_client()) {
+ if (obj->writes_to_pipe()) {
obj->m_logFile->open_file();
}
}
@@ -1299,19 +1248,6 @@ LogObjectManager::find_by_format_name(const char *name) const
return nullptr;
}
-unsigned
-LogObjectManager::get_num_collation_clients() const
-{
- unsigned coll_clients = 0;
-
- for (auto _object : this->_objects) {
- if (_object && _object->is_collation_client()) {
- ++coll_clients;
- }
- }
- return coll_clients;
-}
-
int
LogObjectManager::log(LogAccess *lad)
{
@@ -1319,15 +1255,6 @@ LogObjectManager::log(LogAccess *lad)
ProxyMutex *mutex = this_thread()->mutex.get();
for (unsigned i = 0; i < this->_objects.size(); i++) {
- //
- // Auto created LogObject is only applied to LogBuffer
- // data received from network in collation host. It should
- // be ignored here.
- //
- if (_objects[i]->m_auto_created) {
- continue;
- }
-
ret |= _objects[i]->log(lad);
}
diff --git a/proxy/logging/LogObject.h b/proxy/logging/LogObject.h
index dff5853..73bc329 100644
--- a/proxy/logging/LogObject.h
+++ b/proxy/logging/LogObject.h
@@ -28,7 +28,6 @@
#include "LogFile.h"
#include "LogFormat.h"
#include "LogFilter.h"
-#include "LogHost.h"
#include "LogBuffer.h"
#include "LogAccess.h"
#include "LogFilter.h"
@@ -87,14 +86,11 @@ class LogObject : public RefCountObj
public:
enum LogObjectFlags {
BINARY = 1,
- REMOTE_DATA = 2,
WRITES_TO_PIPE = 4,
LOG_OBJECT_FMT_TIMESTAMP = 8, // always format a timestamp into each log line (for raw text logs)
};
// BINARY: log is written in binary format (rather than ascii)
- // REMOTE_DATA: object receives data from remote collation clients, so
- // it should not be destroyed during a reconfiguration
// WRITES_TO_PIPE: object writes to a named pipe rather than to a file
LogObject(const LogFormat *format, const char *log_dir, const char *basename, LogFileFormat file_format, const char *header,
@@ -105,14 +101,8 @@ public:
void add_filter(LogFilter *filter, bool copy = true);
void set_filter_list(const LogFilterList &list, bool copy = true);
- void add_loghost(LogHost *host, bool copy = true);
inline void
- set_remote_flag()
- {
- m_flags |= REMOTE_DATA;
- };
- inline void
set_fmt_timestamps()
{
m_flags |= LOG_OBJECT_FMT_TIMESTAMP;
@@ -153,11 +143,8 @@ public:
idx = m_buffer_manager_idx++ % m_flush_threads;
}
- if (m_logFile) {
- nfb = m_buffer_manager[idx].preproc_buffers(m_logFile.get());
- } else {
- nfb = m_buffer_manager[idx].preproc_buffers(&m_host_list);
- }
+ nfb = m_buffer_manager[idx].preproc_buffers(m_logFile.get());
+
return nfb;
}
@@ -227,16 +214,6 @@ public:
}
inline bool
- is_collation_client() const
- {
- return (m_logFile ? false : true);
- }
- inline bool
- receives_remote_data() const
- {
- return (m_flags & REMOTE_DATA) ? true : false;
- }
- inline bool
writes_to_pipe() const
{
return (m_flags & WRITES_TO_PIPE) ? true : false;
@@ -276,11 +253,9 @@ public:
bool operator==(LogObject &rhs);
public:
- bool m_auto_created;
LogFormat *m_format;
Ptr<LogFile> m_logFile;
LogFilterList m_filter_list;
- LogHostList m_host_list;
private:
char *m_basename; // the name of the file associated
@@ -426,41 +401,19 @@ public:
{
return _objects.size();
}
- unsigned get_num_collation_clients() const;
};
inline bool
LogObject::operator==(LogObject &old)
{
- if (!receives_remote_data() && !old.receives_remote_data()) {
- return (get_signature() == old.get_signature() &&
- (is_collation_client() && old.is_collation_client() ?
- m_host_list == old.m_host_list :
- m_logFile && old.m_logFile && strcmp(m_logFile->get_name(), old.m_logFile->get_name()) == 0) &&
- (m_filter_list == old.m_filter_list) &&
- (m_rolling_interval_sec == old.m_rolling_interval_sec && m_rolling_offset_hr == old.m_rolling_offset_hr &&
- m_rolling_size_mb == old.m_rolling_size_mb));
- }
- return false;
+ return (get_signature() == old.get_signature() && m_logFile && old.m_logFile &&
+ strcmp(m_logFile->get_name(), old.m_logFile->get_name()) == 0 && (m_filter_list == old.m_filter_list) &&
+ (m_rolling_interval_sec == old.m_rolling_interval_sec && m_rolling_offset_hr == old.m_rolling_offset_hr &&
+ m_rolling_size_mb == old.m_rolling_size_mb));
}
inline off_t
LogObject::get_file_size_bytes()
{
- if (m_logFile) {
- return m_logFile->get_size_bytes();
- } else {
- off_t max_size = 0;
- LogHost *host;
- for (host = m_host_list.first(); host; host = m_host_list.next(host)) {
- LogFile *orphan_logfile = host->get_orphan_logfile();
- if (orphan_logfile) {
- off_t s = orphan_logfile->get_size_bytes();
- if (s > max_size) {
- max_size = s;
- }
- }
- }
- return max_size;
- }
+ return m_logFile->get_size_bytes();
}
diff --git a/proxy/logging/LogSock.cc b/proxy/logging/LogSock.cc
deleted file mode 100644
index bf9a9cd..0000000
--- a/proxy/logging/LogSock.cc
+++ /dev/null
@@ -1,734 +0,0 @@
-/** @file
-
- A brief file description
-
- @section license License
-
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you 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.
- */
-
-#include "tscore/ink_inet.h"
-#include "tscore/ink_string.h"
-#include "P_EventSystem.h"
-
-#include "LogSock.h"
-#include "LogUtils.h"
-
-static const int LS_SOCKTYPE = SOCK_STREAM;
-static const int LS_PROTOCOL = 0;
-
-/**
- LogSock
-
- The constructor establishes the connection table (ct) and initializes the
- first entry of the table (index 0) to be the port on which new
- connections are accepted.
-*/
-LogSock::LogSock(int max_connects) : ct((ConnectTable *)nullptr), m_max_connections(max_connects + 1)
-{
- ink_assert(m_max_connections > 0);
-
- //
- // allocate space for the connection table.
- //
- ct = new ConnectTable[m_max_connections];
- ink_assert(ct != nullptr);
- for (int i = 0; i < m_max_connections; ++i) {
- init_cid(i, nullptr, 0, -1, LogSock::LS_STATE_UNUSED);
- }
-
- Debug("log-sock", "LogSocket established");
-}
-
-/**
- LogSock::~LogSock
-
- Shut down all connections and delete memory for the tables.
-*/
-LogSock::~LogSock()
-{
- Debug("log-sock", "shutting down LogSocket on [%s:%d]", ct[0].host, ct[0].port);
-
- this->close(); // close all connections
- this->close(0); // close accept socket
- delete[] ct; // delete the connection table
-}
-
-/**
- LogSock::listen
-
- This routine sets up the LogSock to begin accepting connections on the
- given @param accept port. A maximum number of connections is also specified,
- which is used to establish the size of the listen queue.
-
- @Return zero if all goes well, -1 otherwise.
-*/
-int
-LogSock::listen(int accept_port, int family)
-{
- IpEndpoint bind_addr;
- char this_host[MAXDNAME];
- int ret;
- ats_scoped_fd accept_sd;
-
- Debug("log-sock", "Listening ...");
-
- // Set up local address for bind.
- bind_addr.setToAnyAddr(family);
- if (!bind_addr.isValid()) {
- Warning("Could not set up socket - invalid address family %d", family);
- return -1;
- }
- bind_addr.port() = htons(accept_port);
-
- int size = ats_ip_size(&bind_addr.sa);
-
- //
- // create the socket for accepting new connections
- //
- accept_sd = ::socket(family, LS_SOCKTYPE, LS_PROTOCOL);
- if (accept_sd < 0) {
- Warning("Could not create a socket for family %d: %s", family, strerror(errno));
- return -1;
- }
- //
- // Set socket options (NO_LINGER, TCP_NODELAY, SO_REUSEADDR)
- //
- // CLOSE ON EXEC
- if ((ret = safe_fcntl(accept_sd, F_SETFD, FD_CLOEXEC)) < 0) {
- Warning("Could not set option CLOSE ON EXEC on socket (%d): %s", ret, strerror(errno));
- return -1;
- }
- // NO_LINGER
- struct linger l;
- l.l_onoff = 0;
- l.l_linger = 0;
- if ((ret = safe_setsockopt(accept_sd, SOL_SOCKET, SO_LINGER, (char *)&l, sizeof(l))) < 0) {
- Warning("Could not set option NO_LINGER on socket (%d): %s", ret, strerror(errno));
- return -1;
- }
- // REUSEADDR
- if ((ret = safe_setsockopt(accept_sd, SOL_SOCKET, SO_REUSEADDR, SOCKOPT_ON, sizeof(int))) < 0) {
- Warning("Could not set option REUSEADDR on socket (%d): %s", ret, strerror(errno));
- return -1;
- }
-
- // Bind to local address.
- if ((ret = safe_bind(accept_sd, &bind_addr.sa, size)) < 0) {
- Warning("Could not bind port: %s", strerror(errno));
- return -1;
- }
-
- if ((ret = safe_setsockopt(accept_sd, IPPROTO_TCP, TCP_NODELAY, SOCKOPT_ON, sizeof(int))) < 0) {
- Warning("Could not set option TCP_NODELAY on socket (%d): %s", ret, strerror(errno));
- return -1;
- }
-
- if ((ret = safe_setsockopt(accept_sd, SOL_SOCKET, SO_KEEPALIVE, SOCKOPT_ON, sizeof(int))) < 0) {
- Warning("Could not set option SO_KEEPALIVE on socket (%d): %s", ret, strerror(errno));
- return -1;
- }
-
- //
- // if the accept_port argument was zero, then the system just picked
- // one for us, so we need to find out what it was and record it in the
- // connection table correctly.
- //
- if (accept_port == 0) {
- ret = safe_getsockname(accept_sd, &bind_addr.sa, &size);
- if (ret == 0) {
- accept_port = ntohs(bind_addr.port());
- }
- }
- //
- // establish the listen queue for incomming connections
- //
- if ((ret = safe_listen(accept_sd, m_max_connections)) < 0) {
- Warning("Could not establish listen queue: %s", strerror(errno));
- return -1;
- }
- //
- // initialize the first entry of the table for accepting incoming
- // connection requests.
- //
- if (gethostname(&this_host[0], MAXDNAME) != 0) {
- snprintf(this_host, sizeof(this_host), "unknown-host");
- }
- init_cid(0, this_host, accept_port, accept_sd, LogSock::LS_STATE_INCOMING);
-
- m_accept_connections = true;
- Debug("log-sock", "LogSocket established on [%s:%d]", this_host, accept_port);
-
- accept_sd.release();
- return 0;
-}
-
-/**
- LogSock::accept
-
- Accept a new connection. This is a blocking operation, so you may want
- to use one of the non-blocking pending_XXX calls to see if there is a
- connection first.
- @return This returns the table index for the new connection.
-*/
-int
-LogSock::accept()
-{
- int cid, connect_sd;
- IpEndpoint connect_addr;
- socklen_t size = sizeof(connect_addr);
- in_port_t connect_port;
-
- if (!m_accept_connections || ct[0].sd < 0) {
- return LogSock::LS_ERROR_NO_CONNECTION;
- }
-
- cid = new_cid();
- if (cid < 0) {
- return LogSock::LS_ERROR_CONNECT_TABLE_FULL;
- }
-
- Debug("log-sock", "waiting to accept a new connection");
-
- connect_sd = ::accept(ct[0].sd, &connect_addr.sa, &size);
- if (connect_sd < 0) {
- return LogSock::LS_ERROR_ACCEPT;
- }
- connect_port = ntohs(connect_addr.port());
-
- init_cid(cid, nullptr, connect_port, connect_sd, LogSock::LS_STATE_INCOMING);
-
- Debug("log-sock", "new connection accepted, cid = %d, port = %d", cid, connect_port);
-
- return cid;
-}
-
-/**
- LogSock::connect
-
- Establish a new connection to another machine [host:port], and place this
- information into the connection and poll tables.
-*/
-int
-LogSock::connect(sockaddr const *ip)
-{
- int cid, ret;
- ats_scoped_fd connect_sd;
- uint16_t port;
-
- if (!ats_is_ip(ip)) {
- Note("Invalid host IP or port number for connection");
- return LogSock::LS_ERROR_NO_SUCH_HOST;
- }
- port = ntohs(ats_ip_port_cast(ip));
-
- ip_port_text_buffer ipstr;
- Debug("log-sock", "connecting to [%s:%d]", ats_ip_nptop(ip, ipstr, sizeof(ipstr)), port);
-
- // get an index into the connection table
- cid = new_cid();
- if (cid < 0) {
- Note("No more connections allowed for this socket");
- return LogSock::LS_ERROR_CONNECT_TABLE_FULL;
- }
- // initialize a new socket descriptor
- connect_sd = ::socket(ip->sa_family, LS_SOCKTYPE, LS_PROTOCOL);
- if (connect_sd < 0) {
- Note("Error initializing socket for connection: %d", static_cast<int>(connect_sd));
- return LogSock::LS_ERROR_SOCKET;
- }
-
- if ((ret = safe_setsockopt(connect_sd, IPPROTO_TCP, TCP_NODELAY, SOCKOPT_ON, sizeof(int))) < 0) {
- Note("Could not set option TCP_NODELAY on socket (%d): %s", ret, strerror(errno));
- return -1;
- }
-
- if ((ret = safe_setsockopt(connect_sd, SOL_SOCKET, SO_KEEPALIVE, SOCKOPT_ON, sizeof(int))) < 0) {
- Note("Could not set option SO_KEEPALIVE on socket (%d): %s", ret, strerror(errno));
- return -1;
- }
-
- // attempt to connect
- if (::connect(connect_sd, ip, ats_ip_size(ip)) != 0) {
- Note("Failure to connect");
- return LogSock::LS_ERROR_CONNECT;
- }
-
- init_cid(cid, ipstr, port, connect_sd, LogSock::LS_STATE_OUTGOING);
-
- Debug("log-sock", "outgoing connection to [%s:%d] established, fd = %d", ipstr, port, cid);
-
- connect_sd.release();
- return cid;
-}
-
-/**
- LogSock::pending_data
-
- This private routine checks for incoming data on some of the socket
- descriptors.
- @return Returns true if there is something incoming, with *cid
- set to the index corresponding to the incoming socket.
-*/
-bool
-LogSock::pending_data(int *cid, int timeout_msec, bool include_connects)
-{
- int ret, n_poll_fds, i;
- static struct pollfd fds[LS_CONST_MAX_CONNS];
- int fd_to_cid[LS_CONST_MAX_CONNS];
-
- ink_assert(m_max_connections <= (LS_CONST_MAX_CONNS + 1));
- ink_assert(cid != nullptr);
- ink_assert(timeout_msec >= 0);
-
- //
- // we'll use the poll() routine, which replaces the select routine
- // to support a larger number of socket descriptors. to use poll,
- // we need to set-up a pollfd array for the socket descriptors
- // that will be polled.
- //
-
- if (*cid >= 0) { // look for data on this specific socket
-
- ink_assert(*cid < m_max_connections);
- fds[0].fd = ct[*cid].sd;
- fds[0].events = POLLIN;
- fds[0].revents = 0;
- fd_to_cid[0] = *cid;
- n_poll_fds = 1;
-
- } else { // look for data on any INCOMING socket
- int start_index;
- if (include_connects) {
- start_index = 0;
- } else {
- start_index = 1;
- }
- n_poll_fds = 0;
- for (i = start_index; i < m_max_connections; i++) {
- if (ct[i].state == LogSock::LS_STATE_INCOMING) {
- fds[n_poll_fds].fd = ct[i].sd;
- fds[n_poll_fds].events = POLLIN;
- fds[n_poll_fds].revents = 0;
- fd_to_cid[n_poll_fds] = i;
- n_poll_fds++;
- }
- }
- }
-
- if (n_poll_fds == 0) {
- return false;
- }
-
- ret = ::poll(fds, n_poll_fds, timeout_msec);
-
- if (ret == 0) {
- return false; // timeout
- } else if (ret < 0) {
- Debug("log-sock", "error on poll");
- return false; // error
- }
- //
- // a positive return value indicates how many descriptors had something
- // waiting on them. We only care about finding one of them, so we'll
- // look for the first one with an revents flag set to POLLIN.
- //
-
- for (i = 0; i < n_poll_fds; i++) {
- if (fds[i].revents & POLLIN) {
- *cid = fd_to_cid[i];
- Debug("log-sock", "poll successful on index %d", *cid);
- return true;
- }
- }
-
- Debug("log-sock", "invalid revents in the poll table");
- return false;
-}
-
-/**
- LogSock::pending_any
-
- Check for incomming data on any of the INCOMING sockets.
-*/
-bool
-LogSock::pending_any(int *cid, int timeout_msec)
-{
- ink_assert(cid != nullptr);
- *cid = -1;
- if (m_accept_connections) {
- return pending_data(cid, timeout_msec, true);
- } else {
- return pending_data(cid, timeout_msec, false);
- }
-}
-
-/*-------------------------------------------------------------------------
- LogSock::pending_message_any
-
- Check for an incomming message on any of the INCOMING sockets, aside from
- the socket reserved for accepting new connections.
- -------------------------------------------------------------------------*/
-
-bool
-LogSock::pending_message_any(int *cid, int timeout_msec)
-{
- ink_assert(cid != nullptr);
- *cid = -1;
- return pending_data(cid, timeout_msec, false);
-}
-
-/**
- LogSock::pending_message_on
-
- Check for incomming data on the specified socket.
-*/
-bool
-LogSock::pending_message_on(int cid, int timeout_msec)
-{
- return pending_data(&cid, timeout_msec, false);
-}
-
-/**
- LogSock::pending_connect
-
- Check for an incoming connection request on the socket reserved for that
- (cid = 0).
-*/
-bool
-LogSock::pending_connect(int timeout_msec)
-{
- int cid = 0;
- if (m_accept_connections) {
- return pending_data(&cid, timeout_msec, true);
- } else {
- return false;
- }
-}
-
-/**
- LogSock::close
-
- Close one (cid specified) or all (no argument) sockets, except for the
- incomming connection socket.
-*/
-void
-LogSock::close(int cid)
-{
- ink_assert(cid >= 0 && cid < m_max_connections);
-
- Debug("log-sock", "closing connection for cid %d", cid);
-
- if (ct[cid].state != LogSock::LS_STATE_UNUSED) {
- ::close(ct[cid].sd);
- delete ct[cid].host;
- ct[cid].state = LogSock::LS_STATE_UNUSED;
- }
-}
-
-void
-LogSock::close()
-{
- for (int i = 1; i < m_max_connections; i++) {
- this->close(i);
- }
-}
-
-/**
- LogSock::write
-
- Write data onto the socket corresponding to the given cid. Return the
- number of bytes actually written.
-*/
-int
-LogSock::write(int cid, void *buf, int bytes)
-{
- LogSock::MsgHeader header = {0};
- header.msg_bytes = 0;
- int ret;
-
- ink_assert(cid >= 0 && cid < m_max_connections);
-
- if (buf == nullptr || bytes == 0) {
- return 0;
- }
-
- if (ct[cid].state != LogSock::LS_STATE_OUTGOING) {
- return LogSock::LS_ERROR_STATE;
- }
-
- Debug("log-sock", "Sending %d bytes to cid %d", bytes, cid);
-
- //
- // send the message header
- //
- Debug("log-sock", " sending header (%zu bytes)", sizeof(LogSock::MsgHeader));
- header.msg_bytes = bytes;
- ret = ::send(ct[cid].sd, (char *)&header, sizeof(LogSock::MsgHeader), 0);
- if (ret != sizeof(LogSock::MsgHeader)) {
- return LogSock::LS_ERROR_WRITE;
- }
- //
- // send the actual data
- //
- Debug("log-sock", " sending data (%d bytes)", bytes);
- return ::send(ct[cid].sd, (char *)buf, bytes, 0);
-}
-
-/**
- LogSock::read
-
- Read data from the specified connection. This is a blocking call, so you
- may want to use one of the pending_XXX calls to see if there is anything
- to read first. Returns number of bytes read.
-*/
-int
-LogSock::read(int cid, void *buf, unsigned maxsize)
-{
- LogSock::MsgHeader header;
- unsigned size;
-
- ink_assert(cid >= 0 && cid < m_max_connections);
- ink_assert(buf != nullptr);
-
- if (ct[cid].state != LogSock::LS_STATE_INCOMING) {
- return LogSock::LS_ERROR_STATE;
- }
-
- Debug("log-sock", "reading data from cid %d", cid);
-
- if (read_header(ct[cid].sd, &header) < 0) {
- return LogSock::LS_ERROR_READ;
- }
-
- size = ((unsigned)header.msg_bytes < maxsize) ? (unsigned)header.msg_bytes : maxsize;
- return read_body(ct[cid].sd, buf, size);
-}
-
-/**
- LogSock::read_alloc
-
- This routine reads data from the specified connection, and returns a
- pointer to newly allocated space (allocated with new) containing the
- data. The number of bytes read is set in the argument size, which is
- expected to be a pointer to an int.
-*/
-void *
-LogSock::read_alloc(int cid, int *size)
-{
- LogSock::MsgHeader header;
- char *data;
-
- ink_assert(cid >= 0 && cid < m_max_connections);
-
- if (ct[cid].state != LogSock::LS_STATE_INCOMING) {
- return nullptr;
- }
-
- Debug("log-sock", "reading data from cid %d", cid);
-
- if (read_header(ct[cid].sd, &header) < 0) {
- return nullptr;
- }
-
- data = new char[header.msg_bytes];
- ink_assert(data != nullptr);
-
- if ((*size = read_body(ct[cid].sd, data, header.msg_bytes)) < 0) {
- delete[] data;
- data = nullptr;
- }
-
- return data;
-}
-
-/**
- */
-bool
-LogSock::is_connected(int cid, bool ping) const
-{
- ink_assert(cid >= 0 && cid < m_max_connections);
-
- if (ct[cid].state == LogSock::LS_STATE_UNUSED) {
- return false;
- }
-
- if (ping) {
- int flags = fcntl(ct[cid].sd, F_GETFL);
- ::fcntl(ct[cid].sd, F_SETFL, O_NONBLOCK);
- int i;
- int j = ::recv(ct[cid].sd, (char *)&i, sizeof(int), MSG_PEEK);
- ::fcntl(ct[cid].sd, F_SETFL, flags);
- if (j != 0) {
- return true;
- } else {
- return false;
- }
- } else {
- return (ct[cid].sd >= 0);
- }
-}
-
-/**
- */
-void
-LogSock::check_connections()
-{
- for (int i = 1; i < m_max_connections; i++) {
- if (ct[i].state == LogSock::LS_STATE_INCOMING) {
- if (!is_connected(i, true)) {
- Debug("log-sock", "Connection %d is no longer connected", i);
- close(i);
- }
- }
- }
-}
-
-/**
- This routine will check to ensure that the client connecting is
- authorized to use the log collation port. To authorize, the client is
- expected to send the logging secret string.
-*/
-bool
-LogSock::authorized_client(int cid, char *key)
-{
- //
- // Wait for up to 5 seconds for the client to authenticate
- //
- if (!pending_message_on(cid, 5000)) {
- return false;
- }
- //
- // Ok, the client has a pending message, so check to see if it matches
- // the given key.
- //
- char buf[1024];
- int size = this->read(cid, buf, 1024);
- ink_assert(size >= 0 && size <= 1024);
-
- if (strncmp(buf, key, size) == 0) {
- return true;
- }
-
- return false;
-}
-
-/**
- */
-char *
-LogSock::connected_host(int cid)
-{
- ink_assert(cid >= 0 && cid < m_max_connections);
- return ct[cid].host;
-}
-
-/**
- */
-int
-LogSock::connected_port(int cid)
-{
- ink_assert(cid >= 0 && cid < m_max_connections);
- return ct[cid].port;
-}
-
-/*-------------------------------------------------------------------------
- LOCAL ROUTINES
- -------------------------------------------------------------------------*/
-
-/**
- LogSock::new_cid
-*/
-int
-LogSock::new_cid()
-{
- int cid = -1;
-
- for (int i = 1; i < m_max_connections; i++) {
- if (ct[i].state == LogSock::LS_STATE_UNUSED) {
- cid = i;
- break;
- }
- }
-
- return cid;
-}
-
-/**
- LogSock::init_cid
-*/
-void
-LogSock::init_cid(int cid, char *host, int port, int sd, LogSock::State state)
-{
- ink_assert(cid >= 0 && cid < m_max_connections);
- // host can be NULL if it's not known
- ink_assert(port >= 0);
- // sd can be -1 to indicate no connection yet
- ink_assert(state >= 0 && state < LogSock::LS_N_STATES);
-
- if (host != nullptr) {
- const size_t host_size = strlen(host) + 1;
- ct[cid].host = new char[host_size];
- ink_strlcpy(ct[cid].host, host, host_size);
- } else {
- ct[cid].host = nullptr;
- }
-
- ct[cid].port = port;
- ct[cid].sd = sd;
- ct[cid].state = state;
-}
-
-/**
- */
-int
-LogSock::read_header(int sd, LogSock::MsgHeader *header)
-{
- ink_assert(sd >= 0);
- ink_assert(header != nullptr);
-
- int bytes = ::recv(sd, (char *)header, sizeof(LogSock::MsgHeader), 0);
- if (bytes != sizeof(LogSock::MsgHeader)) {
- return -1;
- }
-
- return bytes;
-}
-
-/**
- */
-int
-LogSock::read_body(int sd, void *buf, int bytes)
-{
- ink_assert(sd >= 0);
- ink_assert(buf != nullptr);
- ink_assert(bytes >= 0);
-
- if (bytes == 0) {
- return 0;
- }
-
- unsigned bytes_left = bytes;
- char *to = (char *)buf;
-
- while (bytes_left) {
- unsigned bytes_read = ::recv(sd, to, bytes_left, 0);
- to += bytes_read;
- bytes_left -= bytes_read;
- }
-
- return bytes;
-}
diff --git a/proxy/logging/LogSock.h b/proxy/logging/LogSock.h
deleted file mode 100644
index f2eb70e..0000000
--- a/proxy/logging/LogSock.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/** @file
-
- A brief file description
-
- @section license License
-
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you 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.
- */
-
-#pragma once
-
-#include "tscore/ink_platform.h"
-
-/*-------------------------------------------------------------------------
- LogSock
-
- This class implements a multiplexed socket class that supports both
- client and server functionality.
- -------------------------------------------------------------------------*/
-
-class LogSock
-{
-public:
- enum Constant {
- LS_CONST_PACKETSIZE = 1024,
- LS_CONST_MAX_CONNS = 256,
- };
-
- enum Err {
- LS_ERROR_UNKNOWN = -1,
- LS_ERROR_CONNECT_TABLE_FULL = -3,
- LS_ERROR_SOCKET = -4,
- LS_ERROR_BIND = -5,
- LS_ERROR_CONNECT = -6,
- LS_ERROR_ACCEPT = -7,
- LS_ERROR_NO_SUCH_HOST = -8,
- LS_ERROR_NO_CONNECTION = -9,
- LS_ERROR_STATE = -10,
- LS_ERROR_WRITE = -11,
- LS_ERROR_READ = -12
- };
-
- enum State {
- LS_STATE_UNUSED = 0,
- LS_STATE_INCOMING,
- LS_STATE_OUTGOING,
- LS_N_STATES,
- };
-
- explicit LogSock(int max_connects = 1);
- ~LogSock();
-
- bool pending_any(int *cid, int timeout_msec = 0);
- bool pending_message_any(int *cid, int timeout_msec = 0);
- bool pending_message_on(int cid, int timeout_msec = 0);
- bool pending_connect(int timeout_msec = 0);
-
- int listen(int accept_port, int family = AF_INET);
- int accept();
- int connect(sockaddr const *ip);
-
- void close(int cid); // this connection
- void close(); // all connections
-
- int write(int cid, void *buf, int bytes);
-
- int read(int cid, void *buf, unsigned maxsize);
- void *read_alloc(int cid, int *size);
-
- char *
- on_host()
- {
- return ct[0].host;
- }
-
- int
- on_port()
- {
- return ct[0].port;
- }
-
- bool is_connected(int cid, bool ping = false) const;
- void check_connections();
- bool authorized_client(int cid, char *key);
- char *connected_host(int cid);
- int connected_port(int cid);
-
- // noncopyable
- LogSock(const LogSock &) = delete;
- LogSock &operator=(const LogSock &) = delete;
-
-private:
- struct ConnectTable {
- char *host; // hostname for this connection
- int port; // port number for this connection
- int sd; // socket descriptor for this connection
- State state; // state of this entry
- };
-
- struct MsgHeader {
- int msg_bytes; // length of the following message
- };
-
- bool pending_data(int *cid, int timeout_msec, bool include_connects);
- int new_cid();
- void init_cid(int cid, char *host, int port, int sd, State state);
- int read_header(int sd, MsgHeader *header);
- int read_body(int sd, void *buf, int bytes);
-
- ConnectTable *ct; // list of all connections; index 0 is
- // the accept port.
- bool m_accept_connections = false; // do we accept new connections?
- int m_max_connections; // max size of all tables
-};
diff --git a/proxy/logging/Makefile.am b/proxy/logging/Makefile.am
index 9f438ed..abf8e86 100644
--- a/proxy/logging/Makefile.am
+++ b/proxy/logging/Makefile.am
@@ -34,7 +34,7 @@ AM_CPPFLAGS += \
EXTRA_DIST = LogStandalone.cc
-noinst_LIBRARIES = liblogging.a liblogcollation.a
+noinst_LIBRARIES = liblogging.a
liblogging_a_SOURCES = \
Log.cc \
@@ -56,28 +56,15 @@ liblogging_a_SOURCES = \
LogFilter.h \
LogFormat.cc \
LogFormat.h \
- LogHost.cc \
- LogHost.h \
LogLimits.h \
LogObject.cc \
LogObject.h \
- LogSock.cc \
- LogSock.h \
LogUtils.cc \
LogUtils.h \
YamlLogConfig.cc \
YamlLogConfigDecoders.cc \
YamlLogConfig.h
-liblogcollation_a_SOURCES = \
- LogCollationAccept.cc \
- LogCollationAccept.h \
- LogCollationBase.h \
- LogCollationClientSM.cc \
- LogCollationClientSM.h \
- LogCollationHostSM.cc \
- LogCollationHostSM.h
-
check_PROGRAMS = \
test_LogUtils \
test_LogUtils2
@@ -111,5 +98,5 @@ test_LogUtils2_LDADD = \
$(top_builddir)/src/tscpp/util/libtscpputil.la \
$(top_builddir)/iocore/eventsystem/libinkevent.a
-clang-tidy-local: $(liblogging_a_SOURCES) $(liblogcollation_a_SOURCES) $(EXTRA_DIST)
+clang-tidy-local: $(liblogging_a_SOURCES) $(EXTRA_DIST)
$(CXX_Clang_Tidy)
diff --git a/proxy/logging/YamlLogConfig.cc b/proxy/logging/YamlLogConfig.cc
index 8988458..3e8d408 100644
--- a/proxy/logging/YamlLogConfig.cc
+++ b/proxy/logging/YamlLogConfig.cc
@@ -104,8 +104,8 @@ TsEnumDescriptor ROLLING_MODE_LUA = {
{{"log.roll.none", 0}, {"log.roll.time", 1}, {"log.roll.size", 2}, {"log.roll.both", 3}, {"log.roll.any", 4}}};
std::set<std::string> valid_log_object_keys = {
- "filename", "format", "mode", "header", "rolling_enabled", "rolling_interval_sec",
- "rolling_offset_hr", "rolling_size_mb", "filters", "collation_hosts", "min_count"};
+ "filename", "format", "mode", "header", "rolling_enabled", "rolling_interval_sec",
+ "rolling_offset_hr", "rolling_size_mb", "filters", "min_count"};
LogObject *
YamlLogConfig::decodeLogObject(const YAML::Node &node)
@@ -183,8 +183,8 @@ YamlLogConfig::decodeLogObject(const YAML::Node &node)
}
auto logObject = new LogObject(fmt, Log::config->logfile_dir, filename.c_str(), file_type, header.c_str(),
- (Log::RollingEnabledValues)obj_rolling_enabled, Log::config->collation_preproc_threads,
- obj_rolling_interval_sec, obj_rolling_offset_hr, obj_rolling_size_mb);
+ (Log::RollingEnabledValues)obj_rolling_enabled, obj_rolling_interval_sec, obj_rolling_offset_hr,
+ obj_rolling_size_mb);
// Generate LogDeletingInfo entry for later use
std::string ext;
@@ -223,53 +223,5 @@ YamlLogConfig::decodeLogObject(const YAML::Node &node)
}
}
- auto collation_host_list = node["collation_hosts"];
- if (!collation_host_list) {
- return logObject;
- }
-
- if (!collation_host_list.IsSequence()) {
- throw YAML::ParserException(collation_host_list.Mark(), "'collation_hosts' should be a list of collation_host objects");
- }
-
- for (auto const &collation_host : collation_host_list) {
- if (!collation_host["host"]) {
- Warning("no collation 'host' name; cannot add this Collation host");
- continue;
- }
-
- auto collation_host_name = collation_host["host"].as<std::string>();
-
- LogHost *lh = new LogHost(logObject->get_full_filename(), logObject->get_signature());
- if (!lh->set_name_or_ipstr(collation_host_name.c_str())) {
- Warning("Could not set \"%s\" as collation host", collation_host_name.c_str());
- delete lh;
- continue;
- }
-
- logObject->add_loghost(lh, false);
- if (!collation_host["failover"]) {
- continue;
- }
-
- if (!collation_host["failover"].IsSequence()) {
- delete lh;
- throw YAML::ParserException(collation_host["failover"].Mark(), "'failover' should be a list of host names");
- }
-
- LogHost *prev = lh;
- for (auto const &failover_host : collation_host["failover"]) {
- auto failover_host_name = failover_host.as<std::string>();
- LogHost *flh = new LogHost(logObject->get_full_filename(), logObject->get_signature());
- if (!flh->set_name_or_ipstr(failover_host_name.c_str())) {
- Warning("Could not set \"%s\" as a failover host", failover_host_name.c_str());
- delete flh;
- continue;
- }
- prev->failover_link.next = flh;
- prev = flh;
- }
- }
-
return logObject;
}
diff --git a/proxy/shared/UglyLogStubs.cc b/proxy/shared/UglyLogStubs.cc
index ce4d97b..15ec22e 100644
--- a/proxy/shared/UglyLogStubs.cc
+++ b/proxy/shared/UglyLogStubs.cc
@@ -75,22 +75,6 @@ Machine::instance()
return nullptr;
}
-#include "LogCollationAccept.h"
-LogCollationAccept::LogCollationAccept(int port) : Continuation(new_ProxyMutex()), m_port(port) {}
-LogCollationAccept::~LogCollationAccept() {}
-
-#include "LogCollationClientSM.h"
-LogCollationClientSM::LogCollationClientSM(LogHost *log_host) : Continuation(new_ProxyMutex()), m_log_host(log_host) {}
-
-LogCollationClientSM::~LogCollationClientSM() {}
-
-int
-LogCollationClientSM::send(LogBuffer * /* log_buffer ATS_UNUSED */)
-{
- ink_release_assert(false);
- return 0;
-}
-
NetAccept *
UnixNetProcessor::createNetAccept(const NetProcessor::AcceptOptions &opt)
{
diff --git a/src/traffic_logcat/logcat.cc b/src/traffic_logcat/logcat.cc
index b1cd964..fef226b 100644
--- a/src/traffic_logcat/logcat.cc
+++ b/src/traffic_logcat/logcat.cc
@@ -38,12 +38,10 @@
#include "LogFilter.h"
#include "LogFormat.h"
#include "LogFile.h"
-#include "LogHost.h"
#include "LogObject.h"
#include "LogConfig.h"
#include "LogBuffer.h"
#include "LogUtils.h"
-#include "LogSock.h"
#include "Log.h"
// logcat-specific command-line flags
diff --git a/src/traffic_server/InkAPI.cc b/src/traffic_server/InkAPI.cc
index 6945a96..94b829f 100644
--- a/src/traffic_server/InkAPI.cc
+++ b/src/traffic_server/InkAPI.cc
@@ -7257,10 +7257,9 @@ TSTextLogObjectCreate(const char *filename, int mode, TSTextLogObject *new_objec
return TS_ERROR;
}
- TextLogObject *tlog =
- new TextLogObject(filename, Log::config->logfile_dir, (bool)mode & TS_LOG_MODE_ADD_TIMESTAMP, nullptr,
- Log::config->rolling_enabled, Log::config->collation_preproc_threads, Log::config->rolling_interval_sec,
- Log::config->rolling_offset_hr, Log::config->rolling_size_mb);
+ TextLogObject *tlog = new TextLogObject(
+ filename, Log::config->logfile_dir, (bool)mode & TS_LOG_MODE_ADD_TIMESTAMP, nullptr, Log::config->rolling_enabled,
+ Log::config->preproc_threads, Log::config->rolling_interval_sec, Log::config->rolling_offset_hr, Log::config->rolling_size_mb);
if (tlog == nullptr) {
*new_object = nullptr;
return TS_ERROR;
diff --git a/src/traffic_server/Makefile.inc b/src/traffic_server/Makefile.inc
index e828109..a18d6ce 100644
--- a/src/traffic_server/Makefile.inc
+++ b/src/traffic_server/Makefile.inc
@@ -65,7 +65,6 @@ traffic_server_traffic_server_LDADD = \
$(top_builddir)/proxy/http2/libhttp2.a \
$(top_builddir)/proxy/logging/liblogging.a \
$(top_builddir)/proxy/hdrs/libhdrs.a \
- $(top_builddir)/proxy/logging/liblogcollation.a \
$(top_builddir)/proxy/shared/libdiagsconfig.a \
$(top_builddir)/mgmt/libmgmt_p.la \
$(top_builddir)/iocore/utils/libinkutils.a \