def main()

in mssqlscripter/main.py [0:0]

• 66 lines of code
• 19 McCabe index (conditional complexity)

def main(args):
    """
        Main entry point to mssql-scripter.
    """
    scripterlogging.initialize_logger()
    logger.info('Python Information :{}'.format(sys.version_info))
    logger.info('System Information: system={} architecture={} version={}'.format(platform.system(), platform.architecture()[0], platform.version()))

    parameters = parser.parse_arguments(args)
    scrubbed_parameters = copy.deepcopy(parameters)

    try:
        scrubbed_parameters.ConnectionString = '*******'
        scrubbed_parameters.Password = '********'
    except AttributeError:
        # Password was not given, using integrated auth.
        pass

    logger.info(scrubbed_parameters)

    temp_file_path = None

    if not parameters.FilePath and parameters.ScriptDestination == 'ToSingleFile':
        # Generate and track the temp file.
        temp_file_path = tempfile.NamedTemporaryFile(
            prefix=u'mssqlscripter_', delete=False).name
        parameters.FilePath = temp_file_path

    sqltoolsservice_args = [mssqltoolsservice.get_executable_path()]

    if parameters.EnableLogging:
        sqltoolsservice_args.append('--enable-logging')
        sqltoolsservice_args.append('--log-dir')
        sqltoolsservice_args.append(scripterlogging.get_config_log_dir())

    logger.debug('Loading mssqltoolsservice with arguments {}'.format(sqltoolsservice_args))
    try:
        # Start mssqltoolsservice program.
        tools_service_process = subprocess.Popen(
            sqltoolsservice_args,
            bufsize=0,
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE)

        # Python 2.7 uses the built-in File type when referencing the subprocess.PIPE.
        # This built-in type for that version blocks on readinto() because it attempts to fill buffer.
        # Wrap a FileIO around it to use a different implementation that does not attempt to fill the buffer
        # on readinto().
        std_out_wrapped = io.open(
            tools_service_process.stdout.fileno(),
            u'rb',
            buffering=0,
            closefd=False)

        sql_tools_client = sqltoolsclient.SqlToolsClient(
            tools_service_process.stdin,
            std_out_wrapped)

        scripting_request = sql_tools_client.create_request(
            u'scripting_request', vars(parameters))
        scripting_request.execute()

        while not scripting_request.completed():
            response = scripting_request.get_response()
            if response:
                scriptercallbacks.handle_response(response, parameters.DisplayProgress)
            else:
                # The sleep prevents burning up the CPU and lets other threads get scheduled.
                time.sleep(0.1)

        # Only write to stdout if user did not provide a file path.
        logger.info('stdout current encoding: {}'.format(sys.stdout.encoding))
        if temp_file_path:
            with io.open(parameters.FilePath, encoding=u'utf-8') as script_file:
                for line in script_file.readlines():
                    sys.stdout.write(line)

    finally:
        if sql_tools_client:
            sql_tools_client.shutdown()

        if tools_service_process:
            tools_service_process.kill()
            # 1 second time out, allow tools service process to be killed.
            time.sleep(.1)
            # Close the stdout file handle or else we would get a resource warning (found via pytest).
            # This must be closed after the process is killed, otherwise we would block because the process is using
            # it's stdout.
            tools_service_process.stdout.close()
            # None value indicates process has not terminated.
            if not tools_service_process.poll():
                sys.stderr.write(
                    u'Sql Tools Service process was not shut down properly.')
        try:
            # Remove the temp file if we generated one.
            if temp_file_path:
                os.remove(temp_file_path)
        except Exception:
            # Suppress exceptions.
            pass