Merge lp:~therve/landscape-client/remove-recorder into lp:~landscape/landscape-client/trunk

[Thomas Herve]

There were 2 revisions basically to remove.

[Free Ekanayaka (free.ekanayaka)]

Neat, +1!

review: Approve

[Geoff Teale (tealeg)]

+1, nothing controversial here.

review: Approve

=== modified file 'landscape/broker/config.py'
--- landscape/broker/config.py	2012-02-24 18:37:30 +0000
+++ landscape/broker/config.py	2012-03-07 08:45:23 +0000
@@ -20,10 +20,6 @@
     def exchange_store_path(self):
         return os.path.join(self.data_path, "exchange.database")
 
-    @property
-    def record_directory(self):
-        return os.path.join(self.data_path, "exchanges")
-
     def make_parser(self):
         """Parser factory for broker-specific options.
 
@@ -38,7 +34,6 @@
               - C{https_proxy}
               - C{cloud}
               - C{otp}
-              - C{record}
               - C{provisioning_otp}
         """
         parser = super(BrokerConfiguration, self).make_parser()
@@ -72,8 +67,6 @@
         parser.add_option("--tags",
                           help="Comma separated list of tag names to be sent "
                                "to the server.")
-        parser.add_option("--record", action="store_true",
-                          help="Record data sent to the server on filesystem.")
         parser.add_option("--provisioning-otp", default="",
                           help="The OTP to use for a provisioned machine.")
 

=== modified file 'landscape/broker/exchange.py'
--- landscape/broker/exchange.py	2012-03-05 14:11:42 +0000
+++ landscape/broker/exchange.py	2012-03-07 08:45:23 +0000
@@ -111,10 +111,6 @@
             self.schedule_exchange(urgent=True)
         return message_id
 
-    def send_at(self, offset, messages):
-        self._exchange_id = self._reactor.call_later(
-            offset, self.exchange, messages)
-
     def start(self):
         """Start scheduling exchanges. The first one will be urgent."""
         self.schedule_exchange(urgent=True)
@@ -174,7 +170,7 @@
                          self._urgent_exchange_interval)
         self._config.write()
 
-    def exchange(self, messages=None):
+    def exchange(self):
         """Send pending messages to the server and process responses.
 
         An C{pre-exchange} reactor event will be emitted just before the
@@ -195,7 +191,7 @@
 
         self._reactor.fire("pre-exchange")
 
-        payload = self.make_payload(messages)
+        payload = self.make_payload()
 
         start_time = self._create_time()
         if self._urgent_exchange:
@@ -275,7 +271,7 @@
     def _notify_impending_exchange(self):
         self._reactor.fire("impending-exchange")
 
-    def make_payload(self, messages=None):
+    def make_payload(self):
         """Return a dict representing the complete exchange payload.
 
         The payload will contain all pending messages eligible for
@@ -284,11 +280,8 @@
         """
         store = self._message_store
         accepted_types_digest = self._hash_types(store.get_accepted_types())
-        if messages is None:
-            messages = store.get_pending_messages(self._max_messages)
-            total_messages = store.count_pending_messages()
-        else:
-            total_messages = len(messages)
+        messages = store.get_pending_messages(self._max_messages)
+        total_messages = store.count_pending_messages()
         if messages:
             # Each message is tagged with the API that the client was
             # using at the time the message got added to the store.  The

=== modified file 'landscape/broker/service.py'
--- landscape/broker/service.py	2012-02-22 01:46:37 +0000
+++ landscape/broker/service.py	2012-03-07 08:45:23 +0000
@@ -5,7 +5,7 @@
 from landscape.service import LandscapeService, run_landscape_service
 from landscape.broker.registration import RegistrationHandler, Identity
 from landscape.broker.config import BrokerConfiguration
-from landscape.broker.transport import HTTPTransport, PayloadRecorder
+from landscape.broker.transport import HTTPTransport
 from landscape.broker.exchange import MessageExchange
 from landscape.broker.exchangestore import ExchangeStore
 from landscape.broker.ping import Pinger
@@ -48,14 +48,8 @@
             config.data_path, "%s.bpickle" % (self.service_name,))
         super(BrokerService, self).__init__(config)
 
-        if config.record is not None:
-            self.payload_recorder = PayloadRecorder(config.record_directory)
-        else:
-            self.payload_recorder = None
-
         self.transport = self.transport_factory(
-            self.reactor, config.url, config.ssl_public_key,
-            self.payload_recorder)
+            self.reactor, config.url, config.ssl_public_key)
         self.message_store = get_default_message_store(
             self.persist, config.message_store_path)
         self.identity = Identity(self.config, self.persist)

=== modified file 'landscape/broker/tests/test_exchange.py'
--- landscape/broker/tests/test_exchange.py	2011-07-15 21:44:42 +0000
+++ landscape/broker/tests/test_exchange.py	2012-03-07 08:45:23 +0000
@@ -873,64 +873,6 @@
         self.assertTrue(len(ids_after) == len(ids_before) - 1)
         self.assertFalse('234567' in ids_after)
 
-    def test_make_payload_default_messages(self):
-        """
-        When messages are not passed in to L{make_payload}, L{make_payload}
-        should retrieve messages from the message store.
-        """
-        self.mstore.set_accepted_types(["resynchronize"])
-        self.exchanger.send({"type": "resynchronize",
-                             "operation-id": 13579})
-        payload = self.exchanger.make_payload()
-        self.assertEqual(1, len(payload["messages"]))
-        self.assertEqual(1, payload["total-messages"])
-
-    def test_make_payload_non_default_messages(self):
-        """
-        When messages are passed in to L{make_payload}, L{make_payload}
-        should not retrieve messages from the message store.  L{make_payload}
-        should correctly set the message count.
-        """
-        payload = self.exchanger.make_payload(
-            [{"type": "resynchronize",
-              "api": "2.1",
-              "operation-id": 24680},
-             {"type": "resynchronize",
-              "api": "2.1",
-              "operation-id": 24681}])
-        self.assertEqual(2, len(payload["messages"]))
-        self.assertEqual("resynchronize", payload["messages"][0]["type"])
-        self.assertEqual(2, payload["total-messages"])
-
-    def test_exchange_with_messages(self):
-        """
-        L{exchange} should be able to pass messages to make_payload.
-        """
-        self.exchanger.exchange([{"type": "empty",
-                                  "timestamp": 0,
-                                  "api": SERVER_API}])
-        self.assertEqual(len(self.transport.payloads), 1)
-        messages = self.transport.payloads[0]["messages"]
-        self.assertEqual(messages, [{"type": "empty",
-                                     "timestamp": 0,
-                                     "api": SERVER_API}])
-
-    def test_send_at_schedules_an_exchange(self):
-        """
-        L{send_at} should schedule an exchange at the specified time with
-        the supplied messages.
-        """
-        messages = [{"type": "empty",
-                     "timestamp": 0,
-                     "api": SERVER_API}]
-
-        self.exchanger.send_at(338, messages)
-
-        self.assertEqual(1, len(self.reactor._calls))
-        self.assertEqual(338, self.reactor._calls[0][0])
-        self.assertEqual(self.exchanger.exchange, self.reactor._calls[0][1])
-        self.assertEqual(messages, self.reactor._calls[0][2][0])
-
 
 class AcceptedTypesMessageExchangeTest(LandscapeTest):
 

=== modified file 'landscape/broker/tests/test_store.py'
--- landscape/broker/tests/test_store.py	2011-07-14 15:43:11 +0000
+++ landscape/broker/tests/test_store.py	2012-03-07 08:45:23 +0000
@@ -176,6 +176,7 @@
             self.store.add(dict(type=["data", "unaccepted"][i % 2],
                                 data=str(i)))
         self.store.set_pending_offset(2)
+        il = [m["data"] for m in self.store.get_pending_messages(2)]
         self.store.set_accepted_types(["data", "unaccepted"])
         il = [m["data"] for m in self.store.get_pending_messages(20)]
         self.assertEqual(il, map(str, [4, 6, 8, 1, 3, 5, 7, 9]))

=== modified file 'landscape/broker/tests/test_transport.py'
--- landscape/broker/tests/test_transport.py	2012-02-24 19:35:56 +0000
+++ landscape/broker/tests/test_transport.py	2012-03-07 08:45:23 +0000
@@ -1,13 +1,11 @@
 import os
 
 from landscape import VERSION
-from landscape.broker.transport import HTTPTransport, PayloadRecorder
+from landscape.broker.transport import HTTPTransport
 from landscape.lib.fetch import PyCurlError
-from landscape.lib.fs import create_file, read_file
 from landscape.lib import bpickle
 
-from landscape.tests.helpers import (
-    LandscapeTest, LogKeeperHelper, MockerTestCase)
+from landscape.tests.helpers import LandscapeTest, LogKeeperHelper
 
 from twisted.web import server, resource
 from twisted.internet import reactor
@@ -147,124 +145,3 @@
                             in self.logfile.getvalue())
         result.addCallback(got_result)
         return result
-
-    def test_payload_recording_works(self):
-        """
-        When C{HTTPTransport} is configured with a payload recorder, exchanges
-        with the server should be saved to the filesystem.
-        """
-        path = self.makeDir()
-        recorder = PayloadRecorder(path)
-
-        def static_filename():
-            return "filename"
-        recorder.get_payload_filename = static_filename
-
-        transport = HTTPTransport(None, "http://localhost",
-                                  payload_recorder=recorder)
-
-        transport._curl = fake_curl
-
-        transport.exchange("pay load")
-
-        file_path = os.path.join(path, static_filename())
-        self.assertEqual("pay load", bpickle.loads(read_file(file_path)))
-
-    def test_exchange_works_without_payload_recording(self):
-        """
-        When C{HTTPTransport} is configured without a payload recorder,
-        exchanges with the server should still complete.
-        """
-        transport = HTTPTransport(None, "http://localhost")
-        self.called = False
-
-        def fake_curl(param1, param2, param3):
-            """Stub out the curl network call."""
-            self.called = True
-
-            class Curly(object):
-                def getinfo(self, param1):
-                    return 200
-            return (Curly(), bpickle.dumps("pay load response"))
-
-        transport._curl = fake_curl
-
-        transport.exchange("pay load")
-
-        self.assertTrue(self.called)
-
-
-class PayloadRecorderTest(MockerTestCase):
-
-    def test_get_payload_filename(self):
-        """
-        L{PayloadRecorder.get_payload_filename} should return a filename that
-        is equal to the number of seconds since it was created.
-        """
-        mock = self.mocker.replace("time.time")
-        mock()
-        self.mocker.result(0.0)
-        mock()
-        self.mocker.result(12.3456)
-        self.mocker.replay()
-        recorder = PayloadRecorder(None)
-
-        payload_name = recorder.get_payload_filename()
-
-        self.assertEqual("12.346", payload_name)
-
-    def test_get_payload_filename_no_duplicates(self):
-        """
-        L{PayloadRecorder.get_payload_filename} should not generate duplicate
-        payload names.
-        """
-        mock = self.mocker.replace("time.time")
-        mock()
-        self.mocker.result(0.0)
-        mock()
-        self.mocker.result(12.345)
-        mock()
-        self.mocker.result(12.345)
-        self.mocker.replay()
-
-        recorder = PayloadRecorder(None)
-
-        payload_name_1 = recorder.get_payload_filename()
-        payload_name_2 = recorder.get_payload_filename()
-
-        self.assertEqual("12.345", payload_name_1)
-        self.assertEqual("12.346", payload_name_2)
-
-    def test_save(self):
-        """L{PayloadRecorder.save} should save the payload to the filesystem.
-        """
-        path = self.makeDir()
-        recorder = PayloadRecorder(path)
-
-        def static_filename():
-            return "filename"
-        recorder.get_payload_filename = static_filename
-        recorder.save("payload data")
-        file_path = os.path.join(path, static_filename())
-        self.assertEqual("payload data", read_file(file_path))
-
-    def test_create_destination_dir(self):
-        """
-        L{PayloadRecorder} should create the destination directory if it does
-        not exist.
-        """
-        path = self.makeDir()
-        os.rmdir(path)
-        PayloadRecorder(path)
-        self.assertTrue(os.path.isdir(path))
-
-    def test_delete_old_payloads(self):
-        """
-        L{PayloadRecorder} should remove all files from the destination
-        directory before writing new files.
-        """
-        path = self.makeDir()
-        create_file(os.path.join(path, "one"), "one")
-        create_file(os.path.join(path, "two"), "two")
-        PayloadRecorder(path)
-        self.assertEqual([], os.listdir(path))

=== modified file 'landscape/broker/transport.py'
--- landscape/broker/transport.py	2012-02-27 19:14:53 +0000
+++ landscape/broker/transport.py	2012-03-07 08:45:23 +0000
@@ -1,5 +1,4 @@
 """Low-level server communication."""
-import os
 import time
 import logging
 import pprint
@@ -7,7 +6,6 @@
 import pycurl
 
 from landscape.lib.fetch import fetch
-from landscape.lib.fs import create_file
 from landscape.lib import bpickle
 from landscape.log import format_delta
 from landscape import SERVER_API, VERSION
@@ -18,15 +16,12 @@
 
     @param url: URL of the remote Landscape server message system.
     @param pubkey: SSH public key used for secure communication.
-    @param payload_recorder: PayloadRecorder used for recording exchanges
-        with the server.  If C{None}, exchanges will not be recorded.
     """
 
-    def __init__(self, reactor, url, pubkey=None, payload_recorder=None):
+    def __init__(self, reactor, url, pubkey=None):
         self._reactor = reactor
         self._url = url
         self._pubkey = pubkey
-        self._payload_recorder = payload_recorder
 
     def get_url(self):
         """Get the URL of the remote message system."""
@@ -61,8 +56,6 @@
 
         """
         spayload = bpickle.dumps(payload)
-        if self._payload_recorder is not None:
-            self._payload_recorder.save(spayload)
         try:
             start_time = time.time()
             if logging.getLogger().getEffectiveLevel() <= logging.DEBUG:
@@ -92,70 +85,11 @@
         return response
 
 
-class PayloadRecorder(object):
-    """
-    L{PayloadRecorder} records client exchanges with the server to disk for
-    later playback.
-
-    Exchange payloads will be stored one per file, where the file name is
-    the elapsed time since the client was started.
-
-    @param destination_dir - The directory to record exchanges in.
-    """
-
-    def __init__(self, destination_dir):
-        self._time_offset = time.time()
-        self._destination_dir = destination_dir
-        self._last_payload_time = -1
-        if self._destination_dir is not None:
-            self._create_destination_dir(self._destination_dir)
-            self._delete_old_payloads()
-
-    def _create_destination_dir(self, destination_dir):
-        """Create the destination directory if it does not exist.
-
-        @param destination_dir: The directory to be created.
-        """
-        if not os.path.exists(destination_dir):
-            os.mkdir(destination_dir)
-
-    def _delete_old_payloads(self):
-        """Delete payloads lying around from a previous session."""
-        for filename in os.listdir(self._destination_dir):
-            file_path = os.path.join(self._destination_dir, filename)
-            if os.path.isfile(file_path):
-                os.unlink(file_path)
-
-    def save(self, payload):
-        """Persist the given payload to disk.
-
-        @param payload: The payload to be persisted.
-        """
-        payload_name = self.get_payload_filename()
-        create_file(os.path.join(self._destination_dir, payload_name),
-                    payload)
-
-    def get_payload_filename(self):
-        """
-        Generate a payload filename.  This method ensures that payloads
-        will have a unique name.
-        """
-        payload_time = time.time() - self._time_offset
-        last_payload_time = '%.3f' % self._last_payload_time
-        this_payload_time = '%.3f' % payload_time
-        if last_payload_time == this_payload_time:
-            payload_time = payload_time + 0.001
-        self._last_payload_time = payload_time
-        return '%.3f' % payload_time
-
-
 class FakeTransport(object):
     """Fake transport for testing purposes."""
 
-    def __init__(self, reactor=None, url=None, pubkey=None,
-                 payload_recorder=None):
+    def __init__(self, reactor=None, url=None, pubkey=None):
         self._pubkey = pubkey
-        self._payload_recorder = payload_recorder
         self.payloads = []
         self.responses = []
         self._current_response = 0

=== removed directory 'landscape/player'
=== removed file 'landscape/player/__init__.py'
--- landscape/player/__init__.py	2011-06-30 15:27:36 +0000
+++ landscape/player/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-"""
-The player package contains functionality used for playing back previously
-recorded server exchanges.  This package is not used when landscape-client
-is running normally.  It is used for Landscape Server load testing.
-"""

=== removed file 'landscape/player/player.py'
--- landscape/player/player.py	2011-07-18 13:35:59 +0000
+++ landscape/player/player.py	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-from landscape.lib import bpickle
-
-
-class PayloadPlayer(object):
-    """A player that replays old messages.
-
-    @param reader - A L{PayloadReader} that fetches exchanges from the
-        filesystem.
-    @param exchange - The L{MessageExchange} that messages will be played back
-        to.
-    @param playback_speed - The speed multiplier at which to play back messages
-        at.
-    """
-    def __init__(self, reader, exchange, playback_speed):
-        self._exchange = exchange
-        self._reader = reader
-        self._data = []
-        self._playback_speed = playback_speed
-
-    def load(self):
-        """Retrieve exchanges from the L{PayloadReader} and sort them."""
-        data = self._reader.load()
-        self._data = sorted(data, key=lambda x: float(x[0]))
-
-    def play(self):
-        """
-        Schedule events with the L{MessageExchange} that will replay the
-        messages at the expected time offset.
-        """
-        for offset_str, payload in self._data:
-            offset = float(offset_str) / self._playback_speed
-            exchange = bpickle.loads(payload)
-            if len(exchange['messages']) > 0:
-                self._exchange.send_at(offset, exchange['messages'])

=== removed file 'landscape/player/reader.py'
--- landscape/player/reader.py	2011-07-22 16:14:30 +0000
+++ landscape/player/reader.py	1970-01-01 00:00:00 +0000
@@ -1,24 +0,0 @@
-import os
-
-from landscape.lib.fs import read_file
-
-
-class PayloadReader(object):
-    """A reader that reads old exchanges from the filesystem.
-
-    @param source_dir - The directory to read old exchanges from
-    """
-    def __init__(self, source_dir):
-        self._source_dir = source_dir
-
-    def load(self):
-        """Load old exchanges from the filesystem.
-
-        @return: file data in the format [(filename1, file_contents1),
-            (filename2, file_contents2)]
-        """
-        result = []
-        for filename in sorted(os.listdir(self._source_dir)):
-            full_path = os.path.join(self._source_dir, filename)
-            result.append((filename, read_file(full_path)))
-        return result

=== removed file 'landscape/player/service.py'
--- landscape/player/service.py	2011-07-15 22:06:36 +0000
+++ landscape/player/service.py	1970-01-01 00:00:00 +0000
@@ -1,37 +0,0 @@
-"""Deployment code for the player."""
-
-from landscape.service import run_landscape_service
-from landscape.broker.config import BrokerConfiguration
-from landscape.broker.service import BrokerService
-from landscape.player.player import PayloadPlayer
-from landscape.player.reader import PayloadReader
-
-
-class PlaybackService(BrokerService):
-    service_name = "player"
-
-    def __init__(self, config):
-        """
-        @param config: A L{BrokerConfiguration}.
-        """
-        # Disable recording while in playback mode.
-        config.record = None
-        super(PlaybackService, self).__init__(config)
-
-        self.payload_reader = PayloadReader(config.record_directory)
-        self.player = PayloadPlayer(self.payload_reader, self.exchanger, 1)
-
-    def startService(self):
-        """Start the broker.
-
-        Start the L{MessageExchange}, L{Pinger} and L{Player} services.
-        """
-        self.exchanger.start()
-        self.pinger.start()
-        self.player.load()
-        self.player.play()
-
-
-def run(args):
-    """Run the application, given some command line arguments."""
-    run_landscape_service(BrokerConfiguration, PlaybackService, args)

=== removed directory 'landscape/player/tests'
=== removed file 'landscape/player/tests/__init__.py'
=== removed file 'landscape/player/tests/test_player.py'
--- landscape/player/tests/test_player.py	2011-07-14 15:43:11 +0000
+++ landscape/player/tests/test_player.py	1970-01-01 00:00:00 +0000
@@ -1,58 +0,0 @@
-from landscape.lib import bpickle
-from landscape.player.player import PayloadPlayer
-from landscape.tests.helpers import LandscapeTest
-
-
-class PayloadReaderTest(LandscapeTest):
-
-    def test_load_calls_reader(self):
-        """Exchanges should be loaded from C{PayloadPlayer}."""
-        calls = []
-
-        class Reader(object):
-            def __init__(self, calls):
-                self.calls = calls
-
-            def load(self):
-                self.calls.append(True)
-                return []
-
-        player = PayloadPlayer(Reader(calls), None, 1)
-        player.load()
-        self.assertTrue(calls[0])
-
-    def test_load_orders_data(self):
-        """Exchanges should be ordered according to time offset."""
-
-        class Reader(object):
-
-            def load(self):
-                return [
-                    ("55.55", bpickle.dumps({"type": "message type"})),
-                    ("6.66", bpickle.dumps({"type": "message type 2"})),
-                ]
-
-        player = PayloadPlayer(Reader(), None, 1)
-        player.load()
-        self.assertEqual("6.66", player._data[0][0])
-
-    def test_play_should_schedule_exchanges(self):
-        """
-        Exchanges with messages should be scheduled for delivery.
-        """
-        calls = []
-
-        class Exchange(object):
-
-            def __init__(self, calls):
-                self.calls = calls
-
-            def send_at(self, offset, messages):
-                self.calls.append((offset, messages))
-
-        player = PayloadPlayer(None, Exchange(calls), 1)
-        player._data = [("6", bpickle.dumps({"messages": ["in a bottle"]}))]
-        player.play()
-
-        self.assertEqual(6, int(calls[0][0]))
-        self.assertEqual(["in a bottle"], calls[0][1])

=== removed file 'landscape/player/tests/test_reader.py'
--- landscape/player/tests/test_reader.py	2011-07-18 13:35:59 +0000
+++ landscape/player/tests/test_reader.py	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-from landscape.broker.transport import PayloadRecorder
-from landscape.player.reader import PayloadReader
-from landscape.tests.helpers import LandscapeTest
-
-
-class PayloadReaderTest(LandscapeTest):
-
-    def test_load_returns_filename(self):
-        """
-        Each server exchange is saved in a file with the filename being the
-        offset in seconds since recording started.  C{PayloadPlayer.load()}
-        should return the filename in addition to the file contents.
-        """
-        path = self.makeDir()
-        recorder = PayloadRecorder(path)
-
-        def static_filename():
-            return "filename"
-        recorder.get_payload_filename = static_filename
-        recorder.save("payload data")
-
-        reader = PayloadReader(path)
-        payloads = reader.load()
-
-        self.assertEqual("filename", payloads[0][0])
-        self.assertEqual("payload data", payloads[0][1])
-
-    def test_load_returns_multiple_files(self):
-        """
-        Multiple exchanges should be handled in the same manner as
-        a single server exchange.
-        """
-        path = self.makeDir()
-        recorder = PayloadRecorder(path)
-        recorder.save("payload data")
-        recorder.save("other data")
-
-        reader = PayloadReader(path)
-        payloads = reader.load()
-
-        self.assertEqual("payload data", payloads[0][1])
-        self.assertEqual("other data", payloads[1][1])

=== modified file 'landscape/upgraders/__init__.py'
--- landscape/upgraders/__init__.py	2011-07-15 21:44:42 +0000
+++ landscape/upgraders/__init__.py	2012-03-07 08:45:23 +0000
@@ -1,4 +1,4 @@
-from landscape.upgraders import legacy, broker, monitor, package, player
+from landscape.upgraders import legacy, broker, monitor, package
 
 
 UPGRADE_MANAGERS = {
@@ -6,6 +6,4 @@
     "legacy": legacy.upgrade_manager,
     "broker": broker.upgrade_manager,
     "monitor": monitor.upgrade_manager,
-    "package": package.upgrade_manager,
-    "player": player.upgrade_manager,
-    }
+    "package": package.upgrade_manager}

=== removed file 'landscape/upgraders/player.py'
--- landscape/upgraders/player.py	2011-06-30 15:27:36 +0000
+++ landscape/upgraders/player.py	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-from landscape.patch import UpgradeManager
-
-upgrade_manager = UpgradeManager()

=== removed file 'scripts/landscape-player'
--- scripts/landscape-player	2011-06-30 15:27:36 +0000
+++ scripts/landscape-player	1970-01-01 00:00:00 +0000
@@ -1,8 +0,0 @@
-#!/usr/bin/python
-import sys, os
-if os.path.dirname(os.path.abspath(sys.argv[0])) == os.path.abspath("scripts"):
-    sys.path.insert(0, "./")
-
-from landscape.player.service import run
-
-run(sys.argv)