#!/usr/bin/env python
#
# Public Domain 2014-2018 MongoDB, Inc.
# Public Domain 2008-2014 WiredTiger, Inc.
#
# This is free and unencumbered software released into the public domain.
#
# Anyone is free to copy, modify, publish, use, compile, sell, or
# distribute this software, either in source code form or as a compiled
# binary, for any purpose, commercial or non-commercial, and by any
# means.
#
# In jurisdictions that recognize copyright laws, the author or authors
# of this software dedicate any and all copyright interest in the
# software to the public domain. We make this dedication for the benefit
# of the public at large and to the detriment of our heirs and
# successors. We intend this dedication to be an overt act of
# relinquishment in perpetuity of all present and future rights to this
# software under copyright law.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.

import itertools, wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtdataset import SimpleDataSet, SimpleLSMDataSet, ComplexDataSet, \
    ComplexLSMDataSet
from wtscenario import make_scenarios
from wiredtiger import stat

# test_stat02.py
#    Statistics cursor configurations.
class test_stat_cursor_config(wttest.WiredTigerTestCase):
    pfx = 'test_stat_cursor_config'
    uri = [
        ('file',  dict(uri='file:' + pfx, dataset=SimpleDataSet)),
        ('table', dict(uri='table:' + pfx, dataset=SimpleDataSet)),
        ('table-lsm', dict(uri='table:' + pfx, dataset=SimpleLSMDataSet)),
        ('complex', dict(uri='table:' + pfx, dataset=ComplexDataSet)),
        ('complex-lsm', dict(uri='table:' + pfx, dataset=ComplexLSMDataSet))
    ]
    data_config = [
        ('none', dict(data_config='none', ok=[])),
        ( 'all',  dict(data_config='all', ok=['empty', 'fast', 'all', 'size'])),
        ('fast', dict(data_config='fast', ok=['empty', 'fast', 'size']))
    ]
    cursor_config = [
        ('empty', dict(cursor_config='empty')),
        ( 'all', dict(cursor_config='all')),
        ('fast', dict(cursor_config='fast')),
        ('size', dict(cursor_config='size'))
    ]

    scenarios = make_scenarios(uri, data_config, cursor_config)

    # Turn on statistics for this test.
    def conn_config(self):
        return 'statistics=(%s)' % self.data_config

    # For each database/cursor configuration, confirm the right combinations
    # succeed or fail.
    def test_stat_cursor_config(self):
        self.dataset(self, self.uri, 100).populate()
        config = 'statistics=('
        if self.cursor_config != 'empty':
            config = config + self.cursor_config
        config = config + ')'
        if self.ok and self.cursor_config in self.ok:
            self.session.open_cursor('statistics:', None, config)
        else:
            msg = '/database statistics configuration/'
            self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda:
                self.session.open_cursor('statistics:', None, config), msg)

# Test the connection "clear" configuration.
class test_stat_cursor_conn_clear(wttest.WiredTigerTestCase):
    pfx = 'test_stat_cursor_conn_clear'
    conn_config = 'statistics=(all)'

    def test_stat_cursor_conn_clear(self):
        uri = 'table:' + self.pfx
        ComplexDataSet(self, uri, 100).populate()

        # cursor_insert should clear
        # cache_bytes_dirty should not clear
        cursor = self.session.open_cursor(
            'statistics:', None, 'statistics=(all,clear)')
        self.assertGreater(cursor[stat.conn.cache_bytes_dirty][2], 0)
        self.assertGreater(cursor[stat.conn.cursor_insert][2], 0)
        cursor = self.session.open_cursor(
            'statistics:', None, 'statistics=(all,clear)')
        self.assertGreater(cursor[stat.conn.cache_bytes_dirty][2], 0)
        self.assertEqual(cursor[stat.conn.cursor_insert][2], 0)

# Test the data-source "clear" configuration.
class test_stat_cursor_dsrc_clear(wttest.WiredTigerTestCase):
    pfx = 'test_stat_cursor_dsrc_clear'

    uri = [
        ('dsrc_clear_1',  dict(uri='file:' + pfx, dataset=SimpleDataSet)),
        ('dsrc_clear_2', dict(uri='table:' + pfx, dataset=SimpleDataSet)),
        ('dsrc_clear_3', dict(uri='table:' + pfx, dataset=ComplexDataSet)),
        ('dsrc_clear_4', dict(uri='table:' + pfx, dataset=ComplexLSMDataSet))
    ]

    scenarios = make_scenarios(uri)
    conn_config = 'statistics=(all)'

    def test_stat_cursor_dsrc_clear(self):
        self.dataset(self, self.uri, 100).populate()

        # cursor_insert should clear
        #
        # We can't easily test data-source items that shouldn't clear: as I
        # write this, session_cursor_open is the only such item, and it will
        # change to account for the statistics cursors we open here.
        cursor = self.session.open_cursor(
            'statistics:' + self.uri, None, 'statistics=(all,clear)')
        self.assertGreater(cursor[stat.dsrc.cursor_insert][2], 0)
        cursor = self.session.open_cursor(
            'statistics:' + self.uri, None, 'statistics=(all,clear)')
        self.assertEqual(cursor[stat.dsrc.cursor_insert][2], 0)

# Test the "fast" configuration.
class test_stat_cursor_fast(wttest.WiredTigerTestCase):
    pfx = 'test_stat_cursor_fast'

    uri = [
        ('fast_1',  dict(uri='file:' + pfx, dataset=SimpleDataSet)),
        ('fast_2', dict(uri='table:' + pfx, dataset=SimpleDataSet)),
        ('fast_3', dict(uri='table:' + pfx, dataset=ComplexDataSet)),
        ('fast_4', dict(uri='table:' + pfx, dataset=ComplexLSMDataSet))
    ]

    scenarios = make_scenarios(uri)
    conn_config = 'statistics=(all)'

    def test_stat_cursor_fast(self):
        self.dataset(self, self.uri, 100).populate()

        # A "fast" cursor shouldn't see the underlying btree statistics.
        # Check "fast" first, otherwise we get a copy of the statistics
        # we generated in the "all" call, they just aren't updated.
        cursor = self.session.open_cursor(
            'statistics:' + self.uri, None, 'statistics=(fast)')
        self.assertEqual(cursor[stat.dsrc.btree_entries][2], 0)
        cursor = self.session.open_cursor(
            'statistics:' + self.uri, None, 'statistics=(all)')
        self.assertGreater(cursor[stat.dsrc.btree_entries][2], 0)

# Test connection error combinations.
class test_stat_cursor_conn_error(wttest.WiredTigerTestCase):
    def setUpConnectionOpen(self, dir):
        return None
    def setUpSessionOpen(self, conn):
        return None

    def test_stat_cursor_conn_error(self):
        args = ['none', 'all', 'fast']
        for i in list(itertools.permutations(args, 2)):
            config = 'create,statistics=(' + i[0] + ',' + i[1] + ')'
            msg = '/Only one of/'
            self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda: self.wiredtiger_open('.', config), msg)

# Test data-source error combinations.
class test_stat_cursor_dsrc_error(wttest.WiredTigerTestCase):
    pfx = 'test_stat_cursor_dsrc_error'

    uri = [
        ('dsrc_error_1',  dict(uri='file:' + pfx, dataset=SimpleDataSet)),
        ('dsrc_error_2', dict(uri='table:' + pfx, dataset=SimpleDataSet)),
        ('dsrc_error_3', dict(uri='table:' + pfx, dataset=ComplexDataSet)),
        ('dsrc_error_4', dict(uri='table:' + pfx, dataset=ComplexLSMDataSet))
    ]

    scenarios = make_scenarios(uri)
    conn_config = 'statistics=(all)'

    def test_stat_cursor_dsrc_error(self):
        self.dataset(self, self.uri, 100).populate()
        args = ['all', 'fast']
        for i in list(itertools.permutations(args, 2)):
            config = 'statistics=(' + i[0] + ',' + i[1] + ')'
            msg = '/Only one of/'
            self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda: self.session.open_cursor(
                'statistics:' + self.uri, None, config), msg)

# Test data-source cache walk statistics
class test_stat_cursor_dsrc_cache_walk(wttest.WiredTigerTestCase):
    uri = 'file:test_stat_cursor_dsrc_cache_walk'

    conn_config = 'statistics=(none)'

    def test_stat_cursor_dsrc_cache_walk(self):
        SimpleDataSet(self, self.uri, 100).populate()
        # Ensure that it's an error to get cache_walk stats if none is set
        msg = '/doesn\'t match the database statistics/'
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda: self.session.open_cursor(
            'statistics:' + self.uri, None, None), msg)

        # Test configurations that are valid but should not collect
        # cache walk information. Do these first since the cache walk
        # statistics are mostly marked as not cleared - so once they are
        # populated the values will always be returned
        self.conn.reconfigure('statistics=(cache_walk,fast,clear)')
        c = self.session.open_cursor(
            'statistics:' + self.uri, None, 'statistics=(fast)')
        self.assertEqual(c[stat.dsrc.cache_state_root_size][2], 0)
        c.close()

        self.conn.reconfigure('statistics=(all,clear)')
        c = self.session.open_cursor(
            'statistics:' + self.uri, None, 'statistics=(fast)')
        self.assertEqual(c[stat.dsrc.cache_state_root_size][2], 0)
        c.close()

        self.conn.reconfigure('statistics=(cache_walk,fast,clear)')
        c = self.session.open_cursor('statistics:' + self.uri, None, None)
        self.assertGreater(c[stat.dsrc.cache_state_root_size][2], 0)
        # Verify that cache_walk didn't imply tree_walk
        self.assertEqual(c[stat.dsrc.btree_entries][2], 0)
        c.close()

        self.conn.reconfigure('statistics=(cache_walk,tree_walk,fast,clear)')
        c = self.session.open_cursor('statistics:' + self.uri, None, None)
        self.assertGreater(c[stat.dsrc.cache_state_root_size][2], 0)
        # Verify that cache_walk didn't exclude tree_walk
        self.assertGreater(c[stat.dsrc.btree_entries][2], 0)
        c.close()

        self.conn.reconfigure('statistics=(all,clear)')
        c = self.session.open_cursor(
            'statistics:' + self.uri, None, 'statistics=(all)')
        self.assertGreater(c[stat.dsrc.cache_state_root_size][2], 0)
        self.assertGreater(c[stat.dsrc.btree_entries][2], 0)
        c.close()

        # Verify that cache and tree walk can operate independently
        self.conn.reconfigure('statistics=(all,clear)')
        c = self.session.open_cursor(
            'statistics:' + self.uri, None, 'statistics=(cache_walk,fast)')
        self.assertGreater(c[stat.dsrc.cache_state_root_size][2], 0)
        self.assertEqual(c[stat.dsrc.btree_entries][2], 0)
        c.close()

        self.conn.reconfigure('statistics=(all,clear)')
        c = self.session.open_cursor(
            'statistics:' + self.uri, None, 'statistics=(tree_walk,fast)')
        # Don't check the cache walk stats for empty - they won't be cleared
        self.assertGreater(c[stat.dsrc.btree_entries][2], 0)
        c.close()

if __name__ == '__main__':
    wttest.run()
