Beispiel #1
0
def is_product_key_valid(product_key, config=DEFAULT_CONFIG):
    """
    Validate the product key passed in by launching local server process.

    @param key to validate
    @return True if validates correctly, False otherwise

    Raises a RuntimeError if the unity_server binary cannot be executed.
    """
    try:
        cmd = "%s --help" % (config.server_bin)
        subprocess.check_call(cmd,
                              stderr=subprocess.PIPE,
                              stdout=subprocess.PIPE,
                              env=_sys_util.make_unity_server_env(),
                              shell=True)
    except:
        raise RuntimeError("Cannot execute unity_server binary")

    try:
        cmd = "%s --check_product_key_only --product_key='%s'" % (
            config.server_bin, product_key)
        subprocess.check_output(cmd,
                                env=_sys_util.make_unity_server_env(),
                                shell=True)
        return True
    except Exception as e:
        __LOGGER__.debug(config)
        __LOGGER__.debug(e)
        pass

    return False
Beispiel #2
0
def is_product_key_valid(product_key, config=DEFAULT_CONFIG):
    """
    Validate the product key passed in by launching local server process.

    @param key to validate
    @return True if validates correctly, False otherwise

    Raises a RuntimeError if the unity_server binary cannot be executed.
    """
    try:
        cmd = "%s --help" % (config.server_bin)
        subprocess.check_call(cmd, stderr=subprocess.PIPE, stdout=subprocess.PIPE, env=_sys_util.make_unity_server_env(), shell=True)
    except:
        raise RuntimeError("Cannot execute unity_server binary")

    try:
        cmd = "%s --check_product_key_only" % config.server_bin
        if product_key:
            cmd +=  " --product_key='%s'" % product_key
        subprocess.check_output(cmd, env=_sys_util.make_unity_server_env(), shell=True)
        return True
    except Exception as e:
        __LOGGER__.debug(config)
        __LOGGER__.debug(e)
        pass

    return False
Beispiel #3
0
def _is_product_key_valid(product_key, license_info, config=_DEFAULT_CONFIG):
    """
    Validate the product key passed in by launching local server process.

    @param key to validate
    @return True if validates correctly, False otherwise

    Raises a RuntimeError if the unity_server binary cannot be executed.
    """

    import graphlab.connect as _mt
    now = int(_time.mktime(_datetime.datetime.utcnow().timetuple()))
    properties = {'timestamp': now}
    try:
        cmd = "\"%s\" --help" % (config.server_bin)
        import os
        nulldevice = open(os.devnull)
        _subprocess.check_call(cmd, stderr=nulldevice, stdout=nulldevice, env=_sys_util.make_unity_server_env(), shell=True)
    except:
        _mt._get_metric_tracker().track('is_product_key_valid.unity_server_error', properties=properties)
        raise RuntimeError("Cannot execute unity_server binary")

    # return false if there is no license_info
    if product_key is None or license_info is None:
        _mt._get_metric_tracker().track('is_product_key_valid.missing', properties=properties)
        return False

    try:
        cmd = "\"%s\" --check_product_key_only" % config.server_bin
        if product_key:
            cmd +=  " --product_key=%s" % product_key
        if license_info:
            cmd +=  " --license_info=%s" % license_info
        msg = _subprocess.check_output(cmd, stderr=_subprocess.STDOUT, env=_sys_util.make_unity_server_env(), shell=True)
        __LOGGER__.info(msg)
        _mt._get_metric_tracker().track('is_product_key_valid.succeeded', properties=properties)
        return True
    except _subprocess.CalledProcessError as e:
        __LOGGER__.error(e.output)
        _mt._get_metric_tracker().track('is_product_key_valid.failed', properties=properties)
    except Exception as e:
        __LOGGER__.debug(config)
        __LOGGER__.debug(e)
        _mt._get_metric_tracker().track('is_product_key_valid.unexpected_exception', properties=properties)

    return False
def _verify_engine_binary(server_bin):
    try:
        cmd = "\"%s\" --help" % (server_bin)
        # check_output allows us to view the output from the subprocess on
        # failure. In this case, we don't care what the output is if it
        # succeeds.
        _subprocess.check_output(cmd, stderr=_subprocess.STDOUT,
                env=_sys_util.make_unity_server_env(), shell=True)
    except _subprocess.CalledProcessError as e:
        _get_metric_tracker().track('is_product_key_valid.unity_server_error')
        __LOGGER__.error(\
                'unity_server launched with command (%s) failed \nreturn code: %d\nmessage: %s' %
                (e.cmd, e.returncode, e.output))
    except Exception as e:
        #TODO: When will this throw?
        _get_metric_tracker().track('is_product_key_valid.unity_server_error')
        raise
def _is_product_key_valid(product_key, license_info, config=_DEFAULT_CONFIG):
    """
    Validate the product key passed in by launching local server process.

    @param key to validate
    @return True if validates correctly, False otherwise

    Raises a RuntimeError if the unity_server binary cannot be executed.
    """

    # Record the system time when validating the product key. This could help
    # us identify a license validation failure due to clock skew between the
    # local system and our license server.
    import graphlab.connect as _mt
    now = int(_time.mktime(_datetime.datetime.utcnow().timetuple()))
    properties = {'timestamp': now}

    # return false if there is no license_info
    if product_key is None or license_info is None:
        _mt._get_metric_tracker().track('is_product_key_valid.missing', properties=properties)
        return False

    try:
        cmd = "\"%s\" --check_product_key_only" % config.server_bin
        if product_key:
            cmd +=  " --product_key=%s" % product_key
        if license_info:
            cmd +=  " --license_info=%s" % license_info
        msg = _subprocess.check_output(cmd, stderr=_subprocess.STDOUT, env=_sys_util.make_unity_server_env(), shell=True)
        __LOGGER__.info(msg)
        _mt._get_metric_tracker().track('is_product_key_valid.succeeded', properties=properties)
        return True
    except _subprocess.CalledProcessError as e:
        __LOGGER__.error(e.output)
        _mt._get_metric_tracker().track('is_product_key_valid.failed', properties=properties)
    except Exception as e:
        __LOGGER__.debug(config)
        __LOGGER__.debug(e)
        _mt._get_metric_tracker().track('is_product_key_valid.unexpected_exception', properties=properties)

    return False
    def start(self, num_tolerable_ping_failures=4294967295):
        properties = dict(product_key=self.product_key)
        _get_metric_tracker().track("engine-started", value=1, properties=properties, send_sys_info=True)
        _get_metric_tracker().track("engine-started-local", value=1)

        arglist = [self.server_bin, self.server_addr]

        if self.product_key:
            arglist.append("--product_key=%s" % self.product_key)

        if self.auth_token:
            arglist.append("--auth_token=%s" % self.auth_token)

        if self.secret_key != "":
            arglist.append("--secret_key=%s" % self.secret_key)

        arglist.append("--log_file=%s" % self.unity_log)
        arglist.append("--log_rotation_interval=%d" % default_local_conf.log_rotation_interval)
        arglist.append("--log_rotation_truncate=%d" % default_local_conf.log_rotation_truncate)

        self._validate_protocol_and_address()

        if sys.platform == "win32":
            self.unity_log += ".0"

        # Start a local server as a child process.
        try:
            FNULL = open(os.devnull, "w")
            if sys.platform == "win32":
                self.proc = subprocess.Popen(
                    arglist,
                    env=_sys_util.make_unity_server_env(),
                    stdin=subprocess.PIPE,
                    stdout=FNULL,
                    stderr=None,
                    bufsize=-1,
                )  # preexec_fn not supported on windows
            else:
                self.proc = subprocess.Popen(
                    arglist,
                    env=_sys_util.make_unity_server_env(),
                    stdin=subprocess.PIPE,
                    stdout=FNULL,
                    stderr=None,
                    bufsize=-1,
                    preexec_fn=lambda: os.setpgrp(),
                )  # do not forward signal
        except OSError as e:
            raise RuntimeError('Invalid server binary "%s": %s' % (self.server_bin, str(e)))
        except KeyError as e:
            raise RuntimeError(e.message)

        # update the default server_addr
        if self.server_addr == "default":
            self.server_addr = "ipc:///tmp/graphlab_server-%s" % (self.proc.pid)

        self.logger.info(
            "Start server at: " + self.server_addr + " - "
            "Server binary: " + self.server_bin + " - "
            "Server log: " + self.unity_log
        )

        # try to establish a connection to the server.
        (client_public_key, client_secret_key) = ("", "")
        if self.public_key != "" and self.secret_key != "":
            (client_public_key, client_secret_key) = get_public_secret_key_pair()

        max_retry = 5
        retry = 0
        server_alive = True
        while retry < max_retry:
            retry += 1
            # Make sure the server process is still alive
            if self.proc.poll() is not None:
                server_alive = False

            # OK, server is alive, try create a client and connect
            if server_alive:
                try:
                    c = Client(
                        [],
                        self.server_addr,
                        num_tolerable_ping_failures,
                        public_key=client_public_key,
                        secret_key=client_secret_key,
                        server_public_key=self.public_key,
                    )
                    if self.auth_token:
                        c.add_auth_method_token(self.auth_token)
                    c.set_server_alive_watch_pid(self.proc.pid)
                    c.start()
                    # everything works, break out of the retry loop
                    break
                except Exception as e:
                    self.logger.error("Try connecting to server. Error: %s. Retry = %d" % (str(e), retry))
                    time.sleep(0.5)
                finally:
                    c.stop()
            # Server process terminated, raise exception and get the return code
            else:
                retcode = self.proc.returncode
                self.proc = None
                self.logger.error("Cannot start server process. Return code: %d" % retcode)
                raise RuntimeError("Cannot start server process. Return code: %d" % retcode)

        if retry == max_retry:
            self.logger.error("Cannot connect to server. Exceeded max retry (%d)." % max_retry)
            raise RuntimeError("Cannot connect to server. Exceeded max retry (%d)." % max_retry)

        import threading

        def server_wait():
            self.proc.wait()

        self.wait_thread = threading.Thread(target=server_wait)
        self.wait_thread.setDaemon(True)
        self.wait_thread.start()
Beispiel #7
0
    def start(self, num_tolerable_ping_failures=3):
        properties = dict(product_key=self.product_key)
        _get_metric_tracker().track('engine-started',
                                    value=1,
                                    properties=properties,
                                    send_sys_info=True)
        _get_metric_tracker().track('engine-started-local', value=1)

        product_key_arg = "--product_key=%s" % self.product_key

        arglist = [self.server_bin, self.server_addr, product_key_arg]
        if (self.auth_token):
            arglist.append("--auth_token=%s" % self.auth_token)

        if self.secret_key != '':
            arglist.append("--secret_key=%s" % self.secret_key)

        arglist.append("--log_file=%s" % self.unity_log)
        arglist.append("--log_rotation_interval=%d" %
                       default_local_conf.log_rotation_interval)
        arglist.append("--log_rotation_truncate=%d" %
                       default_local_conf.log_rotation_truncate)

        # Start a local server as a child process.
        if self.server_addr == 'default':
            protocol = 'ipc'
        else:
            protocol = _get_server_addr_protocol(self.server_addr)
            if (protocol is "ipc" and os.path.exists(self.server_addr[6:])):
                raise RuntimeError(
                    'Cannot start local server: local address %s already exists'
                    % self.server_addr)
        try:
            FNULL = open(os.devnull, 'w')
            self.proc = subprocess.Popen(
                arglist,
                env=_sys_util.make_unity_server_env(),
                stdin=subprocess.PIPE,
                stdout=FNULL,
                stderr=subprocess.STDOUT,
                bufsize=-1,
                preexec_fn=lambda: os.setpgrp())  # do not forward signal
        except OSError as e:
            raise RuntimeError('Invalid server binary \"%s\": %s' %
                               (self.server_bin, str(e)))
        except KeyError as e:
            raise RuntimeError(e.message)

        # update the default server_addr
        if (self.server_addr == 'default'):
            self.server_addr = 'ipc:///tmp/graphlab_server-%s' % (
                self.proc.pid)

        # sleep one sec and make sure the server is running
        time.sleep(1)
        if (self.proc.poll() is not None):
            self.proc = None
            raise RuntimeError('Unable to start local server.')
        else:
            self.logger.info('Start server at: ' + self.server_addr + " - "
                             'Server binary: ' + self.server_bin + " - "
                             'Server log: ' + self.unity_log)

        # try to establish a connection to the server.
        (client_public_key, client_secret_key) = ('', '')
        if (self.public_key != '' and self.secret_key != ''):
            (client_public_key,
             client_secret_key) = get_public_secret_key_pair()
        max_retry = 3
        retry = 0
        while retry < max_retry:
            try:
                c = Client([],
                           self.server_addr,
                           num_tolerable_ping_failures,
                           public_key=client_public_key,
                           secret_key=client_secret_key,
                           server_public_key=self.public_key)
                if self.auth_token:
                    c.add_auth_method_token(self.auth_token)
                c.start()
                break
            except Exception as e:
                retry = retry + 1
                time.sleep(0.5)
                if retry == max_retry:
                    raise e
            finally:
                c.stop()
Beispiel #8
0
    def start(self, num_tolerable_ping_failures=3):
        properties = dict(product_key=self.product_key)
        _get_metric_tracker().track('engine-started', value=1, properties=properties, send_sys_info=True)
        _get_metric_tracker().track('engine-started-local', value=1)

        arglist = [self.server_bin, self.server_addr]

        if self.product_key:
            arglist.append("--product_key=%s" % self.product_key)

        if (self.auth_token):
            arglist.append("--auth_token=%s" % self.auth_token)

        if self.secret_key != '':
            arglist.append("--secret_key=%s" % self.secret_key)

        arglist.append("--log_file=%s" % self.unity_log)
        arglist.append("--log_rotation_interval=%d" % default_local_conf.log_rotation_interval)
        arglist.append("--log_rotation_truncate=%d" % default_local_conf.log_rotation_truncate)

        # Start a local server as a child process.
        if self.server_addr == 'default':
            protocol = 'ipc'
        else:
            protocol = _get_server_addr_protocol(self.server_addr)
            if (protocol is "ipc" and os.path.exists(self.server_addr[6:])):
                raise RuntimeError('Cannot start local server: local address %s already exists' % self.server_addr)
        try:
            FNULL = open(os.devnull, 'w')
            self.proc = subprocess.Popen(arglist,
                                         env=_sys_util.make_unity_server_env(),
                                         stdin=subprocess.PIPE, stdout=FNULL,
                                         stderr=subprocess.STDOUT, bufsize=-1,
                                         preexec_fn=lambda: os.setpgrp())  # do not forward signal
        except OSError as e:
            raise RuntimeError('Invalid server binary \"%s\": %s' % (self.server_bin, str(e)))
        except KeyError as e:
            raise RuntimeError(e.message)

        # update the default server_addr
        if (self.server_addr == 'default'):
            self.server_addr = 'ipc:///tmp/graphlab_server-%s' % (self.proc.pid)

        # sleep one sec and make sure the server is running
        time.sleep(1)
        if (self.proc.poll() is not None):
            self.proc = None
            raise RuntimeError('Unable to start local server.')
        else:
            self.logger.info('Start server at: ' + self.server_addr + " - "
                             'Server binary: ' + self.server_bin + " - "
                             'Server log: ' + self.unity_log)

        # try to establish a connection to the server.
        (client_public_key, client_secret_key) = ('', '')
        if (self.public_key != '' and self.secret_key != ''):
            (client_public_key, client_secret_key) = get_public_secret_key_pair()
        max_retry = 3
        retry = 0
        while retry < max_retry:
            try:
                c = Client([], self.server_addr, num_tolerable_ping_failures,
                           public_key=client_public_key, secret_key=client_secret_key,
                           server_public_key=self.public_key)
                if self.auth_token:
                    c.add_auth_method_token(self.auth_token)
                c.start()
                break
            except Exception as e:
                retry = retry + 1
                time.sleep(0.5)
                if retry == max_retry:
                    raise e
            finally:
                c.stop()