Exemplo n.º 1
0
    def test_cobbler_alive(self):
        """Test current installation has correctly setup cobbler

        API and cobbler HTTP server are alive

        Scenario:
            1. Revert snapshot "empty"
            2. test cobbler API and HTTP server through send http request

        Duration 1m

        """
        wait(lambda: http(host=self.env.get_admin_node_ip(),
                          url='/cobbler_api',
                          waited_code=501),
             timeout=60)
        server = ServerProxy('http://%s/cobbler_api' %
                             self.env.get_admin_node_ip())

        config = self.env.admin_actions.get_fuel_settings()
        username = config['cobbler']['user']
        password = config['cobbler']['password']

        # raises an error if something isn't right
        server.login(username, password)
Exemplo n.º 2
0
 def test_xmlrpc_server(self, uri='http://127.0.0.1:3423'):
     from six.moves.xmlrpc_client import ServerProxy
     
     client = ServerProxy(uri)
     
     assert client.test_1() == 'test_1'
     assert client.test_3({'asdf':4}) == {'asdf':4}
Exemplo n.º 3
0
def NZBConnection(url):
    """Method to connect to NZBget client

    :param url: nzb url to connect

    :return: True if connected, else False
    """
    nzbGetRPC = ServerProxy(url)
    try:
        if nzbGetRPC.writelog('INFO', 'Medusa connected to test connection.'):
            logger.log('Successful connected to NZBget', logger.DEBUG)
        else:
            logger.log('Successful connected to NZBget, but unable to send a message', logger.WARNING)
        return True

    except socket.error:
        logger.log(
            'Please check your NZBget host and port (if it is running). NZBget is not responding to this combination',
            logger.WARNING)
        return False

    except ProtocolError as e:
        if e.errmsg == 'Unauthorized':
            logger.log('NZBget username or password is incorrect.', logger.WARNING)
        else:
            logger.log('Protocol Error: ' + e.errmsg, logger.ERROR)
        return False
Exemplo n.º 4
0
    def test_cobbler_alive(self):
        """Test current installation has correctly setup cobbler

        Test disabled and move to fuel_tests suite:
            fuel_tests.test.test_admin_node.TestAdminNode

        API and cobbler HTTP server are alive

        Scenario:
            1. Revert snapshot "empty"
            2. test cobbler API and HTTP server through send http request

        Duration 1m

        """
        # pylint: disable=W0101
        warn("Test disabled and move to fuel_tests suite", DeprecationWarning)
        raise SkipTest("Test disabled and move to fuel_tests suite")

        self.env.revert_snapshot("empty")
        wait(lambda: http(host=self.env.get_admin_node_ip(),
                          url='/cobbler_api',
                          waited_code=501),
             timeout=60,
             timeout_msg='Cobler WEB API is not alive')
        server = ServerProxy('http://%s/cobbler_api' %
                             self.env.get_admin_node_ip())

        config = self.env.admin_actions.get_fuel_settings()
        username = config['cobbler']['user']
        password = config['cobbler']['password']

        # raises an error if something isn't right
        server.login(username, password)
Exemplo n.º 5
0
    def test_cobbler_alive(self):
        """Test current installation has correctly setup cobbler

        API and cobbler HTTP server are alive

        Scenario:
            1. Revert snapshot "empty"
            2. test cobbler API and HTTP server through send http request

        Duration 1m

        """
        wait(
            lambda: http(host=self.env.get_admin_node_ip(), url='/cobbler_api',
                         waited_code=501),
            timeout=60
        )
        server = ServerProxy(
            'http://%s/cobbler_api' % self.env.get_admin_node_ip())

        config = self.env.admin_actions.get_fuel_settings()
        username = config['cobbler']['user']
        password = config['cobbler']['password']

        # raises an error if something isn't right
        server.login(username, password)
Exemplo n.º 6
0
    def ping (self):
        """ See if Display server present
    
        Returns True if server present

        * self      = Display object
        """
        from six.moves.xmlrpc_client import ServerProxy
        url = self.serverURL
        if url == "ObitView":
            url = "http://localhost:8765/RPC2"
        server = ServerProxy(url)
        try:
            answer = server.ping(42)
        except:
            answer = False
            pass
        else:
            pass
        if answer:
            print("Display Server "+url+" present")
            return True
        else:
            print("Display Server "+url+" NOT present")
            return False
Exemplo n.º 7
0
    def __init__(self, user=None, password=None, server=None, port=None,
                 anon=False):
        """Initialise an SR trac object."""
        config = Config()

        if server is None:
            server = config["server"]

        if port is None:
            port = config["https_port"]

        self.server = server
        self.port = port

        rpc_settings = {"server": server, "port": port}

        if anon:
            rpc_url = "https://{server}:{port}/trac/rpc"
        else:
            rpc_url = "https://{user}:{password}@{server}:{port}/trac/login" \
                      "/rpc"

            user = config.get_user(user)
            rpc_settings["user"] = user
            rpc_settings["password"] = config.get_password(password, user=user)

        rpc_url = rpc_url.format(**rpc_settings)

        ServerProxy.__init__(self, rpc_url)

        if 'ticket.create' not in self.system.listMethods():
            raise WrongServer()
Exemplo n.º 8
0
 def setUp(self):
     from .server import server, start_server
     self.server = server
     Thread(target=start_server).start()
     self.client = ServerProxy('http://localhost:8000/RPC2',
                               transport=LocustXmlRpcTransport())
     global_stats.reset_all()
Exemplo n.º 9
0
def test_server(host='localhost', port=4966):
    """Test for a Larch server on host and port

    Arguments
      host (str): host name ['localhost']
      port (int): port number [4966]

    Returns
      integer status number:
          0    Not in use.
          1    Connected, valid Larch server
          2    In use, but not a valid Larch server
    """
    server = ServerProxy('http://%s:%d' % (host, port))
    try:
        methods = server.system.listMethods()
    except socket.error:
        return NOT_IN_USE

    # verify that this is a valid larch server
    if len(methods) < 5 or 'larch' not in methods:
        return NOT_LARCHSERVER
    ret = ''
    try:
        ret = server.get_rawdata('_sys.config.user_larchdir')
    except:
        return NOT_LARCHSERVER
    if len(ret) < 1:
        return NOT_LARCHSERVER

    return CONNECTED
Exemplo n.º 10
0
def NZBConnection(url):
    """Method to connect to NZBget client

    :param url: nzb url to connect
    :return: True if connected, else False
    """
    nzbGetRPC = ServerProxy(url)
    try:
        if nzbGetRPC.writelog('INFO', 'Medusa connected to test connection.'):
            log.debug('Successfully connected to NZBget')
        else:
            log.warning('Successfully connected to NZBget but unable to'
                        ' send a message')
        return True

    except socket.error:
        log.warning('Please check your NZBget host and port (if it is'
                    ' running). NZBget is not responding to this combination')
        return False

    except ProtocolError as e:
        if e.errmsg == 'Unauthorized':
            log.warning('NZBget username or password is incorrect.')
        else:
            log.error('Protocol Error: {msg}', {'msg': e.errmsg})
        return False
Exemplo n.º 11
0
 def test_xmlrpc_server(self, uri='http://127.0.0.1:3423'):
     from six.moves.xmlrpc_client import ServerProxy
     
     client = ServerProxy(uri)
     
     assert client.test_1() == 'test_1'
     assert client.test_3({'asdf':4}) == {'asdf':4}
Exemplo n.º 12
0
    def test_cobbler_alive(self):
        """Test current installation has correctly setup cobbler

        Test disabled and move to fuel_tests suite:
            fuel_tests.test.test_admin_node.TestAdminNode

        API and cobbler HTTP server are alive

        Scenario:
            1. Revert snapshot "empty"
            2. test cobbler API and HTTP server through send http request

        Duration 1m

        """
        # pylint: disable=W0101
        warn("Test disabled and move to fuel_tests suite", DeprecationWarning)
        raise SkipTest("Test disabled and move to fuel_tests suite")

        self.env.revert_snapshot("empty")
        wait(
            lambda: http(host=self.env.get_admin_node_ip(), url="/cobbler_api", waited_code=501),
            timeout=60,
            timeout_msg="Cobler WEB API is not alive",
        )
        server = ServerProxy("http://%s/cobbler_api" % self.env.get_admin_node_ip())

        config = self.env.admin_actions.get_fuel_settings()
        username = config["cobbler"]["user"]
        password = config["cobbler"]["password"]

        # raises an error if something isn't right
        server.login(username, password)
Exemplo n.º 13
0
def test_server(host='localhost', port=4966):
    """Test for a Larch server on host and port

    Arguments
      host (str): host name ['localhost']
      port (int): port number [4966]

    Returns
      integer status number:
          0    Not in use.
          1    Connected, valid Larch server
          2    In use, but not a valid Larch server
    """
    server = ServerProxy('http://%s:%d' % (host, port))
    try:
        methods = server.system.listMethods()
    except socket.error:
        return NOT_IN_USE

    # verify that this is a valid larch server
    if len(methods) < 5 or 'larch' not in methods:
        return NOT_LARCHSERVER
    ret = ''
    try:
        ret = server.get_rawdata('_sys.config.user_larchdir')
    except:
        return NOT_LARCHSERVER
    if len(ret) < 1:
        return NOT_LARCHSERVER

    return CONNECTED
Exemplo n.º 14
0
 def __init__(self, username=None, password=None):
     self.server = ServerProxy('https://api.opensubtitles.org/xml-rpc', TimeoutSafeTransport(10))
     if username and not password or not username and password:
         raise ConfigurationError('Username and password must be specified')
     # None values not allowed for logging in, so replace it by ''
     self.username = username or ''
     self.password = password or ''
     self.token = None
Exemplo n.º 15
0
 def __init__(self, sock_path):
     # We can't pass funny characters in the host part of a URL, so we
     # encode the socket path in base16.
     ServerProxy.__init__(self,
                          'http://' +
                          base64.b16encode(sock_path.encode('utf-8')),
                          transport=UnixXmlRpcTransport(),
                          allow_none=1)
Exemplo n.º 16
0
 def __init__(self, username=None, password=None):
     self.server = ServerProxy(self.server_url, TimeoutSafeTransport(10))
     if any((username, password)) and not all((username, password)):
         raise ConfigurationError('Username and password must be specified')
     # None values not allowed for logging in, so replace it by ''
     self.username = username or ''
     self.password = password or ''
     self.token = None
Exemplo n.º 17
0
    def __init__(self, configuration=None, name=None):
        SimpleService.__init__(self, configuration=configuration, name=name)
        self.order = ORDER
        self.definitions = CHARTS
        self.host = self.configuration.get(CONF_PARAM_HOST, DEFAULT_HOST)

        try:
            self.server = ServerProxy(self.host, allow_none=True)
        except:
            self.server = None
Exemplo n.º 18
0
class RobotListener:

    ROBOT_LISTENER_API_VERSION = 2

    def __init__(self):
        server_listener_address = 'http://%s:%s' % (
            LISTENER_HOST, LISTENER_PORT)
        self.server = ServerProxy(server_listener_address)

    def start_test(self, name, attrs):
        self.server.zodb_setup()

    def end_test(self, name, attrs):
        self.server.zodb_teardown()
Exemplo n.º 19
0
    def _ensure_login(self):
        """
        Ensure that the server is opened
        :return:
        :rtype:
        """
        if self.server is None:
            self.server = ServerProxy('https://api.opensubtitles.org/xml-rpc',
                                      TimeoutSafeTransport(100))

            self.logger.info('Logging in')
            response = checked(self.server.LogIn('', '', 'eng', 'subfind v1'))
            self.token = response['token']
            self.logger.debug('Logged in with token %r', self.token)
Exemplo n.º 20
0
def create_proxy(url):
    parsed = urlsplit(url)
    proto = url.split(':')[0].lower()
    if proto == 'scgi':
        if parsed.netloc:
            url = 'http://%s' % parsed.netloc
            logger.debug('Creating SCGI XMLRPC Proxy with url %r' % url)
            return ServerProxy(url, transport=SCGITransport())
        else:
            path = parsed.path
            logger.debug('Creating SCGI XMLRPC Socket Proxy with socket file %r' % path)
            return ServerProxy('http://1', transport=SCGITransport(socket_path=path))
    else:
        logger.debug('Creating Normal XMLRPC Proxy with url %r' % url)
        return ServerProxy(url)
Exemplo n.º 21
0
 def proxy(self):
     """Return the proxy through which this FITS disk can be
        accessed."""
     if self.url:
         return ServerProxy(self.url)
     else:
         return LocalProxy
Exemplo n.º 22
0
 def abort(self):
     """ Abort task
     """
     #print "in abort"
     if self.done:
         return
     # Abort task
     self.myTask.abort(self.proxy, self.tid)
     self.done = True
     
     # Update message window
     server = ServerProxy(self.url)
     arg = {"taskID":self.taskID, "message":"Task Aborted\n"}
     answer = server.DisplayMessage(arg)
     arg = {"taskID":self.taskID, "status":"Task Aborted"}
     answer = server.SetStatus(arg)
Exemplo n.º 23
0
def available_on_pypi(prerelease=current_version.is_prerelease):
    """Return True if an update is available on PyPI.

    >>> available_on_pypi() # doctest: +ELLIPSIS
    <Version('...')>
    >>> available_on_pypi(prerelease=False).is_prerelease
    False
    """
    client = ServerProxy('https://pypi.python.org/pypi')
    versions = client.package_releases('pwntools', True)
    versions = map(packaging.version.Version, versions)

    if not prerelease:
        versions = filter(lambda v: not v.is_prerelease, versions)

    return max(versions)
Exemplo n.º 24
0
 def __getattr__(self, name):
     allnames = dir(self)
     if allnames and name not in allnames:
         raise AttributeError(name)
     method = ServerProxy.__getattr__(self, name)
     # `method` has private __name, so pass it as extra arg to wrapper:
     return XMLRPCMethod(name, method, client=self)
Exemplo n.º 25
0
    def test_sleep(self):
        client = ServerProxy('http://localhost:%d/RPC2' % SERVERPORT,
                             allow_none=True)

        start = time()
        client.sleep(0.1)
        end = time()
        delta = end - start

        dummy_log(local().current)

        self.assertGreater(delta, 0.101)

        traces = DummyClient._client.messages
        self.assertEqual(
            len(traces), 1, "There should be one trace for "
            "the request just processed")
Exemplo n.º 26
0
 def __init__(self, username=None, password=None):
     self.server = ServerProxy('https://api.opensubtitles.org/xml-rpc', TimeoutSafeTransport(10))
     if username and not password or not username and password:
         raise ConfigurationError('Username and password must be specified')
     # None values not allowed for logging in, so replace it by ''
     self.username = username or ''
     self.password = password or ''
     self.token = None
Exemplo n.º 27
0
 def _errata_service(self):
     # XML-RPC client connected to errata_service.
     # Each thread uses a separate client.
     if not hasattr(self._tls, "errata_service"):
         url = self._errata_service_url
         LOG.debug("Creating XML-RPC client for Errata Tool: %s", url)
         self._tls.errata_service = ServerProxy(url)
     return self._tls.errata_service
Exemplo n.º 28
0
    def convert(self, key):
        in_fn = "data/{}.blob".format(key)
        in_mime_type = open("data/{}.mime".format(key)).read()
        file_extension = mimetypes.guess_extension(in_mime_type).strip(".")

        data = b64encode(open(in_fn, "rb").read())
        proxy = ServerProxy(self.SERVER_URL, allow_none=True)

        if in_mime_type.startswith("application/vnd.oasis.opendocument"):
            data = proxy.convertFile(data, file_extension, "pdf")
        else:
            pivot_format = self.pivot_format_map[file_extension]
            data = proxy.convertFile(data, file_extension, pivot_format)
            data = proxy.convertFile(data, pivot_format, "pdf")

        converted = b64decode(data)
        new_key = hashlib.md5(converted).hexdigest()
        with open("data/{}.blob".format(new_key), "wb") as fd:
            fd.write(converted)
        return new_key
Exemplo n.º 29
0
class TestTransport(unittest.TestCase):
    def setUp(self):
        from .server import server, start_server
        self.server = server
        Thread(target=start_server).start()
        self.client = ServerProxy('http://localhost:8000/RPC2',
                                  transport=LocustXmlRpcTransport())
        global_stats.reset_all()

    def test_returns_something(self):
        res = self.client.add(2, 2)
        self.assertEqual(res, 4)
        stats = global_stats.get('/RPC2', 'xmlrpc')
        self.assertEqual(stats.num_requests, 1)

    def test_failure(self):
        self.client.failure('01', 'Test Error')
        stats = global_stats.get('/RPC2', 'xmlrpc')
        self.assertEqual(stats.num_failures, 1)

    def test_failure_not_found(self):
        self.client.method_doesnt_exist()
        stats = global_stats.get('/RPC2', 'xmlrpc')
        self.assertEqual(stats.num_failures, 1)

    def test_delay(self):
        delayed_ms = 500
        res = self.client.delayed(delayed_ms)
        stats = global_stats.get('/RPC2', 'xmlrpc')
        self.assertEqual(res, delayed_ms)
        self.assertEqual(stats.num_requests, 1)
        self.assertGreaterEqual(stats.avg_response_time, delayed_ms)

    def tearDown(self):
        self.server.shutdown()
Exemplo n.º 30
0
def available_on_pypi(prerelease=current_version.is_prerelease):
    """Return True if an update is available on PyPI.

    >>> available_on_pypi() # doctest: +ELLIPSIS
    <Version('...')>
    >>> available_on_pypi(prerelease=False).is_prerelease
    False
    """
    # Deferred import to save startup time
    from six.moves.xmlrpc_client import ServerProxy

    versions = getattr(available_on_pypi, 'cached', None)
    if versions is None:
        client = ServerProxy('https://pypi.python.org/pypi')
        versions = client.package_releases('pwntools', True)
        available_on_pypi.cached = versions

    versions = map(packaging.version.Version, versions)

    if not prerelease:
        versions = filter(lambda v: not v.is_prerelease, versions)

    return max(versions)
Exemplo n.º 31
0
def download_data(file, group, station_id, start, end, get_blobs=False):
    """Download raw data from the datastore

    This function downloads data from the datastore, using the XML-RPC API
    exposed by the public database.

    :param file: The PyTables datafile handler
    :param group: The PyTables destination group, which need not exist
    :param station_id: The HiSPARC station number for which to get events
    :param start: a datetime instance defining the start of the search
        interval
    :param end: a datetime instance defining the end of the search
        interval
    :param get_blobs: boolean, select whether binary data like traces
        should be fetched

    Example::

        >>> import tables
        >>> import datetime
        >>> import sapphire.publicdb
        >>> data = tables.open_file('data.h5', 'w')
        >>> start = datetime.datetime(2010, 9, 1)
        >>> end = datetime.datetime(2010, 9, 2)
        >>> sapphire.publicdb.download_data(data, '/s501', 501, start, end)
        INFO:hisparc.publicdb:2010-09-01 00:00:00 None
        INFO:hisparc.publicdb:Getting server data URL (2010-09-01 00:00:00)
        INFO:hisparc.publicdb:Downloading data...
        INFO:hisparc.publicdb:Storing data...
        INFO:hisparc.publicdb:Done.

    """
    server = ServerProxy(PUBLICDB_XMLRPC_URL)

    for t0, t1 in datetimerange(start, end):
        logger.info("%s %s" % (t0, t1))
        logger.info("Getting server data URL (%s)" % t0)
        try:
            url = server.hisparc.get_data_url(station_id, t0, get_blobs)
        except Exception as exc:
            if re.search("No data", str(exc)):
                logger.warning("No data for %s" % t0)
                continue
            else:
                raise
        logger.info("Downloading data...")
        tmp_datafile, headers = urlretrieve(url)
        logger.info("Storing data...")
        _store_data(file, group, tmp_datafile, t0, t1)
        logger.info("Done.")
Exemplo n.º 32
0
    def __init__(self,
                 user=None,
                 password=None,
                 server=None,
                 port=None,
                 anon=False):
        """Initialise an SR trac object."""
        config = Config()

        if server is None:
            server = config["server"]

        if port is None:
            port = config["https_port"]

        self.server = server
        self.port = port

        rpc_settings = {"server": server, "port": port}

        if anon:
            rpc_url = "https://{server}:{port}/trac/rpc"
        else:
            rpc_url = "https://{user}:{password}@{server}:{port}/trac/login" \
                      "/rpc"

            user = config.get_user(user)
            rpc_settings["user"] = user
            rpc_settings["password"] = config.get_password(password, user=user)

        rpc_url = rpc_url.format(**rpc_settings)

        ServerProxy.__init__(self, rpc_url)

        if 'ticket.create' not in self.system.listMethods():
            raise WrongServer()
Exemplo n.º 33
0
class Service(SimpleService):
    def __init__(self, configuration=None, name=None):
        SimpleService.__init__(self, configuration=configuration, name=name)
        self.order = ORDER
        self.definitions = CHARTS
        self.host = self.configuration.get(CONF_PARAM_HOST, DEFAULT_HOST)

        try:
            self.server = ServerProxy(self.host, allow_none=True)
        except:
            self.server = None

    def check(self):
        if self.server is None:
            self.error('error connecting to the sioworkers server {0}'.format(
                self.host))

        return True

    def get_data(self):
        if self.server is None:
            return None

        capacity = 0
        load = 0

        workers = self.server.get_workers()

        for worker in workers:
            concurrency = worker['info']['concurrency']

            capacity += concurrency

            if bool(worker['is_running_cpu_exec']):
                load += concurrency
            else:
                load += len(worker['tasks'])

        return dict({'capacity': capacity, 'load': load})
Exemplo n.º 34
0
    def __init__(self, context):
        self._serverproxy_list = []
        preference_tool = getToolByName(context, 'portal_preferences')
        self._ooo_server_retry = (
            preference_tool.getPreferredDocumentConversionServerRetry()
            or DOCUMENT_CONVERSION_SERVER_RETRY)
        uri_list = preference_tool.getPreferredDocumentConversionServerUrlList(
        )
        if not uri_list:
            address = preference_tool.getPreferredOoodocServerAddress()
            port = preference_tool.getPreferredOoodocServerPortNumber()
            if not (address and port):
                raise ConversionError(
                    'OOoDocument: cannot proceed with conversion:'
                    ' conversion server url is not defined in preferences')

            LOG('Document', WARNING, 'PreferredOoodocServer{Address,PortNumber}' + \
                ' are DEPRECATED please use PreferredDocumentServerUrl instead', error=True)

            uri_list = ['%s://%s:%s' % ('http', address, port)]

        timeout = (preference_tool.getPreferredOoodocServerTimeout()
                   or DOCUMENT_CONVERSION_SERVER_PROXY_TIMEOUT)
        for uri in uri_list:
            if uri.startswith("http://"):
                scheme = "http"
            elif uri.startswith("https://"):
                scheme = "https"
            else:
                raise ConversionError(
                    'OOoDocument: cannot proceed with conversion:'
                    ' preferred conversion server url is invalid')

            from erp5.component.module.TimeoutTransport import TimeoutTransport
            transport = TimeoutTransport(timeout=timeout, scheme=scheme)

            self._serverproxy_list.append(
                (uri, ServerProxy(uri, allow_none=True, transport=transport)))
Exemplo n.º 35
0
def larch_server_cli():
    """command-line program to control larch XMLRPC server"""
    __version__ = 'version 2.2'
    usage = """usage: %prog [options] [start|stop|restart|next|status|report]

Commands:
   start       start server on specified port
   stop        stop server on specified port
   restart     restart server on specified port
   next        start server on next avaialable port (see also '-n' option)
   status      print a short status message: whether server is running on port
   report      print a multi-line status report
"""

    parser = OptionParser(usage=usage, prog="larch_server",
                          version="larch_server: %s" % __version__)
    parser.add_option("-p", "--port", dest="port", default='4966',
                      metavar='PORT', help="port number for server [4966]")
    parser.add_option("-q", "--quiet", dest="quiet", action="store_true",
                      default=False, help="suppress messaages [False]")
    parser.add_option("-n", "--next", dest="next", action="store_true",
                      default=False, help="show next available port, but do not start [False]")

    (options, args) = parser.parse_args()

    port = int(options.port)
    command = 'status'

    def smsg(port, txt):
        if not options.quiet:
            print('larch_server port=%i: %s' % (port, txt))

    if len(args) >  0:
        command = args[0].lower()

    if options.next:
        port = get_next_port(port=port)
        print("%i" % port)
        sys.exit(0)

    server_state = test_server(port=port)

    if command == 'start':
        if server_state == CONNECTED:
            smsg(port, 'already running')
        elif server_state == NOT_IN_USE:
            spawn_server(port=port)
            smsg(port, 'started')
        else:
            smsg(port, 'port is in use, cannot start')

    elif command == 'stop':
        if server_state == CONNECTED:
            ServerProxy('http://localhost:%d' % (port)).shutdown()
            smsg(port, 'stopped')

    elif command == 'next':
        port = get_next_port(port=port)
        spawn_server(port=port)
        smsg(port, 'started')

    elif command == 'restart':
        if server_state == CONNECTED:
            ServerProxy('http://localhost:%d' % (port)).shutdown()
            sleep(POLL_TIME)
        spawn_server(port=port)

    elif command == 'status':
        if server_state == CONNECTED:
            smsg(port, 'running')
            sys.exit(0)
        elif server_state == NOT_IN_USE:
            smsg(port, 'not running')
            sys.exit(1)
        else:
            smsg(port, 'port is in use by non-larch server')
    elif command == 'report':
        if server_state == CONNECTED:
            s = ServerProxy('http://localhost:%d' % (port))
            info = s.get_client_info()
            last_event = info.get('last_event', 0)
            last_used = ctime(last_event)
            serverid  = int(info.get('pid_server', 0))
            serverport= int(info.get('port', 0))
            procid    = int(info.get('pid', 0))
            appname   = info.get('app',     'unknown')
            machname  = info.get('machine', 'unknown')
            username  = info.get('user',    'unknown')
            keepalive_time = info.get('keepalive_time', -1)
            keepalive_time += (last_event - time())
            keepalive_units = 'seconds'
            if keepalive_time > 300:
                keepalive_time = keepalive_time/60.0
                keepalive_units = 'minutes'
            if keepalive_time > 300:
                keepalive_time = keepalive_time/60.0
                keepalive_units = 'hours'

            print('larch_server report:')
            print(' Client Machine Name = %s' % machname)
            print(' Client Process ID   = %s' % str(procid))
            print(' Client Application  = %s' % appname)
            print(' Client User Name    = %s' % username)
            print(' Client Last Used    = %s' % last_used)
            print(' Server Process ID   = %s' % serverid)
            print(' Server Port Number  = %s' % serverport)
            print(' Server will expire in  %i %s if not used.' % (keepalive_time,
                                                                  keepalive_units))

        elif server_state == NOT_IN_USE:
            smsg(port, 'not running')
            sys.exit(1)
        else:
            smsg(port, 'port is in use by non-larch server')

    else:
        print("larch_server: unknown command '%s'. Try -h" % command)
Exemplo n.º 36
0
 def __init__(self):
     server_listener_address = 'http://%s:%s' % (
         LISTENER_HOST, LISTENER_PORT)
     self.server = ServerProxy(server_listener_address)
Exemplo n.º 37
0
class OpenSubtitlesProvider(Provider):
    """OpenSubtitles Provider.

    :param str username: username.
    :param str password: password.

    """
    languages = {
        Language.fromopensubtitles(l)
        for l in language_converters['opensubtitles'].codes
    }
    subtitle_class = OpenSubtitlesSubtitle

    def __init__(self, username=None, password=None):
        self.server = ServerProxy('https://api.opensubtitles.org/xml-rpc',
                                  TimeoutSafeTransport(10))
        if username and not password or not username and password:
            raise ConfigurationError('Username and password must be specified')
        # None values not allowed for logging in, so replace it by ''
        self.username = username or ''
        self.password = password or ''
        self.token = None

    def initialize(self):
        logger.info('Logging in')
        response = checked(
            self.server.LogIn(self.username, self.password, 'eng',
                              'subliminal v%s' % __short_version__))
        self.token = response['token']
        logger.debug('Logged in with token %r', self.token)

    def terminate(self):
        logger.info('Logging out')
        checked(self.server.LogOut(self.token))
        self.server.close()
        self.token = None
        logger.debug('Logged out')

    def no_operation(self):
        logger.debug('No operation')
        checked(self.server.NoOperation(self.token))

    def query(self,
              languages,
              hash=None,
              size=None,
              imdb_id=None,
              query=None,
              season=None,
              episode=None,
              tag=None):
        # fill the search criteria
        criteria = []
        if hash and size:
            criteria.append({'moviehash': hash, 'moviebytesize': str(size)})
        if imdb_id:
            criteria.append({'imdbid': imdb_id[2:]})
        if tag:
            criteria.append({'tag': tag})
        if query and season and episode:
            criteria.append({
                'query': query.replace('\'', ''),
                'season': season,
                'episode': episode
            })
        elif query:
            criteria.append({'query': query.replace('\'', '')})
        if not criteria:
            raise ValueError('Not enough information')

        # add the language
        for criterion in criteria:
            criterion['sublanguageid'] = ','.join(
                sorted(l.opensubtitles for l in languages))

        # query the server
        logger.info('Searching subtitles %r', criteria)
        response = checked(self.server.SearchSubtitles(self.token, criteria))
        subtitles = []

        # exit if no data
        if not response['data']:
            logger.debug('No subtitles found')
            return subtitles

        # loop over subtitle items
        for subtitle_item in response['data']:
            # read the item
            language = Language.fromopensubtitles(
                subtitle_item['SubLanguageID'])
            hearing_impaired = bool(int(subtitle_item['SubHearingImpaired']))
            page_link = subtitle_item['SubtitlesLink']
            subtitle_id = int(subtitle_item['IDSubtitleFile'])
            matched_by = subtitle_item['MatchedBy']
            movie_kind = subtitle_item['MovieKind']
            hash = subtitle_item['MovieHash']
            movie_name = subtitle_item['MovieName']
            movie_release_name = subtitle_item['MovieReleaseName']
            movie_year = int(subtitle_item['MovieYear']
                             ) if subtitle_item['MovieYear'] else None
            movie_imdb_id = 'tt' + subtitle_item['IDMovieImdb']
            series_season = int(subtitle_item['SeriesSeason']
                                ) if subtitle_item['SeriesSeason'] else None
            series_episode = int(subtitle_item['SeriesEpisode']
                                 ) if subtitle_item['SeriesEpisode'] else None
            filename = subtitle_item['SubFileName']
            encoding = subtitle_item.get('SubEncoding') or None

            subtitle = self.subtitle_class(language, hearing_impaired,
                                           page_link, subtitle_id, matched_by,
                                           movie_kind, hash, movie_name,
                                           movie_release_name, movie_year,
                                           movie_imdb_id, series_season,
                                           series_episode, filename, encoding)
            logger.debug('Found subtitle %r by %s', subtitle, matched_by)
            subtitles.append(subtitle)

        return subtitles

    def list_subtitles(self, video, languages):
        season = episode = None
        if isinstance(video, Episode):
            query = video.series
            season = video.season
            episode = video.episode
        else:
            query = video.title

        return self.query(languages,
                          hash=video.hashes.get('opensubtitles'),
                          size=video.size,
                          imdb_id=video.imdb_id,
                          query=query,
                          season=season,
                          episode=episode,
                          tag=os.path.basename(video.name))

    def download_subtitle(self, subtitle):
        logger.info('Downloading subtitle %r', subtitle)
        response = checked(
            self.server.DownloadSubtitles(self.token,
                                          [str(subtitle.subtitle_id)]))
        subtitle.content = fix_line_ending(
            zlib.decompress(base64.b64decode(response['data'][0]['data']), 47))
Exemplo n.º 38
0
 def __dir__(self):
     try:
         return ServerProxy.__getattr__(self, 'system.listMethods')()
     except Fault as e: # Server doesn't provide method
         warn(str(e))
         return []
Exemplo n.º 39
0
class OpenSubtitlesProvider(Provider):
    languages = {Language.fromopensubtitles(l) for l in language_converters['opensubtitles'].codes}

    def __init__(self, username=None, password=None):
        self.server = ServerProxy('https://api.opensubtitles.org/xml-rpc', TimeoutSafeTransport(10))
        if username and not password or not username and password:
            raise ConfigurationError('Username and password must be specified')
        # None values not allowed for logging in, so replace it by ''
        self.username = username or ''
        self.password = password or ''
        self.token = None

    def initialize(self):
        logger.info('Logging in')
        response = checked(self.server.LogIn(self.username, self.password, 'eng',
                                             'subliminal v%s' % __short_version__))
        self.token = response['token']
        logger.debug('Logged in with token %r', self.token)

    def terminate(self):
        logger.info('Logging out')
        checked(self.server.LogOut(self.token))
        self.server.close()
        self.token = None
        logger.debug('Logged out')

    def no_operation(self):
        logger.debug('No operation')
        checked(self.server.NoOperation(self.token))

    def query(self, languages, hash=None, size=None, imdb_id=None, query=None, season=None, episode=None, tag=None):
        # fill the search criteria
        criteria = []
        if hash and size:
            criteria.append({'moviehash': hash, 'moviebytesize': str(size)})
        if imdb_id:
            criteria.append({'imdbid': imdb_id[2:]})
        if tag:
            criteria.append({'tag': tag})
        if query and season and episode:
            criteria.append({'query': query.replace('\'', ''), 'season': season, 'episode': episode})
        elif query:
            criteria.append({'query': query.replace('\'', '')})
        if not criteria:
            raise ValueError('Not enough information')

        # add the language
        for criterion in criteria:
            criterion['sublanguageid'] = ','.join(sorted(l.opensubtitles for l in languages))

        # query the server
        logger.info('Searching subtitles %r', criteria)
        response = checked(self.server.SearchSubtitles(self.token, criteria))
        subtitles = []

        # exit if no data
        if not response['data']:
            logger.debug('No subtitles found')
            return subtitles

        # loop over subtitle items
        for subtitle_item in response['data']:
            # read the item
            language = Language.fromopensubtitles(subtitle_item['SubLanguageID'])
            hearing_impaired = bool(int(subtitle_item['SubHearingImpaired']))
            page_link = subtitle_item['SubtitlesLink']
            subtitle_id = int(subtitle_item['IDSubtitleFile'])
            matched_by = subtitle_item['MatchedBy']
            movie_kind = subtitle_item['MovieKind']
            hash = subtitle_item['MovieHash']
            movie_name = subtitle_item['MovieName']
            movie_release_name = subtitle_item['MovieReleaseName']
            movie_year = int(subtitle_item['MovieYear']) if subtitle_item['MovieYear'] else None
            movie_imdb_id = 'tt' + subtitle_item['IDMovieImdb']
            series_season = int(subtitle_item['SeriesSeason']) if subtitle_item['SeriesSeason'] else None
            series_episode = int(subtitle_item['SeriesEpisode']) if subtitle_item['SeriesEpisode'] else None
            filename = subtitle_item['SubFileName']
            encoding = subtitle_item.get('SubEncoding') or None

            subtitle = OpenSubtitlesSubtitle(language, hearing_impaired, page_link, subtitle_id, matched_by, movie_kind,
                                             hash, movie_name, movie_release_name, movie_year, movie_imdb_id,
                                             series_season, series_episode, filename, encoding)
            logger.debug('Found subtitle %r by %s', subtitle, matched_by)
            subtitles.append(subtitle)

        return subtitles

    def list_subtitles(self, video, languages):
        season = episode = None
        if isinstance(video, Episode):
            query = video.series
            season = video.season
            episode = video.episode
        else:
            query = video.title

        return self.query(languages, hash=video.hashes.get('opensubtitles'), size=video.size, imdb_id=video.imdb_id,
                          query=query, season=season, episode=episode, tag=os.path.basename(video.name))

    def download_subtitle(self, subtitle):
        logger.info('Downloading subtitle %r', subtitle)
        response = checked(self.server.DownloadSubtitles(self.token, [str(subtitle.subtitle_id)]))
        subtitle.content = fix_line_ending(zlib.decompress(base64.b64decode(response['data'][0]['data']), 47))
Exemplo n.º 40
0
def sendNZB(nzb, proper=False):  # pylint: disable=too-many-locals, too-many-statements, too-many-branches, too-many-return-statements
    """
    Sends NZB to NZBGet client

    :param nzb: nzb object
    :param proper: True if this is a Proper download, False if not. Defaults to False
    """
    if sickbeard.NZBGET_HOST is None:
        logger.log('No NZBget host found in configuration. Please configure it.', logger.WARNING)
        return False

    addToTop = False
    nzbgetprio = 0
    category = sickbeard.NZBGET_CATEGORY
    if nzb.show.is_anime:
        category = sickbeard.NZBGET_CATEGORY_ANIME

    url = 'http{}://{}:{}@{}/xmlrpc'.format(
        's' if sickbeard.NZBGET_USE_HTTPS else '',
        sickbeard.NZBGET_USERNAME,
        sickbeard.NZBGET_PASSWORD,
        sickbeard.NZBGET_HOST)

    nzbGetRPC = ServerProxy(url)
    try:
        if nzbGetRPC.writelog('INFO', 'SickRage connected to drop off {} any moment now.'.format(nzb.name + '.nzb')):
            logger.log('Successful connected to NZBget', logger.DEBUG)
        else:
            logger.log('Successful connected to NZBget, but unable to send a message', logger.WARNING)

    except socket.error:
        logger.log(
            'Please check your NZBget host and port (if it is running). NZBget is not responding to this combination',
            logger.WARNING)
        return False

    except ProtocolError as e:
        if e.errmsg == 'Unauthorized':
            logger.log('NZBget username or password is incorrect.', logger.WARNING)
        else:
            logger.log('Protocol Error: ' + e.errmsg, logger.ERROR)
        return False

    dupekey = ''
    dupescore = 0
    # if it aired recently make it high priority and generate DupeKey/Score
    for curEp in nzb.episodes:
        if dupekey == '':
            if curEp.show.indexer == 1:
                dupekey = 'SickRage-' + str(curEp.show.indexerid)
            elif curEp.show.indexer == 2:
                dupekey = 'SickRage-tvr' + str(curEp.show.indexerid)
        dupekey += '-' + str(curEp.season) + '.' + str(curEp.episode)
        if datetime.date.today() - curEp.airdate <= datetime.timedelta(days=7):
            addToTop = True
            nzbgetprio = sickbeard.NZBGET_PRIORITY
        else:
            category = sickbeard.NZBGET_CATEGORY_BACKLOG
            if nzb.show.is_anime:
                category = sickbeard.NZBGET_CATEGORY_ANIME_BACKLOG

    if nzb.quality != Quality.UNKNOWN:
        dupescore = nzb.quality * 100
    if proper:
        dupescore += 10

    nzbcontent64 = None
    if nzb.resultType == 'nzbdata':
        data = nzb.extraInfo[0]
        nzbcontent64 = standard_b64encode(data)

    logger.log('Sending NZB to NZBget')
    logger.log('URL: ' + url, logger.DEBUG)

    try:
        # Find out if nzbget supports priority (Version 9.0+),
        # old versions beginning with a 0.x will use the old command
        nzbget_version_str = nzbGetRPC.version()
        nzbget_version = try_int(nzbget_version_str[:nzbget_version_str.find('.')])
        if nzbget_version == 0:
            if nzbcontent64:
                nzbget_result = nzbGetRPC.append(nzb.name + '.nzb', category, addToTop, nzbcontent64)
            else:
                if nzb.resultType == 'nzb':
                    if not nzb.provider.login():
                        return False

                    data = nzb.provider.get_url(nzb.url, returns='content')
                    if data is None:
                        return False

                    nzbcontent64 = standard_b64encode(data)

                nzbget_result = nzbGetRPC.append(nzb.name + '.nzb', category, addToTop, nzbcontent64)
        elif nzbget_version == 12:
            if nzbcontent64 is not None:
                nzbget_result = nzbGetRPC.append(nzb.name + '.nzb', category, nzbgetprio, False,
                                                 nzbcontent64, False, dupekey, dupescore, 'score')
            else:
                nzbget_result = nzbGetRPC.appendurl(nzb.name + '.nzb', category, nzbgetprio, False,
                                                    nzb.url, False, dupekey, dupescore, 'score')
        # v13+ has a new combined append method that accepts both (url and content)
        # also the return value has changed from boolean to integer
        # (Positive number representing NZBID of the queue item. 0 and negative numbers represent error codes.)
        elif nzbget_version >= 13:
            nzbget_result = nzbGetRPC.append(nzb.name + '.nzb', nzbcontent64 if nzbcontent64 is not None else nzb.url,
                                             category, nzbgetprio, False, False, dupekey, dupescore,
                                             'score') > 0
        else:
            if nzbcontent64 is not None:
                nzbget_result = nzbGetRPC.append(nzb.name + '.nzb', category, nzbgetprio, False,
                                                 nzbcontent64)
            else:
                nzbget_result = nzbGetRPC.appendurl(nzb.name + '.nzb', category, nzbgetprio, False,
                                                    nzb.url)

        if nzbget_result:
            logger.log('NZB sent to NZBget successfully', logger.DEBUG)
            return True
        else:
            logger.log('NZBget could not add {} to the queue'.format(nzb.name + '.nzb'), logger.WARNING)
            return False
    except Exception:
        logger.log('Connect Error to NZBget: could not add {} to the queue'.format(nzb.name + '.nzb'), logger.WARNING)
        return False
Exemplo n.º 41
0
    def testXmlRpc(self):

        scheme = self.scheme
        if scheme == 'https':
            url = 'https://%s:%s/xmlrpc/' % (self.interface(), self.PORT)
            proxy = ServerProxy(url, transport=HTTPSTransport())
        else:
            url = 'http://%s:%s/xmlrpc/' % (self.interface(), self.PORT)
            proxy = ServerProxy(url)

        # begin the tests ...
        self.getPage('/xmlrpc/foo')
        self.assertBody('Hello world!')

        self.assertEqual(proxy.return_single_item_list(), [42])
        self.assertNotEqual(proxy.return_single_item_list(), 'one bazillion')
        self.assertEqual(proxy.return_string(), 'here is a string')
        self.assertEqual(proxy.return_tuple(),
                         list(('here', 'is', 1, 'tuple')))
        self.assertEqual(proxy.return_dict(), {'a': 1, 'c': 3, 'b': 2})
        self.assertEqual(proxy.return_composite(),
                         [{'a': 1, 'z': 26}, 'hi', ['welcome', 'friend']])
        self.assertEqual(proxy.return_int(), 42)
        self.assertEqual(proxy.return_float(), 3.14)
        self.assertEqual(proxy.return_datetime(),
                         DateTime((2003, 10, 7, 8, 1, 0, 1, 280, -1)))
        self.assertEqual(proxy.return_boolean(), True)
        self.assertEqual(proxy.test_argument_passing(22), 22 * 2)

        # Test an error in the page handler (should raise an xmlrpclib.Fault)
        try:
            proxy.test_argument_passing({})
        except Exception:
            x = sys.exc_info()[1]
            self.assertEqual(x.__class__, Fault)
            self.assertEqual(x.faultString, ('unsupported operand type(s) '
                                             "for *: 'dict' and 'int'"))
        else:
            self.fail('Expected xmlrpclib.Fault')

        # https://github.com/cherrypy/cherrypy/issues/533
        # if a method is not found, an xmlrpclib.Fault should be raised
        try:
            proxy.non_method()
        except Exception:
            x = sys.exc_info()[1]
            self.assertEqual(x.__class__, Fault)
            self.assertEqual(x.faultString,
                             'method "non_method" is not supported')
        else:
            self.fail('Expected xmlrpclib.Fault')

        # Test returning a Fault from the page handler.
        try:
            proxy.test_returning_Fault()
        except Exception:
            x = sys.exc_info()[1]
            self.assertEqual(x.__class__, Fault)
            self.assertEqual(x.faultString, ('custom Fault response'))
        else:
            self.fail('Expected xmlrpclib.Fault')
Exemplo n.º 42
0
#!/usr/bin/env python
from six.moves.xmlrpc_client import ServerProxy

import time
import json
from larch.utils.jsonutils import decode4js
s = ServerProxy('http://127.0.0.1:4966')

print('Avaialable Methods from XML-RPC server: ', s.system.listMethods())
s.larch('m = 222.3')

s.larch('g = group(x=linspace(0, 10, 11))')
s.larch('g.z = cos(g.x)')

# show and print will be done in server process of course!!!
s.larch('show(g)')

s.larch('print( g.z[3:10])')

print( '== Messages:')
print( s.get_messages())
print( '==')


gx  = decode4js(s.get_data('g.z'))
print( 'm = ', s.get_data('m'))
print( 'x = ', s.get_data('x'))

print('gx = ',  gx, type(gx), gx.dtype)

# could tell server to exit!
Exemplo n.º 43
0
 def __init__(self, search_url=None):
     self.server = ServerProxy(self.server_url, TimeoutSafeTransport(10))
     # None values not allowed for logging in, so replace it by ''
     self.token = None
     self.session = Session()
     self.search_url = search_url or get_sub_domain()
Exemplo n.º 44
0
 def __init__(self):
     self.server = ServerProxy('https://api.opensubtitles.org/xml-rpc', TimeoutSafeTransport(10))
     self.token = None