Exemplo n.º 1
0
    def do_describe(self, parsed):
        what = parsed.matched[1][1].lower()

        if (what == 'active' or what == 'pending') and parsed.matched[2][1].lower() == 'search' and parsed.matched[3][1].lower() == 'index':
            resource = parsed.matched[4][1].lower()
            ks = self.cql_unprotect_name(parsed.get_binding('ksname', None))
            cf = self.cql_unprotect_name(parsed.get_binding('cfname'))
            self.describe_search_resource(ks, cf, what, resource)
        else:
            OriginalShell.do_describe(self, parsed)
Exemplo n.º 2
0
    def _start_cql(self):
        c = Cluster([self.hostname])
        self.cqlshell = Shell("127.0.0.1", 9042, use_conn=c)
        self.cqlshell.use_paging = False
        self.outStringWriter = StringIO.StringIO()
        self.cqlshell.query_out = self.outStringWriter
        self.cqlshell.stdout = self.outStringWriter

        cqlsh.setup_cqlruleset(cql3handling)
        cqlsh.setup_cqldocs(cql3handling)

        # cql3handling
        pass
Exemplo n.º 3
0
    def perform_simple_statement(self, statement):
        if not statement:
            return False, None

        default_timeout = self.execution_profile.request_timeout

        # Boost the session timeout for any search core management statements
        statement_prefix = " ".join(statement.query_string.lower().split())
        if (default_timeout is not None
                and default_timeout == cqlsh.DEFAULT_REQUEST_TIMEOUT_SECONDS
                and (statement_prefix.startswith("create search index")
                     or statement_prefix.startswith("alter search index")
                     or statement_prefix.startswith("reload search index")
                     or statement_prefix.startswith("rebuild search index")
                     or statement_prefix.startswith("commit search index")
                     or statement_prefix.startswith("drop search index"))):
            self.execution_profile.request_timeout = core_management_timeout

        success, future = OriginalShell.perform_simple_statement(
            self, statement)

        # reset timeout to its original value
        self.execution_profile.request_timeout = default_timeout

        return success, future
Exemplo n.º 4
0
    def _start_cql(self):
        c = Cluster([self.hostname])
        self.cqlshell = Shell("127.0.0.1", 9042, use_conn = c )
        self.cqlshell.use_paging = False
        self.outStringWriter = StringIO.StringIO()
        self.cqlshell.query_out = self.outStringWriter
        self.cqlshell.stdout = self.outStringWriter

        cqlsh.setup_cqlruleset(cql3handling)
        cqlsh.setup_cqldocs(cql3handling)

        # cql3handling
        pass
Exemplo n.º 5
0
class CQLKernel(Kernel):
    implementation = 'cql_kernel'
    implementation_version = __version__

    @property
    def language_version(self):
        m = version_pat.search(self.banner)
        return m.group(1)

    _banner = None

    # TODO
    @property
    def banner(self):
        # if self._banner is None:
        #     self._banner = check_output(['CQL', '--version']).decode('utf-8')
        # Todo get right version

        self._banner = "CQL Version x"
        return self._banner

    language_info = {
        'name': 'CQL',
        'codemirror_mode': 'sql',
        'mimetype': 'text/x-cassandra',
        'file_extension': '.cql'
    }

    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        self.hostname = os.environ.get('CASSANDRA_HOSTNAME', 'localhost')
        self._start_cql()

    def _start_cql(self):
        c = Cluster([self.hostname])
        self.cqlshell = Shell("127.0.0.1", 9042, use_conn=c)
        self.cqlshell.use_paging = False
        self.outStringWriter = StringIO.StringIO()
        self.cqlshell.query_out = self.outStringWriter
        self.cqlshell.stdout = self.outStringWriter

        cqlsh.setup_cqlruleset(cql3handling)
        cqlsh.setup_cqldocs(cql3handling)

        # cql3handling
        pass

    def do_execute(self,
                   code,
                   silent,
                   store_history=True,
                   user_expressions=None,
                   allow_stdin=False):

        cleanCode = code.strip()

        if not cleanCode:
            return {
                'status': 'ok',
                'execution_count': self.execution_count,
                'payload': [],
                'user_expressions': {}
            }

        if cleanCode[-1] != ';':
            cleanCode += ";"

        self.outStringWriter.truncate(0)

        old_stdout = sys.stdout
        old_stderr = sys.stderr
        sys.stdout = self.outStringWriter
        sys.stderr = self.outStringWriter

        self.cqlshell.onecmd(cleanCode)

        sys.stdout = old_stdout
        sys.stderr = old_stderr

        if not silent:

            outputStr = self.outStringWriter.getvalue().strip()

            #Format desc commands with codemirror (cool feature)

            if code.strip()[:4] == 'desc':
                outputStr = '<script>var x = CodeMirror.fromTextArea(document.getElementById("desc%d"), {readOnly: true, mode:"text/x-cassandra"} )</script><textarea id="desc%d">%s</textarea>' % (
                    self.execution_count, self.execution_count, outputStr)

            # CQL rows come back as HTML

            if outputStr[:1] == '<':
                mime_type = 'text/html'
            else:
                mime_type = 'text/plain'

            stream_content = {
                'execution_count': self.execution_count,
                'data': {
                    mime_type: outputStr
                }
            }

            self.send_response(self.iopub_socket, 'execute_result',
                               stream_content)

        # if exitcode:
        #     return {'status': 'error', 'execution_count': self.execution_count,
        #             'ename': '', 'evalue': str(exitcode), 'traceback': []}
        # else:

        return {
            'status': 'ok',
            'execution_count': self.execution_count,
            'payload': [],
            'user_expressions': {}
        }

    def do_complete(self, code, cursor_pos):
        code = code[:cursor_pos]

        default = {
            'matches': [],
            'cursor_start': 0,
            'cursor_end': cursor_pos,
            'metadata': dict(),
            'status': 'ok'
        }

        # if not code or code[-1] == ' ':
        #     return default
        #

        if code[-1:] in ('.', '(', '<'):
            completed = code
            partial = ''
        else:
            index = code.rfind(' ')
            completed = code[:index + 1]
            partial = code[index + 1:]

        matches = cql3handling.CqlRuleSet.cql_complete(
            completed,
            partial,
            cassandra_conn=self.cqlshell,
            startsymbol='cqlshCommand')

        if not matches:
            return default

        tokens = code.replace(';', ' ').split()
        if not tokens:
            return default

        return {
            'matches': sorted(matches),
            'cursor_start': cursor_pos - len(partial),
            'cursor_end': cursor_pos,
            'metadata': dict(),
            'status': 'ok'
        }
Exemplo n.º 6
0
    def __init__(self,
                 hostname,
                 port,
                 color=False,
                 username=None,
                 password=None,
                 encoding=None,
                 stdin=None,
                 tty=True,
                 completekey=cqlsh.DEFAULT_COMPLETEKEY,
                 browser=None,
                 use_conn=None,
                 cqlver=None,
                 keyspace=None,
                 tracing_enabled=False,
                 expand_enabled=False,
                 no_compact=False,
                 display_nanotime_format=cqlsh.DEFAULT_NANOTIME_FORMAT,
                 display_timestamp_format=cqlsh.DEFAULT_TIMESTAMP_FORMAT,
                 display_date_format=cqlsh.DEFAULT_DATE_FORMAT,
                 display_float_precision=cqlsh.DEFAULT_FLOAT_PRECISION,
                 display_double_precision=cqlsh.DEFAULT_DOUBLE_PRECISION,
                 display_timezone=None,
                 max_trace_wait=cqlsh.DEFAULT_MAX_TRACE_WAIT,
                 ssl=False,
                 single_statement=None,
                 request_timeout=cqlsh.DEFAULT_REQUEST_TIMEOUT_SECONDS,
                 protocol_version=None,
                 connect_timeout=cqlsh.DEFAULT_CONNECT_TIMEOUT_SECONDS,
                 no_file_io=cqlsh.DEFAULT_NO_FILE_IO,
                 is_subshell=False):
        from dselib.authfactory import get_auth_provider
        if username:
            if not password:
                password = getpass.getpass()

        auth_provider = get_auth_provider(cqlsh.CONFIG_FILE, os.environ,
                                          username, password, cqlsh.options)

        self.execute_as = None
        self.consistency_level = dse.ConsistencyLevel.ONE
        self.serial_consistency_level = dse.ConsistencyLevel.SERIAL
        conn = None

        execution_profile = ExecutionProfile(
            load_balancing_policy=WhiteListRoundRobinPolicy([hostname]),
            row_factory=ordered_dict_factory,
            request_timeout=request_timeout,
            consistency_level=self.consistency_level,
            serial_consistency_level=self.serial_consistency_level)

        self.execution_profiles = {EXEC_PROFILE_DEFAULT: execution_profile}

        if use_conn:
            conn = use_conn
        else:
            kwargs = {}
            if protocol_version is not None:
                kwargs['protocol_version'] = protocol_version

            conn = cqlsh.Cluster(
                contact_points=(hostname, ),
                port=port,
                cql_version=cqlver,
                auth_provider=auth_provider,
                ssl_options=sslhandling.ssl_settings(
                    hostname, cqlsh.CONFIG_FILE) if ssl else None,
                control_connection_timeout=connect_timeout,
                connect_timeout=connect_timeout,
                execution_profiles=self.execution_profiles,
                **kwargs)

        OriginalShell.__init__(
            self,
            hostname,
            port,
            color=color,
            auth_provider=auth_provider,
            username=username,
            password=password,
            encoding=encoding,
            stdin=stdin,
            tty=tty,
            completekey=completekey,
            browser=browser,
            use_conn=conn,
            cqlver=cqlver,
            keyspace=keyspace,
            tracing_enabled=tracing_enabled,
            expand_enabled=expand_enabled,
            no_compact=no_compact,
            display_nanotime_format=display_nanotime_format,
            display_timestamp_format=display_timestamp_format,
            display_date_format=display_date_format,
            display_float_precision=display_float_precision,
            display_double_precision=display_double_precision,
            display_timezone=display_timezone,
            max_trace_wait=max_trace_wait,
            ssl=ssl,
            single_statement=single_statement,
            request_timeout=request_timeout,
            protocol_version=protocol_version,
            connect_timeout=connect_timeout,
            no_file_io=no_file_io,
            is_subshell=is_subshell)

        self.owns_connection = not use_conn
        self.execution_profile = self.session.get_execution_profile(
            EXEC_PROFILE_DEFAULT)
Exemplo n.º 7
0
class CQLKernel(Kernel):
    implementation = 'cql_kernel'
    implementation_version = __version__


    @property
    def language_version(self):
        m = version_pat.search(self.banner)
        return m.group(1)

    _banner = None

    # TODO
    @property
    def banner(self):
        # if self._banner is None:
        #     self._banner = check_output(['CQL', '--version']).decode('utf-8')
        # Todo get right version

        self._banner = "CQL Version x"
        return self._banner

    language_info = {'name': 'CQL',
                     'codemirror_mode': 'sql',
                     'mimetype': 'text/x-cassandra',
                     'file_extension': '.cql'}

    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        self.hostname = os.environ.get('CASSANDRA_HOSTNAME','localhost')
        self._start_cql()


    def _start_cql(self):
        c = Cluster([self.hostname])
        self.cqlshell = Shell("127.0.0.1", 9042, use_conn = c )
        self.cqlshell.use_paging = False
        self.outStringWriter = StringIO.StringIO()
        self.cqlshell.query_out = self.outStringWriter
        self.cqlshell.stdout = self.outStringWriter

        cqlsh.setup_cqlruleset(cql3handling)
        cqlsh.setup_cqldocs(cql3handling)

        # cql3handling
        pass

    def do_execute(self, code, silent, store_history=True,
                   user_expressions=None, allow_stdin=False):


        cleanCode = code.strip()

        if not cleanCode:
            return {'status': 'ok', 'execution_count': self.execution_count,
                    'payload': [], 'user_expressions': {}}

        if cleanCode[-1] != ';':
            cleanCode += ";"

        self.outStringWriter.truncate(0)

        old_stdout = sys.stdout
        old_stderr = sys.stderr
        sys.stdout = self.outStringWriter
        sys.stderr = self.outStringWriter

        self.cqlshell.onecmd(cleanCode)

        sys.stdout = old_stdout
        sys.stderr = old_stderr

        if not silent:

            outputStr = self.outStringWriter.getvalue().strip()

            #Format desc commands with codemirror (cool feature)

            if code.strip()[:4] == 'desc':
                outputStr = '<script>var x = CodeMirror.fromTextArea(document.getElementById("desc%d"), {readOnly: true, mode:"text/x-cassandra"} )</script><textarea id="desc%d">%s</textarea>' % (self.execution_count, self.execution_count,outputStr)

            # CQL rows come back as HTML

            if outputStr[:1] == '<':
                mime_type = 'text/html'
            else:
                mime_type = 'text/plain'

            stream_content = {'execution_count': self.execution_count, 'data': {mime_type: outputStr}}

            self.send_response(self.iopub_socket, 'execute_result', stream_content)

        # if exitcode:
        #     return {'status': 'error', 'execution_count': self.execution_count,
        #             'ename': '', 'evalue': str(exitcode), 'traceback': []}
        # else:

        return {'status': 'ok', 'execution_count': self.execution_count,
                'payload': [], 'user_expressions': {}}

    def do_complete(self, code, cursor_pos):
        code = code[:cursor_pos]

        default = {'matches': [], 'cursor_start': 0,
                   'cursor_end': cursor_pos, 'metadata': dict(),
                   'status': 'ok'}

        # if not code or code[-1] == ' ':
        #     return default
        #

        if code[-1:] in ('.','(','<'):
            completed=code
            partial = ''
        else:
            index = code.rfind(' ')
            completed = code[:index+1]
            partial = code[index+1:]

        matches = cql3handling.CqlRuleSet.cql_complete(completed, partial, cassandra_conn=self.cqlshell,
                                                   startsymbol='cqlshCommand')

        if not matches:
            return default

        tokens = code.replace(';', ' ').split()
        if not tokens:
            return default

        return {'matches': sorted(matches), 'cursor_start': cursor_pos - len(partial),
                'cursor_end': cursor_pos, 'metadata': dict(),
                'status': 'ok'}
Exemplo n.º 8
0
    def __init__(self,
                 hostname,
                 port,
                 color=False,
                 username=None,
                 password=None,
                 encoding=None,
                 stdin=None,
                 tty=True,
                 completekey=cqlsh.DEFAULT_COMPLETEKEY,
                 browser=None,
                 use_conn=None,
                 cqlver=None,
                 keyspace=None,
                 secure_connect_bundle=None,
                 consistency_level=None,
                 serial_consistency_level=None,
                 tracing_enabled=False,
                 timing_enabled=False,
                 expand_enabled=False,
                 display_nanotime_format=cqlsh.DEFAULT_NANOTIME_FORMAT,
                 display_timestamp_format=cqlsh.DEFAULT_TIMESTAMP_FORMAT,
                 display_date_format=cqlsh.DEFAULT_DATE_FORMAT,
                 display_float_precision=cqlsh.DEFAULT_FLOAT_PRECISION,
                 display_double_precision=cqlsh.DEFAULT_DOUBLE_PRECISION,
                 display_timezone=None,
                 max_trace_wait=cqlsh.DEFAULT_MAX_TRACE_WAIT,
                 ssl=False,
                 single_statement=None,
                 request_timeout=cqlsh.DEFAULT_REQUEST_TIMEOUT_SECONDS,
                 protocol_version=None,
                 connect_timeout=cqlsh.DEFAULT_CONNECT_TIMEOUT_SECONDS,
                 no_file_io=cqlsh.DEFAULT_NO_FILE_IO,
                 is_subshell=False):
        from dselib.authfactory import get_auth_provider
        if username:
            if not password:
                password = getpass.getpass()

        auth_provider = get_auth_provider(cqlsh.CONFIG_FILE, os.environ, username, password, cqlsh.options) \
            if not is_unix_socket(hostname) else None

        self.execute_as = None

        if not consistency_level:
            raise Exception('Argument consistency_level must not be None')
        if not serial_consistency_level:
            raise Exception(
                'Argument serial_consistency_level must not be None')
        self.consistency_level = consistency_level
        self.serial_consistency_level = serial_consistency_level

        execution_profile = ExecutionProfile(
            row_factory=ordered_dict_factory,
            request_timeout=request_timeout,
            consistency_level=self.consistency_level,
            serial_consistency_level=self.serial_consistency_level)

        self.execution_profiles = {EXEC_PROFILE_DEFAULT: execution_profile}

        if use_conn:
            conn = use_conn
        else:
            conn = cluster_factory(
                hostname,
                port=port,
                protocol_version=protocol_version
                if protocol_version is not None else _NOT_SET,
                cql_version=cqlver,
                auth_provider=auth_provider,
                ssl_options=sslhandling.ssl_settings(
                    hostname, cqlsh.CONFIG_FILE) if ssl else None,
                control_connection_timeout=connect_timeout,
                connect_timeout=connect_timeout,
                execution_profiles=self.execution_profiles,
                secure_connect_bundle=secure_connect_bundle)

        OriginalShell.__init__(
            self,
            hostname,
            port,
            color=color,
            auth_provider=auth_provider,
            username=username,
            password=password,
            encoding=encoding,
            stdin=stdin,
            tty=tty,
            completekey=completekey,
            browser=browser,
            use_conn=conn,
            cqlver=cqlver,
            keyspace=keyspace,
            secure_connect_bundle=secure_connect_bundle,
            consistency_level=consistency_level,
            serial_consistency_level=serial_consistency_level,
            tracing_enabled=tracing_enabled,
            timing_enabled=timing_enabled,
            expand_enabled=expand_enabled,
            display_nanotime_format=display_nanotime_format,
            display_timestamp_format=display_timestamp_format,
            display_date_format=display_date_format,
            display_float_precision=display_float_precision,
            display_double_precision=display_double_precision,
            display_timezone=display_timezone,
            max_trace_wait=max_trace_wait,
            ssl=ssl,
            single_statement=single_statement,
            request_timeout=request_timeout,
            protocol_version=protocol_version,
            connect_timeout=connect_timeout,
            no_file_io=no_file_io,
            is_subshell=is_subshell)

        self.owns_connection = not use_conn
        self.execution_profile = self.session.get_execution_profile(
            EXEC_PROFILE_DEFAULT)