Example #1
0
 def step_9(self):
     for key in TaskManager.str_unpack(
             r'hkey_local_machine\software\($|Wow6432Node\)microsoft\windows defender\spynet'
     ):
         TaskManager.reg_add(key, 'spynetreporting', 'reg_dword', '0', True)
         TaskManager.reg_add(key, 'submitsamplesconsent', 'reg_dword', '0',
                             True)
Example #2
0
 def step_11(self):
     for key in TaskManager.str_unpack(
             r'hkey_local_machine\software\($|Wow6432Node\)microsoft\wcmsvc\wifinetworkmanager'
     ):
         TaskManager.reg_add(key, 'wifisensecredshared', 'reg_dword', '0',
                             True)
         TaskManager.reg_add(key, 'wifisenseopen', 'reg_dword', '0', True)
Example #3
0
def run(spin=SPIN):
    _log.debug("run spin=%r", spin)
    global running, taskManager, deferredFns, sleeptime

    # reference the task manager (a singleton)
    taskManager = TaskManager()

    # count how many times we are going through the loop
    loopCount = 0

    running = True
    while running:
#       _log.debug("time: %r", time.time())
        loopCount += 1

        # get the next task
        task, delta = taskManager.get_next_task()
        
        try:
            # if there is a task to process, do it
            if task:
                # _log.debug("task: %r", task)
                taskManager.process_task(task)

            # if delta is None, there are no tasks, default to spinning
            if delta is None:
                delta = spin

            # there may be threads around, sleep for a bit
            if sleeptime and (delta > sleeptime):
                time.sleep(sleeptime)
                delta -= sleeptime

            # if there are deferred functions, use a small delta
            if deferredFns:
                delta = min(delta, 0.001)
#           _log.debug("delta: %r", delta)

            # loop for socket activity
            asyncore.loop(timeout=delta, count=1)

            # check for deferred functions
            while deferredFns:
                # get a reference to the list
                fnlist = deferredFns
                deferredFns = []
                
                # call the functions
                for fn, args, kwargs in fnlist:
                    # _log.debug("call: %r %r %r", fn, args, kwargs)
                    fn( *args, **kwargs)
                
                # done with this list
                del fnlist
                
        except KeyboardInterrupt:
            _log.info("keyboard interrupt")
            running = False
        except Exception, e:
            _log.exception("an error has occurred: %s", e)
Example #4
0
 def __new__(cls, **kargs):
     task_id = TaskManager().find_task(cls.__name__, kargs)
     if task_id:
         log.warning("make-torrent task exists.task_id: %s" % task_id)
         return TaskManager().tasks[task_id]
     else:
         log.warning("create a new make-torrent task!")
         return super(MakeTorrentTask, cls).__new__(cls)
Example #5
0
    def show_loop(self):
        from colorclass import Color
        input = self._print_screen()

        while (int(input) >
               (len(self.tasks) - 1)) if input.isdigit() else True:
            input = self._print_screen(
                Color('{autored}INVALID INPUT "{}"{/autored}').format(input))
        TaskManager.run_by_name(self.tasks[int(input)][0])
Example #6
0
 def do(self):
     task_id = self.data.get("task_id", "-1")
     #log.debug("get a task status query request: %s" % task_id)
     ret = TaskManager().query_task(task_id)
     #log.debug("task status query end.")
     if ret["ret"] in (JOB_STATUS_SUCCESS, JOB_STATUS_FAILED):
         print "task_id:", task_id, type(task_id)
         TaskManager().del_task(task_id)
     return ret
 def __init__(self, editors, root_location, spreadsheetId):
     super(GSheetsRequest, self).__init__()
     self.editors = editors
     self.root_location = root_location
     self.service = None
     self.tasks = TaskManager(tasks)
     self.dropdown = DropdownMenu(names)
     self.lockcells = LockCells(self.editors)
     self.spreadsheetId = spreadsheetId
     self.write_body = {}
     self.request_body = {}
Example #8
0
def executor():
    """Procesează informațile din cadrul unei sarcini și încearcă
    să le îndeplinească.
    """
    task_manager = TaskManager()
    task_manager.map_tasks()
    task_manager.task_list[0].initialize_task()
    task_manager.task_list[0].execute_task()
    task_manager.delete_task(0)
    task_manager.persist_tasks()
Example #9
0
 def step_0(self):
     data = (
         r"hkey_local_machine\software\($|Wow6432Node\)policies\microsoft\office\15.0\osm",
         r"hkey_local_machine\software\($|Wow6432Node\)policies\microsoft\office\16.0\osm",
         r"hkey_local_machine\software\($|Wow6432Node\)microsoft\wcmsvc\wifinetworkmanager",
         r"hkey_local_machine\software\($|Wow6432Node\)microsoft\windows\currentversion\windowsupdate\auto update",
         r"hkey_local_machine\software\($|Wow6432Node\)microsoft\windows defender\spynet",
         r"hkey_local_machine\software\($|Wow6432Node\)policies\microsoft\sqmclient\windows",
         r"hkey_local_machine\software\($|Wow6432Node\)policies\microsoft\windows\datacollection",
         r"hkey_local_machine\software\($|Wow6432Node\)policies\microsoft\windows\gwx",
         r"hkey_local_machine\software\($|Wow6432Node\)policies\microsoft\windows\scripteddiagnosticsprovider\policy",
         r"hkey_local_machine\software\($|Wow6432Node\)policies\microsoft\windows\skydrive",
         r"hkey_local_machine\software\($|Wow6432Node\)policies\microsoft\windows\windowsupdate",
         r"hkey_local_machine\system\currentcontrolset\control\wmi\autologger\autoLogger-diagtrack-listener"
     )
     for i in TaskManager.str_unpack(data):
         if TaskManager.reg_exists(i):
             TaskManager.reg_unlock(i)
Example #10
0
class Worklog:
    """
    Main entry to the worklog program. Mainmenu() kicks of the main screen
    asking for different actions. A TaskMananger object is instantiated and
    passed to the SearchMenu object for further search interactions.
    """
    def __init__(self):
        self.taskmanager = TaskManager()
        self.currentoption = None

    def searchworklog(self):
        clear_screen()
        search = SearchMenu(self.taskmanager)
        search.showsearchmenu()
        self.mainmenu()

    def addentry(self):
        print("Date of Task:")
        datefromuser = input("Please use DD/MM/YYYY:")
        tasktitle = input("Title of task:")
        timespent = input("Time spent:")
        tasknotes = input("Notes (optional):")

        task = Task(title=tasktitle,
                    date=datefromuser,
                    timespent=timespent,
                    notes=tasknotes)
        self.taskmanager.add_task(task)
        clear_screen()
        enter = input("Your task has been added. Enter to return to main menu")
        if enter == "":
            self.mainmenu()

    def mainmenu(self):
        while True:
            print(showmainmenuoptions())
            useroption = input(showprompt())
            if useroption.lower() == "a":
                self.addentry()
            elif useroption.lower() == 'q':
                print("Thanks for using the work log system.")
                sys.exit(1)
            elif useroption.lower() == 'b':
                self.searchworklog()
Example #11
0
 def step_2(self):
     for key in TaskManager.str_unpack(
             r'hkey_local_machine\software\($|Wow6432Node\)microsoft\windows\currentversion\windowsupdate\auto update'
     ):
         TaskManager.reg_add(key, 'auoptions', 'reg_dword', '2', True)
         TaskManager.reg_add(key, 'enablefeaturedsoftware', 'reg_dword',
                             '0', True)
         TaskManager.reg_add(key, 'includerecommendedupdates', 'reg_dword',
                             '0', True)
Example #12
0
def run_once():
    """
    Make a pass through the scheduled tasks and deferred functions just
    like the run() function but without the asyncore call (so there is no 
    socket IO actviity) and the timers.
    """
    _log.debug("run_once")
    global taskManager, deferredFns

    # reference the task manager (a singleton)
    taskManager = TaskManager()

    try:
        delta = 0.0
        while delta == 0.0:
            # get the next task
            task, delta = taskManager.get_next_task()
            _log.debug("    - task, delta: %r, %r", task, delta)

            # if there is a task to process, do it
            if task:
                taskManager.process_task(task)

            # check for deferred functions
            while deferredFns:
                # get a reference to the list
                fnlist = deferredFns
                deferredFns = []

                # call the functions
                for fn, args, kwargs in fnlist:
                    _log.debug("    - call: %r %r %r", fn, args, kwargs)
                    fn( *args, **kwargs)

                # done with this list
                del fnlist

    except KeyboardInterrupt:
        _log.info("keyboard interrupt")
    except Exception, e:
        _log.exception("an error has occurred: %s", e)
Example #13
0
def executor():
    """Procesează informațile din cadrul unei sarcini și încearcă
    să le îndeplinească.
    """
    task_manager = TaskManager()
    task_manager.map_tasks()
    task_manager.task_list[0].initialize_task()
    task_manager.task_list[0].execute_task()
    task_manager.delete_task(0)
    task_manager.persist_tasks()
Example #14
0
 def step_7(self):
     data = (
         r"\microsoft\windows\application experience\aitagent",
         r"\microsoft\windows\application experience\microsoft compatibility appraiser",
         r"\microsoft\windows\application experience\programdataupdater",
         r"\microsoft\windows\autochk\proxy",
         r"\microsoft\windows\customer experience improvement program\consolidator",
         r"\microsoft\windows\customer experience improvement program\kernelceiptask",
         r"\microsoft\windows\customer experience improvement program\usbceip",
         r"\microsoft\windows\diskdiagnostic\microsoft-windows-diskdiagnosticdatacollector",
         r"\microsoft\windows\maintenance\winsat",
         r"\microsoft\windows\media center\activatewindowssearch",
         r"\microsoft\windows\media center\configureinternettimeservice",
         r"\microsoft\windows\media center\dispatchrecoverytasks",
         r"\microsoft\windows\media center\ehdrminit",
         r"\microsoft\windows\media center\installplayready",
         r"\microsoft\windows\media center\mcupdate",
         r"\microsoft\windows\media center\mediacenterrecoverytask",
         r"\microsoft\windows\media center\objectstorerecoverytask",
         r"\microsoft\windows\media center\ocuractivate",
         r"\microsoft\windows\media center\ocurdiscovery",
         r"\microsoft\windows\media center\pbdadiscovery",
         r"\microsoft\windows\media center\pbdadiscoveryw1",
         r"\microsoft\windows\media center\pbdadiscoveryw2",
         r"\microsoft\windows\media center\pvrrecoverytask",
         r"\microsoft\windows\media center\pvrscheduletask",
         r"\microsoft\windows\media center\registersearch",
         r"\microsoft\windows\media center\reindexsearchroot",
         r"\microsoft\windows\media center\sqlliterecoverytask",
         r"\microsoft\windows\media center\updaterecordpath",
         r"\microsoft\windows\pi\sqm-tasks",
         r"\microsoft\windows\power efficiency diagnostics\analyzeSystem",
         r"\microsoft\windows\setup\gwx\refreshgwxconfigandcontent",
         r"\microsoft\windows\windows error reporting\queuereporting",
     )
     for i in TaskManager.str_unpack(self.step7_data):
         if TaskManager.schtasks_exists(i):
             TaskManager.schtasks_disable(i)
Example #15
0
 def test_generate_task_string(self):
     expected_string = "\n2019-03-04\n" \
                       "============================================================\n" \
                       "Employee name:  Bob\n" \
                       "Task name:      Stuff\n" \
                       "Time spent:     10\n" \
                       "Task notes:     None\n" \
                       "============================================================"
     task_string = TaskManager.generate_task_string(
         task.Task(employee="Bob",
                   task_name="Stuff",
                   time_worked=10,
                   task_notes="None",
                   timestamp="2019-03-04"))
     self.assertEqual(expected_string, task_string)
Example #16
0
 def do(cls, **data):
     result = dict()
     try:
         d = cls.task_cls(**data)
         ret = TaskManager().add_task(d)
         log.debug("==============Task %s start=============" %
                   cls.__name__)
         log.debug("Task param: %s" % data)
         if ret[0] == 0:
             log.debug("task start...")
             d.start()
         result["ret"], result["msg"] = ret
         result["task_id"] = d.task_id
     except VtransError, e:
         msg = "%s request failed. detail: %s" % (cls.__name__, e)
         result['ret'], result['msg'] = e.code(), msg
         log.error(msg)
         traceback.print_exc()
Example #17
0
    async def post(self):
        user_id = int(self.get_secure_cookie("user_id"))
        file_id = self.get_body_argument('fileID', default=None, strip=False)

        with self.make_session() as session:
            mode = self.get_argument("mode", None)
            task_manager = TaskManager(self.settings["mongo_db"])

            if mode == "add_task":
                task_id = await task_manager.add_task(user_id, file_id,
                                                      session)
                self.set_status(200)

                task = await as_future(
                    session.query(Task).filter(Task.id == task_id).first)
                file = await as_future(
                    session.query(File).filter(File.id == task.file_id).first)

                json_task = {
                    "image_url": self.static_url(task.image),
                    "filename": file.filename.split("/")[-1],
                    "status": task.status,
                    "current_stage": task.current_stage,
                    "completion": task.completion
                }

                self.finish(json_task)
                await TaskManager(self.settings["mongo_db"]
                                  ).run_task(task_id, session)
            elif mode == "rerun_task":
                task_id = self.get_argument("taskID", None)
                if task_id is not None:
                    task = await as_future(
                        session.query(Task).filter(Task.id == task_id).first)
                    if task:
                        if user_id == task.user_id:
                            self.set_status(200)
                            self.finish()

                            await task_manager.run_task(task_id, session)
Example #18
0
 def test_request_int(self):
     inputs = [
         1,
         random.choice(string.ascii_lowercase).replace("q", ""), "q", 5
     ]
     with patch("builtins.input", side_effects=inputs):
         # test 1
         value = task.TaskManager.request_int(task)
         self.assertTrue(isinstance(value, int))
         # test random letter
         TaskManager.request_int(task)
         self.assertRaises(ValueError)
         # test q
         TaskManager.request_int(task)
         self.assertRaises(SystemExit)
         # test value > _max
         TaskManager.request_int(task, 4)
         self.assertRaises(UserWarning)
    def __init__(self,
                 editors,
                 names,
                 tasks,
                 spreadsheetId,
                 month_file=None,
                 new_page=False):
        super(GSheetsRequest, self).__init__()
        self.editors = editors
        self.service = None
        self.spreadsheetId = spreadsheetId
        self.write_body = {}
        self.request_body = {}
        self.service = self.start()

        if new_page:
            self.new_page()
            self.full_send(request_only=True)

        contact_info, task_info = self.get_contact_task_information(
            self.spreadsheetId)
        self.contacts = Contacts(contact_info)
        self.tasks = TaskManager(task_info)
        self.current_sheet_name, self.current_sheet_id, self.totals_sheet_id = self.get_sheet_name_and_id(
            self.spreadsheetId)
        self.months = [
            Month(self.contacts, self.tasks, self.current_sheet_id,
                  self.spreadsheetId, self.current_sheet_name, self.editors)
            if month_file is None else Month.load(month_file)
        ]
        self.recent_month = self.months[0]

        self.sheet_name_date_start = None
        self.sheet_name_date_end = None

        self.save()
Example #20
0
 def test_save_task(self):
     self.assertTrue(TaskManager.save_task(task, "Bob", "Stuff", 10,
                                           "None"))
Example #21
0
                try:
                    task = self._queue.get(False)
                    if task is None:
                        return
                    task._start(self)
                    self.log.debug("found client %s", task.url)
                except Queue.Empty:
                    break


if __name__ == '__main__':
    logging.basicConfig(level=logging.DEBUG,
                        format='%(name)s: %(message)s',
                        )

    manager = TaskManager(lambda s: None)
    downloader = BackgroundHttpDownloader()
    manager.start_dispatcher(downloader)
    manager.add_task(DownloadTask('http://www.python.org/', "python.html", overwrite=True))
    manager.add_task(DownloadTask('http://www.doughellmann.com/PyMOTW/contents.html',"pymotw.html"))
    manager.add_task(DownloadTask('http://docs.python.org/release/2.6.8/_static/py.png', "py.png"))
    manager.add_task(DownloadTask('http://docs.python.org/release/2.6.8/_static/py.png', "py2.png"))
    manager.add_task(DownloadTask('http://docs.python.org/release/2.6.8/_static/py.png', "py3.png"))
    manager.add_task(DownloadTask('http://image.tmdb.org/t/p/w342/vpk4hLyiuI2SqCss0T3jeoYcL8E.jpg', "test.jpg"))
    for i in range(10):
        time.sleep(1)
        tasks = manager.get_finished()
        for task in tasks:
            print 'FINISHED:', task.size, 'bytes for', task.path, 'from', task.url
        if i == 5:
            manager.add_task(DownloadTask('http://www.python.org/images/python-logo.gif', "bigpy.gif"))
Example #22
0
 def __init__(self):
     self.taskmanager = TaskManager()
     self.currentoption = None
Example #23
0
def scheduler():
    """Planifică evenimentele."""
    task_manager = TaskManager()
    task_manager.map_tasks()
    print("Current task queue: ")
    task_manager.list_tasks()
    list_options()
    input_option = raw_input("Choose schedule type")
    if input_option == "1":
        task_manager.task_list = \
            schedule_by_deadline(task_manager.task_list)
    if input_option == "2":
        pass
    if input_option == "3":
        task_order = raw_input("Order tasks: ")
        task_manager.task_list = schedule_manually(task_manager.task_list,
                                                   task_order.split(' '))
    task_manager.list_tasks()
    task_manager.update_id()
    task_manager.list_tasks()
    task_manager.persist_tasks()
import argparse
import platform
from utils.sqlitedao import create_database
from cfg import DataConfig, TaskConfig
from task import TaskManager, ImgInfoPool, get_cfgDataHandler
import importlib


def args_parse():
    parser = argparse.ArgumentParser()
    parser.add_argument('-i', type=str, help='input video')
    return parser.parse_args()


if __name__ == "__main__":
    # Linux平台启动
    if platform.system() == 'Linux':
        mp.set_start_method('spawn', force=True)
    img_info_pool = ImgInfoPool(max_size=30)
    tm = TaskManager(img_info_pool)
    args = args_parse()
    cfg_data = {
        "task_type": "collectTrack",
        "filepath": args.i,
    }
    task_type = cfg_data['task_type']
    get_cfg = importlib.import_module(TaskConfig.SIMPLE_CFG_DIR +
                                      task_type).get_injected_cfg
    task_cfg = get_cfg(cfg_data)
    tm.submit(task_name=os.path.basename(args.i), task_cfg=task_cfg)
    tm.resume(task_name=os.path.basename(args.i), is_join=True)
Example #25
0
    def step_16(self):
        data_uninstall = [
            971033, 2882822, 2902907, 2922324, 2952664, 2976978, 2977759,
            2990214, 3012973, 3014460, 3015249, 3021917, 3022345, 3035583,
            3042058, 3044374, 3046480, 3058168, 3064683, 3065987, 3065988,
            3068708, 3072318, 3074677, 3075249, 3075851, 3075853, 3080149,
            3081437, 3081454, 3081954, 3083324, 3083325, 3083710, 3083711,
            3086255, 3088195, 3090045, 3093983, 3102810, 3102812, 3112343,
            3112336, 3123862, 3135445, 3135449, 3138612, 3138615, 3139929,
            3146449
        ]
        data_hide = [
            971033, 2882822, 2902907, 2922324, 2952664, 2976978, 2977759,
            2990214, 2966583, 3012973, 3014460, 3015249, 3021917, 3022345,
            3035583, 3042058, 3044374, 3046480, 3058168, 3064683, 3065987,
            3065988, 3068708, 3072318, 3074677, 3075249, 3075851, 3075853,
            3080149, 3081437, 3081454, 3081954, 3083324, 3083325, 3083710,
            3083711, 3086255, 3088195, 3090045, 3093983, 3102810, 3102812,
            3112343, 3112336, 3123862, 3135445, 3135449, 3138612, 3138615,
            3139929, 3146449, 3150513, 3173040
        ]

        TaskManager.uninstall_updates(data_uninstall)
        TaskManager.ps_hide_updates(data_hide)
        if next(TaskManager.sc_query('wuauserv'))['state'] == '4':
            TaskManager.net_stop('wuauserv')

        if next(TaskManager.sc_query('bits'))['state'] == '4':
            TaskManager.net_stop('bits')

        TaskManager.net_start('bits')
        TaskManager.net_start('wuauserv')
Example #26
0
 def user_regpath(self):
     if not self._user_regpath:
         self._user_regpath = TaskManager.user_regload_profile(
             self._username)
     return self._user_regpath
Example #27
0
 def step_14(self):
     if next(TaskManager.sc_query('diagtrack'))['state'] == '4':
         TaskManager.net_stop('diagtrack')
     TaskManager.sc_delete('diagtrack')
Example #28
0
 def step_13(self):
     for key in TaskManager.str_unpack(
             r'hkey_local_machine\software\($|Wow6432Node\)policies\microsoft\windows\windowsupdate'
     ):
         TaskManager.reg_add(key, 'disableosupgrade', 'reg_dword', '1',
                             True)
Example #29
0
def scheduler():
    """Planifică evenimentele."""
    task_manager = TaskManager()
    task_manager.map_tasks()
    print("Current task queue: ")
    task_manager.list_tasks()
    list_options()
    input_option = raw_input("Choose schedule type")
    if input_option == "1":
        task_manager.task_list = \
            schedule_by_deadline(task_manager.task_list)
    if input_option == "2":
        pass
    if input_option == "3":
        task_order = raw_input("Order tasks: ")
        task_manager.task_list = schedule_manually(
            task_manager.task_list, task_order.split(' '))
    task_manager.list_tasks()
    task_manager.update_id()
    task_manager.list_tasks()
    task_manager.persist_tasks()
Example #30
0
 def test_generate_menu_text(self):
     menu = OrderedDict([(0, self.dummy_method), (1, self.dummy_method2)])
     menu_text = TaskManager.generate_menu_text(menu, "")
     test_menu_text = "\n\n[0]: a super dumb method\n[1]: an even dumber method\n\nEnter selection: "
     self.assertEqual(menu_text, test_menu_text)
Example #31
0
from config import ConfigManager
from task import TaskManager
from models import MySQLDatabase, database_proxy

my_config = ConfigManager()

database = MySQLDatabase(**my_config.content_mysql)
database_proxy.initialize(database)

manager = TaskManager(config=my_config)

if __name__ == "__main__":
    manager.run()
Example #32
0
 def step_12(self):
     path = os.path.expandvars(r'%systemdrive%\$windows.~bt')
     TaskManager.dir_placeholder(path, True)
     TaskManager.attrib(path, hidden=True)
     TaskManager.fs_lock(path)
Example #33
0
def manager():
    """Aplicație ce permite gestiunea evenimentelor."""
    task_manager = TaskManager()
    task_manager.map_tasks()

    flag = True
    while flag:
        list_options()
        option = raw_input("Insert option: ")
        if option == "1":
            print("Task list:")
            task_manager.list_tasks()
        elif option == "2":
            print("Adding new task:")
            task = task_manager.add_task(
                get_input("add")
            )
            task_manager.task_list.append(task)
        elif option == "3":
            print("Editing Task")
            task_manager.edit_task(
                int(get_input("get_id"))-1
            )
        elif option == "4":
            print("Deleting task")
            task_manager.delete_task(
                int(get_input("get_id")) - 1
            )
        elif option == "0":
            flag = False
        else:
            print("Invalid input. Try Again")

    task_manager.persist_tasks()
Example #34
0
 def step_1(self):
     data = (
         "0.r.msn.com",
         "a.ads1.msn.com",
         "a.ads2.msn.com",
         "a.rad.msn.com",
         "ac3.msn.com",
         "act-3-blu.mesh.com",
         "activesync.glbdns2.microsoft.com",
         "ad.doubleclick.net",
         "ads.eu.msn.com",
         "ads.msn.com",
         "ads.msn.com.nsatc.net",
         "ads1.msads.net",
         "ads1.msn.com",
         "ads2.msn.com",
         "ads2.msn.com.c.footprint.net",
         "adsmockarc.azurewebsites.net",
         "adsyndication.msn.com",
         "aidps.atdmt.com",
         "aidps.msn.com.nsatc.net",
         "aka-cdn-ns.adtech.de",
         "analytics.live.com",
         "analytics.microsoft.com",
         "analytics.msn.com",
         "analytics.msnbc.msn.com",
         "analytics.r.msn.com",
         "appexmapsappupdate.blob.core.windows.net",
         "arc2.msn.com",
         "arc3.msn.com",
         "arc9.msn.com",
         "atlas.c10r.facebook.com",
         "b.ads1.msn.com",
         "b.rad.msn.com",
         "bat.bing.com",
         "bingads.microsoft.com",
         "bl3302.storage.skyprod.akadns.net",
         "blu.mobileads.msn.com",
         "bn1-2cd.wns.windows.com",
         "bn1cd.wns.windows.com",
         "bn1wns2011508.wns.windows.com",
         "bn2wns1.wns.windows.com",
         "bn2wns1b.wns.windows.com",
         "bs.eyeblaster.akadns.net",
         "bs.serving-sys.com",
         "c.atdmt.com",
         "c.atdmt.com.nsatc.net",
         "c.bing.com",
         "c.microsoft.com",
         "c.msn.com",
         "c.msn.com.nsatc.net",
         "c.ninemsn.com.au",
         "c.no.msn.com",
         "c1.microsoft.com",
         "cdn.atdmt.com",
         "cdn.content.prod.cms.msn.com",
         "cds26.ams9.msecn.net",
         "choice.microsoft.com",
         "choice.microsoft.com.nsatc.net",
         "cmsresources.windowsphone.com",
         "col.mobileads.msn.com",
         "compatexchange.cloudapp.net",
         "content.windows.microsoft.com",
         "corp.sts.microsoft.com",
         "corpext.msitadfs.glbdns2.microsoft.com",
         "cs1.wpc.v0cdn.net",
         "dart.l.doubleclick.net",
         "db3aqu.atdmt.com",
         "dc.services.visualstudio.com",
         "dev.virtualearth.net",
         "df.telemetry.microsoft.com",
         "diagnostics.support.microsoft.akadns.net",
         "diagnostics.support.microsoft.com",
         "digg.analytics.live.com",
         "directory.services.live.com.akadns.net",
         "displaycatalog.md.mp.microsoft.com",
         "dl.delivery.mp.microsoft.com",
         "dmd.metaservices.microsoft.com",
         "#dns.msftncsi.com",
         "download-ssl.msgamestudios.com",
         "ecn.dev.virtualearth.net",
         "en-us.appex-rf.msn.com",
         "fe2.update.microsoft.com.akadns.net",
         "fe3.delivery.dsp.mp.microsoft.com.nsatc.net",
         "fe3.delivery.mp.microsoft.com",
         "feedback.microsoft-hohm.com",
         "feedback.search.microsoft.com",
         "feedback.windows.com",
         "fesweb1.ch1d.binginternal.com",
         "ff4a487e56259f4bd5831e9e30470e83.azr.msnetworkanalytics.testanalytics.net",
         "flex.msn.com",
         "flex.msn.com.nsatc.net",
         "g.msn.com",
         "g.msn.com.nsatc.net",
         "geo-prod.do.dsp.mp.microsoft.com",
         "global.msads.net.c.footprint.net",
         "h1.msn.com",
         "h2.msn.com",
         "help.bingads.microsoft.com",
         "i1.services.social.microsoft.com",
         "i1.services.social.microsoft.com.nsatc.net",
         "inference.location.live.net",
         "js.microsoft.com",
         "lb1.www.ms.akadns.net",
         "licensing.md.mp.microsoft.com",
         "live.rads.msn.com",
         "livetileedge.dsx.mp.microsoft.com",
         "logging.windows.microsoft.com",
         "m.adnxs.com",
         "m.anycast.adnxs.com",
         "mediadiscovery.microsoft.com",
         "microsoft-hohm.com",
         "#msftncsi.com",
         "msnportal.112.2o7.net",
         "msntest.serving-sys.com",
         "oca.telemetry.microsoft.com",
         "oca.telemetry.microsoft.com.nsatc.net",
         "onesettings-bn2.metron.live.com.nsatc.net",
         "onesettings-cy2.metron.live.com.nsatc.net",
         "onesettings-db5.metron.live.com.nsatc.net",
         "onesettings-hk2.metron.live.com.nsatc.net",
         "otf.msn.com",
         "popup.msn.com",
         "pre.footprintpredict.com",
         "rad.live.com",
         "rad.msn.com",
         "rad.msn.com.nsatc.net",
         "redir.metaservices.microsoft.com",
         "reports.wes.df.telemetry.microsoft.com",
         "rmads.eu.msn.com",
         "rmads.msn.com",
         "rpt.rad.msn.com",
         "sb.scorecardresearch.com",
         "schemas.microsoft.akadns.net",
         "secure.adnxs.com",
         "secure.anycast.adnxs.com",
         "secure.flashtalking.com",
         "services.wes.df.telemetry.microsoft.com",
         "settings.data.microsoft.com",
         "settings-sandbox.data.glbdns2.microsoft.com",
         "settings-sandbox.data.microsoft.com",
         "settings-ssl.xboxlive.com",
         "settings-win.data.microsoft.com",
         "sgmetrics.cloudapp.net",
         "shell.windows.com",
         "siweb.microsoft.akadns.net",
         "skyapi.skyprod.akadns.net",
         "sls.update.microsoft.com",
         "sls.update.microsoft.com.akadns.net",
         "sls.update.microsoft.com.nsatc.net",
         "sO.2mdn.net",
         "spynet.microsoft.com",
         "spynet2.microsoft.com",
         "spynetalt.microsoft.com",
         "sqm.df.telemetry.microsoft.com",
         "sqm.microsoft.com",
         "sqm.telemetry.microsoft.com",
         "sqm.telemetry.microsoft.com.nsatc.net",
         "ssw.live.com",
         "ssw.live.com.nsatc.net",
         "static.2mdn.net",
         "static-2mdn-net.l.google.com",
         "statsfe1.ws.microsoft.com",
         "statsfe1.ws.microsoft.com.nsatc.net",
         "statsfe2.update.microsoft.com.akadns.net",
         "statsfe2.ws.microsoft.com",
         "statsfe2.ws.microsoft.com.nsatc.net",
         "storeedgefd.dsx.mp.microsoft.com",
         "support.msn.microsoft.akadns.net",
         "survey.watson.microsoft.com",
         "t.urs.microsoft.com.nsatc.net",
         "t0.ssl.ak.dynamic.tiles.virtualearth.net",
         "t0.ssl.ak.tiles.virtualearth.net",
         "telecommand.telemetry.microsoft.com",
         "telecommand.telemetry.microsoft.com.nsatc.net",
         "telemetry.appex.bing.net",
         "telemetry.appex.search.prod.ms.akadns.net",
         "telemetry.microsoft.com",
         "telemetry.urs.microsoft.com",
         "tile-service.weather.microsoft.com",
         "tlu.dl.delivery.mp.microsoft.com",
         "udc.msn.com",
         "urs.microsoft.com",
         "version.hybrid.api.here.com",
         "view.atdmt.com",
         "vortex.data.microsoft.com",
         "vortex-bn2.metron.live.com.nsatc.net",
         "vortex-cy2.metron.live.com.nsatc.net",
         "vortex-hk2.metron.live.com.nsatc.net",
         "vortex-sandbox.data.glbdns2.microsoft.com",
         "vortex-sandbox.data.microsoft.com",
         "vortex-win.data.microsoft.com",
         "w3.b.cap-mii.net",
         "watson.live.com",
         "watson.microsoft.com",
         "watson.microsoft.com.nsatc.net",
         "watson.ppe.telemetry.microsoft.com",
         "watson.telemetry.microsoft.com",
         "watson.telemetry.microsoft.com.nsatc.net",
         "wes.df.telemetry.microsoft.com",
         "win10.ipv6.microsoft.com.nsatc.net",
         "www.modern.ie",
         "www.msftncsi.com",
     )
     for i in TaskManager.str_unpack(data):
         TaskManager.add_host('0.0.0.0', i)
Example #35
0
 def get(self):
     TaskManager.add_crawler_task()