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)
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)
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)
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)
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])
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 = {}
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()
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)
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()
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)
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)
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()
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)
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)
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()
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)
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()
def test_save_task(self):
self.assertTrue(TaskManager.save_task(task, "Bob", "Stuff", 10,
"None"))
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"))
def __init__(self):
self.taskmanager = TaskManager()
self.currentoption = None
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)
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')
def user_regpath(self):
if not self._user_regpath:
self._user_regpath = TaskManager.user_regload_profile(
self._username)
return self._user_regpath
def step_14(self):
if next(TaskManager.sc_query('diagtrack'))['state'] == '4':
TaskManager.net_stop('diagtrack')
TaskManager.sc_delete('diagtrack')
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)
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()
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)
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()
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)
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()
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)
def get(self):
TaskManager.add_crawler_task()