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 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 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 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 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 __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 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()
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 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()
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 __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()
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()
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 __init__(self, worklog_file_name):
self.worklog_file_name = worklog_file_name
self.task_manager = TaskManager(worklog_file_name)
if not os.path.exists(FILE_DIR):
os.mkdir(FILE_DIR)
# ------------------------------------------------ #
# Init background scheduler for processing tasks
# & set background executors.
# ------------------------------------------------ #
executors = {'default': ThreadPoolExecutor(8)}
scheduler = BackgroundScheduler(executors=executors)
scheduler.start()
# ------------------------------------------------ #
# Init managers
# ------------------------------------------------ #
manager = TaskManager()
add_to_scheduler(scheduler, manager)
# ------------------------------------------------ #
# Init schema for validation input data
# ------------------------------------------------ #
schema = {
'type': 'object',
'properties': {
'url': {
'type': 'string'
},
},
'required': ['url']
}
def CancelTask(data):
task_id = data.get("task_id", None)
if not task_id:
raise InvalidParamError("task_id param is needed.")
tmgr = TaskManager()
return tmgr.cancel_task(task_id)
def __init__(self):
self.account_mgr = AccountManager()
self.board = Board()
self.task_mgr = TaskManager()
self.pixels = []
SCOPES = 'https://www.googleapis.com/auth/spreadsheets'
store = file.Storage('credentials.json')
creds = store.get()
if not creds or creds.invalid:
flow = client.flow_from_clientsecrets('client_secret_3.json', SCOPES)
creds = tools.run_flow(flow, store)
service = build('sheets', 'v4', http=creds.authorize(Http()))
# Call the Sheets API
SPREADSHEET_ID = '1vMFRfLKJV2hJv1KW2KgP52Ltv6-g8MzCL0sNyt9pApM'
RANGE_NAME = 'TEST!A2:E2'
result = service.spreadsheets().values().get(spreadsheetId=SPREADSHEET_ID,
range=RANGE_NAME).execute()
tasks_file = "tasks.csv"
task_manager = TaskManager(tasks_file)
tasks = task_manager.generate_task_fields()
print(tasks)
# dropdown_menu = DropdownMenu("names.csv")
# dropdown_request = dropdown_menu.generate_request(0, 3, 4, 1, 5)
# editors = ["*****@*****.**"]
# lock_cells = LockCells(editors)
# lock_cells_request = lock_cells.generate_request(0, 5, 6, 0, 5)
# body = {
# "requests": [dropdown_request, lock_cells_request]
# }
# response = service.spreadsheets() \
# .batchUpdate(spreadsheetId=SPREADSHEET_ID, body=body).execute()
import config
from flask_caching import Cache
from task import TaskManager
app = Flask(__name__)
recaptcha = ReCaptcha(app=app,
site_key=config.CAPTCHA_SITE_KEY,
secret_key=config.CAPTCHA_SECRET_KEY)
app.secret_key = config.FLASK_SECRET
db = Database("db.sqlite3")
cache = Cache(app, config={'CACHE_TYPE': 'simple'})
app.jinja_env.globals.update(truncate_path=od_util.truncate_path)
app.jinja_env.globals.update(get_color=od_util.get_color)
app.jinja_env.globals.update(get_mime=od_util.get_mime)
tm = TaskManager()
@app.template_filter("datetime_format")
def datetime_format(value, format='%Y-%m-%d %H:%M UTC'):
return time.strftime(format, time.gmtime(value))
@app.route("/dl")
def downloads():
try:
export_file_stats = os.stat("static/out.csv.xz")
except FileNotFoundError:
print("No export file")
export_file_stats = None
return jsonify({
'code': 20000,
'data': {
'roles': ['admin'],
'introduction': 'I am a super administrator',
'avatar':
'https://wpimg.wallstcn.com/f778738c-e4f8-4870-b634-56703b4acafe.gif',
'name': 'Super Admin'
}
})
@app.route('/api/vue-admin-template/user/logout', methods=['POST'])
def user_logout():
"""
退出登录
:return:
"""
return jsonify({'code': 20000, 'data': 'success'})
if __name__ == "__main__":
# Linux平台启动
if platform.system() == 'Linux':
mp.set_start_method('spawn', force=True)
server_loger = get_logger()
create_database(True)
img_info_pool = ImgInfoPool(max_size=30)
task_manger = TaskManager(img_info_pool)
app.run(port=3001, debug=True)
def __init__(self):
self.taskmanager = TaskManager()
self.currentoption = None
#! /usr/bin/env python3
# -*- coding:utf-8 -*-
from task import TaskManager
from server import EchoHandler, CommanderServer
task_manager = TaskManager()
class CommandHandler(EchoHandler):
task = None
def handle(self):
print('Got connection from: ', self.client_address)
# 告诉士兵，连接建立完毕
self.send_command(b'done')
while True:
report = self.request.recv(1024)
self.deal(report)
def deal(self, report):
if report == b'start':
"""士兵报告可以开始"""
# 获取任务
self.task = task_manager.get_task()
# 读取图片，并发给士兵
with open(self.task.person.person_image, 'rb') as file:
self.wfile.write(file.read())
