scylla-cqlsh 6.0.29__cp310-cp310-win_amd64.whl

cqlshlib/sslhandling.py

@@ -0,0 +1,109 @@
+# 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.
+
+import os
+import sys
+import ssl
+
+import configparser
+
+
+def ssl_settings(host, config_file, env=os.environ):
+    """
+    Function which generates SSL setting for cassandra.Cluster
+
+    Params:
+    * host .........: hostname of Cassandra node.
+    * env ..........: environment variables. SSL factory will use, if passed,
+                      SSL_CERTFILE and SSL_VALIDATE variables.
+    * config_file ..: path to cqlsh config file (usually ~/.cqlshrc).
+                      SSL factory will use, if set, certfile and validate
+                      options in [ssl] section, as well as host to certfile
+                      mapping in [certfiles] section.
+
+    [certfiles] section is optional, 'validate' setting in [ssl] section is
+    optional too. If validation is enabled then SSL certfile must be provided
+    either in the config file or as an environment variable.
+    Environment variables override any options set in cqlsh config file.
+    """
+    configs = configparser.ConfigParser()
+    configs.read(config_file)
+
+    def get_option(section, option):
+        try:
+            return configs.get(section, option)
+        except configparser.Error:
+            return None
+
+    def get_best_tls_protocol(ssl_ver_str):
+        if ssl_ver_str:
+            print("Warning: Explicit SSL and TLS versions in the cqlshrc file or in SSL_VERSION environment property are ignored as the protocol is auto-negotiated.\n")
+        return ssl.PROTOCOL_TLS_CLIENT
+
+    ssl_validate = env.get('SSL_VALIDATE')
+    if ssl_validate is None:
+        ssl_validate = get_option('ssl', 'validate')
+    ssl_validate = ssl_validate is None or ssl_validate.lower() != 'false'
+
+    ssl_check_hostname = env.get('SSL_CHECK_HOSTNAME')
+    if ssl_check_hostname is None:
+        ssl_check_hostname = get_option('ssl', 'check_hostname')
+    ssl_check_hostname = ssl_check_hostname is not None and ssl_check_hostname.lower() != 'false'
+
+    if ssl_check_hostname and not ssl_validate:
+        sys.exit("SSL certificate hostname checking "
+                 "(`check_hostname` in the [ssl] section) must be turned off "
+                 "if certificate `validate` is turned off.")
+        
+    ssl_version_str = env.get('SSL_VERSION')
+    if ssl_version_str is None:
+        ssl_version_str = get_option('ssl', 'version')
+
+    ssl_version = get_best_tls_protocol(ssl_version_str)
+
+    ssl_certfile = env.get('SSL_CERTFILE')
+    if ssl_certfile is None:
+        ssl_certfile = get_option('certfiles', host)
+    if ssl_certfile is None:
+        ssl_certfile = get_option('ssl', 'certfile')
+    if ssl_validate and ssl_certfile is None:
+        sys.exit("Validation is enabled; SSL transport factory requires a valid certfile "
+                 "to be specified. Please provide path to the certfile in [ssl] section "
+                 "as 'certfile' option in %s (or use [certfiles] section) or set SSL_CERTFILE "
+                 "environment variable." % (config_file,))
+    if ssl_certfile is not None:
+        ssl_certfile = os.path.expanduser(ssl_certfile)
+
+    userkey = get_option('ssl', 'userkey')
+    if userkey:
+        userkey = os.path.expanduser(userkey)
+    usercert = get_option('ssl', 'usercert')
+    if usercert:
+        usercert = os.path.expanduser(usercert)
+
+    ssl_context = ssl.SSLContext(ssl_version)
+    ssl_context.check_hostname = ssl_check_hostname
+    if usercert and userkey:
+        ssl_context.load_cert_chain(certfile=usercert,
+                                    keyfile=userkey)
+    if (usercert and not userkey) or (userkey and not usercert):
+        print("Warning: userkey and usercert from [ssl] section, should be both configured, otherwise won't be used")
+
+    ssl_context.verify_mode = ssl.CERT_REQUIRED if ssl_validate else ssl.CERT_NONE
+    if ssl_certfile:
+        ssl_context.load_verify_locations(cafile=ssl_certfile)
+
+    return ssl_context

cqlshlib/tracing.py

@@ -0,0 +1,90 @@
+# 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.
+
+from datetime import datetime
+import time
+
+from cassandra.query import QueryTrace, TraceUnavailable
+from cqlshlib.displaying import MAGENTA
+
+
+def print_trace_session(shell, session, session_id, partial_session=False):
+    """
+    Lookup a trace by session and trace session ID, then print it.
+    """
+    trace = QueryTrace(session_id, session)
+    try:
+        wait_for_complete = not partial_session
+        trace.populate(wait_for_complete=wait_for_complete)
+    except TraceUnavailable:
+        shell.printerr("Session %s wasn't found." % session_id)
+    else:
+        print_trace(shell, trace)
+
+
+def print_trace(shell, trace):
+    """
+    Print an already populated cassandra.query.QueryTrace instance.
+    """
+    rows = make_trace_rows(trace)
+    if not rows:
+        shell.printerr("No rows for session %s found." % (trace.trace_id,))
+        return
+    names = ['activity', 'timestamp', 'source', 'source_elapsed', 'client']
+
+    formatted_names = list(map(shell.myformat_colname, names))
+    formatted_values = [list(map(shell.myformat_value, row)) for row in rows]
+
+    shell.writeresult('')
+    shell.writeresult('Tracing session: ', color=MAGENTA, newline=False)
+    shell.writeresult(trace.trace_id)
+    shell.writeresult('')
+    shell.print_formatted_result(formatted_names, formatted_values, with_header=True, tty=shell.tty)
+    shell.writeresult('')
+
+
+def make_trace_rows(trace):
+    if not trace.events:
+        return []
+
+    rows = [[trace.request_type, str(datetime_from_utc_to_local(trace.started_at)), trace.coordinator, 0, trace.client]]
+
+    # append main rows (from events table).
+    for event in trace.events:
+        rows.append(["%s [%s]" % (event.description, event.thread_name),
+                     str(datetime_from_utc_to_local(event.datetime)),
+                     event.source,
+                     total_micro_seconds(event.source_elapsed),
+                     trace.client])
+    # append footer row (from sessions table).
+    if trace.duration:
+        finished_at = (datetime_from_utc_to_local(trace.started_at) + trace.duration)
+        rows.append(['Request complete', str(finished_at), trace.coordinator, total_micro_seconds(trace.duration), trace.client])
+
+    return rows
+
+
+def total_micro_seconds(td):
+    """
+    Convert a timedelta into total microseconds
+    """
+    return int((td.microseconds + (td.seconds + td.days * 24 * 3600) * 10 ** 6)) if td else "--"
+
+
+def datetime_from_utc_to_local(utc_datetime):
+    now_timestamp = time.time()
+    offset = datetime.fromtimestamp(now_timestamp) - datetime.utcfromtimestamp(now_timestamp)
+    return utc_datetime + offset

cqlshlib/util.py

@@ -0,0 +1,183 @@
+# 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.
+
+
+import cProfile
+import codecs
+import pstats
+import os
+import errno
+import stat
+
+from datetime import timedelta, tzinfo
+from io import StringIO
+
+try:
+    from line_profiler import LineProfiler
+    HAS_LINE_PROFILER = True
+except ImportError:
+    HAS_LINE_PROFILER = False
+
+ZERO = timedelta(0)
+
+
+class UTC(tzinfo):
+    """UTC"""
+
+    def utcoffset(self, dt):
+        return ZERO
+
+    def tzname(self, dt):
+        return "UTC"
+
+    def dst(self, dt):
+        return ZERO
+
+
+def split_list(items, pred):
+    """
+    Split up a list (or other iterable) on the elements which satisfy the
+    given predicate 'pred'. Elements for which 'pred' returns true start a new
+    sublist for subsequent elements, which will accumulate in the new sublist
+    until the next satisfying element.
+
+    >>> split_list([0, 1, 2, 5, 99, 8], lambda n: (n % 2) == 0)
+    [[0], [1, 2], [5, 99, 8], []]
+    """
+
+    thisresult = []
+    results = [thisresult]
+    for i in items:
+        thisresult.append(i)
+        if pred(i):
+            thisresult = []
+            results.append(thisresult)
+    return results
+
+
+def find_common_prefix(strs):
+    """
+    Given a list (iterable) of strings, return the longest common prefix.
+
+    >>> find_common_prefix(['abracadabra', 'abracadero', 'abranch'])
+    'abra'
+    >>> find_common_prefix(['abracadabra', 'abracadero', 'mt. fuji'])
+    ''
+    """
+
+    common = []
+    for cgroup in zip(*strs):
+        if all(x == cgroup[0] for x in cgroup[1:]):
+            common.append(cgroup[0])
+        else:
+            break
+    return ''.join(common)
+
+
+def list_bifilter(pred, iterable):
+    """
+    Filter an iterable into two output lists: the first containing all
+    elements of the iterable for which 'pred' returns true, and the second
+    containing all others. Order of the elements is otherwise retained.
+
+    >>> list_bifilter(lambda x: isinstance(x, int), (4, 'bingo', 1.2, 6, True))
+    ([4, 6], ['bingo', 1.2, True])
+    """
+
+    yes_s = []
+    no_s = []
+    for i in iterable:
+        (yes_s if pred(i) else no_s).append(i)
+    return yes_s, no_s
+
+
+def identity(x):
+    return x
+
+
+def trim_if_present(s, prefix):
+    if s.startswith(prefix):
+        return s[len(prefix):]
+    return s
+
+
+def is_file_secure(filename):
+    try:
+        st = os.stat(filename)
+    except OSError as e:
+        if e.errno != errno.ENOENT:
+            raise
+        # the file doesn't exist, the security of it is irrelevant
+        return True
+    uid = os.getuid()
+
+    # Skip enforcing the file owner and UID matching for the root user (uid == 0).
+    # This is to allow "sudo cqlsh" to work with user owned credentials file.
+    return (uid == 0 or st.st_uid == uid) and stat.S_IMODE(st.st_mode) & (stat.S_IRGRP | stat.S_IROTH) == 0
+
+
+def get_file_encoding_bomsize(filename):
+    """
+    Checks the beginning of a file for a Unicode BOM.  Based on this check,
+    the encoding that should be used to open the file and the number of
+    bytes that should be skipped (to skip the BOM) are returned.
+    """
+    bom_encodings = ((codecs.BOM_UTF8, 'utf-8-sig'),
+                     (codecs.BOM_UTF16_LE, 'utf-16le'),
+                     (codecs.BOM_UTF16_BE, 'utf-16be'),
+                     (codecs.BOM_UTF32_LE, 'utf-32be'),
+                     (codecs.BOM_UTF32_BE, 'utf-32be'))
+
+    firstbytes = open(filename, 'rb').read(4)
+    for bom, encoding in bom_encodings:
+        if firstbytes.startswith(bom):
+            file_encoding, size = encoding, len(bom)
+            break
+    else:
+        file_encoding, size = "utf-8", 0
+
+    return file_encoding, size
+
+
+def profile_on(fcn_names=None):
+    if fcn_names and HAS_LINE_PROFILER:
+        pr = LineProfiler()
+        for fcn_name in fcn_names:
+            pr.add_function(fcn_name)
+        pr.enable()
+        return pr
+
+    pr = cProfile.Profile()
+    pr.enable()
+    return pr
+
+
+def profile_off(pr, file_name):
+    pr.disable()
+    s = StringIO()
+
+    if HAS_LINE_PROFILER and isinstance(pr, LineProfiler):
+        pr.print_stats(s)
+    else:
+        ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
+        ps.print_stats()
+
+    ret = s.getvalue()
+    if file_name:
+        with open(file_name, 'w') as f:
+            print("Writing to %s\n" % (f.name, ))
+            f.write(ret)
+    return ret