def __init__(self, bot, config):
self.bot = bot
self.config = config
self.statuses = statusstore()
self.about = "'sleekmotion_aways' Learn status messages from people, and use them.\nWritten by Kevin Smith"
self.bot.add_handler("<presence />", self.handle_presence)
thread.start_new(self.loop,())
def UpdatePlot(self, data, times):
if USE_THREADS:
if not self.plot.mutex.locked():
self.plot.mutex.acquire()
thread.start_new(self.plot.Update, (data, times))#self.plot.Update(data)
else:
self.plot.Update(data, times)
def start(self):
"""Start the uber basic interface.
All request are handled by BasicWeb method handle_request.
"""
def make_handler(parent):
class RequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
# A super-simple HTTP request handler:
def do_GET(self):
parent.handle_request("GET", self)
def do_POST(self):
parent.handle_request("POST", self)
def do_PUT(self):
parent.handle_request("PUT", self)
def do_DELETE(self):
parent.handle_request("DELETE", self)
def do_HEAD(self):
parent.handle_request("HEAD", self)
return RequestHandler
self.log.info("Creating FakeWebServer.")
self.server = StoppableTCPServer((self.interface, self.port), make_handler(self))
def _start(data=0):
self.log.info("start: URI<%s>" % self.uri)
self.server.serve_forever()
thread.start_new(_start, (0,))
def main():
# Set up arguments
parser = argparse.ArgumentParser()
parser.add_argument("-ps", "--port_server", help="Server for http client port", type=int, default=35001)
parser.add_argument("-pm", "--port_master", help="Master port toward the game instances", type=int, default=65523)
parser.add_argument("-sc", "--screen_config",
help="Pick a screen config of the available files inside the screenconfig folder",
type=str, default="default")
parser.add_argument("-t", "--time", help="How long should the game run before it shutdown, in second", type=int)
parser.add_argument("-m", "--measure", help="Should game resources be measured", type=bool, default=False)
args = parser.parse_args()
#Set up the Master connection
connection_point = mcp.MasterConnectionPoint('0.0.0.0',
args.port_master,
args.screen_config,
args.time,
args.measure)
app.connection_point = connection_point
thread.start_new(connection_point.listen_for_slaves, ())
signal.signal(signal.SIGINT, signal_handler)
#Start running flask
app.run(host='0.0.0.0', port=args.port_server)
def __init__(self, bot, config):
self.bot = bot
self.config = config
self.about = "Eggdropbot allows sleekbots to run Eggdrop IRC (TCL) scripts, providing the (currently partial) Eggdrop API re-implemented for XMPP MUC.\nWritten By: Kevin Smith"
self.bot.addIMCommand('eggdrop', self.handle_eggdrop)
self.bot.addMUCCommand('eggdrop', self.handle_eggdrop)
self.bot.addHelp('eggdrop', 'Eggdrop control command', "Configure eggdrop compatability support.", 'eggdrop [args]')
self.bot.add_event_handler("message", self.handle_message_event, threaded=True)
self.bot.add_event_handler("groupchat_message", self.handle_muc_event, threaded=True)
# queue of outgoing TCL
self.queue = Queue.Queue()
# list of incoming messages from tcl
self.messageQueue = []
#self.queueExec('puts "bert"')
#TCL support scripts - these are the TCL side of the eggdrop emulation
self.queueExec('source "plugins/eggdrop/support.tcl"')
self.queueExec('source "plugins/eggdrop/eggdropcompat.tcl"')
#load the user-specified eggdrop scripts
scripts = self.config.findall('script')
if scripts:
for script in scripts:
logging.info("eggdropbot.py loading script %s." % script.attrib['file'])
self.queueExec('source "scripts/' + script.attrib['file'] + '"')
thread.start_new(self.loop,())
def run():
try:
insert_iptables_rules()
thread.start_new(handle_nfqueue, ())
except:
LOGGER.exception('failed to start dns service')
dns_service_status.error = traceback.format_exc()
def parent():
i = 0
while 1:
i = i + 1
thread.start_new(child, (i,))
if raw_input() == "q":
break
def applyFunctionToNFrames(func, filesPerThread, nframes, conversionargs):
if (nframes < filesPerThread):
func(0, 0, nframes, conversionargs)
else:
try:
import thread
keepSpawning = 1
start = filesPerThread
end = filesPerThread
threadID = 1
# Create a mutex array
numThreads = nframes / filesPerThread
if (numThreads * filesPerThread < nframes):
numThreads = numThreads + 1
exitmutex = [0] * numThreads
while keepSpawning == 1:
end = end + filesPerThread
if (end >= nframes):
end = nframes
keepSpawning = 0
thread.start_new(
applyFunctionToNFramesWMutex,
(threadID, exitmutex, func, start, end, conversionargs))
start = start + filesPerThread
threadID = threadID + 1
# Do the first part of the work on the main thread.
applyFunctionToNFramesWMutex(0, exitmutex, func, 0, filesPerThread,
conversionargs)
# Wait for all of the threads to complete
while 0 in exitmutex:
pass
except ImportError:
print "Could not import threads module."
func(0, 0, nframes, conversionargs)
def __init__(self):
self.log = logging.getLogger()
logging.basicConfig()
self.log.setLevel(logging.DEBUG)
self.GPIO = GPIO.setmode(GPIO.BOARD)
self.log.debug('GPIO.BOARD')
thread.start_new(self.init,(7,))
def init_pipe():
try:
thread.start_new(socket_output_thread, ())
thread.start_new(socket_input_thread,())
except:
print "Could nor start pipe thread ...."
exit()
def aceptarConexionPlayerTCP(self):
print "Esperando aceptar conexion TCP por parte del player VLC"
thread.start_new(self.abrirVLC, ())
(self.socketClientePlayer,
self.direccionPlayer) = self.socketPlayerTCP.accept()
print "Conexion con el player aceptada"
print "Direccion player: ", self.direccionPlayer
def perspective_requestPassword(self, publicname, email):
# TODO: should have some logging here that can be linked to fail2ban
from newplayeremail import LostPasswordEmail
try:
a = Account.byPublicName(publicname)
except:
return (
-1,
"Unknown Public Name, please check spelling and case.\n\n If you continue to have problems, please contact support."
)
if a.email.lower() != email.lower():
return (
-1,
"Email doesn't match, please make sure to specify the email used when registering.\n\n If you continue to have problems, please contact support."
)
if not USE_WX:
import thread
thread.start_new(LostPasswordEmail,
(a.email, a.publicName, a.password))
return (0,
"Your password has been sent to the email address specified.")
def main():
global hpclient
try:
hpclient = hpfeeds.new(args.g[0], 10000, args.g[1], args.g[2])
if args.f:
f = open(args.f, 'a')
f.write('Starting Server at %s\n' % (str(now)))
f.close()
print("Starting NBNS Request Thread...")
thread.start_new(sender, ())
try:
print("Starting UDP Response Server...")
sniff(iface=iface,
filter="udp and port 137",
store=0,
prn=get_packet)
except KeyboardInterrupt:
print("\nStopping Server and Exiting...\n")
now3 = datetime.datetime.now()
if args.f:
f = open(args.f, 'a')
f.write('Stopping Server at %s\n' % (str(now3)))
f.close()
except Exception as err:
print("""Server could not be started, confirm you're running this
as root.\n %s""" % err)
except KeyboardInterrupt:
exit()
except Exception as err:
print("""Server could not be started, confirm you're running this
as root.\n %s""" % err)
finally:
hpclient.close()
def initEventLoop():
global sckt, debugging, hasPassedNameScreen, hasPassedMainScreen
playSound("bgm")
thread.start_new(connectServer, (1, connectAttempts))
while True:
for event in pygame.event.get():
if (event.type == KEYDOWN):
# print "key is", event.key, pygame.key.name(event.key)
if (event.key == K_RETURN):
if hasPassedMainScreen == True:
# has passed main screen
hasPassedNameScreen = True
if event.key<256:
if hasPassedNameScreen == False:
# is on name screen
sckt.send(chr(event.key))
else:
# is on game screen
sckt.send(chr(AltControls(event.key)))
hasPassedMainScreen = True
if (event.key == K_ESCAPE):
screen = pygame.display.set_mode((640, 480))
sys.exit(0)
elif event.type == USEREVENT:
line = event.serverLine
if debugging == 1:
print "about to process", line
processLine(line)
if line != 'sync':
historyList.append([line, pygame.time.get_ticks()])
if line == 'quit':
return
if line == 'abort':
sys.exit(0)
def __init__(self, serverIP, port=8000, autoEvents=True):
utils.logger.debug("RClient.__init__")
synchronized.Synchronized.__init__(self)
dMVC.setRClient(self)
self.__serverIP = serverIP
self.__serverPort = port
self.__rootModel = None
self.__sessionID = None
self.__version = None
self.__initialDataSemaphore = threading.Semaphore(0)
self.__answersCommandsList = []
self.__remoteSuscriptions = {}
self.__socket = None
self.__connect()
self.__commandQueue = Queue.Queue()
self.__asyncCommandQueue = Queue.Queue()
self.__asyncCallback = {}
self.__fragmentAnswer = {}
self.__autoEvents = autoEvents
if self.__autoEvents:
threadProcessCommand = threading.Thread(target=self.processCommandQueue)
threadProcessCommand.setDaemon(True)
threadProcessCommand.start()
thread.start_new(self.__start, ())
def startCell(self):
self._procs = []
modules = self._config.modules()
for module in modules:
print "Importing module %s" % module
exec("import %s" % module)
cmdlines = self._config.commandLines()
for cmd in cmdlines:
print "Running: %s" % (cmd)
pid = os.fork()
if pid==0: # child process
args = [sys.executable]+cmd
os.execvp(sys.executable, args)
# exec shouldn't return in child process
assert 0, "Error launching child process" # exec shou
else:
print "CellManager started child process with command: %s" % \
cmd
# Warning: Magic
args = cmd # [entity|entityservice, name, key]
port = 50000+pid
client = {'name':args[1], 'key':args[2], 'port':port,
'pid':pid, 'queue':Queue()}
thread.start_new(self.handleClient, (client,))
self._clients.append(client)
def resolveFakeDimensions (self, task):
netCdfObject = GmiNetCdfFileTools ()
print "about to start threads for resolving dimensions..."
exitMutexes = []
count = 0
for prefix in self.PREFIXES:
for resolution in ["2x2.5", "1x1.25", "0.625x0.5"]:
fileName = self.basePath + prefix + self.endPath + "." + resolution + ".nc"
if not os.path.exists (fileName): raise fileName + " does not exist! ERROR"
# for each file type fix the fake dimensions
exitMutexes.append (thread.allocate_lock())
thread.start_new (netCdfObject.resolveFieldDimensions, \
(fileName, count, self.GEOS5FIELDS, ['time', 'lat', 'lon'], exitMutexes[count]))
count = count + 1
#----------------------------------------------------------------
# Wait for all three threads before proceeding
#----------------------------------------------------------------
for mutex in exitMutexes:
while not mutex.locked ():
pass
print "All threads returned from resolveFieldDimensions"
def find_url(r, nused):
while True:
try:
for i in r["response"]["posts"]:
id = i["id"]
id = str(id)
#print id
test_url = 'http://api.tumblr.com/v2/blog/'+tumblr+'/posts?id='
test_url += str(i["id"]) + "&api_key=LavgbZzW1LV2skL5EMhhrEucUPikpP4Ag6KKNBJB77dojfzfaw"
#print test_url
testinfo = requests.get(test_url, auth=oauth).json()
for aa in testinfo["response"]["posts"]:
if 'photos' not in aa:
continue
else:
for bb in aa["photos"]:
#print bb["original_size"]["url"]
filename = str(bb["original_size"]["url"])
filename = filename.split('_', 1)[-1]
filename = os.path.join(dest_dir, filename)
while threading.activeCount() >= 100:
sleep(2)
else:
thread.start_new(download_url, (bb["original_size"]["url"], filename))
except requests.exceptions.RequestException:
global problem
problem = problem + 1
sleep(5)
continue
else:
break
def __init__(self):
QtGui.QMainWindow.__init__(self, parent=getMayaWindow())
_DEFAULT_PORT = "18812"
# This is where the tmp geo will be saved (as .obj)
# and load in Houdini from.
self.PATH = os.path.join(os.environ['temp'],
"tmp.obj").replace('\\', '/')
self.setWindowTitle("Maya - Houdini bridge")
cw = QtGui.QWidget()
# Default connection variables
self.houdini_connexion = None
self.hou = None
# Switch variables
self.check_connection = True
self.dynamicCameraON = False
self.cancel = False
cw_layout = QtGui.QVBoxLayout()
cw_layout.setSpacing(10)
# Houdini connection UI
houConnectionLayout = QtGui.QHBoxLayout(spacing=20)
self.houConnectionLabel = QtGui.QLabel("Not connected to Houdini")
self.houConnectionBtn = QtGui.QPushButton("")
self.houConnectionBtn.setFlat(True)
self.houConnectionBtn.setIcon(
QtGui.QIcon(os.path.dirname(__file__) + "/icons/red_light.png"))
self.houConnectionBtn.setFixedSize(32, 32)
self.houConnectionBtn.setIconSize(QtCore.QSize(32, 32))
self.houConnectionBtn.clicked.connect(self._connectTOHou)
houConnectionLayout.addWidget(self.houConnectionBtn)
houConnectionLayout.addWidget(self.houConnectionLabel)
# Send geo button UI
self.sendGeoToHouBtn = QtGui.QPushButton(
"Send selected mesh to houdini", self)
self.sendGeoToHouBtn.clicked.connect(self.sendSelectionToHoudini)
self.sendGeoToHouBtn.setDisabled(True)
# Dynamic camera create / disable button
self.dynCamBtn = QtGui.QPushButton("Create/Enable Dynamic Camera")
self.dynCamBtn.clicked.connect(self.createDynamicCamera)
self.dynCamBtn.setDisabled(True)
cw_layout.addItem(houConnectionLayout)
cw_layout.addWidget(self.sendGeoToHouBtn)
cw_layout.addWidget(self.dynCamBtn)
cw.setLayout(cw_layout)
self.setCentralWidget(cw)
# Check here if we can connect to houdini or not
thread.start_new(self._connectionCheck, ())
def WaitFunc(Parent_, Msg_, Func_, FuncArgs_=(), FuncKW_={}, Frames_=None):
"""
Окно ожидания.
@param Parent_: Ссылка на окно.
@param Msg_: Текст диалога.
@param Func_: Функция, которую необходимо подождать.
@param FuncArgs_: Аргументы функции.
@param FuncKW_: Именованные аргументы функции.
@param Frames_: Файлы-кадры.
"""
global ic_wait_proccess_dlg
wait_result = [None]
if not Frames_:
# Определить кадры по умолчанию
wait_dir = os.path.dirname(__file__) + '/Wait/'
Frames_ = [
wait_dir + 'Wait1.png', wait_dir + 'Wait2.png',
wait_dir + 'Wait3.png', wait_dir + 'Wait4.png',
wait_dir + 'Wait5.png', wait_dir + 'Wait6.png',
wait_dir + 'Wait7.png', wait_dir + 'Wait8.png',
wait_dir + 'Wait9.png', wait_dir + 'Wait10.png',
wait_dir + 'Wait11.png', wait_dir + 'Wait12.png',
wait_dir + 'Wait13.png', wait_dir + 'Wait14.png',
wait_dir + 'Wait15.png'
]
ic_wait_proccess_dlg = wait_box = icWaitBox(Parent_, Msg_, Frames_)
wait_box.SetResultList(wait_result)
# Запустить функцию ожидания
thread.start_new(wait_box.Run, (Func_, FuncArgs_, FuncKW_))
wait_box.ShowModal()
wait_box.Destroy()
ic_wait_proccess_dlg = None
return wait_result[0]
def bConvert(self, widget, data=None):
self.response = gtk.RESPONSE_OK
self.ProgressBar = ProgressBar(self.__progress, self, self.DlgConvert)
self.ProgressBar.start()
thread.start_new(self.worker_thread, (self.convertToXML(), ))
def test_wait(self):
for i in range(NUM_THREADS):
thread.start_new(self.f, (i,))
time.sleep(LONGSLEEP)
a = self.alive.keys()
a.sort()
self.assertEquals(a, range(NUM_THREADS))
prefork_lives = self.alive.copy()
if sys.platform in ['unixware7']:
cpid = os.fork1()
else:
cpid = os.fork()
if cpid == 0:
# Child
time.sleep(LONGSLEEP)
n = 0
for key in self.alive:
if self.alive[key] != prefork_lives[key]:
n += 1
os._exit(n)
else:
# Parent
self.wait_impl(cpid)
# Tell threads to die
self.stop = 1
time.sleep(2*SHORTSLEEP) # Wait for threads to die
def main():
prog = Program()
print "Starting..."
#prog.Login_Online_DB() #moved to __init__
socketIO.on('sendLocation' + PhoneNumber, prog.Update_GPS_Socket)
socketIO.on('TakePic' + PhoneNumber, prog.Update_Picture_Socket)
socketIO.on('Light' + PhoneNumber, prog.Update_Light_Socket)
socketIO.on('sendHeartBit' + PhoneNumber, prog.Update_Pulse_Socket)
try:
thread1 = thread.start_new(prog.Get_Gps, ())
thread2 = thread.start_new(prog.Update_GPS_DB, ())
thread3 = thread.start_new(prog.leds_controler, ())
thread4 = thread.start_new(prog.Get_Pulse, ())
#thread5 = thread.start_new(prog.Get_temperature, ())
except:
print "Thread Exeption"
socketIO.wait(seconds=10000)
def main():
for i in range(NUM_THREADS):
thread.start_new(f, (i, ))
time.sleep(LONGSLEEP)
a = alive.keys()
a.sort()
verify(a == range(NUM_THREADS))
prefork_lives = alive.copy()
if sys.platform in ['unixware7']:
cpid = os.fork1()
else:
cpid = os.fork()
if cpid == 0:
# Child
time.sleep(LONGSLEEP)
n = 0
for key in alive.keys():
if alive[key] != prefork_lives[key]:
n = n + 1
os._exit(n)
else:
# Parent
spid, status = os.waitpid(cpid, 0)
verify(spid == cpid)
verify(status == 0,
"cause = %d, exit = %d" % (status & 0xff, status >> 8))
global stop
# Tell threads to die
stop = 1
time.sleep(2 * SHORTSLEEP) # Wait for threads to die
def __init__(self, bot, config):
self.bot = bot
self.config = config
self.about = "Attempts to keep Sleek in muc channels."
self.shuttingDown = False
thread.start_new(self.loop, ())
self.bot.add_handler("<message xmlns='jabber:client' type='error'><error type='modify' code='406' ><not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/></error></message>", self.handle_message_error)
def test_wait(self):
for i in range(NUM_THREADS):
thread.start_new(self.f, (i, ))
time.sleep(LONGSLEEP)
a = self.alive.keys()
a.sort()
self.assertEquals(a, range(NUM_THREADS))
prefork_lives = self.alive.copy()
if sys.platform in ['unixware7']:
cpid = os.fork1()
else:
cpid = os.fork()
if cpid == 0:
# Child
time.sleep(LONGSLEEP)
n = 0
for key in self.alive:
if self.alive[key] != prefork_lives[key]:
n += 1
os._exit(n)
else:
# Parent
self.wait_impl(cpid)
# Tell threads to die
self.stop = 1
time.sleep(2 * SHORTSLEEP) # Wait for threads to die
def test_fork(self):
# XXX This test depends on a multicore machine, as busy_thread must
# aquire the GIL the instant that the main thread releases it.
# It will incorrectly pass if the GIL is not grabbed in time.
import thread
import os
import time
if not hasattr(os, 'fork'):
skip("No fork on this platform")
run = True
done = []
def busy_thread():
while run:
time.sleep(0)
done.append(None)
try:
thread.start_new(busy_thread, ())
pid = os.fork()
if pid == 0:
os._exit(0)
else:
time.sleep(1)
spid, status = os.waitpid(pid, os.WNOHANG)
assert spid == pid
finally:
run = False
self.waitfor(lambda: done)
def __init__(self, acceptAllTokens=True):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind(("", 7534))
self.socket.listen(2)
self.connections = []
thread.start_new(self.main_loop, tuple())
def test_fork(self):
# XXX This test depends on a multicore machine, as busy_thread must
# aquire the GIL the instant that the main thread releases it.
# It will incorrectly pass if the GIL is not grabbed in time.
import thread
import os
import time
if not hasattr(os, 'fork'):
skip("No fork on this platform")
run = True
done = []
def busy_thread():
while run:
time.sleep(0)
done.append(None)
try:
thread.start_new(busy_thread, ())
pid = os.fork()
if pid == 0:
os._exit(0)
else:
time.sleep(1)
spid, status = os.waitpid(pid, os.WNOHANG)
assert spid == pid
finally:
run = False
self.waitfor(lambda: done)
def get_txt(lang):
try:
txt = open(langs[lang]).read()
return txt
except:
return "no input file"
thread.start_new()
def newAnalyse():
global processors
args = request.get_json()
analysisMode = args.get("mode", "psnr")
referenceVideo = args.get("reference", None)
videos = args.get("videos", None)
if referenceVideo == None or videos == None:
abort(400)
if not type(videos) == list and len(video) > 0:
abort(400)
if not type(referenceVideo) == unicode:
abort(400)
outputFile = os.path.join("results", str(uuid.uuid4()) + ".xml")
processor = QpsnrProcessor()
processor.analysisMode = analysisMode
processor.outputFile = outputFile
processor.referenceVideo = referenceVideo
processor.videos = videos
processors.append(processor)
thread.start_new(processors[len(processors) - 1].run, ())
return jsonify(processor.__dict__)
def run_websocket(self, url):
websocket.enableTrace(True)
if not self.client.ws:
self.client.ws = websocket.WebSocketApp(url=url,
on_message=self.on_message,
header=self.client.headers)
thread.start_new(self.client.ws.run_forever, ())
def main():
monitoring_channel = acquire_xos_monitoring_channel()
if not monitoring_channel:
print 'SRIKANTH: XOS monitoring_channel is not created... Create it before using this app'
return
loadAllXosTenantInfo()
loadAllXosInstanceInfo()
ceilometer_url = monitoring_channel['ceilometer_url']
if use_kafka:
thread.start_new(read_notification_from_ceilometer_over_kafka, (
KAFKA_SERVER_IP,
KAFKA_SERVER_PORT,
KAFKA_TOPIC,
))
subscribe_data = {
"sub_info": "cpu_util",
"app_id": "xos_auto_scale",
"target": LOCAL_KAFKA_TARGET_URL
}
else:
thread.start_new(read_notification_from_ceilometer, (
UDP_IP,
UDP_PORT,
))
subscribe_data = {
"sub_info": "cpu_util",
"app_id": "xos_auto_scale",
"target": "udp://10.11.10.1:12346"
}
subscribe_url = ceilometer_url + 'v2/subscribe'
response = requests.post(subscribe_url, data=json.dumps(subscribe_data))
print 'SRIKANTH: Ceilometer meter "cpu_util" Subscription status:%s' % response.text
#TODO: Fix the typo in 'sucess'
if (not 'sucess' in response.text) and (not 'already exists'
in response.text):
print 'SRIKANTH: Ceilometer meter "cpu_util" Subscription unsuccessful...Exiting'
return
if use_kafka:
subscribe_data = {
"sub_info": "instance",
"app_id": "xos_auto_scale2",
"target": LOCAL_KAFKA_TARGET_URL
}
else:
subscribe_data = {
"sub_info": "instance",
"app_id": "xos_auto_scale2",
"target": "udp://10.11.10.1:12346"
}
subscribe_url = ceilometer_url + 'v2/subscribe'
response = requests.post(subscribe_url, data=json.dumps(subscribe_data))
print 'SRIKANTH: Ceilometer meter "instance" Subscription status:%s' % response.text
#TODO: Fix the typo in 'sucess'
if (not 'sucess' in response.text) and (not 'already exists'
in response.text):
print 'SRIKANTH: Ceilometer meter "instance"Subscription unsuccessful...Exiting'
return
periodic_cpu_threshold_evaluator()
periodic_print()
setup_webserver()
def wait_func(parent, message,
function, func_args=(), func_kwargs={},
art_frames=None):
"""
Окно ожидания.
@param parent: Ссылка на окно.
@param message: Текст диалога.
@param function: Функция, которую необходимо подождать.
@param func_args: Аргументы функции.
@param func_kwargs: Именованные аргументы функции.
@param art_frames: Файлы-кадры.
"""
global ic_wait_process_dlg
wait_result = [None]
if not art_frames:
# Определить кадры по умолчанию
cur_dir = os.path.dirname(__file__)
if not cur_dir:
cur_dir = os.getcwd()
wait_dir = cur_dir+'/img/wait/'
art_gif = wait_dir+'spinner.gif'
if parent is None:
parent = wx.GetApp().GetTopWindow()
ic_wait_process_dlg = wait_box = icWaitBox(parent, message, art_gif)
wait_box.set_result_list(wait_result)
# Запустить функцию ожидания
thread.start_new(wait_box.run, (function, func_args, func_kwargs))
wait_box.ShowModal()
wait_box.Destroy()
ic_wait_process_dlg = None
return wait_result[0]
def start(self):
"""Start the uber basic interface.
All request are handled by BasicWeb method handle_request.
"""
def make_handler(parent):
class RequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
# A super-simple HTTP request handler:
def do_GET(self):
parent.handle_request('GET', self)
def do_POST(self):
parent.handle_request('POST', self)
def do_PUT(self):
parent.handle_request('PUT', self)
def do_DELETE(self):
parent.handle_request('DELETE', self)
def do_HEAD(self):
parent.handle_request('HEAD', self)
return RequestHandler
self.log.info("Creating FakeWebServer.")
self.server = StoppableTCPServer((self.interface, self.port),
make_handler(self))
def _start(data=0):
self.log.info("start: URI<%s>" % self.uri)
self.server.serve_forever()
thread.start_new(_start, (0, ))
def test_fork_with_thread(self):
# XXX This test depends on a multicore machine, as busy_thread must
# aquire the GIL the instant that the main thread releases it.
# It will incorrectly pass if the GIL is not grabbed in time.
import thread
import os
import time
if not hasattr(os, 'fork'):
skip("No fork on this platform")
def busy_thread():
print 'sleep'
while run:
time.sleep(0)
done.append(None)
for i in range(5):
run = True
done = []
try:
print 'sleep'
thread.start_new(busy_thread, ())
pid = os.fork()
if pid == 0:
os._exit(0)
else:
self.timeout_killer(pid, 10)
exitcode = os.waitpid(pid, 0)[1]
assert exitcode == 0 # if 9, process was killed by timer!
finally:
run = False
self.waitfor(lambda: done)
assert done
def applyFunctionToNFrames(func, filesPerThread, nframes, conversionargs):
if(nframes < filesPerThread):
func(0, 0, nframes, conversionargs)
else:
try:
import thread
keepSpawning = 1
start = filesPerThread
end = filesPerThread
threadID = 1
# Create a mutex array
numThreads = nframes / filesPerThread
if(numThreads * filesPerThread < nframes):
numThreads = numThreads + 1
exitmutex = [0] * numThreads
while keepSpawning == 1:
end = end + filesPerThread
if(end >= nframes):
end = nframes
keepSpawning = 0
thread.start_new(applyFunctionToNFramesWMutex, (threadID, exitmutex, func, start, end, conversionargs))
start = start + filesPerThread
threadID = threadID + 1
# Do the first part of the work on the main thread.
applyFunctionToNFramesWMutex(0, exitmutex, func, 0, filesPerThread, conversionargs)
# Wait for all of the threads to complete
while 0 in exitmutex: pass
except ImportError:
print "Could not import threads module."
func(0, 0, nframes, conversionargs)
def __init__(self, input, log):
for row in input:
thread.start_new(self.testPort, (row[0], row[1], log))
self.thread_count = self.thread_count + 1
while self.thread_count > 0:
pass
def POST(self):
web.header("Access-Control-Allow-Origin", "*")
params = web.input()
information = model.Information_model()
information_data = information.query('SELECT * FROM information WHERE \
class_cl_id=%s and exam_ex_id=%s' % (params.class_cl_id, params.ex_id))
information_data = [model.Information_model(**item) for item in information_data]
exam = model.Exam_model.getByPK(params.ex_id)
if exam.ex_type=="0":
for information in information_data:
information.in_endtime = datetime.datetime.now()
information.in_state = '2'
information.in_temp_ip = None
db.update('exam_question', where="information_in_id = %s" % (information.in_id), eq_get_score='-2', )
information.update()
response = util.Response(status=util.Status.__success__, )
return util.objtojson(response)
else:
if exam.ex_auto =="1":
for information in information_data:
information.in_endtime = datetime.datetime.now()
if information.in_state=='1':
information.in_state = '2'
information.in_temp_ip = None
db.update('exam_question', where="information_in_id = %s" % (information.in_id),
eq_get_score='-2', )
information.update()
thread.start_new(util.GetScore, (1,information.in_id))
response = util.Response(status=util.Status.__success__, )
return util.objtojson(response)
def main():
for i in range(NUM_THREADS):
thread.start_new(f, (i,))
time.sleep(LONGSLEEP)
a = alive.keys()
a.sort()
verify(a == range(NUM_THREADS))
prefork_lives = alive.copy()
if sys.platform in ['unixware7']:
cpid = os.fork1()
else:
cpid = os.fork()
if cpid == 0:
# Child
time.sleep(LONGSLEEP)
n = 0
for key in alive.keys():
if alive[key] != prefork_lives[key]:
n = n+1
os._exit(n)
else:
# Parent
spid, status = os.waitpid(cpid, 0)
verify(spid == cpid)
verify(status == 0,
"cause = %d, exit = %d" % (status&0xff, status>>8) )
global stop
# Tell threads to die
stop = 1
time.sleep(2*SHORTSLEEP) # Wait for threads to die
def pressStart(self):
'''
Function triggered by clicking 'START' button.
It will start a new thread to simulate the streaming fashion.
'''
thread.start_new(self.runForever, ());
self.start_btn['state'] = Tkinter.DISABLED;
def main():
bot = TulingWXBot()
bot.DEBUG = True
bot.conf['qr'] = 'tty'
thread.start_new(sendJOYJInfo, (bot, 60))
thread.start_new(sendWeatherReport, (bot, 60 * 60 * 12))
bot.run()
def release(self, path, fh):
if Debug:
print "*********************release"
full_path = self._full_path(path)
info = self.get_info(path)
if info == None or info["isdir"]:
full_path = self._full_path(path)
raise OSError(errno.ENOENT, os.strerror(errno.ENOENT), full_path)
if os.stat(info["content_temp_path"]).st_size != 0:
info["st_atime"] = time.time()
info["st_size"] = os.stat(info["content_temp_path"]).st_size
self.filesCollection.update_one({"_id": info["_id"]}, {"$set": {
"st_size": info["st_size"],
"st_atime": info["st_atime"]
}})
self.set_info(info)
thread.start_new(self.save, (info,))
os.close(fh)
else:
os.close(fh)
os.remove(info["content_temp_path"])
self.fileCacheLock.acquire()
self.fileCache.pop(info["content_hash"], None)
self.fileCacheLock.release()
def httpd(self):
# set up webserver
self.sock = socket( AF_INET, SOCK_STREAM )
self.listening = 0
while self.listening != 1:
try:
print "Creating server... "
if self.public:
self.sock.bind( ("", self.port) )
else:
self.sock.bind( ("localhost", self.port) )
self.sock.listen(5)
self.listening = 1
except:
print "Error binding socket (retrying in 5 secs...)"
time.sleep(5)
print "Created server OK"
self.openbrowser()
while self.listening == 1:
self.newsock, self.address = self.sock.accept()
# print "Incoming from: %s" % self.address[0]
thread.start_new(self.handleClient, (self.newsock,))
def __init__(self, bot, config):
self.bot = bot
self.config = config
self.statuses = statusstore()
self.about = "'sleekmotion_aways' Learn status messages from people, and use them.\nWritten by Kevin Smith"
self.bot.add_handler("<presence />", self.handle_presence)
thread.start_new(self.loop, ())
def _connect_to_client(self, connection_ip, connection_port, direction_list):
client = Client()
try:
send_list = [] # A list to store which direction this connection represent to the other client
client.connect(connection_ip, connection_port)
for direction in direction_list:
self.direction_connection_dict[direction] = client # storing the client to the direction
send_list.append(OPPOSITE_DIRECTION_DICT[direction]) # opposite direction to the ones this game uses
# storing the direction to the client
self.connection_direction_dict[client.connection].extend(direction_list)
self.connected_clients.append(client.connection)
client.send(json.dumps({'cmd': 'setup_migration_direction', "direction": send_list}))
thread.start_new(self._receive_for_ever, (client.connection, 1024))
except socket.error:
# could not connect to direction so should block it
for direction in direction_list:
self.the_game.block_paths_in_direction(direction)
if direction in self.direction_connection_dict:
del self.direction_connection_dict[direction]
if client.connection in self.connection_direction_dict:
del self.connection_direction_dict[client.connection]
if client.connection in self.connected_clients:
self.connected_clients.remove(client.connection)
def startSkulltag(self, deadArg): self.skulltag = subprocess.Popen(['/usr/games/skulltag/skulltag-server', '+sv_markchatlines 1']+self.args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, bufsize=0) self.stdinPoll = select.poll() self.stdinPoll.register(self.skulltag.stdout, select.POLLIN) self.stdoutPoll = select.poll() self.stdoutPoll.register(self.skulltag.stdout, select.POLLOUT) thread.start_new(self.rwLoop, (None,))
def state_change_handler(self, ev): ## to do add flow in switch enter hander and switch leave handler
"""Update topology graph when a switch enters or leaves.
ev -- datapath event and all of it's fields
important fields:
ev.dp.id: dpid that is joining or leaving
ev.enter is true if the datapath is entering and false if it is leaving
"""
dp=ev.datapath
# ports = ev.datapath.ports
ofproto = dp.ofproto
parser = dp.ofproto_parser
assert dp is not None
if dp.id is None:
return
if ev.state == MAIN_DISPATCHER:
match = parser.OFPMatch()
switch_list = []
for i in self.dpid_to_switch:
switch_list.append(i)
self.deploy_flow_entry(dp,switch_list,match)
if not self.graph.has_node(dp.id):
# dpid = format_dpid_str(dpid_to_str(dp.id))
self.graph.add_node(dp.id)
thread.start_new(getPeriodicStats, (dp,))
self.logger.info('Switch %s added to the topology', str(dp.id))
# for port in ev.datapath.ports:
# ports = []
# ports=dp.ports
# out_port = ports[port][0]
# print out_port
# print 'f**k'
# actions =[]
# actions = [parser.OFPActionOutput(out_port)]
# self.add_flow( dp ,0 ,match , actions)
elif ev.state == DEAD_DISPATCHER:
if dp.id is None:
return
if self.graph.has_node(dp.id):
self.graph.remove_node(dp.id)
self.logger.info('Switch %s removed from the topology',
str(dp.id))
nx.draw(self.graph)
plt.show()
LOG.debug(dp)
def messageCB(conn, msg):
# print msg
if msg.getType() == "groupchat":
temp = str(msg.getFrom()).split("/", 1)
sender = temp[0] # Naricht kommt vom Gruppenchat
elif msg.getType() == "chat":
sender = msg.getFrom() # Naricht kommt aus dem privat Chat
if not re.search('.*/' + BOTNAME + '.*', str(
msg.getFrom())): # Wenn Naricht nicht vom Bot stammt
if msg.getSubject(): # wenn das Topic dabei ist - speicher es
global topic
topic = msg.getSubject().encode('utf-8')
if msg.getBody(): # Wenn Text vorhanden ist
if not msg.getTimestamp(
): # wenn Message keinen Timestamp enthaelt -- Annahme: sonst veraltet
text = msg.getBody().encode('utf-8')
print str(msg.getFrom()) + ": " + text # Ausgabe auf Terminal
splittext = text.split(" ", 1)
global COMMAND_HANDLERS
if text == "!help":
global bothelp
sendit(msg.getFrom(), msg.getType(), bothelp)
if COMMAND_HANDLERS.has_key(splittext[0]):
if " " in text:
thread.start_new(COMMAND_HANDLERS[splittext[0]],
(sender, msg.getType(), splittext[1]))
else:
thread.start_new(COMMAND_HANDLERS[splittext[0]],
(sender, msg.getType(), ""))
else:
pass
def dispecher(self):
"""receiving clients and their distribution in the processing flow"""
while True:
connection, address = self._sockobj.accept()
print('server connected by', address)
print('at', self.now())
thread.start_new(self.handleClient, (connection, address,))
def makewidget(self):
root = Tk()
root.title('Chat Server...')
bkInfo = Form(root)
self.bkInfo = bkInfo
thread.start_new(self.start,())
root.mainloop()
def run(self, nworkers):
if not self.work:
return # Nothing to do
for i in range(nworkers - 1):
thread.start_new(self._worker, ())
self._worker()
self.todo.acquire()
def onAction(self, action):
xbmc.log(str(action.getId()))
if action == 11: # Info
from resources.lib import movie
movie.movie_id = self.current_movie["id"]
movie.startup()
if action == 117 or action == 101: # Context
cm = dialogContext("context_menu.xml", addon_path, "Default")
cm.movie = self.current_movie
cm.mode = self.source
cm.xbmc_movies = self.xbmc_movies
cm.session_id = addon.getSetting("session_id")
cm.doModal()
xbmc.sleep(1000)
thread.start_new(self.updateIcons, (self.current_movie, self.current_item, 3))
if action == 10 and action != 101:
d = xbmcgui.Dialog()
ans = d.yesno("tmdb Browser", "Exit themoviedb.org Browser?")
if ans:
xbmc.executebuiltin("Dialog.Close(all,true)")
elif action == 92:
self.close()
elif action == 159:
xbmc.executebuiltin("Dialog.Close(all,true)")
from resources.lib import opening
opening.startup()
def run(self, nworkers): if not self.work: return # Nothing to do for i in range(nworkers-1): thread.start_new(self._worker, ()) self._worker() self.todo.acquire()
def onFocus(self, control):
movieid = self.get_movieid_from_control(control)
if movieid != "":
self.current_item = control - 400
movie = tmdb.get_movie(movieid)
if show_icons == "1":
thread.start_new(self.updateIcons, (movie, 0, 3))
backdrop = self.getControl(32107)
cast = self.getControl(32109)
plot = self.getControl(32108)
self.current_movie = movie
actors = movie["credits"]["cast"]
actors = sorted(actors, key=lambda k: k["order"])
a = ""
i = 0
for actor in actors:
i = i + 1
a = a + actor["name"] + ", "
if i == 3:
break
a = a[:-2]
cast.setLabel("[B]" + a + "[/B]")
try:
self.getControl(3001).setLabel("[B]" + movie["title"] + " (" + movie["release_date"][:4] + ")[/B]")
except:
pass
plot.setText(movie["overview"])
backdrop.setImage("")
if movie["backdrop_path"] != None:
self.getControl(32121).setLabel("Loading")
backdrop.setImage("http://image.tmdb.org/t/p/w300" + movie["backdrop_path"])
else:
self.getControl(32121).setLabel("No Background Available")
def main():
try:
if args.f:
f = open(args.f, 'a')
f.write('Starting Server at %s\n' % (str(now)))
f.close()
print "Starting NBNS Request Thread..."
thread.start_new(sender, ())
try:
print "Starting UDP Response Server..."
sniff(iface='enp0s3',
filter="udp and port 137",
store=0,
prn=get_packet)
except KeyboardInterrupt:
print "\nStopping Server and Exiting...\n"
now3 = datetime.datetime.now()
if args.f:
f = open(args.f, 'a')
f.write('Stopping Server at %s\n' % (str(now3)))
f.close()
except Exception as err:
print "Server could not be started, confirm you're running this as root.\n %s" % err
except KeyboardInterrupt:
exit()
except Exception as err:
print "Server could not be started, confirm you're running this as root.\n %s" % err
def startPycheckerRun(self):
self.result = None
old = win32api.SetCursor(
win32api.LoadCursor(0, win32con.IDC_APPSTARTING))
win32ui.GetApp().AddIdleHandler(self.idleHandler)
import thread
thread.start_new(self.threadPycheckerRun, ())
